diff --git a/CMake/BuildConfigurations/PhenotypingRelease.cmake b/CMake/BuildConfigurations/PhenotypingRelease.cmake
new file mode 100644
index 0000000000..15c1467ec2
--- /dev/null
+++ b/CMake/BuildConfigurations/PhenotypingRelease.cmake
@@ -0,0 +1,15 @@
+include(${CMAKE_CURRENT_LIST_DIR}/WorkbenchRelease.cmake)
+
+list(APPEND MITK_CONFIG_PACKAGES
+ Vigra
+)
+
+list(APPEND MITK_CONFIG_PLUGINS
+ org.mitk.gui.qt.basicimageprocessing
+ org.mitk.gui.qt.radiomics
+)
+
+if(NOT MITK_USE_SUPERBUILD)
+ set(BUILD_BasicImageProcessingMiniApps ON CACHE BOOL "" FORCE)
+ set(BUILD_ClassificationMiniApps ON CACHE BOOL "" FORCE)
+endif()
diff --git a/CMake/BuildConfigurations/WorkbenchRelease.cmake b/CMake/BuildConfigurations/WorkbenchRelease.cmake
index e4b4da592b..694b4b9e35 100644
--- a/CMake/BuildConfigurations/WorkbenchRelease.cmake
+++ b/CMake/BuildConfigurations/WorkbenchRelease.cmake
@@ -1,24 +1,28 @@
include(${CMAKE_CURRENT_LIST_DIR}/Default.cmake)
set(MITK_CONFIG_PACKAGES ${MITK_CONFIG_PACKAGES}
MatchPoint
)
set(MITK_CONFIG_PLUGINS ${MITK_CONFIG_PLUGINS}
org.mitk.gui.qt.multilabelsegmentation
org.mitk.matchpoint.core.helper
org.mitk.gui.qt.matchpoint.algorithm.browser
org.mitk.gui.qt.matchpoint.algorithm.control
org.mitk.gui.qt.matchpoint.mapper
org.mitk.gui.qt.matchpoint.framereg
org.mitk.gui.qt.matchpoint.visualizer
org.mitk.gui.qt.matchpoint.evaluator
org.mitk.gui.qt.matchpoint.manipulator
)
+if(NOT MITK_USE_SUPERBUILD)
+ set(BUILD_CoreCmdApps ON CACHE BOOL "" FORCE)
+endif()
+
set(MITK_VTK_DEBUG_LEAKS OFF CACHE BOOL "Enable VTK Debug Leaks" FORCE)
find_package(Doxygen REQUIRED)
# Ensure that the in-application help can be build
set(BLUEBERRY_QT_HELP_REQUIRED ON CACHE BOOL "Required Qt help documentation in plug-ins" FORCE)
diff --git a/CMake/FindDCMTK.cmake b/CMake/FindDCMTK.cmake
deleted file mode 100644
index aec7baacfe..0000000000
--- a/CMake/FindDCMTK.cmake
+++ /dev/null
@@ -1,342 +0,0 @@
-#.rst:
-# FindDCMTK
-# ---------
-#
-# Find DCMTK libraries and applications
-#
-# The module defines the following variables::
-#
-# DCMTK_INCLUDE_DIRS - Directories to include to use DCMTK
-# DCMTK_LIBRARIES - Files to link against to use DCMTK
-# DCMTK_FOUND - If false, don't try to use DCMTK
-# DCMTK_DIR - (optional) Source directory for DCMTK
-#
-# Compatibility
-# ^^^^^^^^^^^^^
-#
-# This module is able to find a version of DCMTK that does or does not export
-# a *DCMTKConfig.cmake* file. It applies a two step process:
-#
-# * Step 1: Attempt to find DCMTK version providing a *DCMTKConfig.cmake* file.
-# * Step 2: If step 1 failed, rely on *FindDCMTK.cmake* to set `DCMTK_*` variables details below.
-#
-#
-# `Recent DCMTK
-# <http://git.dcmtk.org/web?p=dcmtk.git;a=commit;h=662ae187c493c6b9a73dd5e3875372cebd0c11fe>`_
-# provides a *DCMTKConfig.cmake* :manual:`package configuration file
-# <cmake-packages(7)>`. To exclusively use the package configuration file
-# (recommended when possible), pass the `NO_MODULE` option to
-# :command:`find_package`. For example, `find_package(DCMTK NO_MODULE)`.
-# This requires official DCMTK snapshot *3.6.1_20140617* or newer.
-#
-#
-# Until all clients update to the more recent DCMTK, build systems will need
-# to support different versions of DCMTK.
-#
-# On any given system, the following combinations of DCMTK versions could be
-# considered:
-#
-# +--------+---------------------+-----------------------+-------------------+
-# | | SYSTEM DCMTK | LOCAL DCMTK | Supported ? |
-# +--------+---------------------+-----------------------+-------------------+
-# | Case A | NA | [ ] DCMTKConfig | YES |
-# +--------+---------------------+-----------------------+-------------------+
-# | Case B | NA | [X] DCMTKConfig | YES |
-# +--------+---------------------+-----------------------+-------------------+
-# | Case C | [ ] DCMTKConfig | NA | YES |
-# +--------+---------------------+-----------------------+-------------------+
-# | Case D | [X] DCMTKConfig | NA | YES |
-# +--------+---------------------+-----------------------+-------------------+
-# | Case E | [ ] DCMTKConfig | [ ] DCMTKConfig | YES (*) |
-# +--------+---------------------+-----------------------+-------------------+
-# | Case F | [X] DCMTKConfig | [ ] DCMTKConfig | NO |
-# +--------+---------------------+-----------------------+-------------------+
-# | Case G | [ ] DCMTKConfig | [X] DCMTKConfig | YES |
-# +--------+---------------------+-----------------------+-------------------+
-# | Case H | [X] DCMTKConfig | [X] DCMTKConfig | YES |
-# +--------+---------------------+-----------------------+-------------------+
-#
-# (*) See Troubleshooting section.
-#
-# Legend:
-#
-# NA ...............: Means that no System or Local DCMTK is available
-#
-# [ ] DCMTKConfig ..: Means that the version of DCMTK does NOT export a DCMTKConfig.cmake file.
-#
-# [X] DCMTKConfig ..: Means that the version of DCMTK exports a DCMTKConfig.cmake file.
-#
-#
-# Troubleshooting
-# ^^^^^^^^^^^^^^^
-#
-# What to do if my project finds a different version of DCMTK?
-#
-# Remove DCMTK entry from the CMake cache per :command:`find_package`
-# documentation.
-
-#=============================================================================
-# Copyright 2004-2009 Kitware, Inc.
-# Copyright 2009-2010 Mathieu Malaterre <mathieu.malaterre@gmail.com>
-# Copyright 2010 Thomas Sondergaard <ts@medical-insight.com>
-#
-# Distributed under the OSI-approved BSD License (the "License");
-# see accompanying file Copyright.txt for details.
-#
-# This software is distributed WITHOUT ANY WARRANTY; without even the
-# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the License for more information.
-#=============================================================================
-# (To distribute this file outside of CMake, substitute the full
-# License text for the above reference.)
-
-#
-# Written for VXL by Amitha Perera.
-# Upgraded for GDCM by Mathieu Malaterre.
-# Modified for EasyViz by Thomas Sondergaard.
-#
-
-set(_dcmtk_dir_description "The directory of DCMTK build or install tree.")
-
-# Ensure that DCMTK_DIR is set to a reasonable default value
-# so that DCMTK libraries can be found on a standard Unix distribution.
-# It also overwrite the value of DCMTK_DIR after this one has been
-# set by a successful discovery of DCMTK by the unpatched FindDCMTK.cmake module
-# distributed with CMake (as of 0167cea)
-if(NOT DCMTK_DIR OR DCMTK_DIR STREQUAL "/usr/include/dcmtk")
- set(DCMTK_DIR "/usr" CACHE PATH ${_dcmtk_dir_description} FORCE)
-endif()
-
-set(_SAVED_DCMTK_DIR ${DCMTK_DIR})
-
-#
-# Step1: Attempt to find a version of DCMTK providing a DCMTKConfig.cmake file.
-#
-if(NOT DCMTK_FIND_QUIETLY)
- message(STATUS "Trying to find DCMTK expecting DCMTKConfig.cmake")
-endif()
-find_package(DCMTK QUIET NO_MODULE)
-if(DCMTK_FOUND
- AND NOT "x" STREQUAL "x${DCMTK_LIBRARIES}"
- AND NOT "x" STREQUAL "x${DCMTK_INCLUDE_DIRS}")
-
- if(NOT DCMTK_FIND_QUIETLY)
- message(STATUS "Trying to find DCMTK expecting DCMTKConfig.cmake - ok")
- endif()
- return()
-else()
- if(NOT DCMTK_FIND_QUIETLY)
- message(STATUS "Trying to find DCMTK expecting DCMTKConfig.cmake - failed")
- endif()
-endif()
-
-if(NOT DCMTK_FIND_QUIETLY)
- message(STATUS "Trying to find DCMTK relying on FindDCMTK.cmake")
-endif()
-
-# Restore the value reset by the previous call to 'find_package(DCMTK QUIET NO_MODULE)'
-set(DCMTK_DIR ${_SAVED_DCMTK_DIR} CACHE PATH ${_dcmtk_dir_description} FORCE)
-
-
-#
-# Step2: Attempt to find a version of DCMTK that does NOT provide a DCMTKConfig.cmake file.
-#
-
-# prefer DCMTK_DIR over default system paths like /usr/lib
-if(DCMTK_DIR)
- set(CMAKE_PREFIX_PATH ${DCMTK_DIR}/lib ${CMAKE_PREFIX_PATH}) # this is given to FIND_LIBRARY or FIND_PATH
-endif()
-
-# Find all libraries, store debug and release separately
-foreach(lib
- dcmpstat
- dcmsr
- dcmsign
- dcmtls
- dcmqrdb
- dcmnet
- dcmjpeg
- dcmimage
- dcmimgle
- dcmdata
- dcmpmap
- oflog
- ofstd
- ijg12
- ijg16
- ijg8
- )
-
- # Find Release libraries
- find_library(DCMTK_${lib}_LIBRARY_RELEASE
- ${lib}
- PATHS
- ${DCMTK_DIR}/${lib}/libsrc
- ${DCMTK_DIR}/${lib}/libsrc/Release
- ${DCMTK_DIR}/${lib}/Release
- ${DCMTK_DIR}/lib
- ${DCMTK_DIR}/lib/Release
- ${DCMTK_DIR}/dcmjpeg/lib${lib}/Release
- NO_DEFAULT_PATH
- )
-
- # Find Debug libraries
- find_library(DCMTK_${lib}_LIBRARY_DEBUG
- ${lib}${DCMTK_CMAKE_DEBUG_POSTFIX}
- PATHS
- ${DCMTK_DIR}/${lib}/libsrc
- ${DCMTK_DIR}/${lib}/libsrc/Debug
- ${DCMTK_DIR}/${lib}/Debug
- ${DCMTK_DIR}/lib
- ${DCMTK_DIR}/lib/Debug
- ${DCMTK_DIR}/dcmjpeg/lib${lib}/Debug
- NO_DEFAULT_PATH
- )
-
- mark_as_advanced(DCMTK_${lib}_LIBRARY_RELEASE)
- mark_as_advanced(DCMTK_${lib}_LIBRARY_DEBUG)
-
- # Add libraries to variable according to build type
- if(DCMTK_${lib}_LIBRARY_RELEASE)
- list(APPEND DCMTK_LIBRARIES optimized ${DCMTK_${lib}_LIBRARY_RELEASE})
- endif()
-
- if(DCMTK_${lib}_LIBRARY_DEBUG)
- list(APPEND DCMTK_LIBRARIES debug ${DCMTK_${lib}_LIBRARY_DEBUG})
- endif()
-
-endforeach()
-
-set(CMAKE_THREAD_LIBS_INIT)
-if(DCMTK_oflog_LIBRARY_RELEASE OR DCMTK_oflog_LIBRARY_DEBUG)
- # Hack - Not having a DCMTKConfig.cmake file to read the settings from, we will attempt to
- # find the library in all cases.
- # Ideally, pthread library should be discovered only if DCMTK_WITH_THREADS is enabled.
- set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
- find_package(Threads)
-endif()
-
-if(CMAKE_THREAD_LIBS_INIT)
- list(APPEND DCMTK_LIBRARIES ${CMAKE_THREAD_LIBS_INIT})
-endif()
-
-#
-# SPECIFIC CASE FOR DCMTK BUILD DIR as DCMTK_DIR
-# (as opposed to a DCMTK install dir)
-# Have to find the source directory.
-if(EXISTS ${DCMTK_DIR}/CMakeCache.txt)
- load_cache(${DCMTK_DIR} READ_WITH_PREFIX "EXT"
- DCMTK_SOURCE_DIR)
- if(NOT EXISTS ${EXTDCMTK_SOURCE_DIR})
- message(FATAL_ERROR
- "DCMTK build directory references
-nonexistant DCMTK source directory ${EXTDCMTK_SOURCE_DIR}")
- endif()
-endif()
-
-set(DCMTK_config_TEST_HEADER osconfig.h)
-set(DCMTK_dcmdata_TEST_HEADER dctypes.h)
-set(DCMTK_dcmimage_TEST_HEADER dicoimg.h)
-set(DCMTK_dcmimgle_TEST_HEADER dcmimage.h)
-set(DCMTK_dcmjpeg_TEST_HEADER djdecode.h)
-set(DCMTK_dcmnet_TEST_HEADER assoc.h)
-set(DCMTK_dcmpstat_TEST_HEADER dcmpstat.h)
-set(DCMTK_dcmqrdb_TEST_HEADER dcmqrdba.h)
-set(DCMTK_dcmsign_TEST_HEADER sicert.h)
-set(DCMTK_dcmsr_TEST_HEADER dsrtree.h)
-set(DCMTK_dcmtls_TEST_HEADER tlslayer.h)
-set(DCMTK_ofstd_TEST_HEADER ofstdinc.h)
-set(DCMTK_oflog_TEST_HEADER oflog.h)
-set(DCMTK_dcmjpls_TEST_HEADER djlsutil.h)
-
-set(DCMTK_INCLUDE_DIR_NAMES)
-message("Using default CMAKE FindDCMTK")
-foreach(dir
- config
- dcmdata
- dcmimage
- dcmimgle
- dcmjpeg
- dcmjpls
- dcmnet
- dcmpstat
- dcmqrdb
- dcmsign
- dcmsr
- dcmtls
- dcmpmap
- ofstd
- oflog)
- if(EXTDCMTK_SOURCE_DIR)
- set(SOURCE_DIR_PATH
- ${EXTDCMTK_SOURCE_DIR}/${dir}/include/dcmtk/${dir})
- endif()
- find_path(DCMTK_${dir}_INCLUDE_DIR
- ${DCMTK_${dir}_TEST_HEADER}
- PATHS
- ${DCMTK_DIR}/${dir}/include
- ${DCMTK_DIR}/${dir}
- ${DCMTK_DIR}/include/dcmtk/${dir}
- ${DCMTK_DIR}/${dir}/include/dcmtk/${dir}
- ${DCMTK_DIR}/include/${dir}
- ${SOURCE_DIR_PATH}
- )
- mark_as_advanced(DCMTK_${dir}_INCLUDE_DIR)
- list(APPEND DCMTK_INCLUDE_DIR_NAMES DCMTK_${dir}_INCLUDE_DIR)
-
- if(DCMTK_${dir}_INCLUDE_DIR)
- # add the 'include' path so eg
- #include "dcmtk/dcmimgle/dcmimage.h"
- # works
- get_filename_component(_include ${DCMTK_${dir}_INCLUDE_DIR} PATH)
- get_filename_component(_include ${_include} PATH)
- list(APPEND
- DCMTK_INCLUDE_DIRS
- ${DCMTK_${dir}_INCLUDE_DIR}
- ${_include})
- endif()
-endforeach()
-
-list(APPEND DCMTK_INCLUDE_DIRS ${DCMTK_DIR}/include)
-
-if(WIN32)
- list(APPEND DCMTK_LIBRARIES netapi32 wsock32)
-endif()
-
-if(DCMTK_ofstd_INCLUDE_DIR)
- get_filename_component(DCMTK_dcmtk_INCLUDE_DIR
- ${DCMTK_ofstd_INCLUDE_DIR}
- PATH
- CACHE)
- list(APPEND DCMTK_INCLUDE_DIRS ${DCMTK_dcmtk_INCLUDE_DIR})
- mark_as_advanced(DCMTK_dcmtk_INCLUDE_DIR)
-endif()
-
-# Compatibility: This variable is deprecated
-set(DCMTK_INCLUDE_DIR ${DCMTK_INCLUDE_DIRS})
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(DCMTK
- REQUIRED_VARS ${DCMTK_INCLUDE_DIR_NAMES} DCMTK_LIBRARIES
- FAIL_MESSAGE "Please set DCMTK_DIR and re-run configure")
-
-# Workaround bug in packaging of DCMTK 3.6.0 on Debian.
-# See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=637687
-if(DCMTK_FOUND AND UNIX AND NOT APPLE)
- include(CheckCXXSourceCompiles)
- set(CMAKE_REQUIRED_FLAGS )
- set(CMAKE_REQUIRED_DEFINITIONS )
- set(CMAKE_REQUIRED_INCLUDES ${DCMTK_INCLUDE_DIRS})
- set(CMAKE_REQUIRED_LIBRARIES ${DCMTK_LIBRARIES})
- set(CMAKE_REQUIRED_QUIET ${DCMTK_FIND_QUIETLY})
- check_cxx_source_compiles("#include <dcmtk/config/osconfig.h>\n#include <dcmtk/ofstd/ofstream.h>\nint main(int,char*[]){return 0;}"
- DCMTK_HAVE_CONFIG_H_OPTIONAL
- )
- if(NOT DCMTK_HAVE_CONFIG_H_OPTIONAL)
- set(DCMTK_DEFINITIONS "HAVE_CONFIG_H")
- endif()
-endif()
-
-if(NOT DCMTK_FIND_QUIETLY)
- message(STATUS "Trying to find DCMTK relying on FindDCMTK.cmake - ok")
-endif()
diff --git a/CMake/PackageDepends/MITK_DCMTK_Config.cmake b/CMake/PackageDepends/MITK_DCMTK_Config.cmake
index 155a9ab47b..c331c55e9a 100644
--- a/CMake/PackageDepends/MITK_DCMTK_Config.cmake
+++ b/CMake/PackageDepends/MITK_DCMTK_Config.cmake
@@ -1,10 +1,10 @@
-if( NOT WIN32 AND NOT APPLE )
+if(NOT WIN32 AND NOT APPLE)
set(MISSING_LIBS_REQUIRED_BY_DCMTK tiff z)
-endif( NOT WIN32 AND NOT APPLE )
+endif()
-set(QT_USE_QTSQL 1)
-
-find_package(DCMTK)
+if(NOT DCMTK_FOUND)
+ find_package(DCMTK REQUIRED)
+endif()
list(APPEND ALL_INCLUDE_DIRECTORIES ${DCMTK_INCLUDE_DIRS})
list(APPEND ALL_LIBRARIES ${DCMTK_LIBRARIES} ${MISSING_LIBS_REQUIRED_BY_DCMTK})
diff --git a/CMake/mitkFunctionCreateMatchPointDeployedAlgorithm.cmake b/CMake/mitkFunctionCreateMatchPointDeployedAlgorithm.cmake
index 7478718143..688e4afc38 100644
--- a/CMake/mitkFunctionCreateMatchPointDeployedAlgorithm.cmake
+++ b/CMake/mitkFunctionCreateMatchPointDeployedAlgorithm.cmake
@@ -1,114 +1,111 @@
#!
#! Create a Command Line App.
#!
#! \brief This function will create a command line executable and the scripts required to run it
#!
#! \param NAME (required) Name of the algorithm / cmake target
#! \param DEPENDS (optional) Required MITK modules beyond MitkCommandLine
#! \param PACKAGE_DEPENDS (optional) list of "packages" this command line app depends on (e.g. ITK, VTK, etc.)
#! \param TARGET_DEPENDS (optional) list of additional CMake targets this command line app depends on
#! \param CPP_FILES (optional) list of cpp files, if it is not given NAME.cpp is assumed
#! \param INCLUDE_DIRS (optional): All directories that should be added as include dirs to the project
#! \param PROFILE (optional): The profile file that should be used for the algorithm. If not set it is "./<algname>.profile".
#! \param NO_PROFILE_GEN (optional): Flag. If set no profile resource will be generated.
#! \param ADDITIONAL_LIBS (optional) 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 H_FILES (optional) List of public header files for this module.
#! Assuming that there exists a file called <code>MyApp.cpp</code>, an example call looks like:
#! \code
#! mitkFunctionCreateCommandLineApp(
#! NAME MyApp
#! DEPENDS MitkCore MitkPlanarFigure
#! PACKAGE_DEPENDS ITK VTK
#! )
#! \endcode
#!
function(mitkFunctionCreateMatchPointDeployedAlgorithm)
set(_function_params
NAME # Name of the algorithm/target
PROFILE # Profile of the algorithm that should be used
)
set(_function_multiparams
DEPENDS # list of modules this command line app depends on
PACKAGE_DEPENDS # list of "packages" this command line app depends on (e.g. ITK, VTK, etc.)
TARGET_DEPENDS # list of CMake targets this command line app depends on
CPP_FILES # (optional) list of cpp files, if it is not given NAME.cpp is assumed
INCLUDE_DIRS # include directories: [PUBLIC|PRIVATE|INTERFACE] <list>
ADDITIONAL_LIBS # list of addidtional private libraries linked to this module.
H_FILES # list of header files: [PUBLIC|PRIVATE] <list>
)
set(_function_options
NO_PROFILE_GEN #Flag that indicates that no profile resource should be generated.
)
cmake_parse_arguments(ALG "${_function_options}" "${_function_params}" "${_function_multiparams}" ${ARGN})
if( NOT (DEFINED MITK_USE_MatchPoint) OR NOT (${MITK_USE_MatchPoint}))
message(FATAL_ERROR "Need package Matchpoint to deploy MatchPoint Algorithms.")
endif()
if(NOT ALG_NAME)
message(FATAL_ERROR "NAME argument cannot be empty.")
endif()
- SET(ALG_TARGET "MDRA_${ALG_NAME}")
+ set(ALG_TARGET "MDRA_${ALG_NAME}")
if(NOT ALG_CPP_FILES)
set(ALG_CPP_FILES "${ALG_NAME}.cpp")
endif()
- IF(NOT ALG_PROFILE)
+ if(NOT ALG_PROFILE)
set(ALG_PROFILE "${ALG_NAME}.profile")
- ENDIF(NOT ALG_PROFILE)
-
- IF(NOT ALG_NO_PROFILE_GEN)
- MESSAGE(STATUS "... generate MDRA profile for ${ALG_NAME} (from ${ALG_PROFILE})...")
-
- include(${MatchPoint_SOURCE_DIR}/CMake/mapFunctionCreateAlgorithmProfile.cmake)
- CREATE_ALGORITHM_PROFILE(${ALG_NAME} ${ALG_PROFILE})
+ endif()
- MESSAGE(STATUS "... algorithm UID: ${ALGORITHM_PROFILE_UID}")
- ENDIF(NOT ALG_NO_PROFILE_GEN)
+ if(NOT ALG_NO_PROFILE_GEN)
+ message(STATUS "Generate MDRA profile for ${ALG_NAME} (from ${ALG_PROFILE})")
+ include(${MatchPoint_SOURCE_DIR}/CMake/mapFunctionCreateAlgorithmProfile.cmake)
+ CREATE_ALGORITHM_PROFILE(${ALG_NAME} ${ALG_PROFILE})
+ endif()
- MESSAGE(STATUS "... deploy MDRA algorithm ${ALG_NAME}...")
+ message(STATUS "Deploy MDRA algorithm ${ALG_NAME}")
ADD_LIBRARY(${ALG_TARGET} SHARED ${ALG_CPP_FILES} ${ALGORITHM_PROFILE_FILE})
- SET_TARGET_PROPERTIES(${ALG_TARGET} PROPERTIES
+ set_target_properties(${ALG_TARGET} PROPERTIES
OUTPUT_NAME "mdra-${MatchPoint_VERSION_MAJOR}-${MatchPoint_VERSION_MINOR}_${ALG_NAME}"
OUTPUT_NAME_DEBUG "mdra-D-${MatchPoint_VERSION_MAJOR}-${MatchPoint_VERSION_MINOR}_${ALG_NAME}"
PREFIX ""
FOLDER "${MITK_ROOT_FOLDER}/Modules/MatchPointAlgorithms")
mitk_use_modules(TARGET ${ALG_TARGET}
MODULES ${ALG_DEPENDS}
PACKAGES PRIVATE MatchPoint ${ALG_PACKAGE_DEPENDS}
)
if(ALG_TARGET_DEPENDS)
target_link_libraries(${ALG_TARGET} ${ALG_TARGET_DEPENDS})
endif()
target_include_directories(${ALG_TARGET} PRIVATE ${ALG_INCLUDE_DIRS} ${CMAKE_CURRENT_BINARY_DIR})
if(ALG_ADDITIONAL_LIBS)
target_link_libraries(${ALG_TARGET} PRIVATE ${ALG_ADDITIONAL_LIBS})
get_property(_mitk_additional_library_search_paths GLOBAL PROPERTY MITK_ADDITIONAL_LIBRARY_SEARCH_PATHS)
foreach(_lib_filepath ${ALG_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()
MITK_INSTALL(TARGETS ${ALG_TARGET})
endfunction()
diff --git a/CMakeExternals/DCMQI.cmake b/CMakeExternals/DCMQI.cmake
index f0cbb3ee51..517b1c7625 100644
--- a/CMakeExternals/DCMQI.cmake
+++ b/CMakeExternals/DCMQI.cmake
@@ -1,65 +1,65 @@
#-----------------------------------------------------------------------------
# DCMQI
#-----------------------------------------------------------------------------
if(MITK_USE_DCMQI)
# Sanity checks
if(DEFINED DCMQI_DIR AND NOT EXISTS ${DCMQI_DIR})
message(FATAL_ERROR "DCMQI_DIR variable is defined but corresponds to non-existing directory")
endif()
set(proj DCMQI)
set(proj_DEPENDENCIES DCMTK ITK)
set(DCMQI_DEPENDS ${proj})
if(NOT DEFINED DCMQI_DIR)
set(additional_cmake_args)
if(CTEST_USE_LAUNCHERS)
list(APPEND additional_cmake_args
"-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
)
endif()
mitk_query_custom_ep_vars()
ExternalProject_Add(${proj}
LIST_SEPARATOR ${sep}
GIT_REPOSITORY https://github.com/qiicr/dcmqi.git
- GIT_TAG 99192b76
+ GIT_TAG v1.2.3
UPDATE_COMMAND ""
INSTALL_COMMAND ""
CMAKE_GENERATOR ${gen}
CMAKE_GENERATOR_PLATFORM ${gen_platform}
CMAKE_ARGS
${ep_common_args}
${additional_cmake_args}
#-DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
-DBUILD_SHARED_LIBS:BOOL=ON
-DDCMQI_BUILD_APPS:BOOL=OFF
-DDCMTK_DIR:PATH=${DCMTK_DIR}
-DITK_DIR:PATH=${ITK_DIR}
-DITK_NO_IO_FACTORY_REGISTER_MANAGER:BOOL=ON
-DDCMQI_SUPERBUILD:BOOL=OFF
-DDCMQI_CMAKE_CXX_STANDARD:STRING=14
${${proj}_CUSTOM_CMAKE_ARGS}
CMAKE_CACHE_ARGS
${ep_common_cache_args}
${${proj}_CUSTOM_CMAKE_CACHE_ARGS}
CMAKE_CACHE_DEFAULT_ARGS
${ep_common_cache_default_args}
${${proj}_CUSTOM_CMAKE_CACHE_DEFAULT_ARGS}
DEPENDS ${proj_DEPENDENCIES}
)
ExternalProject_Get_Property(${proj} binary_dir)
set(DCMQI_DIR ${binary_dir})
#set(${proj}_DIR ${ep_prefix})
#message(${proj}_DIR: ${${proj}_DIR})
#mitkFunctionInstallExternalCMakeProject(${proj})
else()
mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
endif()
endif()
diff --git a/CMakeExternals/VTK-9.0.0.patch b/CMakeExternals/VTK-9.0.0.patch
deleted file mode 100644
index a468c8fff2..0000000000
--- a/CMakeExternals/VTK-9.0.0.patch
+++ /dev/null
@@ -1,15 +0,0 @@
-diff --git a/Rendering/FreeType/vtkFreeTypeTools.cxx b/Rendering/FreeType/vtkFreeTypeTools.cxx
-index c54289dc60..03b899c4da 100644
---- a/Rendering/FreeType/vtkFreeTypeTools.cxx
-+++ b/Rendering/FreeType/vtkFreeTypeTools.cxx
-@@ -378,8 +378,7 @@ FTC_CMapCache* vtkFreeTypeTools::GetCMapCache()
- }
-
- //----------------------------------------------------------------------------
--FT_CALLBACK_DEF(FT_Error)
--vtkFreeTypeToolsFaceRequester(
-+static FT_Error vtkFreeTypeToolsFaceRequester(
- FTC_FaceID face_id, FT_Library lib, FT_Pointer request_data, FT_Face* face)
- {
- #if VTK_FTFC_DEBUG_CD
-
diff --git a/CMakeExternals/VTK-9.0.1.patch b/CMakeExternals/VTK-9.0.1.patch
new file mode 100644
index 0000000000..4bb1a4665c
--- /dev/null
+++ b/CMakeExternals/VTK-9.0.1.patch
@@ -0,0 +1,51 @@
+diff --git a/Rendering/FreeType/vtkFreeTypeTools.cxx b/Rendering/FreeType/vtkFreeTypeTools.cxx
+index c54289dc..03b899c4 100644
+--- a/Rendering/FreeType/vtkFreeTypeTools.cxx
++++ b/Rendering/FreeType/vtkFreeTypeTools.cxx
+@@ -378,8 +378,7 @@ FTC_CMapCache* vtkFreeTypeTools::GetCMapCache()
+ }
+
+ //----------------------------------------------------------------------------
+-FT_CALLBACK_DEF(FT_Error)
+-vtkFreeTypeToolsFaceRequester(
++static FT_Error vtkFreeTypeToolsFaceRequester(
+ FTC_FaceID face_id, FT_Library lib, FT_Pointer request_data, FT_Face* face)
+ {
+ #if VTK_FTFC_DEBUG_CD
+diff --git a/ThirdParty/hdf5/vtkhdf5/src/H5Fsuper.c b/ThirdParty/hdf5/vtkhdf5/src/H5Fsuper.c
+index 49995651..00a3dc55 100644
+--- a/ThirdParty/hdf5/vtkhdf5/src/H5Fsuper.c
++++ b/ThirdParty/hdf5/vtkhdf5/src/H5Fsuper.c
+@@ -54,6 +54,7 @@
+ /********************/
+ static herr_t H5F__super_ext_create(H5F_t *f, H5O_loc_t *ext_ptr);
+ static herr_t H5F__update_super_ext_driver_msg(H5F_t *f);
++herr_t H5O__fsinfo_set_version(H5F_t *f, H5O_fsinfo_t *fsinfo);
+
+
+ /*********************/
+diff --git a/ThirdParty/hdf5/vtkhdf5/src/H5Oint.c b/ThirdParty/hdf5/vtkhdf5/src/H5Oint.c
+index 543637c1..a927c0d1 100644
+--- a/ThirdParty/hdf5/vtkhdf5/src/H5Oint.c
++++ b/ThirdParty/hdf5/vtkhdf5/src/H5Oint.c
+@@ -82,6 +82,7 @@ static herr_t H5O__free_visit_visited(void *item, void *key,
+ static herr_t H5O__visit_cb(hid_t group, const char *name, const H5L_info_t *linfo,
+ void *_udata);
+ static const H5O_obj_class_t *H5O__obj_class_real(const H5O_t *oh);
++herr_t H5CX_get_ohdr_flags(uint8_t* oh_flags);
+
+
+ /*********************/
+diff --git a/ThirdParty/hdf5/vtkhdf5/src/H5Rint.c b/ThirdParty/hdf5/vtkhdf5/src/H5Rint.c
+index 159bccac..08bd8c80 100644
+--- a/ThirdParty/hdf5/vtkhdf5/src/H5Rint.c
++++ b/ThirdParty/hdf5/vtkhdf5/src/H5Rint.c
+@@ -46,6 +46,8 @@
+ /********************/
+ /* Local Prototypes */
+ /********************/
++herr_t H5CX_set_libver_bounds(H5F_t*);
++
+
+ /*********************/
+ /* Package Variables */
diff --git a/CMakeExternals/VTK.cmake b/CMakeExternals/VTK.cmake
index 96341d9d64..767dff62a1 100644
--- a/CMakeExternals/VTK.cmake
+++ b/CMakeExternals/VTK.cmake
@@ -1,88 +1,88 @@
#-----------------------------------------------------------------------------
# VTK
#-----------------------------------------------------------------------------
# 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(WIN32)
list(APPEND additional_cmake_args
-DCMAKE_CXX_MP_FLAG:BOOL=ON
)
else()
list(APPEND additional_cmake_args
-DVTK_MODULE_USE_EXTERNAL_VTK_freetype:BOOL=ON
)
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_Qt5)
list(APPEND additional_cmake_args
-DVTK_GROUP_ENABLE_Qt:STRING=YES
-DQt5_DIR:PATH=${Qt5_DIR}
)
endif()
if(CTEST_USE_LAUNCHERS)
list(APPEND additional_cmake_args
"-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
)
endif()
mitk_query_custom_ep_vars()
ExternalProject_Add(${proj}
LIST_SEPARATOR ${sep}
- URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/VTK-9.0.0.tar.gz
- URL_MD5 fa61cd36491d89a17edab18522bdda49
+ URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/VTK-9.0.1.tar.gz
+ URL_MD5 f443c9198495081765910ebbc9dace3a
PATCH_COMMAND
- ${PATCH_COMMAND} -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/VTK-9.0.0.patch
+ ${PATCH_COMMAND} -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/VTK-9.0.1.patch
CMAKE_GENERATOR ${gen}
CMAKE_GENERATOR_PLATFORM ${gen_platform}
CMAKE_ARGS
${ep_common_args}
-DVTK_ENABLE_WRAPPING:BOOL=OFF
-DVTK_LEGACY_REMOVE:BOOL=ON
-DVTK_MODULE_ENABLE_VTK_TestingRendering:STRING=YES
-DVTK_MODULE_ENABLE_VTK_RenderingContextOpenGL2:STRING=YES
-DVTK_MODULE_ENABLE_VTK_RenderingVolumeOpenGL2:STRING=YES
${additional_cmake_args}
${${proj}_CUSTOM_CMAKE_ARGS}
CMAKE_CACHE_ARGS
${ep_common_cache_args}
${${proj}_CUSTOM_CMAKE_CACHE_ARGS}
CMAKE_CACHE_DEFAULT_ARGS
${ep_common_cache_default_args}
${${proj}_CUSTOM_CMAKE_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 9dbf9c2326..60fde9a018 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,1422 +1,1419 @@
set(MITK_CMAKE_MINIMUM_REQUIRED_VERSION 3.18)
cmake_minimum_required(VERSION ${MITK_CMAKE_MINIMUM_REQUIRED_VERSION})
if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.19 AND CMAKE_VERSION VERSION_LESS 3.19.2)
message(FATAL_ERROR "\
CMake v${CMAKE_VERSION} is defective [1]. \
Please either downgrade to v3.18 or upgrade to at least v3.19.2.\n\
[1] https://gitlab.kitware.com/cmake/cmake/-/issues/21529")
endif()
#-----------------------------------------------------------------------------
# Policies
#-----------------------------------------------------------------------------
#[[ T28060
https://cmake.org/cmake/help/v3.18/policy/CMP0091.html
https://cmake.org/cmake/help/v3.18/variable/CMAKE_MSVC_RUNTIME_LIBRARY.html
We pass CMP0091 to all external projects as command-line argument:
-DCMAKE_POLICY_DEFAULT_CMP0091:STRING=OLD
]]
cmake_policy(SET CMP0091 OLD)
#-----------------------------------------------------------------------------
# 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 2018.04.99)
include_directories(SYSTEM ${MITK_SUPERBUILD_BINARY_DIR})
endif()
#-----------------------------------------------------------------------------
# MITK Extension Feature
#-----------------------------------------------------------------------------
set(MITK_EXTENSION_DIRS "" CACHE STRING "")
unset(MITK_ABSOLUTE_EXTENSION_DIRS)
foreach(MITK_EXTENSION_DIR ${MITK_EXTENSION_DIRS})
get_filename_component(MITK_ABSOLUTE_EXTENSION_DIR "${MITK_EXTENSION_DIR}" ABSOLUTE)
list(APPEND MITK_ABSOLUTE_EXTENSION_DIRS "${MITK_ABSOLUTE_EXTENSION_DIR}")
endforeach()
set(MITK_DIR_PLUS_EXTENSION_DIRS "${MITK_SOURCE_DIR}" ${MITK_ABSOLUTE_EXTENSION_DIRS})
#-----------------------------------------------------------------------------
# Update CMake module path
#-----------------------------------------------------------------------------
set(MITK_CMAKE_DIR ${MITK_SOURCE_DIR}/CMake)
set(CMAKE_MODULE_PATH ${MITK_CMAKE_DIR})
foreach(MITK_EXTENSION_DIR ${MITK_ABSOLUTE_EXTENSION_DIRS})
set(MITK_CMAKE_EXTENSION_DIR "${MITK_EXTENSION_DIR}/CMake")
if(EXISTS "${MITK_CMAKE_EXTENSION_DIR}")
list(APPEND CMAKE_MODULE_PATH "${MITK_CMAKE_EXTENSION_DIR}")
endif()
endforeach()
#-----------------------------------------------------------------------------
# CMake function(s) and macro(s)
#-----------------------------------------------------------------------------
# Standard CMake macros
include(FeatureSummary)
include(CTest)
include(CMakeParseArguments)
include(FindPackageHandleStandardArgs)
# MITK macros
include(mitkFunctionGetGccVersion)
include(mitkFunctionCheckCompilerFlags)
include(mitkFunctionSuppressWarnings) # includes several functions
include(mitkMacroEmptyExternalProject)
include(mitkFunctionEnableBuildConfiguration)
include(mitkFunctionWhitelists)
include(mitkFunctionAddExternalProject)
include(mitkFunctionAddLibrarySearchPaths)
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 macOS version
#-----------------------------------------------------------------------------
-# The minimum supported macOS version is 10.13. If you use a version less than 10.13, there is no guarantee that the build still works.
+# The minimum supported macOS version is 10.14. If you use a version less than
+# 10.14, there is no guarantee that the build still works.
if(APPLE)
exec_program(sw_vers ARGS -productVersion OUTPUT_VARIABLE macos_version)
- if (macos_version VERSION_LESS "10.13")
- message(WARNING "Detected macOS version \"${macos_version}\" is not supported anymore. Minimum required macOS version is at least 10.13.")
+ if (macos_version VERSION_LESS "10.14")
+ message(WARNING "Detected macOS version \"${macos_version}\" is not supported anymore. Minimum required macOS version is at least 10.14.")
endif()
- if (CMAKE_OSX_DEPLOYMENT_TARGET AND CMAKE_OSX_DEPLOYMENT_TARGET VERSION_LESS 10.13)
- message(WARNING "Detected macOS deployment target \"${CMAKE_OSX_DEPLOYMENT_TARGET}\" is not supported anymore. Minimum required macOS version is at least 10.13.")
+ if (CMAKE_OSX_DEPLOYMENT_TARGET AND CMAKE_OSX_DEPLOYMENT_TARGET VERSION_LESS 10.14)
+ message(WARNING "Detected macOS deployment target \"${CMAKE_OSX_DEPLOYMENT_TARGET}\" is not supported anymore. Minimum required macOS version is at least 10.14.")
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 14.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 14.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
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 2017
if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.10)
message(FATAL_ERROR "Microsoft Visual Studio 2017 or newer required")
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 14)
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++14 flag for targets.
# However, compile flag checks also need to be done with -std=c++14.
# The MITK_CXX14_FLAG variable is also used for external projects
# build during the MITK super-build.
mitkFunctionCheckCompilerFlags("-std=c++14" MITK_CXX14_FLAG)
#-----------------------------------------------------------------------------
# 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)
#-----------------------------------------------------------------------------
# -----------------------------------------
# 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)
option(MITK_FAST_TESTING "Disable long-running tests like packaging" OFF)
option(MITK_XVFB_TESTING "Execute test drivers through xvfb-run" OFF)
option(MITK_BUILD_ALL_APPS "Build all MITK applications" OFF)
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_XVFB_TESTING
MITK_FAST_TESTING
MITK_BUILD_ALL_APPS
MITK_ENABLE_PIC_READER
)
#-----------------------------------------------------------------------------
# Set UI testing flags
#-----------------------------------------------------------------------------
if(MITK_XVFB_TESTING)
set(MITK_XVFB_TESTING_COMMAND "xvfb-run" "--auto-servernum" CACHE STRING "Command and options to test through Xvfb")
mark_as_advanced(MITK_XVFB_TESTING_COMMAND)
endif(MITK_XVFB_TESTING)
# -----------------------------------------
# Other options
set(MITK_CUSTOM_REVISION_DESC "" CACHE STRING "Override MITK revision description")
mark_as_advanced(MITK_CUSTOM_REVISION_DESC)
set_property(GLOBAL PROPERTY MITK_EXTERNAL_PROJECTS "")
include(CMakeExternals/ExternalProjectList.cmake)
foreach(MITK_EXTENSION_DIR ${MITK_ABSOLUTE_EXTENSION_DIRS})
set(MITK_CMAKE_EXTERNALS_EXTENSION_DIR "${MITK_EXTENSION_DIR}/CMakeExternals")
if(EXISTS "${MITK_CMAKE_EXTERNALS_EXTENSION_DIR}/ExternalProjectList.cmake")
include("${MITK_CMAKE_EXTERNALS_EXTENSION_DIR}/ExternalProjectList.cmake")
endif()
endforeach()
# -----------------------------------------
# Other MITK_USE_* options not related to
# external projects build via the
# MITK superbuild
option(MITK_USE_BLUEBERRY "Build the BlueBerry platform" ON)
option(MITK_USE_OpenCL "Use OpenCL GPU-Computing library" OFF)
option(MITK_USE_OpenMP "Use OpenMP" OFF)
option(MITK_USE_Python3 "Use Python 3" 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()
foreach(MITK_EXTENSION_DIR ${MITK_ABSOLUTE_EXTENSION_DIRS})
file(GLOB _extBuildConfigFiles "${MITK_EXTENSION_DIR}/CMake/BuildConfigurations/*.cmake")
foreach(_extBuildConfigFile ${_extBuildConfigFiles})
get_filename_component(_extBuildConfigFile "${_extBuildConfigFile}" NAME_WE)
list(APPEND _buildConfigs "${_extBuildConfigFile}")
endforeach()
list(REMOVE_DUPLICATES _buildConfigs)
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)
# -----------------------------------------
# Qt version related variables
option(MITK_USE_Qt5 "Use Qt 5 library" ON)
if(MITK_USE_Qt5)
if(WIN32)
set(MITK_QT5_MINIMUM_VERSION 5.12.9)
else()
set(MITK_QT5_MINIMUM_VERSION 5.12)
endif()
set(MITK_QT5_COMPONENTS Concurrent OpenGL PrintSupport Script Sql Svg Widgets Xml XmlPatterns WebEngineWidgets UiTools Help LinguistTools)
if(APPLE)
list(APPEND MITK_QT5_COMPONENTS DBus)
elseif(UNIX)
list(APPEND MITK_QT5_COMPONENTS X11Extras)
endif()
# Hint at default install locations of Qt
if(NOT Qt5_DIR)
if(MSVC)
set(_dir_candidates "C:/Qt")
if(CMAKE_GENERATOR MATCHES "^Visual Studio [0-9]+ ([0-9]+)")
set(_compilers "msvc${CMAKE_MATCH_1}")
elseif(CMAKE_GENERATOR MATCHES "Ninja")
include(mitkFunctionGetMSVCVersion)
mitkFunctionGetMSVCVersion()
if(VISUAL_STUDIO_PRODUCT_NAME MATCHES "^Visual Studio ([0-9]+)")
set(_compilers "msvc${CMAKE_MATCH_1}")
endif()
endif()
if(_compilers MATCHES "[0-9]+")
if (CMAKE_MATCH_0 EQUAL 2019)
list(APPEND _compilers "msvc2017") # Binary compatible to 2019
endif()
endif()
else()
set(_dir_candidates ~/Qt)
if(APPLE)
set(_compilers clang)
else()
list(APPEND _dir_candidates /opt/Qt)
set(_compilers gcc)
endif()
endif()
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
foreach(_compiler ${_compilers})
list(APPEND _compilers64 "${_compiler}_64")
endforeach()
set(_compilers ${_compilers64})
endif()
foreach(_dir_candidate ${_dir_candidates})
get_filename_component(_dir_candidate ${_dir_candidate} REALPATH)
foreach(_compiler ${_compilers})
set(_glob_expression "${_dir_candidate}/5.*/${_compiler}")
file(GLOB _hints ${_glob_expression})
list(SORT _hints)
list(APPEND MITK_QT5_HINTS ${_hints})
endforeach()
endforeach()
endif()
find_package(Qt5 ${MITK_QT5_MINIMUM_VERSION} COMPONENTS ${MITK_QT5_COMPONENTS} REQUIRED HINTS ${MITK_QT5_HINTS})
endif()
# -----------------------------------------
# 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_cpprestsdk)
if(WIN32 AND Qt5_DIR)
set(_dir_candidate "${Qt5_DIR}/../../../../../Tools/OpenSSL/Win_x64")
get_filename_component(_dir_candidate ${_dir_candidate} ABSOLUTE)
if(EXISTS "${_dir_candidate}")
set(OPENSSL_ROOT_DIR "${_dir_candidate}")
endif()
endif()
find_package(OpenSSL QUIET)
if(NOT OpenSSL_FOUND)
set(openssl_message "Could not find OpenSSL (dependency of C++ REST SDK).\n")
if(UNIX)
if(APPLE)
set(openssl_message "${openssl_message}Please install it using your favorite package management "
"system (i.e. Homebrew or MacPorts).\n")
else()
set(openssl_message "${openssl_message}Please install the dev package of OpenSSL (i.e. libssl-dev).\n")
endif()
else()
set(openssl_message "${openssl_message}Please either install Win32 OpenSSL:\n"
" https://slproweb.com/products/Win32OpenSSL.html\n"
"Or use the Qt Maintenance tool to install:\n"
" Developer and Designer Tools > OpenSSL Toolkit > OpenSSL 64-bit binaries\n")
endif()
set(openssl_message "${openssl_message}If it still cannot be found, you can hint CMake to find OpenSSL by "
"adding/setting the OPENSSL_ROOT_DIR variable to the root directory of an "
"OpenSSL installation. Make sure to clear variables of partly found "
"versions of OpenSSL before, or they will be mixed up.")
message(FATAL_ERROR ${openssl_message})
endif()
list(APPEND MITK_USE_Boost_LIBRARIES date_time regex system)
if(UNIX)
list(APPEND MITK_USE_Boost_LIBRARIES atomic chrono filesystem random thread)
endif()
list(REMOVE_DUPLICATES MITK_USE_Boost_LIBRARIES)
set(MITK_USE_Boost_LIBRARIES ${MITK_USE_Boost_LIBRARIES} CACHE STRING "A semi-colon separated list of required Boost libraries" FORCE)
endif()
if(MITK_USE_Python3)
set(MITK_USE_ZLIB ON CACHE BOOL "" FORCE)
if(APPLE AND CMAKE_FRAMEWORK_PATH AND CMAKE_FRAMEWORK_PATH MATCHES "python3\\.?([0-9]+)")
find_package(Python3 3.${CMAKE_MATCH_1} EXACT REQUIRED COMPONENTS Interpreter Development NumPy)
else()
find_package(Python3 REQUIRED COMPONENTS Interpreter Development NumPy)
endif()
if(WIN32)
string(REPLACE "\\" "/" Python3_STDARCH "${Python3_STDARCH}")
string(REPLACE "\\" "/" Python3_STDLIB "${Python3_STDLIB}")
string(REPLACE "\\" "/" Python3_SITELIB "${Python3_SITELIB}")
endif()
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()
find_package(Git REQUIRED)
#-----------------------------------------------------------------------------
# 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 ****************************
#*****************************************************************************
#-----------------------------------------------------------------------------
# Organize MITK targets in folders
#-----------------------------------------------------------------------------
set_property(GLOBAL PROPERTY USE_FOLDERS ON)
set(MITK_ROOT_FOLDER "MITK" CACHE STRING "")
mark_as_advanced(MITK_ROOT_FOLDER)
#-----------------------------------------------------------------------------
# CMake function(s) and macro(s)
#-----------------------------------------------------------------------------
include(WriteBasicConfigVersionFile)
include(CheckCXXSourceCompiles)
include(GenerateExportHeader)
include(mitkFunctionAddCustomModuleTest)
include(mitkFunctionCheckModuleDependencies)
include(mitkFunctionCompileSnippets)
include(mitkFunctionConfigureVisualStudioUserProjectFile)
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(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++14 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 applications
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)
if(NOT MITK_FAST_TESTING)
if(MITK_CTEST_SCRIPT_MODE STREQUAL "Continuous" OR MITK_CTEST_SCRIPT_MODE STREQUAL "Experimental")
set(MITK_FAST_TESTING ON)
endif()
endif()
if(NOT UNIX)
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_DEFAULT_MODULE_NAME_PREFIX "Mitk")
set(MITK_MODULE_NAME_PREFIX ${MITK_DEFAULT_MODULE_NAME_PREFIX})
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 macOS all BlueBerry plugins get copied into every
# application bundle (.app directory) specified here
if(MITK_USE_BLUEBERRY AND APPLE)
foreach(MITK_EXTENSION_DIR ${MITK_DIR_PLUS_EXTENSION_DIRS})
set(MITK_APPLICATIONS_EXTENSION_DIR "${MITK_EXTENSION_DIR}/Applications")
if(EXISTS "${MITK_APPLICATIONS_EXTENSION_DIR}/AppList.cmake")
set(MITK_APPS "")
include("${MITK_APPLICATIONS_EXTENSION_DIR}/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()
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_CXX14_FLAG}")
set(MITK_CXX_FLAGS_DEBUG )
set(MITK_CXX_FLAGS_RELEASE )
set(MITK_EXE_LINKER_FLAGS )
set(MITK_SHARED_LINKER_FLAGS )
if(WIN32)
set(MITK_CXX_FLAGS "${MITK_CXX_FLAGS} -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
mitkFunctionCheckCompilerFlags("/wd4251" MITK_CXX_FLAGS) # warning C4251: 'identifier' : class 'type' needs to have dll-interface to be used by clients of class 'type2'
endif()
if(APPLE)
set(MITK_CXX_FLAGS "${MITK_CXX_FLAGS} -DGL_SILENCE_DEPRECATION") # Apple deprecated OpenGL in macOS 10.14
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-error=deprecated-copy
-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)
set(MITK_CXX_FLAGS_RELEASE "-U_FORTIFY_SOURCES -D_FORTIFY_SOURCE=2 ${MITK_CXX_FLAGS_RELEASE}")
endif()
set(MITK_MODULE_LINKER_FLAGS ${MITK_SHARED_LINKER_FLAGS})
set(MITK_EXE_LINKER_FLAGS ${MITK_SHARED_LINKER_FLAGS})
#-----------------------------------------------------------------------------
# MITK Packages
#-----------------------------------------------------------------------------
set(MITK_MODULES_PACKAGE_DEPENDS_DIR ${MITK_SOURCE_DIR}/CMake/PackageDepends)
set(MODULES_PACKAGE_DEPENDS_DIRS ${MITK_MODULES_PACKAGE_DEPENDS_DIR})
foreach(MITK_EXTENSION_DIR ${MITK_ABSOLUTE_EXTENSION_DIRS})
set(MITK_PACKAGE_DEPENDS_EXTENSION_DIR "${MITK_EXTENSION_DIR}/CMake/PackageDepends")
if(EXISTS "${MITK_PACKAGE_DEPENDS_EXTENSION_DIR}")
list(APPEND MODULES_PACKAGE_DEPENDS_DIRS "${MITK_PACKAGE_DEPENDS_EXTENSION_DIR}")
endif()
endforeach()
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.74 1.74.0)
# We need this later for a DCMTK workaround
set(_dcmtk_dir_orig ${DCMTK_DIR})
# 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.
if(DEFINED ${_package}_DIR)
#we store the information because it will be overwritten by find_package
#and would get lost for all EPs that use on Find<proj>.cmake instead of config
#files.
set(_temp_EP_${_package}_dir ${${_package}_DIR})
endif(DEFINED ${_package}_DIR)
find_package(${_package} QUIET CONFIG)
string(TOUPPER "${_package}" _package_uc)
if(NOT (${_package}_FOUND OR ${_package_uc}_FOUND))
if(DEFINED _temp_EP_${_package}_dir)
set(${_package}_DIR ${_temp_EP_${_package}_dir} CACHE PATH "externaly set dir of the package ${_package}" FORCE)
endif(DEFINED _temp_EP_${_package}_dir)
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_DCMTK)
- # Due to the preferred CONFIG mode in find_package calls above,
- # the DCMTKConfig.cmake file is read, which does not provide useful
- # package information. We explictly need MODULE mode to find DCMTK.
if(${_dcmtk_dir_orig} MATCHES "${MITK_EXTERNAL_PROJECT_PREFIX}.*")
# Help our FindDCMTK.cmake script find our super-build DCMTK
set(DCMTK_DIR ${MITK_EXTERNAL_PROJECT_PREFIX})
else()
# Use the original value
set(DCMTK_DIR ${_dcmtk_dir_orig})
endif()
- find_package(DCMTK REQUIRED MODULE)
endif()
if(MITK_USE_DCMQI)
# Due to the preferred CONFIG mode in find_package calls above,
# the DCMQIConfig.cmake file is read, which does not provide useful
# package information. We explictly need MODULE mode to find DCMQI.
# Help our FindDCMQI.cmake script find our super-build DCMQI
set(DCMQI_DIR ${MITK_EXTERNAL_PROJECT_PREFIX})
find_package(DCMQI REQUIRED)
endif()
if(MITK_USE_OpenIGTLink)
link_directories(${OpenIGTLink_LIBRARY_DIRS})
endif()
if(MITK_USE_OpenCL)
find_package(OpenCL REQUIRED)
endif()
if(MITK_USE_OpenMP)
find_package(OpenMP REQUIRED COMPONENTS CXX)
else()
find_package(OpenMP QUIET COMPONENTS CXX)
if(OpenMP_FOUND)
set(MITK_USE_OpenMP ON CACHE BOOL "" FORCE)
elseif(APPLE AND OpenMP_libomp_LIBRARY AND NOT OpenMP_CXX_LIB_NAMES)
set(OpenMP_CXX_LIB_NAMES libomp CACHE STRING "" FORCE)
get_filename_component(openmp_lib_dir "${OpenMP_libomp_LIBRARY}" DIRECTORY)
set(openmp_include_dir "${openmp_lib_dir}/../include")
if(EXISTS "${openmp_include_dir}")
get_filename_component(openmp_include_dir "${openmp_include_dir}" REALPATH)
set(OpenMP_CXX_FLAGS "-Xpreprocessor -fopenmp -I${openmp_include_dir}" CACHE STRING "" FORCE)
find_package(OpenMP QUIET COMPONENTS CXX)
if(OpenMP_FOUND)
set(MITK_USE_OpenMP ON CACHE BOOL "" FORCE)
endif()
endif()
endif()
endif()
# Qt support
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_Qt5)
message("> Forcing BLUEBERRY_USE_QT_HELP to OFF because MITK_USE_Qt5 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)
#[[ See T27701
# 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 (const std::exception& e)
{
fprintf(stderr, \"%s\\n\", e.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 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 subdirectories
#-----------------------------------------------------------------------------
add_subdirectory(Utilities)
add_subdirectory(Modules)
include("${CMAKE_CURRENT_SOURCE_DIR}/Modules/ModuleList.cmake")
mitkFunctionWhitelistModules(MITK MITK_MODULES)
set(MITK_ROOT_FOLDER_BACKUP "${MITK_ROOT_FOLDER}")
foreach(MITK_EXTENSION_DIR ${MITK_ABSOLUTE_EXTENSION_DIRS})
get_filename_component(MITK_ROOT_FOLDER "${MITK_EXTENSION_DIR}" NAME)
set(MITK_MODULES_EXTENSION_DIR "${MITK_EXTENSION_DIR}/Modules")
if(EXISTS "${MITK_MODULES_EXTENSION_DIR}/ModuleList.cmake")
set(MITK_MODULES "")
include("${MITK_MODULES_EXTENSION_DIR}/ModuleList.cmake")
foreach(mitk_module ${MITK_MODULES})
add_subdirectory("${MITK_MODULES_EXTENSION_DIR}/${mitk_module}" "Modules/${mitk_module}")
endforeach()
endif()
set(MITK_MODULE_NAME_PREFIX ${MITK_DEFAULT_MODULE_NAME_PREFIX})
endforeach()
set(MITK_ROOT_FOLDER "${MITK_ROOT_FOLDER_BACKUP}")
add_subdirectory(Wrapping)
set(MITK_DOXYGEN_OUTPUT_DIR "${PROJECT_BINARY_DIR}/Documentation/Doxygen" CACHE PATH
"Output directory for doxygen generated documentation.")
if(MITK_USE_BLUEBERRY)
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()
set(MITK_PLUGIN_REGEX_LIST "")
foreach(MITK_EXTENSION_DIR ${MITK_ABSOLUTE_EXTENSION_DIRS})
set(MITK_PLUGINS_EXTENSION_DIR "${MITK_EXTENSION_DIR}/Plugins")
if(EXISTS "${MITK_PLUGINS_EXTENSION_DIR}/PluginList.cmake")
set(MITK_PLUGINS "")
include("${MITK_PLUGINS_EXTENSION_DIR}/PluginList.cmake")
foreach(mitk_plugin ${MITK_PLUGINS})
list(APPEND mitk_plugins_fullpath "${MITK_PLUGINS_EXTENSION_DIR}/${mitk_plugin}")
endforeach()
endif()
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 MITK_PLUGIN_REGEX_LIST OUTPUT_VARIABLE ${varname})
endmacro()
# Get infos about application directories and build options
set(mitk_apps_fullpath "")
foreach(MITK_EXTENSION_DIR ${MITK_DIR_PLUS_EXTENSION_DIRS})
set(MITK_APPLICATIONS_EXTENSION_DIR "${MITK_EXTENSION_DIR}/Applications")
if(EXISTS "${MITK_APPLICATIONS_EXTENSION_DIR}/AppList.cmake")
set(MITK_APPS "")
include("${MITK_APPLICATIONS_EXTENSION_DIR}/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 0 directory_name)
list(GET target_info_list 1 option_name)
if(${option_name})
list(APPEND mitk_apps_fullpath "${MITK_APPLICATIONS_EXTENSION_DIR}/${directory_name}^^${option_name}")
endif()
endforeach()
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)
set(ALL_MITK_APPS "")
set(activated_apps_no 0)
foreach(MITK_EXTENSION_DIR ${MITK_DIR_PLUS_EXTENSION_DIRS})
set(MITK_APPLICATIONS_EXTENSION_DIR "${MITK_EXTENSION_DIR}/Applications")
if(EXISTS "${MITK_APPLICATIONS_EXTENSION_DIR}/AppList.cmake")
set(MITK_APPS "")
include("${MITK_APPLICATIONS_EXTENSION_DIR}/AppList.cmake")
foreach(mitk_app ${MITK_APPS})
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)
list(GET target_info_list 2 executable_name)
list(APPEND ALL_MITK_APPS "${MITK_EXTENSION_DIR}/Applications/${directory_name}^^${option_name}^^${executable_name}")
if(${option_name} OR MITK_BUILD_ALL_APPS)
MATH(EXPR activated_apps_no "${activated_apps_no} + 1")
endif()
endforeach()
endif()
endforeach()
list(LENGTH ALL_MITK_APPS app_count)
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 ${ALL_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 "${target_dir}/CPackOptions.cmake")
include("${target_dir}/CPackOptions.cmake")
endif()
if(EXISTS "${target_dir}/CPackConfig.cmake.in")
set(CPACK_PROJECT_CONFIG_FILE "${target_dir}/CPackConfig.cmake")
configure_file(${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()
# 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)
if(MSVC AND TARGET MitkWorkbench)
set_directory_properties(PROPERTIES VS_STARTUP_PROJECT MitkWorkbench)
endif()
foreach(MITK_EXTENSION_DIR ${MITK_ABSOLUTE_EXTENSION_DIRS})
set(MITK_APPLICATIONS_EXTENSION_DIR "${MITK_EXTENSION_DIR}/Applications")
if(EXISTS "${MITK_APPLICATIONS_EXTENSION_DIR}/CMakeLists.txt")
add_subdirectory("${MITK_APPLICATIONS_EXTENSION_DIR}" "Applications")
endif()
endforeach()
#-----------------------------------------------------------------------------
# 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/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/SupportedPlatforms.md b/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/SupportedPlatforms.md
index 84e8914622..596dadc9b5 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/SupportedPlatforms.md
+++ b/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/SupportedPlatforms.md
@@ -1,48 +1,49 @@
Supported Platforms {#SupportedPlatformsPage}
===================
MITK is a cross-platform framework that is available for the following platforms:
- Windows
- Linux
- macOS
Supported Platforms Details
---------------------------
The MITK team provides support for the most frequently used platforms and continuously runs testing procedures
to ensure compatibility. Due to the large amount of possible combinations of operating systems and compiler versions,
we divide platform support into two test categories: Tier 1 and Tier 2.
Although MITK may be built on a broader range of platform-compiler combinations, only a subset of these are actively
supported by the MITK development team.
Tier 1 Platforms
----------------
All Tier 1 platforms are continuously tested by our unit test suite and other internal testing procedures.
Errors or bugs discovered in these platforms are prioritized and corrected as soon as possible.
| Platform | Compilers
| ----------------------------------- | --------------------------------------------------
| Microsoft Windows 10 (x64) | Visual Studio 2019 (latest update)
| Linux Ubuntu 20.04 (x64) | Default GCC version
| Linux Ubuntu 18.04 (x64) | Default GCC version
+| Apple macOS 10.14 "Mojave" | Default Apple Clang version
Tier 2 Platforms
----------------
Tier 2 platforms may or may not be tested on a regular basis. Some Tier 2 platforms are used by individual
members of the MITK development team on a daily basis and some only receive occasional testing. While we
strive to support these platforms, MITK users should note that errors may be present in released versions
as well as in the current master branch.
| Platform | Compilers
| ----------------------------------- | --------------------------------------------------
| Microsoft Windows 10 (x64) | Visual Studio 2017 (latest update)
| Apple macOS 10.15 "Catalina" | Default Apple Clang version
-| Apple macOS 10.14 "Mojave" | Default Apple Clang version
+| Apple macOS 11.1 "Big Sur" (x64) | Default Apple Clang version
All platforms not listed above are not officially supported by the MITK team. However, we will happily accept
contributions to improve support for other platforms.
diff --git a/Examples/Plugins/org.mitk.example.gui.pcaexample/src/internal/PCAExample.cpp b/Examples/Plugins/org.mitk.example.gui.pcaexample/src/internal/PCAExample.cpp
index de72b6f722..f1f35e83a3 100644
--- a/Examples/Plugins/org.mitk.example.gui.pcaexample/src/internal/PCAExample.cpp
+++ b/Examples/Plugins/org.mitk.example.gui.pcaexample/src/internal/PCAExample.cpp
@@ -1,167 +1,167 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "PCAExample.h"
// Qt
#include <QMessageBox>
// mitk image
#include <mitkImage.h>
const std::string PCAExample::VIEW_ID = "org.mitk.views.pcaexample";
void PCAExample::SetFocus()
{
m_Controls.buttonPerformImageProcessing->setFocus();
}
void PCAExample::CreateQtPartControl(QWidget *parent)
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls.setupUi(parent);
connect(m_Controls.buttonPerformImageProcessing, SIGNAL(clicked()), this, SLOT(BtnPerfomPCAClicked()));
//initialize point set widget and point set node
mitk::DataNode::Pointer PointSetNode = mitk::DataNode::New();
PointSetNode->SetName("PCA Example Pointset");
mitk::PointSet::Pointer newPtSet = mitk::PointSet::New();
PointSetNode->SetData(newPtSet);
m_Controls.m_pointSetWidget->SetPointSetNode(PointSetNode);
this->GetDataStorage()->Add(PointSetNode);
}
PCAExample::PCAExample()
{
}
PCAExample::~PCAExample()
{
//clean up
mitk::DataNode::Pointer ptSetNode = m_Controls.m_pointSetWidget->GetPointSetNode();
m_Controls.m_pointSetWidget->SetPointSetNode(nullptr);
this->GetDataStorage()->Remove(ptSetNode);
this->GetDataStorage()->Remove(m_Axis1Node);
this->GetDataStorage()->Remove(m_Axis2Node);
this->GetDataStorage()->Remove(m_Axis3Node);
}
void PCAExample::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*source*/,
const QList<mitk::DataNode::Pointer> &nodes)
{
// iterate all selected objects, adjust warning visibility
foreach (mitk::DataNode::Pointer node, nodes)
{
if (node.IsNotNull() && dynamic_cast<mitk::Image *>(node->GetData()))
{
m_Controls.buttonPerformImageProcessing->setEnabled(true);
return;
}
}
}
void PCAExample::BtnPerfomPCAClicked()
{
std::vector<mitk::Vector3D> eigenVectors;
std::vector<double> eigenValues;
mitk::Vector3D mean;
bool success = comutePCA(m_Controls.m_pointSetWidget->GetPointSet(), eigenVectors, eigenValues, mean);
this->showEigenvectors(eigenVectors, eigenValues, mean);
MITK_INFO << "PCA: " << success;
}
bool PCAExample::comutePCA(mitk::PointSet::Pointer input, std::vector<mitk::Vector3D> &eigenVectors, std::vector<double> &eigenValues, mitk::Vector3D &pointsMean)
{
//Step 1: Construct data matrix
vnl_matrix<double> dataMatrix(3, input->GetSize(), 0.0);
int size = input->GetSize();
for (int i=0; i<size; i++)
{
dataMatrix[0][i] = input->GetPoint(i)[0];
dataMatrix[1][i] = input->GetPoint(i)[1];
dataMatrix[2][i] = input->GetPoint(i)[2];
}
//Step 2: Remove average for each row (Mittelwertbefreiung)
mitk::Vector3D mean;
for (int i = 0; i < size; i++) { mean += mitk::Vector3D(dataMatrix.get_column(i)); }
mean /= size;
for (int i = 0; i<size; i++)
{
mitk::Vector3D removedAverageI = mitk::Vector3D(dataMatrix.get_column(i)) - mean;
dataMatrix.set_column(i, removedAverageI);
}
//Step 3: Compute covariance matrix
vnl_matrix<double> covMatrix = (1.0 / (size - 1.0)) * dataMatrix * dataMatrix.transpose();
//Step 4: Singular value composition
vnl_svd<double> svd(covMatrix);
//Store results and print them to the console
MITK_INFO << "DataMatrix: " << "\n" << dataMatrix;
MITK_INFO << "CovMatrix: " << "\n" << covMatrix;
for (int i = 0; i < 3; i++)
{
eigenVectors.push_back(svd.U().get_column(i));
eigenValues.push_back(sqrt(svd.W(i)));
MITK_INFO << "Eigenvector " << i << ": " << eigenVectors.at(i);
MITK_INFO << "Eigenvalue " << i << ": " << eigenValues.at(i);
}
//Compute center of points
for (int i = 0; i < size; i++) { pointsMean += input->GetPoint(i).GetVectorFromOrigin(); }
pointsMean /= size;
return true;
}
void PCAExample::showEigenvectors(std::vector<mitk::Vector3D> eigenVectors, std::vector<double> eigenValues, mitk::Vector3D center)
{
m_Axis1Node = mitk::DataNode::New();
m_Axis1Node->SetName("Eigenvector 1");
mitk::PointSet::Pointer axis1 = mitk::PointSet::New();
- axis1->InsertPoint(0, center);
- axis1->InsertPoint(1, (center + eigenVectors.at(0)*eigenValues.at(0)));
+ axis1->InsertPoint(0, mitk::Point3D(center));
+ axis1->InsertPoint(1, mitk::Point3D(center + eigenVectors.at(0)*eigenValues.at(0)));
m_Axis1Node->SetData(axis1);
m_Axis1Node->SetBoolProperty("show contour", true);
m_Axis1Node->SetColor(1, 0, 0);
this->GetDataStorage()->Add(m_Axis1Node);
m_Axis2Node = mitk::DataNode::New();
m_Axis2Node->SetName("Eigenvector 2");
mitk::PointSet::Pointer axis2 = mitk::PointSet::New();
- axis2->InsertPoint(0, center);
- axis2->InsertPoint(1, (center + eigenVectors.at(1)*eigenValues.at(1)));
+ axis2->InsertPoint(0, mitk::Point3D(center));
+ axis2->InsertPoint(1, mitk::Point3D(center + eigenVectors.at(1)*eigenValues.at(1)));
m_Axis2Node->SetData(axis2);
m_Axis2Node->SetBoolProperty("show contour", true);
m_Axis2Node->SetColor(1, 0, 0);
this->GetDataStorage()->Add(m_Axis2Node);
m_Axis3Node = mitk::DataNode::New();
m_Axis3Node->SetName("Eigenvector 3");
mitk::PointSet::Pointer axis3 = mitk::PointSet::New();
- axis3->InsertPoint(0, center);
- axis3->InsertPoint(1, (center + eigenVectors.at(2)*eigenValues.at(2)));
+ axis3->InsertPoint(0, mitk::Point3D(center));
+ axis3->InsertPoint(1, mitk::Point3D(center + eigenVectors.at(2)*eigenValues.at(2)));
m_Axis3Node->SetData(axis3);
m_Axis3Node->SetBoolProperty("show contour", true);
m_Axis3Node->SetColor(1, 0, 0);
this->GetDataStorage()->Add(m_Axis3Node);
}
diff --git a/LICENSE b/LICENSE
index d68700c4ab..4cd2f3576a 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,29 +1,29 @@
BSD 3-Clause License
-Copyright (c) 2003-2019, German Cancer Research Center (DKFZ)
+Copyright (c) 2003-2021, German Cancer Research Center (DKFZ)
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. 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.
3. Neither the name of the copyright holder 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/Modules/AppUtil/include/mitkBaseApplication.h b/Modules/AppUtil/include/mitkBaseApplication.h
index 78cd66de27..3d00e1b7c2 100644
--- a/Modules/AppUtil/include/mitkBaseApplication.h
+++ b/Modules/AppUtil/include/mitkBaseApplication.h
@@ -1,317 +1,318 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkBaseApplication_h
#define mitkBaseApplication_h
#include <MitkAppUtilExports.h>
#include <Poco/Util/Application.h>
#include <QString>
#include <QVariant>
class ctkPluginContext;
class ctkPluginFramework;
class QCoreApplication;
class QTranslator;
namespace mitk
{
/**
* A utility class for starting BlueBerry applications.
*
* In the simplest case, create an instance of this class and call run().
* This will launch a CTK plugin framework instance and execute the
* default application registered by a plug-in via the
* org.blueberry.osgi.applications extension point.
*
* This class contains many convenience methods to:
* - Put the application in <em>safe mode</em> which catches unhandled
* exceptions thrown in the Qt event loop and displays an error
* message.
* - Put the application in <em>single mode</em> which by default
* sends the command line arguments to an already running instance
* of the same application instead of creating a second instance.
* - Add a list of library names which should be pre-loaded at
* application start-up, e.g. to speed up the initial launch during
* the caching process of the plug-in meta-data.
* - Set a custom provisioning file to start a specific set of CTK
* plug-ins during application start-up.
* - Set and get CTK plugin framework properties
*
* The behavior can further be customized by deriving from BaseApplication
* and overriding specific methods, such as:
* - initializeLibraryPaths() to add specific library / plugin search paths
* - defineOptions(Poco::Util::OptionSet&) to define a custom set of
* command line options
* - getQApplication() to provide a custom QCoreApplication instance
*
* A simple but complete example:
* \code
* #include <mitkBaseApplication.h>
*
* int main(int argc, char* argv[])
* {
* mitk::BaseApplication app(argc, argv);
* app.setApplicationName("MyApp");
* app.setOrganizationName("MyOrganization");
*
* // Run the workbench
* return app.run();
* }
* \endcode
*/
class MITKAPPUTIL_EXPORT BaseApplication : public Poco::Util::Application
{
public:
// Command line arguments
static const QString ARG_APPLICATION;
static const QString ARG_CLEAN;
static const QString ARG_CONSOLELOG;
static const QString ARG_DEBUG;
static const QString ARG_FORCE_PLUGIN_INSTALL;
static const QString ARG_HOME;
static const QString ARG_NEWINSTANCE;
static const QString ARG_NO_LAZY_REGISTRY_CACHE_LOADING;
static const QString ARG_NO_REGISTRY_CACHE;
static const QString ARG_PLUGIN_CACHE;
static const QString ARG_PLUGIN_DIRS;
static const QString ARG_PRELOAD_LIBRARY;
static const QString ARG_PRODUCT;
static const QString ARG_PROVISIONING;
static const QString ARG_REGISTRY_MULTI_LANGUAGE;
static const QString ARG_SPLASH_IMAGE;
static const QString ARG_STORAGE_DIR;
static const QString ARG_XARGS;
+ static const QString ARG_LOG_QT_MESSAGES;
// BlueBerry specific plugin framework properties
static const QString PROP_APPLICATION;
static const QString PROP_FORCE_PLUGIN_INSTALL;
static const QString PROP_NEWINSTANCE;
static const QString PROP_NO_LAZY_REGISTRY_CACHE_LOADING;
static const QString PROP_NO_REGISTRY_CACHE;
static const QString PROP_PRODUCT;
static const QString PROP_REGISTRY_MULTI_LANGUAGE;
BaseApplication(int argc, char **argv);
~BaseApplication() override;
/**
* Initialize the Qt library such that a QCoreApplication
* instance is available and e.g. Qt widgets can be created.
*
* This is usually not called directly by the user.
*/
void initializeQt();
/**
* Launches the BlueBerry framework and runs the default application
* or the one specified in the PROP_APPLICATION framework property.
*
* @return The return code of the application after it was shut down.
*/
int run() override;
void printHelp(const std::string &name, const std::string &value);
/**
* Set the application name. Same as QCoreApplication::setApplicationName.
* @param name The application name.
*/
void setApplicationName(const QString &name);
QString getApplicationName() const;
/**
* Set the organization name. Same as QCoreApplication::setOrganizationName.
* @param name The organization name.
*/
void setOrganizationName(const QString &name);
QString getOrganizationName() const;
/**
* Set the organization domain. Same as QCoreApplication::setOrganizationDomain.
* @param name The organization domain.
*/
void setOrganizationDomain(const QString &name);
QString getOrganizationDomain() const;
/**
* Put the application in single mode, which by default only allows
* a single instance of the application to be created.
*
* Calling this method after run() has been called has no effect.
*
* @param singleMode
*/
void setSingleMode(bool singleMode);
bool getSingleMode() const;
/**
* Put the application in safe mode, catching exceptions from the
* Qt event loop.
*
* @param safeMode
*/
void setSafeMode(bool safeMode);
bool getSafeMode() const;
/**
* Set a list of library names or absoulte file paths
* which should be loaded at application start-up. The name
* and file path may contain a library version appended at the
* end and separated by a '$' charactger.
*
* For example <code>liborg_mitk_gui_qt_common$1.0</code>.
* Platform specific suffixes are appended automatically.
*
* @param libraryBaseNames A list of library base names.
*/
void setPreloadLibraries(const QStringList &libraryBaseNames);
/**
* Get the list of library base names which should be pre-loaded.
*
* @return A list of pre-loaded libraries.
*/
QStringList getPreloadLibraries() const;
/**
* Set the path to the provisioning file.
*
* By default a provisioning file located in the same directory
* as the executable and named \<executable\>.provisioning
* is loaded if it exists. To disable parsing of provisioning
* files, use an empty string as the argument. Use a
* null QString (\c QString::null ) to reset to the
* default behaviour.
*
* @param filePath An absolute file path to the provisioning file.
*/
void setProvisioningFilePath(const QString &filePath);
/**
* Get the file path to the provisioning file.
* @return The provisioning file path.
*/
QString getProvisioningFilePath() const;
void setProperty(const QString &property, const QVariant &value);
QVariant getProperty(const QString &property) const;
void installTranslator(QTranslator*);
bool isRunning();
void sendMessage(const QByteArray);
protected:
void initialize(Poco::Util::Application &self) override;
void uninitialize() override;
int getArgc() const;
char **getArgv() const;
/**
* Get the framework storage directory for the CTK plugin
* framework. This method is called in the initialize(Poco::Util::Application&)
* method. It must not be called without a QCoreApplications instance.
*
* @return The CTK Plugin Framework storage directory.
*/
virtual QString getCTKFrameworkStorageDir() const;
/**
* Initialize the CppMicroServices library.
*
* The default implementation set the CppMicroServices storage
* path to the current ctkPluginConstants::FRAMEWORK_STORAGE property
* value.
*
* This method is called in the initialize(Poco::Util::Application&)
* after the CTK Plugin Framework storage directory property
* was set.
*/
virtual void initializeCppMicroServices();
/**
* Get the QCoreApplication object.
*
* This method is called in the initialize(Poco::Util::Application&)
* method and must create a QCoreApplication instance if the
* global qApp variable is not initialized yet.
*
* @return The current QCoreApplication instance. This method
* never returns null.
*/
virtual QCoreApplication *getQApplication() const;
/**
* Add plugin library search paths to the CTK Plugin Framework.
*
* This method is called in the nitialize(Poco::Util::Application&)
* method after getQApplication() was called.
*/
virtual void initializeLibraryPaths();
/**
* Runs the application for which the platform was started. The platform
* must be running.
* <p>
* The given argument is passed to the application being run. If it is an invalid QVariant
* then the command line arguments used in starting the platform, and not consumed
* by the platform code, are passed to the application as a <code>QStringList</code>.
* </p>
* @param args the argument passed to the application. May be <code>invalid</code>
* @return the result of running the application
* @throws std::exception if anything goes wrong
*/
int main(const std::vector<std::string> &args) override;
/**
* Define command line arguments
* @param options
*/
void defineOptions(Poco::Util::OptionSet &options) override;
QSharedPointer<ctkPluginFramework> getFramework() const;
ctkPluginContext *getFrameworkContext() const;
/**
* Get the initial properties for the CTK plugin framework.
*
* The returned map contains the initial framework properties for
* initializing the CTK plugin framework. The value of specific
* properties may change at runtime and differ from the initial
* value.
*
* @return The initial CTK Plugin Framework properties.
*/
QHash<QString, QVariant> getFrameworkProperties() const;
/*
* Initialize and display the splash screen if an image filename is given
*
*/
void initializeSplashScreen(QCoreApplication * application) const;
private:
struct Impl;
Impl* d;
};
}
#endif // MITKBASEAPPLICATION_H
diff --git a/Modules/AppUtil/src/mitkBaseApplication.cpp b/Modules/AppUtil/src/mitkBaseApplication.cpp
index b13e425ccb..e41a40fe79 100644
--- a/Modules/AppUtil/src/mitkBaseApplication.cpp
+++ b/Modules/AppUtil/src/mitkBaseApplication.cpp
@@ -1,858 +1,875 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkBaseApplication.h>
#include <mitkExceptionMacro.h>
#include <mitkLogMacros.h>
#include <mitkProvisioningInfo.h>
#include <QmitkSafeApplication.h>
#include <QmitkSingleApplication.h>
#include <Poco/Util/HelpFormatter.h>
#include <ctkPluginFramework.h>
#include <ctkPluginFramework_global.h>
#include <ctkPluginFrameworkLauncher.h>
#include <usModuleSettings.h>
#include <vtkOpenGLRenderWindow.h>
#include <QVTKOpenGLNativeWidget.h>
#include <QCoreApplication>
#include <QDir>
#include <QFileInfo>
#include <QRunnable>
#include <QSplashScreen>
#include <QStandardPaths>
#include <QTime>
#include <QWebEngineUrlScheme>
namespace
{
void outputQtMessage(QtMsgType type, const QMessageLogContext&, const QString& msg)
{
auto message = msg.toStdString();
switch (type)
{
case QtDebugMsg:
MITK_DEBUG << message;
break;
case QtInfoMsg:
MITK_INFO << message;
break;
case QtWarningMsg:
MITK_WARN << message;
break;
case QtCriticalMsg:
MITK_ERROR << message;
break;
case QtFatalMsg:
MITK_ERROR << message;
abort();
default:
MITK_INFO << message;
break;
}
}
}
namespace mitk
{
const QString BaseApplication::ARG_APPLICATION = "BlueBerry.application";
const QString BaseApplication::ARG_CLEAN = "BlueBerry.clean";
const QString BaseApplication::ARG_CONSOLELOG = "BlueBerry.consoleLog";
const QString BaseApplication::ARG_DEBUG = "BlueBerry.debug";
const QString BaseApplication::ARG_FORCE_PLUGIN_INSTALL = "BlueBerry.forcePlugins";
const QString BaseApplication::ARG_HOME = "BlueBerry.home";
const QString BaseApplication::ARG_NEWINSTANCE = "BlueBerry.newInstance";
const QString BaseApplication::ARG_NO_LAZY_REGISTRY_CACHE_LOADING = "BlueBerry.noLazyRegistryCacheLoading";
const QString BaseApplication::ARG_NO_REGISTRY_CACHE = "BlueBerry.noRegistryCache";
const QString BaseApplication::ARG_PLUGIN_CACHE = "BlueBerry.plugin_cache_dir";
const QString BaseApplication::ARG_PLUGIN_DIRS = "BlueBerry.plugin_dirs";
const QString BaseApplication::ARG_PRELOAD_LIBRARY = "BlueBerry.preloadLibrary";
const QString BaseApplication::ARG_PRODUCT = "BlueBerry.product";
const QString BaseApplication::ARG_PROVISIONING = "BlueBerry.provisioning";
const QString BaseApplication::ARG_REGISTRY_MULTI_LANGUAGE = "BlueBerry.registryMultiLanguage";
const QString BaseApplication::ARG_SPLASH_IMAGE = "BlueBerry.splashscreen";
const QString BaseApplication::ARG_STORAGE_DIR = "BlueBerry.storageDir";
const QString BaseApplication::ARG_XARGS = "xargs";
+ const QString BaseApplication::ARG_LOG_QT_MESSAGES = "Qt.logMessages";
const QString BaseApplication::PROP_APPLICATION = "blueberry.application";
const QString BaseApplication::PROP_FORCE_PLUGIN_INSTALL = BaseApplication::ARG_FORCE_PLUGIN_INSTALL;
const QString BaseApplication::PROP_NEWINSTANCE = BaseApplication::ARG_NEWINSTANCE;
const QString BaseApplication::PROP_NO_LAZY_REGISTRY_CACHE_LOADING = BaseApplication::ARG_NO_LAZY_REGISTRY_CACHE_LOADING;
const QString BaseApplication::PROP_NO_REGISTRY_CACHE = BaseApplication::ARG_NO_REGISTRY_CACHE;
const QString BaseApplication::PROP_PRODUCT = "blueberry.product";
const QString BaseApplication::PROP_REGISTRY_MULTI_LANGUAGE = BaseApplication::ARG_REGISTRY_MULTI_LANGUAGE;
class SplashCloserCallback : public QRunnable
{
public:
SplashCloserCallback(QSplashScreen* splashscreen)
: m_Splashscreen(splashscreen)
{
}
void run() override
{
this->m_Splashscreen->close();
}
private:
QSplashScreen *m_Splashscreen; // Owned by BaseApplication::Impl
};
struct BaseApplication::Impl
{
ctkProperties m_FWProps;
QCoreApplication *m_QApp;
int m_Argc;
char **m_Argv;
#ifdef Q_OS_MAC
std::vector<char*> m_Argv_macOS;
#endif
QString m_AppName;
QString m_OrgaName;
QString m_OrgaDomain;
bool m_SingleMode;
bool m_SafeMode;
QSplashScreen *m_Splashscreen;
SplashCloserCallback *m_SplashscreenClosingCallback;
+ bool m_LogQtMessages;
+
QStringList m_PreloadLibs;
QString m_ProvFile;
Impl(int argc, char **argv)
: m_Argc(argc),
m_Argv(argv),
#ifdef Q_OS_MAC
m_Argv_macOS(),
#endif
m_SingleMode(false),
m_SafeMode(true),
m_Splashscreen(nullptr),
- m_SplashscreenClosingCallback(nullptr)
+ m_SplashscreenClosingCallback(nullptr),
+ m_LogQtMessages(false)
{
#ifdef Q_OS_MAC
/* On macOS the process serial number is passed as an command line argument (-psn_<NUMBER>)
in certain circumstances. This option causes a Poco exception. We remove it, if present. */
- m_Argv_macOS.reserve(argc);
+ m_Argv_macOS.reserve(argc + 1);
const char psn[] = "-psn";
- for (decltype(argc) i = 0; i < argc; ++i)
+ for (int i = 0; i < argc; ++i)
{
- if (0 == strncmp(argv[i], psn, sizeof(psn)))
+ if (0 == strncmp(argv[i], psn, sizeof(psn) - 1))
continue;
m_Argv_macOS.push_back(argv[i]);
}
- m_Argc = static_cast<decltype(m_Argc)>(m_Argv_macOS.size());
+ m_Argv_macOS.push_back(nullptr);
+
+ m_Argc = static_cast<decltype(m_Argc)>(m_Argv_macOS.size() - 1);
m_Argv = m_Argv_macOS.data();
#endif
}
~Impl()
{
delete m_SplashscreenClosingCallback;
delete m_Splashscreen;
delete m_QApp;
}
QVariant getProperty(const QString &property) const
{
auto iter = m_FWProps.find(property);
return m_FWProps.end() != iter
? iter.value()
: QVariant();
}
void handleBooleanOption(const std::string &name, const std::string &)
{
+ if (ARG_LOG_QT_MESSAGES.toStdString() == name)
+ {
+ m_LogQtMessages = true;
+ return;
+ }
+
auto fwKey = QString::fromStdString(name);
// Translate some keys to proper framework properties
if (ARG_CONSOLELOG == fwKey)
fwKey = ctkPluginFrameworkLauncher::PROP_CONSOLE_LOG;
// For all other options we use the command line option name as the
// framework property key.
m_FWProps[fwKey] = true;
}
void handlePreloadLibraryOption(const std::string &, const std::string &value)
{
m_PreloadLibs.push_back(QString::fromStdString(value));
}
void handleClean(const std::string &, const std::string &)
{
m_FWProps[ctkPluginConstants::FRAMEWORK_STORAGE_CLEAN] = ctkPluginConstants::FRAMEWORK_STORAGE_CLEAN_ONFIRSTINIT;
}
void initializeCTKPluginFrameworkProperties(Poco::Util::LayeredConfiguration &configuration)
{
// Add all configuration key/value pairs as framework properties
Poco::Util::LayeredConfiguration::Keys keys;
Poco::Util::LayeredConfiguration::Keys keyStack;
configuration.keys(keyStack);
std::vector<std::string> keyChain;
while (!keyStack.empty())
{
const auto currSubKey = keyStack.back();
if (!keyChain.empty() && keyChain.back() == currSubKey)
{
keyChain.pop_back();
keyStack.pop_back();
continue;
}
Poco::Util::LayeredConfiguration::Keys subKeys;
configuration.keys(currSubKey, subKeys);
if (subKeys.empty())
{
std::string finalKey;
keyStack.pop_back();
for (const auto& key : keyChain)
finalKey += key + '.';
finalKey += currSubKey;
keys.push_back(finalKey);
}
else
{
keyChain.push_back(currSubKey);
for (const auto& key : subKeys)
keyStack.push_back(key);
}
}
for (const auto& key : keys)
{
if (configuration.hasProperty(key))
{
// .ini and command line options overwrite already inserted keys
auto qKey = QString::fromStdString(key);
m_FWProps[qKey] = QString::fromStdString(configuration.getString(key));
}
}
}
void parseProvisioningFile(const QString &filePath)
{
// Skip parsing if the file path is empty
if (filePath.isEmpty())
return;
auto consoleLog = this->getProperty(ctkPluginFrameworkLauncher::PROP_CONSOLE_LOG).toBool();
// Read initial plugins from a provisioning file
QFileInfo provFile(filePath);
QStringList pluginsToStart;
if (provFile.exists())
{
MITK_INFO(consoleLog) << "Using provisioning file: " << qPrintable(provFile.absoluteFilePath());
ProvisioningInfo provInfo(provFile.absoluteFilePath());
// It can still happen that the encoding is not compatible with the fromUtf8 function (i.e. when
// manipulating the LANG variable). The QStringList in provInfo is empty then.
if (provInfo.getPluginDirs().empty())
{
MITK_ERROR << "Cannot search for provisioning file, the retrieved directory list is empty.\n"
<< "This can happen if there are some special non-ASCII characters in the install path.";
}
else
{
for(const auto& pluginPath : provInfo.getPluginDirs())
ctkPluginFrameworkLauncher::addSearchPath(pluginPath);
auto pluginUrlsToStart = provInfo.getPluginsToStart();
- for (const auto& url : pluginUrlsToStart)
+ for (const auto& url : qAsConst(pluginUrlsToStart))
pluginsToStart.push_back(url.toString());
}
}
else
{
MITK_INFO(consoleLog) << "Provisionig file does not exist.";
}
if (!pluginsToStart.isEmpty())
{
m_FWProps[ctkPluginFrameworkLauncher::PROP_PLUGINS] = pluginsToStart;
// Use transient start with declared activation policy (this helps when the provisioning file
// changes and some plug-ins should not be installed in the application any more).
ctkPlugin::StartOptions startOptions(ctkPlugin::START_TRANSIENT | ctkPlugin::START_ACTIVATION_POLICY);
m_FWProps[ctkPluginFrameworkLauncher::PROP_PLUGINS_START_OPTIONS] = static_cast<int>(startOptions);
}
}
};
BaseApplication::BaseApplication(int argc, char **argv)
: Application(),
d(new Impl(argc, argv))
{
}
BaseApplication::~BaseApplication()
{
delete d;
}
void BaseApplication::printHelp(const std::string &, const std::string &)
{
Poco::Util::HelpFormatter help(this->options());
help.setAutoIndent();
help.setCommand(this->commandName());
help.format(std::cout);
exit(EXIT_OK);
}
void BaseApplication::setApplicationName(const QString &name)
{
if (nullptr != qApp)
qApp->setApplicationName(name);
d->m_AppName = name;
}
QString BaseApplication::getApplicationName() const
{
return nullptr != qApp
? qApp->applicationName()
: d->m_AppName;
}
void BaseApplication::setOrganizationName(const QString &name)
{
if (nullptr != qApp)
qApp->setOrganizationName(name);
d->m_OrgaName = name;
}
QString BaseApplication::getOrganizationName() const
{
return nullptr != qApp
? qApp->organizationName()
: d->m_OrgaName;
}
void BaseApplication::setOrganizationDomain(const QString &domain)
{
if (nullptr != qApp)
qApp->setOrganizationDomain(domain);
d->m_OrgaDomain = domain;
}
QString BaseApplication::getOrganizationDomain() const
{
return nullptr != qApp
? qApp->organizationDomain()
: d->m_OrgaDomain;
}
void BaseApplication::setSingleMode(bool singleMode)
{
if (nullptr != qApp)
return;
d->m_SingleMode = singleMode;
}
bool BaseApplication::getSingleMode() const
{
return d->m_SingleMode;
}
void BaseApplication::setSafeMode(bool safeMode)
{
if (nullptr != qApp && nullptr == d->m_QApp)
return;
d->m_SafeMode = safeMode;
nullptr == d->m_QApp && getSingleMode()
? static_cast<QmitkSingleApplication *>(d->m_QApp)->setSafeMode(safeMode)
: static_cast<QmitkSafeApplication *>(d->m_QApp)->setSafeMode(safeMode);
}
bool BaseApplication::getSafeMode() const
{
return d->m_SafeMode;
}
void BaseApplication::setPreloadLibraries(const QStringList &libraryBaseNames)
{
d->m_PreloadLibs = libraryBaseNames;
}
QStringList BaseApplication::getPreloadLibraries() const
{
return d->m_PreloadLibs;
}
void BaseApplication::setProvisioningFilePath(const QString &filePath)
{
d->m_ProvFile = filePath;
}
QString BaseApplication::getProvisioningFilePath() const
{
auto provFilePath = d->m_ProvFile;
// A null QString means look up a default provisioning file
if (provFilePath.isNull() && nullptr != qApp)
{
QFileInfo appFilePath(QCoreApplication::applicationFilePath());
QDir basePath(QCoreApplication::applicationDirPath());
auto provFileName = appFilePath.baseName() + ".provisioning";
QFileInfo provFile(basePath.absoluteFilePath(provFileName));
#ifdef Q_OS_MAC
/*
* On macOS, if started from the build directory, the .provisioning file is located at:
* <MITK-build/bin/MitkWorkbench.provisioning>
* The executable path is:
* <MITK-build/bin/MitkWorkbench.app/Contents/MacOS/MitkWorkbench>
* In this case we have to cdUp threetimes.
*
* During packaging the MitkWorkbench.provisioning file is placed at the same
* level like the executable. Nothing has to be done.
*/
if (!provFile.exists())
{
basePath.cdUp();
basePath.cdUp();
basePath.cdUp();
provFile = basePath.absoluteFilePath(provFileName);
}
#endif
if (provFile.exists())
{
provFilePath = provFile.absoluteFilePath();
}
#ifdef CMAKE_INTDIR
else
{
basePath.cdUp();
provFile.setFile(basePath.absoluteFilePath(provFileName));
if (provFile.exists())
provFilePath = provFile.absoluteFilePath();
}
#endif
}
return provFilePath;
}
void BaseApplication::initializeQt()
{
if (nullptr != qApp)
return;
// If parameters have been set before, we have to store them to hand them
// through to the application
auto appName = this->getApplicationName();
auto orgName = this->getOrganizationName();
auto orgDomain = this->getOrganizationDomain();
// Create a QCoreApplication instance
this->getQApplication();
// Provide parameters to QCoreApplication
this->setApplicationName(appName);
this->setOrganizationName(orgName);
this->setOrganizationDomain(orgDomain);
- qInstallMessageHandler(outputQtMessage);
+ if (d->m_LogQtMessages)
+ qInstallMessageHandler(outputQtMessage);
QWebEngineUrlScheme qtHelpScheme("qthelp");
qtHelpScheme.setFlags(QWebEngineUrlScheme::LocalScheme | QWebEngineUrlScheme::LocalAccessAllowed);
QWebEngineUrlScheme::registerScheme(qtHelpScheme);
}
void BaseApplication::initialize(Poco::Util::Application &self)
{
// 1. Call the super-class method
Poco::Util::Application::initialize(self);
// 2. Initialize the Qt framework (by creating a QCoreApplication)
this->initializeQt();
// 3. Seed the random number generator, once at startup.
QTime time = QTime::currentTime();
qsrand((uint)time.msec());
// 4. Load the "default" configuration, which involves parsing
// an optional <executable-name>.ini file and parsing any
// command line arguments
this->loadConfiguration();
// 5. Add configuration data from the command line and the
// optional <executable-name>.ini file as CTK plugin
// framework properties.
d->initializeCTKPluginFrameworkProperties(this->config());
// 6. Initialize splash screen if an image path is provided
// in the .ini file
this->initializeSplashScreen(qApp);
// 7. Set the custom CTK Plugin Framework storage directory
QString storageDir = this->getCTKFrameworkStorageDir();
if (!storageDir.isEmpty())
d->m_FWProps[ctkPluginConstants::FRAMEWORK_STORAGE] = storageDir;
// 8. Set the library search paths and the pre-load library property
this->initializeLibraryPaths();
auto preloadLibs = this->getPreloadLibraries();
if (!preloadLibs.isEmpty())
d->m_FWProps[ctkPluginConstants::FRAMEWORK_PRELOAD_LIBRARIES] = preloadLibs;
// 9. Initialize the CppMicroServices library.
// The initializeCppMicroServices() method reuses the
// FRAMEWORK_STORAGE property, so we call it after the
// getCTKFrameworkStorageDir method.
this->initializeCppMicroServices();
// 10. Parse the (optional) provisioning file and set the
// correct framework properties.
d->parseProvisioningFile(this->getProvisioningFilePath());
// 11. Set the CTK Plugin Framework properties
ctkPluginFrameworkLauncher::setFrameworkProperties(d->m_FWProps);
}
void BaseApplication::uninitialize()
{
auto pfw = this->getFramework();
if (pfw)
{
pfw->stop();
// Wait for up to 10 seconds for the CTK plugin framework to stop
pfw->waitForStop(10000);
}
Poco::Util::Application::uninitialize();
}
int BaseApplication::getArgc() const
{
return d->m_Argc;
}
char **BaseApplication::getArgv() const
{
return d->m_Argv;
}
QString BaseApplication::getCTKFrameworkStorageDir() const
{
QString storageDir;
if (this->getSingleMode())
{
// This function checks if an instance is already running and either sends a message to
// it containing the command line arguments or checks if a new instance was forced by
// providing the BlueBerry.newInstance command line argument. In the latter case, a path
// to a temporary directory for the new application's storage directory is returned.
storageDir = handleNewAppInstance(static_cast<QtSingleApplication *>(d->m_QApp),
d->m_Argc, d->m_Argv, ARG_NEWINSTANCE);
}
if (storageDir.isEmpty())
{
// This is a new instance and no other instance is already running. We specify the
// storage directory here (this is the same code as in berryInternalPlatform.cpp)
// so that we can re-use the location for the persistent data location of the
// the CppMicroServices library.
// Append a hash value of the absolute path of the executable to the data location.
// This allows to start the same application from different build or install trees.
storageDir = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + "/" +
this->getOrganizationName() + "/" + this->getApplicationName() + '_';
storageDir += QString::number(qHash(QCoreApplication::applicationDirPath())) + "/";
}
return storageDir;
}
void BaseApplication::initializeCppMicroServices()
{
auto storageDir = this->getProperty(ctkPluginConstants::FRAMEWORK_STORAGE).toString();
if (!storageDir.isEmpty())
us::ModuleSettings::SetStoragePath((storageDir + "us" + QDir::separator()).toStdString());
}
QCoreApplication *BaseApplication::getQApplication() const
{
if (nullptr == qApp)
{
vtkOpenGLRenderWindow::SetGlobalMaximumNumberOfMultiSamples(0);
auto defaultFormat = QVTKOpenGLNativeWidget::defaultFormat();
defaultFormat.setSamples(0);
QSurfaceFormat::setDefaultFormat(defaultFormat);
#ifdef Q_OS_OSX
QCoreApplication::setAttribute(Qt::AA_DontCreateNativeWidgetSiblings);
#endif
QCoreApplication::setAttribute(Qt::AA_ShareOpenGLContexts);
d->m_QApp = this->getSingleMode()
? static_cast<QCoreApplication*>(new QmitkSingleApplication(d->m_Argc, d->m_Argv, this->getSafeMode()))
: static_cast<QCoreApplication*>(new QmitkSafeApplication(d->m_Argc, d->m_Argv, this->getSafeMode()));
}
return qApp;
}
void BaseApplication::initializeLibraryPaths()
{
QStringList suffixes;
suffixes << "plugins";
#ifdef Q_OS_WINDOWS
suffixes << "bin/plugins";
#ifdef CMAKE_INTDIR
suffixes << "bin/" CMAKE_INTDIR "/plugins";
#endif
#else
suffixes << "lib/plugins";
#ifdef CMAKE_INTDIR
suffixes << "lib/" CMAKE_INTDIR "/plugins";
#endif
#endif
#ifdef Q_OS_MAC
suffixes << "../../plugins";
#endif
// We add a couple of standard library search paths for plug-ins
QDir appDir(QCoreApplication::applicationDirPath());
// Walk one directory up and add bin and lib sub-dirs; this might be redundant
appDir.cdUp();
- for (const auto& suffix : suffixes)
+ for (const auto& suffix : qAsConst(suffixes))
ctkPluginFrameworkLauncher::addSearchPath(appDir.absoluteFilePath(suffix));
}
int BaseApplication::main(const std::vector<std::string> &args)
{
// Start the plugin framework and all installed plug-ins according to their auto-start setting
QStringList arguments;
for (auto const &arg : args)
arguments.push_back(QString::fromStdString(arg));
if (nullptr != d->m_Splashscreen)
{
// A splash screen is displayed. Create the closing callback.
d->m_SplashscreenClosingCallback = new SplashCloserCallback(d->m_Splashscreen);
}
return ctkPluginFrameworkLauncher::run(d->m_SplashscreenClosingCallback, QVariant::fromValue(arguments)).toInt();
}
void BaseApplication::defineOptions(Poco::Util::OptionSet &options)
{
Poco::Util::Option helpOption("help", "h", "print this help text");
helpOption.callback(Poco::Util::OptionCallback<BaseApplication>(this, &BaseApplication::printHelp));
options.addOption(helpOption);
Poco::Util::Option newInstanceOption(ARG_NEWINSTANCE.toStdString(), "", "forces a new instance of this application");
newInstanceOption.callback(Poco::Util::OptionCallback<Impl>(d, &Impl::handleBooleanOption));
options.addOption(newInstanceOption);
Poco::Util::Option cleanOption(ARG_CLEAN.toStdString(), "", "cleans the plugin cache");
cleanOption.callback(Poco::Util::OptionCallback<Impl>(d, &Impl::handleClean));
options.addOption(cleanOption);
Poco::Util::Option productOption(ARG_PRODUCT.toStdString(), "", "the id of the product to be launched");
productOption.argument("<id>").binding(PROP_PRODUCT.toStdString());
options.addOption(productOption);
Poco::Util::Option appOption(ARG_APPLICATION.toStdString(), "", "the id of the application extension to be executed");
appOption.argument("<id>").binding(PROP_APPLICATION.toStdString());
options.addOption(appOption);
Poco::Util::Option provOption(ARG_PROVISIONING.toStdString(), "", "the location of a provisioning file");
provOption.argument("<prov file>").binding(ARG_PROVISIONING.toStdString());
options.addOption(provOption);
Poco::Util::Option storageDirOption(ARG_STORAGE_DIR.toStdString(), "", "the location for storing persistent application data");
storageDirOption.argument("<dir>").binding(ctkPluginConstants::FRAMEWORK_STORAGE.toStdString());
options.addOption(storageDirOption);
Poco::Util::Option consoleLogOption(ARG_CONSOLELOG.toStdString(), "", "log messages to the console");
consoleLogOption.callback(Poco::Util::OptionCallback<Impl>(d, &Impl::handleBooleanOption));
options.addOption(consoleLogOption);
Poco::Util::Option debugOption(ARG_DEBUG.toStdString(), "", "enable debug mode");
debugOption.argument("<options file>", false).binding(ctkPluginFrameworkLauncher::PROP_DEBUG.toStdString());
options.addOption(debugOption);
Poco::Util::Option forcePluginOption(ARG_FORCE_PLUGIN_INSTALL.toStdString(), "", "force installing plug-ins with same symbolic name");
forcePluginOption.callback(Poco::Util::OptionCallback<Impl>(d, &Impl::handleBooleanOption));
options.addOption(forcePluginOption);
Poco::Util::Option preloadLibsOption(ARG_PRELOAD_LIBRARY.toStdString(), "", "preload a library");
preloadLibsOption.argument("<library>")
.repeatable(true)
.callback(Poco::Util::OptionCallback<Impl>(d, &Impl::handlePreloadLibraryOption));
options.addOption(preloadLibsOption);
Poco::Util::Option noRegistryCacheOption(ARG_NO_REGISTRY_CACHE.toStdString(), "", "do not use a cache for the registry");
noRegistryCacheOption.callback(Poco::Util::OptionCallback<Impl>(d, &Impl::handleBooleanOption));
options.addOption(noRegistryCacheOption);
Poco::Util::Option noLazyRegistryCacheLoadingOption(ARG_NO_LAZY_REGISTRY_CACHE_LOADING.toStdString(), "", "do not use lazy cache loading for the registry");
noLazyRegistryCacheLoadingOption.callback(Poco::Util::OptionCallback<Impl>(d, &Impl::handleBooleanOption));
options.addOption(noLazyRegistryCacheLoadingOption);
Poco::Util::Option registryMultiLanguageOption(ARG_REGISTRY_MULTI_LANGUAGE.toStdString(), "", "enable multi-language support for the registry");
registryMultiLanguageOption.callback(Poco::Util::OptionCallback<Impl>(d, &Impl::handleBooleanOption));
options.addOption(registryMultiLanguageOption);
Poco::Util::Option splashScreenOption(ARG_SPLASH_IMAGE.toStdString(), "", "optional picture to use as a splash screen");
splashScreenOption.argument("<filename>").binding(ARG_SPLASH_IMAGE.toStdString());
options.addOption(splashScreenOption);
Poco::Util::Option xargsOption(ARG_XARGS.toStdString(), "", "Extended argument list");
xargsOption.argument("<args>").binding(ARG_XARGS.toStdString());
options.addOption(xargsOption);
+ Poco::Util::Option logQtMessagesOption(ARG_LOG_QT_MESSAGES.toStdString(), "", "log Qt messages");
+ logQtMessagesOption.callback(Poco::Util::OptionCallback<Impl>(d, &Impl::handleBooleanOption));
+ options.addOption(logQtMessagesOption);
+
Poco::Util::Application::defineOptions(options);
}
QSharedPointer<ctkPluginFramework> BaseApplication::getFramework() const
{
return ctkPluginFrameworkLauncher::getPluginFramework();
}
ctkPluginContext *BaseApplication::getFrameworkContext() const
{
auto framework = getFramework();
return framework
? framework->getPluginContext()
: nullptr;
}
void BaseApplication::initializeSplashScreen(QCoreApplication * application) const
{
auto pixmapFileNameProp = d->getProperty(ARG_SPLASH_IMAGE);
if (!pixmapFileNameProp.isNull())
{
auto pixmapFileName = pixmapFileNameProp.toString();
QFileInfo checkFile(pixmapFileName);
if (checkFile.exists() && checkFile.isFile())
{
QPixmap pixmap(checkFile.absoluteFilePath());
d->m_Splashscreen = new QSplashScreen(pixmap, Qt::WindowStaysOnTopHint);
d->m_Splashscreen->show();
application->processEvents();
}
}
}
QHash<QString, QVariant> BaseApplication::getFrameworkProperties() const
{
return d->m_FWProps;
}
int BaseApplication::run()
{
this->init(d->m_Argc, d->m_Argv);
return Application::run();
}
void BaseApplication::setProperty(const QString &property, const QVariant &value)
{
d->m_FWProps[property] = value;
}
QVariant BaseApplication::getProperty(const QString &property) const
{
return d->getProperty(property);
}
void BaseApplication::installTranslator(QTranslator* translator)
{
this->getQApplication()->installTranslator(translator);
}
bool BaseApplication::isRunning()
{
auto app = dynamic_cast<QtSingleApplication*>(this->getQApplication());
if (nullptr != app)
app->isRunning();
mitkThrow() << "Method not implemented.";
}
void BaseApplication::sendMessage(const QByteArray msg)
{
auto app = dynamic_cast<QtSingleApplication*>(this->getQApplication());
if (nullptr != app)
app->sendMessage(msg);
mitkThrow() << "Method not implemented.";
}
}
diff --git a/Modules/BoundingShape/src/Interactions/mitkBoundingShapeInteractor.cpp b/Modules/BoundingShape/src/Interactions/mitkBoundingShapeInteractor.cpp
index 51bd761e0a..3b7b0340bf 100644
--- a/Modules/BoundingShape/src/Interactions/mitkBoundingShapeInteractor.cpp
+++ b/Modules/BoundingShape/src/Interactions/mitkBoundingShapeInteractor.cpp
@@ -1,609 +1,609 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "../DataManagement/mitkBoundingShapeUtil.h"
#include <mitkBoundingShapeInteractor.h>
#include <mitkDisplayInteractor.h>
#include <mitkInteractionConst.h>
#include <mitkInteractionEventObserver.h>
#include <mitkInteractionKeyEvent.h>
#include <mitkInteractionPositionEvent.h>
#include <mitkMouseWheelEvent.h>
#include <vtkCamera.h>
#include <vtkInteractorObserver.h>
#include <vtkInteractorStyle.h>
#include <vtkPointData.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkSmartPointer.h>
#include "usGetModuleContext.h"
#include "usModuleRegistry.h"
// Properties to allow the user to interact with the base data
const char *selectedColorPropertyName = "Bounding Shape.Selected Color";
const char *deselectedColorPropertyName = "Bounding Shape.Deselected Color";
const char *activeHandleIdPropertyName = "Bounding Shape.Active Handle ID";
const char *boundingShapePropertyName = "Bounding Shape";
namespace mitk
{
class BoundingShapeInteractor::Impl
{
public:
Impl() : ScrollEnabled(false), RotationEnabled(false)
{
Point3D initialPoint;
initialPoint.Fill(0.0);
for (int i = 0; i < 6; ++i)
Handles.push_back(Handle(initialPoint, i, GetHandleIndices(i)));
}
~Impl() {}
bool ScrollEnabled;
Point3D InitialPickedWorldPoint;
Point3D LastPickedWorldPoint;
Point2D InitialPickedDisplayPoint;
std::vector<Handle> Handles;
Handle ActiveHandle;
Geometry3D::Pointer OriginalGeometry;
bool RotationEnabled;
std::map<us::ServiceReferenceU, mitk::EventConfig> DisplayInteractorConfigs;
};
}
mitk::BoundingShapeInteractor::BoundingShapeInteractor() : m_Impl(new Impl)
{
}
mitk::BoundingShapeInteractor::~BoundingShapeInteractor()
{
this->RestoreNodeProperties();
delete m_Impl;
}
void mitk::BoundingShapeInteractor::ConnectActionsAndFunctions()
{
// **Conditions** that can be used in the state machine, to ensure that certain conditions are met, before actually
// executing an action
CONNECT_CONDITION("isHoveringOverObject", CheckOverObject);
CONNECT_CONDITION("isHoveringOverHandles", CheckOverHandles);
// **Function** in the statemachine patterns also referred to as **Actions**
CONNECT_FUNCTION("selectObject", SelectObject);
CONNECT_FUNCTION("deselectObject", DeselectObject);
CONNECT_FUNCTION("deselectHandles", DeselectHandles);
CONNECT_FUNCTION("initInteraction", InitInteraction);
CONNECT_FUNCTION("translateObject", TranslateObject);
CONNECT_FUNCTION("selectHandle", SelectHandle);
CONNECT_FUNCTION("scaleObject", ScaleObject);
// CONNECT_FUNCTION("rotateObject",RotateObject);
}
// RotateObject(StateMachineAction*, InteractionEvent* interactionEvent)
// void mitk::BoundingShapeInteractor::RotateGeometry(mitk::ScalarType angle, int rotationaxis, mitk::BaseGeometry*
// geometry)
//{
// mitk::Vector3D rotationAxis = geometry->GetAxisVector(rotationaxis);
// float pointX = 0.0f;
// float pointY = 0.0f;
// float pointZ = 0.0f;
// mitk::Point3D pointOfRotation;
// pointOfRotation.Fill(0.0);
// this->GetDataNode()->GetFloatProperty(anchorPointX, pointX);
// this->GetDataNode()->GetFloatProperty(anchorPointY, pointY);
// this->GetDataNode()->GetFloatProperty(anchorPointZ, pointZ);
// pointOfRotation[0] = pointX;
// pointOfRotation[1] = pointY;
// pointOfRotation[2] = pointZ;
//
// mitk::RotationOperation* doOp = new mitk::RotationOperation(OpROTATE, pointOfRotation, rotationAxis, angle);
//
// geometry->ExecuteOperation(doOp);
// delete doOp;
//}
void mitk::BoundingShapeInteractor::SetRotationEnabled(bool rotationEnabled)
{
m_Impl->RotationEnabled = rotationEnabled;
}
void mitk::BoundingShapeInteractor::DataNodeChanged()
{
mitk::DataNode::Pointer newInputNode = this->GetDataNode();
if (newInputNode == nullptr)
return;
// add color properties
mitk::ColorProperty::Pointer selectedColor =
dynamic_cast<mitk::ColorProperty *>(newInputNode->GetProperty(selectedColorPropertyName));
mitk::ColorProperty::Pointer deselectedColor =
dynamic_cast<mitk::ColorProperty *>(newInputNode->GetProperty(deselectedColorPropertyName));
if (selectedColor.IsNull())
newInputNode->AddProperty(selectedColorPropertyName, mitk::ColorProperty::New(0.0, 1.0, 0.0));
if (deselectedColor.IsNull())
newInputNode->AddProperty(deselectedColorPropertyName, mitk::ColorProperty::New(1.0, 1.0, 1.0));
newInputNode->SetProperty(boundingShapePropertyName, mitk::BoolProperty::New(true));
newInputNode->AddProperty(activeHandleIdPropertyName, mitk::IntProperty::New(-1));
newInputNode->SetProperty("layer", mitk::IntProperty::New(101));
newInputNode->SetBoolProperty("fixedLayer", mitk::BoolProperty::New(true));
newInputNode->SetBoolProperty("pickable", true);
mitk::ColorProperty::Pointer initialColor =
dynamic_cast<mitk::ColorProperty *>(newInputNode->GetProperty(deselectedColorPropertyName));
if (initialColor.IsNotNull())
{
newInputNode->SetColor(initialColor->GetColor());
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void mitk::BoundingShapeInteractor::HandlePositionChanged(const InteractionEvent *interactionEvent, Point3D ¢er)
{
GeometryData::Pointer geometryData = dynamic_cast<GeometryData *>(this->GetDataNode()->GetData());
int timeStep = interactionEvent->GetSender()->GetTimeStep(this->GetDataNode()->GetData());
mitk::BaseGeometry::Pointer geometry = geometryData->GetGeometry(timeStep);
std::vector<Point3D> cornerPoints = GetCornerPoints(geometry, true);
if (m_Impl->Handles.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->Handles[0].SetPosition(pointLeft);
m_Impl->Handles[1].SetPosition(pointRight);
m_Impl->Handles[2].SetPosition(pointTop);
m_Impl->Handles[3].SetPosition(pointBottom);
m_Impl->Handles[4].SetPosition(pointFront);
m_Impl->Handles[5].SetPosition(pointBack);
// calculate center based on half way of the distance between two opposing cornerpoints
center = CalcAvgPoint(cornerPoints[7], cornerPoints[0]);
}
}
void mitk::BoundingShapeInteractor::SetDataNode(DataNode *node)
{
this->RestoreNodeProperties(); // if there is another node set, restore it's color
if (node == nullptr)
return;
DataInteractor::SetDataNode(node); // calls DataNodeChanged internally
this->DataNodeChanged();
}
bool mitk::BoundingShapeInteractor::CheckOverObject(const InteractionEvent *interactionEvent)
{
const auto *positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
if (positionEvent == nullptr)
return false;
GeometryData::Pointer geometryData = dynamic_cast<GeometryData *>(this->GetDataNode()->GetData());
int timeStep = interactionEvent->GetSender()->GetTimeStep(this->GetDataNode()->GetData());
BaseGeometry::Pointer geometry = geometryData->GetGeometry(timeStep);
// calculates translation based on offset+extent not on the transformation matrix (because the cube is located in the
// center not in the origin)
vtkSmartPointer<vtkMatrix4x4> imageTransform = geometry->GetVtkTransform()->GetMatrix();
Point3D center = geometry->GetCenter();
auto translation = vtkSmartPointer<vtkTransform>::New();
auto transform = vtkSmartPointer<vtkTransform>::New();
translation->Translate(center[0] - imageTransform->GetElement(0, 3),
center[1] - imageTransform->GetElement(1, 3),
center[2] - imageTransform->GetElement(2, 3));
transform->SetMatrix(imageTransform);
transform->PostMultiply();
transform->Concatenate(translation);
transform->Update();
mitk::Vector3D extent;
for (unsigned int i = 0; i < 3; ++i)
extent[i] = (geometry->GetExtent(i));
Point3D currentWorldPosition;
Point2D currentDisplayPosition = positionEvent->GetPointerPositionOnScreen();
interactionEvent->GetSender()->DisplayToWorld(currentDisplayPosition, currentWorldPosition);
ScalarType transformedPosition[4];
transformedPosition[0] = currentWorldPosition[0];
transformedPosition[1] = currentWorldPosition[1];
transformedPosition[2] = currentWorldPosition[2];
transformedPosition[3] = 1;
// transform point from world to object coordinates
transform->GetInverse()->TransformPoint(transformedPosition, transformedPosition);
// check if the world point is within bounds
bool isInside = (transformedPosition[0] >= (-extent[0] / 2.0)) && (transformedPosition[0] <= (extent[0] / 2.0)) &&
(transformedPosition[1] >= (-extent[1] / 2.0)) && (transformedPosition[1] <= (extent[1] / 2.0)) &&
(transformedPosition[2] >= (-extent[2] / 2.0)) && (transformedPosition[2] <= (extent[2] / 2.0));
return isInside;
}
bool mitk::BoundingShapeInteractor::CheckOverHandles(const InteractionEvent *interactionEvent)
{
Point3D boundingBoxCenter;
HandlePositionChanged(interactionEvent, boundingBoxCenter);
const auto *positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
if (positionEvent == nullptr)
return false;
Point2D displayCenterPoint;
// to do: change to actual time step (currently not necessary because geometry remains the same for each timestep
int timeStep = 0;
GeometryData::Pointer geometryData = dynamic_cast<GeometryData *>(this->GetDataNode()->GetData());
BaseGeometry::Pointer geometry = geometryData->GetUpdatedTimeGeometry()->GetGeometryForTimeStep(timeStep);
std::vector<Point3D> cornerPoints = GetCornerPoints(geometry, true);
interactionEvent->GetSender()->WorldToDisplay(boundingBoxCenter, displayCenterPoint);
double scale = interactionEvent->GetSender()->GetScaleFactorMMPerDisplayUnit(); // GetDisplaySizeInMM
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 = interactionEvent->GetSender()->GetDisplaySizeInMM();
ScalarType handlesize = ((displaysize[0] + displaysize[1]) / 2.0) * initialHandleSize;
unsigned int handleNum = 0;
for (auto &handle : m_Impl->Handles)
{
Point2D centerpoint;
interactionEvent->GetSender()->WorldToDisplay(handle.GetPosition(), centerpoint);
Point2D currentDisplayPosition = positionEvent->GetPointerPositionOnScreen();
if ((currentDisplayPosition.EuclideanDistanceTo(centerpoint) < (handlesize / scale)) &&
(currentDisplayPosition.EuclideanDistanceTo(displayCenterPoint) >
(handlesize / scale))) // check if mouse is hovering over center point
{
handle.SetActive(true);
m_Impl->ActiveHandle = handle;
this->GetDataNode()->GetPropertyList()->SetProperty(activeHandleIdPropertyName,
mitk::IntProperty::New(handleNum++));
this->GetDataNode()->GetData()->Modified();
RenderingManager::GetInstance()->RequestUpdateAll();
return true;
}
else
{
handleNum++;
handle.SetActive(false);
}
this->GetDataNode()->GetPropertyList()->SetProperty(activeHandleIdPropertyName, mitk::IntProperty::New(-1));
}
return false;
}
void mitk::BoundingShapeInteractor::SelectHandle(StateMachineAction *, InteractionEvent *)
{
this->DisableCrosshairNavigation();
DataNode::Pointer node = this->GetDataNode();
if (node.IsNull())
return;
mitk::ColorProperty::Pointer selectedColor =
dynamic_cast<mitk::ColorProperty *>(node->GetProperty(deselectedColorPropertyName));
if (selectedColor.IsNotNull())
{
this->GetDataNode()->GetPropertyList()->SetProperty("color", selectedColor);
}
this->GetDataNode()->GetData()->UpdateOutputInformation(); // Geometry is up-to-date
this->GetDataNode()->GetData()->Modified();
RenderingManager::GetInstance()->RequestUpdateAll();
return;
}
void mitk::BoundingShapeInteractor::DeselectHandles(StateMachineAction *, InteractionEvent *)
{
this->DisableCrosshairNavigation();
DataNode::Pointer node = this->GetDataNode();
if (node.IsNull())
return;
this->GetDataNode()->GetPropertyList()->SetProperty(activeHandleIdPropertyName, mitk::IntProperty::New(-1));
this->GetDataNode()->GetData()->UpdateOutputInformation(); // Geometry is up-to-date
this->GetDataNode()->GetData()->Modified();
RenderingManager::GetInstance()->RequestUpdateAll();
return;
}
void mitk::BoundingShapeInteractor::SelectObject(StateMachineAction *, InteractionEvent *)
{
this->DisableCrosshairNavigation(); // disable crosshair interaction and scolling if user is hovering over the object
DataNode::Pointer node = this->GetDataNode();
if (node.IsNull())
return;
mitk::ColorProperty::Pointer selectedColor =
dynamic_cast<mitk::ColorProperty *>(node->GetProperty(selectedColorPropertyName));
if (selectedColor.IsNotNull())
{
node->GetPropertyList()->SetProperty("color", selectedColor);
}
this->GetDataNode()->GetData()->UpdateOutputInformation(); // Geometry is up-to-date
this->GetDataNode()->GetData()->Modified();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
return;
}
void mitk::BoundingShapeInteractor::DeselectObject(StateMachineAction *, InteractionEvent *)
{
this->EnableCrosshairNavigation(); // enable crosshair interaction and scolling if user is hovering over the object
DataNode::Pointer node = this->GetDataNode();
if (node.IsNull())
return;
mitk::ColorProperty::Pointer deselectedColor =
dynamic_cast<mitk::ColorProperty *>(node->GetProperty(deselectedColorPropertyName));
if (deselectedColor.IsNotNull())
{
node->GetPropertyList()->SetProperty("color", deselectedColor);
}
this->GetDataNode()->GetData()->UpdateOutputInformation(); // Geometry is up-to-date
this->GetDataNode()->GetData()->Modified();
RenderingManager::GetInstance()->RequestUpdateAll();
return;
}
void mitk::BoundingShapeInteractor::InitInteraction(StateMachineAction *, InteractionEvent *interactionEvent)
{
InitMembers(interactionEvent);
}
bool mitk::BoundingShapeInteractor::InitMembers(InteractionEvent *interactionEvent)
{
auto *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent == nullptr)
return false;
// get initial position coordinates
m_Impl->InitialPickedDisplayPoint = positionEvent->GetPointerPositionOnScreen();
m_Impl->InitialPickedWorldPoint = positionEvent->GetPositionInWorld();
m_Impl->LastPickedWorldPoint = positionEvent->GetPositionInWorld();
return true;
}
void mitk::BoundingShapeInteractor::TranslateObject(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent == nullptr)
return;
int timeStep = interactionEvent->GetSender()->GetTimeStep(this->GetDataNode()->GetData());
mitk::BaseGeometry::Pointer geometry =
this->GetDataNode()->GetData()->GetUpdatedTimeGeometry()->GetGeometryForTimeStep(timeStep);
Vector3D spacing = geometry->GetSpacing();
Point3D currentPickedPoint;
interactionEvent->GetSender()->DisplayToWorld(positionEvent->GetPointerPositionOnScreen(), currentPickedPoint);
Vector3D interactionMove;
// pixel aligned shifting of the bounding box
interactionMove[0] = std::round((currentPickedPoint[0] - m_Impl->LastPickedWorldPoint[0]) / spacing[0]) * spacing[0];
interactionMove[1] = std::round((currentPickedPoint[1] - m_Impl->LastPickedWorldPoint[1]) / spacing[1]) * spacing[1];
interactionMove[2] = std::round((currentPickedPoint[2] - m_Impl->LastPickedWorldPoint[2]) / spacing[2]) * spacing[2];
if ((interactionMove[0] + interactionMove[1] + interactionMove[2]) !=
0.0) // only update current position if a movement occured
{
m_Impl->LastPickedWorldPoint = currentPickedPoint;
geometry->SetOrigin(geometry->GetOrigin() + interactionMove);
this->GetDataNode()->GetData()->UpdateOutputInformation(); // Geometry is up-to-date
this->GetDataNode()->GetData()->Modified();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
return;
}
void mitk::BoundingShapeInteractor::ScaleObject(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent == nullptr)
return;
GeometryData::Pointer geometryData = dynamic_cast<GeometryData *>(this->GetDataNode()->GetData());
Point3D handlePickedPoint = m_Impl->ActiveHandle.GetPosition();
Point3D currentPickedPoint;
interactionEvent->GetSender()->DisplayToWorld(positionEvent->GetPointerPositionOnScreen(), currentPickedPoint);
int timeStep = interactionEvent->GetSender()->GetTimeStep(this->GetDataNode()->GetData());
mitk::BaseGeometry::Pointer geometry = geometryData->GetGeometry(timeStep);
Vector3D spacing = geometry->GetSpacing();
// pixel aligned bounding box
Vector3D interactionMove;
interactionMove[0] = (currentPickedPoint[0] - m_Impl->LastPickedWorldPoint[0]);
interactionMove[1] = (currentPickedPoint[1] - m_Impl->LastPickedWorldPoint[1]);
interactionMove[2] = (currentPickedPoint[2] - m_Impl->LastPickedWorldPoint[2]);
std::vector<int> faces = m_Impl->ActiveHandle.GetFaceIndices();
auto pointscontainer = mitk::BoundingBox::PointsContainer::New();
// calculate cornerpoints from geometry plus visualization offset
std::vector<Point3D> cornerPoints = GetCornerPoints(geometry, true);
unsigned int num = 0;
- for (auto point : cornerPoints)
+ for (const auto &point : cornerPoints)
{
pointscontainer->InsertElement(num++, point);
}
// calculate center based on half way of the distance between two opposing cornerpoints
mitk::Point3D center = CalcAvgPoint(cornerPoints[7], cornerPoints[0]);
Vector3D faceNormal;
faceNormal[0] = handlePickedPoint[0] - center[0];
faceNormal[1] = handlePickedPoint[1] - center[1];
faceNormal[2] = handlePickedPoint[2] - center[2];
Vector3D faceShift = ((faceNormal * interactionMove) / (faceNormal.GetNorm() * faceNormal.GetNorm())) * faceNormal;
// calculate cornerpoints from geometry without visualization offset to update actual geometry
cornerPoints = GetCornerPoints(geometry, false);
num = 0;
- for (auto point : cornerPoints)
+ for (const auto &point : cornerPoints)
{
pointscontainer->InsertElement(num++, point);
}
bool positionChangeThreshold = true;
for (int numFaces = 0; numFaces < 8; numFaces++) // estimate the corresponding face and shift its assigned points
{
if ((numFaces != faces[0]) && (numFaces != faces[1]) && (numFaces != faces[2]) && (numFaces != faces[3]))
{
Point3D point = pointscontainer->GetElement(numFaces);
if (m_Impl->RotationEnabled) // apply if geometry is rotated at a pixel aligned shift is not possible
{
point[0] += faceShift[0];
point[1] += faceShift[1];
point[2] += faceShift[2];
}
else // shift pixelwise
{
point[0] += std::round(faceShift[0] / spacing[0]) * spacing[0];
point[1] += std::round(faceShift[1] / spacing[1]) * spacing[1];
point[2] += std::round(faceShift[2] / spacing[2]) * spacing[2];
}
if (point == pointscontainer->GetElement(numFaces))
positionChangeThreshold = false;
else
m_Impl->LastPickedWorldPoint = point;
pointscontainer->InsertElement(numFaces, point);
}
}
if (positionChangeThreshold) // update only if bounding box is shifted at least by one pixel
{
auto inverse = mitk::AffineTransform3D::New();
geometry->GetIndexToWorldTransform()->GetInverse(inverse);
for (unsigned int pointid = 0; pointid < 8; pointid++)
{
pointscontainer->InsertElement(pointid, inverse->TransformPoint(pointscontainer->GetElement(pointid)));
}
auto bbox = mitk::BoundingBox::New();
bbox->SetPoints(pointscontainer);
bbox->ComputeBoundingBox();
mitk::Point3D BBmin = bbox->GetMinimum();
mitk::Point3D BBmax = bbox->GetMaximum();
if (std::abs(BBmin[0] - BBmax[0]) > 0.01 && std::abs(BBmin[1] - BBmax[1]) > 0.01 &&
std::abs(BBmin[2] - BBmax[2]) > 0.01) // TODO: check if the extent is greater than zero
{
geometry->SetBounds(bbox->GetBounds());
geometry->Modified();
this->GetDataNode()->GetData()->UpdateOutputInformation(); // Geometry is up-to-date
this->GetDataNode()->GetData()->Modified();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
return;
}
void mitk::BoundingShapeInteractor::RestoreNodeProperties()
{
mitk::DataNode::Pointer inputNode = this->GetDataNode();
if (inputNode.IsNull())
return;
mitk::ColorProperty::Pointer color = (mitk::ColorProperty::New(1.0, 1.0, 1.0));
if (color.IsNotNull())
{
inputNode->GetPropertyList()->SetProperty("color", color);
}
inputNode->SetProperty("layer", mitk::IntProperty::New(99));
inputNode->SetProperty(boundingShapePropertyName, mitk::BoolProperty::New(false));
inputNode->GetPropertyList()->DeleteProperty(activeHandleIdPropertyName);
EnableCrosshairNavigation();
// update rendering
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void mitk::BoundingShapeInteractor::EnableCrosshairNavigation()
{
// enable the crosshair navigation
// Re-enabling InteractionEventObservers that have been previously disabled for legacy handling of Tools
// in new interaction framework
for (auto it = m_Impl->DisplayInteractorConfigs.begin();
it != m_Impl->DisplayInteractorConfigs.end();
++it)
{
if (it->first)
{
mitk::DisplayInteractor *displayInteractor = static_cast<mitk::DisplayInteractor *>(
us::GetModuleContext()->GetService<mitk::InteractionEventObserver>(it->first));
if (displayInteractor != nullptr)
{
// here the regular configuration is loaded again
displayInteractor->SetEventConfig(it->second);
// MITK_INFO << "restore config";
}
}
}
m_Impl->DisplayInteractorConfigs.clear();
m_Impl->ScrollEnabled = true;
}
void mitk::BoundingShapeInteractor::DisableCrosshairNavigation()
{
// dont deactivate twice, else we will clutter the config list ...
if (m_Impl->ScrollEnabled == false)
return;
// As a legacy solution the display interaction of the new interaction framework is disabled here to avoid conflicts
// with tools
// Note: this only affects InteractionEventObservers (formerly known as Listeners) all DataNode specific interaction
// will still be enabled
m_Impl->DisplayInteractorConfigs.clear();
std::vector<us::ServiceReference<mitk::InteractionEventObserver>> listEventObserver =
us::GetModuleContext()->GetServiceReferences<mitk::InteractionEventObserver>();
for (auto it = listEventObserver.begin();
it != listEventObserver.end();
++it)
{
auto *displayInteractor =
dynamic_cast<mitk::DisplayInteractor *>(us::GetModuleContext()->GetService<mitk::InteractionEventObserver>(*it));
if (displayInteractor != nullptr)
{
// remember the original configuration
m_Impl->DisplayInteractorConfigs.insert(std::make_pair(*it, displayInteractor->GetEventConfig()));
// here the alternative configuration is loaded
displayInteractor->SetEventConfig("DisplayConfigMITKNoCrosshair.xml");
// MITK_INFO << "change config";
}
}
m_Impl->ScrollEnabled = false;
}
diff --git a/Modules/CEST/src/mitkCustomTagParser.cpp b/Modules/CEST/src/mitkCustomTagParser.cpp
index d9d082671b..fbfee566c0 100644
--- a/Modules/CEST/src/mitkCustomTagParser.cpp
+++ b/Modules/CEST/src/mitkCustomTagParser.cpp
@@ -1,846 +1,846 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkCustomTagParser.h"
#include <mitkProperties.h>
#include <mitkStringProperty.h>
#include "mitkCESTPropertyHelper.h"
#include "mitkIPropertyPersistence.h"
#include "usGetModuleContext.h"
#include "usModule.h"
#include "usModuleContext.h"
#include "usModuleResource.h"
#include "usModuleResourceStream.h"
#include <itksys/SystemTools.hxx>
#include <Poco/Glob.h>
#include <boost/algorithm/string.hpp>
#include <boost/property_tree/json_parser.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/tokenizer.hpp>
#include <algorithm>
#include <cstdint>
#include <map>
#include <string>
#include <vector>
namespace
{
mitk::IPropertyPersistence *GetPersistenceService()
{
mitk::IPropertyPersistence *result = nullptr;
std::vector<us::ServiceReference<mitk::IPropertyPersistence>> persRegisters =
us::GetModuleContext()->GetServiceReferences<mitk::IPropertyPersistence>();
if (!persRegisters.empty())
{
if (persRegisters.size() > 1)
{
MITK_WARN << "Multiple property description services found. Using just one.";
}
result = us::GetModuleContext()->GetService<mitk::IPropertyPersistence>(persRegisters.front());
}
return result;
};
}
const std::string mitk::CustomTagParser::m_CESTPropertyPrefix = "CEST.";
const std::string mitk::CustomTagParser::m_RevisionPropertyName = m_CESTPropertyPrefix + "Revision";
const std::string mitk::CustomTagParser::m_JSONRevisionPropertyName = m_CESTPropertyPrefix + "revision_json";
const std::string mitk::CustomTagParser::m_RevisionIndependentMapping =
"\n"
" \"sProtConsistencyInfo.tSystemType\" : \"SysType\",\n"
" \"sProtConsistencyInfo.flNominalB0\" : \"NominalB0\",\n"
" \"sTXSPEC.asNucleusInfo[0].lFrequency\" : \"FREQ\",\n"
" \"sTXSPEC.asNucleusInfo[0].flReferenceAmplitude\" : \"RefAmp\",\n"
" \"alTR[0]\" : \"TR\",\n"
" \"alTE[0]\" : \"TE\",\n"
" \"lAverages\" : \"averages\",\n"
" \"lRepetitions\" : \"repetitions\",\n"
" \"adFlipAngleDegree[0]\" : \"ImageFlipAngle\",\n"
" \"lTotalScanTimeSec\" : \"TotalScanTime\",";
const std::string mitk::CustomTagParser::m_DefaultJsonString =
"{\n"
" \"default mapping, corresponds to revision 1416\" : \"revision_json\",\n"
" \"sWiPMemBlock.alFree[1]\" : \"AdvancedMode\",\n"
" \"sWiPMemBlock.alFree[2]\" : \"RecoveryMode\",\n"
" \"sWiPMemBlock.alFree[3]\" : \"DoubleIrrMode\",\n"
" \"sWiPMemBlock.alFree[4]\" : \"BinomMode\",\n"
" \"sWiPMemBlock.alFree[5]\" : \"MtMode\",\n"
" \"sWiPMemBlock.alFree[6]\" : \"PreparationType\",\n"
" \"sWiPMemBlock.alFree[7]\" : \"PulseType\",\n"
" \"sWiPMemBlock.alFree[8]\" : \"SamplingType\",\n"
" \"sWiPMemBlock.alFree[9]\" : \"SpoilingType\",\n"
" \"sWiPMemBlock.alFree[10]\" : \"measurements\",\n"
" \"sWiPMemBlock.alFree[11]\" : \"NumberOfPulses\",\n"
" \"sWiPMemBlock.alFree[12]\" : \"NumberOfLockingPulses\",\n"
" \"sWiPMemBlock.alFree[13]\" : \"PulseDuration\",\n"
" \"sWiPMemBlock.alFree[14]\" : \"DutyCycle\",\n"
" \"sWiPMemBlock.alFree[15]\" : \"RecoveryTime\",\n"
" \"sWiPMemBlock.alFree[16]\" : \"RecoveryTimeM0\",\n"
" \"sWiPMemBlock.alFree[17]\" : \"ReadoutDelay\",\n"
" \"sWiPMemBlock.alFree[18]\" : \"BinomDuration\",\n"
" \"sWiPMemBlock.alFree[19]\" : \"BinomDistance\",\n"
" \"sWiPMemBlock.alFree[20]\" : \"BinomNumberofPulses\",\n"
" \"sWiPMemBlock.alFree[21]\" : \"BinomPreRepetions\",\n"
" \"sWiPMemBlock.alFree[22]\" : \"BinomType\",\n"
" \"sWiPMemBlock.adFree[1]\" : \"Offset\",\n"
" \"sWiPMemBlock.adFree[2]\" : \"B1Amplitude\",\n"
" \"sWiPMemBlock.adFree[3]\" : \"AdiabaticPulseMu\",\n"
" \"sWiPMemBlock.adFree[4]\" : \"AdiabaticPulseBW\",\n"
" \"sWiPMemBlock.adFree[5]\" : \"AdiabaticPulseLength\",\n"
" \"sWiPMemBlock.adFree[6]\" : \"AdiabaticPulseAmp\",\n"
" \"sWiPMemBlock.adFree[7]\" : \"FermiSlope\",\n"
" \"sWiPMemBlock.adFree[8]\" : \"FermiFWHM\",\n"
" \"sWiPMemBlock.adFree[9]\" : \"DoubleIrrDuration\",\n"
" \"sWiPMemBlock.adFree[10]\" : \"DoubleIrrAmplitude\",\n"
" \"sWiPMemBlock.adFree[11]\" : \"DoubleIrrRepetitions\",\n"
" \"sWiPMemBlock.adFree[12]\" : \"DoubleIrrPreRepetitions\"\n"
"}";
mitk::CustomTagParser::CustomTagParser(std::string relevantFile) : m_ClosestInternalRevision(""), m_ClosestExternalRevision("")
{
std::string pathToDirectory;
std::string fileName;
itksys::SystemTools::SplitProgramPath(relevantFile, pathToDirectory, fileName);
m_DicomDataPath = pathToDirectory;
m_ParseStrategy = "Automatic";
m_RevisionMappingStrategy = "Fuzzy";
}
std::string mitk::CustomTagParser::ExtractRevision(std::string sequenceFileName)
{
//all rules are case insesitive. Thus we convert everything to lower case
//in order to check everything only once.
std::string cestPrefix = "cest";
std::string cestPrefix2 = "_cest";
std::string cestPrefix3 = "\\cest"; //this version covers the fact that the strings extracted
//from the SIEMENS tag has an additional prefix that is seperated by backslash.
std::string revisionPrefix = "_rev";
std::transform(sequenceFileName.begin(), sequenceFileName.end(), sequenceFileName.begin(), ::tolower);
bool isCEST = sequenceFileName.compare(0, cestPrefix.length(), cestPrefix) == 0;
std::size_t foundPosition = 0;
if (!isCEST)
{
foundPosition = sequenceFileName.find(cestPrefix2);
isCEST = foundPosition != std::string::npos;
}
if (!isCEST)
{
foundPosition = sequenceFileName.find(cestPrefix3);
isCEST = foundPosition != std::string::npos;
}
if (!isCEST)
{
mitkThrow() << "Invalid CEST sequence file name. No CEST prefix found. Could not extract revision.";
}
foundPosition = sequenceFileName.find(revisionPrefix, foundPosition);
if (foundPosition == std::string::npos)
{
mitkThrow() << "Invalid CEST sequence file name. No revision prefix was found in CEST sequence file name. Could not extract revision.";
}
std::string revisionString = sequenceFileName.substr(foundPosition + revisionPrefix.length(), std::string::npos);
std::size_t firstNoneNumber = revisionString.find_first_not_of("0123456789");
if (firstNoneNumber != std::string::npos)
{
revisionString.erase(firstNoneNumber, std::string::npos);
}
return revisionString;
}
bool mitk::CustomTagParser::IsT1Sequence(std::string preparationType,
std::string recoveryMode,
std::string spoilingType,
std::string revisionString)
{
bool isT1 = false;
// if a forced parse strategy is set, use that one
if ("T1" == m_ParseStrategy)
{
return true;
}
if ("CEST/WASABI" == m_ParseStrategy)
{
return false;
}
if (("T1Recovery" == preparationType) || ("T1Inversion" == preparationType))
{
isT1 = true;
}
// How to interpret the recoveryMode depends on the age of the sequence
// older sequences use 0 = false and 1 = true, newer ones 1 = false and 2 = true.
// A rough rule of thumb is to assume that if the SpoilingType is 0, then the first
// convention is chosen, if it is 1, then the second applies. Otherwise
// we assume revision 1485 and newer to follow the new convention.
// This unfortunate heuristic is due to somewhat arbitrary CEST sequence implementations.
if (!isT1)
{
std::string thisIsTrue = "1";
std::string thisIsFalse = "0";
if ("0" == spoilingType)
{
thisIsFalse = "0";
thisIsTrue = "1";
}
else if ("1" == spoilingType)
{
thisIsFalse = "1";
thisIsTrue = "2";
}
else
{
int revisionNrWeAssumeToBeDifferenciating = 1485;
if (std::stoi(revisionString) - revisionNrWeAssumeToBeDifferenciating < 0)
{
thisIsFalse = "0";
thisIsTrue = "1";
}
else
{
thisIsFalse = "1";
thisIsTrue = "2";
}
}
if (thisIsFalse == recoveryMode)
{
isT1 = false;
}
else if (thisIsTrue == recoveryMode)
{
isT1 = true;
}
}
return isT1;
}
mitk::PropertyList::Pointer mitk::CustomTagParser::ParseDicomPropertyString(std::string dicomPropertyString)
{
auto results = mitk::PropertyList::New();
if ("" == dicomPropertyString)
{
//MITK_ERROR << "Could not parse empty custom dicom string";
return results;
}
std::map<std::string, std::string> privateParameters;
// The Siemens private tag contains information like "43\52\23\34".
// We jump over each "\" and convert the number;
std::string bytes;
{
const std::size_t SUBSTR_LENGTH = 2;
const std::size_t INPUT_LENGTH = dicomPropertyString.length();
if (INPUT_LENGTH < SUBSTR_LENGTH)
return results;
const std::size_t MAX_INPUT_OFFSET = INPUT_LENGTH - SUBSTR_LENGTH;
bytes.reserve(INPUT_LENGTH / 3 + 1);
try
{
for (std::size_t i = 0; i <= MAX_INPUT_OFFSET; i += 3)
{
std::string byte_string = dicomPropertyString.substr(i, SUBSTR_LENGTH);
int byte = static_cast<std::string::value_type>(std::stoi(byte_string.c_str(), nullptr, 16));
bytes.push_back(byte);
}
}
catch (const std::invalid_argument&) // std::stoi() could not perform conversion
{
return results;
}
}
// extract parameter list
std::string parameterListString;
{
const std::string ASCCONV_BEGIN = "### ASCCONV BEGIN ###";
const std::string ASCCONV_END = "### ASCCONV END ###";
auto offset = bytes.find(ASCCONV_BEGIN);
if (std::string::npos == offset)
return results;
offset += ASCCONV_BEGIN.length();
auto count = bytes.find(ASCCONV_END, offset);
if (std::string::npos == count)
return results;
count -= offset;
parameterListString = bytes.substr(offset, count);
}
boost::replace_all(parameterListString, "\r\n", "\n");
boost::char_separator<char> newlineSeparator("\n");
boost::tokenizer<boost::char_separator<char>> parameters(parameterListString, newlineSeparator);
for (const auto ¶meter : parameters)
{
std::vector<std::string> parts;
boost::split(parts, parameter, boost::is_any_of("="));
if (parts.size() == 2)
{
parts[0].erase(std::remove(parts[0].begin(), parts[0].end(), ' '), parts[0].end());
parts[1].erase(parts[1].begin(), parts[1].begin() + 1); // first character is a space
privateParameters[parts[0]] = parts[1];
}
}
std::string revisionString = "";
try
{
revisionString = ExtractRevision(privateParameters["tSequenceFileName"]);
}
catch (const std::exception &e)
{
MITK_ERROR << "Cannot deduce revision information. Reason: "<< e.what();
return results;
}
results->SetProperty(m_RevisionPropertyName, mitk::StringProperty::New(revisionString));
std::string jsonString = GetRevisionAppropriateJSONString(revisionString);
boost::property_tree::ptree root;
std::istringstream jsonStream(jsonString);
try
{
boost::property_tree::read_json(jsonStream, root);
}
catch (const boost::property_tree::json_parser_error &e)
{
mitkThrow() << "Could not parse json file. Error was:\n" << e.what();
}
- for (auto it : root)
+ for (const auto &it : root)
{
if (it.second.empty())
{
std::string propertyName = m_CESTPropertyPrefix + it.second.data();
if (m_JSONRevisionPropertyName == propertyName)
{
results->SetProperty(propertyName, mitk::StringProperty::New(it.first));
}
else
{
results->SetProperty(propertyName, mitk::StringProperty::New(privateParameters[it.first]));
}
}
else
{
MITK_ERROR << "Currently no support for nested dicom tag descriptors in json file.";
}
}
std::string offset = "";
std::string measurements = "";
results->GetStringProperty("CEST.Offset", offset);
results->GetStringProperty("CEST.measurements", measurements);
if (measurements.empty())
{
std::string stringRepetitions = "";
results->GetStringProperty("CEST.repetitions", stringRepetitions);
std::string stringAverages = "";
results->GetStringProperty("CEST.averages", stringAverages);
const auto ERROR_STRING = "Could not find measurements, fallback assumption of repetitions + averages could not be determined either.";
if (!stringRepetitions.empty() && !stringAverages.empty())
{
std::stringstream measurementStream;
try
{
measurementStream << std::stoi(stringRepetitions) + std::stoi(stringAverages);
measurements = measurementStream.str();
MITK_INFO << "Could not find measurements, assuming repetitions + averages. That is: " << measurements;
}
catch (const std::invalid_argument&)
{
MITK_ERROR << ERROR_STRING;
}
}
else
{
MITK_WARN << ERROR_STRING;
}
}
std::string preparationType = "";
std::string recoveryMode = "";
std::string spoilingType = "";
results->GetStringProperty(CEST_PROPERTY_NAME_PREPERATIONTYPE().c_str(), preparationType);
results->GetStringProperty(CEST_PROPERTY_NAME_RECOVERYMODE().c_str(), recoveryMode);
results->GetStringProperty(CEST_PROPERTY_NAME_SPOILINGTYPE().c_str(), spoilingType);
if (this->IsT1Sequence(preparationType, recoveryMode, spoilingType, revisionString))
{
MITK_INFO << "Parsed as T1 image";
std::stringstream trecStream;
std::string trecPath = m_DicomDataPath + "/TREC.txt";
auto trec = ReadListFromFile(trecPath);
if(trec.empty())
{
MITK_WARN << "Assumed T1, but could not load TREC at " << trecPath;
}
results->SetStringProperty(CEST_PROPERTY_NAME_TREC().c_str(), trec.c_str());
}
else
{
MITK_INFO << "Parsed as CEST or WASABI image";
std::string sampling = "";
bool hasSamplingInformation = results->GetStringProperty("CEST.SamplingType", sampling);
if (hasSamplingInformation)
{
std::string offsets = GetOffsetString(sampling, offset, measurements);
results->SetStringProperty(CEST_PROPERTY_NAME_OFFSETS().c_str(), offsets.c_str());
}
else
{
MITK_WARN << "Could not determine sampling type.";
}
}
//persist all properties
mitk::IPropertyPersistence *persSrv = GetPersistenceService();
if (persSrv)
{
auto propertyMap = results->GetMap();
for (auto const &prop : *propertyMap)
{
PropertyPersistenceInfo::Pointer info = PropertyPersistenceInfo::New();
std::string key = prop.first;
std::replace(key.begin(), key.end(), '.', '_');
info->SetNameAndKey(prop.first, key);
persSrv->AddInfo(info);
}
}
return results;
}
std::string mitk::CustomTagParser::ReadListFromFile(const std::string& filePath)
{
std::stringstream listStream;
std::ifstream list(filePath.c_str());
list.imbue(std::locale("C"));
if (list.good())
{
std::string currentValue;
while (std::getline(list, currentValue))
{
listStream << currentValue << " ";
}
}
return listStream.str();
}
mitk::PropertyList::Pointer mitk::CustomTagParser::ParseDicomProperty(mitk::TemporoSpatialStringProperty *dicomProperty)
{
if (!dicomProperty)
{
MITK_ERROR << "DICOM property empty";
}
auto results = mitk::PropertyList::New();
if (dicomProperty)
{
results = ParseDicomPropertyString(dicomProperty->GetValue());
}
return results;
}
std::vector<int> mitk::CustomTagParser::GetInternalRevisions()
{
const std::vector<us::ModuleResource> configs =
us::GetModuleContext()->GetModule()->FindResources("/", "*.json", false);
std::vector<int> availableRevisionsVector;
for (const auto& resource : configs)
{
availableRevisionsVector.push_back(std::stoi(resource.GetBaseName()));
}
return availableRevisionsVector;
}
std::vector<int> mitk::CustomTagParser::GetExternalRevisions()
{
std::string stringToJSONDirectory = GetExternalJSONDirectory();
std::string prospectiveJsonsPath = stringToJSONDirectory + "/*.json";
std::set<std::string> JsonFiles;
Poco::Glob::glob(prospectiveJsonsPath, JsonFiles, Poco::Glob::GLOB_CASELESS);
std::vector<int> availableRevisionsVector;
for (const auto& jsonpath : JsonFiles)
{
std::string jsonDir;
std::string jsonName;
itksys::SystemTools::SplitProgramPath(jsonpath, jsonDir, jsonName);
std::string revision = itksys::SystemTools::GetFilenameWithoutExtension(jsonName);
// disregard jsons which contain letters in their name
bool onlyNumbers = (revision.find_first_not_of("0123456789") == std::string::npos);
if(onlyNumbers)
{
availableRevisionsVector.push_back(std::stoi(revision));
}
}
return availableRevisionsVector;
}
std::string mitk::CustomTagParser::GetClosestLowerRevision(std::string revisionString, std::vector<int> availableRevisionsVector)
{
// descending order
std::sort(availableRevisionsVector.begin(), availableRevisionsVector.end(), std::greater<>());
int revision = std::stoi(revisionString);
int index = 0;
int numberOfRevisions = availableRevisionsVector.size();
while (index < numberOfRevisions)
{
// current mapping still has a higher revision number
if ((availableRevisionsVector[index] - revision) > 0)
{
++index;
}
else
{
break;
}
}
if (index < numberOfRevisions)
{
std::stringstream foundRevisionStream;
foundRevisionStream << availableRevisionsVector[index];
return foundRevisionStream.str();
}
return "";
}
void mitk::CustomTagParser::GetClosestLowerRevision(std::string revisionString)
{
m_ClosestInternalRevision = GetClosestLowerRevision(revisionString, GetInternalRevisions());
m_ClosestExternalRevision = GetClosestLowerRevision(revisionString, GetExternalRevisions());
if ("Strict" == m_RevisionMappingStrategy && !((0 == m_ClosestInternalRevision.compare(revisionString)) ||
(0 == m_ClosestExternalRevision.compare(revisionString))))
{ // strict revision mapping and neither revision does match the dicom meta data
std::stringstream errorMessageStream;
errorMessageStream << "\nCould not parse dicom data in strict mode, data revision " << revisionString
<< " has no known matching parameter mapping. To use the closest known older parameter mapping select the "
<< "\"Fuzzy\" revision mapping option when loading the data.\n"
<< "\nCurrently known revision mappings are:\n Precompiled:";
for (const auto revision : GetInternalRevisions())
{
errorMessageStream << " " << revision;
}
errorMessageStream << "\n External:";
for (const auto revision : GetExternalRevisions())
{
errorMessageStream << " " << revision;
}
errorMessageStream << "\n\nExternal revision mapping descriptions should be located at\n\n";
std::string stringToJSONDirectory = GetExternalJSONDirectory();
errorMessageStream << stringToJSONDirectory;
errorMessageStream << "\n\nTo provide an external mapping for this revision create a " << revisionString
<< ".json there. You might need to create the directory first.";
mitkThrow() << errorMessageStream.str();
}
}
std::string mitk::CustomTagParser::GetRevisionAppropriateJSONString(std::string revisionString)
{
std::string returnValue = "";
if ("" == revisionString)
{
MITK_WARN << "Could not extract revision";
}
else
{
GetClosestLowerRevision(revisionString);
bool useExternal = false;
bool useInternal = false;
if ("" != m_ClosestExternalRevision)
{
useExternal = true;
}
if ("" != m_ClosestInternalRevision)
{
useInternal = true;
}
if (useExternal && useInternal)
{
if (std::stoi(m_ClosestInternalRevision) > std::stoi(m_ClosestExternalRevision))
{
useExternal = false;
}
}
if (useExternal)
{
std::string stringToJSONDirectory = GetExternalJSONDirectory();
std::string prospectiveJsonPath = stringToJSONDirectory + "/" + m_ClosestExternalRevision + ".json";
std::ifstream externalJSON(prospectiveJsonPath.c_str());
if (externalJSON.good())
{
MITK_INFO << "Found external json for CEST parameters at " << prospectiveJsonPath;
std::stringstream buffer;
buffer << externalJSON.rdbuf();
returnValue = buffer.str();
useInternal = false;
}
}
if (useInternal)
{
std::string filename = m_ClosestInternalRevision + ".json";
us::ModuleResource jsonResource = us::GetModuleContext()->GetModule()->GetResource(filename);
if (jsonResource.IsValid() && jsonResource.IsFile())
{
MITK_INFO << "Found no external json for CEST parameters. Closest internal mapping is for revision "
<< m_ClosestInternalRevision;
us::ModuleResourceStream jsonStream(jsonResource);
std::stringstream buffer;
buffer << jsonStream.rdbuf();
returnValue = buffer.str();
}
}
}
if ("" == returnValue)
{
MITK_WARN << "Could not identify parameter mapping for the given revision " << revisionString
<< ", using default mapping.";
returnValue = m_DefaultJsonString;
}
// inject the revision independent mapping before the first newline
{
returnValue.insert(returnValue.find("\n"), m_RevisionIndependentMapping);
}
return returnValue;
}
std::string mitk::CustomTagParser::GetOffsetString(std::string samplingType, std::string offset, std::string measurements)
{
std::stringstream results;
results.imbue(std::locale("C"));
std::string normalizationIndicatingOffset = "-300";
double offsetDouble = 0.0;
int measurementsInt = 0;
bool validOffset = false;
bool validMeasurements = false;
if ("" != offset)
{
validOffset = true;
offsetDouble = std::stod(offset);
}
if ("" != measurements)
{
validMeasurements = true;
measurementsInt = std::stoi(measurements);
}
std::vector<double> offsetVector;
if (validOffset && validMeasurements)
{
for (int step = 0; step < measurementsInt -1; ++step)
{
double currentOffset = -offsetDouble + 2 * step * offsetDouble / (measurementsInt - 2.0);
offsetVector.push_back(currentOffset);
}
}
else
{
MITK_WARN << "Invalid offset or measurements, offset calculation will only work for list sampling type.";
}
if (samplingType == "1" || samplingType == "Regular")
{
if (validOffset && validMeasurements)
{
results << normalizationIndicatingOffset << " ";
for (const auto& entry : offsetVector)
{
results << entry << " ";
}
}
}
else if (samplingType == "2" || samplingType == "Alternating")
{
if (validOffset && validMeasurements)
{
results << normalizationIndicatingOffset << " ";
for (auto& entry : offsetVector)
{
entry = std::abs(entry);
}
std::sort(offsetVector.begin(), offsetVector.end(), std::greater<>());
for (unsigned int index = 0; index < offsetVector.size(); ++index)
{
offsetVector[index] = std::pow(-1, index) * offsetVector[index];
}
for (auto& entry : offsetVector)
{
results << entry << " ";
}
}
}
else if (samplingType == "3" || samplingType == "List")
{
std::string listPath = m_DicomDataPath + "/LIST.txt";
auto values = ReadListFromFile(listPath);
if (!values.empty())
{
results << values;
}
else
{
MITK_ERROR << "Could not load list at " << listPath;
}
}
else if (samplingType == "4" || samplingType == "SingleOffset")
{
if (validOffset && validMeasurements)
{
results << normalizationIndicatingOffset << " ";
for (int step = 0; step < measurementsInt - 1; ++step)
{
results << offsetDouble << " ";
}
}
}
else
{
MITK_WARN << "Encountered unknown sampling type.";
}
std::string resultString = results.str();
// replace multiple spaces by a single space
std::string::iterator newEnditerator =
std::unique(resultString.begin(), resultString.end(),
[=](char lhs, char rhs) { return (lhs == rhs) && (lhs == ' '); }
);
resultString.erase(newEnditerator, resultString.end());
if ((resultString.length() > 0) && (resultString.at(resultString.length() - 1) == ' '))
{
resultString.erase(resultString.end() - 1, resultString.end());
}
if ((resultString.length() > 0) && (resultString.at(0) == ' '))
{
resultString.erase(resultString.begin(), ++(resultString.begin()));
}
return resultString;
}
void mitk::CustomTagParser::SetParseStrategy(std::string parseStrategy)
{
m_ParseStrategy = parseStrategy;
}
void mitk::CustomTagParser::SetRevisionMappingStrategy(std::string revisionMappingStrategy)
{
m_RevisionMappingStrategy = revisionMappingStrategy;
}
std::string mitk::CustomTagParser::GetExternalJSONDirectory()
{
std::string moduleLocation = us::GetModuleContext()->GetModule()->GetLocation();
std::string stringToModule;
std::string libraryName;
itksys::SystemTools::SplitProgramPath(moduleLocation, stringToModule, libraryName);
std::stringstream jsonDirectory;
jsonDirectory << stringToModule << "/CESTRevisionMapping";
return jsonDirectory.str();
}
diff --git a/Modules/Classification/CLCore/include/mitkAbstractGlobalImageFeature.h b/Modules/Classification/CLCore/include/mitkAbstractGlobalImageFeature.h
index b72e15a9f5..c28967a9e4 100644
--- a/Modules/Classification/CLCore/include/mitkAbstractGlobalImageFeature.h
+++ b/Modules/Classification/CLCore/include/mitkAbstractGlobalImageFeature.h
@@ -1,342 +1,342 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkAbstractGlobalImageFeature_h
#define mitkAbstractGlobalImageFeature_h
#include <MitkCLCoreExports.h>
#include <mitkBaseData.h>
#include <mitkImage.h>
#include <mitkCommandLineParser.h>
#include <mitkIntensityQuantifier.h>
// STD Includes
// Eigen
#include <Eigen/Dense>
// MITK includes
#include <mitkConfigurationHolder.h>
namespace mitk
{
/**Used as ID for features calculated by feature classes*/
struct MITKCLCORE_EXPORT FeatureID
{
/**Name of the feature*/
std::string name;
/**Name of the feature class*/
std::string featureClass;
/**ID for the setting that is represented by parameters and is specified by the feature class while calculating the features. It must be as unique as the parameters themself.*/
std::string settingID;
/**Alternative name that containes the legacy naming of the feature that encodes the parametersetting directly in the string.*/
std::string legacyName;
/**Version of the feature definition*/
std::string version = "1";
using ParametersType = std::map<std::string, us::Any>;
ParametersType parameters;
bool operator < (const FeatureID& rh) const;
bool operator ==(const FeatureID& rh) const;
};
/**Helper that takes a pass templateID clones it and populates it with the also passed informations befor returning it.
* @param templateID reference ID that should be cloned.
* @param name Name of the feature.*/
MITKCLCORE_EXPORT FeatureID CreateFeatureID(FeatureID templateID, std::string name);
/**
*
*
* ## Histogram Configuration ##
* Most Feature Generation Classes that use histograms use the same parameters and
* initialization logic. In general, all information can be passed either by the corresponding
* Setter (which does not differenciate between global setting and feature specific setting) and
* a parameter object which can be obtained from the command line arguments, for example.
*
* If the image values are used for the initializiation of the histogram, it can be defined
* whether the whole image is used or only the masked areas to find minima and maxima. This is
* done by the option <b>SetIgnoreMask</b> or the corrsponding options
- * <b>-NAME::ignore-mask-for-histogram</b> and <b>-ignore-mask-for-histogram</b>. If these are
+ * <b>-%NAME::ignore-mask-for-histogram</b> and <b>-ignore-mask-for-histogram</b>. If these are
* true, the whole image is used for the calculation.
*
* Depending on the passed arguments, different initialization methods are used. The initialization
* is in the following order:
* - If <b>Minimum Intensity</b>, <b>Maximum Intensity</b>, and <b>Binsize</b>: The histogram is
* initialized between the minimum and maximum intensity. the number of bins is determined by the
* binsize. If the distance between minimum and maximum is not a multiple of the binsize, the maximum
* is increase so that it is.
* - <b>Minimum Intensity</b>, <b>Bins</b>, and <b>Binsize</b>: The histogram is initialized with the
* given binsize, and the intensity range from the minimum to \f$maximum = minimum + binsize*bins\f$.
* - <b>Minimum Intensity</b>, <b>Maximum Intensity</b>, and <b>Bins</b>: The histogram is initialized
* between the given minimum and maximum intensity. The binsize is calculated so that the number
* of bins is equal to the given number of bins.
* - <b>Binsize</b>, and <b>Minimum Intensity</b>: The maximum is set to the maximum that
* occur in the given image. Depending if the mask is considered or not, either only masked voxels or
* the whole image is used for the calculation. The initialization is then equal as if the minimum
* and maximum would have been given right from the beginning.
* - <b>Binsize</b>, and <b>Maximum Intensity</b>: The minimum intensity is set to the minimum that
* occur in the given image. Depending if the mask is considered or not, either only masked voxels or
* the whole image is used for the calculation. The initialization is then equal as if the minimum
* and maximum would have been given right from the beginning.
* - <b>Binsize</b>: The maximum and the minimum intensity is set to the minimum and maximum that
* occur in the given image. Depending if the mask is considered or not, either only masked voxels or
* the whole image is used for the calculation. The initialization is then equal as if the minimum
* and maximum would have been given right from the beginning.
* - <b>Bins</b>, and <b>Minimum Intensity</b>: The maximum is calculated from the image. Depending
* if the mask is considered or not, either only masked voxels or the whole image is used for the calculation. The histogram is
* then initialized as if these values would have been given as minimum and maximum intensity.
* - <b>Bins</b>, and <b>Maximum Intensity</b>: The minimum is calculated from the image. Depending
* if the mask is considered or not, either only masked voxels or the whole image is used for the calculation. The histogram is
* then initialized as if these values would have been given as minimum and maximum intensity.
* - <b>Bins</b>: The minimum and the maximum is calculated from the image. Depending
* if the mask is considered or not, either only masked voxels or * the whole image is used for the calculation. The histogram is
* then initialized as if these values would have been given as minimum and maximum intensity.
* - <b>No Parameter given</b>:The minimum and maximum intensity from the whole image or masked image is calculated and
* the histogram then initialized to this with a standard number of bins (Is set by each filter on its own.)
*
* ### Remark about command line parameter####
* There are generally two options to set a parameter via the command line. A global one that works for
* all filters that use histograms and a local one that set this parameter specific for this filter. The
* local parameters start with the filter name (Indiciated by NAME) followed by two colons, for example
* <b>vol::min</b> to set the minimum intensity for the volume filter. The global parameter is overwritten
* by the local parameter, if it is specified. Otherwise, it is still valid. If this prevents the specification
* of an histogram initialization method (for example, because the binsize is globally specified but the histogram
* should be initialized using a fixed numbe of bins), the parameter <b>NAME::ignore-global-histogram</b> can be passed.
* Then, all global histogram parameters are ignored and only local ones are used.
*
* The maximum intensity can be set by different command line parameters: global for all filters that use histograms
* by <b>-minimum-intensity</b> and <b>-minimum</b>. Alternative it can be set only for this filter by
- * <b>-NAME::minimum</b> and <b>-NAME::min</b>.
+ * <b>-%NAME::minimum</b> and <b>-%NAME::min</b>.
*
* The minimum intensity can be set by different command line parameters: global for all filters that use histograms
* by <b>-maximum-intensity</b> and <b>-maximum</b>. Alternative it can be set only for this filter by
- * <b>-NAME::maximum</b> and <b>-NAME::max</b>.
+ * <b>-%NAME::maximum</b> and <b>-%NAME::max</b>.
*
* The binsize can be set by different command line parameters: global for all filters that use histograms
* by <b>-binsize</b>. Alternative it can be set only for this filter by
- * <b>-NAME::binsize</b>.
+ * <b>-%NAME::binsize</b>.
*
* The number of bins can be set by different command line parameters: global for all filters that use histograms
* by <b>-bins</b>. Alternative it can be set only for this filter by
- * <b>-NAME::bins</b>.
+ * <b>-%NAME::bins</b>.
* ### Note to the developers ###
* All features are supposed to work the same way if a histogram is used somewhere in
* the code. For this, each derived class that makes use of a histogram should use
* the Quantifier object. In order to use this object correctly, the AddArguments-Function should
* contain the line <b>AddQuantifierArguments(parser);</b>, the CalculateFeaturesUsingParameters function
* should contain the line <b>InitializeQuantifierFromParameters(feature, mask);</b> and the CalculateFeatures function
* sould contain the line <b>InitializeQuantifier(image, mask);</b>. These function
* calls ensure that the necessary options are given to the configuration file, and that the initialization
* of the quantifier is done correctly. This ensures an consistend behavior over all FeatureGeneration Classes.
*
*/
class MITKCLCORE_EXPORT AbstractGlobalImageFeature : public BaseData
{
public:
mitkClassMacro(AbstractGlobalImageFeature, BaseData);
typedef std::vector< std::pair<FeatureID, double> > FeatureListType;
using ParametersType = FeatureID::ParametersType;
/**
* \brief Calculates the feature of this abstact interface. Does not necessarily considers the parameter settings.
*/
FeatureListType CalculateFeatures(const Image* image, const Image* mask);
virtual FeatureListType CalculateFeatures(const Image* image, const Image* mask, const Image* maskNoNAN) = 0;
/**
* \brief Calculates the given feature Slice-wise. Might not be availble for an individual filter!
*/
FeatureListType CalculateFeaturesSlicewise(const Image::Pointer & image, const Image::Pointer &mask, int sliceID);
/**
* \brief Calculates the feature of this abstact interface. Does not necessarily considers the parameter settings.
*/
virtual void CalculateAndAppendFeaturesSliceWise(const Image::Pointer & image, const Image::Pointer &mask, int sliceID, FeatureListType &featureList, bool checkParameterActivation = true);
/**
* \brief Calculates the feature of this abstact interface. Does not necessarily considers the parameter settings.
* @param image
* @param mask
* @param maskNoNaN
* @param featureList
* @param checkParameterActivation Indicates if the features should only be calculated and added if the FeatureClass is activated in the parameters.
* True: only append if activated in the parametes. False: always and append it.
*/
void CalculateAndAppendFeatures(const Image* image, const Image* mask, const Image* maskNoNaN, FeatureListType &featureList, bool checkParameterActivation = true);
itkSetMacro(Prefix, std::string);
itkSetMacro(ShortName, std::string);
itkSetMacro(LongName, std::string);
itkSetMacro(FeatureClassName, std::string);
itkSetMacro(Direction, int);
void SetParameters(ParametersType param)
{
m_Parameters = param;
this->ConfigureQuantifierSettingsByParameters();
this->ConfigureSettingsByParameters(param);
this->Modified();
};
itkGetConstMacro(Prefix, std::string);
itkGetConstMacro(ShortName, std::string);
itkGetConstMacro(LongName, std::string);
itkGetConstMacro(FeatureClassName, std::string);
itkGetConstMacro(Parameters, ParametersType);
itkGetMacro(Quantifier, IntensityQuantifier::Pointer);
itkGetConstMacro(Direction, int);
itkSetMacro(MinimumIntensity, double);
itkSetMacro(UseMinimumIntensity, bool);
itkSetMacro(MaximumIntensity, double);
itkSetMacro(UseMaximumIntensity, bool);
itkGetConstMacro(MinimumIntensity, double);
itkGetConstMacro(UseMinimumIntensity, bool);
itkGetConstMacro(MaximumIntensity, double);
itkGetConstMacro(UseMaximumIntensity, bool);
itkSetMacro(Binsize, double);
itkSetMacro(UseBinsize, bool);
itkGetConstMacro(Binsize, double);
itkGetConstMacro(UseBinsize, bool);
itkSetMacro(MorphMask, mitk::Image::Pointer);
itkGetConstMacro(MorphMask, mitk::Image::Pointer);
itkSetMacro(Bins, int);
itkSetMacro(UseBins, bool);
itkGetConstMacro(UseBins, bool);
itkGetConstMacro(Bins, int);
itkSetMacro(IgnoreMask, bool);
itkGetConstMacro(IgnoreMask, bool);
itkSetMacro(EncodeParametersInFeaturePrefix, bool);
itkGetConstMacro(EncodeParametersInFeaturePrefix, bool);
itkBooleanMacro(EncodeParametersInFeaturePrefix);
std::string GetOptionPrefix() const
{
if (!m_Prefix.empty())
return m_Prefix + "::" + m_ShortName;
return m_ShortName;
}
/** Can be called to add all relevant argument for configuring the feature instance to the passed parser instance.
Must be implemented be derived classes. For adding the quantifier arguments use AddQuantifierArguments(...) as
helper function.*/
virtual void AddArguments(mitkCommandLineParser &parser) const = 0;
/** Helper function that generates the legacy feature name without encoding of parameters; as it is used e.g.
in the unit tests.*/
static std::string GenerateLegacyFeatureNameWOEncoding(const FeatureID& id);
protected:
std::vector<double> SplitDouble(std::string str, char delimiter);
virtual FeatureListType DoCalculateFeatures(const Image* image, const Image* mask) = 0;
void AddQuantifierArguments(mitkCommandLineParser& parser) const;
/** Ensures that all quantifier relevant variables of the instance are set correctly given the information in m_Parameters.*/
void ConfigureQuantifierSettingsByParameters();
/** Ensures that the instance is configured according to the information given in the passed parameters.
* This method will be called by SetParameters(...) after ConfigureQuantifierSettingsByParameters() was called.*/
virtual void ConfigureSettingsByParameters(const ParametersType& parameters);
/**Initializes the quantifier gigen the quantifier relevant variables and the passed arguments.*/
void InitializeQuantifier(const Image* image, const Image* mask, unsigned int defaultBins = 256);
/** Helper that encodes the quantifier parameters in a string (e.g. used for the legacy feature name)*/
std::string QuantifierParameterString() const;
/* Creates a template feature id.
* it will set the featureClass, the settingID (assuming that it is the featureClass with the passed suffix
* and all parameters that are global or have the option prefix of the instance.*/
FeatureID CreateTemplateFeatureID(std::string settingsSuffix = "", FeatureID::ParametersType additionalParams = {});
/** Helper that generates the legacy feature names for a passed FeatureID.
* Format of the legacy feature name is: \<ClassName\>::[\<LegacyFeatureEncoding\>::]\<LegacyFeatureNamePart\>
* Overwrite GenerateLegacyFeatureNamePart and GenerateLegacyFeatureEncoding to change behavior in
* derived classes.
*/
virtual std::string GenerateLegacyFeatureName(const FeatureID& id) const;
virtual std::string GenerateLegacyFeatureNamePart(const FeatureID& id) const;
virtual std::string GenerateLegacyFeatureEncoding(const FeatureID& id) const;
public:
//#ifndef DOXYGEN_SKIP
void SetRequestedRegionToLargestPossibleRegion() override {};
bool RequestedRegionIsOutsideOfTheBufferedRegion() override { return true; };
bool VerifyRequestedRegion() override { return false; };
void SetRequestedRegion (const itk::DataObject * /*data*/) override {};
// Override
bool IsEmpty() const override
{
if(IsInitialized() == false)
return true;
const TimeGeometry* timeGeometry = const_cast<AbstractGlobalImageFeature*>(this)->GetUpdatedTimeGeometry();
if(timeGeometry == nullptr)
return true;
return false;
}
private:
std::string m_Prefix; // Prefix before all input parameters
std::string m_ShortName; // Name of all variables
std::string m_LongName; // Long version of the name (For turning on)
std::string m_FeatureClassName;
ParametersType m_Parameters; // Parameter setting
mitk::Image::Pointer m_MorphMask = nullptr;
IntensityQuantifier::Pointer m_Quantifier;
//Quantifier relevant variables
double m_MinimumIntensity = 0;
bool m_UseMinimumIntensity = false;
double m_MaximumIntensity = 100;
bool m_UseMaximumIntensity = false;
bool m_EncodeParametersInFeaturePrefix = false;
double m_Binsize = 1;
bool m_UseBinsize = false;
int m_Bins = 256;
bool m_UseBins = true;
int m_Direction = 0;
bool m_IgnoreMask = false;
//#endif // Skip Doxygen
};
}
#endif //mitkAbstractGlobalImageFeature_h
diff --git a/Modules/Classification/CLMiniApps/CLGlobalImageFeatures.cpp b/Modules/Classification/CLMiniApps/CLGlobalImageFeatures.cpp
index 76b347d77a..80ba5e8016 100644
--- a/Modules/Classification/CLMiniApps/CLGlobalImageFeatures.cpp
+++ b/Modules/Classification/CLMiniApps/CLGlobalImageFeatures.cpp
@@ -1,789 +1,786 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkCLPolyToNrrd_cpp
#define mitkCLPolyToNrrd_cpp
#include "time.h"
#include <sstream>
#include <fstream>
#include <mitkIOUtil.h>
#include "mitkCommandLineParser.h"
#include <mitkSplitParameterToVector.h>
#include <mitkGlobalImageFeaturesParameter.h>
#include <mitkGIFCooccurenceMatrix.h>
#include <mitkGIFCooccurenceMatrix2.h>
#include <mitkGIFGreyLevelRunLength.h>
#include <mitkGIFFirstOrderStatistics.h>
#include <mitkGIFFirstOrderHistogramStatistics.h>
#include <mitkGIFFirstOrderNumericStatistics.h>
#include <mitkGIFVolumetricStatistics.h>
#include <mitkGIFVolumetricDensityStatistics.h>
#include <mitkGIFGreyLevelSizeZone.h>
#include <mitkGIFGreyLevelDistanceZone.h>
#include <mitkGIFImageDescriptionFeatures.h>
#include <mitkGIFLocalIntensity.h>
#include <mitkGIFCurvatureStatistic.h>
#include <mitkGIFIntensityVolumeHistogramFeatures.h>
#include <mitkGIFNeighbourhoodGreyToneDifferenceFeatures.h>
#include <mitkGIFNeighbouringGreyLevelDependenceFeatures.h>
#include <mitkImageAccessByItk.h>
#include <mitkImageCast.h>
#include <mitkITKImageImport.h>
#include <mitkConvert2Dto3DImageFilter.h>
#include <mitkCLResultWriter.h>
#include <mitkCLResultXMLWriter.h>
#include <mitkVersion.h>
#include <iostream>
#include <locale>
#include <itkImageDuplicator.h>
#include <itkImageRegionIterator.h>
#include "itkNearestNeighborInterpolateImageFunction.h"
#include "itkResampleImageFilter.h"
#include <QApplication>
#include <mitkStandaloneDataStorage.h>
#include "QmitkRegisterClasses.h"
#include "QmitkRenderWindow.h"
#include "vtkRenderLargeImage.h"
#include "vtkPNGWriter.h"
typedef itk::Image< double, 3 > FloatImageType;
typedef itk::Image< unsigned short, 3 > MaskImageType;
template <class charT>
class punct_facet : public std::numpunct<charT> {
public:
punct_facet(charT sep) :
m_Sep(sep)
{
}
protected:
charT do_decimal_point() const override { return m_Sep; }
private:
charT m_Sep;
};
template<typename TPixel, unsigned int VImageDimension>
void
ResampleImage(itk::Image<TPixel, VImageDimension>* itkImage, float resolution, mitk::Image::Pointer& newImage)
{
typedef itk::Image<TPixel, VImageDimension> ImageType;
typedef itk::ResampleImageFilter<ImageType, ImageType> ResampleFilterType;
typename ResampleFilterType::Pointer resampler = ResampleFilterType::New();
auto spacing = itkImage->GetSpacing();
auto size = itkImage->GetLargestPossibleRegion().GetSize();
for (unsigned int i = 0; i < VImageDimension; ++i)
{
size[i] = size[i] / (1.0*resolution)*(1.0*spacing[i])+1.0;
}
spacing.Fill(resolution);
resampler->SetInput(itkImage);
resampler->SetSize(size);
resampler->SetOutputSpacing(spacing);
resampler->SetOutputOrigin(itkImage->GetOrigin());
resampler->SetOutputDirection(itkImage->GetDirection());
resampler->Update();
newImage->InitializeByItk(resampler->GetOutput());
mitk::GrabItkImageMemory(resampler->GetOutput(), newImage);
}
template<typename TPixel, unsigned int VImageDimension>
static void
CreateNoNaNMask(itk::Image<TPixel, VImageDimension>* itkValue, mitk::Image::Pointer mask, mitk::Image::Pointer& newMask)
{
typedef itk::Image< TPixel, VImageDimension> LFloatImageType;
typedef itk::Image< unsigned short, VImageDimension> LMaskImageType;
typename LMaskImageType::Pointer itkMask = LMaskImageType::New();
mitk::CastToItkImage(mask, itkMask);
typedef itk::ImageDuplicator< LMaskImageType > DuplicatorType;
typename DuplicatorType::Pointer duplicator = DuplicatorType::New();
duplicator->SetInputImage(itkMask);
duplicator->Update();
auto tmpMask = duplicator->GetOutput();
itk::ImageRegionIterator<LMaskImageType> mask1Iter(itkMask, itkMask->GetLargestPossibleRegion());
itk::ImageRegionIterator<LMaskImageType> mask2Iter(tmpMask, tmpMask->GetLargestPossibleRegion());
itk::ImageRegionIterator<LFloatImageType> imageIter(itkValue, itkValue->GetLargestPossibleRegion());
while (!mask1Iter.IsAtEnd())
{
mask2Iter.Set(0);
if (mask1Iter.Value() > 0)
{
// Is not NaN
if (imageIter.Value() == imageIter.Value())
{
mask2Iter.Set(1);
}
}
++mask1Iter;
++mask2Iter;
++imageIter;
}
newMask->InitializeByItk(tmpMask);
mitk::GrabItkImageMemory(tmpMask, newMask);
}
template<typename TPixel, unsigned int VImageDimension>
static void
ResampleMask(itk::Image<TPixel, VImageDimension>* itkMoving, mitk::Image::Pointer ref, mitk::Image::Pointer& newMask)
{
typedef itk::Image< TPixel, VImageDimension> LMaskImageType;
typedef itk::NearestNeighborInterpolateImageFunction< LMaskImageType> NearestNeighborInterpolateImageFunctionType;
typedef itk::ResampleImageFilter<LMaskImageType, LMaskImageType> ResampleFilterType;
typename NearestNeighborInterpolateImageFunctionType::Pointer nn_interpolator = NearestNeighborInterpolateImageFunctionType::New();
typename LMaskImageType::Pointer itkRef = LMaskImageType::New();
mitk::CastToItkImage(ref, itkRef);
typename ResampleFilterType::Pointer resampler = ResampleFilterType::New();
resampler->SetInput(itkMoving);
resampler->SetReferenceImage(itkRef);
resampler->UseReferenceImageOn();
resampler->SetInterpolator(nn_interpolator);
resampler->Update();
newMask->InitializeByItk(resampler->GetOutput());
mitk::GrabItkImageMemory(resampler->GetOutput(), newMask);
}
static void
ExtractSlicesFromImages(mitk::Image::Pointer image, mitk::Image::Pointer mask,
mitk::Image::Pointer maskNoNaN, mitk::Image::Pointer morphMask,
int direction,
std::vector<mitk::Image::Pointer> &imageVector,
std::vector<mitk::Image::Pointer> &maskVector,
std::vector<mitk::Image::Pointer> &maskNoNaNVector,
std::vector<mitk::Image::Pointer> &morphMaskVector)
{
typedef itk::Image< double, 2 > FloatImage2DType;
typedef itk::Image< unsigned short, 2 > MaskImage2DType;
FloatImageType::Pointer itkFloat = FloatImageType::New();
MaskImageType::Pointer itkMask = MaskImageType::New();
MaskImageType::Pointer itkMaskNoNaN = MaskImageType::New();
MaskImageType::Pointer itkMorphMask = MaskImageType::New();
mitk::CastToItkImage(mask, itkMask);
mitk::CastToItkImage(maskNoNaN, itkMaskNoNaN);
mitk::CastToItkImage(image, itkFloat);
mitk::CastToItkImage(morphMask, itkMorphMask);
int idxA, idxB, idxC;
switch (direction)
{
case 0:
idxA = 1; idxB = 2; idxC = 0;
break;
case 1:
idxA = 0; idxB = 2; idxC = 1;
break;
case 2:
idxA = 0; idxB = 1; idxC = 2;
break;
default:
idxA = 1; idxB = 2; idxC = 0;
break;
}
auto imageSize = image->GetLargestPossibleRegion().GetSize();
FloatImageType::IndexType index3D;
FloatImage2DType::IndexType index2D;
FloatImage2DType::SpacingType spacing2D;
spacing2D[0] = itkFloat->GetSpacing()[idxA];
spacing2D[1] = itkFloat->GetSpacing()[idxB];
for (unsigned int i = 0; i < imageSize[idxC]; ++i)
{
FloatImage2DType::RegionType region;
FloatImage2DType::IndexType start;
FloatImage2DType::SizeType size;
start[0] = 0; start[1] = 0;
size[0] = imageSize[idxA];
size[1] = imageSize[idxB];
region.SetIndex(start);
region.SetSize(size);
FloatImage2DType::Pointer image2D = FloatImage2DType::New();
image2D->SetRegions(region);
image2D->Allocate();
MaskImage2DType::Pointer mask2D = MaskImage2DType::New();
mask2D->SetRegions(region);
mask2D->Allocate();
MaskImage2DType::Pointer masnNoNaN2D = MaskImage2DType::New();
masnNoNaN2D->SetRegions(region);
masnNoNaN2D->Allocate();
MaskImage2DType::Pointer morph2D = MaskImage2DType::New();
morph2D->SetRegions(region);
morph2D->Allocate();
unsigned long voxelsInMask = 0;
for (unsigned int a = 0; a < imageSize[idxA]; ++a)
{
for (unsigned int b = 0; b < imageSize[idxB]; ++b)
{
index3D[idxA] = a;
index3D[idxB] = b;
index3D[idxC] = i;
index2D[0] = a;
index2D[1] = b;
image2D->SetPixel(index2D, itkFloat->GetPixel(index3D));
mask2D->SetPixel(index2D, itkMask->GetPixel(index3D));
masnNoNaN2D->SetPixel(index2D, itkMaskNoNaN->GetPixel(index3D));
morph2D->SetPixel(index2D, itkMorphMask->GetPixel(index3D));
voxelsInMask += (itkMask->GetPixel(index3D) > 0) ? 1 : 0;
}
}
image2D->SetSpacing(spacing2D);
mask2D->SetSpacing(spacing2D);
masnNoNaN2D->SetSpacing(spacing2D);
morph2D->SetSpacing(spacing2D);
mitk::Image::Pointer tmpFloatImage = mitk::Image::New();
tmpFloatImage->InitializeByItk(image2D.GetPointer());
mitk::GrabItkImageMemory(image2D, tmpFloatImage);
mitk::Image::Pointer tmpMaskImage = mitk::Image::New();
tmpMaskImage->InitializeByItk(mask2D.GetPointer());
mitk::GrabItkImageMemory(mask2D, tmpMaskImage);
mitk::Image::Pointer tmpMaskNoNaNImage = mitk::Image::New();
tmpMaskNoNaNImage->InitializeByItk(masnNoNaN2D.GetPointer());
mitk::GrabItkImageMemory(masnNoNaN2D, tmpMaskNoNaNImage);
mitk::Image::Pointer tmpMorphMaskImage = mitk::Image::New();
tmpMorphMaskImage->InitializeByItk(morph2D.GetPointer());
mitk::GrabItkImageMemory(morph2D, tmpMorphMaskImage);
if (voxelsInMask > 0)
{
imageVector.push_back(tmpFloatImage);
maskVector.push_back(tmpMaskImage);
maskNoNaNVector.push_back(tmpMaskNoNaNImage);
morphMaskVector.push_back(tmpMorphMaskImage);
}
}
}
static
void SaveSliceOrImageAsPNG(mitk::Image::Pointer image, mitk::Image::Pointer mask, std::string path, int index)
{
// Create a Standalone Datastorage for the single purpose of saving screenshots..
mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
QmitkRenderWindow renderWindow;
renderWindow.GetRenderer()->SetDataStorage(ds);
auto nodeI = mitk::DataNode::New();
nodeI->SetData(image);
auto nodeM = mitk::DataNode::New();
nodeM->SetData(mask);
ds->Add(nodeI);
ds->Add(nodeM);
auto geo = ds->ComputeBoundingGeometry3D(ds->GetAll());
mitk::RenderingManager::GetInstance()->InitializeViews(geo);
mitk::SliceNavigationController::Pointer sliceNaviController = renderWindow.GetSliceNavigationController();
unsigned int numberOfSteps = 1;
if (sliceNaviController)
{
numberOfSteps = sliceNaviController->GetSlice()->GetSteps();
sliceNaviController->GetSlice()->SetPos(0);
}
renderWindow.show();
renderWindow.resize(256, 256);
for (unsigned int currentStep = 0; currentStep < numberOfSteps; ++currentStep)
{
if (sliceNaviController)
{
sliceNaviController->GetSlice()->SetPos(currentStep);
}
renderWindow.GetRenderer()->PrepareRender();
vtkRenderWindow* renderWindow2 = renderWindow.GetVtkRenderWindow();
mitk::BaseRenderer* baserenderer = mitk::BaseRenderer::GetInstance(renderWindow2);
auto vtkRender = baserenderer->GetVtkRenderer();
vtkRender->GetRenderWindow()->WaitForCompletion();
vtkRenderLargeImage* magnifier = vtkRenderLargeImage::New();
magnifier->SetInput(vtkRender);
magnifier->SetMagnification(3.0);
std::stringstream ss;
ss << path << "_Idx-" << index << "_Step-"<<currentStep<<".png";
std::string tmpImageName;
ss >> tmpImageName;
auto fileWriter = vtkPNGWriter::New();
fileWriter->SetInputConnection(magnifier->GetOutputPort());
fileWriter->SetFileName(tmpImageName.c_str());
fileWriter->Write();
fileWriter->Delete();
}
}
int main(int argc, char* argv[])
{
// Commented : Updated to a common interface, include, if possible, mask is type unsigned short, uses Quantification, Comments
// Name follows standard scheme with Class Name::Feature Name
// Commented 2: Updated to use automatic inclusion of list of parameters if required.
mitk::GIFImageDescriptionFeatures::Pointer ipCalculator = mitk::GIFImageDescriptionFeatures::New(); // Commented 2, Tested
mitk::GIFFirstOrderStatistics::Pointer firstOrderCalculator = mitk::GIFFirstOrderStatistics::New(); //Commented 2
mitk::GIFFirstOrderHistogramStatistics::Pointer firstOrderHistoCalculator = mitk::GIFFirstOrderHistogramStatistics::New(); // Commented 2, Tested
mitk::GIFFirstOrderNumericStatistics::Pointer firstOrderNumericCalculator = mitk::GIFFirstOrderNumericStatistics::New(); // Commented 2, Tested
mitk::GIFVolumetricStatistics::Pointer volCalculator = mitk::GIFVolumetricStatistics::New(); // Commented 2, Tested
mitk::GIFVolumetricDensityStatistics::Pointer voldenCalculator = mitk::GIFVolumetricDensityStatistics::New(); // Commented 2, Tested
mitk::GIFCooccurenceMatrix::Pointer coocCalculator = mitk::GIFCooccurenceMatrix::New(); // Commented 2, Will not be tested
mitk::GIFCooccurenceMatrix2::Pointer cooc2Calculator = mitk::GIFCooccurenceMatrix2::New(); //Commented 2
mitk::GIFNeighbouringGreyLevelDependenceFeature::Pointer ngldCalculator = mitk::GIFNeighbouringGreyLevelDependenceFeature::New(); //Commented 2, Tested
mitk::GIFGreyLevelRunLength::Pointer rlCalculator = mitk::GIFGreyLevelRunLength::New(); // Commented 2
mitk::GIFGreyLevelSizeZone::Pointer glszCalculator = mitk::GIFGreyLevelSizeZone::New(); // Commented 2, Tested
mitk::GIFGreyLevelDistanceZone::Pointer gldzCalculator = mitk::GIFGreyLevelDistanceZone::New(); //Commented 2, Tested
mitk::GIFLocalIntensity::Pointer lociCalculator = mitk::GIFLocalIntensity::New(); //Commented 2, Tested
mitk::GIFIntensityVolumeHistogramFeatures::Pointer ivohCalculator = mitk::GIFIntensityVolumeHistogramFeatures::New(); // Commented 2
mitk::GIFNeighbourhoodGreyToneDifferenceFeatures::Pointer ngtdCalculator = mitk::GIFNeighbourhoodGreyToneDifferenceFeatures::New(); //Commented 2, Tested
mitk::GIFCurvatureStatistic::Pointer curvCalculator = mitk::GIFCurvatureStatistic::New(); //Commented 2, Tested
std::vector<mitk::AbstractGlobalImageFeature::Pointer> features;
features.push_back(volCalculator.GetPointer());
features.push_back(voldenCalculator.GetPointer());
features.push_back(curvCalculator.GetPointer());
features.push_back(firstOrderCalculator.GetPointer());
features.push_back(firstOrderNumericCalculator.GetPointer());
features.push_back(firstOrderHistoCalculator.GetPointer());
features.push_back(ivohCalculator.GetPointer());
features.push_back(lociCalculator.GetPointer());
features.push_back(coocCalculator.GetPointer());
features.push_back(cooc2Calculator.GetPointer());
features.push_back(ngldCalculator.GetPointer());
features.push_back(rlCalculator.GetPointer());
features.push_back(glszCalculator.GetPointer());
features.push_back(gldzCalculator.GetPointer());
features.push_back(ipCalculator.GetPointer());
features.push_back(ngtdCalculator.GetPointer());
mitkCommandLineParser parser;
parser.setArgumentPrefix("--", "-");
mitk::cl::GlobalImageFeaturesParameter param;
param.AddParameter(parser);
parser.addArgument("--","-", mitkCommandLineParser::String, "---", "---", us::Any(),true);
for (auto cFeature : features)
{
cFeature->AddArguments(parser);
}
parser.addArgument("--", "-", mitkCommandLineParser::String, "---", "---", us::Any(), true);
parser.addArgument("description","d",mitkCommandLineParser::String,"Text","Description that is added to the output",us::Any());
parser.addArgument("direction", "dir", mitkCommandLineParser::String, "Int", "Allows to specify the direction for Cooc and RL. 0: All directions, 1: Only single direction (Test purpose), 2,3,4... Without dimension 0,1,2... ", us::Any());
parser.addArgument("slice-wise", "slice", mitkCommandLineParser::String, "Int", "Allows to specify if the image is processed slice-wise (number giving direction) ", us::Any());
parser.addArgument("output-mode", "omode", mitkCommandLineParser::Int, "Int", "Defines the format of the output. 0: (Default) results of an image / slice are written in a single row;"
" 1: results of an image / slice are written in a single column; 2: store the result of on image as structured radiomocs report (XML).");
// Miniapp Infos
parser.setCategory("Classification Tools");
parser.setTitle("Global Image Feature calculator");
parser.setDescription("Calculates different global statistics for a given segmentation / image combination");
parser.setContributor("German Cancer Research Center (DKFZ)");
std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
param.ParseParameter(parsedArgs);
if (parsedArgs.size()==0)
{
return EXIT_FAILURE;
}
if ( parsedArgs.count("help") || parsedArgs.count("h"))
{
return EXIT_SUCCESS;
}
- //bool savePNGofSlices = true;
- //std::string folderForPNGOfSlices = "E:\\tmp\\bonekamp\\fig\\";
-
std::string version = "Version: 1.23";
MITK_INFO << version;
std::ofstream log;
if (param.useLogfile)
{
log.open(param.logfilePath, std::ios::app);
log << std::endl;
log << version;
log << "Image: " << param.imagePath;
log << "Mask: " << param.maskPath;
}
if (param.useDecimalPoint)
{
std::cout.imbue(std::locale(std::cout.getloc(), new punct_facet<char>(param.decimalPoint)));
}
//representing the original loaded image data without any prepropcessing that might come.
mitk::Image::Pointer loadedImage = mitk::IOUtil::Load<mitk::Image>(param.imagePath);
//representing the original loaded mask data without any prepropcessing that might come.
mitk::Image::Pointer loadedMask = mitk::IOUtil::Load<mitk::Image>(param.maskPath);
mitk::Image::Pointer image = loadedImage;
mitk::Image::Pointer mask = loadedMask;
mitk::Image::Pointer tmpImage = loadedImage;
mitk::Image::Pointer tmpMask = loadedMask;
mitk::Image::Pointer morphMask = mask;
if (param.useMorphMask)
{
morphMask = mitk::IOUtil::Load<mitk::Image>(param.morphPath);
}
log << " Check for Dimensions -";
if ((image->GetDimension() != mask->GetDimension()))
{
MITK_INFO << "Dimension of image does not match. ";
MITK_INFO << "Correct one image, may affect the result";
if (image->GetDimension() == 2)
{
mitk::Convert2Dto3DImageFilter::Pointer multiFilter2 = mitk::Convert2Dto3DImageFilter::New();
multiFilter2->SetInput(tmpImage);
multiFilter2->Update();
image = multiFilter2->GetOutput();
}
if (mask->GetDimension() == 2)
{
mitk::Convert2Dto3DImageFilter::Pointer multiFilter3 = mitk::Convert2Dto3DImageFilter::New();
multiFilter3->SetInput(tmpMask);
multiFilter3->Update();
mask = multiFilter3->GetOutput();
}
}
int writeDirection = 0;
if (parsedArgs.count("output-mode"))
{
writeDirection = us::any_cast<int>(parsedArgs["output-mode"]);
}
log << " Check for Resolution -";
if (param.resampleToFixIsotropic)
{
mitk::Image::Pointer newImage = mitk::Image::New();
AccessByItk_2(image, ResampleImage, param.resampleResolution, newImage);
image = newImage;
}
log << " Resample if required -";
if (param.resampleMask)
{
mitk::Image::Pointer newMaskImage = mitk::Image::New();
AccessByItk_2(mask, ResampleMask, image, newMaskImage);
mask = newMaskImage;
}
if ( ! mitk::Equal(mask->GetGeometry(0)->GetOrigin(), image->GetGeometry(0)->GetOrigin()))
{
MITK_INFO << "Not equal Origins";
if (param.ensureSameSpace)
{
MITK_INFO << "Warning!";
MITK_INFO << "The origin of the input image and the mask do not match. They are";
MITK_INFO << "now corrected. Please check to make sure that the images still match";
image->GetGeometry(0)->SetOrigin(mask->GetGeometry(0)->GetOrigin());
} else
{
return -1;
}
}
log << " Check for Equality -";
if ( ! mitk::Equal(mask->GetGeometry(0)->GetSpacing(), image->GetGeometry(0)->GetSpacing()))
{
MITK_INFO << "Not equal Spacing";
if (param.ensureSameSpace)
{
MITK_INFO << "Warning!";
MITK_INFO << "The spacing of the mask was set to match the spacing of the input image.";
MITK_INFO << "This might cause unintended spacing of the mask image";
image->GetGeometry(0)->SetSpacing(mask->GetGeometry(0)->GetSpacing());
} else
{
MITK_INFO << "The spacing of the mask and the input images is not equal.";
MITK_INFO << "Terminating the programm. You may use the '-fi' option";
return -1;
}
}
int direction = 0;
if (parsedArgs.count("direction"))
{
direction = mitk::cl::splitDouble(parsedArgs["direction"].ToString(), ';')[0];
}
MITK_INFO << "Start creating Mask without NaN";
mitk::Image::Pointer maskNoNaN = mitk::Image::New();
AccessByItk_2(image, CreateNoNaNMask, mask, maskNoNaN);
//CreateNoNaNMask(mask, image, maskNoNaN);
bool sliceWise = false;
int sliceDirection = 0;
unsigned int currentSlice = 0;
bool imageToProcess = true;
std::vector<mitk::Image::Pointer> floatVector;
std::vector<mitk::Image::Pointer> maskVector;
std::vector<mitk::Image::Pointer> maskNoNaNVector;
std::vector<mitk::Image::Pointer> morphMaskVector;
if ((parsedArgs.count("slice-wise")) && image->GetDimension() > 2)
{
MITK_INFO << "Enabled slice-wise";
sliceWise = true;
sliceDirection = mitk::cl::splitDouble(parsedArgs["slice-wise"].ToString(), ';')[0];
MITK_INFO << sliceDirection;
ExtractSlicesFromImages(image, mask, maskNoNaN, morphMask, sliceDirection, floatVector, maskVector, maskNoNaNVector, morphMaskVector);
MITK_INFO << "Slice";
}
log << " Configure features -";
for (auto cFeature : features)
{
if (param.defineGlobalMinimumIntensity)
{
cFeature->SetMinimumIntensity(param.globalMinimumIntensity);
cFeature->SetUseMinimumIntensity(true);
}
if (param.defineGlobalMaximumIntensity)
{
cFeature->SetMaximumIntensity(param.globalMaximumIntensity);
cFeature->SetUseMaximumIntensity(true);
}
if (param.defineGlobalNumberOfBins)
{
cFeature->SetBins(param.globalNumberOfBins);
MITK_INFO << param.globalNumberOfBins;
}
cFeature->SetParameters(parsedArgs);
cFeature->SetDirection(direction);
cFeature->SetEncodeParametersInFeaturePrefix(param.encodeParameter);
}
bool addDescription = parsedArgs.count("description");
mitk::cl::FeatureResultWriter writer(param.outputPath, writeDirection);
if (param.useDecimalPoint)
{
writer.SetDecimalPoint(param.decimalPoint);
}
std::string description = "";
if (addDescription)
{
description = parsedArgs["description"].ToString();
}
mitk::Image::Pointer cImage = image;
mitk::Image::Pointer cMask = mask;
mitk::Image::Pointer cMaskNoNaN = maskNoNaN;
mitk::Image::Pointer cMorphMask = morphMask;
if (param.useHeader)
{
writer.AddColumn("SoftwareVersion");
writer.AddColumn("Patient");
writer.AddColumn("Image");
writer.AddColumn("Segmentation");
}
// Create a QTApplication and a Datastorage
// This is necessary in order to save screenshots of
// each image / slice.
QApplication qtapplication(argc, argv);
QmitkRegisterClasses();
std::vector<mitk::AbstractGlobalImageFeature::FeatureListType> allStats;
log << " Begin Processing -";
while (imageToProcess)
{
if (sliceWise)
{
cImage = floatVector[currentSlice];
cMask = maskVector[currentSlice];
cMaskNoNaN = maskNoNaNVector[currentSlice];
cMorphMask = morphMaskVector[currentSlice];
imageToProcess = (floatVector.size()-1 > (currentSlice)) ? true : false ;
}
else
{
imageToProcess = false;
}
if (param.writePNGScreenshots)
{
SaveSliceOrImageAsPNG(cImage, cMask, param.pngScreenshotsPath, currentSlice);
}
if (param.writeAnalysisImage)
{
mitk::IOUtil::Save(cImage, param.anaylsisImagePath);
}
if (param.writeAnalysisMask)
{
mitk::IOUtil::Save(cMask, param.analysisMaskPath);
}
mitk::AbstractGlobalImageFeature::FeatureListType stats;
for (auto cFeature : features)
{
log << " Calculating " << cFeature->GetFeatureClassName() << " -";
cFeature->SetMorphMask(cMorphMask);
cFeature->CalculateAndAppendFeatures(cImage, cMask, cMaskNoNaN, stats, !param.calculateAllFeatures);
}
for (std::size_t i = 0; i < stats.size(); ++i)
{
std::cout << stats[i].first.legacyName << " - " << stats[i].second << std::endl;
}
writer.AddHeader(description, currentSlice, stats, param.useHeader, addDescription);
if (true)
{
writer.AddSubjectInformation(MITK_REVISION);
writer.AddSubjectInformation(param.imageFolder);
writer.AddSubjectInformation(param.imageName);
writer.AddSubjectInformation(param.maskName);
}
writer.AddResult(description, currentSlice, stats, param.useHeader, addDescription);
allStats.push_back(stats);
++currentSlice;
}
log << " Process Slicewise -";
if (sliceWise)
{
mitk::AbstractGlobalImageFeature::FeatureListType statMean, statStd;
for (std::size_t i = 0; i < allStats[0].size(); ++i)
{
auto cElement1 = allStats[0][i];
cElement1.first.legacyName = "SliceWise Mean " + cElement1.first.legacyName;
cElement1.second = 0.0;
auto cElement2 = allStats[0][i];
cElement2.first.legacyName = "SliceWise Var. " + cElement2.first.legacyName;
cElement2.second = 0.0;
statMean.push_back(cElement1);
statStd.push_back(cElement2);
}
for (auto cStat : allStats)
{
for (std::size_t i = 0; i < cStat.size(); ++i)
{
statMean[i].second += cStat[i].second / (1.0*allStats.size());
}
}
for (auto cStat : allStats)
{
for (std::size_t i = 0; i < cStat.size(); ++i)
{
statStd[i].second += (cStat[i].second - statMean[i].second)*(cStat[i].second - statMean[i].second) / (1.0*allStats.size());
}
}
for (std::size_t i = 0; i < statMean.size(); ++i)
{
std::cout << statMean[i].first.legacyName << " - " << statMean[i].second << std::endl;
std::cout << statStd[i].first.legacyName << " - " << statStd[i].second << std::endl;
}
if (true)
{
writer.AddSubjectInformation(MITK_REVISION);
writer.AddSubjectInformation(param.imageFolder);
writer.AddSubjectInformation(param.imageName);
writer.AddSubjectInformation(param.maskName + " - Mean");
}
writer.AddResult(description, currentSlice, statMean, param.useHeader, addDescription);
if (true)
{
writer.AddSubjectInformation(MITK_REVISION);
writer.AddSubjectInformation(param.imageFolder);
writer.AddSubjectInformation(param.imageName);
writer.AddSubjectInformation(param.maskName + " - Var.");
}
writer.AddResult(description, currentSlice, statStd, param.useHeader, addDescription);
}
int returnCode = EXIT_SUCCESS;
if (!param.outputXMLPath.empty())
{
if (sliceWise)
{
MITK_ERROR << "Xml output is not supported in slicewise mode";
returnCode = EXIT_FAILURE;
}
else
{
mitk::cl::CLResultXMLWriter xmlWriter;
xmlWriter.SetCLIArgs(parsedArgs);
xmlWriter.SetFeatures(allStats.front());
xmlWriter.SetImage(loadedImage);
xmlWriter.SetMask(loadedMask);
xmlWriter.SetMethodName("CLGlobalImageFeatures");
xmlWriter.SetMethodVersion(version + "(mitk: " MITK_VERSION_STRING+")");
xmlWriter.SetOrganisation("German Cancer Research Center (DKFZ)");
xmlWriter.SetPipelineUID(param.pipelineUID);
xmlWriter.write(param.outputXMLPath);
}
}
if (param.useLogfile)
{
log << "Finished calculation" << std::endl;
log.close();
}
return returnCode;
}
#endif
diff --git a/Modules/Classification/CLUtilities/test/mitkGIFCooc2Test.cpp b/Modules/Classification/CLUtilities/test/mitkGIFCooc2Test.cpp
index 5ea6e310af..feb9e30118 100644
--- a/Modules/Classification/CLUtilities/test/mitkGIFCooc2Test.cpp
+++ b/Modules/Classification/CLUtilities/test/mitkGIFCooc2Test.cpp
@@ -1,247 +1,247 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkTestingMacros.h>
#include <mitkTestFixture.h>
#include "mitkIOUtil.h"
#include <cmath>
#include <mitkGIFCooccurenceMatrix2.h>
class mitkGIFCooc2TestSuite : public mitk::TestFixture
{
CPPUNIT_TEST_SUITE(mitkGIFCooc2TestSuite);
MITK_TEST(ImageDescription_PhantomTest_3D);
MITK_TEST(ImageDescription_PhantomTest_2D);
CPPUNIT_TEST_SUITE_END();
private:
mitk::Image::Pointer m_IBSI_Phantom_Image_Small;
mitk::Image::Pointer m_IBSI_Phantom_Image_Large;
mitk::Image::Pointer m_IBSI_Phantom_Mask_Small;
mitk::Image::Pointer m_IBSI_Phantom_Mask_Large;
public:
void setUp(void) override
{
m_IBSI_Phantom_Image_Small = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Image_Small.nrrd"));
m_IBSI_Phantom_Image_Large = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Image_Large.nrrd"));
m_IBSI_Phantom_Mask_Small = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Mask_Small.nrrd"));
m_IBSI_Phantom_Mask_Large = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Mask_Large.nrrd"));
}
void ImageDescription_PhantomTest_3D()
{
mitk::GIFCooccurenceMatrix2::Pointer featureCalculator = mitk::GIFCooccurenceMatrix2::New();
featureCalculator->SetUseBinsize(true);
featureCalculator->SetBinsize(1.0);
featureCalculator->SetUseMinimumIntensity(true);
featureCalculator->SetUseMaximumIntensity(true);
featureCalculator->SetMinimumIntensity(0.5);
featureCalculator->SetMaximumIntensity(6.5);
auto featureList = featureCalculator->CalculateFeatures(m_IBSI_Phantom_Image_Large, m_IBSI_Phantom_Mask_Large);
std::map<std::string, double> results;
- for (auto valuePair : featureList)
+ for (const auto &valuePair : featureList)
{
MITK_INFO << mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first) << " : " << valuePair.second;
results[valuePair.first.featureClass + "::" + valuePair.first.name] = valuePair.second;
}
CPPUNIT_ASSERT_EQUAL_MESSAGE("Image Diagnostics should calculate 18 features.", std::size_t(93), featureList.size());
// These values are obtained with IBSI (3D Comb)
// Standard accuracy is 0.01
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall Joint Maximum with Large IBSI Phantom Image", 0.509, results["Co-occurenced Based Features::Overall Joint Maximum"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall Joint Average with Large IBSI Phantom Image", 2.149, results["Co-occurenced Based Features::Overall Joint Average"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall Joint Variance with Large IBSI Phantom Image", 3.132, results["Co-occurenced Based Features::Overall Joint Variance"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall Joint Entropy with Large IBSI Phantom Image", 2.574, results["Co-occurenced Based Features::Overall Joint Entropy"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall Difference Average with Large IBSI Phantom Image", 1.379, results["Co-occurenced Based Features::Overall Difference Average"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall Difference Variance with Large IBSI Phantom Image", 3.215, results["Co-occurenced Based Features::Overall Difference Variance"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall Difference Entropy with Large IBSI Phantom Image", 1.641, results["Co-occurenced Based Features::Overall Difference Entropy"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall Sum Average with Large IBSI Phantom Image", 4.298, results["Co-occurenced Based Features::Overall Sum Average"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall Sum Variance with Large IBSI Phantom Image", 7.412, results["Co-occurenced Based Features::Overall Sum Variance"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall Sum Entropy with Large IBSI Phantom Image", 2.110, results["Co-occurenced Based Features::Overall Sum Entropy"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall Angular Second Moment with Large IBSI Phantom Image", 0.291, results["Co-occurenced Based Features::Overall Angular Second Moment"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall Contrast with Large IBSI Phantom Image", 5.118, results["Co-occurenced Based Features::Overall Contrast"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall Dissimilarity with Large IBSI Phantom Image", 1.380, results["Co-occurenced Based Features::Overall Dissimilarity"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall Inverse Difference with Large IBSI Phantom Image", 0.688, results["Co-occurenced Based Features::Overall Inverse Difference"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall Inverse Difference Normalized with Large IBSI Phantom Image", 0.856, results["Co-occurenced Based Features::Overall Inverse Difference Normalized"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall Inverse Difference Moment with Large IBSI Phantom Image", 0.631, results["Co-occurenced Based Features::Overall Inverse Difference Moment"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall Inverse Difference Moment Normalized with Large IBSI Phantom Image", 0.902, results["Co-occurenced Based Features::Overall Inverse Difference Moment Normalized"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall Inverse Variance with Large IBSI Phantom Image", 0.057, results["Co-occurenced Based Features::Overall Inverse Variance"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall Correlation with Large IBSI Phantom Image", 0.183, results["Co-occurenced Based Features::Overall Correlation"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall Autocorrelation with Large IBSI Phantom Image", 5.192, results["Co-occurenced Based Features::Overall Autocorrelation"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall Cluster Tendency with Large IBSI Phantom Image", 7.412, results["Co-occurenced Based Features::Overall Cluster Tendency"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall Cluster Shade with Large IBSI Phantom Image", 17.419, results["Co-occurenced Based Features::Overall Cluster Shade"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall Cluster Prominence with Large IBSI Phantom Image", 147.464, results["Co-occurenced Based Features::Overall Cluster Prominence"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall First Measure of Information Correlation with Large IBSI Phantom Image", -0.0288, results["Co-occurenced Based Features::Overall First Measure of Information Correlation"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall Second Measure of Information Correlation with Large IBSI Phantom Image", 0.269, results["Co-occurenced Based Features::Overall Second Measure of Information Correlation"], 0.001);
// These values are obtained by manually running the tool
// Values might be wrong.
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall Row Maximum with Large IBSI Phantom Image", 0.679, results["Co-occurenced Based Features::Overall Row Maximum"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall Row Average with Large IBSI Phantom Image", 2.149, results["Co-occurenced Based Features::Overall Row Average"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall Row Variance with Large IBSI Phantom Image", 3.132, results["Co-occurenced Based Features::Overall Row Variance"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall Row Entropy with Large IBSI Phantom Image", 1.306, results["Co-occurenced Based Features::Overall Row Entropy"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall First Row-Column Entropy with Large IBSI Phantom Image", 2.611, results["Co-occurenced Based Features::Overall First Row-Column Entropy"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Overall Second Row-Column Entropy with Large IBSI Phantom Image", 2.611, results["Co-occurenced Based Features::Overall Second Row-Column Entropy"], 0.001);
// These values are obtained with IBSI (3D Avg)
// Standard accuracy is 0.01
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean Joint Maximum with Large IBSI Phantom Image", 0.503, results["Co-occurenced Based Features::Mean Joint Maximum"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean Joint Average with Large IBSI Phantom Image", 2.143, results["Co-occurenced Based Features::Mean Joint Average"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean Joint Variance with Large IBSI Phantom Image", 3.099, results["Co-occurenced Based Features::Mean Joint Variance"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean Joint Entropy with Large IBSI Phantom Image", 2.399, results["Co-occurenced Based Features::Mean Joint Entropy"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean Difference Average with Large IBSI Phantom Image", 1.431, results["Co-occurenced Based Features::Mean Difference Average"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean Difference Variance with Large IBSI Phantom Image", 3.056, results["Co-occurenced Based Features::Mean Difference Variance"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean Difference Entropy with Large IBSI Phantom Image", 1.563, results["Co-occurenced Based Features::Mean Difference Entropy"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean Sum Average with Large IBSI Phantom Image", 4.2859, results["Co-occurenced Based Features::Mean Sum Average"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean Sum Variance with Large IBSI Phantom Image", 7.072, results["Co-occurenced Based Features::Mean Sum Variance"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean Sum Entropy with Large IBSI Phantom Image", 1.9226, results["Co-occurenced Based Features::Mean Sum Entropy"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean Angular Second Moment with Large IBSI Phantom Image", 0.303, results["Co-occurenced Based Features::Mean Angular Second Moment"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean Contrast with Large IBSI Phantom Image", 5.3245, results["Co-occurenced Based Features::Mean Contrast"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean Dissimilarity with Large IBSI Phantom Image", 1.431, results["Co-occurenced Based Features::Mean Dissimilarity"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean Inverse Difference with Large IBSI Phantom Image", 0.6766, results["Co-occurenced Based Features::Mean Inverse Difference"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean Inverse Difference Normalized with Large IBSI Phantom Image", 0.8506, results["Co-occurenced Based Features::Mean Inverse Difference Normalized"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean Inverse Difference Moment with Large IBSI Phantom Image", 0.6177, results["Co-occurenced Based Features::Mean Inverse Difference Moment"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean Inverse Difference Moment Normalized with Large IBSI Phantom Image", 0.8984, results["Co-occurenced Based Features::Mean Inverse Difference Moment Normalized"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean Inverse Variance with Large IBSI Phantom Image", 0.0604, results["Co-occurenced Based Features::Mean Inverse Variance"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean Correlation with Large IBSI Phantom Image", 0.157, results["Co-occurenced Based Features::Mean Correlation"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean Autocorrelation with Large IBSI Phantom Image", 5.05544, results["Co-occurenced Based Features::Mean Autocorrelation"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean Cluster Tendency with Large IBSI Phantom Image", 7.0728, results["Co-occurenced Based Features::Mean Cluster Tendency"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean Cluster Shade with Large IBSI Phantom Image", 16.6441, results["Co-occurenced Based Features::Mean Cluster Shade"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean Cluster Prominence with Large IBSI Phantom Image", 144.703, results["Co-occurenced Based Features::Mean Cluster Prominence"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean First Measure of Information Correlation with Large IBSI Phantom Image", -0.15684, results["Co-occurenced Based Features::Mean First Measure of Information Correlation"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean Second Measure of Information Correlation with Large IBSI Phantom Image", 0.519588, results["Co-occurenced Based Features::Mean Second Measure of Information Correlation"], 0.001);
// These values are obtained by manually running the tool
// Values might be wrong.
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean Row Maximum with Large IBSI Phantom Image", 0.6808, results["Co-occurenced Based Features::Mean Row Maximum"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean Row Average with Large IBSI Phantom Image", 2.143, results["Co-occurenced Based Features::Mean Row Average"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean Row Variance with Large IBSI Phantom Image", 3.0993, results["Co-occurenced Based Features::Mean Row Variance"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean Row Entropy with Large IBSI Phantom Image", 1.29699, results["Co-occurenced Based Features::Mean Row Entropy"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean First Row-Column Entropy with Large IBSI Phantom Image", 2.5939, results["Co-occurenced Based Features::Mean First Row-Column Entropy"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Co-occurenced Based Features::Mean Second Row-Column Entropy with Large IBSI Phantom Image", 2.5939, results["Co-occurenced Based Features::Mean Second Row-Column Entropy"], 0.001);
}
void ImageDescription_PhantomTest_2D()
{
mitk::GIFCooccurenceMatrix2::Pointer featureCalculator = mitk::GIFCooccurenceMatrix2::New();
featureCalculator->SetUseBinsize(true);
featureCalculator->SetBinsize(1.0);
featureCalculator->SetUseMinimumIntensity(true);
featureCalculator->SetUseMaximumIntensity(true);
featureCalculator->SetMinimumIntensity(0.5);
featureCalculator->SetMaximumIntensity(6.5);
auto featureList = featureCalculator->CalculateFeaturesSlicewise(m_IBSI_Phantom_Image_Large, m_IBSI_Phantom_Mask_Large, 2);
std::map<std::string, double> results;
- for (auto valuePair : featureList)
+ for (const auto &valuePair : featureList)
{
MITK_INFO << mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first) << " : " << valuePair.second;
results[mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first)] = valuePair.second;
}
CPPUNIT_ASSERT_EQUAL_MESSAGE("Image Diagnostics should calculate 558 features.", std::size_t(558), featureList.size());
// These values are obtained with IBSI
// Standard accuracy is 0.01
// These values are obtained with IBSI (2D Comb)
// Standard accuracy is 0.01
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall Joint Maximum with Large IBSI Phantom Image", 0.512, results["SliceWise Mean Co-occurenced Based Features::Overall Joint Maximum"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall Joint Average with Large IBSI Phantom Image", 2.143, results["SliceWise Mean Co-occurenced Based Features::Overall Joint Average"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall Joint Variance with Large IBSI Phantom Image", 2.7115, results["SliceWise Mean Co-occurenced Based Features::Overall Joint Variance"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall Joint Entropy with Large IBSI Phantom Image", 2.2383, results["SliceWise Mean Co-occurenced Based Features::Overall Joint Entropy"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall Difference Average with Large IBSI Phantom Image", 1.3990, results["SliceWise Mean Co-occurenced Based Features::Overall Difference Average"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall Difference Variance with Large IBSI Phantom Image", 3.06426, results["SliceWise Mean Co-occurenced Based Features::Overall Difference Variance"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall Difference Entropy with Large IBSI Phantom Image", 1.49262, results["SliceWise Mean Co-occurenced Based Features::Overall Difference Entropy"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall Sum Average with Large IBSI Phantom Image", 4.28686, results["SliceWise Mean Co-occurenced Based Features::Overall Sum Average"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall Sum Variance with Large IBSI Phantom Image", 5.65615, results["SliceWise Mean Co-occurenced Based Features::Overall Sum Variance"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall Sum Entropy with Large IBSI Phantom Image", 1.79494, results["SliceWise Mean Co-occurenced Based Features::Overall Sum Entropy"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall Angular Second Moment with Large IBSI Phantom Image", 0.351678, results["SliceWise Mean Co-occurenced Based Features::Overall Angular Second Moment"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall Contrast with Large IBSI Phantom Image", 5.19019, results["SliceWise Mean Co-occurenced Based Features::Overall Contrast"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall Dissimilarity with Large IBSI Phantom Image", 1.3990, results["SliceWise Mean Co-occurenced Based Features::Overall Dissimilarity"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall Inverse Difference with Large IBSI Phantom Image", 0.683294, results["SliceWise Mean Co-occurenced Based Features::Overall Inverse Difference"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall Inverse Difference Normalized with Large IBSI Phantom Image", 0.8538, results["SliceWise Mean Co-occurenced Based Features::Overall Inverse Difference Normalized"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall Inverse Difference Moment with Large IBSI Phantom Image", 0.625003, results["SliceWise Mean Co-occurenced Based Features::Overall Inverse Difference Moment"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall Inverse Difference Moment Normalized with Large IBSI Phantom Image", 0.90088, results["SliceWise Mean Co-occurenced Based Features::Overall Inverse Difference Moment Normalized"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall Inverse Variance with Large IBSI Phantom Image", 0.055286, results["SliceWise Mean Co-occurenced Based Features::Overall Inverse Variance"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall Correlation with Large IBSI Phantom Image", 0.0173072, results["SliceWise Mean Co-occurenced Based Features::Overall Correlation"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall Autocorrelation with Large IBSI Phantom Image", 5.13953, results["SliceWise Mean Co-occurenced Based Features::Overall Autocorrelation"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall Cluster Tendency with Large IBSI Phantom Image", 5.6561, results["SliceWise Mean Co-occurenced Based Features::Overall Cluster Tendency"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall Cluster Shade with Large IBSI Phantom Image", 6.97661, results["SliceWise Mean Co-occurenced Based Features::Overall Cluster Shade"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall Cluster Prominence with Large IBSI Phantom Image", 80.3855, results["SliceWise Mean Co-occurenced Based Features::Overall Cluster Prominence"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall First Measure of Information Correlation with Large IBSI Phantom Image", -0.0340891, results["SliceWise Mean Co-occurenced Based Features::Overall First Measure of Information Correlation"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall Second Measure of Information Correlation with Large IBSI Phantom Image", 0.2625, results["SliceWise Mean Co-occurenced Based Features::Overall Second Measure of Information Correlation"], 0.001);
// These values are obtained by manually running the tool
// Values might be wrong.
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall Row Maximum with Large IBSI Phantom Image", 0.682689, results["SliceWise Mean Co-occurenced Based Features::Overall Row Maximum"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall Row Average with Large IBSI Phantom Image", 2.14343, results["SliceWise Mean Co-occurenced Based Features::Overall Row Average"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall Row Variance with Large IBSI Phantom Image", 2.71158, results["SliceWise Mean Co-occurenced Based Features::Overall Row Variance"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall Row Entropy with Large IBSI Phantom Image", 1.13773, results["SliceWise Mean Co-occurenced Based Features::Overall Row Entropy"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall First Row-Column Entropy with Large IBSI Phantom Image", 2.27545, results["SliceWise Mean Co-occurenced Based Features::Overall First Row-Column Entropy"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Overall Second Row-Column Entropy with Large IBSI Phantom Image", 2.27545, results["SliceWise Mean Co-occurenced Based Features::Overall Second Row-Column Entropy"], 0.001);
// These values are obtained with IBSI (2D Avg)
// Standard accuracy is 0.01
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean Joint Maximum with Large IBSI Phantom Image", 0.5188, results["SliceWise Mean Co-occurenced Based Features::Mean Joint Maximum"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean Joint Average with Large IBSI Phantom Image", 2.14242, results["SliceWise Mean Co-occurenced Based Features::Mean Joint Average"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean Joint Variance with Large IBSI Phantom Image", 2.6877, results["SliceWise Mean Co-occurenced Based Features::Mean Joint Variance"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean Joint Entropy with Large IBSI Phantom Image", 2.04966, results["SliceWise Mean Co-occurenced Based Features::Mean Joint Entropy"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean Difference Average with Large IBSI Phantom Image", 1.42247, results["SliceWise Mean Co-occurenced Based Features::Mean Difference Average"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean Difference Variance with Large IBSI Phantom Image", 2.90159, results["SliceWise Mean Co-occurenced Based Features::Mean Difference Variance"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean Difference Entropy with Large IBSI Phantom Image", 1.39615, results["SliceWise Mean Co-occurenced Based Features::Mean Difference Entropy"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean Sum Average with Large IBSI Phantom Image", 4.28484, results["SliceWise Mean Co-occurenced Based Features::Mean Sum Average"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean Sum Variance with Large IBSI Phantom Image", 5.47293, results["SliceWise Mean Co-occurenced Based Features::Mean Sum Variance"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean Sum Entropy with Large IBSI Phantom Image", 1.60319, results["SliceWise Mean Co-occurenced Based Features::Mean Sum Entropy"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean Angular Second Moment with Large IBSI Phantom Image", 0.367529, results["SliceWise Mean Co-occurenced Based Features::Mean Angular Second Moment"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean Contrast with Large IBSI Phantom Image", 5.27785, results["SliceWise Mean Co-occurenced Based Features::Mean Contrast"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean Dissimilarity with Large IBSI Phantom Image", 1.42247, results["SliceWise Mean Co-occurenced Based Features::Mean Dissimilarity"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean Inverse Difference with Large IBSI Phantom Image", 0.677949, results["SliceWise Mean Co-occurenced Based Features::Mean Inverse Difference"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean Inverse Difference Normalized with Large IBSI Phantom Image", 0.851399, results["SliceWise Mean Co-occurenced Based Features::Mean Inverse Difference Normalized"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean Inverse Difference Moment with Large IBSI Phantom Image", 0.618737, results["SliceWise Mean Co-occurenced Based Features::Mean Inverse Difference Moment"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean Inverse Difference Moment Normalized with Large IBSI Phantom Image", 0.899219, results["SliceWise Mean Co-occurenced Based Features::Mean Inverse Difference Moment Normalized"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean Inverse Variance with Large IBSI Phantom Image", 0.0566983, results["SliceWise Mean Co-occurenced Based Features::Mean Inverse Variance"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean Correlation with Large IBSI Phantom Image", -.012107, results["SliceWise Mean Co-occurenced Based Features::Mean Correlation"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean Autocorrelation with Large IBSI Phantom Image", 5.09437, results["SliceWise Mean Co-occurenced Based Features::Mean Autocorrelation"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean Cluster Tendency with Large IBSI Phantom Image", 5.47293, results["SliceWise Mean Co-occurenced Based Features::Mean Cluster Tendency"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean Cluster Shade with Large IBSI Phantom Image", 6.99782, results["SliceWise Mean Co-occurenced Based Features::Mean Cluster Shade"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean Cluster Prominence with Large IBSI Phantom Image", 79.1126, results["SliceWise Mean Co-occurenced Based Features::Mean Cluster Prominence"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean First Measure of Information Correlation with Large IBSI Phantom Image", -0.15512, results["SliceWise Mean Co-occurenced Based Features::Mean First Measure of Information Correlation"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean Second Measure of Information Correlation with Large IBSI Phantom Image", 0.487457, results["SliceWise Mean Co-occurenced Based Features::Mean Second Measure of Information Correlation"], 0.001);
// These values are obtained by manually running the tool
// Values might be wrong.
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean Row Maximum with Large IBSI Phantom Image", 0.689717, results["SliceWise Mean Co-occurenced Based Features::Mean Row Maximum"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean Row Average with Large IBSI Phantom Image", 2.14242, results["SliceWise Mean Co-occurenced Based Features::Mean Row Average"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean Row Variance with Large IBSI Phantom Image", 2.6877, results["SliceWise Mean Co-occurenced Based Features::Mean Row Variance"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean Row Entropy with Large IBSI Phantom Image", 1.1238, results["SliceWise Mean Co-occurenced Based Features::Mean Row Entropy"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean First Row-Column Entropy with Large IBSI Phantom Image", 2.24761, results["SliceWise Mean Co-occurenced Based Features::Mean First Row-Column Entropy"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Co-occurenced Based Features::Mean Second Row-Column Entropy with Large IBSI Phantom Image", 2.24761, results["SliceWise Mean Co-occurenced Based Features::Mean Second Row-Column Entropy"], 0.001);
}
};
MITK_TEST_SUITE_REGISTRATION(mitkGIFCooc2 )
diff --git a/Modules/Classification/CLUtilities/test/mitkGIFCurvatureStatisticTest.cpp b/Modules/Classification/CLUtilities/test/mitkGIFCurvatureStatisticTest.cpp
index 77591dcee2..d56d087a0d 100644
--- a/Modules/Classification/CLUtilities/test/mitkGIFCurvatureStatisticTest.cpp
+++ b/Modules/Classification/CLUtilities/test/mitkGIFCurvatureStatisticTest.cpp
@@ -1,118 +1,118 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkTestingMacros.h>
#include <mitkTestFixture.h>
#include "mitkIOUtil.h"
#include <cmath>
#include <mitkGIFCurvatureStatistic.h>
class mitkGIFCurvatureStatisticTestSuite : public mitk::TestFixture
{
CPPUNIT_TEST_SUITE(mitkGIFCurvatureStatisticTestSuite);
MITK_TEST(ImageDescription_PhantomTest);
CPPUNIT_TEST_SUITE_END();
private:
mitk::Image::Pointer m_IBSI_Phantom_Image_Small;
mitk::Image::Pointer m_IBSI_Phantom_Image_Large;
mitk::Image::Pointer m_IBSI_Phantom_Mask_Small;
mitk::Image::Pointer m_IBSI_Phantom_Mask_Large;
public:
void setUp(void) override
{
m_IBSI_Phantom_Image_Small = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Image_Small.nrrd"));
m_IBSI_Phantom_Image_Large = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Image_Large.nrrd"));
m_IBSI_Phantom_Mask_Small = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Mask_Small.nrrd"));
m_IBSI_Phantom_Mask_Large = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Mask_Large.nrrd"));
}
void ImageDescription_PhantomTest()
{
mitk::GIFCurvatureStatistic::Pointer featureCalculator = mitk::GIFCurvatureStatistic::New();
featureCalculator->SetUseBinsize(true);
featureCalculator->SetBinsize(1.0);
featureCalculator->SetUseMinimumIntensity(true);
featureCalculator->SetUseMaximumIntensity(true);
featureCalculator->SetMinimumIntensity(0.5);
featureCalculator->SetMaximumIntensity(6.5);
auto featureList = featureCalculator->CalculateFeatures(m_IBSI_Phantom_Image_Large, m_IBSI_Phantom_Mask_Large);
std::map<std::string, double> results;
- for (auto valuePair : featureList)
+ for (const auto &valuePair : featureList)
{
MITK_INFO << mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first) << " : " << valuePair.second;
results[mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first)] = valuePair.second;
}
CPPUNIT_ASSERT_EQUAL_MESSAGE("Image Diagnostics should calculate 44 features.", std::size_t(44), featureList.size());
// These values are obtained by a run of the filter.
// The might be wrong!
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Minimum Mean Curvature with Large IBSI Phantom Image", -1.51, results["Curvature Feature::Minimum Mean Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Maximum Mean Curvature with Large IBSI Phantom Image", 0.51, results["Curvature Feature::Maximum Mean Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Mean Mean Curvature with Large IBSI Phantom Image", 0.095, results["Curvature Feature::Mean Mean Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Standard Deviation Mean Curvature with Large IBSI Phantom Image", 0.45, results["Curvature Feature::Standard Deviation Mean Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Skewness Mean Curvature with Large IBSI Phantom Image", -2.55, results["Curvature Feature::Skewness Mean Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Mean Positive Mean Curvature with Large IBSI Phantom Image", 0.30, results["Curvature Feature::Mean Positive Mean Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Standard Deviation Positive Mean Curvature with Large IBSI Phantom Image", 0.12, results["Curvature Feature::Standard Deviation Positive Mean Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Skewness Positive Mean Curvature with Large IBSI Phantom Image", 0.60, results["Curvature Feature::Skewness Positive Mean Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Mean Negative Mean Curvature with Large IBSI Phantom Image", -0.955, results["Curvature Feature::Mean Negative Mean Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Standard Deviation Negative Mean Curvature with Large IBSI Phantom Image", 0.56, results["Curvature Feature::Standard Deviation Negative Mean Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Skewness Negative Mean Curvature with Large IBSI Phantom Image", 0.09, results["Curvature Feature::Skewness Negative Mean Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Minimum Gaussian Curvature with Large IBSI Phantom Image", -0.211, results["Curvature Feature::Minimum Gaussian Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Maximum Gaussian Curvature with Large IBSI Phantom Image", 1.81, results["Curvature Feature::Maximum Gaussian Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Mean Gaussian Curvature with Large IBSI Phantom Image", 0.14, results["Curvature Feature::Mean Gaussian Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Standard Deviation Gaussian Curvature with Large IBSI Phantom Image", 0.42, results["Curvature Feature::Standard Deviation Gaussian Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Skewness Gaussian Curvature with Large IBSI Phantom Image", 3.51, results["Curvature Feature::Skewness Gaussian Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Mean Positive Gaussian Curvature with Large IBSI Phantom Image", 0.26, results["Curvature Feature::Mean Positive Gaussian Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Standard Deviation Positive Gaussian Curvature with Large IBSI Phantom Image", 0.53, results["Curvature Feature::Standard Deviation Positive Gaussian Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Skewness Positive Gaussian Curvature with Large IBSI Phantom Image", 2.52, results["Curvature Feature::Skewness Positive Gaussian Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Mean Negative Gaussian Curvature with Large IBSI Phantom Image", -0.03, results["Curvature Feature::Mean Negative Gaussian Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Standard Deviation Negative Gaussian Curvature with Large IBSI Phantom Image", 0.055, results["Curvature Feature::Standard Deviation Negative Gaussian Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Skewness Negative Gaussian Curvature with Large IBSI Phantom Image", -1.92, results["Curvature Feature::Skewness Negative Gaussian Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Minimum Minimum Curvature with Large IBSI Phantom Image", -2.19, results["Curvature Feature::Minimum Minimum Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Maximum Minimum Curvature with Large IBSI Phantom Image", 0.35, results["Curvature Feature::Maximum Minimum Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Mean Minimum Curvature with Large IBSI Phantom Image", -0.11, results["Curvature Feature::Mean Minimum Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Standard Deviation Minimum Curvature with Large IBSI Phantom Image", 0.573, results["Curvature Feature::Standard Deviation Minimum Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Skewness Minimum Curvature with Large IBSI Phantom Image", -2.742, results["Curvature Feature::Skewness Minimum Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Mean Positive Minimum Curvature with Large IBSI Phantom Image", 0.161, results["Curvature Feature::Mean Positive Minimum Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Standard Deviation Positive Minimum Curvature with Large IBSI Phantom Image", 0.165, results["Curvature Feature::Standard Deviation Positive Minimum Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Skewness Positive Minimum Curvature with Large IBSI Phantom Image", 0.108, results["Curvature Feature::Skewness Positive Minimum Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Mean Negative Minimum Curvature with Large IBSI Phantom Image", -0.42, results["Curvature Feature::Mean Negative Minimum Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Standard Deviation Negative Minimum Curvature with Large IBSI Phantom Image", 0.733, results["Curvature Feature::Standard Deviation Negative Minimum Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Skewness Negative Minimum Curvature with Large IBSI Phantom Image", -1.73, results["Curvature Feature::Skewness Negative Minimum Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Minimum Maximum Curvature with Large IBSI Phantom Image", -0.83, results["Curvature Feature::Minimum Maximum Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Maximum Maximum Curvature with Large IBSI Phantom Image", 0.79, results["Curvature Feature::Maximum Maximum Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Mean Maximum Curvature with Large IBSI Phantom Image", 0.30, results["Curvature Feature::Mean Maximum Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Standard Deviation Maximum Curvature with Large IBSI Phantom Image", 0.369, results["Curvature Feature::Standard Deviation Maximum Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Skewness Maximum Curvature with Large IBSI Phantom Image", -1.617, results["Curvature Feature::Skewness Maximum Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Mean Positive Maximum Curvature with Large IBSI Phantom Image", 0.419, results["Curvature Feature::Mean Positive Maximum Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Standard Deviation Positive Maximum Curvature with Large IBSI Phantom Image", 0.217, results["Curvature Feature::Standard Deviation Positive Maximum Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Skewness Positive Maximum Curvature with Large IBSI Phantom Image", -0.958, results["Curvature Feature::Skewness Positive Maximum Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Mean Negative Maximum Curvature with Large IBSI Phantom Image", -0.44, results["Curvature Feature::Mean Negative Maximum Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Standard Deviation Negative Maximum Curvature with Large IBSI Phantom Image", 0.399, results["Curvature Feature::Standard Deviation Negative Maximum Curvature"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Curvature Feature::Skewness Negative Maximum Curvature with Large IBSI Phantom Image", 0.109, results["Curvature Feature::Skewness Negative Maximum Curvature"], 0.01);
}
};
MITK_TEST_SUITE_REGISTRATION(mitkGIFCurvatureStatistic )
diff --git a/Modules/Classification/CLUtilities/test/mitkGIFFirstOrderHistogramStatisticsTest.cpp b/Modules/Classification/CLUtilities/test/mitkGIFFirstOrderHistogramStatisticsTest.cpp
index 92a79b47c9..33ff00e6cb 100644
--- a/Modules/Classification/CLUtilities/test/mitkGIFFirstOrderHistogramStatisticsTest.cpp
+++ b/Modules/Classification/CLUtilities/test/mitkGIFFirstOrderHistogramStatisticsTest.cpp
@@ -1,123 +1,123 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkTestingMacros.h>
#include <mitkTestFixture.h>
#include "mitkIOUtil.h"
#include <cmath>
#include <mitkGIFFirstOrderHistogramStatistics.h>
class mitkGIFFirstOrderHistogramStatisticsTestSuite : public mitk::TestFixture
{
CPPUNIT_TEST_SUITE(mitkGIFFirstOrderHistogramStatisticsTestSuite);
MITK_TEST(ImageDescription_PhantomTest);
CPPUNIT_TEST_SUITE_END();
private:
mitk::Image::Pointer m_IBSI_Phantom_Image_Small;
mitk::Image::Pointer m_IBSI_Phantom_Image_Large;
mitk::Image::Pointer m_IBSI_Phantom_Mask_Small;
mitk::Image::Pointer m_IBSI_Phantom_Mask_Large;
public:
void setUp(void) override
{
m_IBSI_Phantom_Image_Small = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Image_Small.nrrd"));
m_IBSI_Phantom_Image_Large = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Image_Large.nrrd"));
m_IBSI_Phantom_Mask_Small = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Mask_Small.nrrd"));
m_IBSI_Phantom_Mask_Large = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Mask_Large.nrrd"));
}
void ImageDescription_PhantomTest()
{
mitk::GIFFirstOrderHistogramStatistics::Pointer featureCalculator = mitk::GIFFirstOrderHistogramStatistics::New();
featureCalculator->SetUseBinsize(true);
featureCalculator->SetBinsize(1.0);
featureCalculator->SetUseMinimumIntensity(true);
featureCalculator->SetUseMaximumIntensity(true);
featureCalculator->SetMinimumIntensity(0.5);
featureCalculator->SetMaximumIntensity(6.5);
auto featureList = featureCalculator->CalculateFeatures(m_IBSI_Phantom_Image_Large, m_IBSI_Phantom_Mask_Large);
std::map<std::string, double> results;
- for (auto valuePair : featureList)
+ for (const auto &valuePair : featureList)
{
MITK_INFO << mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first) << " : " << valuePair.second;
results[mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first)] = valuePair.second;
}
CPPUNIT_ASSERT_EQUAL_MESSAGE("Image Diagnostics should calculate 46 features.", std::size_t(46), featureList.size());
// These values are obtained by a run of the filter.
// The might be wrong!
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Mean Value should be 2.15 with Large IBSI Phantom Image", 2.15, results["First Order Histogram::Mean Value"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Variance Value should be 3.05 with Large IBSI Phantom Image", 3.05, results["First Order Histogram::Variance Value"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Skewness Value should be 1.08 with Large IBSI Phantom Image", 1.08, results["First Order Histogram::Skewness Value"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Excess Kurtosis Value should be -0.355 with Large IBSI Phantom Image", -0.355, results["First Order Histogram::Excess Kurtosis Value"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Median Value should be 1 with Large IBSI Phantom Image", 1.0, results["First Order Histogram::Median Value"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Minimum Value should be 1 with Large IBSI Phantom Image", 1, results["First Order Histogram::Minimum Value"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Percentile 10 Value should be 0.648 with Large IBSI Phantom Image", 0.648, results["First Order Histogram::Percentile 10 Value"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Percentile 90 Value should be 4.475 with Large IBSI Phantom Image", 4.475, results["First Order Histogram::Percentile 90 Value"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Maximum Value should be 6 with Large IBSI Phantom Image", 6, results["First Order Histogram::Maximum Value"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Mode Value should be 1 with Large IBSI Phantom Image", 1, results["First Order Histogram::Mode Value"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Interquantile Range Value should be 2.9 with Large IBSI Phantom Image", 2.911, results["First Order Histogram::Interquantile Range Value"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Range Value should be 5 with Large IBSI Phantom Image", 5, results["First Order Histogram::Range Value"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Mean Absolute Deviation Value should be 1.55 with Large IBSI Phantom Image", 1.55, results["First Order Histogram::Mean Absolute Deviation Value"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Robust Mean Absolute Deviation Value should be 1.11 with Large IBSI Phantom Image", 1.11, results["First Order Histogram::Robust Mean Absolute Deviation Value"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Median Absolute Deviation Value should be 1.14 with Large IBSI Phantom Image", 1.14, results["First Order Histogram::Median Absolute Deviation Value"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Coefficient of Variation Value should be 0.812 with Large IBSI Phantom Image", 0.812, results["First Order Histogram::Coefficient of Variation Value"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Quantile coefficient of Dispersion Value should be 0.626 with Large IBSI Phantom Image", 0.626, results["First Order Histogram::Quantile coefficient of Dispersion Value"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Entropy Value should be 1.27 with Large IBSI Phantom Image", 1.27, results["First Order Histogram::Entropy Value"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Uniformity Value should be 0.512 with Large IBSI Phantom Image", 0.512, results["First Order Histogram::Uniformity Value"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Robust Mean Index should be 0.746 with Large IBSI Phantom Image", 0.746, results["First Order Histogram::Robust Mean Index"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Robust Mean Value should be 1.746 with Large IBSI Phantom Image", 1.746, results["First Order Histogram::Robust Mean Value"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Number of Bins should be 6", 6, results["First Order Histogram::Number of Bins"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Bin Size should be 1", 1, results["First Order Histogram::Bin Size"], 0.01);
// These values are taken from the IBSI Initiative to ensure compatibility
// The values are given with an accuracy of 0.01
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Mean Index should be 2.15 with Large IBSI Phantom Image", 2.15, results["First Order Histogram::Mean Index"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Variance Index should be 3.05 with Large IBSI Phantom Image", 3.05, results["First Order Histogram::Variance Index"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Skewness Index should be 1.08 with Large IBSI Phantom Image", 1.08, results["First Order Histogram::Skewness Index"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Excess Kurtosis Index should be -0.355 with Large IBSI Phantom Image", -0.355, results["First Order Histogram::Excess Kurtosis Index"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Median Index should be 1 with Large IBSI Phantom Image", 1.0, results["First Order Histogram::Median Index"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Minimum Index should be 1 with Large IBSI Phantom Image", 1, results["First Order Histogram::Minimum Index"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Percentile 10 Index should be 1 with Large IBSI Phantom Image", 1, results["First Order Histogram::Percentile 10 Index"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Percentile 90 Index should be 2.15 with Large IBSI Phantom Image", 4, results["First Order Histogram::Percentile 90 Index"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Maximum Index should be 6 with Large IBSI Phantom Image", 6, results["First Order Histogram::Maximum Index"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Mode Index should be 1 with Large IBSI Phantom Image", 1, results["First Order Histogram::Mode Index"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Interquantile Range Index should be 3 with Large IBSI Phantom Image", 3, results["First Order Histogram::Interquantile Range Index"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Range Index should be 5 with Large IBSI Phantom Image", 5, results["First Order Histogram::Range Index"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Mean Absolute Deviation Index should be 3 with Large IBSI Phantom Image", 1.55, results["First Order Histogram::Mean Absolute Deviation Index"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Robust Mean Absolute Deviation Index should be 1.11 with Large IBSI Phantom Image", 1.11, results["First Order Histogram::Robust Mean Absolute Deviation Index"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Median Absolute Deviation Index should be 1.14 with Large IBSI Phantom Image", 1.14, results["First Order Histogram::Median Absolute Deviation Index"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Coefficient of Variation Index should be 0.812 with Large IBSI Phantom Image", 0.812, results["First Order Histogram::Coefficient of Variation Index"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Quantile coefficient of Dispersion Index should be 0.6 with Large IBSI Phantom Image", 0.6, results["First Order Histogram::Quantile coefficient of Dispersion Index"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Entropy Index should be 1.27 with Large IBSI Phantom Image", 1.27, results["First Order Histogram::Entropy Index"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Uniformity Index should be 0.512 with Large IBSI Phantom Image", 0.512, results["First Order Histogram::Uniformity Index"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Maximum Gradient should be 8 with Large IBSI Phantom Image", 8, results["First Order Histogram::Maximum Gradient"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Maximum Gradient Index should be 3 with Large IBSI Phantom Image", 3, results["First Order Histogram::Maximum Gradient Index"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Minimum Gradient should be -50 with Large IBSI Phantom Image", -50, results["First Order Histogram::Minimum Gradient"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Histogram::Minimum Gradient Index should be 3 with Large IBSI Phantom Image", 1, results["First Order Histogram::Minimum Gradient Index"], 0.01);
}
};
MITK_TEST_SUITE_REGISTRATION(mitkGIFFirstOrderHistogramStatistics )
diff --git a/Modules/Classification/CLUtilities/test/mitkGIFFirstOrderNumericStatisticsTest.cpp b/Modules/Classification/CLUtilities/test/mitkGIFFirstOrderNumericStatisticsTest.cpp
index b6c31c2ee1..6a6f51ef36 100644
--- a/Modules/Classification/CLUtilities/test/mitkGIFFirstOrderNumericStatisticsTest.cpp
+++ b/Modules/Classification/CLUtilities/test/mitkGIFFirstOrderNumericStatisticsTest.cpp
@@ -1,109 +1,109 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkTestingMacros.h>
#include <mitkTestFixture.h>
#include "mitkIOUtil.h"
#include <cmath>
#include <mitkGIFFirstOrderNumericStatistics.h>
class mitkGIFFirstOrderNumericStatisticsTestSuite : public mitk::TestFixture
{
CPPUNIT_TEST_SUITE(mitkGIFFirstOrderNumericStatisticsTestSuite);
MITK_TEST(ImageDescription_PhantomTest);
CPPUNIT_TEST_SUITE_END();
private:
mitk::Image::Pointer m_IBSI_Phantom_Image_Small;
mitk::Image::Pointer m_IBSI_Phantom_Image_Large;
mitk::Image::Pointer m_IBSI_Phantom_Mask_Small;
mitk::Image::Pointer m_IBSI_Phantom_Mask_Large;
public:
void setUp(void) override
{
m_IBSI_Phantom_Image_Small = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Image_Small.nrrd"));
m_IBSI_Phantom_Image_Large = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Image_Large.nrrd"));
m_IBSI_Phantom_Mask_Small = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Mask_Small.nrrd"));
m_IBSI_Phantom_Mask_Large = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Mask_Large.nrrd"));
}
void ImageDescription_PhantomTest()
{
mitk::GIFFirstOrderNumericStatistics::Pointer featureCalculator = mitk::GIFFirstOrderNumericStatistics::New();
featureCalculator->SetUseBinsize(true);
featureCalculator->SetBinsize(1.0);
featureCalculator->SetUseMinimumIntensity(true);
featureCalculator->SetUseMaximumIntensity(true);
featureCalculator->SetMinimumIntensity(0.5);
featureCalculator->SetMaximumIntensity(6.5);
auto featureList = featureCalculator->CalculateFeatures(m_IBSI_Phantom_Image_Large, m_IBSI_Phantom_Mask_Large);
std::map<std::string, double> results;
- for (auto valuePair : featureList)
+ for (const auto &valuePair : featureList)
{
MITK_INFO << mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first) << " : " << valuePair.second;
results[mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first)] = valuePair.second;
}
CPPUNIT_ASSERT_EQUAL_MESSAGE("Image Diagnostics should calculate 50 features.", std::size_t(50), featureList.size());
// These values are obtained by a run of the filter.
// The might be wrong!
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Mean with Large IBSI Phantom Image", 2.15, results["First Order Numeric::Mean"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Variance with Large IBSI Phantom Image", 3.05, results["First Order Numeric::Variance"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Skewness with Large IBSI Phantom Image", 1.08, results["First Order Numeric::Skewness"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Excess kurtosis with Large IBSI Phantom Image", -0.355, results["First Order Numeric::Excess kurtosis"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Median with Large IBSI Phantom Image", 1, results["First Order Numeric::Median"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Minimum with Large IBSI Phantom Image", 1, results["First Order Numeric::Minimum"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::10th Percentile with Large IBSI Phantom Image", 1, results["First Order Numeric::10th Percentile"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::90th Percentile with Large IBSI Phantom Image", 4, results["First Order Numeric::90th Percentile"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Maximum with Large IBSI Phantom Image", 6, results["First Order Numeric::Maximum"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Interquantile range with Large IBSI Phantom Image", 3, results["First Order Numeric::Interquantile range"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Range with Large IBSI Phantom Image", 5, results["First Order Numeric::Range"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Mean absolute deviation with Large IBSI Phantom Image", 1.55, results["First Order Numeric::Mean absolute deviation"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Robust mean absolute deviation with Large IBSI Phantom Image", 1.11, results["First Order Numeric::Robust mean absolute deviation"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Median absolute deviation with Large IBSI Phantom Image", 1.15, results["First Order Numeric::Median absolute deviation"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Coefficient of variation with Large IBSI Phantom Image", 0.812, results["First Order Numeric::Coefficient of variation"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Quantile coefficient of dispersion with Large IBSI Phantom Image", 0.6, results["First Order Numeric::Quantile coefficient of dispersion"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Energy with Large IBSI Phantom Image", 567, results["First Order Numeric::Energy"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Root mean square with Large IBSI Phantom Image", 2.77, results["First Order Numeric::Root mean square"], 0.01);
// These values are taken from the IBSI Initiative to ensure compatibility
// The values are given with an accuracy of 0.01
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Standard Deviation with Large IBSI Phantom Image", 1.74513, results["First Order Numeric::Standard Deviation"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Kurtosis with Large IBSI Phantom Image", 2.64538, results["First Order Numeric::Kurtosis"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Robust mean with Large IBSI Phantom Image", 1.74627, results["First Order Numeric::Robust mean"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Robust variance with Large IBSI Phantom Image", 1.65204, results["First Order Numeric::Robust variance"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Covered image intensity range with Large IBSI Phantom Image", 0.83333, results["First Order Numeric::Covered image intensity range"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Mode index with Large IBSI Phantom Image",0 , results["First Order Numeric::Mode index"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Mode value with Large IBSI Phantom Image", 1, results["First Order Numeric::Mode value"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Mode probability with Large IBSI Phantom Image", 0.675676, results["First Order Numeric::Mode probability"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Entropy with Large IBSI Phantom Image", -1.26561, results["First Order Numeric::Entropy"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Uniformtiy with Large IBSI Phantom Image", 0.512418, results["First Order Numeric::Uniformtiy"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Number of voxels with Large IBSI Phantom Image", 74 , results["First Order Numeric::Number of voxels"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Sum of voxels with Large IBSI Phantom Image", 159, results["First Order Numeric::Sum of voxels"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Voxel space with Large IBSI Phantom Image", 8, results["First Order Numeric::Voxel space"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Voxel volume with Large IBSI Phantom Image", 8, results["First Order Numeric::Voxel volume"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order Numeric::Image Dimension with Large IBSI Phantom Image", 3, results["First Order Numeric::Image Dimension"], 0.01);
}
};
MITK_TEST_SUITE_REGISTRATION(mitkGIFFirstOrderNumericStatistics )
diff --git a/Modules/Classification/CLUtilities/test/mitkGIFFirstOrderStatisticsTest.cpp b/Modules/Classification/CLUtilities/test/mitkGIFFirstOrderStatisticsTest.cpp
index c6683a7255..af41a4c4cd 100644
--- a/Modules/Classification/CLUtilities/test/mitkGIFFirstOrderStatisticsTest.cpp
+++ b/Modules/Classification/CLUtilities/test/mitkGIFFirstOrderStatisticsTest.cpp
@@ -1,108 +1,108 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkTestingMacros.h>
#include <mitkTestFixture.h>
#include "mitkIOUtil.h"
#include <cmath>
#include <mitkGIFFirstOrderStatistics.h>
class mitkGIFFirstOrderStatisticsTestSuite : public mitk::TestFixture
{
CPPUNIT_TEST_SUITE(mitkGIFFirstOrderStatisticsTestSuite);
MITK_TEST(ImageDescription_PhantomTest);
CPPUNIT_TEST_SUITE_END();
private:
mitk::Image::Pointer m_IBSI_Phantom_Image_Small;
mitk::Image::Pointer m_IBSI_Phantom_Image_Large;
mitk::Image::Pointer m_IBSI_Phantom_Mask_Small;
mitk::Image::Pointer m_IBSI_Phantom_Mask_Large;
public:
void setUp(void) override
{
m_IBSI_Phantom_Image_Small = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Image_Small.nrrd"));
m_IBSI_Phantom_Image_Large = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Image_Large.nrrd"));
m_IBSI_Phantom_Mask_Small = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Mask_Small.nrrd"));
m_IBSI_Phantom_Mask_Large = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Mask_Large.nrrd"));
}
void ImageDescription_PhantomTest()
{
mitk::GIFFirstOrderStatistics::Pointer featureCalculator = mitk::GIFFirstOrderStatistics::New();
featureCalculator->SetUseBinsize(true);
featureCalculator->SetBinsize(1);
featureCalculator->SetUseMinimumIntensity(true);
featureCalculator->SetUseMaximumIntensity(true);
featureCalculator->SetMinimumIntensity(0.5);
featureCalculator->SetMaximumIntensity(6.5);
auto featureList = featureCalculator->CalculateFeatures(m_IBSI_Phantom_Image_Large, m_IBSI_Phantom_Mask_Large);
std::map<std::string, double> results;
- for (auto valuePair : featureList)
+ for (const auto &valuePair : featureList)
{
MITK_INFO << mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first) << " : " << valuePair.second;
results[mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first)] = valuePair.second;
}
CPPUNIT_ASSERT_EQUAL_MESSAGE("Image Diagnostics should calculate 50 features.", std::size_t(50), featureList.size());
// These values are obtained by a run of the filter.
// The might be wrong!
// These values are taken from the IBSI Initiative to ensure compatibility
// The values are given with an accuracy of 0.01
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Mean with Large IBSI Phantom Image", 2.15, results["First Order::Mean"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Unbiased Variance with Large IBSI Phantom Image", 3.09, results["First Order::Unbiased Variance"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Biased Variance with Large IBSI Phantom Image", 3.05, results["First Order::Biased Variance"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Skewness with Large IBSI Phantom Image", 1.08, results["First Order::Skewness"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Kurtosis with Large IBSI Phantom Image", 2.65, results["First Order::Kurtosis"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Median with Large IBSI Phantom Image", 1, results["First Order::Median"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Minimum with Large IBSI Phantom Image", 1, results["First Order::Minimum"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Maximum with Large IBSI Phantom Image", 6, results["First Order::Maximum"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Range with Large IBSI Phantom Image", 5, results["First Order::Range"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Mean Absolute Deviation with Large IBSI Phantom Image", 1.55, results["First Order::Mean Absolute Deviation"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Robust Mean Absolute Deviation with Large IBSI Phantom Image", 1.11, results["First Order::Robust Mean Absolute Deviation"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Median Absolute Deviation with Large IBSI Phantom Image", 1.15, results["First Order::Median Absolute Deviation"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Coefficient of variation with Large IBSI Phantom Image", 0.812, results["First Order::Coefficient Of Variation"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Quantile coefficient of dispersion with Large IBSI Phantom Image", 0.625, results["First Order::Quantile Coefficient Of Dispersion"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Energy with Large IBSI Phantom Image", 567, results["First Order::Energy"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Root mean square with Large IBSI Phantom Image", 2.77, results["First Order::Root Mean Square"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Entropy with Large IBSI Phantom Image", 1.26561, results["First Order::Entropy"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Excess Kurtosis with Large IBSI Phantom Image", -0.35462, results["First Order::Excess Kurtosis"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Covered image intensity range with Large IBSI Phantom Image", 0.5555555, results["First Order::Covered Image Intensity Range"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Sum of voxels with Large IBSI Phantom Image", 159, results["First Order::Sum"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Mode with Large IBSI Phantom Image", 1, results["First Order::Mode"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Mode Probability with Large IBSI Phantom Image", 50, results["First Order::Mode Probability"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Unbiased Standard deviation with Large IBSI Phantom Image", 1.757, results["First Order::Unbiased Standard deviation"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Biased Standard deviation with Large IBSI Phantom Image", 1.74627, results["First Order::Biased Standard deviation"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Robust mean with Large IBSI Phantom Image", 1.74627, results["First Order::Robust Mean"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Number Of Voxels with Large IBSI Phantom Image", 74, results["First Order::Number Of Voxels"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::10th Percentile with Large IBSI Phantom Image", 0.648, results["First Order::10th Percentile"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::90th Percentile with Large IBSI Phantom Image", 4.475, results["First Order::90th Percentile"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Interquantile Range with Large IBSI Phantom Image", 2.91125, results["First Order::Interquartile Range"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Voxel Space with Large IBSI Phantom Image", 8, results["First Order::Voxel Space"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Voxel Volume with Large IBSI Phantom Image", 8, results["First Order::Voxel Volume"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("First Order::Image Dimension with Large IBSI Phantom Image", 3, results["First Order::Image Dimension"], 0.01);
}
};
MITK_TEST_SUITE_REGISTRATION(mitkGIFFirstOrderStatistics )
diff --git a/Modules/Classification/CLUtilities/test/mitkGIFGreyLevelDistanceZoneTest.cpp b/Modules/Classification/CLUtilities/test/mitkGIFGreyLevelDistanceZoneTest.cpp
index b197e1405f..3a9e7c9361 100644
--- a/Modules/Classification/CLUtilities/test/mitkGIFGreyLevelDistanceZoneTest.cpp
+++ b/Modules/Classification/CLUtilities/test/mitkGIFGreyLevelDistanceZoneTest.cpp
@@ -1,143 +1,143 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkTestingMacros.h>
#include <mitkTestFixture.h>
#include "mitkIOUtil.h"
#include <cmath>
#include <mitkGIFGreyLevelDistanceZone.h>
class mitkGIFGreyLevelDistanceZoneTestSuite : public mitk::TestFixture
{
CPPUNIT_TEST_SUITE(mitkGIFGreyLevelDistanceZoneTestSuite );
MITK_TEST(ImageDescription_PhantomTest_3D);
MITK_TEST(ImageDescription_PhantomTest_2D);
CPPUNIT_TEST_SUITE_END();
private:
mitk::Image::Pointer m_IBSI_Phantom_Image_Small;
mitk::Image::Pointer m_IBSI_Phantom_Image_Large;
mitk::Image::Pointer m_IBSI_Phantom_Mask_Small;
mitk::Image::Pointer m_IBSI_Phantom_Mask_Large;
public:
void setUp(void) override
{
m_IBSI_Phantom_Image_Small = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Image_Small.nrrd"));
m_IBSI_Phantom_Image_Large = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Image_Large.nrrd"));
m_IBSI_Phantom_Mask_Small = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Mask_Small.nrrd"));
m_IBSI_Phantom_Mask_Large = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Mask_Large.nrrd"));
}
void ImageDescription_PhantomTest_3D()
{
mitk::GIFGreyLevelDistanceZone::Pointer featureCalculator = mitk::GIFGreyLevelDistanceZone::New();
featureCalculator->SetUseBinsize(true);
featureCalculator->SetBinsize(1.0);
featureCalculator->SetUseMinimumIntensity(true);
featureCalculator->SetUseMaximumIntensity(true);
featureCalculator->SetMinimumIntensity(0.5);
featureCalculator->SetMaximumIntensity(6.5);
auto featureList = featureCalculator->CalculateFeatures(m_IBSI_Phantom_Image_Large, m_IBSI_Phantom_Mask_Large);
std::map<std::string, double> results;
- for (auto valuePair : featureList)
+ for (const auto &valuePair : featureList)
{
MITK_INFO << mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first) << " : " << valuePair.second;
results[valuePair.first.featureClass+"::"+valuePair.first.name] = valuePair.second;
}
CPPUNIT_ASSERT_EQUAL_MESSAGE("Image Diagnostics should calculate 19 features.", std::size_t(19), featureList.size());
// These values are obtained with IBSI
// Standard accuracy is 0.01
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Distance Zone::Small Distance Emphasis with Large IBSI Phantom Image", 1, results["Grey Level Distance Zone::Small Distance Emphasis"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Distance Zone::Large Distance Emphasis with Large IBSI Phantom Image", 1, results["Grey Level Distance Zone::Large Distance Emphasis"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Distance Zone::Low Grey Level Emphasis with Large IBSI Phantom Image", 0.253, results["Grey Level Distance Zone::Low Grey Level Emphasis"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Distance Zone::High Grey Level Emphasis with Large IBSI Phantom Image", 15.6, results["Grey Level Distance Zone::High Grey Level Emphasis"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Distance Zone::Small Distance Low Grey Level Emphasis with Large IBSI Phantom Image", 0.253, results["Grey Level Distance Zone::Small Distance Low Grey Level Emphasis"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Distance Zone::Small Distance High Grey Level Emphasis with Large IBSI Phantom Image", 15.6, results["Grey Level Distance Zone::Small Distance High Grey Level Emphasis"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Distance Zone::Large Distance Low Grey Level Emphasis with Large IBSI Phantom Image", 0.253, results["Grey Level Distance Zone::Large Distance Low Grey Level Emphasis"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Distance Zone::Large Distance High Grey Level Emphasis with Large IBSI Phantom Image", 15.6, results["Grey Level Distance Zone::Large Distance High Grey Level Emphasis"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Distance Zone::Grey Level Non-Uniformity with Large IBSI Phantom Image", 1.4, results["Grey Level Distance Zone::Grey Level Non-Uniformity"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Distance Zone::Grey Level Non-Uniformity Normalized with Large IBSI Phantom Image", 0.28, results["Grey Level Distance Zone::Grey Level Non-Uniformity Normalized"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Distance Zone::Distance Size Non-Uniformity with Large IBSI Phantom Image", 5, results["Grey Level Distance Zone::Distance Size Non-Uniformity"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Distance Zone::Distance Size Non-Uniformity Normalized with Large IBSI Phantom Image", 1, results["Grey Level Distance Zone::Distance Size Non-Uniformity Normalized"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Distance Zone::Zone Percentage with Large IBSI Phantom Image", 0.0676, results["Grey Level Distance Zone::Zone Percentage"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Distance Zone::Grey Level Variance with Large IBSI Phantom Image", 2.64, results["Grey Level Distance Zone::Grey Level Variance"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Distance Zone::Zone Distance Variance with Large IBSI Phantom Image", 0, results["Grey Level Distance Zone::Zone Distance Variance"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Distance Zone::Zone Distance Entropy with Large IBSI Phantom Image", 1.92, results["Grey Level Distance Zone::Zone Distance Entropy"], 0.01);
//CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Distance Zone:: with Large IBSI Phantom Image", 0.045, results["Grey Level Distance Zone::"], 0.001);
// These values are obtained by manually running the tool
// Values might be wrong.
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Distance Zone::Grey Level Mean with Large IBSI Phantom Image", 3.6, results["Grey Level Distance Zone::Grey Level Mean"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Distance Zone::Zone Distance Mean with Large IBSI Phantom Image", 1, results["Grey Level Distance Zone::Zone Distance Mean"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Distance Zone::Grey Level Entropy with Large IBSI Phantom Image", 1.92, results["Grey Level Distance Zone::Grey Level Entropy"], 0.01);
}
void ImageDescription_PhantomTest_2D()
{
mitk::GIFGreyLevelDistanceZone::Pointer featureCalculator = mitk::GIFGreyLevelDistanceZone::New();
featureCalculator->SetUseBinsize(true);
featureCalculator->SetBinsize(1.0);
featureCalculator->SetUseMinimumIntensity(true);
featureCalculator->SetUseMaximumIntensity(true);
featureCalculator->SetMinimumIntensity(0.5);
featureCalculator->SetMaximumIntensity(6.5);
auto featureList = featureCalculator->CalculateFeaturesSlicewise(m_IBSI_Phantom_Image_Large, m_IBSI_Phantom_Mask_Large, 2);
std::map<std::string, double> results;
- for (auto valuePair : featureList)
+ for (const auto &valuePair : featureList)
{
MITK_INFO << mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first) << " : " << valuePair.second;
results[mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first)] = valuePair.second;
}
CPPUNIT_ASSERT_EQUAL_MESSAGE("Image Diagnostics should calculate 114 features.", std::size_t(114), featureList.size());
// These values are obtained with IBSI
// Standard accuracy is 0.01
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Distance Zone::Small Distance Emphasis with Large IBSI Phantom Image", 0.946, results["SliceWise Mean Grey Level Distance Zone::Small Distance Emphasis"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Distance Zone::Large Distance Emphasis with Large IBSI Phantom Image", 1.21, results["SliceWise Mean Grey Level Distance Zone::Large Distance Emphasis"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Distance Zone::Low Grey Level Emphasis with Large IBSI Phantom Image", 0.371, results["SliceWise Mean Grey Level Distance Zone::Low Grey Level Emphasis"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Distance Zone::High Grey Level Emphasis with Large IBSI Phantom Image", 16.4, results["SliceWise Mean Grey Level Distance Zone::High Grey Level Emphasis"], 0.1);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Distance Zone::Small Distance Low Grey Level Emphasis with Large IBSI Phantom Image", 0.367, results["SliceWise Mean Grey Level Distance Zone::Small Distance Low Grey Level Emphasis"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Distance Zone::Small Distance High Grey Level Emphasis with Large IBSI Phantom Image", 15.2, results["SliceWise Mean Grey Level Distance Zone::Small Distance High Grey Level Emphasis"], 0.1);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Distance Zone::Large Distance Low Grey Level Emphasis with Large IBSI Phantom Image", 0.386, results["SliceWise Mean Grey Level Distance Zone::Large Distance Low Grey Level Emphasis"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Distance Zone::Large Distance High Grey Level Emphasis with Large IBSI Phantom Image", 21.3, results["SliceWise Mean Grey Level Distance Zone::Large Distance High Grey Level Emphasis"], 0.1);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Distance Zone::Grey Level Non-Uniformity with Large IBSI Phantom Image", 1.41, results["SliceWise Mean Grey Level Distance Zone::Grey Level Non-Uniformity"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Distance Zone::Grey Level Non-Uniformity Normalized with Large IBSI Phantom Image", 0.323, results["SliceWise Mean Grey Level Distance Zone::Grey Level Non-Uniformity Normalized"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Distance Zone::Distance Size Non-Uniformity with Large IBSI Phantom Image", 3.79, results["SliceWise Mean Grey Level Distance Zone::Distance Size Non-Uniformity"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Distance Zone::Distance Size Non-Uniformity Normalized with Large IBSI Phantom Image", 0.898, results["SliceWise Mean Grey Level Distance Zone::Distance Size Non-Uniformity Normalized"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Distance Zone::Zone Percentage with Large IBSI Phantom Image", 0.24, results["SliceWise Mean Grey Level Distance Zone::Zone Percentage"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Distance Zone::Grey Level Variance with Large IBSI Phantom Image", 3.97, results["SliceWise Mean Grey Level Distance Zone::Grey Level Variance"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Distance Zone::Zone Distance Variance with Large IBSI Phantom Image", 0.051, results["SliceWise Mean Grey Level Distance Zone::Zone Distance Variance"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Distance Zone::Zone Distance Entropy with Large IBSI Phantom Image", 1.73, results["SliceWise Mean Grey Level Distance Zone::Zone Distance Entropy"], 0.01);
//CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Distance Zone:: with Large IBSI Phantom Image", 0.045, results["Grey Level Distance Zone::"], 0.001);
// These values are obtained by manually running the tool
// Values might be wrong.
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Distance Zone::Grey Level Mean with Large IBSI Phantom Image", 3.526, results["SliceWise Mean Grey Level Distance Zone::Grey Level Mean"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Distance Zone::Zone Distance Mean with Large IBSI Phantom Image", 1.071, results["SliceWise Mean Grey Level Distance Zone::Zone Distance Mean"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Distance Zone::Grey Level Entropy with Large IBSI Phantom Image", 1.732, results["SliceWise Mean Grey Level Distance Zone::Grey Level Entropy"], 0.01);
}
};
MITK_TEST_SUITE_REGISTRATION(mitkGIFGreyLevelDistanceZone )
diff --git a/Modules/Classification/CLUtilities/test/mitkGIFGreyLevelSizeZoneTest.cpp b/Modules/Classification/CLUtilities/test/mitkGIFGreyLevelSizeZoneTest.cpp
index 46adb4a03b..d101342762 100644
--- a/Modules/Classification/CLUtilities/test/mitkGIFGreyLevelSizeZoneTest.cpp
+++ b/Modules/Classification/CLUtilities/test/mitkGIFGreyLevelSizeZoneTest.cpp
@@ -1,141 +1,141 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkTestingMacros.h>
#include <mitkTestFixture.h>
#include "mitkIOUtil.h"
#include <cmath>
#include <mitkGIFGreyLevelSizeZone.h>
class mitkGIFGreyLevelSizeZoneTestSuite : public mitk::TestFixture
{
CPPUNIT_TEST_SUITE(mitkGIFGreyLevelSizeZoneTestSuite );
MITK_TEST(ImageDescription_PhantomTest_3D);
MITK_TEST(ImageDescription_PhantomTest_2D);
CPPUNIT_TEST_SUITE_END();
private:
mitk::Image::Pointer m_IBSI_Phantom_Image_Small;
mitk::Image::Pointer m_IBSI_Phantom_Image_Large;
mitk::Image::Pointer m_IBSI_Phantom_Mask_Small;
mitk::Image::Pointer m_IBSI_Phantom_Mask_Large;
public:
void setUp(void) override
{
m_IBSI_Phantom_Image_Small = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Image_Small.nrrd"));
m_IBSI_Phantom_Image_Large = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Image_Large.nrrd"));
m_IBSI_Phantom_Mask_Small = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Mask_Small.nrrd"));
m_IBSI_Phantom_Mask_Large = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Mask_Large.nrrd"));
}
void ImageDescription_PhantomTest_3D()
{
mitk::GIFGreyLevelSizeZone::Pointer featureCalculator = mitk::GIFGreyLevelSizeZone::New();
featureCalculator->SetUseBinsize(true);
featureCalculator->SetBinsize(1.0);
featureCalculator->SetUseMinimumIntensity(true);
featureCalculator->SetUseMaximumIntensity(true);
featureCalculator->SetMinimumIntensity(0.5);
featureCalculator->SetMaximumIntensity(6.5);
auto featureList = featureCalculator->CalculateFeatures(m_IBSI_Phantom_Image_Large, m_IBSI_Phantom_Mask_Large);
std::map<std::string, double> results;
- for (auto valuePair : featureList)
+ for (const auto &valuePair : featureList)
{
MITK_INFO << mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first) << " : " << valuePair.second;
results[mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first)] = valuePair.second;
}
CPPUNIT_ASSERT_EQUAL_MESSAGE("Image Diagnostics should calculate 18 features.", std::size_t(18), featureList.size());
// These values are obtained with IBSI
// Standard accuracy is 0.01
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Size Zone::Small Zone Emphasis with Large IBSI Phantom Image", 0.255, results["Grey Level Size Zone::Small Zone Emphasis"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Size Zone::Large Zone Emphasis with Large IBSI Phantom Image", 550, results["Grey Level Size Zone::Large Zone Emphasis"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Size Zone::Low Grey Level Emphasis with Large IBSI Phantom Image", 0.253, results["Grey Level Size Zone::Low Grey Level Emphasis"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Size Zone::High Grey Level Emphasis with Large IBSI Phantom Image", 15.6, results["Grey Level Size Zone::High Grey Level Emphasis"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Size Zone::Small Zone Low Grey Level Emphasis with Large IBSI Phantom Image", 0.0256, results["Grey Level Size Zone::Small Zone Low Grey Level Emphasis"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Size Zone::Small Zone High Grey Level Emphasis with Large IBSI Phantom Image", 2.76, results["Grey Level Size Zone::Small Zone High Grey Level Emphasis"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Size Zone::Large Zone Low Grey Level Emphasis with Large IBSI Phantom Image", 503, results["Grey Level Size Zone::Large Zone Low Grey Level Emphasis"], 1);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Size Zone::Large Zone High Grey Level Emphasis with Large IBSI Phantom Image", 1495, results["Grey Level Size Zone::Large Zone High Grey Level Emphasis"], 1);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Size Zone::Grey Level Non-Uniformity with Large IBSI Phantom Image", 1.4, results["Grey Level Size Zone::Grey Level Non-Uniformity"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Size Zone::Grey Level Non-Uniformity Normalized with Large IBSI Phantom Image", 0.28, results["Grey Level Size Zone::Grey Level Non-Uniformity Normalized"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Size Zone::Zone Size Non-Uniformity with Large IBSI Phantom Image", 1, results["Grey Level Size Zone::Zone Size Non-Uniformity"], 0.1);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Size Zone::Zone Size Non-Uniformity Normalized with Large IBSI Phantom Image", 0.2, results["Grey Level Size Zone::Zone Size Non-Uniformity Normalized"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Size Zone::Zone Percentage with Large IBSI Phantom Image", 0.0676, results["Grey Level Size Zone::Zone Percentage"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Size Zone::Grey Level Variance with Large IBSI Phantom Image", 2.64, results["Grey Level Size Zone::Grey Level Variance"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Size Zone::Zone Size Variance with Large IBSI Phantom Image", 331, results["Grey Level Size Zone::Zone Size Variance"], 0.1);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Size Zone::Zone Size Entropy with Large IBSI Phantom Image", 2.32, results["Grey Level Size Zone::Zone Size Entropy"], 0.01);
//CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Size Zone:: with Large IBSI Phantom Image", 0.045, results["Grey Level Size Zone::"], 0.001);
// These values are obtained by manually running the tool
// Values might be wrong.
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Size Zone::Grey Level Mean with Large IBSI Phantom Image", 3.6, results["Grey Level Size Zone::Grey Level Mean"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Grey Level Size Zone::Zone Size Mean with Large IBSI Phantom Image", 14.8, results["Grey Level Size Zone::Zone Size Mean"], 0.001);
}
void ImageDescription_PhantomTest_2D()
{
mitk::GIFGreyLevelSizeZone::Pointer featureCalculator = mitk::GIFGreyLevelSizeZone::New();
featureCalculator->SetUseBinsize(true);
featureCalculator->SetBinsize(1.0);
featureCalculator->SetUseMinimumIntensity(true);
featureCalculator->SetUseMaximumIntensity(true);
featureCalculator->SetMinimumIntensity(0.5);
featureCalculator->SetMaximumIntensity(6.5);
auto featureList = featureCalculator->CalculateFeaturesSlicewise(m_IBSI_Phantom_Image_Large, m_IBSI_Phantom_Mask_Large, 2);
std::map<std::string, double> results;
- for (auto valuePair : featureList)
+ for (const auto &valuePair : featureList)
{
MITK_INFO << mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first) << " : " << valuePair.second;
results[mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first)] = valuePair.second;
}
CPPUNIT_ASSERT_EQUAL_MESSAGE("Image Diagnostics should calculate 108 features.", std::size_t(108), featureList.size());
// These values are obtained with IBSI
// Standard accuracy is 0.01
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Size Zone::Small Zone Emphasis with Large IBSI Phantom Image", 0.363, results["SliceWise Mean Grey Level Size Zone::Small Zone Emphasis"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Size Zone::Large Zone Emphasis with Large IBSI Phantom Image", 43.9, results["SliceWise Mean Grey Level Size Zone::Large Zone Emphasis"], 0.1);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Size Zone::Low Grey Level Emphasis with Large IBSI Phantom Image", 0.371, results["SliceWise Mean Grey Level Size Zone::Low Grey Level Emphasis"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Size Zone::High Grey Level Emphasis with Large IBSI Phantom Image", 16.4, results["SliceWise Mean Grey Level Size Zone::High Grey Level Emphasis"], 0.1);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Size Zone::Small Zone Low Grey Level Emphasis with Large IBSI Phantom Image", 0.0259, results["SliceWise Mean Grey Level Size Zone::Small Zone Low Grey Level Emphasis"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Size Zone::Small Zone High Grey Level Emphasis with Large IBSI Phantom Image", 10.3, results["SliceWise Mean Grey Level Size Zone::Small Zone High Grey Level Emphasis"], 0.1);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Size Zone::Large Zone Low Grey Level Emphasis with Large IBSI Phantom Image", 40.4, results["SliceWise Mean Grey Level Size Zone::Large Zone Low Grey Level Emphasis"], 1);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Size Zone::Large Zone High Grey Level Emphasis with Large IBSI Phantom Image", 113, results["SliceWise Mean Grey Level Size Zone::Large Zone High Grey Level Emphasis"], 1);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Size Zone::Grey Level Non-Uniformity with Large IBSI Phantom Image", 1.41, results["SliceWise Mean Grey Level Size Zone::Grey Level Non-Uniformity"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Size Zone::Grey Level Non-Uniformity Normalized with Large IBSI Phantom Image", 0.323, results["SliceWise Mean Grey Level Size Zone::Grey Level Non-Uniformity Normalized"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Size Zone::Zone Size Non-Uniformity with Large IBSI Phantom Image", 1.49, results["SliceWise Mean Grey Level Size Zone::Zone Size Non-Uniformity"], 0.1);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Size Zone::Zone Size Non-Uniformity Normalized with Large IBSI Phantom Image", 0.333, results["SliceWise Mean Grey Level Size Zone::Zone Size Non-Uniformity Normalized"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Size Zone::Zone Percentage with Large IBSI Phantom Image", 0.24, results["SliceWise Mean Grey Level Size Zone::Zone Percentage"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Size Zone::Grey Level Variance with Large IBSI Phantom Image", 3.97, results["SliceWise Mean Grey Level Size Zone::Grey Level Variance"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Size Zone::Zone Size Variance with Large IBSI Phantom Image", 21, results["SliceWise Mean Grey Level Size Zone::Zone Size Variance"], 0.1);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Size Zone::Zone Size Entropy with Large IBSI Phantom Image", 1.93, results["SliceWise Mean Grey Level Size Zone::Zone Size Entropy"], 0.01);
//CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Size Zone:: with Large IBSI Phantom Image", 0.045, results["SliceWise Mean Grey Level Size Zone::"], 0.001);
// These values are obtained by manually running the tool
// Values might be wrong.
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Size Zone::Grey Level Mean with Large IBSI Phantom Image", 3.526, results["SliceWise Mean Grey Level Size Zone::Grey Level Mean"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Grey Level Size Zone::Zone Size Mean with Large IBSI Phantom Image", 4.59524, results["SliceWise Mean Grey Level Size Zone::Zone Size Mean"], 0.001);
}
};
MITK_TEST_SUITE_REGISTRATION(mitkGIFGreyLevelSizeZone )
diff --git a/Modules/Classification/CLUtilities/test/mitkGIFImageDescriptionFeaturesTest.cpp b/Modules/Classification/CLUtilities/test/mitkGIFImageDescriptionFeaturesTest.cpp
index 74aa3d40c5..2c0851bd79 100644
--- a/Modules/Classification/CLUtilities/test/mitkGIFImageDescriptionFeaturesTest.cpp
+++ b/Modules/Classification/CLUtilities/test/mitkGIFImageDescriptionFeaturesTest.cpp
@@ -1,91 +1,91 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkTestingMacros.h>
#include <mitkTestFixture.h>
#include "mitkIOUtil.h"
#include <cmath>
#include <mitkGIFImageDescriptionFeatures.h>
class mitkGIFImageDescriptionFeaturesTestSuite : public mitk::TestFixture
{
CPPUNIT_TEST_SUITE(mitkGIFImageDescriptionFeaturesTestSuite );
MITK_TEST(ImageDescription_PhantomTest);
CPPUNIT_TEST_SUITE_END();
private:
mitk::Image::Pointer m_IBSI_Phantom_Image_Small;
mitk::Image::Pointer m_IBSI_Phantom_Image_Large;
mitk::Image::Pointer m_IBSI_Phantom_Mask_Small;
mitk::Image::Pointer m_IBSI_Phantom_Mask_Large;
public:
void setUp(void) override
{
m_IBSI_Phantom_Image_Small = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Image_Small.nrrd"));
m_IBSI_Phantom_Image_Large = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Image_Large.nrrd"));
m_IBSI_Phantom_Mask_Small = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Mask_Small.nrrd"));
m_IBSI_Phantom_Mask_Large = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Mask_Large.nrrd"));
}
void ImageDescription_PhantomTest()
{
mitk::GIFImageDescriptionFeatures::Pointer featureCalculator = mitk::GIFImageDescriptionFeatures::New();
auto featureList = featureCalculator->CalculateFeatures(m_IBSI_Phantom_Image_Large, m_IBSI_Phantom_Mask_Large);
std::map<std::string, double> results;
- for (auto valuePair : featureList)
+ for (const auto &valuePair : featureList)
{
MITK_INFO << mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first) << " : " << valuePair.second;
results[mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first)] = valuePair.second;
}
CPPUNIT_ASSERT_EQUAL_MESSAGE("Image Diagnostics should calculate 22 features.", std::size_t(22), featureList.size());
// These values are calculated obtained by using this filter. Changes, especially with mean values could happen.
CPPUNIT_ASSERT_EQUAL_MESSAGE("Diagnostic::Image Dimension X should be 7 with Large IBSI Phantom Image", int(7), int(results["Diagnostic::Image Dimension X"]));
CPPUNIT_ASSERT_EQUAL_MESSAGE("Diagnostic::Image Dimension Y should be 6 with Large IBSI Phantom Image", int(6), int(results["Diagnostic::Image Dimension Y"]));
CPPUNIT_ASSERT_EQUAL_MESSAGE("Diagnostic::Image Dimension Z should be 6 with Large IBSI Phantom Image", int(6), int(results["Diagnostic::Image Dimension Z"]));
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Diagnostic::Image Spacing X should be 2 with Large IBSI Phantom Image", 2.0, results["Diagnostic::Image Spacing X"], 0.0001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Diagnostic::Image Spacing Y should be 2 with Large IBSI Phantom Image", 2.0, results["Diagnostic::Image Spacing Y"], 0.0001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Diagnostic::Image Spacing Z should be 2 with Large IBSI Phantom Image", 2.0, results["Diagnostic::Image Spacing Z"], 0.0001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Diagnostic::Image Mean intensity should be 0.6865 with Large IBSI Phantom Image", 0.686508, results["Diagnostic::Image Mean intensity"], 0.0001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Diagnostic::Image Minimum intensity should be 0 with Large IBSI Phantom Image", 0, results["Diagnostic::Image Minimum intensity"], 0.0001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Diagnostic::Image Maximum intensity should be 9 with Large IBSI Phantom Image", 9, results["Diagnostic::Image Maximum intensity"], 0.0001);
CPPUNIT_ASSERT_EQUAL_MESSAGE("Diagnostic::Mask Dimension X should be 7 with Large IBSI Phantom Image", int(7), int(results["Diagnostic::Mask Dimension X"]));
CPPUNIT_ASSERT_EQUAL_MESSAGE("Diagnostic::Mask Dimension Y should be 6 with Large IBSI Phantom Image", int(6), int(results["Diagnostic::Mask Dimension Y"]));
CPPUNIT_ASSERT_EQUAL_MESSAGE("Diagnostic::Mask Dimension Z should be 6 with Large IBSI Phantom Image", int(6), int(results["Diagnostic::Mask Dimension Z"]));
CPPUNIT_ASSERT_EQUAL_MESSAGE("Diagnostic::Mask bounding box X should be 5 with Large IBSI Phantom Image", int(5), int(results["Diagnostic::Mask bounding box X"]));
CPPUNIT_ASSERT_EQUAL_MESSAGE("Diagnostic::Mask bounding box Y should be 4 with Large IBSI Phantom Image", int(4), int(results["Diagnostic::Mask bounding box Y"]));
CPPUNIT_ASSERT_EQUAL_MESSAGE("Diagnostic::Mask bounding box Z should be 4 with Large IBSI Phantom Image", int(4), int(results["Diagnostic::Mask bounding box Z"]));
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Diagnostic::Mask Spacing X should be 2 with Large IBSI Phantom Image", 2.0, results["Diagnostic::Mask Spacing X"], 0.0001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Diagnostic::Mask Spacing Y should be 2 with Large IBSI Phantom Image", 2.0, results["Diagnostic::Mask Spacing Y"], 0.0001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Diagnostic::Mask Spacing Z should be 2 with Large IBSI Phantom Image", 2.0, results["Diagnostic::Mask Spacing Z"], 0.0001);
CPPUNIT_ASSERT_EQUAL_MESSAGE("Diagnostic::Mask Voxel Count should be 74 with Large IBSI Phantom Image", int(74), int(results["Diagnostic::Mask Voxel Count"]));
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Diagnostic::Mask Mean intensity should be 2.14865 with Large IBSI Phantom Image", 2.14865, results["Diagnostic::Mask Mean intensity"], 0.0001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Diagnostic::Mask Minimum intensity should be 1 with Large IBSI Phantom Image", 1, results["Diagnostic::Mask Minimum intensity"], 0.0001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Diagnostic::Mask Maximum intensity should be 6 with Large IBSI Phantom Image", 6, results["Diagnostic::Mask Maximum intensity"], 0.0001);
}
};
MITK_TEST_SUITE_REGISTRATION(mitkGIFImageDescriptionFeatures )
diff --git a/Modules/Classification/CLUtilities/test/mitkGIFIntensityVolumeHistogramTest.cpp b/Modules/Classification/CLUtilities/test/mitkGIFIntensityVolumeHistogramTest.cpp
index d8c238b798..533d4859df 100644
--- a/Modules/Classification/CLUtilities/test/mitkGIFIntensityVolumeHistogramTest.cpp
+++ b/Modules/Classification/CLUtilities/test/mitkGIFIntensityVolumeHistogramTest.cpp
@@ -1,155 +1,155 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkTestingMacros.h>
#include <mitkTestFixture.h>
#include "mitkIOUtil.h"
#include <cmath>
#include <mitkGIFIntensityVolumeHistogramFeatures.h>
class mitkGIFIntensityVolumeHistogramTestSuite : public mitk::TestFixture
{
CPPUNIT_TEST_SUITE( mitkGIFIntensityVolumeHistogramTestSuite);
MITK_TEST(ImageDescription_PhantomTest_Large);
MITK_TEST(ImageDescription_PhantomTest_Small);
MITK_TEST(ImageDescription_PhantomTest_2D);
CPPUNIT_TEST_SUITE_END();
private:
mitk::Image::Pointer m_IBSI_Phantom_Image_Small;
mitk::Image::Pointer m_IBSI_Phantom_Image_Large;
mitk::Image::Pointer m_IBSI_Phantom_Mask_Small;
mitk::Image::Pointer m_IBSI_Phantom_Mask_Large;
public:
void setUp(void) override
{
m_IBSI_Phantom_Image_Small = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Image_Small.nrrd"));
m_IBSI_Phantom_Image_Large = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Image_Large.nrrd"));
m_IBSI_Phantom_Mask_Small = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Mask_Small.nrrd"));
m_IBSI_Phantom_Mask_Large = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Mask_Large.nrrd"));
}
void ImageDescription_PhantomTest_Large()
{
mitk::GIFIntensityVolumeHistogramFeatures::Pointer featureCalculator = mitk::GIFIntensityVolumeHistogramFeatures::New();
featureCalculator->SetUseBinsize(true);
featureCalculator->SetBinsize(1.0);
featureCalculator->SetUseMinimumIntensity(true);
featureCalculator->SetUseMaximumIntensity(true);
featureCalculator->SetMinimumIntensity(0.5);
featureCalculator->SetMaximumIntensity(6.5);
auto featureList = featureCalculator->CalculateFeatures(m_IBSI_Phantom_Image_Large, m_IBSI_Phantom_Mask_Large);
std::map<std::string, double> results;
- for (auto valuePair : featureList)
+ for (const auto &valuePair : featureList)
{
MITK_INFO << mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first) << " : " << valuePair.second;
results[mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first)] = valuePair.second;
}
CPPUNIT_ASSERT_EQUAL_MESSAGE("Image Diagnostics should calculate 7 features.", std::size_t(7), featureList.size());
// These values are obtained in cooperation with IBSI
// Reported with an accuracy of 0.1
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Intensity Volume Histogram::Volume fraction at 0.10 intensity with Large IBSI Phantom Image", 0.3243, results["Intensity Volume Histogram::Volume fraction at 0.10 intensity"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Intensity Volume Histogram::Volume fraction at 0.90 intensity with Large IBSI Phantom Image", 0.09459, results["Intensity Volume Histogram::Volume fraction at 0.90 intensity"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Intensity Volume Histogram::Intensity at 0.10 volume with Large IBSI Phantom Image", 5, results["Intensity Volume Histogram::Intensity at 0.10 volume"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Intensity Volume Histogram::Intensity at 0.90 volume with Large IBSI Phantom Image", 2, results["Intensity Volume Histogram::Intensity at 0.90 volume"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Intensity Volume Histogram::Difference volume fraction at 0.10 and 0.90 intensity with Large IBSI Phantom Image", 0.22973, results["Intensity Volume Histogram::Difference volume fraction at 0.10 and 0.90 intensity"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Intensity Volume Histogram::Difference intensity at 0.10 and 0.90 volume with Large IBSI Phantom Image", 3, results["Intensity Volume Histogram::Difference intensity at 0.10 and 0.90 volume"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Intensity Volume Histogram::Area under IVH curve with Large IBSI Phantom Image", 0.32027, results["Intensity Volume Histogram::Area under IVH curve"], 0.001);
}
void ImageDescription_PhantomTest_Small()
{
mitk::GIFIntensityVolumeHistogramFeatures::Pointer featureCalculator = mitk::GIFIntensityVolumeHistogramFeatures::New();
featureCalculator->SetUseBinsize(true);
featureCalculator->SetBinsize(1.0);
featureCalculator->SetUseMinimumIntensity(true);
featureCalculator->SetUseMaximumIntensity(true);
featureCalculator->SetMinimumIntensity(0.5);
featureCalculator->SetMaximumIntensity(6.5);
auto featureList = featureCalculator->CalculateFeatures(m_IBSI_Phantom_Image_Small, m_IBSI_Phantom_Mask_Small);
std::map<std::string, double> results;
- for (auto valuePair : featureList)
+ for (const auto &valuePair : featureList)
{
MITK_INFO << mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first) << " : " << valuePair.second;
results[mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first)] = valuePair.second;
}
CPPUNIT_ASSERT_EQUAL_MESSAGE("Image Diagnostics should calculate 7 features.", std::size_t(7), featureList.size());
// These values are obtained in cooperation with IBSI
// Reported with an accuracy of 0.1
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Intensity Volume Histogram::Volume fraction at 0.10 intensity with Large IBSI Phantom Image", 0.3243, results["Intensity Volume Histogram::Volume fraction at 0.10 intensity"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Intensity Volume Histogram::Volume fraction at 0.90 intensity with Large IBSI Phantom Image", 0.09459, results["Intensity Volume Histogram::Volume fraction at 0.90 intensity"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Intensity Volume Histogram::Intensity at 0.10 volume with Large IBSI Phantom Image", 5, results["Intensity Volume Histogram::Intensity at 0.10 volume"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Intensity Volume Histogram::Intensity at 0.90 volume with Large IBSI Phantom Image", 2, results["Intensity Volume Histogram::Intensity at 0.90 volume"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Intensity Volume Histogram::Difference volume fraction at 0.10 and 0.90 intensity with Large IBSI Phantom Image", 0.22973, results["Intensity Volume Histogram::Difference volume fraction at 0.10 and 0.90 intensity"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Intensity Volume Histogram::Difference intensity at 0.10 and 0.90 volume with Large IBSI Phantom Image", 3, results["Intensity Volume Histogram::Difference intensity at 0.10 and 0.90 volume"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Intensity Volume Histogram::Area under IVH curve with Large IBSI Phantom Image", 0.32027, results["Intensity Volume Histogram::Area under IVH curve"], 0.001);
}
void ImageDescription_PhantomTest_2D()
{
mitk::GIFIntensityVolumeHistogramFeatures::Pointer featureCalculator = mitk::GIFIntensityVolumeHistogramFeatures::New();
featureCalculator->SetUseBinsize(true);
featureCalculator->SetBinsize(1.0);
featureCalculator->SetUseMinimumIntensity(true);
featureCalculator->SetUseMaximumIntensity(true);
featureCalculator->SetMinimumIntensity(0.5);
featureCalculator->SetMaximumIntensity(6.5);
auto featureList = featureCalculator->CalculateFeaturesSlicewise(m_IBSI_Phantom_Image_Large, m_IBSI_Phantom_Mask_Large, 2);
std::map<std::string, double> results;
- for (auto valuePair : featureList)
+ for (const auto &valuePair : featureList)
{
MITK_INFO << mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first) << " : " << valuePair.second;
results[mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first)] = valuePair.second;
}
CPPUNIT_ASSERT_EQUAL_MESSAGE("Image Diagnostics should calculate 42 features.", std::size_t(42), featureList.size());
// These values are obtained by calculating on the features
// Could be wrong!
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Intensity Volume Histogram::Volume fraction at 0.10 intensity with Large IBSI Phantom Image", 0.31539, results["SliceWise Mean Intensity Volume Histogram::Volume fraction at 0.10 intensity"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Intensity Volume Histogram::Volume fraction at 0.90 intensity with Large IBSI Phantom Image", 0.0924106, results["SliceWise Mean Intensity Volume Histogram::Volume fraction at 0.90 intensity"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Intensity Volume Histogram::Intensity at 0.10 volume with Large IBSI Phantom Image", 6, results["SliceWise Mean Intensity Volume Histogram::Intensity at 0.10 volume"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Intensity Volume Histogram::Intensity at 0.90 volume with Large IBSI Phantom Image", 2, results["SliceWise Mean Intensity Volume Histogram::Intensity at 0.90 volume"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Intensity Volume Histogram::Difference volume fraction at 0.10 and 0.90 intensity with Large IBSI Phantom Image", 0.222979, results["SliceWise Mean Intensity Volume Histogram::Difference volume fraction at 0.10 and 0.90 intensity"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Intensity Volume Histogram::Difference intensity at 0.10 and 0.90 volume with Large IBSI Phantom Image", 4, results["SliceWise Mean Intensity Volume Histogram::Difference intensity at 0.10 and 0.90 volume"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Intensity Volume Histogram::Area under IVH curve with Large IBSI Phantom Image", 0.314325, results["SliceWise Mean Intensity Volume Histogram::Area under IVH curve"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Var. Intensity Volume Histogram::Volume fraction at 0.10 intensity with Large IBSI Phantom Image", 0.0248178, results["SliceWise Var. Intensity Volume Histogram::Volume fraction at 0.10 intensity"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Var. Intensity Volume Histogram::Volume fraction at 0.90 intensity with Large IBSI Phantom Image", 0.00149203, results["SliceWise Var. Intensity Volume Histogram::Volume fraction at 0.90 intensity"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Var. Intensity Volume Histogram::Intensity at 0.10 volume with Large IBSI Phantom Image", 1, results["SliceWise Var. Intensity Volume Histogram::Intensity at 0.10 volume"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Var. Intensity Volume Histogram::Intensity at 0.90 volume with Large IBSI Phantom Image", 0, results["SliceWise Var. Intensity Volume Histogram::Intensity at 0.90 volume"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Var. Intensity Volume Histogram::Difference volume fraction at 0.10 and 0.90 intensity with Large IBSI Phantom Image", 0.01414, results["SliceWise Var. Intensity Volume Histogram::Difference volume fraction at 0.10 and 0.90 intensity"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Var. Intensity Volume Histogram::Difference intensity at 0.10 and 0.90 volume with Large IBSI Phantom Image", 1, results["SliceWise Var. Intensity Volume Histogram::Difference intensity at 0.10 and 0.90 volume"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Var. Intensity Volume Histogram::Area under IVH curve with Large IBSI Phantom Image", 0.0110923, results["SliceWise Var. Intensity Volume Histogram::Area under IVH curve"], 0.001);
}
};
MITK_TEST_SUITE_REGISTRATION(mitkGIFIntensityVolumeHistogram)
diff --git a/Modules/Classification/CLUtilities/test/mitkGIFLocalIntensityTest.cpp b/Modules/Classification/CLUtilities/test/mitkGIFLocalIntensityTest.cpp
index 25df1f8a28..a6af3c6327 100644
--- a/Modules/Classification/CLUtilities/test/mitkGIFLocalIntensityTest.cpp
+++ b/Modules/Classification/CLUtilities/test/mitkGIFLocalIntensityTest.cpp
@@ -1,110 +1,110 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkTestingMacros.h>
#include <mitkTestFixture.h>
#include "mitkIOUtil.h"
#include <cmath>
#include <mitkGIFLocalIntensity.h>
class mitkGIFLocalIntensityTestSuite : public mitk::TestFixture
{
CPPUNIT_TEST_SUITE(mitkGIFLocalIntensityTestSuite);
MITK_TEST(ImageDescription_PhantomTest_Small);
MITK_TEST(ImageDescription_PhantomTest_Large);
MITK_TEST(ImageDescription_PhantomTest_Large_RangeChanged);
CPPUNIT_TEST_SUITE_END();
private:
mitk::Image::Pointer m_IBSI_Phantom_Image_Small;
mitk::Image::Pointer m_IBSI_Phantom_Image_Large;
mitk::Image::Pointer m_IBSI_Phantom_Mask_Small;
mitk::Image::Pointer m_IBSI_Phantom_Mask_Large;
public:
void setUp(void) override
{
m_IBSI_Phantom_Image_Small = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Image_Small.nrrd"));
m_IBSI_Phantom_Image_Large = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Image_Large.nrrd"));
m_IBSI_Phantom_Mask_Small = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Mask_Small.nrrd"));
m_IBSI_Phantom_Mask_Large = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Mask_Large.nrrd"));
}
void ImageDescription_PhantomTest_Small()
{
mitk::GIFLocalIntensity::Pointer featureCalculator = mitk::GIFLocalIntensity::New();
auto featureList = featureCalculator->CalculateFeatures(m_IBSI_Phantom_Image_Small, m_IBSI_Phantom_Mask_Small);
std::map<std::string, double> results;
- for (auto valuePair : featureList)
+ for (const auto &valuePair : featureList)
{
MITK_INFO << mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first) << " : " << valuePair.second;
results[mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first)] = valuePair.second;
}
CPPUNIT_ASSERT_EQUAL_MESSAGE("Image Diagnostics should calculate 2 features.", std::size_t(2), featureList.size());
// These values are obtained in cooperation with IBSI
// Reported with an accuracy of 0.1
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Local Intensity::Local Intensity Peak with Large IBSI Phantom Image", 2.6, results["Local Intensity::2. Local Intensity Peak"], 0.1);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Local Intensity::Global Intensity Peak with Large IBSI Phantom Image", 3.1, results["Local Intensity::2. Global Intensity Peak"], 0.1);
}
void ImageDescription_PhantomTest_Large()
{
mitk::GIFLocalIntensity::Pointer featureCalculator = mitk::GIFLocalIntensity::New();
auto featureList = featureCalculator->CalculateFeatures(m_IBSI_Phantom_Image_Large, m_IBSI_Phantom_Mask_Large);
std::map<std::string, double> results;
- for (auto valuePair : featureList)
+ for (const auto &valuePair : featureList)
{
MITK_INFO << mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first) << " : " << valuePair.second;
results[mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first)] = valuePair.second;
}
CPPUNIT_ASSERT_EQUAL_MESSAGE("Image Diagnostics should calculate 2 features.", std::size_t(2), featureList.size());
// These values are obtained by running the tool
// They might be wrong
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Local Intensity::Local Intensity Peak with Large IBSI Phantom Image", 1.43, results["Local Intensity::2. Local Intensity Peak"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Local Intensity::Global Intensity Peak with Large IBSI Phantom Image", 1.43, results["Local Intensity::2. Global Intensity Peak"], 0.01);
}
void ImageDescription_PhantomTest_Large_RangeChanged()
{
mitk::GIFLocalIntensity::Pointer featureCalculator = mitk::GIFLocalIntensity::New();
featureCalculator->SetRange(1);
auto featureList = featureCalculator->CalculateFeatures(m_IBSI_Phantom_Image_Large, m_IBSI_Phantom_Mask_Large);
std::map<std::string, double> results;
- for (auto valuePair : featureList)
+ for (const auto &valuePair : featureList)
{
MITK_INFO << mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first) << " : " << valuePair.second;
results[mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first)] = valuePair.second;
}
CPPUNIT_ASSERT_EQUAL_MESSAGE("Image Diagnostics should calculate 2 features.", std::size_t(2), featureList.size());
// These values are obtained by running the tool
// They might be wrong
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Local Intensity::Local Intensity Peak with Large IBSI Phantom Image", 6, results["Local Intensity::2. Local Intensity Peak"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Local Intensity::Global Intensity Peak with Large IBSI Phantom Image", 6, results["Local Intensity::2. Global Intensity Peak"], 0.01);
}
};
MITK_TEST_SUITE_REGISTRATION(mitkGIFLocalIntensity )
diff --git a/Modules/Classification/CLUtilities/test/mitkGIFNeighbourhoodGreyToneDifferenceFeaturesTest.cpp b/Modules/Classification/CLUtilities/test/mitkGIFNeighbourhoodGreyToneDifferenceFeaturesTest.cpp
index ff0c33fce9..d87d6aa325 100644
--- a/Modules/Classification/CLUtilities/test/mitkGIFNeighbourhoodGreyToneDifferenceFeaturesTest.cpp
+++ b/Modules/Classification/CLUtilities/test/mitkGIFNeighbourhoodGreyToneDifferenceFeaturesTest.cpp
@@ -1,107 +1,107 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkTestingMacros.h>
#include <mitkTestFixture.h>
#include "mitkIOUtil.h"
#include <cmath>
#include <mitkGIFNeighbourhoodGreyToneDifferenceFeatures.h>
class mitkGIFNeighbourhoodGreyToneDifferenceFeaturesTestSuite : public mitk::TestFixture
{
CPPUNIT_TEST_SUITE(mitkGIFNeighbourhoodGreyToneDifferenceFeaturesTestSuite);
MITK_TEST(ImageDescription_PhantomTest_3D);
MITK_TEST(ImageDescription_PhantomTest_2D);
CPPUNIT_TEST_SUITE_END();
private:
mitk::Image::Pointer m_IBSI_Phantom_Image_Small;
mitk::Image::Pointer m_IBSI_Phantom_Image_Large;
mitk::Image::Pointer m_IBSI_Phantom_Mask_Small;
mitk::Image::Pointer m_IBSI_Phantom_Mask_Large;
public:
void setUp(void) override
{
m_IBSI_Phantom_Image_Small = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Image_Small.nrrd"));
m_IBSI_Phantom_Image_Large = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Image_Large.nrrd"));
m_IBSI_Phantom_Mask_Small = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Mask_Small.nrrd"));
m_IBSI_Phantom_Mask_Large = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Mask_Large.nrrd"));
}
void ImageDescription_PhantomTest_3D()
{
mitk::GIFNeighbourhoodGreyToneDifferenceFeatures::Pointer featureCalculator = mitk::GIFNeighbourhoodGreyToneDifferenceFeatures::New();
featureCalculator->SetUseBinsize(true);
featureCalculator->SetBinsize(1.0);
featureCalculator->SetUseMinimumIntensity(true);
featureCalculator->SetUseMaximumIntensity(true);
featureCalculator->SetMinimumIntensity(0.5);
featureCalculator->SetMaximumIntensity(6.5);
auto featureList = featureCalculator->CalculateFeatures(m_IBSI_Phantom_Image_Large, m_IBSI_Phantom_Mask_Large);
std::map<std::string, double> results;
- for (auto valuePair : featureList)
+ for (const auto &valuePair : featureList)
{
MITK_INFO << mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first) << " : " << valuePair.second;
results[mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first)] = valuePair.second;
}
CPPUNIT_ASSERT_EQUAL_MESSAGE("Image Diagnostics should calculate 5 features.", std::size_t(5), featureList.size());
// These values are obtained with IBSI
// Standard accuracy is 0.01
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Neighbourhood Grey Tone Difference::Coarsness with Large IBSI Phantom Image", 0.0296, results["Neighbourhood Grey Tone Difference::Coarsness"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Neighbourhood Grey Tone Difference::Contrast with Large IBSI Phantom Image", 0.584, results["Neighbourhood Grey Tone Difference::Contrast"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Neighbourhood Grey Tone Difference::Busyness with Large IBSI Phantom Image", 6.54, results["Neighbourhood Grey Tone Difference::Busyness"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Neighbourhood Grey Tone Difference::Complexity with Large IBSI Phantom Image", 13.5, results["Neighbourhood Grey Tone Difference::Complexity"], 0.1);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Neighbourhood Grey Tone Difference::Strength with Large IBSI Phantom Image", 0.763, results["Neighbourhood Grey Tone Difference::Strength"], 0.01);
}
void ImageDescription_PhantomTest_2D()
{
mitk::GIFNeighbourhoodGreyToneDifferenceFeatures::Pointer featureCalculator = mitk::GIFNeighbourhoodGreyToneDifferenceFeatures::New();
featureCalculator->SetUseBinsize(true);
featureCalculator->SetBinsize(1.0);
featureCalculator->SetUseMinimumIntensity(true);
featureCalculator->SetUseMaximumIntensity(true);
featureCalculator->SetMinimumIntensity(0.5);
featureCalculator->SetMaximumIntensity(6.5);
auto featureList = featureCalculator->CalculateFeaturesSlicewise(m_IBSI_Phantom_Image_Large, m_IBSI_Phantom_Mask_Large, 2);
std::map<std::string, double> results;
- for (auto valuePair : featureList)
+ for (const auto &valuePair : featureList)
{
MITK_INFO << mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first) << " : " << valuePair.second;
results[mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first)] = valuePair.second;
}
CPPUNIT_ASSERT_EQUAL_MESSAGE("Image Diagnostics should calculate 30 features.", std::size_t(30), featureList.size());
// These values are obtained with IBSI
// Standard accuracy is 0.01
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Neighbourhood Grey Tone Difference::Coarsness with Large IBSI Phantom Image", 0.121, results["SliceWise Mean Neighbourhood Grey Tone Difference::Coarsness"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Neighbourhood Grey Tone Difference::Contrast with Large IBSI Phantom Image", 0.925, results["SliceWise Mean Neighbourhood Grey Tone Difference::Contrast"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Neighbourhood Grey Tone Difference::Busyness with Large IBSI Phantom Image", 2.99, results["SliceWise Mean Neighbourhood Grey Tone Difference::Busyness"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Neighbourhood Grey Tone Difference::Complexity with Large IBSI Phantom Image", 10.4, results["SliceWise Mean Neighbourhood Grey Tone Difference::Complexity"], 0.1);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Neighbourhood Grey Tone Difference::Strength with Large IBSI Phantom Image", 2.88, results["SliceWise Mean Neighbourhood Grey Tone Difference::Strength"], 0.01);
}
};
MITK_TEST_SUITE_REGISTRATION(mitkGIFNeighbourhoodGreyToneDifferenceFeatures )
diff --git a/Modules/Classification/CLUtilities/test/mitkGIFNeighbouringGreyLevelDependenceFeatureTest.cpp b/Modules/Classification/CLUtilities/test/mitkGIFNeighbouringGreyLevelDependenceFeatureTest.cpp
index 989fb21ca4..a12cdc4289 100644
--- a/Modules/Classification/CLUtilities/test/mitkGIFNeighbouringGreyLevelDependenceFeatureTest.cpp
+++ b/Modules/Classification/CLUtilities/test/mitkGIFNeighbouringGreyLevelDependenceFeatureTest.cpp
@@ -1,151 +1,151 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkTestingMacros.h>
#include <mitkTestFixture.h>
#include "mitkIOUtil.h"
#include <cmath>
#include <mitkGIFNeighbouringGreyLevelDependenceFeatures.h>
class mitkGIFNeighbouringGreyLevelDependenceFeatureTestSuite : public mitk::TestFixture
{
CPPUNIT_TEST_SUITE(mitkGIFNeighbouringGreyLevelDependenceFeatureTestSuite );
MITK_TEST(ImageDescription_PhantomTest_3D);
MITK_TEST(ImageDescription_PhantomTest_2D);
CPPUNIT_TEST_SUITE_END();
private:
mitk::Image::Pointer m_IBSI_Phantom_Image_Small;
mitk::Image::Pointer m_IBSI_Phantom_Image_Large;
mitk::Image::Pointer m_IBSI_Phantom_Mask_Small;
mitk::Image::Pointer m_IBSI_Phantom_Mask_Large;
public:
void setUp(void) override
{
m_IBSI_Phantom_Image_Small = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Image_Small.nrrd"));
m_IBSI_Phantom_Image_Large = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Image_Large.nrrd"));
m_IBSI_Phantom_Mask_Small = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Mask_Small.nrrd"));
m_IBSI_Phantom_Mask_Large = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Mask_Large.nrrd"));
}
void ImageDescription_PhantomTest_3D()
{
mitk::GIFNeighbouringGreyLevelDependenceFeature::Pointer featureCalculator = mitk::GIFNeighbouringGreyLevelDependenceFeature::New();
featureCalculator->SetUseBinsize(true);
featureCalculator->SetBinsize(1.0);
featureCalculator->SetUseMinimumIntensity(true);
featureCalculator->SetUseMaximumIntensity(true);
featureCalculator->SetMinimumIntensity(0.5);
featureCalculator->SetMaximumIntensity(6.5);
auto featureList = featureCalculator->CalculateFeatures(m_IBSI_Phantom_Image_Large, m_IBSI_Phantom_Mask_Large);
std::map<std::string, double> results;
- for (auto valuePair : featureList)
+ for (const auto &valuePair : featureList)
{
MITK_INFO << mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first) << " : " << valuePair.second;
results[mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first)] = valuePair.second;
}
CPPUNIT_ASSERT_EQUAL_MESSAGE("Image Diagnostics should calculate 24 features.", std::size_t(24), featureList.size());
// These values are obtained with IBSI
// Standard accuracy is 0.01
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Neighbouring Grey Level Dependence::Low Dependence Emphasis with Large IBSI Phantom Image", 0.045, results["Neighbouring Grey Level Dependence::Low Dependence Emphasis"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Neighbouring Grey Level Dependence::High Dependence Emphasis with Large IBSI Phantom Image", 109, results["Neighbouring Grey Level Dependence::High Dependence Emphasis"], 1.0);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Neighbouring Grey Level Dependence::Low Grey Level Count Emphasis with Large IBSI Phantom Image", 0.693, results["Neighbouring Grey Level Dependence::Low Grey Level Count Emphasis"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Neighbouring Grey Level Dependence::High Grey Level Count Emphasis with Large IBSI Phantom Image", 7.66, results["Neighbouring Grey Level Dependence::High Grey Level Count Emphasis"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Neighbouring Grey Level Dependence::Low Dependence Low Grey Level Emphasis with Large IBSI Phantom Image", 0.00963, results["Neighbouring Grey Level Dependence::Low Dependence Low Grey Level Emphasis"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Neighbouring Grey Level Dependence::Low Dependence High Grey Level Emphasis with Large IBSI Phantom Image", 0.736, results["Neighbouring Grey Level Dependence::Low Dependence High Grey Level Emphasis"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Neighbouring Grey Level Dependence::High Dependence Low Grey Level Emphasis with Large IBSI Phantom Image", 102, results["Neighbouring Grey Level Dependence::High Dependence Low Grey Level Emphasis"], 1);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Neighbouring Grey Level Dependence::High Dependence High Grey Level Emphasis with Large IBSI Phantom Image", 235, results["Neighbouring Grey Level Dependence::High Dependence High Grey Level Emphasis"], 1);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Neighbouring Grey Level Dependence::Grey Level Non-Uniformity with Large IBSI Phantom Image", 37.9, results["Neighbouring Grey Level Dependence::Grey Level Non-Uniformity"], 0.1);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Neighbouring Grey Level Dependence::Grey Level Non-Uniformity Normalised with Large IBSI Phantom Image", 0.512, results["Neighbouring Grey Level Dependence::Grey Level Non-Uniformity Normalised"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Neighbouring Grey Level Dependence::Dependence Count Non-Uniformity with Large IBSI Phantom Image", 4.86, results["Neighbouring Grey Level Dependence::Dependence Count Non-Uniformity"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Neighbouring Grey Level Dependence::Dependence Count Non-Uniformity Normalised with Large IBSI Phantom Image", 0.0657, results["Neighbouring Grey Level Dependence::Dependence Count Non-Uniformity Normalised"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Neighbouring Grey Level Dependence::Dependence Count Percentage with Large IBSI Phantom Image", 1, results["Neighbouring Grey Level Dependence::Dependence Count Percentage"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Neighbouring Grey Level Dependence::Grey Level Variance with Large IBSI Phantom Image", 3.05, results["Neighbouring Grey Level Dependence::Grey Level Variance"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Neighbouring Grey Level Dependence::Dependence Count Variance with Large IBSI Phantom Image", 22.1, results["Neighbouring Grey Level Dependence::Dependence Count Variance"], 0.1);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Neighbouring Grey Level Dependence::Dependence Count Entropy with Large IBSI Phantom Image", 4.4, results["Neighbouring Grey Level Dependence::Dependence Count Entropy"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Neighbouring Grey Level Dependence::Dependence Count Energy with Large IBSI Phantom Image", 0.0533, results["Neighbouring Grey Level Dependence::Dependence Count Energy"], 0.01);
// These values are obtained by manually running the tool
// Values might be wrong.
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Neighbouring Grey Level Dependence::Grey Level Mean with Large IBSI Phantom Image", 2.15, results["Neighbouring Grey Level Dependence::Grey Level Mean"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Neighbouring Grey Level Dependence::Dependence Count Mean with Large IBSI Phantom Image", 9.32, results["Neighbouring Grey Level Dependence::Dependence Count Mean"], 0.1);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Neighbouring Grey Level Dependence::Expected Neighbourhood Size with Large IBSI Phantom Image", 26, results["Neighbouring Grey Level Dependence::Expected Neighbourhood Size"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Neighbouring Grey Level Dependence::Average Neighbourhood Size with Large IBSI Phantom Image", 14.24, results["Neighbouring Grey Level Dependence::Average Neighbourhood Size"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Neighbouring Grey Level Dependence::Average Incomplete Neighbourhood Size with Large IBSI Phantom Image", 14.24, results["Neighbouring Grey Level Dependence::Average Incomplete Neighbourhood Size"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Neighbouring Grey Level Dependence::Percentage of complete Neighbourhoods with Large IBSI Phantom Image", 0, results["Neighbouring Grey Level Dependence::Percentage of complete Neighbourhoods"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Neighbouring Grey Level Dependence::Percentage of Dependence Neighbour Voxels with Large IBSI Phantom Image", 0.584, results["Neighbouring Grey Level Dependence::Percentage of Dependence Neighbour Voxels"], 0.01);
}
void ImageDescription_PhantomTest_2D()
{
mitk::GIFNeighbouringGreyLevelDependenceFeature::Pointer featureCalculator = mitk::GIFNeighbouringGreyLevelDependenceFeature::New();
featureCalculator->SetUseBinsize(true);
featureCalculator->SetBinsize(1.0);
featureCalculator->SetUseMinimumIntensity(true);
featureCalculator->SetUseMaximumIntensity(true);
featureCalculator->SetMinimumIntensity(0.5);
featureCalculator->SetMaximumIntensity(6.5);
auto featureList = featureCalculator->CalculateFeaturesSlicewise(m_IBSI_Phantom_Image_Large, m_IBSI_Phantom_Mask_Large, 2);
std::map<std::string, double> results;
- for (auto valuePair : featureList)
+ for (const auto &valuePair : featureList)
{
MITK_INFO << mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first) << " : " << valuePair.second;
results[mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first)] = valuePair.second;
}
CPPUNIT_ASSERT_EQUAL_MESSAGE("Image Diagnostics should calculate 144 features.", std::size_t(144), featureList.size());
// These values are obtained with IBSI
// Standard accuracy is 0.01
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Neighbouring Grey Level Dependence::Low Dependence Emphasis with Large IBSI Phantom Image", 0.158, results["SliceWise Mean Neighbouring Grey Level Dependence::Low Dependence Emphasis"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Neighbouring Grey Level Dependence::High Dependence Emphasis with Large IBSI Phantom Image", 19.2, results["SliceWise Mean Neighbouring Grey Level Dependence::High Dependence Emphasis"], 1.0);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Neighbouring Grey Level Dependence::Low Grey Level Count Emphasis with Large IBSI Phantom Image", 0.702, results["SliceWise Mean Neighbouring Grey Level Dependence::Low Grey Level Count Emphasis"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Neighbouring Grey Level Dependence::High Grey Level Count Emphasis with Large IBSI Phantom Image", 7.49, results["SliceWise Mean Neighbouring Grey Level Dependence::High Grey Level Count Emphasis"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Neighbouring Grey Level Dependence::Low Dependence Low Grey Level Emphasis with Large IBSI Phantom Image", 0.0473, results["SliceWise Mean Neighbouring Grey Level Dependence::Low Dependence Low Grey Level Emphasis"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Neighbouring Grey Level Dependence::Low Dependence High Grey Level Emphasis with Large IBSI Phantom Image", 3.06, results["SliceWise Mean Neighbouring Grey Level Dependence::Low Dependence High Grey Level Emphasis"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Neighbouring Grey Level Dependence::High Dependence Low Grey Level Emphasis with Large IBSI Phantom Image", 17.6, results["SliceWise Mean Neighbouring Grey Level Dependence::High Dependence Low Grey Level Emphasis"], 1);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Neighbouring Grey Level Dependence::High Dependence High Grey Level Emphasis with Large IBSI Phantom Image", 49.5, results["SliceWise Mean Neighbouring Grey Level Dependence::High Dependence High Grey Level Emphasis"], 1);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Neighbouring Grey Level Dependence::Grey Level Non-Uniformity with Large IBSI Phantom Image", 10.2, results["SliceWise Mean Neighbouring Grey Level Dependence::Grey Level Non-Uniformity"], 0.1);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Neighbouring Grey Level Dependence::Grey Level Non-Uniformity Normalised with Large IBSI Phantom Image", 0.562, results["SliceWise Mean Neighbouring Grey Level Dependence::Grey Level Non-Uniformity Normalised"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Neighbouring Grey Level Dependence::Dependence Count Non-Uniformity with Large IBSI Phantom Image", 3.96, results["SliceWise Mean Neighbouring Grey Level Dependence::Dependence Count Non-Uniformity"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Neighbouring Grey Level Dependence::Dependence Count Non-Uniformity Normalised with Large IBSI Phantom Image", 0.212, results["SliceWise Mean Neighbouring Grey Level Dependence::Dependence Count Non-Uniformity Normalised"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Neighbouring Grey Level Dependence::Dependence Count Percentage with Large IBSI Phantom Image", 1, results["SliceWise Mean Neighbouring Grey Level Dependence::Dependence Count Percentage"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Neighbouring Grey Level Dependence::Grey Level Variance with Large IBSI Phantom Image", 2.7, results["SliceWise Mean Neighbouring Grey Level Dependence::Grey Level Variance"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Neighbouring Grey Level Dependence::Dependence Count Variance with Large IBSI Phantom Image", 2.73, results["SliceWise Mean Neighbouring Grey Level Dependence::Dependence Count Variance"], 0.1);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Neighbouring Grey Level Dependence::Dependence Count Entropy with Large IBSI Phantom Image", 2.71, results["SliceWise Mean Neighbouring Grey Level Dependence::Dependence Count Entropy"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Neighbouring Grey Level Dependence::Dependence Count Energy with Large IBSI Phantom Image", 0.17, results["SliceWise Mean Neighbouring Grey Level Dependence::Dependence Count Energy"], 0.01);
// These values are obtained by manually running the tool
// Values might be wrong.
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Neighbouring Grey Level Dependence::Grey Level Mean with Large IBSI Phantom Image", 2.12, results["SliceWise Mean Neighbouring Grey Level Dependence::Grey Level Mean"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Neighbouring Grey Level Dependence::Dependence Count Mean with Large IBSI Phantom Image", 3.98, results["SliceWise Mean Neighbouring Grey Level Dependence::Dependence Count Mean"], 0.1);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Neighbouring Grey Level Dependence::Expected Neighbourhood Size with Large IBSI Phantom Image", 8, results["SliceWise Mean Neighbouring Grey Level Dependence::Expected Neighbourhood Size"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Neighbouring Grey Level Dependence::Average Neighbourhood Size with Large IBSI Phantom Image", 5.20, results["SliceWise Mean Neighbouring Grey Level Dependence::Average Neighbourhood Size"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Neighbouring Grey Level Dependence::Average Incomplete Neighbourhood Size with Large IBSI Phantom Image", 4.5598, results["SliceWise Mean Neighbouring Grey Level Dependence::Average Incomplete Neighbourhood Size"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Neighbouring Grey Level Dependence::Percentage of complete Neighbourhoods with Large IBSI Phantom Image", 0.1831, results["SliceWise Mean Neighbouring Grey Level Dependence::Percentage of complete Neighbourhoods"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SliceWise Mean Neighbouring Grey Level Dependence::Percentage of Dependence Neighbour Voxels with Large IBSI Phantom Image", 0.579, results["SliceWise Mean Neighbouring Grey Level Dependence::Percentage of Dependence Neighbour Voxels"], 0.01);
}
};
MITK_TEST_SUITE_REGISTRATION(mitkGIFNeighbouringGreyLevelDependenceFeature )
diff --git a/Modules/Classification/CLUtilities/test/mitkGIFVolumetricDensityStatisticsTest.cpp b/Modules/Classification/CLUtilities/test/mitkGIFVolumetricDensityStatisticsTest.cpp
index c1de6520b6..f3aed016f3 100644
--- a/Modules/Classification/CLUtilities/test/mitkGIFVolumetricDensityStatisticsTest.cpp
+++ b/Modules/Classification/CLUtilities/test/mitkGIFVolumetricDensityStatisticsTest.cpp
@@ -1,88 +1,88 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkTestingMacros.h>
#include <mitkTestFixture.h>
#include "mitkIOUtil.h"
#include <cmath>
#include <mitkGIFVolumetricDensityStatistics.h>
class mitkGIFVolumetricDensityStatisticsTestSuite : public mitk::TestFixture
{
CPPUNIT_TEST_SUITE(mitkGIFVolumetricDensityStatisticsTestSuite);
MITK_TEST(ImageDescription_PhantomTest);
CPPUNIT_TEST_SUITE_END();
private:
mitk::Image::Pointer m_IBSI_Phantom_Image_Small;
mitk::Image::Pointer m_IBSI_Phantom_Image_Large;
mitk::Image::Pointer m_IBSI_Phantom_Mask_Small;
mitk::Image::Pointer m_IBSI_Phantom_Mask_Large;
public:
void setUp(void) override
{
m_IBSI_Phantom_Image_Small = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Image_Small.nrrd"));
m_IBSI_Phantom_Image_Large = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Image_Large.nrrd"));
m_IBSI_Phantom_Mask_Small = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Mask_Small.nrrd"));
m_IBSI_Phantom_Mask_Large = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Mask_Large.nrrd"));
}
void ImageDescription_PhantomTest()
{
mitk::GIFVolumetricDensityStatistics::Pointer featureCalculator = mitk::GIFVolumetricDensityStatistics::New();
featureCalculator->SetUseBinsize(true);
featureCalculator->SetBinsize(1.0);
featureCalculator->SetUseMinimumIntensity(true);
featureCalculator->SetUseMaximumIntensity(true);
featureCalculator->SetMinimumIntensity(0.5);
featureCalculator->SetMaximumIntensity(6.5);
auto featureList = featureCalculator->CalculateFeatures(m_IBSI_Phantom_Image_Large, m_IBSI_Phantom_Mask_Large);
std::map<std::string, double> results;
- for (auto valuePair : featureList)
+ for (const auto &valuePair : featureList)
{
MITK_INFO << mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first) << " : " << valuePair.second;
results[mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first)] = valuePair.second;
}
CPPUNIT_ASSERT_EQUAL_MESSAGE("Image Diagnostics should calculate 13 features.", std::size_t(13), featureList.size());
// These values are obtained by a run of the filter.
// The might be wrong!
// These values are obtained in collaboration with IBSI.
// They are usually reported with an accuracy of 0.01
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Morphological Density::Volume integrated intensity with Large IBSI Phantom Image", 1195, results["Morphological Density::Volume integrated intensity"], 1.0);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Morphological Density::Volume Moran's I index with Large IBSI Phantom Image", 0.0397, results["Morphological Density::Volume Moran's I index"], 0.0001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Morphological Density::Volume Geary's C measure with Large IBSI Phantom Image", 0.974, results["Morphological Density::Volume Geary's C measure"], 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Morphological Density::Volume Volume density axis-aligned bounding box with Large IBSI Phantom Image", 0.87, results["Morphological Density::Volume density axis-aligned bounding box"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Morphological Density::Surface Volume density axis-aligned bounding box with Large IBSI Phantom Image", 0.87, results["Morphological Density::Surface density axis-aligned bounding box"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Morphological Density::Volume Volume oriented minimum bounding box with Large IBSI Phantom Image", 0.87, results["Morphological Density::Volume density oriented minimum bounding box"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Morphological Density::Surface Volume oriented minimum bounding box with Large IBSI Phantom Image", 0.86, results["Morphological Density::Surface density oriented minimum bounding box"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Morphological Density::Volume Volume approx. enclosing ellipsoid with Large IBSI Phantom Image", 1.17, results["Morphological Density::Volume density approx. enclosing ellipsoid"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Morphological Density::Surface Volume approx. enclosing ellipsoid with Large IBSI Phantom Image", 1.34, results["Morphological Density::Surface density approx. enclosing ellipsoid"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Morphological Density::Volume Volume minimum volume enclosing ellipsoid with Large IBSI Phantom Image", 0.24, results["Morphological Density::Volume density approx. minimum volume enclosing ellipsoid"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Morphological Density::Surface Volume minimum volume enclosing ellipsoid with Large IBSI Phantom Image", 0.49, results["Morphological Density::Surface density approx. minimum volume enclosing ellipsoid"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Morphological Density::Volume Volume convex hull with Large IBSI Phantom Image", 0.96, results["Morphological Density::Volume density convex hull"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Morphological Density::Surface Volume convex hull with Large IBSI Phantom Image", 1.03, results["Morphological Density::Surface density convex hull"], 0.01);
}
};
MITK_TEST_SUITE_REGISTRATION(mitkGIFVolumetricDensityStatistics )
diff --git a/Modules/Classification/CLUtilities/test/mitkGIFVolumetricStatisticsTest.cpp b/Modules/Classification/CLUtilities/test/mitkGIFVolumetricStatisticsTest.cpp
index c23fb3317f..2b8d874e9c 100644
--- a/Modules/Classification/CLUtilities/test/mitkGIFVolumetricStatisticsTest.cpp
+++ b/Modules/Classification/CLUtilities/test/mitkGIFVolumetricStatisticsTest.cpp
@@ -1,106 +1,106 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkTestingMacros.h>
#include <mitkTestFixture.h>
#include "mitkIOUtil.h"
#include <cmath>
#include <mitkGIFVolumetricStatistics.h>
class mitkGIFVolumetricStatisticsTestSuite : public mitk::TestFixture
{
CPPUNIT_TEST_SUITE(mitkGIFVolumetricStatisticsTestSuite);
MITK_TEST(ImageDescription_PhantomTest);
CPPUNIT_TEST_SUITE_END();
private:
mitk::Image::Pointer m_IBSI_Phantom_Image_Small;
mitk::Image::Pointer m_IBSI_Phantom_Image_Large;
mitk::Image::Pointer m_IBSI_Phantom_Mask_Small;
mitk::Image::Pointer m_IBSI_Phantom_Mask_Large;
public:
void setUp(void) override
{
m_IBSI_Phantom_Image_Small = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Image_Small.nrrd"));
m_IBSI_Phantom_Image_Large = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Image_Large.nrrd"));
m_IBSI_Phantom_Mask_Small = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Mask_Small.nrrd"));
m_IBSI_Phantom_Mask_Large = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Radiomics/IBSI_Phantom_Mask_Large.nrrd"));
}
void ImageDescription_PhantomTest()
{
mitk::GIFVolumetricStatistics::Pointer featureCalculator = mitk::GIFVolumetricStatistics::New();
auto featureList = featureCalculator->CalculateFeatures(m_IBSI_Phantom_Image_Large, m_IBSI_Phantom_Mask_Large);
std::map<std::string, double> results;
- for (auto valuePair : featureList)
+ for (const auto &valuePair : featureList)
{
MITK_INFO << mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first) << " : " << valuePair.second;
results[mitk::AbstractGlobalImageFeature::GenerateLegacyFeatureNameWOEncoding(valuePair.first)] = valuePair.second;
}
CPPUNIT_ASSERT_EQUAL_MESSAGE("Volume Statistic should calculate 33 features.", std::size_t(38), featureList.size());
// These values are obtained in cooperation with IBSI
// Default accuracy is 0.01
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::Volume (mesh based) with Large IBSI Phantom Image", 556, results["Volumetric Features::Volume (mesh based)"], 1.0);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::Volume (voxel based) with Large IBSI Phantom Image", 592, results["Volumetric Features::Volume (voxel based)"], 1.0);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::Surface (mesh based) with Large IBSI Phantom Image", 388, results["Volumetric Features::Surface (mesh based)"], 1.0);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::Surface to volume ratio (mesh based) with Large IBSI Phantom Image", 0.698, results["Volumetric Features::Surface to volume ratio (mesh based)"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::Compactness 1 (mesh, mesh based) with Large IBSI Phantom Image", 0.04105, results["Volumetric Features::Compactness 1 (mesh, mesh based)"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::Compactness 2 (mesh, mesh based) with Large IBSI Phantom Image", 0.599, results["Volumetric Features::Compactness 2 (mesh, mesh based)"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::Spherical disproportion (mesh, mesh based) with Large IBSI Phantom Image", 1.18, results["Volumetric Features::Spherical disproportion (mesh, mesh based)"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::Sphericity (mesh, mesh based) with Large IBSI Phantom Image", 0.843, results["Volumetric Features::Sphericity (mesh, mesh based)"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::Asphericity (mesh based) with Large IBSI Phantom Image", 0.186, results["Volumetric Features::Asphericity (mesh, mesh based)"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::Centre of mass shift with Large IBSI Phantom Image", 0.672, results["Volumetric Features::Centre of mass shift"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::Maximum 3D diameter with Large IBSI Phantom Image", 11.66, results["Volumetric Features::Maximum 3D diameter"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::PCA Major axis length with Large IBSI Phantom Image", 11.40, results["Volumetric Features::PCA Major axis length"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::PCA Minor axis length with Large IBSI Phantom Image", 9.31, results["Volumetric Features::PCA Minor axis length"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::PCA Least axis length with Large IBSI Phantom Image", 8.54, results["Volumetric Features::PCA Least axis length"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::PCA Elongation with Large IBSI Phantom Image", 0.816, results["Volumetric Features::PCA Elongation"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::PCA Flatness with Large IBSI Phantom Image", 0.749, results["Volumetric Features::PCA Flatness"], 0.01);
// These values are obtained by running the filter
// They might be wrong!
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::Voxel Volume with Large IBSI Phantom Image", 8, results["Volumetric Features::Voxel Volume"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::Volume (voxel based) with Large IBSI Phantom Image", 592, results["Volumetric Features::Volume (voxel based)"], 0.1);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::Surface (voxel based) with Large IBSI Phantom Image", 488, results["Volumetric Features::Surface (voxel based)"], 1.0);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::Centre of mass shift (uncorrected) with Large IBSI Phantom Image", 0.672, results["Volumetric Features::Centre of mass shift (uncorrected)"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::Bounding Box Volume with Large IBSI Phantom Image", 288, results["Volumetric Features::Bounding Box Volume"], 1.0);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::Surface to volume ratio (voxel based) with Large IBSI Phantom Image", 0.824, results["Volumetric Features::Surface to volume ratio (voxel based)"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::Sphericity (voxel based) with Large IBSI Phantom Image", 0.699, results["Volumetric Features::Sphericity (voxel based)"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::Asphericity (voxel based) with Large IBSI Phantom Image", 0.431, results["Volumetric Features::Asphericity (voxel based)"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::Sphericity (mesh based) with Large IBSI Phantom Image", 0.879, results["Volumetric Features::Sphericity (mesh based)"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::Asphericity (mesh based) with Large IBSI Phantom Image", 0.138, results["Volumetric Features::Asphericity (mesh based)"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::Asphericity (mesh based) with Large IBSI Phantom Image", 0.138, results["Volumetric Features::Asphericity (mesh based)"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::Compactness 1 (voxel based) with Large IBSI Phantom Image", 0.031, results["Volumetric Features::Compactness 1 (voxel based)"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::Compactness 1 old (voxel based) with Large IBSI Phantom Image", 5.388, results["Volumetric Features::Compactness 1 old (voxel based)"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::Compactness 2 (voxel based) with Large IBSI Phantom Image", 0.341, results["Volumetric Features::Compactness 2 (voxel based)"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::Compactness 1 (mesh based) with Large IBSI Phantom Image", 0.0437, results["Volumetric Features::Compactness 1 (mesh based)"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::Compactness 2 (mesh based) with Large IBSI Phantom Image", 0.678, results["Volumetric Features::Compactness 2 (mesh based)"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::Spherical disproportion (voxel based) with Large IBSI Phantom Image", 1.43, results["Volumetric Features::Spherical disproportion (voxel based)"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::PCA Major axis length (uncorrected) with Large IBSI Phantom Image", 11.40, results["Volumetric Features::PCA Major axis length (uncorrected)"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::PCA Minor axis length (uncorrected) with Large IBSI Phantom Image", 9.31, results["Volumetric Features::PCA Minor axis length (uncorrected)"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::PCA Least axis length (uncorrected) with Large IBSI Phantom Image", 8.54, results["Volumetric Features::PCA Least axis length (uncorrected)"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::PCA Elongation (uncorrected) with Large IBSI Phantom Image", 0.816, results["Volumetric Features::PCA Elongation (uncorrected)"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::PCA Flatness (uncorrected) with Large IBSI Phantom Image", 0.749, results["Volumetric Features::PCA Flatness (uncorrected)"], 0.01);
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Volumetric Features::Compactness 1 old (mesh based) with Large IBSI Phantom Image", 6.278, results["Volumetric Features::Compactness 1 old (mesh based)"], 0.01);
}
};
MITK_TEST_SUITE_REGISTRATION(mitkGIFVolumetricStatistics )
diff --git a/Modules/CommandLine/include/mitkCommandLineParser.h b/Modules/CommandLine/include/mitkCommandLineParser.h
index ddba149101..24cd81b25a 100644
--- a/Modules/CommandLine/include/mitkCommandLineParser.h
+++ b/Modules/CommandLine/include/mitkCommandLineParser.h
@@ -1,392 +1,391 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
/*=========================================================================
Library: CTK
Copyright (c) Kitware Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0.txt
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
=========================================================================*/
#ifndef __mitkCommandLineParser_h
#define __mitkCommandLineParser_h
#include <map>
#include <usAny.h>
#include <MitkCommandLineExports.h>
#include <mitkVersion.h>
/**
*
* The MITK command line parser, based on the CTK command line parser.
*
* Use this class to add information about the command line arguments
* your program understands and to easily parse them from a given list
* of strings.
*
* This parser provides the following features:
*
* <ul>
* <li>Add arguments by supplying a long name and/or a short name.
* Arguments are validated using a regular expression. They can have
* a default value and a help string.</li>
* <li>Deprecated arguments.</li>
* <li>Custom regular expressions for argument validation.</li>
* <li>Set different argument name prefixes for native platform look and feel.</li>
* <li>Create a help text for the command line arguments with support for
* grouping arguments.</li>
* </ul>
*
* The main difference between the MITK command line parser and the CTK command line
* parser is that the former does not depend on Qt. Apart from that an image type was
* added and XML output improved for automatic GUI generation.
*
* std::out is used for output to keep dependencies to a minimum.
*/
class MITKCOMMANDLINE_EXPORT mitkCommandLineParser
{
public:
enum Type
{
String = 0,
Bool = 1,
StringList = 2,
Int = 3,
Float = 4,
Directory = 5,
File = 6,
Image = 7
};
enum Channel
{
None = 0,
Input = 1,
Output = 2
};
typedef std::vector<std::string> StringContainerType;
mitkCommandLineParser();
~mitkCommandLineParser();
/**
* Parse a given list of command line arguments.
*
* This method parses a list of string elements considering the known arguments
* added by calls to <code>addArgument()</code>. If any one of the argument
* values does not match the corresponding regular expression,
* <code>ok</code> is set to false and an empty map object is returned.
*
* The keys in the returned map object correspond to the long argument string,
* if it is not empty. Otherwise, the short argument string is used as key. The
* us::Any values can safely be converted to the type specified in the
* <code>addArgument()</code> method call.
*
* @param arguments A StringContainerType containing command line arguments.
* @param ok A pointer to a boolean variable. Will be set to <code>true</code>
* if all regular expressions matched, <code>false</code> otherwise.
* @return A map object mapping the long argument (if empty, the short one)
* to a us::Any containing the value.
*/
std::map<std::string, us::Any> parseArguments(const StringContainerType &arguments, bool *ok = nullptr);
/**
* Convenient method allowing to parse a given list of command line arguments.
* @see parseArguments(const StringContainerType &, bool*)
*/
std::map<std::string, us::Any> parseArguments(int argc, char **argv, bool *ok = nullptr);
/**
* Returns a detailed error description if a call to <code>parseArguments()</code>
* failed.
*
* @return The error description, empty if no error occured.
* @see parseArguments(const StringContainerType&, bool*)
*/
std::string errorString() const;
/**
* This method returns all unparsed arguments, i.e. all arguments
* for which no long or short name has been registered via a call
* to <code>addArgument()</code>.
*
* @see addArgument()
*
* @return A list containing unparsed arguments.
*/
const StringContainerType &unparsedArguments() const;
/**
* Checks if the given argument has been added via a call
* to <code>addArgument()</code>.
*
* @see addArgument()
*
* @param argument The argument to be checked.
* @return <code>true</code> if the argument was added, <code>false</code>
* otherwise.
*/
bool argumentAdded(const std::string &argument) const;
/**
* Checks if the given argument has been parsed successfully by a previous
* call to <code>parseArguments()</code>.
*
* @param argument The argument to be checked.
* @return <code>true</code> if the argument was parsed, <code>false</code>
* otherwise.
*/
bool argumentParsed(const std::string &argument) const;
/**
* Adds a command line argument. An argument can have a long name
* (like --long-argument-name), a short name (like -l), or both. The type
* of the argument can be specified by using the <code>type</code> parameter.
* The following types are supported:
*
* <table>
* <tr><td><b>Type</b></td><td><b># of parameters</b></td><td><b>Default regular expr</b></td>
* <td><b>Example</b></td></tr>
* <tr><td>us::Any::String</td><td>1</td><td>.*</td><td>--test-string StringParameter</td></tr>
* <tr><td>us::Any::Bool</td><td>0</td><td>does not apply</td><td>--enable-something</td></tr>
* <tr><td>us::Any::StringList</td><td>-1</td><td>.*</td><td>--test-list string1 string2</td></tr>
* <tr><td>us::Any::Int</td><td>1</td><td>-?[0-9]+</td><td>--test-int -5</td></tr>
* </table>
*
* The regular expressions are used to validate the parameters of command line
* arguments. You can restrict the valid set of parameters by calling
* <code>setExactMatchRegularExpression()</code> for your argument.
*
* Optionally, a help string and a default value can be provided for the argument. If
* the us::Any type of the default value does not match <code>type</code>, an
* exception is thrown. Arguments with default values are always returned by
* <code>parseArguments()</code>.
*
* You can also declare an argument deprecated, by setting <code>deprecated</code>
* to <code>true</code>. Alternatively you can add a deprecated argument by calling
* <code>addDeprecatedArgument()</code>.
*
* If the long or short argument has already been added, or if both are empty strings,
* the method call has no effect.
*
* @param longarg The long argument name.
* @param shortarg The short argument name.
* @param type The argument type (see the list above for supported types).
* @param argLabel The label of this argument, when auto generated interface is used.
* @param argHelp A help string describing the argument.
* @param defaultValue A default value for the argument.
* @param optional
* @param ignoreRest All arguments after the current one will be ignored.
* @param deprecated Declares the argument deprecated.
* @param channel
*
* @see setExactMatchRegularExpression()
* @see addDeprecatedArgument()
* @throws std::logic_error If the us::Any type of <code>defaultValue</code>
* does not match <code>type</code>, a <code>std::logic_error</code> is thrown.
*/
void addArgument(const std::string &longarg,
const std::string &shortarg,
Type type,
const std::string &argLabel,
const std::string &argHelp = std::string(),
const us::Any &defaultValue = us::Any(),
bool optional = true,
bool ignoreRest = false,
bool deprecated = false,
mitkCommandLineParser::Channel channel = mitkCommandLineParser::Channel::None);
/**
* Adds a deprecated command line argument. If a deprecated argument is provided
* on the command line, <code>argHelp</code> is displayed in the console and
* processing continues with the next argument.
*
* Deprecated arguments are grouped separately at the end of the help text
* returned by <code>helpText()</code>.
*
* @param longarg The long argument name.
* @param shortarg The short argument name.
* @param argLabel
* @param argHelp A help string describing alternatives to the deprecated argument.
*/
void addDeprecatedArgument(const std::string &longarg,
const std::string &shortarg,
const std::string &argLabel,
const std::string &argHelp);
/**
* Returns the vector of current Command line Parameter
*
*/
std::vector < std::map<std::string, us::Any> > getArgumentList();
/**
* Sets a custom regular expression for validating argument parameters. The method
* <code>errorString()</code> can be used the get the last error description.
*
* @param argument The previously added long or short argument name.
* @param expression A regular expression which the arugment parameters must match.
* @param exactMatchFailedMessage An error message explaining why the parameter did
* not match.
*
* @return <code>true</code> if the argument was found and the regular expression was set,
* <code>false</code> otherwise.
*
* @see errorString()
*/
bool setExactMatchRegularExpression(const std::string &argument,
const std::string &expression,
const std::string &exactMatchFailedMessage);
/**
* The field width for the argument names without the help text.
*
* @return The argument names field width in the help text.
*/
std::string::size_type fieldWidth() const;
/**
* Creates a help text containing properly formatted argument names and help strings
* provided by calls to <code>addArgument()</code>. The arguments can be grouped by
* using <code>beginGroup()</code> and <code>endGroup()</code>.
*
- * @param charPad The padding character.
* @return The formatted help text.
*/
std::string helpText() const;
/**
* Sets the argument prefix for long and short argument names. This can be used
* to create native command line arguments without changing the calls to
* <code>addArgument()</code>. For example on Unix-based systems, long argument
* names start with "--" and short names with "-", while on Windows argument names
* always start with "/".
*
* Note that all methods in mitkCommandLineParser which take an argument name
* expect the name as it was supplied to <code>addArgument</code>.
*
* Example usage:
*
* \code
* ctkCommandLineParser parser;
* parser.setArgumentPrefix("--", "-");
* parser.addArgument("long-argument", "l", us::Any::String);
* StringContainerType args;
* args << "program name" << "--long-argument Hi";
* parser.parseArguments(args);
* \endcode
*
* @param longPrefix The prefix for long argument names.
* @param shortPrefix The prefix for short argument names.
*/
void setArgumentPrefix(const std::string &longPrefix, const std::string &shortPrefix);
/**
* Begins a new group for documenting arguments. All newly added arguments via
* <code>addArgument()</code> will be put in the new group. You can close the
* current group by calling <code>endGroup()</code> or be opening a new group.
*
* Note that groups cannot be nested and all arguments which do not belong to
* a group will be listed at the top of the text created by <code>helpText()</code>.
*
* @param description The description of the group
*/
void beginGroup(const std::string &description);
/**
* Ends the current group.
*
* @see beginGroup(const std::string&)
*/
void endGroup();
/**
* Can be used to teach the parser to stop parsing the arguments and return False when
* an unknown argument is encountered. By default <code>StrictMode</code> is disabled.
*
* @see parseArguments(const StringContainerType &, bool*)
*/
void setStrictModeEnabled(bool strictMode);
/**
* Is used to generate an XML output for any commandline program.
*/
void generateXmlOutput();
/**
* Is used to set the title of the auto generated interface.
*
* @param title The title of the app.
*/
void setTitle(std::string title);
/**
* Is used to set the contributor for the help view in the auto generated interface.
*
* @param contributor Contributor of the app.
*/
void setContributor(std::string contributor);
/**
* Is used to categorize the apps in the commandline module.
*
* @param category The category of the app.
*/
void setCategory(std::string category);
/**
* Is used as the help text in the auto generated interface.
*
* @param description A short description for the app.
*/
void setDescription(std::string description);
/**
* Is used to group several Parameters in one groupbox in the auto generated interface.
* Default name is "Parameters", with the tooltip: "Groupbox containing parameters."
*
* To change the group of several arguments, call this method before the arguments are added.
*
* @param name The name of the groupbox.
* @param tooltip The tooltip of the groupbox.
*/
void changeParameterGroup(std::string name, std::string tooltip);
protected:
class ctkInternal;
ctkInternal *Internal;
std::string Title;
std::string Contributor;
std::string Category;
std::string Description;
std::string ParameterGroupName;
std::string ParameterGroupDescription;
};
#endif
diff --git a/Modules/CommandLine/src/mitkCommandLineParser.cpp b/Modules/CommandLine/src/mitkCommandLineParser.cpp
index a331d79326..7b663c3464 100644
--- a/Modules/CommandLine/src/mitkCommandLineParser.cpp
+++ b/Modules/CommandLine/src/mitkCommandLineParser.cpp
@@ -1,1056 +1,1056 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
/*=========================================================================
Library: CTK
Copyright (c) Kitware Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0.txt
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
=========================================================================*/
// STL includes
#include <iostream>
#include <stdexcept>
// MITK includes
#include "mitkCommandLineParser.h"
using namespace std;
namespace
{
// --------------------------------------------------------------------------
class CommandLineParserArgumentDescription
{
public:
CommandLineParserArgumentDescription(const string &longArg,
const string &longArgPrefix,
const string &shortArg,
const string &shortArgPrefix,
mitkCommandLineParser::Type type,
const string &argHelp,
const string &argLabel,
const us::Any &defaultValue,
bool ignoreRest,
bool deprecated,
bool optional,
mitkCommandLineParser::Channel channel,
string &argGroup,
string &groupDescription)
: LongArg(longArg),
LongArgPrefix(longArgPrefix),
ShortArg(shortArg),
ShortArgPrefix(shortArgPrefix),
ArgHelp(argHelp),
ArgLabel(argLabel),
ArgGroup(argGroup),
ArgGroupDescription(groupDescription),
IgnoreRest(ignoreRest),
NumberOfParametersToProcess(0),
Deprecated(deprecated),
Optional(optional),
Channel(channel),
DefaultValue(defaultValue),
Value(type),
ValueType(type)
{
Value = defaultValue;
switch (type)
{
case mitkCommandLineParser::String:
{
NumberOfParametersToProcess = 1;
}
break;
case mitkCommandLineParser::Bool:
{
NumberOfParametersToProcess = 0;
}
break;
case mitkCommandLineParser::StringList:
{
NumberOfParametersToProcess = -1;
}
break;
case mitkCommandLineParser::Int:
{
NumberOfParametersToProcess = 1;
}
break;
case mitkCommandLineParser::Float:
{
NumberOfParametersToProcess = 1;
}
break;
case mitkCommandLineParser::Directory:
{
NumberOfParametersToProcess = 1;
}
break;
case mitkCommandLineParser::File:
{
NumberOfParametersToProcess = 1;
}
break;
case mitkCommandLineParser::Image:
{
NumberOfParametersToProcess = 1;
}
break;
default:
std::cout << "Type not supported: " << static_cast<int>(type);
}
}
~CommandLineParserArgumentDescription() {}
bool addParameter(const string &value);
string helpText();
string LongArg;
string LongArgPrefix;
string ShortArg;
string ShortArgPrefix;
string ArgHelp;
string ArgLabel;
string ArgGroup;
string ArgGroupDescription;
bool IgnoreRest;
int NumberOfParametersToProcess;
bool Deprecated;
bool Optional;
mitkCommandLineParser::Channel Channel;
us::Any DefaultValue;
us::Any Value;
mitkCommandLineParser::Type ValueType;
};
// --------------------------------------------------------------------------
bool CommandLineParserArgumentDescription::addParameter(const string &value)
{
switch (ValueType)
{
case mitkCommandLineParser::String:
{
Value = value;
}
break;
case mitkCommandLineParser::Bool:
{
if (value.compare("true") == 0)
Value = true;
else
Value = false;
}
break;
case mitkCommandLineParser::StringList:
{
try
{
mitkCommandLineParser::StringContainerType list =
us::any_cast<mitkCommandLineParser::StringContainerType>(Value);
list.push_back(value);
Value = list;
}
catch (...)
{
mitkCommandLineParser::StringContainerType list;
list.push_back(value);
Value = list;
}
}
break;
case mitkCommandLineParser::Int:
{
stringstream ss(value);
int i;
ss >> i;
Value = i;
}
break;
case mitkCommandLineParser::Float:
{
stringstream ss(value);
float f;
ss >> f;
Value = f;
}
break;
case mitkCommandLineParser::Directory:
case mitkCommandLineParser::Image:
case mitkCommandLineParser::File:
{
Value = value;
}
break;
default:
return false;
}
return true;
}
// --------------------------------------------------------------------------
string CommandLineParserArgumentDescription::helpText()
{
string text;
string shortAndLongArg;
if (!this->ShortArg.empty())
{
shortAndLongArg = " ";
shortAndLongArg += this->ShortArgPrefix;
shortAndLongArg += this->ShortArg;
}
if (!this->LongArg.empty())
{
if (this->ShortArg.empty())
shortAndLongArg.append(" ");
else
shortAndLongArg.append(", ");
shortAndLongArg += this->LongArgPrefix;
shortAndLongArg += this->LongArg;
}
text = text + shortAndLongArg + ", " + this->ArgHelp;
if (this->Optional)
text += " (optional)";
if (!this->DefaultValue.Empty())
{
if (this->ValueType == 1)
{
if (this->DefaultValue.ToString() == "0")
text = text + ", (default: false)";
else
text = text + ", (default: true)";
}
else
text = text + ", (default: " + this->DefaultValue.ToString() + ")";
}
string value_type = "Unknown";
switch (this->ValueType)
{
case 0:
{
value_type = "String";
break;
}
case 1:
{
value_type = "Bool";
break;
}
case 2:
{
value_type = "StringList";
break;
}
case 3:
{
value_type = "Int";
break;
}
case 4:
{
value_type = "Float";
break;
}
case 5:
{
value_type = "Directory";
break;
}
case 6:
{
value_type = "File";
break;
}
case 7:
{
value_type = "Image";
}
}
text = text + ", Type: " + value_type;
if (this->Channel == mitkCommandLineParser::Input)
text = text + ", Channel: input";
else if (this->Channel == mitkCommandLineParser::Output)
text = text + ", Channel: output";
text += "\n";
return text;
}
}
// --------------------------------------------------------------------------
// ctkCommandLineParser::ctkInternal class
// --------------------------------------------------------------------------
class mitkCommandLineParser::ctkInternal
{
public:
ctkInternal() : Debug(false), FieldWidth(0), StrictMode(false) {}
~ctkInternal() {}
CommandLineParserArgumentDescription *argumentDescription(const string &argument);
vector<CommandLineParserArgumentDescription *> ArgumentDescriptionList;
map<string, CommandLineParserArgumentDescription *> ArgNameToArgumentDescriptionMap;
map<string, vector<CommandLineParserArgumentDescription *>> GroupToArgumentDescriptionListMap;
StringContainerType UnparsedArguments;
StringContainerType ProcessedArguments;
string ErrorString;
bool Debug;
string::size_type FieldWidth;
string LongPrefix;
string ShortPrefix;
string CurrentGroup;
string DisableQSettingsLongArg;
string DisableQSettingsShortArg;
bool StrictMode;
};
// --------------------------------------------------------------------------
// ctkCommandLineParser::ctkInternal methods
// --------------------------------------------------------------------------
CommandLineParserArgumentDescription *mitkCommandLineParser::ctkInternal::argumentDescription(const string &argument)
{
string unprefixedArg = argument;
if (!LongPrefix.empty() && argument.compare(0, LongPrefix.size(), LongPrefix) == 0)
{
// Case when (ShortPrefix + UnPrefixedArgument) matches LongPrefix
if (argument == LongPrefix && !ShortPrefix.empty() && argument.compare(0, ShortPrefix.size(), ShortPrefix) == 0)
{
unprefixedArg = argument.substr(ShortPrefix.size(), argument.size());
}
else
{
unprefixedArg = argument.substr(LongPrefix.size(), argument.size());
}
}
else if (!ShortPrefix.empty() && argument.compare(0, ShortPrefix.size(), ShortPrefix) == 0)
{
unprefixedArg = argument.substr(ShortPrefix.size(), argument.size());
}
else if (!LongPrefix.empty() && !ShortPrefix.empty())
{
return nullptr;
}
if (ArgNameToArgumentDescriptionMap.count(unprefixedArg))
{
return this->ArgNameToArgumentDescriptionMap[unprefixedArg];
}
return nullptr;
}
// --------------------------------------------------------------------------
// ctkCommandLineParser methods
// --------------------------------------------------------------------------
mitkCommandLineParser::mitkCommandLineParser()
{
this->Internal = new ctkInternal();
this->Category = string();
this->Title = string();
this->Contributor = string();
this->Description = string();
this->ParameterGroupName = "Parameters";
this->ParameterGroupDescription = "Parameters";
}
// --------------------------------------------------------------------------
mitkCommandLineParser::~mitkCommandLineParser()
{
delete this->Internal;
}
// --------------------------------------------------------------------------
map<string, us::Any> mitkCommandLineParser::parseArguments(const StringContainerType &arguments, bool *ok)
{
// Reset
this->Internal->UnparsedArguments.clear();
this->Internal->ProcessedArguments.clear();
this->Internal->ErrorString.clear();
// foreach (CommandLineParserArgumentDescription* desc, this->Internal->ArgumentDescriptionList)
for (unsigned int i = 0; i < Internal->ArgumentDescriptionList.size(); i++)
{
CommandLineParserArgumentDescription *desc = Internal->ArgumentDescriptionList.at(i);
desc->Value = us::Any(desc->ValueType);
if (!desc->DefaultValue.Empty())
{
desc->Value = desc->DefaultValue;
}
}
bool error = false;
bool ignoreRest = false;
CommandLineParserArgumentDescription *currentArgDesc = nullptr;
vector<CommandLineParserArgumentDescription *> parsedArgDescriptions;
for (unsigned int i = 1; i < arguments.size(); ++i)
{
string argument = arguments.at(i);
if (this->Internal->Debug)
{
std::cout << "Processing" << argument;
}
if (!argument.compare("--version"))
{
std::cout << "Git commit hash: " << MITK_REVISION << std::endl;
std::cout << "Git branch name: " << MITK_REVISION_NAME << "\n" << std::endl;
}
if (!argument.compare("--xml") || !argument.compare("-xml") || !argument.compare("--XML") ||
!argument.compare("-XML"))
{
this->generateXmlOutput();
return map<string, us::Any>();
}
// should argument be ignored ?
if (ignoreRest)
{
if (this->Internal->Debug)
{
std::cout << " Skipping: IgnoreRest flag was been set";
}
this->Internal->UnparsedArguments.push_back(argument);
continue;
}
// Skip if the argument does not start with the defined prefix
if (!(argument.compare(0, Internal->LongPrefix.size(), Internal->LongPrefix) == 0 ||
argument.compare(0, Internal->ShortPrefix.size(), Internal->ShortPrefix) == 0))
{
if (this->Internal->StrictMode)
{
this->Internal->ErrorString = "Unknown argument ";
this->Internal->ErrorString += argument;
error = true;
break;
}
if (this->Internal->Debug)
{
std::cout << " Skipping: It does not start with the defined prefix";
}
this->Internal->UnparsedArguments.push_back(argument);
continue;
}
// Skip if argument has already been parsed ...
bool alreadyProcessed = false;
- for (auto alreadyHandledArgument : Internal->ProcessedArguments)
+ for (const auto &alreadyHandledArgument : Internal->ProcessedArguments)
if (argument.compare(alreadyHandledArgument) == 0)
{
alreadyProcessed = true;
break;
}
if (alreadyProcessed)
{
if (this->Internal->StrictMode)
{
this->Internal->ErrorString = "Argument ";
this->Internal->ErrorString += argument;
this->Internal->ErrorString += " already processed !";
error = true;
break;
}
if (this->Internal->Debug)
{
std::cout << " Skipping: Already processed !";
}
continue;
}
// Retrieve corresponding argument description
currentArgDesc = this->Internal->argumentDescription(argument);
// Is there a corresponding argument description ?
if (currentArgDesc)
{
// If the argument is deprecated, print the help text but continue processing
if (currentArgDesc->Deprecated)
{
std::cout << "Deprecated argument " << argument << ": " << currentArgDesc->ArgHelp;
}
else
{
parsedArgDescriptions.push_back(currentArgDesc);
}
this->Internal->ProcessedArguments.push_back(currentArgDesc->ShortArg);
this->Internal->ProcessedArguments.push_back(currentArgDesc->LongArg);
int numberOfParametersToProcess = currentArgDesc->NumberOfParametersToProcess;
ignoreRest = currentArgDesc->IgnoreRest;
if (this->Internal->Debug && ignoreRest)
{
std::cout << " IgnoreRest flag is True";
}
// Is the number of parameters associated with the argument being processed known ?
if (numberOfParametersToProcess == 0)
{
currentArgDesc->addParameter("true");
}
else if (numberOfParametersToProcess > 0)
{
string missingParameterError = "Argument %1 has %2 value(s) associated whereas exacly %3 are expected.";
for (int j = 1; j <= numberOfParametersToProcess; ++j)
{
if (i + j >= arguments.size())
{
// this->Internal->ErrorString =
// missingParameterError.arg(argument).arg(j-1).arg(numberOfParametersToProcess);
// if (this->Internal->Debug) { std::cout << this->Internal->ErrorString; }
if (ok)
{
*ok = false;
}
return map<string, us::Any>();
}
string parameter = arguments.at(i + j);
if (this->Internal->Debug)
{
std::cout << " Processing parameter" << j << ", value:" << parameter;
}
if (this->argumentAdded(parameter))
{
// this->Internal->ErrorString =
// missingParameterError.arg(argument).arg(j-1).arg(numberOfParametersToProcess);
// if (this->Internal->Debug) { std::cout << this->Internal->ErrorString; }
if (ok)
{
*ok = false;
}
return map<string, us::Any>();
}
if (!currentArgDesc->addParameter(parameter))
{
// this->Internal->ErrorString = string(
// "Value(s) associated with argument %1 are incorrect. %2").
// arg(argument).arg(currentArgDesc->ExactMatchFailedMessage);
// if (this->Internal->Debug) { std::cout << this->Internal->ErrorString; }
if (ok)
{
*ok = false;
}
return map<string, us::Any>();
}
}
// Update main loop increment
i = i + numberOfParametersToProcess;
}
else if (numberOfParametersToProcess == -1)
{
if (this->Internal->Debug)
{
std::cout << " Proccessing StringList ...";
}
int j = 1;
while (j + i < arguments.size())
{
if (this->argumentAdded(arguments.at(j + i)))
{
if (this->Internal->Debug)
{
std::cout << " No more parameter for" << argument;
}
break;
}
string parameter = arguments.at(j + i);
if (parameter.compare(0, Internal->LongPrefix.size(), Internal->LongPrefix) == 0 ||
parameter.compare(0, Internal->ShortPrefix.size(), Internal->ShortPrefix) == 0)
{
j--;
break;
}
if (this->Internal->Debug)
{
std::cout << " Processing parameter" << j << ", value:" << parameter;
}
if (!currentArgDesc->addParameter(parameter))
{
// this->Internal->ErrorString = string(
// "Value(s) associated with argument %1 are incorrect. %2").
// arg(argument).arg(currentArgDesc->ExactMatchFailedMessage);
// if (this->Internal->Debug) { std::cout << this->Internal->ErrorString; }
if (ok)
{
*ok = false;
}
return map<string, us::Any>();
}
j++;
}
// Update main loop increment
i = i + j;
}
}
else
{
if (this->Internal->StrictMode)
{
this->Internal->ErrorString = "Unknown argument ";
this->Internal->ErrorString += argument;
error = true;
break;
}
if (this->Internal->Debug)
{
std::cout << " Skipping: Unknown argument";
}
this->Internal->UnparsedArguments.push_back(argument);
}
}
if (ok)
{
*ok = !error;
}
map<string, us::Any> parsedArguments;
int obligatoryArgs = 0;
vector<CommandLineParserArgumentDescription *>::iterator it;
for (it = Internal->ArgumentDescriptionList.begin(); it != Internal->ArgumentDescriptionList.end(); ++it)
{
CommandLineParserArgumentDescription *desc = *it;
if (!desc->Optional)
obligatoryArgs++;
}
int parsedObligatoryArgs = 0;
for (it = parsedArgDescriptions.begin(); it != parsedArgDescriptions.end(); ++it)
{
CommandLineParserArgumentDescription *desc = *it;
string key;
if (!desc->LongArg.empty())
{
key = desc->LongArg;
}
else
{
key = desc->ShortArg;
}
if (!desc->Optional)
parsedObligatoryArgs++;
std::pair<string, us::Any> elem;
elem.first = key;
elem.second = desc->Value;
parsedArguments.insert(elem);
}
if (obligatoryArgs > parsedObligatoryArgs)
{
parsedArguments.clear();
cout << helpText();
}
return parsedArguments;
}
// -------------------------------------------------------------------------
map<string, us::Any> mitkCommandLineParser::parseArguments(int argc, char **argv, bool *ok)
{
std::cout << "Running Command Line Utility *" << Title << "*" << std::endl;
StringContainerType arguments;
// Create a StringContainerType of arguments
for (int i = 0; i < argc; ++i)
arguments.push_back(argv[i]);
return this->parseArguments(arguments, ok);
}
// -------------------------------------------------------------------------
string mitkCommandLineParser::errorString() const
{
return this->Internal->ErrorString;
}
// -------------------------------------------------------------------------
const mitkCommandLineParser::StringContainerType &mitkCommandLineParser::unparsedArguments() const
{
return this->Internal->UnparsedArguments;
}
// --------------------------------------------------------------------------
void mitkCommandLineParser::addArgument(const string &longarg,
const string &shortarg,
Type type,
const string &argLabel,
const string &argHelp,
const us::Any &defaultValue,
bool optional,
bool ignoreRest,
bool deprecated,
mitkCommandLineParser::Channel channel)
{
if (longarg.empty() && shortarg.empty())
{
return;
}
/* Make sure it's not already added */
bool added = (this->Internal->ArgNameToArgumentDescriptionMap.count(longarg) != 0);
if (added)
{
return;
}
added = (this->Internal->ArgNameToArgumentDescriptionMap.count(shortarg) != 0);
if (added)
{
return;
}
auto argDesc = new CommandLineParserArgumentDescription(longarg,
this->Internal->LongPrefix,
shortarg,
this->Internal->ShortPrefix,
type,
argHelp,
argLabel,
defaultValue,
ignoreRest,
deprecated,
optional,
channel,
ParameterGroupName,
ParameterGroupDescription);
std::string::size_type argWidth = 0;
if (!longarg.empty())
{
this->Internal->ArgNameToArgumentDescriptionMap[longarg] = argDesc;
argWidth += longarg.size() + this->Internal->LongPrefix.size();
}
if (!shortarg.empty())
{
this->Internal->ArgNameToArgumentDescriptionMap[shortarg] = argDesc;
argWidth += shortarg.size() + this->Internal->ShortPrefix.size() + 2;
}
argWidth += 5;
// Set the field width for the arguments
if (argWidth > this->Internal->FieldWidth)
{
this->Internal->FieldWidth = argWidth;
}
this->Internal->ArgumentDescriptionList.push_back(argDesc);
this->Internal->GroupToArgumentDescriptionListMap[this->Internal->CurrentGroup].push_back(argDesc);
}
// --------------------------------------------------------------------------
void mitkCommandLineParser::addDeprecatedArgument(const string &longarg,
const string &shortarg,
const string &argLabel,
const string &argHelp)
{
addArgument(longarg, shortarg, StringList, argLabel, argHelp, us::Any(), false, true, false);
}
// --------------------------------------------------------------------------
std::vector < std::map<std::string, us::Any> > mitkCommandLineParser::getArgumentList()
{
std::vector < std::map<std::string, us::Any> > parameterList;
//for (CommandLineParserArgumentDescription* argument : this->Internal->ArgumentDescriptionList)
for (std::size_t i = 0; i< this->Internal->ArgumentDescriptionList.size(); ++i)
{
CommandLineParserArgumentDescription* argument = this->Internal->ArgumentDescriptionList[i];
std::map<std::string, us::Any> tmpMap;
//tmpMap["helptext"] = us::Any(argument->helpText);
tmpMap["longarg"] = us::Any(argument->LongArg);
tmpMap["longargprefix"] = us::Any(argument->LongArgPrefix);
tmpMap["shortarg"] = us::Any(argument->ShortArg);
tmpMap["shortargprefix"] = us::Any(argument->ShortArgPrefix);
tmpMap["arghelp"] = us::Any(argument->ArgHelp);
tmpMap["arglabel"] = us::Any(argument->ArgLabel);
tmpMap["arggroup"] = us::Any(argument->ArgGroup);
tmpMap["arggroupdescription"] = us::Any(argument->ArgGroupDescription);
tmpMap["ignorerest"] = us::Any(argument->IgnoreRest);
tmpMap["numberofparameterstoprocess"] = us::Any(argument->NumberOfParametersToProcess);
tmpMap["deprecated"] = us::Any(argument->Deprecated);
tmpMap["optional"] = us::Any(argument->Optional);
tmpMap["defaultvalue"] = argument->DefaultValue;
tmpMap["value"] = argument->Value;
tmpMap["valuetype"] = us::Any(argument->ValueType);
tmpMap["channel"] = us::Any(argument->Channel);
parameterList.push_back(tmpMap);
}
return parameterList;
}
// --------------------------------------------------------------------------
std::string::size_type mitkCommandLineParser::fieldWidth() const
{
return this->Internal->FieldWidth;
}
// --------------------------------------------------------------------------
void mitkCommandLineParser::beginGroup(const string &description)
{
this->Internal->CurrentGroup = description;
}
// --------------------------------------------------------------------------
void mitkCommandLineParser::endGroup()
{
this->Internal->CurrentGroup.clear();
}
// --------------------------------------------------------------------------
string mitkCommandLineParser::helpText() const
{
string text;
vector<CommandLineParserArgumentDescription *> deprecatedArgs;
text = "Command Line Utility *" + Title + "* in Category *" + Category + "*\n";
text += Description + "\n";
text += Contributor + "\n\n";
text += "Use --xml to generate an XML description parsable as a CTK Command Line Module Plugin.\n";
text += "Use --version to print MITK revision information.\n";
// Loop over grouped argument descriptions
map<string, vector<CommandLineParserArgumentDescription *>>::iterator it;
for (it = Internal->GroupToArgumentDescriptionListMap.begin();
it != Internal->GroupToArgumentDescriptionListMap.end();
++it)
{
if (!(*it).first.empty())
{
text = text + "\n" + (*it).first + "\n";
}
vector<CommandLineParserArgumentDescription *>::iterator it2;
for (it2 = (*it).second.begin(); it2 != (*it).second.end(); ++it2)
{
CommandLineParserArgumentDescription *argDesc = *it2;
if (argDesc->Deprecated)
{
deprecatedArgs.push_back(argDesc);
}
else
{
text += argDesc->helpText();
}
}
}
if (!deprecatedArgs.empty())
{
text += "\nDeprecated arguments:\n";
vector<CommandLineParserArgumentDescription *>::iterator it2;
for (it2 = deprecatedArgs.begin(); it2 != deprecatedArgs.end(); ++it2)
{
CommandLineParserArgumentDescription *argDesc = *it2;
text += argDesc->helpText();
}
}
return text;
}
// --------------------------------------------------------------------------
bool mitkCommandLineParser::argumentAdded(const string &argument) const
{
return (this->Internal->ArgNameToArgumentDescriptionMap.count(argument) != 0);
}
// --------------------------------------------------------------------------
bool mitkCommandLineParser::argumentParsed(const string &argument) const
{
for (unsigned int i = 0; i < Internal->ProcessedArguments.size(); i++)
if (argument.compare(Internal->ProcessedArguments.at(i)) == 0)
return true;
return false;
}
// --------------------------------------------------------------------------
void mitkCommandLineParser::setArgumentPrefix(const string &longPrefix, const string &shortPrefix)
{
this->Internal->LongPrefix = longPrefix;
this->Internal->ShortPrefix = shortPrefix;
}
// --------------------------------------------------------------------------
void mitkCommandLineParser::setStrictModeEnabled(bool strictMode)
{
this->Internal->StrictMode = strictMode;
}
void mitkCommandLineParser::generateXmlOutput()
{
std::stringstream xml;
xml << "<executable>" << endl;
xml << "<category>" << Category << "</category>" << endl;
xml << "<title>" << Title << "</title>" << endl;
xml << "<description>" << Description << "</description>" << endl;
xml << "<contributor>" << Contributor << "</contributor>" << endl;
xml << "<parameters>" << endl;
std::vector<CommandLineParserArgumentDescription *>::iterator it;
std::string lastParameterGroup = "";
for (it = this->Internal->ArgumentDescriptionList.begin(); it != this->Internal->ArgumentDescriptionList.end(); it++)
{
std::string type;
switch ((*it)->ValueType)
{
case mitkCommandLineParser::String:
type = "string";
break;
case mitkCommandLineParser::Bool:
type = "boolean";
break;
case mitkCommandLineParser::StringList:
type = "string-vector";
break;
case mitkCommandLineParser::Int:
type = "integer";
break;
case mitkCommandLineParser::Float:
type = "float";
break;
case mitkCommandLineParser::Directory:
type = "directory";
break;
case mitkCommandLineParser::Image:
type = "image";
break;
case mitkCommandLineParser::File:
type = "file";
break;
}
if (lastParameterGroup.compare((*it)->ArgGroup))
{
if (it != this->Internal->ArgumentDescriptionList.begin())
{
xml << "</parameters>" << endl;
xml << "<parameters>" << endl;
}
xml << "<label>" << (*it)->ArgGroup << "</label>" << endl;
xml << "<description>" << (*it)->ArgGroupDescription << "</description>" << endl;
lastParameterGroup = (*it)->ArgGroup;
}
// Skip help item, as it's no use in GUI
if ((*it)->ShortArg == "h")
continue;
auto name = (*it)->LongArg;
if (name.empty())
name = (*it)->ShortArg;
xml << "<" << type << ">" << endl;
xml << "<name>" << name << "</name>" << endl;
xml << "<description>" << (*it)->ArgHelp << "</description>" << endl;
xml << "<label>" << (*it)->ArgLabel << "</label>" << endl;
if (!(*it)->DefaultValue.Empty())
xml << "<default>" << (*it)->DefaultValue.ToString() << "</default>" << endl;
xml << "<longflag>" << (*it)->LongArg << "</longflag>" << endl;
xml << "<flag>" << (*it)->ShortArg << "</flag>" << endl;
if (((*it)->ValueType == mitkCommandLineParser::File ||
(*it)->ValueType == mitkCommandLineParser::Directory ||
(*it)->ValueType == mitkCommandLineParser::Image) &&
(*it)->Channel == mitkCommandLineParser::Channel::Input)
{
xml << "<channel>input</channel>" << endl;
}
else if (((*it)->ValueType == mitkCommandLineParser::File ||
(*it)->ValueType == mitkCommandLineParser::Directory ||
(*it)->ValueType == mitkCommandLineParser::Image) &&
(*it)->Channel == mitkCommandLineParser::Channel::Output)
{
xml << "<channel>output</channel>" << endl;
}
else if ((*it)->Channel == mitkCommandLineParser::Channel::Output ||
(*it)->Channel == mitkCommandLineParser::Channel::Input)
{
std::cout << "Only the types Directory, File or Image may be flagged as Input or Output! Ignoring flag for parameter " + name << std::endl;
}
xml << "</" << type << ">" << endl;
}
xml << "</parameters>" << endl;
xml << "</executable>" << endl;
cout << xml.str();
}
void mitkCommandLineParser::setTitle(string title)
{
Title = title;
}
void mitkCommandLineParser::setContributor(string contributor)
{
Contributor = contributor;
}
void mitkCommandLineParser::setCategory(string category)
{
Category = category;
}
void mitkCommandLineParser::setDescription(string description)
{
Description = description;
}
void mitkCommandLineParser::changeParameterGroup(string name, string tooltip)
{
ParameterGroupName = name;
ParameterGroupDescription = tooltip;
}
diff --git a/Modules/ContourModel/Algorithms/mitkContourModelSubDivisionFilter.cpp b/Modules/ContourModel/Algorithms/mitkContourModelSubDivisionFilter.cpp
index dec4e7d708..a7840e854f 100644
--- a/Modules/ContourModel/Algorithms/mitkContourModelSubDivisionFilter.cpp
+++ b/Modules/ContourModel/Algorithms/mitkContourModelSubDivisionFilter.cpp
@@ -1,202 +1,202 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkContourModelSubDivisionFilter.h"
#include <mitkInteractionConst.h>
#include <mitkPointOperation.h>
mitk::ContourModelSubDivisionFilter::ContourModelSubDivisionFilter()
{
OutputType::Pointer output = dynamic_cast<OutputType *>(this->MakeOutput(0).GetPointer());
this->SetNumberOfRequiredInputs(1);
this->SetNumberOfIndexedOutputs(1);
this->SetNthOutput(0, output.GetPointer());
this->m_InterpolationIterations = 4;
}
mitk::ContourModelSubDivisionFilter::~ContourModelSubDivisionFilter()
{
}
void mitk::ContourModelSubDivisionFilter::SetInput(const mitk::ContourModelSubDivisionFilter::InputType *input)
{
this->SetInput(0, input);
}
void mitk::ContourModelSubDivisionFilter::SetInput(unsigned int idx,
const mitk::ContourModelSubDivisionFilter::InputType *input)
{
if (idx + 1 > this->GetNumberOfInputs())
{
this->SetNumberOfRequiredInputs(idx + 1);
}
if (input != static_cast<InputType *>(this->ProcessObject::GetInput(idx)))
{
this->ProcessObject::SetNthInput(idx, const_cast<InputType *>(input));
this->Modified();
}
}
const mitk::ContourModelSubDivisionFilter::InputType *mitk::ContourModelSubDivisionFilter::GetInput(void)
{
if (this->GetNumberOfInputs() < 1)
return nullptr;
return static_cast<const mitk::ContourModelSubDivisionFilter::InputType *>(this->ProcessObject::GetInput(0));
}
const mitk::ContourModelSubDivisionFilter::InputType *mitk::ContourModelSubDivisionFilter::GetInput(unsigned int idx)
{
if (this->GetNumberOfInputs() < 1)
return nullptr;
return static_cast<const mitk::ContourModelSubDivisionFilter::InputType *>(this->ProcessObject::GetInput(idx));
}
void mitk::ContourModelSubDivisionFilter::GenerateData()
{
mitk::ContourModel::Pointer input = const_cast<mitk::ContourModel *>(this->GetInput(0));
// mitk::ContourModelSubDivisionFilter::OutputType::Pointer outputContour = this->GetOutput();
mitk::ContourModel::Pointer contour(input);
- auto timestep = static_cast<int>(input->GetTimeSteps());
+ auto timestep = static_cast<TimeStepType>(input->GetTimeSteps());
- for (int currentTimestep = 0; currentTimestep < timestep; currentTimestep++)
+ for (decltype(timestep) currentTimestep = 0; currentTimestep < timestep; currentTimestep++)
{
if (input->GetNumberOfVertices(currentTimestep) >= 4)
{
for (int iterations = 0; iterations < this->m_InterpolationIterations; iterations++)
{
auto it = contour->IteratorBegin();
auto end = contour->IteratorEnd();
auto first = contour->IteratorBegin();
auto last = contour->IteratorEnd() - 1;
// tempory contour to store result of a subdivision iteration
mitk::ContourModel::Pointer tempContour = mitk::ContourModel::New();
// insert subpoints
while (it != end)
{
// add the current point to the temp contour
tempContour->AddVertex((*it)->Coordinates, (*it)->IsControlPoint, currentTimestep);
// control points for interpolation
auto Ci = it;
InputType::VertexIterator CiPlus1;
InputType::VertexIterator CiPlus2;
InputType::VertexIterator CiMinus1;
// consider all possible cases
if (it == first)
{
if (input->IsClosed(currentTimestep))
{
CiPlus1 = it + 1;
CiPlus2 = it + 2;
CiMinus1 = last;
}
else
{
CiPlus1 = it + 1;
CiPlus2 = it + 2;
CiMinus1 = it;
}
}
else if (it == last)
{
if (input->IsClosed(currentTimestep))
{
CiPlus1 = first;
CiPlus2 = first + 1;
CiMinus1 = it - 1;
}
else
{
// don't add point after last
break;
}
}
else if (it == (last - 1))
{
if (input->IsClosed(currentTimestep))
{
CiPlus1 = it + 1;
CiPlus2 = first;
CiMinus1 = it - 1;
}
else
{
CiPlus1 = it + 1;
CiPlus2 = it + 1;
CiMinus1 = it - 1;
}
}
else
{
CiPlus1 = it + 1;
CiPlus2 = it + 2;
CiMinus1 = it - 1;
}
/* F2i = Ci
* F2i+1 = -1/16Ci-1 + 9/16Ci + 9/16Ci+1 - 1/16Ci+2
*/
mitk::Point3D subpoint;
mitk::Point3D a;
a[0] = (-1.0 / 16.0) * (*CiMinus1)->Coordinates[0];
a[1] = (-1.0 / 16.0) * (*CiMinus1)->Coordinates[1];
a[2] = (-1.0 / 16.0) * (*CiMinus1)->Coordinates[2];
mitk::Point3D b;
b[0] = (9.0 / 16.0) * (*Ci)->Coordinates[0];
b[1] = (9.0 / 16.0) * (*Ci)->Coordinates[1];
b[2] = (9.0 / 16.0) * (*Ci)->Coordinates[2];
mitk::Point3D c;
c[0] = (9.0 / 16.0) * (*CiPlus1)->Coordinates[0];
c[1] = (9.0 / 16.0) * (*CiPlus1)->Coordinates[1];
c[2] = (9.0 / 16.0) * (*CiPlus1)->Coordinates[2];
mitk::Point3D d;
d[0] = (-1.0 / 16.0) * (*CiPlus2)->Coordinates[0];
d[1] = (-1.0 / 16.0) * (*CiPlus2)->Coordinates[1];
d[2] = (-1.0 / 16.0) * (*CiPlus2)->Coordinates[2];
subpoint[0] = a[0] + b[0] + c[0] + d[0];
subpoint[1] = a[1] + b[1] + c[1] + d[1];
subpoint[2] = a[2] + b[2] + c[2] + d[2];
InputType::VertexType subdivisionPoint(subpoint, false);
// add the new subdivision point to our tempContour
tempContour->AddVertex(subdivisionPoint.Coordinates, currentTimestep);
it++;
}
// set the interpolated contour as the contour for the next iteration
contour = tempContour;
}
}
else
{
// filter not executeable - set input to output
contour = input;
}
}
// somehow the isClosed property is not set via copy constructor
contour->SetClosed(input->IsClosed());
this->SetNthOutput(0, contour);
}
diff --git a/Modules/ContourModel/Algorithms/mitkContourModelUtils.cpp b/Modules/ContourModel/Algorithms/mitkContourModelUtils.cpp
index c2eff3c43f..f96f7a385e 100755
--- a/Modules/ContourModel/Algorithms/mitkContourModelUtils.cpp
+++ b/Modules/ContourModel/Algorithms/mitkContourModelUtils.cpp
@@ -1,228 +1,238 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkContourModelUtils.h>
#include <mitkContourModelToSurfaceFilter.h>
#include <mitkLabelSetImage.h>
#include <mitkSurface.h>
#include <vtkImageStencil.h>
#include <vtkPointData.h>
#include <vtkPolyData.h>
#include <vtkPolyDataToImageStencil.h>
mitk::ContourModelUtils::ContourModelUtils()
{
}
mitk::ContourModelUtils::~ContourModelUtils()
{
}
mitk::ContourModel::Pointer mitk::ContourModelUtils::ProjectContourTo2DSlice(
- Image *slice, ContourModel *contourIn3D, bool, bool)
+ const Image *slice, const ContourModel *contourIn3D, bool, bool)
{
if (nullptr == slice || nullptr == contourIn3D)
return nullptr;
auto projectedContour = ContourModel::New();
projectedContour->Initialize(*contourIn3D);
auto sliceGeometry = slice->GetGeometry();
- auto numberOfTimesteps = static_cast<int>(contourIn3D->GetTimeSteps());
+ auto numberOfTimesteps = static_cast<TimeStepType>(contourIn3D->GetTimeSteps());
for (decltype(numberOfTimesteps) t = 0; t < numberOfTimesteps; ++t)
{
auto iter = contourIn3D->Begin(t);
auto end = contourIn3D->End(t);
while (iter != end)
{
const auto ¤tPointIn3D = (*iter)->Coordinates;
Point3D projectedPointIn2D;
projectedPointIn2D.Fill(0.0);
sliceGeometry->WorldToIndex(currentPointIn3D, projectedPointIn2D);
projectedContour->AddVertex(projectedPointIn2D, t);
++iter;
}
}
return projectedContour;
}
mitk::ContourModel::Pointer mitk::ContourModelUtils::BackProjectContourFrom2DSlice(
- const BaseGeometry *sliceGeometry, ContourModel *contourIn2D, bool)
+ const BaseGeometry *sliceGeometry, const ContourModel *contourIn2D, bool)
{
if (nullptr == sliceGeometry || nullptr == contourIn2D)
return nullptr;
auto worldContour = ContourModel::New();
worldContour->Initialize(*contourIn2D);
- auto numberOfTimesteps = static_cast<int>(contourIn2D->GetTimeSteps());
+ auto numberOfTimesteps = static_cast<TimeStepType>(contourIn2D->GetTimeSteps());
for (decltype(numberOfTimesteps) t = 0; t < numberOfTimesteps; ++t)
{
auto iter = contourIn2D->Begin(t);
auto end = contourIn2D->End(t);
while (iter != end)
{
const auto ¤tPointIn2D = (*iter)->Coordinates;
Point3D worldPointIn3D;
worldPointIn3D.Fill(0.0);
sliceGeometry->IndexToWorld(currentPointIn2D, worldPointIn3D);
worldContour->AddVertex(worldPointIn3D, t);
++iter;
}
}
return worldContour;
}
void mitk::ContourModelUtils::FillContourInSlice(
- ContourModel *projectedContour, Image *sliceImage, Image::Pointer workingImage, int paintingPixelValue)
+ const ContourModel *projectedContour, Image *sliceImage, const Image* workingImage, int paintingPixelValue)
{
FillContourInSlice(projectedContour, 0, sliceImage, workingImage, paintingPixelValue);
}
void mitk::ContourModelUtils::FillContourInSlice(
- ContourModel *projectedContour, unsigned int t, Image *sliceImage, Image::Pointer workingImage, int paintingPixelValue)
+ const ContourModel *projectedContour, TimeStepType contourTimeStep, Image *sliceImage, const Image* workingImage, int paintingPixelValue)
{
+ if (nullptr == projectedContour)
+ {
+ mitkThrow() << "Cannot fill contour in slice. Passed contour is invalid";
+ }
+
+ if (nullptr == sliceImage)
+ {
+ mitkThrow() << "Cannot fill contour in slice. Passed slice is invalid";
+ }
+
auto contourModelFilter = mitk::ContourModelToSurfaceFilter::New();
contourModelFilter->SetInput(projectedContour);
contourModelFilter->Update();
auto surface = mitk::Surface::New();
surface = contourModelFilter->GetOutput();
- if (nullptr == surface->GetVtkPolyData(t))
+ if (nullptr == surface->GetVtkPolyData(contourTimeStep))
{
MITK_WARN << "Could not create surface from contour model.";
return;
}
auto surface2D = vtkSmartPointer<vtkPolyData>::New();
- surface2D->SetPoints(surface->GetVtkPolyData(t)->GetPoints());
- surface2D->SetLines(surface->GetVtkPolyData(t)->GetLines());
+ surface2D->SetPoints(surface->GetVtkPolyData(contourTimeStep)->GetPoints());
+ surface2D->SetLines(surface->GetVtkPolyData(contourTimeStep)->GetLines());
auto image = vtkSmartPointer<vtkImageData>::New();
image->DeepCopy(sliceImage->GetVtkImageData());
const double FOREGROUND_VALUE = 255.0;
const double BACKGROUND_VALUE = 0.0;
vtkIdType count = image->GetNumberOfPoints();
for (decltype(count) i = 0; i < count; ++i)
image->GetPointData()->GetScalars()->SetTuple1(i, FOREGROUND_VALUE);
auto polyDataToImageStencil = vtkSmartPointer<vtkPolyDataToImageStencil>::New();
// Set a minimal tolerance, so that clipped pixels will be added to contour as well.
polyDataToImageStencil->SetTolerance(mitk::eps);
polyDataToImageStencil->SetInputData(surface2D);
polyDataToImageStencil->Update();
auto imageStencil = vtkSmartPointer<vtkImageStencil>::New();
imageStencil->SetInputData(image);
imageStencil->SetStencilConnection(polyDataToImageStencil->GetOutputPort());
imageStencil->ReverseStencilOff();
imageStencil->SetBackgroundValue(BACKGROUND_VALUE);
imageStencil->Update();
vtkSmartPointer<vtkImageData> filledImage = imageStencil->GetOutput();
vtkSmartPointer<vtkImageData> resultImage = sliceImage->GetVtkImageData();
FillSliceInSlice(filledImage, resultImage, workingImage, paintingPixelValue);
sliceImage->SetVolume(resultImage->GetScalarPointer());
}
void mitk::ContourModelUtils::FillSliceInSlice(
- vtkSmartPointer<vtkImageData> filledImage, vtkSmartPointer<vtkImageData> resultImage, mitk::Image::Pointer image, int paintingPixelValue)
+ vtkSmartPointer<vtkImageData> filledImage, vtkSmartPointer<vtkImageData> resultImage, const Image* image, int paintingPixelValue)
{
- auto labelImage = dynamic_cast<LabelSetImage *>(image.GetPointer());
+ auto labelImage = dynamic_cast<const LabelSetImage *>(image);
auto numberOfPoints = filledImage->GetNumberOfPoints();
if (nullptr == labelImage)
{
for (decltype(numberOfPoints) i = 0; i < numberOfPoints; ++i)
{
if (1 < filledImage->GetPointData()->GetScalars()->GetTuple1(i))
resultImage->GetPointData()->GetScalars()->SetTuple1(i, paintingPixelValue);
}
}
else
{
auto backgroundValue = labelImage->GetExteriorLabel()->GetValue();
if (paintingPixelValue != backgroundValue)
{
for (decltype(numberOfPoints) i = 0; i < numberOfPoints; ++i)
{
if (1 < filledImage->GetPointData()->GetScalars()->GetTuple1(i))
{
auto existingValue = resultImage->GetPointData()->GetScalars()->GetTuple1(i);
if (!labelImage->GetLabel(existingValue, labelImage->GetActiveLayer())->GetLocked())
resultImage->GetPointData()->GetScalars()->SetTuple1(i, paintingPixelValue);
}
}
}
else
{
auto activePixelValue = labelImage->GetActiveLabel(labelImage->GetActiveLayer())->GetValue();
for (decltype(numberOfPoints) i = 0; i < numberOfPoints; ++i)
{
if (1 < filledImage->GetPointData()->GetScalars()->GetTuple1(i))
{
if (resultImage->GetPointData()->GetScalars()->GetTuple1(i) == activePixelValue)
resultImage->GetPointData()->GetScalars()->SetTuple1(i, paintingPixelValue);
}
}
}
}
}
-mitk::ContourModel::Pointer mitk::ContourModelUtils::MoveZerothContourTimeStep(const ContourModel *contour, unsigned int t)
+mitk::ContourModel::Pointer mitk::ContourModelUtils::MoveZerothContourTimeStep(const ContourModel *contour, TimeStepType t)
{
if (nullptr == contour)
return nullptr;
auto resultContour = ContourModel::New();
resultContour->Expand(t + 1);
std::for_each(contour->Begin(), contour->End(), [&resultContour, t](ContourElement::VertexType *vertex) {
- resultContour->AddVertex(vertex, t);
+ resultContour->AddVertex(*vertex, t);
});
return resultContour;
}
-int mitk::ContourModelUtils::GetActivePixelValue(mitk::Image* workingImage)
+int mitk::ContourModelUtils::GetActivePixelValue(const Image* workingImage)
{
- auto* labelSetImage = dynamic_cast<LabelSetImage*>(workingImage);
+ auto labelSetImage = dynamic_cast<const LabelSetImage*>(workingImage);
int activePixelValue = 1;
if (nullptr != labelSetImage)
{
activePixelValue = labelSetImage->GetActiveLabel(labelSetImage->GetActiveLayer())->GetValue();
}
return activePixelValue;
}
diff --git a/Modules/ContourModel/Algorithms/mitkContourModelUtils.h b/Modules/ContourModel/Algorithms/mitkContourModelUtils.h
index 61a33c0c87..cfc364b9df 100644
--- a/Modules/ContourModel/Algorithms/mitkContourModelUtils.h
+++ b/Modules/ContourModel/Algorithms/mitkContourModelUtils.h
@@ -1,106 +1,113 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkContourModelUtils_h
#define mitkContourModelUtils_h
#include <mitkContourModel.h>
#include <mitkImage.h>
#include <vtkSmartPointer.h>
#include <MitkContourModelExports.h>
namespace mitk
{
/**
* \brief Helpful methods for working with contours and images
*
*
*/
class MITKCONTOURMODEL_EXPORT ContourModelUtils : public itk::Object
{
public:
mitkClassMacroItkParent(ContourModelUtils, itk::Object);
/**
\brief Projects a contour onto an image point by point. Converts from world to index coordinates.
\param slice
\param contourIn3D
\param correctionForIpSegmentation adds 0.5 to x and y index coordinates (difference between ipSegmentation and
MITK contours)
\param constrainToInside
*/
- static ContourModel::Pointer ProjectContourTo2DSlice(Image *slice,
- ContourModel *contourIn3D,
+ static ContourModel::Pointer ProjectContourTo2DSlice(const Image *slice,
+ const ContourModel *contourIn3D,
bool correctionForIpSegmentation,
bool constrainToInside);
/**
\brief Projects a slice index coordinates of a contour back into world coordinates.
\param sliceGeometry
\param contourIn2D
\param correctionForIpSegmentation subtracts 0.5 to x and y index coordinates (difference between ipSegmentation
and MITK contours)
*/
static ContourModel::Pointer BackProjectContourFrom2DSlice(const BaseGeometry *sliceGeometry,
- ContourModel *contourIn2D,
+ const ContourModel *contourIn2D,
bool correctionForIpSegmentation = false);
/**
- \brief Fill a contour in a 2D slice with a specified pixel value at time step 0.
+ \brief Fill a contour in a 2D slice with a specified pixel value.
+ This version always uses the contour of time step 0 and fills the image.
+ \pre sliceImage points to a valid instance
+ \pre projectedContour points to a valid instance
*/
- static void FillContourInSlice(ContourModel *projectedContour,
+ static void FillContourInSlice(const ContourModel *projectedContour,
Image *sliceImage,
- mitk::Image::Pointer workingImage,
+ const Image* workingImage,
int paintingPixelValue = 1);
/**
- \brief Fill a contour in a 2D slice with a specified pixel value at a given time step.
+ \brief Fill a contour in a 2D slice with a specified pixel value.
+ This overloaded version uses the contour at the passed contourTimeStep
+ to fill the passed image slice.
+ \pre sliceImage points to a valid instance
+ \pre projectedContour points to a valid instance
*/
- static void FillContourInSlice(ContourModel *projectedContour,
- unsigned int timeStep,
+ static void FillContourInSlice(const ContourModel *projectedContour,
+ TimeStepType contourTimeStep,
Image *sliceImage,
- mitk::Image::Pointer workingImage,
+ const Image* workingImage,
int paintingPixelValue = 1);
/**
\brief Fills a image (filledImage) into another image (resultImage) by incorporating the rules of LabelSet-Images
*/
static void FillSliceInSlice(vtkSmartPointer<vtkImageData> filledImage,
vtkSmartPointer<vtkImageData> resultImage,
- mitk::Image::Pointer image,
+ const Image* image,
int paintingPixelValue);
/**
\brief Move the contour in time step 0 to to a new contour model at the given time step.
*/
- static ContourModel::Pointer MoveZerothContourTimeStep(const ContourModel *contour, unsigned int timeStep);
+ static ContourModel::Pointer MoveZerothContourTimeStep(const ContourModel *contour, TimeStepType timeStep);
/**
\brief Retrieves the active pixel value of a (labelset) image.
If the image is basic image, the pixel value 1 (one) will be returned.
If the image is actually a labelset image, the pixel value of the active label of the active layer will be
returned.
\param workingImage The (labelset) image to retrieve the active pixel value of.
*/
- static int GetActivePixelValue(mitk::Image* workingImage);
+ static int GetActivePixelValue(const Image* workingImage);
protected:
ContourModelUtils();
~ContourModelUtils() override;
};
}
#endif
diff --git a/Modules/ContourModel/DataManagement/mitkContourElement.cpp b/Modules/ContourModel/DataManagement/mitkContourElement.cpp
index fd14eacedb..bd906acb7b 100644
--- a/Modules/ContourModel/DataManagement/mitkContourElement.cpp
+++ b/Modules/ContourModel/DataManagement/mitkContourElement.cpp
@@ -1,471 +1,419 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <algorithm>
#include <mitkContourElement.h>
#include <vtkMath.h>
-mitk::ContourElement::ContourElement()
+bool mitk::ContourElement::ContourModelVertex::operator ==(const ContourModelVertex& other) const
{
- this->m_Vertices = new VertexListType();
- this->m_IsClosed = false;
+ return this->Coordinates == other.Coordinates && this->IsControlPoint == other.IsControlPoint;
+}
+
+mitk::ContourElement::ConstVertexIterator mitk::ContourElement::ConstIteratorBegin() const
+{
+ return this->begin();
+}
+
+mitk::ContourElement::ConstVertexIterator mitk::ContourElement::ConstIteratorEnd() const
+{
+ return this->end();
+}
+
+mitk::ContourElement::VertexIterator mitk::ContourElement::IteratorBegin()
+{
+ return this->begin();
+}
+
+mitk::ContourElement::VertexIterator mitk::ContourElement::IteratorEnd()
+{
+ return this->end();
+}
+
+mitk::ContourElement::ConstVertexIterator mitk::ContourElement::begin() const
+{
+ return this->m_Vertices.begin();
+}
+
+mitk::ContourElement::ConstVertexIterator mitk::ContourElement::end() const
+{
+ return this->m_Vertices.end();
+}
+
+mitk::ContourElement::VertexIterator mitk::ContourElement::begin()
+{
+ return this->m_Vertices.begin();
+}
+
+mitk::ContourElement::VertexIterator mitk::ContourElement::end()
+{
+ return this->m_Vertices.end();
}
mitk::ContourElement::ContourElement(const mitk::ContourElement &other)
- : itk::LightObject(), m_Vertices(other.m_Vertices), m_IsClosed(other.m_IsClosed)
+ : itk::LightObject(), m_IsClosed(other.m_IsClosed)
{
+ for (const auto& v : other.m_Vertices)
+ {
+ m_Vertices.push_back(new ContourModelVertex(*v));
+ }
}
-mitk::ContourElement::~ContourElement()
+mitk::ContourElement& mitk::ContourElement::operator = (const ContourElement& other)
{
- delete this->m_Vertices;
+ if (this != &other)
+ {
+ this->Clear();
+ for (const auto& v : other.m_Vertices)
+ {
+ m_Vertices.push_back(new ContourModelVertex(*v));
+ }
+ }
+
+ this->m_IsClosed = other.m_IsClosed;
+ return *this;
}
-void mitk::ContourElement::AddVertex(mitk::Point3D &vertex, bool isControlPoint)
+mitk::ContourElement::~ContourElement()
{
- this->m_Vertices->push_back(new VertexType(vertex, isControlPoint));
+ this->Clear();
}
-void mitk::ContourElement::AddVertex(VertexType &vertex)
+mitk::ContourElement::VertexSizeType mitk::ContourElement::GetSize() const
{
- this->m_Vertices->push_back(&vertex);
+ return this->m_Vertices.size();
}
-void mitk::ContourElement::AddVertexAtFront(mitk::Point3D &vertex, bool isControlPoint)
+void mitk::ContourElement::AddVertex(const mitk::Point3D &vertex, bool isControlPoint)
{
- this->m_Vertices->push_front(new VertexType(vertex, isControlPoint));
+ this->m_Vertices.push_back(new VertexType(vertex, isControlPoint));
}
-void mitk::ContourElement::AddVertexAtFront(VertexType &vertex)
+void mitk::ContourElement::AddVertexAtFront(const mitk::Point3D &vertex, bool isControlPoint)
{
- this->m_Vertices->push_front(&vertex);
+ this->m_Vertices.push_front(new VertexType(vertex, isControlPoint));
}
-void mitk::ContourElement::InsertVertexAtIndex(mitk::Point3D &vertex, bool isControlPoint, int index)
+void mitk::ContourElement::InsertVertexAtIndex(const mitk::Point3D &vertex, bool isControlPoint, VertexSizeType index)
{
if (index >= 0 && this->GetSize() > index)
{
- auto _where = this->m_Vertices->begin();
+ auto _where = this->m_Vertices.begin();
_where += index;
- this->m_Vertices->insert(_where, new VertexType(vertex, isControlPoint));
+ this->m_Vertices.insert(_where, new VertexType(vertex, isControlPoint));
}
}
-void mitk::ContourElement::SetVertexAt(int pointId, const Point3D &point)
+void mitk::ContourElement::SetVertexAt(VertexSizeType pointId, const Point3D &point)
{
if (pointId >= 0 && this->GetSize() > pointId)
{
- this->m_Vertices->at(pointId)->Coordinates = point;
+ this->m_Vertices[pointId]->Coordinates = point;
}
}
-void mitk::ContourElement::SetVertexAt(int pointId, const VertexType *vertex)
+void mitk::ContourElement::SetVertexAt(VertexSizeType pointId, const VertexType *vertex)
{
+ if (nullptr == vertex)
+ {
+ mitkThrow() << "Cannot set vertex. Passed vertex instance is invalid. Index to set: " << pointId;
+ }
+
if (pointId >= 0 && this->GetSize() > pointId)
{
- this->m_Vertices->at(pointId)->Coordinates = vertex->Coordinates;
- this->m_Vertices->at(pointId)->IsControlPoint = vertex->IsControlPoint;
+ this->m_Vertices[pointId]->Coordinates = vertex->Coordinates;
+ this->m_Vertices[pointId]->IsControlPoint = vertex->IsControlPoint;
}
}
-mitk::ContourElement::VertexType *mitk::ContourElement::GetVertexAt(int index)
+mitk::ContourElement::VertexType *mitk::ContourElement::GetVertexAt(VertexSizeType index)
{
- return this->m_Vertices->at(index);
+ return this->m_Vertices.at(index);
}
-bool mitk::ContourElement::IsEmpty()
+const mitk::ContourElement::VertexType* mitk::ContourElement::GetVertexAt(VertexSizeType index) const
{
- return this->m_Vertices->empty();
+ return this->m_Vertices.at(index);
+}
+
+bool mitk::ContourElement::IsEmpty() const
+{
+ return this->m_Vertices.empty();
}
mitk::ContourElement::VertexType *mitk::ContourElement::GetVertexAt(const mitk::Point3D &point, float eps)
{
/* current version iterates over the whole deque - should some kind of an octree with spatial query*/
if (eps > 0)
{
// currently no method with better performance is available
return BruteForceGetVertexAt(point, eps);
} // if eps < 0
return nullptr;
}
-mitk::ContourElement::VertexType *mitk::ContourElement::BruteForceGetVertexAt(const mitk::Point3D &point, float eps)
+mitk::ContourElement::VertexType *mitk::ContourElement::BruteForceGetVertexAt(const mitk::Point3D &point, double eps)
{
if (eps > 0)
{
std::deque<std::pair<double, VertexType *>> nearestlist;
- ConstVertexIterator it = this->m_Vertices->begin();
+ ConstVertexIterator it = this->m_Vertices.begin();
- ConstVertexIterator end = this->m_Vertices->end();
+ ConstVertexIterator end = this->m_Vertices.end();
while (it != end)
{
mitk::Point3D currentPoint = (*it)->Coordinates;
double distance = currentPoint.EuclideanDistanceTo(point);
if (distance < eps)
{
// if list is emtpy, add point to list
if (nearestlist.size() < 1)
{
nearestlist.push_front(std::pair<double, VertexType *>((*it)->Coordinates.EuclideanDistanceTo(point), (*it)));
}
// found an approximate point - check if current is closer then first in nearestlist
else if (distance < nearestlist.front().first)
{
// found even closer vertex
nearestlist.push_front(std::pair<double, VertexType *>((*it)->Coordinates.EuclideanDistanceTo(point), (*it)));
}
} // if distance > eps
it++;
} // while
if (nearestlist.size() > 0)
{
/*++++++++++++++++++++ return the nearest active point if one was found++++++++++++++++++*/
auto it = nearestlist.begin();
auto end = nearestlist.end();
while (it != end)
{
if ((*it).second->IsControlPoint)
{
return (*it).second;
}
it++;
}
/*---------------------------------------------------------------------------------------*/
// return closest point
return nearestlist.front().second;
}
}
return nullptr;
}
-/*mitk::ContourElement::VertexType* mitk::ContourElement::OptimizedGetVertexAt(const mitk::Point3D &point, float eps)
-{
- if( (eps > 0) && (this->m_Vertices->size()>0) )
- {
- int k = 1;
- int dim = 3;
- int nPoints = this->m_Vertices->size();
- ANNpointArray pointsArray;
- ANNpoint queryPoint;
- ANNidxArray indexArray;
- ANNdistArray distanceArray;
- ANNkd_tree* kdTree;
-
- queryPoint = annAllocPt(dim);
- pointsArray = annAllocPts(nPoints, dim);
- indexArray = new ANNidx[k];
- distanceArray = new ANNdist[k];
-
-
- int i = 0;
-
- //fill points array with our control points
- for(VertexIterator it = this->m_Vertices->begin(); it != this->m_Vertices->end(); it++, i++)
- {
- mitk::Point3D cur = (*it)->Coordinates;
- pointsArray[i][0]= cur[0];
- pointsArray[i][1]= cur[1];
- pointsArray[i][2]= cur[2];
- }
-
- //create the kd tree
- kdTree = new ANNkd_tree(pointsArray,nPoints, dim);
-
- //fill mitk::Point3D into ANN query point
- queryPoint[0] = point[0];
- queryPoint[1] = point[1];
- queryPoint[2] = point[2];
-
- //k nearest neighbour search
- kdTree->annkSearch(queryPoint, k, indexArray, distanceArray, eps);
-
- VertexType* ret = nullptr;
-
- try
- {
- ret = this->m_Vertices->at(indexArray[0]);
- }
- catch(std::out_of_range ex)
- {
- //ret stays nullptr
- return ret;
- }
-
- //clean up ANN
- delete [] indexArray;
- delete [] distanceArray;
- delete kdTree;
- annClose();
-
- return ret;
- }
- return nullptr;
-}
-*/
-
-mitk::ContourElement::VertexListType *mitk::ContourElement::GetVertexList()
+const mitk::ContourElement::VertexListType *mitk::ContourElement::GetVertexList() const
{
- return this->m_Vertices;
+ return &(this->m_Vertices);
}
-bool mitk::ContourElement::IsClosed()
+bool mitk::ContourElement::IsClosed() const
{
return this->m_IsClosed;
}
-bool mitk::ContourElement::IsNearContour(const mitk::Point3D &point, float eps)
+bool mitk::ContourElement::IsNearContour(const mitk::Point3D &point, float eps) const
{
- ConstVertexIterator it1 = this->m_Vertices->begin();
- ConstVertexIterator it2 = this->m_Vertices->begin();
+ ConstVertexIterator it1 = this->m_Vertices.begin();
+ ConstVertexIterator it2 = this->m_Vertices.begin();
it2++; // it2 runs one position ahead
- ConstVertexIterator end = this->m_Vertices->end();
+ ConstVertexIterator end = this->m_Vertices.end();
int counter = 0;
for (; it1 != end; it1++, it2++, counter++)
{
if (it2 == end)
- it2 = this->m_Vertices->begin();
+ it2 = this->m_Vertices.begin();
mitk::Point3D v1 = (*it1)->Coordinates;
mitk::Point3D v2 = (*it2)->Coordinates;
const float l2 = v1.SquaredEuclideanDistanceTo(v2);
mitk::Vector3D p_v1 = point - v1;
mitk::Vector3D v2_v1 = v2 - v1;
double tc = (p_v1 * v2_v1) / l2;
// take into account we have line segments and not (infinite) lines
if (tc < 0.0)
tc = 0.0;
if (tc > 1.0)
tc = 1.0;
mitk::Point3D crossPoint = v1 + v2_v1 * tc;
double distance = point.SquaredEuclideanDistanceTo(crossPoint);
if (distance < eps)
{
return true;
}
}
return false;
}
void mitk::ContourElement::Close()
{
this->m_IsClosed = true;
}
void mitk::ContourElement::Open()
{
this->m_IsClosed = false;
}
void mitk::ContourElement::SetClosed(bool isClosed)
{
isClosed ? this->Close() : this->Open();
}
-mitk::ContourElement::VertexListType *mitk::ContourElement::GetControlVertices()
+mitk::ContourElement::VertexListType mitk::ContourElement::GetControlVertices() const
{
- auto newVertices = new VertexListType();
+ VertexListType controlVertices;
- auto it = this->m_Vertices->begin();
- auto end = this->m_Vertices->end();
+ std::copy_if(this->m_Vertices.begin(), this->m_Vertices.end(), std::back_inserter(controlVertices), [](const VertexType* v) {return v->IsControlPoint; });
- while (it != end)
- {
- if ((*it)->IsControlPoint)
- {
- newVertices->push_back((*it));
- }
- it++;
- }
-
- return newVertices;
+ return controlVertices;
}
-void mitk::ContourElement::Concatenate(mitk::ContourElement *other, bool check)
+void mitk::ContourElement::Concatenate(const mitk::ContourElement *other, bool check)
{
if (other->GetSize() > 0)
{
- ConstVertexIterator otherIt = other->m_Vertices->begin();
- ConstVertexIterator otherEnd = other->m_Vertices->end();
- while (otherIt != otherEnd)
+ for (const auto& sourceVertex : other->m_Vertices)
{
if (check)
{
- ConstVertexIterator thisIt = this->m_Vertices->begin();
- ConstVertexIterator thisEnd = this->m_Vertices->end();
+ auto finding = std::find_if(this->m_Vertices.begin(), this->m_Vertices.end(), [sourceVertex](const VertexType* v) {return sourceVertex->Coordinates == v->Coordinates; });
- bool found = false;
- while (thisIt != thisEnd)
+ if (finding == this->m_Vertices.end())
{
- if ((*thisIt)->Coordinates == (*otherIt)->Coordinates)
- {
- found = true;
- break;
- }
-
- thisIt++;
+ this->m_Vertices.push_back(new ContourModelVertex(*sourceVertex));
}
- if (!found)
- this->m_Vertices->push_back(*otherIt);
}
else
{
- this->m_Vertices->push_back(*otherIt);
+ this->m_Vertices.push_back(new ContourModelVertex(*sourceVertex));
}
- otherIt++;
}
}
}
-bool mitk::ContourElement::RemoveVertex(const VertexType *vertex)
+mitk::ContourElement::VertexSizeType mitk::ContourElement::GetIndex(const VertexType* vertex) const
{
- auto it = this->m_Vertices->begin();
+ VertexSizeType result = NPOS;
- auto end = this->m_Vertices->end();
+ auto finding = std::find(this->m_Vertices.begin(), this->m_Vertices.end(), vertex);
- // search for vertex and remove it if exists
- while (it != end)
+ if (finding != this->m_Vertices.end())
{
- if ((*it) == vertex)
- {
- this->m_Vertices->erase(it);
- return true;
- }
-
- it++;
+ result = finding - this->m_Vertices.begin();
}
- return false;
+ return result;
}
-int mitk::ContourElement::GetIndex(const VertexType *vertex)
+bool mitk::ContourElement::RemoveVertex(const VertexType *vertex)
{
- auto it = this->m_Vertices->begin();
+ auto finding = std::find(this->m_Vertices.begin(), this->m_Vertices.end(), vertex);
- auto end = this->m_Vertices->end();
-
- int index = 0;
+ return RemoveVertexByIterator(finding);
+}
- // search for vertex
- while (it != end)
+bool mitk::ContourElement::RemoveVertexAt(VertexSizeType index)
+{
+ if (index >= 0 && index < this->m_Vertices.size())
{
- if ((*it) == vertex)
- {
- return index;
- }
-
- it++;
- ++index;
+ auto delIter = this->m_Vertices.begin() + index;
+ return RemoveVertexByIterator(delIter);
}
- return -1; // not found
+ return false;
}
-bool mitk::ContourElement::RemoveVertexAt(int index)
+bool mitk::ContourElement::RemoveVertexAt(const mitk::Point3D &point, double eps)
{
- if (index >= 0 && static_cast<VertexListType::size_type>(index) < this->m_Vertices->size())
- {
- this->m_Vertices->erase(this->m_Vertices->begin() + index);
- return true;
- }
- else
+ if (eps > 0)
{
- return false;
+ auto finding = std::find_if(this->m_Vertices.begin(), this->m_Vertices.end(), [point, eps](const VertexType* v) {return v->Coordinates.EuclideanDistanceTo(point) < eps; });
+
+ return RemoveVertexByIterator(finding);
}
+ return false;
}
-bool mitk::ContourElement::RemoveVertexAt(mitk::Point3D &point, float eps)
+bool mitk::ContourElement::RemoveVertexByIterator(VertexListType::iterator& iter)
{
- /* current version iterates over the whole deque - should be some kind of an octree with spatial query*/
-
- if (eps > 0)
+ if (iter != this->m_Vertices.end())
{
- auto it = this->m_Vertices->begin();
-
- auto end = this->m_Vertices->end();
-
- while (it != end)
- {
- mitk::Point3D currentPoint = (*it)->Coordinates;
-
- if (currentPoint.EuclideanDistanceTo(point) < eps)
- {
- // approximate point found
- // now erase it
- this->m_Vertices->erase(it);
- return true;
- }
-
- it++;
- }
+ delete* iter;
+ this->m_Vertices.erase(iter);
+ return true;
}
+
return false;
}
void mitk::ContourElement::Clear()
{
- this->m_Vertices->clear();
+ for (auto vertex : m_Vertices)
+ {
+ delete vertex;
+ }
+ this->m_Vertices.clear();
}
+
//----------------------------------------------------------------------
void mitk::ContourElement::RedistributeControlVertices(const VertexType *selected, int period)
{
int counter = 0;
- auto _where = this->m_Vertices->begin();
+ auto _where = this->m_Vertices.begin();
if (selected != nullptr)
{
- while (_where != this->m_Vertices->end())
+ auto finding = std::find(this->m_Vertices.begin(), this->m_Vertices.end(), selected);
+
+ if (finding != this->m_Vertices.end())
{
- if ((*_where) == selected)
- {
- break;
- }
- _where++;
+ _where = finding;
}
}
auto _iter = _where;
- while (_iter != this->m_Vertices->end())
+ while (_iter != this->m_Vertices.end())
{
div_t divresult;
divresult = div(counter, period);
(*_iter)->IsControlPoint = (divresult.rem == 0);
counter++;
_iter++;
}
_iter = _where;
counter = 0;
- while (_iter != this->m_Vertices->begin())
+ while (_iter != this->m_Vertices.begin())
{
div_t divresult;
divresult = div(counter, period);
(*_iter)->IsControlPoint = (divresult.rem == 0);
counter++;
_iter--;
}
}
diff --git a/Modules/ContourModel/DataManagement/mitkContourElement.h b/Modules/ContourModel/DataManagement/mitkContourElement.h
index 9191b72409..42be258cc3 100644
--- a/Modules/ContourModel/DataManagement/mitkContourElement.h
+++ b/Modules/ContourModel/DataManagement/mitkContourElement.h
@@ -1,237 +1,260 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef _mitkContourElement_H_
#define _mitkContourElement_H_
#include "mitkCommon.h"
#include <MitkContourModelExports.h>
#include <mitkNumericTypes.h>
-//#include <ANN/ANN.h>
-
#include <deque>
namespace mitk
{
/** \brief Represents a contour in 3D space.
A ContourElement is consisting of linked vertices implicitely defining the contour.
They are stored in a double ended queue making it possible to add vertices at front and
end of the contour and to iterate in both directions.
To mark a vertex as a special one it can be set as a control point.
- \note It is highly not recommend to use this class directly as no secure mechanism is used here.
- Use mitk::ContourModel instead providing some additional features.
+ \note This class assumes that it manages its vertices. So if a vertex instance is added to this
+ class the ownership of the vertex is transfered to the ContourElement instance.
+ The ContourElement instance takes care of deleting vertex instances if needed.
+ It is highly not recommend to use this class directly as it is designed as a internal class of
+ ContourModel. Therefore it is adviced to use ContourModel if contour representations are needed in
+ MITK.
*/
class MITKCONTOURMODEL_EXPORT ContourElement : public itk::LightObject
{
public:
mitkClassMacroItkParent(ContourElement, itk::LightObject);
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
- // Data container representing vertices
-
- /** \brief Represents a single vertex of contour.
- */
- struct ContourModelVertex
+ /** \brief Represents a single vertex of a contour.
+ */
+ struct MITKCONTOURMODEL_EXPORT ContourModelVertex
{
- ContourModelVertex(mitk::Point3D &point, bool active = false) : IsControlPoint(active), Coordinates(point) {}
- ContourModelVertex(const ContourModelVertex &other)
+ ContourModelVertex(const mitk::Point3D& point, bool active = false) : IsControlPoint(active), Coordinates(point) {};
+ ContourModelVertex(const ContourModelVertex& other)
: IsControlPoint(other.IsControlPoint), Coordinates(other.Coordinates)
{
- }
+ };
/** \brief Treat point special. */
bool IsControlPoint;
/** \brief Coordinates in 3D space. */
mitk::Point3D Coordinates;
+
+ bool operator ==(const ContourModelVertex& other) const;
};
- // END Data container representing vertices
- typedef ContourModelVertex VertexType;
- typedef std::deque<VertexType *> VertexListType;
- typedef VertexListType::iterator VertexIterator;
- typedef VertexListType::const_iterator ConstVertexIterator;
+ using VertexType = ContourModelVertex;
+ using VertexListType = std::deque<VertexType*>;
+ using VertexIterator = VertexListType::iterator;
+ using ConstVertexIterator = VertexListType::const_iterator;
+ using VertexSizeType = VertexListType::size_type;
- // start of inline methods
+ /**Indicates an invalid index.
+ * It is always the maximum of the unsigned int type.*/
+ static const VertexSizeType NPOS = -1;
+
+ /** \brief Return a const iterator a the front.
+ */
+ ConstVertexIterator ConstIteratorBegin() const;
+ /** \brief Return a const iterator a the end.
+ */
+ ConstVertexIterator ConstIteratorEnd() const;
+ /** \brief Return an iterator a the front.
+ */
+ VertexIterator IteratorBegin();
+ /** \brief Return an iterator a the end.
+ */
+ VertexIterator IteratorEnd();
/** \brief Return a const iterator a the front.
+ * For easier support of stl functionality.
*/
- virtual ConstVertexIterator ConstIteratorBegin() { return this->m_Vertices->begin(); }
+ ConstVertexIterator begin() const;
/** \brief Return a const iterator a the end.
+ * For easier support of stl functionality.
*/
- virtual ConstVertexIterator ConstIteratorEnd() { return this->m_Vertices->end(); }
+ ConstVertexIterator end() const;
/** \brief Return an iterator a the front.
+ * For easier support of stl functionality.
*/
- virtual VertexIterator IteratorBegin() { return this->m_Vertices->begin(); }
+ VertexIterator begin();
/** \brief Return an iterator a the end.
+ * For easier support of stl functionality.
*/
- virtual VertexIterator IteratorEnd() { return this->m_Vertices->end(); }
+ VertexIterator end();
+
/** \brief Returns the number of contained vertices.
*/
- virtual int GetSize() { return this->m_Vertices->size(); }
- // end of inline methods
+ VertexSizeType GetSize() const;
/** \brief Add a vertex at the end of the contour
\param point - coordinates in 3D space.
\param isControlPoint - is the vertex a special control point.
*/
- virtual void AddVertex(mitk::Point3D &point, bool isControlPoint);
-
- /** \brief Add a vertex at the end of the contour
- \param vertex - a contour element vertex.
- */
- virtual void AddVertex(VertexType &vertex);
+ void AddVertex(const mitk::Point3D &point, bool isControlPoint);
/** \brief Add a vertex at the front of the contour
\param point - coordinates in 3D space.
\param isControlPoint - is the vertex a control point.
*/
- virtual void AddVertexAtFront(mitk::Point3D &point, bool isControlPoint);
-
- /** \brief Add a vertex at the front of the contour
- \param vertex - a contour element vertex.
- */
- virtual void AddVertexAtFront(VertexType &vertex);
+ void AddVertexAtFront(const mitk::Point3D &point, bool isControlPoint);
/** \brief Add a vertex at a given index of the contour
\param point - coordinates in 3D space.
\param isControlPoint - is the vertex a special control point.
\param index - the index to be inserted at.
*/
- virtual void InsertVertexAtIndex(mitk::Point3D &point, bool isControlPoint, int index);
+ void InsertVertexAtIndex(const mitk::Point3D &point, bool isControlPoint, VertexSizeType index);
/** \brief Set coordinates a given index.
\param pointId Index of vertex.
\param point Coordinates.
*/
- virtual void SetVertexAt(int pointId, const mitk::Point3D &point);
+ void SetVertexAt(VertexSizeType pointId, const mitk::Point3D &point);
- /** \brief Set vertex a given index.
+ /** \brief Set vertex a given index (by copying the values).
\param pointId Index of vertex.
\param vertex Vertex.
+ \pre Passed vertex is a valid instance
*/
- virtual void SetVertexAt(int pointId, const VertexType *vertex);
+ void SetVertexAt(VertexSizeType pointId, const VertexType* vertex);
/** \brief Returns the vertex a given index
\param index
+ \pre index must be valid.
*/
- virtual VertexType *GetVertexAt(int index);
+ VertexType* GetVertexAt(VertexSizeType index);
+ const VertexType* GetVertexAt(VertexSizeType index) const;
/** \brief Returns the approximate nearest vertex a given posoition in 3D space
\param point - query position in 3D space.
\param eps - the error bound for search algorithm.
*/
- virtual VertexType *GetVertexAt(const mitk::Point3D &point, float eps);
+ VertexType *GetVertexAt(const mitk::Point3D &point, float eps);
/** \brief Returns the index of the given vertex within the contour.
\param vertex - the vertex to be searched.
- \return index of vertex. -1 if not found.
+ \return index of vertex. Returns ContourElement::NPOS if not found.
*/
- virtual int GetIndex(const VertexType *vertex);
+ VertexSizeType GetIndex(const VertexType *vertex) const;
/** \brief Returns the container of the vertices.
*/
- VertexListType *GetVertexList();
+ const VertexListType *GetVertexList() const;
/** \brief Returns whether the contour element is empty.
*/
- bool IsEmpty();
+ bool IsEmpty() const;
/** \brief Returns if the conour is closed or not.
*/
- virtual bool IsClosed();
+ bool IsClosed() const;
/** \brief Returns whether a given point is near a contour, according to eps.
\param point - query position in 3D space.
\param eps - the error bound for search algorithm.
*/
- virtual bool IsNearContour(const mitk::Point3D &point, float eps);
+ bool IsNearContour(const mitk::Point3D &point, float eps) const;
/** \brief Close the contour.
Connect first with last element.
*/
- virtual void Close();
+ void Close();
/** \brief Open the contour.
Disconnect first and last element.
*/
- virtual void Open();
+ void Open();
/** \brief Set the contours IsClosed property.
\param isClosed - true = closed; false = open;
*/
- virtual void SetClosed(bool isClosed);
+ void SetClosed(bool isClosed);
/** \brief Concatenate the contuor with a another contour.
- All vertices of the other contour will be added after last vertex.
+ All vertices of the other contour will be cloned and added after last vertex.
\param other - the other contour
- \param check - set it true to avoid intersections
+ \param check - set it true to avoid adding of vertices that are already in the source contour
*/
- void Concatenate(mitk::ContourElement *other, bool check);
+ void Concatenate(const mitk::ContourElement *other, bool check);
/** \brief Remove the given vertex from the container if exists.
\param vertex - the vertex to be removed.
*/
- virtual bool RemoveVertex(const VertexType *vertex);
+ bool RemoveVertex(const VertexType *vertex);
/** \brief Remove a vertex at given index within the container if exists.
\param index - the index where the vertex should be removed.
*/
- virtual bool RemoveVertexAt(int index);
+ bool RemoveVertexAt(VertexSizeType index);
/** \brief Remove the approximate nearest vertex at given position in 3D space if one exists.
\param point - query point in 3D space.
\param eps - error bound for search algorithm.
*/
- virtual bool RemoveVertexAt(mitk::Point3D &point, float eps);
+ bool RemoveVertexAt(const mitk::Point3D &point, double eps);
/** \brief Clear the storage container.
*/
- virtual void Clear();
+ void Clear();
/** \brief Returns the approximate nearest vertex a given posoition in 3D space
\param point - query position in 3D space.
\param eps - the error bound for search algorithm.
*/
- VertexType *BruteForceGetVertexAt(const mitk::Point3D &point, float eps);
+ VertexType *BruteForceGetVertexAt(const mitk::Point3D &point, double eps);
- /** \brief Returns the approximate nearest vertex a given posoition in 3D space
- \param point - query position in 3D space.
- \param eps - the error bound for search algorithm.
- */
- // VertexType* OptimizedGetVertexAt(const mitk::Point3D &point, float eps);
-
- VertexListType *GetControlVertices();
+ /** Returns a list pointing to all vertices that are indicated to be control
+ points.
+ \remark It is important to note, that the vertex pointers in the returned
+ list directly point to the vertices stored interanlly. So they are still
+ owned by the ContourElement instance that returns the list. If one wants
+ to take over ownership, one has to clone the vertex instances.
+ */
+ VertexListType GetControlVertices() const;
/** \brief Uniformly redistribute control points with a given period (in number of vertices)
\param vertex - the vertex around which the redistribution is done.
\param period - number of vertices between control points.
*/
void RedistributeControlVertices(const VertexType *vertex, int period);
protected:
mitkCloneMacro(Self);
- ContourElement();
+ ContourElement() = default;
ContourElement(const mitk::ContourElement &other);
- ~ContourElement() override;
+ ~ContourElement();
+
+ ContourElement& operator = (const ContourElement & other);
+
+ /** Internal helper function to correctly remove the element indicated by the iterator
+ from the list. After the call the iterator is invalid.
+ Caller of the function must ensure that the iterator is valid!.
+ \result Indicates if the element indicated by the iterator was removed. If iterator points to end it returns false.*/
+ bool RemoveVertexByIterator(VertexListType::iterator& iter);
- VertexListType *m_Vertices; // double ended queue with vertices
- bool m_IsClosed;
+ VertexListType m_Vertices; // double ended queue with vertices
+ bool m_IsClosed = false;
};
} // namespace mitk
#endif // _mitkContourElement_H_
diff --git a/Modules/ContourModel/DataManagement/mitkContourModel.cpp b/Modules/ContourModel/DataManagement/mitkContourModel.cpp
index 6d88174b43..d6e04cb150 100644
--- a/Modules/ContourModel/DataManagement/mitkContourModel.cpp
+++ b/Modules/ContourModel/DataManagement/mitkContourModel.cpp
@@ -1,635 +1,628 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkContourModel.h>
#include <mitkPlaneGeometry.h>
mitk::ContourModel::ContourModel() : m_UpdateBoundingBox(true)
{
// set to initial state
this->InitializeEmpty();
}
-mitk::ContourModel::ContourModel(const mitk::ContourModel &other)
- : mitk::BaseData(other), m_ContourSeries(other.m_ContourSeries), m_lineInterpolation(other.m_lineInterpolation)
+mitk::ContourModel::ContourModel(const ContourModel &other)
+ : BaseData(other), m_ContourSeries(other.m_ContourSeries), m_lineInterpolation(other.m_lineInterpolation)
{
m_SelectedVertex = nullptr;
}
mitk::ContourModel::~ContourModel()
{
m_SelectedVertex = nullptr;
this->m_ContourSeries.clear(); // TODO check destruction
}
-void mitk::ContourModel::AddVertex(mitk::Point3D &vertex, int timestep)
+void mitk::ContourModel::AddVertex(const Point3D &vertex, TimeStepType timestep)
{
if (!this->IsEmptyTimeStep(timestep))
{
this->AddVertex(vertex, false, timestep);
}
}
-void mitk::ContourModel::AddVertex(mitk::Point3D &vertex, bool isControlPoint, int timestep)
+void mitk::ContourModel::AddVertex(const Point3D &vertex, bool isControlPoint, TimeStepType timestep)
{
if (!this->IsEmptyTimeStep(timestep))
{
this->m_ContourSeries[timestep]->AddVertex(vertex, isControlPoint);
this->InvokeEvent(ContourModelSizeChangeEvent());
this->Modified();
this->m_UpdateBoundingBox = true;
}
}
-void mitk::ContourModel::AddVertex(VertexType &vertex, int timestep)
+void mitk::ContourModel::AddVertex(const VertexType &vertex, TimeStepType timestep)
{
- if (!this->IsEmptyTimeStep(timestep))
- {
- this->m_ContourSeries[timestep]->AddVertex(vertex);
- this->InvokeEvent(ContourModelSizeChangeEvent());
- this->Modified();
- this->m_UpdateBoundingBox = true;
- }
-}
-
-void mitk::ContourModel::AddVertex(const VertexType *vertex, int timestep)
-{
- if (vertex != nullptr)
- {
- this->m_ContourSeries[timestep]->AddVertex(*const_cast<VertexType *>(vertex));
- }
+ this->AddVertex(vertex.Coordinates, vertex.IsControlPoint, timestep);
}
-void mitk::ContourModel::AddVertexAtFront(mitk::Point3D &vertex, int timestep)
+void mitk::ContourModel::AddVertexAtFront(const Point3D &vertex, TimeStepType timestep)
{
if (!this->IsEmptyTimeStep(timestep))
{
this->AddVertexAtFront(vertex, false, timestep);
}
}
-void mitk::ContourModel::AddVertexAtFront(mitk::Point3D &vertex, bool isControlPoint, int timestep)
+void mitk::ContourModel::AddVertexAtFront(const Point3D &vertex, bool isControlPoint, TimeStepType timestep)
{
if (!this->IsEmptyTimeStep(timestep))
{
this->m_ContourSeries[timestep]->AddVertexAtFront(vertex, isControlPoint);
this->InvokeEvent(ContourModelSizeChangeEvent());
this->Modified();
this->m_UpdateBoundingBox = true;
}
}
-void mitk::ContourModel::AddVertexAtFront(VertexType &vertex, int timestep)
+void mitk::ContourModel::AddVertexAtFront(const VertexType &vertex, TimeStepType timestep)
{
- if (!this->IsEmptyTimeStep(timestep))
- {
- this->m_ContourSeries[timestep]->AddVertexAtFront(vertex);
- this->InvokeEvent(ContourModelSizeChangeEvent());
- this->Modified();
- this->m_UpdateBoundingBox = true;
- }
+ this->AddVertexAtFront(vertex.Coordinates, vertex.IsControlPoint, timestep);
}
-bool mitk::ContourModel::SetVertexAt(int pointId, const Point3D &point, unsigned int timestep)
+bool mitk::ContourModel::SetVertexAt(int pointId, const Point3D &point, TimeStepType timestep)
{
if (!this->IsEmptyTimeStep(timestep))
{
- if (pointId >= 0 && this->m_ContourSeries[timestep]->GetSize() > pointId)
+ if (pointId >= 0 && this->m_ContourSeries[timestep]->GetSize() > ContourElement::VertexSizeType(pointId))
{
this->m_ContourSeries[timestep]->SetVertexAt(pointId, point);
this->Modified();
this->m_UpdateBoundingBox = true;
return true;
}
return false;
}
return false;
}
-bool mitk::ContourModel::SetVertexAt(int pointId, const VertexType *vertex, unsigned int timestep)
+bool mitk::ContourModel::SetVertexAt(int pointId, const VertexType *vertex, TimeStepType timestep)
{
if (vertex == nullptr)
return false;
if (!this->IsEmptyTimeStep(timestep))
{
- if (pointId >= 0 && this->m_ContourSeries[timestep]->GetSize() > pointId)
+ if (pointId >= 0 && this->m_ContourSeries[timestep]->GetSize() > ContourElement::VertexSizeType(pointId))
{
this->m_ContourSeries[timestep]->SetVertexAt(pointId, vertex);
this->Modified();
this->m_UpdateBoundingBox = true;
return true;
}
return false;
}
return false;
}
-void mitk::ContourModel::InsertVertexAtIndex(mitk::Point3D &vertex, int index, bool isControlPoint, int timestep)
+void mitk::ContourModel::InsertVertexAtIndex(const Point3D &vertex, int index, bool isControlPoint, TimeStepType timestep)
{
if (!this->IsEmptyTimeStep(timestep))
{
- if (index >= 0 && this->m_ContourSeries[timestep]->GetSize() > index)
+ if (index >= 0 && this->m_ContourSeries[timestep]->GetSize() > ContourElement::VertexSizeType(index))
{
this->m_ContourSeries[timestep]->InsertVertexAtIndex(vertex, isControlPoint, index);
this->InvokeEvent(ContourModelSizeChangeEvent());
this->Modified();
this->m_UpdateBoundingBox = true;
}
}
}
-bool mitk::ContourModel::IsEmpty(int timestep) const
+void mitk::ContourModel::UpdateContour(const ContourModel* sourceModel, TimeStepType destinationTimeStep, TimeStepType sourceTimeStep)
+{
+ if (nullptr == sourceModel)
+ {
+ mitkThrow() << "Cannot update contour. Passed source model is invalid.";
+ }
+
+ if (!sourceModel->GetTimeGeometry()->IsValidTimeStep(sourceTimeStep))
+ {
+ mitkThrow() << "Cannot update contour. Source contour time geometry does not support passed time step. Invalid time step: " << sourceTimeStep;
+ }
+
+ if (!this->GetTimeGeometry()->IsValidTimeStep(destinationTimeStep))
+ {
+ MITK_WARN << "Cannot update contour. Contour time geometry does not support passed time step. Invalid time step: " << destinationTimeStep;
+ return;
+ }
+
+ this->Clear(destinationTimeStep);
+
+ std::for_each(sourceModel->Begin(sourceTimeStep), sourceModel->End(sourceTimeStep), [this, destinationTimeStep](ContourElement::VertexType* vertex) {
+ this->m_ContourSeries[destinationTimeStep]->AddVertex(vertex->Coordinates, vertex->IsControlPoint);
+ });
+
+ this->InvokeEvent(ContourModelSizeChangeEvent());
+ this->Modified();
+ this->m_UpdateBoundingBox = true;
+}
+
+bool mitk::ContourModel::IsEmpty(TimeStepType timestep) const
{
if (!this->IsEmptyTimeStep(timestep))
{
return this->m_ContourSeries[timestep]->IsEmpty();
}
return true;
}
bool mitk::ContourModel::IsEmpty() const
{
return this->IsEmpty(0);
}
-int mitk::ContourModel::GetNumberOfVertices(int timestep) const
+int mitk::ContourModel::GetNumberOfVertices(TimeStepType timestep) const
{
if (!this->IsEmptyTimeStep(timestep))
{
return this->m_ContourSeries[timestep]->GetSize();
}
return -1;
}
-const mitk::ContourModel::VertexType *mitk::ContourModel::GetVertexAt(int index, int timestep) const
+const mitk::ContourModel::VertexType *mitk::ContourModel::GetVertexAt(int index, TimeStepType timestep) const
{
- if (!this->IsEmptyTimeStep(timestep))
+ if (!this->IsEmptyTimeStep(timestep) && this->m_ContourSeries[timestep]->GetSize() > mitk::ContourElement::VertexSizeType(index))
{
return this->m_ContourSeries[timestep]->GetVertexAt(index);
}
return nullptr;
}
-int mitk::ContourModel::GetIndex(const VertexType *vertex, int timestep)
+int mitk::ContourModel::GetIndex(const VertexType *vertex, TimeStepType timestep)
{
if (!this->IsEmptyTimeStep(timestep))
{
return this->m_ContourSeries[timestep]->GetIndex(vertex);
}
return -1;
}
-void mitk::ContourModel::Close(int timestep)
+void mitk::ContourModel::Close(TimeStepType timestep)
{
if (!this->IsEmptyTimeStep(timestep))
{
this->m_ContourSeries[timestep]->Close();
this->InvokeEvent(ContourModelClosedEvent());
this->Modified();
this->m_UpdateBoundingBox = true;
}
}
-void mitk::ContourModel::Open(int timestep)
+void mitk::ContourModel::Open(TimeStepType timestep)
{
if (!this->IsEmptyTimeStep(timestep))
{
this->m_ContourSeries[timestep]->Open();
this->InvokeEvent(ContourModelClosedEvent());
this->Modified();
this->m_UpdateBoundingBox = true;
}
}
-void mitk::ContourModel::SetClosed(bool isClosed, int timestep)
+void mitk::ContourModel::SetClosed(bool isClosed, TimeStepType timestep)
{
if (!this->IsEmptyTimeStep(timestep))
{
this->m_ContourSeries[timestep]->SetClosed(isClosed);
this->InvokeEvent(ContourModelClosedEvent());
this->Modified();
this->m_UpdateBoundingBox = true;
}
}
bool mitk::ContourModel::IsEmptyTimeStep(unsigned int t) const
{
return (this->m_ContourSeries.size() <= t);
}
-bool mitk::ContourModel::IsNearContour(mitk::Point3D &point, float eps, int timestep)
+bool mitk::ContourModel::IsNearContour(Point3D &point, float eps, TimeStepType timestep)
{
if (!this->IsEmptyTimeStep(timestep))
{
return this->m_ContourSeries[timestep]->IsNearContour(point, eps);
}
return false;
}
-void mitk::ContourModel::Concatenate(mitk::ContourModel *other, int timestep, bool check)
+void mitk::ContourModel::Concatenate(ContourModel *other, TimeStepType timestep, bool check)
{
if (!this->IsEmptyTimeStep(timestep))
{
if (!this->m_ContourSeries[timestep]->IsClosed())
{
this->m_ContourSeries[timestep]->Concatenate(other->m_ContourSeries[timestep], check);
this->InvokeEvent(ContourModelSizeChangeEvent());
this->Modified();
this->m_UpdateBoundingBox = true;
}
}
}
-mitk::ContourModel::VertexIterator mitk::ContourModel::Begin(int timestep) const
+mitk::ContourModel::VertexIterator mitk::ContourModel::Begin(TimeStepType timestep) const
{
return this->IteratorBegin(timestep);
}
-mitk::ContourModel::VertexIterator mitk::ContourModel::IteratorBegin(int timestep) const
+mitk::ContourModel::VertexIterator mitk::ContourModel::IteratorBegin(TimeStepType timestep) const
{
if (!this->IsEmptyTimeStep(timestep))
{
return this->m_ContourSeries[timestep]->IteratorBegin();
}
else
{
mitkThrow() << "No iterator at invalid timestep " << timestep << ". There are only " << this->GetTimeSteps()
<< " timesteps available.";
}
}
-mitk::ContourModel::VertexIterator mitk::ContourModel::End(int timestep) const
+mitk::ContourModel::VertexIterator mitk::ContourModel::End(TimeStepType timestep) const
{
return this->IteratorEnd(timestep);
}
-mitk::ContourModel::VertexIterator mitk::ContourModel::IteratorEnd(int timestep) const
+mitk::ContourModel::VertexIterator mitk::ContourModel::IteratorEnd(TimeStepType timestep) const
{
if (!this->IsEmptyTimeStep(timestep))
{
return this->m_ContourSeries[timestep]->IteratorEnd();
}
else
{
mitkThrow() << "No iterator at invalid timestep " << timestep << ". There are only " << this->GetTimeSteps()
<< " timesteps available.";
}
}
bool mitk::ContourModel::IsClosed(int timestep) const
{
if (!this->IsEmptyTimeStep(timestep))
{
return this->m_ContourSeries[timestep]->IsClosed();
}
return false;
}
-bool mitk::ContourModel::SelectVertexAt(mitk::Point3D &point, float eps, int timestep)
+bool mitk::ContourModel::SelectVertexAt(Point3D &point, float eps, TimeStepType timestep)
{
if (!this->IsEmptyTimeStep(timestep))
{
this->m_SelectedVertex = this->m_ContourSeries[timestep]->GetVertexAt(point, eps);
}
return this->m_SelectedVertex != nullptr;
}
-bool mitk::ContourModel::SelectVertexAt(int index, int timestep)
+bool mitk::ContourModel::SelectVertexAt(int index, TimeStepType timestep)
{
if (!this->IsEmptyTimeStep(timestep) && index >= 0)
{
return (this->m_SelectedVertex = this->m_ContourSeries[timestep]->GetVertexAt(index));
}
return false;
}
-bool mitk::ContourModel::SetControlVertexAt(mitk::Point3D &point, float eps, int timestep)
+bool mitk::ContourModel::SetControlVertexAt(Point3D &point, float eps, TimeStepType timestep)
{
if (!this->IsEmptyTimeStep(timestep))
{
VertexType *vertex = this->m_ContourSeries[timestep]->GetVertexAt(point, eps);
if (vertex != nullptr)
{
vertex->IsControlPoint = true;
return true;
}
}
return false;
}
-bool mitk::ContourModel::SetControlVertexAt(int index, int timestep)
+bool mitk::ContourModel::SetControlVertexAt(int index, TimeStepType timestep)
{
if (!this->IsEmptyTimeStep(timestep) && index >= 0)
{
VertexType *vertex = this->m_ContourSeries[timestep]->GetVertexAt(index);
if (vertex != nullptr)
{
vertex->IsControlPoint = true;
return true;
}
}
return false;
}
-bool mitk::ContourModel::RemoveVertex(const VertexType *vertex, int timestep)
+bool mitk::ContourModel::RemoveVertex(const VertexType *vertex, TimeStepType timestep)
{
if (!this->IsEmptyTimeStep(timestep))
{
if (this->m_ContourSeries[timestep]->RemoveVertex(vertex))
{
this->Modified();
this->m_UpdateBoundingBox = true;
this->InvokeEvent(ContourModelSizeChangeEvent());
return true;
}
}
return false;
}
-bool mitk::ContourModel::RemoveVertexAt(int index, int timestep)
+bool mitk::ContourModel::RemoveVertexAt(int index, TimeStepType timestep)
{
if (!this->IsEmptyTimeStep(timestep))
{
if (this->m_ContourSeries[timestep]->RemoveVertexAt(index))
{
this->Modified();
this->m_UpdateBoundingBox = true;
this->InvokeEvent(ContourModelSizeChangeEvent());
return true;
}
}
return false;
}
-bool mitk::ContourModel::RemoveVertexAt(mitk::Point3D &point, float eps, int timestep)
+bool mitk::ContourModel::RemoveVertexAt(Point3D &point, float eps, TimeStepType timestep)
{
if (!this->IsEmptyTimeStep(timestep))
{
if (this->m_ContourSeries[timestep]->RemoveVertexAt(point, eps))
{
this->Modified();
this->m_UpdateBoundingBox = true;
this->InvokeEvent(ContourModelSizeChangeEvent());
return true;
}
}
return false;
}
-void mitk::ContourModel::ShiftSelectedVertex(mitk::Vector3D &translate)
+void mitk::ContourModel::ShiftSelectedVertex(Vector3D &translate)
{
if (this->m_SelectedVertex)
{
this->ShiftVertex(this->m_SelectedVertex, translate);
this->Modified();
this->m_UpdateBoundingBox = true;
}
}
-void mitk::ContourModel::ShiftContour(mitk::Vector3D &translate, int timestep)
+void mitk::ContourModel::ShiftContour(Vector3D &translate, TimeStepType timestep)
{
if (!this->IsEmptyTimeStep(timestep))
{
- VertexListType *vList = this->m_ContourSeries[timestep]->GetVertexList();
- auto it = vList->begin();
- auto end = vList->end();
-
// shift all vertices
- while (it != end)
+ for (auto vertex : *(this->m_ContourSeries[timestep]))
{
- this->ShiftVertex((*it), translate);
- it++;
+ this->ShiftVertex(vertex, translate);
}
this->Modified();
this->m_UpdateBoundingBox = true;
this->InvokeEvent(ContourModelShiftEvent());
}
}
-void mitk::ContourModel::ShiftVertex(VertexType *vertex, mitk::Vector3D &vector)
+void mitk::ContourModel::ShiftVertex(VertexType *vertex, Vector3D &vector)
{
vertex->Coordinates[0] += vector[0];
vertex->Coordinates[1] += vector[1];
vertex->Coordinates[2] += vector[2];
}
-void mitk::ContourModel::Clear(int timestep)
+void mitk::ContourModel::Clear(TimeStepType timestep)
{
if (!this->IsEmptyTimeStep(timestep))
{
// clear data at timestep
this->m_ContourSeries[timestep]->Clear();
- this->InitializeEmpty();
this->Modified();
this->m_UpdateBoundingBox = true;
}
}
void mitk::ContourModel::Expand(unsigned int timeSteps)
{
std::size_t oldSize = this->m_ContourSeries.size();
if (static_cast<std::size_t>(timeSteps) > oldSize)
{
Superclass::Expand(timeSteps);
// insert contours for each new timestep
for (std::size_t i = oldSize; i < static_cast<std::size_t>(timeSteps); i++)
{
- m_ContourSeries.push_back(mitk::ContourElement::New());
+ m_ContourSeries.push_back(ContourElement::New());
}
this->InvokeEvent(ContourModelExpandTimeBoundsEvent());
}
}
void mitk::ContourModel::SetRequestedRegionToLargestPossibleRegion()
{
// no support for regions
}
bool mitk::ContourModel::RequestedRegionIsOutsideOfTheBufferedRegion()
{
// no support for regions
return false;
}
bool mitk::ContourModel::VerifyRequestedRegion()
{
// no support for regions
return true;
}
-const mitk::BaseGeometry *mitk::ContourModel::GetUpdatedGeometry(int t)
-{
- return Superclass::GetUpdatedGeometry(t);
-}
-
-mitk::BaseGeometry *mitk::ContourModel::GetGeometry(int t) const
-{
- return Superclass::GetGeometry(t);
-}
-
void mitk::ContourModel::SetRequestedRegion(const itk::DataObject * /*data*/)
{
// no support for regions
}
void mitk::ContourModel::Clear()
{
// clear data and set to initial state again
this->ClearData();
this->InitializeEmpty();
this->Modified();
this->m_UpdateBoundingBox = true;
}
-void mitk::ContourModel::RedistributeControlVertices(int period, int timestep)
+void mitk::ContourModel::RedistributeControlVertices(int period, TimeStepType timestep)
{
if (!this->IsEmptyTimeStep(timestep))
{
this->m_ContourSeries[timestep]->RedistributeControlVertices(this->GetSelectedVertex(), period);
this->InvokeEvent(ContourModelClosedEvent());
this->Modified();
this->m_UpdateBoundingBox = true;
}
}
void mitk::ContourModel::ClearData()
{
// call the superclass, this releases the data of BaseData
Superclass::ClearData();
// clear out the time resolved contours
this->m_ContourSeries.clear();
}
void mitk::ContourModel::Initialize()
{
this->InitializeEmpty();
this->Modified();
this->m_UpdateBoundingBox = true;
}
-void mitk::ContourModel::Initialize(mitk::ContourModel &other)
+void mitk::ContourModel::Initialize(const ContourModel &other)
{
- mitk::TimeStepType numberOfTimesteps = other.GetTimeGeometry()->CountTimeSteps();
+ TimeStepType numberOfTimesteps = other.GetTimeGeometry()->CountTimeSteps();
this->InitializeTimeGeometry(numberOfTimesteps);
- for (mitk::TimeStepType currentTimestep = 0; currentTimestep < numberOfTimesteps; currentTimestep++)
+ for (TimeStepType currentTimestep = 0; currentTimestep < numberOfTimesteps; currentTimestep++)
{
- this->m_ContourSeries.push_back(mitk::ContourElement::New());
+ this->m_ContourSeries.push_back(ContourElement::New());
this->SetClosed(other.IsClosed(currentTimestep), currentTimestep);
}
m_SelectedVertex = nullptr;
this->m_lineInterpolation = other.m_lineInterpolation;
this->Modified();
this->m_UpdateBoundingBox = true;
}
void mitk::ContourModel::InitializeEmpty()
{
// clear data at timesteps
this->m_ContourSeries.resize(0);
- this->m_ContourSeries.push_back(mitk::ContourElement::New());
+ this->m_ContourSeries.push_back(ContourElement::New());
// set number of timesteps to one
this->InitializeTimeGeometry(1);
m_SelectedVertex = nullptr;
this->m_lineInterpolation = ContourModel::LINEAR;
}
void mitk::ContourModel::UpdateOutputInformation()
{
if (this->GetSource())
{
this->GetSource()->UpdateOutputInformation();
}
if (this->m_UpdateBoundingBox)
{
// update the bounds of the geometry according to the stored vertices
ScalarType mitkBounds[6];
// calculate the boundingbox at each timestep
typedef itk::BoundingBox<unsigned long, 3, ScalarType> BoundingBoxType;
typedef BoundingBoxType::PointsContainer PointsContainer;
int timesteps = this->GetTimeSteps();
// iterate over the timesteps
for (int currenTimeStep = 0; currenTimeStep < timesteps; currenTimeStep++)
{
- if (dynamic_cast<mitk::PlaneGeometry *>(this->GetGeometry(currenTimeStep)))
+ if (dynamic_cast<PlaneGeometry *>(this->GetGeometry(currenTimeStep)))
{
// do not update bounds for 2D geometries, as they are unfortunately defined with min bounds 0!
return;
}
else
{ // we have a 3D geometry -> let's update bounds
// only update bounds if the contour was modified
if (this->GetMTime() > this->GetGeometry(currenTimeStep)->GetBoundingBox()->GetMTime())
{
mitkBounds[0] = 0.0;
mitkBounds[1] = 0.0;
mitkBounds[2] = 0.0;
mitkBounds[3] = 0.0;
mitkBounds[4] = 0.0;
mitkBounds[5] = 0.0;
BoundingBoxType::Pointer boundingBox = BoundingBoxType::New();
PointsContainer::Pointer points = PointsContainer::New();
auto it = this->IteratorBegin(currenTimeStep);
auto end = this->IteratorEnd(currenTimeStep);
// fill the boundingbox with the points
while (it != end)
{
Point3D currentP = (*it)->Coordinates;
BoundingBoxType::PointType p;
p.CastFrom(currentP);
points->InsertElement(points->Size(), p);
it++;
}
// construct the new boundingBox
boundingBox->SetPoints(points);
boundingBox->ComputeBoundingBox();
BoundingBoxType::BoundsArrayType tmp = boundingBox->GetBounds();
mitkBounds[0] = tmp[0];
mitkBounds[1] = tmp[1];
mitkBounds[2] = tmp[2];
mitkBounds[3] = tmp[3];
mitkBounds[4] = tmp[4];
mitkBounds[5] = tmp[5];
// set boundingBox at current timestep
BaseGeometry *geometry3d = this->GetGeometry(currenTimeStep);
geometry3d->SetBounds(mitkBounds);
}
}
}
this->m_UpdateBoundingBox = false;
}
GetTimeGeometry()->Update();
}
-void mitk::ContourModel::ExecuteOperation(mitk::Operation * /*operation*/)
+void mitk::ContourModel::ExecuteOperation(Operation * /*operation*/)
{
// not supported yet
}
diff --git a/Modules/ContourModel/DataManagement/mitkContourModel.h b/Modules/ContourModel/DataManagement/mitkContourModel.h
index 45aae9bcda..d234d9cefb 100644
--- a/Modules/ContourModel/DataManagement/mitkContourModel.h
+++ b/Modules/ContourModel/DataManagement/mitkContourModel.h
@@ -1,453 +1,437 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef _MITK_CONTOURMODEL_H_
#define _MITK_CONTOURMODEL_H_
#include "mitkBaseData.h"
#include "mitkCommon.h"
#include <MitkContourModelExports.h>
#include <mitkContourElement.h>
namespace mitk
{
/**
\brief ContourModel is a structure of linked vertices defining a contour in 3D space.
The vertices are stored in a mitk::ContourElement is stored for each timestep.
The contour line segments are implicitly defined by the given linked vertices.
By default two control points are are linked by a straight line.It is possible to add
vertices at front and end of the contour and to iterate in both directions.
Points are specified containing coordinates and additional (data) information,
see mitk::ContourElement.
For accessing a specific vertex either an index or a position in 3D Space can be used.
The vertices are best accessed by using a VertexIterator.
Interaction with the contour is thus available without any mitk interactor class using the
api of ContourModel. It is possible to shift single vertices also as shifting the whole
contour.
A contour can be either open like a single curved line segment or
closed. A closed contour can for example represent a jordan curve.
\section mitkContourModelDisplayOptions Display Options
The default mappers for this data structure are mitk::ContourModelGLMapper2D and
mitk::ContourModelMapper3D. See these classes for display options which can
can be set via properties.
*/
class MITKCONTOURMODEL_EXPORT ContourModel : public BaseData
{
public:
mitkClassMacro(ContourModel, BaseData);
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
- /*+++++++++++++++ typedefs +++++++++++++++++++++++++++++++*/
- typedef mitk::ContourElement::VertexType VertexType;
- typedef mitk::ContourElement::VertexListType VertexListType;
- typedef mitk::ContourElement::VertexIterator VertexIterator;
- typedef mitk::ContourElement::ConstVertexIterator ConstVertexIterator;
- typedef std::vector<mitk::ContourElement::Pointer> ContourModelSeries;
+ /*+++++++++++++++ typedefs +++++++++++++++++++++++++++++++*/
+ typedef ContourElement::VertexType VertexType;
+ typedef ContourElement::VertexListType VertexListType;
+ typedef ContourElement::VertexIterator VertexIterator;
+ typedef ContourElement::ConstVertexIterator ConstVertexIterator;
+ typedef std::vector<ContourElement::Pointer> ContourModelSeries;
/*+++++++++++++++ END typedefs ++++++++++++++++++++++++++++*/
/** \brief Possible interpolation of the line segments between control points */
enum LineSegmentInterpolation
{
LINEAR,
B_SPLINE
};
/*++++++++++++++++ inline methods +++++++++++++++++++++++*/
/** \brief Get the current selected vertex.
*/
VertexType *GetSelectedVertex() { return this->m_SelectedVertex; }
/** \brief Deselect vertex.
*/
void Deselect() { this->m_SelectedVertex = nullptr; }
/** \brief Set selected vertex as control point
*/
void SetSelectedVertexAsControlPoint(bool isControlPoint = true)
{
if (this->m_SelectedVertex)
{
m_SelectedVertex->IsControlPoint = isControlPoint;
this->Modified();
}
}
/** \brief Set the interpolation of the line segments between control points.
*/
void SetLineSegmentInterpolation(LineSegmentInterpolation interpolation)
{
this->m_lineInterpolation = interpolation;
this->Modified();
}
/** \brief Get the interpolation of the line segments between control points.
*/
LineSegmentInterpolation GetLineSegmentInterpolation() { return this->m_lineInterpolation; }
/*++++++++++++++++ END inline methods +++++++++++++++++++++++*/
/** \brief Add a vertex to the contour at given timestep.
The vertex is added at the end of contour.
\param vertex - coordinate representation of a control point
\param timestep - the timestep at which the vertex will be add ( default 0)
@note Adding a vertex to a timestep which exceeds the timebounds of the contour
will not be added, the TimeGeometry will not be expanded.
*/
- void AddVertex(mitk::Point3D &vertex, int timestep = 0);
+ void AddVertex(const Point3D &vertex, TimeStepType timestep = 0);
/** \brief Add a vertex to the contour at given timestep.
- The vertex is added at the end of contour.
-
+ A copy of the passed vertex is added at the end of contour.
\param vertex - coordinate representation of a control point
\param timestep - the timestep at which the vertex will be add ( default 0)
-
@note Adding a vertex to a timestep which exceeds the timebounds of the contour
will not be added, the TimeGeometry will not be expanded.
*/
- void AddVertex(VertexType &vertex, int timestep = 0);
-
- /** \brief Add a vertex to the contour at given timestep.
- The vertex is added at the end of contour.
-
- \param vertex - coordinate representation of a control point
- \param timestep - the timestep at which the vertex will be add ( default 0)
-
- @note Adding a vertex to a timestep which exceeds the timebounds of the contour
- will not be added, the TimeSlicedGeometry will not be expanded.
- */
- void AddVertex(const VertexType *vertex, int timestep = 0);
+ void AddVertex(const VertexType &vertex, TimeStepType timestep = 0);
/** \brief Add a vertex to the contour.
-
\param vertex - coordinate representation of a control point
\param timestep - the timestep at which the vertex will be add ( default 0)
\param isControlPoint - specifies the vertex to be handled in a special way (e.g. control points
will be rendered).
-
-
@note Adding a vertex to a timestep which exceeds the timebounds of the contour
will not be added, the TimeGeometry will not be expanded.
*/
- void AddVertex(mitk::Point3D &vertex, bool isControlPoint, int timestep = 0);
+ void AddVertex(const Point3D& vertex, bool isControlPoint, TimeStepType timestep = 0);
+
+ /** Clears the contour of destinationTimeStep and copies
+ the contour of the passed source model at the sourceTimeStep.
+ @pre soureModel must point to a valid instance
+ @pre sourceTimePoint must be valid
+ @note Updateing a vertex to a timestep which exceeds the timebounds of the contour
+ will not be added, the TimeGeometry will not be expanded.
+ */
+ void UpdateContour(const ContourModel* sourceModel, TimeStepType destinationTimeStep, TimeStepType sourceTimeStep);
/** \brief Add a vertex to the contour at given timestep AT THE FRONT of the contour.
The vertex is added at the FRONT of contour.
\param vertex - coordinate representation of a control point
\param timestep - the timestep at which the vertex will be add ( default 0)
@note Adding a vertex to a timestep which exceeds the timebounds of the contour
will not be added, the TimeGeometry will not be expanded.
*/
- void AddVertexAtFront(mitk::Point3D &vertex, int timestep = 0);
+ void AddVertexAtFront(const Point3D &vertex, TimeStepType timestep = 0);
/** \brief Add a vertex to the contour at given timestep AT THE FRONT of the contour.
The vertex is added at the FRONT of contour.
\param vertex - coordinate representation of a control point
\param timestep - the timestep at which the vertex will be add ( default 0)
@note Adding a vertex to a timestep which exceeds the timebounds of the contour
will not be added, the TimeGeometry will not be expanded.
*/
- void AddVertexAtFront(VertexType &vertex, int timestep = 0);
+ void AddVertexAtFront(const VertexType &vertex, TimeStepType timestep = 0);
/** \brief Add a vertex to the contour at given timestep AT THE FRONT of the contour.
\param vertex - coordinate representation of a control point
\param timestep - the timestep at which the vertex will be add ( default 0)
\param isControlPoint - specifies the vertex to be handled in a special way (e.g. control points
will be rendered).
@note Adding a vertex to a timestep which exceeds the timebounds of the contour
will not be added, the TimeGeometry will not be expanded.
*/
- void AddVertexAtFront(mitk::Point3D &vertex, bool isControlPoint, int timestep = 0);
+ void AddVertexAtFront(const Point3D &vertex, bool isControlPoint, TimeStepType timestep = 0);
/** \brief Insert a vertex at given index.
*/
- void InsertVertexAtIndex(mitk::Point3D &vertex, int index, bool isControlPoint = false, int timestep = 0);
+ void InsertVertexAtIndex(const Point3D &vertex, int index, bool isControlPoint = false, TimeStepType timestep = 0);
/** \brief Set a coordinates for point at given index.
*/
- bool SetVertexAt(int pointId, const mitk::Point3D &point, unsigned int timestep = 0);
+ bool SetVertexAt(int pointId, const Point3D &point, TimeStepType timestep = 0);
- /** \brief Set a coordinates for point at given index.
+ /** \brief Set a coordinates and control state for point at given index.
*/
- bool SetVertexAt(int pointId, const VertexType *vertex, unsigned int timestep = 0);
+ bool SetVertexAt(int pointId, const VertexType *vertex, TimeStepType timestep = 0);
/** \brief Return if the contour is closed or not.
*/
bool IsClosed(int timestep = 0) const;
/** \brief Concatenate two contours.
The starting control point of the other will be added at the end of the contour.
\param other
\param timestep - the timestep at which the vertex will be add ( default 0)
\param check - check for intersections ( default false)
*/
- void Concatenate(mitk::ContourModel *other, int timestep = 0, bool check = false);
+ void Concatenate(ContourModel *other, TimeStepType timestep = 0, bool check = false);
/** \brief Returns a const VertexIterator at the start element of the contour.
@throw mitk::Exception if the timestep is invalid.
*/
- VertexIterator Begin(int timestep = 0) const;
+ VertexIterator Begin(TimeStepType timestep = 0) const;
/** \brief Returns a const VertexIterator at the start element of the contour.
@throw mitk::Exception if the timestep is invalid.
*/
- VertexIterator IteratorBegin(int timestep = 0) const;
+ VertexIterator IteratorBegin(TimeStepType timestep = 0) const;
/** \brief Returns a const VertexIterator at the end element of the contour.
@throw mitk::Exception if the timestep is invalid.
*/
- VertexIterator End(int timestep = 0) const;
+ VertexIterator End(TimeStepType timestep = 0) const;
/** \brief Returns a const VertexIterator at the end element of the contour.
@throw mitk::Exception if the timestep is invalid.
*/
- VertexIterator IteratorEnd(int timestep = 0) const;
+ VertexIterator IteratorEnd(TimeStepType timestep = 0) const;
/** \brief Close the contour.
The last control point will be linked with the first point.
*/
- virtual void Close(int timestep = 0);
+ virtual void Close(TimeStepType timestep = 0);
/** \brief Set isClosed to false contour.
The link between the last control point the first point will be removed.
*/
- virtual void Open(int timestep = 0);
+ virtual void Open(TimeStepType timestep = 0);
/** \brief Set closed property to given boolean.
false - The link between the last control point the first point will be removed.
true - The last control point will be linked with the first point.
*/
- virtual void SetClosed(bool isClosed, int timestep = 0);
+ virtual void SetClosed(bool isClosed, TimeStepType timestep = 0);
/** \brief Returns the number of vertices at a given timestep.
\param timestep - default = 0
*/
- int GetNumberOfVertices(int timestep = 0) const;
+ int GetNumberOfVertices(TimeStepType timestep = 0) const;
/** \brief Returns whether the contour model is empty at a given timestep.
\param timestep - default = 0
*/
- virtual bool IsEmpty(int timestep) const;
+ virtual bool IsEmpty(TimeStepType timestep) const;
/** \brief Returns whether the contour model is empty.
*/
bool IsEmpty() const override;
/** \brief Returns the vertex at the index position within the container.
+ * If the index or timestep is invalid a nullptr will be returned.
*/
- virtual const VertexType *GetVertexAt(int index, int timestep = 0) const;
+ virtual const VertexType *GetVertexAt(int index, TimeStepType timestep = 0) const;
/** \brief Remove a vertex at given timestep within the container.
\return index of vertex. -1 if not found.
*/
- int GetIndex(const VertexType *vertex, int timestep = 0);
+ int GetIndex(const VertexType *vertex, TimeStepType timestep = 0);
/** \brief Check if there isn't something at this timestep.
*/
bool IsEmptyTimeStep(unsigned int t) const override;
/** \brief Check if mouse cursor is near the contour.
*/
- virtual bool IsNearContour(mitk::Point3D &point, float eps, int timestep);
+ virtual bool IsNearContour(Point3D &point, float eps, TimeStepType timestep);
/** \brief Mark a vertex at an index in the container as selected.
*/
- bool SelectVertexAt(int index, int timestep = 0);
+ bool SelectVertexAt(int index, TimeStepType timestep = 0);
/** \brief Mark a vertex at an index in the container as control point.
*/
- bool SetControlVertexAt(int index, int timestep = 0);
+ bool SetControlVertexAt(int index, TimeStepType timestep = 0);
/** \brief Mark a vertex at a given position in 3D space.
\param point - query point in 3D space
\param eps - radius for nearest neighbour search (error bound).
\param timestep - search at this timestep
@return true = vertex found; false = no vertex found
*/
- bool SelectVertexAt(mitk::Point3D &point, float eps, int timestep = 0);
+ bool SelectVertexAt(Point3D &point, float eps, TimeStepType timestep = 0);
/*
\pararm point - query point in 3D space
\pararm eps - radius for nearest neighbour search (error bound).
\pararm timestep - search at this timestep
@return true = vertex found; false = no vertex found
*/
- bool SetControlVertexAt(mitk::Point3D &point, float eps, int timestep = 0);
+ bool SetControlVertexAt(Point3D &point, float eps, TimeStepType timestep = 0);
/** \brief Remove a vertex at given index within the container.
@return true = the vertex was successfuly removed; false = wrong index.
*/
- bool RemoveVertexAt(int index, int timestep = 0);
+ bool RemoveVertexAt(int index, TimeStepType timestep = 0);
/** \brief Remove a vertex at given timestep within the container.
@return true = the vertex was successfuly removed.
*/
- bool RemoveVertex(const VertexType *vertex, int timestep = 0);
+ bool RemoveVertex(const VertexType *vertex, TimeStepType timestep = 0);
/** \brief Remove a vertex at a query position in 3D space.
The vertex to be removed will be search by nearest neighbour search.
Note that possibly no vertex at this position and eps is stored inside
the contour.
@return true = the vertex was successfuly removed; false = no vertex found.
*/
- bool RemoveVertexAt(mitk::Point3D &point, float eps, int timestep = 0);
+ bool RemoveVertexAt(Point3D &point, float eps, TimeStepType timestep = 0);
/** \brief Shift the currently selected vertex by a translation vector.
\param translate - the translation vector.
*/
- void ShiftSelectedVertex(mitk::Vector3D &translate);
+ void ShiftSelectedVertex(Vector3D &translate);
/** \brief Shift the whole contour by a translation vector at given timestep.
\param translate - the translation vector.
\param timestep - at this timestep the contour will be shifted.
*/
- void ShiftContour(mitk::Vector3D &translate, int timestep = 0);
+ void ShiftContour(Vector3D &translate, TimeStepType timestep = 0);
/** \brief Clear the storage container at given timestep.
All control points are removed at
timestep.
*/
- virtual void Clear(int timestep);
+ virtual void Clear(TimeStepType timestep);
/** \brief Initialize all data objects
*/
void Initialize() override;
/** \brief Initialize object with specs of other contour.
Note: No data will be copied.
*/
- void Initialize(mitk::ContourModel &other);
+ void Initialize(const ContourModel &other);
/*++++++++++++++++++ method inherit from base data +++++++++++++++++++++++++++*/
/**
\brief Inherit from base data - no region support available for contourModel objects.
*/
void SetRequestedRegionToLargestPossibleRegion() override;
/**
\brief Inherit from base data - no region support available for contourModel objects.
*/
bool RequestedRegionIsOutsideOfTheBufferedRegion() override;
/**
\brief Inherit from base data - no region support available for contourModel objects.
*/
bool VerifyRequestedRegion() override;
- /**
- \brief Get the updated geometry with recomputed bounds.
- */
- virtual const mitk::BaseGeometry *GetUpdatedGeometry(int t = 0);
-
- /**
- \brief Get the BaseGeometry for timestep t.
- */
- virtual mitk::BaseGeometry *GetGeometry(int t = 0) const;
-
/**
\brief Inherit from base data - no region support available for contourModel objects.
*/
void SetRequestedRegion(const itk::DataObject *data) override;
/**
- \brief Expand the timebounds of the TimeGeometry to given number of timesteps.
+ \brief Expand the contour model and its TimeGeometry to given number of timesteps.
*/
void Expand(unsigned int timeSteps) override;
/**
\brief Update the OutputInformation of a ContourModel object
The BoundingBox of the contour will be updated, if necessary.
*/
void UpdateOutputInformation() override;
/**
\brief Clear the storage container.
The object is set to initial state. All control points are removed and the number of
timesteps are set to 1.
*/
void Clear() override;
/**
\brief overwrite if the Data can be called by an Interactor (StateMachine).
*/
void ExecuteOperation(Operation *operation) override;
/** \brief Redistributes ontrol vertices with a given period (as number of vertices)
\param period - the number of vertices between control points.
\param timestep - at this timestep all lines will be rebuilt.
*/
- virtual void RedistributeControlVertices(int period, int timestep);
+ virtual void RedistributeControlVertices(int period, TimeStepType timestep);
protected:
mitkCloneMacro(Self);
ContourModel();
- ContourModel(const mitk::ContourModel &other);
+ ContourModel(const ContourModel &other);
~ContourModel() override;
// inherit from BaseData. called by Clear()
void ClearData() override;
// inherit from BaseData. Initial state of a contour with no vertices and a single timestep.
void InitializeEmpty() override;
// Shift a vertex
- void ShiftVertex(VertexType *vertex, mitk::Vector3D &vector);
+ static void ShiftVertex(VertexType *vertex, Vector3D &vector);
// Storage with time resolved support.
ContourModelSeries m_ContourSeries;
// The currently selected vertex.
VertexType *m_SelectedVertex;
// The interpolation of the line segment between control points.
LineSegmentInterpolation m_lineInterpolation;
// only update the bounding geometry if necessary
bool m_UpdateBoundingBox;
};
itkEventMacro(ContourModelEvent, itk::AnyEvent);
itkEventMacro(ContourModelShiftEvent, ContourModelEvent);
itkEventMacro(ContourModelSizeChangeEvent, ContourModelEvent);
itkEventMacro(ContourModelAddEvent, ContourModelSizeChangeEvent);
itkEventMacro(ContourModelRemoveEvent, ContourModelSizeChangeEvent);
itkEventMacro(ContourModelExpandTimeBoundsEvent, ContourModelEvent);
itkEventMacro(ContourModelClosedEvent, ContourModelEvent);
}
#endif
diff --git a/Modules/ContourModel/Rendering/mitkContourModelGLMapper2DBase.cpp b/Modules/ContourModel/Rendering/mitkContourModelGLMapper2DBase.cpp
index 675fa1b921..980672e655 100644
--- a/Modules/ContourModel/Rendering/mitkContourModelGLMapper2DBase.cpp
+++ b/Modules/ContourModel/Rendering/mitkContourModelGLMapper2DBase.cpp
@@ -1,396 +1,396 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkContourModelSetGLMapper2D.h"
#include "mitkColorProperty.h"
#include "mitkContourModelSet.h"
#include "mitkPlaneGeometry.h"
#include "mitkProperties.h"
#include <vtkLinearTransform.h>
#include "vtkPen.h"
#include "vtkContext2D.h"
#include "vtkContextDevice2D.h"
#include "vtkOpenGLContextDevice2D.h"
#include "mitkManualPlacementAnnotationRenderer.h"
#include "mitkBaseRenderer.h"
#include "mitkContourModel.h"
#include "mitkTextAnnotation2D.h"
mitk::ContourModelGLMapper2DBase::ContourModelGLMapper2DBase(): m_Initialized(false)
{
m_PointNumbersAnnotation = mitk::TextAnnotation2D::New();
m_ControlPointNumbersAnnotation = mitk::TextAnnotation2D::New();
}
mitk::ContourModelGLMapper2DBase::~ContourModelGLMapper2DBase()
{
}
void mitk::ContourModelGLMapper2DBase::Initialize(mitk::BaseRenderer *)
{
vtkOpenGLContextDevice2D *device = nullptr;
device = vtkOpenGLContextDevice2D::New();
if (device)
{
this->m_Context->Begin(device);
device->Delete();
this->m_Initialized = true;
}
else
{
}
}
void mitk::ContourModelGLMapper2DBase::ApplyColorAndOpacityProperties(mitk::BaseRenderer *renderer, vtkActor * /*actor*/)
{
float rgba[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
// check for color prop and use it for rendering if it exists
GetDataNode()->GetColor(rgba, renderer, "color");
// check for opacity prop and use it for rendering if it exists
GetDataNode()->GetOpacity(rgba[3], renderer, "opacity");
if (this->m_Context->GetPen() == nullptr)
{
return;
}
this->m_Context->GetPen()->SetColorF((double)rgba[0], (double)rgba[1], (double)rgba[2], (double)rgba[3]);
}
void mitk::ContourModelGLMapper2DBase::DrawContour(mitk::ContourModel *renderingContour, mitk::BaseRenderer *renderer)
{
if (std::find(m_RendererList.begin(), m_RendererList.end(), renderer) == m_RendererList.end())
{
m_RendererList.push_back(renderer);
}
mitk::ManualPlacementAnnotationRenderer::AddAnnotation(m_PointNumbersAnnotation.GetPointer(), renderer);
m_PointNumbersAnnotation->SetVisibility(false);
mitk::ManualPlacementAnnotationRenderer::AddAnnotation(m_ControlPointNumbersAnnotation.GetPointer(), renderer);
m_ControlPointNumbersAnnotation->SetVisibility(false);
InternalDrawContour(renderingContour, renderer);
}
void mitk::ContourModelGLMapper2DBase::InternalDrawContour(mitk::ContourModel *renderingContour,
mitk::BaseRenderer *renderer)
{
if (!renderingContour)
return;
if (!this->m_Initialized)
{
this->Initialize(renderer);
}
vtkOpenGLContextDevice2D::SafeDownCast(
this->m_Context->GetDevice())->Begin(renderer->GetVtkRenderer());
mitk::DataNode *dataNode = this->GetDataNode();
renderingContour->UpdateOutputInformation();
- unsigned int timestep = renderer->GetTimeStep();
+ const auto timestep = this->GetTimestep();
if (!renderingContour->IsEmptyTimeStep(timestep))
{
// apply color and opacity read from the PropertyList
ApplyColorAndOpacityProperties(renderer);
mitk::ColorProperty::Pointer colorprop =
dynamic_cast<mitk::ColorProperty *>(dataNode->GetProperty("contour.color", renderer));
float opacity = 0.5;
dataNode->GetFloatProperty("opacity", opacity, renderer);
if (colorprop)
{
// set the color of the contour
double red = colorprop->GetColor().GetRed();
double green = colorprop->GetColor().GetGreen();
double blue = colorprop->GetColor().GetBlue();
this->m_Context->GetPen()->SetColorF(red, green, blue, opacity);
}
mitk::ColorProperty::Pointer selectedcolor =
dynamic_cast<mitk::ColorProperty *>(dataNode->GetProperty("contour.points.color", renderer));
if (!selectedcolor)
{
selectedcolor = mitk::ColorProperty::New(1.0, 0.0, 0.1);
}
vtkLinearTransform *transform = dataNode->GetVtkTransform();
// ContourModel::OutputType point;
mitk::Point3D point;
mitk::Point3D p;
float vtkp[3];
float lineWidth = 3.0;
bool drawit = false;
bool isHovering = false;
dataNode->GetBoolProperty("contour.hovering", isHovering);
if (isHovering)
dataNode->GetFloatProperty("contour.hovering.width", lineWidth);
else
dataNode->GetFloatProperty("contour.width", lineWidth);
bool showSegments = false;
dataNode->GetBoolProperty("contour.segments.show", showSegments);
bool showControlPoints = false;
dataNode->GetBoolProperty("contour.controlpoints.show", showControlPoints);
bool showPoints = false;
dataNode->GetBoolProperty("contour.points.show", showPoints);
bool showPointsNumbers = false;
dataNode->GetBoolProperty("contour.points.text", showPointsNumbers);
bool showControlPointsNumbers = false;
dataNode->GetBoolProperty("contour.controlpoints.text", showControlPointsNumbers);
bool projectmode = false;
dataNode->GetVisibility(projectmode, renderer, "contour.project-onto-plane");
auto pointsIt = renderingContour->IteratorBegin(timestep);
Point2D pt2d; // projected_p in display coordinates
Point2D lastPt2d;
int index = 0;
mitk::ScalarType maxDiff = 0.25;
while (pointsIt != renderingContour->IteratorEnd(timestep))
{
lastPt2d = pt2d;
point = (*pointsIt)->Coordinates;
itk2vtk(point, vtkp);
transform->TransformPoint(vtkp, vtkp);
vtk2itk(vtkp, p);
renderer->WorldToView(p, pt2d);
ScalarType scalardiff = fabs(renderer->GetCurrentWorldPlaneGeometry()->SignedDistance(p));
// project to plane
if (projectmode)
{
drawit = true;
}
else if (scalardiff < maxDiff) // point is close enough to be drawn
{
drawit = true;
}
else
{
drawit = false;
}
// draw line
if (drawit)
{
if (showSegments)
{
// lastPt2d is not valid in first step
if (!(pointsIt == renderingContour->IteratorBegin(timestep)))
{
this->m_Context->GetPen()->SetWidth(lineWidth);
this->m_Context->DrawLine(pt2d[0], pt2d[1], lastPt2d[0], lastPt2d[1]);
this->m_Context->GetPen()->SetWidth(1);
}
}
if (showControlPoints)
{
// draw ontrol points
if ((*pointsIt)->IsControlPoint)
{
float pointsize = 4;
Point2D tmp;
Vector2D horz, vert;
horz[1] = 0;
vert[0] = 0;
horz[0] = pointsize;
vert[1] = pointsize;
this->m_Context->GetPen()->SetColorF(selectedcolor->GetColor().GetRed(),
selectedcolor->GetColor().GetBlue(),
selectedcolor->GetColor().GetGreen());
this->m_Context->GetPen()->SetWidth(1);
// a rectangle around the point with the selected color
auto* rectPts = new float[8];
tmp = pt2d - horz;
rectPts[0] = tmp[0];
rectPts[1] = tmp[1];
tmp = pt2d + vert;
rectPts[2] = tmp[0];
rectPts[3] = tmp[1];
tmp = pt2d + horz;
rectPts[4] = tmp[0];
rectPts[5] = tmp[1];
tmp = pt2d - vert;
rectPts[6] = tmp[0];
rectPts[7] = tmp[1];
this->m_Context->DrawPolygon(rectPts,4);
// the actual point in the specified color to see the usual color of the point
this->m_Context->GetPen()->SetColorF(
colorprop->GetColor().GetRed(), colorprop->GetColor().GetGreen(), colorprop->GetColor().GetBlue());
this->m_Context->DrawPoint(pt2d[0], pt2d[1]);
}
}
if (showPoints)
{
float pointsize = 3;
Point2D tmp;
Vector2D horz, vert;
horz[1] = 0;
vert[0] = 0;
horz[0] = pointsize;
vert[1] = pointsize;
this->m_Context->GetPen()->SetColorF(0.0, 0.0, 0.0);
this->m_Context->GetPen()->SetWidth(1);
// a rectangle around the point with the selected color
auto* rectPts = new float[8];
tmp = pt2d - horz;
rectPts[0] = tmp[0];
rectPts[1] = tmp[1];
tmp = pt2d + vert;
rectPts[2] = tmp[0];
rectPts[3] = tmp[1];
tmp = pt2d + horz;
rectPts[4] = tmp[0];
rectPts[5] = tmp[1];
tmp = pt2d - vert;
rectPts[6] = tmp[0];
rectPts[7] = tmp[1];
this->m_Context->DrawPolygon(rectPts, 4);
// the actual point in the specified color to see the usual color of the point
this->m_Context->GetPen()->SetColorF(
colorprop->GetColor().GetRed(), colorprop->GetColor().GetGreen(), colorprop->GetColor().GetBlue());
this->m_Context->DrawPoint(pt2d[0], pt2d[1]);
}
if (showPointsNumbers)
{
std::string l;
std::stringstream ss;
ss << index;
l.append(ss.str());
float rgb[3];
rgb[0] = 0.0;
rgb[1] = 0.0;
rgb[2] = 0.0;
WriteTextWithAnnotation(m_PointNumbersAnnotation, l.c_str(), rgb, pt2d, renderer);
}
if (showControlPointsNumbers && (*pointsIt)->IsControlPoint)
{
std::string l;
std::stringstream ss;
ss << index;
l.append(ss.str());
float rgb[3];
rgb[0] = 1.0;
rgb[1] = 1.0;
rgb[2] = 0.0;
WriteTextWithAnnotation(m_ControlPointNumbersAnnotation, l.c_str(), rgb, pt2d, renderer);
}
index++;
}
pointsIt++;
} // end while iterate over controlpoints
// close contour if necessary
if (renderingContour->IsClosed(timestep) && drawit && showSegments)
{
lastPt2d = pt2d;
point = renderingContour->GetVertexAt(0, timestep)->Coordinates;
itk2vtk(point, vtkp);
transform->TransformPoint(vtkp, vtkp);
vtk2itk(vtkp, p);
renderer->WorldToDisplay(p, pt2d);
this->m_Context->GetPen()->SetWidth(lineWidth);
this->m_Context->DrawLine(lastPt2d[0], lastPt2d[1], pt2d[0], pt2d[1]);
this->m_Context->GetPen()->SetWidth(1);
}
// draw selected vertex if exists
if (renderingContour->GetSelectedVertex())
{
// transform selected vertex
point = renderingContour->GetSelectedVertex()->Coordinates;
itk2vtk(point, vtkp);
transform->TransformPoint(vtkp, vtkp);
vtk2itk(vtkp, p);
renderer->WorldToDisplay(p, pt2d);
ScalarType scalardiff = fabs(renderer->GetCurrentWorldPlaneGeometry()->SignedDistance(p));
//----------------------------------
// draw point if close to plane
if (scalardiff < maxDiff)
{
float pointsize = 5;
Point2D tmp;
this->m_Context->GetPen()->SetColorF(0.0, 1.0, 0.0);
this->m_Context->GetPen()->SetWidth(1);
// a rectangle around the point with the selected color
auto* rectPts = new float[8];
// a diamond around the point
// begin from upper left corner and paint clockwise
rectPts[0] = pt2d[0] - pointsize;
rectPts[1] = pt2d[1] + pointsize;
rectPts[2] = pt2d[0] + pointsize;
rectPts[3] = pt2d[1] + pointsize;
rectPts[4] = pt2d[0] + pointsize;
rectPts[5] = pt2d[1] - pointsize;
rectPts[6] = pt2d[0] - pointsize;
rectPts[7] = pt2d[1] - pointsize;
this->m_Context->DrawPolygon(rectPts, 4);
}
//------------------------------------
}
}
this->m_Context->GetDevice()->End();
}
void mitk::ContourModelGLMapper2DBase::WriteTextWithAnnotation(TextAnnotationPointerType textAnnotation,
const char *text,
float rgb[3],
Point2D /*pt2d*/,
mitk::BaseRenderer * /*renderer*/)
{
textAnnotation->SetText(text);
textAnnotation->SetColor(rgb);
textAnnotation->SetOpacity(1);
textAnnotation->SetFontSize(16);
textAnnotation->SetBoolProperty("drawShadow", false);
textAnnotation->SetVisibility(true);
}
diff --git a/Modules/ContourModel/Rendering/mitkContourModelMapper2D.cpp b/Modules/ContourModel/Rendering/mitkContourModelMapper2D.cpp
index 3e2df04f9d..4fdf5d812d 100644
--- a/Modules/ContourModel/Rendering/mitkContourModelMapper2D.cpp
+++ b/Modules/ContourModel/Rendering/mitkContourModelMapper2D.cpp
@@ -1,372 +1,372 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkContourModelMapper2D.h>
#include <mitkContourModelSubDivisionFilter.h>
#include <vtkAppendPolyData.h>
#include <vtkCellArray.h>
#include <vtkCutter.h>
#include <vtkPlane.h>
#include <vtkPoints.h>
#include <vtkProperty.h>
#include <vtkSphereSource.h>
#include <vtkStripper.h>
#include <vtkTubeFilter.h>
#include <mitkPlaneGeometry.h>
mitk::ContourModelMapper2D::ContourModelMapper2D()
{
}
mitk::ContourModelMapper2D::~ContourModelMapper2D()
{
}
const mitk::ContourModel *mitk::ContourModelMapper2D::GetInput(void)
{
// convient way to get the data from the dataNode
return static_cast<const mitk::ContourModel *>(GetDataNode()->GetData());
}
vtkProp *mitk::ContourModelMapper2D::GetVtkProp(mitk::BaseRenderer *renderer)
{
// return the actor corresponding to the renderer
return m_LSH.GetLocalStorage(renderer)->m_Actor;
}
void mitk::ContourModelMapper2D::GenerateDataForRenderer(mitk::BaseRenderer *renderer)
{
/*++ convert the contour to vtkPolyData and set it as input for our mapper ++*/
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
auto *inputContour = static_cast<mitk::ContourModel *>(GetDataNode()->GetData());
- unsigned int timestep = renderer->GetTimeStep();
+ const auto timestep = this->GetTimestep();
// if there's something to be rendered
if (inputContour->GetNumberOfVertices(timestep) > 0)
{
localStorage->m_OutlinePolyData = this->CreateVtkPolyDataFromContour(inputContour, renderer);
}
this->ApplyContourProperties(renderer);
localStorage->m_Mapper->SetInputData(localStorage->m_OutlinePolyData);
}
void mitk::ContourModelMapper2D::Update(mitk::BaseRenderer *renderer)
{
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if (!visible)
return;
// check if there is something to be rendered
auto *data = static_cast<mitk::ContourModel *>(GetDataNode()->GetData());
if (data == nullptr)
{
return;
}
// Calculate time step of the input data for the specified renderer (integer value)
this->CalculateTimeStep(renderer);
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
// Check if time step is valid
const TimeGeometry *dataTimeGeometry = data->GetTimeGeometry();
if ((dataTimeGeometry == nullptr) || (dataTimeGeometry->CountTimeSteps() == 0) ||
(!dataTimeGeometry->IsValidTimeStep(renderer->GetTimeStep())))
{
// clear the rendered polydata
localStorage->m_Mapper->RemoveAllInputs(); // SetInput(vtkSmartPointer<vtkPolyData>::New());
return;
}
const DataNode *node = this->GetDataNode();
data->UpdateOutputInformation();
// check if something important has changed and we need to rerender
if ((localStorage->m_LastUpdateTime < node->GetMTime()) // was the node modified?
||
(localStorage->m_LastUpdateTime < data->GetPipelineMTime()) // Was the data modified?
||
(localStorage->m_LastUpdateTime <
renderer->GetCurrentWorldPlaneGeometryUpdateTime()) // was the geometry modified?
||
(localStorage->m_LastUpdateTime < renderer->GetCurrentWorldPlaneGeometry()->GetMTime()) ||
(localStorage->m_LastUpdateTime < node->GetPropertyList()->GetMTime()) // was a property modified?
||
(localStorage->m_LastUpdateTime < node->GetPropertyList(renderer)->GetMTime()))
{
this->GenerateDataForRenderer(renderer);
}
// since we have checked that nothing important has changed, we can set
// m_LastUpdateTime to the current time
localStorage->m_LastUpdateTime.Modified();
}
vtkSmartPointer<vtkPolyData> mitk::ContourModelMapper2D::CreateVtkPolyDataFromContour(mitk::ContourModel *inputContour,
mitk::BaseRenderer *renderer)
{
- unsigned int timestep = this->GetTimestep();
+ const auto timestep = this->GetTimestep();
// Create a polydata to store everything in
vtkSmartPointer<vtkPolyData> resultingPolyData = vtkSmartPointer<vtkPolyData>::New();
// check for the worldgeometry from the current render window
const mitk::PlaneGeometry *currentWorldGeometry = renderer->GetCurrentWorldPlaneGeometry();
if (currentWorldGeometry)
{
// origin and normal of vtkPlane
mitk::Point3D origin = currentWorldGeometry->GetOrigin();
mitk::Vector3D normal = currentWorldGeometry->GetNormal();
// the implicit function to slice through the polyData
vtkSmartPointer<vtkPlane> plane = vtkSmartPointer<vtkPlane>::New();
plane->SetOrigin(origin[0], origin[1], origin[2]);
plane->SetNormal(normal[0], normal[1], normal[2]);
/* First of all convert the control points of the contourModel to vtk points
* and add lines in between them
*/
// the points to draw
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
// the lines to connect the points
vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New();
// Create a polydata to store everything in
vtkSmartPointer<vtkPolyData> polyDataIn3D = vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkAppendPolyData> appendPoly = vtkSmartPointer<vtkAppendPolyData>::New();
mitk::ContourModel::Pointer renderingContour = mitk::ContourModel::New();
renderingContour = inputContour;
bool subdivision = false;
this->GetDataNode()->GetBoolProperty("subdivision curve", subdivision, renderer);
if (subdivision)
{
mitk::ContourModel::Pointer subdivContour = mitk::ContourModel::New();
mitk::ContourModelSubDivisionFilter::Pointer subdivFilter = mitk::ContourModelSubDivisionFilter::New();
subdivFilter->SetInput(inputContour);
subdivFilter->Update();
subdivContour = subdivFilter->GetOutput();
if (subdivContour->GetNumberOfVertices() == 0)
{
subdivContour = inputContour;
}
renderingContour = subdivContour;
}
// iterate over all control points
auto current = renderingContour->IteratorBegin(timestep);
auto next = renderingContour->IteratorBegin(timestep);
if (next != renderingContour->IteratorEnd(timestep))
{
next++;
auto end = renderingContour->IteratorEnd(timestep);
while (next != end)
{
mitk::ContourModel::VertexType *currentControlPoint = *current;
mitk::ContourModel::VertexType *nextControlPoint = *next;
vtkIdType p1 = points->InsertNextPoint(currentControlPoint->Coordinates[0],
currentControlPoint->Coordinates[1],
currentControlPoint->Coordinates[2]);
vtkIdType p2 = points->InsertNextPoint(
nextControlPoint->Coordinates[0], nextControlPoint->Coordinates[1], nextControlPoint->Coordinates[2]);
// add the line between both contorlPoints
lines->InsertNextCell(2);
lines->InsertCellPoint(p1);
lines->InsertCellPoint(p2);
if (currentControlPoint->IsControlPoint)
{
double coordinates[3];
coordinates[0] = currentControlPoint->Coordinates[0];
coordinates[1] = currentControlPoint->Coordinates[1];
coordinates[2] = currentControlPoint->Coordinates[2];
double distance = plane->DistanceToPlane(coordinates);
if (distance < 0.1)
{
vtkSmartPointer<vtkSphereSource> sphere = vtkSmartPointer<vtkSphereSource>::New();
sphere->SetRadius(1.2);
sphere->SetCenter(coordinates[0], coordinates[1], coordinates[2]);
sphere->Update();
appendPoly->AddInputConnection(sphere->GetOutputPort());
}
}
current++;
next++;
} // end while (it!=end)
// check if last control point is enabled to draw it
if ((*current)->IsControlPoint)
{
double coordinates[3];
coordinates[0] = (*current)->Coordinates[0];
coordinates[1] = (*current)->Coordinates[1];
coordinates[2] = (*current)->Coordinates[2];
double distance = plane->DistanceToPlane(coordinates);
if (distance < 0.1)
{
vtkSmartPointer<vtkSphereSource> sphere = vtkSmartPointer<vtkSphereSource>::New();
sphere->SetRadius(1.2);
sphere->SetCenter(coordinates[0], coordinates[1], coordinates[2]);
sphere->Update();
appendPoly->AddInputConnection(sphere->GetOutputPort());
}
}
/* If the contour is closed an additional line has to be created between the very first point
* and the last point
*/
if (renderingContour->IsClosed(timestep))
{
// add a line from the last to the first control point
mitk::ContourModel::VertexType *firstControlPoint = *(renderingContour->IteratorBegin(timestep));
mitk::ContourModel::VertexType *lastControlPoint = *(--(renderingContour->IteratorEnd(timestep)));
vtkIdType p2 = points->InsertNextPoint(
lastControlPoint->Coordinates[0], lastControlPoint->Coordinates[1], lastControlPoint->Coordinates[2]);
vtkIdType p1 = points->InsertNextPoint(
firstControlPoint->Coordinates[0], firstControlPoint->Coordinates[1], firstControlPoint->Coordinates[2]);
// add the line between both contorlPoints
lines->InsertNextCell(2);
lines->InsertCellPoint(p1);
lines->InsertCellPoint(p2);
} // end if(isClosed)
// Add the points to the dataset
polyDataIn3D->SetPoints(points);
// Add the lines to the dataset
polyDataIn3D->SetLines(lines);
// cut through polyData
bool useCuttingPlane = false;
this->GetDataNode()->GetBoolProperty("use cutting plane", useCuttingPlane, renderer);
if (useCuttingPlane)
{
// slice through the data to get a 2D representation of the (possible) 3D contour
// needed because currently there is no outher solution if the contour is within the plane
vtkSmartPointer<vtkTubeFilter> tubeFilter = vtkSmartPointer<vtkTubeFilter>::New();
tubeFilter->SetInputData(polyDataIn3D);
tubeFilter->SetRadius(0.05);
// cuts through vtkPolyData with a given implicit function. In our case a plane
vtkSmartPointer<vtkCutter> cutter = vtkSmartPointer<vtkCutter>::New();
cutter->SetCutFunction(plane);
cutter->SetInputConnection(tubeFilter->GetOutputPort());
// we want the scalars of the input - so turn off generating the scalars within vtkCutter
cutter->GenerateCutScalarsOff();
cutter->Update();
// set to 2D representation of the contour
resultingPolyData = cutter->GetOutput();
} // end if(project contour)
else
{
// set to 3D polyData
resultingPolyData = polyDataIn3D;
}
} // end if (it != end)
appendPoly->AddInputData(resultingPolyData);
appendPoly->Update();
// return contour with control points
return appendPoly->GetOutput();
}
else
{
// return empty polyData
return resultingPolyData;
}
}
void mitk::ContourModelMapper2D::ApplyContourProperties(mitk::BaseRenderer *renderer)
{
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
float lineWidth(1.0);
if (this->GetDataNode()->GetFloatProperty("width", lineWidth, renderer))
{
localStorage->m_Actor->GetProperty()->SetLineWidth(lineWidth);
}
mitk::ColorProperty::Pointer colorprop =
dynamic_cast<mitk::ColorProperty *>(GetDataNode()->GetProperty("color", renderer));
if (colorprop)
{
// set the color of the contour
double red = colorprop->GetColor().GetRed();
double green = colorprop->GetColor().GetGreen();
double blue = colorprop->GetColor().GetBlue();
localStorage->m_Actor->GetProperty()->SetColor(red, green, blue);
}
// make sure that directional lighting isn't used for our contour
localStorage->m_Actor->GetProperty()->SetAmbient(1.0);
localStorage->m_Actor->GetProperty()->SetDiffuse(0.0);
localStorage->m_Actor->GetProperty()->SetSpecular(0.0);
}
/*+++++++++++++++++++ LocalStorage part +++++++++++++++++++++++++*/
mitk::ContourModelMapper2D::LocalStorage *mitk::ContourModelMapper2D::GetLocalStorage(mitk::BaseRenderer *renderer)
{
return m_LSH.GetLocalStorage(renderer);
}
mitk::ContourModelMapper2D::LocalStorage::LocalStorage()
{
m_Mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
m_Actor = vtkSmartPointer<vtkActor>::New();
m_OutlinePolyData = vtkSmartPointer<vtkPolyData>::New();
// set the mapper for the actor
m_Actor->SetMapper(m_Mapper);
}
void mitk::ContourModelMapper2D::SetDefaultProperties(mitk::DataNode *node,
mitk::BaseRenderer *renderer,
bool overwrite)
{
node->AddProperty("color", ColorProperty::New(0.9, 1.0, 0.1), renderer, overwrite);
node->AddProperty("width", mitk::FloatProperty::New(1.0), renderer, overwrite);
node->AddProperty("use cutting plane", mitk::BoolProperty::New(true), renderer, overwrite);
node->AddProperty("subdivision curve", mitk::BoolProperty::New(false), renderer, overwrite);
Superclass::SetDefaultProperties(node, renderer, overwrite);
}
diff --git a/Modules/ContourModel/Rendering/mitkContourModelMapper3D.cpp b/Modules/ContourModel/Rendering/mitkContourModelMapper3D.cpp
index 84e7bacc3b..03fa9641fc 100644
--- a/Modules/ContourModel/Rendering/mitkContourModelMapper3D.cpp
+++ b/Modules/ContourModel/Rendering/mitkContourModelMapper3D.cpp
@@ -1,233 +1,233 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkContourModelMapper3D.h>
#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkProperty.h>
mitk::ContourModelMapper3D::ContourModelMapper3D()
{
}
mitk::ContourModelMapper3D::~ContourModelMapper3D()
{
}
const mitk::ContourModel *mitk::ContourModelMapper3D::GetInput(void)
{
// convient way to get the data from the dataNode
return static_cast<const mitk::ContourModel *>(GetDataNode()->GetData());
}
vtkProp *mitk::ContourModelMapper3D::GetVtkProp(mitk::BaseRenderer *renderer)
{
// return the actor corresponding to the renderer
return m_LSH.GetLocalStorage(renderer)->m_Actor;
}
void mitk::ContourModelMapper3D::GenerateDataForRenderer(mitk::BaseRenderer *renderer)
{
/* First convert the contourModel to vtkPolyData, then tube filter it and
* set it input for our mapper
*/
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
auto *inputContour = static_cast<mitk::ContourModel *>(GetDataNode()->GetData());
localStorage->m_OutlinePolyData = this->CreateVtkPolyDataFromContour(inputContour);
this->ApplyContourProperties(renderer);
// tube filter the polyData
localStorage->m_TubeFilter->SetInputData(localStorage->m_OutlinePolyData);
float lineWidth(1.0);
if (this->GetDataNode()->GetFloatProperty("contour.3D.width", lineWidth, renderer))
{
localStorage->m_TubeFilter->SetRadius(lineWidth);
}
else
{
localStorage->m_TubeFilter->SetRadius(0.5);
}
localStorage->m_TubeFilter->CappingOn();
localStorage->m_TubeFilter->SetNumberOfSides(10);
localStorage->m_TubeFilter->Update();
localStorage->m_Mapper->SetInputConnection(localStorage->m_TubeFilter->GetOutputPort());
}
void mitk::ContourModelMapper3D::Update(mitk::BaseRenderer *renderer)
{
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
auto *data = static_cast<mitk::ContourModel *>(GetDataNode()->GetData());
if (data == nullptr)
{
return;
}
// Calculate time step of the input data for the specified renderer (integer value)
this->CalculateTimeStep(renderer);
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
// Check if time step is valid
const TimeGeometry *dataTimeGeometry = data->GetTimeGeometry();
if ((dataTimeGeometry == nullptr) || (dataTimeGeometry->CountTimeSteps() == 0) ||
(!dataTimeGeometry->IsValidTimePoint(renderer->GetTime())) || (this->GetTimestep() == -1))
{
// clear the rendered polydata
localStorage->m_Mapper->SetInputData(vtkSmartPointer<vtkPolyData>::New());
return;
}
const DataNode *node = this->GetDataNode();
data->UpdateOutputInformation();
// check if something important has changed and we need to rerender
if ((localStorage->m_LastUpdateTime < node->GetMTime()) // was the node modified?
||
(localStorage->m_LastUpdateTime < data->GetPipelineMTime()) // Was the data modified?
||
(localStorage->m_LastUpdateTime <
renderer->GetCurrentWorldPlaneGeometryUpdateTime()) // was the geometry modified?
||
(localStorage->m_LastUpdateTime < renderer->GetCurrentWorldPlaneGeometry()->GetMTime()) ||
(localStorage->m_LastUpdateTime < node->GetPropertyList()->GetMTime()) // was a property modified?
||
(localStorage->m_LastUpdateTime < node->GetPropertyList(renderer)->GetMTime()))
{
this->GenerateDataForRenderer(renderer);
}
// since we have checked that nothing important has changed, we can set
// m_LastUpdateTime to the current time
localStorage->m_LastUpdateTime.Modified();
}
vtkSmartPointer<vtkPolyData> mitk::ContourModelMapper3D::CreateVtkPolyDataFromContour(mitk::ContourModel *inputContour)
{
- unsigned int timestep = this->GetTimestep();
+ const auto timestep = this->GetTimestep();
// the points to draw
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
// the lines to connect the points
vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New();
// Create a polydata to store everything in
vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
// iterate over the control points
auto current = inputContour->IteratorBegin(timestep);
auto next = inputContour->IteratorBegin(timestep);
if (next != inputContour->IteratorEnd(timestep))
{
next++;
auto end = inputContour->IteratorEnd(timestep);
while (next != end)
{
mitk::ContourModel::VertexType *currentControlPoint = *current;
mitk::ContourModel::VertexType *nextControlPoint = *next;
if (!(currentControlPoint->Coordinates[0] == nextControlPoint->Coordinates[0] &&
currentControlPoint->Coordinates[1] == nextControlPoint->Coordinates[1] &&
currentControlPoint->Coordinates[2] == nextControlPoint->Coordinates[2]))
{
vtkIdType p1 = points->InsertNextPoint(currentControlPoint->Coordinates[0],
currentControlPoint->Coordinates[1],
currentControlPoint->Coordinates[2]);
vtkIdType p2 = points->InsertNextPoint(
nextControlPoint->Coordinates[0], nextControlPoint->Coordinates[1], nextControlPoint->Coordinates[2]);
// add the line between both contorlPoints
lines->InsertNextCell(2);
lines->InsertCellPoint(p1);
lines->InsertCellPoint(p2);
}
current++;
next++;
}
if (inputContour->IsClosed(timestep))
{
// If the contour is closed add a line from the last to the first control point
mitk::ContourModel::VertexType *firstControlPoint = *(inputContour->IteratorBegin(timestep));
mitk::ContourModel::VertexType *lastControlPoint = *(--(inputContour->IteratorEnd(timestep)));
if (lastControlPoint->Coordinates[0] != firstControlPoint->Coordinates[0] ||
lastControlPoint->Coordinates[1] != firstControlPoint->Coordinates[1] ||
lastControlPoint->Coordinates[2] != firstControlPoint->Coordinates[2])
{
vtkIdType p2 = points->InsertNextPoint(
lastControlPoint->Coordinates[0], lastControlPoint->Coordinates[1], lastControlPoint->Coordinates[2]);
vtkIdType p1 = points->InsertNextPoint(
firstControlPoint->Coordinates[0], firstControlPoint->Coordinates[1], firstControlPoint->Coordinates[2]);
// add the line to the cellArray
lines->InsertNextCell(2);
lines->InsertCellPoint(p1);
lines->InsertCellPoint(p2);
}
}
// Add the points to the dataset
polyData->SetPoints(points);
// Add the lines to the dataset
polyData->SetLines(lines);
}
return polyData;
}
void mitk::ContourModelMapper3D::ApplyContourProperties(mitk::BaseRenderer *renderer)
{
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
mitk::ColorProperty::Pointer colorprop =
dynamic_cast<mitk::ColorProperty *>(GetDataNode()->GetProperty("contour.color", renderer));
if (colorprop)
{
// set the color of the contour
double red = colorprop->GetColor().GetRed();
double green = colorprop->GetColor().GetGreen();
double blue = colorprop->GetColor().GetBlue();
localStorage->m_Actor->GetProperty()->SetColor(red, green, blue);
}
}
/*+++++++++++++++++++ LocalStorage part +++++++++++++++++++++++++*/
mitk::ContourModelMapper3D::LocalStorage *mitk::ContourModelMapper3D::GetLocalStorage(mitk::BaseRenderer *renderer)
{
return m_LSH.GetLocalStorage(renderer);
}
mitk::ContourModelMapper3D::LocalStorage::LocalStorage()
{
m_Mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
m_Actor = vtkSmartPointer<vtkActor>::New();
m_OutlinePolyData = vtkSmartPointer<vtkPolyData>::New();
m_TubeFilter = vtkSmartPointer<vtkTubeFilter>::New();
// set the mapper for the actor
m_Actor->SetMapper(m_Mapper);
}
void mitk::ContourModelMapper3D::SetDefaultProperties(mitk::DataNode *node,
mitk::BaseRenderer *renderer,
bool overwrite)
{
node->AddProperty("color", ColorProperty::New(1.0, 0.0, 0.0), renderer, overwrite);
node->AddProperty("contour.3D.width", mitk::FloatProperty::New(0.5), renderer, overwrite);
Superclass::SetDefaultProperties(node, renderer, overwrite);
}
diff --git a/Modules/ContourModel/Rendering/mitkContourModelSetMapper3D.cpp b/Modules/ContourModel/Rendering/mitkContourModelSetMapper3D.cpp
index 0cd56a24a1..cab6397f83 100644
--- a/Modules/ContourModel/Rendering/mitkContourModelSetMapper3D.cpp
+++ b/Modules/ContourModel/Rendering/mitkContourModelSetMapper3D.cpp
@@ -1,232 +1,232 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkContourModelSetMapper3D.h>
#include "mitkSurface.h"
#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkPolyLine.h>
#include <vtkProperty.h>
mitk::ContourModelSetMapper3D::ContourModelSetMapper3D()
{
}
mitk::ContourModelSetMapper3D::~ContourModelSetMapper3D()
{
}
const mitk::ContourModelSet *mitk::ContourModelSetMapper3D::GetInput(void)
{
// convenient way to get the data from the dataNode
return static_cast<const mitk::ContourModelSet *>(GetDataNode()->GetData());
}
vtkProp *mitk::ContourModelSetMapper3D::GetVtkProp(mitk::BaseRenderer *renderer)
{
// return the actor corresponding to the renderer
return m_LSH.GetLocalStorage(renderer)->m_Assembly;
}
void mitk::ContourModelSetMapper3D::GenerateDataForRenderer(mitk::BaseRenderer *renderer)
{
/* First convert the contourModel to vtkPolyData, then tube filter it and
* set it input for our mapper
*/
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
auto *contourModelSet = dynamic_cast<ContourModelSet *>(this->GetDataNode()->GetData());
if (contourModelSet != nullptr)
{
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
vtkIdType baseIndex = 0;
auto it = contourModelSet->Begin();
auto end = contourModelSet->End();
while (it != end)
{
ContourModel *contourModel = it->GetPointer();
auto vertIt = contourModel->Begin();
auto vertEnd = contourModel->End();
while (vertIt != vertEnd)
{
points->InsertNextPoint((*vertIt)->Coordinates[0], (*vertIt)->Coordinates[1], (*vertIt)->Coordinates[2]);
++vertIt;
}
vtkSmartPointer<vtkPolyLine> line = vtkSmartPointer<vtkPolyLine>::New();
vtkIdList *pointIds = line->GetPointIds();
vtkIdType numPoints = contourModel->GetNumberOfVertices();
pointIds->SetNumberOfIds(numPoints + 1);
for (vtkIdType i = 0; i < numPoints; ++i)
pointIds->SetId(i, baseIndex + i);
pointIds->SetId(numPoints, baseIndex);
cells->InsertNextCell(line);
baseIndex += numPoints;
++it;
}
vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
polyData->SetPoints(points);
polyData->SetLines(cells);
vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
actor->SetMapper(mapper);
mapper->SetInputData(polyData);
localStorage->m_Assembly->AddPart(actor);
}
this->ApplyContourProperties(renderer);
this->ApplyContourModelSetProperties(renderer);
}
void mitk::ContourModelSetMapper3D::Update(mitk::BaseRenderer *renderer)
{
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
auto *data = static_cast<mitk::ContourModel *>(GetDataNode()->GetData());
if (data == nullptr)
{
return;
}
// Calculate time step of the input data for the specified renderer (integer value)
this->CalculateTimeStep(renderer);
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
if (this->GetTimestep() == -1)
{
return;
}
const DataNode *node = this->GetDataNode();
data->UpdateOutputInformation();
// check if something important has changed and we need to rerender
if ((localStorage->m_LastUpdateTime < node->GetMTime()) // was the node modified?
||
(localStorage->m_LastUpdateTime < data->GetPipelineMTime()) // Was the data modified?
||
(localStorage->m_LastUpdateTime <
renderer->GetCurrentWorldPlaneGeometryUpdateTime()) // was the geometry modified?
||
(localStorage->m_LastUpdateTime < renderer->GetCurrentWorldPlaneGeometry()->GetMTime()) ||
(localStorage->m_LastUpdateTime < node->GetPropertyList()->GetMTime()) // was a property modified?
||
(localStorage->m_LastUpdateTime < node->GetPropertyList(renderer)->GetMTime()))
{
this->GenerateDataForRenderer(renderer);
}
// since we have checked that nothing important has changed, we can set
// m_LastUpdateTime to the current time
localStorage->m_LastUpdateTime.Modified();
}
vtkSmartPointer<vtkPolyData> mitk::ContourModelSetMapper3D::CreateVtkPolyDataFromContour(
mitk::ContourModel *inputContour, mitk::BaseRenderer *renderer)
{
- unsigned int timestep = this->GetTimestep();
+ const auto timestep = this->GetTimestep();
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
localStorage->m_contourToPolyData->SetInput(inputContour);
localStorage->m_contourToPolyData->Update();
vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
polyData = localStorage->m_contourToPolyData->GetOutput()->GetVtkPolyData(timestep);
return polyData;
}
void mitk::ContourModelSetMapper3D::ApplyContourModelSetProperties(BaseRenderer *renderer)
{
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
DataNode *dataNode = this->GetDataNode();
if (dataNode != nullptr)
{
float lineWidth = 1;
dataNode->GetFloatProperty("contour.3D.width", lineWidth, renderer);
vtkSmartPointer<vtkPropCollection> collection = vtkSmartPointer<vtkPropCollection>::New();
localStorage->m_Assembly->GetActors(collection);
collection->InitTraversal();
for (vtkIdType i = 0; i < collection->GetNumberOfItems(); i++)
{
vtkActor::SafeDownCast(collection->GetNextProp())->GetProperty()->SetLineWidth(lineWidth);
}
}
}
void mitk::ContourModelSetMapper3D::ApplyContourProperties(mitk::BaseRenderer *renderer)
{
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
mitk::ColorProperty::Pointer colorprop =
dynamic_cast<mitk::ColorProperty *>(GetDataNode()->GetProperty("contour.color", renderer));
if (colorprop)
{
// set the color of the contour
double red = colorprop->GetColor().GetRed();
double green = colorprop->GetColor().GetGreen();
double blue = colorprop->GetColor().GetBlue();
vtkSmartPointer<vtkPropCollection> collection = vtkSmartPointer<vtkPropCollection>::New();
localStorage->m_Assembly->GetActors(collection);
collection->InitTraversal();
for (vtkIdType i = 0; i < collection->GetNumberOfItems(); i++)
{
vtkActor::SafeDownCast(collection->GetNextProp())->GetProperty()->SetColor(red, green, blue);
}
}
}
/*+++++++++++++++++++ LocalStorage part +++++++++++++++++++++++++*/
mitk::ContourModelSetMapper3D::LocalStorage *mitk::ContourModelSetMapper3D::GetLocalStorage(
mitk::BaseRenderer *renderer)
{
return m_LSH.GetLocalStorage(renderer);
}
mitk::ContourModelSetMapper3D::LocalStorage::LocalStorage()
{
m_Assembly = vtkSmartPointer<vtkAssembly>::New();
m_contourToPolyData = mitk::ContourModelToSurfaceFilter::New();
}
void mitk::ContourModelSetMapper3D::SetDefaultProperties(mitk::DataNode *node,
mitk::BaseRenderer *renderer,
bool overwrite)
{
node->AddProperty("color", ColorProperty::New(1.0, 0.0, 0.0), renderer, overwrite);
node->AddProperty("contour.3D.width", mitk::FloatProperty::New(0.5), renderer, overwrite);
Superclass::SetDefaultProperties(node, renderer, overwrite);
}
diff --git a/Modules/ContourModel/Testing/CMakeLists.txt b/Modules/ContourModel/Testing/CMakeLists.txt
index 263e573340..153cd81e2e 100644
--- a/Modules/ContourModel/Testing/CMakeLists.txt
+++ b/Modules/ContourModel/Testing/CMakeLists.txt
@@ -1,2 +1 @@
MITK_CREATE_MODULE_TESTS()
-#mitkAddCustomModuleTest(mitkSegmentationInterpolationTest mitkSegmentationInterpolationTest ${MITK_DATA_DIR}/interpolation_test_manual.nrrd ${MITK_DATA_DIR}/interpolation_test_result.nrrd)
diff --git a/Modules/ContourModel/Testing/files.cmake b/Modules/ContourModel/Testing/files.cmake
index 8d8021a143..804bb86385 100644
--- a/Modules/ContourModel/Testing/files.cmake
+++ b/Modules/ContourModel/Testing/files.cmake
@@ -1,13 +1,14 @@
set(MODULE_TESTS
+ mitkContourElementTest.cpp
mitkContourModelTest.cpp
mitkContourModelIOTest.cpp
mitkContourModelSetTest.cpp
)
set(MODULE_IMAGE_TESTS
)
set(MODULE_CUSTOM_TESTS
)
set(MODULE_TESTIMAGE
)
diff --git a/Modules/ContourModel/Testing/mitkContourElementTest.cpp b/Modules/ContourModel/Testing/mitkContourElementTest.cpp
new file mode 100644
index 0000000000..b75a434883
--- /dev/null
+++ b/Modules/ContourModel/Testing/mitkContourElementTest.cpp
@@ -0,0 +1,349 @@
+/*============================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center (DKFZ)
+All rights reserved.
+
+Use of this source code is governed by a 3-clause BSD license that can be
+found in the LICENSE file.
+
+============================================================================*/
+
+#include "mitkContourElement.h"
+
+#include "mitkTestFixture.h"
+#include "mitkTestingMacros.h"
+#include <limits>
+
+class mitkContourElementTestSuite : public mitk::TestFixture
+{
+ CPPUNIT_TEST_SUITE(mitkContourElementTestSuite);
+ // Test the append method
+ MITK_TEST(Iterator);
+ MITK_TEST(AddVertex);
+ MITK_TEST(AddVertexAtFront);
+ MITK_TEST(InsertVertexAtIndex);
+ MITK_TEST(GetSetVertexAt);
+ MITK_TEST(OpenAndClose);
+ MITK_TEST(OtherGetters);
+ MITK_TEST(Concatenate);
+ MITK_TEST(RemoveVertex);
+ MITK_TEST(Clear);
+ MITK_TEST(GetControlVertices);
+ MITK_TEST(RedistributeControlVertices);
+ MITK_TEST(Others);
+
+ CPPUNIT_TEST_SUITE_END();
+
+private:
+ mitk::ContourElement::Pointer m_Contour1to4;
+ mitk::ContourElement::Pointer m_Contour5to6;
+ mitk::ContourElement::Pointer m_Contour_empty;
+ mitk::Point3D m_p1;
+ mitk::Point3D m_p2;
+ mitk::Point3D m_p3;
+ mitk::Point3D m_p4;
+ mitk::Point3D m_p5;
+ mitk::Point3D m_p6;
+ mitk::Point3D m_p7;
+
+public:
+ static mitk::Point3D GeneratePoint(double val)
+ {
+ return mitk::Point3D(val);
+ }
+
+ void setUp() override
+ {
+ m_p1 = GeneratePoint(1);
+ m_p2 = GeneratePoint(2);
+ m_p3 = GeneratePoint(3);
+ m_p4 = GeneratePoint(4);
+ m_p5 = GeneratePoint(5);
+ m_p6 = GeneratePoint(6);
+ m_p7 = GeneratePoint(7);
+
+ m_Contour1to4 = mitk::ContourElement::New();
+ m_Contour5to6 = mitk::ContourElement::New();
+ m_Contour_empty = mitk::ContourElement::New();
+
+ m_Contour1to4->AddVertex(m_p1, true);
+ m_Contour1to4->AddVertex(m_p2, false);
+ m_Contour1to4->AddVertex(m_p3, true);
+ m_Contour1to4->AddVertex(m_p4, false);
+
+ m_Contour5to6->AddVertex(m_p5, false);
+ m_Contour5to6->AddVertex(m_p6, true);
+
+ }
+
+ void tearDown() override {}
+
+ void Iterator()
+ {
+ mitk::ContourElement::ConstPointer constcontour = m_Contour5to6.GetPointer();
+ CPPUNIT_ASSERT_MESSAGE("Begin does not point to correct element", m_Contour1to4->IteratorBegin().operator*()->Coordinates == m_p1);
+ CPPUNIT_ASSERT_MESSAGE("Begin does not point to correct element", m_Contour1to4->ConstIteratorBegin().operator*()->Coordinates == m_p1);
+ CPPUNIT_ASSERT_MESSAGE("Begin does not point to correct element", m_Contour5to6->begin().operator*()->Coordinates == m_p5);
+ CPPUNIT_ASSERT_MESSAGE("Begin does not point to correct element", constcontour->begin().operator*()->Coordinates == m_p5);
+
+ CPPUNIT_ASSERT_MESSAGE("End does not point to correct element", m_Contour_empty->ConstIteratorBegin() == m_Contour_empty->ConstIteratorEnd());
+ CPPUNIT_ASSERT_MESSAGE("End does not point to correct element", m_Contour_empty->IteratorBegin() == m_Contour_empty->IteratorEnd());
+ CPPUNIT_ASSERT_MESSAGE("End does not point to correct element", m_Contour_empty->begin() == m_Contour_empty->end());
+ }
+
+ void AddVertex()
+ {
+ m_Contour_empty->AddVertex(m_p1, false);
+ CPPUNIT_ASSERT(m_Contour_empty->GetVertexAt(0)->Coordinates == m_p1);
+ CPPUNIT_ASSERT(m_Contour_empty->GetVertexAt(0)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour_empty->GetSize() == 1);
+
+ m_Contour_empty->AddVertex(m_p7, true);
+ CPPUNIT_ASSERT(m_Contour_empty->GetVertexAt(0)->Coordinates == m_p1);
+ CPPUNIT_ASSERT(m_Contour_empty->GetVertexAt(0)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour_empty->GetVertexAt(1)->Coordinates == m_p7);
+ CPPUNIT_ASSERT(m_Contour_empty->GetVertexAt(1)->IsControlPoint == true);
+ CPPUNIT_ASSERT(m_Contour_empty->GetSize() == 2);
+ }
+
+ void AddVertexAtFront()
+ {
+ m_Contour_empty->AddVertexAtFront(m_p1, false);
+ CPPUNIT_ASSERT(m_Contour_empty->GetVertexAt(0)->Coordinates == m_p1);
+ CPPUNIT_ASSERT(m_Contour_empty->GetVertexAt(0)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour_empty->GetSize() == 1);
+
+ m_Contour_empty->AddVertexAtFront(m_p7, true);
+ CPPUNIT_ASSERT(m_Contour_empty->GetVertexAt(1)->Coordinates == m_p1);
+ CPPUNIT_ASSERT(m_Contour_empty->GetVertexAt(1)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour_empty->GetVertexAt(0)->Coordinates == m_p7);
+ CPPUNIT_ASSERT(m_Contour_empty->GetVertexAt(0)->IsControlPoint == true);
+ CPPUNIT_ASSERT(m_Contour_empty->GetSize() == 2);
+ }
+
+ void InsertVertexAtIndex()
+ {
+ mitk::Point3D outOfBountPoint;
+ m_Contour1to4->InsertVertexAtIndex(m_p5, false, 0);
+ m_Contour1to4->InsertVertexAtIndex(m_p7, true, 2);
+ m_Contour1to4->InsertVertexAtIndex(outOfBountPoint, true, 6);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(0)->Coordinates == m_p5);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(0)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(1)->Coordinates == m_p1);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(1)->IsControlPoint == true);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(2)->Coordinates == m_p7);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(2)->IsControlPoint == true);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(3)->Coordinates == m_p2);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(3)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour1to4->GetSize() == 6);
+ }
+
+ void GetSetVertexAt()
+ {
+ mitk::ContourElement::ConstPointer constcontour = m_Contour1to4.GetPointer();
+
+ auto v0 = m_Contour1to4->GetVertexAt(0);
+ auto v1 = m_Contour1to4->GetVertexAt(1);
+
+ CPPUNIT_ASSERT(v0->Coordinates == m_p1);
+ CPPUNIT_ASSERT(v0->IsControlPoint == true);
+ CPPUNIT_ASSERT(v1->Coordinates == m_p2);
+ CPPUNIT_ASSERT(v1->IsControlPoint == false);
+ CPPUNIT_ASSERT(constcontour->GetVertexAt(0)->Coordinates == m_p1);
+ CPPUNIT_ASSERT(constcontour->GetVertexAt(0)->IsControlPoint == true);
+ CPPUNIT_ASSERT(constcontour->GetVertexAt(1)->Coordinates == m_p2);
+ CPPUNIT_ASSERT(constcontour->GetVertexAt(1)->IsControlPoint == false);
+
+ m_Contour1to4->SetVertexAt(0, m_p7);
+ CPPUNIT_ASSERT(v0->Coordinates == m_p7);
+ CPPUNIT_ASSERT(v0->IsControlPoint == true);
+
+ m_Contour1to4->SetVertexAt(1, m_Contour5to6->GetVertexAt(1));
+ CPPUNIT_ASSERT(v1->Coordinates == m_Contour5to6->GetVertexAt(1)->Coordinates);
+ CPPUNIT_ASSERT(v1->IsControlPoint == m_Contour5to6->GetVertexAt(1)->IsControlPoint);
+ CPPUNIT_ASSERT(v1 != m_Contour5to6->GetVertexAt(1));
+
+ mitk::Point3D search = GeneratePoint(6.05);
+
+ auto finding = m_Contour1to4->GetVertexAt(search, 0.);
+ CPPUNIT_ASSERT(nullptr == finding);
+
+ finding = m_Contour1to4->GetVertexAt(search, 0.1);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(1) == finding);
+ }
+
+ void OpenAndClose()
+ {
+ CPPUNIT_ASSERT(!m_Contour1to4->IsClosed());
+ CPPUNIT_ASSERT(!m_Contour_empty->IsClosed());
+ m_Contour1to4->Close();
+ m_Contour_empty->SetClosed(true);
+ CPPUNIT_ASSERT(m_Contour1to4->IsClosed());
+ CPPUNIT_ASSERT(m_Contour_empty->IsClosed());
+ m_Contour1to4->Open();
+ m_Contour_empty->SetClosed(false);
+ CPPUNIT_ASSERT(!m_Contour1to4->IsClosed());
+ CPPUNIT_ASSERT(!m_Contour_empty->IsClosed());
+ }
+
+ void OtherGetters()
+ {
+ CPPUNIT_ASSERT(m_Contour1to4->GetIndex(m_Contour1to4->GetVertexAt(0)) == 0);
+ CPPUNIT_ASSERT(m_Contour1to4->GetIndex(m_Contour1to4->GetVertexAt(1)) == 1);
+ CPPUNIT_ASSERT(m_Contour1to4->GetIndex(m_Contour1to4->GetVertexAt(3)) == 3);
+ CPPUNIT_ASSERT(m_Contour1to4->GetIndex(m_Contour5to6->GetVertexAt(0)) == mitk::ContourElement::NPOS);
+ }
+
+ void Concatenate()
+ {
+ m_Contour5to6->Concatenate(m_Contour1to4, true);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(0)->Coordinates == m_p5);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(0)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(1)->Coordinates == m_p6);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(1)->IsControlPoint == true);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(2)->Coordinates == m_p1);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(2)->IsControlPoint == true);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(3)->Coordinates == m_p2);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(3)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(4)->Coordinates == m_p3);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(4)->IsControlPoint == true);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(5)->Coordinates == m_p4);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(5)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour5to6->GetSize() == 6);
+
+ m_Contour_empty->AddVertex(m_p1, false);
+ m_Contour5to6->Concatenate(m_Contour_empty, true);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(0)->Coordinates == m_p5);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(0)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(1)->Coordinates == m_p6);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(1)->IsControlPoint == true);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(2)->Coordinates == m_p1);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(2)->IsControlPoint == true);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(3)->Coordinates == m_p2);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(3)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(4)->Coordinates == m_p3);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(4)->IsControlPoint == true);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(5)->Coordinates == m_p4);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(5)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour5to6->GetSize() == 6);
+
+ m_Contour5to6->Concatenate(m_Contour_empty, false);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(0)->Coordinates == m_p5);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(0)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(1)->Coordinates == m_p6);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(1)->IsControlPoint == true);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(2)->Coordinates == m_p1);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(2)->IsControlPoint == true);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(3)->Coordinates == m_p2);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(3)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(4)->Coordinates == m_p3);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(4)->IsControlPoint == true);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(5)->Coordinates == m_p4);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(5)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(6)->Coordinates == m_p1);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(6)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour5to6->GetSize() == 7);
+ }
+
+ void RemoveVertex()
+ {
+ CPPUNIT_ASSERT(m_Contour1to4->RemoveVertex(m_Contour1to4->GetVertexAt(0)));
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(0)->Coordinates == m_p2);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(0)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour1to4->GetSize() == 3);
+ CPPUNIT_ASSERT(!m_Contour1to4->RemoveVertex(m_Contour5to6->GetVertexAt(0)));
+ CPPUNIT_ASSERT(m_Contour1to4->GetSize() == 3);
+
+ CPPUNIT_ASSERT(m_Contour1to4->RemoveVertexAt(1));
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(0)->Coordinates == m_p2);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(0)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(1)->Coordinates == m_p4);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(1)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour1to4->GetSize() == 2);
+
+ CPPUNIT_ASSERT(!m_Contour1to4->RemoveVertexAt(2));
+ CPPUNIT_ASSERT(m_Contour1to4->GetSize() == 2);
+
+ mitk::Point3D search = GeneratePoint(6.05);
+
+ CPPUNIT_ASSERT(!m_Contour1to4->RemoveVertexAt(search,0.1));
+ CPPUNIT_ASSERT(m_Contour1to4->GetSize() == 2);
+
+ CPPUNIT_ASSERT(m_Contour5to6->RemoveVertexAt(search, 0.1));
+ CPPUNIT_ASSERT(m_Contour5to6->GetSize() == 1);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(0)->Coordinates == m_p5);
+ CPPUNIT_ASSERT(m_Contour5to6->GetVertexAt(0)->IsControlPoint == false);
+ }
+
+ void Clear()
+ {
+ m_Contour1to4->Clear();
+ CPPUNIT_ASSERT(m_Contour1to4->IsEmpty());
+ m_Contour_empty->Clear();
+ CPPUNIT_ASSERT(m_Contour_empty->IsEmpty());
+ }
+
+ void GetControlVertices()
+ {
+ auto controlVs = m_Contour1to4->GetControlVertices();
+ CPPUNIT_ASSERT(controlVs.size() == 2);
+ CPPUNIT_ASSERT(controlVs[0] == m_Contour1to4->GetVertexAt(0));
+ CPPUNIT_ASSERT(controlVs[1] == m_Contour1to4->GetVertexAt(2));
+
+ controlVs = m_Contour_empty->GetControlVertices();
+ CPPUNIT_ASSERT(controlVs.empty());
+ }
+
+ void RedistributeControlVertices()
+ {
+ //just adding more nodes to better check the redistribution
+ m_Contour1to4->Concatenate(m_Contour1to4, false);
+ m_Contour1to4->Concatenate(m_Contour1to4, false);
+
+ m_Contour1to4->RedistributeControlVertices(nullptr, 3);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(0)->IsControlPoint == true);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(1)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(2)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(3)->IsControlPoint == true);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(4)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(5)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(6)->IsControlPoint == true);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(7)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(8)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(9)->IsControlPoint == true);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(10)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(11)->IsControlPoint == false);
+
+ m_Contour1to4->RedistributeControlVertices(m_Contour1to4->GetVertexAt(4), 4);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(0)->IsControlPoint == true);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(1)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(2)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(3)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(4)->IsControlPoint == true);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(5)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(6)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(7)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(8)->IsControlPoint == true);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(9)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(10)->IsControlPoint == false);
+ CPPUNIT_ASSERT(m_Contour1to4->GetVertexAt(11)->IsControlPoint == false);
+ }
+
+ void Others()
+ {
+ CPPUNIT_ASSERT(m_Contour1to4->GetSize() == 4);
+ CPPUNIT_ASSERT(m_Contour_empty->GetSize() == 0);
+ CPPUNIT_ASSERT(!m_Contour1to4->IsEmpty());
+ CPPUNIT_ASSERT(m_Contour_empty->IsEmpty());
+
+ mitk::ContourElement::Pointer copyConstructed = m_Contour5to6->Clone();
+ CPPUNIT_ASSERT(*(m_Contour5to6->GetVertexAt(0)) == *(copyConstructed->GetVertexAt(0)));
+ CPPUNIT_ASSERT(*(m_Contour5to6->GetVertexAt(1)) == *(copyConstructed->GetVertexAt(1)));
+ CPPUNIT_ASSERT(m_Contour5to6->GetSize() == copyConstructed->GetSize());
+ }
+
+};
+
+MITK_TEST_SUITE_REGISTRATION(mitkContourElement)
diff --git a/Modules/ContourModel/Testing/mitkContourModelTest.cpp b/Modules/ContourModel/Testing/mitkContourModelTest.cpp
index 7f2e643776..9464bdcb83 100644
--- a/Modules/ContourModel/Testing/mitkContourModelTest.cpp
+++ b/Modules/ContourModel/Testing/mitkContourModelTest.cpp
@@ -1,419 +1,483 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkContourModel.h>
#include <mitkTestingMacros.h>
// Add a vertex to the contour and see if size changed
static void TestAddVertex()
{
mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
mitk::Point3D p;
p[0] = p[1] = p[2] = 0;
contour->AddVertex(p);
- MITK_TEST_CONDITION(contour->GetNumberOfVertices() > 0, "Add a Vertex, size increased");
+ MITK_TEST_CONDITION(contour->GetNumberOfVertices() == 1, "Add a Vertex, size increased");
+ MITK_TEST_CONDITION(contour->GetVertexAt(0)->Coordinates == p, "Added vertex has the correct value.");
+
+ mitk::Point3D outOfTimeBoundPoint;
+ outOfTimeBoundPoint[0] = outOfTimeBoundPoint[1] = outOfTimeBoundPoint[2] = 1;
+
+ contour->AddVertex(outOfTimeBoundPoint, mitk::TimeStepType(1));
+
+ MITK_TEST_CONDITION(contour->GetTimeSteps() == 1, "Add a vertex to an unsupported time step has not changed geometry.");
+ MITK_TEST_CONDITION(contour->IsEmptyTimeStep(1), "Add a vertex to an unsupported time step has not added an contour element.");
+ MITK_TEST_CONDITION(contour->GetNumberOfVertices(1) == -1, "Add a vertex to an unsupported time step has not added an contour element.");
+
+ contour->Expand(3);
+
+ mitk::Point3D p2;
+ p2[0] = p2[1] = p2[2] = 2;
+ mitk::Point3D p3;
+ p3[0] = p3[1] = p3[2] = 3;
+
+ contour->AddVertex(p2, mitk::TimeStepType(1));
+ contour->AddVertex(mitk::ContourModel::VertexType(p3), mitk::TimeStepType(1));
+
+ MITK_TEST_CONDITION(!contour->IsEmptyTimeStep(1), "Add a vertex to an unsupported time step has not added an contour element.");
+ MITK_TEST_CONDITION(contour->GetVertexAt(0,1)->Coordinates == p2, "Add a vertex to the 2nd time step (as Point).");
+ MITK_TEST_CONDITION(contour->GetVertexAt(1,1)->Coordinates == p3, "Add a vertex to the 2nd time step via overload (as vertex type).");
+ MITK_TEST_CONDITION(contour->GetNumberOfVertices(1) == 2, "Add a vertex to an unsupported time step has not added an contour element.");
}
// Select a vertex by index. successful if the selected vertex member of the contour is no longer set to null
static void TestSelectVertexAtIndex()
{
mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
mitk::Point3D p;
p[0] = p[1] = p[2] = 0;
contour->AddVertex(p);
contour->SelectVertexAt(0);
MITK_TEST_CONDITION(contour->GetSelectedVertex() != nullptr, "Vertex was selected at index");
}
// Select a vertex by worldposition. successful if the selected vertex member of the contour is no longer set to null
static void TestSelectVertexAtWorldposition()
{
mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
mitk::Point3D p;
p[0] = p[1] = p[2] = 0;
contour->AddVertex(p);
// same point is used here so the epsilon can be chosen very small
contour->SelectVertexAt(p, 0.01);
MITK_TEST_CONDITION(contour->GetSelectedVertex() != nullptr, "Vertex was selected at position");
}
// Move a vertex by a translation vector
static void TestMoveSelectedVertex()
{
mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
mitk::Point3D p;
p[0] = p[1] = p[2] = 0;
contour->AddVertex(p);
// Same point is used here so the epsilon can be chosen very small
contour->SelectVertexAt(p, 0.01);
mitk::Vector3D v;
v[0] = 1;
v[1] = 3;
v[2] = -1;
contour->ShiftSelectedVertex(v);
const mitk::ContourModel::VertexType *vertex = contour->GetSelectedVertex();
bool correctlyMoved = false;
correctlyMoved =
(vertex->Coordinates)[0] == (v[0]) && (vertex->Coordinates)[1] == (v[1]) && (vertex->Coordinates)[2] == (v[2]);
MITK_TEST_CONDITION(correctlyMoved, "Vertex has been moved");
}
// Test to move the whole contour
/*
static void TestMoveContour()
{
mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
mitk::Point3D p;
p[0] = p[1] = p[2] = 0;
contour->AddVertex(p);
mitk::Point3D p2;
p2[0] = p2[1] = p2[2] = 0;
contour->AddVertex(p2);
mitk::Vector3D v;
v[0] = 1;
v[1] = 3;
v[2] = -1;
contour->ShiftContour(v);
mitk::ContourModel::VertexIterator it = contour->IteratorBegin();
mitk::ContourModel::VertexIterator end = contour->IteratorEnd();
bool correctlyMoved = false;
while(it != end)
{
correctlyMoved &= (*it)->Coordinates[0] == (v[0]) &&
(*it)->Coordinates[1] == (v[1]) &&
(*it)->Coordinates[2] == (v[2]);
}
MITK_TEST_CONDITION(correctlyMoved, "Contour has been moved");
}
*/
// Remove a vertex by index
static void TestRemoveVertexAtIndex()
{
mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
mitk::Point3D p;
p[0] = p[1] = p[2] = 0;
contour->AddVertex(p);
contour->RemoveVertexAt(0);
MITK_TEST_CONDITION(contour->GetNumberOfVertices() == 0, "removed vertex");
}
// Remove a vertex by position
static void TestRemoveVertexAtWorldPosition()
{
mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
mitk::Point3D p;
p[0] = p[1] = p[2] = 0;
contour->AddVertex(p);
contour->RemoveVertexAt(p, 0.01);
MITK_TEST_CONDITION(contour->GetNumberOfVertices() == 0, "removed vertex");
}
// Check closeable contour
static void TestIsclosed()
{
mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
mitk::Point3D p;
p[0] = p[1] = p[2] = 0;
contour->AddVertex(p);
mitk::Point3D p2;
p2[0] = p2[1] = p2[2] = 1;
contour->AddVertex(p2);
contour->Close();
MITK_TEST_CONDITION(contour->IsClosed(), "closed contour");
// no vertices should be added to a closed contour
int oldNumberOfVertices = contour->GetNumberOfVertices();
mitk::Point3D p3;
p3[0] = p3[1] = p3[2] = 4;
contour->AddVertex(p3);
int newNumberOfVertices = contour->GetNumberOfVertices();
MITK_TEST_CONDITION(oldNumberOfVertices != newNumberOfVertices, "vertices added to closed contour");
}
// Test concatenating two contours
static void TestConcatenate()
{
mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
mitk::Point3D p;
p[0] = p[1] = p[2] = 0;
contour->AddVertex(p);
mitk::Point3D p2;
p2[0] = p2[1] = p2[2] = 1;
contour->AddVertex(p2);
mitk::ContourModel::Pointer contour2 = mitk::ContourModel::New();
mitk::Point3D p3;
p3[0] = -2;
p3[1] = 10;
p3[2] = 0;
contour2->AddVertex(p3);
mitk::Point3D p4;
p4[0] = -3;
p4[1] = 6;
p4[2] = -5;
contour2->AddVertex(p4);
contour->Concatenate(contour2);
MITK_TEST_CONDITION(contour->GetNumberOfVertices() == 4, "two contours were concatenated");
}
// Try to select a vertex at position (within a epsilon of course) where no vertex is.
// So the selected verted member should be null.
static void TestSelectVertexAtWrongPosition()
{
mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
MITK_TEST_CONDITION_REQUIRED(contour->GetSelectedVertex() == nullptr, "selected vertex is nullptr");
mitk::Point3D p;
p[0] = p[1] = p[2] = 0;
contour->AddVertex(p);
mitk::Point3D p2;
p2[0] = p2[1] = p2[2] = 2;
contour->SelectVertexAt(p2, 0.1);
MITK_TEST_CONDITION(contour->GetSelectedVertex() == nullptr, "Vertex was not selected");
}
static void TestInsertVertex()
{
mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
mitk::Point3D p;
p[0] = p[1] = p[2] = 0;
contour->AddVertex(p);
mitk::Point3D p2;
p2[0] = p2[1] = p2[2] = 1;
contour->AddVertex(p2);
mitk::Point3D pointToInsert;
pointToInsert[0] = pointToInsert[1] = pointToInsert[2] = 10;
contour->InsertVertexAtIndex(pointToInsert, 1);
MITK_TEST_CONDITION(contour->GetNumberOfVertices() == 3, "test insert vertex");
MITK_TEST_CONDITION(contour->GetVertexAt(1)->Coordinates == pointToInsert, "compare inserted vertex");
+
+ mitk::Point3D outOfTimeBoundPoint;
+ outOfTimeBoundPoint[0] = outOfTimeBoundPoint[1] = outOfTimeBoundPoint[2] = 1;
+
+ contour->InsertVertexAtIndex(outOfTimeBoundPoint, 4, false, mitk::TimeStepType(1));
+
+ MITK_TEST_CONDITION(contour->GetTimeSteps() == 1, "Insert a vertex to an unsupported time step has not changed geometry.");
+ MITK_TEST_CONDITION(contour->IsEmptyTimeStep(1), "Insert a vertex to an unsupported time step has not added an contour element.");
+ MITK_TEST_CONDITION(contour->GetNumberOfVertices(1) == -1, "Insert a vertex to an unsupported time step has not added an contour element.");
}
// try to access an invalid timestep
static void TestInvalidTimeStep()
{
mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
mitk::Point3D p;
p[0] = p[1] = p[2] = 0;
contour->AddVertex(p);
mitk::Point3D p2;
p2[0] = p2[1] = p2[2] = 1;
contour->AddVertex(p2);
- int invalidTimeStep = 42;
+ mitk::TimeStepType invalidTimeStep = 42;
MITK_TEST_CONDITION_REQUIRED(contour->IsEmptyTimeStep(invalidTimeStep), "invalid timestep required");
MITK_TEST_FOR_EXCEPTION(std::exception, contour->IteratorBegin(-1));
contour->Close(invalidTimeStep);
MITK_TEST_CONDITION(contour->IsClosed() == false, "test close for timestep 0");
MITK_TEST_CONDITION(contour->IsClosed(invalidTimeStep) == false, "test close at invalid timestep");
contour->SetClosed(true, invalidTimeStep);
MITK_TEST_CONDITION(contour->GetNumberOfVertices(invalidTimeStep) == -1,
"test number of vertices at invalid timestep");
contour->AddVertex(p2, invalidTimeStep);
MITK_TEST_CONDITION(contour->GetNumberOfVertices(invalidTimeStep) == -1, "test add vertex at invalid timestep");
contour->InsertVertexAtIndex(p2, 0, false, invalidTimeStep);
MITK_TEST_CONDITION(contour->GetNumberOfVertices(invalidTimeStep) == -1, "test insert vertex at invalid timestep");
MITK_TEST_CONDITION(contour->SelectVertexAt(0, invalidTimeStep) == false, "test select vertex at invalid timestep");
MITK_TEST_CONDITION(contour->RemoveVertexAt(0, invalidTimeStep) == false, "test remove vertex at invalid timestep");
+
+ MITK_TEST_CONDITION(contour->GetVertexAt(0, 5) == nullptr, "Access a vertex on an invalid time step.");
+ MITK_TEST_CONDITION(contour->GetVertexAt(10, 0) == nullptr, "Access a vertex on an invalid index.");
}
static void TestEmptyContour()
{
mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
MITK_TEST_CONDITION(contour->IteratorBegin() == contour->IteratorEnd(), "test iterator of emtpy contour");
MITK_TEST_CONDITION(contour->GetNumberOfVertices() == 0, "test numberof vertices of empty contour");
}
static void TestSetVertices()
{
mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
mitk::Point3D p;
p[0] = p[1] = p[2] = 0;
contour->AddVertex(p);
mitk::Point3D newCoordinates;
newCoordinates[0] = newCoordinates[1] = newCoordinates[2] = 1;
contour->SetVertexAt(0, newCoordinates);
MITK_TEST_CONDITION(mitk::Equal(contour->GetVertexAt(0)->Coordinates, newCoordinates), "set coordinates");
mitk::ContourModel::Pointer contour2 = mitk::ContourModel::New();
mitk::Point3D p3;
p3[0] = -2;
p3[1] = 10;
p3[2] = 0;
contour2->AddVertex(p3);
mitk::Point3D p4;
p4[0] = -3;
p4[1] = 6;
p4[2] = -5;
contour2->AddVertex(p4);
contour->AddVertex(p);
-
- contour->SetVertexAt(1, contour2->GetVertexAt(1));
+ contour->SetVertexAt(1, contour2->GetVertexAt(1), 0);
MITK_TEST_CONDITION(
mitk::Equal(contour->GetVertexAt(1)->Coordinates, contour2->GetVertexAt(1)->Coordinates), "Use setter and getter combination");
}
static void TestContourModelAPI()
{
mitk::ContourModel::Pointer contour1 = mitk::ContourModel::New();
mitk::Point3D p1;
p1[0] = -2;
p1[1] = 10;
p1[2] = 0;
contour1->AddVertex(p1);
// adding vertices should always copy the content and not store pointers or references.
MITK_TEST_CONDITION(&p1 != &(contour1->GetVertexAt(0)->Coordinates), "copied point");
mitk::Point3D p2;
p2[0] = -3;
p2[1] = 6;
p2[2] = -5;
contour1->AddVertex(p2);
// test use of setter and getter with const and non-const pointers
const mitk::ContourModel::VertexType *vertex = contour1->GetVertexAt(1);
MITK_TEST_CONDITION(contour1->GetIndex(vertex) == 1, "Get index");
auto *nonConstVertex = const_cast<mitk::ContourModel::VertexType *>(vertex);
MITK_TEST_CONDITION(contour1->GetIndex(nonConstVertex) == 1, "Get index non-const");
mitk::ContourModel::Pointer contour2 = mitk::ContourModel::New();
- contour2->AddVertex(contour1->GetVertexAt(0));
+ contour2->AddVertex(*(contour1->GetVertexAt(0)));
MITK_TEST_CONDITION(contour2->GetNumberOfVertices() == 1, "Add call with another contour");
}
+static void TestClear()
+{
+ mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
+ contour->Expand(3);
+
+ contour->Expand(3);
+ mitk::Point3D p;
+ p[0] = p[1] = p[2] = 0;
+ contour->AddVertex(p);
+ p[0] = p[1] = p[2] = 1;
+ contour->AddVertex(p, mitk::TimeStepType(1));
+ p[0] = p[1] = p[2] = 2;
+ contour->AddVertex(p, mitk::TimeStepType(2));
+
+ contour->Clear(1);
+
+ MITK_TEST_CONDITION(contour->GetTimeSteps() == 3, "Check time step count stays 3.");
+ MITK_TEST_CONDITION(!contour->IsEmpty(0), "Check time step 0 is not empty.");
+ MITK_TEST_CONDITION(contour->IsEmpty(1), "Check time step 1 is empty.");
+ MITK_TEST_CONDITION(!contour->IsEmpty(2), "Check time step 2 is not empty.");
+ MITK_TEST_CONDITION(contour->GetVertexAt(0, 2)->Coordinates == p, "compare if vertex at t == 2 is still the same");
+
+ contour->Clear();
+ MITK_TEST_CONDITION(contour->GetTimeSteps() == 1, "Check time step count stays 1.");
+ MITK_TEST_CONDITION(contour->IsEmpty(0), "Check time step 0 is empty.");
+}
+
int mitkContourModelTest(int /*argc*/, char * /*argv*/ [])
{
MITK_TEST_BEGIN("mitkContourModelTest")
TestAddVertex();
TestSelectVertexAtIndex();
TestSelectVertexAtWorldposition();
TestMoveSelectedVertex();
TestRemoveVertexAtIndex();
TestRemoveVertexAtWorldPosition();
TestIsclosed();
TestConcatenate();
TestInvalidTimeStep();
TestInsertVertex();
TestEmptyContour();
TestSetVertices();
TestSelectVertexAtWrongPosition();
TestContourModelAPI();
+ TestClear();
MITK_TEST_END()
}
diff --git a/Modules/Core/TestingHelper/include/mitkInteractionTestHelper.h b/Modules/Core/TestingHelper/include/mitkInteractionTestHelper.h
index 71d54b482a..c1ba0efb79 100644
--- a/Modules/Core/TestingHelper/include/mitkInteractionTestHelper.h
+++ b/Modules/Core/TestingHelper/include/mitkInteractionTestHelper.h
@@ -1,143 +1,142 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkInteractionTestHelper_h
#define mitkInteractionTestHelper_h
#include <mitkDataStorage.h>
#include <mitkMouseModeSwitcher.h>
#include <mitkRenderWindow.h>
#include <mitkXML2EventParser.h>
#include <MitkTestingHelperExports.h>
class vtkRenderWindow;
class vtkRenderer;
namespace mitk
{
/** @brief Creates everything needed to load and playback interaction events.
*
* The interaction is loaded from an xml file and the event are created. This file is
* usually a recorded user interaction with the GUI. This can be done with InteractionEventRecorder
* plugin. Also all necessary objects to handle interaction events are generated.
* The user of this class is responsible to add the data object to interact with to the data storage
* of InteractionTestHelper. And must also make sure that a proper data interactor is associated with the data
* object.
*
* To test a PointSet interaction for instance make sure you have a PointSet node and a PointSetDataInteractor.
* Then just add the node to the storage of the your InteractionTestHelper by calling
* InteractionTestHelper::AddNodeToStorage.
* Use InteractionTestHelper::PlaybackInteraction to execute. The result can afterwards be compared to a reference
* object.
*
* Make sure to destroy the test helper instance after each test, since all render windows and its renderers have to
* be
* unregistered.
*
* \sa XML2EventParser
* \sa EventFactory
* \sa EventRecorder
*/
class MITKTESTINGHELPER_EXPORT InteractionTestHelper
{
public:
/**
* @brief InteractionTestHelper set up all neseccary objects by calling Initialize.
* @param interactionXmlFilePath path to xml file containing events and configuration information for the render
* windows.
*/
InteractionTestHelper(const std::string &interactionXmlFilePath);
// unregisters all render windows and its renderers.
virtual ~InteractionTestHelper();
/** @brief Returns the datastorage, in order to modify the data inside a rendering test.
**/
mitk::DataStorage::Pointer GetDataStorage();
/**
* @brief AddNodeToStorage Add a node to the datastorage and perform a reinit which is necessary for rendering.
* @param node The data you want to add.
*/
void AddNodeToStorage(mitk::DataNode::Pointer node);
/**
* @brief PlaybackInteraction playback loaded interaction by passing events to the dispatcher.
*/
void PlaybackInteraction();
/**
* @brief SetTimeStep Sets timesteps of all SliceNavigationControllers to given timestep.
* @param newTimeStep new timestep
*
* Does the same as using ImageNavigators Time slider. Use this if your data was modified in a timestep other than
* 0.
*/
void SetTimeStep(int newTimeStep);
typedef std::vector<mitk::RenderWindow::Pointer> RenderWindowListType;
const RenderWindowListType &GetRenderWindowList() { return m_RenderWindowList; }
/**
* @brief GetRenderWindowByName Get renderWindow by the name of its renderer.
* @param name The name of the renderer of the desired renderWindow.
* @return nullptr if not found.
*/
RenderWindow *GetRenderWindowByName(const std::string &name);
/**
* @brief GetRenderWindowByDefaultViewDirection Get a renderWindow by its default viewdirection.
* @param viewDirection
* @return nullptr if not found.
*/
RenderWindow *GetRenderWindowByDefaultViewDirection(mitk::SliceNavigationController::ViewDirection viewDirection);
/**
* @brief GetRenderWindow Get renderWindow at position 'index'.
* @param index Position within the renderWindow list.
* @return nullptr if index is out of bounds.
*/
RenderWindow *GetRenderWindow(unsigned int index);
/**
* @brief AddDisplayPlaneSubTree
*
* Creates DisplayPlanes that are shown in a 3D RenderWindow.
*/
void AddDisplayPlaneSubTree();
void Set3dCameraSettings();
protected:
/**
* @brief Initialize Internal method to initialize the renderwindow and set the datastorage.
* @throws mitk::Exception if interaction xml file can not be loaded.
*/
void Initialize(const std::string &interactionXmlFilePath);
/**
* @brief LoadInteraction loads events from xml file.
- * @param interactionXmlPath path to xml file with interaction events.
*/
void LoadInteraction();
mitk::XML2EventParser::EventContainerType m_Events; // List with loaded interaction events
std::string m_InteractionFilePath;
RenderWindowListType m_RenderWindowList;
mitk::DataStorage::Pointer m_DataStorage;
mitk::MouseModeSwitcher::Pointer m_MouseModeSwitcher;
};
} // namespace mitk
#endif
diff --git a/Modules/Core/TestingHelper/src/mitkInteractionTestHelper.cpp b/Modules/Core/TestingHelper/src/mitkInteractionTestHelper.cpp
index 92578ca3cf..80f98daa8a 100644
--- a/Modules/Core/TestingHelper/src/mitkInteractionTestHelper.cpp
+++ b/Modules/Core/TestingHelper/src/mitkInteractionTestHelper.cpp
@@ -1,429 +1,429 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
// MITK
#include <mitkIOUtil.h>
#include <mitkInteractionEventConst.h>
#include <mitkInteractionTestHelper.h>
#include <mitkPlaneGeometryDataMapper2D.h>
#include <mitkStandaloneDataStorage.h>
// VTK
#include <vtkCamera.h>
#include <vtkRenderWindowInteractor.h>
// us
#include <usGetModuleContext.h>
#include <tinyxml2.h>
mitk::InteractionTestHelper::InteractionTestHelper(const std::string &interactionXmlFilePath)
: m_InteractionFilePath(interactionXmlFilePath)
{
this->Initialize(interactionXmlFilePath);
}
void mitk::InteractionTestHelper::Initialize(const std::string &interactionXmlFilePath)
{
tinyxml2::XMLDocument document;
if (tinyxml2::XML_SUCCESS == document.LoadFile(interactionXmlFilePath.c_str()))
{
// get RenderingManager instance
auto rm = mitk::RenderingManager::GetInstance();
// create data storage
m_DataStorage = mitk::StandaloneDataStorage::New();
// for each renderer found create a render window and configure
for (auto *element = document.FirstChildElement(mitk::InteractionEventConst::xmlTagInteractions().c_str())
->FirstChildElement(mitk::InteractionEventConst::xmlTagConfigRoot().c_str())
->FirstChildElement(mitk::InteractionEventConst::xmlTagRenderer().c_str());
element != nullptr;
element = element->NextSiblingElement(mitk::InteractionEventConst::xmlTagRenderer().c_str()))
{
// get name of renderer
const char *rendererName =
element->Attribute(mitk::InteractionEventConst::xmlEventPropertyRendererName().c_str());
// get view direction
mitk::SliceNavigationController::ViewDirection viewDirection = mitk::SliceNavigationController::Axial;
if (element->Attribute(mitk::InteractionEventConst::xmlEventPropertyViewDirection().c_str()) != nullptr)
{
int viewDirectionNum =
std::atoi(element->Attribute(mitk::InteractionEventConst::xmlEventPropertyViewDirection().c_str()));
viewDirection = static_cast<mitk::SliceNavigationController::ViewDirection>(viewDirectionNum);
}
// get mapper slot id
mitk::BaseRenderer::MapperSlotId mapperID = mitk::BaseRenderer::Standard2D;
if (element->Attribute(mitk::InteractionEventConst::xmlEventPropertyMapperID().c_str()) != nullptr)
{
int mapperIDNum =
std::atoi(element->Attribute(mitk::InteractionEventConst::xmlEventPropertyMapperID().c_str()));
mapperID = static_cast<mitk::BaseRenderer::MapperSlotId>(mapperIDNum);
}
// Get Size of Render Windows
int size[3];
size[0] = size[1] = size[2] = 0;
if (element->Attribute(mitk::InteractionEventConst::xmlRenderSizeX().c_str()) != nullptr)
{
size[0] = std::atoi(element->Attribute(mitk::InteractionEventConst::xmlRenderSizeX().c_str()));
}
if (element->Attribute(mitk::InteractionEventConst::xmlRenderSizeY().c_str()) != nullptr)
{
size[1] = std::atoi(element->Attribute(mitk::InteractionEventConst::xmlRenderSizeY().c_str()));
}
if (element->Attribute(mitk::InteractionEventConst::xmlRenderSizeZ().c_str()) != nullptr)
{
size[2] = std::atoi(element->Attribute(mitk::InteractionEventConst::xmlRenderSizeZ().c_str()));
}
// create renderWindow, renderer and dispatcher
auto rw = RenderWindow::New(nullptr, rendererName); // VtkRenderWindow is created within constructor if nullptr
if (size[0] != 0 && size[1] != 0)
{
rw->SetSize(size[0], size[1]);
rw->GetRenderer()->Resize(size[0], size[1]);
}
// set storage of renderer
rw->GetRenderer()->SetDataStorage(m_DataStorage);
// set view direction to axial
rw->GetSliceNavigationController()->SetDefaultViewDirection(viewDirection);
// set renderer to render 2D
rw->GetRenderer()->SetMapperID(mapperID);
rw->GetRenderer()->PrepareRender();
// Some more magic for the 3D render window case:
// Camera view direction, position and focal point
if (mapperID == mitk::BaseRenderer::Standard3D)
{
if (element->Attribute(mitk::InteractionEventConst::xmlCameraFocalPointX().c_str()) != nullptr)
{
double cameraFocalPoint[3];
cameraFocalPoint[0] =
std::atoi(element->Attribute(mitk::InteractionEventConst::xmlCameraFocalPointX().c_str()));
cameraFocalPoint[1] =
std::atoi(element->Attribute(mitk::InteractionEventConst::xmlCameraFocalPointY().c_str()));
cameraFocalPoint[2] =
std::atoi(element->Attribute(mitk::InteractionEventConst::xmlCameraFocalPointZ().c_str()));
rw->GetRenderer()->GetVtkRenderer()->GetActiveCamera()->SetFocalPoint(cameraFocalPoint);
}
if (element->Attribute(mitk::InteractionEventConst::xmlCameraPositionX().c_str()) != nullptr)
{
double cameraPosition[3];
cameraPosition[0] = std::atoi(element->Attribute(mitk::InteractionEventConst::xmlCameraPositionX().c_str()));
cameraPosition[1] = std::atoi(element->Attribute(mitk::InteractionEventConst::xmlCameraPositionY().c_str()));
cameraPosition[2] = std::atoi(element->Attribute(mitk::InteractionEventConst::xmlCameraPositionZ().c_str()));
rw->GetRenderer()->GetVtkRenderer()->GetActiveCamera()->SetPosition(cameraPosition);
}
if (element->Attribute(mitk::InteractionEventConst::xmlViewUpX().c_str()) != nullptr)
{
double viewUp[3];
viewUp[0] = std::atoi(element->Attribute(mitk::InteractionEventConst::xmlViewUpX().c_str()));
viewUp[1] = std::atoi(element->Attribute(mitk::InteractionEventConst::xmlViewUpY().c_str()));
viewUp[2] = std::atoi(element->Attribute(mitk::InteractionEventConst::xmlViewUpZ().c_str()));
rw->GetRenderer()->GetVtkRenderer()->GetActiveCamera()->SetViewUp(viewUp);
}
}
rw->GetVtkRenderWindow()->Render();
rw->GetVtkRenderWindow()->WaitForCompletion();
// connect SliceNavigationControllers to timestep changed event of TimeNavigationController
rw->GetSliceNavigationController()->ConnectGeometryTimeEvent(rm->GetTimeNavigationController(), false);
rm->GetTimeNavigationController()->ConnectGeometryTimeEvent(rw->GetSliceNavigationController(), false);
// add to list of kown render windows
m_RenderWindowList.push_back(rw);
}
// TODO: check the following lines taken from QmitkStdMultiWidget and adapt them to be executed in our code here.
// mitkWidget1->GetSliceNavigationController()
// ->ConnectGeometrySendEvent(mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow()));
//########### register display interactor to handle scroll events ##################
// use MouseModeSwitcher to ensure that the statemachine of DisplayInteractor is loaded correctly
m_MouseModeSwitcher = mitk::MouseModeSwitcher::New();
}
else
{
mitkThrow() << "Can not load interaction xml file <" << m_InteractionFilePath << ">";
}
// WARNING assumes a 3D window exists !!!!
this->AddDisplayPlaneSubTree();
}
mitk::InteractionTestHelper::~InteractionTestHelper()
{
mitk::RenderingManager *rm = mitk::RenderingManager::GetInstance();
// unregister renderers
auto it = m_RenderWindowList.begin();
auto end = m_RenderWindowList.end();
for (; it != end; ++it)
{
rm->GetTimeNavigationController()->Disconnect((*it)->GetSliceNavigationController());
(*it)->GetSliceNavigationController()->Disconnect(rm->GetTimeNavigationController());
mitk::BaseRenderer::RemoveInstance((*it)->GetVtkRenderWindow());
}
rm->RemoveAllObservers();
}
mitk::DataStorage::Pointer mitk::InteractionTestHelper::GetDataStorage()
{
return m_DataStorage;
}
void mitk::InteractionTestHelper::AddNodeToStorage(mitk::DataNode::Pointer node)
{
this->m_DataStorage->Add(node);
this->Set3dCameraSettings();
}
void mitk::InteractionTestHelper::PlaybackInteraction()
{
mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(m_DataStorage);
// load events if not loaded yet
if (m_Events.empty())
this->LoadInteraction();
auto it = m_RenderWindowList.begin();
auto end = m_RenderWindowList.end();
for (; it != end; ++it)
{
(*it)->GetRenderer()->PrepareRender();
(*it)->GetVtkRenderWindow()->Render();
(*it)->GetVtkRenderWindow()->WaitForCompletion();
}
mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(m_DataStorage);
it = m_RenderWindowList.begin();
for (; it != end; ++it)
{
(*it)->GetVtkRenderWindow()->Render();
(*it)->GetVtkRenderWindow()->WaitForCompletion();
}
// mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
// playback all events in queue
for (unsigned long i = 0; i < m_Events.size(); ++i)
{
// let dispatcher of sending renderer process the event
m_Events.at(i)->GetSender()->GetDispatcher()->ProcessEvent(m_Events.at(i));
}
if (false)
{
it--;
(*it)->GetVtkRenderWindow()->GetInteractor()->Start();
}
}
void mitk::InteractionTestHelper::LoadInteraction()
{
// load interaction pattern from xml file
std::ifstream xmlStream(m_InteractionFilePath.c_str());
mitk::XML2EventParser parser(xmlStream);
m_Events = parser.GetInteractions();
xmlStream.close();
// Avoid VTK warning: Trying to delete object with non-zero reference count.
parser.SetReferenceCount(0);
}
void mitk::InteractionTestHelper::SetTimeStep(int newTimeStep)
{
mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(m_DataStorage);
bool timeStepIsvalid =
mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetCreatedWorldGeometry()->IsValidTimeStep(
newTimeStep);
if (timeStepIsvalid)
{
mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetTime()->SetPos(newTimeStep);
}
}
mitk::RenderWindow *mitk::InteractionTestHelper::GetRenderWindowByName(const std::string &name)
{
auto it = m_RenderWindowList.begin();
auto end = m_RenderWindowList.end();
for (; it != end; ++it)
{
if (name.compare((*it)->GetRenderer()->GetName()) == 0)
return (*it).GetPointer();
}
return nullptr;
}
mitk::RenderWindow *mitk::InteractionTestHelper::GetRenderWindowByDefaultViewDirection(
mitk::SliceNavigationController::ViewDirection viewDirection)
{
auto it = m_RenderWindowList.begin();
auto end = m_RenderWindowList.end();
for (; it != end; ++it)
{
if (viewDirection == (*it)->GetSliceNavigationController()->GetDefaultViewDirection())
return (*it).GetPointer();
}
return nullptr;
}
mitk::RenderWindow *mitk::InteractionTestHelper::GetRenderWindow(unsigned int index)
{
if (index < m_RenderWindowList.size())
{
return m_RenderWindowList.at(index).GetPointer();
}
else
{
return nullptr;
}
}
void mitk::InteractionTestHelper::AddDisplayPlaneSubTree()
{
// add the displayed planes of the multiwidget to a node to which the subtree
// @a planesSubTree points ...
mitk::PlaneGeometryDataMapper2D::Pointer mapper;
mitk::IntProperty::Pointer layer = mitk::IntProperty::New(1000);
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetProperty("name", mitk::StringProperty::New("Widgets"));
node->SetProperty("helper object", mitk::BoolProperty::New(true));
m_DataStorage->Add(node);
for (auto it : m_RenderWindowList)
{
if (it->GetRenderer()->GetMapperID() == BaseRenderer::Standard3D)
continue;
// ... of widget 1
mitk::DataNode::Pointer planeNode1 =
(mitk::BaseRenderer::GetInstance(it->GetVtkRenderWindow()))->GetCurrentWorldPlaneGeometryNode();
planeNode1->SetProperty("visible", mitk::BoolProperty::New(true));
planeNode1->SetProperty("name", mitk::StringProperty::New("widget1Plane"));
planeNode1->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
planeNode1->SetProperty("helper object", mitk::BoolProperty::New(true));
planeNode1->SetProperty("layer", layer);
planeNode1->SetColor(1.0, 0.0, 0.0);
mapper = mitk::PlaneGeometryDataMapper2D::New();
planeNode1->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
m_DataStorage->Add(planeNode1, node);
}
}
void mitk::InteractionTestHelper::Set3dCameraSettings()
{
tinyxml2::XMLDocument document;
if (tinyxml2::XML_SUCCESS == document.LoadFile(m_InteractionFilePath.c_str()))
{
// for each renderer found create a render window and configure
for (auto *element = document.FirstChildElement(mitk::InteractionEventConst::xmlTagInteractions().c_str())
->FirstChildElement(mitk::InteractionEventConst::xmlTagConfigRoot().c_str())
->FirstChildElement(mitk::InteractionEventConst::xmlTagRenderer().c_str());
element != nullptr;
element = element->NextSiblingElement(mitk::InteractionEventConst::xmlTagRenderer().c_str()))
{
// get name of renderer
const char *rendererName =
element->Attribute(mitk::InteractionEventConst::xmlEventPropertyRendererName().c_str());
// get mapper slot id
mitk::BaseRenderer::MapperSlotId mapperID = mitk::BaseRenderer::Standard2D;
if (element->Attribute(mitk::InteractionEventConst::xmlEventPropertyMapperID().c_str()) != nullptr)
{
int mapperIDNum =
std::atoi(element->Attribute(mitk::InteractionEventConst::xmlEventPropertyMapperID().c_str()));
mapperID = static_cast<mitk::BaseRenderer::MapperSlotId>(mapperIDNum);
}
if (mapperID == mitk::BaseRenderer::Standard3D)
{
RenderWindow *namedRenderer = nullptr;
- for (auto it : m_RenderWindowList)
+ for (const auto &it : m_RenderWindowList)
{
if (strcmp(it->GetRenderer()->GetName(), rendererName) == 0)
{
namedRenderer = it.GetPointer();
break;
}
}
if (namedRenderer == nullptr)
{
MITK_ERROR << "No match for render window was found.";
return;
}
namedRenderer->GetRenderer()->PrepareRender();
if (element->Attribute(mitk::InteractionEventConst::xmlCameraFocalPointX().c_str()) != nullptr)
{
double cameraFocalPoint[3];
cameraFocalPoint[0] =
std::atoi(element->Attribute(mitk::InteractionEventConst::xmlCameraFocalPointX().c_str()));
cameraFocalPoint[1] =
std::atoi(element->Attribute(mitk::InteractionEventConst::xmlCameraFocalPointY().c_str()));
cameraFocalPoint[2] =
std::atoi(element->Attribute(mitk::InteractionEventConst::xmlCameraFocalPointZ().c_str()));
namedRenderer->GetRenderer()->GetVtkRenderer()->GetActiveCamera()->SetFocalPoint(cameraFocalPoint);
}
if (element->Attribute(mitk::InteractionEventConst::xmlCameraPositionX().c_str()) != nullptr)
{
double cameraPosition[3];
cameraPosition[0] = std::atoi(element->Attribute(mitk::InteractionEventConst::xmlCameraPositionX().c_str()));
cameraPosition[1] = std::atoi(element->Attribute(mitk::InteractionEventConst::xmlCameraPositionY().c_str()));
cameraPosition[2] = std::atoi(element->Attribute(mitk::InteractionEventConst::xmlCameraPositionZ().c_str()));
namedRenderer->GetRenderer()->GetVtkRenderer()->GetActiveCamera()->SetPosition(cameraPosition);
}
if (element->Attribute(mitk::InteractionEventConst::xmlViewUpX().c_str()) != nullptr)
{
double viewUp[3];
viewUp[0] = std::atoi(element->Attribute(mitk::InteractionEventConst::xmlViewUpX().c_str()));
viewUp[1] = std::atoi(element->Attribute(mitk::InteractionEventConst::xmlViewUpY().c_str()));
viewUp[2] = std::atoi(element->Attribute(mitk::InteractionEventConst::xmlViewUpZ().c_str()));
namedRenderer->GetRenderer()->GetVtkRenderer()->GetActiveCamera()->SetViewUp(viewUp);
}
namedRenderer->GetVtkRenderWindow()->Render();
}
}
}
}
diff --git a/Modules/Core/include/mitkBaseRenderer.h b/Modules/Core/include/mitkBaseRenderer.h
index b50a10e5c1..b4015ffd7a 100644
--- a/Modules/Core/include/mitkBaseRenderer.h
+++ b/Modules/Core/include/mitkBaseRenderer.h
@@ -1,532 +1,532 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef BASERENDERER_H_HEADER_INCLUDED_C1CCA0F4
#define BASERENDERER_H_HEADER_INCLUDED_C1CCA0F4
#include "mitkCameraRotationController.h"
#include "mitkDataStorage.h"
#include "mitkPlaneGeometry.h"
#include "mitkPlaneGeometryData.h"
#include "mitkSliceNavigationController.h"
#include "mitkTimeGeometry.h"
#include "mitkBindDispatcherInteractor.h"
#include "mitkDispatcher.h"
#include <vtkRenderWindow.h>
#include <vtkRenderer.h>
#include <map>
#include <set>
// DEPRECATED
#include <mitkTimeSlicedGeometry.h>
namespace mitk
{
class NavigationController;
class SliceNavigationController;
class CameraRotationController;
class CameraController;
class DataStorage;
class Mapper;
class BaseLocalStorageHandler;
class KeyEvent;
//##Documentation
//## @brief Organizes the rendering process
//##
//## Organizes the rendering process. A Renderer contains a reference to a
//## DataStorage and asks the mappers of the data objects to render
//## the data into the renderwindow it is associated to.
//##
//## \#Render() checks if rendering is currently allowed by calling
//## RenderWindow::PrepareRendering(). Initialization of a rendering context
//## can also be performed in this method.
//##
//## The actual rendering code has been moved to \#Repaint()
//## Both \#Repaint() and \#Update() are declared protected now.
//##
//## Note: Separation of the Repaint and Update processes (rendering vs
//## creating a vtk prop tree) still needs to be worked on. The whole
//## rendering process also should be reworked to use VTK based classes for
//## both 2D and 3D rendering.
//## @ingroup Renderer
class MITKCORE_EXPORT BaseRenderer : public itk::Object
{
public:
typedef std::map<vtkRenderWindow *, BaseRenderer *> BaseRendererMapType;
static BaseRendererMapType baseRendererMap;
static BaseRenderer *GetInstance(vtkRenderWindow *renWin);
static void AddInstance(vtkRenderWindow *renWin, BaseRenderer *baseRenderer);
static void RemoveInstance(vtkRenderWindow *renWin);
static BaseRenderer *GetByName(const std::string &name);
static vtkRenderWindow *GetRenderWindowByName(const std::string &name);
#pragma GCC visibility push(default)
itkEventMacro(RendererResetEvent, itk::AnyEvent);
#pragma GCC visibility pop
/** Standard class typedefs. */
mitkClassMacroItkParent(BaseRenderer, itk::Object);
BaseRenderer(const char *name = nullptr, vtkRenderWindow *renWin = nullptr);
//##Documentation
//## @brief MapperSlotId defines which kind of mapper (e.g. 2D or 3D) should be used.
typedef int MapperSlotId;
enum StandardMapperSlot
{
Standard2D = 1,
Standard3D = 2
};
//##Documentation
//## @brief Possible view directions for render windows.
enum class ViewDirection
{
AXIAL = 0,
SAGITTAL,
CORONAL,
THREE_D
};
virtual void SetDataStorage(DataStorage *storage); ///< set the datastorage that will be used for rendering
//##Documentation
//## return the DataStorage that is used for rendering
virtual DataStorage::Pointer GetDataStorage() const { return m_DataStorage.GetPointer(); }
//##Documentation
//## @brief Access the RenderWindow into which this renderer renders.
vtkRenderWindow *GetRenderWindow() const { return m_RenderWindow; }
vtkRenderer *GetVtkRenderer() const { return m_VtkRenderer; }
//##Documentation
//## @brief Returns the Dispatcher which handles Events for this BaseRenderer
Dispatcher::Pointer GetDispatcher() const;
//##Documentation
//## @brief Default mapper id to use.
static const MapperSlotId defaultMapper;
//##Documentation
//## @brief Do the rendering and flush the result.
virtual void Paint();
//##Documentation
//## @brief Initialize the RenderWindow. Should only be called from RenderWindow.
virtual void Initialize();
//##Documentation
//## @brief Called to inform the renderer that the RenderWindow has been resized.
virtual void Resize(int w, int h);
//##Documentation
//## @brief Initialize the renderer with a RenderWindow (@a renderwindow).
virtual void InitRenderer(vtkRenderWindow *renderwindow);
//##Documentation
//## @brief Set the initial size. Called by RenderWindow after it has become
//## visible for the first time.
virtual void InitSize(int w, int h);
//##Documentation
//## @brief Draws a point on the widget.
//## Should be used during conferences to show the position of the remote mouse
virtual void DrawOverlayMouse(Point2D &p2d);
//##Documentation
//## @brief Set/Get the WorldGeometry (m_WorldGeometry) for 3D and 2D rendering, that describing the
//## (maximal) area to be rendered.
//##
//## Depending of the type of the passed BaseGeometry more or less information can be extracted:
//## \li if it is a PlaneGeometry (which is a sub-class of BaseGeometry), m_CurrentWorldPlaneGeometry is
//## also set to point to it. m_WorldTimeGeometry is set to nullptr.
//## \li if it is a TimeGeometry, m_WorldTimeGeometry is also set to point to it.
//## If m_WorldTimeGeometry contains instances of SlicedGeometry3D, m_CurrentWorldPlaneGeometry is set to
//## one of geometries stored in the SlicedGeometry3D according to the value of m_Slice; otherwise
//## a PlaneGeometry describing the top of the bounding-box of the BaseGeometry is set as the
//## m_CurrentWorldPlaneGeometry.
//## \li otherwise a PlaneGeometry describing the top of the bounding-box of the BaseGeometry
//## is set as the m_CurrentWorldPlaneGeometry. m_WorldTimeGeometry is set to nullptr.
//## @todo add calculation of PlaneGeometry describing the top of the bounding-box of the BaseGeometry
//## when the passed BaseGeometry is not sliced.
//## \sa m_WorldGeometry
//## \sa m_WorldTimeGeometry
//## \sa m_CurrentWorldPlaneGeometry
virtual void SetWorldGeometry3D(const BaseGeometry *geometry);
virtual void SetWorldTimeGeometry(const mitk::TimeGeometry *geometry);
/**
* \deprecatedSince{2013_09} Please use TimeGeometry instead of TimeSlicedGeometry. For more information see
* http://www.mitk.org/Development/Refactoring%20of%20the%20Geometry%20Classes%20-%20Part%201
*/
DEPRECATED(void SetWorldGeometry3D(TimeSlicedGeometry *geometry));
itkGetConstObjectMacro(WorldTimeGeometry, TimeGeometry);
//##Documentation
//## @brief Get the current 3D-worldgeometry (m_CurrentWorldGeometry) used for 3D-rendering
itkGetConstObjectMacro(CurrentWorldGeometry, BaseGeometry);
//##Documentation
//## @brief Get the current 2D-worldgeometry (m_CurrentWorldPlaneGeometry) used for 2D-rendering
itkGetConstObjectMacro(CurrentWorldPlaneGeometry, PlaneGeometry)
/**
* \deprecatedSince{2014_10} Please use GetCurrentWorldPlaneGeometry
*/
DEPRECATED(const PlaneGeometry *GetCurrentWorldGeometry2D())
{
return GetCurrentWorldPlaneGeometry();
};
//##Documentation
//## Calculates the bounds of the DataStorage (if it contains any valid data),
//## creates a geometry from these bounds and sets it as world geometry of the renderer.
//##
//## Call this method to re-initialize the renderer to the current DataStorage
//## (e.g. after loading an additional dataset), to ensure that the view is
//## aligned correctly.
//## \warning This is not implemented yet.
virtual bool SetWorldGeometryToDataStorageBounds() { return false; }
//##Documentation
//## @brief Set/Get m_Slice which defines together with m_TimeStep the 2D geometry
//## stored in m_WorldTimeGeometry used as m_CurrentWorldPlaneGeometry
//##
//## \sa m_Slice
virtual void SetSlice(unsigned int slice);
itkGetConstMacro(Slice, unsigned int);
//##Documentation
//## @brief Set/Get m_TimeStep which defines together with m_Slice the 2D geometry
//## stored in m_WorldTimeGeometry used as m_CurrentWorldPlaneGeometry
//##
//## \sa m_TimeStep
virtual void SetTimeStep(unsigned int timeStep);
itkGetConstMacro(TimeStep, unsigned int);
//##Documentation
//## @brief Get the time-step of a BaseData object which
//## exists at the time of the currently displayed content
//##
//## Returns -1 or mitk::BaseData::m_TimeSteps if there
//## is no data at the current time.
//## \sa GetTimeStep, m_TimeStep
- int GetTimeStep(const BaseData *data) const;
+ TimeStepType GetTimeStep(const BaseData *data) const;
//##Documentation
//## @brief Get the time in ms of the currently displayed content
//##
//## \sa GetTimeStep, m_TimeStep
ScalarType GetTime() const;
//##Documentation
//## @brief SetWorldGeometry is called according to the geometrySliceEvent,
//## which is supposed to be a SliceNavigationController::GeometrySendEvent
virtual void SetGeometry(const itk::EventObject &geometrySliceEvent);
//##Documentation
//## @brief UpdateWorldGeometry is called to re-read the 2D geometry from the
//## slice navigation controller
virtual void UpdateGeometry(const itk::EventObject &geometrySliceEvent);
//##Documentation
//## @brief SetSlice is called according to the geometrySliceEvent,
//## which is supposed to be a SliceNavigationController::GeometrySliceEvent
virtual void SetGeometrySlice(const itk::EventObject &geometrySliceEvent);
//##Documentation
//## @brief SetTimeStep is called according to the geometrySliceEvent,
//## which is supposed to be a SliceNavigationController::GeometryTimeEvent
virtual void SetGeometryTime(const itk::EventObject &geometryTimeEvent);
//##Documentation
//## @brief Get a DataNode pointing to a data object containing the current 2D-worldgeometry
// m_CurrentWorldPlaneGeometry (for 2D rendering)
itkGetObjectMacro(CurrentWorldPlaneGeometryNode, DataNode)
/**
* \deprecatedSince{2014_10} Please use GetCurrentWorldPlaneGeometryNode
*/
DEPRECATED(DataNode *GetCurrentWorldGeometry2DNode())
{
return GetCurrentWorldPlaneGeometryNode();
};
//##Documentation
//## @brief Sets timestamp of CurrentWorldPlaneGeometry and forces so reslicing in that renderwindow
void SendUpdateSlice();
//##Documentation
//## @brief Get timestamp of last call of SetCurrentWorldPlaneGeometry
unsigned long GetCurrentWorldPlaneGeometryUpdateTime() { return m_CurrentWorldPlaneGeometryUpdateTime; }
/**
* \deprecatedSince{2014_10} Please use GetCurrentWorldPlaneGeometryUpdateTime
*/
DEPRECATED(unsigned long GetCurrentWorldGeometry2DUpdateTime())
{
return GetCurrentWorldPlaneGeometryUpdateTime();
};
//##Documentation
//## @brief Get timestamp of last change of current TimeStep
unsigned long GetTimeStepUpdateTime() { return m_TimeStepUpdateTime; }
//##Documentation
//## @brief Perform a picking: find the x,y,z world coordinate of a
//## display x,y coordinate.
//## @warning Has to be overwritten in subclasses for the 3D-case.
//##
//## Implemented here only for 2D-rendering
virtual void PickWorldPoint(const Point2D &diplayPosition, Point3D &worldPosition) const = 0;
/** \brief Determines the object (mitk::DataNode) closest to the current
* position by means of picking
*
* \warning Implementation currently empty for 2D rendering; intended to be
* implemented for 3D renderers */
virtual DataNode *PickObject(const Point2D & /*displayPosition*/, Point3D & /*worldPosition*/) const
{
return nullptr;
}
//##Documentation
//## @brief Get the MapperSlotId to use.
itkGetMacro(MapperID, MapperSlotId);
itkGetConstMacro(MapperID, MapperSlotId);
//##Documentation
//## @brief Set the MapperSlotId to use.
virtual void SetMapperID(MapperSlotId id);
virtual int *GetSize() const;
virtual int *GetViewportSize() const;
void SetSliceNavigationController(SliceNavigationController *SlicenavigationController);
itkGetObjectMacro(CameraController, CameraController);
itkGetObjectMacro(SliceNavigationController, SliceNavigationController);
itkGetObjectMacro(CameraRotationController, CameraRotationController);
itkGetMacro(EmptyWorldGeometry, bool);
//##Documentation
//## @brief Tells if the displayed region is shifted and rescaled if the render window is resized.
itkGetMacro(KeepDisplayedRegion, bool)
//##Documentation
//## @brief Tells if the displayed region should be shifted and rescaled if the render window is resized.
itkSetMacro(KeepDisplayedRegion, bool);
//##Documentation
//## @brief get the name of the Renderer
//## @note
const char *GetName() const
{
return m_Name.c_str();
}
//##Documentation
//## @brief get the x_size of the RendererWindow
//## @note
int GetSizeX() const { return GetSize()[0]; }
//##Documentation
//## @brief get the y_size of the RendererWindow
//## @note
int GetSizeY() const { return GetSize()[1]; }
const double *GetBounds() const;
void RequestUpdate();
void ForceImmediateUpdate();
/** Returns number of mappers which are visible and have level-of-detail
* rendering enabled */
unsigned int GetNumberOfVisibleLODEnabledMappers() const;
//##Documentation
//## @brief This method converts a display point to the 3D world index
//## using the geometry of the renderWindow.
void DisplayToWorld(const Point2D &displayPoint, Point3D &worldIndex) const;
//##Documentation
//## @brief This method converts a display point to the 2D world index, mapped onto the display plane
//## using the geometry of the renderWindow.
void DisplayToPlane(const Point2D &displayPoint, Point2D &planePointInMM) const;
//##Documentation
//## @brief This method converts a 3D world index to the display point
//## using the geometry of the renderWindow.
void WorldToDisplay(const Point3D &worldIndex, Point2D &displayPoint) const;
//##Documentation
//## @brief This method converts a 3D world index to the point on the viewport
//## using the geometry of the renderWindow.
void WorldToView(const Point3D &worldIndex, Point2D &viewPoint) const;
//##Documentation
//## @brief This method converts a 2D plane coordinate to the display point
//## using the geometry of the renderWindow.
void PlaneToDisplay(const Point2D &planePointInMM, Point2D &displayPoint) const;
//##Documentation
//## @brief This method converts a 2D plane coordinate to the point on the viewport
//## using the geometry of the renderWindow.
void PlaneToView(const Point2D &planePointInMM, Point2D &viewPoint) const;
double GetScaleFactorMMPerDisplayUnit() const;
Point2D GetDisplaySizeInMM() const;
Point2D GetViewportSizeInMM() const;
Point2D GetOriginInMM() const;
itkGetConstMacro(ConstrainZoomingAndPanning, bool) virtual void SetConstrainZoomingAndPanning(bool constrain);
/**
* \brief Provides (1) world coordinates for a given mouse position and (2)
* translates mousePosition to Display coordinates
* \deprecated Map2DRendererPositionTo3DWorldPosition is deprecated. Please use DisplayToWorld instead.
*/
DEPRECATED(virtual Point3D Map2DRendererPositionTo3DWorldPosition(const Point2D &mousePosition) const);
protected:
~BaseRenderer() override;
//##Documentation
//## @brief Call update of all mappers. To be implemented in subclasses.
virtual void Update() = 0;
vtkRenderWindow *m_RenderWindow;
vtkRenderer *m_VtkRenderer;
//##Documentation
//## @brief MapperSlotId to use. Defines which kind of mapper (e.g., 2D or 3D) shoud be used.
MapperSlotId m_MapperID;
//##Documentation
//## @brief The DataStorage that is used for rendering.
DataStorage::Pointer m_DataStorage;
//##Documentation
//## @brief Timestamp of last call of Update().
unsigned long m_LastUpdateTime;
//##Documentation
//## @brief CameraController for 3D rendering
//## @note preliminary.
itk::SmartPointer<CameraController> m_CameraController;
SliceNavigationController::Pointer m_SliceNavigationController;
CameraRotationController::Pointer m_CameraRotationController;
//##Documentation
//## @brief Sets m_CurrentWorldPlaneGeometry
virtual void SetCurrentWorldPlaneGeometry(const PlaneGeometry *geometry2d);
/**
* \deprecatedSince{2014_10} Please use SetCurrentWorldPlaneGeometry
*/
DEPRECATED(void SetCurrentWorldGeometry2D(PlaneGeometry *geometry2d)) { SetCurrentWorldPlaneGeometry(geometry2d); };
//##Documentation
//## @brief Sets m_CurrentWorldGeometry
virtual void SetCurrentWorldGeometry(const BaseGeometry *geometry);
private:
//##Documentation
//## m_WorldTimeGeometry is set by SetWorldGeometry if the passed BaseGeometry is a
//## TimeGeometry (or a sub-class of it). If it contains instances of SlicedGeometry3D,
//## m_Slice and m_TimeStep (set via SetSlice and SetTimeStep, respectively) define
//## which 2D geometry stored in m_WorldTimeGeometry (if available)
//## is used as m_CurrentWorldPlaneGeometry.
//## \sa m_CurrentWorldPlaneGeometry
TimeGeometry::ConstPointer m_WorldTimeGeometry;
//##Documentation
//## Pointer to the current 3D-worldgeometry.
BaseGeometry::ConstPointer m_CurrentWorldGeometry;
//##Documentation
//## Pointer to the current 2D-worldgeometry. The 2D-worldgeometry
//## describes the maximal area (2D manifold) to be rendered in case we
//## are doing 2D-rendering.
//## It is const, since we are not allowed to change it (it may be taken
//## directly from the geometry of an image-slice and thus it would be
//## very strange when suddenly the image-slice changes its geometry).
PlaneGeometry::Pointer m_CurrentWorldPlaneGeometry;
//##Documentation
//## Defines together with m_Slice which 2D geometry stored in m_WorldTimeGeometry
//## is used as m_CurrentWorldPlaneGeometry: m_WorldTimeGeometry->GetPlaneGeometry(m_Slice, m_TimeStep).
//## \sa m_WorldTimeGeometry
unsigned int m_Slice;
//##Documentation
//## Defines together with m_TimeStep which 2D geometry stored in m_WorldTimeGeometry
//## is used as m_CurrentWorldPlaneGeometry: m_WorldTimeGeometry->GetPlaneGeometry(m_Slice, m_TimeStep).
//## \sa m_WorldTimeGeometry
unsigned int m_TimeStep;
//##Documentation
//## @brief timestamp of last call of SetWorldGeometry
itk::TimeStamp m_CurrentWorldPlaneGeometryUpdateTime;
//##Documentation
//## @brief timestamp of last change of the current time step
itk::TimeStamp m_TimeStepUpdateTime;
//##Documentation
//## @brief Helper class which establishes connection between Interactors and Dispatcher via a common DataStorage.
BindDispatcherInteractor *m_BindDispatcherInteractor;
//##Documentation
//## @brief Tells if the displayed region should be shifted or rescaled if the render window is resized.
bool m_KeepDisplayedRegion;
protected:
void PrintSelf(std::ostream &os, itk::Indent indent) const override;
//##Documentation
//## Data object containing the m_CurrentWorldPlaneGeometry defined above.
PlaneGeometryData::Pointer m_CurrentWorldPlaneGeometryData;
//##Documentation
//## DataNode objects containing the m_CurrentWorldPlaneGeometryData defined above.
DataNode::Pointer m_CurrentWorldPlaneGeometryNode;
//##Documentation
//## @brief test only
unsigned long m_CurrentWorldPlaneGeometryTransformTime;
std::string m_Name;
double m_Bounds[6];
bool m_EmptyWorldGeometry;
typedef std::set<Mapper *> LODEnabledMappersType;
/** Number of mappers which are visible and have level-of-detail
* rendering enabled */
unsigned int m_NumberOfVisibleLODEnabledMappers;
// Local Storage Handling for mappers
protected:
std::list<mitk::BaseLocalStorageHandler *> m_RegisteredLocalStorageHandlers;
bool m_ConstrainZoomingAndPanning;
public:
void RemoveAllLocalStorages();
void RegisterLocalStorageHandler(mitk::BaseLocalStorageHandler *lsh);
void UnregisterLocalStorageHandler(mitk::BaseLocalStorageHandler *lsh);
};
} // namespace mitk
#endif /* BASERENDERER_H_HEADER_INCLUDED_C1CCA0F4 */
diff --git a/Modules/Core/include/mitkMessage.h b/Modules/Core/include/mitkMessage.h
index f1c4b48617..47cf00cac8 100644
--- a/Modules/Core/include/mitkMessage.h
+++ b/Modules/Core/include/mitkMessage.h
@@ -1,697 +1,697 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkMessageHIncluded
#define mitkMessageHIncluded
#include <functional>
#include <itkSimpleFastMutexLock.h>
#include <vector>
/**
* Adds a Message<> variable and methods to add/remove message delegates to/from
* this variable.
*/
#define mitkNewMessageMacro(msgHandleObject) \
private: \
::mitk::Message<> m_##msgHandleObject##Message; \
\
public: \
inline void Add##msgHandleObject##Listener(const ::mitk::MessageAbstractDelegate<> &delegate) \
{ \
m_##msgHandleObject##Message += delegate; \
} \
inline void Remove##msgHandleObject##Listener(const ::mitk::MessageAbstractDelegate<> &delegate) \
{ \
m_##msgHandleObject##Message -= delegate; \
}
#define mitkNewMessageWithReturnMacro(msgHandleObject, returnType) \
private: \
::mitk::Message<returnType> m_##msgHandleObject##Message; \
\
public: \
inline void Add##msgHandleObject##Listener(const ::mitk::MessageAbstractDelegate<returnType> &delegate) \
{ \
m_##msgHandleObject##Message += delegate; \
} \
inline void Remove##msgHandleObject##Listener(const ::mitk::MessageAbstractDelegate<returnType> &delegate) \
{ \
m_##msgHandleObject##Message -= delegate; \
}
#define mitkNewMessage1Macro(msgHandleObject, type1) \
private: \
::mitk::Message1<type1> m_##msgHandleObject##Message; \
\
public: \
void Add##msgHandleObject##Listener(const ::mitk::MessageAbstractDelegate1<type1> &delegate) \
{ \
m_##msgHandleObject##Message += delegate; \
} \
void Remove##msgHandleObject##Listener(const ::mitk::MessageAbstractDelegate1<type1> &delegate) \
{ \
m_##msgHandleObject##Message -= delegate; \
}
#define mitkNewMessage2Macro(msgHandleObject, type1, type2) \
private: \
::mitk::Message2<type1, type2> m_##msgHandleObject##Message; \
\
public: \
void Add##msgHandleObject##Listener(const ::mitk::MessageAbstractDelegate2<type1, type2> &delegate) \
{ \
m_##msgHandleObject##Message += delegate; \
} \
void Remove##msgHandleObject##Listener(const ::mitk::MessageAbstractDelegate2<type1, type2> &delegate) \
{ \
m_##msgHandleObject##Message -= delegate; \
}
namespace mitk
{
template <typename A = void>
class MessageAbstractDelegate
{
public:
virtual ~MessageAbstractDelegate() {}
virtual A Execute() const = 0;
virtual bool operator==(const MessageAbstractDelegate *cmd) const = 0;
virtual MessageAbstractDelegate *Clone() const = 0;
};
template <typename T, typename A = void>
class MessageAbstractDelegate1
{
public:
virtual ~MessageAbstractDelegate1() {}
virtual A Execute(T t) const = 0;
virtual bool operator==(const MessageAbstractDelegate1 *cmd) const = 0;
virtual MessageAbstractDelegate1 *Clone() const = 0;
};
template <typename T, typename U, typename A = void>
class MessageAbstractDelegate2
{
public:
virtual ~MessageAbstractDelegate2() {}
virtual A Execute(T t, U u) const = 0;
virtual bool operator==(const MessageAbstractDelegate2 *cmd) const = 0;
virtual MessageAbstractDelegate2 *Clone() const = 0;
};
template <typename T, typename U, typename V, typename A = void>
class MessageAbstractDelegate3
{
public:
virtual ~MessageAbstractDelegate3() {}
virtual A Execute(T t, U u, V v) const = 0;
virtual bool operator==(const MessageAbstractDelegate3 *cmd) const = 0;
virtual MessageAbstractDelegate3 *Clone() const = 0;
};
template <typename T, typename U, typename V, typename W, typename A = void>
class MessageAbstractDelegate4
{
public:
virtual ~MessageAbstractDelegate4() {}
virtual A Execute(T t, U u, V v, W w) const = 0;
virtual bool operator==(const MessageAbstractDelegate4 *cmd) const = 0;
virtual MessageAbstractDelegate4 *Clone() const = 0;
};
/**
* This class essentially wraps a function pointer with signature
* A(R::*function)(). A is the return type of your callback function
* and R the type of the class implementing the function.
*
* Use this class to add a callback function to
* messages without parameters.
*/
template <class R, typename A = void>
class MessageDelegate : public MessageAbstractDelegate<A>
{
public:
// constructor - takes pointer to an object and pointer to a member and stores
// them in two private variables
MessageDelegate(R *object, A (R::*memberFunctionPointer)())
: m_Object(object), m_MemberFunctionPointer(memberFunctionPointer)
{
}
~MessageDelegate() override {}
// override function "Call"
A Execute() const override
{
return (m_Object->*m_MemberFunctionPointer)(); // execute member function
}
bool operator==(const MessageAbstractDelegate<A> *c) const override
{
const MessageDelegate<R, A> *cmd = dynamic_cast<const MessageDelegate<R, A> *>(c);
if (!cmd)
return false;
if ((void *)this->m_Object != (void *)cmd->m_Object)
return false;
if (this->m_MemberFunctionPointer != cmd->m_MemberFunctionPointer)
return false;
return true;
}
MessageAbstractDelegate<A> *Clone() const override { return new MessageDelegate(m_Object, m_MemberFunctionPointer); }
private:
R *m_Object; // pointer to object
A (R::*m_MemberFunctionPointer)(); // pointer to member function
};
/**
* This class essentially wraps a function pointer with signature
* A(R::*function)(T). A is the return type of your callback function,
* R the type of the class implementing the function and T the type
* of the argument.
*
* Use this class to add a callback function to
* messages with one parameter.
*
* If you need more parameters, use MessageDelegate2 etc.
*/
template <class R, typename T, typename A = void>
class MessageDelegate1 : public MessageAbstractDelegate1<T, A>
{
public:
// constructor - takes pointer to an object and pointer to a member and stores
// them in two private variables
MessageDelegate1(R *object, A (R::*memberFunctionPointer)(T))
: m_Object(object), m_MemberFunctionPointer(memberFunctionPointer)
{
}
~MessageDelegate1() override {}
// override function "Call"
A Execute(T t) const override
{
return (m_Object->*m_MemberFunctionPointer)(t); // execute member function
}
bool operator==(const MessageAbstractDelegate1<T, A> *c) const override
{
const MessageDelegate1<R, T, A> *cmd = dynamic_cast<const MessageDelegate1<R, T, A> *>(c);
if (!cmd)
return false;
if ((void *)this->m_Object != (void *)cmd->m_Object)
return false;
if (this->m_MemberFunctionPointer != cmd->m_MemberFunctionPointer)
return false;
return true;
}
MessageAbstractDelegate1<T, A> *Clone() const override { return new MessageDelegate1(m_Object, m_MemberFunctionPointer); }
private:
R *m_Object; // pointer to object
A (R::*m_MemberFunctionPointer)(T); // pointer to member function
};
template <class R, typename T, typename U, typename A = void>
class MessageDelegate2 : public MessageAbstractDelegate2<T, U, A>
{
public:
// constructor - takes pointer to an object and pointer to a member and stores
// them in two private variables
MessageDelegate2(R *object, A (R::*memberFunctionPointer)(T, U))
: m_Object(object), m_MemberFunctionPointer(memberFunctionPointer)
{
}
~MessageDelegate2() override {}
// override function "Call"
A Execute(T t, U u) const override
{
return (m_Object->*m_MemberFunctionPointer)(t, u); // execute member function
}
bool operator==(const MessageAbstractDelegate2<T, U, A> *c) const override
{
const MessageDelegate2<R, T, U, A> *cmd = dynamic_cast<const MessageDelegate2<R, T, U, A> *>(c);
if (!cmd)
return false;
if ((void *)this->m_Object != (void *)cmd->m_Object)
return false;
if (this->m_MemberFunctionPointer != cmd->m_MemberFunctionPointer)
return false;
return true;
}
MessageAbstractDelegate2<T, U, A> *Clone() const override { return new MessageDelegate2(m_Object, m_MemberFunctionPointer); }
private:
R *m_Object; // pointer to object
A (R::*m_MemberFunctionPointer)(T, U); // pointer to member function
};
template <class R, typename T, typename U, typename V, typename A = void>
class MessageDelegate3 : public MessageAbstractDelegate3<T, U, V, A>
{
public:
// constructor - takes pointer to an object and pointer to a member and stores
// them in two private variables
MessageDelegate3(R *object, A (R::*memberFunctionPointer)(T, U, V))
: m_Object(object), m_MemberFunctionPointer(memberFunctionPointer)
{
}
~MessageDelegate3() override {}
// override function "Call"
A Execute(T t, U u, V v) const override
{
return (m_Object->*m_MemberFunctionPointer)(t, u, v); // execute member function
}
bool operator==(const MessageAbstractDelegate3<T, U, V, A> *c) const override
{
const MessageDelegate3<R, T, U, V, A> *cmd = dynamic_cast<const MessageDelegate3<R, T, U, V, A> *>(c);
if (!cmd)
return false;
if ((void *)this->m_Object != (void *)cmd->m_Object)
return false;
if (this->m_MemberFunctionPointer != cmd->m_MemberFunctionPointer)
return false;
return true;
}
MessageAbstractDelegate3<T, U, V, A> *Clone() const override
{
return new MessageDelegate3(m_Object, m_MemberFunctionPointer);
}
private:
R *m_Object; // pointer to object
A (R::*m_MemberFunctionPointer)(T, U, V); // pointer to member function
};
template <class R, typename T, typename U, typename V, typename W, typename A = void>
class MessageDelegate4 : public MessageAbstractDelegate4<T, U, V, W, A>
{
public:
// constructor - takes pointer to an object and pointer to a member and stores
// them in two private variables
MessageDelegate4(R *object, A (R::*memberFunctionPointer)(T, U, V, W))
: m_Object(object), m_MemberFunctionPointer(memberFunctionPointer)
{
}
virtual ~MessageDelegate4() {}
// override function "Call"
virtual A Execute(T t, U u, V v, W w) const
{
return (m_Object->*m_MemberFunctionPointer)(t, u, v, w); // execute member function
}
bool operator==(const MessageAbstractDelegate4<T, U, V, W, A> *c) const
{
const MessageDelegate4<R, T, U, V, W, A> *cmd = dynamic_cast<const MessageDelegate4<R, T, U, V, W, A> *>(c);
if (!cmd)
return false;
if ((void *)this->m_Object != (void *)cmd->m_Object)
return false;
if (this->m_MemberFunctionPointer != cmd->m_MemberFunctionPointer)
return false;
return true;
}
MessageAbstractDelegate4<T, U, V, W, A> *Clone() const
{
return new MessageDelegate4(m_Object, m_MemberFunctionPointer);
}
private:
R *m_Object; // pointer to object
A (R::*m_MemberFunctionPointer)(T, U, V, W); // pointer to member function
};
template <typename AbstractDelegate>
class MessageBase
{
public:
typedef std::vector<AbstractDelegate *> ListenerList;
virtual ~MessageBase()
{
for (auto iter = m_Listeners.begin(); iter != m_Listeners.end(); ++iter)
{
delete *iter;
}
}
MessageBase() {}
MessageBase(const MessageBase &o)
{
for (typename ListenerList::iterator iter = o.m_Listeners.begin(); iter != o.m_Listeners.end(); ++iter)
{
m_Listeners.push_back((*iter)->Clone());
}
}
MessageBase &operator=(const MessageBase &o)
{
MessageBase tmp(o);
std::swap(tmp.m_Listeners, this->m_Listeners);
return *this;
}
void AddListener(const AbstractDelegate &delegate) const
{
AbstractDelegate *msgCmd = delegate.Clone();
m_Mutex.Lock();
for (auto iter = m_Listeners.begin(); iter != m_Listeners.end(); ++iter)
{
if ((*iter)->operator==(msgCmd))
{
delete msgCmd;
m_Mutex.Unlock();
return;
}
}
m_Listeners.push_back(msgCmd);
m_Mutex.Unlock();
}
void operator+=(const AbstractDelegate &delegate) const { this->AddListener(delegate); }
void RemoveListener(const AbstractDelegate &delegate) const
{
m_Mutex.Lock();
for (auto iter = m_Listeners.begin(); iter != m_Listeners.end(); ++iter)
{
if ((*iter)->operator==(&delegate))
{
delete *iter;
m_Listeners.erase(iter);
m_Mutex.Unlock();
return;
}
}
m_Mutex.Unlock();
}
void operator-=(const AbstractDelegate &delegate) const { this->RemoveListener(delegate); }
const ListenerList &GetListeners() const { return m_Listeners; }
bool HasListeners() const { return !m_Listeners.empty(); }
bool IsEmpty() const { return m_Listeners.empty(); }
protected:
/**
* \brief List of listeners.
*
* This is declared mutable for a reason: Imagine an object that sends out notifications and
* someone gets a <tt>const Database</tt> object, because he/she should not write to the
* database. He/she should anyway be able to register for notifications about changes in the database
* -- this is why AddListener and RemoveListener are declared <tt>const</tt>. m_Listeners must be
* mutable so that AddListener and RemoveListener can modify it regardless of the object's constness.
*/
mutable ListenerList m_Listeners;
mutable itk::SimpleFastMutexLock m_Mutex;
};
/**
* \brief Event/message/notification class.
*
* \sa mitk::BinaryThresholdTool
* \sa QmitkBinaryThresholdToolGUI
*
* This totally ITK, Qt, VTK, whatever toolkit independent class
* allows one class to send out messages and another class to
* receive these message. This class is templated over the
* return type (A) of the callback functions.
* There are variations of this class
* (Message1, Message2, etc.) for sending
* one, two or more parameters along with the messages.
*
* This is an implementation of the Observer pattern.
*
* \li There is no guarantee about the order of which observer is notified first. At the moment the observers which
* register first will be notified first.
* \li Notifications are <b>synchronous</b>, by direct method calls. There is no support for asynchronous messages.
*
* To conveniently add methods for registering/unregistering observers
* to Message variables of your class, you can use the mitkNewMessageMacro
* macros.
*/
template <typename A = void>
class Message : public MessageBase<MessageAbstractDelegate<A>>
{
public:
typedef MessageBase<MessageAbstractDelegate<A>> Super;
typedef typename Super::ListenerList ListenerList;
- void Send()
+ void Send() const
{
ListenerList listeners;
{
this->m_Mutex.Lock();
listeners.assign(this->m_Listeners.begin(), this->m_Listeners.end());
this->m_Mutex.Unlock();
}
for (auto iter = listeners.begin(); iter != listeners.end(); ++iter)
{
// notify each listener
(*iter)->Execute();
}
}
- void operator()() { this->Send(); }
+ void operator()() const { this->Send(); }
};
// message with 1 parameter and return type
template <typename T, typename A = void>
class Message1 : public MessageBase<MessageAbstractDelegate1<T, A>>
{
public:
typedef MessageBase<MessageAbstractDelegate1<T, A>> Super;
typedef typename Super::ListenerList ListenerList;
- void Send(T t)
+ void Send(T t) const
{
ListenerList listeners;
{
this->m_Mutex.Lock();
listeners.assign(this->m_Listeners.begin(), this->m_Listeners.end());
this->m_Mutex.Unlock();
}
for (auto iter = listeners.begin(); iter != listeners.end(); ++iter)
{
// notify each listener
(*iter)->Execute(t);
}
}
- void operator()(T t) { this->Send(t); }
+ void operator() (T t) const { this->Send(t); }
};
// message with 2 parameters and return type
template <typename T, typename U, typename A = void>
class Message2 : public MessageBase<MessageAbstractDelegate2<T, U, A>>
{
public:
typedef MessageBase<MessageAbstractDelegate2<T, U, A>> Super;
typedef typename Super::ListenerList ListenerList;
- void Send(T t, U u)
+ void Send(T t, U u) const
{
ListenerList listeners;
{
this->m_Mutex.Lock();
listeners.assign(this->m_Listeners.begin(), this->m_Listeners.end());
this->m_Mutex.Unlock();
}
for (auto iter = listeners.begin(); iter != listeners.end(); ++iter)
{
// notify each listener
(*iter)->Execute(t, u);
}
}
- void operator()(T t, U u) { this->Send(t, u); }
+ void operator()(T t, U u) const { this->Send(t, u); }
};
// message with 3 parameters and return type
template <typename T, typename U, typename V, typename A = void>
class Message3 : public MessageBase<MessageAbstractDelegate3<T, U, V, A>>
{
public:
typedef MessageBase<MessageAbstractDelegate3<T, U, V, A>> Super;
typedef typename Super::ListenerList ListenerList;
- void Send(T t, U u, V v)
+ void Send(T t, U u, V v) const
{
ListenerList listeners;
{
this->m_Mutex.Lock();
listeners.assign(this->m_Listeners.begin(), this->m_Listeners.end());
this->m_Mutex.Unlock();
}
for (typename ListenerList::iterator iter = listeners.begin(); iter != listeners.end(); ++iter)
{
// notify each listener
(*iter)->Execute(t, u, v);
}
}
- void operator()(T t, U u, V v) { this->Send(t, u, v); }
+ void operator()(T t, U u, V v) const { this->Send(t, u, v); }
};
// message with 4 parameters and return type
template <typename T, typename U, typename V, typename W, typename A = void>
class Message4 : public MessageBase<MessageAbstractDelegate4<T, U, V, W>>
{
public:
typedef MessageBase<MessageAbstractDelegate4<T, U, V, W, A>> Super;
typedef typename Super::ListenerList ListenerList;
- void Send(T t, U u, V v, W w)
+ void Send(T t, U u, V v, W w) const
{
ListenerList listeners;
{
this->m_Mutex.Lock();
listeners.assign(this->m_Listeners.begin(), this->m_Listeners.end());
this->m_Mutex.Unlock();
}
for (typename ListenerList::iterator iter = listeners.begin(); iter != listeners.end(); ++iter)
{
// notify each listener
(*iter)->Execute(t, u, v, w);
}
}
- void operator()(T t, U u, V v, W w) { this->Send(t, u, v, w); }
+ void operator()(T t, U u, V v, W w) const { this->Send(t, u, v, w); }
};
/* Here is an example how to use the macros and templates:
*
* // An object to be send around
* class Law
* {
* private:
* std::string m_Description;
*
* public:
*
* Law(const std::string law) : m_Description(law)
* { }
*
* std::string GetDescription() const
* {
* return m_Description;
* }
* };
*
* // The NewtonMachine will issue specific events
* class NewtonMachine
* {
* mitkNewMessageMacro(AnalysisStarted);
* mitkNewMessage1Macro(AnalysisStopped, bool);
* mitkNewMessage1Macro(LawDiscovered, const Law&);
*
* public:
*
* void StartAnalysis()
* {
* // send the "started" signal
* m_AnalysisStartedMessage();
*
* // we found a new law of nature by creating one :-)
* Law massLaw("F=ma");
* m_LawDiscoveredMessage(massLaw);
* }
*
* void StopAnalysis()
* {
* // send the "stop" message with false, indicating
* // that no error occured
* m_AnalysisStoppedMessage(false);
* }
* };
*
* class Observer
* {
* private:
*
* NewtonMachine* m_Machine;
*
* public:
*
* Observer(NewtonMachine* machine) : m_Machine(machine)
* {
* // Add "observers", i.e. function pointers to the machine
* m_Machine->AddAnalysisStartedListener(
* ::mitk::MessageDelegate<Observer>(this, &Observer::MachineStarted));
* m_Machine->AddAnalysisStoppedListener(
* ::mitk::MessageDelegate1<Observer, bool>(this, &Observer::MachineStopped));
* m_Machine->AddLawDiscoveredListener(
* ::mitk::MessageDelegate1<Observer, const Law&>(this, &Observer::LawDiscovered));
* }
*
* ~Observer()
* {
* // Always remove your observers when finished
* m_Machine->RemoveAnalysisStartedListener(
* ::mitk::MessagDelegate<Observer>(this, &Observer::MachineStarted));
* m_Machine->RemoveAnalysisStoppedListener(
* ::mitk::MessageDelegate1<Observer, bool>(this, &Observer::MachineStopped));
* m_Machine->RemoveLawDiscoveredListener(
* ::mitk::MessageDelegate1<Observer, const Law&>(this, &Observer::LawDiscovered));
* }
*
* void MachineStarted()
* {
* std::cout << "Observed machine has started" << std::endl;
* }
*
* void MachineStopped(bool error)
* {
* std::cout << "Observed machine stopped " << (error ? "with an error" : "") << std::endl;
* }
*
* void LawDiscovered(const Law& law)
* {
* std::cout << "New law of nature discovered: " << law.GetDescription() << std::endl;
* }
* };
*
* NewtonMachine newtonMachine;
* Observer observer(&newtonMachine);
*
* // This will send two events to registered observers
* newtonMachine.StartAnalysis();
* // This will send one event to registered observers
* newtonMachine.StopAnalysis();
*
* Another example of how to use these message classes can be
* found in the directory Testing, file mitkMessageTest.cpp
*
*/
} // namespace
#endif
diff --git a/Modules/Core/include/mitkNodePredicateGeometry.h b/Modules/Core/include/mitkNodePredicateGeometry.h
index 42c8fd55c5..105bbf1d6e 100644
--- a/Modules/Core/include/mitkNodePredicateGeometry.h
+++ b/Modules/Core/include/mitkNodePredicateGeometry.h
@@ -1,80 +1,83 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef MITKNODEPREDICATEGEOMETRY_H_HEADER_INCLUDED_
#define MITKNODEPREDICATEGEOMETRY_H_HEADER_INCLUDED_
#include "mitkNodePredicateBase.h"
#include "mitkBaseGeometry.h"
#include "mitkTimeGeometry.h"
namespace mitk
{
class BaseData;
/**Documentation
@brief Predicate that evaluates if the given DataNode's data object
has the same geometry (in terms of spacing, origin, orientation) like
the reference geometry.
One can either check the whole time geometry of
the date node by defining a referenc time geometry or check against one given
reference base geometry. If the predicate should check against a base geometry,
you can specify the timepoint of the data's time geometry that should be checked.
If no timepoint is defined the predicate will evaluate the data geometry in
the first timestep.
Evaluates to "false" for unsupported or undefined data objects/geometries.
One can specify the tolerance/precision of the check via SetCheckPrecision().
@remark The default tolerance is 1e-6 and therefore not as strict as mitk::eps. The reason is,
that, for the typical use of the node predicate, mitk::eps would be to pedantic. We
often encounter floating point differences and practically it makes no difference e.g.
if two images differ something like 0.000001 mm in size or spacing.
@ingroup DataStorage */
class MITKCORE_EXPORT NodePredicateGeometry : public NodePredicateBase
{
public:
mitkClassMacro(NodePredicateGeometry, NodePredicateBase);
mitkNewMacro1Param(NodePredicateGeometry, const TimeGeometry*);
mitkNewMacro1Param(NodePredicateGeometry, const BaseGeometry*);
mitkNewMacro2Param(NodePredicateGeometry, const BaseGeometry*, TimePointType);
itkSetMacro(CheckPrecision, mitk::ScalarType);
itkGetMacro(CheckPrecision, mitk::ScalarType);
~NodePredicateGeometry() override;
bool CheckNode(const mitk::DataNode *node) const override;
protected:
/**Constructor that is used configures the predicate to check the reference geometry against the first data timepoint.*/
NodePredicateGeometry(const BaseGeometry* refGeometry);
/**Constructor allows to define the timepoint that should be evaluated against the reference.*/
NodePredicateGeometry(const BaseGeometry* refGeometry, TimePointType relevantTimePoint);
/**Constructor that is used configures the predicate to check against the whole time geometry.*/
NodePredicateGeometry(const TimeGeometry* refGeometry);
BaseGeometry::ConstPointer m_RefGeometry;
TimeGeometry::ConstPointer m_RefTimeGeometry;
TimePointType m_TimePoint;
/**Indicates if m_TimePoint should be regarded or always the first timestep should be used.*/
bool m_UseTimePoint;
/**Precision that should be used for the equal checks.*/
mitk::ScalarType m_CheckPrecision;
};
- constexpr double NODE_PREDICATE_GEOMETRY_DEFAULT_CHECK_PRECISION = 1e-6;
+ /* Changed NODE_PREDICATE_GEOMETRY_DEFAULT_CHECK_PRECISION from 1e-6 due to
+ T28127. If https://github.com/QIICR/dcmqi/issues/414 is clarified we could
+ change it back*/
+ constexpr double NODE_PREDICATE_GEOMETRY_DEFAULT_CHECK_PRECISION = 5e-5;
} // namespace mitk
#endif /* MITKNodePredicateGeometry_H_HEADER_INCLUDED_ */
diff --git a/Modules/Core/include/mitkPixelType.h b/Modules/Core/include/mitkPixelType.h
index 8717986986..3464c89f37 100644
--- a/Modules/Core/include/mitkPixelType.h
+++ b/Modules/Core/include/mitkPixelType.h
@@ -1,299 +1,299 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkPixelType_h
#define mitkPixelType_h
#include "mitkCommon.h"
#include "mitkPixelTypeTraits.h"
#include <MitkCoreExports.h>
#include <string>
#include <typeinfo>
#include <itkImage.h>
#include <itkImageIOBase.h>
#include <vtkImageData.h>
namespace mitk
{
template <typename T>
std::string PixelComponentTypeToString()
{
return itk::ImageIOBase::GetComponentTypeAsString(itk::ImageIOBase::MapPixelType<T>::CType);
}
template <typename PixelT>
std::string PixelTypeToString()
{
return std::string();
}
/**
* @brief Class for defining the data type of pixels
*
* To obtain additional type information not provided by this class
* itk::ImageIOBase can be used by passing the return value of
* PixelType::GetItkTypeId() to itk::ImageIOBase::SetPixelTypeInfo
* and using the itk::ImageIOBase methods GetComponentType,
* GetComponentTypeAsString, GetPixelType, GetPixelTypeAsString.
* @ingroup Data
*/
class MITKCORE_EXPORT PixelType
{
public:
typedef itk::ImageIOBase::IOPixelType ItkIOPixelType;
typedef itk::ImageIOBase::IOComponentType ItkIOComponentType;
PixelType(const mitk::PixelType &aPixelType);
PixelType &operator=(const PixelType &other);
itk::ImageIOBase::IOPixelType GetPixelType() const;
/**
* \brief Get the \a component type (the scalar (!) type). Each element
* may contain m_NumberOfComponents (more than one) of these scalars.
*
*/
int GetComponentType() const;
/**
* \brief Returns a string containing the ITK pixel type name.
*/
std::string GetPixelTypeAsString() const;
/**
* \brief Returns a string containing the name of the component.
*/
std::string GetComponentTypeAsString() const;
/**
* \brief Returns a string representing the pixel type and pixel components.
*/
std::string GetTypeAsString() const;
/**
* \brief Get size of the PixelType in bytes
*
* A RGBA PixelType of floats will return 4 * sizeof(float)
*/
size_t GetSize() const;
/**
* \brief Get the number of bits per element (of an
* element)
*
* A vector of double with three components will return
* 8*sizeof(double)*3.
* \sa GetBitsPerComponent
* \sa GetItkTypeId
* \sa GetTypeId
*/
size_t GetBpe() const;
/**
* \brief Get the number of components of which each element consists
*
* Each pixel can consist of multiple components, e.g. RGB.
*/
size_t GetNumberOfComponents() const;
/**
* \brief Get the number of bits per components
* \sa GetBitsPerComponent
*/
size_t GetBitsPerComponent() const;
bool operator==(const PixelType &rhs) const;
bool operator!=(const PixelType &rhs) const;
~PixelType();
private:
friend PixelType MakePixelType(const itk::ImageIOBase *imageIO);
template <typename ComponentT, typename PixelT>
- friend PixelType MakePixelType(std::size_t numberOfComponents);
+ friend PixelType MakePixelType(std::size_t numOfComponents);
template <typename ItkImageType>
friend PixelType MakePixelType();
template <typename ItkImageType>
friend PixelType MakePixelType(size_t);
PixelType(const int componentType,
const ItkIOPixelType pixelType,
std::size_t bytesPerComponent,
- std::size_t numberOfComponents,
+ std::size_t numOfComponents,
const std::string &componentTypeName,
const std::string &pixelTypeName);
// default constructor is disabled on purpose
PixelType(void);
/** \brief the \a type_info of the scalar (!) component type. Each element
may contain m_NumberOfComponents (more than one) of these scalars.
*/
int m_ComponentType;
ItkIOPixelType m_PixelType;
std::string m_ComponentTypeName;
std::string m_PixelTypeName;
std::size_t m_NumberOfComponents;
std::size_t m_BytesPerComponent;
};
/**
* @brief deduct the PixelType for a given vtk image
*
* @param vtkimagedata the image the PixelType shall be deducted from
* @return the mitk::PixelType
*/
MITKCORE_EXPORT mitk::PixelType MakePixelType(vtkImageData *vtkimagedata);
/**
* \brief A template method for creating a pixel type.
*/
template <typename ComponentT, typename PixelT>
PixelType MakePixelType(std::size_t numOfComponents)
{
return PixelType(MapPixelType<PixelT, isPrimitiveType<PixelT>::value>::IOComponentType,
MapPixelType<PixelT, isPrimitiveType<PixelT>::value>::IOPixelType,
sizeof(ComponentT),
numOfComponents,
PixelComponentTypeToString<ComponentT>(),
PixelTypeToString<PixelT>());
}
/**
* \brief A template method for creating a pixel type.
*
* @deprecated, use version with one numOfComponents as function argument instead.
*/
template <typename ComponentT, typename PixelT, std::size_t numOfComponents>
PixelType MakePixelType()
{
return MakePixelType<ComponentT, PixelT>(numOfComponents);
}
/**
* \brief A helper template for compile-time checking of supported ITK image types.
*
* Unsupported image types will be marked by template specializations with
* missing definitions;
*/
template <typename ItkImageType>
struct AssertImageTypeIsValid
{
};
// The itk::VariableLengthVector pixel type is not supported in MITK if it is
// used with an itk::Image (it cannot be represented as a mitk::Image object).
// Use a itk::VectorImage instead.
template <typename TPixelType, unsigned int VImageDimension>
struct AssertImageTypeIsValid<itk::Image<itk::VariableLengthVector<TPixelType>, VImageDimension>>;
/** \brief A template method for creating a MITK pixel type na ITK image type
*
* \param numOfComponents The number of components for the pixel type of the ITK image
*/
template <typename ItkImageType>
PixelType MakePixelType(std::size_t numOfComponents)
{
AssertImageTypeIsValid<ItkImageType>();
// define new type, since the ::PixelType is used to distinguish between simple and compound types
typedef typename ItkImageType::PixelType ImportPixelType;
// get the component type ( is either directly ImportPixelType or ImportPixelType::ValueType for compound types )
typedef typename GetComponentType<ImportPixelType>::ComponentType ComponentT;
// The PixelType is the same as the ComponentT for simple types
typedef typename ItkImageType::PixelType PixelT;
// call the constructor
return PixelType(MapPixelType<PixelT, isPrimitiveType<PixelT>::value>::IOComponentType,
MapPixelType<PixelT, isPrimitiveType<PixelT>::value>::IOPixelType,
sizeof(ComponentT),
numOfComponents,
PixelComponentTypeToString<ComponentT>(),
PixelTypeToString<PixelT>());
}
/** \brief A template method for creating a MITK pixel type from an ITK image
* pixel type and dimension
*
* \param numOfComponents The number of components for the pixel type \c TPixelType
*/
template <typename TPixelType, unsigned int VImageDimension>
PixelType MakePixelType(std::size_t numOfComponents)
{
typedef typename ImageTypeTrait<TPixelType, VImageDimension>::ImageType ItkImageType;
return MakePixelType<ItkImageType>(numOfComponents);
}
/** \brief A template method for creating a MITK pixel type from an ITK image
* pixel type and dimension
*
* For images where the number of components of the pixel type is determined at
* runtime (e.g. pixel types like itk::VariableLengthVector<short>) the
* MakePixelType(std::size_t) function must be used.
*/
template <typename ItkImageType>
PixelType MakePixelType()
{
if (ImageTypeTrait<ItkImageType>::IsVectorImage)
{
mitkThrow() << " Variable pixel type given but the length is not specified. Use the parametric MakePixelType( "
"size_t ) method instead.";
}
// Use the InternalPixelType to get "1" for the number of components in case of
// a itk::VectorImage
typedef typename ItkImageType::InternalPixelType PixelT;
const std::size_t numComp = ComponentsTrait<isPrimitiveType<PixelT>::value, ItkImageType>::Size;
// call the constructor
return MakePixelType<ItkImageType>(numComp);
}
/**
* \brief Create a MITK pixel type based on a itk::ImageIOBase object
*/
inline PixelType MakePixelType(const itk::ImageIOBase *imageIO)
{
return mitk::PixelType(imageIO->GetComponentType(),
imageIO->GetPixelType(),
imageIO->GetComponentSize(),
imageIO->GetNumberOfComponents(),
imageIO->GetComponentTypeAsString(imageIO->GetComponentType()),
imageIO->GetPixelTypeAsString(imageIO->GetPixelType()));
}
/** \brief An interface to the MakePixelType method for creating scalar pixel types.
*
* Usage: for example MakeScalarPixelType<short>() for a scalar short image
*/
template <typename T>
PixelType MakeScalarPixelType()
{
return MakePixelType<T, T, 1>();
}
} // namespace mitk
#endif /* mitkPixelType_h */
diff --git a/Modules/Core/include/mitkPlaneGeometry.h b/Modules/Core/include/mitkPlaneGeometry.h
index f06e23e30d..783a6a4d5e 100644
--- a/Modules/Core/include/mitkPlaneGeometry.h
+++ b/Modules/Core/include/mitkPlaneGeometry.h
@@ -1,614 +1,614 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
/**
* \brief Describes the geometry of a plane object
*
* Describes a two-dimensional manifold, i.e., to put it simply,
* an object that can be described using a 2D coordinate-system.
*
* PlaneGeometry can map points between 3D world coordinates
* (in mm) and the described 2D coordinate-system (in mm) by first projecting
* the 3D point onto the 2D manifold and then calculating the 2D-coordinates
* (in mm). These 2D-mm-coordinates can be further converted into
* 2D-unit-coordinates (e.g., pixels), giving a parameter representation of
* the object with parameter values inside a rectangle
* (e.g., [0,0]..[width, height]), which is the bounding box (bounding range
* in z-direction always [0]..[1]).
*
* A PlaneGeometry describes the 2D representation within a 3D object (derived from BaseGeometry). For example,
* a single CT-image (slice) is 2D in the sense that you can access the
* pixels using 2D-coordinates, but is also 3D, as the pixels are really
* voxels, thus have an extension (thickness) in the 3rd dimension.
*
*
* Optionally, a reference BaseGeometry can be specified, which usually would
* be the geometry associated with the underlying dataset. This is currently
* used for calculating the intersection of inclined / rotated planes
* (represented as PlaneGeometry) with the bounding box of the associated
* BaseGeometry.
*
* \warning The PlaneGeometry are not necessarily up-to-date and not even
* initialized. As described in the previous paragraph, one of the
* Generate-/Copy-/UpdateOutputInformation methods have to initialize it.
* mitk::BaseData::GetPlaneGeometry() makes sure, that the PlaneGeometry is
* up-to-date before returning it (by setting the update extent appropriately
* and calling UpdateOutputInformation).
*
* Rule: everything is in mm (or ms for temporal information) if not
* stated otherwise.
* \ingroup Geometry
*/
#ifndef PLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C
#define PLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C
#include "mitkBaseGeometry.h"
#include "mitkRestorePlanePositionOperation.h"
#include <MitkCoreExports.h>
#include <vnl/vnl_cross.h>
namespace mitk
{
template <class TCoordRep, unsigned int NPointDimension>
class Line;
typedef Line<ScalarType, 3> Line3D;
class PlaneGeometry;
/** \deprecatedSince{2014_10} This class is deprecated. Please use PlaneGeometry instead. */
DEPRECATED(typedef PlaneGeometry Geometry2D);
/**
* \brief Describes a two-dimensional, rectangular plane
*
* \ingroup Geometry
*/
class MITKCORE_EXPORT PlaneGeometry : public BaseGeometry
{
public:
mitkClassMacro(PlaneGeometry, BaseGeometry);
/** Method for creation through the object factory. */
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
enum PlaneOrientation {
Axial,
Sagittal,
Frontal, // also known as "Coronal" in mitk.
None // This defines the PlaneGeometry for the 3D renderWindow which
// curiously also needs a PlaneGeometry. This should be reconsidered some time.
};
virtual void IndexToWorld(const Point2D &pt_units, Point2D &pt_mm) const;
virtual void WorldToIndex(const Point2D &pt_mm, Point2D &pt_units) const;
//##Documentation
//## @brief Convert (continuous or discrete) index coordinates of a \em vector
//## \a vec_units to world coordinates (in mm)
//## @deprecated First parameter (Point2D) is not used. If possible, please use void IndexToWorld(const
// mitk::Vector2D& vec_units, mitk::Vector2D& vec_mm) const.
//## For further information about coordinates types, please see the Geometry documentation
virtual void IndexToWorld(const mitk::Point2D &atPt2d_untis,
const mitk::Vector2D &vec_units,
mitk::Vector2D &vec_mm) const;
//##Documentation
//## @brief Convert (continuous or discrete) index coordinates of a \em vector
//## \a vec_units to world coordinates (in mm)
//## For further information about coordinates types, please see the Geometry documentation
virtual void IndexToWorld(const mitk::Vector2D &vec_units, mitk::Vector2D &vec_mm) const;
//##Documentation
//## @brief Convert world coordinates (in mm) of a \em vector
//## \a vec_mm to (continuous!) index coordinates.
//## @deprecated First parameter (Point2D) is not used. If possible, please use void WorldToIndex(const
// mitk::Vector2D& vec_mm, mitk::Vector2D& vec_units) const.
//## For further information about coordinates types, please see the Geometry documentation
virtual void WorldToIndex(const mitk::Point2D &atPt2d_mm,
const mitk::Vector2D &vec_mm,
mitk::Vector2D &vec_units) const;
//##Documentation
//## @brief Convert world coordinates (in mm) of a \em vector
//## \a vec_mm to (continuous!) index coordinates.
//## For further information about coordinates types, please see the Geometry documentation
virtual void WorldToIndex(const mitk::Vector2D &vec_mm, mitk::Vector2D &vec_units) const;
/**
* \brief Initialize a plane with orientation \a planeorientation
* (default: axial) with respect to \a BaseGeometry (default: identity).
* Spacing also taken from \a BaseGeometry.
*
* \warning A former version of this method created a geometry with unit
* spacing. For unit spacing use
*
* \code
* // for in-plane unit spacing:
* thisgeometry->SetSizeInUnits(thisgeometry->GetExtentInMM(0),
* thisgeometry->GetExtentInMM(1));
* // additionally, for unit spacing in normal direction (former version
* // did not do this):
* thisgeometry->SetExtentInMM(2, 1.0);
* \endcode
*/
virtual void InitializeStandardPlane(const BaseGeometry *geometry3D,
PlaneOrientation planeorientation = Axial,
ScalarType zPosition = 0,
bool frontside = true,
bool rotated = false,
bool top = true);
/**
* \brief Initialize a plane with orientation \a planeorientation
* (default: axial) with respect to \a BaseGeometry (default: identity).
* Spacing also taken from \a BaseGeometry.
*
* \param geometry3D
* \param top if \a true, create plane at top, otherwise at bottom
* (for PlaneOrientation Axial, for other plane locations respectively)
* \param planeorientation
* \param frontside
* \param rotated
*/
virtual void InitializeStandardPlane(const BaseGeometry *geometry3D,
bool top,
PlaneOrientation planeorientation = Axial,
bool frontside = true,
bool rotated = false);
/**
* \brief Initialize a plane with orientation \a planeorientation
* (default: axial) with respect to \a transform (default: identity)
* given width and height in units.
*
* \a Rotated means rotated by 180 degrees (1/2 rotation) within the plane.
* Rotation by 90 degrees (1/4 rotation) is not implemented as of now.
*
* \a Frontside/Backside:
* Viewed from below = frontside in the axial case;
* (radiologist's view versus neuro-surgeon's view, see:
* http://www.itk.org/Wiki/images/e/ed/DICOM-OrientationDiagram-Radiologist-vs-NeuroSurgeon.png )
* Viewed from front = frontside in the coronal case;
* Viewed from left = frontside in the sagittal case.
*
* \a Cave/Caution: Currently only RPI, LAI, LPS and RAS in the three standard planes are covered,
* i.e. 12 cases of 144: 3 standard planes * 48 coordinate orientations = 144 cases.
*/
virtual void InitializeStandardPlane(ScalarType width,
ScalarType height,
const AffineTransform3D *transform = nullptr,
PlaneOrientation planeorientation = Axial,
ScalarType zPosition = 0,
bool frontside = true,
bool rotated = false,
bool top = true);
/**
* \brief Initialize plane with orientation \a planeorientation
* (default: axial) given width, height and spacing.
*
*/
virtual void InitializeStandardPlane(ScalarType width,
ScalarType height,
const Vector3D &spacing,
PlaneOrientation planeorientation = Axial,
ScalarType zPosition = 0,
bool frontside = true,
bool rotated = false,
bool top = true);
/**
* \brief Initialize plane by width and height in pixels, right-/down-vector
* (itk) to describe orientation in world-space (vectors will be normalized)
* and spacing (default: 1.0 mm in all directions).
*
* The vectors are normalized and multiplied by the respective spacing before
* they are set in the matrix.
*
* This overloaded version of InitializeStandardPlane() creates only righthanded
* coordinate orientations, unless spacing contains 1 or 3 negative entries.
*
*/
virtual void InitializeStandardPlane(ScalarType width,
ScalarType height,
const Vector3D &rightVector,
const Vector3D &downVector,
const Vector3D *spacing = nullptr);
/**
* \brief Initialize plane by width and height in pixels,
* right-/down-vector (vnl) to describe orientation in world-space (vectors
* will be normalized) and spacing (default: 1.0 mm in all directions).
*
* The vectors are normalized and multiplied by the respective spacing
* before they are set in the matrix.
*
* This overloaded version of InitializeStandardPlane() creates only righthanded
* coordinate orientations, unless spacing contains 1 or 3 negative entries.
*
*/
virtual void InitializeStandardPlane(ScalarType width,
ScalarType height,
const VnlVector &rightVector,
const VnlVector &downVector,
const Vector3D *spacing = nullptr);
/**
* \brief Initialize plane by right-/down-vector (itk) and spacing
* (default: 1.0 mm in all directions).
*
* The length of the right-/-down-vector is used as width/height in units,
* respectively. Then, the vectors are normalized and multiplied by the
* respective spacing before they are set in the matrix.
*/
virtual void InitializeStandardPlane(const Vector3D &rightVector,
const Vector3D &downVector,
const Vector3D *spacing = nullptr);
/**
* \brief Initialize plane by right-/down-vector (vnl) and spacing
* (default: 1.0 mm in all directions).
*
* The length of the right-/-down-vector is used as width/height in units,
* respectively. Then, the vectors are normalized and multiplied by the
* respective spacing before they are set in the matrix.
*/
virtual void InitializeStandardPlane(const VnlVector &rightVector,
const VnlVector &downVector,
const Vector3D *spacing = nullptr);
/**
* \brief Initialize plane by origin and normal (size is 1.0 mm in
* all directions, direction of right-/down-vector valid but
* undefined).
* \warning This function can only produce righthanded coordinate orientation, not lefthanded.
*/
virtual void InitializePlane(const Point3D &origin, const Vector3D &normal);
/**
* \brief Initialize plane by right-/down-vector.
*
* \warning The vectors are set into the matrix as they are,
* \em without normalization!
* This function creates a righthanded IndexToWorldTransform,
* only a negative thickness could still make it lefthanded.
*/
void SetMatrixByVectors(const VnlVector &rightVector, const VnlVector &downVector, ScalarType thickness = 1.0);
/**
* \brief Check if matrix is a rotation matrix:
* - determinant is 1?
* - R*R^T is ID?
* Output warning otherwise.
*/
static bool CheckRotationMatrix(AffineTransform3D *transform, double epsilon=mitk::eps);
/**
* \brief Normal of the plane
*
*/
Vector3D GetNormal() const;
/**
* \brief Normal of the plane as VnlVector
*
*/
VnlVector GetNormalVnl() const;
virtual ScalarType SignedDistance(const Point3D &pt3d_mm) const;
/**
* \brief Calculates, whether a point is below or above the plane. There are two different
*calculation methods, with or without consideration of the bounding box.
*/
virtual bool IsAbove(const Point3D &pt3d_mm, bool considerBoundingBox = false) const;
/**
* \brief Distance of the point from the plane
* (bounding-box \em not considered)
*
*/
ScalarType DistanceFromPlane(const Point3D &pt3d_mm) const;
/**
* \brief Signed distance of the point from the plane
* (bounding-box \em not considered)
*
* > 0 : point is in the direction of the direction vector.
*/
inline ScalarType SignedDistanceFromPlane(const Point3D &pt3d_mm) const
{
ScalarType len = GetNormalVnl().two_norm();
if (len == 0)
return 0;
return (pt3d_mm - GetOrigin()) * GetNormal() / len;
}
/**
* \brief Distance of the plane from another plane
* (bounding-box \em not considered)
*
* Result is 0 if planes are not parallel.
*/
ScalarType DistanceFromPlane(const PlaneGeometry *plane) const { return fabs(SignedDistanceFromPlane(plane)); }
/**
* \brief Signed distance of the plane from another plane
* (bounding-box \em not considered)
*
* Result is 0 if planes are not parallel.
*/
inline ScalarType SignedDistanceFromPlane(const PlaneGeometry *plane) const
{
if (IsParallel(plane))
{
return SignedDistance(plane->GetOrigin());
}
return 0;
}
/**
* \brief Calculate the intersecting line of two planes
*
* \return \a true planes are intersecting
* \return \a false planes do not intersect
*/
bool IntersectionLine(const PlaneGeometry *plane, Line3D &crossline) const;
/**
* \brief Calculate two points where another plane intersects the border of this plane
*
* \return number of intersection points (0..2). First interection point (if existing)
* is returned in \a lineFrom, second in \a lineTo.
*/
unsigned int IntersectWithPlane2D(const PlaneGeometry *plane, Point2D &lineFrom, Point2D &lineTo) const;
/**
* \brief Calculate the angle between two planes
*
* \return angle in radiants
*/
double Angle(const PlaneGeometry *plane) const;
/**
* \brief Calculate the angle between the plane and a line
*
* \return angle in radiants
*/
double Angle(const Line3D &line) const;
/**
* \brief Calculate intersection point between the plane and a line
*
* \param line
* \param intersectionPoint intersection point
* \return \a true if \em unique intersection exists, i.e., if line
* is \em not on or parallel to the plane
*/
bool IntersectionPoint(const Line3D &line, Point3D &intersectionPoint) const;
/**
* \brief Calculate line parameter of intersection point between the
* plane and a line
*
* \param line
* \param t parameter of line: intersection point is
* line.GetPoint()+t*line.GetDirection()
* \return \a true if \em unique intersection exists, i.e., if line
* is \em not on or parallel to the plane
*/
bool IntersectionPointParam(const Line3D &line, double &t) const;
/**
* \brief Returns whether the plane is parallel to another plane
*
* @return true iff the normal vectors both point to the same or exactly oposit direction
*/
bool IsParallel(const PlaneGeometry *plane) const;
/**
* \brief Returns whether the point is on the plane
* (bounding-box \em not considered)
*/
bool IsOnPlane(const Point3D &point) const;
/**
* \brief Returns whether the line is on the plane
* (bounding-box \em not considered)
*/
bool IsOnPlane(const Line3D &line) const;
/**
* \brief Returns whether the plane is on the plane
* (bounding-box \em not considered)
*
- * @return true iff the normal vector of the planes point to the same or the exactly oposit direction and
+ * @return true if the normal vector of the planes point to the same or the exactly oposit direction and
* the distance of the planes is < eps
*
*/
bool IsOnPlane(const PlaneGeometry *plane) const;
/**
* \brief Returns the lot from the point to the plane
*/
Point3D ProjectPointOntoPlane(const Point3D &pt) const;
itk::LightObject::Pointer InternalClone() const override;
/** Implements operation to re-orient the plane */
void ExecuteOperation(Operation *operation) override;
/**
* \brief Project a 3D point given in mm (\a pt3d_mm) onto the 2D
* geometry. The result is a 2D point in mm (\a pt2d_mm).
*
* The result is a 2D point in mm (\a pt2d_mm) relative to the upper-left
* corner of the geometry. To convert this point into units (e.g., pixels
* in case of an image), use WorldToIndex.
* \return true projection was possible
* \sa Project(const mitk::Point3D &pt3d_mm, mitk::Point3D
* &projectedPt3d_mm)
*/
virtual bool Map(const mitk::Point3D &pt3d_mm, mitk::Point2D &pt2d_mm) const;
/**
* \brief Converts a 2D point given in mm (\a pt2d_mm) relative to the
* upper-left corner of the geometry into the corresponding
* world-coordinate (a 3D point in mm, \a pt3d_mm).
*
* To convert a 2D point given in units (e.g., pixels in case of an
* image) into a 2D point given in mm (as required by this method), use
* IndexToWorld.
*/
virtual void Map(const mitk::Point2D &pt2d_mm, mitk::Point3D &pt3d_mm) const;
/**
* \brief Set the width and height of this 2D-geometry in units by calling
* SetBounds. This does \a not change the extent in mm!
*
* For an image, this is the number of pixels in x-/y-direction.
* \note In contrast to calling SetBounds directly, this does \a not change
* the extent in mm!
*/
virtual void SetSizeInUnits(mitk::ScalarType width, mitk::ScalarType height);
/**
* \brief Project a 3D point given in mm (\a pt3d_mm) onto the 2D
* geometry. The result is a 3D point in mm (\a projectedPt3d_mm).
*
* \return true projection was possible
*/
virtual bool Project(const mitk::Point3D &pt3d_mm, mitk::Point3D &projectedPt3d_mm) const;
/**
* \brief Project a 3D vector given in mm (\a vec3d_mm) onto the 2D
* geometry. The result is a 2D vector in mm (\a vec2d_mm).
*
* The result is a 2D vector in mm (\a vec2d_mm) relative to the
* upper-left
* corner of the geometry. To convert this point into units (e.g., pixels
* in case of an image), use WorldToIndex.
* \return true projection was possible
* \sa Project(const mitk::Vector3D &vec3d_mm, mitk::Vector3D
* &projectedVec3d_mm)
*/
virtual bool Map(const mitk::Point3D &atPt3d_mm, const mitk::Vector3D &vec3d_mm, mitk::Vector2D &vec2d_mm) const;
/**
* \brief Converts a 2D vector given in mm (\a vec2d_mm) relative to the
* upper-left corner of the geometry into the corresponding
* world-coordinate (a 3D vector in mm, \a vec3d_mm).
*
* To convert a 2D vector given in units (e.g., pixels in case of an
* image) into a 2D vector given in mm (as required by this method), use
* IndexToWorld.
*/
virtual void Map(const mitk::Point2D &atPt2d_mm, const mitk::Vector2D &vec2d_mm, mitk::Vector3D &vec3d_mm) const;
/**
* \brief Project a 3D vector given in mm (\a vec3d_mm) onto the 2D
* geometry. The result is a 3D vector in mm (\a projectedVec3d_mm).
*
* DEPRECATED. Use Project(vector,vector) instead
*
* \return true projection was possible
*/
virtual bool Project(const mitk::Point3D &atPt3d_mm,
const mitk::Vector3D &vec3d_mm,
mitk::Vector3D &projectedVec3d_mm) const;
/**
* \brief Project a 3D vector given in mm (\a vec3d_mm) onto the 2D
* geometry. The result is a 3D vector in mm (\a projectedVec3d_mm).
*
* \return true projection was possible
*/
virtual bool Project(const mitk::Vector3D &vec3d_mm, mitk::Vector3D &projectedVec3d_mm) const;
/**
* \brief Distance of the point from the geometry
* (bounding-box \em not considered)
*
*/
inline ScalarType Distance(const Point3D &pt3d_mm) const { return fabs(SignedDistance(pt3d_mm)); }
/**
* \brief Set the geometrical frame of reference in which this PlaneGeometry
* is placed.
*
* This would usually be the BaseGeometry of the underlying dataset, but
* setting it is optional.
*/
void SetReferenceGeometry(const mitk::BaseGeometry *geometry);
/**
* \brief Get the geometrical frame of reference for this PlaneGeometry.
*/
const BaseGeometry *GetReferenceGeometry() const;
bool HasReferenceGeometry() const;
static std::vector< int > CalculateDominantAxes(mitk::AffineTransform3D::MatrixType::InternalMatrixType& rotation_matrix);
protected:
PlaneGeometry();
PlaneGeometry(const PlaneGeometry &other);
~PlaneGeometry() override;
void PrintSelf(std::ostream &os, itk::Indent indent) const override;
const mitk::BaseGeometry *m_ReferenceGeometry;
//##Documentation
//## @brief PreSetSpacing
//##
//## These virtual function allows a different beahiour in subclasses.
//## Do implement them in every subclass of BaseGeometry. If not needed, use
//## {Superclass::PreSetSpacing();};
void PreSetSpacing(const mitk::Vector3D &aSpacing) override { Superclass::PreSetSpacing(aSpacing); };
//##Documentation
//## @brief CheckBounds
//##
//## This function is called in SetBounds. Assertions can be implemented in this function (see PlaneGeometry.cpp).
//## If you implement this function in a subclass, make sure, that all classes were your class inherits from
//## have an implementation of CheckBounds
//## (e.g. inheritance BaseGeometry <- A <- B. Implementation of CheckBounds in class B needs implementation in A as
// well!)
void CheckBounds(const BoundsArrayType &bounds) override;
//##Documentation
//## @brief CheckIndexToWorldTransform
//##
//## This function is called in SetIndexToWorldTransform. Assertions can be implemented in this function (see
// PlaneGeometry.cpp).
//## In Subclasses of BaseGeometry, implement own conditions or call Superclass::CheckBounds(bounds);.
void CheckIndexToWorldTransform(mitk::AffineTransform3D *transform) override;
private:
/**
* \brief Compares plane with another plane: \a true if IsOnPlane
* (bounding-box \em not considered)
*/
virtual bool operator==(const PlaneGeometry *) const { return false; };
/**
* \brief Compares plane with another plane: \a false if IsOnPlane
* (bounding-box \em not considered)
*/
virtual bool operator!=(const PlaneGeometry *) const { return false; };
};
} // namespace mitk
#endif /* PLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C */
diff --git a/Modules/Core/include/mitkPoint.h b/Modules/Core/include/mitkPoint.h
index a0f0cc3b85..779deb73e8 100644
--- a/Modules/Core/include/mitkPoint.h
+++ b/Modules/Core/include/mitkPoint.h
@@ -1,135 +1,135 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef MITKPOINT_H_
#define MITKPOINT_H_
#include <itkPoint.h>
#include "mitkArray.h"
#include "mitkEqual.h"
#include "mitkNumericConstants.h"
namespace mitk
{
//##Documentation
//##@brief enumeration of the type a point can be
enum PointSpecificationType
{
PTUNDEFINED = 0,
PTSTART,
PTCORNER,
PTEDGE,
PTEND
};
template <class TCoordRep, unsigned int NPointDimension = 3>
class Point : public itk::Point<TCoordRep, NPointDimension>
{
public:
/** Default constructor has nothing to do. */
explicit Point<TCoordRep, NPointDimension>() : itk::Point<TCoordRep, NPointDimension>() {}
/** Pass-through constructors for the Array base class. */
template <typename TPointValueType>
explicit Point(const Point<TPointValueType, NPointDimension> &r) : itk::Point<TCoordRep, NPointDimension>(r)
{
}
template <typename TPointValueType>
explicit Point(const TPointValueType r[NPointDimension]) : itk::Point<TCoordRep, NPointDimension>(r)
{
}
template <typename TPointValueType>
- Point(const TPointValueType &v) : itk::Point<TCoordRep, NPointDimension>(v)
+ explicit Point(const TPointValueType &v) : itk::Point<TCoordRep, NPointDimension>(v)
{
}
Point<TCoordRep, NPointDimension>(const mitk::Point<TCoordRep, NPointDimension> &r)
: itk::Point<TCoordRep, NPointDimension>(r)
{
}
Point<TCoordRep, NPointDimension>(const TCoordRep r[NPointDimension]) : itk::Point<TCoordRep, NPointDimension>(r) {}
Point<TCoordRep, NPointDimension>(const TCoordRep &v) : itk::Point<TCoordRep, NPointDimension>(v) {}
Point<TCoordRep, NPointDimension>(const itk::Point<TCoordRep, NPointDimension> &p)
: itk::Point<TCoordRep, NPointDimension>(p)
{
}
/**
* Copies the elements from array array to this.
* Note that this method will assign doubles to floats without complaining!
*
* @param array the array whose values shall be copied. Must overload [] operator.
*/
template <typename ArrayType>
void FillPoint(const ArrayType &array)
{
itk::FixedArray<TCoordRep, NPointDimension> *thisP =
dynamic_cast<itk::FixedArray<TCoordRep, NPointDimension> *>(this);
mitk::FillArray<ArrayType, TCoordRep, NPointDimension>(*thisP, array);
}
/**
* Copies the values stored in this point into the array array.
*
* @param array the array which should store the values of this.
*/
template <typename ArrayType>
void ToArray(ArrayType array) const
{
mitk::ToArray<ArrayType, TCoordRep, NPointDimension>(array, *this);
}
};
typedef Point<ScalarType, 2> Point2D;
typedef Point<ScalarType, 3> Point3D;
typedef Point<ScalarType, 4> Point4D;
typedef Point<int, 2> Point2I;
typedef Point<int, 3> Point3I;
typedef Point<int, 4> Point4I;
/**
* @ingroup MITKTestingAPI
*
* @param point1 Point to compare.
* @param point2 Point to compare.
* @param eps Tolerance for floating point comparison.
* @param verbose Flag indicating detailed console output.
* @return True if points are equal.
*/
template <typename TCoordRep, unsigned int NPointDimension>
inline bool Equal(const itk::Point<TCoordRep, NPointDimension> &point1,
const itk::Point<TCoordRep, NPointDimension> &point2,
TCoordRep eps = mitk::eps,
bool verbose = false)
{
bool isEqual = true;
typename itk::Point<TCoordRep, NPointDimension>::VectorType diff = point1 - point2;
for (unsigned int i = 0; i < NPointDimension; i++)
{
if (DifferenceBiggerOrEqualEps(diff[i], eps))
{
isEqual = false;
break;
}
}
ConditionalOutputOfDifference(point1, point2, eps, verbose, isEqual);
return isEqual;
}
} // namespace mitk
#endif /* MITKPOINT_H_ */
diff --git a/Modules/Core/include/mitkVector.h b/Modules/Core/include/mitkVector.h
index 095a9de995..e62c166238 100644
--- a/Modules/Core/include/mitkVector.h
+++ b/Modules/Core/include/mitkVector.h
@@ -1,232 +1,239 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef MITKVECTOR_H_
#define MITKVECTOR_H_
#include <itkVector.h>
#include <vnl/vnl_vector.h>
#include <vnl/vnl_vector_fixed.h>
#include "mitkArray.h"
#include "mitkEqual.h"
#include "mitkExceptionMacro.h"
#include "mitkNumericConstants.h"
namespace mitk
{
template <class TCoordRep, unsigned int NVectorDimension = 3>
class Vector : public itk::Vector<TCoordRep, NVectorDimension>
{
public:
/**
* @brief Default constructor has nothing to do.
*/
explicit Vector<TCoordRep, NVectorDimension>() : itk::Vector<TCoordRep, NVectorDimension>() {}
/**
* @brief Copy constructor.
*/
explicit Vector<TCoordRep, NVectorDimension>(const mitk::Vector<TCoordRep, NVectorDimension> &r)
: itk::Vector<TCoordRep, NVectorDimension>(r)
{
}
+ /** Pass-through assignment operator for the Vector base class. */
+ Vector<TCoordRep, NVectorDimension> & operator=(const Vector<TCoordRep, NVectorDimension> & r)
+ {
+ itk::Vector<TCoordRep, NVectorDimension>::operator=(r);
+ return *this;
+ }
+
/**
* @brief Constructor to convert from itk::Vector to mitk::Vector.
*/
Vector<TCoordRep, NVectorDimension>(const itk::Vector<TCoordRep, NVectorDimension> &r)
: itk::Vector<TCoordRep, NVectorDimension>(r)
{
}
/**
* @brief Constructor to convert an array to mitk::Vector
* @param r the array.
* @attention must have NVectorDimension valid arguments!
*/
Vector<TCoordRep, NVectorDimension>(const TCoordRep r[NVectorDimension])
: itk::Vector<TCoordRep, NVectorDimension>(r)
{
}
/**
* Constructor to initialize entire vector to one value.
*/
Vector<TCoordRep, NVectorDimension>(const TCoordRep &v) : itk::Vector<TCoordRep, NVectorDimension>(v) {}
/**
* @brief Constructor for vnl_vectors.
* @throws mitk::Exception if vnl_vector.size() != NVectorDimension.
*/
Vector<TCoordRep, NVectorDimension>(const vnl_vector<TCoordRep> &vnlVector)
: itk::Vector<TCoordRep, NVectorDimension>()
{
if (vnlVector.size() != NVectorDimension)
mitkThrow() << "when constructing mitk::Vector from vnl_vector: sizes didn't match: mitk::Vector "
<< NVectorDimension << "; vnl_vector " << vnlVector.size();
for (unsigned int var = 0; (var < NVectorDimension) && (var < vnlVector.size()); ++var)
{
this->SetElement(var, vnlVector.get(var));
}
}
/**
* @brief Constructor for vnl_vector_fixed.
*/
Vector<TCoordRep, NVectorDimension>(const vnl_vector_fixed<TCoordRep, NVectorDimension> &vnlVectorFixed)
: itk::Vector<TCoordRep, NVectorDimension>()
{
for (unsigned int var = 0; var < NVectorDimension; ++var)
{
this->SetElement(var, vnlVectorFixed[var]);
}
};
/**
* Copies the elements from array array to this.
* Note that this method will assign doubles to floats without complaining!
*
* @param array the array whose values shall be copied. Must overload [] operator.
*/
template <typename ArrayType>
void FillVector(const ArrayType &array)
{
itk::FixedArray<TCoordRep, NVectorDimension> *thisP =
dynamic_cast<itk::FixedArray<TCoordRep, NVectorDimension> *>(this);
mitk::FillArray<ArrayType, TCoordRep, NVectorDimension>(*thisP, array);
}
/**
* Copies the values stored in this vector into the array array.d
*
* @param array the array which should store the values of this.
*/
template <typename ArrayType>
void ToArray(ArrayType array) const
{
mitk::ToArray<ArrayType, TCoordRep, NVectorDimension>(array, *this);
}
/**
* @brief User defined conversion of mitk::Vector to vnl_vector.
* Note: the conversion to mitk::Vector to vnl_vector_fixed has not been implemented since this
* would collide with the conversion vnl_vector to vnl_vector_fixed provided by vnl.
*/
operator vnl_vector<TCoordRep>() const { return this->GetVnlVector(); }
}; // end mitk::Vector
// convenience typedefs for often used mitk::Vector representations.
typedef Vector<ScalarType, 2> Vector2D;
typedef Vector<ScalarType, 3> Vector3D;
typedef Vector<ScalarType, 4> Vector4D;
// other vector types used in MITK
typedef vnl_vector<ScalarType> VnlVector;
// The equal methods to compare vectors for equality are below:
/**
* @ingroup MITKTestingAPI
*
* @param vector1 Vector to compare.
* @param vector2 Vector to compare.
* @param eps Tolerance for floating point comparison.
* @param verbose Flag indicating detailed console output.
* @return True if vectors are equal.
*/
template <typename TCoordRep, unsigned int NPointDimension>
inline bool Equal(const itk::Vector<TCoordRep, NPointDimension> &vector1,
const itk::Vector<TCoordRep, NPointDimension> &vector2,
TCoordRep eps = mitk::eps,
bool verbose = false)
{
bool isEqual = true;
typename itk::Vector<TCoordRep, NPointDimension>::VectorType diff = vector1 - vector2;
for (unsigned int i = 0; i < NPointDimension; i++)
{
if (DifferenceBiggerOrEqualEps(diff[i], eps))
{
isEqual = false;
break;
}
}
ConditionalOutputOfDifference(vector1, vector2, eps, verbose, isEqual);
return isEqual;
}
/**
* @ingroup MITKTestingAPI
*
* @param vector1 Vector to compare.
* @param vector2 Vector to compare.
* @param eps Tolerance for floating point comparison.
* @param verbose Flag indicating detailed console output.
* @return True if vectors are equal.
*/
inline bool Equal(const mitk::VnlVector &vector1,
const mitk::VnlVector &vector2,
ScalarType eps = mitk::eps,
bool verbose = false)
{
bool isEqual = true;
mitk::VnlVector diff = vector1 - vector2;
for (unsigned int i = 0; i < diff.size(); i++)
{
if (DifferenceBiggerOrEqualEps(diff[i], eps))
{
isEqual = false;
break;
}
}
ConditionalOutputOfDifference(vector1, vector2, eps, verbose, isEqual);
return isEqual;
}
/**
* @ingroup MITKTestingAPI
*
* @param vector1 Vector to compare.
* @param vector2 Vector to compare.
* @param eps Tolerance for floating point comparison.
* @param verbose Flag indicating detailed console output.
* @return True if vectors are equal.
*/
template <typename TCoordRep, unsigned int NPointDimension>
inline bool Equal(const vnl_vector_fixed<TCoordRep, NPointDimension> &vector1,
const vnl_vector_fixed<TCoordRep, NPointDimension> &vector2,
TCoordRep eps = mitk::eps,
bool verbose = false)
{
vnl_vector_fixed<TCoordRep, NPointDimension> diff = vector1 - vector2;
bool isEqual = true;
for (unsigned int i = 0; i < diff.size(); i++)
{
if (DifferenceBiggerOrEqualEps(diff[i], eps))
{
isEqual = false;
break;
}
}
ConditionalOutputOfDifference(vector1, vector2, eps, verbose, isEqual);
return isEqual;
}
} // end namespace mitk
#endif /* MITKVECTOR_H_ */
diff --git a/Modules/Core/src/DataManagement/mitkBaseGeometry.cpp b/Modules/Core/src/DataManagement/mitkBaseGeometry.cpp
index 038edbc41b..ba87e198ea 100644
--- a/Modules/Core/src/DataManagement/mitkBaseGeometry.cpp
+++ b/Modules/Core/src/DataManagement/mitkBaseGeometry.cpp
@@ -1,1096 +1,1096 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <iomanip>
#include <sstream>
#include <bitset>
#include <vtkMatrix4x4.h>
#include <vtkMatrixToLinearTransform.h>
#include "mitkApplyTransformMatrixOperation.h"
#include "mitkBaseGeometry.h"
#include "mitkGeometryTransformHolder.h"
#include "mitkInteractionConst.h"
#include "mitkMatrixConvert.h"
#include "mitkModifiedLock.h"
#include "mitkPointOperation.h"
#include "mitkRestorePlanePositionOperation.h"
#include "mitkRotationOperation.h"
#include "mitkScaleOperation.h"
#include "mitkVector.h"
#include "mitkMatrix.h"
mitk::BaseGeometry::BaseGeometry()
: Superclass(),
mitk::OperationActor(),
m_FrameOfReferenceID(0),
m_IndexToWorldTransformLastModified(0),
m_ImageGeometry(false),
m_ModifiedLockFlag(false),
m_ModifiedCalledFlag(false)
{
m_GeometryTransform = new GeometryTransformHolder();
Initialize();
}
mitk::BaseGeometry::BaseGeometry(const BaseGeometry &other)
: Superclass(),
mitk::OperationActor(),
m_FrameOfReferenceID(other.m_FrameOfReferenceID),
m_IndexToWorldTransformLastModified(other.m_IndexToWorldTransformLastModified),
m_ImageGeometry(other.m_ImageGeometry),
m_ModifiedLockFlag(false),
m_ModifiedCalledFlag(false)
{
m_GeometryTransform = new GeometryTransformHolder(*other.GetGeometryTransformHolder());
other.InitializeGeometry(this);
}
mitk::BaseGeometry::~BaseGeometry()
{
delete m_GeometryTransform;
}
void mitk::BaseGeometry::SetVtkMatrixDeepCopy(vtkTransform *vtktransform)
{
m_GeometryTransform->SetVtkMatrixDeepCopy(vtktransform);
}
const mitk::Point3D mitk::BaseGeometry::GetOrigin() const
{
return m_GeometryTransform->GetOrigin();
}
void mitk::BaseGeometry::SetOrigin(const Point3D &origin)
{
mitk::ModifiedLock lock(this);
if (origin != GetOrigin())
{
m_GeometryTransform->SetOrigin(origin);
Modified();
}
}
const mitk::Vector3D mitk::BaseGeometry::GetSpacing() const
{
return m_GeometryTransform->GetSpacing();
}
void mitk::BaseGeometry::Initialize()
{
float b[6] = {0, 1, 0, 1, 0, 1};
SetFloatBounds(b);
m_GeometryTransform->Initialize();
m_FrameOfReferenceID = 0;
m_ImageGeometry = false;
}
void mitk::BaseGeometry::SetFloatBounds(const float bounds[6])
{
mitk::BoundingBox::BoundsArrayType b;
const float *input = bounds;
int i = 0;
for (mitk::BoundingBox::BoundsArrayType::Iterator it = b.Begin(); i < 6; ++i)
*it++ = (mitk::ScalarType)*input++;
SetBounds(b);
}
void mitk::BaseGeometry::SetFloatBounds(const double bounds[6])
{
mitk::BoundingBox::BoundsArrayType b;
const double *input = bounds;
int i = 0;
for (mitk::BoundingBox::BoundsArrayType::Iterator it = b.Begin(); i < 6; ++i)
*it++ = (mitk::ScalarType)*input++;
SetBounds(b);
}
/** Initialize the geometry */
void mitk::BaseGeometry::InitializeGeometry(BaseGeometry *newGeometry) const
{
newGeometry->SetBounds(m_BoundingBox->GetBounds());
newGeometry->SetFrameOfReferenceID(GetFrameOfReferenceID());
newGeometry->InitializeGeometryTransformHolder(this);
newGeometry->m_ImageGeometry = m_ImageGeometry;
}
void mitk::BaseGeometry::InitializeGeometryTransformHolder(const BaseGeometry *otherGeometry)
{
this->m_GeometryTransform->Initialize(otherGeometry->GetGeometryTransformHolder());
}
/** Set the bounds */
void mitk::BaseGeometry::SetBounds(const BoundsArrayType &bounds)
{
mitk::ModifiedLock lock(this);
this->CheckBounds(bounds);
m_BoundingBox = BoundingBoxType::New();
BoundingBoxType::PointsContainer::Pointer pointscontainer = BoundingBoxType::PointsContainer::New();
BoundingBoxType::PointType p;
BoundingBoxType::PointIdentifier pointid;
for (pointid = 0; pointid < 2; ++pointid)
{
unsigned int i;
for (i = 0; i < m_NDimensions; ++i)
{
p[i] = bounds[2 * i + pointid];
}
pointscontainer->InsertElement(pointid, p);
}
m_BoundingBox->SetPoints(pointscontainer);
m_BoundingBox->ComputeBoundingBox();
this->Modified();
}
void mitk::BaseGeometry::SetIndexToWorldTransform(mitk::AffineTransform3D *transform)
{
mitk::ModifiedLock lock(this);
CheckIndexToWorldTransform(transform);
m_GeometryTransform->SetIndexToWorldTransform(transform);
Modified();
}
void mitk::BaseGeometry::SetIndexToWorldTransformWithoutChangingSpacing(mitk::AffineTransform3D *transform)
{
// security check
mitk::Vector3D originalSpacing = this->GetSpacing();
mitk::ModifiedLock lock(this);
CheckIndexToWorldTransform(transform);
m_GeometryTransform->SetIndexToWorldTransformWithoutChangingSpacing(transform);
Modified();
// Security check. Spacig must not have changed
if (!mitk::Equal(originalSpacing, this->GetSpacing()))
{
MITK_WARN << "Spacing has changed in a method, where the spacing must not change.";
assert(false);
}
}
const mitk::BaseGeometry::BoundsArrayType mitk::BaseGeometry::GetBounds() const
{
assert(m_BoundingBox.IsNotNull());
return m_BoundingBox->GetBounds();
}
bool mitk::BaseGeometry::IsValid() const
{
return true;
}
void mitk::BaseGeometry::SetSpacing(const mitk::Vector3D &aSpacing, bool enforceSetSpacing)
{
PreSetSpacing(aSpacing);
_SetSpacing(aSpacing, enforceSetSpacing);
}
void mitk::BaseGeometry::_SetSpacing(const mitk::Vector3D &aSpacing, bool enforceSetSpacing)
{
m_GeometryTransform->SetSpacing(aSpacing, enforceSetSpacing);
}
mitk::Vector3D mitk::BaseGeometry::GetAxisVector(unsigned int direction) const
{
Vector3D frontToBack;
frontToBack.SetVnlVector(this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(direction));
frontToBack *= GetExtent(direction);
return frontToBack;
}
mitk::ScalarType mitk::BaseGeometry::GetExtent(unsigned int direction) const
{
assert(m_BoundingBox.IsNotNull());
if (direction >= m_NDimensions)
mitkThrow() << "Direction is too big. This geometry is for 3D Data";
BoundsArrayType bounds = m_BoundingBox->GetBounds();
return bounds[direction * 2 + 1] - bounds[direction * 2];
}
bool mitk::BaseGeometry::Is2DConvertable()
{
bool isConvertableWithoutLoss = true;
do
{
if (this->GetSpacing()[2] != 1)
{
isConvertableWithoutLoss = false;
break;
}
if (this->GetOrigin()[2] != 0)
{
isConvertableWithoutLoss = false;
break;
}
mitk::Vector3D col0, col1, col2;
col0.SetVnlVector(this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(0));
col1.SetVnlVector(this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(1));
col2.SetVnlVector(this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2));
if ((col0[2] != 0) || (col1[2] != 0) || (col2[0] != 0) || (col2[1] != 0) || (col2[2] != 1))
{
isConvertableWithoutLoss = false;
break;
}
} while (false);
return isConvertableWithoutLoss;
}
mitk::Point3D mitk::BaseGeometry::GetCenter() const
{
assert(m_BoundingBox.IsNotNull());
Point3D c = m_BoundingBox->GetCenter();
if (m_ImageGeometry)
{
// Get Center returns the middel of min and max pixel index. In corner based images, this is the right position.
// In center based images (imageGeometry == true), the index needs to be shifted back.
c[0] -= 0.5;
c[1] -= 0.5;
c[2] -= 0.5;
}
this->IndexToWorld(c, c);
return c;
}
double mitk::BaseGeometry::GetDiagonalLength2() const
{
Vector3D diagonalvector = GetCornerPoint() - GetCornerPoint(false, false, false);
return diagonalvector.GetSquaredNorm();
}
double mitk::BaseGeometry::GetDiagonalLength() const
{
return sqrt(GetDiagonalLength2());
}
mitk::Point3D mitk::BaseGeometry::GetCornerPoint(int id) const
{
assert(id >= 0);
assert(this->IsBoundingBoxNull() == false);
BoundingBox::BoundsArrayType bounds = this->GetBoundingBox()->GetBounds();
Point3D cornerpoint;
switch (id)
{
case 0:
FillVector3D(cornerpoint, bounds[0], bounds[2], bounds[4]);
break;
case 1:
FillVector3D(cornerpoint, bounds[0], bounds[2], bounds[5]);
break;
case 2:
FillVector3D(cornerpoint, bounds[0], bounds[3], bounds[4]);
break;
case 3:
FillVector3D(cornerpoint, bounds[0], bounds[3], bounds[5]);
break;
case 4:
FillVector3D(cornerpoint, bounds[1], bounds[2], bounds[4]);
break;
case 5:
FillVector3D(cornerpoint, bounds[1], bounds[2], bounds[5]);
break;
case 6:
FillVector3D(cornerpoint, bounds[1], bounds[3], bounds[4]);
break;
case 7:
FillVector3D(cornerpoint, bounds[1], bounds[3], bounds[5]);
break;
default:
{
itkExceptionMacro(<< "A cube only has 8 corners. These are labeled 0-7.");
}
}
if (m_ImageGeometry)
{
// Here i have to adjust the 0.5 offset manually, because the cornerpoint is the corner of the
// bounding box. The bounding box itself is no image, so it is corner-based
FillVector3D(cornerpoint, cornerpoint[0] - 0.5, cornerpoint[1] - 0.5, cornerpoint[2] - 0.5);
}
return this->GetIndexToWorldTransform()->TransformPoint(cornerpoint);
}
mitk::Point3D mitk::BaseGeometry::GetCornerPoint(bool xFront, bool yFront, bool zFront) const
{
assert(this->IsBoundingBoxNull() == false);
BoundingBox::BoundsArrayType bounds = this->GetBoundingBox()->GetBounds();
Point3D cornerpoint;
cornerpoint[0] = (xFront ? bounds[0] : bounds[1]);
cornerpoint[1] = (yFront ? bounds[2] : bounds[3]);
cornerpoint[2] = (zFront ? bounds[4] : bounds[5]);
if (m_ImageGeometry)
{
// Here i have to adjust the 0.5 offset manually, because the cornerpoint is the corner of the
// bounding box. The bounding box itself is no image, so it is corner-based
FillVector3D(cornerpoint, cornerpoint[0] - 0.5, cornerpoint[1] - 0.5, cornerpoint[2] - 0.5);
}
return this->GetIndexToWorldTransform()->TransformPoint(cornerpoint);
}
mitk::ScalarType mitk::BaseGeometry::GetExtentInMM(int direction) const
{
return this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(direction).magnitude() *
GetExtent(direction);
}
void mitk::BaseGeometry::SetExtentInMM(int direction, ScalarType extentInMM)
{
mitk::ModifiedLock lock(this);
ScalarType len = GetExtentInMM(direction);
if (fabs(len - extentInMM) >= mitk::eps)
{
AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
vnlmatrix = m_GeometryTransform->GetVnlMatrix();
if (len > extentInMM)
vnlmatrix.set_column(direction, vnlmatrix.get_column(direction) / len * extentInMM);
else
vnlmatrix.set_column(direction, vnlmatrix.get_column(direction) * extentInMM / len);
Matrix3D matrix;
matrix = vnlmatrix;
m_GeometryTransform->SetMatrix(matrix);
Modified();
}
}
bool mitk::BaseGeometry::IsInside(const mitk::Point3D &p) const
{
mitk::Point3D index;
WorldToIndex(p, index);
return IsIndexInside(index);
}
bool mitk::BaseGeometry::IsIndexInside(const mitk::Point3D &index) const
{
bool inside = false;
// if it is an image geometry, we need to convert the index to discrete values
// this is done by applying the rounding function also used in WorldToIndex (see line 323)
if (m_ImageGeometry)
{
mitk::Point3D discretIndex;
discretIndex[0] = itk::Math::RoundHalfIntegerUp<mitk::ScalarType>(index[0]);
discretIndex[1] = itk::Math::RoundHalfIntegerUp<mitk::ScalarType>(index[1]);
discretIndex[2] = itk::Math::RoundHalfIntegerUp<mitk::ScalarType>(index[2]);
inside = this->GetBoundingBox()->IsInside(discretIndex);
// we have to check if the index is at the upper border of each dimension,
// because the boundingbox is not centerbased
if (inside)
{
const BoundingBox::BoundsArrayType &bounds = this->GetBoundingBox()->GetBounds();
if ((discretIndex[0] == bounds[1]) || (discretIndex[1] == bounds[3]) || (discretIndex[2] == bounds[5]))
inside = false;
}
}
else
inside = this->GetBoundingBox()->IsInside(index);
return inside;
}
void mitk::BaseGeometry::WorldToIndex(const mitk::Point3D &pt_mm, mitk::Point3D &pt_units) const
{
mitk::Vector3D tempIn, tempOut;
const TransformType::OffsetType &offset = this->GetIndexToWorldTransform()->GetOffset();
tempIn = pt_mm.GetVectorFromOrigin() - offset;
WorldToIndex(tempIn, tempOut);
- pt_units = tempOut;
+ pt_units = Point3D(tempOut);
}
void mitk::BaseGeometry::WorldToIndex(const mitk::Vector3D &vec_mm, mitk::Vector3D &vec_units) const
{
// Get WorldToIndex transform
if (m_IndexToWorldTransformLastModified != this->GetIndexToWorldTransform()->GetMTime())
{
if (!m_InvertedTransform)
{
m_InvertedTransform = TransformType::New();
}
if (!this->GetIndexToWorldTransform()->GetInverse(m_InvertedTransform.GetPointer()))
{
itkExceptionMacro("Internal ITK matrix inversion error, cannot proceed.");
}
m_IndexToWorldTransformLastModified = this->GetIndexToWorldTransform()->GetMTime();
}
// Check for valid matrix inversion
const TransformType::MatrixType &inverse = m_InvertedTransform->GetMatrix();
if (inverse.GetVnlMatrix().has_nans())
{
itkExceptionMacro("Internal ITK matrix inversion error, cannot proceed. Matrix was: "
<< std::endl
<< this->GetIndexToWorldTransform()->GetMatrix()
<< "Suggested inverted matrix is:"
<< std::endl
<< inverse);
}
vec_units = inverse * vec_mm;
}
void mitk::BaseGeometry::WorldToIndex(const mitk::Point3D & /*atPt3d_mm*/,
const mitk::Vector3D &vec_mm,
mitk::Vector3D &vec_units) const
{
MITK_WARN << "Warning! Call of the deprecated function BaseGeometry::WorldToIndex(point, vec, vec). Use "
"BaseGeometry::WorldToIndex(vec, vec) instead!";
this->WorldToIndex(vec_mm, vec_units);
}
mitk::VnlVector mitk::BaseGeometry::GetOriginVnl() const
{
return GetOrigin().GetVnlVector();
}
vtkLinearTransform *mitk::BaseGeometry::GetVtkTransform() const
{
return m_GeometryTransform->GetVtkTransform();
}
void mitk::BaseGeometry::SetIdentity()
{
mitk::ModifiedLock lock(this);
m_GeometryTransform->SetIdentity();
Modified();
}
void mitk::BaseGeometry::Compose(const mitk::BaseGeometry::TransformType *other, bool pre)
{
mitk::ModifiedLock lock(this);
m_GeometryTransform->Compose(other, pre);
Modified();
}
void mitk::BaseGeometry::Compose(const vtkMatrix4x4 *vtkmatrix, bool pre)
{
mitk::BaseGeometry::TransformType::Pointer itkTransform = mitk::BaseGeometry::TransformType::New();
TransferVtkMatrixToItkTransform(vtkmatrix, itkTransform.GetPointer());
Compose(itkTransform, pre);
}
void mitk::BaseGeometry::Translate(const Vector3D &vector)
{
if ((vector[0] != 0) || (vector[1] != 0) || (vector[2] != 0))
{
this->SetOrigin(this->GetOrigin() + vector);
}
}
void mitk::BaseGeometry::IndexToWorld(const mitk::Point3D &pt_units, mitk::Point3D &pt_mm) const
{
pt_mm = this->GetIndexToWorldTransform()->TransformPoint(pt_units);
}
void mitk::BaseGeometry::IndexToWorld(const mitk::Vector3D &vec_units, mitk::Vector3D &vec_mm) const
{
vec_mm = this->GetIndexToWorldTransform()->TransformVector(vec_units);
}
void mitk::BaseGeometry::ExecuteOperation(Operation *operation)
{
mitk::ModifiedLock lock(this);
vtkTransform *vtktransform = vtkTransform::New();
vtktransform->SetMatrix(this->GetVtkMatrix());
switch (operation->GetOperationType())
{
case OpNOTHING:
break;
case OpMOVE:
{
auto *pointOp = dynamic_cast<mitk::PointOperation *>(operation);
if (pointOp == nullptr)
{
MITK_ERROR << "Point move operation is null!";
return;
}
mitk::Point3D newPos = pointOp->GetPoint();
ScalarType data[3];
vtktransform->GetPosition(data);
vtktransform->PostMultiply();
vtktransform->Translate(newPos[0], newPos[1], newPos[2]);
vtktransform->PreMultiply();
break;
}
case OpSCALE:
{
auto *scaleOp = dynamic_cast<mitk::ScaleOperation *>(operation);
if (scaleOp == nullptr)
{
MITK_ERROR << "Scale operation is null!";
return;
}
mitk::Point3D newScale = scaleOp->GetScaleFactor();
ScalarType scalefactor[3];
scalefactor[0] = 1 + (newScale[0] / GetMatrixColumn(0).magnitude());
scalefactor[1] = 1 + (newScale[1] / GetMatrixColumn(1).magnitude());
scalefactor[2] = 1 + (newScale[2] / GetMatrixColumn(2).magnitude());
mitk::Point3D anchor = scaleOp->GetScaleAnchorPoint();
vtktransform->PostMultiply();
vtktransform->Translate(-anchor[0], -anchor[1], -anchor[2]);
vtktransform->Scale(scalefactor[0], scalefactor[1], scalefactor[2]);
vtktransform->Translate(anchor[0], anchor[1], anchor[2]);
break;
}
case OpROTATE:
{
auto *rotateOp = dynamic_cast<mitk::RotationOperation *>(operation);
if (rotateOp == nullptr)
{
MITK_ERROR << "Rotation operation is null!";
return;
}
Vector3D rotationVector = rotateOp->GetVectorOfRotation();
Point3D center = rotateOp->GetCenterOfRotation();
ScalarType angle = rotateOp->GetAngleOfRotation();
vtktransform->PostMultiply();
vtktransform->Translate(-center[0], -center[1], -center[2]);
vtktransform->RotateWXYZ(angle, rotationVector[0], rotationVector[1], rotationVector[2]);
vtktransform->Translate(center[0], center[1], center[2]);
vtktransform->PreMultiply();
break;
}
case OpRESTOREPLANEPOSITION:
{
// Copy necessary to avoid vtk warning
vtkMatrix4x4 *matrix = vtkMatrix4x4::New();
TransferItkTransformToVtkMatrix(
dynamic_cast<mitk::RestorePlanePositionOperation *>(operation)->GetTransform().GetPointer(), matrix);
vtktransform->SetMatrix(matrix);
matrix->Delete();
break;
}
case OpAPPLYTRANSFORMMATRIX:
{
auto *applyMatrixOp = dynamic_cast<ApplyTransformMatrixOperation *>(operation);
vtktransform->SetMatrix(applyMatrixOp->GetMatrix());
break;
}
default:
vtktransform->Delete();
return;
}
this->SetVtkMatrixDeepCopy(vtktransform);
Modified();
vtktransform->Delete();
}
mitk::VnlVector mitk::BaseGeometry::GetMatrixColumn(unsigned int direction) const
{
return this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(direction);
}
mitk::BoundingBox::Pointer mitk::BaseGeometry::CalculateBoundingBoxRelativeToTransform(
const mitk::AffineTransform3D *transform) const
{
mitk::BoundingBox::PointsContainer::Pointer pointscontainer = mitk::BoundingBox::PointsContainer::New();
mitk::BoundingBox::PointIdentifier pointid = 0;
unsigned char i;
if (transform != nullptr)
{
mitk::AffineTransform3D::Pointer inverse = mitk::AffineTransform3D::New();
transform->GetInverse(inverse);
for (i = 0; i < 8; ++i)
pointscontainer->InsertElement(pointid++, inverse->TransformPoint(GetCornerPoint(i)));
}
else
{
for (i = 0; i < 8; ++i)
pointscontainer->InsertElement(pointid++, GetCornerPoint(i));
}
mitk::BoundingBox::Pointer result = mitk::BoundingBox::New();
result->SetPoints(pointscontainer);
result->ComputeBoundingBox();
return result;
}
const std::string mitk::BaseGeometry::GetTransformAsString(TransformType *transformType)
{
std::ostringstream out;
out << '[';
for (int i = 0; i < 3; ++i)
{
out << '[';
for (int j = 0; j < 3; ++j)
out << transformType->GetMatrix().GetVnlMatrix().get(i, j) << ' ';
out << ']';
}
out << "][";
for (int i = 0; i < 3; ++i)
out << transformType->GetOffset()[i] << ' ';
out << "]\0";
return out.str();
}
void mitk::BaseGeometry::SetIndexToWorldTransformByVtkMatrix(vtkMatrix4x4 *vtkmatrix)
{
m_GeometryTransform->SetIndexToWorldTransformByVtkMatrix(vtkmatrix);
}
void mitk::BaseGeometry::SetIndexToWorldTransformByVtkMatrixWithoutChangingSpacing(vtkMatrix4x4 *vtkmatrix)
{
m_GeometryTransform->SetIndexToWorldTransformByVtkMatrixWithoutChangingSpacing(vtkmatrix);
}
void mitk::BaseGeometry::IndexToWorld(const mitk::Point3D & /*atPt3d_units*/,
const mitk::Vector3D &vec_units,
mitk::Vector3D &vec_mm) const
{
MITK_WARN << "Warning! Call of the deprecated function BaseGeometry::IndexToWorld(point, vec, vec). Use "
"BaseGeometry::IndexToWorld(vec, vec) instead!";
// vec_mm = m_IndexToWorldTransform->TransformVector(vec_units);
this->IndexToWorld(vec_units, vec_mm);
}
vtkMatrix4x4 *mitk::BaseGeometry::GetVtkMatrix()
{
return m_GeometryTransform->GetVtkMatrix();
}
bool mitk::BaseGeometry::IsBoundingBoxNull() const
{
return m_BoundingBox.IsNull();
}
bool mitk::BaseGeometry::IsIndexToWorldTransformNull() const
{
return m_GeometryTransform->IsIndexToWorldTransformNull();
}
void mitk::BaseGeometry::ChangeImageGeometryConsideringOriginOffset(const bool isAnImageGeometry)
{
// If Geometry is switched to ImageGeometry, you have to put an offset to the origin, because
// imageGeometries origins are pixel-center-based
// ... and remove the offset, if you switch an imageGeometry back to a normal geometry
// For more information please see the Geometry documentation page
if (m_ImageGeometry == isAnImageGeometry)
return;
const BoundingBox::BoundsArrayType &boundsarray = this->GetBoundingBox()->GetBounds();
Point3D originIndex;
FillVector3D(originIndex, boundsarray[0], boundsarray[2], boundsarray[4]);
if (isAnImageGeometry == true)
FillVector3D(originIndex, originIndex[0] + 0.5, originIndex[1] + 0.5, originIndex[2] + 0.5);
else
FillVector3D(originIndex, originIndex[0] - 0.5, originIndex[1] - 0.5, originIndex[2] - 0.5);
Point3D originWorld;
originWorld = GetIndexToWorldTransform()->TransformPoint(originIndex);
// instead could as well call IndexToWorld(originIndex,originWorld);
SetOrigin(originWorld);
this->SetImageGeometry(isAnImageGeometry);
}
void mitk::BaseGeometry::PrintSelf(std::ostream &os, itk::Indent indent) const
{
os << indent << " IndexToWorldTransform: ";
if (this->IsIndexToWorldTransformNull())
os << "nullptr" << std::endl;
else
{
// from itk::MatrixOffsetTransformBase
unsigned int i, j;
os << std::endl;
os << indent << "Matrix: " << std::endl;
for (i = 0; i < 3; i++)
{
os << indent.GetNextIndent();
for (j = 0; j < 3; j++)
{
os << this->GetIndexToWorldTransform()->GetMatrix()[i][j] << " ";
}
os << std::endl;
}
os << indent << "Offset: " << this->GetIndexToWorldTransform()->GetOffset() << std::endl;
os << indent << "Center: " << this->GetIndexToWorldTransform()->GetCenter() << std::endl;
os << indent << "Translation: " << this->GetIndexToWorldTransform()->GetTranslation() << std::endl;
os << indent << "Inverse: " << std::endl;
for (i = 0; i < 3; i++)
{
os << indent.GetNextIndent();
for (j = 0; j < 3; j++)
{
os << this->GetIndexToWorldTransform()->GetInverseMatrix()[i][j] << " ";
}
os << std::endl;
}
// from itk::ScalableAffineTransform
os << indent << "Scale : ";
for (i = 0; i < 3; i++)
{
os << this->GetIndexToWorldTransform()->GetScale()[i] << " ";
}
os << std::endl;
}
os << indent << " BoundingBox: ";
if (this->IsBoundingBoxNull())
os << "nullptr" << std::endl;
else
{
os << indent << "( ";
for (unsigned int i = 0; i < 3; i++)
{
os << this->GetBoundingBox()->GetBounds()[2 * i] << "," << this->GetBoundingBox()->GetBounds()[2 * i + 1] << " ";
}
os << " )" << std::endl;
}
os << indent << " Origin: " << this->GetOrigin() << std::endl;
os << indent << " ImageGeometry: " << this->GetImageGeometry() << std::endl;
os << indent << " Spacing: " << this->GetSpacing() << std::endl;
}
void mitk::BaseGeometry::Modified() const
{
if (!m_ModifiedLockFlag)
Superclass::Modified();
else
m_ModifiedCalledFlag = true;
}
mitk::AffineTransform3D *mitk::BaseGeometry::GetIndexToWorldTransform()
{
return m_GeometryTransform->GetIndexToWorldTransform();
}
const mitk::AffineTransform3D *mitk::BaseGeometry::GetIndexToWorldTransform() const
{
return m_GeometryTransform->GetIndexToWorldTransform();
}
const mitk::GeometryTransformHolder *mitk::BaseGeometry::GetGeometryTransformHolder() const
{
return m_GeometryTransform;
}
bool mitk::Equal(const mitk::BaseGeometry::BoundingBoxType &leftHandSide,
const mitk::BaseGeometry::BoundingBoxType &rightHandSide,
ScalarType eps,
bool verbose)
{
bool result = true;
BaseGeometry::BoundsArrayType rightBounds = rightHandSide.GetBounds();
BaseGeometry::BoundsArrayType leftBounds = leftHandSide.GetBounds();
BaseGeometry::BoundsArrayType::Iterator itLeft = leftBounds.Begin();
for (BaseGeometry::BoundsArrayType::Iterator itRight = rightBounds.Begin(); itRight != rightBounds.End(); ++itRight)
{
if ((!mitk::Equal(*itLeft, *itRight, eps)))
{
if (verbose)
{
MITK_INFO << "[( Geometry3D::BoundingBoxType )] bounds are not equal.";
MITK_INFO << "rightHandSide is " << setprecision(12) << *itRight << " : leftHandSide is " << *itLeft
<< " and tolerance is " << eps;
}
result = false;
}
itLeft++;
}
return result;
}
bool mitk::Equal(const mitk::BaseGeometry &leftHandSide,
const mitk::BaseGeometry &rightHandSide,
ScalarType coordinateEps,
ScalarType directionEps,
bool verbose)
{
bool result = true;
// Compare spacings
if (!mitk::Equal(leftHandSide.GetSpacing(), rightHandSide.GetSpacing(), coordinateEps))
{
if (verbose)
{
MITK_INFO << "[( Geometry3D )] Spacing differs.";
MITK_INFO << "rightHandSide is " << setprecision(12) << rightHandSide.GetSpacing() << " : leftHandSide is "
<< leftHandSide.GetSpacing() << " and tolerance is " << coordinateEps;
}
result = false;
}
// Compare Origins
if (!mitk::Equal(leftHandSide.GetOrigin(), rightHandSide.GetOrigin(), coordinateEps))
{
if (verbose)
{
MITK_INFO << "[( Geometry3D )] Origin differs.";
MITK_INFO << "rightHandSide is " << setprecision(12) << rightHandSide.GetOrigin() << " : leftHandSide is "
<< leftHandSide.GetOrigin() << " and tolerance is " << coordinateEps;
}
result = false;
}
// Compare Axis and Extents
for (unsigned int i = 0; i < 3; ++i)
{
if (!mitk::Equal(leftHandSide.GetAxisVector(i), rightHandSide.GetAxisVector(i), directionEps))
{
if (verbose)
{
MITK_INFO << "[( Geometry3D )] AxisVector #" << i << " differ";
MITK_INFO << "rightHandSide is " << setprecision(12) << rightHandSide.GetAxisVector(i) << " : leftHandSide is "
<< leftHandSide.GetAxisVector(i) << " and tolerance is " << directionEps;
}
result = false;
}
if (!mitk::Equal(leftHandSide.GetExtent(i), rightHandSide.GetExtent(i), coordinateEps))
{
if (verbose)
{
MITK_INFO << "[( Geometry3D )] Extent #" << i << " differ";
MITK_INFO << "rightHandSide is " << setprecision(12) << rightHandSide.GetExtent(i) << " : leftHandSide is "
<< leftHandSide.GetExtent(i) << " and tolerance is " << coordinateEps;
}
result = false;
}
}
// Compare ImageGeometry Flag
if (rightHandSide.GetImageGeometry() != leftHandSide.GetImageGeometry())
{
if (verbose)
{
MITK_INFO << "[( Geometry3D )] GetImageGeometry is different.";
MITK_INFO << "rightHandSide is " << rightHandSide.GetImageGeometry() << " : leftHandSide is "
<< leftHandSide.GetImageGeometry();
}
result = false;
}
// Compare FrameOfReference ID
if (rightHandSide.GetFrameOfReferenceID() != leftHandSide.GetFrameOfReferenceID())
{
if (verbose)
{
MITK_INFO << "[( Geometry3D )] GetFrameOfReferenceID is different.";
MITK_INFO << "rightHandSide is " << rightHandSide.GetFrameOfReferenceID() << " : leftHandSide is "
<< leftHandSide.GetFrameOfReferenceID();
}
result = false;
}
// Compare BoundingBoxes
if (!mitk::Equal(*leftHandSide.GetBoundingBox(), *rightHandSide.GetBoundingBox(), coordinateEps, verbose))
{
result = false;
}
// Compare IndexToWorldTransform Matrix
if (!mitk::Equal(*leftHandSide.GetIndexToWorldTransform(), *rightHandSide.GetIndexToWorldTransform(), directionEps, verbose))
{
result = false;
}
return result;
}
bool mitk::Equal(const mitk::BaseGeometry& leftHandSide,
const mitk::BaseGeometry& rightHandSide,
ScalarType eps,
bool verbose)
{
return Equal(leftHandSide, rightHandSide, eps, eps, verbose);
}
bool mitk::Equal(const mitk::BaseGeometry::TransformType &leftHandSide,
const mitk::BaseGeometry::TransformType &rightHandSide,
ScalarType eps,
bool verbose)
{
// Compare IndexToWorldTransform Matrix
if (!mitk::MatrixEqualElementWise(leftHandSide.GetMatrix(), rightHandSide.GetMatrix(), eps))
{
if (verbose)
{
MITK_INFO << "[( Geometry3D::TransformType )] Index to World Transformation matrix differs.";
MITK_INFO << "rightHandSide is " << setprecision(12) << rightHandSide.GetMatrix() << " : leftHandSide is "
<< leftHandSide.GetMatrix() << " and tolerance is " << eps;
}
return false;
}
return true;
}
bool mitk::IsSubGeometry(const mitk::BaseGeometry& testGeo,
const mitk::BaseGeometry& referenceGeo,
ScalarType coordinateEps,
ScalarType directionEps,
bool verbose)
{
bool result = true;
// Compare spacings (must be equal)
const auto testedSpacing = testGeo.GetSpacing();
if (!mitk::Equal(testedSpacing, referenceGeo.GetSpacing(), coordinateEps))
{
if (verbose)
{
MITK_INFO << "[( Geometry3D )] Spacing differs.";
MITK_INFO << "testedGeometry is " << setprecision(12) << testedSpacing << " : referenceGeometry is "
<< referenceGeo.GetSpacing() << " and tolerance is " << coordinateEps;
}
result = false;
}
// Compare ImageGeometry Flag (must be equal)
if (referenceGeo.GetImageGeometry() != testGeo.GetImageGeometry())
{
if (verbose)
{
MITK_INFO << "[( Geometry3D )] GetImageGeometry is different.";
MITK_INFO << "referenceGeo is " << referenceGeo.GetImageGeometry() << " : testGeo is "
<< testGeo.GetImageGeometry();
}
result = false;
}
// Compare IndexToWorldTransform Matrix (must be equal -> same axis directions)
if (!Equal(*(testGeo.GetIndexToWorldTransform()), *(referenceGeo.GetIndexToWorldTransform()), directionEps, verbose))
{
result = false;
}
for (int i = 0; i<8; ++i)
{
auto testCorner = testGeo.GetCornerPoint(i);
bool isInside = false;
mitk::Point3D testCornerIndex;
referenceGeo.WorldToIndex(testCorner, testCornerIndex);
std::bitset<sizeof(int)> bs(i);
//To regard the directionEps, we substract or add it to the index elments
//depending on wether it was constructed by a lower or an upper bound value
//(see implementation of BaseGeometry::GetCorner()).
if (bs.test(0))
{
testCornerIndex[2] -= directionEps;
}
else
{
testCornerIndex[2] += directionEps;
}
if (bs.test(1))
{
testCornerIndex[1] -= directionEps;
}
else
{
testCornerIndex[1] += directionEps;
}
if (bs.test(2))
{
testCornerIndex[0] -= directionEps;
}
else
{
testCornerIndex[0] += directionEps;
}
isInside = referenceGeo.IsIndexInside(testCornerIndex);
if (!isInside)
{
if (verbose)
{
MITK_INFO << "[( Geometry3D )] corner point is not inside. ";
MITK_INFO << "referenceGeo is " << setprecision(12) << referenceGeo << " : tested corner is "
<< testGeo.GetCornerPoint(i);
}
result = false;
}
}
// check grid of test geometry is on the grid of the reference geometry. This is important as the
// boundingbox is only checked for containing the tested geometry, but if a corner (one is enough
// as we know that axis and spacing are equal, due to equal transfor (see above)) of the tested geometry
// is on the grid it is really a sub geometry (as they have the same spacing and axis).
auto cornerOffset = testGeo.GetCornerPoint(0) - referenceGeo.GetCornerPoint(0);
mitk::Vector3D cornerIndexOffset;
referenceGeo.WorldToIndex(cornerOffset, cornerIndexOffset);
for (unsigned int i = 0; i < 3; ++i)
{
auto pixelCountContinous = cornerIndexOffset[i];
auto pixelCount = std::round(pixelCountContinous);
if (std::abs(pixelCount - pixelCountContinous) > coordinateEps)
{
if (verbose)
{
MITK_INFO << "[( Geometry3D )] Tested geometry is not on the grid of the reference geometry. ";
MITK_INFO << "referenceGeo is " << setprecision(15) << referenceGeo << " : tested corner offset in pixels is "
<< pixelCountContinous << " for axis "<<i;
}
result = false;
}
}
return result;
}
bool mitk::IsSubGeometry(const mitk::BaseGeometry& testGeo,
const mitk::BaseGeometry& referenceGeo,
ScalarType eps,
bool verbose)
{
return IsSubGeometry(testGeo, referenceGeo, eps, eps, verbose);
}
diff --git a/Modules/Core/src/DataManagement/mitkDataNode.cpp b/Modules/Core/src/DataManagement/mitkDataNode.cpp
index 3097aa7f3c..c9280edff8 100644
--- a/Modules/Core/src/DataManagement/mitkDataNode.cpp
+++ b/Modules/Core/src/DataManagement/mitkDataNode.cpp
@@ -1,732 +1,732 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkDataNode.h"
#include "mitkCoreObjectFactory.h"
#include <vtkTransform.h>
#include "mitkGroupTagProperty.h"
#include "mitkProperties.h"
#include "mitkSmartPointerProperty.h"
#include "mitkStringProperty.h"
//#include "mitkMaterialProperty.h"
#include "mitkColorProperty.h"
#include "mitkCoreObjectFactory.h"
#include "mitkGenericProperty.h"
#include "mitkGeometry3D.h"
#include "mitkImageSource.h"
#include "mitkLevelWindowProperty.h"
#include "mitkRenderingManager.h"
mitk::Mapper *mitk::DataNode::GetMapper(MapperSlotId id) const
{
if ((id >= m_Mappers.size()) || (m_Mappers[id].IsNull()))
{
if (id >= m_Mappers.capacity())
{
// int i, size=id-m_Mappers.capacity()+10;
m_Mappers.resize(id + 10);
}
m_Mappers[id] = CoreObjectFactory::GetInstance()->CreateMapper(const_cast<DataNode *>(this), id);
}
return m_Mappers[id];
}
mitk::BaseData *mitk::DataNode::GetData() const
{
return m_Data;
}
void mitk::DataNode::SetData(mitk::BaseData *baseData)
{
if (m_Data != baseData)
{
m_Mappers.clear();
m_Mappers.resize(10);
if (m_Data.IsNotNull() && baseData != nullptr)
{
// Do previous and new data have same type? Keep existing properties.
if (0 == strcmp(m_Data->GetNameOfClass(), baseData->GetNameOfClass()))
{
m_Data = baseData;
}
else
{
m_Data = baseData;
this->GetPropertyList()->Clear();
mitk::CoreObjectFactory::GetInstance()->SetDefaultProperties(this);
}
}
else
{
m_Data = baseData;
mitk::CoreObjectFactory::GetInstance()->SetDefaultProperties(this);
}
m_DataReferenceChangedTime.Modified();
Modified();
}
}
mitk::DataNode::DataNode()
: m_PropertyList(PropertyList::New()),
m_PropertyListModifiedObserverTag(0)
{
m_Mappers.resize(10);
// subscribe for modified event
itk::MemberCommand<mitk::DataNode>::Pointer _PropertyListModifiedCommand = itk::MemberCommand<mitk::DataNode>::New();
_PropertyListModifiedCommand->SetCallbackFunction(this, &mitk::DataNode::PropertyListModified);
m_PropertyListModifiedObserverTag = m_PropertyList->AddObserver(itk::ModifiedEvent(), _PropertyListModifiedCommand);
}
mitk::DataNode::~DataNode()
{
if (m_PropertyList.IsNotNull())
m_PropertyList->RemoveObserver(m_PropertyListModifiedObserverTag);
m_Mappers.clear();
m_Data = nullptr;
}
mitk::DataNode &mitk::DataNode::operator=(const DataNode &right)
{
mitk::DataNode *node = mitk::DataNode::New();
node->SetData(right.GetData());
return *node;
}
mitk::DataNode &mitk::DataNode::operator=(mitk::BaseData *right)
{
mitk::DataNode *node = mitk::DataNode::New();
node->SetData(right);
return *node;
}
#if (_MSC_VER > 1200) || !defined(_MSC_VER)
std::istream &mitk::operator>>(std::istream &i, mitk::DataNode::Pointer &dtn)
#endif
#if ((defined(_MSC_VER)) && (_MSC_VER <= 1200))
std::istream &
operator>>(std::istream &i, mitk::DataNode::Pointer &dtn)
#endif
{
dtn = mitk::DataNode::New();
// i >> av.get();
return i;
}
#if (_MSC_VER > 1200) || !defined(_MSC_VER)
std::ostream &mitk::operator<<(std::ostream &o, mitk::DataNode::Pointer &dtn)
#endif
#if ((defined(_MSC_VER)) && (_MSC_VER <= 1200))
std::ostream &
operator<<(std::ostream &o, mitk::DataNode::Pointer &dtn)
#endif
{
if (dtn->GetData() != nullptr)
o << dtn->GetData()->GetNameOfClass();
else
o << "empty data";
return o;
}
void mitk::DataNode::SetMapper(MapperSlotId id, mitk::Mapper *mapper)
{
m_Mappers[id] = mapper;
if (mapper != nullptr)
mapper->SetDataNode(this);
}
void mitk::DataNode::UpdateOutputInformation()
{
if (this->GetSource())
{
this->GetSource()->UpdateOutputInformation();
}
}
void mitk::DataNode::SetRequestedRegionToLargestPossibleRegion()
{
}
bool mitk::DataNode::RequestedRegionIsOutsideOfTheBufferedRegion()
{
return false;
}
bool mitk::DataNode::VerifyRequestedRegion()
{
return true;
}
void mitk::DataNode::SetRequestedRegion(const itk::DataObject * /*data*/)
{
}
mitk::DataNode::PropertyListKeyNames mitk::DataNode::GetPropertyListNames() const
{
PropertyListKeyNames result;
- for (auto entries : m_MapOfPropertyLists)
+ for (const auto &entries : m_MapOfPropertyLists)
result.push_back(entries.first);
return result;
}
void mitk::DataNode::CopyInformation(const itk::DataObject * /*data*/)
{
}
mitk::PropertyList *mitk::DataNode::GetPropertyList(const mitk::BaseRenderer *renderer) const
{
if (renderer == nullptr)
return m_PropertyList;
return this->GetPropertyList(renderer->GetName());
}
mitk::PropertyList *mitk::DataNode::GetPropertyList(const std::string &rendererName) const
{
if (rendererName.empty())
return m_PropertyList;
mitk::PropertyList::Pointer &propertyList = m_MapOfPropertyLists[rendererName];
if (propertyList.IsNull())
propertyList = mitk::PropertyList::New();
assert(m_MapOfPropertyLists[rendererName].IsNotNull());
return propertyList;
}
void mitk::DataNode::ConcatenatePropertyList(PropertyList *pList, bool replace)
{
m_PropertyList->ConcatenatePropertyList(pList, replace);
}
mitk::BaseProperty *mitk::DataNode::GetProperty(const char *propertyKey, const mitk::BaseRenderer *renderer, bool fallBackOnDataProperties) const
{
if (nullptr == propertyKey)
return nullptr;
if (nullptr != renderer)
{
auto it = m_MapOfPropertyLists.find(renderer->GetName());
if (m_MapOfPropertyLists.end() != it)
{
auto property = it->second->GetProperty(propertyKey);
if (nullptr != property)
return property;
}
}
auto property = m_PropertyList->GetProperty(propertyKey);
if (nullptr == property && fallBackOnDataProperties && m_Data.IsNotNull())
property = m_Data->GetProperty(propertyKey);
return property;
}
mitk::DataNode::GroupTagList mitk::DataNode::GetGroupTags() const
{
GroupTagList groups;
const PropertyList::PropertyMap *propertyMap = m_PropertyList->GetMap();
for (auto groupIter =
propertyMap->begin(); // m_PropertyList is created in the constructor, so we don't check it here
groupIter != propertyMap->end();
++groupIter)
{
const BaseProperty *bp = groupIter->second;
if (dynamic_cast<const GroupTagProperty *>(bp))
{
groups.insert(groupIter->first);
}
}
return groups;
}
bool mitk::DataNode::GetBoolProperty(const char *propertyKey, bool &boolValue, const mitk::BaseRenderer *renderer) const
{
mitk::BoolProperty::Pointer boolprop = dynamic_cast<mitk::BoolProperty *>(GetProperty(propertyKey, renderer));
if (boolprop.IsNull())
return false;
boolValue = boolprop->GetValue();
return true;
}
bool mitk::DataNode::GetIntProperty(const char *propertyKey, int &intValue, const mitk::BaseRenderer *renderer) const
{
mitk::IntProperty::Pointer intprop = dynamic_cast<mitk::IntProperty *>(GetProperty(propertyKey, renderer));
if (intprop.IsNull())
return false;
intValue = intprop->GetValue();
return true;
}
bool mitk::DataNode::GetFloatProperty(const char *propertyKey,
float &floatValue,
const mitk::BaseRenderer *renderer) const
{
mitk::FloatProperty::Pointer floatprop = dynamic_cast<mitk::FloatProperty *>(GetProperty(propertyKey, renderer));
if (floatprop.IsNull())
return false;
floatValue = floatprop->GetValue();
return true;
}
bool mitk::DataNode::GetDoubleProperty(const char *propertyKey,
double &doubleValue,
const mitk::BaseRenderer *renderer) const
{
mitk::DoubleProperty::Pointer doubleprop = dynamic_cast<mitk::DoubleProperty *>(GetProperty(propertyKey, renderer));
if (doubleprop.IsNull())
{
// try float instead
float floatValue = 0;
if (this->GetFloatProperty(propertyKey, floatValue, renderer))
{
doubleValue = floatValue;
return true;
}
return false;
}
doubleValue = doubleprop->GetValue();
return true;
}
bool mitk::DataNode::GetStringProperty(const char *propertyKey,
std::string &string,
const mitk::BaseRenderer *renderer) const
{
mitk::StringProperty::Pointer stringProp = dynamic_cast<mitk::StringProperty *>(GetProperty(propertyKey, renderer));
if (stringProp.IsNull())
{
return false;
}
else
{
// memcpy((void*)string, stringProp->GetValue(), strlen(stringProp->GetValue()) + 1 ); // looks dangerous
string = stringProp->GetValue();
return true;
}
}
bool mitk::DataNode::GetColor(float rgb[3], const mitk::BaseRenderer *renderer, const char *propertyKey) const
{
mitk::ColorProperty::Pointer colorprop = dynamic_cast<mitk::ColorProperty *>(GetProperty(propertyKey, renderer));
if (colorprop.IsNull())
return false;
memcpy(rgb, colorprop->GetColor().GetDataPointer(), 3 * sizeof(float));
return true;
}
bool mitk::DataNode::GetOpacity(float &opacity, const mitk::BaseRenderer *renderer, const char *propertyKey) const
{
mitk::FloatProperty::Pointer opacityprop = dynamic_cast<mitk::FloatProperty *>(GetProperty(propertyKey, renderer));
if (opacityprop.IsNull())
return false;
opacity = opacityprop->GetValue();
return true;
}
bool mitk::DataNode::GetLevelWindow(mitk::LevelWindow &levelWindow,
const mitk::BaseRenderer *renderer,
const char *propertyKey) const
{
mitk::LevelWindowProperty::Pointer levWinProp =
dynamic_cast<mitk::LevelWindowProperty *>(GetProperty(propertyKey, renderer));
if (levWinProp.IsNull())
return false;
levelWindow = levWinProp->GetLevelWindow();
return true;
}
void mitk::DataNode::SetColor(const mitk::Color &color, const mitk::BaseRenderer *renderer, const char *propertyKey)
{
mitk::ColorProperty::Pointer prop;
prop = mitk::ColorProperty::New(color);
GetPropertyList(renderer)->SetProperty(propertyKey, prop);
}
void mitk::DataNode::SetColor(
float red, float green, float blue, const mitk::BaseRenderer *renderer, const char *propertyKey)
{
float color[3];
color[0] = red;
color[1] = green;
color[2] = blue;
SetColor(color, renderer, propertyKey);
}
void mitk::DataNode::SetColor(const float rgb[3], const mitk::BaseRenderer *renderer, const char *propertyKey)
{
mitk::ColorProperty::Pointer prop;
prop = mitk::ColorProperty::New(rgb);
GetPropertyList(renderer)->SetProperty(propertyKey, prop);
}
void mitk::DataNode::SetVisibility(bool visible, const mitk::BaseRenderer *renderer, const char *propertyKey)
{
mitk::BoolProperty::Pointer prop;
prop = mitk::BoolProperty::New(visible);
GetPropertyList(renderer)->SetProperty(propertyKey, prop);
}
void mitk::DataNode::SetOpacity(float opacity, const mitk::BaseRenderer *renderer, const char *propertyKey)
{
mitk::FloatProperty::Pointer prop;
prop = mitk::FloatProperty::New(opacity);
GetPropertyList(renderer)->SetProperty(propertyKey, prop);
}
void mitk::DataNode::SetLevelWindow(mitk::LevelWindow levelWindow,
const mitk::BaseRenderer *renderer,
const char *propertyKey)
{
mitk::LevelWindowProperty::Pointer prop;
prop = mitk::LevelWindowProperty::New(levelWindow);
GetPropertyList(renderer)->SetProperty(propertyKey, prop);
}
void mitk::DataNode::SetIntProperty(const char *propertyKey, int intValue, const mitk::BaseRenderer *renderer)
{
GetPropertyList(renderer)->SetProperty(propertyKey, mitk::IntProperty::New(intValue));
}
void mitk::DataNode::SetBoolProperty(const char *propertyKey,
bool boolValue,
const mitk::BaseRenderer *renderer /*=nullptr*/)
{
GetPropertyList(renderer)->SetProperty(propertyKey, mitk::BoolProperty::New(boolValue));
}
void mitk::DataNode::SetFloatProperty(const char *propertyKey,
float floatValue,
const mitk::BaseRenderer *renderer /*=nullptr*/)
{
if (dynamic_cast<DoubleProperty *>(this->GetProperty(propertyKey, renderer)) != nullptr)
{
MITK_WARN << "Setting float property " << propertyKey
<< " although a double property with the same name already exists";
}
GetPropertyList(renderer)->SetProperty(propertyKey, mitk::FloatProperty::New(floatValue));
}
void mitk::DataNode::SetDoubleProperty(const char *propertyKey, double doubleValue, const mitk::BaseRenderer *renderer)
{
if (dynamic_cast<FloatProperty *>(this->GetProperty(propertyKey, renderer)) != nullptr)
{
MITK_WARN << "Setting double property " << propertyKey
<< " although a float property with the same name already exists";
}
GetPropertyList(renderer)->SetProperty(propertyKey, mitk::DoubleProperty::New(doubleValue));
}
void mitk::DataNode::SetStringProperty(const char *propertyKey,
const char *stringValue,
const mitk::BaseRenderer *renderer /*=nullptr*/)
{
GetPropertyList(renderer)->SetProperty(propertyKey, mitk::StringProperty::New(stringValue));
}
void mitk::DataNode::SetProperty(const char *propertyKey,
BaseProperty *propertyValue,
const mitk::BaseRenderer *renderer)
{
GetPropertyList(renderer)->SetProperty(propertyKey, propertyValue);
}
void mitk::DataNode::ReplaceProperty(const char *propertyKey,
BaseProperty *propertyValue,
const mitk::BaseRenderer *renderer)
{
GetPropertyList(renderer)->ReplaceProperty(propertyKey, propertyValue);
}
void mitk::DataNode::AddProperty(const char *propertyKey,
BaseProperty *propertyValue,
const mitk::BaseRenderer *renderer,
bool overwrite)
{
if ((overwrite) || (GetProperty(propertyKey, renderer) == nullptr))
{
SetProperty(propertyKey, propertyValue, renderer);
}
}
vtkLinearTransform *mitk::DataNode::GetVtkTransform(int t) const
{
assert(m_Data.IsNotNull());
mitk::BaseGeometry *geometry = m_Data->GetGeometry(t);
if (geometry == nullptr)
return nullptr;
return geometry->GetVtkTransform();
}
unsigned long mitk::DataNode::GetMTime() const
{
unsigned long time = Superclass::GetMTime();
if (m_Data.IsNotNull())
{
if ((time < m_Data->GetMTime()) || ((m_Data->GetSource().IsNotNull()) && (time < m_Data->GetSource()->GetMTime())))
{
Modified();
return Superclass::GetMTime();
}
}
return time;
}
void mitk::DataNode::SetSelected(bool selected, const mitk::BaseRenderer *renderer)
{
mitk::BoolProperty::Pointer selectedProperty = dynamic_cast<mitk::BoolProperty *>(GetProperty("selected"));
if (selectedProperty.IsNull())
{
selectedProperty = mitk::BoolProperty::New();
selectedProperty->SetValue(false);
SetProperty("selected", selectedProperty, renderer);
}
if (selectedProperty->GetValue() != selected)
{
selectedProperty->SetValue(selected);
itk::ModifiedEvent event;
InvokeEvent(event);
}
}
/*
class SelectedEvent : public itk::ModifiedEvent
{
public:
typedef SelectedEvent Self;
typedef itk::ModifiedEvent Superclass;
SelectedEvent(DataNode* dataNode)
{ m_DataNode = dataNode; };
DataNode* GetDataNode()
{ return m_DataNode; };
virtual const char * GetEventName() const
{ return "SelectedEvent"; }
virtual bool CheckEvent(const ::itk::EventObject* e) const
{ return dynamic_cast<const Self*>(e); }
virtual ::itk::EventObject* MakeObject() const
{ return new Self(m_DataNode); }
private:
DataNode* m_DataNode;
SelectedEvent(const Self& event)
{ m_DataNode = event.m_DataNode; };
void operator=(const Self& event)
{ m_DataNode = event.m_DataNode; }
};
*/
bool mitk::DataNode::IsSelected(const mitk::BaseRenderer *renderer)
{
bool selected;
if (!GetBoolProperty("selected", selected, renderer))
return false;
return selected;
}
void mitk::DataNode::SetDataInteractor(const DataInteractor::Pointer interactor)
{
if (m_DataInteractor == interactor)
return;
m_DataInteractor = interactor;
this->Modified();
mitk::DataNode::InteractorChangedEvent changedEvent;
this->InvokeEvent(changedEvent);
}
mitk::DataInteractor::Pointer mitk::DataNode::GetDataInteractor() const
{
return m_DataInteractor;
}
void mitk::DataNode::PropertyListModified(const itk::Object * /*caller*/, const itk::EventObject &)
{
Modified();
}
mitk::BaseProperty::ConstPointer mitk::DataNode::GetConstProperty(const std::string &propertyKey, const std::string &contextName, bool fallBackOnDefaultContext) const
{
if (propertyKey.empty())
return nullptr;
if (!contextName.empty())
{
auto propertyListIter = m_MapOfPropertyLists.find(contextName);
if (m_MapOfPropertyLists.end() != propertyListIter)
{
BaseProperty::ConstPointer property = propertyListIter->second->GetProperty(propertyKey);
if (property.IsNotNull())
return property;
}
}
if (contextName.empty() || fallBackOnDefaultContext)
{
BaseProperty::ConstPointer property = m_PropertyList->GetProperty(propertyKey);
if (property.IsNull() && m_Data.IsNotNull())
property = m_Data->GetProperty(propertyKey.c_str());
return property;
}
return nullptr;
}
mitk::BaseProperty * mitk::DataNode::GetNonConstProperty(const std::string &propertyKey, const std::string &contextName, bool fallBackOnDefaultContext)
{
if (propertyKey.empty())
return nullptr;
if (!contextName.empty())
{
auto propertyListIter = m_MapOfPropertyLists.find(contextName);
if (m_MapOfPropertyLists.end() != propertyListIter)
{
auto property = propertyListIter->second->GetProperty(propertyKey);
if (nullptr != property)
return property;
}
}
if (contextName.empty() || fallBackOnDefaultContext)
{
auto property = m_PropertyList->GetProperty(propertyKey);
if (nullptr == property && m_Data.IsNotNull())
property = m_Data->GetProperty(propertyKey.c_str());
return property;
}
return nullptr;
}
void mitk::DataNode::SetProperty(const std::string &propertyKey, BaseProperty *property, const std::string &contextName, bool fallBackOnDefaultContext)
{
if (propertyKey.empty())
mitkThrow() << "Property key is empty.";
if (!contextName.empty())
{
auto propertyListIter = m_MapOfPropertyLists.find(contextName);
if (m_MapOfPropertyLists.end() != propertyListIter)
{
propertyListIter->second->SetProperty(propertyKey, property);
return;
}
}
if (contextName.empty() || fallBackOnDefaultContext)
{
m_PropertyList->SetProperty(propertyKey, property);
return;
}
mitkThrow() << "Unknown property context.";
}
void mitk::DataNode::RemoveProperty(const std::string &propertyKey, const std::string &contextName, bool fallBackOnDefaultContext)
{
if (propertyKey.empty())
mitkThrow() << "Property key is empty.";
if (!contextName.empty())
{
auto propertyListIter = m_MapOfPropertyLists.find(contextName);
if (m_MapOfPropertyLists.end() != propertyListIter)
{
propertyListIter->second->RemoveProperty(propertyKey);
return;
}
}
if (contextName.empty() || fallBackOnDefaultContext)
{
m_PropertyList->RemoveProperty(propertyKey);
return;
}
mitkThrow() << "Unknown property context.";
}
std::vector<std::string> mitk::DataNode::GetPropertyKeys(const std::string &contextName, bool includeDefaultContext) const
{
std::vector<std::string> propertyKeys;
if (contextName.empty())
{
- for (auto property : *m_PropertyList->GetMap())
+ for (const auto &property : *m_PropertyList->GetMap())
propertyKeys.push_back(property.first);
return propertyKeys;
}
auto propertyListIter = m_MapOfPropertyLists.find(contextName);
if (m_MapOfPropertyLists.end() != propertyListIter)
{
- for (auto property : *propertyListIter->second->GetMap())
+ for (const auto &property : *propertyListIter->second->GetMap())
propertyKeys.push_back(property.first);
}
if (includeDefaultContext)
{
- for (auto property : *m_PropertyList->GetMap())
+ for (const auto &property : *m_PropertyList->GetMap())
{
auto propertyKeyIter = std::find(propertyKeys.begin(), propertyKeys.end(), property.first);
if (propertyKeys.end() == propertyKeyIter)
propertyKeys.push_back(property.first);
}
}
return propertyKeys;
}
std::vector<std::string> mitk::DataNode::GetPropertyContextNames() const
{
return this->GetPropertyListNames();
}
diff --git a/Modules/Core/src/DataManagement/mitkDataStorage.cpp b/Modules/Core/src/DataManagement/mitkDataStorage.cpp
index 890128e9f7..5a555a15da 100644
--- a/Modules/Core/src/DataManagement/mitkDataStorage.cpp
+++ b/Modules/Core/src/DataManagement/mitkDataStorage.cpp
@@ -1,584 +1,584 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkDataStorage.h"
#include "itkCommand.h"
#include "itkMutexLockHolder.h"
#include "mitkDataNode.h"
#include "mitkGroupTagProperty.h"
#include "mitkImage.h"
#include "mitkNodePredicateBase.h"
#include "mitkNodePredicateProperty.h"
#include "mitkProperties.h"
#include "mitkArbitraryTimeGeometry.h"
mitk::DataStorage::DataStorage() : itk::Object(), m_BlockNodeModifiedEvents(false)
{
}
mitk::DataStorage::~DataStorage()
{
///// we can not call GetAll() in destructor, because it is implemented in a subclass
// SetOfObjects::ConstPointer all = this->GetAll();
// for (SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
// this->RemoveListeners(it->Value());
// m_NodeModifiedObserverTags.clear();
// m_NodeDeleteObserverTags.clear();
}
void mitk::DataStorage::Add(DataNode *node, DataNode *parent)
{
DataStorage::SetOfObjects::Pointer parents = DataStorage::SetOfObjects::New();
if (parent != nullptr) //< Return empty set if parent is null
parents->InsertElement(0, parent);
this->Add(node, parents);
}
void mitk::DataStorage::Remove(const DataStorage::SetOfObjects *nodes)
{
if (nodes == nullptr)
return;
for (DataStorage::SetOfObjects::ConstIterator it = nodes->Begin(); it != nodes->End(); it++)
this->Remove(it.Value());
}
mitk::DataStorage::SetOfObjects::ConstPointer mitk::DataStorage::GetSubset(const NodePredicateBase *condition) const
{
DataStorage::SetOfObjects::ConstPointer result = this->FilterSetOfObjects(this->GetAll(), condition);
return result;
}
mitk::DataNode *mitk::DataStorage::GetNamedNode(const char *name) const
{
if (name == nullptr)
return nullptr;
StringProperty::Pointer s(StringProperty::New(name));
NodePredicateProperty::Pointer p = NodePredicateProperty::New("name", s);
DataStorage::SetOfObjects::ConstPointer rs = this->GetSubset(p);
if (rs->Size() >= 1)
return rs->GetElement(0);
else
return nullptr;
}
mitk::DataNode *mitk::DataStorage::GetNode(const NodePredicateBase *condition) const
{
if (condition == nullptr)
return nullptr;
DataStorage::SetOfObjects::ConstPointer rs = this->GetSubset(condition);
if (rs->Size() >= 1)
return rs->GetElement(0);
else
return nullptr;
}
mitk::DataNode *mitk::DataStorage::GetNamedDerivedNode(const char *name,
const DataNode *sourceNode,
bool onlyDirectDerivations) const
{
if (name == nullptr)
return nullptr;
StringProperty::Pointer s(StringProperty::New(name));
NodePredicateProperty::Pointer p = NodePredicateProperty::New("name", s);
DataStorage::SetOfObjects::ConstPointer rs = this->GetDerivations(sourceNode, p, onlyDirectDerivations);
if (rs->Size() >= 1)
return rs->GetElement(0);
else
return nullptr;
}
void mitk::DataStorage::PrintSelf(std::ostream &os, itk::Indent indent) const
{
// Superclass::PrintSelf(os, indent);
DataStorage::SetOfObjects::ConstPointer all = this->GetAll();
os << indent << "DataStorage " << this << " is managing " << all->Size() << " objects. List of objects:" << std::endl;
for (DataStorage::SetOfObjects::ConstIterator allIt = all->Begin(); allIt != all->End(); allIt++)
{
std::string name;
allIt.Value()->GetName(name);
std::string datatype;
if (allIt.Value()->GetData() != nullptr)
datatype = allIt.Value()->GetData()->GetNameOfClass();
os << indent << " " << allIt.Value().GetPointer() << "<" << datatype << ">: " << name << std::endl;
DataStorage::SetOfObjects::ConstPointer parents = this->GetSources(allIt.Value());
if (parents->Size() > 0)
{
os << indent << " Direct sources: ";
for (DataStorage::SetOfObjects::ConstIterator parentIt = parents->Begin(); parentIt != parents->End();
parentIt++)
os << parentIt.Value().GetPointer() << ", ";
os << std::endl;
}
DataStorage::SetOfObjects::ConstPointer derivations = this->GetDerivations(allIt.Value());
if (derivations->Size() > 0)
{
os << indent << " Direct derivations: ";
for (DataStorage::SetOfObjects::ConstIterator derivationIt = derivations->Begin();
derivationIt != derivations->End();
derivationIt++)
os << derivationIt.Value().GetPointer() << ", ";
os << std::endl;
}
}
os << std::endl;
}
mitk::DataStorage::SetOfObjects::ConstPointer mitk::DataStorage::FilterSetOfObjects(const SetOfObjects *set,
const NodePredicateBase *condition) const
{
if (set == nullptr)
return nullptr;
DataStorage::SetOfObjects::Pointer result = DataStorage::SetOfObjects::New();
for (DataStorage::SetOfObjects::ConstIterator it = set->Begin(); it != set->End(); it++)
if (condition == nullptr ||
condition->CheckNode(it.Value()) ==
true) // alway copy the set, otherwise the iterator in DataStorage::Remove() will crash
result->InsertElement(result->Size(), it.Value());
return DataStorage::SetOfObjects::ConstPointer(result);
}
const mitk::DataNode::GroupTagList mitk::DataStorage::GetGroupTags() const
{
DataNode::GroupTagList result;
SetOfObjects::ConstPointer all = this->GetAll();
if (all.IsNull())
return result;
for (DataStorage::SetOfObjects::ConstIterator nodeIt = all->Begin(); nodeIt != all->End();
nodeIt++) // for each node
{
PropertyList *pl = nodeIt.Value()->GetPropertyList();
for (auto propIt = pl->GetMap()->begin(); propIt != pl->GetMap()->end();
++propIt)
if (dynamic_cast<GroupTagProperty *>(propIt->second.GetPointer()) != nullptr)
result.insert(propIt->first);
}
return result;
}
void mitk::DataStorage::EmitAddNodeEvent(const DataNode *node)
{
AddNodeEvent.Send(node);
}
void mitk::DataStorage::EmitRemoveNodeEvent(const DataNode *node)
{
RemoveNodeEvent.Send(node);
}
void mitk::DataStorage::OnNodeInteractorChanged(itk::Object *caller, const itk::EventObject &)
{
const auto *_Node = dynamic_cast<const DataNode *>(caller);
if (_Node)
{
InteractorChangedNodeEvent.Send(_Node);
}
}
void mitk::DataStorage::OnNodeModifiedOrDeleted(const itk::Object *caller, const itk::EventObject &event)
{
if (m_BlockNodeModifiedEvents)
return;
const auto *_Node = dynamic_cast<const DataNode *>(caller);
if (_Node)
{
const auto *modEvent = dynamic_cast<const itk::ModifiedEvent *>(&event);
if (modEvent)
ChangedNodeEvent.Send(_Node);
else
DeleteNodeEvent.Send(_Node);
}
}
void mitk::DataStorage::AddListeners(const DataNode *_Node)
{
itk::MutexLockHolder<itk::SimpleFastMutexLock> locked(m_MutexOne);
// node must not be 0 and must not be yet registered
auto *NonConstNode = const_cast<DataNode *>(_Node);
if (_Node && m_NodeModifiedObserverTags.find(NonConstNode) == m_NodeModifiedObserverTags.end())
{
itk::MemberCommand<DataStorage>::Pointer nodeModifiedCommand = itk::MemberCommand<DataStorage>::New();
nodeModifiedCommand->SetCallbackFunction(this, &DataStorage::OnNodeModifiedOrDeleted);
m_NodeModifiedObserverTags[NonConstNode] = NonConstNode->AddObserver(itk::ModifiedEvent(), nodeModifiedCommand);
itk::MemberCommand<DataStorage>::Pointer interactorChangedCommand =
itk::MemberCommand<DataStorage>::New();
interactorChangedCommand->SetCallbackFunction(this, &DataStorage::OnNodeInteractorChanged);
m_NodeInteractorChangedObserverTags[NonConstNode] =
NonConstNode->AddObserver(DataNode::InteractorChangedEvent(), interactorChangedCommand);
// add itk delete listener on datastorage
itk::MemberCommand<DataStorage>::Pointer deleteCommand = itk::MemberCommand<DataStorage>::New();
deleteCommand->SetCallbackFunction(this, &DataStorage::OnNodeModifiedOrDeleted);
// add observer
m_NodeDeleteObserverTags[NonConstNode] = NonConstNode->AddObserver(itk::DeleteEvent(), deleteCommand);
}
}
void mitk::DataStorage::RemoveListeners(const DataNode *_Node)
{
itk::MutexLockHolder<itk::SimpleFastMutexLock> locked(m_MutexOne);
// node must not be 0 and must be registered
auto *NonConstNode = const_cast<DataNode *>(_Node);
if (_Node && m_NodeModifiedObserverTags.find(NonConstNode) != m_NodeModifiedObserverTags.end())
{
// const cast is bad! but sometimes it is necessary. removing an observer does not really
// touch the internal state
NonConstNode->RemoveObserver(m_NodeModifiedObserverTags.find(NonConstNode)->second);
NonConstNode->RemoveObserver(m_NodeDeleteObserverTags.find(NonConstNode)->second);
NonConstNode->RemoveObserver(m_NodeInteractorChangedObserverTags.find(NonConstNode)->second);
m_NodeModifiedObserverTags.erase(NonConstNode);
m_NodeDeleteObserverTags.erase(NonConstNode);
m_NodeInteractorChangedObserverTags.erase(NonConstNode);
}
}
mitk::TimeGeometry::ConstPointer mitk::DataStorage::ComputeBoundingGeometry3D(const SetOfObjects *input,
const char *boolPropertyKey,
const BaseRenderer *renderer,
const char *boolPropertyKey2) const
{
if (input == nullptr)
throw std::invalid_argument("DataStorage: input is invalid");
BoundingBox::PointsContainer::Pointer pointscontainer = BoundingBox::PointsContainer::New();
BoundingBox::PointIdentifier pointid = 0;
Point3D point;
Vector3D minSpacing;
minSpacing.Fill(itk::NumericTraits<ScalarType>::max());
ScalarType stmax = itk::NumericTraits<ScalarType>::max();
ScalarType stmin = itk::NumericTraits<ScalarType>::NonpositiveMin();
std::set<ScalarType> existingTimePoints;
ScalarType maximalTime = 0;
// Needed for check of zero bounding boxes
ScalarType nullpoint[] = {0, 0, 0, 0, 0, 0};
BoundingBox::BoundsArrayType itkBoundsZero(nullpoint);
for (SetOfObjects::ConstIterator it = input->Begin(); it != input->End(); ++it)
{
DataNode::Pointer node = it->Value();
if ((node.IsNotNull()) && (node->GetData() != nullptr) && (node->GetData()->IsEmpty() == false) &&
node->IsOn(boolPropertyKey, renderer) && node->IsOn(boolPropertyKey2, renderer))
{
const TimeGeometry *timeGeometry = node->GetData()->GetUpdatedTimeGeometry();
if (timeGeometry != nullptr)
{
// bounding box (only if non-zero)
BoundingBox::BoundsArrayType itkBounds = timeGeometry->GetBoundingBoxInWorld()->GetBounds();
if (itkBounds == itkBoundsZero)
{
continue;
}
unsigned char i;
for (i = 0; i < 8; ++i)
{
point = timeGeometry->GetCornerPointInWorld(i);
if (point[0] * point[0] + point[1] * point[1] + point[2] * point[2] < large)
pointscontainer->InsertElement(pointid++, point);
else
{
itkGenericOutputMacro(<< "Unrealistically distant corner point encountered. Ignored. Node: " << node);
}
}
try
{
// time bounds
// iterate over all time steps
// Attention: Objects with zero bounding box are not respected in time bound calculation
for (TimeStepType i = 0; i < timeGeometry->CountTimeSteps(); i++)
{
// We must not use 'node->GetData()->GetGeometry(i)->GetSpacing()' here, as it returns the spacing
// in its original space, which, in case of an image geometry, can have the values in different
// order than in world space. For the further calculations, we need to have the spacing values
// in world coordinate order (sag-cor-ax).
Vector3D spacing;
spacing.Fill(1.0);
node->GetData()->GetGeometry(i)->IndexToWorld(spacing, spacing);
for (int axis = 0; axis < 3; ++ axis)
{
ScalarType space = std::abs(spacing[axis]);
if (space < minSpacing[axis])
{
minSpacing[axis] = space;
}
}
const auto curTimeBounds = timeGeometry->GetTimeBounds(i);
if ((curTimeBounds[0] > stmin) && (curTimeBounds[0] < stmax))
{
existingTimePoints.insert(curTimeBounds[0]);
}
if ((curTimeBounds[1] > maximalTime) && (curTimeBounds[1] < stmax))
{
maximalTime = curTimeBounds[1];
}
}
}
catch ( const itk::ExceptionObject &e )
{
MITK_ERROR << e.GetDescription() << std::endl;
}
}
}
}
BoundingBox::Pointer result = BoundingBox::New();
result->SetPoints(pointscontainer);
result->ComputeBoundingBox();
// compute the number of time steps
if (existingTimePoints.empty()) // make sure that there is at least one time sliced geometry in the data storage
{
existingTimePoints.insert(0.0);
maximalTime = 1.0;
}
ArbitraryTimeGeometry::Pointer timeGeometry = nullptr;
if (result->GetPoints()->Size() > 0)
{
// Initialize a geometry of a single time step
Geometry3D::Pointer geometry = Geometry3D::New();
geometry->Initialize();
// correct bounding-box (is now in mm, should be in index-coordinates)
// according to spacing
BoundingBox::BoundsArrayType bounds = result->GetBounds();
AffineTransform3D::OutputVectorType offset;
for (int i = 0; i < 3; ++i)
{
offset[i] = bounds[i * 2];
bounds[i * 2] = 0.0;
bounds[i * 2 + 1] = (bounds[i * 2 + 1] - offset[i]) / minSpacing[i];
}
geometry->GetIndexToWorldTransform()->SetOffset(offset);
geometry->SetBounds(bounds);
geometry->SetSpacing(minSpacing);
// Initialize the time sliced geometry
auto tsIterator = existingTimePoints.cbegin();
auto tsPredecessor = tsIterator++;
auto tsEnd = existingTimePoints.cend();
timeGeometry = ArbitraryTimeGeometry::New();
for (; tsIterator != tsEnd; ++tsIterator, ++tsPredecessor)
{
timeGeometry->AppendNewTimeStep(geometry, *tsPredecessor, *tsIterator);
}
timeGeometry->AppendNewTimeStep(geometry, *tsPredecessor, maximalTime);
timeGeometry->Update();
}
return timeGeometry.GetPointer();
}
mitk::TimeGeometry::ConstPointer mitk::DataStorage::ComputeBoundingGeometry3D(const char *boolPropertyKey,
const BaseRenderer *renderer,
const char *boolPropertyKey2) const
{
return this->ComputeBoundingGeometry3D(this->GetAll(), boolPropertyKey, renderer, boolPropertyKey2);
}
mitk::TimeGeometry::ConstPointer mitk::DataStorage::ComputeVisibleBoundingGeometry3D(const BaseRenderer *renderer,
const char *boolPropertyKey)
{
return ComputeBoundingGeometry3D("visible", renderer, boolPropertyKey);
}
mitk::BoundingBox::Pointer mitk::DataStorage::ComputeBoundingBox(const char *boolPropertyKey,
const BaseRenderer *renderer,
const char *boolPropertyKey2)
{
BoundingBox::PointsContainer::Pointer pointscontainer = BoundingBox::PointsContainer::New();
BoundingBox::PointIdentifier pointid = 0;
Point3D point;
// Needed for check of zero bounding boxes
ScalarType nullpoint[] = {0, 0, 0, 0, 0, 0};
BoundingBox::BoundsArrayType itkBoundsZero(nullpoint);
SetOfObjects::ConstPointer all = this->GetAll();
for (SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
{
DataNode::Pointer node = it->Value();
if ((node.IsNotNull()) && (node->GetData() != nullptr) && (node->GetData()->IsEmpty() == false) &&
node->IsOn(boolPropertyKey, renderer) && node->IsOn(boolPropertyKey2, renderer))
{
const TimeGeometry *geometry = node->GetData()->GetUpdatedTimeGeometry();
if (geometry != nullptr)
{
// bounding box (only if non-zero)
BoundingBox::BoundsArrayType itkBounds = geometry->GetBoundingBoxInWorld()->GetBounds();
if (itkBounds == itkBoundsZero)
{
continue;
}
unsigned char i;
for (i = 0; i < 8; ++i)
{
point = geometry->GetCornerPointInWorld(i);
if (point[0] * point[0] + point[1] * point[1] + point[2] * point[2] < large)
pointscontainer->InsertElement(pointid++, point);
else
{
itkGenericOutputMacro(<< "Unrealistically distant corner point encountered. Ignored. Node: " << node);
}
}
}
}
}
BoundingBox::Pointer result = BoundingBox::New();
result->SetPoints(pointscontainer);
result->ComputeBoundingBox();
return result;
}
mitk::TimeBounds mitk::DataStorage::ComputeTimeBounds(const char *boolPropertyKey,
const BaseRenderer *renderer,
const char *boolPropertyKey2)
{
TimeBounds timeBounds;
ScalarType stmin, stmax, cur;
stmin = itk::NumericTraits<ScalarType>::NonpositiveMin();
stmax = itk::NumericTraits<ScalarType>::max();
timeBounds[0] = stmax;
timeBounds[1] = stmin;
SetOfObjects::ConstPointer all = this->GetAll();
for (SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
{
DataNode::Pointer node = it->Value();
if ((node.IsNotNull()) && (node->GetData() != nullptr) && (node->GetData()->IsEmpty() == false) &&
node->IsOn(boolPropertyKey, renderer) && node->IsOn(boolPropertyKey2, renderer))
{
const TimeGeometry *geometry = node->GetData()->GetUpdatedTimeGeometry();
if (geometry != nullptr)
{
const TimeBounds &curTimeBounds = geometry->GetTimeBounds();
cur = curTimeBounds[0];
// is it after -infinity, but before everything else that we found until now?
if ((cur > stmin) && (cur < timeBounds[0]))
timeBounds[0] = cur;
cur = curTimeBounds[1];
// is it before infinity, but after everything else that we found until now?
if ((cur < stmax) && (cur > timeBounds[1]))
timeBounds[1] = cur;
}
}
}
if (!(timeBounds[0] < stmax))
{
timeBounds[0] = stmin;
timeBounds[1] = stmax;
}
return timeBounds;
}
void mitk::DataStorage::BlockNodeModifiedEvents(bool block)
{
m_BlockNodeModifiedEvents = block;
}
mitk::DataNode::Pointer mitk::FindTopmostVisibleNode(const DataStorage::SetOfObjects::ConstPointer nodes,
const Point3D worldPosition,
const TimePointType timePoint,
const BaseRenderer* baseRender)
{
if (nodes.IsNull())
{
return nullptr;
}
mitk::DataNode::Pointer topLayerNode = nullptr;
int maxLayer = std::numeric_limits<int>::min();
- for (auto node : *nodes)
+ for (const auto &node : *nodes)
{
if (node.IsNull())
{
continue;
}
bool isHelperObject = false;
node->GetBoolProperty("helper object", isHelperObject);
if (isHelperObject)
{
continue;
}
auto data = node->GetData();
if (nullptr == data)
{
continue;
}
auto geometry = data->GetGeometry();
if (nullptr == geometry || !geometry->IsInside(worldPosition))
{
continue;
}
auto timeGeometry = data->GetUpdatedTimeGeometry();
if (nullptr == timeGeometry)
{
continue;
}
if (!timeGeometry->IsValidTimePoint(timePoint))
{
continue;
}
int layer = 0;
if (!node->GetIntProperty("layer", layer, baseRender))
{
continue;
}
if (layer <= maxLayer)
{
continue;
}
if (!node->IsVisible(baseRender))
{
continue;
}
topLayerNode = node;
maxLayer = layer;
}
return topLayerNode;
}
diff --git a/Modules/Core/src/DataManagement/mitkGeometryTransformHolder.cpp b/Modules/Core/src/DataManagement/mitkGeometryTransformHolder.cpp
index 8d354ca719..a20204ef84 100644
--- a/Modules/Core/src/DataManagement/mitkGeometryTransformHolder.cpp
+++ b/Modules/Core/src/DataManagement/mitkGeometryTransformHolder.cpp
@@ -1,335 +1,335 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
/*
* mitkGeometryTransformHolder.cpp
*
* Created on: Sep 3, 2014
* Author: wirkert
*/
#include <cassert>
#include <itkMatrix.h>
#include <itkScalableAffineTransform.h>
#include <itkSmartPointer.h>
#include <mitkBaseGeometry.h>
#include <mitkGeometryTransformHolder.h>
#include <mitkMatrix.h>
#include <mitkMatrixConvert.h>
#include <mitkPoint.h>
#include <mitkVector.h>
#include <vnl/vnl_matrix_fixed.h>
#include <vnl/vnl_vector.h>
#include <vnl/vnl_vector_fixed.h>
#include <vtkMatrix4x4.h>
#include <vtkMatrixToLinearTransform.h>
#include <vtkTransform.h>
namespace mitk
{
void GeometryTransformHolder::CopySpacingFromTransform(const mitk::AffineTransform3D *transform,
mitk::Vector3D &spacing)
{
mitk::AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
vnlmatrix = transform->GetMatrix().GetVnlMatrix();
spacing[0] = vnlmatrix.get_column(0).magnitude();
spacing[1] = vnlmatrix.get_column(1).magnitude();
spacing[2] = vnlmatrix.get_column(2).magnitude();
}
GeometryTransformHolder::GeometryTransformHolder()
{
m_VtkMatrix = vtkMatrix4x4::New();
m_VtkIndexToWorldTransform = vtkMatrixToLinearTransform::New();
m_VtkIndexToWorldTransform->SetInput(m_VtkMatrix);
this->Initialize();
}
GeometryTransformHolder::GeometryTransformHolder(const GeometryTransformHolder &other)
{
m_VtkMatrix = vtkMatrix4x4::New();
m_VtkIndexToWorldTransform = vtkMatrixToLinearTransform::New();
m_VtkIndexToWorldTransform->SetInput(m_VtkMatrix);
this->Initialize(&other);
}
GeometryTransformHolder::~GeometryTransformHolder()
{
m_VtkMatrix->Delete();
m_VtkIndexToWorldTransform->Delete();
}
void GeometryTransformHolder::Initialize()
{
if (m_IndexToWorldTransform.IsNull())
m_IndexToWorldTransform = TransformType::New();
else
m_IndexToWorldTransform->SetIdentity();
m_VtkMatrix->Identity();
}
void GeometryTransformHolder::Initialize(const GeometryTransformHolder *other)
{
Initialize();
if (other->GetIndexToWorldTransform())
{
TransformType::Pointer indexToWorldTransform = other->GetIndexToWorldTransform()->Clone();
this->SetIndexToWorldTransform(indexToWorldTransform);
}
}
//##Documentation
//## @brief Copy the ITK transform
//## (m_IndexToWorldTransform) to the VTK transform
//## \sa SetIndexToWorldTransform
void GeometryTransformHolder::TransferItkToVtkTransform()
{
TransferItkTransformToVtkMatrix(m_IndexToWorldTransform.GetPointer(), m_VtkMatrix);
}
//##Documentation
//## @brief Copy the VTK transform
//## to the ITK transform (m_IndexToWorldTransform)
//## \sa SetIndexToWorldTransform
void GeometryTransformHolder::TransferVtkToItkTransform()
{
TransferVtkMatrixToItkTransform(m_VtkMatrix, m_IndexToWorldTransform.GetPointer());
}
//##Documentation
//## @brief Get the origin, e.g. the upper-left corner of the plane
const Point3D GeometryTransformHolder::GetOrigin() const
{
- mitk::Point3D origin = this->GetIndexToWorldTransform()->GetOffset();
+ Point3D origin = Point3D(this->GetIndexToWorldTransform()->GetOffset());
return origin;
}
//##Documentation
//## @brief Set the origin, i.e. the upper-left corner of the plane
//##
void GeometryTransformHolder::SetOrigin(const Point3D &origin)
{
m_IndexToWorldTransform->SetOffset(origin.GetVectorFromOrigin());
TransferItkToVtkTransform();
}
//##Documentation
//## @brief Get the spacing (size of a pixel).
//##
const mitk::Vector3D GeometryTransformHolder::GetSpacing() const
{
mitk::Vector3D spacing;
CopySpacingFromTransform(this->GetIndexToWorldTransform(), spacing);
return spacing;
}
//##Documentation
//## @brief Set the spacing.
//##
//##The spacing is also changed in the IndexToWorldTransform.
void GeometryTransformHolder::SetSpacing(const mitk::Vector3D &aSpacing, bool enforceSetSpacing)
{
if (mitk::Equal(this->GetSpacing(), aSpacing) == false || enforceSetSpacing)
{
assert(aSpacing[0] > 0 && aSpacing[1] > 0 && aSpacing[2] > 0);
AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
vnlmatrix = m_IndexToWorldTransform->GetMatrix().GetVnlMatrix();
mitk::VnlVector col;
col = vnlmatrix.get_column(0);
col.normalize();
col *= aSpacing[0];
vnlmatrix.set_column(0, col);
col = vnlmatrix.get_column(1);
col.normalize();
col *= aSpacing[1];
vnlmatrix.set_column(1, col);
col = vnlmatrix.get_column(2);
col.normalize();
col *= aSpacing[2];
vnlmatrix.set_column(2, col);
Matrix3D matrix;
matrix = vnlmatrix;
AffineTransform3D::Pointer transform = AffineTransform3D::New();
transform->SetMatrix(matrix);
transform->SetOffset(m_IndexToWorldTransform->GetOffset());
SetIndexToWorldTransform(transform.GetPointer());
}
}
//##Documentation
//## @brief Get the transformation used to convert from index
//## to world coordinates
mitk::AffineTransform3D *GeometryTransformHolder::GetIndexToWorldTransform() { return m_IndexToWorldTransform; }
//##Documentation
//## @brief Get the transformation used to convert from index
//## to world coordinates
const mitk::AffineTransform3D *GeometryTransformHolder::GetIndexToWorldTransform() const
{
return m_IndexToWorldTransform;
}
//## @brief Set the transformation used to convert from index
//## to world coordinates. The spacing of the new transform is
//## copied to m_spacing.
void GeometryTransformHolder::SetIndexToWorldTransform(mitk::AffineTransform3D *transform)
{
m_IndexToWorldTransform = transform;
TransferItkToVtkTransform();
}
//##Documentation
//## @brief Convenience method for setting the ITK transform
//## (m_IndexToWorldTransform) via an vtkMatrix4x4.The spacing of
//## the new transform is copied to m_spacing.
//## \sa SetIndexToWorldTransform
void GeometryTransformHolder::SetIndexToWorldTransformByVtkMatrix(vtkMatrix4x4 *vtkmatrix)
{
m_VtkMatrix->DeepCopy(vtkmatrix);
TransferVtkToItkTransform();
}
//## @brief Set the transformation used to convert from index
//## to world coordinates.This function keeps the original spacing.
void GeometryTransformHolder::SetIndexToWorldTransformWithoutChangingSpacing(mitk::AffineTransform3D *transform)
{
mitk::Vector3D originalSpacing = this->GetSpacing();
this->SetIndexToWorldTransform(transform);
this->SetSpacing(originalSpacing);
}
//##Documentation
//## @brief Convenience method for setting the ITK transform
//## (m_IndexToWorldTransform) via an vtkMatrix4x4. This function keeps the original spacing.
//## \sa SetIndexToWorldTransform
void GeometryTransformHolder::SetIndexToWorldTransformByVtkMatrixWithoutChangingSpacing(vtkMatrix4x4 *vtkmatrix)
{
mitk::Vector3D originalSpacing = this->GetSpacing();
this->SetIndexToWorldTransformByVtkMatrix(vtkmatrix);
this->SetSpacing(originalSpacing);
}
//## Get the Vtk Matrix which describes the transform.
vtkMatrix4x4 *GeometryTransformHolder::GetVtkMatrix() { return m_VtkMatrix; }
//## Get the Vtk Matrix which describes the transform.
const vtkMatrix4x4 *GeometryTransformHolder::GetVtkMatrix() const { return m_VtkMatrix; }
//##Documentation
//## @brief Get the m_IndexToWorldTransform as a vtkLinearTransform
vtkLinearTransform *GeometryTransformHolder::GetVtkTransform() const
{
return (vtkLinearTransform *)m_VtkIndexToWorldTransform;
}
void GeometryTransformHolder::SetMatrix(Matrix3D &matrix)
{
m_IndexToWorldTransform->SetMatrix(matrix);
TransferItkToVtkTransform();
}
void GeometryTransformHolder::SetIdentity()
{
m_IndexToWorldTransform->SetIdentity();
TransferItkToVtkTransform();
}
void GeometryTransformHolder::Compose(const TransformType *other, bool pre)
{
m_IndexToWorldTransform->Compose(other, pre);
TransferItkToVtkTransform();
}
void GeometryTransformHolder::SetVtkMatrixDeepCopy(vtkTransform *vtktransform)
{
m_VtkMatrix->DeepCopy(vtktransform->GetMatrix());
TransferVtkToItkTransform();
}
bool GeometryTransformHolder::IsIndexToWorldTransformNull() { return m_IndexToWorldTransform.IsNull(); }
AffineTransform3D::MatrixType::InternalMatrixType GeometryTransformHolder::GetVnlMatrix()
{
return m_IndexToWorldTransform->GetMatrix().GetVnlMatrix();
}
}
bool mitk::Equal(const mitk::GeometryTransformHolder *leftHandSide,
const mitk::GeometryTransformHolder *rightHandSide,
ScalarType eps,
bool verbose)
{
if ((leftHandSide == nullptr) || (rightHandSide == nullptr))
{
MITK_ERROR << "mitk::Equal(const mitk::Geometry3D *leftHandSide, const mitk::Geometry3D *rightHandSide, ScalarType "
"eps, bool verbose) does not with nullptr pointer input.";
return false;
}
return Equal(*leftHandSide, *rightHandSide, eps, verbose);
}
bool mitk::Equal(const mitk::GeometryTransformHolder &leftHandSide,
const mitk::GeometryTransformHolder &rightHandSide,
ScalarType eps,
bool verbose)
{
bool result = true;
// Compare spacings
if (!mitk::Equal(leftHandSide.GetSpacing(), rightHandSide.GetSpacing(), eps))
{
if (verbose)
{
MITK_INFO << "[( Geometry3D )] Spacing differs.";
MITK_INFO << "rightHandSide is " << setprecision(12) << rightHandSide.GetSpacing() << " : leftHandSide is "
<< leftHandSide.GetSpacing() << " and tolerance is " << eps;
}
result = false;
}
// Compare Origins
if (!mitk::Equal(leftHandSide.GetOrigin(), rightHandSide.GetOrigin(), eps))
{
if (verbose)
{
MITK_INFO << "[( Geometry3D )] Origin differs.";
MITK_INFO << "rightHandSide is " << setprecision(12) << rightHandSide.GetOrigin() << " : leftHandSide is "
<< leftHandSide.GetOrigin() << " and tolerance is " << eps;
}
result = false;
}
// Compare IndexToWorldTransform Matrix
if (!mitk::Equal(*leftHandSide.GetIndexToWorldTransform(), *rightHandSide.GetIndexToWorldTransform(), eps, verbose))
{
result = false;
}
// Compare vtk Matrix
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
if (leftHandSide.GetVtkMatrix()->GetElement(i, j) != rightHandSide.GetVtkMatrix()->GetElement(i, j))
{
result = false;
}
}
}
return result;
}
diff --git a/Modules/Core/src/DataManagement/mitkPropertyList.cpp b/Modules/Core/src/DataManagement/mitkPropertyList.cpp
index 69d6aaed01..d9ad1ac009 100644
--- a/Modules/Core/src/DataManagement/mitkPropertyList.cpp
+++ b/Modules/Core/src/DataManagement/mitkPropertyList.cpp
@@ -1,376 +1,376 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkPropertyList.h"
#include "mitkNumericTypes.h"
#include "mitkProperties.h"
#include "mitkStringProperty.h"
mitk::BaseProperty::ConstPointer mitk::PropertyList::GetConstProperty(const std::string &propertyKey, const std::string &/*contextName*/, bool /*fallBackOnDefaultContext*/) const
{
PropertyMap::const_iterator it;
it = m_Properties.find(propertyKey);
if (it != m_Properties.cend())
return it->second.GetPointer();
else
return nullptr;
};
std::vector<std::string> mitk::PropertyList::GetPropertyKeys(const std::string &contextName, bool includeDefaultContext) const
{
std::vector<std::string> propertyKeys;
if (contextName.empty() || includeDefaultContext)
{
- for (auto property : this->m_Properties)
+ for (const auto &property : this->m_Properties)
propertyKeys.push_back(property.first);
}
return propertyKeys;
};
std::vector<std::string> mitk::PropertyList::GetPropertyContextNames() const
{
return std::vector<std::string>();
};
mitk::BaseProperty *mitk::PropertyList::GetProperty(const std::string &propertyKey) const
{
PropertyMap::const_iterator it;
it = m_Properties.find(propertyKey);
if (it != m_Properties.cend())
return it->second;
else
return nullptr;
}
mitk::BaseProperty * mitk::PropertyList::GetNonConstProperty(const std::string &propertyKey, const std::string &/*contextName*/, bool /*fallBackOnDefaultContext*/)
{
return this->GetProperty(propertyKey);
}
void mitk::PropertyList::SetProperty(const std::string &propertyKey, BaseProperty *property, const std::string &/*contextName*/, bool /*fallBackOnDefaultContext*/)
{
if (propertyKey.empty())
mitkThrow() << "Property key is empty.";
if (!property)
return;
// make sure that BaseProperty*, which may have just been created and never been
// assigned to a SmartPointer, is registered/unregistered properly. If we do not
// do that, it will a) not deleted in case it is identical to the old one or
// b) possibly deleted when temporarily added to a smartpointer somewhere below.
BaseProperty::Pointer tmpSmartPointerToProperty = property;
auto it(m_Properties.find(propertyKey));
// Is a property with key @a propertyKey contained in the list?
if (it != m_Properties.cend())
{
// yes
// is the property contained in the list identical to the new one?
if (it->second->operator==(*property))
{
// yes? do nothing and return.
return;
}
if (it->second->AssignProperty(*property))
{
// The assignment was successfull
this->Modified();
}
else
{
MITK_ERROR << "In " __FILE__ ", l." << __LINE__ << ": Trying to set existing property " << it->first
<< " of type " << it->second->GetNameOfClass() << " to a property with different type "
<< property->GetNameOfClass() << "."
<< " Use ReplaceProperty() instead." << std::endl;
}
return;
}
// no? add it.
m_Properties.insert(PropertyMap::value_type(propertyKey, property));
this->Modified();
}
void mitk::PropertyList::ReplaceProperty(const std::string &propertyKey, BaseProperty *property)
{
if (!property)
return;
auto it(m_Properties.find(propertyKey));
// Is a property with key @a propertyKey contained in the list?
if (it != m_Properties.cend())
{
it->second = nullptr;
m_Properties.erase(it);
}
// no? add/replace it.
m_Properties.insert(PropertyMap::value_type(propertyKey, property));
Modified();
}
void mitk::PropertyList::RemoveProperty(const std::string &propertyKey, const std::string &/*contextName*/, bool /*fallBackOnDefaultContext*/)
{
auto it(m_Properties.find(propertyKey));
// Is a property with key @a propertyKey contained in the list?
if (it != m_Properties.cend())
{
it->second = nullptr;
m_Properties.erase(it);
Modified();
}
}
mitk::PropertyList::PropertyList()
{
}
mitk::PropertyList::PropertyList(const mitk::PropertyList &other) : itk::Object()
{
for (auto i = other.m_Properties.cbegin(); i != other.m_Properties.cend(); ++i)
{
m_Properties.insert(std::make_pair(i->first, i->second->Clone()));
}
}
mitk::PropertyList::~PropertyList()
{
Clear();
}
/**
* Consider the list as changed when any of the properties has changed recently.
*/
unsigned long mitk::PropertyList::GetMTime() const
{
for (auto it = m_Properties.cbegin(); it != m_Properties.cend(); ++it)
{
if (it->second.IsNull())
{
itkWarningMacro(<< "Property '" << it->first << "' contains nothing (nullptr).");
continue;
}
if (Superclass::GetMTime() < it->second->GetMTime())
{
Modified();
break;
}
}
return Superclass::GetMTime();
}
bool mitk::PropertyList::DeleteProperty(const std::string &propertyKey)
{
auto it = m_Properties.find(propertyKey);
if (it != m_Properties.end())
{
it->second = nullptr;
m_Properties.erase(it);
Modified();
return true;
}
return false;
}
void mitk::PropertyList::Clear()
{
auto it = m_Properties.begin(), end = m_Properties.end();
while (it != end)
{
it->second = nullptr;
++it;
}
m_Properties.clear();
}
itk::LightObject::Pointer mitk::PropertyList::InternalClone() const
{
itk::LightObject::Pointer result(new Self(*this));
result->UnRegister();
return result;
}
void mitk::PropertyList::ConcatenatePropertyList(PropertyList *pList, bool replace)
{
if (pList)
{
const PropertyMap *propertyMap = pList->GetMap();
for (auto iter = propertyMap->cbegin(); // m_PropertyList is created in the constructor, so we don't check it here
iter != propertyMap->cend();
++iter)
{
const std::string key = iter->first;
BaseProperty *value = iter->second;
if (replace)
{
ReplaceProperty(key.c_str(), value);
}
else
{
SetProperty(key.c_str(), value);
}
}
}
}
bool mitk::PropertyList::GetBoolProperty(const char *propertyKey, bool &boolValue) const
{
BoolProperty *gp = dynamic_cast<BoolProperty *>(GetProperty(propertyKey));
if (gp != nullptr)
{
boolValue = gp->GetValue();
return true;
}
return false;
// Templated Method does not work on Macs
// return GetPropertyValue<bool>(propertyKey, boolValue);
}
bool mitk::PropertyList::GetIntProperty(const char *propertyKey, int &intValue) const
{
IntProperty *gp = dynamic_cast<IntProperty *>(GetProperty(propertyKey));
if (gp != nullptr)
{
intValue = gp->GetValue();
return true;
}
return false;
// Templated Method does not work on Macs
// return GetPropertyValue<int>(propertyKey, intValue);
}
bool mitk::PropertyList::GetFloatProperty(const char *propertyKey, float &floatValue) const
{
FloatProperty *gp = dynamic_cast<FloatProperty *>(GetProperty(propertyKey));
if (gp != nullptr)
{
floatValue = gp->GetValue();
return true;
}
return false;
// Templated Method does not work on Macs
// return GetPropertyValue<float>(propertyKey, floatValue);
}
bool mitk::PropertyList::GetStringProperty(const char *propertyKey, std::string &stringValue) const
{
StringProperty *sp = dynamic_cast<StringProperty *>(GetProperty(propertyKey));
if (sp != nullptr)
{
stringValue = sp->GetValue();
return true;
}
return false;
}
void mitk::PropertyList::SetIntProperty(const char *propertyKey, int intValue)
{
SetProperty(propertyKey, mitk::IntProperty::New(intValue));
}
void mitk::PropertyList::SetBoolProperty(const char *propertyKey, bool boolValue)
{
SetProperty(propertyKey, mitk::BoolProperty::New(boolValue));
}
void mitk::PropertyList::SetFloatProperty(const char *propertyKey, float floatValue)
{
SetProperty(propertyKey, mitk::FloatProperty::New(floatValue));
}
void mitk::PropertyList::SetStringProperty(const char *propertyKey, const char *stringValue)
{
SetProperty(propertyKey, mitk::StringProperty::New(stringValue));
}
void mitk::PropertyList::Set(const char *propertyKey, bool boolValue)
{
this->SetBoolProperty(propertyKey, boolValue);
}
void mitk::PropertyList::Set(const char *propertyKey, int intValue)
{
this->SetIntProperty(propertyKey, intValue);
}
void mitk::PropertyList::Set(const char *propertyKey, float floatValue)
{
this->SetFloatProperty(propertyKey, floatValue);
}
void mitk::PropertyList::Set(const char *propertyKey, double doubleValue)
{
this->SetDoubleProperty(propertyKey, doubleValue);
}
void mitk::PropertyList::Set(const char *propertyKey, const char *stringValue)
{
this->SetStringProperty(propertyKey, stringValue);
}
void mitk::PropertyList::Set(const char *propertyKey, const std::string &stringValue)
{
this->SetStringProperty(propertyKey, stringValue.c_str());
}
bool mitk::PropertyList::Get(const char *propertyKey, bool &boolValue) const
{
return this->GetBoolProperty(propertyKey, boolValue);
}
bool mitk::PropertyList::Get(const char *propertyKey, int &intValue) const
{
return this->GetIntProperty(propertyKey, intValue);
}
bool mitk::PropertyList::Get(const char *propertyKey, float &floatValue) const
{
return this->GetFloatProperty(propertyKey, floatValue);
}
bool mitk::PropertyList::Get(const char *propertyKey, double &doubleValue) const
{
return this->GetDoubleProperty(propertyKey, doubleValue);
}
bool mitk::PropertyList::Get(const char *propertyKey, std::string &stringValue) const
{
return this->GetStringProperty(propertyKey, stringValue);
}
bool mitk::PropertyList::GetDoubleProperty(const char *propertyKey, double &doubleValue) const
{
DoubleProperty *gp = dynamic_cast<DoubleProperty *>(GetProperty(propertyKey));
if (gp != nullptr)
{
doubleValue = gp->GetValue();
return true;
}
return false;
}
void mitk::PropertyList::SetDoubleProperty(const char *propertyKey, double doubleValue)
{
SetProperty(propertyKey, mitk::DoubleProperty::New(doubleValue));
}
diff --git a/Modules/Core/src/DataManagement/mitkSourceImageRelationRule.cpp b/Modules/Core/src/DataManagement/mitkSourceImageRelationRule.cpp
index de0916c8d5..b743e4d531 100644
--- a/Modules/Core/src/DataManagement/mitkSourceImageRelationRule.cpp
+++ b/Modules/Core/src/DataManagement/mitkSourceImageRelationRule.cpp
@@ -1,419 +1,419 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <regex>
#include <mutex>
#include "mitkSourceImageRelationRule.h"
#include "mitkPropertyNameHelper.h"
#include "mitkStringProperty.h"
#include "mitkTemporoSpatialStringProperty.h"
#include "mitkDataNode.h"
#include "mitkIdentifiable.h"
std::string mitk::SourceImageRelationRule::GenerateRuleID(const std::string& purpose) const
{
std::string result = "SourceImageRelation";
if (!purpose.empty())
{
result += " " + purpose;
}
return result;
}
bool mitk::SourceImageRelationRule::IsAbstract() const
{
return m_PurposeTag.empty();
};
bool mitk::SourceImageRelationRule::IsSupportedRuleID(const RuleIDType& ruleID) const
{
return ruleID == this->GetRuleID() || (IsAbstract() && ruleID.find("SourceImageRelation ") == 0);
};
mitk::SourceImageRelationRule::RuleIDType mitk::SourceImageRelationRule::GetRuleID() const
{
return this->GenerateRuleID(m_PurposeTag);
};
std::string mitk::SourceImageRelationRule::GetDisplayName() const
{
return m_DisplayName;
};
std::string mitk::SourceImageRelationRule::GetSourceRoleName() const
{
return m_SourceRole;
};
std::string mitk::SourceImageRelationRule::GetDestinationRoleName() const
{
return m_DestinationRole;
};
bool mitk::SourceImageRelationRule::IsDestinationCandidate(const IPropertyProvider *owner) const
{
auto node = dynamic_cast<const DataNode*>(owner);
auto image = nullptr != node
? dynamic_cast<const Image*>(node->GetData())
: dynamic_cast<const Image*>(owner);
return image != nullptr;
}
mitk::SourceImageRelationRule::RelationUIDType mitk::SourceImageRelationRule::Connect(Image *source, const Image *destination) const
{
return Superclass::Connect(source, destination);
};
mitk::SourceImageRelationRule::SourceImageRelationRule()
: m_PurposeTag(""), m_DisplayName("Abstract image to image relation"), m_SourceRole("derived data"), m_DestinationRole("source image")
{};
mitk::SourceImageRelationRule::SourceImageRelationRule(const RuleIDType &purposeTag)
: SourceImageRelationRule(purposeTag, purposeTag + " relation"){};
mitk::SourceImageRelationRule::SourceImageRelationRule(const RuleIDType &purposeTag, const std::string &displayName)
: SourceImageRelationRule(
purposeTag, displayName, "derived data", "source image"){};
mitk::SourceImageRelationRule::SourceImageRelationRule(const RuleIDType &purposeTag,
const std::string &displayName,
const std::string &sourceRole,
const std::string &destinationRole)
: m_PurposeTag(purposeTag), m_DisplayName(displayName), m_SourceRole(sourceRole), m_DestinationRole(destinationRole){};
mitk::SourceImageRelationRule::DataRelationUIDVectorType
mitk::SourceImageRelationRule::GetRelationUIDs_DataLayer(const IPropertyProvider* source,
const IPropertyProvider* destination, const InstanceIDVectorType& instances_IDLayer) const
{
DataRelationUIDVectorType result;
auto relevantIndicesAndRuleIDs = GetReferenceSequenceIndices(source, destination, instances_IDLayer);
auto itemRIIRegExStr = this->GetRIIPropertyRegEx("SourceImageSequenceItem");
auto regEx = std::regex(itemRIIRegExStr);
//workaround until T24729 is done. Please remove if T24728 is done
auto keys = PropertyRelationRuleBase::GetPropertyKeys(source);
//end workaround for T24729
for (const auto &indexNRule : relevantIndicesAndRuleIDs)
{
bool relationCoveredByRII = false;
for (const auto& key : keys)
{
if (std::regex_match(key, regEx))
{
auto sequItemProp = source->GetConstProperty(key);
if (sequItemProp.IsNotNull() && sequItemProp->GetValueAsString() == std::to_string(indexNRule.first))
{
relationCoveredByRII = true;
auto instanceID = GetInstanceIDByPropertyName(key);
auto ruleID = GetRuleIDByInstanceID(source, instanceID);
if (this->IsSupportedRuleID(ruleID))
{
result.emplace_back(this->GetRelationUIDByInstanceID(source, instanceID), ruleID);
}
}
}
}
if (!relationCoveredByRII)
{
//the relation is not covered on the RII level, so we generate the property path to the DICOM source reference (this is done via
//the SOP Instance UIDs which uniquely identify an DICOM IOD). We use this property path as relation UID because it is identifying
//on the data level (even so not long term stable if relations with a lower index are removed).
PropertyKeyPath referencedInstanceUIDs;
referencedInstanceUIDs.AddElement("DICOM").AddElement("0008").AddSelection("2112", indexNRule.first).AddElement("0008").AddElement("1155");
std::string ruleID = "";
if (!indexNRule.second.empty())
{
ruleID = this->GenerateRuleID(indexNRule.second);
}
result.emplace_back(PropertyKeyPathToPropertyName(referencedInstanceUIDs), ruleID);
}
}
return result;
};
std::vector<std::pair<size_t,std::string> > mitk::SourceImageRelationRule::GetReferenceSequenceIndices(const IPropertyProvider * source,
const IPropertyProvider * destination, InstanceIDVectorType ignoreInstances) const
{
std::vector<std::pair<size_t, std::string> > result;
BaseProperty::ConstPointer destInstanceUIDProp;
std::string destinationUID = "";
if (destination)
{
destInstanceUIDProp = destination->GetConstProperty(GeneratePropertyNameForDICOMTag(0x0008, 0x0018));
if (destInstanceUIDProp.IsNull())
{
return result;
}
auto identifiable = this->CastProviderAsIdentifiable(destination);
if (identifiable)
{
destinationUID= identifiable->GetUID();
}
}
std::vector<std::string> ignoreItemIndices;
for (const auto& iID : ignoreInstances)
{
auto sourceImageRefPath = GetRootKeyPath().AddElement(iID).AddElement("SourceImageSequenceItem");
auto imageRefProp = source->GetConstProperty(PropertyKeyPathToPropertyName(sourceImageRefPath));
if (imageRefProp.IsNotNull())
{
ignoreItemIndices.emplace_back(imageRefProp->GetValueAsString());
}
}
PropertyKeyPath referencedInstanceUIDs;
referencedInstanceUIDs.AddElement("DICOM").AddElement("0008").AddAnySelection("2112").AddElement("0008").AddElement("1155");
auto sourceRegExStr = PropertyKeyPathToPropertyRegEx(referencedInstanceUIDs);
auto regEx = std::regex(sourceRegExStr);
std::vector<std::string> keys;
//workaround until T24729 is done. Please remove if T24728 is done
keys = PropertyRelationRuleBase::GetPropertyKeys(source);
//end workaround for T24729
for (const auto &key : keys)
{
if (std::regex_match(key, regEx))
{
auto refUIDProp = source->GetConstProperty(key);
if (destination==nullptr || *refUIDProp == *destInstanceUIDProp)
{
auto currentKeyPath = PropertyNameToPropertyKeyPath(key);
auto currentKeyPathSelection = currentKeyPath.GetNode(2).selection;
auto finding = std::find(ignoreItemIndices.begin(), ignoreItemIndices.end(), std::to_string(currentKeyPathSelection));
if (finding == ignoreItemIndices.end())
{
PropertyKeyPath purposePath;
purposePath.AddElement("DICOM").AddElement("0008").AddSelection("2112", currentKeyPathSelection).AddElement("0040").AddSelection("a170", 0).AddElement("0008").AddElement("0104");
auto purposeProp = source->GetConstProperty(PropertyKeyPathToPropertyName(purposePath));
std::string currentPurpose = "";
if (purposeProp.IsNotNull())
{
currentPurpose = purposeProp->GetValueAsString();
}
if (this->IsAbstract() || (purposeProp.IsNotNull() && currentPurpose == this->m_PurposeTag))
{
result.emplace_back(currentKeyPathSelection, currentPurpose);
}
}
}
}
}
return result;
};
/**This mutex is used to guard mitk::SourceImageRelationRule::CreateNewSourceImageSequenceItem by a class wide mutex to avoid
racing conditions in a scenario where rules are used concurrently. It is not in the class interface itself, because it
is an implementation detail.
*/
namespace
{
std::mutex sequenceItemCreationLock;
}
mitk::PropertyKeyPath::ItemSelectionIndex mitk::SourceImageRelationRule::CreateNewSourceImageSequenceItem(
IPropertyOwner *source) const
{
std::lock_guard<std::mutex> guard(sequenceItemCreationLock);
//////////////////////////////////////
// Get all existing sequence items
std::vector<PropertyKeyPath::ItemSelectionIndex> instanceIDs;
PropertyKeyPath::ItemSelectionIndex newID = 0;
PropertyKeyPath referencedInstanceUIDs;
referencedInstanceUIDs.AddElement("DICOM").AddElement("0008").AddAnySelection("2112").AddElement("0008").AddElement("1155");
auto regExStr = PropertyKeyPathToPropertyRegEx(referencedInstanceUIDs);
auto regEx = std::regex(regExStr);
std::smatch instance_matches;
//workaround until T24729 is done. You can use directly source->GetPropertyKeys again, when fixed.
const auto keys = GetPropertyKeys(source);
//end workaround for T24729
for (const auto &key : keys)
{
if (std::regex_search(key, instance_matches, regEx))
{
if (instance_matches.size()>1)
{
instanceIDs.push_back(std::stoi(instance_matches[1]));
}
}
}
//////////////////////////////////////
// Get new ID
std::sort(instanceIDs.begin(), instanceIDs.end());
if (!instanceIDs.empty())
{
newID = instanceIDs.back()+1;
}
//////////////////////////////////////
// reserve new ID
PropertyKeyPath newSourceImageSequencePath;
newSourceImageSequencePath.AddElement("DICOM").AddElement("0008").AddSelection("2112",newID).AddElement("0008").AddElement("1155");
auto newKey =
PropertyKeyPathToPropertyName(newSourceImageSequencePath);
source->SetProperty(newKey, mitk::TemporoSpatialStringProperty::New("reserved slot for source image sequence"));
return newID;
};
void mitk::SourceImageRelationRule::Connect_datalayer(IPropertyOwner * source,
const IPropertyProvider * destination,
const InstanceIDType & instanceID) const
{
auto destInstanceUIDProp = destination->GetConstProperty(GeneratePropertyNameForDICOMTag(0x0008,0x0018));
auto destClassUIDProp = destination->GetConstProperty(GeneratePropertyNameForDICOMTag(0x0008, 0x0016));
if (destInstanceUIDProp.IsNotNull() && destClassUIDProp.IsNotNull())
{
auto existingRefs = this->GetReferenceSequenceIndices(source, destination);
std::string newSelectionIndexStr;
if (!existingRefs.empty())
{
newSelectionIndexStr = std::to_string(existingRefs[0].first);
}
else
{
PropertyKeyPath::ItemSelectionIndex newSelectionIndex = CreateNewSourceImageSequenceItem(source);
PropertyKeyPath refInstanceUIDPath;
refInstanceUIDPath.AddElement("DICOM").AddElement("0008").AddSelection("2112", newSelectionIndex).AddElement("0008").AddElement("1155");
source->SetProperty(PropertyKeyPathToPropertyName(refInstanceUIDPath), destInstanceUIDProp->Clone());
PropertyKeyPath refClassUIDPath;
refClassUIDPath.AddElement("DICOM").AddElement("0008").AddSelection("2112", newSelectionIndex).AddElement("0008").AddElement("1150");
source->SetProperty(PropertyKeyPathToPropertyName(refClassUIDPath), destClassUIDProp->Clone());
PropertyKeyPath purposePath;
purposePath.AddElement("DICOM").AddElement("0008").AddSelection("2112", newSelectionIndex).AddElement("0040").AddSelection("a170", 0).AddElement("0008").AddElement("0104");
source->SetProperty(PropertyKeyPathToPropertyName(purposePath), StringProperty::New(m_PurposeTag));
newSelectionIndexStr = std::to_string(newSelectionIndex);
}
auto sourceImageRefPath = GetRootKeyPath().AddElement(instanceID).AddElement("SourceImageSequenceItem");
source->SetProperty(PropertyKeyPathToPropertyName(sourceImageRefPath), StringProperty::New(newSelectionIndexStr).GetPointer());
}
else
{
MITK_DEBUG << "Cannot connect SourceImageRelationRule on data layer. Passed destination does not have properties for DICOM SOP Instance UIDs(0x0008, 0x0018) and DICOM SOP Class UID(0x0008, 0x0016)";
}
};
void mitk::SourceImageRelationRule::Disconnect_datalayer(IPropertyOwner * source, const RelationUIDType & relationUID) const
{
std::string deletedImageRefSequenceIndexStr = "";
if (relationUID.find("DICOM") == 0)
{ //relation that is purly data based.
auto currentKeyPath = PropertyNameToPropertyKeyPath(relationUID);
deletedImageRefSequenceIndexStr = std::to_string(currentKeyPath.GetNode(2).selection);
}
else
{
auto sourceImageRefPath = GetRootKeyPath().AddElement(this->GetInstanceIDByRelationUID(source,relationUID)).AddElement("SourceImageSequenceItem");
auto imageRefProp = source->GetConstProperty(PropertyKeyPathToPropertyName(sourceImageRefPath));
if (imageRefProp.IsNotNull())
{
deletedImageRefSequenceIndexStr = imageRefProp->GetValueAsString();
}
}
if(!deletedImageRefSequenceIndexStr.empty())
{
auto deletedImageRefSequenceIndex = std::stoull(deletedImageRefSequenceIndexStr);
auto refs = GetReferenceSequenceIndices(source);
std::sort(refs.begin(), refs.end());
- for (auto refIndex : refs)
+ for (const auto &refIndex : refs)
{
if (refIndex.first >= deletedImageRefSequenceIndex)
{
PropertyKeyPath refDICOMDataPath;
refDICOMDataPath.AddElement("DICOM").AddElement("0008").AddSelection("2112", refIndex.first);
auto prefix = PropertyKeyPathToPropertyName(refDICOMDataPath);
PropertyKeyPath refRelDataPath = GetRootKeyPath().AddAnyElement().AddElement("SourceImageSequenceItem");;
auto riiRegEx = std::regex(PropertyKeyPathToPropertyRegEx(refRelDataPath));
//workaround until T24729 is done. You can use directly source->GetPropertyKeys again, when fixed.
const auto keys = GetPropertyKeys(source);
//end workaround for T24729
for (const auto &key : keys)
{
if (key.find(prefix) == 0)
{ //its a relevant DICOM property delete or update
if (refIndex.first != deletedImageRefSequenceIndex)
{
//reindex to close the gap in the dicom sequence.
auto newPath = PropertyNameToPropertyKeyPath(key);
newPath.GetNode(2).selection = refIndex.first - 1;
source->SetProperty(PropertyKeyPathToPropertyName(newPath), source->GetNonConstProperty(key));
}
//remove old/outdated data layer information
source->RemoveProperty(key);
}
if (std::regex_match(key, riiRegEx))
{ //it is a relevant RII property, remove it or update it.
auto imageSequenceItemProp = source->GetConstProperty(key);
if (imageSequenceItemProp->GetValueAsString() == deletedImageRefSequenceIndexStr)
{
source->RemoveProperty(key);
}
else if (imageSequenceItemProp->GetValueAsString() == std::to_string(refIndex.first))
{
//its a relevant data property of the relation rule reindex it.
source->SetProperty(key, StringProperty::New(std::to_string(refIndex.first - 1)));
}
}
}
}
}
}
};
itk::LightObject::Pointer mitk::SourceImageRelationRule::InternalClone() const
{
itk::LightObject::Pointer result = Self::New(this->m_PurposeTag, this->m_DisplayName, this->m_SourceRole, this->m_DestinationRole).GetPointer();
return result;
};
diff --git a/Modules/Core/src/IO/mitkIOUtil.cpp b/Modules/Core/src/IO/mitkIOUtil.cpp
index 13be752926..0c4f21a46c 100644
--- a/Modules/Core/src/IO/mitkIOUtil.cpp
+++ b/Modules/Core/src/IO/mitkIOUtil.cpp
@@ -1,1027 +1,1027 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkIOUtil.h"
#include <mitkCoreObjectFactory.h>
#include <mitkCoreServices.h>
#include <mitkExceptionMacro.h>
#include <mitkFileReaderRegistry.h>
#include <mitkFileWriterRegistry.h>
#include <mitkIMimeTypeProvider.h>
#include <mitkProgressBar.h>
#include <mitkStandaloneDataStorage.h>
#include <usGetModuleContext.h>
#include <usLDAPProp.h>
#include <usModuleContext.h>
#include <usModuleResource.h>
#include <usModuleResourceStream.h>
#include <mitkAbstractFileReader.h>
// ITK
#include <itksys/SystemTools.hxx>
// VTK
#include <vtkPolyData.h>
#include <vtkSmartPointer.h>
#include <vtkTriangleFilter.h>
#include <cerrno>
#include <cstdlib>
static std::string GetLastErrorStr()
{
#ifdef US_PLATFORM_POSIX
return std::string(strerror(errno));
#else
// Retrieve the system error message for the last-error code
LPVOID lpMsgBuf;
DWORD dw = GetLastError();
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
nullptr,
dw,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR)&lpMsgBuf,
0,
nullptr);
std::string errMsg((LPCTSTR)lpMsgBuf);
LocalFree(lpMsgBuf);
return errMsg;
#endif
}
#ifdef US_PLATFORM_WINDOWS
#include <direct.h>
#include <io.h>
// make the posix flags point to the obsolte bsd types on windows
#define S_IRUSR S_IREAD
#define S_IWUSR S_IWRITE
#else
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#endif
#include <fcntl.h>
#include <sys/stat.h>
static const char validLetters[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
// A cross-platform version of the mkstemps function
static int mkstemps_compat(char *tmpl, int suffixlen)
{
static unsigned long long value = 0;
int savedErrno = errno;
// Lower bound on the number of temporary files to attempt to generate.
#define ATTEMPTS_MIN (62 * 62 * 62)
/* The number of times to attempt to generate a temporary file. To
conform to POSIX, this must be no smaller than TMP_MAX. */
#if ATTEMPTS_MIN < TMP_MAX
const unsigned int attempts = TMP_MAX;
#else
const unsigned int attempts = ATTEMPTS_MIN;
#endif
const int len = strlen(tmpl);
if ((len - suffixlen) < 6 || strncmp(&tmpl[len - 6 - suffixlen], "XXXXXX", 6))
{
errno = EINVAL;
return -1;
}
/* This is where the Xs start. */
char *XXXXXX = &tmpl[len - 6 - suffixlen];
/* Get some more or less random data. */
#ifdef US_PLATFORM_WINDOWS
{
SYSTEMTIME stNow;
FILETIME ftNow;
// get system time
GetSystemTime(&stNow);
stNow.wMilliseconds = 500;
if (!SystemTimeToFileTime(&stNow, &ftNow))
{
errno = -1;
return -1;
}
unsigned long long randomTimeBits = ((static_cast<unsigned long long>(ftNow.dwHighDateTime) << 32) |
static_cast<unsigned long long>(ftNow.dwLowDateTime));
value = randomTimeBits ^ static_cast<unsigned long long>(GetCurrentThreadId());
}
#else
{
struct timeval tv;
gettimeofday(&tv, nullptr);
unsigned long long randomTimeBits =
((static_cast<unsigned long long>(tv.tv_usec) << 32) | static_cast<unsigned long long>(tv.tv_sec));
value = randomTimeBits ^ static_cast<unsigned long long>(getpid());
}
#endif
for (unsigned int count = 0; count < attempts; value += 7777, ++count)
{
unsigned long long v = value;
/* Fill in the random bits. */
XXXXXX[0] = validLetters[v % 62];
v /= 62;
XXXXXX[1] = validLetters[v % 62];
v /= 62;
XXXXXX[2] = validLetters[v % 62];
v /= 62;
XXXXXX[3] = validLetters[v % 62];
v /= 62;
XXXXXX[4] = validLetters[v % 62];
v /= 62;
XXXXXX[5] = validLetters[v % 62];
int fd = open(tmpl, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
if (fd >= 0)
{
errno = savedErrno;
return fd;
}
else if (errno != EEXIST)
{
return -1;
}
}
/* We got out of the loop because we ran out of combinations to try. */
errno = EEXIST;
return -1;
}
// A cross-platform version of the POSIX mkdtemp function
static char *mkdtemps_compat(char *tmpl, int suffixlen)
{
static unsigned long long value = 0;
int savedErrno = errno;
// Lower bound on the number of temporary dirs to attempt to generate.
#define ATTEMPTS_MIN (62 * 62 * 62)
/* The number of times to attempt to generate a temporary dir. To
conform to POSIX, this must be no smaller than TMP_MAX. */
#if ATTEMPTS_MIN < TMP_MAX
const unsigned int attempts = TMP_MAX;
#else
const unsigned int attempts = ATTEMPTS_MIN;
#endif
const int len = strlen(tmpl);
if ((len - suffixlen) < 6 || strncmp(&tmpl[len - 6 - suffixlen], "XXXXXX", 6))
{
errno = EINVAL;
return nullptr;
}
/* This is where the Xs start. */
char *XXXXXX = &tmpl[len - 6 - suffixlen];
/* Get some more or less random data. */
#ifdef US_PLATFORM_WINDOWS
{
SYSTEMTIME stNow;
FILETIME ftNow;
// get system time
GetSystemTime(&stNow);
stNow.wMilliseconds = 500;
if (!SystemTimeToFileTime(&stNow, &ftNow))
{
errno = -1;
return nullptr;
}
unsigned long long randomTimeBits = ((static_cast<unsigned long long>(ftNow.dwHighDateTime) << 32) |
static_cast<unsigned long long>(ftNow.dwLowDateTime));
value = randomTimeBits ^ static_cast<unsigned long long>(GetCurrentThreadId());
}
#else
{
struct timeval tv;
gettimeofday(&tv, nullptr);
unsigned long long randomTimeBits =
((static_cast<unsigned long long>(tv.tv_usec) << 32) | static_cast<unsigned long long>(tv.tv_sec));
value = randomTimeBits ^ static_cast<unsigned long long>(getpid());
}
#endif
unsigned int count = 0;
for (; count < attempts; value += 7777, ++count)
{
unsigned long long v = value;
/* Fill in the random bits. */
XXXXXX[0] = validLetters[v % 62];
v /= 62;
XXXXXX[1] = validLetters[v % 62];
v /= 62;
XXXXXX[2] = validLetters[v % 62];
v /= 62;
XXXXXX[3] = validLetters[v % 62];
v /= 62;
XXXXXX[4] = validLetters[v % 62];
v /= 62;
XXXXXX[5] = validLetters[v % 62];
#ifdef US_PLATFORM_WINDOWS
int fd = _mkdir(tmpl); //, _S_IREAD | _S_IWRITE | _S_IEXEC);
#else
int fd = mkdir(tmpl, S_IRUSR | S_IWUSR | S_IXUSR);
#endif
if (fd >= 0)
{
errno = savedErrno;
return tmpl;
}
else if (errno != EEXIST)
{
return nullptr;
}
}
/* We got out of the loop because we ran out of combinations to try. */
errno = EEXIST;
return nullptr;
}
//#endif
//**************************************************************
// mitk::IOUtil method definitions
namespace mitk
{
struct IOUtil::Impl
{
struct FixedReaderOptionsFunctor : public ReaderOptionsFunctorBase
{
FixedReaderOptionsFunctor(const IFileReader::Options &options) : m_Options(options) {}
bool operator()(LoadInfo &loadInfo) const override
{
IFileReader *reader = loadInfo.m_ReaderSelector.GetSelected().GetReader();
if (reader)
{
reader->SetOptions(m_Options);
}
return false;
}
private:
const IFileReader::Options &m_Options;
};
struct FixedWriterOptionsFunctor : public WriterOptionsFunctorBase
{
FixedWriterOptionsFunctor(const IFileReader::Options &options) : m_Options(options) {}
bool operator()(SaveInfo &saveInfo) const override
{
IFileWriter *writer = saveInfo.m_WriterSelector.GetSelected().GetWriter();
if (writer)
{
writer->SetOptions(m_Options);
}
return false;
}
private:
const IFileWriter::Options &m_Options;
};
static BaseData::Pointer LoadBaseDataFromFile(const std::string &path, const ReaderOptionsFunctorBase* optionsCallback = nullptr);
static void SetDefaultDataNodeProperties(mitk::DataNode *node, const std::string &filePath = std::string());
};
BaseData::Pointer IOUtil::Impl::LoadBaseDataFromFile(const std::string &path,
const ReaderOptionsFunctorBase *optionsCallback)
{
std::vector<BaseData::Pointer> baseDataList = Load(path, optionsCallback);
// The Load(path) call above should throw an exception if nothing could be loaded
assert(!baseDataList.empty());
return baseDataList.front();
}
#ifdef US_PLATFORM_WINDOWS
std::string IOUtil::GetProgramPath()
{
char path[512];
std::size_t index = std::string(path, GetModuleFileName(nullptr, path, 512)).find_last_of('\\');
return std::string(path, index);
}
#elif defined(US_PLATFORM_APPLE)
#include <mach-o/dyld.h>
std::string IOUtil::GetProgramPath()
{
char path[512];
uint32_t size = sizeof(path);
if (_NSGetExecutablePath(path, &size) == 0)
{
std::size_t index = std::string(path).find_last_of('/');
std::string strPath = std::string(path, index);
// const char* execPath = strPath.c_str();
// mitk::StandardFileLocations::GetInstance()->AddDirectoryForSearch(execPath,false);
return strPath;
}
return std::string();
}
#else
#include <sstream>
#include <sys/types.h>
#include <unistd.h>
std::string IOUtil::GetProgramPath()
{
std::stringstream ss;
ss << "/proc/" << getpid() << "/exe";
char proc[512] = {0};
ssize_t ch = readlink(ss.str().c_str(), proc, 512);
if (ch == -1)
return std::string();
std::size_t index = std::string(proc).find_last_of('/');
return std::string(proc, index);
}
#endif
char IOUtil::GetDirectorySeparator()
{
#ifdef US_PLATFORM_WINDOWS
return '\\';
#else
return '/';
#endif
}
std::string IOUtil::GetTempPath()
{
static std::string result;
if (result.empty())
{
#ifdef US_PLATFORM_WINDOWS
char tempPathTestBuffer[1];
DWORD bufferLength = ::GetTempPath(1, tempPathTestBuffer);
if (bufferLength == 0)
{
mitkThrow() << GetLastErrorStr();
}
std::vector<char> tempPath(bufferLength);
bufferLength = ::GetTempPath(bufferLength, &tempPath[0]);
if (bufferLength == 0)
{
mitkThrow() << GetLastErrorStr();
}
result.assign(tempPath.begin(), tempPath.begin() + static_cast<std::size_t>(bufferLength));
#else
result = "/tmp/";
#endif
}
return result;
}
std::string IOUtil::CreateTemporaryFile(const std::string &templateName, std::string path)
{
std::ofstream tmpOutputStream;
std::string returnValue = CreateTemporaryFile(tmpOutputStream, templateName, path);
tmpOutputStream.close();
return returnValue;
}
std::string IOUtil::CreateTemporaryFile(std::ofstream &f, const std::string &templateName, std::string path)
{
return CreateTemporaryFile(f, std::ios_base::out | std::ios_base::trunc, templateName, path);
}
std::string IOUtil::CreateTemporaryFile(std::ofstream &f,
std::ios_base::openmode mode,
const std::string &templateName,
std::string path)
{
if (path.empty())
{
path = GetTempPath();
}
path += templateName;
std::vector<char> dst_path(path.begin(), path.end());
dst_path.push_back('\0');
std::size_t lastX = path.find_last_of('X');
std::size_t firstX = path.find_last_not_of('X', lastX);
int firstNonX = firstX == std::string::npos ? -1 : firstX - 1;
while (lastX != std::string::npos && (lastX - firstNonX) < 6)
{
lastX = path.find_last_of('X', firstX);
firstX = path.find_last_not_of('X', lastX);
firstNonX = firstX == std::string::npos ? -1 : firstX - 1;
}
std::size_t suffixlen = lastX == std::string::npos ? path.size() : path.size() - lastX - 1;
int fd = mkstemps_compat(&dst_path[0], suffixlen);
if (fd != -1)
{
path.assign(dst_path.begin(), dst_path.end() - 1);
f.open(path.c_str(), mode | std::ios_base::out | std::ios_base::trunc);
close(fd);
}
else
{
mitkThrow() << "Creating temporary file " << &dst_path[0] << " failed: " << GetLastErrorStr();
}
return path;
}
std::string IOUtil::CreateTemporaryDirectory(const std::string &templateName, std::string path)
{
if (path.empty())
{
path = GetTempPath();
}
path += GetDirectorySeparator() + templateName;
std::vector<char> dst_path(path.begin(), path.end());
dst_path.push_back('\0');
std::size_t lastX = path.find_last_of('X');
std::size_t firstX = path.find_last_not_of('X', lastX);
int firstNonX = firstX == std::string::npos ? -1 : firstX - 1;
while (lastX != std::string::npos && (lastX - firstNonX) < 6)
{
lastX = path.find_last_of('X', firstX);
firstX = path.find_last_not_of('X', lastX);
firstNonX = firstX == std::string::npos ? -1 : firstX - 1;
}
std::size_t suffixlen = lastX == std::string::npos ? path.size() : path.size() - lastX - 1;
if (mkdtemps_compat(&dst_path[0], suffixlen) == nullptr)
{
mitkThrow() << "Creating temporary directory " << &dst_path[0] << " failed: " << GetLastErrorStr();
}
path.assign(dst_path.begin(), dst_path.end() - 1);
return path;
}
DataStorage::SetOfObjects::Pointer IOUtil::Load(const std::string &path, DataStorage &storage, const ReaderOptionsFunctorBase *optionsCallback)
{
std::vector<std::string> paths;
paths.push_back(path);
return Load(paths, storage, optionsCallback);
}
DataStorage::SetOfObjects::Pointer IOUtil::Load(const std::string &path,
const IFileReader::Options &options,
DataStorage &storage)
{
std::vector<LoadInfo> loadInfos;
loadInfos.push_back(LoadInfo(path));
DataStorage::SetOfObjects::Pointer nodeResult = DataStorage::SetOfObjects::New();
Impl::FixedReaderOptionsFunctor optionsCallback(options);
std::string errMsg = Load(loadInfos, nodeResult, &storage, &optionsCallback);
if (!errMsg.empty())
{
mitkThrow() << errMsg;
}
return nodeResult;
}
std::vector<BaseData::Pointer> IOUtil::Load(const std::string &path, const ReaderOptionsFunctorBase *optionsCallback)
{
std::vector<std::string> paths;
paths.push_back(path);
return Load(paths, optionsCallback);
}
std::vector<BaseData::Pointer> IOUtil::Load(const std::string &path, const IFileReader::Options &options)
{
std::vector<LoadInfo> loadInfos;
loadInfos.push_back(LoadInfo(path));
Impl::FixedReaderOptionsFunctor optionsCallback(options);
std::string errMsg = Load(loadInfos, nullptr, nullptr, &optionsCallback);
if (!errMsg.empty())
{
mitkThrow() << errMsg;
}
return loadInfos.front().m_Output;
}
DataStorage::SetOfObjects::Pointer IOUtil::Load(const std::vector<std::string> &paths, DataStorage &storage, const ReaderOptionsFunctorBase *optionsCallback)
{
DataStorage::SetOfObjects::Pointer nodeResult = DataStorage::SetOfObjects::New();
std::vector<LoadInfo> loadInfos;
- for (auto loadInfo : paths)
+ for (const auto &loadInfo : paths)
{
loadInfos.push_back(loadInfo);
}
std::string errMsg = Load(loadInfos, nodeResult, &storage, optionsCallback);
if (!errMsg.empty())
{
mitkThrow() << errMsg;
}
return nodeResult;
}
std::vector<BaseData::Pointer> IOUtil::Load(const std::vector<std::string> &paths, const ReaderOptionsFunctorBase *optionsCallback)
{
std::vector<BaseData::Pointer> result;
std::vector<LoadInfo> loadInfos;
- for (auto loadInfo : paths)
+ for (const auto &loadInfo : paths)
{
loadInfos.push_back(loadInfo);
}
std::string errMsg = Load(loadInfos, nullptr, nullptr, optionsCallback);
if (!errMsg.empty())
{
mitkThrow() << errMsg;
}
for (std::vector<LoadInfo>::const_iterator iter = loadInfos.begin(), iterEnd = loadInfos.end(); iter != iterEnd;
++iter)
{
result.insert(result.end(), iter->m_Output.begin(), iter->m_Output.end());
}
return result;
}
std::string IOUtil::Load(std::vector<LoadInfo> &loadInfos,
DataStorage::SetOfObjects *nodeResult,
DataStorage *ds,
const ReaderOptionsFunctorBase *optionsCallback)
{
if (loadInfos.empty())
{
return "No input files given";
}
int filesToRead = loadInfos.size();
mitk::ProgressBar::GetInstance()->AddStepsToDo(2 * filesToRead);
std::string errMsg;
std::map<std::string, FileReaderSelector::Item> usedReaderItems;
std::vector< std::string > read_files;
for (auto &loadInfo : loadInfos)
{
if(std::find(read_files.begin(), read_files.end(), loadInfo.m_Path) != read_files.end())
continue;
std::vector<FileReaderSelector::Item> readers = loadInfo.m_ReaderSelector.Get();
if (readers.empty())
{
if (!itksys::SystemTools::FileExists(loadInfo.m_Path.c_str()))
{
errMsg += "File '" + loadInfo.m_Path + "' does not exist\n";
}
else
{
errMsg += "No reader available for '" + loadInfo.m_Path + "'\n";
}
continue;
}
bool callOptionsCallback = readers.size() > 1 || !readers.front().GetReader()->GetOptions().empty();
// check if we already used a reader which should be re-used
std::vector<MimeType> currMimeTypes = loadInfo.m_ReaderSelector.GetMimeTypes();
std::string selectedMimeType;
for (std::vector<MimeType>::const_iterator mimeTypeIter = currMimeTypes.begin(),
mimeTypeIterEnd = currMimeTypes.end();
mimeTypeIter != mimeTypeIterEnd;
++mimeTypeIter)
{
std::map<std::string, FileReaderSelector::Item>::const_iterator oldSelectedItemIter =
usedReaderItems.find(mimeTypeIter->GetName());
if (oldSelectedItemIter != usedReaderItems.end())
{
// we found an already used item for a mime-type which is contained
// in the current reader set, check all current readers if there service
// id equals the old reader
for (std::vector<FileReaderSelector::Item>::const_iterator currReaderItem = readers.begin(),
currReaderItemEnd = readers.end();
currReaderItem != currReaderItemEnd;
++currReaderItem)
{
if (currReaderItem->GetMimeType().GetName() == mimeTypeIter->GetName() &&
currReaderItem->GetServiceId() == oldSelectedItemIter->second.GetServiceId() &&
currReaderItem->GetConfidenceLevel() >= oldSelectedItemIter->second.GetConfidenceLevel())
{
// okay, we used the same reader already, re-use its options
selectedMimeType = mimeTypeIter->GetName();
callOptionsCallback = false;
loadInfo.m_ReaderSelector.Select(oldSelectedItemIter->second.GetServiceId());
loadInfo.m_ReaderSelector.GetSelected().GetReader()->SetOptions(
oldSelectedItemIter->second.GetReader()->GetOptions());
break;
}
}
if (!selectedMimeType.empty())
break;
}
}
if (callOptionsCallback && optionsCallback)
{
callOptionsCallback = (*optionsCallback)(loadInfo);
if (!callOptionsCallback && !loadInfo.m_Cancel)
{
usedReaderItems.erase(selectedMimeType);
FileReaderSelector::Item selectedItem = loadInfo.m_ReaderSelector.GetSelected();
usedReaderItems.insert(std::make_pair(selectedItem.GetMimeType().GetName(), selectedItem));
}
}
if (loadInfo.m_Cancel)
{
errMsg += "Reading operation(s) cancelled.";
break;
}
IFileReader *reader = loadInfo.m_ReaderSelector.GetSelected().GetReader();
if (reader == nullptr)
{
errMsg += "Unexpected nullptr reader.";
break;
}
// Do the actual reading
try
{
DataStorage::SetOfObjects::Pointer nodes;
if (ds != nullptr)
{
nodes = reader->Read(*ds);
std::vector< std::string > new_files = reader->GetReadFiles();
read_files.insert( read_files.end(), new_files.begin(), new_files.end() );
}
else
{
nodes = DataStorage::SetOfObjects::New();
std::vector<mitk::BaseData::Pointer> baseData = reader->Read();
for (auto iter = baseData.begin(); iter != baseData.end(); ++iter)
{
if (iter->IsNotNull())
{
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(*iter);
nodes->InsertElement(nodes->Size(), node);
}
}
std::vector< std::string > new_files = reader->GetReadFiles();
read_files.insert( read_files.end(), new_files.begin(), new_files.end() );
}
for (DataStorage::SetOfObjects::ConstIterator nodeIter = nodes->Begin(), nodeIterEnd = nodes->End();
nodeIter != nodeIterEnd;
++nodeIter)
{
const mitk::DataNode::Pointer &node = nodeIter->Value();
mitk::BaseData::Pointer data = node->GetData();
if (data.IsNull())
{
continue;
}
mitk::StringProperty::Pointer pathProp = mitk::StringProperty::New(loadInfo.m_Path);
data->SetProperty("path", pathProp);
loadInfo.m_Output.push_back(data);
if (nodeResult)
{
nodeResult->push_back(nodeIter->Value());
}
}
if (loadInfo.m_Output.empty() || (nodeResult && nodeResult->Size() == 0))
{
errMsg += "Unknown read error occurred reading " + loadInfo.m_Path;
}
}
catch (const std::exception &e)
{
errMsg += "Exception occured when reading file " + loadInfo.m_Path + ":\n" + e.what() + "\n\n";
}
mitk::ProgressBar::GetInstance()->Progress(2);
--filesToRead;
}
if (!errMsg.empty())
{
MITK_ERROR << errMsg;
}
mitk::ProgressBar::GetInstance()->Progress(2 * filesToRead);
return errMsg;
}
std::vector<BaseData::Pointer> IOUtil::Load(const us::ModuleResource &usResource, std::ios_base::openmode mode)
{
us::ModuleResourceStream resStream(usResource, mode);
mitk::CoreServicePointer<mitk::IMimeTypeProvider> mimeTypeProvider(mitk::CoreServices::GetMimeTypeProvider());
std::vector<MimeType> mimetypes = mimeTypeProvider->GetMimeTypesForFile(usResource.GetResourcePath());
std::vector<mitk::BaseData::Pointer> data;
if (mimetypes.empty())
{
mitkThrow() << "No mimetype for resource stream: " << usResource.GetResourcePath();
return data;
}
mitk::FileReaderRegistry fileReaderRegistry;
std::vector<us::ServiceReference<IFileReader>> refs = fileReaderRegistry.GetReferences(mimetypes[0]);
if (refs.empty())
{
mitkThrow() << "No reader available for resource stream: " << usResource.GetResourcePath();
return data;
}
mitk::IFileReader *reader = fileReaderRegistry.GetReader(refs[0]);
reader->SetInput(usResource.GetResourcePath(), &resStream);
data = reader->Read();
return data;
}
void IOUtil::Save(const BaseData *data, const std::string &path, bool setPathProperty) { Save(data, path, IFileWriter::Options(), setPathProperty); }
void IOUtil::Save(const BaseData *data, const std::string &path, const IFileWriter::Options &options, bool setPathProperty)
{
Save(data, std::string(), path, options, setPathProperty);
}
void IOUtil::Save(const BaseData *data, const std::string &mimeType, const std::string &path, bool addExtension, bool setPathProperty)
{
Save(data, mimeType, path, IFileWriter::Options(), addExtension, setPathProperty);
}
void IOUtil::Save(const BaseData *data,
const std::string &mimeType,
const std::string &path,
const IFileWriter::Options &options,
bool addExtension,
bool setPathProperty)
{
if ((data == nullptr) || (data->IsEmpty()))
mitkThrow() << "BaseData cannotbe null or empty for save methods in IOUtil.h.";
std::string errMsg;
if (options.empty())
{
errMsg = Save(data, mimeType, path, nullptr, addExtension, setPathProperty);
}
else
{
Impl::FixedWriterOptionsFunctor optionsCallback(options);
errMsg = Save(data, mimeType, path, &optionsCallback, addExtension, setPathProperty);
}
if (!errMsg.empty())
{
mitkThrow() << errMsg;
}
}
void IOUtil::Save(std::vector<IOUtil::SaveInfo> &saveInfos, bool setPathProperty)
{
std::string errMsg = Save(saveInfos, nullptr, setPathProperty);
if (!errMsg.empty())
{
mitkThrow() << errMsg;
}
}
std::string IOUtil::Save(const BaseData *data,
const std::string &mimeTypeName,
const std::string &path,
WriterOptionsFunctorBase *optionsCallback,
bool addExtension,
bool setPathProperty)
{
if (path.empty())
{
return "No output filename given";
}
mitk::CoreServicePointer<mitk::IMimeTypeProvider> mimeTypeProvider(mitk::CoreServices::GetMimeTypeProvider());
MimeType mimeType = mimeTypeProvider->GetMimeTypeForName(mimeTypeName);
SaveInfo saveInfo(data, mimeType, path);
std::string ext = itksys::SystemTools::GetFilenameExtension(path);
if (saveInfo.m_WriterSelector.IsEmpty())
{
return std::string("No suitable writer found for the current data of type ") + data->GetNameOfClass() +
(mimeType.IsValid() ? (std::string(" and mime-type ") + mimeType.GetName()) : std::string()) +
(ext.empty() ? std::string() : (std::string(" with extension ") + ext));
}
// Add an extension if not already specified
if (ext.empty() && addExtension)
{
saveInfo.m_MimeType.GetExtensions().empty() ? std::string() : "." + saveInfo.m_MimeType.GetExtensions().front();
}
std::vector<SaveInfo> infos;
infos.push_back(saveInfo);
return Save(infos, optionsCallback, setPathProperty);
}
std::string IOUtil::Save(std::vector<SaveInfo> &saveInfos, WriterOptionsFunctorBase *optionsCallback, bool setPathProperty)
{
if (saveInfos.empty())
{
return "No data for saving available";
}
int filesToWrite = saveInfos.size();
mitk::ProgressBar::GetInstance()->AddStepsToDo(2 * filesToWrite);
std::string errMsg;
std::set<SaveInfo> usedSaveInfos;
for (auto &saveInfo : saveInfos)
{
const std::string baseDataType = saveInfo.m_BaseData->GetNameOfClass();
std::vector<FileWriterSelector::Item> writers = saveInfo.m_WriterSelector.Get();
// Error out if no compatible Writer was found
if (writers.empty())
{
errMsg += std::string("No writer available for ") + baseDataType + " data.\n";
continue;
}
bool callOptionsCallback = writers.size() > 1 || !writers[0].GetWriter()->GetOptions().empty();
// check if we already used a writer for this base data type
// which should be re-used
auto oldSaveInfoIter = usedSaveInfos.find(saveInfo);
if (oldSaveInfoIter != usedSaveInfos.end())
{
// we previously saved a base data object of the same data with the same mime-type,
// check if the same writer is contained in the current writer set and if the
// confidence level matches
FileWriterSelector::Item oldSelectedItem =
oldSaveInfoIter->m_WriterSelector.Get(oldSaveInfoIter->m_WriterSelector.GetSelectedId());
for (std::vector<FileWriterSelector::Item>::const_iterator currWriterItem = writers.begin(),
currWriterItemEnd = writers.end();
currWriterItem != currWriterItemEnd;
++currWriterItem)
{
if (currWriterItem->GetServiceId() == oldSelectedItem.GetServiceId() &&
currWriterItem->GetConfidenceLevel() >= oldSelectedItem.GetConfidenceLevel())
{
// okay, we used the same writer already, re-use its options
callOptionsCallback = false;
saveInfo.m_WriterSelector.Select(oldSaveInfoIter->m_WriterSelector.GetSelectedId());
saveInfo.m_WriterSelector.GetSelected().GetWriter()->SetOptions(oldSelectedItem.GetWriter()->GetOptions());
break;
}
}
}
if (callOptionsCallback && optionsCallback)
{
callOptionsCallback = (*optionsCallback)(saveInfo);
if (!callOptionsCallback && !saveInfo.m_Cancel)
{
usedSaveInfos.erase(saveInfo);
usedSaveInfos.insert(saveInfo);
}
}
if (saveInfo.m_Cancel)
{
errMsg += "Writing operation(s) cancelled.";
break;
}
IFileWriter *writer = saveInfo.m_WriterSelector.GetSelected().GetWriter();
if (writer == nullptr)
{
errMsg += "Unexpected nullptr writer.";
break;
}
// Do the actual writing
try
{
writer->SetOutputLocation(saveInfo.m_Path);
writer->Write();
}
catch (const std::exception &e)
{
errMsg += std::string("Exception occurred when writing to ") + saveInfo.m_Path + ":\n" + e.what() + "\n";
}
if (setPathProperty)
saveInfo.m_BaseData->GetPropertyList()->SetStringProperty("path", saveInfo.m_Path.c_str());
mitk::ProgressBar::GetInstance()->Progress(2);
--filesToWrite;
}
if (!errMsg.empty())
{
MITK_ERROR << errMsg;
}
mitk::ProgressBar::GetInstance()->Progress(2 * filesToWrite);
return errMsg;
}
// This method can be removed after the deprecated LoadDataNode() method was removed
void IOUtil::Impl::SetDefaultDataNodeProperties(DataNode *node, const std::string &filePath)
{
// path
mitk::StringProperty::Pointer pathProp = mitk::StringProperty::New(itksys::SystemTools::GetFilenamePath(filePath));
node->SetProperty(StringProperty::PATH, pathProp);
// name already defined?
mitk::StringProperty::Pointer nameProp = dynamic_cast<mitk::StringProperty *>(node->GetProperty("name"));
if (nameProp.IsNull() || nameProp->GetValue() == DataNode::NO_NAME_VALUE())
{
// name already defined in BaseData
mitk::StringProperty::Pointer baseDataNameProp =
dynamic_cast<mitk::StringProperty *>(node->GetData()->GetProperty("name").GetPointer());
if (baseDataNameProp.IsNull() || baseDataNameProp->GetValue() == DataNode::NO_NAME_VALUE())
{
// name neither defined in node, nor in BaseData -> name = filename
nameProp = mitk::StringProperty::New(itksys::SystemTools::GetFilenameWithoutExtension(filePath));
node->SetProperty("name", nameProp);
}
else
{
// name defined in BaseData!
nameProp = mitk::StringProperty::New(baseDataNameProp->GetValue());
node->SetProperty("name", nameProp);
}
}
// visibility
if (!node->GetProperty("visible"))
{
node->SetVisibility(true);
}
}
IOUtil::SaveInfo::SaveInfo(const BaseData *baseData, const MimeType &mimeType, const std::string &path)
: m_BaseData(baseData),
m_WriterSelector(baseData, mimeType.GetName(), path),
m_MimeType(mimeType.IsValid() ? mimeType // use the original mime-type
:
(m_WriterSelector.IsEmpty() ?
mimeType // no writer found, use the original invalid mime-type
:
m_WriterSelector.GetDefault().GetMimeType() // use the found default mime-type
)),
m_Path(path),
m_Cancel(false)
{
}
bool IOUtil::SaveInfo::operator<(const IOUtil::SaveInfo &other) const
{
int r = strcmp(m_BaseData->GetNameOfClass(), other.m_BaseData->GetNameOfClass());
if (r == 0)
{
return m_WriterSelector.GetSelected().GetMimeType() < other.m_WriterSelector.GetSelected().GetMimeType();
}
return r < 0;
}
IOUtil::LoadInfo::LoadInfo(const std::string &path) : m_Path(path), m_ReaderSelector(path), m_Cancel(false) {}
}
diff --git a/Modules/Core/src/IO/mitkItkImageIO.cpp b/Modules/Core/src/IO/mitkItkImageIO.cpp
index 55a4b86dc9..13297e122a 100644
--- a/Modules/Core/src/IO/mitkItkImageIO.cpp
+++ b/Modules/Core/src/IO/mitkItkImageIO.cpp
@@ -1,724 +1,736 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkItkImageIO.h"
#include <mitkArbitraryTimeGeometry.h>
#include <mitkCoreServices.h>
#include <mitkCustomMimeType.h>
#include <mitkIOMimeTypes.h>
#include <mitkIPropertyPersistence.h>
#include <mitkImage.h>
#include <mitkImageReadAccessor.h>
#include <mitkLocaleSwitch.h>
#include <mitkUIDManipulator.h>
#include <itkImage.h>
#include <itkImageFileReader.h>
#include <itkImageIOFactory.h>
#include <itkImageIORegion.h>
#include <itkMetaDataObject.h>
#include <algorithm>
namespace mitk
{
const char *const PROPERTY_NAME_TIMEGEOMETRY_TYPE = "org.mitk.timegeometry.type";
const char *const PROPERTY_NAME_TIMEGEOMETRY_TIMEPOINTS = "org.mitk.timegeometry.timepoints";
const char *const PROPERTY_KEY_TIMEGEOMETRY_TYPE = "org_mitk_timegeometry_type";
const char *const PROPERTY_KEY_TIMEGEOMETRY_TIMEPOINTS = "org_mitk_timegeometry_timepoints";
const char* const PROPERTY_KEY_UID = "org_mitk_uid";
ItkImageIO::ItkImageIO(const ItkImageIO &other)
: AbstractFileIO(other), m_ImageIO(dynamic_cast<itk::ImageIOBase *>(other.m_ImageIO->Clone().GetPointer()))
{
this->InitializeDefaultMetaDataKeys();
}
std::vector<std::string> ItkImageIO::FixUpImageIOExtensions(const std::string &imageIOName)
{
std::vector<std::string> extensions;
// Try to fix-up some known ITK image IO classes
if (imageIOName == "GiplImageIO")
{
extensions.push_back("gipl");
extensions.push_back("gipl.gz");
}
else if (imageIOName == "GDCMImageIO")
{
extensions.push_back("gdcm");
extensions.push_back("dcm");
extensions.push_back("DCM");
extensions.push_back("dc3");
extensions.push_back("DC3");
extensions.push_back("ima");
extensions.push_back("img");
}
else if (imageIOName == "PNGImageIO")
{
extensions.push_back("png");
extensions.push_back("PNG");
}
else if (imageIOName == "StimulateImageIO")
{
extensions.push_back("spr");
}
else if (imageIOName == "HDF5ImageIO")
{
extensions.push_back("hdf");
extensions.push_back("h4");
extensions.push_back("hdf4");
extensions.push_back("h5");
extensions.push_back("hdf5");
extensions.push_back("he4");
extensions.push_back("he5");
extensions.push_back("hd5");
}
else if ("GE4ImageIO" == imageIOName || "GE5ImageIO" == imageIOName || "Bruker2dseqImageIO" == imageIOName)
{
extensions.push_back("");
}
if (!extensions.empty())
{
MITK_DEBUG << "Fixing up known extensions for " << imageIOName;
}
return extensions;
}
void ItkImageIO::FixUpCustomMimeTypeName(const std::string &imageIOName, CustomMimeType &customMimeType)
{
if ("GE4ImageIO" == imageIOName)
{
customMimeType.SetName(this->AbstractFileReader::GetMimeTypePrefix() + "ge4");
}
else if ("GE5ImageIO" == imageIOName)
{
customMimeType.SetName(this->AbstractFileReader::GetMimeTypePrefix() + "ge5");
}
else if ("Bruker2dseqImageIO" == imageIOName)
{
customMimeType.SetName(this->AbstractFileReader::GetMimeTypePrefix() + "bruker2dseq");
}
}
ItkImageIO::ItkImageIO(itk::ImageIOBase::Pointer imageIO)
: AbstractFileIO(Image::GetStaticNameOfClass()), m_ImageIO(imageIO)
{
if (m_ImageIO.IsNull())
{
mitkThrow() << "ITK ImageIOBase argument must not be nullptr";
}
this->AbstractFileReader::SetMimeTypePrefix(IOMimeTypes::DEFAULT_BASE_NAME() + ".image.");
this->InitializeDefaultMetaDataKeys();
std::vector<std::string> readExtensions = m_ImageIO->GetSupportedReadExtensions();
if (readExtensions.empty())
{
std::string imageIOName = m_ImageIO->GetNameOfClass();
MITK_DEBUG << "ITK ImageIOBase " << imageIOName << " does not provide read extensions";
readExtensions = FixUpImageIOExtensions(imageIOName);
}
CustomMimeType customReaderMimeType;
customReaderMimeType.SetCategory("Images");
for (std::vector<std::string>::const_iterator iter = readExtensions.begin(), endIter = readExtensions.end();
iter != endIter;
++iter)
{
std::string extension = *iter;
if (!extension.empty() && extension[0] == '.')
{
extension.assign(iter->begin() + 1, iter->end());
}
customReaderMimeType.AddExtension(extension);
}
auto extensions = customReaderMimeType.GetExtensions();
if (extensions.empty() || (extensions.size() == 1 && extensions[0].empty()))
{
std::string imageIOName = m_ImageIO->GetNameOfClass();
FixUpCustomMimeTypeName(imageIOName, customReaderMimeType);
}
this->AbstractFileReader::SetMimeType(customReaderMimeType);
std::vector<std::string> writeExtensions = imageIO->GetSupportedWriteExtensions();
if (writeExtensions.empty())
{
std::string imageIOName = imageIO->GetNameOfClass();
MITK_DEBUG << "ITK ImageIOBase " << imageIOName << " does not provide write extensions";
writeExtensions = FixUpImageIOExtensions(imageIOName);
}
if (writeExtensions != readExtensions)
{
CustomMimeType customWriterMimeType;
customWriterMimeType.SetCategory("Images");
for (std::vector<std::string>::const_iterator iter = writeExtensions.begin(), endIter = writeExtensions.end();
iter != endIter;
++iter)
{
std::string extension = *iter;
if (!extension.empty() && extension[0] == '.')
{
extension.assign(iter->begin() + 1, iter->end());
}
customWriterMimeType.AddExtension(extension);
}
auto extensions = customWriterMimeType.GetExtensions();
if (extensions.empty() || (extensions.size() == 1 && extensions[0].empty()))
{
std::string imageIOName = m_ImageIO->GetNameOfClass();
FixUpCustomMimeTypeName(imageIOName, customWriterMimeType);
}
this->AbstractFileWriter::SetMimeType(customWriterMimeType);
}
std::string description = std::string("ITK ") + imageIO->GetNameOfClass();
this->SetReaderDescription(description);
this->SetWriterDescription(description);
this->RegisterService();
}
ItkImageIO::ItkImageIO(const CustomMimeType &mimeType, itk::ImageIOBase::Pointer imageIO, int rank)
: AbstractFileIO(Image::GetStaticNameOfClass(), mimeType, std::string("ITK ") + imageIO->GetNameOfClass()),
m_ImageIO(imageIO)
{
if (m_ImageIO.IsNull())
{
mitkThrow() << "ITK ImageIOBase argument must not be nullptr";
}
this->AbstractFileReader::SetMimeTypePrefix(IOMimeTypes::DEFAULT_BASE_NAME() + ".image.");
this->InitializeDefaultMetaDataKeys();
if (rank)
{
this->AbstractFileReader::SetRanking(rank);
this->AbstractFileWriter::SetRanking(rank);
}
this->RegisterService();
}
std::vector<TimePointType> ConvertMetaDataObjectToTimePointList(const itk::MetaDataObjectBase* data)
{
const auto* timeGeometryTimeData =
dynamic_cast<const itk::MetaDataObject<std::string>*>(data);
std::vector<TimePointType> result;
if (timeGeometryTimeData)
{
std::string dataStr = timeGeometryTimeData->GetMetaDataObjectValue();
std::stringstream stream(dataStr);
TimePointType tp;
while (stream >> tp)
{
result.push_back(tp);
}
}
return result;
};
itk::MetaDataObjectBase::Pointer ConvertTimePointListToMetaDataObject(const mitk::TimeGeometry* timeGeometry)
{
std::stringstream stream;
stream << timeGeometry->GetTimeBounds(0)[0];
const auto maxTimePoints = timeGeometry->CountTimeSteps();
for (TimeStepType pos = 0; pos < maxTimePoints; ++pos)
{
stream << " " << timeGeometry->GetTimeBounds(pos)[1];
}
auto result = itk::MetaDataObject<std::string>::New();
result->SetMetaDataObjectValue(stream.str());
return result.GetPointer();
};
std::vector<BaseData::Pointer> ItkImageIO::DoRead()
{
std::vector<BaseData::Pointer> result;
mitk::LocaleSwitch localeSwitch("C");
Image::Pointer image = Image::New();
const unsigned int MINDIM = 2;
const unsigned int MAXDIM = 4;
const std::string path = this->GetLocalFileName();
MITK_INFO << "loading " << path << " via itk::ImageIOFactory... " << std::endl;
// Check to see if we can read the file given the name or prefix
if (path.empty())
{
mitkThrow() << "Empty filename in mitk::ItkImageIO ";
}
// Got to allocate space for the image. Determine the characteristics of
// the image.
m_ImageIO->SetFileName(path);
m_ImageIO->ReadImageInformation();
unsigned int ndim = m_ImageIO->GetNumberOfDimensions();
if (ndim < MINDIM || ndim > MAXDIM)
{
MITK_WARN << "Sorry, only dimensions 2, 3 and 4 are supported. The given file has " << ndim
<< " dimensions! Reading as 4D.";
ndim = MAXDIM;
}
itk::ImageIORegion ioRegion(ndim);
itk::ImageIORegion::SizeType ioSize = ioRegion.GetSize();
itk::ImageIORegion::IndexType ioStart = ioRegion.GetIndex();
unsigned int dimensions[MAXDIM];
dimensions[0] = 0;
dimensions[1] = 0;
dimensions[2] = 0;
dimensions[3] = 0;
ScalarType spacing[MAXDIM];
spacing[0] = 1.0f;
spacing[1] = 1.0f;
spacing[2] = 1.0f;
spacing[3] = 1.0f;
Point3D origin;
origin.Fill(0);
unsigned int i;
for (i = 0; i < ndim; ++i)
{
ioStart[i] = 0;
ioSize[i] = m_ImageIO->GetDimensions(i);
if (i < MAXDIM)
{
dimensions[i] = m_ImageIO->GetDimensions(i);
spacing[i] = m_ImageIO->GetSpacing(i);
if (spacing[i] <= 0)
spacing[i] = 1.0f;
}
if (i < 3)
{
origin[i] = m_ImageIO->GetOrigin(i);
}
}
ioRegion.SetSize(ioSize);
ioRegion.SetIndex(ioStart);
MITK_INFO << "ioRegion: " << ioRegion << std::endl;
m_ImageIO->SetIORegion(ioRegion);
void *buffer = new unsigned char[m_ImageIO->GetImageSizeInBytes()];
m_ImageIO->Read(buffer);
image->Initialize(MakePixelType(m_ImageIO), ndim, dimensions);
image->SetImportChannel(buffer, 0, Image::ManageMemory);
const itk::MetaDataDictionary &dictionary = m_ImageIO->GetMetaDataDictionary();
// access direction of itk::Image and include spacing
mitk::Matrix3D matrix;
matrix.SetIdentity();
unsigned int j, itkDimMax3 = (ndim >= 3 ? 3 : ndim);
for (i = 0; i < itkDimMax3; ++i)
for (j = 0; j < itkDimMax3; ++j)
matrix[i][j] = m_ImageIO->GetDirection(j)[i];
// re-initialize PlaneGeometry with origin and direction
PlaneGeometry *planeGeometry = image->GetSlicedGeometry(0)->GetPlaneGeometry(0);
planeGeometry->SetOrigin(origin);
planeGeometry->GetIndexToWorldTransform()->SetMatrix(matrix);
// re-initialize SlicedGeometry3D
SlicedGeometry3D *slicedGeometry = image->GetSlicedGeometry(0);
slicedGeometry->InitializeEvenlySpaced(planeGeometry, image->GetDimension(2));
slicedGeometry->SetSpacing(spacing);
MITK_INFO << slicedGeometry->GetCornerPoint(false, false, false);
MITK_INFO << slicedGeometry->GetCornerPoint(true, true, true);
// re-initialize TimeGeometry
TimeGeometry::Pointer timeGeometry;
if (dictionary.HasKey(PROPERTY_NAME_TIMEGEOMETRY_TYPE) || dictionary.HasKey(PROPERTY_KEY_TIMEGEOMETRY_TYPE))
{ // also check for the name because of backwards compatibility. Past code version stored with the name and not with
// the key
itk::MetaDataObject<std::string>::ConstPointer timeGeometryTypeData = nullptr;
if (dictionary.HasKey(PROPERTY_NAME_TIMEGEOMETRY_TYPE))
{
timeGeometryTypeData =
dynamic_cast<const itk::MetaDataObject<std::string> *>(dictionary.Get(PROPERTY_NAME_TIMEGEOMETRY_TYPE));
}
else
{
timeGeometryTypeData =
dynamic_cast<const itk::MetaDataObject<std::string> *>(dictionary.Get(PROPERTY_KEY_TIMEGEOMETRY_TYPE));
}
if (timeGeometryTypeData->GetMetaDataObjectValue() == ArbitraryTimeGeometry::GetStaticNameOfClass())
{
MITK_INFO << "used time geometry: " << ArbitraryTimeGeometry::GetStaticNameOfClass();
typedef std::vector<TimePointType> TimePointVector;
TimePointVector timePoints;
if (dictionary.HasKey(PROPERTY_NAME_TIMEGEOMETRY_TIMEPOINTS))
{
timePoints = ConvertMetaDataObjectToTimePointList(dictionary.Get(PROPERTY_NAME_TIMEGEOMETRY_TIMEPOINTS));
}
else if (dictionary.HasKey(PROPERTY_KEY_TIMEGEOMETRY_TIMEPOINTS))
{
timePoints = ConvertMetaDataObjectToTimePointList(dictionary.Get(PROPERTY_KEY_TIMEGEOMETRY_TIMEPOINTS));
}
if (timePoints.empty())
{
MITK_ERROR << "Stored timepoints are empty. Meta information seems to bee invalid. Switch to ProportionalTimeGeometry fallback";
}
else if (timePoints.size() - 1 != image->GetDimension(3))
{
MITK_ERROR << "Stored timepoints (" << timePoints.size() - 1 << ") and size of image time dimension ("
<< image->GetDimension(3) << ") do not match. Switch to ProportionalTimeGeometry fallback";
}
else
{
ArbitraryTimeGeometry::Pointer arbitraryTimeGeometry = ArbitraryTimeGeometry::New();
TimePointVector::const_iterator pos = timePoints.begin();
auto prePos = pos++;
for (; pos != timePoints.end(); ++prePos, ++pos)
{
arbitraryTimeGeometry->AppendNewTimeStepClone(slicedGeometry, *prePos, *pos);
}
timeGeometry = arbitraryTimeGeometry;
}
}
}
if (timeGeometry.IsNull())
{ // Fallback. If no other valid time geometry has been created, create a ProportionalTimeGeometry
MITK_INFO << "used time geometry: " << ProportionalTimeGeometry::GetStaticNameOfClass();
ProportionalTimeGeometry::Pointer propTimeGeometry = ProportionalTimeGeometry::New();
propTimeGeometry->Initialize(slicedGeometry, image->GetDimension(3));
timeGeometry = propTimeGeometry;
}
image->SetTimeGeometry(timeGeometry);
buffer = nullptr;
MITK_INFO << "number of image components: " << image->GetPixelType().GetNumberOfComponents();
for (auto iter = dictionary.Begin(), iterEnd = dictionary.End(); iter != iterEnd;
++iter)
{
if (iter->second->GetMetaDataObjectTypeInfo() == typeid(std::string))
{
const std::string &key = iter->first;
std::string assumedPropertyName = key;
std::replace(assumedPropertyName.begin(), assumedPropertyName.end(), '_', '.');
std::string mimeTypeName = GetMimeType()->GetName();
// Check if there is already a info for the key and our mime type.
mitk::CoreServicePointer<IPropertyPersistence> propPersistenceService(mitk::CoreServices::GetPropertyPersistence());
IPropertyPersistence::InfoResultType infoList = propPersistenceService->GetInfoByKey(key);
auto predicate = [&mimeTypeName](const PropertyPersistenceInfo::ConstPointer &x) {
return x.IsNotNull() && x->GetMimeTypeName() == mimeTypeName;
};
auto finding = std::find_if(infoList.begin(), infoList.end(), predicate);
if (finding == infoList.end())
{
auto predicateWild = [](const PropertyPersistenceInfo::ConstPointer &x) {
return x.IsNotNull() && x->GetMimeTypeName() == PropertyPersistenceInfo::ANY_MIMETYPE_NAME();
};
finding = std::find_if(infoList.begin(), infoList.end(), predicateWild);
}
PropertyPersistenceInfo::ConstPointer info;
if (finding != infoList.end())
{
assumedPropertyName = (*finding)->GetName();
info = *finding;
}
else
{ // we have not found anything suitable so we generate our own info
auto newInfo = PropertyPersistenceInfo::New();
newInfo->SetNameAndKey(assumedPropertyName, key);
newInfo->SetMimeTypeName(PropertyPersistenceInfo::ANY_MIMETYPE_NAME());
info = newInfo;
}
std::string value =
dynamic_cast<itk::MetaDataObject<std::string> *>(iter->second.GetPointer())->GetMetaDataObjectValue();
mitk::BaseProperty::Pointer loadedProp = info->GetDeserializationFunction()(value);
image->SetProperty(assumedPropertyName.c_str(), loadedProp);
// Read properties should be persisted unless they are default properties
// which are written anyway
bool isDefaultKey(false);
for (const auto &defaultKey : m_DefaultMetaDataKeys)
{
if (defaultKey.length() <= assumedPropertyName.length())
{
// does the start match the default key
if (assumedPropertyName.substr(0, defaultKey.length()).find(defaultKey) != std::string::npos)
{
isDefaultKey = true;
break;
}
}
}
if (!isDefaultKey)
{
propPersistenceService->AddInfo(info);
}
}
}
// Handle UID
if (dictionary.HasKey(PROPERTY_KEY_UID))
{
itk::MetaDataObject<std::string>::ConstPointer uidData = dynamic_cast<const itk::MetaDataObject<std::string>*>(dictionary.Get(PROPERTY_KEY_UID));
if (uidData.IsNotNull())
{
mitk::UIDManipulator uidManipulator(image);
uidManipulator.SetUID(uidData->GetMetaDataObjectValue());
}
}
MITK_INFO << "...finished!";
result.push_back(image.GetPointer());
return result;
}
AbstractFileIO::ConfidenceLevel ItkImageIO::GetReaderConfidenceLevel() const
{
return m_ImageIO->CanReadFile(GetLocalFileName().c_str()) ? IFileReader::Supported : IFileReader::Unsupported;
}
void ItkImageIO::Write()
{
const auto *image = dynamic_cast<const mitk::Image *>(this->GetInput());
if (image == nullptr)
{
mitkThrow() << "Cannot write non-image data";
}
// Switch the current locale to "C"
LocaleSwitch localeSwitch("C");
// Clone the image geometry, because we might have to change it
// for writing purposes
BaseGeometry::Pointer geometry = image->GetGeometry()->Clone();
// Check if geometry information will be lost
if (image->GetDimension() == 2 && !geometry->Is2DConvertable())
{
MITK_WARN << "Saving a 2D image with 3D geometry information. Geometry information will be lost! You might "
"consider using Convert2Dto3DImageFilter before saving.";
// set matrix to identity
mitk::AffineTransform3D::Pointer affTrans = mitk::AffineTransform3D::New();
affTrans->SetIdentity();
mitk::Vector3D spacing = geometry->GetSpacing();
mitk::Point3D origin = geometry->GetOrigin();
geometry->SetIndexToWorldTransform(affTrans);
geometry->SetSpacing(spacing);
geometry->SetOrigin(origin);
}
LocalFile localFile(this);
const std::string path = localFile.GetFileName();
MITK_INFO << "Writing image: " << path << std::endl;
try
{
// Implementation of writer using itkImageIO directly. This skips the use
// of templated itkImageFileWriter, which saves the multiplexing on MITK side.
const unsigned int dimension = image->GetDimension();
const unsigned int *const dimensions = image->GetDimensions();
const mitk::PixelType pixelType = image->GetPixelType();
const mitk::Vector3D mitkSpacing = geometry->GetSpacing();
const mitk::Point3D mitkOrigin = geometry->GetOrigin();
// Due to templating in itk, we are forced to save a 4D spacing and 4D Origin,
// though they are not supported in MITK
itk::Vector<double, 4u> spacing4D;
spacing4D[0] = mitkSpacing[0];
spacing4D[1] = mitkSpacing[1];
spacing4D[2] = mitkSpacing[2];
spacing4D[3] = 1; // There is no support for a 4D spacing. However, we should have a valid value here
itk::Vector<double, 4u> origin4D;
origin4D[0] = mitkOrigin[0];
origin4D[1] = mitkOrigin[1];
origin4D[2] = mitkOrigin[2];
origin4D[3] = 0; // There is no support for a 4D origin. However, we should have a valid value here
// Set the necessary information for imageIO
m_ImageIO->SetNumberOfDimensions(dimension);
m_ImageIO->SetPixelType(pixelType.GetPixelType());
m_ImageIO->SetComponentType(pixelType.GetComponentType() < PixelComponentUserType ?
static_cast<itk::ImageIOBase::IOComponentType>(pixelType.GetComponentType()) :
itk::ImageIOBase::UNKNOWNCOMPONENTTYPE);
m_ImageIO->SetNumberOfComponents(pixelType.GetNumberOfComponents());
itk::ImageIORegion ioRegion(dimension);
for (unsigned int i = 0; i < dimension; i++)
{
m_ImageIO->SetDimensions(i, dimensions[i]);
m_ImageIO->SetSpacing(i, spacing4D[i]);
m_ImageIO->SetOrigin(i, origin4D[i]);
mitk::Vector3D mitkDirection;
mitkDirection.SetVnlVector(geometry->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(i));
itk::Vector<double, 4u> direction4D;
direction4D[0] = mitkDirection[0];
direction4D[1] = mitkDirection[1];
direction4D[2] = mitkDirection[2];
// MITK only supports a 3x3 direction matrix. Due to templating in itk, however, we must
// save a 4x4 matrix for 4D images. in this case, add an homogneous component to the matrix.
if (i == 3)
{
direction4D[3] = 1; // homogenous component
}
else
{
direction4D[3] = 0;
}
vnl_vector<double> axisDirection(dimension);
for (unsigned int j = 0; j < dimension; j++)
{
axisDirection[j] = direction4D[j] / spacing4D[i];
}
m_ImageIO->SetDirection(i, axisDirection);
ioRegion.SetSize(i, image->GetLargestPossibleRegion().GetSize(i));
ioRegion.SetIndex(i, image->GetLargestPossibleRegion().GetIndex(i));
}
// use compression if available
m_ImageIO->UseCompressionOn();
m_ImageIO->SetIORegion(ioRegion);
m_ImageIO->SetFileName(path);
// Handle time geometry
const auto *arbitraryTG = dynamic_cast<const ArbitraryTimeGeometry *>(image->GetTimeGeometry());
if (arbitraryTG)
{
itk::EncapsulateMetaData<std::string>(m_ImageIO->GetMetaDataDictionary(),
PROPERTY_KEY_TIMEGEOMETRY_TYPE,
ArbitraryTimeGeometry::GetStaticNameOfClass());
auto metaTimePoints = ConvertTimePointListToMetaDataObject(arbitraryTG);
m_ImageIO->GetMetaDataDictionary().Set(PROPERTY_KEY_TIMEGEOMETRY_TIMEPOINTS, metaTimePoints);
}
// Handle properties
mitk::PropertyList::Pointer imagePropertyList = image->GetPropertyList();
for (const auto &property : *imagePropertyList->GetMap())
{
mitk::CoreServicePointer<IPropertyPersistence> propPersistenceService(mitk::CoreServices::GetPropertyPersistence());
IPropertyPersistence::InfoResultType infoList = propPersistenceService->GetInfo(property.first, GetMimeType()->GetName(), true);
if (infoList.empty())
{
continue;
}
- std::string value = infoList.front()->GetSerializationFunction()(property.second);
+ std::string value = mitk::BaseProperty::VALUE_CANNOT_BE_CONVERTED_TO_STRING;
+ try
+ {
+ value = infoList.front()->GetSerializationFunction()(property.second);
+ }
+ catch (const std::exception& e)
+ {
+ MITK_ERROR << "Error when serializing content of property. This often indicates the use of an out dated reader. Property will not be stored. Skipped property: " << property.first << ". Reason: " << e.what();
+ }
+ catch (...)
+ {
+ MITK_ERROR << "Unkown error when serializing content of property. This often indicates the use of an out dated reader. Property will not be stored. Skipped property: " << property.first;
+ }
if (value == mitk::BaseProperty::VALUE_CANNOT_BE_CONVERTED_TO_STRING)
{
continue;
}
std::string key = infoList.front()->GetKey();
itk::EncapsulateMetaData<std::string>(m_ImageIO->GetMetaDataDictionary(), key, value);
}
// Handle UID
itk::EncapsulateMetaData<std::string>(m_ImageIO->GetMetaDataDictionary(), PROPERTY_KEY_UID, image->GetUID());
ImageReadAccessor imageAccess(image);
LocaleSwitch localeSwitch2("C");
m_ImageIO->Write(imageAccess.GetData());
}
catch (const std::exception &e)
{
mitkThrow() << e.what();
}
}
AbstractFileIO::ConfidenceLevel ItkImageIO::GetWriterConfidenceLevel() const
{
// Check if the image dimension is supported
const auto *image = dynamic_cast<const Image *>(this->GetInput());
if (image == nullptr)
{
// We cannot write a null object, DUH!
return IFileWriter::Unsupported;
}
if (!m_ImageIO->SupportsDimension(image->GetDimension()))
{
// okay, dimension is not supported. We have to look at a special case:
// 3D-Image with one slice. We can treat that as a 2D image.
if ((image->GetDimension() == 3) && (image->GetSlicedGeometry()->GetSlices() == 1))
return IFileWriter::Supported;
else
return IFileWriter::Unsupported;
}
// Check if geometry information will be lost
if (image->GetDimension() == 2 && !image->GetGeometry()->Is2DConvertable())
{
return IFileWriter::PartiallySupported;
}
return IFileWriter::Supported;
}
ItkImageIO *ItkImageIO::IOClone() const { return new ItkImageIO(*this); }
void ItkImageIO::InitializeDefaultMetaDataKeys()
{
this->m_DefaultMetaDataKeys.push_back("NRRD.space");
this->m_DefaultMetaDataKeys.push_back("NRRD.kinds");
this->m_DefaultMetaDataKeys.push_back(PROPERTY_NAME_TIMEGEOMETRY_TYPE);
this->m_DefaultMetaDataKeys.push_back(PROPERTY_NAME_TIMEGEOMETRY_TIMEPOINTS);
this->m_DefaultMetaDataKeys.push_back("ITK.InputFilterName");
}
}
diff --git a/Modules/Core/src/IO/mitkPreferenceListReaderOptionsFunctor.cpp b/Modules/Core/src/IO/mitkPreferenceListReaderOptionsFunctor.cpp
index 632bf1a0a6..7ac4c6b8b8 100644
--- a/Modules/Core/src/IO/mitkPreferenceListReaderOptionsFunctor.cpp
+++ b/Modules/Core/src/IO/mitkPreferenceListReaderOptionsFunctor.cpp
@@ -1,88 +1,88 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkPreferenceListReaderOptionsFunctor.h"
mitk::PreferenceListReaderOptionsFunctor::PreferenceListReaderOptionsFunctor()
{
}
mitk::PreferenceListReaderOptionsFunctor::PreferenceListReaderOptionsFunctor(const ListType& preference, const IFileReader::Options& options) : m_PreferenceList(preference), m_Options(options)
{
}
mitk::PreferenceListReaderOptionsFunctor::PreferenceListReaderOptionsFunctor(const ListType& preference, const ListType& black) : m_PreferenceList(preference), m_BlackList(black)
{
}
mitk::PreferenceListReaderOptionsFunctor::PreferenceListReaderOptionsFunctor(const ListType& preference, const ListType& black, const IFileReader::Options& options) : m_PreferenceList(preference), m_BlackList(black), m_Options(options)
{
}
bool mitk::PreferenceListReaderOptionsFunctor::operator()(IOUtil::LoadInfo &loadInfo) const
{
auto readerItems = loadInfo.m_ReaderSelector.Get();
auto selectedID = loadInfo.m_ReaderSelector.GetSelectedId();
//check if the pre selected ID is on the blacklist. If true, "un"select.
auto finding = std::find(m_BlackList.begin(), m_BlackList.end(), loadInfo.m_ReaderSelector.GetSelected().GetDescription());
if (finding != m_BlackList.end())
{
selectedID = -1;
}
- for (auto reader : readerItems)
+ for (const auto &reader : readerItems)
{
finding = std::find(m_BlackList.begin(), m_BlackList.end(), reader.GetDescription());
if (finding != m_BlackList.end())
{
continue;
}
finding = std::find(m_PreferenceList.begin(), m_PreferenceList.end(), reader.GetDescription());
if (finding != m_PreferenceList.end())
{
selectedID = reader.GetServiceId();
break;
}
if (selectedID==-1)
{
selectedID = reader.GetServiceId();
}
}
if (selectedID == -1)
{
mitkThrow() << "No valid reader found. All available readers are black listed.";
}
if (!loadInfo.m_ReaderSelector.Select(selectedID))
{
MITK_DEBUG << "Was not able to select reader found by the PreferenceListReaderOptionsFunctor";
}
auto reader = loadInfo.m_ReaderSelector.GetSelected().GetReader();
if (!m_Options.empty() && nullptr != reader)
{
reader->SetOptions(m_Options);
}
return true;
}
diff --git a/Modules/Core/src/IO/mitkProportionalTimeGeometryToXML.cpp b/Modules/Core/src/IO/mitkProportionalTimeGeometryToXML.cpp
index 3b42888705..03a0384d62 100644
--- a/Modules/Core/src/IO/mitkProportionalTimeGeometryToXML.cpp
+++ b/Modules/Core/src/IO/mitkProportionalTimeGeometryToXML.cpp
@@ -1,164 +1,164 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkProportionalTimeGeometryToXML.h"
#include "mitkGeometry3DToXML.h"
#include <mitkLexicalCast.h>
#include <tinyxml2.h>
tinyxml2::XMLElement *mitk::ProportionalTimeGeometryToXML::ToXML(tinyxml2::XMLDocument& doc, const ProportionalTimeGeometry *timeGeom)
{
assert(timeGeom);
auto *timeGeomElem = doc.NewElement("ProportionalTimeGeometry");
timeGeomElem->SetAttribute("NumberOfTimeSteps", static_cast<int>(timeGeom->CountTimeSteps()));
// TinyXML cannot serialize infinity (default value for time step)
// So we guard this value and the first time point against serialization problems
// by not writing them. The reader can then tell that absence of those values
// means "keep the default values"
if (timeGeom->GetFirstTimePoint() != -std::numeric_limits<TimePointType>::max())
timeGeomElem->SetAttribute("FirstTimePoint", boost::lexical_cast<std::string>(timeGeom->GetFirstTimePoint()).c_str());
if (timeGeom->GetStepDuration() != std::numeric_limits<TimePointType>::infinity())
timeGeomElem->SetAttribute("StepDuration", boost::lexical_cast<std::string>(timeGeom->GetStepDuration()).c_str());
for (TimeStepType t = 0; t < timeGeom->CountTimeSteps(); ++t)
{
// add a node for the geometry of each time step
const Geometry3D *geom3D(nullptr);
if ((geom3D = dynamic_cast<const Geometry3D *>(timeGeom->GetGeometryForTimeStep(t).GetPointer())))
{
auto *geom3DElement = Geometry3DToXML::ToXML(doc, geom3D);
geom3DElement->SetAttribute("TimeStep", static_cast<int>(t)); // mark order for us
timeGeomElem->InsertEndChild(geom3DElement);
}
else
{
MITK_WARN << "Serializing a ProportionalTimeGeometry that contains something other than Geometry3D!"
<< " (in time step " << t << ")"
<< " File will miss information!";
}
}
return timeGeomElem;
}
mitk::ProportionalTimeGeometry::Pointer mitk::ProportionalTimeGeometryToXML::FromXML(const tinyxml2::XMLElement *timeGeometryElement)
{
if (!timeGeometryElement)
{
MITK_ERROR << "Cannot deserialize ProportionalTimeGeometry from nullptr.";
return nullptr;
}
int numberOfTimeSteps = 0;
if (tinyxml2::XML_SUCCESS != timeGeometryElement->QueryIntAttribute("NumberOfTimeSteps", &numberOfTimeSteps))
{
MITK_WARN << "<ProportionalTimeGeometry> found without NumberOfTimeSteps attribute. Counting...";
}
// might be missing!
TimePointType firstTimePoint;
const char* firstTimePoint_s = nullptr;
TimePointType stepDuration;
const char* stepDuration_s = nullptr;
try
{
firstTimePoint_s = timeGeometryElement->Attribute("FirstTimePoint");
if (nullptr != firstTimePoint_s)
{
firstTimePoint = boost::lexical_cast<double>(firstTimePoint_s);
}
else
{
firstTimePoint = -std::numeric_limits<TimePointType>::max();
}
stepDuration_s = timeGeometryElement->Attribute("StepDuration");
if (nullptr != stepDuration_s)
{
stepDuration = boost::lexical_cast<double>(stepDuration_s);
}
else
{
stepDuration = std::numeric_limits<TimePointType>::infinity();
}
}
catch ( const boost::bad_lexical_cast &e )
{
MITK_ERROR << "Could not parse string as number: " << e.what();
return nullptr;
}
// list of all geometries with their time steps
std::multimap<TimeStepType, BaseGeometry::Pointer> allReadGeometries;
int indexForUnlabeledTimeStep(-1);
for (auto *currentElement = timeGeometryElement->FirstChildElement(); currentElement != nullptr;
currentElement = currentElement->NextSiblingElement())
{
// different geometries could have been inside a ProportionalTimeGeometry.
// By now, we only support Geometry3D
std::string tagName = currentElement->Value();
if (tagName == "Geometry3D")
{
Geometry3D::Pointer restoredGeometry = Geometry3DToXML::FromXML(currentElement);
if (restoredGeometry.IsNotNull())
{
int timeStep(-1);
if (tinyxml2::XML_SUCCESS != currentElement->QueryIntAttribute("TimeStep", &timeStep))
{
timeStep = indexForUnlabeledTimeStep--; // decrement index for next one
MITK_WARN << "Found <Geometry3D> without 'TimeStep' attribute in <ProportionalTimeGeometry>. No guarantees "
"on order anymore.";
}
if (allReadGeometries.count(static_cast<TimeStepType>(timeStep)) > 0)
{
MITK_WARN << "Found <Geometry3D> tags with identical 'TimeStep' attribute in <ProportionalTimeGeometry>. No "
"guarantees on order anymore.";
}
allReadGeometries.insert(std::make_pair(static_cast<TimeStepType>(timeStep), restoredGeometry.GetPointer()));
}
}
else
{
MITK_WARN << "Found unsupported tag <" << tagName << "> inside <ProportionalTimeGeometry>. Ignoring.";
}
}
// now add all BaseGeometries that were read to a new instance
// of ProportionalTimeGeometry
ProportionalTimeGeometry::Pointer newTimeGeometry = ProportionalTimeGeometry::New();
newTimeGeometry->SetFirstTimePoint(firstTimePoint);
newTimeGeometry->SetStepDuration(stepDuration);
newTimeGeometry->ReserveSpaceForGeometries(allReadGeometries.size());
TimeStepType t(0);
- for (auto entry : allReadGeometries)
+ for (const auto &entry : allReadGeometries)
{
// We add items with newly assigned time steps.
// This avoids great confusion when a file contains
// bogus numbers.
newTimeGeometry->SetTimeStepGeometry(entry.second, t++);
}
// Need to re-calculate global bounding box.
// This is neither stored in a file, nor done by SetTimeStepGeometry
newTimeGeometry->UpdateBoundingBox();
return newTimeGeometry;
}
diff --git a/Modules/Core/src/Interactions/mitkPointSetDataInteractor.cpp b/Modules/Core/src/Interactions/mitkPointSetDataInteractor.cpp
index ac2d921e9a..cfecd85744 100644
--- a/Modules/Core/src/Interactions/mitkPointSetDataInteractor.cpp
+++ b/Modules/Core/src/Interactions/mitkPointSetDataInteractor.cpp
@@ -1,621 +1,621 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#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
auto *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent != nullptr)
{
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; }
auto *doOp = new mitk::PointOperation(OpINSERT, timeInMs, itkPoint, lastPosition);
// 3) If Undo is enabled, also create the inverse Operation
if (m_UndoEnabled)
{
auto *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;
RenderingManager::GetInstance()->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(nullptr, 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();
auto *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent != nullptr)
{
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);
auto *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;
RenderingManager::GetInstance()->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();
auto *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent != nullptr)
{
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];
auto *doOp = new mitk::PointOperation(OpREMOVE, timeInMs, itkPoint, position);
if (m_UndoEnabled) // write to UndoMechanism
{
auto *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);
}
}
RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void mitk::PointSetDataInteractor::IsClosedContour(StateMachineAction *, InteractionEvent *interactionEvent)
{
unsigned int timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
auto *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent != nullptr)
{
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(nullptr, 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();
auto *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent != nullptr)
{
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;
auto *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
RenderingManager::GetInstance()->RequestUpdateAll();
IsClosedContour(stateMachineAction, interactionEvent);
}
}
void mitk::PointSetDataInteractor::UnSelectPointAtPosition(StateMachineAction *, InteractionEvent *interactionEvent)
{
unsigned int timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
ScalarType timeInMs = interactionEvent->GetSender()->GetTime();
auto *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent != nullptr)
{
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)
{
auto *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;
RenderingManager::GetInstance()->RequestUpdateAll();
}
}
}
void mitk::PointSetDataInteractor::UnSelectAll(mitk::StateMachineAction *, mitk::InteractionEvent *interactionEvent)
{
unsigned int timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
ScalarType timeInMs = interactionEvent->GetSender()->GetTime();
auto *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent != nullptr)
{
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);
auto *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);
}
RenderingManager::GetInstance()->RequestUpdateAll();
}
void mitk::PointSetDataInteractor::UpdatePointSet(mitk::StateMachineAction *, mitk::InteractionEvent *)
{
auto *pointSet = dynamic_cast<mitk::PointSet *>(this->GetDataNode()->GetData());
if (pointSet == nullptr)
{
MITK_ERROR << "PointSetDataInteractor:: No valid point set .";
return;
}
m_PointSet = pointSet;
}
void mitk::PointSetDataInteractor::Abort(StateMachineAction *, InteractionEvent *interactionEvent)
{
InternalEvent::Pointer event = InternalEvent::New(nullptr, 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)
{
auto *points = dynamic_cast<PointSet *>(GetDataNode()->GetData());
if (points == nullptr)
{
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)
{
auto *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent == nullptr)
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();
auto *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent != nullptr)
{
// 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];
auto *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);
auto *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
RenderingManager::GetInstance()->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
auto *points = dynamic_cast<PointSet *>(GetDataNode()->GetData());
int index = -1;
if (points == nullptr)
{
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 auto *positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
if (positionEvent != nullptr)
{
- int timeStep = positionEvent->GetSender()->GetTimeStep();
+ const auto timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
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)
{
auto *pointSet = dynamic_cast<mitk::PointSet *>(GetDataNode()->GetData());
if (pointSet == nullptr)
{
return;
}
mitk::PointSet::DataType *itkPointSet = pointSet->GetPointSet(timeStep);
if (itkPointSet == nullptr)
{
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);
auto *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)
{
auto *pointSet = dynamic_cast<mitk::PointSet *>(this->GetDataNode()->GetData());
// if List is empty, then no selection of a point can be done!
if ((pointSet == nullptr) || (pointSet->GetSize(timeStep) <= 0))
{
return;
}
// dummyPoint... not needed anyway
mitk::Point3D noPoint;
noPoint.Fill(0);
auto *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/src/Rendering/mitkAnnotation.cpp b/Modules/Core/src/Rendering/mitkAnnotation.cpp
index 8c7e1e092c..c9ac002908 100644
--- a/Modules/Core/src/Rendering/mitkAnnotation.cpp
+++ b/Modules/Core/src/Rendering/mitkAnnotation.cpp
@@ -1,348 +1,348 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkAnnotation.h"
#include "usGetModuleContext.h"
const std::string mitk::Annotation::US_INTERFACE_NAME = "org.mitk.services.Annotation";
const std::string mitk::Annotation::US_PROPKEY_AnnotationNAME = US_INTERFACE_NAME + ".name";
const std::string mitk::Annotation::US_PROPKEY_ID = US_INTERFACE_NAME + ".id";
const std::string mitk::Annotation::US_PROPKEY_MODIFIED = US_INTERFACE_NAME + ".modified";
const std::string mitk::Annotation::US_PROPKEY_RENDERER_ID = US_INTERFACE_NAME + ".rendererId";
const std::string mitk::Annotation::US_PROPKEY_AR_ID = US_INTERFACE_NAME + ".arId";
mitk::Annotation::Annotation() : m_PropertyListModifiedObserverTag(0)
{
m_PropertyList = mitk::PropertyList::New();
itk::MemberCommand<mitk::Annotation>::Pointer _PropertyListModifiedCommand =
itk::MemberCommand<mitk::Annotation>::New();
_PropertyListModifiedCommand->SetCallbackFunction(this, &mitk::Annotation::PropertyListModified);
m_PropertyListModifiedObserverTag = m_PropertyList->AddObserver(itk::ModifiedEvent(), _PropertyListModifiedCommand);
this->SetName(this->GetNameOfClass());
this->SetVisibility(true);
this->SetOpacity(1.0);
}
void mitk::Annotation::PropertyListModified(const itk::Object * /*caller*/, const itk::EventObject &)
{
AnnotationModified();
}
mitk::Annotation::~Annotation()
{
this->UnRegisterMicroservice();
}
void mitk::Annotation::SetUSProperty(const std::string &propertyKey, us::Any value)
{
if (this->m_ServiceRegistration)
{
us::ServiceProperties props;
std::vector<std::string> propertyKeys;
m_ServiceRegistration.GetReference().GetPropertyKeys(propertyKeys);
- for (std::string key : propertyKeys)
+ for (const std::string &key : propertyKeys)
{
props[key] = m_ServiceRegistration.GetReference().GetProperty(key);
}
props[propertyKey] = value;
m_ServiceRegistration.SetProperties(props);
}
}
void mitk::Annotation::SetProperty(const std::string &propertyKey, const BaseProperty::Pointer &propertyValue)
{
this->m_PropertyList->SetProperty(propertyKey, propertyValue);
}
void mitk::Annotation::ReplaceProperty(const std::string &propertyKey, const BaseProperty::Pointer &propertyValue)
{
this->m_PropertyList->ReplaceProperty(propertyKey, propertyValue);
}
void mitk::Annotation::AddProperty(const std::string &propertyKey,
const BaseProperty::Pointer &propertyValue,
bool overwrite)
{
if ((overwrite) || (GetProperty(propertyKey) == nullptr))
{
SetProperty(propertyKey, propertyValue);
}
}
void mitk::Annotation::ConcatenatePropertyList(PropertyList *pList, bool replace)
{
m_PropertyList->ConcatenatePropertyList(pList, replace);
}
mitk::BaseProperty *mitk::Annotation::GetProperty(const std::string &propertyKey) const
{
mitk::BaseProperty::Pointer property = m_PropertyList->GetProperty(propertyKey);
if (property.IsNotNull())
return property;
// only to satisfy compiler!
return nullptr;
}
bool mitk::Annotation::GetBoolProperty(const std::string &propertyKey, bool &boolValue) const
{
mitk::BoolProperty::Pointer boolprop = dynamic_cast<mitk::BoolProperty *>(GetProperty(propertyKey));
if (boolprop.IsNull())
return false;
boolValue = boolprop->GetValue();
return true;
}
bool mitk::Annotation::GetIntProperty(const std::string &propertyKey, int &intValue) const
{
mitk::IntProperty::Pointer intprop = dynamic_cast<mitk::IntProperty *>(GetProperty(propertyKey));
if (intprop.IsNull())
return false;
intValue = intprop->GetValue();
return true;
}
bool mitk::Annotation::GetFloatProperty(const std::string &propertyKey, float &floatValue) const
{
mitk::FloatProperty::Pointer floatprop = dynamic_cast<mitk::FloatProperty *>(GetProperty(propertyKey));
if (floatprop.IsNull())
return false;
floatValue = floatprop->GetValue();
return true;
}
bool mitk::Annotation::GetStringProperty(const std::string &propertyKey, std::string &string) const
{
mitk::StringProperty::Pointer stringProp = dynamic_cast<mitk::StringProperty *>(GetProperty(propertyKey));
if (stringProp.IsNull())
{
return false;
}
else
{
// memcpy((void*)string, stringProp->GetValue(), strlen(stringProp->GetValue()) + 1 ); // looks dangerous
string = stringProp->GetValue();
return true;
}
}
void mitk::Annotation::SetIntProperty(const std::string &propertyKey, int intValue)
{
this->m_PropertyList->SetProperty(propertyKey, mitk::IntProperty::New(intValue));
Modified();
}
void mitk::Annotation::SetBoolProperty(const std::string &propertyKey, bool boolValue)
{
this->m_PropertyList->SetProperty(propertyKey, mitk::BoolProperty::New(boolValue));
Modified();
}
void mitk::Annotation::SetFloatProperty(const std::string &propertyKey, float floatValue)
{
this->m_PropertyList->SetProperty(propertyKey, mitk::FloatProperty::New(floatValue));
Modified();
}
void mitk::Annotation::SetDoubleProperty(const std::string &propertyKey, double doubleValue)
{
this->m_PropertyList->SetProperty(propertyKey, mitk::DoubleProperty::New(doubleValue));
Modified();
}
void mitk::Annotation::SetStringProperty(const std::string &propertyKey, const std::string &stringValue)
{
this->m_PropertyList->SetProperty(propertyKey, mitk::StringProperty::New(stringValue));
Modified();
}
std::string mitk::Annotation::GetName() const
{
mitk::StringProperty *sp = dynamic_cast<mitk::StringProperty *>(this->GetProperty("name"));
if (sp == nullptr)
return "";
return sp->GetValue();
}
void mitk::Annotation::SetName(const std::string &name)
{
this->SetStringProperty("name", name);
}
bool mitk::Annotation::GetName(std::string &nodeName, const std::string &propertyKey) const
{
return GetStringProperty(propertyKey, nodeName);
}
void mitk::Annotation::SetText(std::string text)
{
SetStringProperty("Text", text.c_str());
}
std::string mitk::Annotation::GetText() const
{
std::string text;
GetStringProperty("Text", text);
return text;
}
void mitk::Annotation::SetFontSize(int fontSize)
{
SetIntProperty("FontSize", fontSize);
}
int mitk::Annotation::GetFontSize() const
{
int fontSize = 1;
GetIntProperty("FontSize", fontSize);
return fontSize;
}
bool mitk::Annotation::GetVisibility(bool &visible, const std::string &propertyKey) const
{
return GetBoolProperty(propertyKey, visible);
}
bool mitk::Annotation::IsVisible(const std::string &propertyKey, bool defaultIsOn) const
{
return IsOn(propertyKey, defaultIsOn);
}
bool mitk::Annotation::GetColor(float rgb[], const std::string &propertyKey) const
{
mitk::ColorProperty::Pointer colorprop = dynamic_cast<mitk::ColorProperty *>(GetProperty(propertyKey));
if (colorprop.IsNull())
return false;
memcpy(rgb, colorprop->GetColor().GetDataPointer(), 3 * sizeof(float));
return true;
}
void mitk::Annotation::SetColor(const mitk::Color &color, const std::string &propertyKey)
{
mitk::ColorProperty::Pointer prop;
prop = mitk::ColorProperty::New(color);
this->m_PropertyList->SetProperty(propertyKey, prop);
}
void mitk::Annotation::SetColor(float red, float green, float blue, const std::string &propertyKey)
{
float color[3];
color[0] = red;
color[1] = green;
color[2] = blue;
SetColor(color, propertyKey);
}
void mitk::Annotation::SetColor(const float rgb[], const std::string &propertyKey)
{
mitk::ColorProperty::Pointer prop;
prop = mitk::ColorProperty::New(rgb);
this->m_PropertyList->SetProperty(propertyKey, prop);
}
bool mitk::Annotation::GetOpacity(float &opacity, const std::string &propertyKey) const
{
mitk::FloatProperty::Pointer opacityprop = dynamic_cast<mitk::FloatProperty *>(GetProperty(propertyKey));
if (opacityprop.IsNull())
return false;
opacity = opacityprop->GetValue();
return true;
}
void mitk::Annotation::SetOpacity(float opacity, const std::string &propertyKey)
{
mitk::FloatProperty::Pointer prop;
prop = mitk::FloatProperty::New(opacity);
this->m_PropertyList->SetProperty(propertyKey, prop);
}
void mitk::Annotation::SetVisibility(bool visible, const std::string &propertyKey)
{
mitk::BoolProperty::Pointer prop;
prop = mitk::BoolProperty::New(visible);
this->m_PropertyList->SetProperty(propertyKey, prop);
Modified();
}
bool mitk::Annotation::BaseLocalStorage::IsGenerateDataRequired(mitk::BaseRenderer *renderer,
mitk::Annotation *Annotation)
{
if (m_LastGenerateDataTime < Annotation->GetMTime())
return true;
if (m_LastGenerateDataTime < Annotation->GetPropertyList()->GetMTime())
return true;
if (renderer && m_LastGenerateDataTime < renderer->GetTimeStepUpdateTime())
return true;
return false;
}
mitk::Annotation::Bounds mitk::Annotation::GetBoundsOnDisplay(mitk::BaseRenderer *) const
{
mitk::Annotation::Bounds bounds;
bounds.Position[0] = bounds.Position[1] = bounds.Size[0] = bounds.Size[1] = 0;
return bounds;
}
void mitk::Annotation::SetBoundsOnDisplay(mitk::BaseRenderer *, const mitk::Annotation::Bounds &)
{
}
void mitk::Annotation::SetForceInForeground(bool forceForeground)
{
m_ForceInForeground = forceForeground;
}
bool mitk::Annotation::IsForceInForeground() const
{
return m_ForceInForeground;
}
mitk::PropertyList *mitk::Annotation::GetPropertyList() const
{
return m_PropertyList;
}
std::string mitk::Annotation::GetMicroserviceID()
{
return this->m_ServiceRegistration.GetReference().GetProperty(US_PROPKEY_ID).ToString();
}
void mitk::Annotation::RegisterAsMicroservice(us::ServiceProperties props)
{
if (m_ServiceRegistration != nullptr)
m_ServiceRegistration.Unregister();
us::ModuleContext *context = us::GetModuleContext();
// Define ServiceProps
mitk::UIDGenerator uidGen = mitk::UIDGenerator("org.mitk.services.Annotation.id_");
props[US_PROPKEY_ID] = uidGen.GetUID();
m_ServiceRegistration = context->RegisterService(this, props);
}
void mitk::Annotation::UnRegisterMicroservice()
{
if (m_ServiceRegistration != nullptr)
m_ServiceRegistration.Unregister();
m_ServiceRegistration = 0;
}
void mitk::Annotation::AnnotationModified()
{
Modified();
this->SetUSProperty(US_PROPKEY_MODIFIED, this->GetMTime());
}
diff --git a/Modules/Core/src/Rendering/mitkAnnotationUtils.cpp b/Modules/Core/src/Rendering/mitkAnnotationUtils.cpp
index 256bc14643..f67a16d14b 100644
--- a/Modules/Core/src/Rendering/mitkAnnotationUtils.cpp
+++ b/Modules/Core/src/Rendering/mitkAnnotationUtils.cpp
@@ -1,124 +1,124 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkAnnotationUtils.h"
#include "mitkAnnotation.h"
#include "vtkCallbackCommand.h"
#include "vtkCommand.h"
#include <mitkAbstractAnnotationRenderer.h>
namespace mitk
{
AnnotationUtils::AnnotationUtils() {}
AnnotationUtils::~AnnotationUtils() {}
AbstractAnnotationRenderer *AnnotationUtils::GetAnnotationRenderer(const std::string &arTypeID,
const std::string &rendererID)
{
// get the context
us::ModuleContext *context = us::GetModuleContext();
// specify a filter that defines the requested type
std::string filter = "(&(" + AbstractAnnotationRenderer::US_PROPKEY_ID + "=" + arTypeID + ")(" +
AbstractAnnotationRenderer::US_PROPKEY_RENDERER_ID + "=" + rendererID + "))";
// find the fitting service
std::vector<us::ServiceReferenceU> serviceReferences =
context->GetServiceReferences(AbstractAnnotationRenderer::US_INTERFACE_NAME, filter);
// check if a service reference was found. It is also possible that several
// services were found. This is not checked here, just the first one is taken.
AbstractAnnotationRenderer *ar = nullptr;
if (serviceReferences.size())
{
ar = context->GetService<AbstractAnnotationRenderer>(serviceReferences.front());
}
// no service reference was found or found service reference has no valid source
return ar;
}
void AnnotationUtils::RegisterAnnotationRenderer(AbstractAnnotationRenderer *annotationRenderer)
{
static AnnotationRendererServices AnnotationRendererServices;
// Define ServiceProps
us::ServiceProperties props;
props[AbstractAnnotationRenderer::US_PROPKEY_RENDERER_ID] = annotationRenderer->GetRendererID();
props[AbstractAnnotationRenderer::US_PROPKEY_ID] = annotationRenderer->GetID();
us::GetModuleContext()->RegisterService(annotationRenderer, props);
AnnotationRendererServices.push_back(std::unique_ptr<AbstractAnnotationRenderer>(annotationRenderer));
}
void AnnotationUtils::UpdateAnnotationRenderer(const std::string &rendererID)
{
for (AbstractAnnotationRenderer *annotationRenderer : GetAnnotationRenderer(rendererID))
{
annotationRenderer->Update();
}
}
void AnnotationUtils::BaseRendererChanged(BaseRenderer *renderer)
{
for (AbstractAnnotationRenderer *annotationRenderer : GetAnnotationRenderer(renderer->GetName()))
{
annotationRenderer->CurrentBaseRendererChanged();
}
vtkCallbackCommand *renderCallbackCommand = vtkCallbackCommand::New();
renderCallbackCommand->SetCallback(AnnotationUtils::RenderWindowCallback);
renderer->GetRenderWindow()->AddObserver(vtkCommand::ModifiedEvent, renderCallbackCommand);
renderCallbackCommand->Delete();
}
void AnnotationUtils::RenderWindowCallback(vtkObject *caller, unsigned long, void *, void *)
{
auto *renderWindow = dynamic_cast<vtkRenderWindow *>(caller);
if (!renderWindow)
return;
BaseRenderer *renderer = BaseRenderer::GetInstance(renderWindow);
if (nullptr != renderer)
{
for (AbstractAnnotationRenderer *annotationRenderer : GetAnnotationRenderer(renderer->GetName()))
annotationRenderer->OnRenderWindowModified();
}
}
Annotation *AnnotationUtils::GetAnnotation(const std::string &AnnotationID)
{
std::string ldapFilter = "(" + Annotation::US_PROPKEY_ID + "=" + AnnotationID + ")";
us::ModuleContext *context = us::GetModuleContext();
std::vector<us::ServiceReference<mitk::Annotation>> annotations =
context->GetServiceReferences<mitk::Annotation>(ldapFilter);
Annotation *annotation = nullptr;
if (!annotations.empty())
{
annotation = us::GetModuleContext()->GetService<mitk::Annotation>(annotations.front());
}
return annotation;
}
std::vector<AbstractAnnotationRenderer *> AnnotationUtils::GetAnnotationRenderer(const std::string &rendererID)
{
us::ModuleContext *context = us::GetModuleContext();
// specify a filter that defines the requested type
std::string filter = "(&(" + AbstractAnnotationRenderer::US_PROPKEY_ID + "=*)(" +
AbstractAnnotationRenderer::US_PROPKEY_RENDERER_ID + "=" + rendererID + "))";
// find the fitting service
std::vector<us::ServiceReferenceU> serviceReferences =
context->GetServiceReferences(AbstractAnnotationRenderer::US_INTERFACE_NAME, filter);
std::vector<AbstractAnnotationRenderer *> arList;
- for (us::ServiceReferenceU service : serviceReferences)
+ for (const us::ServiceReferenceU &service : serviceReferences)
{
arList.push_back(context->GetService<AbstractAnnotationRenderer>(service));
}
return arList;
}
}
diff --git a/Modules/Core/src/Rendering/mitkBaseRenderer.cpp b/Modules/Core/src/Rendering/mitkBaseRenderer.cpp
index ee62b659cd..58f2831295 100644
--- a/Modules/Core/src/Rendering/mitkBaseRenderer.cpp
+++ b/Modules/Core/src/Rendering/mitkBaseRenderer.cpp
@@ -1,784 +1,784 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkBaseRenderer.h"
#include "mitkMapper.h"
#include "mitkResliceMethodProperty.h"
// Geometries
#include "mitkPlaneGeometry.h"
#include "mitkSlicedGeometry3D.h"
// Controllers
#include "mitkCameraController.h"
#include "mitkCameraRotationController.h"
#include "mitkSliceNavigationController.h"
#include "mitkVtkLayerController.h"
#include "mitkInteractionConst.h"
#include "mitkProperties.h"
#include "mitkWeakPointerProperty.h"
// VTK
#include <vtkCamera.h>
#include <vtkLinearTransform.h>
#include <vtkRenderWindow.h>
#include <vtkRenderer.h>
#include <vtkActor.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
mitk::BaseRenderer::BaseRendererMapType mitk::BaseRenderer::baseRendererMap;
mitk::BaseRenderer *mitk::BaseRenderer::GetInstance(vtkRenderWindow *renWin)
{
for (auto mapit = baseRendererMap.begin(); mapit != baseRendererMap.end(); ++mapit)
{
if ((*mapit).first == renWin)
return (*mapit).second;
}
return nullptr;
}
void mitk::BaseRenderer::AddInstance(vtkRenderWindow *renWin, BaseRenderer *baseRenderer)
{
if (renWin == nullptr || baseRenderer == nullptr)
return;
// ensure that no BaseRenderer is managed twice
mitk::BaseRenderer::RemoveInstance(renWin);
baseRendererMap.insert(BaseRendererMapType::value_type(renWin, baseRenderer));
}
void mitk::BaseRenderer::RemoveInstance(vtkRenderWindow *renWin)
{
auto mapit = baseRendererMap.find(renWin);
if (mapit != baseRendererMap.end())
baseRendererMap.erase(mapit);
}
mitk::BaseRenderer *mitk::BaseRenderer::GetByName(const std::string &name)
{
for (auto mapit = baseRendererMap.begin(); mapit != baseRendererMap.end(); ++mapit)
{
if ((*mapit).second->m_Name == name)
return (*mapit).second;
}
return nullptr;
}
vtkRenderWindow *mitk::BaseRenderer::GetRenderWindowByName(const std::string &name)
{
for (auto mapit = baseRendererMap.begin(); mapit != baseRendererMap.end(); ++mapit)
{
if ((*mapit).second->m_Name == name)
return (*mapit).first;
}
return nullptr;
}
mitk::BaseRenderer::BaseRenderer(const char *name,
vtkRenderWindow *renWin)
: m_RenderWindow(nullptr),
m_VtkRenderer(nullptr),
m_MapperID(defaultMapper),
m_DataStorage(nullptr),
m_LastUpdateTime(0),
m_CameraController(nullptr),
m_SliceNavigationController(nullptr),
m_CameraRotationController(nullptr),
m_WorldTimeGeometry(nullptr),
m_CurrentWorldGeometry(nullptr),
m_CurrentWorldPlaneGeometry(nullptr),
m_Slice(0),
m_TimeStep(),
m_CurrentWorldPlaneGeometryUpdateTime(),
m_TimeStepUpdateTime(),
m_KeepDisplayedRegion(true),
m_CurrentWorldPlaneGeometryData(nullptr),
m_CurrentWorldPlaneGeometryNode(nullptr),
m_CurrentWorldPlaneGeometryTransformTime(0),
m_Name(name),
m_EmptyWorldGeometry(true),
m_NumberOfVisibleLODEnabledMappers(0)
{
m_Bounds[0] = 0;
m_Bounds[1] = 0;
m_Bounds[2] = 0;
m_Bounds[3] = 0;
m_Bounds[4] = 0;
m_Bounds[5] = 0;
if (name != nullptr)
{
m_Name = name;
}
else
{
m_Name = "unnamed renderer";
itkWarningMacro(<< "Created unnamed renderer. Bad for serialization. Please choose a name.");
}
if (renWin != nullptr)
{
m_RenderWindow = renWin;
m_RenderWindow->Register(nullptr);
}
else
{
itkWarningMacro(<< "Created mitkBaseRenderer without vtkRenderWindow present.");
}
// instances.insert( this );
// adding this BaseRenderer to the List of all BaseRenderer
m_BindDispatcherInteractor = new mitk::BindDispatcherInteractor(GetName());
WeakPointerProperty::Pointer rendererProp = WeakPointerProperty::New((itk::Object *)this);
m_CurrentWorldPlaneGeometry = mitk::PlaneGeometry::New();
m_CurrentWorldPlaneGeometryData = mitk::PlaneGeometryData::New();
m_CurrentWorldPlaneGeometryData->SetPlaneGeometry(m_CurrentWorldPlaneGeometry);
m_CurrentWorldPlaneGeometryNode = mitk::DataNode::New();
m_CurrentWorldPlaneGeometryNode->SetData(m_CurrentWorldPlaneGeometryData);
m_CurrentWorldPlaneGeometryNode->GetPropertyList()->SetProperty("renderer", rendererProp);
m_CurrentWorldPlaneGeometryNode->GetPropertyList()->SetProperty("layer", IntProperty::New(1000));
m_CurrentWorldPlaneGeometryNode->SetProperty("reslice.thickslices", mitk::ResliceMethodProperty::New());
m_CurrentWorldPlaneGeometryNode->SetProperty("reslice.thickslices.num", mitk::IntProperty::New(1));
m_CurrentWorldPlaneGeometryTransformTime = m_CurrentWorldPlaneGeometryNode->GetVtkTransform()->GetMTime();
mitk::SliceNavigationController::Pointer sliceNavigationController = mitk::SliceNavigationController::New();
sliceNavigationController->SetRenderer(this);
sliceNavigationController->ConnectGeometrySliceEvent(this);
sliceNavigationController->ConnectGeometryUpdateEvent(this);
sliceNavigationController->ConnectGeometryTimeEvent(this, false);
m_SliceNavigationController = sliceNavigationController;
m_CameraRotationController = mitk::CameraRotationController::New();
m_CameraRotationController->SetRenderWindow(m_RenderWindow);
m_CameraRotationController->AcquireCamera();
m_CameraController = mitk::CameraController::New();
m_CameraController->SetRenderer(this);
m_VtkRenderer = vtkRenderer::New();
m_VtkRenderer->SetMaximumNumberOfPeels(16);
if (AntiAliasing::FastApproximate == RenderingManager::GetInstance()->GetAntiAliasing())
m_VtkRenderer->UseFXAAOn();
if (nullptr == mitk::VtkLayerController::GetInstance(m_RenderWindow))
mitk::VtkLayerController::AddInstance(m_RenderWindow, m_VtkRenderer);
mitk::VtkLayerController::GetInstance(m_RenderWindow)->InsertSceneRenderer(m_VtkRenderer);
}
mitk::BaseRenderer::~BaseRenderer()
{
if (m_VtkRenderer != nullptr)
{
m_VtkRenderer->Delete();
m_VtkRenderer = nullptr;
}
if (m_CameraController.IsNotNull())
m_CameraController->SetRenderer(nullptr);
mitk::VtkLayerController::RemoveInstance(m_RenderWindow);
RemoveAllLocalStorages();
m_DataStorage = nullptr;
if (m_BindDispatcherInteractor != nullptr)
{
delete m_BindDispatcherInteractor;
}
if (m_RenderWindow != nullptr)
{
m_RenderWindow->Delete();
m_RenderWindow = nullptr;
}
}
void mitk::BaseRenderer::SetMapperID(MapperSlotId id)
{
if (m_MapperID != id)
{
bool useDepthPeeling = Standard3D == id;
m_VtkRenderer->SetUseDepthPeeling(useDepthPeeling);
m_VtkRenderer->SetUseDepthPeelingForVolumes(useDepthPeeling);
m_MapperID = id;
this->Modified();
}
}
void mitk::BaseRenderer::RemoveAllLocalStorages()
{
this->InvokeEvent(mitk::BaseRenderer::RendererResetEvent());
std::list<mitk::BaseLocalStorageHandler *>::iterator it;
for (it = m_RegisteredLocalStorageHandlers.begin(); it != m_RegisteredLocalStorageHandlers.end(); ++it)
(*it)->ClearLocalStorage(this, false);
m_RegisteredLocalStorageHandlers.clear();
}
void mitk::BaseRenderer::RegisterLocalStorageHandler(mitk::BaseLocalStorageHandler *lsh)
{
m_RegisteredLocalStorageHandlers.push_back(lsh);
}
mitk::Dispatcher::Pointer mitk::BaseRenderer::GetDispatcher() const
{
return m_BindDispatcherInteractor->GetDispatcher();
}
void mitk::BaseRenderer::UnregisterLocalStorageHandler(mitk::BaseLocalStorageHandler *lsh)
{
m_RegisteredLocalStorageHandlers.remove(lsh);
}
void mitk::BaseRenderer::SetDataStorage(DataStorage *storage)
{
if (storage != m_DataStorage && storage != nullptr)
{
m_DataStorage = storage;
m_BindDispatcherInteractor->SetDataStorage(m_DataStorage);
this->Modified();
}
}
const mitk::BaseRenderer::MapperSlotId mitk::BaseRenderer::defaultMapper = 1;
void mitk::BaseRenderer::Paint()
{
}
void mitk::BaseRenderer::Initialize()
{
}
void mitk::BaseRenderer::Resize(int w, int h)
{
this->m_RenderWindow->SetSize(w, h);
}
void mitk::BaseRenderer::InitRenderer(vtkRenderWindow *renderwindow)
{
if (m_RenderWindow != renderwindow)
{
if (m_RenderWindow != nullptr)
{
m_RenderWindow->Delete();
}
m_RenderWindow = renderwindow;
if (m_RenderWindow != nullptr)
{
m_RenderWindow->Register(nullptr);
}
}
RemoveAllLocalStorages();
if (m_CameraController.IsNotNull())
{
m_CameraController->SetRenderer(this);
}
}
void mitk::BaseRenderer::InitSize(int w, int h)
{
this->m_RenderWindow->SetSize(w, h);
}
void mitk::BaseRenderer::SetSlice(unsigned int slice)
{
if (m_Slice != slice)
{
m_Slice = slice;
if (m_WorldTimeGeometry.IsNotNull())
{
// get world geometry which may be rotated, for the current time step
SlicedGeometry3D *slicedWorldGeometry =
dynamic_cast<SlicedGeometry3D *>(m_WorldTimeGeometry->GetGeometryForTimeStep(m_TimeStep).GetPointer());
if (slicedWorldGeometry != nullptr)
{
// if slice position is part of the world geometry...
if (m_Slice >= slicedWorldGeometry->GetSlices())
// set the current worldplanegeomety as the selected 2D slice of the world geometry
m_Slice = slicedWorldGeometry->GetSlices() - 1;
SetCurrentWorldPlaneGeometry(slicedWorldGeometry->GetPlaneGeometry(m_Slice));
SetCurrentWorldGeometry(slicedWorldGeometry);
}
}
else
Modified();
}
}
void mitk::BaseRenderer::SetTimeStep(unsigned int timeStep)
{
if (m_TimeStep != timeStep)
{
m_TimeStep = timeStep;
m_TimeStepUpdateTime.Modified();
if (m_WorldTimeGeometry.IsNotNull())
{
if (m_TimeStep >= m_WorldTimeGeometry->CountTimeSteps())
m_TimeStep = m_WorldTimeGeometry->CountTimeSteps() - 1;
SlicedGeometry3D *slicedWorldGeometry =
dynamic_cast<SlicedGeometry3D *>(m_WorldTimeGeometry->GetGeometryForTimeStep(m_TimeStep).GetPointer());
if (slicedWorldGeometry != nullptr)
{
SetCurrentWorldPlaneGeometry(slicedWorldGeometry->GetPlaneGeometry(m_Slice));
SetCurrentWorldGeometry(slicedWorldGeometry);
}
}
else
Modified();
}
}
-int mitk::BaseRenderer::GetTimeStep(const mitk::BaseData *data) const
+mitk::TimeStepType mitk::BaseRenderer::GetTimeStep(const mitk::BaseData *data) const
{
if ((data == nullptr) || (data->IsInitialized() == false))
{
return -1;
}
return data->GetTimeGeometry()->TimePointToTimeStep(GetTime());
}
mitk::ScalarType mitk::BaseRenderer::GetTime() const
{
if (m_WorldTimeGeometry.IsNull())
{
return 0;
}
else
{
ScalarType timeInMS = m_WorldTimeGeometry->TimeStepToTimePoint(GetTimeStep());
if (timeInMS == itk::NumericTraits<mitk::ScalarType>::NonpositiveMin())
return 0;
else
return timeInMS;
}
}
void mitk::BaseRenderer::SetWorldTimeGeometry(const mitk::TimeGeometry *geometry)
{
assert(geometry != nullptr);
itkDebugMacro("setting WorldTimeGeometry to " << geometry);
if (m_WorldTimeGeometry != geometry)
{
if (geometry->GetBoundingBoxInWorld()->GetDiagonalLength2() == 0)
return;
m_WorldTimeGeometry = geometry;
itkDebugMacro("setting WorldTimeGeometry to " << m_WorldTimeGeometry);
if (m_TimeStep >= m_WorldTimeGeometry->CountTimeSteps())
m_TimeStep = m_WorldTimeGeometry->CountTimeSteps() - 1;
BaseGeometry *geometry3d;
geometry3d = m_WorldTimeGeometry->GetGeometryForTimeStep(m_TimeStep);
SetWorldGeometry3D(geometry3d);
}
}
void mitk::BaseRenderer::SetWorldGeometry3D(const mitk::BaseGeometry *geometry)
{
itkDebugMacro("setting WorldGeometry3D to " << geometry);
if (geometry->GetBoundingBox()->GetDiagonalLength2() == 0)
return;
const SlicedGeometry3D *slicedWorldGeometry;
slicedWorldGeometry = dynamic_cast<const SlicedGeometry3D *>(geometry);
PlaneGeometry::ConstPointer geometry2d;
if (slicedWorldGeometry != nullptr)
{
if (m_Slice >= slicedWorldGeometry->GetSlices() && (m_Slice != 0))
m_Slice = slicedWorldGeometry->GetSlices() - 1;
geometry2d = slicedWorldGeometry->GetPlaneGeometry(m_Slice);
if (geometry2d.IsNull())
{
PlaneGeometry::Pointer plane = mitk::PlaneGeometry::New();
plane->InitializeStandardPlane(slicedWorldGeometry);
geometry2d = plane;
}
SetCurrentWorldGeometry(slicedWorldGeometry);
}
else
{
geometry2d = dynamic_cast<const PlaneGeometry *>(geometry);
if (geometry2d.IsNull())
{
PlaneGeometry::Pointer plane = PlaneGeometry::New();
plane->InitializeStandardPlane(geometry);
geometry2d = plane;
}
SetCurrentWorldGeometry(geometry);
}
SetCurrentWorldPlaneGeometry(geometry2d); // calls Modified()
if (m_CurrentWorldPlaneGeometry.IsNull())
itkWarningMacro("m_CurrentWorldPlaneGeometry is nullptr");
}
void mitk::BaseRenderer::SetCurrentWorldPlaneGeometry(const mitk::PlaneGeometry *geometry2d)
{
if (m_CurrentWorldPlaneGeometry != geometry2d)
{
m_CurrentWorldPlaneGeometry = geometry2d->Clone();
m_CurrentWorldPlaneGeometryData->SetPlaneGeometry(m_CurrentWorldPlaneGeometry);
m_CurrentWorldPlaneGeometryUpdateTime.Modified();
Modified();
}
}
void mitk::BaseRenderer::SendUpdateSlice()
{
m_CurrentWorldPlaneGeometryUpdateTime.Modified();
}
int *mitk::BaseRenderer::GetSize() const
{
return this->m_RenderWindow->GetSize();
}
int *mitk::BaseRenderer::GetViewportSize() const
{
return this->m_VtkRenderer->GetSize();
}
void mitk::BaseRenderer::SetCurrentWorldGeometry(const mitk::BaseGeometry *geometry)
{
m_CurrentWorldGeometry = geometry;
if (geometry == nullptr)
{
m_Bounds[0] = 0;
m_Bounds[1] = 0;
m_Bounds[2] = 0;
m_Bounds[3] = 0;
m_Bounds[4] = 0;
m_Bounds[5] = 0;
m_EmptyWorldGeometry = true;
return;
}
BoundingBox::Pointer boundingBox = m_CurrentWorldGeometry->CalculateBoundingBoxRelativeToTransform(nullptr);
const BoundingBox::BoundsArrayType &worldBounds = boundingBox->GetBounds();
m_Bounds[0] = worldBounds[0];
m_Bounds[1] = worldBounds[1];
m_Bounds[2] = worldBounds[2];
m_Bounds[3] = worldBounds[3];
m_Bounds[4] = worldBounds[4];
m_Bounds[5] = worldBounds[5];
if (boundingBox->GetDiagonalLength2() <= mitk::eps)
m_EmptyWorldGeometry = true;
else
m_EmptyWorldGeometry = false;
}
void mitk::BaseRenderer::SetGeometry(const itk::EventObject &geometrySendEvent)
{
const auto *sendEvent =
dynamic_cast<const SliceNavigationController::GeometrySendEvent *>(&geometrySendEvent);
assert(sendEvent != nullptr);
SetWorldTimeGeometry(sendEvent->GetTimeGeometry());
}
void mitk::BaseRenderer::UpdateGeometry(const itk::EventObject &geometryUpdateEvent)
{
const auto *updateEvent =
dynamic_cast<const SliceNavigationController::GeometryUpdateEvent *>(&geometryUpdateEvent);
if (updateEvent == nullptr)
return;
if (m_CurrentWorldGeometry.IsNotNull())
{
auto *slicedWorldGeometry = dynamic_cast<const SlicedGeometry3D *>(m_CurrentWorldGeometry.GetPointer());
if (slicedWorldGeometry)
{
PlaneGeometry *geometry2D = slicedWorldGeometry->GetPlaneGeometry(m_Slice);
SetCurrentWorldPlaneGeometry(geometry2D); // calls Modified()
}
}
}
void mitk::BaseRenderer::SetGeometrySlice(const itk::EventObject &geometrySliceEvent)
{
const auto *sliceEvent =
dynamic_cast<const SliceNavigationController::GeometrySliceEvent *>(&geometrySliceEvent);
assert(sliceEvent != nullptr);
SetSlice(sliceEvent->GetPos());
}
void mitk::BaseRenderer::SetGeometryTime(const itk::EventObject &geometryTimeEvent)
{
const auto *timeEvent =
dynamic_cast<const SliceNavigationController::GeometryTimeEvent *>(&geometryTimeEvent);
assert(timeEvent != nullptr);
SetTimeStep(timeEvent->GetPos());
}
const double *mitk::BaseRenderer::GetBounds() const
{
return m_Bounds;
}
void mitk::BaseRenderer::DrawOverlayMouse(mitk::Point2D &itkNotUsed(p2d))
{
MITK_INFO << "BaseRenderer::DrawOverlayMouse()- should be inconcret implementation OpenGLRenderer." << std::endl;
}
void mitk::BaseRenderer::RequestUpdate()
{
SetConstrainZoomingAndPanning(true);
RenderingManager::GetInstance()->RequestUpdate(this->m_RenderWindow);
}
void mitk::BaseRenderer::ForceImmediateUpdate()
{
RenderingManager::GetInstance()->ForceImmediateUpdate(this->m_RenderWindow);
}
unsigned int mitk::BaseRenderer::GetNumberOfVisibleLODEnabledMappers() const
{
return m_NumberOfVisibleLODEnabledMappers;
}
/*!
Sets the new Navigation controller
*/
void mitk::BaseRenderer::SetSliceNavigationController(mitk::SliceNavigationController *SlicenavigationController)
{
if (SlicenavigationController == nullptr)
return;
// copy worldgeometry
SlicenavigationController->SetInputWorldTimeGeometry(SlicenavigationController->GetCreatedWorldGeometry());
SlicenavigationController->Update();
// set new
m_SliceNavigationController = SlicenavigationController;
m_SliceNavigationController->SetRenderer(this);
if (m_SliceNavigationController.IsNotNull())
{
m_SliceNavigationController->ConnectGeometrySliceEvent(this);
m_SliceNavigationController->ConnectGeometryUpdateEvent(this);
m_SliceNavigationController->ConnectGeometryTimeEvent(this, false);
}
}
void mitk::BaseRenderer::DisplayToWorld(const Point2D &displayPoint, Point3D &worldIndex) const
{
if (m_MapperID == BaseRenderer::Standard2D)
{
double display[3], *world;
// For the rigth z-position in display coordinates, take the focal point, convert it to display and use it for
// correct depth.
double *displayCoord;
double cameraFP[4];
// Get camera focal point and position. Convert to display (screen)
// coordinates. We need a depth value for z-buffer.
this->GetVtkRenderer()->GetActiveCamera()->GetFocalPoint(cameraFP);
cameraFP[3] = 0.0;
this->GetVtkRenderer()->SetWorldPoint(cameraFP[0], cameraFP[1], cameraFP[2], cameraFP[3]);
this->GetVtkRenderer()->WorldToDisplay();
displayCoord = this->GetVtkRenderer()->GetDisplayPoint();
// now convert the display point to world coordinates
display[0] = displayPoint[0];
display[1] = displayPoint[1];
display[2] = displayCoord[2];
this->GetVtkRenderer()->SetDisplayPoint(display);
this->GetVtkRenderer()->DisplayToWorld();
world = this->GetVtkRenderer()->GetWorldPoint();
for (int i = 0; i < 3; i++)
{
worldIndex[i] = world[i] / world[3];
}
}
else if (m_MapperID == BaseRenderer::Standard3D)
{
PickWorldPoint(
displayPoint,
worldIndex); // Seems to be the same code as above, but subclasses may contain different implementations.
}
return;
}
void mitk::BaseRenderer::DisplayToPlane(const Point2D &displayPoint, Point2D &planePointInMM) const
{
if (m_MapperID == BaseRenderer::Standard2D)
{
Point3D worldPoint;
this->DisplayToWorld(displayPoint, worldPoint);
this->m_CurrentWorldPlaneGeometry->Map(worldPoint, planePointInMM);
}
else if (m_MapperID == BaseRenderer::Standard3D)
{
MITK_WARN << "No conversion possible with 3D mapper.";
return;
}
return;
}
void mitk::BaseRenderer::WorldToDisplay(const Point3D &worldIndex, Point2D &displayPoint) const
{
double world[4], *display;
world[0] = worldIndex[0];
world[1] = worldIndex[1];
world[2] = worldIndex[2];
world[3] = 1.0;
this->GetVtkRenderer()->SetWorldPoint(world);
this->GetVtkRenderer()->WorldToDisplay();
display = this->GetVtkRenderer()->GetDisplayPoint();
displayPoint[0] = display[0];
displayPoint[1] = display[1];
return;
}
void mitk::BaseRenderer::WorldToView(const mitk::Point3D &worldIndex, mitk::Point2D &viewPoint) const
{
double world[4], *view;
world[0] = worldIndex[0];
world[1] = worldIndex[1];
world[2] = worldIndex[2];
world[3] = 1.0;
this->GetVtkRenderer()->SetWorldPoint(world);
this->GetVtkRenderer()->WorldToView();
view = this->GetVtkRenderer()->GetViewPoint();
this->GetVtkRenderer()->ViewToNormalizedViewport(view[0], view[1], view[2]);
viewPoint[0] = view[0] * this->GetViewportSize()[0];
viewPoint[1] = view[1] * this->GetViewportSize()[1];
return;
}
void mitk::BaseRenderer::PlaneToDisplay(const Point2D &planePointInMM, Point2D &displayPoint) const
{
Point3D worldPoint;
this->m_CurrentWorldPlaneGeometry->Map(planePointInMM, worldPoint);
this->WorldToDisplay(worldPoint, displayPoint);
return;
}
void mitk::BaseRenderer::PlaneToView(const Point2D &planePointInMM, Point2D &viewPoint) const
{
Point3D worldPoint;
this->m_CurrentWorldPlaneGeometry->Map(planePointInMM, worldPoint);
this->WorldToView(worldPoint,viewPoint);
return;
}
double mitk::BaseRenderer::GetScaleFactorMMPerDisplayUnit() const
{
if (this->GetMapperID() == BaseRenderer::Standard2D)
{
// GetParallelScale returns half of the height of the render window in mm.
// Divided by the half size of the Display size in pixel givest the mm per pixel.
return this->GetVtkRenderer()->GetActiveCamera()->GetParallelScale() * 2.0 / GetViewportSize()[1];
}
else
return 1.0;
}
mitk::Point2D mitk::BaseRenderer::GetDisplaySizeInMM() const
{
Point2D dispSizeInMM;
dispSizeInMM[0] = GetSizeX() * GetScaleFactorMMPerDisplayUnit();
dispSizeInMM[1] = GetSizeY() * GetScaleFactorMMPerDisplayUnit();
return dispSizeInMM;
}
mitk::Point2D mitk::BaseRenderer::GetViewportSizeInMM() const
{
Point2D dispSizeInMM;
dispSizeInMM[0] = GetViewportSize()[0] * GetScaleFactorMMPerDisplayUnit();
dispSizeInMM[1] = GetViewportSize()[1] * GetScaleFactorMMPerDisplayUnit();
return dispSizeInMM;
}
mitk::Point2D mitk::BaseRenderer::GetOriginInMM() const
{
Point2D originPx;
originPx[0] = m_VtkRenderer->GetOrigin()[0];
originPx[1] = m_VtkRenderer->GetOrigin()[1];
Point2D displayGeometryOriginInMM;
DisplayToPlane(originPx, displayGeometryOriginInMM); // top left of the render window (Origin)
return displayGeometryOriginInMM;
}
void mitk::BaseRenderer::SetConstrainZoomingAndPanning(bool constrain)
{
m_ConstrainZoomingAndPanning = constrain;
if (m_ConstrainZoomingAndPanning)
{
this->GetCameraController()->AdjustCameraToPlane();
}
}
mitk::Point3D mitk::BaseRenderer::Map2DRendererPositionTo3DWorldPosition(const Point2D &mousePosition) const
{
// DEPRECATED: Map2DRendererPositionTo3DWorldPosition is deprecated. use DisplayToWorldInstead
Point3D position;
DisplayToWorld(mousePosition, position);
return position;
}
void mitk::BaseRenderer::PrintSelf(std::ostream &os, itk::Indent indent) const
{
os << indent << " MapperID: " << m_MapperID << std::endl;
os << indent << " Slice: " << m_Slice << std::endl;
os << indent << " TimeStep: " << m_TimeStep << std::endl;
os << indent << " CurrentWorldPlaneGeometry: ";
if (m_CurrentWorldPlaneGeometry.IsNull())
os << "nullptr" << std::endl;
else
m_CurrentWorldPlaneGeometry->Print(os, indent);
os << indent << " CurrentWorldPlaneGeometryUpdateTime: " << m_CurrentWorldPlaneGeometryUpdateTime << std::endl;
os << indent << " CurrentWorldPlaneGeometryTransformTime: " << m_CurrentWorldPlaneGeometryTransformTime << std::endl;
Superclass::PrintSelf(os, indent);
}
diff --git a/Modules/Core/test/mitkPreferenceListReaderOptionsFunctorTest.cpp b/Modules/Core/test/mitkPreferenceListReaderOptionsFunctorTest.cpp
index f81ee9152c..0559a8df0f 100644
--- a/Modules/Core/test/mitkPreferenceListReaderOptionsFunctorTest.cpp
+++ b/Modules/Core/test/mitkPreferenceListReaderOptionsFunctorTest.cpp
@@ -1,219 +1,219 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkPreferenceListReaderOptionsFunctor.h"
#include "mitkTestFixture.h"
#include "mitkTestingMacros.h"
#include <mitkAbstractFileReader.h>
#include <mitkCustomMimeType.h>
#include <mitkIOMimeTypes.h>
#include <usModuleContext.h>
#include <limits>
namespace mitk
{
class TestFileReaderService : public mitk::AbstractFileReader
{
public:
TestFileReaderService(const std::string &description)
: AbstractFileReader(CustomMimeType("TestMimeType"), description)
{
Options options;
options["o1"] = 0;
this->SetDefaultOptions(options);
m_ServiceRegistration = RegisterService();
};
~TestFileReaderService() override
{
};
using AbstractFileReader::Read;
std::vector<itk::SmartPointer<BaseData>> DoRead() override
{
std::vector<itk::SmartPointer<BaseData>> result;
return result;
};
ConfidenceLevel GetConfidenceLevel() const override
{
return Supported;
};
private:
TestFileReaderService * Clone() const override
{
return new TestFileReaderService(*this);
};
us::ServiceRegistration<IFileWriter> m_ServiceRegistration;
};
} // namespace mitk
class mitkPreferenceListReaderOptionsFunctorTestSuite : public mitk::TestFixture
{
CPPUNIT_TEST_SUITE(mitkPreferenceListReaderOptionsFunctorTestSuite);
MITK_TEST(UsePreferenceList);
MITK_TEST(UseBlackList);
MITK_TEST(UseNoList);
MITK_TEST(UseBlackAndPreferenceList);
MITK_TEST(UseOverlappingBlackAndPreferenceList);
MITK_TEST(UsePreferenceListWithInexistantReaders);
MITK_TEST(UseAllBlackedList);
MITK_TEST(SetOptions);
CPPUNIT_TEST_SUITE_END();
private:
std::string m_ImagePath;
mitk::PreferenceListReaderOptionsFunctor::ListType preference;
mitk::PreferenceListReaderOptionsFunctor::ListType black;
mitk::PreferenceListReaderOptionsFunctor::ListType emptyList;
mitk::TestFileReaderService* m_NormalService;
mitk::TestFileReaderService* m_PrefService;
mitk::TestFileReaderService* m_BlackService;
mitk::CustomMimeType* m_TestMimeType;
public:
void setUp() override
{
m_ImagePath = GetTestDataFilePath("BallBinary30x30x30.nrrd");
preference = { "Prefered Test Service" };
black = { "Unwanted Test Service" };
emptyList = {};
m_TestMimeType = new mitk::CustomMimeType("TestMimeType");
m_TestMimeType->AddExtension("nrrd");
m_TestMimeType->SetCategory(mitk::IOMimeTypes::CATEGORY_IMAGES());
m_TestMimeType->SetComment("Test mime type");
us::ModuleContext *context = us::GetModuleContext();
us::ServiceProperties props;
props[us::ServiceConstants::SERVICE_RANKING()] = 100;
context->RegisterService(m_TestMimeType, props);
m_NormalService = new mitk::TestFileReaderService("Normal Test Service");
m_PrefService = new mitk::TestFileReaderService("Prefered Test Service");
m_BlackService = new mitk::TestFileReaderService("Unwanted Test Service");
}
void tearDown() override
{
delete m_PrefService;
delete m_BlackService;
delete m_NormalService;
delete m_TestMimeType;
}
void UsePreferenceList()
{
mitk::IOUtil::LoadInfo info(m_ImagePath);
mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor(preference, emptyList);
CPPUNIT_ASSERT(true == functor(info));
auto description = info.m_ReaderSelector.GetSelected().GetDescription();
CPPUNIT_ASSERT_EQUAL(std::string("Prefered Test Service"), description);
CPPUNIT_ASSERT("0" == info.m_ReaderSelector.GetSelected().GetReader()->GetOptions()["o1"].ToString());
}
void UseNoList()
{
mitk::IOUtil::LoadInfo info(m_ImagePath);
mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor(emptyList, emptyList);
CPPUNIT_ASSERT(true == functor(info));
auto description = info.m_ReaderSelector.GetSelected().GetDescription();
CPPUNIT_ASSERT_EQUAL(std::string("Normal Test Service"), description);
}
void UseBlackList()
{
mitk::IOUtil::LoadInfo info(m_ImagePath);
mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor(emptyList, black);
CPPUNIT_ASSERT(true == functor(info));
auto description = info.m_ReaderSelector.GetSelected().GetDescription();
CPPUNIT_ASSERT(description != "Unwanted Test Service");
}
void UseBlackAndPreferenceList()
{
mitk::IOUtil::LoadInfo info(m_ImagePath);
mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor(preference, black);
CPPUNIT_ASSERT(true == functor(info));
auto description = info.m_ReaderSelector.GetSelected().GetDescription();
CPPUNIT_ASSERT_EQUAL(std::string("Prefered Test Service"), description);
}
void UseOverlappingBlackAndPreferenceList()
{
mitk::IOUtil::LoadInfo info(m_ImagePath);
black.push_back("Prefered Test Service");
black.push_back("Normal Test Service");
mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor(preference, black);
CPPUNIT_ASSERT(true == functor(info));
auto description = info.m_ReaderSelector.GetSelected().GetDescription();
CPPUNIT_ASSERT_EQUAL(std::string("ITK NrrdImageIO"), description);
}
void UsePreferenceListWithInexistantReaders()
{
mitk::IOUtil::LoadInfo info(m_ImagePath);
preference.push_back("InexistantReader");
mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor(preference, emptyList);
CPPUNIT_ASSERT(true == functor(info));
auto description = info.m_ReaderSelector.GetSelected().GetDescription();
CPPUNIT_ASSERT_EQUAL(std::string("Prefered Test Service"), description);
}
void UseAllBlackedList()
{
mitk::IOUtil::LoadInfo info(m_ImagePath);
- for (auto reader : info.m_ReaderSelector.Get())
+ for (const auto &reader : info.m_ReaderSelector.Get())
{
black.push_back(reader.GetDescription());
}
mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor(emptyList, black);
CPPUNIT_ASSERT_THROW(functor(info), mitk::Exception);
}
void SetOptions()
{
mitk::IOUtil::LoadInfo info(m_ImagePath);
mitk::IFileReader::Options options;
options.insert(std::make_pair("o1", 42));
mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor(preference, options);
CPPUNIT_ASSERT(true == functor(info));
auto description = info.m_ReaderSelector.GetSelected().GetDescription();
CPPUNIT_ASSERT_EQUAL(std::string("Prefered Test Service"), description);
CPPUNIT_ASSERT("42" == info.m_ReaderSelector.GetSelected().GetReader()->GetOption("o1").ToString());
}
};
MITK_TEST_SUITE_REGISTRATION(mitkPreferenceListReaderOptionsFunctor)
diff --git a/Modules/CoreCmdApps/CMakeLists.txt b/Modules/CoreCmdApps/CMakeLists.txt
index 12d751c887..5841e7e289 100644
--- a/Modules/CoreCmdApps/CMakeLists.txt
+++ b/Modules/CoreCmdApps/CMakeLists.txt
@@ -1,7 +1,6 @@
option(BUILD_CoreCmdApps "Build command-line apps of the MitkCore module" OFF)
if(BUILD_CoreCmdApps OR MITK_BUILD_ALL_APPS)
mitkFunctionCreateCommandLineApp(NAME FileConverter)
mitkFunctionCreateCommandLineApp(NAME ImageTypeConverter)
- mitkFunctionCreateCommandLineApp(NAME RectifyImage)
endif()
diff --git a/Modules/CoreCmdApps/RectifyImage.cpp b/Modules/CoreCmdApps/RectifyImage.cpp
deleted file mode 100644
index 664c13adb0..0000000000
--- a/Modules/CoreCmdApps/RectifyImage.cpp
+++ /dev/null
@@ -1,194 +0,0 @@
-/*===================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center,
-Division of Medical and Biological Informatics.
-All rights reserved.
-
-This software is distributed WITHOUT ANY WARRANTY; without
-even the implied warranty of MERCHANTABILITY or FITNESS FOR
-A PARTICULAR PURPOSE.
-
-See LICENSE.txt or http://www.mitk.org for details.
-
-===================================================================*/
-
-#include <mitkCommandLineParser.h>
-#include <mitkImagePixelReadAccessor.h>
-#include <mitkImagePixelWriteAccessor.h>
-#include <mitkIOUtil.h>
-
-template <typename TPixelType>
-void RectifyImage(mitk::Image::Pointer inputImage, mitk::Image::Pointer outputImage)
-{
- mitk::ImagePixelReadAccessor<TPixelType, 3> pixelReadAccess(inputImage);
- mitk::ImagePixelWriteAccessor<TPixelType, 3> pixelWriteAccess(outputImage);
-
- const auto DEPTH = static_cast<itk::IndexValueType>(outputImage->GetDimension(2));
- const auto HEIGHT = static_cast<itk::IndexValueType>(outputImage->GetDimension(1));
- const auto WIDTH = static_cast<itk::IndexValueType>(outputImage->GetDimension(0));
-
- auto geometry = outputImage->GetGeometry();
- itk::Index<3> index;
- mitk::Point3D worldCoords;
-
- for (index[2] = 0; index[2] < DEPTH; ++index[2])
- {
- for (index[1] = 0; index[1] < HEIGHT; ++index[1])
- {
- for (index[0] = 0; index[0] < WIDTH; ++index[0])
- {
- geometry->IndexToWorld(index, worldCoords);
- pixelWriteAccess.SetPixelByIndex(index, pixelReadAccess.GetPixelByWorldCoordinates(worldCoords));
- }
- }
- }
-}
-
-int main(int argc, char* argv[])
-{
- mitkCommandLineParser parser;
-
- parser.setTitle("Rectify Image");
- parser.setCategory("Basic Image Processing");
- parser.setDescription("Resample image based on standard world to index transform");
- parser.setContributor("German Cancer Research Center (DKFZ)");
-
- parser.setArgumentPrefix("--", "-");
- parser.addArgument("input", "i", mitkCommandLineParser::Image, "Input Image", "Path to input image", us::Any(), false);
- parser.addArgument("output", "o", mitkCommandLineParser::Image, "Output Image", "Path to output image", us::Any(), false);
-
- auto parsedArgs = parser.parseArguments(argc, argv);
-
- if (2 != parsedArgs.size() || 0 == parsedArgs.count("input") || 0 == parsedArgs.count("output"))
- return EXIT_FAILURE;
-
- auto inputImagePath = us::any_value_to_string(parsedArgs["input"]);
- mitk::Image::Pointer inputImage;
-
- try
- {
- inputImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(inputImagePath)[0].GetPointer());
- }
- catch (const mitk::Exception&)
- {
- return EXIT_FAILURE;
- }
-
- if (3 != inputImage->GetDimension())
- {
- MITK_ERROR << "Only 3-d images are supported.";
- return EXIT_FAILURE;
- }
-
- auto inputGeometry = inputImage->GetGeometry();
-
- mitk::Point3D minInputIndex;
- mitk::FillVector3D(minInputIndex, 0.0, 0.0, 0.0);
-
- mitk::Point3D minInputIndexInWorld;
- inputGeometry->IndexToWorld(minInputIndex, minInputIndexInWorld);
-
- mitk::Point3D maxInputIndex;
- for (int i = 0; i < 3; ++i)
- maxInputIndex[i] = inputGeometry->GetExtent(i) - 1;
-
- mitk::Point3D maxInputIndexInWorld;
- inputGeometry->IndexToWorld(maxInputIndex, maxInputIndexInWorld);
-
- mitk::Point3D minOutputIndexInWorld;
- for (int i = 0; i < 3; ++i)
- minOutputIndexInWorld[i] = std::min(minInputIndexInWorld[i], maxInputIndexInWorld[i]);
-
- mitk::Point3D maxOutputIndexInWorld;
- for (int i = 0; i < 3; ++i)
- maxOutputIndexInWorld[i] = std::max(minInputIndexInWorld[i], maxInputIndexInWorld[i]);
-
- mitk::Vector3D spacing = inputGeometry->GetSpacing();
- auto transform = inputGeometry->GetIndexToWorldTransform()->Clone();
- auto matrix = transform->GetMatrix();
-
- for (int i = 0; i < 3; ++i)
- {
- for (int j = 0; j < 3; ++j)
- {
- matrix[i][j] = std::abs(matrix[i][j]) / spacing[j];
- }
- }
-
- transform->SetMatrix(matrix);
- spacing = transform->TransformVector(spacing);
-
- mitk::Vector3D outputExtent = (maxOutputIndexInWorld - minOutputIndexInWorld + spacing);
- for (int i = 0; i < 3; ++i)
- outputExtent[i] /= spacing[i];
-
- mitk::Point3D origin = minOutputIndexInWorld;
-
- mitk::Vector3D right;
- mitk::FillVector3D(right, outputExtent[0], 0.0, 0.0);
-
- mitk::Vector3D down;
- mitk::FillVector3D(down, 0.0, outputExtent[1], 0.0);
-
- auto planeGeometry = mitk::PlaneGeometry::New();
- planeGeometry->InitializeStandardPlane(right, down, &spacing);
- planeGeometry->SetOrigin(origin);
- planeGeometry->SetImageGeometry(true);
-
- auto slicedGeometry = mitk::SlicedGeometry3D::New();
- slicedGeometry->InitializeEvenlySpaced(planeGeometry, static_cast<unsigned int>(outputExtent[2]));
-
- auto outputGeometry = mitk::ProportionalTimeGeometry::New();
- outputGeometry->SetTimeStepGeometry(slicedGeometry, 0);
-
- auto pixelType = inputImage->GetPixelType();
-
- auto outputImage = mitk::Image::New();
- outputImage->Initialize(pixelType, *outputGeometry);
-
- try
- {
- switch (pixelType.GetComponentType())
- {
- case itk::ImageIOBase::CHAR:
- RectifyImage<char>(inputImage, outputImage);
- break;
-
- case itk::ImageIOBase::UCHAR:
- RectifyImage<unsigned char>(inputImage, outputImage);
- break;
-
- case itk::ImageIOBase::SHORT:
- RectifyImage<short>(inputImage, outputImage);
- break;
-
- case itk::ImageIOBase::USHORT:
- RectifyImage<unsigned short>(inputImage, outputImage);
- break;
-
- default:
- MITK_ERROR << "Pixel type is not supported.";
- return EXIT_FAILURE;
- }
- }
- catch (const mitk::Exception &e)
- {
- MITK_ERROR << e.GetDescription();
- return EXIT_FAILURE;
- }
-
- auto outputImagePath = us::any_value_to_string(parsedArgs["output"]);
-
- try
- {
- mitk::IOUtil::Save(outputImage, outputImagePath);
- }
- catch (const mitk::Exception &)
- {
- return EXIT_FAILURE;
- }
-
- return EXIT_SUCCESS;
-}
diff --git a/Modules/CppMicroServices/CMakeLists.txt b/Modules/CppMicroServices/CMakeLists.txt
index fc114d6bdb..b801ea8334 100644
--- a/Modules/CppMicroServices/CMakeLists.txt
+++ b/Modules/CppMicroServices/CMakeLists.txt
@@ -1,444 +1,444 @@
project(CppMicroServices)
set(${PROJECT_NAME}_MAJOR_VERSION 2)
set(${PROJECT_NAME}_MINOR_VERSION 99)
set(${PROJECT_NAME}_PATCH_VERSION 0)
set(${PROJECT_NAME}_VERSION ${${PROJECT_NAME}_MAJOR_VERSION}.${${PROJECT_NAME}_MINOR_VERSION}.${${PROJECT_NAME}_PATCH_VERSION})
-cmake_minimum_required(VERSION 2.8)
-cmake_policy(VERSION 2.8)
+cmake_minimum_required(VERSION 2.8.12)
+cmake_policy(VERSION 2.8.12)
cmake_policy(SET CMP0017 NEW)
#-----------------------------------------------------------------------------
# Update CMake module path
#------------------------------------------------------------------------------
set(US_CMAKE_DIR ${PROJECT_SOURCE_DIR}/cmake)
set(CMAKE_MODULE_PATH
${US_CMAKE_DIR}
${CMAKE_MODULE_PATH}
)
#-----------------------------------------------------------------------------
# CMake function(s) and macro(s)
#-----------------------------------------------------------------------------
include(CMakeParseArguments)
include(CMakePackageConfigHelpers)
include(CheckCXXSourceCompiles)
include(usFunctionAddResources)
include(usFunctionEmbedResources)
include(usFunctionGetResourceSource)
include(usFunctionCheckResourceLinking)
include(usFunctionCheckCompilerFlags)
include(usFunctionGetGccVersion)
include(usFunctionGenerateModuleInit)
include(usMacroCreateModule)
if(US_BUILD_TESTING)
include(usFunctionCompileSnippets)
endif()
#-----------------------------------------------------------------------------
# Init output directories
#-----------------------------------------------------------------------------
set(US_ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib")
set(US_LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib")
set(US_RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/bin")
foreach(_type ARCHIVE LIBRARY RUNTIME)
if(NOT CMAKE_${_type}_OUTPUT_DIRECTORY)
set(CMAKE_${_type}_OUTPUT_DIRECTORY ${US_${_type}_OUTPUT_DIRECTORY})
endif()
endforeach()
#-----------------------------------------------------------------------------
# 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()
#-----------------------------------------------------------------------------
# CMake options
#-----------------------------------------------------------------------------
function(us_cache_var _var_name _var_default _var_type _var_help)
set(_advanced 0)
set(_force)
foreach(_argn ${ARGN})
if(_argn STREQUAL ADVANCED)
set(_advanced 1)
elseif(_argn STREQUAL FORCE)
set(_force FORCE)
endif()
endforeach()
if(US_IS_EMBEDDED)
if(NOT DEFINED ${_var_name} OR _force)
set(${_var_name} ${_var_default} PARENT_SCOPE)
endif()
else()
set(${_var_name} ${_var_default} CACHE ${_var_type} "${_var_help}" ${_force})
if(_advanced)
mark_as_advanced(${_var_name})
endif()
endif()
endfunction()
# Determine if we are being build inside a larger project
if(NOT DEFINED US_IS_EMBEDDED)
if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
set(US_IS_EMBEDDED 0)
else()
set(US_IS_EMBEDDED 1)
endif()
endif()
# Determine the name of the install component for "SDK" artifacts.
# The default is "sdk"
if(NOT DEFINED US_SDK_INSTALL_COMPONENT)
set(US_SDK_INSTALL_COMPONENT COMPONENT sdk)
elseif(US_SDK_INSTALL_COMPONENT)
set(US_SDK_INSTALL_COMPONENT COMPONENT ${US_SDK_INSTALL_COMPONENT})
endif()
us_cache_var(US_ENABLE_AUTOLOADING_SUPPORT OFF BOOL "Enable module auto-loading support")
us_cache_var(US_ENABLE_THREADING_SUPPORT OFF BOOL "Enable threading support")
us_cache_var(US_ENABLE_DEBUG_OUTPUT OFF BOOL "Enable debug messages" ADVANCED)
us_cache_var(US_BUILD_SHARED_LIBS ON BOOL "Build shared libraries")
us_cache_var(US_BUILD_TESTING OFF BOOL "Build tests")
us_cache_var(US_BUILD_EXAMPLES OFF BOOL "Build example projects")
if(US_BUILD_TESTING)
enable_testing()
endif()
if(WIN32 AND NOT CYGWIN)
set(default_runtime_install_dir bin/)
set(default_library_install_dir bin/)
set(default_archive_install_dir lib/)
set(default_header_install_dir include/)
set(default_auxiliary_install_dir share/)
else()
set(default_runtime_install_dir bin/)
set(default_library_install_dir lib/${PROJECT_NAME})
set(default_archive_install_dir lib/${PROJECT_NAME})
set(default_header_install_dir include/${PROJECT_NAME})
set(default_auxiliary_install_dir share/${PROJECT_NAME})
endif()
us_cache_var(RUNTIME_INSTALL_DIR ${default_runtime_install_dir} STRING "Relative install location for binaries" ADVANCED)
us_cache_var(LIBRARY_INSTALL_DIR ${default_library_install_dir} STRING "Relative install location for libraries" ADVANCED)
us_cache_var(ARCHIVE_INSTALL_DIR ${default_archive_install_dir} STRING "Relative install location for archives" ADVANCED)
us_cache_var(HEADER_INSTALL_DIR ${default_header_install_dir} STRING "Relative install location for headers" ADVANCED)
us_cache_var(AUXILIARY_INSTALL_DIR ${default_auxiliary_install_dir} STRING "Relative install location for auxiliary files" ADVANCED)
set(AUXILIARY_CMAKE_INSTALL_DIR ${AUXILIARY_INSTALL_DIR}/cmake)
us_cache_var(US_NAMESPACE "us" STRING "The namespace for the C++ Micro Services symbols")
set(BUILD_SHARED_LIBS ${US_BUILD_SHARED_LIBS})
set(US_MODULE_INIT_TEMPLATE "${US_CMAKE_DIR}/usModuleInit.cpp" CACHE INTERNAL "The module initialization template code")
set(US_RESOURCE_RC_TEMPLATE "${US_CMAKE_DIR}/us_resources.rc.in" CACHE INTERNAL "The Windows RC resource template")
set(US_CMAKE_RESOURCE_DEPENDENCIES_CPP "${US_CMAKE_DIR}/usCMakeResourceDependencies.cpp" CACHE INTERNAL "The dummy resource dependencies code")
#-----------------------------------------------------------------------------
# US C/CXX Flags
#-----------------------------------------------------------------------------
if(US_IS_EMBEDDED)
set(CMAKE_C_FLAGS)
set(CMAKE_C_FLAGS_RELEASE)
set(CMAKE_C_FLAGS_DEBUG)
set(CMAKE_CXX_FLAGS)
set(CMAKE_CXX_FLAGS_RELEASE)
set(CMAKE_CXX_FLAGS_DEBUG)
set(CMAKE_LINK_FLAGS)
set(CMAKE_LINK_FLAGS_RELEASE)
set(CMAKE_LINK_FLAGS_DEBUG)
endif()
# Set C++ compiler flags
if(NOT MSVC)
foreach(_cxxflag -Werror -Wall -Wextra -Wpointer-arith -Winvalid-pch -Wcast-align
-Wwrite-strings -Woverloaded-virtual -Wnon-virtual-dtor -Wold-style-cast
-Wstrict-null-sentinel -Wsign-promo -fdiagnostics-show-option -Wno-error=deprecated-copy
-Wno-error=implicit-int-float-conversion)
usFunctionCheckCompilerFlags(${_cxxflag} US_CXX_FLAGS)
endforeach()
endif()
set(US_HAVE_VISIBILITY_ATTRIBUTE 0)
usFunctionCheckCompilerFlags("-fvisibility=hidden -fvisibility-inlines-hidden" _have_visibility)
if(_have_visibility)
set(US_HAVE_VISIBILITY_ATTRIBUTE 1)
endif()
if(CMAKE_COMPILER_IS_GNUCXX)
usFunctionGetGccVersion(${CMAKE_CXX_COMPILER} GCC_VERSION)
if(${GCC_VERSION} VERSION_LESS "4.0.0")
message(FATAL_ERROR "gcc version ${GCC_VERSION} not supported. Please use gcc >= 4.")
endif()
# With older versions of gcc the flag -fstack-protector-all requires an extra dependency to libssp.so.
# If the gcc version is lower than 4.4.0 and the build type is Release let's not include the flag.
if(${GCC_VERSION} VERSION_GREATER "4.4.0" OR (CMAKE_BUILD_TYPE STREQUAL "Debug" AND ${GCC_VERSION} VERSION_LESS "4.4.0"))
usFunctionCheckCompilerFlags("-fstack-protector-all" US_CXX_FLAGS)
endif()
# Enable visibility support (only for gcc >= 4.5)
# We only support hidden visibility with gcc for now.
#
# Clang has troubles with correctly marking template declarations and explicit template
# instantiations as exported across shared library boundaries. Specifically, comparing
# type_info objects from STL types does not work (used in us::Any::Type() == typeid(std::string))
# which could be related to the default visibility of STL types declared in libstdc++ and/or libc++
# but also to using RTLD_LOCAL or RTLD_GLOBAL when loading shared libraries via dlopen().
#
# See http://comments.gmane.org/gmane.comp.compilers.clang.scm/50028
# and http://llvm.org/bugs/show_bug.cgi?id=10113
#
if(_have_visibility AND NOT ${GCC_VERSION} VERSION_LESS "4.5")
set(US_CXX_FLAGS "${US_CXX_FLAGS} ${_have_visibility}")
else()
set(US_GCC_RTTI_WORKAROUND_NEEDED 1)
endif()
usFunctionCheckCompilerFlags("-O1 -D_FORTIFY_SOURCE=2" _fortify_source_flag)
if(_fortify_source_flag)
set(US_CXX_FLAGS_RELEASE "${US_CXX_FLAGS_RELEASE} -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2")
endif()
endif()
if(MSVC)
set(US_CXX_FLAGS "/MP /WX /wd4180 /wd4996 /wd4251 /wd4503 ${US_CXX_FLAGS}")
endif()
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${US_CXX_FLAGS}")
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${US_CXX_FLAGS_RELEASE}")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${US_C_FLAGS}")
set(CMAKE_C_FLAGS_REALEASE "${CMAKE_C_FLAGS_RELEASE} ${US_C_FLAGS_RELEASE}")
#-----------------------------------------------------------------------------
# US Link Flags
#-----------------------------------------------------------------------------
set(US_LINK_FLAGS )
if(CMAKE_COMPILER_IS_GNUCXX AND NOT APPLE)
foreach(_linkflag -Wl,--no-undefined)
set(_add_flag)
usFunctionCheckCompilerFlags("${_linkflag}" _add_flag)
if(_add_flag)
set(US_LINK_FLAGS "${US_LINK_FLAGS} ${_linkflag}")
endif()
endforeach()
endif()
usFunctionCheckResourceLinking()
#-----------------------------------------------------------------------------
# US Header Checks
#-----------------------------------------------------------------------------
include(CheckIncludeFileCXX)
include(CheckCXXSourceCompiles)
CHECK_INCLUDE_FILE_CXX(cxxabi.h US_HAVE_CXXABI_H)
CHECK_INCLUDE_FILE_CXX(stdint.h US_HAVE_STDINT_H)
CHECK_INCLUDE_FILE_CXX(tr1/unordered_map US_HAVE_TR1_UNORDERED_MAP_H)
CHECK_INCLUDE_FILE_CXX(tr1/unordered_set US_HAVE_TR1_UNORDERED_SET_H)
CHECK_INCLUDE_FILE_CXX(tr1/functional US_HAVE_TR1_FUNCTIONAL_H)
CHECK_INCLUDE_FILE_CXX(unordered_map US_HAVE_UNORDERED_MAP_H)
CHECK_INCLUDE_FILE_CXX(unordered_set US_HAVE_UNORDERED_SET_H)
CHECK_INCLUDE_FILE_CXX(functional US_HAVE_FUNCTIONAL_H)
if(US_HAVE_UNORDERED_MAP_H)
CHECK_CXX_SOURCE_COMPILES("#include <unordered_map>\nint main() { std::tr1::unordered_map<int,int> m; return 0; }"
US_HAVE_TR1_UNORDERED_MAP)
CHECK_CXX_SOURCE_COMPILES("#include <unordered_map>\nint main() { std::unordered_map<int,int> m; return 0; }"
US_HAVE_STD_UNORDERED_MAP)
CHECK_CXX_SOURCE_COMPILES("#include <unordered_map>\nint main() { std::tr1::hash<int>(); return 0; }"
US_HAVE_TR1_HASH)
CHECK_CXX_SOURCE_COMPILES("#include <unordered_map>\nint main() { std::hash<int>(); return 0; }"
US_HAVE_STD_HASH)
if(US_HAVE_STD_HASH)
CHECK_CXX_SOURCE_COMPILES("#include <unordered_map>\nstruct A { friend struct std::hash<int>; }; int main() { return 0; }"
US_HAVE_STD_HASH_STRUCT)
CHECK_CXX_SOURCE_COMPILES("#include <unordered_map>\nstruct A { friend class std::hash<int>; }; int main() { return 0; }"
US_HAVE_STD_HASH_CLASS)
elseif(US_HAVE_TR1_HASH)
CHECK_CXX_SOURCE_COMPILES("#include <unordered_map>\nstruct A { friend struct std::tr1::hash<int>; }; int main() { return 0; }"
US_HAVE_TR1_HASH_STRUCT)
CHECK_CXX_SOURCE_COMPILES("#include <unordered_map>\nstruct A { friend class std::tr1::hash<int>; }; int main() { return 0; }"
US_HAVE_TR1_HASH_CLASS)
endif()
elseif(US_HAVE_TR1_UNORDERED_MAP_H)
CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_map>\nint main() { std::tr1::unordered_map<int,int> m; return 0; }"
US_HAVE_TR1_UNORDERED_MAP)
CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_map>\nint main() { std::unordered_map<int,int> m; return 0; }"
US_HAVE_STD_UNORDERED_MAP)
CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_map>\nint main() { std::tr1::hash<int>(); return 0; }"
US_HAVE_TR1_HASH)
CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_map>\nint main() { std::hash<int>(); return 0; }"
US_HAVE_STD_HASH)
if(US_HAVE_STD_HASH)
CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_map>\nstruct A { friend struct std::hash<int>; }; int main() { return 0; }"
US_HAVE_STD_HASH_STRUCT)
CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_map>\nstruct A { friend class std::hash<int>; }; int main() { return 0; }"
US_HAVE_STD_HASH_CLASS)
elseif(US_HAVE_TR1_HASH)
CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_map>\nstruct A { friend struct std::tr1::hash<int>; }; int main() { return 0; }"
US_HAVE_TR1_HASH_STRUCT)
CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_map>\nstruct A { friend class std::tr1::hash<int>; }; int main() { return 0; }"
US_HAVE_TR1_HASH_CLASS)
endif()
else()
message(SEND_ERROR "The header file \"unordered_map\" is not available.")
endif()
if(NOT (US_HAVE_TR1_UNORDERED_MAP OR US_HAVE_STD_UNORDERED_MAP))
message(SEND_ERROR "The \"unordered_map\" type is not available.")
endif()
if(US_HAVE_UNORDERED_SET_H)
CHECK_CXX_SOURCE_COMPILES("#include <unordered_set>\nint main() { std::tr1::unordered_set<int> s; return 0; }"
US_HAVE_TR1_UNORDERED_SET)
CHECK_CXX_SOURCE_COMPILES("#include <unordered_set>\nint main() { std::unordered_set<int> s; return 0; }"
US_HAVE_STD_UNORDERED_SET)
elseif(US_HAVE_TR1_UNORDERED_SET_H)
CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_set>\nint main() { std::tr1::unordered_set<int> s; return 0; }"
US_HAVE_TR1_UNORDERED_SET)
CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_set>\nint main() { std::unordered_set<int> s; return 0; }"
US_HAVE_STD_UNORDERED_SET)
else()
message(SEND_ERROR "The header file \"unordered_set\" is not available.")
endif()
if(NOT (US_HAVE_TR1_UNORDERED_SET OR US_HAVE_STD_UNORDERED_SET))
message(SEND_ERROR "The \"unordered_set\" type is not available.")
endif()
if(NOT (US_HAVE_FUNCTIONAL_H OR US_HAVE_TR1_FUNCTIONAL_H))
message(SEND_ERROR "The header file \"functional\" is not available.")
endif()
if(US_HAVE_FUNCTIONAL_H)
CHECK_CXX_SOURCE_COMPILES("#include <functional>\nint main() { std::tr1::function<int(void)> f(main); return 0; }"
US_HAVE_TR1_FUNCTION)
CHECK_CXX_SOURCE_COMPILES("#include <functional>\nint main() { std::function<int(void)> f(main); return 0; }"
US_HAVE_STD_FUNCTION)
endif()
if((NOT (US_HAVE_STD_FUNCTION OR US_HAVE_TR1_FUNCTION)) AND US_HAVE_TR1_FUNCTIONAL_H)
unset(US_HAVE_TR1_FUNCTION CACHE)
unset(US_HAVE_STD_FUNCTION CACHE)
CHECK_CXX_SOURCE_COMPILES("#include <tr1/functional>\nint main() { std::tr1::function<int(void)> f(main); return 0; }"
US_HAVE_TR1_FUNCTION)
CHECK_CXX_SOURCE_COMPILES("#include <tr1/functional>\nint main() { std::function<int(void)> f(main); return 0; }"
US_HAVE_STD_FUNCTION)
endif()
if(NOT (US_HAVE_STD_FUNCTION OR US_HAVE_TR1_FUNCTION))
message(SEND_ERROR "The \"function\" type is not available.")
endif()
#-----------------------------------------------------------------------------
# Source directory
#-----------------------------------------------------------------------------
set(US_INCLUDE_DIRS ${PROJECT_SOURCE_DIR}/third_party ${PROJECT_BINARY_DIR}/include)
# Configure CppMicroServicesConfig.cmake for the build tree.
# The file is used in sub-directories.
set(PACKAGE_CONFIG_INCLUDE_DIR ${US_INCLUDE_DIRS})
set(PACKAGE_CONFIG_RUNTIME_DIR ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
set(PACKAGE_CONFIG_CMAKE_DIR ${US_CMAKE_DIR})
set(US_RCC_EXECUTABLE_NAME usResourceCompiler CACHE INTERNAL "The target name of the usResourceCompiler executable.")
configure_file(
${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}Config.cmake.in
${PROJECT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
@ONLY
)
set(us_global_config_h_file "${PROJECT_BINARY_DIR}/include/usGlobalConfig.h")
configure_file(${US_CMAKE_DIR}/usGlobalConfig.h.in ${us_global_config_h_file})
include_directories(${US_INCLUDE_DIRS})
add_subdirectory(tools)
add_subdirectory(core)
#-----------------------------------------------------------------------------
# Documentation
#-----------------------------------------------------------------------------
add_subdirectory(doc)
#-----------------------------------------------------------------------------
# Last configuration and install steps
#-----------------------------------------------------------------------------
# Version information
configure_file(
${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}ConfigVersion.cmake.in
${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
@ONLY
)
export(TARGETS ${US_RCC_EXECUTABLE_NAME}
FILE ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Targets.cmake)
if(NOT US_NO_INSTALL)
install(EXPORT ${PROJECT_NAME}Targets
FILE ${PROJECT_NAME}Targets.cmake
DESTINATION ${AUXILIARY_CMAKE_INSTALL_DIR})
set(_install_cmake_scripts
${US_MODULE_INIT_TEMPLATE}
${US_CMAKE_RESOURCE_DEPENDENCIES_CPP}
${US_CMAKE_DIR}/usFunctionGenerateModuleInit.cmake
${US_CMAKE_DIR}/usFunctionAddResources.cmake
${US_CMAKE_DIR}/usFunctionEmbedResources.cmake
${US_CMAKE_DIR}/usFunctionGetResourceSource.cmake
${US_CMAKE_DIR}/usFunctionCheckResourceLinking.cmake
${US_CMAKE_DIR}/usFunctionCheckCompilerFlags.cmake
)
install(FILES ${_install_cmake_scripts}
DESTINATION ${AUXILIARY_CMAKE_INSTALL_DIR})
install(FILES ${us_global_config_h_file}
DESTINATION ${HEADER_INSTALL_DIR})
# Configure CppMicroServicesConfig.cmake for the install tree
set(CONFIG_INCLUDE_DIR ${HEADER_INSTALL_DIR})
set(CONFIG_RUNTIME_DIR ${RUNTIME_INSTALL_DIR})
set(CONFIG_CMAKE_DIR ${AUXILIARY_CMAKE_INSTALL_DIR})
configure_package_config_file(
${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}Config.cmake.in
${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/${PROJECT_NAME}Config.cmake
INSTALL_DESTINATION ${AUXILIARY_CMAKE_INSTALL_DIR}
PATH_VARS CONFIG_INCLUDE_DIR CONFIG_RUNTIME_DIR CONFIG_CMAKE_DIR
NO_SET_AND_CHECK_MACRO
NO_CHECK_REQUIRED_COMPONENTS_MACRO
)
install(FILES ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/${PROJECT_NAME}Config.cmake
${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
DESTINATION ${AUXILIARY_CMAKE_INSTALL_DIR}
${US_SDK_INSTALL_COMPONENT}
)
endif()
diff --git a/Modules/CppMicroServices/core/doc/doxygen/MicroServices_Resources.md b/Modules/CppMicroServices/core/doc/doxygen/MicroServices_Resources.md
index c18d3bb0c9..9cb2102f78 100644
--- a/Modules/CppMicroServices/core/doc/doxygen/MicroServices_Resources.md
+++ b/Modules/CppMicroServices/core/doc/doxygen/MicroServices_Resources.md
@@ -1,75 +1,75 @@
The Resources System {#MicroServices_Resources}
====================
The C++ Micro Services library provides a generic resources system to embed arbitrary files into a
module's shared library (the size limitation per resource is 2GB, due to the used ZIP format).
The following features are supported:
* Embed arbitrary data into shared or static modules or executables.
* Data is embedded in a compressed format (zip) with a configurable compression level.
* Resources are accessed via a Module instance, providing individual resource lookup and access
for each module.
* Resources are managed in a tree hierarchy, modeling the original child - parent relationship
on the file-system.
* The ModuleResource class provides a high-level API for accessing resource information and
traversing the resource tree.
* The ModuleResourceStream class provides an STL input stream derived class for the seamless usage
of embedded resource data in third-party libraries.
The following conventions and limitations apply:
* Resource entries are stored with case-insensitive names. On case-sensitive file systemes,
adding resources with the same name but different capitalization will lead to an error.
* Looking up resources by name at runtime *is* case sensitive.
* The CppMicroServices library will search for a valid zip file inside a shared library,
starting from the end of the file. If other zip files are embedded in the module as
well (e.g. as an additional resource embedded via the Windows RC compiler or using
other techniques), it will stop at the first valid zip file and use it a the resource
container.
Embedding Resources in a %Module
--------------------------------
Resources are embedded into a module's shared or static library (or into an executable)
by using the `usResourceCompiler` executable. It will create a ZIP archive of all input
files and can append it to the module file.
-If you are using CMake, consider using the provided `#usFunctionEmbedResources` CMake macro which
+If you are using CMake, consider using the provided `usFunctionEmbedResources` CMake macro which
handles the invocation of the `usResourceCompiler` executable and sets up the correct file
dependencies. Otherwise, you also need to make sure that the set of static modules linked
into a shared module or executable is also in the input file list of your `usResourceCompiler`
call for that shared module or executable.
Here is a full example creating a module and embedding resource data:
\include uServices-resources-cmake/CMakeLists_example.txt
Accessing Resources at Runtime
------------------------------
Each module provides access to its embedded resources via the Module class which provides methods
returning ModuleResource objects. The ModuleResourceStream class provides a std::istream compatible
object to access the resource contents.
The following example shows how to retrieve a resource from each currently loaded module whose path
is specified by a module property:
\snippet uServices-resources/main.cpp 2
This example could be enhanced to dynamically react to modules being loaded and unloaded, making use
of the popular "extender pattern" from OSGi.
Runtime overhead
----------------
The resources system has the following runtime characteristics:
* During static initialization of a module, it's ZIP archive header data (if available)
is parsed and stored in memory.
* Querying `Module` or `ModuleResource` objects for resource information will not
extract the embedded resource data and hence only has minimal runtime and memory
overhead.
* Creating a `ModuleResourceStream` object will allocate memory for the uncompressed
resource data and inflate it. The memory will be free'ed after the `ModuleResourceStream`
object is destroyed.
diff --git a/Modules/CppMicroServices/core/doc/doxygen/MicroServices_TheModuleContext.md b/Modules/CppMicroServices/core/doc/doxygen/MicroServices_TheModuleContext.md
index d3dd740cc0..15df41382c 100644
--- a/Modules/CppMicroServices/core/doc/doxygen/MicroServices_TheModuleContext.md
+++ b/Modules/CppMicroServices/core/doc/doxygen/MicroServices_TheModuleContext.md
@@ -1,38 +1,38 @@
The Module Context {#MicroServices_TheModuleContext}
===================
In the context of the C++ Micro Services library, we will call all supported "shared library" types
(DLL, DSO, DyLib, etc.) uniformly a *module*. A module accesses the C++ Micro Services API via a
ModuleContext object, which is specific to each module.
### Creating a ModuleContext
To create a ModuleContext object for a specific library, you have two options. If your project uses
-CMake as the build system, use the supplied `#usFunctionGenerateModuleInit` CMake function to automatically
+CMake as the build system, use the supplied `usFunctionGenerateModuleInit` CMake function to automatically
create a source file and add it to your module's sources:
~~~{.cpp}
set(module_srcs )
usFunctionGenerateModuleInit(module_srcs)
add_library(mylib ${module_srcs})
set_property(TARGET ${mylib} APPEND PROPERTY COMPILE_DEFINITIONS US_MODULE_NAME=mylib)
~~~
You also need to specify a unique module name by using the `US_MODULE_NAME` compile definition as
shown in the last line. The module name must be a valid C identifier and in the case of
executables is required to be defined to `main`.
If you do not use CMake, you have to add a call to the macro `#US_INITIALIZE_MODULE` in one of the source
files of your module:
\snippet uServices-modulecontext/main.cpp InitializeModule
### Getting a ModuleContext
To retrieve the module specific ModuleContext object from anywhere in your module, use the
-`#GetModuleContext` function:
+`GetModuleContext` function:
\snippet uServices-modulecontext/main.cpp GetModuleContext
-Please note that trying to use `#GetModuleContext` without proper initialization code
+Please note that trying to use `GetModuleContext` without proper initialization code
in the using shared library while either lead to compile or rumtime errors.
diff --git a/Modules/CppMicroServices/core/doc/doxygen/examples/MicroServices_Example1.md b/Modules/CppMicroServices/core/doc/doxygen/examples/MicroServices_Example1.md
index 8b684bd413..afc7f9c11a 100644
--- a/Modules/CppMicroServices/core/doc/doxygen/examples/MicroServices_Example1.md
+++ b/Modules/CppMicroServices/core/doc/doxygen/examples/MicroServices_Example1.md
@@ -1,97 +1,97 @@
Example 1 - Service Event Listener {#MicroServices_Example1}
==================================
This example creates a simple module that listens for service events.
This example does not do much at first, because it only prints out the details
of registering and unregistering services. In the next example we will create
a module that implements a service, which will cause this module to actually
do something. For now, we will just use this example to help us understand the
basics of creating a module and its activator.
A module gains access to the C++ Micro Services API using a unique instance
of ModuleContext. This unique module context can be used during static
initialization of the module or at any later point during the life-time of the
module. To execute code during static initialization (and de-initialization)
time, the module must provide an implementation of the ModuleActivator interface;
this interface has two methods, Load() and Unload(), that both receive the
module's context and are called when the module is loaded (statically initialized)
and unloaded, respectively.
\note You do not need to remember the ModuleContext instance within the
ModuleActivator::Load() method and provide custom access methods for later
retrieval. Use the GetModuleContext() function to easily retrieve the current
module's context.
In the following source code, our module implements
the ModuleActivator interface and uses the context to add itself as a listener
for service events (in the `eventlistener/Activator.cpp` file):
\snippet eventlistener/Activator.cpp Activator
After implementing the C++ source code for the module activator, we must *export*
the activator such that the C++ Micro Services library can create an instance
of it and call the `Load()` and `Unload()` methods:
\dontinclude eventlistener/Activator.cpp
\skipline US_EXPORT
Now we need to compile the source code. This example uses CMake as the build
system and the top-level CMakeLists.txt file could look like this:
\dontinclude core/examples/CMakeLists.txt
\skip project
\until eventlistener
and the CMakeLists.txt file in the eventlistener subdirectory is:
\include eventlistener/CMakeLists.txt
-The call to `#usFunctionGenerateModuleInit` is necessary to integrate the shared
+The call to `usFunctionGenerateModuleInit` is necessary to integrate the shared
library as a module within the C++ Micro Service library. If you are not using
CMake, you have to place a macro call to `#US_INITIALIZE_MODULE` yourself into the
module's source code, e.g. in `Activator.cpp`. Have a look at the
Getting Started documentation for more details about using CMake
or other build systems (e.g. Makefiles) when writing modules.
To run the examples contained in the C++ Micro Services library, we use a small
driver program called `usCoreExamplesDriver`:
\verbatim
CppMicroServices-build> bin/usCoreExamplesDriver
> h
h This help text
l <id | name> Load the module with id <id> or name <name>
u <id> Unload the module with id <id>
s Print status information
q Quit
>
\endverbatim
Typing `s` at the command prompt lists the available, loaded, and unloaded modules.
To load the eventlistener module, type `l eventlistener` at the command prompt:
\verbatim
> s
Id | Name | Status
-----------------------------------
- | dictionaryclient | -
- | dictionaryclient2 | -
- | dictionaryclient3 | -
- | dictionaryservice | -
- | eventlistener | -
- | frenchdictionary | -
- | spellcheckclient | -
- | spellcheckservice | -
1 | CppMicroServices | LOADED
> l eventlistener
Starting to listen for service events.
>
\endverbatim
The above command loaded the eventlistener module (by loading its shared library).
Keep in mind, that this module will not do much at this point since it only
listens for service events and we are not registering any services. In the next
example we will register a service that will generate an event for this module to
receive. To exit the `usCoreExamplesDriver`, use the `q` command.
Next: \ref MicroServices_Example2
diff --git a/Modules/DICOM/autoload/DICOMImageIO/src/mitkDICOMImageIOActivator.cpp b/Modules/DICOM/autoload/DICOMImageIO/src/mitkDICOMImageIOActivator.cpp
index 95ea5f389d..785e1c0791 100644
--- a/Modules/DICOM/autoload/DICOMImageIO/src/mitkDICOMImageIOActivator.cpp
+++ b/Modules/DICOM/autoload/DICOMImageIO/src/mitkDICOMImageIOActivator.cpp
@@ -1,123 +1,123 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkDICOMImageIOActivator.h"
#include "mitkAutoSelectingDICOMReaderService.h"
#include "mitkManualSelectingDICOMReaderService.h"
#include "mitkDICOMTagsOfInterestService.h"
#include "mitkSimpleVolumeDICOMSeriesReaderService.h"
#include "mitkCoreServices.h"
#include "mitkPropertyPersistenceInfo.h"
#include "mitkDICOMIOMetaInformationPropertyConstants.h"
#include "mitkIPropertyPersistence.h"
#include "mitkTemporoSpatialStringProperty.h"
#include <usModuleContext.h>
#include <usModuleRegistry.h>
void AddPropertyPersistence(const mitk::PropertyKeyPath& propPath, bool temporoSpatial = false)
{
mitk::CoreServicePointer<mitk::IPropertyPersistence> persistenceService(mitk::CoreServices::GetPropertyPersistence());
mitk::PropertyPersistenceInfo::Pointer info = mitk::PropertyPersistenceInfo::New();
if (propPath.IsExplicit())
{
std::string name = mitk::PropertyKeyPathToPropertyName(propPath);
std::string key = name;
std::replace(key.begin(), key.end(), '.', '_');
info->SetNameAndKey(name, key);
}
else
{
std::string key = mitk::PropertyKeyPathToPersistenceKeyRegEx(propPath);
std::string keyTemplate = mitk::PropertyKeyPathToPersistenceKeyTemplate(propPath);
std::string propRegEx = mitk::PropertyKeyPathToPropertyRegEx(propPath);
std::string propTemplate = mitk::PropertyKeyPathToPersistenceNameTemplate(propPath);
info->UseRegEx(propRegEx, propTemplate, key, keyTemplate);
}
if (temporoSpatial)
{
info->SetDeserializationFunction(mitk::PropertyPersistenceDeserialization::deserializeJSONToTemporoSpatialStringProperty);
info->SetSerializationFunction(mitk::PropertyPersistenceSerialization::serializeTemporoSpatialStringPropertyToJSON);
}
persistenceService->AddInfo(info);
}
namespace mitk {
void DICOMImageIOActivator::Load(us::ModuleContext* context)
{
m_Context = context;
m_AutoSelectingDICOMReader = std::make_unique<AutoSelectingDICOMReaderService>();
m_SimpleVolumeDICOMSeriesReader = std::make_unique<SimpleVolumeDICOMSeriesReaderService>();
m_DICOMTagsOfInterestService = std::make_unique<DICOMTagsOfInterestService>();
context->RegisterService<mitk::IDICOMTagsOfInterest>(m_DICOMTagsOfInterestService.get());
DICOMTagPathMapType tagmap = GetDefaultDICOMTagsOfInterest();
- for (auto tag : tagmap)
+ for (const auto &tag : tagmap)
{
m_DICOMTagsOfInterestService->AddTagOfInterest(tag.first);
}
//add properties that should be persistent (if possible/supported by the writer)
AddPropertyPersistence(mitk::DICOMIOMetaInformationPropertyConstants::READER_3D_plus_t());
AddPropertyPersistence(mitk::DICOMIOMetaInformationPropertyConstants::READER_CONFIGURATION());
AddPropertyPersistence(mitk::DICOMIOMetaInformationPropertyConstants::READER_DCMTK());
AddPropertyPersistence(mitk::DICOMIOMetaInformationPropertyConstants::READER_FILES(), true);
AddPropertyPersistence(mitk::DICOMIOMetaInformationPropertyConstants::READER_GANTRY_TILT_CORRECTED());
AddPropertyPersistence(mitk::DICOMIOMetaInformationPropertyConstants::READER_GDCM());
AddPropertyPersistence(mitk::DICOMIOMetaInformationPropertyConstants::READER_IMPLEMENTATION_LEVEL());
AddPropertyPersistence(mitk::DICOMIOMetaInformationPropertyConstants::READER_IMPLEMENTATION_LEVEL_STRING());
AddPropertyPersistence(mitk::DICOMIOMetaInformationPropertyConstants::READER_PIXEL_SPACING_INTERPRETATION());
AddPropertyPersistence(mitk::DICOMIOMetaInformationPropertyConstants::READER_PIXEL_SPACING_INTERPRETATION_STRING());
//We have to handle ManualSelectingDICOMSeriesReader different then the other
//readers. Reason: The reader uses DICOMFileReaderSelector in its constructor.
//this class needs to access resources of MitkDICOM module, which might
//not be initialized yet (that would lead to a crash, see i.a. T27553). Thus check if the module
//is alreade loaded. If not, register a listener and create the reader as soon
//as the module is available.
auto dicomModule = us::ModuleRegistry::GetModule("MitkDICOM");
if (nullptr == dicomModule)
{
std::lock_guard<std::mutex> lock(m_Mutex);
// Listen for events of module life cycle.
m_Context->AddModuleListener(this, &DICOMImageIOActivator::EnsureManualSelectingDICOMSeriesReader);
}
else
{
m_ManualSelectingDICOMSeriesReader = std::make_unique<ManualSelectingDICOMReaderService>();
}
}
void DICOMImageIOActivator::Unload(us::ModuleContext*)
{
}
void DICOMImageIOActivator::EnsureManualSelectingDICOMSeriesReader(const us::ModuleEvent event)
{
//We have to handle ManualSelectingDICOMSeriesReader different then the other
//readers. For more details see the explanations in the constructor.
std::lock_guard<std::mutex> lock(m_Mutex);
if (nullptr == m_ManualSelectingDICOMSeriesReader && event.GetModule()->GetName()=="MitkDICOM" && event.GetType() == us::ModuleEvent::LOADED)
{
m_ManualSelectingDICOMSeriesReader = std::make_unique<ManualSelectingDICOMReaderService>();
}
}
}
US_EXPORT_MODULE_ACTIVATOR(mitk::DICOMImageIOActivator)
diff --git a/Modules/DICOM/src/mitkDICOMFilesHelper.cpp b/Modules/DICOM/src/mitkDICOMFilesHelper.cpp
index 5cd3ed1ba2..d3e3d09f45 100644
--- a/Modules/DICOM/src/mitkDICOMFilesHelper.cpp
+++ b/Modules/DICOM/src/mitkDICOMFilesHelper.cpp
@@ -1,80 +1,80 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkDICOMFilesHelper.h"
#include <itkGDCMImageIO.h>
#include <itksys/SystemTools.hxx>
#include <gdcmDirectory.h>
#include <gdcmScanner.h>
mitk::DICOMFilePathList mitk::GetDICOMFilesInSameDirectory(const std::string& filePath)
{
DICOMFilePathList result;
if (!filePath.empty())
{
std::string dir = filePath;
if (!itksys::SystemTools::FileIsDirectory(filePath))
{
dir = itksys::SystemTools::GetFilenamePath(filePath);
}
gdcm::Directory directoryLister;
directoryLister.Load(dir.c_str(), false); // non-recursive
result = FilterForDICOMFiles(directoryLister.GetFilenames());
}
return result;
};
mitk::DICOMFilePathList mitk::FilterForDICOMFiles(const DICOMFilePathList& fileList)
{
mitk::DICOMFilePathList result;
itk::GDCMImageIO::Pointer io = itk::GDCMImageIO::New();
- for (auto aFile : fileList)
+ for (const auto &aFile : fileList)
{
if (io->CanReadFile(aFile.c_str()))
{
result.push_back(aFile);
}
}
return result;
};
mitk::DICOMFilePathList mitk::FilterDICOMFilesForSameSeries(const std::string& refFilePath, const DICOMFilePathList& fileList)
{
auto dicomFiles = FilterForDICOMFiles(fileList);
//use the gdcm scanner directly instead of our wrapping classes, as it is a very simple task
//and I want to spare the indirection/overhead.
gdcm::Scanner scanner;
const gdcm::Tag seriesInstanceUIDTag(0x0020, 0x000e);
scanner.AddTag(seriesInstanceUIDTag); //Series Instance UID;
scanner.Scan({ refFilePath });
auto uid = scanner.GetValue(refFilePath.c_str(), seriesInstanceUIDTag);
if (uid != nullptr)
{
const std::string refUID = uid;
scanner.Scan(dicomFiles);
return scanner.GetAllFilenamesFromTagToValue(seriesInstanceUIDTag, refUID.c_str());
}
return mitk::DICOMFilePathList();
}
diff --git a/Modules/DICOM/src/mitkDICOMImageBlockDescriptor.cpp b/Modules/DICOM/src/mitkDICOMImageBlockDescriptor.cpp
index 69ca0c9109..df4fa8ed0a 100644
--- a/Modules/DICOM/src/mitkDICOMImageBlockDescriptor.cpp
+++ b/Modules/DICOM/src/mitkDICOMImageBlockDescriptor.cpp
@@ -1,913 +1,913 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkDICOMImageBlockDescriptor.h"
#include "mitkStringProperty.h"
#include "mitkLevelWindowProperty.h"
#include "mitkPropertyKeyPath.h"
#include "mitkDICOMIOMetaInformationPropertyConstants.h"
#include <gdcmUIDs.h>
#include <vector>
#include <gdcmVersion.h>
#include <dcmtk/config/osconfig.h>
mitk::DICOMImageBlockDescriptor::DICOMImageBlockDescriptor()
: m_ReaderImplementationLevel( SOPClassUnknown )
, m_PropertyList( PropertyList::New() )
, m_TagCache( nullptr )
, m_PropertiesOutOfDate( true )
{
m_PropertyFunctor = &mitk::DICOMImageBlockDescriptor::GetPropertyForDICOMValues;
}
mitk::DICOMImageBlockDescriptor::~DICOMImageBlockDescriptor()
{
}
mitk::DICOMImageBlockDescriptor::DICOMImageBlockDescriptor( const DICOMImageBlockDescriptor& other )
: m_ImageFrameList( other.m_ImageFrameList )
, m_MitkImage( other.m_MitkImage )
, m_SliceIsLoaded( other.m_SliceIsLoaded )
, m_ReaderImplementationLevel( other.m_ReaderImplementationLevel )
, m_TiltInformation( other.m_TiltInformation )
, m_PropertyList( other.m_PropertyList->Clone() )
, m_TagCache( other.m_TagCache )
, m_PropertiesOutOfDate( other.m_PropertiesOutOfDate )
, m_AdditionalTagMap(other.m_AdditionalTagMap)
, m_FoundAdditionalTags(other.m_FoundAdditionalTags)
, m_PropertyFunctor(other.m_PropertyFunctor)
{
if ( m_MitkImage )
{
m_MitkImage = m_MitkImage->Clone();
}
}
mitk::DICOMImageBlockDescriptor& mitk::DICOMImageBlockDescriptor::
operator=( const DICOMImageBlockDescriptor& other )
{
if ( this != &other )
{
m_ImageFrameList = other.m_ImageFrameList;
m_MitkImage = other.m_MitkImage;
m_SliceIsLoaded = other.m_SliceIsLoaded;
m_ReaderImplementationLevel = other.m_ReaderImplementationLevel;
m_TiltInformation = other.m_TiltInformation;
m_AdditionalTagMap = other.m_AdditionalTagMap;
m_FoundAdditionalTags = other.m_FoundAdditionalTags;
m_PropertyFunctor = other.m_PropertyFunctor;
if ( other.m_PropertyList )
{
m_PropertyList = other.m_PropertyList->Clone();
}
if ( other.m_MitkImage )
{
m_MitkImage = other.m_MitkImage->Clone();
}
m_TagCache = other.m_TagCache;
m_PropertiesOutOfDate = other.m_PropertiesOutOfDate;
}
return *this;
}
mitk::DICOMTagList mitk::DICOMImageBlockDescriptor::GetTagsOfInterest()
{
DICOMTagList completeList;
completeList.push_back( DICOMTag( 0x0018, 0x1164 ) ); // pixel spacing
completeList.push_back( DICOMTag( 0x0028, 0x0030 ) ); // imager pixel spacing
completeList.push_back( DICOMTag( 0x0008, 0x0018 ) ); // sop instance UID
completeList.push_back( DICOMTag( 0x0008, 0x0016 ) ); // sop class UID
completeList.push_back( DICOMTag( 0x0020, 0x0011 ) ); // series number
completeList.push_back( DICOMTag( 0x0008, 0x1030 ) ); // study description
completeList.push_back( DICOMTag( 0x0008, 0x103e ) ); // series description
completeList.push_back( DICOMTag( 0x0008, 0x0060 ) ); // modality
completeList.push_back( DICOMTag( 0x0018, 0x0024 ) ); // sequence name
completeList.push_back( DICOMTag( 0x0020, 0x0037 ) ); // image orientation
completeList.push_back( DICOMTag( 0x0020, 0x1041 ) ); // slice location
completeList.push_back( DICOMTag( 0x0020, 0x0012 ) ); // acquisition number
completeList.push_back( DICOMTag( 0x0020, 0x0013 ) ); // instance number
completeList.push_back( DICOMTag( 0x0020, 0x0032 ) ); // image position patient
completeList.push_back( DICOMTag( 0x0028, 0x1050 ) ); // window center
completeList.push_back( DICOMTag( 0x0028, 0x1051 ) ); // window width
completeList.push_back( DICOMTag( 0x0008, 0x0008 ) ); // image type
completeList.push_back( DICOMTag( 0x0028, 0x0004 ) ); // photometric interpretation
return completeList;
}
void mitk::DICOMImageBlockDescriptor::SetAdditionalTagsOfInterest(
const AdditionalTagsMapType& tagMap)
{
m_AdditionalTagMap = tagMap;
}
void mitk::DICOMImageBlockDescriptor::SetTiltInformation( const GantryTiltInformation& info )
{
m_TiltInformation = info;
}
const mitk::GantryTiltInformation mitk::DICOMImageBlockDescriptor::GetTiltInformation() const
{
return m_TiltInformation;
}
void mitk::DICOMImageBlockDescriptor::SetImageFrameList( const DICOMImageFrameList& framelist )
{
m_ImageFrameList = framelist;
m_SliceIsLoaded.resize( framelist.size() );
m_SliceIsLoaded.assign( framelist.size(), false );
m_PropertiesOutOfDate = true;
}
const mitk::DICOMImageFrameList& mitk::DICOMImageBlockDescriptor::GetImageFrameList() const
{
return m_ImageFrameList;
}
void mitk::DICOMImageBlockDescriptor::SetMitkImage( Image::Pointer image )
{
if ( m_MitkImage != image )
{
if ( m_TagCache.IsExpired() )
{
MITK_ERROR << "Unable to describe MITK image with properties without a tag-cache object!";
m_MitkImage = nullptr;
return;
}
if ( m_ImageFrameList.empty() )
{
MITK_ERROR << "Unable to describe MITK image with properties without a frame list!";
m_MitkImage = nullptr;
return;
}
// Should verify that the image matches m_ImageFrameList and m_TagCache
// however, this is hard to do without re-analyzing all
// TODO we should at least make sure that the number of frames is identical (plus rows/columns,
// orientation)
// without gantry tilt correction, we can also check image origin
m_MitkImage = this->DescribeImageWithProperties( this->FixupSpacing( image ) );
}
}
mitk::Image::Pointer mitk::DICOMImageBlockDescriptor::GetMitkImage() const
{
return m_MitkImage;
}
mitk::Image::Pointer mitk::DICOMImageBlockDescriptor::FixupSpacing( Image* mitkImage )
{
if ( mitkImage )
{
Vector3D imageSpacing = mitkImage->GetGeometry()->GetSpacing();
ScalarType desiredSpacingX = imageSpacing[0];
ScalarType desiredSpacingY = imageSpacing[1];
this->GetDesiredMITKImagePixelSpacing(
desiredSpacingX, desiredSpacingY ); // prefer pixel spacing over imager pixel spacing
if ( desiredSpacingX <= 0 || desiredSpacingY <= 0 )
{
return mitkImage;
}
MITK_DEBUG << "Loaded image with spacing " << imageSpacing[0] << ", " << imageSpacing[1];
MITK_DEBUG << "Found correct spacing info " << desiredSpacingX << ", " << desiredSpacingY;
imageSpacing[0] = desiredSpacingX;
imageSpacing[1] = desiredSpacingY;
mitkImage->GetGeometry()->SetSpacing( imageSpacing );
}
return mitkImage;
}
void mitk::DICOMImageBlockDescriptor::SetSliceIsLoaded( unsigned int index, bool isLoaded )
{
if ( index < m_SliceIsLoaded.size() )
{
m_SliceIsLoaded[index] = isLoaded;
}
else
{
std::stringstream ss;
ss << "Index " << index << " out of range (" << m_SliceIsLoaded.size() << " indices reserved)";
throw std::invalid_argument( ss.str() );
}
}
bool mitk::DICOMImageBlockDescriptor::IsSliceLoaded( unsigned int index ) const
{
if ( index < m_SliceIsLoaded.size() )
{
return m_SliceIsLoaded[index];
}
else
{
std::stringstream ss;
ss << "Index " << index << " out of range (" << m_SliceIsLoaded.size() << " indices reserved)";
throw std::invalid_argument( ss.str() );
}
}
bool mitk::DICOMImageBlockDescriptor::AllSlicesAreLoaded() const
{
bool allLoaded = true;
for ( auto iter = m_SliceIsLoaded.cbegin(); iter != m_SliceIsLoaded.cend(); ++iter )
{
allLoaded &= *iter;
}
return allLoaded;
}
/*
PS defined IPS defined PS==IPS
0 0 --> UNKNOWN spacing, loader will invent
0 1 --> spacing as at detector surface
1 0 --> spacing as in patient
1 1 0 --> detector surface spacing CORRECTED for geometrical
magnifications: spacing as in patient
1 1 1 --> detector surface spacing NOT corrected for geometrical
magnifications: spacing as at detector
*/
mitk::PixelSpacingInterpretation mitk::DICOMImageBlockDescriptor::GetPixelSpacingInterpretation() const
{
if ( m_ImageFrameList.empty() || m_TagCache.IsExpired() )
{
MITK_ERROR << "Invalid call to GetPixelSpacingInterpretation. Need to have initialized tag-cache!";
return SpacingUnknown;
}
const std::string pixelSpacing = this->GetPixelSpacing();
const std::string imagerPixelSpacing = this->GetImagerPixelSpacing();
if ( pixelSpacing.empty() )
{
if ( imagerPixelSpacing.empty() )
{
return SpacingUnknown;
}
else
{
return SpacingAtDetector;
}
}
else // Pixel Spacing defined
{
if ( imagerPixelSpacing.empty() )
{
return SpacingInPatient;
}
else if ( pixelSpacing != imagerPixelSpacing )
{
return SpacingInPatient;
}
else
{
return SpacingAtDetector;
}
}
}
std::string mitk::DICOMImageBlockDescriptor::GetPixelSpacing() const
{
if ( m_ImageFrameList.empty() || m_TagCache.IsExpired() )
{
MITK_ERROR << "Invalid call to GetPixelSpacing. Need to have initialized tag-cache!";
return std::string( "" );
}
static const DICOMTag tagPixelSpacing( 0x0028, 0x0030 );
return m_TagCache.Lock()->GetTagValue( m_ImageFrameList.front(), tagPixelSpacing ).value;
}
std::string mitk::DICOMImageBlockDescriptor::GetImagerPixelSpacing() const
{
if ( m_ImageFrameList.empty() || m_TagCache.IsExpired() )
{
MITK_ERROR << "Invalid call to GetImagerPixelSpacing. Need to have initialized tag-cache!";
return std::string( "" );
}
static const DICOMTag tagImagerPixelSpacing( 0x0018, 0x1164 );
return m_TagCache.Lock()->GetTagValue( m_ImageFrameList.front(), tagImagerPixelSpacing ).value;
}
void mitk::DICOMImageBlockDescriptor::GetDesiredMITKImagePixelSpacing( ScalarType& spacingX,
ScalarType& spacingY ) const
{
const std::string pixelSpacing = this->GetPixelSpacing();
// preference for "in patient" pixel spacing
if ( !DICOMStringToSpacing( pixelSpacing, spacingX, spacingY ) )
{
const std::string imagerPixelSpacing = this->GetImagerPixelSpacing();
// fallback to "on detector" spacing
if ( !DICOMStringToSpacing( imagerPixelSpacing, spacingX, spacingY ) )
{
// at this point we have no hints whether the spacing is correct
// do a quick sanity check and either trust in the input or set both to 1
// We assume neither spacing to be negative, zero or unexpectedly large for
// medical images
if (spacingX < mitk::eps || spacingX > 1000 || spacingY < mitk::eps || spacingY > 1000)
{
spacingX = spacingY = 1.0;
}
}
}
}
void mitk::DICOMImageBlockDescriptor::SetProperty( const std::string& key, BaseProperty* value )
{
m_PropertyList->SetProperty( key, value );
}
mitk::BaseProperty* mitk::DICOMImageBlockDescriptor::GetProperty( const std::string& key ) const
{
this->UpdateImageDescribingProperties();
return m_PropertyList->GetProperty( key );
}
std::string mitk::DICOMImageBlockDescriptor::GetPropertyAsString( const std::string& key ) const
{
this->UpdateImageDescribingProperties();
const mitk::BaseProperty::Pointer property = m_PropertyList->GetProperty( key );
if ( property.IsNotNull() )
{
return property->GetValueAsString();
}
else
{
return std::string( "" );
}
}
void mitk::DICOMImageBlockDescriptor::SetFlag( const std::string& key, bool value )
{
m_PropertyList->ReplaceProperty( key, BoolProperty::New( value ) );
}
bool mitk::DICOMImageBlockDescriptor::GetFlag( const std::string& key, bool defaultValue ) const
{
this->UpdateImageDescribingProperties();
BoolProperty::ConstPointer boolProp = dynamic_cast<BoolProperty*>( this->GetProperty( key ) );
if ( boolProp.IsNotNull() )
{
return boolProp->GetValue();
}
else
{
return defaultValue;
}
}
void mitk::DICOMImageBlockDescriptor::SetIntProperty( const std::string& key, int value )
{
m_PropertyList->ReplaceProperty( key, IntProperty::New( value ) );
}
int mitk::DICOMImageBlockDescriptor::GetIntProperty( const std::string& key, int defaultValue ) const
{
this->UpdateImageDescribingProperties();
IntProperty::ConstPointer intProp = dynamic_cast<IntProperty*>( this->GetProperty( key ) );
if ( intProp.IsNotNull() )
{
return intProp->GetValue();
}
else
{
return defaultValue;
}
}
double mitk::DICOMImageBlockDescriptor::stringtodouble( const std::string& str ) const
{
double d;
std::string trimmedstring( str );
try
{
trimmedstring = trimmedstring.erase( trimmedstring.find_last_not_of( " \n\r\t" ) + 1 );
}
catch ( ... )
{
// no last not of
}
std::string firstcomponent( trimmedstring );
try
{
firstcomponent = trimmedstring.erase( trimmedstring.find_first_of( "\\" ) );
}
catch ( ... )
{
// no last not of
}
std::istringstream converter( firstcomponent );
if ( !firstcomponent.empty() && ( converter >> d ) && converter.eof() )
{
return d;
}
else
{
throw std::invalid_argument( "Argument is not a convertable number" );
}
}
mitk::Image::Pointer mitk::DICOMImageBlockDescriptor::DescribeImageWithProperties( Image* mitkImage )
{
// TODO: this is a collection of properties that have been provided by the
// legacy DicomSeriesReader.
// We should at some point clean up this collection and name them in a more
// consistent way!
if ( !mitkImage )
return mitkImage;
mitkImage->SetProperty(PropertyKeyPathToPropertyName(DICOMIOMetaInformationPropertyConstants::READER_FILES()), this->GetProperty("filenamesForSlices"));
mitkImage->SetProperty(PropertyKeyPathToPropertyName(DICOMIOMetaInformationPropertyConstants::READER_PIXEL_SPACING_INTERPRETATION_STRING()),
StringProperty::New(PixelSpacingInterpretationToString(this->GetPixelSpacingInterpretation())));
mitkImage->SetProperty(PropertyKeyPathToPropertyName(DICOMIOMetaInformationPropertyConstants::READER_PIXEL_SPACING_INTERPRETATION()),
GenericProperty<PixelSpacingInterpretation>::New(this->GetPixelSpacingInterpretation()));
mitkImage->SetProperty(PropertyKeyPathToPropertyName(DICOMIOMetaInformationPropertyConstants::READER_IMPLEMENTATION_LEVEL_STRING()),
StringProperty::New(ReaderImplementationLevelToString(m_ReaderImplementationLevel)));
mitkImage->SetProperty(PropertyKeyPathToPropertyName(DICOMIOMetaInformationPropertyConstants::READER_IMPLEMENTATION_LEVEL()),
GenericProperty<ReaderImplementationLevel>::New(m_ReaderImplementationLevel));
mitkImage->SetProperty(PropertyKeyPathToPropertyName(DICOMIOMetaInformationPropertyConstants::READER_GANTRY_TILT_CORRECTED()),
BoolProperty::New(this->GetTiltInformation().IsRegularGantryTilt()));
mitkImage->SetProperty(PropertyKeyPathToPropertyName(DICOMIOMetaInformationPropertyConstants::READER_3D_plus_t()), BoolProperty::New(this->GetFlag("3D+t", false)));
mitkImage->SetProperty(PropertyKeyPathToPropertyName(DICOMIOMetaInformationPropertyConstants::READER_GDCM()), StringProperty::New(gdcm::Version::GetVersion()));
mitkImage->SetProperty(PropertyKeyPathToPropertyName(DICOMIOMetaInformationPropertyConstants::READER_DCMTK()), StringProperty::New(PACKAGE_VERSION));
// get all found additional tags of interest
- for (auto tag : m_FoundAdditionalTags)
+ for (const auto &tag : m_FoundAdditionalTags)
{
BaseProperty* prop = this->GetProperty(tag);
if (prop)
{
mitkImage->SetProperty(tag.c_str(), prop);
}
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//// Deprecated properties should be removed sooner then later (see above)
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// first part: add some tags that describe individual slices
// these propeties are defined at analysis time (see UpdateImageDescribingProperties())
const char* propertyKeySliceLocation = "dicom.image.0020.1041";
const char* propertyKeyInstanceNumber = "dicom.image.0020.0013";
const char* propertyKeySOPInstanceUID = "dicom.image.0008.0018";
mitkImage->SetProperty( propertyKeySliceLocation, this->GetProperty( "sliceLocationForSlices" ) );
mitkImage->SetProperty( propertyKeyInstanceNumber, this->GetProperty( "instanceNumberForSlices" ) );
mitkImage->SetProperty( propertyKeySOPInstanceUID, this->GetProperty( "SOPInstanceUIDForSlices" ) );
mitkImage->SetProperty( "files", this->GetProperty( "filenamesForSlices_deprecated" ) );
// second part: add properties that describe the whole image block
mitkImage->SetProperty( "dicomseriesreader.SOPClassUID", StringProperty::New( this->GetSOPClassUID() ) );
mitkImage->SetProperty( "dicomseriesreader.SOPClass", StringProperty::New( this->GetSOPClassUIDAsName() ) );
mitkImage->SetProperty(
"dicomseriesreader.PixelSpacingInterpretationString",
StringProperty::New( PixelSpacingInterpretationToString( this->GetPixelSpacingInterpretation() ) ) );
mitkImage->SetProperty(
"dicomseriesreader.PixelSpacingInterpretation",
GenericProperty<PixelSpacingInterpretation>::New( this->GetPixelSpacingInterpretation() ) );
mitkImage->SetProperty(
"dicomseriesreader.ReaderImplementationLevelString",
StringProperty::New( ReaderImplementationLevelToString( m_ReaderImplementationLevel ) ) );
mitkImage->SetProperty( "dicomseriesreader.ReaderImplementationLevel",
GenericProperty<ReaderImplementationLevel>::New( m_ReaderImplementationLevel ) );
mitkImage->SetProperty( "dicomseriesreader.GantyTiltCorrected",
BoolProperty::New( this->GetTiltInformation().IsRegularGantryTilt() ) );
mitkImage->SetProperty( "dicomseriesreader.3D+t", BoolProperty::New( this->GetFlag( "3D+t", false ) ) );
// level window
const std::string windowCenter = this->GetPropertyAsString( "windowCenter" );
const std::string windowWidth = this->GetPropertyAsString( "windowWidth" );
try
{
const double level = stringtodouble( windowCenter );
const double window = stringtodouble( windowWidth );
mitkImage->SetProperty( "levelwindow", LevelWindowProperty::New( LevelWindow( level, window ) ) );
}
catch ( ... )
{
// nothing, no levelwindow to be predicted...
}
const std::string modality = this->GetPropertyAsString( "modality" );
mitkImage->SetProperty( "modality", StringProperty::New( modality ) );
mitkImage->SetProperty( "dicom.pixel.PhotometricInterpretation",
this->GetProperty( "photometricInterpretation" ) );
mitkImage->SetProperty( "dicom.image.imagetype", this->GetProperty( "imagetype" ) );
mitkImage->SetProperty( "dicom.study.StudyDescription", this->GetProperty( "studyDescription" ) );
mitkImage->SetProperty( "dicom.series.SeriesDescription", this->GetProperty( "seriesDescription" ) );
mitkImage->SetProperty( "dicom.pixel.Rows", this->GetProperty( "rows" ) );
mitkImage->SetProperty( "dicom.pixel.Columns", this->GetProperty( "columns" ) );
// fourth part: get something from ImageIO. BUT this needs to be created elsewhere. or not at all!
return mitkImage;
}
void mitk::DICOMImageBlockDescriptor::SetReaderImplementationLevel( const ReaderImplementationLevel& level )
{
m_ReaderImplementationLevel = level;
}
mitk::ReaderImplementationLevel mitk::DICOMImageBlockDescriptor::GetReaderImplementationLevel() const
{
return m_ReaderImplementationLevel;
}
std::string mitk::DICOMImageBlockDescriptor::GetSOPClassUID() const
{
if ( !m_ImageFrameList.empty() && !m_TagCache.IsExpired() )
{
static const DICOMTag tagSOPClassUID( 0x0008, 0x0016 );
return m_TagCache.Lock()->GetTagValue( m_ImageFrameList.front(), tagSOPClassUID ).value;
}
else
{
MITK_ERROR
<< "Invalid call to DICOMImageBlockDescriptor::GetSOPClassUID(). Need to have initialized tag-cache!";
return std::string( "" );
}
}
std::string mitk::DICOMImageBlockDescriptor::GetSOPClassUIDAsName() const
{
if ( !m_ImageFrameList.empty() && !m_TagCache.IsExpired() )
{
gdcm::UIDs uidKnowledge;
uidKnowledge.SetFromUID( this->GetSOPClassUID().c_str() );
const char* name = uidKnowledge.GetName();
if ( name )
{
return std::string( name );
}
else
{
return std::string( "" );
}
}
else
{
MITK_ERROR << "Invalid call to DICOMImageBlockDescriptor::GetSOPClassUIDAsName(). Need to have "
"initialized tag-cache!";
return std::string( "" );
}
}
int mitk::DICOMImageBlockDescriptor::GetNumberOfTimeSteps() const
{
int result = 1;
this->m_PropertyList->GetIntProperty("timesteps", result);
return result;
};
int mitk::DICOMImageBlockDescriptor::GetNumberOfFramesPerTimeStep() const
{
const int numberOfTimesteps = this->GetNumberOfTimeSteps();
int numberOfFramesPerTimestep = this->m_ImageFrameList.size() / numberOfTimesteps;
assert(int(double((double)this->m_ImageFrameList.size() / (double)numberOfTimesteps))
== numberOfFramesPerTimestep); // this should hold
return numberOfFramesPerTimestep;
};
void mitk::DICOMImageBlockDescriptor::SetTagCache( DICOMTagCache* privateCache )
{
// this must only be used during loading and never afterwards
m_TagCache = privateCache;
}
#define printPropertyRange( label, property_name ) \
\
{ \
const std::string first = this->GetPropertyAsString( #property_name "First" ); \
const std::string last = this->GetPropertyAsString( #property_name "Last" ); \
if ( !first.empty() || !last.empty() ) \
{ \
if ( first == last ) \
{ \
os << " " label ": '" << first << "'" << std::endl; \
} \
else \
{ \
os << " " label ": '" << first << "' - '" << last << "'" << std::endl; \
} \
} \
\
}
#define printProperty( label, property_name ) \
\
{ \
const std::string first = this->GetPropertyAsString( #property_name ); \
if ( !first.empty() ) \
{ \
os << " " label ": '" << first << "'" << std::endl; \
} \
\
}
#define printBool( label, commands ) \
\
{ \
os << " " label ": '" << ( commands ? "yes" : "no" ) << "'" << std::endl; \
\
}
void mitk::DICOMImageBlockDescriptor::Print(std::ostream& os, bool filenameDetails) const
{
os << " Number of Frames: '" << m_ImageFrameList.size() << "'" << std::endl;
os << " SOP class: '" << this->GetSOPClassUIDAsName() << "'" << std::endl;
printProperty( "Series Number", seriesNumber );
printProperty( "Study Description", studyDescription );
printProperty( "Series Description", seriesDescription );
printProperty( "Modality", modality );
printProperty( "Sequence Name", sequenceName );
printPropertyRange( "Slice Location", sliceLocation );
printPropertyRange( "Acquisition Number", acquisitionNumber );
printPropertyRange( "Instance Number", instanceNumber );
printPropertyRange( "Image Position", imagePositionPatient );
printProperty( "Image Orientation", orientation );
os << " Pixel spacing interpretation: '"
<< PixelSpacingInterpretationToString( this->GetPixelSpacingInterpretation() ) << "'" << std::endl;
printBool( "Gantry Tilt", this->GetTiltInformation().IsRegularGantryTilt() )
// printBool("3D+t", this->GetFlag("3D+t",false))
// os << " MITK image loaded: '" << (this->GetMitkImage().IsNotNull() ? "yes" : "no") << "'" <<
// std::endl;
if ( filenameDetails )
{
os << " Files in this image block:" << std::endl;
for ( auto frameIter = m_ImageFrameList.begin(); frameIter != m_ImageFrameList.end(); ++frameIter )
{
os << " " << ( *frameIter )->Filename;
if ( ( *frameIter )->FrameNo > 0 )
{
os << ", " << ( *frameIter )->FrameNo;
}
os << std::endl;
}
}
}
#define storeTagValueToProperty( tag_name, tag_g, tag_e ) \
\
{ \
const DICOMTag t( tag_g, tag_e ); \
const std::string tagValue = tagCache->GetTagValue( firstFrame, t ).value; \
const_cast<DICOMImageBlockDescriptor*>( this ) \
->SetProperty( #tag_name, StringProperty::New( tagValue ) ); \
\
}
#define storeTagValueRangeToProperty( tag_name, tag_g, tag_e ) \
\
{ \
const DICOMTag t( tag_g, tag_e ); \
const std::string tagValueFirst = tagCache->GetTagValue( firstFrame, t ).value; \
const std::string tagValueLast = tagCache->GetTagValue( lastFrame, t ).value; \
const_cast<DICOMImageBlockDescriptor*>( this ) \
->SetProperty( #tag_name "First", StringProperty::New( tagValueFirst ) ); \
const_cast<DICOMImageBlockDescriptor*>( this ) \
->SetProperty( #tag_name "Last", StringProperty::New( tagValueLast ) ); \
\
}
void mitk::DICOMImageBlockDescriptor::UpdateImageDescribingProperties() const
{
if ( !m_PropertiesOutOfDate )
return;
if ( !m_ImageFrameList.empty() )
{
if ( m_TagCache.IsExpired() )
{
MITK_ERROR << "Invalid call to DICOMImageBlockDescriptor::UpdateImageDescribingProperties(). Need to "
"have initialized tag-cache!";
return;
}
auto tagCache = m_TagCache.Lock();
if (tagCache.IsNull())
{
MITK_ERROR << "Invalid call to DICOMImageBlockDescriptor::UpdateImageDescribingProperties(). Need to "
"have initialized tag-cache!";
return;
}
const DICOMImageFrameInfo::Pointer firstFrame = m_ImageFrameList.front();
const DICOMImageFrameInfo::Pointer lastFrame = m_ImageFrameList.back();
// see macros above
storeTagValueToProperty( seriesNumber, 0x0020, 0x0011 );
storeTagValueToProperty( studyDescription, 0x0008, 0x1030 );
storeTagValueToProperty( seriesDescription, 0x0008, 0x103e );
storeTagValueToProperty( modality, 0x0008, 0x0060 );
storeTagValueToProperty( sequenceName, 0x0018, 0x0024 );
storeTagValueToProperty( orientation, 0x0020, 0x0037 );
storeTagValueToProperty( rows, 0x0028, 0x0010 );
storeTagValueToProperty( columns, 0x0028, 0x0011 );
storeTagValueRangeToProperty( sliceLocation, 0x0020, 0x1041 );
storeTagValueRangeToProperty( acquisitionNumber, 0x0020, 0x0012 );
storeTagValueRangeToProperty( instanceNumber, 0x0020, 0x0013 );
storeTagValueRangeToProperty( imagePositionPatient, 0x0020, 0x0032 );
storeTagValueToProperty( windowCenter, 0x0028, 0x1050 );
storeTagValueToProperty( windowWidth, 0x0028, 0x1051 );
storeTagValueToProperty( imageType, 0x0008, 0x0008 );
storeTagValueToProperty( photometricInterpretation, 0x0028, 0x0004 );
// some per-image attributes
// frames are just numbered starting from 0. timestep 1 (the second time-step) has frames starting at
// (number-of-frames-per-timestep)
// std::string propertyKeySliceLocation = "dicom.image.0020.1041";
// std::string propertyKeyInstanceNumber = "dicom.image.0020.0013";
// std::string propertyKeySOPInstanceNumber = "dicom.image.0008.0018";
StringLookupTable sliceLocationForSlices;
StringLookupTable instanceNumberForSlices;
StringLookupTable SOPInstanceUIDForSlices;
StringLookupTable filenamesForSlices_deprecated;
DICOMCachedValueLookupTable filenamesForSlices;
const DICOMTag tagSliceLocation( 0x0020, 0x1041 );
const DICOMTag tagInstanceNumber( 0x0020, 0x0013 );
const DICOMTag tagSOPInstanceNumber( 0x0008, 0x0018 );
std::unordered_map<std::string, DICOMCachedValueLookupTable> additionalTagResultList;
unsigned int slice(0);
int timePoint(-1);
const int framesPerTimeStep = this->GetNumberOfFramesPerTimeStep();
for ( auto frameIter = m_ImageFrameList.begin(); frameIter != m_ImageFrameList.end();
++slice, ++frameIter )
{
unsigned int zSlice = slice%framesPerTimeStep;
if ( zSlice == 0)
{
timePoint++;
}
const std::string sliceLocation = tagCache->GetTagValue( *frameIter, tagSliceLocation ).value;
sliceLocationForSlices.SetTableValue( slice, sliceLocation );
const std::string instanceNumber = tagCache->GetTagValue( *frameIter, tagInstanceNumber ).value;
instanceNumberForSlices.SetTableValue( slice, instanceNumber );
const std::string sopInstanceUID = tagCache->GetTagValue( *frameIter, tagSOPInstanceNumber ).value;
SOPInstanceUIDForSlices.SetTableValue( slice, sopInstanceUID );
const std::string filename = ( *frameIter )->Filename;
filenamesForSlices_deprecated.SetTableValue( slice, filename );
filenamesForSlices.SetTableValue(slice, { static_cast<unsigned int>(timePoint), zSlice, filename });
MITK_DEBUG << "Tag info for slice " << slice << ": SL '" << sliceLocation << "' IN '" << instanceNumber
<< "' SOP instance UID '" << sopInstanceUID << "'";
for (const auto& tag : m_AdditionalTagMap)
{
const DICOMTagCache::FindingsListType findings = tagCache->GetTagValue( *frameIter, tag.first );
for (const auto& finding : findings)
{
if (finding.isValid)
{
std::string propKey = (tag.second.empty()) ? DICOMTagPathToPropertyName(finding.path) : tag.second;
DICOMCachedValueInfo info{ static_cast<unsigned int>(timePoint), zSlice, finding.value };
additionalTagResultList[propKey].SetTableValue(slice, info);
}
}
}
}
// add property or properties with proper names
auto* thisInstance = const_cast<DICOMImageBlockDescriptor*>( this );
thisInstance->SetProperty( "sliceLocationForSlices",
StringLookupTableProperty::New( sliceLocationForSlices ) );
thisInstance->SetProperty( "instanceNumberForSlices",
StringLookupTableProperty::New( instanceNumberForSlices ) );
thisInstance->SetProperty( "SOPInstanceUIDForSlices",
StringLookupTableProperty::New( SOPInstanceUIDForSlices ) );
thisInstance->SetProperty( "filenamesForSlices_deprecated", StringLookupTableProperty::New( filenamesForSlices_deprecated ) );
thisInstance->SetProperty("filenamesForSlices", m_PropertyFunctor(filenamesForSlices));
//add properties for additional tags of interest
for ( auto iter = additionalTagResultList.cbegin(); iter != additionalTagResultList.cend(); ++iter )
{
thisInstance->SetProperty( iter->first, m_PropertyFunctor( iter->second ) );
thisInstance->m_FoundAdditionalTags.insert(m_FoundAdditionalTags.cend(),iter->first);
}
m_PropertiesOutOfDate = false;
}
}
mitk::BaseProperty::Pointer
mitk::DICOMImageBlockDescriptor::GetPropertyForDICOMValues(const DICOMCachedValueLookupTable& cacheLookupTable)
{
const auto& lookupTable = cacheLookupTable.GetLookupTable();
typedef std::pair<int, DICOMCachedValueInfo> PairType;
if ( std::adjacent_find(
lookupTable.cbegin(),
lookupTable.cend(),
[]( const PairType& lhs, const PairType& rhs ) { return lhs.second.Value != rhs.second.Value; } )
== lookupTable.cend() )
{
return static_cast<mitk::BaseProperty::Pointer>(
mitk::StringProperty::New(cacheLookupTable.GetTableValue(0).Value).GetPointer());
}
StringLookupTable stringTable;
- for (auto element : lookupTable)
+ for (const auto &element : lookupTable)
{
stringTable.SetTableValue(element.first, element.second.Value);
}
return static_cast<mitk::BaseProperty::Pointer>(
mitk::StringLookupTableProperty::New(stringTable).GetPointer());
}
void mitk::DICOMImageBlockDescriptor::SetTagLookupTableToPropertyFunctor( TagLookupTableToPropertyFunctor functor )
{
if ( functor != nullptr )
{
m_PropertyFunctor = functor;
}
}
mitk::BaseProperty::ConstPointer mitk::DICOMImageBlockDescriptor::GetConstProperty(const std::string &propertyKey,
const std::string &/*contextName*/, bool /*fallBackOnDefaultContext*/) const
{
this->UpdateImageDescribingProperties();
return m_PropertyList->GetConstProperty(propertyKey);
};
std::vector<std::string> mitk::DICOMImageBlockDescriptor::GetPropertyKeys(const std::string &/*contextName*/, bool /*includeDefaultContext*/) const
{
this->UpdateImageDescribingProperties();
return m_PropertyList->GetPropertyKeys();
};
std::vector<std::string> mitk::DICOMImageBlockDescriptor::GetPropertyContextNames() const
{
return std::vector<std::string>();
};
diff --git a/Modules/DICOM/src/mitkDICOMProperty.cpp b/Modules/DICOM/src/mitkDICOMProperty.cpp
index c82c2923ba..89ecf35724 100644
--- a/Modules/DICOM/src/mitkDICOMProperty.cpp
+++ b/Modules/DICOM/src/mitkDICOMProperty.cpp
@@ -1,55 +1,55 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkDICOMProperty.h"
mitk::BaseProperty::Pointer
mitk::GetDICOMPropertyForDICOMValuesFunctor(const mitk::DICOMCachedValueLookupTable& cacheLookupTable)
{
const auto& lookupTable = cacheLookupTable.GetLookupTable();
mitk::DICOMProperty::Pointer prop = mitk::DICOMProperty::New();
- for (auto element : lookupTable)
+ for (const auto &element : lookupTable)
{
prop->SetValue(element.second.TimePoint, element.second.SliceInTimePoint, element.second.Value);
}
return prop.GetPointer();
}
std::map< std::string, mitk::BaseProperty::Pointer> mitk::GetPropertyByDICOMTagPath(const mitk::PropertyList* list, const mitk::DICOMTagPath& path)
{
std::map< std::string, mitk::BaseProperty::Pointer> result;
for (const auto& iter : *(list->GetMap()))
{
DICOMTagPath propPath = PropertyNameToDICOMTagPath(iter.first);
if (!propPath.IsEmpty() && path.Equals(propPath))
{
result.insert(iter);
}
}
return result;
};
std::map< std::string, mitk::BaseProperty::Pointer> mitk::GetPropertyByDICOMTagPath(const mitk::BaseData* data, const mitk::DICOMTagPath& path)
{
std::map< std::string, mitk::BaseProperty::Pointer> result;
if (data)
{
result = GetPropertyByDICOMTagPath(data->GetPropertyList(), path);
}
return result;
};
diff --git a/Modules/DICOMPM/autoload/DICOMPMIO/mitkDICOMPMIO.cpp b/Modules/DICOMPM/autoload/DICOMPMIO/mitkDICOMPMIO.cpp
index b03d29e22e..1d25a7e344 100644
--- a/Modules/DICOMPM/autoload/DICOMPMIO/mitkDICOMPMIO.cpp
+++ b/Modules/DICOMPM/autoload/DICOMPMIO/mitkDICOMPMIO.cpp
@@ -1,217 +1,217 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef __mitkDICOMPMIO__cpp
#define __mitkDICOMPMIO__cpp
#include "mitkDICOMPMIO.h"
#include "mitkDICOMPMIOMimeTypes.h"
#include <mitkDICOMDCMTKTagScanner.h>
#include <mitkDICOMIOHelper.h>
#include <mitkDICOMProperty.h>
#include <mitkIDICOMTagsOfInterest.h>
#include <mitkImageAccessByItk.h>
#include <mitkImageCast.h>
#include <mitkLocaleSwitch.h>
#include <mitkPropertyNameHelper.h>
#include <dcmqi/ParaMapConverter.h>
#include "mitkParamapPresetsParser.h"
// us
#include <usGetModuleContext.h>
#include <usModuleContext.h>
// model fit parameters
#include "mitkModelFitConstants.h"
namespace mitk
{
DICOMPMIO::DICOMPMIO()
: AbstractFileIO(Image::GetStaticNameOfClass(),
mitk::MitkDICOMPMIOMimeTypes::DICOMPM_MIMETYPE_NAME(),
"DICOM PM")
{
AbstractFileWriter::SetRanking(10);
AbstractFileReader::SetRanking(10);
this->RegisterService();
}
IFileIO::ConfidenceLevel DICOMPMIO::GetWriterConfidenceLevel() const
{
if (AbstractFileIO::GetWriterConfidenceLevel() == Unsupported)
return Unsupported;
const Image *PMinput = static_cast<const Image *>(this->GetInput());
if (PMinput)
{
auto modalityProperty = PMinput->GetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0008, 0x0060).c_str());
if (modalityProperty.IsNotNull())
{
std::string modality = modalityProperty->GetValueAsString();
if (modality == "PM")
{
return Supported;
}
else return Unsupported;
}
else return Unsupported;
}
else return Unsupported;
}
void DICOMPMIO::Write()
{
ValidateOutputLocation();
mitk::LocaleSwitch localeSwitch("C");
LocalFile localFile(this);
const std::string path = localFile.GetFileName();
auto PMinput = dynamic_cast<const Image *>(this->GetInput());
if (PMinput == nullptr)
mitkThrow() << "Cannot write non-image data";
// Get DICOM information from referenced image
vector<std::unique_ptr<DcmDataset>> dcmDatasetsSourceImage;
std::unique_ptr<DcmFileFormat> readFileFormat(new DcmFileFormat());
try
{
// Generate dcmdataset witk DICOM tags from property list; ATM the source are the filepaths from the
// property list
mitk::StringLookupTableProperty::Pointer filesProp =
dynamic_cast<mitk::StringLookupTableProperty *>(PMinput->GetProperty("referenceFiles").GetPointer());
if (filesProp.IsNull())
{
mitkThrow() << "No property with dicom file path.";
return;
}
// returns a list of all referenced files
StringLookupTable filesLut = filesProp->GetValue();
const StringLookupTable::LookupTableType &lookUpTableMap = filesLut.GetLookupTable();
- for (auto it : lookUpTableMap)
+ for (const auto &it : lookUpTableMap)
{
const char *fileName = (it.second).c_str();
if (readFileFormat->loadFile(fileName, EXS_Unknown).good())
{
std::unique_ptr<DcmDataset> readDCMDataset(readFileFormat->getAndRemoveDataset());
dcmDatasetsSourceImage.push_back(std::move(readDCMDataset));
}
}
}
catch (const std::exception &e)
{
MITK_ERROR << "An error occurred while getting the dicom information: " << e.what() << endl;
return;
}
mitk::Image *mitkPMImage = const_cast<mitk::Image *>(PMinput);
// Cast input PMinput to itk image
ImageToItk<PMitkInputImageType>::Pointer PMimageToItkFilter = ImageToItk<PMitkInputImageType>::New();
PMimageToItkFilter->SetInput(mitkPMImage);
// Cast from original itk type to dcmqi input itk image type
typedef itk::CastImageFilter<PMitkInputImageType, PMitkInternalImageType> castItkImageFilterType;
castItkImageFilterType::Pointer castFilter = castItkImageFilterType::New();
castFilter->SetInput(PMimageToItkFilter->GetOutput());
castFilter->Update();
PMitkInternalImageType::Pointer itkParamapImage = castFilter->GetOutput();
// Create PM meta information
const std::string tmpMetaInfoFile = this->CreateMetaDataJsonFilePM();
// Convert itk PM images to dicom image
MITK_INFO << "Writing PM image: " << path << std::endl;
try
{
// convert from unique to raw pointer
vector<DcmDataset*> rawVecDataset;
for ( const auto& dcmDataSet : dcmDatasetsSourceImage ) { rawVecDataset.push_back( dcmDataSet.get() ); }
std::unique_ptr<dcmqi::ParaMapConverter> PMconverter(new dcmqi::ParaMapConverter());
std::unique_ptr<DcmDataset> PMresult (PMconverter->itkimage2paramap(itkParamapImage, rawVecDataset, tmpMetaInfoFile));
// Write dicom file
DcmFileFormat dcmFileFormat(PMresult.get());
std::string filePath = path.substr(0, path.find_last_of("."));
filePath = filePath + ".dcm";
dcmFileFormat.saveFile(filePath.c_str(), EXS_LittleEndianExplicit);
}
catch (const std::exception &e)
{
MITK_ERROR << "An error occurred during writing the DICOM Paramap: " << e.what() << endl;
return;
}
}
const std::string mitk::DICOMPMIO::CreateMetaDataJsonFilePM() const
{
const mitk::Image *PMimage = dynamic_cast<const mitk::Image *>(this->GetInput());
dcmqi::JSONParametricMapMetaInformationHandler PMhandler;
// Get Metadata from modelFitConstants
std::string parameterName;
PMimage->GetPropertyList()->GetStringProperty(ModelFitConstants::PARAMETER_NAME_PROPERTY_NAME().c_str(), parameterName);
std::string modelName;
PMimage->GetPropertyList()->GetStringProperty(ModelFitConstants::MODEL_NAME_PROPERTY_NAME().c_str(), modelName);
mitk::ParamapPresetsParser* pmPresets = mitk::ParamapPresetsParser::New();
// Here the mitkParamapPresets.xml file containing the Coding Schmeme Designator and Code Value are parsed and the relevant values extracted
pmPresets->LoadPreset();
auto pmType_parameterName = pmPresets->GetType(parameterName);
auto pmType_modelName = pmPresets->GetType(modelName);
// Pass codes to Paramap Converter
PMhandler.setDerivedPixelContrast("TCS");
PMhandler.setFrameLaterality("U");
PMhandler.setQuantityValueCode(pmType_parameterName.codeValue, pmType_parameterName.codeScheme, parameterName);
PMhandler.setMeasurementMethodCode(pmType_modelName.codeValue, pmType_modelName.codeScheme, modelName);
PMhandler.setMeasurementUnitsCode("/min", "UCUM", "/m");
PMhandler.setSeriesNumber("1");
PMhandler.setInstanceNumber("1");
PMhandler.setDerivationCode("129104", "DCM", "Perfusion image analysis");
PMhandler.setRealWorldValueSlope("1");
return PMhandler.getJSONOutputAsString();
}
std::vector<BaseData::Pointer> DICOMPMIO::DoRead()
{
mitk::LocaleSwitch localeSwitch("C");
std::vector<BaseData::Pointer> result;
return result;
}
IFileIO::ConfidenceLevel DICOMPMIO::GetReaderConfidenceLevel() const
{
return Unsupported;
}
DICOMPMIO *DICOMPMIO::IOClone() const { return new DICOMPMIO(*this); }
} // namespace
#endif //__mitkDICOMPMIO__cpp
diff --git a/Modules/DICOMUI/src/QmitkDicomLocalStorageWidget.cpp b/Modules/DICOMUI/src/QmitkDicomLocalStorageWidget.cpp
index ba2679faa5..975912427f 100644
--- a/Modules/DICOMUI/src/QmitkDicomLocalStorageWidget.cpp
+++ b/Modules/DICOMUI/src/QmitkDicomLocalStorageWidget.cpp
@@ -1,228 +1,228 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
// Qmitk
#include "QmitkDicomLocalStorageWidget.h"
//#include <mitkLogMacros.h>
// Qt
#include <QLabel>
#include <QMessageBox>
#include <QProgressDialog>
#include <QVariant>
const std::string QmitkDicomLocalStorageWidget::Widget_ID = "org.mitk.Widgets.QmitkDicomLocalStorageWidget";
QmitkDicomLocalStorageWidget::QmitkDicomLocalStorageWidget(QWidget *parent)
: QWidget(parent), m_LocalIndexer(new ctkDICOMIndexer(parent)), m_Controls(nullptr)
{
CreateQtPartControl(this);
}
QmitkDicomLocalStorageWidget::~QmitkDicomLocalStorageWidget()
{
m_LocalDatabase->closeDatabase();
}
void QmitkDicomLocalStorageWidget::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
m_Controls = new Ui::QmitkDicomLocalStorageWidgetControls;
m_Controls->setupUi(parent);
connect(m_Controls->deleteButton, SIGNAL(clicked()), this, SLOT(OnDeleteButtonClicked()));
connect(m_Controls->viewInternalDataButton, SIGNAL(clicked()), this, SLOT(OnViewButtonClicked()));
connect(m_Controls->ctkDicomBrowser,
SIGNAL(seriesSelectionChanged(const QStringList &)),
this,
SLOT(OnSeriesSelectionChanged(const QStringList &)));
connect(m_Controls->ctkDicomBrowser,
SIGNAL(seriesSelectionChanged(const QStringList &)),
this,
SLOT(OnSeriesSelectionChanged(const QStringList &)));
connect(
m_Controls->ctkDicomBrowser, SIGNAL(seriesDoubleClicked(const QModelIndex &)), this, SLOT(OnViewButtonClicked()));
connect(m_LocalIndexer, SIGNAL(indexingComplete(int, int, int, int)), this, SIGNAL(SignalFinishedImport()));
m_Controls->ctkDicomBrowser->setTableOrientation(Qt::Vertical);
}
}
void QmitkDicomLocalStorageWidget::OnStartDicomImport(const QString &dicomData)
{
if (m_LocalDatabase->isOpen())
{
m_LocalIndexer->addDirectory(dicomData);
}
}
void QmitkDicomLocalStorageWidget::OnStartDicomImport(const QStringList &dicomData)
{
if (m_LocalDatabase->isOpen())
{
m_LocalIndexer->addListOfFiles( dicomData);
}
}
void QmitkDicomLocalStorageWidget::OnDeleteButtonClicked()
{
if (!this->DeletePatients())
{
if (!this->DeleteStudies())
{
this->DeleteSeries();
}
}
m_Controls->ctkDicomBrowser->updateTableViews();
}
bool QmitkDicomLocalStorageWidget::DeletePatients()
{
auto selectedPatientUIDs = m_Controls->ctkDicomBrowser->currentPatientsSelection();
if (!selectedPatientUIDs.empty())
{
QStringList studyUIDs;
- for (const auto &patientUID : selectedPatientUIDs)
+ for (const auto &patientUID : qAsConst(selectedPatientUIDs))
studyUIDs.append(m_LocalDatabase->studiesForPatient(patientUID));
QStringList seriesUIDs;
for (const auto &studyUID : studyUIDs)
seriesUIDs.append(m_LocalDatabase->seriesForStudy(studyUID));
auto answer = QMessageBox::question(nullptr,
"Delete Patients",
QString("Do you really want to delete %1 %2, containing %3 series in %4 %5?")
.arg(selectedPatientUIDs.count())
.arg(selectedPatientUIDs.count() != 1 ? "patients" : "patient")
.arg(seriesUIDs.count())
.arg(studyUIDs.count())
.arg(studyUIDs.count() != 1 ? "studies" : "study"),
QMessageBox::Yes | QMessageBox::No,
QMessageBox::No);
if (answer == QMessageBox::Yes)
{
- for (const auto &patientUID : selectedPatientUIDs)
+ for (const auto &patientUID : qAsConst(selectedPatientUIDs))
m_LocalDatabase->removePatient(patientUID);
}
return true;
}
return false;
}
bool QmitkDicomLocalStorageWidget::DeleteStudies()
{
auto selectedStudyUIDs = m_Controls->ctkDicomBrowser->currentStudiesSelection();
if (!selectedStudyUIDs.empty())
{
QStringList seriesUIDs;
- for (const auto &studyUID : selectedStudyUIDs)
+ for (const auto &studyUID : qAsConst(selectedStudyUIDs))
seriesUIDs.append(m_LocalDatabase->seriesForStudy(studyUID));
auto answer = QMessageBox::question(nullptr,
"Delete Studies",
QString("Do you really want to delete %1 %2, containing %3 series?")
.arg(selectedStudyUIDs.count())
.arg(selectedStudyUIDs.count() != 1 ? "studies" : "study")
.arg(seriesUIDs.count()),
QMessageBox::Yes | QMessageBox::No,
QMessageBox::No);
if (answer == QMessageBox::Yes)
{
- for (const auto &studyUID : selectedStudyUIDs)
+ for (const auto &studyUID : qAsConst(selectedStudyUIDs))
m_LocalDatabase->removeStudy(studyUID);
}
return true;
}
return false;
}
bool QmitkDicomLocalStorageWidget::DeleteSeries()
{
auto selectedSeriesUIDs = m_Controls->ctkDicomBrowser->currentSeriesSelection();
if (!selectedSeriesUIDs.empty())
{
auto answer =
QMessageBox::question(nullptr,
"Delete Series",
QString("Do you really want to delete %1 series?").arg(selectedSeriesUIDs.count()),
QMessageBox::Yes | QMessageBox::No,
QMessageBox::No);
if (answer == QMessageBox::Yes)
{
- for (const auto &seriesUID : selectedSeriesUIDs)
+ for (const auto &seriesUID : qAsConst(selectedSeriesUIDs))
m_LocalDatabase->removeSeries(seriesUID);
}
return true;
}
return false;
}
void QmitkDicomLocalStorageWidget::OnViewButtonClicked()
{
QStringList uids = m_Controls->ctkDicomBrowser->currentSeriesSelection();
QString uid;
foreach (uid, uids)
{
QStringList filesForSeries = m_LocalDatabase->filesForSeries(uid);
QHash<QString, QVariant> eventProperty;
eventProperty.insert("FilesForSeries", filesForSeries);
if (!filesForSeries.isEmpty())
{
QString modality = m_LocalDatabase->fileValue(filesForSeries.at(0), "0008,0060");
eventProperty.insert("Modality", modality);
}
emit SignalDicomToDataManager(eventProperty);
}
}
void QmitkDicomLocalStorageWidget::SetDatabaseDirectory(QString newDatatbaseDirectory)
{
QDir databaseDirecory = QDir(newDatatbaseDirectory);
if (!databaseDirecory.exists())
{
databaseDirecory.mkpath(databaseDirecory.absolutePath());
}
QString newDatatbaseFile = databaseDirecory.absolutePath() + QString("/ctkDICOM.sql");
this->SetDatabase(newDatatbaseFile);
}
void QmitkDicomLocalStorageWidget::SetDatabase(QString databaseFile)
{
m_LocalDatabase = new ctkDICOMDatabase(databaseFile);
m_LocalDatabase->setParent(this);
m_Controls->ctkDicomBrowser->setDICOMDatabase(m_LocalDatabase);
m_LocalIndexer->setDatabase(m_LocalDatabase);
}
void QmitkDicomLocalStorageWidget::OnSeriesSelectionChanged(const QStringList &s)
{
m_Controls->viewInternalDataButton->setEnabled((s.size() != 0));
}
diff --git a/Modules/DataTypesExt/include/mitkCompressedImageContainer.h b/Modules/DataTypesExt/include/mitkCompressedImageContainer.h
index 71d5d9878e..32ead859c3 100644
--- a/Modules/DataTypesExt/include/mitkCompressedImageContainer.h
+++ b/Modules/DataTypesExt/include/mitkCompressedImageContainer.h
@@ -1,80 +1,80 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkCompressedImageContainer_h_Included
#define mitkCompressedImageContainer_h_Included
#include "MitkDataTypesExtExports.h"
#include "mitkCommon.h"
#include "mitkGeometry3D.h"
#include "mitkImage.h"
#include "mitkImageDataItem.h"
#include <itkObject.h>
#include <vector>
namespace mitk
{
/**
\brief Holds one (compressed) mitk::Image
Uses zlib to compress the data of an mitk::Image.
$Author$
*/
class MITKDATATYPESEXT_EXPORT CompressedImageContainer : public itk::Object
{
public:
mitkClassMacroItkParent(CompressedImageContainer, itk::Object);
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
/**
* \brief Creates a compressed version of the image.
*
* Will not hold any further SmartPointers to the image.
*
*/
- void SetImage(Image *);
+ void SetImage(const Image *);
/**
* \brief Creates a full mitk::Image from its compressed version.
*
* This Method hold no buffer, so the uncompression algorithm will be
* executed every time you call this method. Don't overdo it.
*
*/
- Image::Pointer GetImage();
+ Image::Pointer GetImage() const;
protected:
CompressedImageContainer(); // purposely hidden
~CompressedImageContainer() override;
PixelType *m_PixelType;
unsigned int m_ImageDimension;
std::vector<unsigned int> m_ImageDimensions;
unsigned long m_OneTimeStepImageSizeInBytes;
unsigned int m_NumberOfTimeSteps;
/// one for each timestep. first = pointer to compressed data; second = size of buffer in bytes
std::vector<std::pair<unsigned char *, unsigned long>> m_ByteBuffers;
BaseGeometry::Pointer m_ImageGeometry;
};
} // namespace
#endif
diff --git a/Modules/DataTypesExt/src/mitkCompressedImageContainer.cpp b/Modules/DataTypesExt/src/mitkCompressedImageContainer.cpp
index bfad62d7ef..7d11a9e9a9 100644
--- a/Modules/DataTypesExt/src/mitkCompressedImageContainer.cpp
+++ b/Modules/DataTypesExt/src/mitkCompressedImageContainer.cpp
@@ -1,178 +1,178 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkCompressedImageContainer.h"
#include "mitkImageReadAccessor.h"
#include "itk_zlib.h"
#include <cstdlib>
mitk::CompressedImageContainer::CompressedImageContainer() : m_PixelType(nullptr), m_ImageGeometry(nullptr)
{
}
mitk::CompressedImageContainer::~CompressedImageContainer()
{
for (auto iter = m_ByteBuffers.begin(); iter != m_ByteBuffers.end(); ++iter)
{
free(iter->first);
}
delete m_PixelType;
}
-void mitk::CompressedImageContainer::SetImage(Image *image)
+void mitk::CompressedImageContainer::SetImage(const Image *image)
{
for (auto iter = m_ByteBuffers.begin(); iter != m_ByteBuffers.end(); ++iter)
{
free(iter->first);
}
m_ByteBuffers.clear();
// Compress diff image using zlib (will be restored on demand)
// determine memory size occupied by voxel data
m_ImageDimension = image->GetDimension();
m_ImageDimensions.clear();
m_PixelType = new mitk::PixelType(image->GetPixelType());
m_OneTimeStepImageSizeInBytes = m_PixelType->GetSize(); // bits per element divided by 8
for (unsigned int i = 0; i < m_ImageDimension; ++i)
{
unsigned int currentImageDimension = image->GetDimension(i);
m_ImageDimensions.push_back(currentImageDimension);
if (i < 3)
{
m_OneTimeStepImageSizeInBytes *= currentImageDimension; // only the 3D memory size
}
}
m_ImageGeometry = image->GetGeometry();
m_NumberOfTimeSteps = 1;
if (m_ImageDimension > 3)
{
m_NumberOfTimeSteps = image->GetDimension(3);
}
for (unsigned int timestep = 0; timestep < m_NumberOfTimeSteps; ++timestep)
{
// allocate a buffer as specified by zlib
unsigned long bufferSize =
m_OneTimeStepImageSizeInBytes + static_cast<unsigned long>(m_OneTimeStepImageSizeInBytes * 0.2) + 12;
auto *byteBuffer = (unsigned char *)malloc(bufferSize);
if (itk::Object::GetDebug())
{
// compress image here into a buffer
MITK_INFO << "Using ZLib version: '" << zlibVersion() << "'" << std::endl
<< "Attempting to compress " << m_OneTimeStepImageSizeInBytes << " image bytes into a buffer of size "
<< bufferSize << std::endl;
}
ImageReadAccessor imgAcc(image, image->GetVolumeData(timestep));
::Bytef *dest(byteBuffer);
::uLongf destLen(bufferSize);
auto *source((unsigned char *)imgAcc.GetData());
::uLongf sourceLen(m_OneTimeStepImageSizeInBytes);
int zlibRetVal = ::compress(dest, &destLen, source, sourceLen);
if (itk::Object::GetDebug())
{
if (zlibRetVal == Z_OK)
{
MITK_INFO << "Success, using " << destLen << " bytes of the buffer (ratio "
<< ((double)destLen / (double)sourceLen) << ")" << std::endl;
}
else
{
switch (zlibRetVal)
{
case Z_MEM_ERROR:
MITK_ERROR << "not enough memory" << std::endl;
break;
case Z_BUF_ERROR:
MITK_ERROR << "output buffer too small" << std::endl;
break;
default:
MITK_ERROR << "other, unspecified error" << std::endl;
break;
}
}
}
// only use the neccessary amount of memory, realloc the buffer!
byteBuffer = (unsigned char *)realloc(byteBuffer, destLen);
bufferSize = destLen;
// MITK_INFO << "Using " << bufferSize << " bytes to store compressed image (" << destLen << " needed)" <<
// std::endl;
m_ByteBuffers.push_back(std::pair<unsigned char *, unsigned long>(byteBuffer, bufferSize));
}
}
-mitk::Image::Pointer mitk::CompressedImageContainer::GetImage()
+mitk::Image::Pointer mitk::CompressedImageContainer::GetImage() const
{
if (m_ByteBuffers.empty())
return nullptr;
// uncompress image data, create an Image
Image::Pointer image = Image::New();
unsigned int dims[20]; // more than 20 dimensions and bang
for (unsigned int dim = 0; dim < m_ImageDimension; ++dim)
dims[dim] = m_ImageDimensions[dim];
image->Initialize(*m_PixelType, m_ImageDimension, dims); // this IS needed, right ?? But it does allocate memory ->
// does create one big lump of memory (also in windows)
unsigned int timeStep(0);
for (auto iter = m_ByteBuffers.begin(); iter != m_ByteBuffers.end(); ++iter, ++timeStep)
{
ImageReadAccessor imgAcc(image, image->GetVolumeData(timeStep));
auto *dest((unsigned char *)imgAcc.GetData());
::uLongf destLen(m_OneTimeStepImageSizeInBytes);
::Bytef *source(iter->first);
::uLongf sourceLen(iter->second);
int zlibRetVal = ::uncompress(dest, &destLen, source, sourceLen);
if (itk::Object::GetDebug())
{
if (zlibRetVal == Z_OK)
{
MITK_INFO << "Success, destLen now " << destLen << " bytes" << std::endl;
}
else
{
switch (zlibRetVal)
{
case Z_DATA_ERROR:
MITK_ERROR << "compressed data corrupted" << std::endl;
break;
case Z_MEM_ERROR:
MITK_ERROR << "not enough memory" << std::endl;
break;
case Z_BUF_ERROR:
MITK_ERROR << "output buffer too small" << std::endl;
break;
default:
MITK_ERROR << "other, unspecified error" << std::endl;
break;
}
}
}
}
image->SetGeometry(m_ImageGeometry);
image->Modified();
return image;
}
diff --git a/Modules/Gizmo/src/mitkGizmoInteractor.cpp b/Modules/Gizmo/src/mitkGizmoInteractor.cpp
index a682f70a24..7749ad82de 100644
--- a/Modules/Gizmo/src/mitkGizmoInteractor.cpp
+++ b/Modules/Gizmo/src/mitkGizmoInteractor.cpp
@@ -1,465 +1,465 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkGizmoInteractor.h"
#include "mitkGizmoMapper2D.h"
// MITK includes
#include <mitkInteractionConst.h>
#include <mitkInteractionPositionEvent.h>
#include <mitkInternalEvent.h>
#include <mitkLookupTableProperty.h>
#include <mitkOperationEvent.h>
#include <mitkRotationOperation.h>
#include <mitkScaleOperation.h>
#include <mitkSurface.h>
#include <mitkUndoController.h>
#include <mitkVtkMapper.h>
// VTK includes
#include <vtkCamera.h>
#include <vtkInteractorObserver.h>
#include <vtkInteractorStyle.h>
#include <vtkMath.h>
#include <vtkPointData.h>
#include <vtkPolyData.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkVector.h>
#include <vtkVectorOperators.h>
mitk::GizmoInteractor::GizmoInteractor()
{
m_ColorForHighlight[0] = 1.0;
m_ColorForHighlight[1] = 0.5;
m_ColorForHighlight[2] = 0.0;
m_ColorForHighlight[3] = 1.0;
// TODO if we want to get this configurable, the this is the recipe:
// - make the 2D mapper add corresponding properties to control "enabled" and "color"
// - make the interactor evaluate those properties
// - in an ideal world, modify the state machine on the fly and skip mouse move handling
}
mitk::GizmoInteractor::~GizmoInteractor()
{
}
void mitk::GizmoInteractor::ConnectActionsAndFunctions()
{
CONNECT_CONDITION("PickedHandle", HasPickedHandle);
CONNECT_FUNCTION("DecideInteraction", DecideInteraction);
CONNECT_FUNCTION("MoveAlongAxis", MoveAlongAxis);
CONNECT_FUNCTION("RotateAroundAxis", RotateAroundAxis);
CONNECT_FUNCTION("MoveFreely", MoveFreely);
CONNECT_FUNCTION("ScaleEqually", ScaleEqually);
CONNECT_FUNCTION("FeedUndoStack", FeedUndoStack);
}
void mitk::GizmoInteractor::SetGizmoNode(DataNode *node)
{
DataInteractor::SetDataNode(node);
m_Gizmo = dynamic_cast<Gizmo *>(node->GetData());
// setup picking from just this object
m_Picker.clear();
}
void mitk::GizmoInteractor::SetManipulatedObjectNode(DataNode *node)
{
if (node && node->GetData())
{
m_ManipulatedObjectGeometry = node->GetData()->GetGeometry();
}
}
bool mitk::GizmoInteractor::HasPickedHandle(const InteractionEvent *interactionEvent)
{
auto positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
if (positionEvent == nullptr ||
m_Gizmo.IsNull() ||
m_ManipulatedObjectGeometry.IsNull() ||
interactionEvent->GetSender()->GetRenderWindow()->GetNeverRendered())
{
return false;
}
if (interactionEvent->GetSender()->GetMapperID() == BaseRenderer::Standard2D)
{
m_PickedHandle = PickFrom2D(positionEvent);
}
else
{
m_PickedHandle = PickFrom3D(positionEvent);
}
UpdateHandleHighlight();
return m_PickedHandle != Gizmo::NoHandle;
}
void mitk::GizmoInteractor::DecideInteraction(StateMachineAction *, InteractionEvent *interactionEvent)
{
assert(m_PickedHandle != Gizmo::NoHandle);
auto positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
if (positionEvent == nullptr)
{
return;
}
// if something relevant was picked, we calculate a number of
// important points and axes for the upcoming geometry manipulations
// note initial state
m_InitialClickPosition2D = positionEvent->GetPointerPositionOnScreen();
m_InitialClickPosition3D = positionEvent->GetPositionInWorld();
auto renderer = positionEvent->GetSender()->GetVtkRenderer();
renderer->SetWorldPoint(m_InitialClickPosition3D[0], m_InitialClickPosition3D[1], m_InitialClickPosition3D[2], 0);
renderer->WorldToDisplay();
m_InitialClickPosition2DZ = renderer->GetDisplayPoint()[2];
m_InitialGizmoCenter3D = m_Gizmo->GetCenter();
positionEvent->GetSender()->WorldToDisplay(m_InitialGizmoCenter3D, m_InitialGizmoCenter2D);
m_InitialManipulatedObjectGeometry = m_ManipulatedObjectGeometry->Clone();
switch ( m_PickedHandle ) {
case Gizmo::MoveAlongAxisX:
case Gizmo::RotateAroundAxisX:
case Gizmo::ScaleX:
m_AxisOfMovement = m_InitialManipulatedObjectGeometry->GetAxisVector(0);
break;
case Gizmo::MoveAlongAxisY:
case Gizmo::RotateAroundAxisY:
case Gizmo::ScaleY:
m_AxisOfMovement = m_InitialManipulatedObjectGeometry->GetAxisVector(1);
break;
case Gizmo::MoveAlongAxisZ:
case Gizmo::RotateAroundAxisZ:
case Gizmo::ScaleZ:
m_AxisOfMovement = m_InitialManipulatedObjectGeometry->GetAxisVector(2);
break;
default:
break;
}
m_AxisOfMovement.Normalize();
m_AxisOfRotation = m_AxisOfMovement;
// for translation: test whether the user clicked into the "object's real" axis direction
// or into the other one
Vector3D intendedAxis = m_InitialClickPosition3D - m_InitialGizmoCenter3D;
if ( intendedAxis * m_AxisOfMovement < 0 ) {
m_AxisOfMovement *= -1.0;
}
// for rotation: test whether the axis of rotation is more looking in the direction
// of the camera or in the opposite
vtkCamera *camera = renderer->GetActiveCamera();
vtkVector3d cameraDirection(camera->GetDirectionOfProjection());
double angle_rad = vtkMath::AngleBetweenVectors(cameraDirection.GetData(), m_AxisOfRotation.GetDataPointer());
if ( angle_rad < vtkMath::Pi() / 2.0 ) {
m_AxisOfRotation *= -1.0;
}
InternalEvent::Pointer decision;
switch (m_PickedHandle)
{
case Gizmo::MoveAlongAxisX:
case Gizmo::MoveAlongAxisY:
case Gizmo::MoveAlongAxisZ:
decision = InternalEvent::New(interactionEvent->GetSender(), this, "StartTranslationAlongAxis");
break;
case Gizmo::RotateAroundAxisX:
case Gizmo::RotateAroundAxisY:
case Gizmo::RotateAroundAxisZ:
decision = InternalEvent::New(interactionEvent->GetSender(), this, "StartRotationAroundAxis");
break;
case Gizmo::MoveFreely:
decision = InternalEvent::New(interactionEvent->GetSender(), this, "MoveFreely");
break;
case Gizmo::ScaleX:
case Gizmo::ScaleY:
case Gizmo::ScaleZ:
// Implementation note: Why didn't we implement per-axis scaling yet?
// When this was implemented, the mitk::ScaleOperation was able to only describe
// uniform scaling around a central point. Since we use operations for all modifications
// in order to have undo/redo working, any axis-specific scaling should also
// use operations.
// Consequence: enhance ScaleOperation when there is need to have scaling per axis.
decision = InternalEvent::New(interactionEvent->GetSender(), this, "ScaleEqually");
break;
default:
break;
}
interactionEvent->GetSender()->GetDispatcher()->QueueEvent(decision);
}
void mitk::GizmoInteractor::MoveAlongAxis(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
if (positionEvent == nullptr)
{
return;
}
Point2D currentPosition2D = positionEvent->GetPointerPositionOnScreen();
// re-use the initial z value to calculate movements parallel to the camera plane
auto renderer = positionEvent->GetSender()->GetVtkRenderer();
renderer->SetDisplayPoint(currentPosition2D[0], currentPosition2D[1], m_InitialClickPosition2DZ);
renderer->DisplayToWorld();
vtkVector3d worldPointVTK(renderer->GetWorldPoint());
Point3D worldPointITK(worldPointVTK.GetData());
Vector3D freeMouseMovement3D(worldPointITK - m_InitialClickPosition3D);
double projectedMouseMovement3D = freeMouseMovement3D * m_AxisOfMovement;
Vector3D appliedMovement3D = projectedMouseMovement3D * m_AxisOfMovement;
ApplyTranslationToManipulatedObject(appliedMovement3D);
RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
void mitk::GizmoInteractor::RotateAroundAxis(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
if (positionEvent == nullptr)
{
return;
}
Vector2D originalVector = m_InitialClickPosition2D - m_InitialGizmoCenter2D;
Vector2D currentVector = positionEvent->GetPointerPositionOnScreen() - m_InitialGizmoCenter2D;
originalVector.Normalize();
currentVector.Normalize();
double angle_rad = std::atan2(currentVector[1], currentVector[0]) - std::atan2(originalVector[1], originalVector[0]);
ApplyRotationToManipulatedObject(vtkMath::DegreesFromRadians(angle_rad));
RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
void mitk::GizmoInteractor::MoveFreely(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
if (positionEvent == nullptr)
{
return;
}
Point2D currentPosition2D = positionEvent->GetPointerPositionOnScreen();
// re-use the initial z value to really move parallel to the camera plane
auto renderer = positionEvent->GetSender()->GetVtkRenderer();
renderer->SetDisplayPoint(currentPosition2D[0], currentPosition2D[1], m_InitialClickPosition2DZ);
renderer->DisplayToWorld();
vtkVector3d worldPointVTK(renderer->GetWorldPoint());
Point3D worldPointITK(worldPointVTK.GetData());
Vector3D movementITK(worldPointITK - m_InitialClickPosition3D);
ApplyTranslationToManipulatedObject(movementITK);
RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
void mitk::GizmoInteractor::ScaleEqually(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
if (positionEvent == nullptr)
{
return;
}
Point2D currentPosition2D = positionEvent->GetPointerPositionOnScreen();
double relativeSize = (currentPosition2D - m_InitialGizmoCenter2D).GetNorm() /
(m_InitialClickPosition2D - m_InitialGizmoCenter2D).GetNorm();
ApplyEqualScalingToManipulatedObject(relativeSize);
RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
void mitk::GizmoInteractor::ApplyTranslationToManipulatedObject(const Vector3D &translation)
{
assert(m_ManipulatedObjectGeometry.IsNotNull());
auto manipulatedGeometry = m_InitialManipulatedObjectGeometry->Clone();
- m_FinalDoOperation.reset(new PointOperation(OpMOVE, translation));
+ m_FinalDoOperation.reset(new PointOperation(OpMOVE, Point3D(translation)));
if (m_UndoEnabled)
{
- m_FinalUndoOperation.reset(new PointOperation(OpMOVE, -translation));
+ m_FinalUndoOperation.reset(new PointOperation(OpMOVE, Point3D(-translation)));
}
manipulatedGeometry->ExecuteOperation(m_FinalDoOperation.get());
m_ManipulatedObjectGeometry->SetIndexToWorldTransform(manipulatedGeometry->GetIndexToWorldTransform());
}
void mitk::GizmoInteractor::ApplyEqualScalingToManipulatedObject(double scalingFactor)
{
assert(m_ManipulatedObjectGeometry.IsNotNull());
auto manipulatedGeometry = m_InitialManipulatedObjectGeometry->Clone();
m_FinalDoOperation.reset(new ScaleOperation(OpSCALE, scalingFactor - 1.0, m_InitialGizmoCenter3D));
if (m_UndoEnabled)
{
m_FinalUndoOperation.reset(new ScaleOperation(OpSCALE, -(scalingFactor - 1.0), m_InitialGizmoCenter3D));
}
manipulatedGeometry->ExecuteOperation(m_FinalDoOperation.get());
m_ManipulatedObjectGeometry->SetIndexToWorldTransform(manipulatedGeometry->GetIndexToWorldTransform());
}
void mitk::GizmoInteractor::ApplyRotationToManipulatedObject(double angle_deg)
{
assert(m_ManipulatedObjectGeometry.IsNotNull());
auto manipulatedGeometry = m_InitialManipulatedObjectGeometry->Clone();
m_FinalDoOperation.reset(new RotationOperation(OpROTATE, m_InitialGizmoCenter3D, m_AxisOfRotation, angle_deg));
if (m_UndoEnabled)
{
m_FinalUndoOperation.reset(new RotationOperation(OpROTATE, m_InitialGizmoCenter3D, m_AxisOfRotation, -angle_deg));
}
manipulatedGeometry->ExecuteOperation(m_FinalDoOperation.get());
m_ManipulatedObjectGeometry->SetIndexToWorldTransform(manipulatedGeometry->GetIndexToWorldTransform());
}
void mitk::GizmoInteractor::FeedUndoStack(StateMachineAction *, InteractionEvent *)
{
if (m_UndoEnabled)
{
OperationEvent *operationEvent = new OperationEvent(m_ManipulatedObjectGeometry,
// OperationEvent will destroy operations!
// --> release() and not get()
m_FinalDoOperation.release(),
m_FinalUndoOperation.release(),
"Direct geometry manipulation");
mitk::OperationEvent::IncCurrObjectEventId(); // save each modification individually
m_UndoController->SetOperationEvent(operationEvent);
}
}
mitk::Gizmo::HandleType mitk::GizmoInteractor::PickFrom2D(const InteractionPositionEvent *positionEvent)
{
BaseRenderer *renderer = positionEvent->GetSender();
auto mapper = GetDataNode()->GetMapper(BaseRenderer::Standard2D);
auto gizmo_mapper = dynamic_cast<GizmoMapper2D *>(mapper);
auto &picker = m_Picker[renderer];
if (picker == nullptr)
{
picker = vtkSmartPointer<vtkCellPicker>::New();
picker->SetTolerance(0.005);
if (gizmo_mapper)
{ // doing this each time is bizarre
picker->AddPickList(gizmo_mapper->GetVtkProp(renderer));
picker->PickFromListOn();
}
}
auto displayPosition = positionEvent->GetPointerPositionOnScreen();
picker->Pick(displayPosition[0], displayPosition[1], 0, positionEvent->GetSender()->GetVtkRenderer());
vtkIdType pickedPointID = picker->GetPointId();
if (pickedPointID == -1)
{
return Gizmo::NoHandle;
}
vtkPolyData *polydata = gizmo_mapper->GetVtkPolyData(renderer);
if (polydata && polydata->GetPointData() && polydata->GetPointData()->GetScalars())
{
double dataValue = polydata->GetPointData()->GetScalars()->GetTuple1(pickedPointID);
return m_Gizmo->GetHandleFromPointDataValue(dataValue);
}
return Gizmo::NoHandle;
}
mitk::Gizmo::HandleType mitk::GizmoInteractor::PickFrom3D(const InteractionPositionEvent *positionEvent)
{
BaseRenderer *renderer = positionEvent->GetSender();
auto &picker = m_Picker[renderer];
if (picker == nullptr)
{
picker = vtkSmartPointer<vtkCellPicker>::New();
picker->SetTolerance(0.005);
auto mapper = GetDataNode()->GetMapper(BaseRenderer::Standard3D);
auto vtk_mapper = dynamic_cast<VtkMapper *>(mapper);
if (vtk_mapper)
{ // doing this each time is bizarre
picker->AddPickList(vtk_mapper->GetVtkProp(renderer));
picker->PickFromListOn();
}
}
auto displayPosition = positionEvent->GetPointerPositionOnScreen();
picker->Pick(displayPosition[0], displayPosition[1], 0, positionEvent->GetSender()->GetVtkRenderer());
vtkIdType pickedPointID = picker->GetPointId();
if (pickedPointID == -1)
{
return Gizmo::NoHandle;
}
// _something_ picked
return m_Gizmo->GetHandleFromPointID(pickedPointID);
}
void mitk::GizmoInteractor::UpdateHandleHighlight()
{
if (m_HighlightedHandle != m_PickedHandle) {
auto node = GetDataNode();
if (node == nullptr) return;
auto base_prop = node->GetProperty("LookupTable");
if (base_prop == nullptr) return;
auto lut_prop = dynamic_cast<LookupTableProperty*>(base_prop);
if (lut_prop == nullptr) return;
auto lut = lut_prop->GetLookupTable();
if (lut == nullptr) return;
// Table size is expected to constructed as one entry per gizmo-part enum value
assert(lut->GetVtkLookupTable()->GetNumberOfTableValues() > std::max(m_PickedHandle, m_HighlightedHandle));
// Reset previously overwritten color
if (m_HighlightedHandle != Gizmo::NoHandle)
{
lut->SetTableValue(m_HighlightedHandle, m_ColorReplacedByHighlight);
}
// Overwrite currently highlighted color
if (m_PickedHandle != Gizmo::NoHandle)
{
lut->GetTableValue(m_PickedHandle, m_ColorReplacedByHighlight);
lut->SetTableValue(m_PickedHandle, m_ColorForHighlight);
}
// Mark node modified to allow repaint
node->Modified();
RenderingManager::GetInstance()->RequestUpdateAll(RenderingManager::REQUEST_UPDATE_ALL);
m_HighlightedHandle = m_PickedHandle;
}
}
diff --git a/Modules/IGT/Algorithms/mitkNavigationDataToIGTLMessageFilter.cpp b/Modules/IGT/Algorithms/mitkNavigationDataToIGTLMessageFilter.cpp
index 300ed54246..186d9fc2fc 100644
--- a/Modules/IGT/Algorithms/mitkNavigationDataToIGTLMessageFilter.cpp
+++ b/Modules/IGT/Algorithms/mitkNavigationDataToIGTLMessageFilter.cpp
@@ -1,319 +1,319 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkNavigationDataToIGTLMessageFilter.h"
#include "igtlQuaternionTrackingDataMessage.h"
#include "igtlTrackingDataMessage.h"
#include "igtlTransformMessage.h"
#include "igtlPositionMessage.h"
#include <mitkInteractionConst.h>
#include <itksys/SystemTools.hxx>
mitk::NavigationDataToIGTLMessageFilter::NavigationDataToIGTLMessageFilter()
{
mitk::IGTLMessage::Pointer output = mitk::IGTLMessage::New();
this->SetNumberOfRequiredOutputs(1);
this->SetNthOutput(0, output.GetPointer());
this->SetNumberOfRequiredInputs(1);
// m_OperationMode = Mode3D;
m_CurrentTimeStep = 0;
// m_RingBufferSize = 50; //the default ring buffer size
// m_NumberForMean = 100;
}
mitk::NavigationDataToIGTLMessageFilter::~NavigationDataToIGTLMessageFilter()
{
}
void mitk::NavigationDataToIGTLMessageFilter::GenerateData()
{
switch (m_OperationMode)
{
case ModeSendQTDataMsg:
this->GenerateDataModeSendQTDataMsg();
break;
case ModeSendTDataMsg:
this->GenerateDataModeSendTDataMsg();
break;
case ModeSendQTransMsg:
this->GenerateDataModeSendQTransMsg();
break;
case ModeSendTransMsg:
this->GenerateDataModeSendTransMsg();
break;
default:
break;
}
}
void mitk::NavigationDataToIGTLMessageFilter::SetInput(const NavigationData* nd)
{
// Process object is not const-correct so the const_cast is required here
this->ProcessObject::SetNthInput(0, const_cast<NavigationData*>(nd));
this->CreateOutputsForAllInputs();
}
void mitk::NavigationDataToIGTLMessageFilter::SetInput(unsigned int idx, const NavigationData* nd)
{
// Process object is not const-correct so the const_cast is required here
this->ProcessObject::SetNthInput(idx, const_cast<NavigationData*>(nd));
this->CreateOutputsForAllInputs();
}
const mitk::NavigationData* mitk::NavigationDataToIGTLMessageFilter::GetInput(void)
{
if (this->GetNumberOfInputs() < 1)
return nullptr;
return static_cast<const NavigationData*>(this->ProcessObject::GetInput(0));
}
const mitk::NavigationData* mitk::NavigationDataToIGTLMessageFilter::GetInput(unsigned int idx)
{
if (this->GetNumberOfInputs() < 1)
return nullptr;
return static_cast<const NavigationData*>(this->ProcessObject::GetInput(idx));
}
void mitk::NavigationDataToIGTLMessageFilter::CreateOutputsForAllInputs()
{
switch (m_OperationMode)
{
case ModeSendQTDataMsg:
// create one message output for all navigation data inputs
this->SetNumberOfIndexedOutputs(1);
// set the type for this filter
this->SetType("QTDATA");
break;
case ModeSendTDataMsg:
// create one message output for all navigation data inputs
this->SetNumberOfIndexedOutputs(1);
// set the type for this filter
this->SetType("TDATA");
break;
case ModeSendQTransMsg:
// create one message output for all navigation data input together
this->SetNumberOfIndexedOutputs(1);
// set the type for this filter
this->SetType("POSITION");
break;
case ModeSendTransMsg:
// create one message output for each navigation data input
this->SetNumberOfIndexedOutputs(this->GetNumberOfIndexedInputs());
// set the type for this filter
this->SetType("TRANS");
break;
default:
break;
}
for (unsigned int idx = 0; idx < this->GetNumberOfIndexedOutputs(); ++idx)
{
if (this->GetOutput(idx) == nullptr)
{
DataObjectPointer newOutput = this->MakeOutput(idx);
this->SetNthOutput(idx, newOutput);
}
this->Modified();
}
}
void ConvertAffineTransformationIntoIGTLMatrix(mitk::AffineTransform3D* trans,
igtl::Matrix4x4 igtlTransform)
{
const mitk::AffineTransform3D::MatrixType& matrix = trans->GetMatrix();
mitk::Vector3D position = trans->GetOffset();
//copy the data into a matrix type that igtl understands
for (unsigned int r = 0; r < 3; r++)
{
for (unsigned int c = 0; c < 3; c++)
{
igtlTransform[r][c] = matrix(r, c);
}
igtlTransform[r][3] = position[r];
}
for (unsigned int c = 0; c < 3; c++)
{
igtlTransform[3][c] = 0.0;
}
igtlTransform[3][3] = 1.0;
}
void mitk::NavigationDataToIGTLMessageFilter::GenerateDataModeSendQTransMsg()
{
// for each output message
for (unsigned int i = 0; i < this->GetNumberOfIndexedInputs(); ++i)
{
mitk::IGTLMessage* output = this->GetOutput(i);
assert(output);
const mitk::NavigationData* input = this->GetInput(i);
assert(input);
// do not add navigation data to message if input is invalid
if (input->IsDataValid() == false)
continue;
//get the navigation data components
mitk::NavigationData::PositionType pos = input->GetPosition();
mitk::NavigationData::OrientationType ori = input->GetOrientation();
//insert this information into the message
igtl::PositionMessage::Pointer posMsg = igtl::PositionMessage::New();
posMsg->SetPosition(pos[0], pos[1], pos[2]);
posMsg->SetQuaternion(ori[0], ori[1], ori[2], ori[3]);
igtl::TimeStamp::Pointer timestamp = ConvertToIGTLTimeStamp(input->GetIGTTimeStamp());
posMsg->SetTimeStamp(timestamp);
posMsg->SetDeviceName(input->GetName());
posMsg->Pack();
//add the igtl message to the mitk::IGTLMessage
output->SetMessage(posMsg.GetPointer());
}
}
void mitk::NavigationDataToIGTLMessageFilter::GenerateDataModeSendTransMsg()
{
// for each output message
for (unsigned int i = 0; i < this->GetNumberOfIndexedInputs(); ++i)
{
mitk::IGTLMessage* output = this->GetOutput(i);
assert(output);
const mitk::NavigationData* input = this->GetInput(i);
assert(input);
// do not add navigation data to message if input is invalid
if (input->IsDataValid() == false)
continue;
//get the navigation data components
mitk::AffineTransform3D::Pointer transform = input->GetAffineTransform3D();
- mitk::NavigationData::PositionType position = transform->GetOffset();
+ mitk::NavigationData::PositionType position = Point3D(transform->GetOffset());
//convert the transform into a igtl type
igtl::Matrix4x4 igtlTransform;
ConvertAffineTransformationIntoIGTLMatrix(transform, igtlTransform);
//insert this information into the message
igtl::TransformMessage::Pointer transMsg = igtl::TransformMessage::New();
transMsg->SetMatrix(igtlTransform);
transMsg->SetPosition(position[0], position[1], position[2]);
igtl::TimeStamp::Pointer timestamp = ConvertToIGTLTimeStamp(input->GetIGTTimeStamp());
transMsg->SetTimeStamp(timestamp);
transMsg->SetDeviceName(input->GetName());
transMsg->Pack();
//add the igtl message to the mitk::IGTLMessage
output->SetMessage(transMsg.GetPointer());
}
}
igtl::TimeStamp::Pointer mitk::NavigationDataToIGTLMessageFilter::ConvertToIGTLTimeStamp(double IGTTimeStamp)
{
igtl::TimeStamp::Pointer timestamp = igtl::TimeStamp::New();
timestamp->SetTime(IGTTimeStamp / 1000, (int)(IGTTimeStamp) % 1000);
return timestamp;
}
void mitk::NavigationDataToIGTLMessageFilter::GenerateDataModeSendQTDataMsg()
{
mitk::IGTLMessage* output = this->GetOutput();
assert(output);
//create a output igtl message
igtl::QuaternionTrackingDataMessage::Pointer qtdMsg =
igtl::QuaternionTrackingDataMessage::New();
mitk::NavigationData::PositionType pos;
mitk::NavigationData::OrientationType ori;
for (unsigned int index = 0; index < this->GetNumberOfIndexedInputs(); index++)
{
const mitk::NavigationData* nd = GetInput(index);
assert(nd);
//get the navigation data components
pos = nd->GetPosition();
ori = nd->GetOrientation();
//insert the information into the tracking element
igtl::QuaternionTrackingDataElement::Pointer tde =
igtl::QuaternionTrackingDataElement::New();
tde->SetPosition(pos[0], pos[1], pos[2]);
tde->SetQuaternion(ori[0], ori[1], ori[2], ori[3]);
tde->SetName(nd->GetName());
//insert this element into the tracking data message
qtdMsg->AddQuaternionTrackingDataElement(tde);
MITK_INFO << ConvertToIGTLTimeStamp(nd->GetIGTTimeStamp());
}
qtdMsg->Pack();
//add the igtl message to the mitk::IGTLMessage
output->SetMessage(qtdMsg.GetPointer());
}
void mitk::NavigationDataToIGTLMessageFilter::GenerateDataModeSendTDataMsg()
{
igtl::TrackingDataMessage::Pointer tdMsg = igtl::TrackingDataMessage::New();
mitk::IGTLMessage* output = this->GetOutput(0);
assert(output);
// for each output message
for (unsigned int i = 0; i < this->GetNumberOfIndexedInputs(); ++i)
{
const mitk::NavigationData* input = this->GetInput(i);
assert(input);
// do not add navigation data to message if input is invalid
if (input->IsDataValid() == false)
continue;
//get the navigation data components
mitk::AffineTransform3D::Pointer transform = input->GetAffineTransform3D();
- mitk::NavigationData::PositionType position = transform->GetOffset();
+ mitk::NavigationData::PositionType position = Point3D(transform->GetOffset());
//convert the transform into a igtl type
igtl::Matrix4x4 igtlTransform;
ConvertAffineTransformationIntoIGTLMatrix(transform, igtlTransform);
//insert this information into the message
igtl::TrackingDataElement::Pointer tde = igtl::TrackingDataElement::New();
tde->SetMatrix(igtlTransform);
tde->SetPosition(position[0], position[1], position[2]);
tde->SetName(input->GetName());
tde->SetType(igtl::TrackingDataElement::TYPE_6D);
tdMsg->AddTrackingDataElement(tde);
}
//use time stamp from first input
igtl::TimeStamp::Pointer timestamp = ConvertToIGTLTimeStamp(this->GetInput(0)->GetIGTTimeStamp());
tdMsg->SetTimeStamp(timestamp);
//tdMsg->SetDeviceName("MITK OpenIGTLink Connection");
tdMsg->Pack();
tdMsg->SetDeviceName("MITK OpenIGTLink Source");
output->SetMessage(tdMsg.GetPointer());
}
void mitk::NavigationDataToIGTLMessageFilter::SetOperationMode(OperationMode mode)
{
m_OperationMode = mode;
this->Modified();
}
void mitk::NavigationDataToIGTLMessageFilter::ConnectTo(
mitk::NavigationDataSource* UpstreamFilter)
{
for (DataObjectPointerArraySizeType i = 0;
i < UpstreamFilter->GetNumberOfOutputs(); i++)
{
this->SetInput(i, UpstreamFilter->GetOutput(i));
}
}
diff --git a/Modules/IGT/CMakeLists.txt b/Modules/IGT/CMakeLists.txt
index 51ae8db7fe..79ab9c6f5c 100644
--- a/Modules/IGT/CMakeLists.txt
+++ b/Modules/IGT/CMakeLists.txt
@@ -1,61 +1,54 @@
include(MITKIGTHardware.cmake)
if(MITK_USE_MICRON_TRACKER)
set(ADDITIONAL_INCLUDE_DIRS ${ADDITIONAL_INCLUDE_DIRS} ${MITK_MICRON_TRACKER_INCLUDE_DIR})
set(ADDITIONAL_LIBS ${ADDITIONAL_LIBS} ${MITK_MICRON_TRACKER_LIB})
-endif(MITK_USE_MICRON_TRACKER)
+endif()
if(MITK_USE_OPTITRACK_TRACKER)
set(ADDITIONAL_INCLUDE_DIRS ${ADDITIONAL_INCLUDE_DIRS} ${MITK_OPTITRACK_TRACKER_INCLUDE_DIR})
set(ADDITIONAL_LIBS ${ADDITIONAL_LIBS} ${MITK_OPTITRACK_TRACKER_LIB})
add_definitions( -DMITK_USE_OPTITRACK_TRACKER )
-endif(MITK_USE_OPTITRACK_TRACKER)
+endif()
if(MITK_USE_MICROBIRD_TRACKER)
set(ADDITIONAL_INCLUDE_DIRS ${ADDITIONAL_INCLUDE_DIRS} ${MITK_USE_MICROBIRD_TRACKER_INCLUDE_DIR})
set(ADDITIONAL_LIBS ${ADDITIONAL_LIBS} ${MITK_USE_MICROBIRD_TRACKER_LIB})
-endif(MITK_USE_MICROBIRD_TRACKER)
+endif()
if(MITK_USE_POLHEMUS_TRACKER)
set(ADDITIONAL_INCLUDE_DIRS ${ADDITIONAL_INCLUDE_DIRS} ${MITK_POLHEMUS_TRACKER_INCLUDE_DIR})
set(ADDITIONAL_LIBS ${ADDITIONAL_LIBS} ${MITK_POLHEMUS_TRACKER_LIB})
-endif(MITK_USE_POLHEMUS_TRACKER)
+endif()
-MITK_CREATE_MODULE(
+mitk_create_module(
INCLUDE_DIRS
PUBLIC Algorithms Common DataManagement ExceptionHandling IO Rendering TrackingDevices TestingHelper
PRIVATE ${ADDITIONAL_INCLUDE_DIRS}
DEPENDS PUBLIC MitkImageStatistics MitkSceneSerialization MitkIGTBase MitkOpenIGTLink
PACKAGE_DEPENDS PRIVATE ITK|RegistrationCommon OpenIGTLink tinyxml2
ADDITIONAL_LIBS "${ADDITIONAL_LIBS}"
)
if(MitkIGT_IS_ENABLED)
MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/ClaronMicron.stl )
MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/IntuitiveDaVinci.stl )
MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIAurora.stl )
MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIAurora_Dome.stl )
MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIAuroraCompactFG_Dome.stl )
MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIAuroraPlanarFG_Dome.stl )
MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIAuroraTabletopFG_Dome.stl )
MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIAuroraTabletopFG_Prototype_Dome.stl )
MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIPolarisOldModel.stl )
MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIPolarisSpectra.stl )
MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIPolarisSpectraExtendedPyramid.stl )
MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIPolarisVicra.stl )
endif()
-if(NOT MODULE_IS_ENABLED)
- message(STATUS "IGTTutorialStep1 won't be built. Missing: ${_RESULT}")
-else()
-## create IGT config
-configure_file(mitkIGTConfig.h.in ${PROJECT_BINARY_DIR}/mitkIGTConfig.h @ONLY)
-
-add_subdirectory(autoload/DeviceRegistry)
-
-add_subdirectory(Tutorial)
-
-add_subdirectory(Testing)
+if(MODULE_IS_ENABLED)
+ configure_file(mitkIGTConfig.h.in ${PROJECT_BINARY_DIR}/mitkIGTConfig.h @ONLY)
+ add_subdirectory(autoload/DeviceRegistry)
+ add_subdirectory(Tutorial)
+ add_subdirectory(Testing)
endif()
-
diff --git a/Modules/IGT/Testing/mitkNavigationDataReferenceTransformFilterTest.cpp b/Modules/IGT/Testing/mitkNavigationDataReferenceTransformFilterTest.cpp
index f76ed9bae0..3c557e6186 100644
--- a/Modules/IGT/Testing/mitkNavigationDataReferenceTransformFilterTest.cpp
+++ b/Modules/IGT/Testing/mitkNavigationDataReferenceTransformFilterTest.cpp
@@ -1,223 +1,223 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkNavigationDataReferenceTransformFilter.h"
#include "mitkNavigationData.h"
#include "mitkTestingMacros.h"
#include <itkQuaternionRigidTransform.h>
#include <iostream>
/**Documentation
* test for the class "NavigationDataReferenceTransformFilter".
*/
int mitkNavigationDataReferenceTransformFilterTest(int /* argc */, char* /*argv*/[])
{
MITK_TEST_BEGIN("NavigationDataReferenceTransformFilter")
// let's create an object of our class
mitk::NavigationDataReferenceTransformFilter::Pointer myFilter = mitk::NavigationDataReferenceTransformFilter::New();
// first test: did this work?
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(myFilter.IsNotNull(),"Testing instantiation");
/*create helper objects: positions of the ND sources*/
mitk::Point3D sourcePos1,sourcePos2, sourcePos3, targetPos1, targetPos2, targetPos3;
mitk::FillVector3D(sourcePos1, 11.1, 11.1, 11.1);
mitk::FillVector3D(sourcePos2, 22.2, 22.2, 22.2);
mitk::FillVector3D(sourcePos3, 33.3, 33.3, 33.3);
mitk::FillVector3D(targetPos1, -1.1, -2.2, -3.3);
mitk::FillVector3D(targetPos2, -4.4, -5.5, -6.6);
mitk::FillVector3D(targetPos3, -7.7, -8.8, -9.9);
/*create helper objects: orientations of the ND sources*/
mitk::NavigationData::OrientationType sourceOri1(0.1, 0.1, 0.1, 0.1);
mitk::NavigationData::OrientationType sourceOri2(0.2, 0.2, 0.2, 0.2);
mitk::NavigationData::OrientationType sourceOri3(0.3, 0.3, 0.3, 0.3);
mitk::NavigationData::OrientationType targetOri1(0.4, 0.4, 0.4, 0.4);
mitk::NavigationData::OrientationType targetOri2(0.5, 0.5, 0.5, 0.5);
mitk::NavigationData::OrientationType targetOri3(0.6, 0.6, 0.6, 0.6);
/*create helper objects: ND position accurancy and validity bool*/
mitk::ScalarType initialError(0.0);
bool initialValid(true);
/*create helper objects: NDs for the source and target NDs*/
mitk::NavigationData::Pointer snd1 = mitk::NavigationData::New();
snd1->SetPosition(sourcePos1);
snd1->SetOrientation(sourceOri1);
snd1->SetPositionAccuracy(initialError);
snd1->SetDataValid(initialValid);
mitk::NavigationData::Pointer snd2 = mitk::NavigationData::New();
snd2->SetPosition(sourcePos2);
snd2->SetOrientation(sourceOri2);
snd2->SetPositionAccuracy(initialError);
snd2->SetDataValid(initialValid);
mitk::NavigationData::Pointer snd3 = mitk::NavigationData::New();
snd3->SetPosition(sourcePos3);
snd3->SetOrientation(sourceOri3);
snd3->SetPositionAccuracy(initialError);
snd3->SetDataValid(initialValid);
mitk::NavigationData::Pointer tnd1 = mitk::NavigationData::New();
tnd1->SetPosition(targetPos1);
tnd1->SetOrientation(targetOri1);
tnd1->SetPositionAccuracy(initialError);
tnd1->SetDataValid(initialValid);
mitk::NavigationData::Pointer tnd2 = mitk::NavigationData::New();
tnd2->SetPosition(targetPos2);
tnd2->SetOrientation(targetOri2);
tnd2->SetPositionAccuracy(initialError);
tnd2->SetDataValid(initialValid);
mitk::NavigationData::Pointer tnd3 = mitk::NavigationData::New();
tnd3->SetPosition(targetPos3);
tnd3->SetOrientation(targetOri3);
tnd3->SetPositionAccuracy(initialError);
tnd3->SetDataValid(initialValid);
std::vector<mitk::NavigationData::Pointer> emptySourceNDs;
std::vector<mitk::NavigationData::Pointer> oneSourceNDs;
oneSourceNDs.push_back(snd1);
std::vector<mitk::NavigationData::Pointer> twoSourceNDs;
twoSourceNDs.push_back(snd1);
twoSourceNDs.push_back(snd2);
std::vector<mitk::NavigationData::Pointer> threeSourceNDs;
threeSourceNDs.push_back(snd1);
threeSourceNDs.push_back(snd2);
threeSourceNDs.push_back(snd3);
std::vector<mitk::NavigationData::Pointer> emptyTargetNDs;
std::vector<mitk::NavigationData::Pointer> oneTargetNDs;
oneTargetNDs.push_back(tnd1);
std::vector<mitk::NavigationData::Pointer> twoTargetNDs;
twoTargetNDs.push_back(tnd1);
twoTargetNDs.push_back(tnd2);
std::vector<mitk::NavigationData::Pointer> threeTargetNDs;
threeTargetNDs.push_back(tnd1);
threeTargetNDs.push_back(tnd2);
threeTargetNDs.push_back(tnd3);
// ------------------ setting no NDs ------------------
myFilter->SetSourceNavigationDatas(emptySourceNDs);
MITK_TEST_CONDITION_REQUIRED(myFilter->GetSourceLandmarks()->IsEmpty() == true, "Testing behaviour if setting no source NDs");
myFilter->SetSourceNavigationDatas(emptyTargetNDs);
MITK_TEST_CONDITION_REQUIRED(myFilter->GetTargetLandmarks()->IsEmpty() == true, "Testing behaviour if setting no target NDs");
// ------------------ setting one ND ------------------
myFilter->SetSourceNavigationDatas(oneSourceNDs);
MITK_TEST_CONDITION_REQUIRED(myFilter->GetSourceLandmarks()->GetSize() == 3, "Testing if 3 source points are generated from one source ND");
myFilter->SetTargetNavigationDatas(oneTargetNDs);
MITK_TEST_CONDITION_REQUIRED(myFilter->GetTargetLandmarks()->GetSize() == 3, "Testing if 3 target points are generated from one target ND");
// ------------------ setting two NDs ------------------
myFilter->SetSourceNavigationDatas(twoSourceNDs);
MITK_TEST_CONDITION_REQUIRED(myFilter->GetSourceLandmarks()->GetSize() == 6, "Testing if 6 source points are generated from two source NDs");
myFilter->SetTargetNavigationDatas(twoTargetNDs);
MITK_TEST_CONDITION_REQUIRED(myFilter->GetTargetLandmarks()->GetSize() == 6, "Testing if 6 target points are generated from two target NDs");
// ------------------ setting three NDs ------------------
myFilter->SetSourceNavigationDatas(threeSourceNDs);
MITK_TEST_CONDITION_REQUIRED(myFilter->GetSourceLandmarks()->GetSize() == 3, "Testing if 3 source NDs are passed to 3 source points");
myFilter->SetTargetNavigationDatas(threeTargetNDs);
MITK_TEST_CONDITION_REQUIRED(myFilter->GetTargetLandmarks()->GetSize() == 3, "Testing if 3 target NDs are passed to 3 target points");
// ------------------ setting different number of NDs for source and target ------------------
bool firstInitialize = myFilter->InitializeTransform();
myFilter->SetTargetNavigationDatas(twoTargetNDs);
MITK_TEST_CONDITION_REQUIRED((firstInitialize == true && myFilter->InitializeTransform() == false), "Testing if initialization is denied, if different number of source and target NDs are set");
// ------------------ reinit of this filter ------------------
bool sourcePointsSet = myFilter->GetSourceLandmarks()->GetSize() > 0;
bool targetPointsSet = myFilter->GetTargetLandmarks()->GetSize() > 0;
MITK_TEST_CONDITION_REQUIRED(sourcePointsSet && targetPointsSet, "Testing if there are source and target landmarks set in the superclass");
myFilter->ReinitFilter();
bool sourcePointsCleared = myFilter->GetSourceLandmarks()->GetSize() == 0;
bool targetPointsCleared = myFilter->GetTargetLandmarks()->GetSize() == 0;
MITK_TEST_CONDITION_REQUIRED(sourcePointsCleared && targetPointsCleared, "Testing if reinit of filter was successful");
// ------------------ testing the point generation ------------------
myFilter->SetSourceNavigationDatas(oneSourceNDs); // set the ND with sourcePos1 and sourceOri1 for that the points will be generated
itk::QuaternionRigidTransform<double>::Pointer quaternionTransform = itk::QuaternionRigidTransform<double>::New();
vnl_quaternion<double> const vnlQuatIn(sourceOri1.x(), sourceOri1.y(), sourceOri1.z(), sourceOri1.r());
quaternionTransform->SetRotation(vnlQuatIn);
mitk::Point3D pointA;
mitk::Point3D pointB;
mitk::Point3D pointC;
//initializing three points with position(0|0|0)
pointA.Fill(0);
pointB.Fill(0);
pointC.Fill(0);
// changing position off all points in order to make them orthogonal
pointA[0] = 1;
pointB[1] = 1;
pointC[2] = 1;
// quaternion transform the points
pointA = quaternionTransform->GetMatrix() * pointA;
pointB = quaternionTransform->GetMatrix() * pointB;
pointC = quaternionTransform->GetMatrix() * pointC;
// now subtract them from the filter landmarks and compare them to the source pos
- pointA = myFilter->GetSourceLandmarks()->GetPoint(0)-pointA;
- pointB = myFilter->GetSourceLandmarks()->GetPoint(1)-pointB;
- pointC = myFilter->GetSourceLandmarks()->GetPoint(2)-pointC;
+ pointA = mitk::Point3D(myFilter->GetSourceLandmarks()->GetPoint(0)-pointA);
+ pointB = mitk::Point3D(myFilter->GetSourceLandmarks()->GetPoint(1)-pointB);
+ pointC = mitk::Point3D(myFilter->GetSourceLandmarks()->GetPoint(2)-pointC);
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(sourcePos1,pointA,mitk::eps,true), "Testing if point generation of first point is correct");
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(sourcePos1,pointB,mitk::eps,true), "Testing if point generation of second point is correct");
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(sourcePos1,pointC,mitk::eps,true), "Testing if point generation of third point is correct");
// deleting helper objects
myFilter = nullptr;
quaternionTransform = nullptr;
snd1 = nullptr;
snd2 = nullptr;
snd3 = nullptr;
tnd1 = nullptr;
tnd2 = nullptr;
tnd3 = nullptr;
// always end with this!
MITK_TEST_END();
}
diff --git a/Modules/IGTBase/include/mitkNavigationDataSet.h b/Modules/IGTBase/include/mitkNavigationDataSet.h
index c7475addf8..e69b031e5a 100644
--- a/Modules/IGTBase/include/mitkNavigationDataSet.h
+++ b/Modules/IGTBase/include/mitkNavigationDataSet.h
@@ -1,170 +1,161 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef MITKNAVIGATIONDATASET_H_HEADER_INCLUDED_
#define MITKNAVIGATIONDATASET_H_HEADER_INCLUDED_
#include <MitkIGTBaseExports.h>
#include "mitkBaseData.h"
#include "mitkNavigationData.h"
namespace mitk {
/**
* \brief Data structure which stores streams of mitk::NavigationData for
* multiple tools.
*
* Use mitk::NavigationDataRecorder to create these sets easily from pipelines.
* Use mitk::NavigationDataPlayer to stream from these sets easily.
*
*/
class MITKIGTBASE_EXPORT NavigationDataSet : public BaseData
{
public:
/**
* \brief This iterator iterates over the distinct time steps in this set.
*
* It returns an array of the length equal to GetNumberOfTools(), containing a
* mitk::NavigationData for each tool..
*/
typedef std::vector< std::vector<mitk::NavigationData::Pointer> >::iterator NavigationDataSetIterator;
/**
* \brief This iterator iterates over the distinct time steps in this set. And is const.
*
* It returns an array of the length equal to GetNumberOfTools(), containing a
* mitk::NavigationData for each tool..
*/
typedef std::vector< std::vector<mitk::NavigationData::Pointer> >::const_iterator NavigationDataSetConstIterator;
mitkClassMacro(NavigationDataSet, BaseData);
mitkNewMacro1Param(Self, unsigned int);
/**
* \brief Add mitk::NavigationData of the given tool to the Set.
*
* @param navigationDatas vector of mitk::NavigationData objects to be added. Make sure that the size of the
* vector equals the number of tools given in the constructor
* @return true if object was be added to the set successfully, false otherwise
*/
bool AddNavigationDatas( std::vector<mitk::NavigationData::Pointer> navigationDatas );
/**
* \brief Get mitk::NavigationData from the given tool at given index.
*
* @param toolIndex Index of the tool from which mitk::NavigationData should be returned.
* @param index Index of the mitk::NavigationData object that should be returned.
* @return mitk::NavigationData at the specified indices, 0 if there is no object at the indices.
*/
NavigationData::Pointer GetNavigationDataForIndex( unsigned int index, unsigned int toolIndex ) const;
- ///**
- //* \brief Get last mitk::Navigation object for given tool whose timestamp is less than the given timestamp.
- //* @param toolIndex Index of the tool from which mitk::NavigationData should be returned.
- //* @param timestamp Timestamp for selecting last object before.
- //* @return Last mitk::NavigationData with timestamp less than given timestamp, 0 if there is no adequate object.
- //*/
- // Method not yet supported!
- //NavigationData::Pointer GetNavigationDataBeforeTimestamp( mitk::NavigationData::TimeStampType timestamp , unsigned int toolIndex ) const;
-
/**
* \brief Returns a vector that contains all tracking data for a given tool.
*
* This is a relatively expensive operation, as it requires the construction of a new vector.
*
* @param toolIndex Index of the tool for which the stream should be returned.
* @return Returns a vector that contains all tracking data for a given tool.
*/
virtual std::vector< mitk::NavigationData::Pointer > GetDataStreamForTool(unsigned int toolIndex);
/**
* \brief Returns a vector that contains NavigationDatas for each tool for a given timestep.
*
* If GetNumberOFTools() equals four, then 4 NavigationDatas will be returned.
*
* @param index Index of the timeStep for which the datas should be returned. cannot be larger than mitk::NavigationDataSet::Size()
* @return Returns a vector that contains all tracking data for a given tool.
*/
virtual std::vector< mitk::NavigationData::Pointer > GetTimeStep(unsigned int index) const;
/**
* \brief Returns the number of tools for which NavigationDatas are stored in this set.
*
* This is always equal to the number given in the constructor of this class.
*
* @return the number of tools for which NavigationDatas are stored in this set.
*/
unsigned int GetNumberOfTools() const;
/**
* \brief Returns the number of time steps stored in this NavigationDataSet.
*
* This is not the total number of Navigation Datas stored in this set, but the number stored for each tool.
* i.e. the total number of NavigationDatas equals Size() * GetNumberOfTools();
*
* @return Returns the number of time steps stored in this NavigationDataSet.
*/
unsigned int Size() const;
/**
* \brief Returns an iterator pointing to the first TimeStep.
*
* @return Returns an iterator pointing to the first TimeStep.
*/
virtual NavigationDataSetConstIterator Begin() const;
/**
* \brief Returns an iterator pointing behind to the last TimeStep.
*
* @return Returns an iterator pointing behind to the last TimeStep.
*/
virtual NavigationDataSetConstIterator End() const;
// virtual methods, that need to be implemented, but aren't reasonable for NavigationData
void SetRequestedRegionToLargestPossibleRegion( ) override;
bool RequestedRegionIsOutsideOfTheBufferedRegion( ) override;
bool VerifyRequestedRegion( ) override;
void SetRequestedRegion( const itk::DataObject *data ) override;
/**
* \brief This overrid is probably a little hacky. See Bug 19086.
*/
bool IsEmpty() const override;
//Converts Navigation Data for each tool to a Point Set and adds it to the data storage
void ConvertNavigationDataToPointSet() const;
protected:
/**
* \brief Constructs set with fixed number of tools.
* @param numTools How many tools are used with this mitk::NavigationDataSet.
*/
NavigationDataSet( unsigned int numTools );
~NavigationDataSet( ) override;
/**
* \brief Holds all the mitk::NavigationData objects managed by this class.
*
* The first dimension is the index of the navigation data, the second is the
* tool to which this data belongs. i.e. the first dimension is usually the longer one.
*/
std::vector<std::vector<NavigationData::Pointer> > m_NavigationDataVectors;
/**
* \brief The Number of Tools that this class is going to support.
*/
unsigned int m_NumberOfTools;
};
}
#endif // MITKNAVIGATIONDATASET_H_HEADER_INCLUDED_
diff --git a/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.cpp b/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.cpp
index 60cb9e101c..11fa90a23f 100644
--- a/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.cpp
@@ -1,393 +1,393 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkNavigationToolCreationWidget.h"
//mitk headers
#include <mitkTrackingTypes.h>
#include <mitkSurface.h>
#include <mitkNavigationData.h>
#include <mitkRenderingManager.h>
#include "mitkTrackingDeviceTypeCollection.h"
//qt headers
#include <qfiledialog.h>
#include <qmessagebox.h>
#include <mitkIOUtil.h>
#include <QmitkIGTCommonHelper.h>
#include <QDialogButtonBox>
//poco headers
#include <Poco/Path.h>
const std::string QmitkNavigationToolCreationWidget::VIEW_ID = "org.mitk.views.navigationtoolcreationwizardwidget";
QmitkNavigationToolCreationWidget::QmitkNavigationToolCreationWidget(QWidget* parent, Qt::WindowFlags f)
: QWidget(parent, f)
{
m_Controls = nullptr;
m_ToolToBeEdited = mitk::NavigationTool::New();
m_FinalTool = mitk::NavigationTool::New();
m_ToolTransformationWidget = new QmitkInteractiveTransformationWidget();
m_Controls = nullptr;
CreateQtPartControl(this);
CreateConnections();
this->InitializeUIToolLandmarkLists();
Initialize(nullptr, "");
//Default values, which are not stored in tool
m_Controls->m_CalibrationFileName->setText("none");
m_Controls->m_Surface_Use_Sphere->setChecked(true);
m_Controls->m_CalibrationLandmarksList->EnableEditButton(false);
m_Controls->m_RegistrationLandmarksList->EnableEditButton(false);
RefreshTrackingDeviceCollection();
OnSurfaceUseToggled();
}
QmitkNavigationToolCreationWidget::~QmitkNavigationToolCreationWidget()
{
m_Controls->m_CalibrationLandmarksList->SetPointSetNode(nullptr);
m_Controls->m_RegistrationLandmarksList->SetPointSetNode(nullptr);
delete m_ToolTransformationWidget;
}
void QmitkNavigationToolCreationWidget::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkNavigationToolCreationWidgetControls;
m_Controls->setupUi(parent);
}
}
void QmitkNavigationToolCreationWidget::CreateConnections()
{
if (m_Controls)
{
connect((QObject*)(m_Controls->m_TrackingDeviceTypeChooser), SIGNAL(currentIndexChanged(int)), this, SLOT(GetValuesFromGuiElements()));
connect((QObject*)(m_Controls->m_ToolNameEdit), SIGNAL(textChanged(const QString)), this, SLOT(GetValuesFromGuiElements()));
connect((QObject*)(m_Controls->m_ToolTypeChooser), SIGNAL(currentIndexChanged(int)), this, SLOT(GetValuesFromGuiElements()));
connect((QObject*)(m_Controls->m_IdentifierEdit), SIGNAL(textChanged(const QString)), this, SLOT(GetValuesFromGuiElements()));
connect((QObject*)(m_Controls->m_SerialNumberEdit), SIGNAL(textChanged(const QString)), this, SLOT(GetValuesFromGuiElements()));
connect((QObject*)(m_Controls->m_ToolAxisX), SIGNAL(valueChanged(int)), this, SLOT(GetValuesFromGuiElements()));
connect((QObject*)(m_Controls->m_ToolAxisY), SIGNAL(valueChanged(int)), this, SLOT(GetValuesFromGuiElements()));
connect((QObject*)(m_Controls->m_ToolAxisZ), SIGNAL(valueChanged(int)), this, SLOT(GetValuesFromGuiElements()));
//Buttons
connect((QObject*)(m_Controls->m_LoadCalibrationFile), SIGNAL(clicked()), this, SLOT(OnLoadCalibrationFile()));
connect(m_Controls->m_Surface_Use_Other, SIGNAL(toggled(bool)), this, SLOT(OnSurfaceUseToggled()));
connect(m_Controls->m_Surface_Load_File, SIGNAL(toggled(bool)), this, SLOT(OnSurfaceUseToggled()));
connect((QObject*)(m_Controls->m_LoadSurface), SIGNAL(clicked()), this, SLOT(OnLoadSurface()));
connect((QObject*)(m_Controls->m_EditToolTip), SIGNAL(clicked()), this, SLOT(OnEditToolTip()));
connect((QObject*)(m_ToolTransformationWidget), SIGNAL(EditToolTipFinished(mitk::AffineTransform3D::Pointer)), this,
SLOT(OnEditToolTipFinished(mitk::AffineTransform3D::Pointer)));
connect((QObject*)(m_Controls->m_cancel), SIGNAL(clicked()), this, SLOT(OnCancel()));
connect((QObject*)(m_Controls->m_finished), SIGNAL(clicked()), this, SLOT(OnFinished()));
}
}
void QmitkNavigationToolCreationWidget::Initialize(mitk::DataStorage* dataStorage, const std::string& supposedIdentifier, const std::string& supposedName)
{
m_DataStorage = dataStorage;
//initialize UI components
m_Controls->m_SurfaceChooser->SetDataStorage(m_DataStorage);
m_Controls->m_SurfaceChooser->SetAutoSelectNewItems(true);
m_Controls->m_SurfaceChooser->SetPredicate(mitk::NodePredicateDataType::New("Surface"));
//Create new tool, which should be edited/created
m_ToolToBeEdited = nullptr;//Reset
m_ToolToBeEdited = mitk::NavigationTool::New();//Reinitialize
m_ToolToBeEdited->SetIdentifier(supposedIdentifier);
m_ToolToBeEdited->GetDataNode()->SetName(supposedName);
this->SetDefaultData(m_ToolToBeEdited);
}
void QmitkNavigationToolCreationWidget::ShowToolPreview(std::string _name)
{
m_DataStorage->Add(m_ToolToBeEdited->GetDataNode());
m_ToolToBeEdited->GetDataNode()->SetName(_name);
//change color to blue
m_ToolToBeEdited->GetDataNode()->SetProperty("color", mitk::ColorProperty::New(0, 0, 1));
//Global Reinit to show new tool
mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(m_DataStorage);
}
void QmitkNavigationToolCreationWidget::SetDefaultData(mitk::NavigationTool::Pointer DefaultTool)
{
//Set Members. This can either be the new initialized tool from call of Initialize() or a tool which already exists in the toolStorage
m_ToolToBeEdited = DefaultTool->Clone();
//Set all gui variables
SetGuiElements();
}
void QmitkNavigationToolCreationWidget::SetGuiElements()
{
//Block signals, so that we don't call SetGuiElements again. This is undone at the end of this function!
m_Controls->m_TrackingDeviceTypeChooser->blockSignals(true);
m_Controls->m_ToolNameEdit->blockSignals(true);
m_Controls->m_ToolTypeChooser->blockSignals(true);
m_Controls->m_IdentifierEdit->blockSignals(true);
m_Controls->m_SerialNumberEdit->blockSignals(true);
m_Controls->m_ToolAxisX->blockSignals(true);
m_Controls->m_ToolAxisY->blockSignals(true);
m_Controls->m_ToolAxisZ->blockSignals(true);
//DeviceType
int index = m_Controls->m_TrackingDeviceTypeChooser->findText(QString::fromStdString(m_ToolToBeEdited->GetTrackingDeviceType()));
if (index >= 0)
{
m_Controls->m_TrackingDeviceTypeChooser->setCurrentIndex(index);
}
m_Controls->m_ToolNameEdit->setText(QString(m_ToolToBeEdited->GetToolName().c_str()));
m_Controls->m_CalibrationFileName->setText(QString(m_ToolToBeEdited->GetCalibrationFile().c_str()));
FillUIToolLandmarkLists(m_ToolToBeEdited->GetToolControlPoints(), m_ToolToBeEdited->GetToolLandmarks());
switch (m_ToolToBeEdited->GetType())
{
case mitk::NavigationTool::Instrument:
m_Controls->m_ToolTypeChooser->setCurrentIndex(0); break;
case mitk::NavigationTool::Fiducial:
m_Controls->m_ToolTypeChooser->setCurrentIndex(1); break;
case mitk::NavigationTool::Skinmarker:
m_Controls->m_ToolTypeChooser->setCurrentIndex(2); break;
case mitk::NavigationTool::Unknown:
m_Controls->m_ToolTypeChooser->setCurrentIndex(3); break;
}
m_Controls->m_IdentifierEdit->setText(QString(m_ToolToBeEdited->GetIdentifier().c_str()));
m_Controls->m_SerialNumberEdit->setText(QString(m_ToolToBeEdited->GetSerialNumber().c_str()));
QString _label = "(" +
QString::number(m_ToolToBeEdited->GetToolTipPosition()[0], 'f', 1) + ", " +
QString::number(m_ToolToBeEdited->GetToolTipPosition()[1], 'f', 1) + ", " +
QString::number(m_ToolToBeEdited->GetToolTipPosition()[2], 'f', 1) + "), quat: [" +
QString::number(m_ToolToBeEdited->GetToolAxisOrientation()[0], 'f', 2) + ", " +
QString::number(m_ToolToBeEdited->GetToolAxisOrientation()[1], 'f', 2) + ", " +
QString::number(m_ToolToBeEdited->GetToolAxisOrientation()[2], 'f', 2) + ", " +
QString::number(m_ToolToBeEdited->GetToolAxisOrientation()[3], 'f', 2) + "]";
m_Controls->m_ToolTipLabel->setText(_label);
//Undo block signals. Don't remove it, if signals are still blocked at the beginning of this function!
m_Controls->m_TrackingDeviceTypeChooser->blockSignals(false);
m_Controls->m_ToolNameEdit->blockSignals(false);
m_Controls->m_ToolTypeChooser->blockSignals(false);
m_Controls->m_IdentifierEdit->blockSignals(false);
m_Controls->m_SerialNumberEdit->blockSignals(false);
m_Controls->m_ToolAxisX->blockSignals(false);
m_Controls->m_ToolAxisY->blockSignals(false);
m_Controls->m_ToolAxisZ->blockSignals(false);
}
void QmitkNavigationToolCreationWidget::OnSurfaceUseToggled()
{
if (m_Controls->m_Surface_Use_Sphere->isChecked()) m_ToolToBeEdited->SetDefaultSurface();
m_Controls->m_SurfaceChooser->setEnabled(m_Controls->m_Surface_Use_Other->isChecked());
m_Controls->m_LoadSurface->setEnabled(m_Controls->m_Surface_Load_File->isChecked());
//Global Reinit to show tool surface preview
mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(m_DataStorage);
}
void QmitkNavigationToolCreationWidget::OnLoadSurface()
{
std::string filename = QFileDialog::getOpenFileName(nullptr, tr("Open Surface"), QmitkIGTCommonHelper::GetLastFileLoadPath(), tr("STL (*.stl)")).toLatin1().data();
QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(QString::fromStdString(filename));
mitk::Surface::Pointer surface;
try
{
surface = mitk::IOUtil::Load<mitk::Surface>(filename.c_str());
}
catch (mitk::Exception &e)
{
MITK_ERROR << "Exception occured: " << e.what();
return;
}
m_ToolToBeEdited->GetDataNode()->SetData(surface);
//Global Reinit to show tool surface or preview
mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(m_DataStorage);
}
void QmitkNavigationToolCreationWidget::OnLoadCalibrationFile()
{
QString fileName = QFileDialog::getOpenFileName(nullptr, tr("Open Calibration File"), QmitkIGTCommonHelper::GetLastFileLoadPath(), "*.*");
QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(fileName);
m_Controls->m_CalibrationFileName->setText(fileName);
m_ToolToBeEdited->SetCalibrationFile(fileName.toStdString());
}
void QmitkNavigationToolCreationWidget::GetValuesFromGuiElements()
{
//Tracking Device
m_ToolToBeEdited->SetTrackingDeviceType(m_Controls->m_TrackingDeviceTypeChooser->currentText().toStdString());
//m_ToolToBeEdited->GetDataNode()->SetName(m_Controls->m_ToolNameEdit->text().toStdString());
//Tool Landmarks
mitk::PointSet::Pointer toolCalLandmarks, toolRegLandmarks;
GetUIToolLandmarksLists(toolCalLandmarks, toolRegLandmarks);
m_ToolToBeEdited->SetToolControlPoints(toolCalLandmarks);
m_ToolToBeEdited->SetToolLandmarks(toolRegLandmarks);
//Advanced
if (m_Controls->m_ToolTypeChooser->currentText() == "Instrument") m_ToolToBeEdited->SetType(mitk::NavigationTool::Instrument);
else if (m_Controls->m_ToolTypeChooser->currentText() == "Fiducial") m_ToolToBeEdited->SetType(mitk::NavigationTool::Fiducial);
else if (m_Controls->m_ToolTypeChooser->currentText() == "Skinmarker") m_ToolToBeEdited->SetType(mitk::NavigationTool::Skinmarker);
else m_FinalTool->SetType(mitk::NavigationTool::Unknown);
m_ToolToBeEdited->SetIdentifier(m_Controls->m_IdentifierEdit->text().toLatin1().data());
m_ToolToBeEdited->SetSerialNumber(m_Controls->m_SerialNumberEdit->text().toLatin1().data());
////Tool Axis
//mitk::Point3D toolAxis;
//toolAxis.SetElement(0, (m_Controls->m_ToolAxisX->value()));
//toolAxis.SetElement(1, (m_Controls->m_ToolAxisY->value()));
//toolAxis.SetElement(2, (m_Controls->m_ToolAxisZ->value()));
//m_ToolToBeEdited->SetToolAxis(toolAxis);
}
mitk::NavigationTool::Pointer QmitkNavigationToolCreationWidget::GetCreatedTool()
{
return m_FinalTool;
}
void QmitkNavigationToolCreationWidget::OnFinished()
{
if (m_Controls->m_Surface_Use_Other->isChecked())
m_ToolToBeEdited->GetDataNode()->SetData(m_Controls->m_SurfaceChooser->GetSelectedNode()->GetData());
//here we create a new tool
m_FinalTool = m_ToolToBeEdited->Clone();
//Set the correct name of data node, cause the m_ToolToBeEdited was called "Tool preview"
m_FinalTool->GetDataNode()->SetName(m_Controls->m_ToolNameEdit->text().toStdString());
emit NavigationToolFinished();
}
void QmitkNavigationToolCreationWidget::OnCancel()
{
Initialize(nullptr, "");//Reset everything to a fresh tool, like it was done in the constructor
emit Canceled();
}
void QmitkNavigationToolCreationWidget::SetTrackingDeviceType(mitk::TrackingDeviceType type, bool changeable /*= true*/)
{
//Adapt Gui
int index = m_Controls->m_TrackingDeviceTypeChooser->findText(QString::fromStdString(type));
if (index >= 0)
{
m_Controls->m_TrackingDeviceTypeChooser->setCurrentIndex(index);
}
m_Controls->m_TrackingDeviceTypeChooser->setEditable(changeable);
//Set data to member
m_ToolToBeEdited->SetTrackingDeviceType(type);
}
//##################################################################################
//############################## internal help methods #############################
//##################################################################################
void QmitkNavigationToolCreationWidget::MessageBox(std::string s)
{
QMessageBox msgBox;
msgBox.setText(s.c_str());
msgBox.exec();
}
void QmitkNavigationToolCreationWidget::OnEditToolTip()
{
m_ToolTransformationWidget->SetToolToEdit(m_ToolToBeEdited);
m_ToolTransformationWidget->SetDefaultRotation(m_ToolToBeEdited->GetToolAxisOrientation());
m_ToolTransformationWidget->SetDefaultOffset(m_ToolToBeEdited->GetToolTipPosition());
m_ToolTransformationWidget->open();
}
void QmitkNavigationToolCreationWidget::OnEditToolTipFinished(mitk::AffineTransform3D::Pointer toolTip)
{
//if user pressed cancle, nullptr is returned. Do nothing. Else, set values.
if (toolTip)
{
- m_ToolToBeEdited->SetToolTipPosition(toolTip->GetOffset());
+ m_ToolToBeEdited->SetToolTipPosition(mitk::Point3D(toolTip->GetOffset()));
mitk::NavigationData::Pointer tempND = mitk::NavigationData::New(toolTip);//Convert to Navigation data for simple transversion to quaternion
m_ToolToBeEdited->SetToolAxisOrientation(tempND->GetOrientation());
//Update Label
QString _label = "(" +
QString::number(m_ToolToBeEdited->GetToolTipPosition()[0], 'f', 1) + ", " +
QString::number(m_ToolToBeEdited->GetToolTipPosition()[1], 'f', 1) + ", " +
QString::number(m_ToolToBeEdited->GetToolTipPosition()[2], 'f', 1) + "), quat: [" +
QString::number(m_ToolToBeEdited->GetToolAxisOrientation()[0], 'f', 2) + ", " +
QString::number(m_ToolToBeEdited->GetToolAxisOrientation()[1], 'f', 2) + ", " +
QString::number(m_ToolToBeEdited->GetToolAxisOrientation()[2], 'f', 2) + ", " +
QString::number(m_ToolToBeEdited->GetToolAxisOrientation()[3], 'f', 2) + "]";
m_Controls->m_ToolTipLabel->setText(_label);
}
}
void QmitkNavigationToolCreationWidget::FillUIToolLandmarkLists(mitk::PointSet::Pointer calLandmarks, mitk::PointSet::Pointer regLandmarks)
{
m_calLandmarkNode->SetData(calLandmarks);
m_regLandmarkNode->SetData(regLandmarks);
m_Controls->m_CalibrationLandmarksList->SetPointSetNode(m_calLandmarkNode);
m_Controls->m_RegistrationLandmarksList->SetPointSetNode(m_regLandmarkNode);
}
void QmitkNavigationToolCreationWidget::GetUIToolLandmarksLists(mitk::PointSet::Pointer& calLandmarks, mitk::PointSet::Pointer& regLandmarks)
{
calLandmarks = dynamic_cast<mitk::PointSet*>(m_calLandmarkNode->GetData());
regLandmarks = dynamic_cast<mitk::PointSet*>(m_regLandmarkNode->GetData());
}
void QmitkNavigationToolCreationWidget::InitializeUIToolLandmarkLists()
{
m_calLandmarkNode = mitk::DataNode::New();
m_regLandmarkNode = mitk::DataNode::New();
FillUIToolLandmarkLists(mitk::PointSet::New(), mitk::PointSet::New());
}
void QmitkNavigationToolCreationWidget::RefreshTrackingDeviceCollection()
{
us::ModuleContext* context = us::GetModuleContext();
std::vector<us::ServiceReference<mitk::TrackingDeviceTypeCollection> > refs = context->GetServiceReferences<mitk::TrackingDeviceTypeCollection>();
if (refs.empty())
{
MITK_WARN << "No tracking device service found!";
return;
}
mitk::TrackingDeviceTypeCollection* _DeviceTypeCollection = context->GetService<mitk::TrackingDeviceTypeCollection>(refs.front());
for (auto name : _DeviceTypeCollection->GetTrackingDeviceTypeNames())
{
//if the device is not included yet, add name to comboBox and widget to stackedWidget
if (m_Controls->m_TrackingDeviceTypeChooser->findText(QString::fromStdString(name)) == -1)
{
m_Controls->m_TrackingDeviceTypeChooser->addItem(QString::fromStdString(name));
}
}
}
diff --git a/Modules/ImageStatistics/mitkImageStatisticsContainer.cpp b/Modules/ImageStatistics/mitkImageStatisticsContainer.cpp
index 34f21704af..6b8851bdd4 100644
--- a/Modules/ImageStatistics/mitkImageStatisticsContainer.cpp
+++ b/Modules/ImageStatistics/mitkImageStatisticsContainer.cpp
@@ -1,240 +1,240 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkImageStatisticsContainer.h>
#include <algorithm>
namespace mitk
{
ImageStatisticsContainer::ImageStatisticsContainer() { this->Reset(); }
// The order is derived from the old (<2018) image statistics plugin.
const ImageStatisticsContainer::ImageStatisticsObject::StatisticNameVector
ImageStatisticsContainer::ImageStatisticsObject::m_DefaultNames = {ImageStatisticsConstants::MEAN(),
ImageStatisticsConstants::MEDIAN(),
ImageStatisticsConstants::STANDARDDEVIATION(),
ImageStatisticsConstants::RMS(),
ImageStatisticsConstants::MAXIMUM(),
ImageStatisticsConstants::MAXIMUMPOSITION(),
ImageStatisticsConstants::MINIMUM(),
ImageStatisticsConstants::MINIMUMPOSITION(),
ImageStatisticsConstants::NUMBEROFVOXELS(),
ImageStatisticsConstants::VOLUME(),
ImageStatisticsConstants::SKEWNESS(),
ImageStatisticsConstants::KURTOSIS(),
ImageStatisticsConstants::UNIFORMITY(),
ImageStatisticsConstants::ENTROPY(),
ImageStatisticsConstants::MPP(),
ImageStatisticsConstants::UPP()};
ImageStatisticsContainer::ImageStatisticsObject::ImageStatisticsObject() { Reset(); }
void ImageStatisticsContainer::ImageStatisticsObject::AddStatistic(const std::string &key, StatisticsVariantType value)
{
m_Statistics.emplace(key, value);
if (std::find(m_DefaultNames.cbegin(), m_DefaultNames.cend(), key) == m_DefaultNames.cend())
{
if (std::find(m_CustomNames.cbegin(), m_CustomNames.cend(), key) == m_CustomNames.cend())
{
m_CustomNames.emplace_back(key);
}
}
}
const ImageStatisticsContainer::ImageStatisticsObject::StatisticNameVector &
ImageStatisticsContainer::ImageStatisticsObject::GetDefaultStatisticNames()
{
return m_DefaultNames;
}
const ImageStatisticsContainer::ImageStatisticsObject::StatisticNameVector &
ImageStatisticsContainer::ImageStatisticsObject::GetCustomStatisticNames() const
{
return m_CustomNames;
}
ImageStatisticsContainer::ImageStatisticsObject::StatisticNameVector
ImageStatisticsContainer::ImageStatisticsObject::GetAllStatisticNames() const
{
StatisticNameVector names = GetDefaultStatisticNames();
names.insert(names.cend(), m_CustomNames.cbegin(), m_CustomNames.cend());
return names;
}
ImageStatisticsContainer::ImageStatisticsObject::StatisticNameVector
ImageStatisticsContainer::ImageStatisticsObject::GetExistingStatisticNames() const
{
StatisticNameVector names;
std::transform(m_Statistics.begin(), m_Statistics.end(), std::back_inserter(names), [](const auto &pair) {
return pair.first;
});
return names;
}
bool ImageStatisticsContainer::ImageStatisticsObject::HasStatistic(const std::string &name) const
{
return m_Statistics.find(name) != m_Statistics.cend();
}
ImageStatisticsContainer::StatisticsVariantType ImageStatisticsContainer::ImageStatisticsObject::GetValueNonConverted(
const std::string &name) const
{
if (HasStatistic(name))
{
return m_Statistics.find(name)->second;
}
else
{
mitkThrow() << "invalid statistic key, could not find";
}
}
void ImageStatisticsContainer::ImageStatisticsObject::Reset()
{
m_Statistics.clear();
m_CustomNames.clear();
}
bool ImageStatisticsContainer::TimeStepExists(TimeStepType timeStep) const
{
return m_TimeStepMap.find(timeStep) != m_TimeStepMap.end();
}
const ImageStatisticsContainer::HistogramType*
ImageStatisticsContainer::GetHistogramForTimeStep(TimeStepType timeStep) const
{
return this->GetStatisticsForTimeStep(timeStep).m_Histogram;
}
const ImageStatisticsContainer::ImageStatisticsObject &ImageStatisticsContainer::GetStatisticsForTimeStep(
TimeStepType timeStep) const
{
auto it = m_TimeStepMap.find(timeStep);
if (it != m_TimeStepMap.end())
{
return it->second;
}
mitkThrow() << "StatisticsObject for timeStep " << timeStep << " not found!";
}
void ImageStatisticsContainer::SetStatisticsForTimeStep(TimeStepType timeStep, ImageStatisticsObject statistics)
{
if (timeStep < this->GetTimeSteps())
{
m_TimeStepMap.emplace(timeStep, statistics);
this->Modified();
}
else
{
mitkThrow() << "Given timeStep " << timeStep
<< " out of timeStep geometry bounds. TimeSteps in geometry: " << this->GetTimeSteps();
}
}
void ImageStatisticsContainer::PrintSelf(std::ostream &os, itk::Indent indent) const
{
Superclass::PrintSelf(os, indent);
for (unsigned int i = 0; i < this->GetTimeSteps(); i++)
{
auto statisticsValues = GetStatisticsForTimeStep(i);
os << std::endl << indent << "Statistics instance for timeStep " << i << ":";
auto statisticKeys = statisticsValues.GetExistingStatisticNames();
os << std::endl << indent << "Number of entries: " << statisticKeys.size();
for (const auto &aKey : statisticKeys)
{
os << std::endl << indent.GetNextIndent() << aKey << ": " << statisticsValues.GetValueNonConverted(aKey);
}
}
}
unsigned int ImageStatisticsContainer::GetNumberOfTimeSteps() const { return this->GetTimeSteps(); }
void ImageStatisticsContainer::Reset()
{
for (auto iter = m_TimeStepMap.begin(); iter != m_TimeStepMap.end(); iter++)
{
iter->second.Reset();
}
}
itk::LightObject::Pointer ImageStatisticsContainer::InternalClone() const
{
itk::LightObject::Pointer ioPtr = Superclass::InternalClone();
Self::Pointer rval = dynamic_cast<Self *>(ioPtr.GetPointer());
if (rval.IsNull())
{
itkExceptionMacro(<< "downcast to type "
<< "StatisticsContainer"
<< " failed.");
}
rval->SetTimeStepMap(m_TimeStepMap);
rval->SetTimeGeometry(this->GetTimeGeometry()->Clone());
return ioPtr;
}
void ImageStatisticsContainer::SetTimeStepMap(TimeStepMapType map) { m_TimeStepMap = map; }
ImageStatisticsContainer::ImageStatisticsObject::StatisticNameVector GetAllStatisticNames(
const ImageStatisticsContainer *container)
{
ImageStatisticsContainer::ImageStatisticsObject::StatisticNameVector names =
ImageStatisticsContainer::ImageStatisticsObject::GetDefaultStatisticNames();
if (container)
{
std::set<std::string> customKeys;
for (unsigned int i = 0; i < container->GetTimeSteps(); i++)
{
auto statisticKeys = container->GetStatisticsForTimeStep(i).GetCustomStatisticNames();
customKeys.insert(statisticKeys.cbegin(), statisticKeys.cend());
}
names.insert(names.cend(), customKeys.cbegin(), customKeys.cend());
}
return names;
}
ImageStatisticsContainer::ImageStatisticsObject::StatisticNameVector GetAllStatisticNames(
std::vector<ImageStatisticsContainer::ConstPointer> containers)
{
ImageStatisticsContainer::ImageStatisticsObject::StatisticNameVector names =
ImageStatisticsContainer::ImageStatisticsObject::GetDefaultStatisticNames();
std::set<std::string> customKeys;
- for (auto container : containers)
+ for (const auto &container : containers)
{
for (unsigned int i = 0; i < container->GetTimeSteps(); i++)
{
if(container->TimeStepExists(i))
{
auto statisticKeys = container->GetStatisticsForTimeStep(i).GetCustomStatisticNames();
customKeys.insert(statisticKeys.cbegin(), statisticKeys.cend());
}
}
}
names.insert(names.end(), customKeys.begin(), customKeys.end());
return names;
};
} // namespace mitk
diff --git a/Modules/ImageStatisticsUI/Qmitk/QmitkDataGeneratorBase.cpp b/Modules/ImageStatisticsUI/Qmitk/QmitkDataGeneratorBase.cpp
index f32be6e324..5b8d159cba 100644
--- a/Modules/ImageStatisticsUI/Qmitk/QmitkDataGeneratorBase.cpp
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkDataGeneratorBase.cpp
@@ -1,275 +1,275 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkDataGeneratorBase.h"
#include "QmitkDataGenerationJobBase.h"
#include "mitkDataNode.h"
#include "mitkProperties.h"
#include "mitkImageStatisticsContainerManager.h"
#include <QThreadPool>
QmitkDataGeneratorBase::QmitkDataGeneratorBase(mitk::DataStorage::Pointer storage, QObject* parent) : QObject(parent)
{
this->SetDataStorage(storage);
}
QmitkDataGeneratorBase::QmitkDataGeneratorBase(QObject* parent): QObject(parent)
{}
QmitkDataGeneratorBase::~QmitkDataGeneratorBase()
{
auto dataStorage = m_Storage.Lock();
if (dataStorage.IsNotNull())
{
// remove "change node listener" from data storage
dataStorage->ChangedNodeEvent.RemoveListener(
mitk::MessageDelegate1<QmitkDataGeneratorBase, const mitk::DataNode*>(this, &QmitkDataGeneratorBase::NodeAddedOrModified));
}
}
mitk::DataStorage::Pointer QmitkDataGeneratorBase::GetDataStorage() const
{
return m_Storage.Lock();
}
bool QmitkDataGeneratorBase::GetAutoUpdate() const
{
return m_AutoUpdate;
}
bool QmitkDataGeneratorBase::IsGenerating() const
{
return m_WIP;
}
void QmitkDataGeneratorBase::SetDataStorage(mitk::DataStorage* storage)
{
if (storage == m_Storage) return;
std::lock_guard<std::mutex> mutexguard(m_DataMutex);
auto oldStorage = m_Storage.Lock();
if (oldStorage.IsNotNull())
{
// remove "change node listener" from old data storage
oldStorage->ChangedNodeEvent.RemoveListener(
mitk::MessageDelegate1<QmitkDataGeneratorBase, const mitk::DataNode*>(this, &QmitkDataGeneratorBase::NodeAddedOrModified));
}
m_Storage = storage;
auto newStorage = m_Storage.Lock();
if (newStorage.IsNotNull())
{
// add change node listener for new data storage
newStorage->ChangedNodeEvent.AddListener(
mitk::MessageDelegate1<QmitkDataGeneratorBase, const mitk::DataNode*>(this, &QmitkDataGeneratorBase::NodeAddedOrModified));
}
}
void QmitkDataGeneratorBase::SetAutoUpdate(bool autoUpdate)
{
m_AutoUpdate = autoUpdate;
}
void QmitkDataGeneratorBase::OnJobError(QString error, const QmitkDataGenerationJobBase* failedJob) const
{
emit JobError(error, failedJob);
}
void QmitkDataGeneratorBase::OnFinalResultsAvailable(JobResultMapType results, const QmitkDataGenerationJobBase *job) const
{
auto resultnodes = mitk::DataStorage::SetOfObjects::New();
- for (auto pos : results)
+ for (const auto &pos : results)
{
resultnodes->push_back(this->PrepareResultForStorage(pos.first, pos.second, job));
}
{
std::lock_guard<std::mutex> mutexguard(m_DataMutex);
auto storage = m_Storage.Lock();
if (storage.IsNotNull())
{
m_AddingToStorage = true;
for (auto pos = resultnodes->Begin(); pos != resultnodes->End(); ++pos)
{
storage->Add(pos->Value());
}
m_AddingToStorage = false;
}
}
emit NewDataAvailable(resultnodes.GetPointer());
if (!resultnodes->empty())
{
this->EnsureRecheckingAndGeneration();
}
}
void QmitkDataGeneratorBase::NodeAddedOrModified(const mitk::DataNode* node)
{
if (!m_AddingToStorage)
{
if (this->ChangedNodeIsRelevant(node))
{
this->EnsureRecheckingAndGeneration();
}
}
}
void QmitkDataGeneratorBase::EnsureRecheckingAndGeneration() const
{
m_RestartGeneration = true;
if (!m_InGenerate)
{
this->Generate();
}
}
bool QmitkDataGeneratorBase::Generate() const
{
bool everythingValid = false;
if (m_InGenerate)
{
m_RestartGeneration = true;
}
else
{
m_InGenerate = true;
m_RestartGeneration = true;
while (m_RestartGeneration)
{
m_RestartGeneration = false;
everythingValid = DoGenerate();
}
m_InGenerate = false;
}
return everythingValid;
}
mitk::DataNode::Pointer QmitkDataGeneratorBase::CreateWIPDataNode(mitk::BaseData* dataDummy, const std::string& nodeName)
{
if (!dataDummy) {
mitkThrow() << "data is nullptr";
}
auto interimResultNode = mitk::DataNode::New();
interimResultNode->SetProperty("helper object", mitk::BoolProperty::New(true));
dataDummy->SetProperty(mitk::STATS_GENERATION_STATUS_PROPERTY_NAME.c_str(), mitk::StringProperty::New(mitk::STATS_GENERATION_STATUS_VALUE_PENDING));
interimResultNode->SetVisibility(false);
interimResultNode->SetData(dataDummy);
if (!nodeName.empty())
{
interimResultNode->SetName(nodeName);
}
return interimResultNode;
}
QmitkDataGeneratorBase::InputPairVectorType QmitkDataGeneratorBase::FilterImageROICombinations(InputPairVectorType&& imageROICombinations) const
{
std::lock_guard<std::mutex> mutexguard(m_DataMutex);
InputPairVectorType filteredImageROICombinations;
auto storage = m_Storage.Lock();
if (storage.IsNotNull())
{
for (auto inputPair : imageROICombinations)
{
if (storage->Exists(inputPair.first) && (inputPair.second.IsNull() || storage->Exists(inputPair.second)))
{
filteredImageROICombinations.emplace_back(inputPair);
}
else
{
MITK_DEBUG << "Ignore pair because at least one of the nodes is not in storage. Pair: " << GetPairDescription(inputPair);
}
}
}
return filteredImageROICombinations;
}
std::string QmitkDataGeneratorBase::GetPairDescription(const InputPairVectorType::value_type& imageAndSeg) const
{
if (imageAndSeg.second.IsNotNull())
{
return imageAndSeg.first->GetName() + " and ROI " + imageAndSeg.second->GetName();
}
else
{
return imageAndSeg.first->GetName();
}
}
bool QmitkDataGeneratorBase::DoGenerate() const
{
auto filteredImageROICombinations = FilterImageROICombinations(this->GetAllImageROICombinations());
QThreadPool* threadPool = QThreadPool::globalInstance();
bool everythingValid = true;
for (const auto& imageAndSeg : filteredImageROICombinations)
{
MITK_DEBUG << "checking node " << GetPairDescription(imageAndSeg);
if (!this->IsValidResultAvailable(imageAndSeg.first.GetPointer(), imageAndSeg.second.GetPointer()))
{
this->IndicateFutureResults(imageAndSeg.first.GetPointer(), imageAndSeg.second.GetPointer());
if (everythingValid)
{
m_WIP = true;
everythingValid = false;
}
MITK_DEBUG << "No valid result available. Requesting next necessary job." << imageAndSeg.first->GetName();
auto nextJob = this->GetNextMissingGenerationJob(imageAndSeg.first.GetPointer(), imageAndSeg.second.GetPointer());
//other jobs are pending, nothing has to be done
if (nextJob.first==nullptr && nextJob.second.IsNotNull())
{
MITK_DEBUG << "Last generation job still running, pass on till job is finished...";
}
else if(nextJob.first != nullptr && nextJob.second.IsNotNull())
{
MITK_DEBUG << "Next generation job started...";
nextJob.first->setAutoDelete(true);
nextJob.second->GetData()->SetProperty(mitk::STATS_GENERATION_STATUS_PROPERTY_NAME.c_str(), mitk::StringProperty::New(mitk::STATS_GENERATION_STATUS_VALUE_WORK_IN_PROGRESS));
connect(nextJob.first, &QmitkDataGenerationJobBase::Error, this, &QmitkDataGeneratorBase::OnJobError, Qt::BlockingQueuedConnection);
connect(nextJob.first, &QmitkDataGenerationJobBase::ResultsAvailable, this, &QmitkDataGeneratorBase::OnFinalResultsAvailable, Qt::BlockingQueuedConnection);
emit DataGenerationStarted(imageAndSeg.first.GetPointer(), imageAndSeg.second.GetPointer(), nextJob.first);
threadPool->start(nextJob.first);
}
}
else
{
this->RemoveObsoleteDataNodes(imageAndSeg.first.GetPointer(), imageAndSeg.second.GetPointer());
}
}
if (everythingValid && m_WIP)
{
m_WIP = false;
emit GenerationFinished();
}
return everythingValid;
}
diff --git a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeModel.cpp b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeModel.cpp
index f0b184289b..56bb7ac961 100644
--- a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeModel.cpp
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeModel.cpp
@@ -1,425 +1,425 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkImageStatisticsTreeModel.h"
#include "QmitkImageStatisticsTreeItem.h"
#include "itkMutexLockHolder.h"
#include "mitkImageStatisticsContainerManager.h"
#include "mitkProportionalTimeGeometry.h"
#include "mitkStatisticsToImageRelationRule.h"
#include "mitkStatisticsToMaskRelationRule.h"
#include "QmitkStyleManager.h"
QmitkImageStatisticsTreeModel::QmitkImageStatisticsTreeModel(QObject *parent) : QmitkAbstractDataStorageModel(parent)
{
m_RootItem = new QmitkImageStatisticsTreeItem();
}
QmitkImageStatisticsTreeModel ::~QmitkImageStatisticsTreeModel()
{
// set data storage to nullptr so that the event listener gets removed
this->SetDataStorage(nullptr);
delete m_RootItem;
};
void QmitkImageStatisticsTreeModel::DataStorageChanged()
{
emit beginResetModel();
UpdateByDataStorage();
emit endResetModel();
emit modelChanged();
}
void QmitkImageStatisticsTreeModel::NodePredicateChanged()
{
emit beginResetModel();
UpdateByDataStorage();
emit endResetModel();
emit modelChanged();
}
int QmitkImageStatisticsTreeModel::columnCount(const QModelIndex& /*parent*/) const
{
int columns = m_StatisticNames.size() + 1;
return columns;
}
int QmitkImageStatisticsTreeModel::rowCount(const QModelIndex &parent) const
{
QmitkImageStatisticsTreeItem *parentItem;
if (parent.column() > 0)
return 0;
if (!parent.isValid())
parentItem = m_RootItem;
else
parentItem = static_cast<QmitkImageStatisticsTreeItem *>(parent.internalPointer());
return parentItem->childCount();
}
QVariant QmitkImageStatisticsTreeModel::data(const QModelIndex &index, int role) const
{
if (!index.isValid())
return QVariant();
QmitkImageStatisticsTreeItem* item = static_cast<QmitkImageStatisticsTreeItem*>(index.internalPointer());
if (role == Qt::DisplayRole)
{
return item->data(index.column());
}
else if (role == Qt::DecorationRole && index.column() == 0 && item->isWIP() && item->childCount()==0)
{
return QVariant(QmitkStyleManager::ThemeIcon(QStringLiteral(":/Qmitk/hourglass-half-solid.svg")));
}
return QVariant();
}
QModelIndex QmitkImageStatisticsTreeModel::index(int row, int column, const QModelIndex &parent) const
{
if (!hasIndex(row, column, parent))
return QModelIndex();
QmitkImageStatisticsTreeItem *parentItem;
if (!parent.isValid())
parentItem = m_RootItem;
else
parentItem = static_cast<QmitkImageStatisticsTreeItem *>(parent.internalPointer());
QmitkImageStatisticsTreeItem *childItem = parentItem->child(row);
if (childItem)
return createIndex(row, column, childItem);
else
return QModelIndex();
}
QModelIndex QmitkImageStatisticsTreeModel::parent(const QModelIndex &child) const
{
if (!child.isValid())
return QModelIndex();
QmitkImageStatisticsTreeItem *childItem = static_cast<QmitkImageStatisticsTreeItem *>(child.internalPointer());
QmitkImageStatisticsTreeItem *parentItem = childItem->parentItem();
if (parentItem == m_RootItem)
return QModelIndex();
return createIndex(parentItem->row(), 0, parentItem);
}
Qt::ItemFlags QmitkImageStatisticsTreeModel::flags(const QModelIndex &index) const
{
if (!index.isValid())
return nullptr;
return QAbstractItemModel::flags(index);
}
QVariant QmitkImageStatisticsTreeModel::headerData(int section, Qt::Orientation orientation, int role) const
{
if ((Qt::DisplayRole == role) && (Qt::Horizontal == orientation))
{
if (section == 0)
{
return m_HeaderFirstColumn;
}
else
{
return QVariant(m_StatisticNames.at(section - 1).c_str());
}
}
return QVariant();
}
void QmitkImageStatisticsTreeModel::SetImageNodes(const std::vector<mitk::DataNode::ConstPointer> &nodes)
{
std::vector<std::pair<mitk::DataNode::ConstPointer, unsigned int>> tempNodes;
for (const auto &node : nodes)
{
auto data = node->GetData();
if (data)
{
auto timeSteps = data->GetTimeSteps();
for (unsigned int i = 0; i < timeSteps; i++)
{
tempNodes.push_back(std::make_pair(node, i));
}
}
}
emit beginResetModel();
m_TimeStepResolvedImageNodes = std::move(tempNodes);
m_ImageNodes = nodes;
UpdateByDataStorage();
emit endResetModel();
emit modelChanged();
}
void QmitkImageStatisticsTreeModel::SetMaskNodes(const std::vector<mitk::DataNode::ConstPointer> &nodes)
{
std::vector<std::pair<mitk::DataNode::ConstPointer, unsigned int>> tempNodes;
for (const auto &node : nodes)
{
auto data = node->GetData();
if (data)
{
auto timeSteps = data->GetTimeSteps();
// special case: apply one mask to each timestep of an 4D image
if (timeSteps == 1 && m_TimeStepResolvedImageNodes.size() > 1)
{
timeSteps = m_TimeStepResolvedImageNodes.size();
}
for (unsigned int i = 0; i < timeSteps; i++)
{
tempNodes.push_back(std::make_pair(node, i));
}
}
}
emit beginResetModel();
m_TimeStepResolvedMaskNodes = std::move(tempNodes);
m_MaskNodes = nodes;
UpdateByDataStorage();
emit endResetModel();
emit modelChanged();
}
void QmitkImageStatisticsTreeModel::Clear()
{
emit beginResetModel();
m_Statistics.clear();
m_ImageNodes.clear();
m_TimeStepResolvedImageNodes.clear();
m_MaskNodes.clear();
m_StatisticNames.clear();
emit endResetModel();
emit modelChanged();
}
void QmitkImageStatisticsTreeModel::SetIgnoreZeroValueVoxel(bool _arg)
{
if (m_IgnoreZeroValueVoxel != _arg)
{
emit beginResetModel();
m_IgnoreZeroValueVoxel = _arg;
UpdateByDataStorage();
emit endResetModel();
emit modelChanged();
}
}
bool QmitkImageStatisticsTreeModel::GetIgnoreZeroValueVoxel() const
{
return this->m_IgnoreZeroValueVoxel;
}
void QmitkImageStatisticsTreeModel::SetHistogramNBins(unsigned int nbins)
{
if (m_HistogramNBins != nbins)
{
emit beginResetModel();
m_HistogramNBins = nbins;
UpdateByDataStorage();
emit endResetModel();
emit modelChanged();
}
}
unsigned int QmitkImageStatisticsTreeModel::GetHistogramNBins() const
{
return this->m_HistogramNBins;
}
void QmitkImageStatisticsTreeModel::UpdateByDataStorage()
{
StatisticsContainerVector newStatistics;
auto datamanager = m_DataStorage.Lock();
if (datamanager.IsNotNull())
{
for (const auto &image : m_ImageNodes)
{
if (m_MaskNodes.empty())
{
auto stats = mitk::ImageStatisticsContainerManager::GetImageStatistics(datamanager, image->GetData(), nullptr, m_IgnoreZeroValueVoxel, m_HistogramNBins, true, false);
if (stats.IsNotNull())
{
newStatistics.emplace_back(stats);
}
}
else
{
for (const auto &mask : m_MaskNodes)
{
auto stats =
mitk::ImageStatisticsContainerManager::GetImageStatistics(datamanager, image->GetData(), mask->GetData(), m_IgnoreZeroValueVoxel, m_HistogramNBins, true, false);
if (stats.IsNotNull())
{
newStatistics.emplace_back(stats);
}
}
}
}
if (!newStatistics.empty())
{
emit dataAvailable();
}
}
{
itk::MutexLockHolder<itk::SimpleFastMutexLock> locked(m_Mutex);
m_Statistics = newStatistics;
}
m_StatisticNames = mitk::GetAllStatisticNames(m_Statistics);
BuildHierarchicalModel();
}
void QmitkImageStatisticsTreeModel::BuildHierarchicalModel()
{
// reset old model
delete m_RootItem;
m_RootItem = new QmitkImageStatisticsTreeItem();
bool hasMask = false;
bool hasMultipleTimesteps = false;
std::map<mitk::DataNode::ConstPointer, QmitkImageStatisticsTreeItem *> dataNodeToTreeItem;
- for (auto statistic : m_Statistics)
+ for (const auto &statistic : m_Statistics)
{
bool isWIP = statistic->GetProperty(mitk::STATS_GENERATION_STATUS_PROPERTY_NAME.c_str()).IsNotNull();
// get the connected image data node/mask data node
auto imageRule = mitk::StatisticsToImageRelationRule::New();
auto imageOfStatisticsPredicate = imageRule->GetDestinationsDetector(statistic);
auto imageFinding = std::find_if(m_ImageNodes.begin(), m_ImageNodes.end(), [&imageOfStatisticsPredicate](const mitk::DataNode::ConstPointer& testNode) { return imageOfStatisticsPredicate->CheckNode(testNode); });
auto maskRule = mitk::StatisticsToMaskRelationRule::New();
auto maskOfStatisticsPredicate = maskRule->GetDestinationsDetector(statistic);
auto maskFinding = std::find_if(m_MaskNodes.begin(), m_MaskNodes.end(), [&maskOfStatisticsPredicate](const mitk::DataNode::ConstPointer& testNode) { return maskOfStatisticsPredicate->CheckNode(testNode); });
if (imageFinding == m_ImageNodes.end())
{
mitkThrow() << "no image found connected to statistic" << statistic << " Aborting.";
}
auto& image = *imageFinding;
// image: 1. hierarchy level
QmitkImageStatisticsTreeItem *imageItem = nullptr;
auto search = dataNodeToTreeItem.find(image);
// the tree item was created previously
if (search != dataNodeToTreeItem.end())
{
imageItem = search->second;
}
// create the tree item
else
{
QString imageLabel = QString::fromStdString(image->GetName());
if (statistic->GetTimeSteps() == 1 && maskFinding == m_MaskNodes.end())
{
auto statisticsObject = statistic->GetStatisticsForTimeStep(0);
imageItem = new QmitkImageStatisticsTreeItem(statisticsObject, m_StatisticNames, imageLabel, isWIP, m_RootItem);
}
else
{
imageItem = new QmitkImageStatisticsTreeItem(m_StatisticNames, imageLabel, isWIP, m_RootItem);
}
m_RootItem->appendChild(imageItem);
dataNodeToTreeItem.emplace(image, imageItem);
}
// mask: 2. hierarchy level (optional, only if mask exists)
QmitkImageStatisticsTreeItem *lastParent = nullptr;
if (maskFinding != m_MaskNodes.end())
{
auto& mask = *maskFinding;
QString maskLabel = QString::fromStdString(mask->GetName());
QmitkImageStatisticsTreeItem *maskItem;
// add statistical values directly in this hierarchy level
if (statistic->GetTimeSteps() == 1)
{
auto statisticsObject = statistic->GetStatisticsForTimeStep(0);
maskItem = new QmitkImageStatisticsTreeItem(statisticsObject, m_StatisticNames, maskLabel, isWIP, imageItem);
}
else
{
maskItem = new QmitkImageStatisticsTreeItem(m_StatisticNames, maskLabel, isWIP, imageItem);
}
imageItem->appendChild(maskItem);
lastParent = maskItem;
hasMask = true;
}
else
{
lastParent = imageItem;
}
// 3. hierarchy level (optional, only if >1 timestep)
if (statistic->GetTimeSteps() > 1)
{
for (unsigned int i = 0; i < statistic->GetTimeSteps(); i++)
{
QString timeStepLabel = "[" + QString::number(i) + "] " +
QString::number(statistic->GetTimeGeometry()->TimeStepToTimePoint(i)) + " ms";
if (statistic->TimeStepExists(i))
{
auto statisticsItem = new QmitkImageStatisticsTreeItem(
statistic->GetStatisticsForTimeStep(i), m_StatisticNames, timeStepLabel, isWIP, lastParent);
lastParent->appendChild(statisticsItem);
}
}
hasMultipleTimesteps = true;
}
}
QString headerString = "Images";
if (hasMask)
{
headerString += "/Masks";
}
if (hasMultipleTimesteps)
{
headerString += "/Timesteps";
}
m_HeaderFirstColumn = headerString;
}
void QmitkImageStatisticsTreeModel::NodeRemoved(const mitk::DataNode *)
{
emit beginResetModel();
UpdateByDataStorage();
emit endResetModel();
emit modelChanged();
}
void QmitkImageStatisticsTreeModel::NodeAdded(const mitk::DataNode *)
{
emit beginResetModel();
UpdateByDataStorage();
emit endResetModel();
emit modelChanged();
}
void QmitkImageStatisticsTreeModel::NodeChanged(const mitk::DataNode *)
{
emit beginResetModel();
UpdateByDataStorage();
emit endResetModel();
emit modelChanged();
}
diff --git a/Modules/MatchPointRegistration/CMakeLists.txt b/Modules/MatchPointRegistration/CMakeLists.txt
index 71204d9f1a..577f222225 100644
--- a/Modules/MatchPointRegistration/CMakeLists.txt
+++ b/Modules/MatchPointRegistration/CMakeLists.txt
@@ -1,29 +1,29 @@
-MITK_CREATE_MODULE(
+mitk_create_module(
INCLUDE_DIRS
PUBLIC algorithms
PRIVATE src/Helper src/Rendering
DEPENDS MitkCore MitkSceneSerializationBase
PACKAGE_DEPENDS
PUBLIC MatchPoint
PRIVATE VTK|ImagingGeneral+ImagingHybrid
)
if(TARGET ${MODULE_TARGET})
set(ALG_PROFILE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/algorithms)
include(${MatchPoint_SOURCE_DIR}/CMake/mapFunctionCreateAlgorithmProfile.cmake)
file(GLOB ALG_PROFILE_FILES LIST_DIRECTORIES false RELATIVE ${ALG_PROFILE_DIR} "${ALG_PROFILE_DIR}/*.profile")
foreach(profile_file ${ALG_PROFILE_FILES})
get_filename_component(profile_name ${profile_file} NAME_WE)
- MESSAGE(STATUS "... generate MDRA profile ${profile_name} (from ${profile_file})...")
+ message(STATUS "Generate MDRA profile ${profile_name} (from ${profile_file})")
CREATE_ALGORITHM_PROFILE(${profile_name} ${ALG_PROFILE_DIR}/${profile_file})
- endforeach(profile_file)
+ endforeach()
- ADD_SUBDIRECTORY(autoload/IO)
- ADD_SUBDIRECTORY(deployment)
+ add_subdirectory(autoload/IO)
+ add_subdirectory(deployment)
if(BUILD_TESTING)
- ADD_SUBDIRECTORY(Testing)
- endif(BUILD_TESTING)
- ADD_SUBDIRECTORY(cmdapps)
+ add_subdirectory(Testing)
+ endif()
+ add_subdirectory(cmdapps)
endif()
diff --git a/Modules/MatchPointRegistration/src/Rendering/mitkRegEvaluationMapper2D.cpp b/Modules/MatchPointRegistration/src/Rendering/mitkRegEvaluationMapper2D.cpp
index 32ff499f6b..a2938eb0c8 100644
--- a/Modules/MatchPointRegistration/src/Rendering/mitkRegEvaluationMapper2D.cpp
+++ b/Modules/MatchPointRegistration/src/Rendering/mitkRegEvaluationMapper2D.cpp
@@ -1,836 +1,836 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
//MITK
#include <mitkAbstractTransformGeometry.h>
#include <mitkDataNode.h>
#include <mitkImageSliceSelector.h>
#include <mitkLevelWindowProperty.h>
#include <mitkLookupTableProperty.h>
#include <mitkPlaneGeometry.h>
#include <mitkProperties.h>
#include <mitkResliceMethodProperty.h>
#include <mitkVtkResliceInterpolationProperty.h>
#include <mitkPixelType.h>
#include <mitkTransferFunctionProperty.h>
#include "mitkImageStatisticsHolder.h"
#include "mitkPlaneClipping.h"
#include "mitkRegVisPropertyTags.h"
#include "mitkRegVisHelper.h"
#include "mitkRegEvalStyleProperty.h"
#include "mitkRegEvalWipeStyleProperty.h"
//MITK Rendering
#include "mitkRegEvaluationMapper2D.h"
#include "vtkMitkThickSlicesFilter.h"
#include "vtkMitkLevelWindowFilter.h"
#include "vtkNeverTranslucentTexture.h"
//VTK
#include <vtkProperty.h>
#include <vtkTransform.h>
#include <vtkMatrix4x4.h>
#include <vtkLookupTable.h>
#include <vtkImageData.h>
#include <vtkPoints.h>
#include <vtkGeneralTransform.h>
#include <vtkImageExtractComponents.h>
#include <vtkImageReslice.h>
#include <vtkImageChangeInformation.h>
#include <vtkPlaneSource.h>
#include <vtkPolyDataMapper.h>
#include <vtkCellArray.h>
#include <vtkCamera.h>
#include <vtkColorTransferFunction.h>
#include <vtkImageCheckerboard.h>
#include <vtkImageWeightedSum.h>
#include <vtkImageMathematics.h>
#include <vtkImageRectilinearWipe.h>
#include <vtkImageGradientMagnitude.h>
#include <vtkImageAppendComponents.h>
#include <vtkImageExtractComponents.h>
//ITK
#include <itkRGBAPixel.h>
#include <mitkRenderingModeProperty.h>
//MatchPoint
#include <mitkRegEvaluationObject.h>
#include <mitkImageMappingHelper.h>
mitk::RegEvaluationMapper2D::RegEvaluationMapper2D()
{
}
mitk::RegEvaluationMapper2D::~RegEvaluationMapper2D()
{
}
//set the two points defining the textured plane according to the dimension and spacing
void mitk::RegEvaluationMapper2D::GeneratePlane(mitk::BaseRenderer* renderer, double planeBounds[6])
{
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
float depth = this->CalculateLayerDepth(renderer);
//Set the origin to (xMin; yMin; depth) of the plane. This is necessary for obtaining the correct
//plane size in crosshair rotation and swivel mode.
localStorage->m_Plane->SetOrigin(planeBounds[0], planeBounds[2], depth);
//These two points define the axes of the plane in combination with the origin.
//Point 1 is the x-axis and point 2 the y-axis.
//Each plane is transformed according to the view (axial, coronal and saggital) afterwards.
localStorage->m_Plane->SetPoint1(planeBounds[1] , planeBounds[2], depth); //P1: (xMax, yMin, depth)
localStorage->m_Plane->SetPoint2(planeBounds[0], planeBounds[3], depth); //P2: (xMin, yMax, depth)
}
float mitk::RegEvaluationMapper2D::CalculateLayerDepth(mitk::BaseRenderer* renderer)
{
//get the clipping range to check how deep into z direction we can render images
double maxRange = renderer->GetVtkRenderer()->GetActiveCamera()->GetClippingRange()[1];
//Due to a VTK bug, we cannot use the whole clipping range. /100 is empirically determined
float depth = -maxRange*0.01; // divide by 100
int layer = 0;
GetDataNode()->GetIntProperty( "layer", layer, renderer);
//add the layer property for each image to render images with a higher layer on top of the others
depth += layer*10; //*10: keep some room for each image (e.g. for ODFs in between)
if(depth > 0.0f) {
depth = 0.0f;
MITK_WARN << "Layer value exceeds clipping range. Set to minimum instead.";
}
return depth;
}
const mitk::Image* mitk::RegEvaluationMapper2D::GetTargetImage( void )
{
const mitk::RegEvaluationObject* evalObj = dynamic_cast< const mitk::RegEvaluationObject* >( GetDataNode()->GetData() );
if (evalObj)
{
return evalObj->GetTargetImage();
}
return nullptr;
}
const mitk::Image* mitk::RegEvaluationMapper2D::GetMovingImage( void )
{
const mitk::RegEvaluationObject* evalObj = dynamic_cast< const mitk::RegEvaluationObject* >( GetDataNode()->GetData() );
if (evalObj)
{
return evalObj->GetMovingImage();
}
return nullptr;
}
const mitk::DataNode* mitk::RegEvaluationMapper2D::GetTargetNode(void)
{
const mitk::RegEvaluationObject* evalObj = dynamic_cast< const mitk::RegEvaluationObject* >(GetDataNode()->GetData());
if (evalObj)
{
return evalObj->GetTargetNode();
}
return nullptr;
}
const mitk::DataNode* mitk::RegEvaluationMapper2D::GetMovingNode(void)
{
const mitk::RegEvaluationObject* evalObj = dynamic_cast< const mitk::RegEvaluationObject* >(GetDataNode()->GetData());
if (evalObj)
{
return evalObj->GetMovingNode();
}
return nullptr;
}
const mitk::MAPRegistrationWrapper* mitk::RegEvaluationMapper2D::GetRegistration( void )
{
const mitk::RegEvaluationObject* evalObj = dynamic_cast< const mitk::RegEvaluationObject* >( GetDataNode()->GetData() );
if (evalObj)
{
return evalObj->GetRegistration();
}
return nullptr;
}
vtkProp* mitk::RegEvaluationMapper2D::GetVtkProp(mitk::BaseRenderer* renderer)
{
//return the actor corresponding to the renderer
return m_LSH.GetLocalStorage(renderer)->m_Actors;
}
void mitk::RegEvaluationMapper2D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
{
bool updated = false;
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
mitk::Image::Pointer targetInput = const_cast< mitk::Image * >( this->GetTargetImage() );
mitk::DataNode* datanode = this->GetDataNode();
if ( targetInput.IsNull() || targetInput->IsInitialized() == false )
{
return;
}
mitk::Image::ConstPointer movingInput = this->GetMovingImage();
if ( movingInput.IsNull() || movingInput->IsInitialized() == false )
{
return;
}
mitk::MAPRegistrationWrapper::ConstPointer reg = this->GetRegistration();
//check if there is a valid worldGeometry
const PlaneGeometry *worldGeometry = renderer->GetCurrentWorldPlaneGeometry();
if( ( worldGeometry == nullptr ) || ( !worldGeometry->IsValid() ) || ( !worldGeometry->HasReferenceGeometry() ))
{
return;
}
if(targetInput->GetMTime()>localStorage->m_LastUpdateTime
|| (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldPlaneGeometryUpdateTime()) //was the geometry modified?
|| (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldPlaneGeometry()->GetMTime()))
{ //target input has been modified -> reslice target input
targetInput->Update();
// early out if there is no intersection of the current rendering geometry
// and the geometry of the image that is to be rendered.
if ( !RenderingGeometryIntersectsImage( worldGeometry, targetInput->GetSlicedGeometry() ) )
{
// set image to nullptr, to clear the texture in 3D, because
// the latest image is used there if the plane is out of the geometry
// see bug-13275
localStorage->m_EvaluationImage = nullptr;
localStorage->m_Mapper->SetInputData( localStorage->m_EmptyPolyData );
return;
}
//set main input for ExtractSliceFilter
localStorage->m_Reslicer->SetInput(targetInput);
localStorage->m_Reslicer->SetWorldGeometry(worldGeometry);
localStorage->m_Reslicer->SetTimeStep( this->GetTimestep() );
//set the transformation of the image to adapt reslice axis
localStorage->m_Reslicer->SetResliceTransformByGeometry( targetInput->GetTimeGeometry()->GetGeometryForTimeStep( this->GetTimestep() ) );
//is the geometry of the slice based on the input image or the worldgeometry?
bool inPlaneResampleExtentByGeometry = false;
datanode->GetBoolProperty("in plane resample extent by geometry", inPlaneResampleExtentByGeometry, renderer);
localStorage->m_Reslicer->SetInPlaneResampleExtentByGeometry(inPlaneResampleExtentByGeometry);
// Initialize the interpolation mode for resampling; switch to nearest
// neighbor if the input image is too small.
if ( (targetInput->GetDimension() >= 3) && (targetInput->GetDimension(2) > 1) )
{
VtkResliceInterpolationProperty *resliceInterpolationProperty;
datanode->GetProperty(
resliceInterpolationProperty, "reslice interpolation" );
int interpolationMode = VTK_RESLICE_NEAREST;
if ( resliceInterpolationProperty != nullptr )
{
interpolationMode = resliceInterpolationProperty->GetInterpolation();
}
switch ( interpolationMode )
{
case VTK_RESLICE_NEAREST:
localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_NEAREST);
break;
case VTK_RESLICE_LINEAR:
localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_LINEAR);
break;
case VTK_RESLICE_CUBIC:
localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_CUBIC);
break;
}
}
else
{
localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_NEAREST);
}
//this is needed when thick mode was enable bevore. These variable have to be reset to default values
localStorage->m_Reslicer->SetOutputDimensionality( 2 );
localStorage->m_Reslicer->SetOutputSpacingZDirection(1.0);
localStorage->m_Reslicer->SetOutputExtentZDirection( 0, 0 );
localStorage->m_Reslicer->Modified();
//start the pipeline with updating the largest possible, needed if the geometry of the input has changed
localStorage->m_Reslicer->UpdateLargestPossibleRegion();
localStorage->m_slicedTargetImage = localStorage->m_Reslicer->GetOutput();
updated = true;
}
if(updated ||
movingInput->GetMTime() > localStorage->m_LastUpdateTime ||
reg->GetMTime() > localStorage->m_LastUpdateTime)
{
//Map moving image
localStorage->m_slicedMappedImage = mitk::ImageMappingHelper::map(movingInput,reg,false,0,localStorage->m_slicedTargetImage->GetGeometry(),false,0);
updated = true;
}
// Bounds information for reslicing (only required if reference geometry
// is present)
//this used for generating a vtkPLaneSource with the right size
double sliceBounds[6] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
if (updated
|| (localStorage->m_LastUpdateTime < datanode->GetPropertyList()->GetMTime()) //was a property modified?
|| (localStorage->m_LastUpdateTime < datanode->GetPropertyList(renderer)->GetMTime())
|| (localStorage->m_LastUpdateTime < this->GetTargetNode()->GetMTime())
|| (localStorage->m_LastUpdateTime < this->GetMovingNode()->GetMTime()))
{
localStorage->m_Reslicer->GetClippedPlaneBounds(sliceBounds);
//get the spacing of the slice
localStorage->m_mmPerPixel = localStorage->m_Reslicer->GetOutputSpacing();
// calculate minimum bounding rect of IMAGE in texture
{
double textureClippingBounds[6] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
// Calculate the actual bounds of the transformed plane clipped by the
// dataset bounding box; this is required for drawing the texture at the
// correct position during 3D mapping.
const PlaneGeometry *planeGeometry = dynamic_cast<const PlaneGeometry *>(worldGeometry);
mitk::PlaneClipping::CalculateClippedPlaneBounds(targetInput->GetGeometry(), planeGeometry, textureClippingBounds);
textureClippingBounds[0] = static_cast<int>(textureClippingBounds[0] / localStorage->m_mmPerPixel[0] + 0.5);
textureClippingBounds[1] = static_cast<int>(textureClippingBounds[1] / localStorage->m_mmPerPixel[0] + 0.5);
textureClippingBounds[2] = static_cast<int>(textureClippingBounds[2] / localStorage->m_mmPerPixel[1] + 0.5);
textureClippingBounds[3] = static_cast<int>(textureClippingBounds[3] / localStorage->m_mmPerPixel[1] + 0.5);
//clipping bounds for cutting the image
localStorage->m_TargetLevelWindowFilter->SetClippingBounds(textureClippingBounds);
localStorage->m_MappedLevelWindowFilter->SetClippingBounds(textureClippingBounds);
}
this->ApplyLookuptable(renderer, this->GetTargetNode(), localStorage->m_TargetLevelWindowFilter);
this->ApplyLookuptable(renderer, this->GetMovingNode(), localStorage->m_MappedLevelWindowFilter);
this->ApplyLevelWindow(renderer, this->GetTargetNode(), localStorage->m_TargetLevelWindowFilter);
this->ApplyLevelWindow(renderer, this->GetMovingNode(), localStorage->m_MappedLevelWindowFilter);
//connect the input with the levelwindow filter
localStorage->m_TargetLevelWindowFilter->SetInputData(localStorage->m_slicedTargetImage->GetVtkImageData());
localStorage->m_MappedLevelWindowFilter->SetInputData(localStorage->m_slicedMappedImage->GetVtkImageData());
localStorage->m_TargetExtractFilter->SetInputConnection(localStorage->m_TargetLevelWindowFilter->GetOutputPort());
localStorage->m_MappedExtractFilter->SetInputConnection(localStorage->m_MappedLevelWindowFilter->GetOutputPort());
localStorage->m_TargetExtractFilter->SetComponents(0);
localStorage->m_MappedExtractFilter->SetComponents(0);
updated = true;
}
//Generate evaluation image
bool isStyleOutdated = mitk::PropertyIsOutdated(datanode,mitk::nodeProp_RegEvalStyle,localStorage->m_LastUpdateTime);
bool isBlendOutdated = mitk::PropertyIsOutdated(datanode,mitk::nodeProp_RegEvalBlendFactor,localStorage->m_LastUpdateTime);
bool isCheckerOutdated = mitk::PropertyIsOutdated(datanode,mitk::nodeProp_RegEvalCheckerCount,localStorage->m_LastUpdateTime);
bool isWipeStyleOutdated = mitk::PropertyIsOutdated(datanode,mitk::nodeProp_RegEvalWipeStyle,localStorage->m_LastUpdateTime);
bool isContourOutdated = mitk::PropertyIsOutdated(datanode,mitk::nodeProp_RegEvalTargetContour,localStorage->m_LastUpdateTime);
bool isPositionOutdated = mitk::PropertyIsOutdated(datanode, mitk::nodeProp_RegEvalCurrentPosition, localStorage->m_LastUpdateTime);
if (updated ||
isStyleOutdated ||
isBlendOutdated ||
isCheckerOutdated ||
isWipeStyleOutdated ||
isContourOutdated ||
isPositionOutdated)
{
mitk::RegEvalStyleProperty::Pointer evalStyleProp = mitk::RegEvalStyleProperty::New();
datanode->GetProperty(evalStyleProp, mitk::nodeProp_RegEvalStyle);
switch (evalStyleProp->GetValueAsId())
{
case 0 :
{
PrepareBlend(datanode, localStorage);
break;
}
case 1 :
{
PrepareColorBlend(localStorage);
break;
}
case 2 :
{
PrepareCheckerBoard(datanode, localStorage);
break;
}
case 3 :
{
const PlaneGeometry *worldGeometry = renderer->GetCurrentWorldPlaneGeometry();
Point3D currentPos3D;
datanode->GetPropertyValue<Point3D>(mitk::nodeProp_RegEvalCurrentPosition, currentPos3D);
Point2D currentPos2D;
worldGeometry->Map(currentPos3D, currentPos2D);
Point2D currentIndex2D;
worldGeometry->WorldToIndex(currentPos2D, currentIndex2D);
PrepareWipe(datanode, localStorage, currentIndex2D);
break;
}
case 4 :
{
PrepareDifference(localStorage);
break;
}
case 5 :
{
PrepareContour(datanode, localStorage);
break;
}
}
updated = true;
}
if(updated
|| (localStorage->m_LastUpdateTime < datanode->GetPropertyList()->GetMTime()) //was a property modified?
|| (localStorage->m_LastUpdateTime < datanode->GetPropertyList(renderer)->GetMTime()) )
{
this->ApplyOpacity( renderer );
// do not use a VTK lookup table (we do that ourselves in m_LevelWindowFilter)
localStorage->m_Texture->SetColorModeToDirectScalars();
// check for texture interpolation property
bool textureInterpolation = false;
GetDataNode()->GetBoolProperty( "texture interpolation", textureInterpolation, renderer );
//set the interpolation modus according to the property
localStorage->m_Texture->SetInterpolate(textureInterpolation);
// connect the texture with the output of the levelwindow filter
localStorage->m_Texture->SetInputData(localStorage->m_EvaluationImage);
this->TransformActor( renderer );
vtkActor* contourShadowActor = dynamic_cast<vtkActor*> (localStorage->m_Actors->GetParts()->GetItemAsObject(0));
//Connect the mapper with the input texture. This is the standard case.
//setup the textured plane
this->GeneratePlane( renderer, sliceBounds );
//set the plane as input for the mapper
localStorage->m_Mapper->SetInputConnection(localStorage->m_Plane->GetOutputPort());
//set the texture for the actor
localStorage->m_Actor->SetTexture(localStorage->m_Texture);
contourShadowActor->SetVisibility( false );
// We have been modified => save this for next Update()
localStorage->m_LastUpdateTime.Modified();
}
}
void mitk::RegEvaluationMapper2D::PrepareContour( mitk::DataNode* datanode, LocalStorage * localStorage )
{
bool targetContour = true;
datanode->GetBoolProperty(mitk::nodeProp_RegEvalTargetContour,targetContour);
vtkSmartPointer<vtkImageGradientMagnitude> magFilter =
vtkSmartPointer<vtkImageGradientMagnitude>::New();
if(targetContour)
{
magFilter->SetInputConnection(localStorage->m_TargetExtractFilter->GetOutputPort());
}
else
{
magFilter->SetInputConnection(localStorage->m_MappedExtractFilter->GetOutputPort());
}
vtkSmartPointer<vtkImageAppendComponents> appendFilter =
vtkSmartPointer<vtkImageAppendComponents>::New();
appendFilter->AddInputConnection(magFilter->GetOutputPort());
appendFilter->AddInputConnection(magFilter->GetOutputPort());
if(targetContour)
{
appendFilter->AddInputConnection(localStorage->m_MappedExtractFilter->GetOutputPort());
}
else
{
appendFilter->AddInputConnection(localStorage->m_TargetExtractFilter->GetOutputPort());
}
appendFilter->Update();
localStorage->m_EvaluationImage = appendFilter->GetOutput();
}
void mitk::RegEvaluationMapper2D::PrepareDifference( LocalStorage * localStorage )
{
vtkSmartPointer<vtkImageMathematics> diffFilter =
vtkSmartPointer<vtkImageMathematics>::New();
vtkSmartPointer<vtkImageMathematics> minFilter =
vtkSmartPointer<vtkImageMathematics>::New();
vtkSmartPointer<vtkImageMathematics> maxFilter =
vtkSmartPointer<vtkImageMathematics>::New();
minFilter->SetInputConnection(0, localStorage->m_TargetExtractFilter->GetOutputPort());
minFilter->SetInputConnection(1, localStorage->m_MappedExtractFilter->GetOutputPort());
minFilter->SetOperationToMin();
maxFilter->SetInputConnection(0, localStorage->m_TargetExtractFilter->GetOutputPort());
maxFilter->SetInputConnection(1, localStorage->m_MappedExtractFilter->GetOutputPort());
maxFilter->SetOperationToMax();
diffFilter->SetInputConnection(0, maxFilter->GetOutputPort());
diffFilter->SetInputConnection(1, minFilter->GetOutputPort());
diffFilter->SetOperationToSubtract();
diffFilter->Update();
localStorage->m_EvaluationImage = diffFilter->GetOutput();
}
void mitk::RegEvaluationMapper2D::PrepareWipe(mitk::DataNode* datanode, LocalStorage * localStorage, const Point2D& currentIndex2D)
{
mitk::RegEvalWipeStyleProperty::Pointer evalWipeStyleProp = mitk::RegEvalWipeStyleProperty::New();
datanode->GetProperty(evalWipeStyleProp, mitk::nodeProp_RegEvalWipeStyle);
vtkSmartPointer<vtkImageRectilinearWipe> wipedFilter =
vtkSmartPointer<vtkImageRectilinearWipe>::New();
wipedFilter->SetInputConnection(0, localStorage->m_TargetLevelWindowFilter->GetOutputPort());
wipedFilter->SetInputConnection(1, localStorage->m_MappedLevelWindowFilter->GetOutputPort());
wipedFilter->SetPosition(currentIndex2D[0], currentIndex2D[1]);
if (evalWipeStyleProp->GetValueAsId() == 0)
{
wipedFilter->SetWipeToQuad();
}
else if (evalWipeStyleProp->GetValueAsId() == 1)
{
wipedFilter->SetWipeToHorizontal();
}
else if (evalWipeStyleProp->GetValueAsId() == 2)
{
wipedFilter->SetWipeToVertical();
}
wipedFilter->Update();
localStorage->m_EvaluationImage = wipedFilter->GetOutput();
}
void mitk::RegEvaluationMapper2D::PrepareCheckerBoard( mitk::DataNode* datanode, LocalStorage * localStorage )
{
int checkerCount = 5;
datanode->GetIntProperty(mitk::nodeProp_RegEvalCheckerCount,checkerCount);
vtkSmartPointer<vtkImageCheckerboard> checkerboardFilter =
vtkSmartPointer<vtkImageCheckerboard>::New();
checkerboardFilter->SetInputConnection(0, localStorage->m_TargetLevelWindowFilter->GetOutputPort());
checkerboardFilter->SetInputConnection(1, localStorage->m_MappedLevelWindowFilter->GetOutputPort());
checkerboardFilter->SetNumberOfDivisions(checkerCount, checkerCount, 1);
checkerboardFilter->Update();
localStorage->m_EvaluationImage = checkerboardFilter->GetOutput();
}
void mitk::RegEvaluationMapper2D::PrepareColorBlend( LocalStorage * localStorage )
{
vtkSmartPointer<vtkImageAppendComponents> appendFilter =
vtkSmartPointer<vtkImageAppendComponents>::New();
//red channel
appendFilter->AddInputConnection(localStorage->m_MappedExtractFilter->GetOutputPort());
//green channel
appendFilter->AddInputConnection(localStorage->m_MappedExtractFilter->GetOutputPort());
//blue channel
appendFilter->AddInputConnection(localStorage->m_TargetExtractFilter->GetOutputPort());
appendFilter->Update();
localStorage->m_EvaluationImage = appendFilter->GetOutput();
}
void mitk::RegEvaluationMapper2D::PrepareBlend( mitk::DataNode* datanode, LocalStorage * localStorage )
{
int blendfactor = 50;
datanode->GetIntProperty(mitk::nodeProp_RegEvalBlendFactor,blendfactor);
vtkSmartPointer<vtkImageWeightedSum> blendFilter =
vtkSmartPointer<vtkImageWeightedSum>::New();
blendFilter->AddInputConnection(localStorage->m_TargetExtractFilter->GetOutputPort());
blendFilter->AddInputConnection(localStorage->m_MappedExtractFilter->GetOutputPort());
blendFilter->SetWeight(0, (100 - blendfactor) / 100.);
blendFilter->SetWeight(1,blendfactor/100.);
blendFilter->Update();
localStorage->m_EvaluationImage = blendFilter->GetOutput();
}
void mitk::RegEvaluationMapper2D::ApplyLevelWindow(mitk::BaseRenderer *renderer, const mitk::DataNode* dataNode, vtkMitkLevelWindowFilter* levelFilter)
{
LevelWindow levelWindow;
dataNode->GetLevelWindow(levelWindow, renderer, "levelwindow");
levelFilter->GetLookupTable()->SetRange(levelWindow.GetLowerWindowBound(), levelWindow.GetUpperWindowBound());
mitk::LevelWindow opacLevelWindow;
if (dataNode->GetLevelWindow(opacLevelWindow, renderer, "opaclevelwindow"))
{
//pass the opaque level window to the filter
levelFilter->SetMinOpacity(opacLevelWindow.GetLowerWindowBound());
levelFilter->SetMaxOpacity(opacLevelWindow.GetUpperWindowBound());
}
else
{
//no opaque level window
levelFilter->SetMinOpacity(0.0);
levelFilter->SetMaxOpacity(255.0);
}
}
void mitk::RegEvaluationMapper2D::ApplyLookuptable(mitk::BaseRenderer* renderer, const mitk::DataNode* dataNode, vtkMitkLevelWindowFilter* levelFilter)
{
LocalStorage* localStorage = m_LSH.GetLocalStorage(renderer);
vtkLookupTable* usedLookupTable = localStorage->m_ColorLookupTable;
// If lookup table or transferfunction use is requested...
mitk::LookupTableProperty::Pointer lookupTableProp = dynamic_cast<mitk::LookupTableProperty*>(dataNode->GetProperty("LookupTable"));
if (lookupTableProp.IsNotNull()) // is a lookuptable set?
{
usedLookupTable = lookupTableProp->GetLookupTable()->GetVtkLookupTable();
}
else
{
//"Image Rendering.Mode was set to use a lookup table but there is no property 'LookupTable'.
//A default (rainbow) lookup table will be used.
//Here have to do nothing. Warning for the user has been removed, due to unwanted console output
//in every interation of the rendering.
}
levelFilter->SetLookupTable(usedLookupTable);
}
void mitk::RegEvaluationMapper2D::ApplyOpacity( mitk::BaseRenderer* renderer )
{
LocalStorage* localStorage = this->GetLocalStorage( renderer );
float opacity = 1.0f;
// check for opacity prop and use it for rendering if it exists
GetDataNode()->GetOpacity( opacity, renderer, "opacity" );
//set the opacity according to the properties
localStorage->m_Actor->GetProperty()->SetOpacity(opacity);
if ( localStorage->m_Actors->GetParts()->GetNumberOfItems() > 1 )
{
dynamic_cast<vtkActor*>( localStorage->m_Actors->GetParts()->GetItemAsObject(0) )->GetProperty()->SetOpacity(opacity);
}
}
void mitk::RegEvaluationMapper2D::Update(mitk::BaseRenderer* renderer)
{
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if ( !visible )
{
return;
}
mitk::Image* data = const_cast<mitk::Image *>( this->GetTargetImage() );
if ( data == nullptr )
{
return;
}
// Calculate time step of the input data for the specified renderer (integer value)
this->CalculateTimeStep( renderer );
// Check if time step is valid
const TimeGeometry *dataTimeGeometry = data->GetTimeGeometry();
if ( ( dataTimeGeometry == nullptr )
|| ( dataTimeGeometry->CountTimeSteps() == 0 )
|| ( !dataTimeGeometry->IsValidTimeStep( this->GetTimestep() ) ) )
{
return;
}
const DataNode *node = this->GetDataNode();
data->UpdateOutputInformation();
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
//check if something important has changed and we need to rerender
if ( (localStorage->m_LastUpdateTime < node->GetMTime()) //was the node modified?
|| (localStorage->m_LastUpdateTime < data->GetPipelineMTime()) //Was the data modified?
|| (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldPlaneGeometryUpdateTime()) //was the geometry modified?
|| (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldPlaneGeometry()->GetMTime())
|| (localStorage->m_LastUpdateTime < node->GetPropertyList()->GetMTime()) //was a property modified?
|| (localStorage->m_LastUpdateTime < node->GetPropertyList(renderer)->GetMTime())
|| (localStorage->m_LastUpdateTime < this->GetTargetNode()->GetMTime()) //was the target node modified?
|| (localStorage->m_LastUpdateTime < this->GetMovingNode()->GetMTime()) //was the moving node modified?
|| (localStorage->m_LastUpdateTime < this->GetTargetNode()->GetPropertyList()->GetMTime()) //was a target node property modified?
|| (localStorage->m_LastUpdateTime < this->GetTargetNode()->GetPropertyList(renderer)->GetMTime())
|| (localStorage->m_LastUpdateTime < this->GetMovingNode()->GetPropertyList()->GetMTime()) //was a moving node property modified?
|| (localStorage->m_LastUpdateTime < this->GetMovingNode()->GetPropertyList(renderer)->GetMTime()))
{
this->GenerateDataForRenderer( renderer );
}
// since we have checked that nothing important has changed, we can set
// m_LastUpdateTime to the current time
localStorage->m_LastUpdateTime.Modified();
}
void mitk::RegEvaluationMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
{
mitk::RegEvaluationObject* regEval = dynamic_cast<mitk::RegEvaluationObject*>(node->GetData());
if(!regEval)
{
return;
}
// Properties common for both images and segmentations
node->AddProperty( "depthOffset", mitk::FloatProperty::New( 0.0 ), renderer, overwrite );
if(regEval->GetTargetImage() && regEval->GetTargetImage()->IsRotated()) node->AddProperty( "reslice interpolation", mitk::VtkResliceInterpolationProperty::New(VTK_RESLICE_CUBIC) );
else node->AddProperty( "reslice interpolation", mitk::VtkResliceInterpolationProperty::New() );
node->AddProperty( "texture interpolation", mitk::BoolProperty::New( false ) ); // set to user configurable default value (see global options)
node->AddProperty( "in plane resample extent by geometry", mitk::BoolProperty::New( false ) );
node->AddProperty( "bounding box", mitk::BoolProperty::New( false ) );
mitk::RenderingModeProperty::Pointer renderingModeProperty = mitk::RenderingModeProperty::New();
node->AddProperty( "Image Rendering.Mode", renderingModeProperty);
// Set default grayscale look-up table
mitk::LookupTable::Pointer mitkLut = mitk::LookupTable::New();
mitk::LookupTableProperty::Pointer mitkLutProp = mitk::LookupTableProperty::New();
mitkLutProp->SetLookupTable(mitkLut);
node->SetProperty("LookupTable", mitkLutProp);
node->AddProperty( "opacity", mitk::FloatProperty::New(1.0f), renderer, overwrite );
node->AddProperty( "color", ColorProperty::New(1.0,1.0,1.0), renderer, overwrite );
node->AddProperty( "binary", mitk::BoolProperty::New( false ), renderer, overwrite );
node->AddProperty("layer", mitk::IntProperty::New(0), renderer, overwrite);
node->AddProperty(mitk::nodeProp_RegEvalStyle, mitk::RegEvalStyleProperty::New(0), renderer, overwrite);
node->AddProperty(mitk::nodeProp_RegEvalBlendFactor, mitk::IntProperty::New(50), renderer, overwrite);
node->AddProperty(mitk::nodeProp_RegEvalCheckerCount, mitk::IntProperty::New(3), renderer, overwrite);
node->AddProperty(mitk::nodeProp_RegEvalTargetContour, mitk::BoolProperty::New(true), renderer, overwrite);
node->AddProperty(mitk::nodeProp_RegEvalWipeStyle, mitk::RegEvalWipeStyleProperty::New(0), renderer, overwrite);
- node->AddProperty(mitk::nodeProp_RegEvalCurrentPosition, mitk::GenericProperty<mitk::Point3D>::New(mitk::Point3D()), renderer, overwrite);
+ node->AddProperty(mitk::nodeProp_RegEvalCurrentPosition, mitk::Point3dProperty::New(mitk::Point3D()), renderer, overwrite);
Superclass::SetDefaultProperties(node, renderer, overwrite);
}
mitk::RegEvaluationMapper2D::LocalStorage* mitk::RegEvaluationMapper2D::GetLocalStorage(mitk::BaseRenderer* renderer)
{
return m_LSH.GetLocalStorage(renderer);
}
void mitk::RegEvaluationMapper2D::TransformActor(mitk::BaseRenderer* renderer)
{
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
//get the transformation matrix of the reslicer in order to render the slice as axial, coronal or saggital
vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
vtkSmartPointer<vtkMatrix4x4> matrix = localStorage->m_Reslicer->GetResliceAxes();
trans->SetMatrix(matrix);
//transform the plane/contour (the actual actor) to the corresponding view (axial, coronal or saggital)
localStorage->m_Actor->SetUserTransform(trans);
//transform the origin to center based coordinates, because MITK is center based.
localStorage->m_Actor->SetPosition( -0.5*localStorage->m_mmPerPixel[0], -0.5*localStorage->m_mmPerPixel[1], 0.0);
if ( localStorage->m_Actors->GetNumberOfPaths() > 1 )
{
vtkActor* secondaryActor = dynamic_cast<vtkActor*>( localStorage->m_Actors->GetParts()->GetItemAsObject(0) );
secondaryActor->SetUserTransform(trans);
secondaryActor->SetPosition( -0.5*localStorage->m_mmPerPixel[0], -0.5*localStorage->m_mmPerPixel[1], 0.0);
}
}
bool mitk::RegEvaluationMapper2D::RenderingGeometryIntersectsImage( const PlaneGeometry* renderingGeometry, SlicedGeometry3D* imageGeometry )
{
// if either one of the two geometries is nullptr we return true
// for safety reasons
if ( renderingGeometry == nullptr || imageGeometry == nullptr )
return true;
// get the distance for the first cornerpoint
ScalarType initialDistance = renderingGeometry->SignedDistance( imageGeometry->GetCornerPoint( 0 ) );
for( int i=1; i<8; i++ )
{
mitk::Point3D cornerPoint = imageGeometry->GetCornerPoint( i );
// get the distance to the other cornerpoints
ScalarType distance = renderingGeometry->SignedDistance( cornerPoint );
// if it has not the same signing as the distance of the first point
if ( initialDistance * distance < 0 )
{
// we have an intersection and return true
return true;
}
}
// all distances have the same sign, no intersection and we return false
return false;
}
mitk::RegEvaluationMapper2D::LocalStorage::~LocalStorage()
{
}
mitk::RegEvaluationMapper2D::LocalStorage::LocalStorage()
{
m_TargetLevelWindowFilter = vtkSmartPointer<vtkMitkLevelWindowFilter>::New();
m_MappedLevelWindowFilter = vtkSmartPointer<vtkMitkLevelWindowFilter>::New();
m_TargetExtractFilter = vtkSmartPointer<vtkImageExtractComponents>::New();
m_MappedExtractFilter = vtkSmartPointer<vtkImageExtractComponents>::New();
m_mmPerPixel = nullptr;
//Do as much actions as possible in here to avoid double executions.
m_Plane = vtkSmartPointer<vtkPlaneSource>::New();
//m_Texture = vtkSmartPointer<vtkNeverTranslucentTexture>::New().GetPointer();
m_Texture = vtkSmartPointer<vtkOpenGLTexture>::New().GetPointer();
m_DefaultLookupTable = vtkSmartPointer<vtkLookupTable>::New();
m_ColorLookupTable = vtkSmartPointer<vtkLookupTable>::New();
m_Mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
m_Actor = vtkSmartPointer<vtkActor>::New();
m_Actors = vtkSmartPointer<vtkPropAssembly>::New();
m_Reslicer = mitk::ExtractSliceFilter::New();
m_EvaluationImage = vtkSmartPointer<vtkImageData>::New();
m_EmptyPolyData = vtkSmartPointer<vtkPolyData>::New();
mitk::LookupTable::Pointer mitkLUT = mitk::LookupTable::New();
//built a default lookuptable
mitkLUT->SetType(mitk::LookupTable::GRAYSCALE);
m_DefaultLookupTable = mitkLUT->GetVtkLookupTable();
mitkLUT->SetType(mitk::LookupTable::JET);
m_ColorLookupTable = mitkLUT->GetVtkLookupTable();
//do not repeat the texture (the image)
m_Texture->RepeatOff();
//set the mapper for the actor
m_Actor->SetMapper( m_Mapper );
vtkSmartPointer<vtkActor> outlineShadowActor = vtkSmartPointer<vtkActor>::New();
outlineShadowActor->SetMapper( m_Mapper );
m_Actors->AddPart( outlineShadowActor );
m_Actors->AddPart( m_Actor );
}
diff --git a/Modules/MatchPointRegistrationUI/Qmitk/QmitkRegEvalSettingsWidget.h b/Modules/MatchPointRegistrationUI/Qmitk/QmitkRegEvalSettingsWidget.h
index abbb5628ee..293db09e8c 100644
--- a/Modules/MatchPointRegistrationUI/Qmitk/QmitkRegEvalSettingsWidget.h
+++ b/Modules/MatchPointRegistrationUI/Qmitk/QmitkRegEvalSettingsWidget.h
@@ -1,70 +1,69 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QMITK_REG_EVAL_SETTINGS_WIDGET_H
#define QMITK_REG_EVAL_SETTINGS_WIDGET_H
#include <MitkMatchPointRegistrationUIExports.h>
#include "ui_QmitkRegEvalSettingsWidget.h"
#include <QWidget>
#include <mitkDataNode.h>
/**
* \class QmitkRegEvalSettingsWidget
* \brief Widget that views the information and profile of an algorithm stored in an DLLInfo object.
*/
class MITKMATCHPOINTREGISTRATIONUI_EXPORT QmitkRegEvalSettingsWidget : public QWidget,
private Ui::QmitkRegEvalSettingsWidget
{
Q_OBJECT
public:
QmitkRegEvalSettingsWidget(QWidget *parent = nullptr);
/**
* Configures the passed settings according to the current state of the
* widget.
- * \param pointer to a instance based on QmitkMappingJobSettings.
* \pre settings must point to a valid instance..
*/
void ConfigureControls();
public Q_SLOTS:
/**
* \brief Slot that can be used to set the node that should be configured by the widget.*/
void SetNode(mitk::DataNode *node);
signals:
void SettingsChanged(mitk::DataNode *node);
protected Q_SLOTS:
void OnComboStyleChanged(int);
void OnBlend50Pushed();
void OnBlendTargetPushed();
void OnBlendMovingPushed();
void OnBlendTogglePushed();
void OnSlideBlendChanged(int);
void OnSpinBlendChanged(int);
void OnSpinCheckerChanged(int);
void OnWipeStyleChanged();
void OnContourStyleChanged();
private:
mitk::DataNode::Pointer m_selectedEvalNode;
bool m_internalBlendUpdate;
bool m_internalUpdate;
};
#endif // QmitkRegEvalSettingsWidget_H
diff --git a/Modules/ModelFit/src/Common/mitkModelFitCmdAppsHelper.cpp b/Modules/ModelFit/src/Common/mitkModelFitCmdAppsHelper.cpp
index 2dc1760558..31e2352642 100644
--- a/Modules/ModelFit/src/Common/mitkModelFitCmdAppsHelper.cpp
+++ b/Modules/ModelFit/src/Common/mitkModelFitCmdAppsHelper.cpp
@@ -1,120 +1,120 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkModelFitCmdAppsHelper.h>
std::string sanitizeString(const std::string& path)
{
auto result = path;
std::string illegalChars = "\\/:?\"<>|%* ";
for (auto &c : result)
{
bool found = illegalChars.find(c) != std::string::npos;
if (found){
c = '_';
}
}
return result;
}
MITKMODELFIT_EXPORT std::string mitk::generateModelFitResultImagePath(const std::string& outputPathTemplate, const std::string& parameterName)
{
std::string ext = ::itksys::SystemTools::GetFilenameLastExtension(outputPathTemplate);
std::string dir = itksys::SystemTools::GetFilenamePath(outputPathTemplate);
dir = itksys::SystemTools::ConvertToOutputPath(dir);
std::string rootName = itksys::SystemTools::GetFilenameWithoutLastExtension(outputPathTemplate);
std::string fileName = rootName + "_" + sanitizeString(parameterName) + ext;
std::string fullOutPath = itksys::SystemTools::ConvertToOutputPath(dir + "/" + fileName);
return fullOutPath;
}
std::string convertParameterTypeToStr(mitk::modelFit::Parameter::Type type)
{
switch (type)
{
case mitk::modelFit::Parameter::ParameterType: return "parameter";
case mitk::modelFit::Parameter::DerivedType: return "derived";
case mitk::modelFit::Parameter::CriterionType: return "criterion";
case mitk::modelFit::Parameter::EvaluationType: return "evaluation";
default: return "unkown";
}
}
MITKMODELFIT_EXPORT void mitk::storeModelFitResultImage(const std::string& outputPathTemplate, const std::string& parameterName, mitk::Image* image, mitk::modelFit::Parameter::Type nodeType, const mitk::modelFit::ModelFitInfo* modelFitInfo)
{
mitk::modelFit::SetModelFitDataProperties(image, parameterName, nodeType, modelFitInfo);
storeParameterResultImage(outputPathTemplate, parameterName, image, nodeType);
}
MITKMODELFIT_EXPORT void mitk::storeParameterResultImage(const std::string& outputPathTemplate, const std::string& parameterName, mitk::Image* image, mitk::modelFit::Parameter::Type parameterType)
{
std::string fullOutPath = generateModelFitResultImagePath(outputPathTemplate, parameterName);
mitk::IOUtil::Save(image, fullOutPath);
std::cout << "Store result " << convertParameterTypeToStr(parameterType) << ": " << parameterName << " -> " << fullOutPath << std::endl;
}
MITKMODELFIT_EXPORT void mitk::storeModelFitGeneratorResults(const std::string& outputPathTemplate, mitk::ParameterFitImageGeneratorBase* generator, const mitk::modelFit::ModelFitInfo* fitSession)
{
if (generator)
{
- for (auto imageIterator : generator->GetParameterImages())
+ for (const auto &imageIterator : generator->GetParameterImages())
{
storeModelFitResultImage(outputPathTemplate, imageIterator.first, imageIterator.second, mitk::modelFit::Parameter::ParameterType, fitSession);
}
- for (auto imageIterator : generator->GetDerivedParameterImages())
+ for (const auto &imageIterator : generator->GetDerivedParameterImages())
{
storeModelFitResultImage(outputPathTemplate, imageIterator.first, imageIterator.second, mitk::modelFit::Parameter::DerivedType, fitSession);
}
- for (auto imageIterator : generator->GetCriterionImages())
+ for (const auto &imageIterator : generator->GetCriterionImages())
{
storeModelFitResultImage(outputPathTemplate, imageIterator.first, imageIterator.second, mitk::modelFit::Parameter::CriterionType, fitSession);
}
- for (auto imageIterator : generator->GetEvaluationParameterImages())
+ for (const auto &imageIterator : generator->GetEvaluationParameterImages())
{
storeModelFitResultImage(outputPathTemplate, imageIterator.first, imageIterator.second, mitk::modelFit::Parameter::EvaluationType, fitSession);
}
}
}
MITKMODELFIT_EXPORT void mitk::previewModelFitGeneratorResults(const std::string& outputPathTemplate, mitk::ParameterFitImageGeneratorBase* generator)
{
if (generator)
{
- for (auto aName : generator->GetParameterNames())
+ for (const auto &aName : generator->GetParameterNames())
{
std::cout << "Store result " << convertParameterTypeToStr(modelFit::Parameter::ParameterType) << ": " << aName << " -> " << generateModelFitResultImagePath(outputPathTemplate, aName) << std::endl;
}
- for (auto aName : generator->GetDerivedParameterNames())
+ for (const auto &aName : generator->GetDerivedParameterNames())
{
std::cout << "Store result " << convertParameterTypeToStr(modelFit::Parameter::DerivedType) << ": " << aName << " -> " << generateModelFitResultImagePath(outputPathTemplate, aName) << std::endl;
}
- for (auto aName : generator->GetCriterionNames())
+ for (const auto &aName : generator->GetCriterionNames())
{
std::cout << "Store result " << convertParameterTypeToStr(modelFit::Parameter::CriterionType) << ": " << aName << " -> " << generateModelFitResultImagePath(outputPathTemplate, aName) << std::endl;
}
- for (auto aName : generator->GetEvaluationParameterNames())
+ for (const auto &aName : generator->GetEvaluationParameterNames())
{
std::cout << "Store result " << convertParameterTypeToStr(modelFit::Parameter::EvaluationType) << ": " << aName << " -> " << generateModelFitResultImagePath(outputPathTemplate, aName) << std::endl;
}
std::cout << "Preview done." << std::endl;
}
}
diff --git a/Modules/ModelFitUI/Qmitk/QmitkFitPlotDataModel.cpp b/Modules/ModelFitUI/Qmitk/QmitkFitPlotDataModel.cpp
index 6c0e0e2b86..b405653fad 100644
--- a/Modules/ModelFitUI/Qmitk/QmitkFitPlotDataModel.cpp
+++ b/Modules/ModelFitUI/Qmitk/QmitkFitPlotDataModel.cpp
@@ -1,280 +1,280 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkExceptionMacro.h"
#include "QmitkFitPlotDataModel.h"
QmitkFitPlotDataModel::
QmitkFitPlotDataModel(QObject* parent) :
QAbstractTableModel(parent)
{
}
const mitk::ModelFitPlotData*
QmitkFitPlotDataModel::
GetPlotData() const
{
return &m_PlotData;
};
void
QmitkFitPlotDataModel::
SetPlotData(const mitk::ModelFitPlotData* data)
{
emit beginResetModel();
m_PlotData = *data;
emit endResetModel();
};
const std::string&
QmitkFitPlotDataModel::
GetXName() const
{
return m_XName;
};
void
QmitkFitPlotDataModel::
SetXName(const std::string& xName)
{
emit beginResetModel();
m_XName = xName;
emit endResetModel();
};
int
QmitkFitPlotDataModel::
rowCount(const QModelIndex&) const
{
//we assume that all plots have the same nr of values (except the interpolated signal which will be ignored).
//Thus we have only to check one plot. Reason: One fit is always derived from one input data and therefore
//all derived data should have the same size.
auto plot = GetCurveByColumn(0);
if (plot.second)
{
return plot.second->GetValues().size();
}
return 0;
}
std::pair<bool, mitk::ModelFitPlotData::PositionalCollectionMap::value_type> QmitkFitPlotDataModel::GetPositionalCurvePoint(const mitk::PlotDataCurve* curve) const
{
for (auto collection : this->m_PlotData.positionalPlots)
{
- for (auto aCurve : collection.second.second->CastToSTLContainer())
+ for (const auto &aCurve : collection.second.second->CastToSTLContainer())
{
if (curve == aCurve.second.GetPointer())
{
return std::make_pair(true, collection);
}
}
}
return std::make_pair(false, mitk::ModelFitPlotData::PositionalCollectionMap::value_type());
}
int
QmitkFitPlotDataModel::
columnCount(const QModelIndex& parent) const
{
if (parent.isValid())
{
return 0;
}
else
{
auto size = this->m_PlotData.currentPositionPlots->size() + this->m_PlotData.staticPlots->size();
if (mitk::ModelFitPlotData::GetInterpolatedSignalPlot(this->m_PlotData.currentPositionPlots))
{ //don't take the interpolated signal into account
size -= 1;
}
if (mitk::ModelFitPlotData::GetInterpolatedSignalPlot(this->m_PlotData.staticPlots))
{ //don't take the interpolated signal into account
size -= 1;
}
for (const auto& coll : this->m_PlotData.positionalPlots)
{
size += coll.second.second->size();
if (mitk::ModelFitPlotData::GetInterpolatedSignalPlot(coll.second.second))
{ //don't take the interpolated signal into account
size -= 1;
}
}
return size+2;
}
}
bool GetCurveFromCollection(const mitk::PlotDataCurveCollection* collection, std::size_t index, std::pair<std::string, const mitk::PlotDataCurve*>& finding, std::size_t& actualCount)
{
actualCount = 0;
for (const auto& iter : *(collection))
{
if (iter.first != mitk::MODEL_FIT_PLOT_INTERPOLATED_SIGNAL_NAME())
{
if (actualCount == index)
{
finding = std::make_pair(iter.first, iter.second.GetPointer());
return true;
}
++actualCount;
}
}
return false;
}
std::pair<std::string, const mitk::PlotDataCurve*>
QmitkFitPlotDataModel::
GetCurveByColumn(int col) const
{
if (col == 1)
{ /*the x axis is needed so just get the first signal.*/
col = 0;
}
else if (col > 1)
{ /*a normal signal is requested, correct the column index to ignore the timestep and timepoint column*/
col -= 2;
}
std::pair<std::string, const mitk::PlotDataCurve*> finding;
std::size_t actualCount;
if (GetCurveFromCollection(this->m_PlotData.currentPositionPlots.GetPointer(), col, finding, actualCount))
{
return finding;
}
col -= actualCount;
- for (auto collection : this->m_PlotData.positionalPlots)
+ for (const auto &collection : this->m_PlotData.positionalPlots)
{
if (GetCurveFromCollection(collection.second.second.GetPointer(), col, finding, actualCount))
{
return finding;
}
col -= actualCount;
}
GetCurveFromCollection(this->m_PlotData.staticPlots.GetPointer(), col, finding, actualCount);
return finding;
};
QVariant
QmitkFitPlotDataModel::
data(const QModelIndex& index, int role) const
{
if (!index.isValid())
{
return QVariant();
}
QVariant result;
if (index.column() == 0)
{
if (role == Qt::DisplayRole || role == Qt::EditRole)
{
result = QVariant(QString::number(index.row()));
}
else if (role == Qt::ToolTipRole)
{
result = QVariant("Index in plot.");
}
}
else if (index.column() == 1)
{
auto finding = GetCurveByColumn(index.column());
if (role == Qt::DisplayRole || role == Qt::EditRole)
{
if (finding.second && index.row() < static_cast<int>(finding.second->GetValues().size()))
{
result = QVariant(QString::number(finding.second->GetValues()[index.row()].first));
}
}
else if (role == Qt::ToolTipRole)
{
result = QVariant("x value in plot.");
}
}
else
{
auto finding = GetCurveByColumn(index.column());
if (role == Qt::DisplayRole || role == Qt::EditRole)
{
if (finding.second && index.row() < static_cast<int>(finding.second->GetValues().size()))
{
result = QVariant(QString::number(finding.second->GetValues()[index.row()].second));
}
}
else if (role == Qt::ToolTipRole)
{
result = QVariant("This is a value of the respective curve.");
}
}
return result;
}
Qt::ItemFlags
QmitkFitPlotDataModel::
flags(const QModelIndex& index) const
{
Qt::ItemFlags flags = QAbstractItemModel::flags(index);
return flags;
}
QVariant
QmitkFitPlotDataModel::
headerData(int section, Qt::Orientation orientation, int role) const
{
if ((Qt::DisplayRole == role) &&
(Qt::Horizontal == orientation))
{
if (section == 0)
{
return QVariant("#");
}
else if (section == 1)
{
return QVariant(QString::fromStdString(m_XName));
}
else
{
auto finding = GetCurveByColumn(section);
auto pointFinding = GetPositionalCurvePoint(finding.second);
std::ostringstream nameStrm;
nameStrm.imbue(std::locale("C"));
nameStrm << finding.first;
if (pointFinding.first)
{
nameStrm << " @ " << mitk::ModelFitPlotData::GetPositionalCollectionName(pointFinding.second);
}
return QVariant(QString::fromStdString(nameStrm.str()));
}
}
return QVariant();
}
bool
QmitkFitPlotDataModel::
setData(const QModelIndex&, const QVariant&, int)
{
return false;
};
diff --git a/Modules/Multilabel/Testing/mitkLabelSetImageTest.cpp b/Modules/Multilabel/Testing/mitkLabelSetImageTest.cpp
index 8637823ce0..97516291b0 100644
--- a/Modules/Multilabel/Testing/mitkLabelSetImageTest.cpp
+++ b/Modules/Multilabel/Testing/mitkLabelSetImageTest.cpp
@@ -1,435 +1,442 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkIOUtil.h>
#include <mitkImageStatisticsHolder.h>
#include <mitkLabelSetImage.h>
#include <mitkTestFixture.h>
#include <mitkTestingMacros.h>
class mitkLabelSetImageTestSuite : public mitk::TestFixture
{
CPPUNIT_TEST_SUITE(mitkLabelSetImageTestSuite);
MITK_TEST(TestInitialize);
MITK_TEST(TestAddLayer);
MITK_TEST(TestGetActiveLabelSet);
MITK_TEST(TestGetActiveLabel);
MITK_TEST(TestInitializeByLabeledImage);
MITK_TEST(TestGetLabelSet);
MITK_TEST(TestGetLabel);
MITK_TEST(TestSetExteriorLabel);
MITK_TEST(TestGetTotalNumberOfLabels);
MITK_TEST(TestExistsLabel);
MITK_TEST(TestExistsLabelSet);
MITK_TEST(TestSetActiveLayer);
MITK_TEST(TestRemoveLayer);
MITK_TEST(TestRemoveLabels);
MITK_TEST(TestMergeLabel);
CPPUNIT_TEST_SUITE_END();
private:
mitk::LabelSetImage::Pointer m_LabelSetImage;
public:
void setUp() override
{
// Create a new labelset image
m_LabelSetImage = mitk::LabelSetImage::New();
mitk::Image::Pointer regularImage = mitk::Image::New();
unsigned int dimensions[3] = { 96, 128, 52 };
regularImage->Initialize(mitk::MakeScalarPixelType<char>(), 3, dimensions);
m_LabelSetImage->Initialize(regularImage);
}
void tearDown() override
{
// Delete LabelSetImage
m_LabelSetImage = nullptr;
}
void TestInitialize()
{
// LabelSet image should always has the pixel type mitk::Label::PixelType
CPPUNIT_ASSERT_MESSAGE("LabelSetImage has wrong pixel type",
m_LabelSetImage->GetPixelType() == mitk::MakeScalarPixelType<mitk::Label::PixelType>());
mitk::Image::Pointer regularImage = mitk::Image::New();
unsigned int dimensions[3] = { 96, 128, 52 };
regularImage->Initialize(mitk::MakeScalarPixelType<char>(), 3, dimensions);
mitk::BaseGeometry::Pointer regularImageGeo = regularImage->GetGeometry();
mitk::BaseGeometry::Pointer labelImageGeo = m_LabelSetImage->GetGeometry();
MITK_ASSERT_EQUAL(labelImageGeo, regularImageGeo, "LabelSetImage has wrong geometry");
// By default one layer containing the exterior label should be added
CPPUNIT_ASSERT_MESSAGE("Image was not correctly initialized - number of layers is not one",
m_LabelSetImage->GetNumberOfLayers() == 1);
CPPUNIT_ASSERT_MESSAGE("Image was not correctly initialized - active layer has wrong ID",
m_LabelSetImage->GetActiveLayer() == 0);
CPPUNIT_ASSERT_MESSAGE("Image was not correctly initialized - active label is not the exterior label",
m_LabelSetImage->GetActiveLabel()->GetValue() == 0);
}
void TestAddLayer()
{
CPPUNIT_ASSERT_MESSAGE("Number of layers is not zero", m_LabelSetImage->GetNumberOfLayers() == 1);
m_LabelSetImage->AddLayer();
CPPUNIT_ASSERT_MESSAGE("Layer was not added correctly to image - number of layers is not one",
m_LabelSetImage->GetNumberOfLayers() == 2);
CPPUNIT_ASSERT_MESSAGE("Layer was not added correctly to image - active layer has wrong ID",
m_LabelSetImage->GetActiveLayer() == 1);
CPPUNIT_ASSERT_MESSAGE("Layer was not added correctly to image - active label is not the exterior label",
m_LabelSetImage->GetActiveLabel()->GetValue() == 0);
mitk::LabelSet::Pointer newlayer = mitk::LabelSet::New();
mitk::Label::Pointer label1 = mitk::Label::New();
label1->SetName("Label1");
label1->SetValue(1);
mitk::Label::Pointer label2 = mitk::Label::New();
label2->SetName("Label2");
label2->SetValue(200);
newlayer->AddLabel(label1);
newlayer->AddLabel(label2);
newlayer->SetActiveLabel(200);
unsigned int layerID = m_LabelSetImage->AddLayer(newlayer);
CPPUNIT_ASSERT_MESSAGE("Layer was not added correctly to image - number of layers is not two",
m_LabelSetImage->GetNumberOfLayers() == 3);
CPPUNIT_ASSERT_MESSAGE("Layer was not added correctly to image - active layer has wrong ID",
m_LabelSetImage->GetActiveLayer() == layerID);
CPPUNIT_ASSERT_MESSAGE("Layer was not added correctly to image - active label is wrong",
m_LabelSetImage->GetActiveLabel(layerID)->GetValue() == 200);
}
void TestGetActiveLabelSet()
{
mitk::LabelSet::Pointer newlayer = mitk::LabelSet::New();
mitk::Label::Pointer label1 = mitk::Label::New();
label1->SetName("Label1");
label1->SetValue(1);
mitk::Label::Pointer label2 = mitk::Label::New();
label2->SetName("Label2");
label2->SetValue(200);
newlayer->AddLabel(label1);
newlayer->AddLabel(label2);
newlayer->SetActiveLabel(200);
unsigned int layerID = m_LabelSetImage->AddLayer(newlayer);
mitk::LabelSet::Pointer activeLayer = m_LabelSetImage->GetActiveLabelSet();
CPPUNIT_ASSERT_MESSAGE("Wrong layer ID was returned", layerID == 1);
CPPUNIT_ASSERT_MESSAGE("Wrong active labelset returned", mitk::Equal(*newlayer, *activeLayer, 0.00001, true));
+
+ mitk::LabelSet::ConstPointer constActiveLayer = const_cast<const mitk::LabelSetImage*>(m_LabelSetImage.GetPointer())->GetActiveLabelSet();
+ CPPUNIT_ASSERT_MESSAGE("Wrong active labelset returned", mitk::Equal(*newlayer, *constActiveLayer, 0.00001, true));
}
void TestGetActiveLabel()
{
mitk::Label::Pointer label1 = mitk::Label::New();
label1->SetName("Label1");
mitk::Label::PixelType value1 = 1;
label1->SetValue(value1);
mitk::Label::Pointer label2 = mitk::Label::New();
label2->SetName("Label2");
mitk::Label::PixelType value2 = 200;
label2->SetValue(value2);
m_LabelSetImage->GetActiveLabelSet()->AddLabel(label1);
m_LabelSetImage->GetActiveLabelSet()->AddLabel(label2);
m_LabelSetImage->GetActiveLabelSet()->SetActiveLabel(1);
CPPUNIT_ASSERT_MESSAGE("Layer was not added correctly to image - active label is wrong",
m_LabelSetImage->GetActiveLabel()->GetValue() == value1);
m_LabelSetImage->GetActiveLabelSet()->SetActiveLabel(value2);
CPPUNIT_ASSERT_MESSAGE("Layer was not added correctly to image - active label is wrong",
m_LabelSetImage->GetActiveLabel()->GetValue() == value2);
+
+ CPPUNIT_ASSERT_MESSAGE("Active Label was not correctly retreived with const getter",
+ const_cast<const mitk::LabelSetImage*>(m_LabelSetImage.GetPointer())->GetActiveLabel()->GetValue() == value2);
+
}
void TestInitializeByLabeledImage()
{
mitk::Image::Pointer image =
mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Multilabel/LabelSetTestInitializeImage.nrrd"));
m_LabelSetImage->InitializeByLabeledImage(image);
CPPUNIT_ASSERT_MESSAGE("Image - number of labels is not 6", m_LabelSetImage->GetNumberOfLabels() == 6);
}
void TestGetLabelSet()
{
// Test get non existing lset
mitk::LabelSet::ConstPointer lset = m_LabelSetImage->GetLabelSet(10000);
CPPUNIT_ASSERT_MESSAGE("Non existing labelset is not nullptr", lset.IsNull());
lset = m_LabelSetImage->GetLabelSet(0);
CPPUNIT_ASSERT_MESSAGE("Existing labelset is nullptr", lset.IsNotNull());
}
void TestGetLabel()
{
mitk::Label::Pointer label1 = mitk::Label::New();
label1->SetName("Label1");
mitk::Label::PixelType value1 = 1;
label1->SetValue(value1);
mitk::Label::Pointer label2 = mitk::Label::New();
label2->SetName("Label2");
mitk::Label::PixelType value2 = 200;
label2->SetValue(value2);
m_LabelSetImage->GetActiveLabelSet()->AddLabel(label1);
m_LabelSetImage->AddLayer();
m_LabelSetImage->GetLabelSet(1)->AddLabel(label2);
CPPUNIT_ASSERT_MESSAGE("Wrong label retrieved for active layer",
mitk::Equal(*m_LabelSetImage->GetLabel(1), *label1, 0.0001, true));
CPPUNIT_ASSERT_MESSAGE("Wrong label retrieved for layer 1",
mitk::Equal(*m_LabelSetImage->GetLabel(200, 1), *label2, 0.0001, true));
// Try to get a non existing label
mitk::Label *label3 = m_LabelSetImage->GetLabel(1000);
CPPUNIT_ASSERT_MESSAGE("Non existing label should be nullptr", label3 == nullptr);
// Try to get a label from a non existing layer
label3 = m_LabelSetImage->GetLabel(200, 1000);
CPPUNIT_ASSERT_MESSAGE("Label from non existing layer should be nullptr", label3 == nullptr);
}
void TestSetExteriorLabel()
{
mitk::Label::Pointer exteriorLabel = mitk::Label::New();
exteriorLabel->SetName("MyExteriorSpecialLabel");
mitk::Label::PixelType value1 = 10000;
exteriorLabel->SetValue(value1);
m_LabelSetImage->SetExteriorLabel(exteriorLabel);
CPPUNIT_ASSERT_MESSAGE("Wrong label retrieved for layer 1",
mitk::Equal(*m_LabelSetImage->GetExteriorLabel(), *exteriorLabel, 0.0001, true));
// Exterior label should be set automatically for each new layer
m_LabelSetImage->AddLayer();
CPPUNIT_ASSERT_MESSAGE("Wrong label retrieved for layer 1",
mitk::Equal(*m_LabelSetImage->GetLabel(10000, 1), *exteriorLabel, 0.0001, true));
}
void TestGetTotalNumberOfLabels()
{
mitk::Label::Pointer label1 = mitk::Label::New();
label1->SetName("Label1");
mitk::Label::PixelType value1 = 1;
label1->SetValue(value1);
mitk::Label::Pointer label2 = mitk::Label::New();
label2->SetName("Label2");
mitk::Label::PixelType value2 = 200;
label2->SetValue(value2);
m_LabelSetImage->GetActiveLabelSet()->AddLabel(label1);
m_LabelSetImage->AddLayer();
m_LabelSetImage->GetLabelSet(1)->AddLabel(label2);
CPPUNIT_ASSERT_MESSAGE(
"Wrong total number of labels",
m_LabelSetImage->GetTotalNumberOfLabels() == 4); // added 2 labels + 2 exterior default labels
}
void TestExistsLabel()
{
mitk::Label::Pointer label = mitk::Label::New();
label->SetName("Label2");
mitk::Label::PixelType value = 200;
label->SetValue(value);
m_LabelSetImage->AddLayer();
m_LabelSetImage->GetLabelSet(1)->AddLabel(label);
m_LabelSetImage->SetActiveLayer(0);
CPPUNIT_ASSERT_MESSAGE("Existing label was not found", m_LabelSetImage->ExistLabel(value) == true);
CPPUNIT_ASSERT_MESSAGE("Non existing label was found", m_LabelSetImage->ExistLabel(10000) == false);
}
void TestExistsLabelSet()
{
// Cache active layer
mitk::LabelSet::ConstPointer activeLayer = m_LabelSetImage->GetActiveLabelSet();
// Add new layer
mitk::LabelSet::Pointer newlayer = mitk::LabelSet::New();
mitk::Label::Pointer label1 = mitk::Label::New();
label1->SetName("Label1");
label1->SetValue(1);
mitk::Label::Pointer label2 = mitk::Label::New();
label2->SetName("Label2");
label2->SetValue(200);
newlayer->AddLabel(label1);
newlayer->AddLabel(label2);
newlayer->SetActiveLabel(200);
m_LabelSetImage->AddLayer(newlayer);
CPPUNIT_ASSERT_MESSAGE("Check for existing layer failed", m_LabelSetImage->ExistLabelSet(0) == true);
CPPUNIT_ASSERT_MESSAGE("Check for existing layer failed", m_LabelSetImage->ExistLabelSet(1) == true);
CPPUNIT_ASSERT_MESSAGE("Check for existing layer failed", m_LabelSetImage->ExistLabelSet(20) == false);
}
void TestSetActiveLayer()
{
// Cache active layer
mitk::LabelSet::ConstPointer activeLayer = m_LabelSetImage->GetActiveLabelSet();
// Add new layer
mitk::LabelSet::Pointer newlayer = mitk::LabelSet::New();
mitk::Label::Pointer label1 = mitk::Label::New();
label1->SetName("Label1");
label1->SetValue(1);
mitk::Label::Pointer label2 = mitk::Label::New();
label2->SetName("Label2");
label2->SetValue(200);
newlayer->AddLabel(label1);
newlayer->AddLabel(label2);
newlayer->SetActiveLabel(200);
unsigned int layerID = m_LabelSetImage->AddLayer(newlayer);
// Set initial layer as active layer
m_LabelSetImage->SetActiveLayer(0);
CPPUNIT_ASSERT_MESSAGE("Wrong active labelset returned",
mitk::Equal(*activeLayer, *m_LabelSetImage->GetActiveLabelSet(), 0.00001, true));
// Set previously added layer as active layer
m_LabelSetImage->SetActiveLayer(layerID);
CPPUNIT_ASSERT_MESSAGE("Wrong active labelset returned",
mitk::Equal(*newlayer, *m_LabelSetImage->GetActiveLabelSet(), 0.00001, true));
// Set a non existing layer as active layer - nothing should change
m_LabelSetImage->SetActiveLayer(10000);
CPPUNIT_ASSERT_MESSAGE("Wrong active labelset returned",
mitk::Equal(*newlayer, *m_LabelSetImage->GetActiveLabelSet(), 0.00001, true));
}
void TestRemoveLayer()
{
// Cache active layer
mitk::LabelSet::ConstPointer activeLayer = m_LabelSetImage->GetActiveLabelSet();
// Add new layers
m_LabelSetImage->AddLayer();
mitk::LabelSet::Pointer newlayer = mitk::LabelSet::New();
mitk::Label::Pointer label1 = mitk::Label::New();
label1->SetName("Label1");
label1->SetValue(1);
mitk::Label::Pointer label2 = mitk::Label::New();
label2->SetName("Label2");
label2->SetValue(200);
newlayer->AddLabel(label1);
newlayer->AddLabel(label2);
newlayer->SetActiveLabel(200);
m_LabelSetImage->AddLayer(newlayer);
CPPUNIT_ASSERT_MESSAGE("Wrong active labelset returned",
mitk::Equal(*newlayer, *m_LabelSetImage->GetActiveLabelSet(), 0.00001, true));
m_LabelSetImage->RemoveLayer();
CPPUNIT_ASSERT_MESSAGE("Wrong number of layers, after a layer was removed",
m_LabelSetImage->GetNumberOfLayers() == 2);
CPPUNIT_ASSERT_MESSAGE("Check for existing layer failed", m_LabelSetImage->ExistLabelSet(2) == false);
CPPUNIT_ASSERT_MESSAGE("Check for existing layer failed", m_LabelSetImage->ExistLabelSet(1) == true);
CPPUNIT_ASSERT_MESSAGE("Check for existing layer failed", m_LabelSetImage->ExistLabelSet(0) == true);
m_LabelSetImage->RemoveLayer();
CPPUNIT_ASSERT_MESSAGE("Wrong number of layers, after a layer was removed",
m_LabelSetImage->GetNumberOfLayers() == 1);
CPPUNIT_ASSERT_MESSAGE("Check for existing layer failed", m_LabelSetImage->ExistLabelSet(1) == false);
CPPUNIT_ASSERT_MESSAGE("Check for existing layer failed", m_LabelSetImage->ExistLabelSet(0) == true);
CPPUNIT_ASSERT_MESSAGE("Wrong active layer",
mitk::Equal(*activeLayer, *m_LabelSetImage->GetActiveLabelSet(), 0.00001, true));
m_LabelSetImage->RemoveLayer();
CPPUNIT_ASSERT_MESSAGE("Wrong number of layers, after a layer was removed",
m_LabelSetImage->GetNumberOfLayers() == 0);
CPPUNIT_ASSERT_MESSAGE("Check for existing layer failed", m_LabelSetImage->ExistLabelSet(0) == false);
CPPUNIT_ASSERT_MESSAGE("Active layers is not nullptr although all layer have been removed",
m_LabelSetImage->GetActiveLabelSet() == nullptr);
}
void TestRemoveLabels()
{
mitk::Image::Pointer image =
mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Multilabel/LabelSetTestInitializeImage.nrrd"));
m_LabelSetImage->InitializeByLabeledImage(image);
CPPUNIT_ASSERT_MESSAGE("Image - number of labels is not 6", m_LabelSetImage->GetNumberOfLabels() == 6);
// 2ndMin because of the exterior label = 0
CPPUNIT_ASSERT_MESSAGE("Labels with value 1 and 3 was not remove from the image",
m_LabelSetImage->GetStatistics()->GetScalarValue2ndMin() == 1);
CPPUNIT_ASSERT_MESSAGE("Label with value 7 was not remove from the image",
m_LabelSetImage->GetStatistics()->GetScalarValueMax() == 7);
CPPUNIT_ASSERT_MESSAGE("Label with ID 3 does not exists after initialization",
m_LabelSetImage->ExistLabel(3) == true);
CPPUNIT_ASSERT_MESSAGE("Label with ID 7 does not exists after initialization",
m_LabelSetImage->ExistLabel(7) == true);
std::vector<mitk::Label::PixelType> labelsToBeRemoved;
labelsToBeRemoved.push_back(1);
labelsToBeRemoved.push_back(3);
labelsToBeRemoved.push_back(7);
m_LabelSetImage->RemoveLabels(labelsToBeRemoved);
CPPUNIT_ASSERT_MESSAGE("Wrong number of labels after some have been removed",
m_LabelSetImage->GetNumberOfLabels() == 3);
// Values within the image are 0, 1, 3, 5, 6, 7 - New Min/Max value should be 5 / 6
// 2ndMin because of the exterior label = 0
CPPUNIT_ASSERT_MESSAGE("Labels with value 1 and 3 was not remove from the image",
m_LabelSetImage->GetStatistics()->GetScalarValue2ndMin() == 5);
CPPUNIT_ASSERT_MESSAGE("Label with value 7 was not remove from the image",
m_LabelSetImage->GetStatistics()->GetScalarValueMax() == 6);
}
void TestMergeLabel()
{
mitk::Image::Pointer image = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Multilabel/LabelSetTestInitializeImage.nrrd"));
m_LabelSetImage = nullptr;
m_LabelSetImage = mitk::LabelSetImage::New();
m_LabelSetImage->InitializeByLabeledImage(image);
CPPUNIT_ASSERT_MESSAGE("Image - number of labels is not 6", m_LabelSetImage->GetNumberOfLabels() == 6);
// 2ndMin because of the exterior label = 0
CPPUNIT_ASSERT_MESSAGE("Wrong MIN value", m_LabelSetImage->GetStatistics()->GetScalarValueMin() == 0);
CPPUNIT_ASSERT_MESSAGE("Wrong MAX value", m_LabelSetImage->GetStatistics()->GetScalarValueMax() == 7);
m_LabelSetImage->GetActiveLabelSet()->SetActiveLabel(6);
// Merge label 7 with label 0. Result should be that label 7 is not present any more
m_LabelSetImage->MergeLabel(6, 7);
CPPUNIT_ASSERT_MESSAGE("Label with value 7 was not remove from the image", m_LabelSetImage->GetStatistics()->GetScalarValueMax() == 6);
m_LabelSetImage->GetStatistics()->GetScalarValue2ndMax();
// Count all pixels with value 7 = 823
// Count all pixels with value 6 = 507
// Check if merge label has 507 + 823 = 1330 pixels
CPPUNIT_ASSERT_MESSAGE("Label with value 7 was not remove from the image", m_LabelSetImage->GetStatistics()->GetCountOfMaxValuedVoxels() == 1330);
}
};
MITK_TEST_SUITE_REGISTRATION(mitkLabelSetImage)
diff --git a/Modules/Multilabel/autoload/DICOMSegIO/mitkDICOMSegmentationIO.cpp b/Modules/Multilabel/autoload/DICOMSegIO/mitkDICOMSegmentationIO.cpp
index a8caa81a5f..ec08b5baf2 100644
--- a/Modules/Multilabel/autoload/DICOMSegIO/mitkDICOMSegmentationIO.cpp
+++ b/Modules/Multilabel/autoload/DICOMSegIO/mitkDICOMSegmentationIO.cpp
@@ -1,704 +1,704 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef __mitkDICOMSegmentationIO__cpp
#define __mitkDICOMSegmentationIO__cpp
#include "mitkDICOMSegmentationIO.h"
#include "mitkDICOMSegIOMimeTypes.h"
#include "mitkDICOMSegmentationConstants.h"
#include <mitkDICOMDCMTKTagScanner.h>
#include <mitkDICOMIOHelper.h>
#include <mitkDICOMProperty.h>
#include <mitkIDICOMTagsOfInterest.h>
#include <mitkImageAccessByItk.h>
#include <mitkImageCast.h>
#include <mitkLocaleSwitch.h>
#include <mitkPropertyNameHelper.h>
// itk
#include <itkThresholdImageFilter.h>
// dcmqi
#include <dcmqi/ImageSEGConverter.h>
// us
#include <usGetModuleContext.h>
#include <usModuleContext.h>
namespace mitk
{
DICOMSegmentationIO::DICOMSegmentationIO()
: AbstractFileIO(LabelSetImage::GetStaticNameOfClass(),
mitk::MitkDICOMSEGIOMimeTypes::DICOMSEG_MIMETYPE_NAME(),
"DICOM Segmentation")
{
AbstractFileWriter::SetRanking(10);
AbstractFileReader::SetRanking(10);
this->RegisterService();
}
std::vector<mitk::DICOMTagPath> DICOMSegmentationIO::GetDICOMTagsOfInterest()
{
std::vector<mitk::DICOMTagPath> result;
result.emplace_back(DICOMSegmentationConstants::SEGMENT_SEQUENCE_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENT_NUMBER_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENT_LABEL_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENT_ALGORITHM_TYPE_PATH());
result.emplace_back(DICOMSegmentationConstants::ANATOMIC_REGION_SEQUENCE_PATH());
result.emplace_back(DICOMSegmentationConstants::ANATOMIC_REGION_CODE_VALUE_PATH());
result.emplace_back(DICOMSegmentationConstants::ANATOMIC_REGION_CODE_SCHEME_PATH());
result.emplace_back(DICOMSegmentationConstants::ANATOMIC_REGION_CODE_MEANING_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENTED_PROPERTY_CATEGORY_SEQUENCE_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENT_CATEGORY_CODE_VALUE_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENT_CATEGORY_CODE_SCHEME_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENT_CATEGORY_CODE_MEANING_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENTED_PROPERTY_TYPE_SEQUENCE_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENT_TYPE_CODE_VALUE_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENT_TYPE_CODE_SCHEME_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENT_TYPE_CODE_MEANING_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENTED_PROPERTY_MODIFIER_SEQUENCE_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENT_MODIFIER_CODE_VALUE_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENT_MODIFIER_CODE_SCHEME_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENT_MODIFIER_CODE_MEANING_PATH());
return result;
}
IFileIO::ConfidenceLevel DICOMSegmentationIO::GetWriterConfidenceLevel() const
{
if (AbstractFileIO::GetWriterConfidenceLevel() == Unsupported)
return Unsupported;
// Check if the input file is a segmentation
const LabelSetImage *input = static_cast<const LabelSetImage *>(this->GetInput());
if (input)
{
if ((input->GetDimension() != 3))
{
MITK_INFO << "DICOM segmentation writer is tested only with 3D images, sorry.";
return Unsupported;
}
// Check if input file has dicom information for the referenced image (original DICOM image, e.g. CT) Still necessary, see write()
mitk::StringLookupTableProperty::Pointer dicomFilesProp =
dynamic_cast<mitk::StringLookupTableProperty *>(input->GetProperty("referenceFiles").GetPointer());
if (dicomFilesProp.IsNotNull())
return Supported;
}
return Unsupported;
}
void DICOMSegmentationIO::Write()
{
ValidateOutputLocation();
mitk::LocaleSwitch localeSwitch("C");
LocalFile localFile(this);
const std::string path = localFile.GetFileName();
auto input = dynamic_cast<const LabelSetImage *>(this->GetInput());
if (input == nullptr)
mitkThrow() << "Cannot write non-image data";
// Get DICOM information from referenced image
vector<std::unique_ptr<DcmDataset>> dcmDatasetsSourceImage;
std::unique_ptr<DcmFileFormat> readFileFormat(new DcmFileFormat());
try
{
// TODO: Generate dcmdataset witk DICOM tags from property list; ATM the source are the filepaths from the
// property list
mitk::StringLookupTableProperty::Pointer filesProp =
dynamic_cast<mitk::StringLookupTableProperty *>(input->GetProperty("referenceFiles").GetPointer());
if (filesProp.IsNull())
{
mitkThrow() << "No property with dicom file path.";
return;
}
StringLookupTable filesLut = filesProp->GetValue();
const StringLookupTable::LookupTableType &lookUpTableMap = filesLut.GetLookupTable();
- for (auto it : lookUpTableMap)
+ for (const auto &it : lookUpTableMap)
{
const char *fileName = (it.second).c_str();
if (readFileFormat->loadFile(fileName, EXS_Unknown).good())
{
std::unique_ptr<DcmDataset> readDCMDataset(readFileFormat->getAndRemoveDataset());
dcmDatasetsSourceImage.push_back(std::move(readDCMDataset));
}
}
}
catch (const std::exception &e)
{
MITK_ERROR << "An error occurred while getting the dicom informations: " << e.what() << endl;
return;
}
// Iterate over all layers. For each a dcm file will be generated
for (unsigned int layer = 0; layer < input->GetNumberOfLayers(); ++layer)
{
vector<itkInternalImageType::Pointer> segmentations;
try
{
// Hack: Remove the const attribute to switch between the layer images. Normally you could get the different
// layer images by input->GetLayerImage(layer)
mitk::LabelSetImage *mitkLayerImage = const_cast<mitk::LabelSetImage *>(input);
mitkLayerImage->SetActiveLayer(layer);
// Cast mitk layer image to itk
ImageToItk<itkInputImageType>::Pointer imageToItkFilter = ImageToItk<itkInputImageType>::New();
imageToItkFilter->SetInput(mitkLayerImage);
// Cast from original itk type to dcmqi input itk image type
typedef itk::CastImageFilter<itkInputImageType, itkInternalImageType> castItkImageFilterType;
castItkImageFilterType::Pointer castFilter = castItkImageFilterType::New();
castFilter->SetInput(imageToItkFilter->GetOutput());
castFilter->Update();
itkInternalImageType::Pointer itkLabelImage = castFilter->GetOutput();
itkLabelImage->DisconnectPipeline();
// Iterate over all labels. For each label a segmentation image will be created
const LabelSet *labelSet = input->GetLabelSet(layer);
auto labelIter = labelSet->IteratorConstBegin();
// Ignore background label
++labelIter;
for (; labelIter != labelSet->IteratorConstEnd(); ++labelIter)
{
// Thresold over the image with the given label value
itk::ThresholdImageFilter<itkInternalImageType>::Pointer thresholdFilter =
itk::ThresholdImageFilter<itkInternalImageType>::New();
thresholdFilter->SetInput(itkLabelImage);
thresholdFilter->ThresholdOutside(labelIter->first, labelIter->first);
thresholdFilter->SetOutsideValue(0);
thresholdFilter->Update();
itkInternalImageType::Pointer segmentImage = thresholdFilter->GetOutput();
segmentImage->DisconnectPipeline();
segmentations.push_back(segmentImage);
}
}
catch (const itk::ExceptionObject &e)
{
MITK_ERROR << e.GetDescription() << endl;
return;
}
// Create segmentation meta information
const std::string tmpMetaInfoFile = this->CreateMetaDataJsonFile(layer);
MITK_INFO << "Writing image: " << path << std::endl;
try
{
//TODO is there a better way? Interface expects a vector of raw pointer.
vector<DcmDataset*> rawVecDataset;
for (const auto& dcmDataSet : dcmDatasetsSourceImage)
rawVecDataset.push_back(dcmDataSet.get());
// Convert itk segmentation images to dicom image
std::unique_ptr<dcmqi::ImageSEGConverter> converter = std::make_unique<dcmqi::ImageSEGConverter>();
std::unique_ptr<DcmDataset> result(converter->itkimage2dcmSegmentation(rawVecDataset, segmentations, tmpMetaInfoFile, false));
// Write dicom file
DcmFileFormat dcmFileFormat(result.get());
std::string filePath = path.substr(0, path.find_last_of("."));
// If there is more than one layer, we have to write more than 1 dicom file
if (input->GetNumberOfLayers() != 1)
filePath = filePath + std::to_string(layer) + ".dcm";
else
filePath = filePath + ".dcm";
dcmFileFormat.saveFile(filePath.c_str(), EXS_LittleEndianExplicit);
}
catch (const std::exception &e)
{
MITK_ERROR << "An error occurred during writing the DICOM Seg: " << e.what() << endl;
return;
}
} // Write a dcm file for the next layer
}
IFileIO::ConfidenceLevel DICOMSegmentationIO::GetReaderConfidenceLevel() const
{
if (AbstractFileIO::GetReaderConfidenceLevel() == Unsupported)
return Unsupported;
const std::string fileName = this->GetLocalFileName();
DcmFileFormat dcmFileFormat;
OFCondition status = dcmFileFormat.loadFile(fileName.c_str());
if (status.bad())
return Unsupported;
OFString modality;
if (dcmFileFormat.getDataset()->findAndGetOFString(DCM_Modality, modality).good())
{
if (modality.compare("SEG") == 0)
return Supported;
else
return Unsupported;
}
return Unsupported;
}
std::vector<BaseData::Pointer> DICOMSegmentationIO::DoRead()
{
mitk::LocaleSwitch localeSwitch("C");
LabelSetImage::Pointer labelSetImage;
std::vector<BaseData::Pointer> result;
const std::string path = this->GetLocalFileName();
MITK_INFO << "loading " << path << std::endl;
if (path.empty())
mitkThrow() << "Empty filename in mitk::ItkImageIO ";
try
{
// Get the dcm data set from file path
DcmFileFormat dcmFileFormat;
OFCondition status = dcmFileFormat.loadFile(path.c_str());
if (status.bad())
mitkThrow() << "Can't read the input file!";
DcmDataset *dataSet = dcmFileFormat.getDataset();
if (dataSet == nullptr)
mitkThrow() << "Can't read data from input file!";
//=============================== dcmqi part ====================================
// Read the DICOM SEG images (segItkImages) and DICOM tags (metaInfo)
std::unique_ptr<dcmqi::ImageSEGConverter> converter = std::make_unique<dcmqi::ImageSEGConverter>();
pair<map<unsigned, itkInternalImageType::Pointer>, string> dcmqiOutput =
converter->dcmSegmentation2itkimage(dataSet);
map<unsigned, itkInternalImageType::Pointer> segItkImages = dcmqiOutput.first;
dcmqi::JSONSegmentationMetaInformationHandler metaInfo(dcmqiOutput.second.c_str());
metaInfo.read();
MITK_INFO << "Input " << metaInfo.getJSONOutputAsString();
//===============================================================================
// Get the label information from segment attributes for each itk image
vector<map<unsigned, dcmqi::SegmentAttributes *>>::const_iterator segmentIter =
metaInfo.segmentsAttributesMappingList.begin();
// For each itk image add a layer to the LabelSetImage output
for (auto &element : segItkImages)
{
// Get the labeled image and cast it to mitkImage
typedef itk::CastImageFilter<itkInternalImageType, itkInputImageType> castItkImageFilterType;
castItkImageFilterType::Pointer castFilter = castItkImageFilterType::New();
castFilter->SetInput(element.second);
castFilter->Update();
Image::Pointer layerImage;
CastToMitkImage(castFilter->GetOutput(), layerImage);
// Get pixel value of the label
itkInternalImageType::ValueType segValue = 1;
typedef itk::ImageRegionIterator<const itkInternalImageType> IteratorType;
// Iterate over the image to find the pixel value of the label
IteratorType iter(element.second, element.second->GetLargestPossibleRegion());
iter.GoToBegin();
while (!iter.IsAtEnd())
{
itkInputImageType::PixelType value = iter.Get();
if (value != 0)
{
segValue = value;
break;
}
++iter;
}
// Get Segment information map
map<unsigned, dcmqi::SegmentAttributes *> segmentMap = (*segmentIter);
map<unsigned, dcmqi::SegmentAttributes *>::const_iterator segmentMapIter = (*segmentIter).begin();
dcmqi::SegmentAttributes *segmentAttribute = (*segmentMapIter).second;
OFString labelName;
if (segmentAttribute->getSegmentedPropertyTypeCodeSequence() != nullptr)
{
segmentAttribute->getSegmentedPropertyTypeCodeSequence()->getCodeMeaning(labelName);
if (segmentAttribute->getSegmentedPropertyTypeModifierCodeSequence() != nullptr)
{
OFString modifier;
segmentAttribute->getSegmentedPropertyTypeModifierCodeSequence()->getCodeMeaning(modifier);
labelName.append(" (").append(modifier).append(")");
}
}
else
{
labelName = std::to_string(segmentAttribute->getLabelID()).c_str();
if (labelName.empty())
labelName = "Unnamed";
}
float tmp[3] = { 0.0, 0.0, 0.0 };
if (segmentAttribute->getRecommendedDisplayRGBValue() != nullptr)
{
tmp[0] = segmentAttribute->getRecommendedDisplayRGBValue()[0] / 255.0;
tmp[1] = segmentAttribute->getRecommendedDisplayRGBValue()[1] / 255.0;
tmp[2] = segmentAttribute->getRecommendedDisplayRGBValue()[2] / 255.0;
}
Label *newLabel = nullptr;
// If labelSetImage do not exists (first image)
if (labelSetImage.IsNull())
{
// Initialize the labelSetImage with the read image
labelSetImage = LabelSetImage::New();
labelSetImage->InitializeByLabeledImage(layerImage);
// Already a label was generated, so set the information to this
newLabel = labelSetImage->GetActiveLabel(labelSetImage->GetActiveLayer());
newLabel->SetName(labelName.c_str());
newLabel->SetColor(Color(tmp));
newLabel->SetValue(segValue);
}
else
{
// Add a new layer to the labelSetImage. Background label is set automatically
labelSetImage->AddLayer(layerImage);
// Add new label
newLabel = new Label;
newLabel->SetName(labelName.c_str());
newLabel->SetColor(Color(tmp));
newLabel->SetValue(segValue);
labelSetImage->GetLabelSet(labelSetImage->GetActiveLayer())->AddLabel(newLabel);
}
// Add some more label properties
this->SetLabelProperties(newLabel, segmentAttribute);
++segmentIter;
}
labelSetImage->GetLabelSet()->SetAllLabelsVisible(true);
// Add some general DICOM Segmentation properties
mitk::IDICOMTagsOfInterest *toiSrv = GetDicomTagsOfInterestService();
auto tagsOfInterest = toiSrv->GetTagsOfInterest();
DICOMTagPathList tagsOfInterestList;
for (const auto &tag : tagsOfInterest)
{
tagsOfInterestList.push_back(tag.first);
}
mitk::DICOMDCMTKTagScanner::Pointer scanner = mitk::DICOMDCMTKTagScanner::New();
scanner->SetInputFiles({ GetInputLocation() });
scanner->AddTagPaths(tagsOfInterestList);
scanner->Scan();
mitk::DICOMDatasetAccessingImageFrameList frames = scanner->GetFrameInfoList();
if (frames.empty())
{
MITK_ERROR << "Error reading the DICOM Seg file" << std::endl;
return result;
}
auto findings = ExtractPathsOfInterest(tagsOfInterestList, frames);
SetProperties(labelSetImage, findings);
// Set active layer to the first layer of the labelset image
if (labelSetImage->GetNumberOfLayers() > 1 && labelSetImage->GetActiveLayer() != 0)
labelSetImage->SetActiveLayer(0);
}
catch (const std::exception &e)
{
MITK_ERROR << "An error occurred while reading the DICOM Seg file: " << e.what();
return result;
}
catch (...)
{
MITK_ERROR << "An error occurred in dcmqi while reading the DICOM Seg file";
return result;
}
result.push_back(labelSetImage.GetPointer());
return result;
}
const std::string mitk::DICOMSegmentationIO::CreateMetaDataJsonFile(int layer)
{
const mitk::LabelSetImage *image = dynamic_cast<const mitk::LabelSetImage *>(this->GetInput());
const std::string output;
dcmqi::JSONSegmentationMetaInformationHandler handler;
// 1. Metadata attributes that will be listed in the resulting DICOM SEG object
std::string contentCreatorName;
if (!image->GetPropertyList()->GetStringProperty(GeneratePropertyNameForDICOMTag(0x0070, 0x0084).c_str(),
contentCreatorName))
contentCreatorName = "MITK";
handler.setContentCreatorName(contentCreatorName);
std::string clinicalTrailSeriesId;
if (!image->GetPropertyList()->GetStringProperty(GeneratePropertyNameForDICOMTag(0x0012, 0x0071).c_str(),
clinicalTrailSeriesId))
clinicalTrailSeriesId = "Session 1";
handler.setClinicalTrialSeriesID(clinicalTrailSeriesId);
std::string clinicalTrialTimePointID;
if (!image->GetPropertyList()->GetStringProperty(GeneratePropertyNameForDICOMTag(0x0012, 0x0050).c_str(),
clinicalTrialTimePointID))
clinicalTrialTimePointID = "0";
handler.setClinicalTrialTimePointID(clinicalTrialTimePointID);
std::string clinicalTrialCoordinatingCenterName = "";
if (!image->GetPropertyList()->GetStringProperty(GeneratePropertyNameForDICOMTag(0x0012, 0x0060).c_str(),
clinicalTrialCoordinatingCenterName))
clinicalTrialCoordinatingCenterName = "Unknown";
handler.setClinicalTrialCoordinatingCenterName(clinicalTrialCoordinatingCenterName);
std::string seriesDescription;
if (!image->GetPropertyList()->GetStringProperty("name", seriesDescription))
seriesDescription = "MITK Segmentation";
handler.setSeriesDescription(seriesDescription);
handler.setSeriesNumber("0" + std::to_string(layer));
handler.setInstanceNumber("1");
handler.setBodyPartExamined("");
const LabelSet *labelSet = image->GetLabelSet(layer);
auto labelIter = labelSet->IteratorConstBegin();
// Ignore background label
++labelIter;
for (; labelIter != labelSet->IteratorConstEnd(); ++labelIter)
{
const Label *label = labelIter->second;
if (label != nullptr)
{
TemporoSpatialStringProperty *segmentNumberProp = dynamic_cast<mitk::TemporoSpatialStringProperty *>(label->GetProperty(
mitk::DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_NUMBER_PATH()).c_str()));
TemporoSpatialStringProperty *segmentLabelProp = dynamic_cast<mitk::TemporoSpatialStringProperty *>(label->GetProperty(
mitk::DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_LABEL_PATH()).c_str()));
TemporoSpatialStringProperty *algorithmTypeProp = dynamic_cast<mitk::TemporoSpatialStringProperty *>(label->GetProperty(
mitk::DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_ALGORITHM_TYPE_PATH()).c_str()));
TemporoSpatialStringProperty *segmentCategoryCodeValueProp = dynamic_cast<mitk::TemporoSpatialStringProperty *>(label->GetProperty(
mitk::DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_CATEGORY_CODE_VALUE_PATH()).c_str()));
TemporoSpatialStringProperty *segmentCategoryCodeSchemeProp = dynamic_cast<mitk::TemporoSpatialStringProperty *>(label->GetProperty(
mitk::DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_CATEGORY_CODE_SCHEME_PATH()).c_str()));
TemporoSpatialStringProperty *segmentCategoryCodeMeaningProp = dynamic_cast<mitk::TemporoSpatialStringProperty *>(label->GetProperty(
mitk::DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_CATEGORY_CODE_MEANING_PATH()).c_str()));
TemporoSpatialStringProperty *segmentTypeCodeValueProp = dynamic_cast<mitk::TemporoSpatialStringProperty *>(label->GetProperty(
mitk::DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_TYPE_CODE_VALUE_PATH()).c_str()));
TemporoSpatialStringProperty *segmentTypeCodeSchemeProp = dynamic_cast<mitk::TemporoSpatialStringProperty *>(label->GetProperty(
mitk::DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_TYPE_CODE_SCHEME_PATH()).c_str()));
TemporoSpatialStringProperty *segmentTypeCodeMeaningProp = dynamic_cast<mitk::TemporoSpatialStringProperty *>(label->GetProperty(
mitk::DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_TYPE_CODE_MEANING_PATH()).c_str()));
TemporoSpatialStringProperty *segmentModifierCodeValueProp = dynamic_cast<mitk::TemporoSpatialStringProperty *>(label->GetProperty(
mitk::DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_MODIFIER_CODE_VALUE_PATH()).c_str()));
TemporoSpatialStringProperty *segmentModifierCodeSchemeProp = dynamic_cast<mitk::TemporoSpatialStringProperty *>(label->GetProperty(
mitk::DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_MODIFIER_CODE_SCHEME_PATH()).c_str()));
TemporoSpatialStringProperty *segmentModifierCodeMeaningProp = dynamic_cast<mitk::TemporoSpatialStringProperty *>(label->GetProperty(
mitk::DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_MODIFIER_CODE_MEANING_PATH()).c_str()));
dcmqi::SegmentAttributes *segmentAttribute = nullptr;
if (segmentNumberProp->GetValue() == "")
{
MITK_ERROR << "Something went wrong with the label ID.";
}
else
{
int labelId = std::stoi(segmentNumberProp->GetValue());
segmentAttribute = handler.createAndGetNewSegment(labelId);
}
if (segmentAttribute != nullptr)
{
segmentAttribute->setSegmentDescription(segmentLabelProp->GetValueAsString());
segmentAttribute->setSegmentAlgorithmType(algorithmTypeProp->GetValueAsString());
segmentAttribute->setSegmentAlgorithmName("MITK Segmentation");
if (segmentCategoryCodeValueProp != nullptr && segmentCategoryCodeSchemeProp != nullptr &&
segmentCategoryCodeMeaningProp != nullptr)
segmentAttribute->setSegmentedPropertyCategoryCodeSequence(
segmentCategoryCodeValueProp->GetValueAsString(),
segmentCategoryCodeSchemeProp->GetValueAsString(),
segmentCategoryCodeMeaningProp->GetValueAsString());
else
// some default values
segmentAttribute->setSegmentedPropertyCategoryCodeSequence(
"M-01000", "SRT", "Morphologically Altered Structure");
if (segmentTypeCodeValueProp != nullptr && segmentTypeCodeSchemeProp != nullptr &&
segmentTypeCodeMeaningProp != nullptr)
{
segmentAttribute->setSegmentedPropertyTypeCodeSequence(segmentTypeCodeValueProp->GetValueAsString(),
segmentTypeCodeSchemeProp->GetValueAsString(),
segmentTypeCodeMeaningProp->GetValueAsString());
handler.setBodyPartExamined(segmentTypeCodeMeaningProp->GetValueAsString());
}
else
{
// some default values
segmentAttribute->setSegmentedPropertyTypeCodeSequence("M-03000", "SRT", "Mass");
handler.setBodyPartExamined("Mass");
}
if (segmentModifierCodeValueProp != nullptr && segmentModifierCodeSchemeProp != nullptr &&
segmentModifierCodeMeaningProp != nullptr)
segmentAttribute->setSegmentedPropertyTypeModifierCodeSequence(
segmentModifierCodeValueProp->GetValueAsString(),
segmentModifierCodeSchemeProp->GetValueAsString(),
segmentModifierCodeMeaningProp->GetValueAsString());
Color color = label->GetColor();
segmentAttribute->setRecommendedDisplayRGBValue(color[0] * 255, color[1] * 255, color[2] * 255);
}
}
}
return handler.getJSONOutputAsString();
}
void mitk::DICOMSegmentationIO::SetLabelProperties(mitk::Label *label, dcmqi::SegmentAttributes *segmentAttribute)
{
// Segment Number:Identification number of the segment.The value of Segment Number(0062, 0004) shall be unique
// within the Segmentation instance in which it is created
label->SetProperty(DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_NUMBER_PATH()).c_str(),
TemporoSpatialStringProperty::New(std::to_string(label->GetValue())));
// Segment Label: User-defined label identifying this segment.
label->SetProperty(DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_LABEL_PATH()).c_str(),
TemporoSpatialStringProperty::New(label->GetName()));
// Segment Algorithm Type: Type of algorithm used to generate the segment.
if (!segmentAttribute->getSegmentAlgorithmType().empty())
label->SetProperty(DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_ALGORITHM_TYPE_PATH()).c_str(),
TemporoSpatialStringProperty::New(segmentAttribute->getSegmentAlgorithmType()));
// Add Segmented Property Category Code Sequence tags
auto categoryCodeSequence = segmentAttribute->getSegmentedPropertyCategoryCodeSequence();
if (categoryCodeSequence != nullptr)
{
OFString codeValue; // (0008,0100) Code Value
categoryCodeSequence->getCodeValue(codeValue);
label->SetProperty(
DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_CATEGORY_CODE_VALUE_PATH()).c_str(),
TemporoSpatialStringProperty::New(codeValue.c_str()));
OFString codeScheme; // (0008,0102) Coding Scheme Designator
categoryCodeSequence->getCodingSchemeDesignator(codeScheme);
label->SetProperty(
DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_CATEGORY_CODE_SCHEME_PATH()).c_str(),
TemporoSpatialStringProperty::New(codeScheme.c_str()));
OFString codeMeaning; // (0008,0104) Code Meaning
categoryCodeSequence->getCodeMeaning(codeMeaning);
label->SetProperty(
DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_CATEGORY_CODE_MEANING_PATH()).c_str(),
TemporoSpatialStringProperty::New(codeMeaning.c_str()));
}
// Add Segmented Property Type Code Sequence tags
auto typeCodeSequence = segmentAttribute->getSegmentedPropertyTypeCodeSequence();
if (typeCodeSequence != nullptr)
{
OFString codeValue; // (0008,0100) Code Value
typeCodeSequence->getCodeValue(codeValue);
label->SetProperty(DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_TYPE_CODE_VALUE_PATH()).c_str(),
TemporoSpatialStringProperty::New(codeValue.c_str()));
OFString codeScheme; // (0008,0102) Coding Scheme Designator
typeCodeSequence->getCodingSchemeDesignator(codeScheme);
label->SetProperty(
DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_TYPE_CODE_SCHEME_PATH()).c_str(),
TemporoSpatialStringProperty::New(codeScheme.c_str()));
OFString codeMeaning; // (0008,0104) Code Meaning
typeCodeSequence->getCodeMeaning(codeMeaning);
label->SetProperty(
DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_TYPE_CODE_MEANING_PATH()).c_str(),
TemporoSpatialStringProperty::New(codeMeaning.c_str()));
}
// Add Segmented Property Type Modifier Code Sequence tags
auto modifierCodeSequence = segmentAttribute->getSegmentedPropertyTypeModifierCodeSequence();
if (modifierCodeSequence != nullptr)
{
OFString codeValue; // (0008,0100) Code Value
modifierCodeSequence->getCodeValue(codeValue);
label->SetProperty(
DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_MODIFIER_CODE_VALUE_PATH()).c_str(),
TemporoSpatialStringProperty::New(codeValue.c_str()));
OFString codeScheme; // (0008,0102) Coding Scheme Designator
modifierCodeSequence->getCodingSchemeDesignator(codeScheme);
label->SetProperty(
DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_MODIFIER_CODE_SCHEME_PATH()).c_str(),
TemporoSpatialStringProperty::New(codeScheme.c_str()));
OFString codeMeaning; // (0008,0104) Code Meaning
modifierCodeSequence->getCodeMeaning(codeMeaning);
label->SetProperty(
DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_MODIFIER_CODE_MEANING_PATH()).c_str(),
TemporoSpatialStringProperty::New(codeMeaning.c_str()));
}
// Add Atomic RegionSequence tags
auto atomicRegionSequence = segmentAttribute->getAnatomicRegionSequence();
if (atomicRegionSequence != nullptr)
{
OFString codeValue; // (0008,0100) Code Value
atomicRegionSequence->getCodeValue(codeValue);
label->SetProperty(
DICOMTagPathToPropertyName(DICOMSegmentationConstants::ANATOMIC_REGION_CODE_VALUE_PATH()).c_str(),
TemporoSpatialStringProperty::New(codeValue.c_str()));
OFString codeScheme; // (0008,0102) Coding Scheme Designator
atomicRegionSequence->getCodingSchemeDesignator(codeScheme);
label->SetProperty(
DICOMTagPathToPropertyName(DICOMSegmentationConstants::ANATOMIC_REGION_CODE_SCHEME_PATH()).c_str(),
TemporoSpatialStringProperty::New(codeScheme.c_str()));
OFString codeMeaning; // (0008,0104) Code Meaning
atomicRegionSequence->getCodeMeaning(codeMeaning);
label->SetProperty(
DICOMTagPathToPropertyName(DICOMSegmentationConstants::ANATOMIC_REGION_CODE_MEANING_PATH()).c_str(),
TemporoSpatialStringProperty::New(codeMeaning.c_str()));
}
}
DICOMSegmentationIO *DICOMSegmentationIO::IOClone() const { return new DICOMSegmentationIO(*this); }
} // namespace
#endif //__mitkDICOMSegmentationIO__cpp
diff --git a/Modules/Multilabel/mitkLabelSetImage.cpp b/Modules/Multilabel/mitkLabelSetImage.cpp
index 71a099210e..507157853d 100644
--- a/Modules/Multilabel/mitkLabelSetImage.cpp
+++ b/Modules/Multilabel/mitkLabelSetImage.cpp
@@ -1,989 +1,1005 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkLabelSetImage.h"
#include "mitkImageAccessByItk.h"
#include "mitkImageCast.h"
#include "mitkImagePixelReadAccessor.h"
#include "mitkImagePixelWriteAccessor.h"
#include "mitkInteractionConst.h"
#include "mitkLookupTableProperty.h"
#include "mitkPadImageFilter.h"
#include "mitkRenderingManager.h"
#include "mitkDICOMSegmentationPropertyHelper.h"
#include "mitkDICOMQIPropertyHelper.h"
#include <vtkCell.h>
#include <vtkTransform.h>
#include <vtkTransformPolyDataFilter.h>
#include <itkImageRegionIterator.h>
#include <itkQuadEdgeMesh.h>
#include <itkTriangleMeshToBinaryImageFilter.h>
//#include <itkRelabelComponentImageFilter.h>
#include <itkCommand.h>
template <typename TPixel, unsigned int VDimensions>
void SetToZero(itk::Image<TPixel, VDimensions> *source)
{
source->FillBuffer(0);
}
template <unsigned int VImageDimension = 3>
void CreateLabelMaskProcessing(mitk::Image *layerImage, mitk::Image *mask, mitk::LabelSet::PixelType index)
{
mitk::ImagePixelReadAccessor<mitk::LabelSet::PixelType, VImageDimension> readAccessor(layerImage);
mitk::ImagePixelWriteAccessor<mitk::LabelSet::PixelType, VImageDimension> writeAccessor(mask);
std::size_t numberOfPixels = 1;
for (int dim = 0; dim < static_cast<int>(VImageDimension); ++dim)
numberOfPixels *= static_cast<std::size_t>(readAccessor.GetDimension(dim));
auto src = readAccessor.GetData();
auto dest = writeAccessor.GetData();
for (std::size_t i = 0; i < numberOfPixels; ++i)
{
if (index == *(src + i))
*(dest + i) = 1;
}
}
mitk::LabelSetImage::LabelSetImage()
: mitk::Image(), m_ActiveLayer(0), m_activeLayerInvalid(false), m_ExteriorLabel(nullptr)
{
// Iniitlaize Background Label
mitk::Color color;
color.Set(0, 0, 0);
m_ExteriorLabel = mitk::Label::New();
m_ExteriorLabel->SetColor(color);
m_ExteriorLabel->SetName("Exterior");
m_ExteriorLabel->SetOpacity(0.0);
m_ExteriorLabel->SetLocked(false);
m_ExteriorLabel->SetValue(0);
// Add some DICOM Tags as properties to segmentation image
DICOMSegmentationPropertyHelper::DeriveDICOMSegmentationProperties(this);
}
mitk::LabelSetImage::LabelSetImage(const mitk::LabelSetImage &other)
: Image(other),
m_ActiveLayer(other.GetActiveLayer()),
m_activeLayerInvalid(false),
m_ExteriorLabel(other.GetExteriorLabel()->Clone())
{
for (unsigned int i = 0; i < other.GetNumberOfLayers(); i++)
{
// Clone LabelSet data
mitk::LabelSet::Pointer lsClone = other.GetLabelSet(i)->Clone();
// add modified event listener to LabelSet (listen to LabelSet changes)
itk::SimpleMemberCommand<Self>::Pointer command = itk::SimpleMemberCommand<Self>::New();
command->SetCallbackFunction(this, &mitk::LabelSetImage::OnLabelSetModified);
lsClone->AddObserver(itk::ModifiedEvent(), command);
m_LabelSetContainer.push_back(lsClone);
// clone layer Image data
mitk::Image::Pointer liClone = other.GetLayerImage(i)->Clone();
m_LayerContainer.push_back(liClone);
}
// Add some DICOM Tags as properties to segmentation image
DICOMSegmentationPropertyHelper::DeriveDICOMSegmentationProperties(this);
}
void mitk::LabelSetImage::OnLabelSetModified()
{
Superclass::Modified();
}
void mitk::LabelSetImage::SetExteriorLabel(mitk::Label *label)
{
m_ExteriorLabel = label;
}
mitk::Label *mitk::LabelSetImage::GetExteriorLabel()
{
return m_ExteriorLabel;
}
const mitk::Label *mitk::LabelSetImage::GetExteriorLabel() const
{
return m_ExteriorLabel;
}
void mitk::LabelSetImage::Initialize(const mitk::Image *other)
{
mitk::PixelType pixelType(mitk::MakeScalarPixelType<LabelSetImage::PixelType>());
if (other->GetDimension() == 2)
{
const unsigned int dimensions[] = {other->GetDimension(0), other->GetDimension(1), 1};
Superclass::Initialize(pixelType, 3, dimensions);
}
else
{
Superclass::Initialize(pixelType, other->GetDimension(), other->GetDimensions());
}
auto originalGeometry = other->GetTimeGeometry()->Clone();
this->SetTimeGeometry(originalGeometry);
// initialize image memory to zero
if (4 == this->GetDimension())
{
AccessFixedDimensionByItk(this, SetToZero, 4);
}
else
{
AccessByItk(this, SetToZero);
}
// Transfer some general DICOM properties from the source image to derived image (e.g. Patient information,...)
DICOMQIPropertyHelper::DeriveDICOMSourceProperties(other, this);
// Add a inital LabelSet ans corresponding image data to the stack
AddLayer();
}
mitk::LabelSetImage::~LabelSetImage()
{
m_LabelSetContainer.clear();
}
mitk::Image *mitk::LabelSetImage::GetLayerImage(unsigned int layer)
{
return m_LayerContainer[layer];
}
const mitk::Image *mitk::LabelSetImage::GetLayerImage(unsigned int layer) const
{
return m_LayerContainer[layer];
}
unsigned int mitk::LabelSetImage::GetActiveLayer() const
{
return m_ActiveLayer;
}
unsigned int mitk::LabelSetImage::GetNumberOfLayers() const
{
return m_LabelSetContainer.size();
}
void mitk::LabelSetImage::RemoveLayer()
{
int layerToDelete = GetActiveLayer();
// remove all observers from active label set
GetLabelSet(layerToDelete)->RemoveAllObservers();
// set the active layer to one below, if exists.
if (layerToDelete != 0)
{
SetActiveLayer(layerToDelete - 1);
}
else
{
// we are deleting layer zero, it should not be copied back into the vector
m_activeLayerInvalid = true;
}
// remove labelset and image data
m_LabelSetContainer.erase(m_LabelSetContainer.begin() + layerToDelete);
m_LayerContainer.erase(m_LayerContainer.begin() + layerToDelete);
if (layerToDelete == 0)
{
this->SetActiveLayer(layerToDelete);
}
this->Modified();
}
unsigned int mitk::LabelSetImage::AddLayer(mitk::LabelSet::Pointer lset)
{
mitk::Image::Pointer newImage = mitk::Image::New();
newImage->Initialize(this->GetPixelType(),
this->GetDimension(),
this->GetDimensions(),
this->GetImageDescriptor()->GetNumberOfChannels());
newImage->SetTimeGeometry(this->GetTimeGeometry()->Clone());
if (newImage->GetDimension() < 4)
{
AccessByItk(newImage, SetToZero);
}
else
{
AccessFixedDimensionByItk(newImage, SetToZero, 4);
}
unsigned int newLabelSetId = this->AddLayer(newImage, lset);
return newLabelSetId;
}
unsigned int mitk::LabelSetImage::AddLayer(mitk::Image::Pointer layerImage, mitk::LabelSet::Pointer lset)
{
unsigned int newLabelSetId = m_LayerContainer.size();
// Add labelset to layer
mitk::LabelSet::Pointer ls;
if (lset.IsNotNull())
{
ls = lset;
}
else
{
ls = mitk::LabelSet::New();
ls->AddLabel(GetExteriorLabel());
ls->SetActiveLabel(0 /*Exterior Label*/);
}
ls->SetLayer(newLabelSetId);
// Add exterior Label to label set
// mitk::Label::Pointer exteriorLabel = CreateExteriorLabel();
// push a new working image for the new layer
m_LayerContainer.push_back(layerImage);
// push a new labelset for the new layer
m_LabelSetContainer.push_back(ls);
// add modified event listener to LabelSet (listen to LabelSet changes)
itk::SimpleMemberCommand<Self>::Pointer command = itk::SimpleMemberCommand<Self>::New();
command->SetCallbackFunction(this, &mitk::LabelSetImage::OnLabelSetModified);
ls->AddObserver(itk::ModifiedEvent(), command);
SetActiveLayer(newLabelSetId);
// MITK_INFO << GetActiveLayer();
this->Modified();
return newLabelSetId;
}
void mitk::LabelSetImage::AddLabelSetToLayer(const unsigned int layerIdx, const mitk::LabelSet::Pointer labelSet)
{
if (m_LayerContainer.size() <= layerIdx)
{
mitkThrow() << "Trying to add labelSet to non-existing layer.";
}
if (layerIdx < m_LabelSetContainer.size())
{
m_LabelSetContainer[layerIdx] = labelSet;
}
else
{
while (layerIdx >= m_LabelSetContainer.size())
{
mitk::LabelSet::Pointer defaultLabelSet = mitk::LabelSet::New();
defaultLabelSet->AddLabel(GetExteriorLabel());
defaultLabelSet->SetActiveLabel(0 /*Exterior Label*/);
defaultLabelSet->SetLayer(m_LabelSetContainer.size());
m_LabelSetContainer.push_back(defaultLabelSet);
}
m_LabelSetContainer.push_back(labelSet);
}
}
void mitk::LabelSetImage::SetActiveLayer(unsigned int layer)
{
try
{
if (4 == this->GetDimension())
{
if ((layer != GetActiveLayer() || m_activeLayerInvalid) && (layer < this->GetNumberOfLayers()))
{
BeforeChangeLayerEvent.Send();
if (m_activeLayerInvalid)
{
// We should not write the invalid layer back to the vector
m_activeLayerInvalid = false;
}
else
{
AccessFixedDimensionByItk_n(this, ImageToLayerContainerProcessing, 4, (GetActiveLayer()));
}
m_ActiveLayer = layer; // only at this place m_ActiveLayer should be manipulated!!! Use Getter and Setter
AccessFixedDimensionByItk_n(this, LayerContainerToImageProcessing, 4, (GetActiveLayer()));
AfterChangeLayerEvent.Send();
}
}
else
{
if ((layer != GetActiveLayer() || m_activeLayerInvalid) && (layer < this->GetNumberOfLayers()))
{
BeforeChangeLayerEvent.Send();
if (m_activeLayerInvalid)
{
// We should not write the invalid layer back to the vector
m_activeLayerInvalid = false;
}
else
{
AccessByItk_1(this, ImageToLayerContainerProcessing, GetActiveLayer());
}
m_ActiveLayer = layer; // only at this place m_ActiveLayer should be manipulated!!! Use Getter and Setter
AccessByItk_1(this, LayerContainerToImageProcessing, GetActiveLayer());
AfterChangeLayerEvent.Send();
}
}
}
catch (itk::ExceptionObject &e)
{
mitkThrow() << e.GetDescription();
}
this->Modified();
}
void mitk::LabelSetImage::Concatenate(mitk::LabelSetImage *other)
{
const unsigned int *otherDims = other->GetDimensions();
const unsigned int *thisDims = this->GetDimensions();
if ((otherDims[0] != thisDims[0]) || (otherDims[1] != thisDims[1]) || (otherDims[2] != thisDims[2]))
mitkThrow() << "Dimensions do not match.";
try
{
int numberOfLayers = other->GetNumberOfLayers();
for (int layer = 0; layer < numberOfLayers; ++layer)
{
this->SetActiveLayer(layer);
AccessByItk_1(this, ConcatenateProcessing, other);
mitk::LabelSet *ls = other->GetLabelSet(layer);
auto it = ls->IteratorConstBegin();
auto end = ls->IteratorConstEnd();
it++; // skip exterior
while (it != end)
{
GetLabelSet()->AddLabel((it->second));
// AddLabelEvent.Send();
it++;
}
}
}
catch (itk::ExceptionObject &e)
{
mitkThrow() << e.GetDescription();
}
this->Modified();
}
void mitk::LabelSetImage::ClearBuffer()
{
try
{
AccessByItk(this, ClearBufferProcessing);
this->Modified();
}
catch (itk::ExceptionObject &e)
{
mitkThrow() << e.GetDescription();
}
}
bool mitk::LabelSetImage::ExistLabel(PixelType pixelValue) const
{
bool exist = false;
for (unsigned int lidx = 0; lidx < GetNumberOfLayers(); lidx++)
exist |= m_LabelSetContainer[lidx]->ExistLabel(pixelValue);
return exist;
}
bool mitk::LabelSetImage::ExistLabel(PixelType pixelValue, unsigned int layer) const
{
bool exist = m_LabelSetContainer[layer]->ExistLabel(pixelValue);
return exist;
}
bool mitk::LabelSetImage::ExistLabelSet(unsigned int layer) const
{
return layer < m_LabelSetContainer.size();
}
void mitk::LabelSetImage::MergeLabel(PixelType pixelValue, PixelType sourcePixelValue, unsigned int layer)
{
try
{
AccessByItk_2(this, MergeLabelProcessing, pixelValue, sourcePixelValue);
}
catch (itk::ExceptionObject &e)
{
mitkThrow() << e.GetDescription();
}
GetLabelSet(layer)->SetActiveLabel(pixelValue);
Modified();
}
void mitk::LabelSetImage::MergeLabels(PixelType pixelValue, std::vector<PixelType>& vectorOfSourcePixelValues, unsigned int layer)
{
try
{
for (unsigned int idx = 0; idx < vectorOfSourcePixelValues.size(); idx++)
{
AccessByItk_2(this, MergeLabelProcessing, pixelValue, vectorOfSourcePixelValues[idx]);
}
}
catch (itk::ExceptionObject &e)
{
mitkThrow() << e.GetDescription();
}
GetLabelSet(layer)->SetActiveLabel(pixelValue);
Modified();
}
void mitk::LabelSetImage::RemoveLabels(std::vector<PixelType> &VectorOfLabelPixelValues, unsigned int layer)
{
for (unsigned int idx = 0; idx < VectorOfLabelPixelValues.size(); idx++)
{
GetLabelSet(layer)->RemoveLabel(VectorOfLabelPixelValues[idx]);
EraseLabel(VectorOfLabelPixelValues[idx], layer);
}
}
void mitk::LabelSetImage::EraseLabels(std::vector<PixelType> &VectorOfLabelPixelValues, unsigned int layer)
{
for (unsigned int i = 0; i < VectorOfLabelPixelValues.size(); i++)
{
this->EraseLabel(VectorOfLabelPixelValues[i], layer);
}
}
void mitk::LabelSetImage::EraseLabel(PixelType pixelValue, unsigned int layer)
{
try
{
AccessByItk_2(this, EraseLabelProcessing, pixelValue, layer);
}
catch (itk::ExceptionObject &e)
{
mitkThrow() << e.GetDescription();
}
Modified();
}
mitk::Label *mitk::LabelSetImage::GetActiveLabel(unsigned int layer)
{
if (m_LabelSetContainer.size() <= layer)
return nullptr;
else
- return m_LabelSetContainer[layer]->GetActiveLabel();;
+ return m_LabelSetContainer[layer]->GetActiveLabel();
+}
+
+const mitk::Label* mitk::LabelSetImage::GetActiveLabel(unsigned int layer) const
+{
+ if (m_LabelSetContainer.size() <= layer)
+ return nullptr;
+ else
+ return m_LabelSetContainer[layer]->GetActiveLabel();
}
mitk::Label *mitk::LabelSetImage::GetLabel(PixelType pixelValue, unsigned int layer) const
{
if (m_LabelSetContainer.size() <= layer)
return nullptr;
else
return m_LabelSetContainer[layer]->GetLabel(pixelValue);
}
mitk::LabelSet *mitk::LabelSetImage::GetLabelSet(unsigned int layer)
{
if (m_LabelSetContainer.size() <= layer)
return nullptr;
else
return m_LabelSetContainer[layer].GetPointer();
}
const mitk::LabelSet *mitk::LabelSetImage::GetLabelSet(unsigned int layer) const
{
if (m_LabelSetContainer.size() <= layer)
return nullptr;
else
return m_LabelSetContainer[layer].GetPointer();
}
mitk::LabelSet *mitk::LabelSetImage::GetActiveLabelSet()
{
if (m_LabelSetContainer.size() == 0)
return nullptr;
else
return m_LabelSetContainer[GetActiveLayer()].GetPointer();
}
+const mitk::LabelSet* mitk::LabelSetImage::GetActiveLabelSet() const
+{
+ if (m_LabelSetContainer.size() == 0)
+ return nullptr;
+ else
+ return m_LabelSetContainer[GetActiveLayer()].GetPointer();
+}
+
void mitk::LabelSetImage::UpdateCenterOfMass(PixelType pixelValue, unsigned int layer)
{
if (4 == this->GetDimension())
{
AccessFixedDimensionByItk_2(this, CalculateCenterOfMassProcessing, 4, pixelValue, layer);
}
else
{
AccessByItk_2(this, CalculateCenterOfMassProcessing, pixelValue, layer);
}
}
unsigned int mitk::LabelSetImage::GetNumberOfLabels(unsigned int layer) const
{
return m_LabelSetContainer[layer]->GetNumberOfLabels();
}
unsigned int mitk::LabelSetImage::GetTotalNumberOfLabels() const
{
unsigned int totalLabels(0);
auto layerIter = m_LabelSetContainer.begin();
for (; layerIter != m_LabelSetContainer.end(); ++layerIter)
totalLabels += (*layerIter)->GetNumberOfLabels();
return totalLabels;
}
void mitk::LabelSetImage::MaskStamp(mitk::Image *mask, bool forceOverwrite)
{
try
{
mitk::PadImageFilter::Pointer padImageFilter = mitk::PadImageFilter::New();
padImageFilter->SetInput(0, mask);
padImageFilter->SetInput(1, this);
padImageFilter->SetPadConstant(0);
padImageFilter->SetBinaryFilter(false);
padImageFilter->SetLowerThreshold(0);
padImageFilter->SetUpperThreshold(1);
padImageFilter->Update();
mitk::Image::Pointer paddedMask = padImageFilter->GetOutput();
if (paddedMask.IsNull())
return;
AccessByItk_2(this, MaskStampProcessing, paddedMask, forceOverwrite);
}
catch (...)
{
mitkThrow() << "Could not stamp the provided mask on the selected label.";
}
}
mitk::Image::Pointer mitk::LabelSetImage::CreateLabelMask(PixelType index, bool useActiveLayer, unsigned int layer)
{
auto previousActiveLayer = this->GetActiveLayer();
auto mask = mitk::Image::New();
try
{
mask->Initialize(this);
auto byteSize = sizeof(LabelSetImage::PixelType);
for (unsigned int dim = 0; dim < mask->GetDimension(); ++dim)
byteSize *= mask->GetDimension(dim);
{
ImageWriteAccessor accessor(mask);
memset(accessor.GetData(), 0, byteSize);
}
if (!useActiveLayer)
this->SetActiveLayer(layer);
if (4 == this->GetDimension())
{
::CreateLabelMaskProcessing<4>(this, mask, index);
}
else if (3 == this->GetDimension())
{
::CreateLabelMaskProcessing(this, mask, index);
}
else
{
mitkThrow();
}
}
catch (...)
{
if (!useActiveLayer)
this->SetActiveLayer(previousActiveLayer);
mitkThrow() << "Could not create a mask out of the selected label.";
}
if (!useActiveLayer)
this->SetActiveLayer(previousActiveLayer);
return mask;
}
void mitk::LabelSetImage::InitializeByLabeledImage(mitk::Image::Pointer image)
{
if (image.IsNull() || image->IsEmpty() || !image->IsInitialized())
mitkThrow() << "Invalid labeled image.";
try
{
this->Initialize(image);
unsigned int byteSize = sizeof(LabelSetImage::PixelType);
for (unsigned int dim = 0; dim < image->GetDimension(); ++dim)
{
byteSize *= image->GetDimension(dim);
}
mitk::ImageWriteAccessor *accessor = new mitk::ImageWriteAccessor(static_cast<mitk::Image *>(this));
memset(accessor->GetData(), 0, byteSize);
delete accessor;
auto geometry = image->GetTimeGeometry()->Clone();
this->SetTimeGeometry(geometry);
if (image->GetDimension() == 3)
{
AccessTwoImagesFixedDimensionByItk(this, image, InitializeByLabeledImageProcessing, 3);
}
else if (image->GetDimension() == 4)
{
AccessTwoImagesFixedDimensionByItk(this, image, InitializeByLabeledImageProcessing, 4);
}
else
{
mitkThrow() << image->GetDimension() << "-dimensional label set images not yet supported";
}
}
catch (...)
{
mitkThrow() << "Could not intialize by provided labeled image.";
}
this->Modified();
}
template <typename LabelSetImageType, typename ImageType>
void mitk::LabelSetImage::InitializeByLabeledImageProcessing(LabelSetImageType *labelSetImage, ImageType *image)
{
typedef itk::ImageRegionConstIteratorWithIndex<ImageType> SourceIteratorType;
typedef itk::ImageRegionIterator<LabelSetImageType> TargetIteratorType;
TargetIteratorType targetIter(labelSetImage, labelSetImage->GetRequestedRegion());
targetIter.GoToBegin();
SourceIteratorType sourceIter(image, image->GetRequestedRegion());
sourceIter.GoToBegin();
while (!sourceIter.IsAtEnd())
{
auto sourceValue = static_cast<PixelType>(sourceIter.Get());
targetIter.Set(sourceValue);
if (!this->ExistLabel(sourceValue))
{
std::stringstream name;
name << "object-" << sourceValue;
double rgba[4];
m_LabelSetContainer[this->GetActiveLayer()]->GetLookupTable()->GetTableValue(sourceValue, rgba);
mitk::Color color;
color.SetRed(rgba[0]);
color.SetGreen(rgba[1]);
color.SetBlue(rgba[2]);
auto label = mitk::Label::New();
label->SetName(name.str().c_str());
label->SetColor(color);
label->SetOpacity(rgba[3]);
label->SetValue(sourceValue);
this->GetLabelSet()->AddLabel(label);
if (GetActiveLabelSet()->GetNumberOfLabels() >= mitk::Label::MAX_LABEL_VALUE ||
sourceValue >= mitk::Label::MAX_LABEL_VALUE)
this->AddLayer();
}
++sourceIter;
++targetIter;
}
}
template <typename ImageType>
void mitk::LabelSetImage::MaskStampProcessing(ImageType *itkImage, mitk::Image *mask, bool forceOverwrite)
{
typename ImageType::Pointer itkMask;
mitk::CastToItkImage(mask, itkMask);
typedef itk::ImageRegionConstIterator<ImageType> SourceIteratorType;
typedef itk::ImageRegionIterator<ImageType> TargetIteratorType;
SourceIteratorType sourceIter(itkMask, itkMask->GetLargestPossibleRegion());
sourceIter.GoToBegin();
TargetIteratorType targetIter(itkImage, itkImage->GetLargestPossibleRegion());
targetIter.GoToBegin();
int activeLabel = this->GetActiveLabel(GetActiveLayer())->GetValue();
while (!sourceIter.IsAtEnd())
{
PixelType sourceValue = sourceIter.Get();
PixelType targetValue = targetIter.Get();
if ((sourceValue != 0) &&
(forceOverwrite || !this->GetLabel(targetValue)->GetLocked())) // skip exterior and locked labels
{
targetIter.Set(activeLabel);
}
++sourceIter;
++targetIter;
}
this->Modified();
}
template <typename ImageType>
void mitk::LabelSetImage::CalculateCenterOfMassProcessing(ImageType *itkImage, PixelType pixelValue, unsigned int layer)
{
// for now, we just retrieve the voxel in the middle
typedef itk::ImageRegionConstIterator<ImageType> IteratorType;
IteratorType iter(itkImage, itkImage->GetLargestPossibleRegion());
iter.GoToBegin();
std::vector<typename ImageType::IndexType> indexVector;
while (!iter.IsAtEnd())
{
// TODO fix comparison warning more effective
if (iter.Get() == pixelValue)
{
indexVector.push_back(iter.GetIndex());
}
++iter;
}
mitk::Point3D pos;
pos.Fill(0.0);
if (!indexVector.empty())
{
typename itk::ImageRegionConstIteratorWithIndex<ImageType>::IndexType centerIndex;
centerIndex = indexVector.at(indexVector.size() / 2);
if (centerIndex.GetIndexDimension() == 3)
{
pos[0] = centerIndex[0];
pos[1] = centerIndex[1];
pos[2] = centerIndex[2];
}
else
return;
}
GetLabelSet(layer)->GetLabel(pixelValue)->SetCenterOfMassIndex(pos);
this->GetSlicedGeometry()->IndexToWorld(pos, pos); // TODO: TimeGeometry?
GetLabelSet(layer)->GetLabel(pixelValue)->SetCenterOfMassCoordinates(pos);
}
template <typename ImageType>
void mitk::LabelSetImage::ClearBufferProcessing(ImageType *itkImage)
{
itkImage->FillBuffer(0);
}
// todo: concatenate all layers and not just the active one
template <typename ImageType>
void mitk::LabelSetImage::ConcatenateProcessing(ImageType *itkTarget, mitk::LabelSetImage *other)
{
typename ImageType::Pointer itkSource = ImageType::New();
mitk::CastToItkImage(other, itkSource);
typedef itk::ImageRegionConstIterator<ImageType> ConstIteratorType;
typedef itk::ImageRegionIterator<ImageType> IteratorType;
ConstIteratorType sourceIter(itkSource, itkSource->GetLargestPossibleRegion());
IteratorType targetIter(itkTarget, itkTarget->GetLargestPossibleRegion());
int numberOfTargetLabels = this->GetNumberOfLabels(GetActiveLayer()) - 1; // skip exterior
sourceIter.GoToBegin();
targetIter.GoToBegin();
while (!sourceIter.IsAtEnd())
{
PixelType sourceValue = sourceIter.Get();
PixelType targetValue = targetIter.Get();
if ((sourceValue != 0) && !this->GetLabel(targetValue)->GetLocked()) // skip exterior and locked labels
{
targetIter.Set(sourceValue + numberOfTargetLabels);
}
++sourceIter;
++targetIter;
}
}
template <typename TPixel, unsigned int VImageDimension>
void mitk::LabelSetImage::LayerContainerToImageProcessing(itk::Image<TPixel, VImageDimension> *target,
unsigned int layer)
{
typedef itk::Image<TPixel, VImageDimension> ImageType;
typename ImageType::Pointer itkSource;
// mitk::CastToItkImage(m_LayerContainer[layer], itkSource);
itkSource = ImageToItkImage<TPixel, VImageDimension>(m_LayerContainer[layer]);
typedef itk::ImageRegionConstIterator<ImageType> SourceIteratorType;
typedef itk::ImageRegionIterator<ImageType> TargetIteratorType;
SourceIteratorType sourceIter(itkSource, itkSource->GetLargestPossibleRegion());
sourceIter.GoToBegin();
TargetIteratorType targetIter(target, target->GetLargestPossibleRegion());
targetIter.GoToBegin();
while (!sourceIter.IsAtEnd())
{
targetIter.Set(sourceIter.Get());
++sourceIter;
++targetIter;
}
}
template <typename TPixel, unsigned int VImageDimension>
void mitk::LabelSetImage::ImageToLayerContainerProcessing(itk::Image<TPixel, VImageDimension> *source,
unsigned int layer) const
{
typedef itk::Image<TPixel, VImageDimension> ImageType;
typename ImageType::Pointer itkTarget;
// mitk::CastToItkImage(m_LayerContainer[layer], itkTarget);
itkTarget = ImageToItkImage<TPixel, VImageDimension>(m_LayerContainer[layer]);
typedef itk::ImageRegionConstIterator<ImageType> SourceIteratorType;
typedef itk::ImageRegionIterator<ImageType> TargetIteratorType;
SourceIteratorType sourceIter(source, source->GetLargestPossibleRegion());
sourceIter.GoToBegin();
TargetIteratorType targetIter(itkTarget, itkTarget->GetLargestPossibleRegion());
targetIter.GoToBegin();
while (!sourceIter.IsAtEnd())
{
targetIter.Set(sourceIter.Get());
++sourceIter;
++targetIter;
}
}
template <typename ImageType>
void mitk::LabelSetImage::EraseLabelProcessing(ImageType *itkImage, PixelType pixelValue, unsigned int /*layer*/)
{
typedef itk::ImageRegionIterator<ImageType> IteratorType;
IteratorType iter(itkImage, itkImage->GetLargestPossibleRegion());
iter.GoToBegin();
while (!iter.IsAtEnd())
{
PixelType value = iter.Get();
if (value == pixelValue)
{
iter.Set(0);
}
++iter;
}
}
template <typename ImageType>
void mitk::LabelSetImage::MergeLabelProcessing(ImageType *itkImage, PixelType pixelValue, PixelType index)
{
typedef itk::ImageRegionIterator<ImageType> IteratorType;
IteratorType iter(itkImage, itkImage->GetLargestPossibleRegion());
iter.GoToBegin();
while (!iter.IsAtEnd())
{
if (iter.Get() == index)
{
iter.Set(pixelValue);
}
++iter;
}
}
bool mitk::Equal(const mitk::LabelSetImage &leftHandSide,
const mitk::LabelSetImage &rightHandSide,
ScalarType eps,
bool verbose)
{
bool returnValue = true;
/* LabelSetImage members */
MITK_INFO(verbose) << "--- LabelSetImage Equal ---";
// number layers
returnValue = leftHandSide.GetNumberOfLayers() == rightHandSide.GetNumberOfLayers();
if (!returnValue)
{
MITK_INFO(verbose) << "Number of layers not equal.";
return false;
}
// total number labels
returnValue = leftHandSide.GetTotalNumberOfLabels() == rightHandSide.GetTotalNumberOfLabels();
if (!returnValue)
{
MITK_INFO(verbose) << "Total number of labels not equal.";
return false;
}
// active layer
returnValue = leftHandSide.GetActiveLayer() == rightHandSide.GetActiveLayer();
if (!returnValue)
{
MITK_INFO(verbose) << "Active layer not equal.";
return false;
}
if (4 == leftHandSide.GetDimension())
{
MITK_INFO(verbose) << "Can not compare image data for 4D images - skipping check.";
}
else
{
// working image data
returnValue = mitk::Equal((const mitk::Image &)leftHandSide, (const mitk::Image &)rightHandSide, eps, verbose);
if (!returnValue)
{
MITK_INFO(verbose) << "Working image data not equal.";
return false;
}
}
for (unsigned int layerIndex = 0; layerIndex < leftHandSide.GetNumberOfLayers(); layerIndex++)
{
if (4 == leftHandSide.GetDimension())
{
MITK_INFO(verbose) << "Can not compare image data for 4D images - skipping check.";
}
else
{
// layer image data
returnValue =
mitk::Equal(*leftHandSide.GetLayerImage(layerIndex), *rightHandSide.GetLayerImage(layerIndex), eps, verbose);
if (!returnValue)
{
MITK_INFO(verbose) << "Layer image data not equal.";
return false;
}
}
// layer labelset data
returnValue =
mitk::Equal(*leftHandSide.GetLabelSet(layerIndex), *rightHandSide.GetLabelSet(layerIndex), eps, verbose);
if (!returnValue)
{
MITK_INFO(verbose) << "Layer labelset data not equal.";
return false;
}
}
return returnValue;
}
diff --git a/Modules/Multilabel/mitkLabelSetImage.h b/Modules/Multilabel/mitkLabelSetImage.h
index e65e6752e8..2d02b05287 100644
--- a/Modules/Multilabel/mitkLabelSetImage.h
+++ b/Modules/Multilabel/mitkLabelSetImage.h
@@ -1,340 +1,342 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef __mitkLabelSetImage_H_
#define __mitkLabelSetImage_H_
#include <mitkImage.h>
#include <mitkLabelSet.h>
#include <MitkMultilabelExports.h>
namespace mitk
{
//##Documentation
//## @brief LabelSetImage class for handling labels and layers in a segmentation session.
//##
//## Handles operations for adding, removing, erasing and editing labels and layers.
//## @ingroup Data
class MITKMULTILABEL_EXPORT LabelSetImage : public Image
{
public:
mitkClassMacro(LabelSetImage, Image);
itkNewMacro(Self);
typedef mitk::Label::PixelType PixelType;
/**
* \brief BeforeChangeLayerEvent (e.g. used for GUI integration)
* As soon as active labelset should be changed, the signal emits.
* Emitted by SetActiveLayer(int layer);
*/
Message<> BeforeChangeLayerEvent;
/**
* \brief AfterchangeLayerEvent (e.g. used for GUI integration)
* As soon as active labelset was changed, the signal emits.
* Emitted by SetActiveLayer(int layer);
*/
Message<> AfterChangeLayerEvent;
/**
* @brief Initialize an empty mitk::LabelSetImage using the information
* of an mitk::Image
* @param image the image which is used for initializing the mitk::LabelSetImage
*/
using mitk::Image::Initialize;
void Initialize(const mitk::Image *image) override;
/**
* \brief */
void Concatenate(mitk::LabelSetImage *image);
/**
* \brief */
void ClearBuffer();
/**
* @brief Merges the mitk::Label with a given target value with the active label
*
* @param pixelValue the value of the label that should be the new merged label
* @param sourcePixelValue the value of the label that should be merged into the specified one
* @param layer the layer in which the merge should be performed
*/
void MergeLabel(PixelType pixelValue, PixelType sourcePixelValue, unsigned int layer = 0);
/**
* @brief Merges a list of mitk::Labels with the mitk::Label that has a specific value
*
* @param pixelValue the value of the label that should be the new merged label
* @param vectorOfSourcePixelValues the list of label values that should be merge into the specified one
* @param layer the layer in which the merge should be performed
*/
void MergeLabels(PixelType pixelValue, std::vector<PixelType>& vectorOfSourcePixelValues, unsigned int layer = 0);
/**
* \brief */
void UpdateCenterOfMass(PixelType pixelValue, unsigned int layer = 0);
/**
* @brief Removes labels from the mitk::LabelSet of given layer.
* Calls mitk::LabelSetImage::EraseLabels() which also removes the labels from within the image.
* @param VectorOfLabelPixelValues a list of labels to be removed
* @param layer the layer in which the labels should be removed
*/
void RemoveLabels(std::vector<PixelType> &VectorOfLabelPixelValues, unsigned int layer = 0);
/**
* @brief Erases the label with the given value in the given layer from the underlying image.
* The label itself will not be erased from the respective mitk::LabelSet. In order to
* remove the label itself use mitk::LabelSetImage::RemoveLabels()
* @param pixelValue the label which will be remove from the image
* @param layer the layer in which the label should be removed
*/
void EraseLabel(PixelType pixelValue, unsigned int layer = 0);
/**
* @brief Similar to mitk::LabelSetImage::EraseLabel() this funtion erase a list of labels from the image
* @param VectorOfLabelPixelValues the list of labels that should be remove
* @param layer the layer for which the labels should be removed
*/
void EraseLabels(std::vector<PixelType> &VectorOfLabelPixelValues, unsigned int layer = 0);
/**
* \brief Returns true if the value exists in one of the labelsets*/
bool ExistLabel(PixelType pixelValue) const;
/**
* @brief Checks if a label exists in a certain layer
* @param pixelValue the label value
* @param layer the layer in which should be searched for the label
* @return true if the label exists otherwise false
*/
bool ExistLabel(PixelType pixelValue, unsigned int layer) const;
/**
* \brief Returns true if the labelset exists*/
bool ExistLabelSet(unsigned int layer) const;
/**
* @brief Returns the active label of a specific layer
* @param layer the layer ID for which the active label should be returned
* @return the active label of the specified layer
*/
mitk::Label *GetActiveLabel(unsigned int layer = 0);
+ const mitk::Label* GetActiveLabel(unsigned int layer = 0) const;
/**
* @brief Returns the mitk::Label with the given pixelValue and for the given layer
* @param pixelValue the pixel value of the label
* @param layer the layer in which the labels should be located
* @return the mitk::Label if available otherwise nullptr
*/
mitk::Label *GetLabel(PixelType pixelValue, unsigned int layer = 0) const;
/**
* @brief Returns the currently active mitk::LabelSet
* @return the mitk::LabelSet of the active layer or nullptr if non is present
*/
mitk::LabelSet *GetActiveLabelSet();
+ const mitk::LabelSet* GetActiveLabelSet() const;
/**
* @brief Gets the mitk::LabelSet for the given layer
* @param layer the layer for which the mitk::LabelSet should be retrieved
* @return the respective mitk::LabelSet or nullptr if non exists for the given layer
*/
mitk::LabelSet *GetLabelSet(unsigned int layer = 0);
const mitk::LabelSet *GetLabelSet(unsigned int layer = 0) const;
/**
* @brief Gets the ID of the currently active layer
* @return the ID of the active layer
*/
unsigned int GetActiveLayer() const;
/**
* @brief Get the number of all existing mitk::Labels for a given layer
* @param layer the layer ID for which the active mitk::Labels should be retrieved
* @return the number of all existing mitk::Labels for the given layer
*/
unsigned int GetNumberOfLabels(unsigned int layer = 0) const;
/**
* @brief Returns the number of all labels summed up across all layers
* @return the overall number of labels across all layers
*/
unsigned int GetTotalNumberOfLabels() const;
// This function will need to be ported to an external class
// it requires knowledge of pixeltype and dimension and includes
// too much algorithm to be sensibly part of a data class
///**
// * \brief */
// void SurfaceStamp(mitk::Surface* surface, bool forceOverwrite);
/**
* \brief */
mitk::Image::Pointer CreateLabelMask(PixelType index, bool useActiveLayer = true, unsigned int layer = 0);
/**
* @brief Initialize a new mitk::LabelSetImage by an given image.
* For all distinct pixel values of the parameter image new labels will
* be created. If the number of distinct pixel values exceeds mitk::Label::MAX_LABEL_VALUE
* a new layer will be created
* @param image the image which is used for initialization
*/
void InitializeByLabeledImage(mitk::Image::Pointer image);
/**
* \brief */
void MaskStamp(mitk::Image *mask, bool forceOverwrite);
/**
* \brief */
void SetActiveLayer(unsigned int layer);
/**
* \brief */
unsigned int GetNumberOfLayers() const;
/**
* @brief Adds a new layer to the LabelSetImage. The new layer will be set as the active one
* @param layer a mitk::LabelSet which will be set as new layer.
* @return the layer ID of the new layer
*/
unsigned int AddLayer(mitk::LabelSet::Pointer layer = nullptr);
/**
* \brief Add a layer based on a provided mitk::Image
* \param layerImage is added to the vector of label images
* \param lset a label set that will be added to the new layer if provided
*\return the layer ID of the new layer
*/
unsigned int AddLayer(mitk::Image::Pointer layerImage, mitk::LabelSet::Pointer lset = nullptr);
/**
* \brief Add a LabelSet to an existing layer
*
* This will replace an existing labelSet if one exists. Throws an exceptions if you are trying
* to add a labelSet to a non-existing layer.
*
* If there are no labelSets for layers with an id less than layerIdx default ones will be added
* for them.
*
* \param layerIdx The index of the layer the LabelSet should be added to
* \param labelSet The LabelSet that should be added
*/
void AddLabelSetToLayer(const unsigned int layerIdx, const mitk::LabelSet::Pointer labelSet);
/**
* @brief Removes the active layer and the respective mitk::LabelSet and image information.
* The new active layer is the one below, if exists
*/
void RemoveLayer();
/**
* \brief */
mitk::Image *GetLayerImage(unsigned int layer);
const mitk::Image *GetLayerImage(unsigned int layer) const;
void OnLabelSetModified();
/**
* @brief Sets the label which is used as default exterior label when creating a new layer
* @param label the label which will be used as new exterior label
*/
void SetExteriorLabel(mitk::Label *label);
/**
* @brief Gets the mitk::Label which is used as default exterior label
* @return the exterior mitk::Label
*/
mitk::Label *GetExteriorLabel();
const mitk::Label *GetExteriorLabel() const;
protected:
mitkCloneMacro(Self);
LabelSetImage();
LabelSetImage(const LabelSetImage &other);
~LabelSetImage() override;
template <typename ImageType1, typename ImageType2>
void ChangeLayerProcessing(ImageType1 *source, ImageType2 *target);
template <typename TPixel, unsigned int VImageDimension>
void LayerContainerToImageProcessing(itk::Image<TPixel, VImageDimension> *source, unsigned int layer);
template <typename TPixel, unsigned int VImageDimension>
void ImageToLayerContainerProcessing(itk::Image<TPixel, VImageDimension> *source, unsigned int layer) const;
template <typename ImageType>
void CalculateCenterOfMassProcessing(ImageType *input, PixelType index, unsigned int layer);
template <typename ImageType>
void ClearBufferProcessing(ImageType *input);
template <typename ImageType>
void EraseLabelProcessing(ImageType *input, PixelType index, unsigned int layer);
// template < typename ImageType >
// void ReorderLabelProcessing( ImageType* input, int index, int layer);
template <typename ImageType>
void MergeLabelProcessing(ImageType *input, PixelType pixelValue, PixelType index);
template <typename ImageType>
void ConcatenateProcessing(ImageType *input, mitk::LabelSetImage *other);
template <typename ImageType>
void MaskStampProcessing(ImageType *input, mitk::Image *mask, bool forceOverwrite);
template <typename LabelSetImageType, typename ImageType>
void InitializeByLabeledImageProcessing(LabelSetImageType *input, ImageType *other);
std::vector<LabelSet::Pointer> m_LabelSetContainer;
std::vector<Image::Pointer> m_LayerContainer;
int m_ActiveLayer;
bool m_activeLayerInvalid;
mitk::Label::Pointer m_ExteriorLabel;
};
/**
* @brief Equal A function comparing two label set images for beeing equal in meta- and imagedata
*
* @ingroup MITKTestingAPI
*
* Following aspects are tested for equality:
* - LabelSetImage members
* - working image data
* - layer image data
* - labels in label set
*
* @param rightHandSide An image to be compared
* @param leftHandSide An image to be compared
* @param eps Tolerance for comparison. You can use mitk::eps in most cases.
* @param verbose Flag indicating if the user wants detailed console output or not.
* @return true, if all subsequent comparisons are true, false otherwise
*/
MITKMULTILABEL_EXPORT bool Equal(const mitk::LabelSetImage &leftHandSide,
const mitk::LabelSetImage &rightHandSide,
ScalarType eps,
bool verbose);
} // namespace mitk
#endif // __mitkLabelSetImage_H_
diff --git a/Modules/Multilabel/mitkLabelSetImageToSurfaceFilter.h b/Modules/Multilabel/mitkLabelSetImageToSurfaceFilter.h
index 034a04bcf1..c30ca766b1 100644
--- a/Modules/Multilabel/mitkLabelSetImageToSurfaceFilter.h
+++ b/Modules/Multilabel/mitkLabelSetImageToSurfaceFilter.h
@@ -1,157 +1,157 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef _mitkLabelSetImageToSurfaceFilter_H_
#define _mitkLabelSetImageToSurfaceFilter_H_
#include "MitkMultilabelExports.h"
#include "mitkLabelSetImage.h"
#include "mitkSurface.h"
#include <mitkSurfaceSource.h>
#include <vtkMatrix4x4.h>
#include <itkImage.h>
#include <map>
namespace mitk
{
/**
* Generates surface meshes from a labelset image.
* If you want to calculate a surface representation for all available labels,
* you may call GenerateAllLabelsOn().
*/
class MITKMULTILABEL_EXPORT LabelSetImageToSurfaceFilter : public SurfaceSource
{
public:
mitkClassMacro(LabelSetImageToSurfaceFilter, SurfaceSource);
itkNewMacro(Self);
typedef LabelSetImage::PixelType LabelType;
typedef std::map<LabelType, unsigned long> LabelMapType;
typedef std::map<unsigned int, LabelType> IndexToLabelMapType;
/**
* Returns a const pointer to the labelset image set as input
*/
const mitk::Image *GetInput(void);
/**
* Set the labelset image to create a surface from.
*/
using ProcessObject::SetInput;
virtual void SetInput(const mitk::Image *image);
// virtual void SetObserver(mitk::ProcessObserver::Pointer observer);
/**
* Set whether you want to extract all labesl (true) or a single one.
*/
itkSetMacro(GenerateAllLabels, bool);
/**
* @returns if all labels or only a specific label should be
* extracted.
*/
itkGetMacro(GenerateAllLabels, bool);
itkBooleanMacro(GenerateAllLabels);
/**
* Set the label you want to extract. This method only has an effect,
* if GenerateAllLabels() is set to false
* @param _arg the label to extract, by default 1
*/
itkSetMacro(RequestedLabel, int);
/**
* Returns the label you want to extract. This method only has an effect,
* if GenerateAllLabels() is set to false
- * @returns _arg the label to extract, by default 1
+ * @return the label to extract, by default 1
*/
itkGetMacro(RequestedLabel, int);
/**
* Sets the label value of the background. No surface will be generated for this label.
* @param _arg the label of the background, by default 0
*/
itkSetMacro(BackgroundLabel, int);
/**
* Gets the label value of the background. No surface will be generated for this label.
- * @param _arg the label of the background, by default 0
+ * @return the label of the background, by default 0
*/
itkGetMacro(BackgroundLabel, int);
/**
* Sets whether to provide a smoothed surface
*/
itkSetMacro(UseSmoothing, int);
/**
* Sets the Sigma used in the gaussian smoothing
*/
itkSetMacro(Sigma, float);
protected:
LabelSetImageToSurfaceFilter();
~LabelSetImageToSurfaceFilter() override;
/**
* Transforms a point by a 4x4 matrix
*/
template <class T1, class T2, class T3>
inline void mitkVtkLinearTransformPoint(T1 matrix[4][4], T2 in[3], T3 out[3])
{
T3 x = matrix[0][0] * in[0] + matrix[0][1] * in[1] + matrix[0][2] * in[2] + matrix[0][3];
T3 y = matrix[1][0] * in[0] + matrix[1][1] * in[1] + matrix[1][2] * in[2] + matrix[1][3];
T3 z = matrix[2][0] * in[0] + matrix[2][1] * in[1] + matrix[2][2] * in[2] + matrix[2][3];
out[0] = x;
out[1] = y;
out[2] = z;
}
mitk::Image::Pointer m_ResultImage;
template <typename TPixel, unsigned int VImageDimension>
void InternalProcessing(const itk::Image<TPixel, VImageDimension> *input, mitk::Surface *surface);
bool m_GenerateAllLabels;
int m_RequestedLabel;
int m_BackgroundLabel;
int m_UseSmoothing;
float m_Sigma;
LabelMapType m_AvailableLabels;
IndexToLabelMapType m_IndexToLabels;
mitk::Vector3D m_InputImageSpacing;
void GenerateData() override;
void GenerateOutputInformation() override;
// mitk::ProcessObserver::Pointer m_Observer;
};
} // end of namespace mitk
#endif //_mitkLabelSetImageToSurfaceFilter_H_
diff --git a/Modules/OpenCL/mitkOclFilter.h b/Modules/OpenCL/mitkOclFilter.h
index 4de5217d7a..b958ffaf56 100644
--- a/Modules/OpenCL/mitkOclFilter.h
+++ b/Modules/OpenCL/mitkOclFilter.h
@@ -1,159 +1,157 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef __mitkOclFilter_h
#define __mitkOclFilter_h
#include "mitkOclUtils.h"
#include "mitkCommon.h"
#include <vector>
#include <usModule.h>
#include <MitkOpenCLExports.h>
namespace mitk
{
/**
@class OclFilter
@brief Superclass for all OpenCL based filter.
This class takes care of loading and compiling the external GPU program code.
*/
class MITKOPENCL_EXPORT OclFilter
{
public:
/**
* @brief Add a source file from the resource files to the
* OpenCL shader file list. Multiple files can be added to the list.
*
* @param filename of the file in the resource system
*/
void AddSourceFile(const char* filename);
/**
* @brief Set specific compilerflags to compile the CL source. Default is set to nullptr;
* example: "-cl-fast-relaxed-math -cl-mad-enable -cl-strict-aliasing"
*
* @param flags to the modulefolder that contains the gpuSource
*/
void SetCompilerFlags(const char* flags);
/**
* @brief Returns true if the initialization was successfull
*/
virtual bool IsInitialized();
/**
* @brief Returns the amount of global memory of the used device in bytes
*/
virtual unsigned long GetDeviceMemory();
/** @brief Destructor */
virtual ~OclFilter();
protected:
typedef std::vector<const char*> CStringList;
typedef std::vector<size_t> ClSizeList;
/** @brief Constructor */
OclFilter();
/** @brief Constructor ( overloaded ) */
OclFilter(const char* filename);
/** @brief String that contains the compiler flags */
const char* m_ClCompilerFlags;
/** @brief The compiled OpenCL program */
cl_program m_ClProgram;
/** @brief Command queue for the filter */
cl_command_queue m_CommandQue;
/** @brief Unique ID of the filter, needs to be specified in the constructor of the derived class */
std::string m_FilterID;
/*! @brief source preambel for e.g. \c \#define commands to be inserted into the OpenCL source */
const char* m_Preambel;
/** @brief List of sourcefiles that will be compiled for this filter.*/
CStringList m_ClFiles;
/** @brief status of the filter */
bool m_Initialized;
/** @brief The local work size fo the filter */
size_t m_LocalWorkSize[3];
/** @brief The global work size of the filter */
size_t m_GlobalWorkSize[3];
/** @brief Set the working size for the following OpenCL kernel call */
void SetWorkingSize(unsigned int locx, unsigned int dimx,
unsigned int locy = 1, unsigned int dimy = 1,
unsigned int locz = 1, unsigned int dimz = 1);
/** @brief Execute the given kernel on the OpenCL Index-Space defined by the local and global work sizes
*/
bool ExecuteKernel( cl_kernel kernel, unsigned int workSizeDim );
/** @brief Execute the given kernel on the OpenCL Index-Space defined by the local and global work sizes, but divide it into chunks of dimension chunksDim
*/
bool ExecuteKernelChunks( cl_kernel kernel, unsigned int workSizeDim, size_t* chunksDim );
/** @brief Execute the given kernel on the OpenCL Index-Space defined by the local and global work sizes, but divide it into chunks of dimension chunksDim and wait between
* batches of batchSize chunks a time of waitTimems milliseconds
*/
bool ExecuteKernelChunksInBatches(cl_kernel kernel, unsigned int workSizeDim, size_t* chunksDim, size_t batchSize, int waitTimems);
/**
* \brief Initialize all necessary parts of the filter
*
* The Initialize() method creates the command queue and the m_clProgram.
* The program is either compiled from the given source or taken from the
* OclResourceManager if the program was compiled already.
*/
bool Initialize();
/**
* @brief Compile the program source
- *
- * @param preambel e.g. defines for the shader code
*/
void CompileSource();
/**
* @brief Add some source code on the beginning of the loaded source
*
* In this way, some preprocessor flags for the CL compiler can at the beginning of the filter
* @param preambel Source preambel for e.g. \c \#define commands to be inserted into the OpenCL source
*/
void SetSourcePreambel(const char* preambel);
/**
* @brief Get the Module of the filter. Needs to be implemented by every subclass.
* The filter will load the OpenCL sourcefiles from this module context.
*/
virtual us::Module* GetModule() = 0;
/**
* @brief Helper functions that load sourcefiles from the module context in the Initialize function.
* @param SourceCodeList holds the sourcecode for every file as string, the SourceCodeSizeList holst the
* size of every file in bytes.
* @param SourceCodeSizeList
*/
void LoadSourceFiles(CStringList &SourceCodeList, ClSizeList &SourceCodeSizeList);
};
}
#endif // __mitkOclFilter_h
diff --git a/Modules/Pharmacokinetics/src/Functors/mitkCurveParameterFunctor.cpp b/Modules/Pharmacokinetics/src/Functors/mitkCurveParameterFunctor.cpp
index 4a61df2446..f4b5db81cf 100644
--- a/Modules/Pharmacokinetics/src/Functors/mitkCurveParameterFunctor.cpp
+++ b/Modules/Pharmacokinetics/src/Functors/mitkCurveParameterFunctor.cpp
@@ -1,137 +1,137 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkCurveParameterFunctor.h"
mitk::SimpleFunctorBase::OutputPixelVectorType
mitk::CurveParameterFunctor::Compute(const mitk::SimpleFunctorBase::InputPixelVectorType& value)
const
{
if (this->m_Grid.GetSize() == 0)
{
itkExceptionMacro("Error. Cannot compute Curve Description Parameters. No Curve Grid set!");
}
if (this->m_DescriptorMap.size() == 0)
{
itkGenericExceptionMacro( <<
"Error. Cannot compute Curve Description Parameters. No Parameters registered!");
}
CurveDescriptionParameterBase::CurveType sample(value.size());
for (CurveDescriptionParameterBase::CurveType::SizeValueType i = 0; i < sample.Size(); ++i)
{
sample[i] = value [i];
}
mitk::SimpleFunctorBase::OutputPixelVectorType result;
result.reserve(m_DescriptorMap.size()); //we will have at least this number of values
unsigned int i = 0;
for (DescriptionParameterMapType::const_iterator pos = m_DescriptorMap.begin();
pos != m_DescriptorMap.end(); ++pos, ++i)
{
CurveDescriptionParameterBase* paramFct = const_cast<CurveDescriptionParameterBase*>
(pos->second.GetPointer());
CurveDescriptionParameterBase::DescriptionParameterResultsType fctResults =
paramFct->GetCurveDescriptionParameter(sample, this->m_Grid);
result.insert(result.end(), fctResults.begin(), fctResults.end());
}
if (this->GetDescriptionParameterNames().size() != result.size())
{
itkGenericExceptionMacro( <<
"Error. Curve parameter functor has an invalid state. Number of parameter names and number of computed values does not match. Names count: "
<< this->GetDescriptionParameterNames().size() << "; value count: " << result.size());
}
return result;
};
unsigned int
mitk::CurveParameterFunctor::GetNumberOfOutputs() const
{
return GetDescriptionParameterNames().size();
};
mitk::CurveParameterFunctor::GridArrayType
mitk::CurveParameterFunctor::GetGrid() const
{
return m_Grid;
};
void
mitk::CurveParameterFunctor::ResetDescriptionParameters()
{
m_DescriptorMap.clear();
};
void
mitk::CurveParameterFunctor::RegisterDescriptionParameter(const std::string& parameterName,
CurveDescriptionParameterBase* parameterFunction)
{
CurveDescriptionParameterBase::Pointer paramFunctPtr = parameterFunction;
m_DescriptorMap.insert(std::make_pair(parameterName, paramFunctPtr));
};
mitk::CurveParameterFunctor::ParameterNamesType
mitk::CurveParameterFunctor::GetDescriptionParameterNames() const
{
ParameterNamesType result;
- for (auto descriptor : m_DescriptorMap)
+ for (const auto &descriptor : m_DescriptorMap)
{
CurveDescriptionParameterBase::DescriptionParameterNamesType fctResults =
descriptor.second->GetDescriptionParameterName();
if (fctResults.size() > 1)
{
- for (auto fctName : fctResults)
+ for (const auto &fctName : fctResults)
{
result.push_back(descriptor.first + "_" + fctName);
}
}
else
{ //if the descriptor has only one parameter just use the registered descriptor name.
result.push_back(descriptor.first);
}
}
return result;
};
const mitk::CurveDescriptionParameterBase*
mitk::CurveParameterFunctor::GetDescriptionParameterFunction(const std::string& parameterName) const
{
const CurveDescriptionParameterBase* result = nullptr;
DescriptionParameterMapType::const_iterator pos = m_DescriptorMap.find(parameterName);
if (pos != m_DescriptorMap.end())
{
result = (pos->second).GetPointer();
}
return result;
};
mitk::CurveParameterFunctor::
CurveParameterFunctor()
{};
mitk::CurveParameterFunctor::
~CurveParameterFunctor() {};
diff --git a/Modules/PharmacokineticsUI/Qmitk/QmitkDescriptionParameterBackgroundJob.cpp b/Modules/PharmacokineticsUI/Qmitk/QmitkDescriptionParameterBackgroundJob.cpp
index 0ab7b626ff..bd0a16a8d3 100644
--- a/Modules/PharmacokineticsUI/Qmitk/QmitkDescriptionParameterBackgroundJob.cpp
+++ b/Modules/PharmacokineticsUI/Qmitk/QmitkDescriptionParameterBackgroundJob.cpp
@@ -1,123 +1,123 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkDescriptionParameterBackgroundJob.h"
#include "mitkModelFitInfo.h"
void DescriptionParameterBackgroundJob::OnComputeEvent(::itk::Object* caller,
const itk::EventObject& event)
{
itk::ProgressEvent progressEvent;
itk::InitializeEvent initEvent;
itk::StartEvent startEvent;
itk::EndEvent endEvent;
if (progressEvent.CheckEvent(&event))
{
mitk::DescriptionParameterImageGeneratorBase* castedReporter =
dynamic_cast<mitk::DescriptionParameterImageGeneratorBase*>(caller);
emit JobProgress(castedReporter->GetProgress());
}
else if (initEvent.CheckEvent(&event))
{
emit JobStatusChanged(QString("Initializing description parameter generator"));
}
else if (startEvent.CheckEvent(&event))
{
emit JobStatusChanged(QString("Started parameter computation process."));
}
else if (endEvent.CheckEvent(&event))
{
emit JobStatusChanged(QString("Finished parameter computation process."));
}
}
DescriptionParameterBackgroundJob::
DescriptionParameterBackgroundJob(mitk::DescriptionParameterImageGeneratorBase* generator,
mitk::DataNode* parentNode)
{
if (!generator)
{
mitkThrow() << "Cannot create description parameter background job. Passed fit generator is NULL.";
}
m_Generator = generator;
m_ParentNode = parentNode;
m_spCommand = ::itk::MemberCommand<DescriptionParameterBackgroundJob>::New();
m_spCommand->SetCallbackFunction(this, &DescriptionParameterBackgroundJob::OnComputeEvent);
m_ObserverID = m_Generator->AddObserver(::itk::AnyEvent(), m_spCommand);
};
mitk::DataNode*
DescriptionParameterBackgroundJob::
GetParentNode() const
{
return m_ParentNode;
};
DescriptionParameterBackgroundJob::
~DescriptionParameterBackgroundJob()
{
m_Generator->RemoveObserver(m_ObserverID);
};
mitk::modelFit::ModelFitResultNodeVectorType DescriptionParameterBackgroundJob::CreateResultNodes(
const mitk::DescriptionParameterImageGeneratorBase::ParameterImageMapType& paramimages)
{
mitk::modelFit::ModelFitResultNodeVectorType results;
- for (auto image : paramimages)
+ for (const auto &image : paramimages)
{
if (image.second.IsNull())
{
mitkThrow() << "Cannot generate result node. Passed parameterImage is null. parameter name: " <<
image.first;
}
mitk::DataNode::Pointer result = mitk::DataNode::New();
result->SetData(image.second);
result->SetName(image.first);
result->SetVisibility(true);
results.push_back(result);
}
return results;
};
void
DescriptionParameterBackgroundJob::
run()
{
try
{
emit JobStatusChanged(QString("Started session..."));
m_Generator->Generate();
emit JobStatusChanged(QString("Generate result nodes."));
m_Results = CreateResultNodes(m_Generator->GetParameterImages());
emit ResultsAreAvailable(m_Results, this);
}
catch (::std::exception& e)
{
emit Error(QString("Error while processing data. Details: ") + QString::fromLatin1(e.what()));
}
catch (...)
{
emit Error(QString("Unkown error when processing the data."));
}
emit Finished();
};
diff --git a/Modules/QtWidgets/src/QmitkAbstractNodeSelectionWidget.cpp b/Modules/QtWidgets/src/QmitkAbstractNodeSelectionWidget.cpp
index 39acb451f4..1b3d6c9e98 100644
--- a/Modules/QtWidgets/src/QmitkAbstractNodeSelectionWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkAbstractNodeSelectionWidget.cpp
@@ -1,426 +1,426 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkAbstractNodeSelectionWidget.h"
#include "QmitkModelViewSelectionConnector.h"
QmitkAbstractNodeSelectionWidget::QmitkAbstractNodeSelectionWidget(QWidget* parent)
: QWidget(parent)
, m_InvalidInfo("Error. Select data.")
, m_EmptyInfo("Empty. Make a selection.")
, m_PopUpTitel("Select a data node")
, m_PopUpHint("")
, m_IsOptional(false)
, m_SelectOnlyVisibleNodes(true)
, m_DataStorageDeletedTag(0)
, m_LastEmissionAllowance(true)
, m_RecursionGuard(false)
{
}
QmitkAbstractNodeSelectionWidget::~QmitkAbstractNodeSelectionWidget()
{
auto dataStorage = m_DataStorage.Lock();
if (dataStorage.IsNotNull())
{
// remove Listener for the data storage itself
dataStorage->RemoveObserver(m_DataStorageDeletedTag);
// remove "add node listener" from data storage
dataStorage->AddNodeEvent.RemoveListener(
mitk::MessageDelegate1<QmitkAbstractNodeSelectionWidget, const mitk::DataNode*>(this, &QmitkAbstractNodeSelectionWidget::NodeAddedToStorage));
// remove "remove node listener" from data storage
dataStorage->RemoveNodeEvent.RemoveListener(
mitk::MessageDelegate1<QmitkAbstractNodeSelectionWidget, const mitk::DataNode*>(this, &QmitkAbstractNodeSelectionWidget::NodeRemovedFromStorage));
}
for (auto& node : m_CurrentInternalSelection)
{
this->RemoveNodeObserver(node);
}
}
QmitkAbstractNodeSelectionWidget::NodeList QmitkAbstractNodeSelectionWidget::GetSelectedNodes() const
{
return this->CompileEmitSelection();
}
QmitkAbstractNodeSelectionWidget::ConstNodeStdVector QmitkAbstractNodeSelectionWidget::GetSelectedNodesStdVector() const
{
auto result = this->GetSelectedNodes();
return ConstNodeStdVector(result.begin(), result.end());
}
void QmitkAbstractNodeSelectionWidget::SetDataStorage(mitk::DataStorage* dataStorage)
{
if (m_DataStorage == dataStorage)
{
return;
}
auto oldStorage = m_DataStorage.Lock();
if (oldStorage.IsNotNull())
{
// remove Listener for the data storage itself
oldStorage->RemoveObserver(m_DataStorageDeletedTag);
// remove "add node listener" from old data storage
oldStorage->AddNodeEvent.RemoveListener(
mitk::MessageDelegate1<QmitkAbstractNodeSelectionWidget, const mitk::DataNode*>(this, &QmitkAbstractNodeSelectionWidget::NodeAddedToStorage));
// remove "remove node listener" from old data storage
oldStorage->RemoveNodeEvent.RemoveListener(
mitk::MessageDelegate1<QmitkAbstractNodeSelectionWidget, const mitk::DataNode*>(this, &QmitkAbstractNodeSelectionWidget::NodeRemovedFromStorage));
}
m_DataStorage = dataStorage;
auto newStorage = m_DataStorage.Lock();
if (newStorage.IsNotNull())
{
// add Listener for the data storage itself
auto command = itk::SimpleMemberCommand<QmitkAbstractNodeSelectionWidget>::New();
command->SetCallbackFunction(this, &QmitkAbstractNodeSelectionWidget::SetDataStorageDeleted);
m_DataStorageDeletedTag = newStorage->AddObserver(itk::DeleteEvent(), command);
// add "add node listener" for new data storage
newStorage->AddNodeEvent.AddListener(
mitk::MessageDelegate1<QmitkAbstractNodeSelectionWidget, const mitk::DataNode*>(this, &QmitkAbstractNodeSelectionWidget::NodeAddedToStorage));
// add remove node listener for new data storage
newStorage->RemoveNodeEvent.AddListener(
mitk::MessageDelegate1<QmitkAbstractNodeSelectionWidget, const mitk::DataNode*>(this, &QmitkAbstractNodeSelectionWidget::NodeRemovedFromStorage));
}
this->OnDataStorageChanged();
this->HandleChangeOfInternalSelection({});
}
void QmitkAbstractNodeSelectionWidget::SetNodePredicate(const mitk::NodePredicateBase* nodePredicate)
{
if (m_NodePredicate != nodePredicate)
{
m_NodePredicate = nodePredicate;
this->OnNodePredicateChanged();
NodeList newInternalNodes;
for (auto& node : m_CurrentInternalSelection)
{
if (m_NodePredicate.IsNull() || m_NodePredicate->CheckNode(node))
{
newInternalNodes.append(node);
}
}
if (!m_SelectOnlyVisibleNodes)
{
for (auto& node : m_CurrentExternalSelection)
{
if (!newInternalNodes.contains(node) && (m_NodePredicate.IsNull() || m_NodePredicate->CheckNode(node)))
{
newInternalNodes.append(node);
}
}
}
this->HandleChangeOfInternalSelection(newInternalNodes);
}
}
void QmitkAbstractNodeSelectionWidget::HandleChangeOfInternalSelection(NodeList newInternalSelection)
{
if (!EqualNodeSelections(m_CurrentInternalSelection, newInternalSelection))
{
this->ReviseSelectionChanged(m_CurrentInternalSelection, newInternalSelection);
this->SetCurrentInternalSelection(newInternalSelection);
this->OnInternalSelectionChanged();
auto newEmission = this->CompileEmitSelection();
this->EmitSelection(newEmission);
this->UpdateInfo();
}
}
void QmitkAbstractNodeSelectionWidget::SetCurrentSelection(NodeList selectedNodes)
{
if (!m_RecursionGuard)
{
m_CurrentExternalSelection = selectedNodes;
auto dataStorage = m_DataStorage.Lock();
NodeList newInternalSelection;
- for (auto node : selectedNodes)
+ for (const auto &node : qAsConst(selectedNodes))
{
if (dataStorage.IsNotNull() && dataStorage->Exists(node) && (m_NodePredicate.IsNull() || m_NodePredicate->CheckNode(node)))
{
newInternalSelection.append(node);
}
}
this->HandleChangeOfInternalSelection(newInternalSelection);
}
}
const mitk::NodePredicateBase* QmitkAbstractNodeSelectionWidget::GetNodePredicate() const
{
return m_NodePredicate;
}
QString QmitkAbstractNodeSelectionWidget::GetInvalidInfo() const
{
return m_InvalidInfo;
}
QString QmitkAbstractNodeSelectionWidget::GetEmptyInfo() const
{
return m_EmptyInfo;
}
QString QmitkAbstractNodeSelectionWidget::GetPopUpTitel() const
{
return m_PopUpTitel;
}
QString QmitkAbstractNodeSelectionWidget::GetPopUpHint() const
{
return m_PopUpHint;
}
bool QmitkAbstractNodeSelectionWidget::GetSelectionIsOptional() const
{
return m_IsOptional;
}
bool QmitkAbstractNodeSelectionWidget::GetSelectOnlyVisibleNodes() const
{
return m_SelectOnlyVisibleNodes;
}
void QmitkAbstractNodeSelectionWidget::SetSelectOnlyVisibleNodes(bool selectOnlyVisibleNodes)
{
if (m_SelectOnlyVisibleNodes != selectOnlyVisibleNodes)
{
m_SelectOnlyVisibleNodes = selectOnlyVisibleNodes;
auto newEmission = this->CompileEmitSelection();
this->EmitSelection(newEmission);
}
}
void QmitkAbstractNodeSelectionWidget::SetInvalidInfo(QString info)
{
m_InvalidInfo = info;
this->UpdateInfo();
}
void QmitkAbstractNodeSelectionWidget::SetEmptyInfo(QString info)
{
m_EmptyInfo = info;
this->UpdateInfo();
}
void QmitkAbstractNodeSelectionWidget::SetPopUpTitel(QString info)
{
m_PopUpTitel = info;
}
void QmitkAbstractNodeSelectionWidget::SetPopUpHint(QString info)
{
m_PopUpHint = info;
}
void QmitkAbstractNodeSelectionWidget::SetSelectionIsOptional(bool isOptional)
{
m_IsOptional = isOptional;
this->UpdateInfo();
}
void QmitkAbstractNodeSelectionWidget::SetDataStorageDeleted()
{
this->OnDataStorageChanged();
this->HandleChangeOfInternalSelection({});
}
void QmitkAbstractNodeSelectionWidget::ReviseSelectionChanged(const NodeList& /*oldInternalSelection*/, NodeList& /*newInternalSelection*/)
{
}
bool QmitkAbstractNodeSelectionWidget::AllowEmissionOfSelection(const NodeList& /*emissionCandidates*/) const
{
return true;
}
void QmitkAbstractNodeSelectionWidget::EmitSelection(const NodeList& emissionCandidates)
{
m_LastEmissionAllowance = this->AllowEmissionOfSelection(emissionCandidates);
if (m_LastEmissionAllowance && !EqualNodeSelections(m_LastEmission, emissionCandidates))
{
m_RecursionGuard = true;
emit CurrentSelectionChanged(emissionCandidates);
m_RecursionGuard = false;
m_LastEmission = emissionCandidates;
}
}
void QmitkAbstractNodeSelectionWidget::SetCurrentInternalSelection(NodeList selectedNodes)
{
for (auto& node : m_CurrentInternalSelection)
{
this->RemoveNodeObserver(node);
}
m_CurrentInternalSelection = selectedNodes;
for (auto& node : m_CurrentInternalSelection)
{
this->AddNodeObserver(node);
}
}
const QmitkAbstractNodeSelectionWidget::NodeList& QmitkAbstractNodeSelectionWidget::GetCurrentInternalSelection() const
{
return m_CurrentInternalSelection;
}
const QmitkAbstractNodeSelectionWidget::NodeList& QmitkAbstractNodeSelectionWidget::GetCurrentExternalSelection() const
{
return m_CurrentExternalSelection;
}
void QmitkAbstractNodeSelectionWidget::OnNodePredicateChanged()
{
}
void QmitkAbstractNodeSelectionWidget::OnDataStorageChanged()
{
}
void QmitkAbstractNodeSelectionWidget::OnInternalSelectionChanged()
{
}
void QmitkAbstractNodeSelectionWidget::NodeAddedToStorage(const mitk::DataNode* node)
{
this->OnNodeAddedToStorage(node);
}
void QmitkAbstractNodeSelectionWidget::OnNodeAddedToStorage(const mitk::DataNode* /*node*/)
{
}
void QmitkAbstractNodeSelectionWidget::NodeRemovedFromStorage(const mitk::DataNode* node)
{
this->OnNodeRemovedFromStorage(node);
this->RemoveNodeFromSelection(node);
}
void QmitkAbstractNodeSelectionWidget::OnNodeRemovedFromStorage(const mitk::DataNode* /*node*/)
{
}
QmitkAbstractNodeSelectionWidget::NodeList QmitkAbstractNodeSelectionWidget::CompileEmitSelection() const
{
NodeList result = m_CurrentInternalSelection;
if (!m_SelectOnlyVisibleNodes)
{
- for (auto node : m_CurrentExternalSelection)
+ for (const auto &node : m_CurrentExternalSelection)
{
if (!result.contains(node) && m_NodePredicate.IsNotNull() && !m_NodePredicate->CheckNode(node))
{
result.append(node);
}
}
}
return result;
}
void QmitkAbstractNodeSelectionWidget::RemoveNodeFromSelection(const mitk::DataNode* node)
{
auto newSelection = m_CurrentInternalSelection;
auto finding = std::find(std::begin(newSelection), std::end(newSelection), node);
if (finding != std::end(newSelection))
{
newSelection.erase(finding);
this->HandleChangeOfInternalSelection(newSelection);
}
}
void QmitkAbstractNodeSelectionWidget::OnNodeModified(const itk::Object * caller, const itk::EventObject & event)
{
if (itk::ModifiedEvent().CheckEvent(&event))
{
auto node = dynamic_cast<const mitk::DataNode*>(caller);
if (node)
{
if (m_NodePredicate.IsNotNull() && !m_NodePredicate->CheckNode(node))
{
this->RemoveNodeFromSelection(node);
}
else
{
auto oldAllowance = m_LastEmissionAllowance;
auto newEmission = this->CompileEmitSelection();
auto nonConstNode = const_cast<mitk::DataNode*>(node);
if (newEmission.contains(nonConstNode) && (oldAllowance != this->AllowEmissionOfSelection(newEmission)))
{
this->EmitSelection(newEmission);
this->UpdateInfo();
}
}
}
}
}
void QmitkAbstractNodeSelectionWidget::AddNodeObserver(mitk::DataNode* node)
{
if (node)
{
auto modifiedCommand = itk::MemberCommand<QmitkAbstractNodeSelectionWidget>::New();
modifiedCommand->SetCallbackFunction(this, &QmitkAbstractNodeSelectionWidget::OnNodeModified);
auto nodeModifiedObserverTag = node->AddObserver(itk::ModifiedEvent(), modifiedCommand);
m_NodeObserverTags.insert(std::make_pair(node, nodeModifiedObserverTag));
}
}
void QmitkAbstractNodeSelectionWidget::RemoveNodeObserver(mitk::DataNode* node)
{
if (node)
{
auto finding = m_NodeObserverTags.find(node);
if (finding != std::end(m_NodeObserverTags))
{
node->RemoveObserver(finding->second);
}
else
{
MITK_ERROR << "Selection widget is in a wrong state. A node should be removed from the internal selection but seems to have no observer. Node:" << node;
}
m_NodeObserverTags.erase(node);
}
}
diff --git a/Modules/QtWidgets/src/QmitkDataStorageFavoriteNodesInspector.cpp b/Modules/QtWidgets/src/QmitkDataStorageFavoriteNodesInspector.cpp
index f64a2a8146..271e19c06d 100644
--- a/Modules/QtWidgets/src/QmitkDataStorageFavoriteNodesInspector.cpp
+++ b/Modules/QtWidgets/src/QmitkDataStorageFavoriteNodesInspector.cpp
@@ -1,55 +1,55 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <QmitkDataStorageFavoriteNodesInspector.h>
#include "QmitkDataStorageDefaultListModel.h"
#include "mitkNodePredicateAnd.h"
#include "QPushButton"
#include "QmitkStyleManager.h"
QmitkDataStorageFavoriteNodesInspector::QmitkDataStorageFavoriteNodesInspector(QWidget* parent/* = nullptr*/)
: QmitkDataStorageListInspector(parent)
{
auto favoriteNodesButton = new QPushButton(parent);
QmitkDataStorageListInspector::m_Controls.verticalLayout->addWidget(favoriteNodesButton, 0, Qt::AlignRight);
favoriteNodesButton->setIcon(QmitkStyleManager::ThemeIcon(QStringLiteral(":/Qmitk/favorite_remove.svg")));
favoriteNodesButton->setIconSize(QSize(24, 24));
favoriteNodesButton->setToolTip("Remove selected nodes as favorite");
m_FavoriteNodeSelectionPredicate = mitk::NodePredicateProperty::New("org.mitk.selection.favorite", mitk::BoolProperty::New(true));
m_NodePredicate = m_FavoriteNodeSelectionPredicate;
connect(favoriteNodesButton, &QPushButton::clicked, this, &QmitkDataStorageFavoriteNodesInspector::OnFavoriteNodesButtonClicked);
}
void QmitkDataStorageFavoriteNodesInspector::SetNodePredicate(const mitk::NodePredicateBase* nodePredicate)
{
mitk::NodePredicateAnd::Pointer combinedPredicate = mitk::NodePredicateAnd::New();
combinedPredicate->AddPredicate(m_FavoriteNodeSelectionPredicate);
combinedPredicate->AddPredicate(nodePredicate);
QmitkDataStorageListInspector::SetNodePredicate(combinedPredicate);
}
void QmitkDataStorageFavoriteNodesInspector::OnFavoriteNodesButtonClicked()
{
auto selectedNodes = GetSelectedNodes();
- for (auto node : selectedNodes)
+ for (auto node : qAsConst(selectedNodes))
{
node->SetBoolProperty("org.mitk.selection.favorite", false);
}
}
diff --git a/Modules/QtWidgets/src/QmitkIOUtil.cpp b/Modules/QtWidgets/src/QmitkIOUtil.cpp
index 3754154f2e..f25869f0e2 100644
--- a/Modules/QtWidgets/src/QmitkIOUtil.cpp
+++ b/Modules/QtWidgets/src/QmitkIOUtil.cpp
@@ -1,586 +1,586 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkIOUtil.h"
#include "mitkCoreServices.h"
#include "mitkCustomMimeType.h"
#include "mitkFileReaderRegistry.h"
#include "mitkFileWriterRegistry.h"
#include "mitkIMimeTypeProvider.h"
#include "mitkMimeType.h"
#include <mitkCoreObjectFactory.h>
#include <mitkIOUtil.h>
#include "QmitkFileReaderOptionsDialog.h"
#include "QmitkFileWriterOptionsDialog.h"
// QT
#include <QDebug>
#include <QFileDialog>
#include <QMessageBox>
#include <QSet>
#include <QString>
// ITK
#include <itksys/SystemTools.hxx>
#include <algorithm>
struct QmitkIOUtil::Impl
{
struct ReaderOptionsDialogFunctor : public ReaderOptionsFunctorBase
{
bool operator()(LoadInfo &loadInfo) const override
{
QmitkFileReaderOptionsDialog dialog(loadInfo);
if (dialog.exec() == QDialog::Accepted)
{
return !dialog.ReuseOptions();
}
else
{
loadInfo.m_Cancel = true;
return true;
}
}
};
struct WriterOptionsDialogFunctor : public WriterOptionsFunctorBase
{
bool operator()(SaveInfo &saveInfo) const override
{
QmitkFileWriterOptionsDialog dialog(saveInfo);
if (dialog.exec() == QDialog::Accepted)
{
return !dialog.ReuseOptions();
}
else
{
saveInfo.m_Cancel = true;
return true;
}
}
};
//! Filename characters that are not valid - depending on the platform (Windows, Posix)
static QString s_InvalidFilenameCharacters;
//! Return 'true' when:
//! - the specified filename contains characters not accepted by the file system (see s_InvalidFilenameCharacters)
//! - filename starts or ends in space characters
//!
//! This test is not exhaustive but just excluding the most common problems.
static bool IsIllegalFilename(const QString &fullFilename)
{
QFileInfo fi(fullFilename);
auto filename = fi.fileName();
- for (const auto &ch : s_InvalidFilenameCharacters)
+ for (const auto &ch : qAsConst(s_InvalidFilenameCharacters))
{
if (filename.contains(ch))
{
return true;
}
}
if (filename.startsWith(' ' || filename.endsWith(' ')))
{
return true;
}
return false;
}
}; // Impl
#if defined(_WIN32) || defined(_WIN64)
QString QmitkIOUtil::Impl::s_InvalidFilenameCharacters = "<>:\"/\\|?*";
#else
QString QmitkIOUtil::Impl::s_InvalidFilenameCharacters = "/";
#endif
struct MimeTypeComparison : public std::unary_function<mitk::MimeType, bool>
{
MimeTypeComparison(const std::string &mimeTypeName) : m_Name(mimeTypeName) {}
bool operator()(const mitk::MimeType &mimeType) const { return mimeType.GetName() == m_Name; }
const std::string m_Name;
};
QString QmitkIOUtil::GetFileOpenFilterString()
{
QString filters;
mitk::CoreServicePointer<mitk::IMimeTypeProvider> mimeTypeProvider(mitk::CoreServices::GetMimeTypeProvider());
std::vector<std::string> categories = mimeTypeProvider->GetCategories();
for (std::vector<std::string>::iterator cat = categories.begin(); cat != categories.end(); ++cat)
{
QSet<QString> filterExtensions;
std::vector<mitk::MimeType> mimeTypes = mimeTypeProvider->GetMimeTypesForCategory(*cat);
for (std::vector<mitk::MimeType>::iterator mt = mimeTypes.begin(); mt != mimeTypes.end(); ++mt)
{
std::vector<std::string> extensions = mt->GetExtensions();
for (std::vector<std::string>::iterator ext = extensions.begin(); ext != extensions.end(); ++ext)
{
filterExtensions << QString::fromStdString(*ext);
}
}
QString filter = QString::fromStdString(*cat) + " (";
foreach (const QString &extension, filterExtensions)
{
filter += "*." + extension + " ";
}
filter = filter.replace(filter.size() - 1, 1, ')');
filters += ";;" + filter;
}
filters.prepend("All (*)");
return filters;
}
QList<mitk::BaseData::Pointer> QmitkIOUtil::Load(const QStringList &paths, QWidget *parent)
{
std::vector<LoadInfo> loadInfos;
foreach (const QString &file, paths)
{
loadInfos.push_back(LoadInfo(file.toLocal8Bit().constData()));
}
Impl::ReaderOptionsDialogFunctor optionsCallback;
std::string errMsg = Load(loadInfos, nullptr, nullptr, &optionsCallback);
if (!errMsg.empty())
{
QMessageBox::warning(parent, "Error reading files", QString::fromStdString(errMsg));
mitkThrow() << errMsg;
}
QList<mitk::BaseData::Pointer> qResult;
for (std::vector<LoadInfo>::const_iterator iter = loadInfos.begin(), iterEnd = loadInfos.end(); iter != iterEnd;
++iter)
{
for (const auto &elem : iter->m_Output)
{
qResult << elem;
}
}
return qResult;
}
mitk::DataStorage::SetOfObjects::Pointer QmitkIOUtil::Load(const QStringList &paths,
mitk::DataStorage &storage,
QWidget *parent)
{
std::vector<LoadInfo> loadInfos;
foreach (const QString &file, paths)
{
loadInfos.push_back(LoadInfo(file.toLocal8Bit().constData()));
}
mitk::DataStorage::SetOfObjects::Pointer nodeResult = mitk::DataStorage::SetOfObjects::New();
Impl::ReaderOptionsDialogFunctor optionsCallback;
std::string errMsg = Load(loadInfos, nodeResult, &storage, &optionsCallback);
if (!errMsg.empty())
{
QMessageBox::warning(parent, "Error reading files", QString::fromStdString(errMsg));
}
return nodeResult;
}
QList<mitk::BaseData::Pointer> QmitkIOUtil::Load(const QString &path, QWidget *parent)
{
QStringList paths;
paths << path;
return Load(paths, parent);
}
mitk::DataStorage::SetOfObjects::Pointer QmitkIOUtil::Load(const QString &path,
mitk::DataStorage &storage,
QWidget *parent)
{
QStringList paths;
paths << path;
return Load(paths, storage, parent);
}
QString QmitkIOUtil::Save(const mitk::BaseData *data,
const QString &defaultBaseName,
const QString &defaultPath,
QWidget *parent,
bool setPathProperty)
{
std::vector<const mitk::BaseData *> dataVector;
dataVector.push_back(data);
QStringList defaultBaseNames;
defaultBaseNames.push_back(defaultBaseName);
return Save(dataVector, defaultBaseNames, defaultPath, parent, setPathProperty).back();
}
QStringList QmitkIOUtil::Save(const std::vector<const mitk::BaseData *> &data,
const QStringList &defaultBaseNames,
const QString &defaultPath,
QWidget *parent,
bool setPathProperty)
{
QStringList fileNames;
QString currentPath = defaultPath;
std::vector<SaveInfo> saveInfos;
int counter = 0;
for (std::vector<const mitk::BaseData *>::const_iterator dataIter = data.begin(), dataIterEnd = data.end();
dataIter != dataIterEnd;
++dataIter, ++counter)
{
SaveInfo saveInfo(*dataIter, mitk::MimeType(), std::string());
SaveFilter filters(saveInfo);
// If there is only the "__all__" filter string, it means there is no writer for this base data
if (filters.Size() < 2)
{
QMessageBox::warning(
parent,
"Saving not possible",
QString("No writer available for type \"%1\"").arg(QString::fromStdString((*dataIter)->GetNameOfClass())));
continue;
}
// Construct a default path and file name
QString filterString = filters.ToString();
QString selectedFilter = filters.GetDefaultFilter();
QString fileName = currentPath;
QString dialogTitle = "Save " + QString::fromStdString((*dataIter)->GetNameOfClass());
if (counter < defaultBaseNames.size())
{
dialogTitle += " \"" + defaultBaseNames[counter] + "\"";
fileName += QDir::separator() + defaultBaseNames[counter];
// We do not append an extension to the file name by default. The extension
// is chosen by the user by either selecting a filter or writing the
// extension in the file name himself (in the file save dialog).
/*
QString defaultExt = filters.GetDefaultExtension();
if (!defaultExt.isEmpty())
{
fileName += "." + defaultExt;
}
*/
}
// Ask the user for a file name
QString nextName = QFileDialog::getSaveFileName(parent, dialogTitle, fileName, filterString, &selectedFilter);
if (Impl::IsIllegalFilename(nextName))
{
QMessageBox::warning(
parent,
"Saving not possible",
QString("File \"%2\" contains invalid characters.\n\nPlease avoid any of \"%1\"")
.arg(Impl::s_InvalidFilenameCharacters.split("", QString::SkipEmptyParts).join(" "))
.arg(nextName));
continue;
}
if (nextName.isEmpty())
{
// We stop asking for further file names, but we still save the
// data where the user already confirmed the save dialog.
break;
}
fileName = nextName;
std::string stdFileName = fileName.toLocal8Bit().constData();
QFileInfo fileInfo(fileName);
currentPath = fileInfo.absolutePath();
QString suffix = fileInfo.completeSuffix();
mitk::MimeType filterMimeType = filters.GetMimeTypeForFilter(selectedFilter);
mitk::MimeType selectedMimeType;
if (fileInfo.exists() && !fileInfo.isFile())
{
QMessageBox::warning(parent, "Saving not possible", QString("The path \"%1\" is not a file").arg(fileName));
continue;
}
// Theoretically, the user could have entered an extension that does not match the selected filter
// The extension then has prioritry over the filter
// Check if one of the available mime-types match the filename
std::vector<mitk::MimeType> filterMimeTypes = filters.GetMimeTypes();
for (std::vector<mitk::MimeType>::const_iterator mimeTypeIter = filterMimeTypes.begin(),
mimeTypeIterEnd = filterMimeTypes.end();
mimeTypeIter != mimeTypeIterEnd;
++mimeTypeIter)
{
if (mimeTypeIter->MatchesExtension(stdFileName))
{
selectedMimeType = *mimeTypeIter;
break;
}
}
if (!selectedMimeType.IsValid())
{
// The file name either does not contain an extension or the
// extension is unknown.
// If the file already exists, we stop here because we are unable
// to (over)write the file without adding a custom suffix. If the file
// does not exist, we add the default extension from the currently
// selected filter. If the "All" filter was selected, we only add the
// default extensions if the file name itself does not already contain
// an extension.
if (!fileInfo.exists())
{
if (filterMimeType == SaveFilter::ALL_MIMETYPE())
{
if (suffix.isEmpty())
{
// Use the highest ranked mime-type from the list
selectedMimeType = filters.GetDefaultMimeType();
}
}
else
{
selectedMimeType = filterMimeType;
}
if (selectedMimeType.IsValid())
{
suffix = QString::fromStdString(selectedMimeType.GetExtensions().front());
fileName += "." + suffix;
stdFileName = fileName.toLocal8Bit().constData();
// We changed the file name (added a suffix) so ask in case
// the file aready exists.
fileInfo = QFileInfo(fileName);
if (fileInfo.exists())
{
if (!fileInfo.isFile())
{
QMessageBox::warning(
parent, "Saving not possible", QString("The path \"%1\" is not a file").arg(fileName));
continue;
}
if (QMessageBox::question(
parent,
"Replace File",
QString("A file named \"%1\" already exists. Do you want to replace it?").arg(fileName)) ==
QMessageBox::No)
{
continue;
}
}
}
}
}
if (!selectedMimeType.IsValid())
{
// The extension/filename is not valid (no mime-type found), bail out
QMessageBox::warning(
parent, "Saving not possible", QString("No mime-type available which can handle \"%1\".").arg(fileName));
continue;
}
if (!QFileInfo(fileInfo.absolutePath()).isWritable())
{
QMessageBox::warning(parent, "Saving not possible", QString("The path \"%1\" is not writable").arg(fileName));
continue;
}
fileNames.push_back(fileName);
saveInfo.m_Path = stdFileName;
saveInfo.m_MimeType = selectedMimeType;
// pre-select the best writer for the chosen mime-type
saveInfo.m_WriterSelector.Select(selectedMimeType.GetName());
saveInfos.push_back(saveInfo);
}
if (!saveInfos.empty())
{
Impl::WriterOptionsDialogFunctor optionsCallback;
std::string errMsg = Save(saveInfos, &optionsCallback, setPathProperty);
if (!errMsg.empty())
{
QMessageBox::warning(parent, "Error writing files", QString::fromStdString(errMsg));
mitkThrow() << errMsg;
}
}
return fileNames;
}
void QmitkIOUtil::SaveBaseDataWithDialog(mitk::BaseData *data, std::string fileName, QWidget * /*parent*/)
{
Save(data, fileName);
}
void QmitkIOUtil::SaveSurfaceWithDialog(mitk::Surface::Pointer surface, std::string fileName, QWidget * /*parent*/)
{
Save(surface, fileName);
}
void QmitkIOUtil::SaveImageWithDialog(mitk::Image::Pointer image, std::string fileName, QWidget * /*parent*/)
{
Save(image, fileName);
}
void QmitkIOUtil::SavePointSetWithDialog(mitk::PointSet::Pointer pointset, std::string fileName, QWidget * /*parent*/)
{
Save(pointset, fileName);
}
struct QmitkIOUtil::SaveFilter::Impl
{
Impl(const mitk::IOUtil::SaveInfo &saveInfo) : m_SaveInfo(saveInfo)
{
// Add an artifical filter for "All"
m_MimeTypes.push_back(ALL_MIMETYPE());
m_FilterStrings.push_back("All (*.*)");
// Get all writers and their mime types for the given base data type
// (this is sorted already)
std::vector<mitk::MimeType> mimeTypes = saveInfo.m_WriterSelector.GetMimeTypes();
for (std::vector<mitk::MimeType>::const_reverse_iterator iter = mimeTypes.rbegin(), iterEnd = mimeTypes.rend();
iter != iterEnd;
++iter)
{
QList<QString> filterExtensions;
mitk::MimeType mimeType = *iter;
std::vector<std::string> extensions = mimeType.GetExtensions();
for (auto &extension : extensions)
{
filterExtensions << QString::fromStdString(extension);
}
if (m_DefaultExtension.isEmpty())
{
m_DefaultExtension = QString::fromStdString(extensions.front());
}
QString filter = QString::fromStdString(mimeType.GetComment()) + " (";
foreach (const QString &extension, filterExtensions)
{
filter += "*." + extension + " ";
}
filter = filter.replace(filter.size() - 1, 1, ')');
m_MimeTypes.push_back(mimeType);
m_FilterStrings.push_back(filter);
}
}
const mitk::IOUtil::SaveInfo m_SaveInfo;
std::vector<mitk::MimeType> m_MimeTypes;
QStringList m_FilterStrings;
QString m_DefaultExtension;
};
mitk::MimeType QmitkIOUtil::SaveFilter::ALL_MIMETYPE()
{
static mitk::CustomMimeType allMimeType(std::string("__all__"));
return mitk::MimeType(allMimeType, -1, -1);
}
QmitkIOUtil::SaveFilter::SaveFilter(const QmitkIOUtil::SaveFilter &other) : d(new Impl(*other.d))
{
}
QmitkIOUtil::SaveFilter::SaveFilter(const SaveInfo &saveInfo) : d(new Impl(saveInfo))
{
}
QmitkIOUtil::SaveFilter &QmitkIOUtil::SaveFilter::operator=(const QmitkIOUtil::SaveFilter &other)
{
d.reset(new Impl(*other.d));
return *this;
}
std::vector<mitk::MimeType> QmitkIOUtil::SaveFilter::GetMimeTypes() const
{
return d->m_MimeTypes;
}
QString QmitkIOUtil::SaveFilter::GetFilterForMimeType(const std::string &mimeType) const
{
std::vector<mitk::MimeType>::const_iterator iter =
std::find_if(d->m_MimeTypes.begin(), d->m_MimeTypes.end(), MimeTypeComparison(mimeType));
if (iter == d->m_MimeTypes.end())
{
return QString();
}
int index = static_cast<int>(iter - d->m_MimeTypes.begin());
if (index < 0 || index >= d->m_FilterStrings.size())
{
return QString();
}
return d->m_FilterStrings[index];
}
mitk::MimeType QmitkIOUtil::SaveFilter::GetMimeTypeForFilter(const QString &filter) const
{
int index = d->m_FilterStrings.indexOf(filter);
if (index < 0)
{
return mitk::MimeType();
}
return d->m_MimeTypes[index];
}
QString QmitkIOUtil::SaveFilter::GetDefaultFilter() const
{
if (d->m_FilterStrings.size() > 1)
{
return d->m_FilterStrings.at(1);
}
else if (d->m_FilterStrings.size() > 0)
{
return d->m_FilterStrings.front();
}
return QString();
}
QString QmitkIOUtil::SaveFilter::GetDefaultExtension() const
{
return d->m_DefaultExtension;
}
mitk::MimeType QmitkIOUtil::SaveFilter::GetDefaultMimeType() const
{
if (d->m_MimeTypes.size() > 1)
{
return d->m_MimeTypes.at(1);
}
else if (d->m_MimeTypes.size() > 0)
{
return d->m_MimeTypes.front();
}
return mitk::MimeType();
}
QString QmitkIOUtil::SaveFilter::ToString() const
{
return d->m_FilterStrings.join(";;");
}
int QmitkIOUtil::SaveFilter::Size() const
{
return d->m_FilterStrings.size();
}
bool QmitkIOUtil::SaveFilter::IsEmpty() const
{
return d->m_FilterStrings.isEmpty();
}
bool QmitkIOUtil::SaveFilter::ContainsMimeType(const std::string &mimeType)
{
return std::find_if(d->m_MimeTypes.begin(), d->m_MimeTypes.end(), MimeTypeComparison(mimeType)) !=
d->m_MimeTypes.end();
}
diff --git a/Modules/QtWidgets/src/QmitkModelViewSelectionConnector.cpp b/Modules/QtWidgets/src/QmitkModelViewSelectionConnector.cpp
index 93a75e0e09..a52e840471 100644
--- a/Modules/QtWidgets/src/QmitkModelViewSelectionConnector.cpp
+++ b/Modules/QtWidgets/src/QmitkModelViewSelectionConnector.cpp
@@ -1,185 +1,185 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
// mitk gui qt common plugin
#include "QmitkModelViewSelectionConnector.h"
// qt widgets module
#include "QmitkCustomVariants.h"
#include "QmitkEnums.h"
QmitkModelViewSelectionConnector::QmitkModelViewSelectionConnector()
: m_Model(nullptr)
, m_View(nullptr)
, m_SelectOnlyVisibleNodes(false)
{
// nothing here
}
void QmitkModelViewSelectionConnector::SetView(QAbstractItemView* view)
{
if (nullptr != m_View)
{
disconnect(m_View->selectionModel(), SIGNAL(selectionChanged(const QItemSelection&, const QItemSelection&)), this, SLOT(ChangeModelSelection(const QItemSelection&, const QItemSelection&)));
}
// reset model-view pair and check for valid function argument
m_View = nullptr;
if (nullptr == view)
{
mitkThrow() << "Invalid item view. To use the model-view selection connector please specify a valid 'QAbstractItemView'.";
}
auto storageModel = dynamic_cast<QmitkAbstractDataStorageModel*>(view->model());
if (storageModel == nullptr)
{
mitkThrow() << "Invalid data model. To use the model-view selection connector please set a valid 'QmitkAbstractDataStorageModel' for the given item view.";
}
// a valid item view and a valid data model was found
m_View = view;
m_Model = storageModel;
connect(m_View->selectionModel(), SIGNAL(selectionChanged(const QItemSelection&, const QItemSelection&)), SLOT(ChangeModelSelection(const QItemSelection&, const QItemSelection&)));
}
void QmitkModelViewSelectionConnector::SetSelectOnlyVisibleNodes(bool selectOnlyVisibleNodes)
{
m_SelectOnlyVisibleNodes = selectOnlyVisibleNodes;
}
void QmitkModelViewSelectionConnector::SetCurrentSelection(QList<mitk::DataNode::Pointer> selectedNodes)
{
if (nullptr == m_Model || nullptr == m_View)
{
return;
}
// filter input nodes and return the modified input node list
QList<mitk::DataNode::Pointer> filteredNodes = FilterNodeList(selectedNodes);
bool equal = EqualNodeSelections(this->GetInternalSelectedNodes(), filteredNodes);
if (equal)
{
return;
}
if (!m_SelectOnlyVisibleNodes)
{
// store the unmodified selection
m_NonVisibleSelection = selectedNodes;
// remove the nodes in the original selection that are already contained in the filtered input node list
// this will keep the selection of the original nodes that are not presented by the current view unmodified, but allows to change the selection of the filtered nodes
// later, the nodes of the 'm_NonVisibleSelection' member have to be added again to the list of selected (filtered) nodes, if a selection is sent from the current view (see 'ModelSelectionChanged')
auto lambda = [&filteredNodes](mitk::DataNode::Pointer original) { return filteredNodes.contains(original); };
m_NonVisibleSelection.erase(std::remove_if(m_NonVisibleSelection.begin(), m_NonVisibleSelection.end(), lambda), m_NonVisibleSelection.end());
}
// create new selection by retrieving the corresponding indices of the (filtered) nodes
QItemSelection newCurrentSelection;
- for (const auto& node : filteredNodes)
+ for (const auto& node : qAsConst(filteredNodes))
{
QModelIndexList matched = m_Model->match(m_Model->index(0, 0), QmitkDataNodeRole, QVariant::fromValue<mitk::DataNode::Pointer>(node), 1, Qt::MatchRecursive);
if (!matched.empty())
{
newCurrentSelection.select(matched.front(), matched.front());
}
}
m_View->selectionModel()->select(newCurrentSelection, QItemSelectionModel::ClearAndSelect);
}
void QmitkModelViewSelectionConnector::ChangeModelSelection(const QItemSelection& /*selected*/, const QItemSelection& /*deselected*/)
{
emit CurrentSelectionChanged(GetSelectedNodes());
}
bool QmitkModelViewSelectionConnector::GetSelectOnlyVisibleNodes() const
{
return m_SelectOnlyVisibleNodes;
}
QList<mitk::DataNode::Pointer> QmitkModelViewSelectionConnector::GetSelectedNodes() const
{
auto nodes = GetInternalSelectedNodes();
if (!m_SelectOnlyVisibleNodes)
{
// add the non-visible nodes from the original selection
nodes.append(m_NonVisibleSelection);
}
return nodes;
}
QList<mitk::DataNode::Pointer> QmitkModelViewSelectionConnector::GetInternalSelectedNodes() const
{
if (nullptr == m_Model || nullptr == m_View)
{
return QList<mitk::DataNode::Pointer>();
}
QList<mitk::DataNode::Pointer> nodes;
QModelIndexList selectedIndexes = m_View->selectionModel()->selectedIndexes();
- for (const auto& index : selectedIndexes)
+ for (const auto& index : qAsConst(selectedIndexes))
{
QVariant qvariantDataNode = m_Model->data(index, QmitkDataNodeRole);
if (qvariantDataNode.canConvert<mitk::DataNode::Pointer>())
{
nodes.push_back(qvariantDataNode.value<mitk::DataNode::Pointer>());
}
}
return nodes;
}
QList<mitk::DataNode::Pointer> QmitkModelViewSelectionConnector::FilterNodeList(const QList<mitk::DataNode::Pointer>& nodes) const
{
if (nodes.isEmpty())
{
return QList<mitk::DataNode::Pointer>();
}
if (nullptr == m_Model)
{
return nodes;
}
auto nodePredicate = m_Model->GetNodePredicate();
if (nullptr == nodePredicate)
{
// no filter set
return nodes;
}
QList<mitk::DataNode::Pointer> result;
for (const auto& node : nodes)
{
if (true == nodePredicate->CheckNode(node))
{
result.push_back(node);
}
}
return result;
}
bool MITKQTWIDGETS_EXPORT EqualNodeSelections(const QList<mitk::DataNode::Pointer>& selection1, const QList<mitk::DataNode::Pointer>& selection2)
{
if (selection1.size() == selection2.size())
{
// lambda to compare node pointer inside both lists
auto lambda = [](mitk::DataNode::Pointer lhs, mitk::DataNode::Pointer rhs) { return lhs == rhs; };
return std::is_permutation(selection1.begin(), selection1.end(), selection2.begin(), selection2.end(), lambda);
}
return false;
}
diff --git a/Modules/QtWidgets/src/QmitkMultiWidgetLayoutSelectionWidget.cpp b/Modules/QtWidgets/src/QmitkMultiWidgetLayoutSelectionWidget.cpp
index 637997248c..0575c4a260 100644
--- a/Modules/QtWidgets/src/QmitkMultiWidgetLayoutSelectionWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkMultiWidgetLayoutSelectionWidget.cpp
@@ -1,76 +1,76 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkMultiWidgetLayoutSelectionWidget.h"
QmitkMultiWidgetLayoutSelectionWidget::QmitkMultiWidgetLayoutSelectionWidget(QWidget* parent/* = 0*/)
: QWidget(parent)
{
Init();
}
void QmitkMultiWidgetLayoutSelectionWidget::Init()
{
ui.setupUi(this);
auto stylesheet = "QTableWidget::item{background-color: white;}\nQTableWidget::item:selected{background-color: #1C97EA;}";
ui.tableWidget->setStyleSheet(stylesheet);
connect(ui.tableWidget, &QTableWidget::itemSelectionChanged, this, &QmitkMultiWidgetLayoutSelectionWidget::OnTableItemSelectionChanged);
connect(ui.setLayoutPushButton, &QPushButton::clicked, this, &QmitkMultiWidgetLayoutSelectionWidget::OnSetLayoutButtonClicked);
}
void QmitkMultiWidgetLayoutSelectionWidget::OnTableItemSelectionChanged()
{
QItemSelectionModel* selectionModel = ui.tableWidget->selectionModel();
int row = 0;
int column = 0;
QModelIndexList indices = selectionModel->selectedIndexes();
if (indices.size() > 0)
{
row = indices[0].row();
column = indices[0].column();
QModelIndex topLeft = ui.tableWidget->model()->index(0, 0, QModelIndex());
QModelIndex bottomRight = ui.tableWidget->model()->index(row, column, QModelIndex());
QItemSelection cellSelection;
cellSelection.select(topLeft, bottomRight);
selectionModel->select(cellSelection, QItemSelectionModel::Select);
}
}
void QmitkMultiWidgetLayoutSelectionWidget::OnSetLayoutButtonClicked()
{
int row = 0;
int column = 0;
QModelIndexList indices = ui.tableWidget->selectionModel()->selectedIndexes();
if (indices.size() > 0)
{
// find largest row and column
- for (const QModelIndex modelIndex : indices)
+ for (const auto& modelIndex : qAsConst(indices))
{
if (modelIndex.row() > row)
{
row = modelIndex.row();
}
if (modelIndex.column() > column)
{
column = modelIndex.column();
}
}
close();
emit LayoutSet(row+1, column+1);
}
}
diff --git a/Modules/QtWidgets/src/QmitkPropertyItemModel.cpp b/Modules/QtWidgets/src/QmitkPropertyItemModel.cpp
index f65d8888e1..66b89810ff 100644
--- a/Modules/QtWidgets/src/QmitkPropertyItemModel.cpp
+++ b/Modules/QtWidgets/src/QmitkPropertyItemModel.cpp
@@ -1,474 +1,474 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkPropertyItemModel.h"
#include "QmitkPropertyItem.h"
#include <QColor>
#include <mitkColorProperty.h>
#include <mitkEnumerationProperty.h>
#include <mitkIPropertyAliases.h>
#include <mitkIPropertyFilters.h>
#include <mitkProperties.h>
#include <mitkRenderingManager.h>
#include <mitkStringProperty.h>
namespace
{
QColor MitkToQt(const mitk::Color& color)
{
return QColor(color.GetRed() * 255, color.GetGreen() * 255, color.GetBlue() * 255);
}
mitk::BaseProperty* GetBaseProperty(const QVariant& data)
{
return data.isValid() ? reinterpret_cast<mitk::BaseProperty*>(data.value<void*>()) : nullptr;
}
mitk::Color QtToMitk(const QColor& color)
{
mitk::Color mitkColor;
mitkColor.SetRed(color.red() / 255.0f);
mitkColor.SetGreen(color.green() / 255.0f);
mitkColor.SetBlue(color.blue() / 255.0f);
return mitkColor;
}
}
class PropertyEqualTo
{
public:
PropertyEqualTo(const mitk::BaseProperty *property) : m_Property(property) {}
bool operator()(const mitk::PropertyList::PropertyMapElementType &pair) const
{
return pair.second.GetPointer() == m_Property;
}
private:
const mitk::BaseProperty *m_Property;
};
QmitkPropertyItemModel::QmitkPropertyItemModel(QObject *parent)
: QAbstractItemModel(parent),
m_PropertyAliases(mitk::CoreServices::GetPropertyAliases()),
m_PropertyFilters(mitk::CoreServices::GetPropertyFilters())
{
this->CreateRootItem();
}
QmitkPropertyItemModel::~QmitkPropertyItemModel()
{
this->SetNewPropertyList(nullptr);
}
int QmitkPropertyItemModel::columnCount(const QModelIndex &parent) const
{
if (parent.isValid())
return static_cast<QmitkPropertyItem *>(parent.internalPointer())->GetColumnCount();
else
return m_RootItem->GetColumnCount();
}
void QmitkPropertyItemModel::CreateRootItem()
{
QList<QVariant> rootData;
rootData << "Property"
<< "Value";
m_RootItem.reset(new QmitkPropertyItem(rootData));
this->beginResetModel();
this->endResetModel();
}
QVariant QmitkPropertyItemModel::data(const QModelIndex &index, int role) const
{
if (!index.isValid())
return QVariant();
mitk::BaseProperty *property =
index.column() == 1 ? GetBaseProperty(static_cast<QmitkPropertyItem *>(index.internalPointer())->GetData(1)) : nullptr;
if (role == Qt::DisplayRole)
{
if (index.column() == 0)
{
return static_cast<QmitkPropertyItem *>(index.internalPointer())->GetData(0);
}
else if (index.column() == 1 && property != nullptr)
{
if (auto colorProperty = dynamic_cast<mitk::ColorProperty *>(property))
return MitkToQt(colorProperty->GetValue());
else if (dynamic_cast<mitk::BoolProperty *>(property) == nullptr)
return QString::fromStdString(property->GetValueAsString());
}
}
else if (index.column() == 1 && property != nullptr)
{
if (role == Qt::CheckStateRole)
{
if (auto boolProperty = dynamic_cast<mitk::BoolProperty *>(property))
return boolProperty->GetValue() ? Qt::Checked : Qt::Unchecked;
}
else if (role == Qt::EditRole)
{
if (dynamic_cast<mitk::StringProperty *>(property) != nullptr)
{
return QString::fromStdString(property->GetValueAsString());
}
else if (auto intProperty = dynamic_cast<mitk::IntProperty *>(property))
{
return intProperty->GetValue();
}
else if (auto floatProperty = dynamic_cast<mitk::FloatProperty *>(property))
{
return floatProperty->GetValue();
}
else if (auto doubleProperty = dynamic_cast<mitk::DoubleProperty *>(property))
{
return doubleProperty->GetValue();
}
else if (auto enumProperty = dynamic_cast<mitk::EnumerationProperty *>(property))
{
QStringList values;
for (mitk::EnumerationProperty::EnumConstIterator it = enumProperty->Begin(); it != enumProperty->End(); it++)
values << QString::fromStdString(it->second);
return values;
}
else if (auto colorProperty = dynamic_cast<mitk::ColorProperty *>(property))
{
return MitkToQt(colorProperty->GetValue());
}
}
else if (role == mitk::PropertyRole)
{
return QVariant::fromValue<void *>(property);
}
}
return QVariant();
}
QModelIndex QmitkPropertyItemModel::FindProperty(const mitk::BaseProperty *property)
{
if (property == nullptr)
return QModelIndex();
if (m_PropertyList.IsExpired())
return QModelIndex();
auto propertyMap = m_PropertyList.Lock()->GetMap();
auto it = std::find_if(propertyMap->begin(), propertyMap->end(), PropertyEqualTo(property));
if (it == propertyMap->end())
return QModelIndex();
QString name = QString::fromStdString(it->first);
if (!name.contains('.'))
{
QModelIndexList item = this->match(index(0, 0), Qt::DisplayRole, name, 1, Qt::MatchExactly);
if (!item.empty())
return item[0];
}
else
{
QStringList names = name.split('.');
QModelIndexList items =
this->match(index(0, 0), Qt::DisplayRole, names.last(), -1, Qt::MatchRecursive | Qt::MatchExactly);
- for (auto item : items)
+ for (auto item : qAsConst(items))
{
QModelIndex candidate = item;
for (int i = names.length() - 1; i != 0; --i)
{
QModelIndex parent = item.parent();
if (parent.parent() == QModelIndex())
{
if (parent.data() != names.first())
break;
return candidate;
}
if (parent.data() != names[i - 1])
break;
item = parent;
}
}
}
return QModelIndex();
}
Qt::ItemFlags QmitkPropertyItemModel::flags(const QModelIndex &index) const
{
Qt::ItemFlags flags = QAbstractItemModel::flags(index);
if (index.column() == 1)
{
if (index.data(Qt::EditRole).isValid())
flags |= Qt::ItemIsEditable;
if (index.data(Qt::CheckStateRole).isValid())
flags |= Qt::ItemIsUserCheckable;
}
return flags;
}
mitk::PropertyList *QmitkPropertyItemModel::GetPropertyList() const
{
return m_PropertyList.Lock().GetPointer();
}
QVariant QmitkPropertyItemModel::headerData(int section, Qt::Orientation orientation, int role) const
{
if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
return m_RootItem->GetData(section);
return QVariant();
}
QModelIndex QmitkPropertyItemModel::index(int row, int column, const QModelIndex &parent) const
{
if (!this->hasIndex(row, column, parent))
return QModelIndex();
QmitkPropertyItem *parentItem =
parent.isValid() ? static_cast<QmitkPropertyItem *>(parent.internalPointer()) : m_RootItem.get();
QmitkPropertyItem *childItem = parentItem->GetChild(row);
return childItem != nullptr ? this->createIndex(row, column, childItem) : QModelIndex();
}
void QmitkPropertyItemModel::OnPropertyListModified()
{
this->SetNewPropertyList(m_PropertyList.Lock());
}
void QmitkPropertyItemModel::OnPropertyListDeleted()
{
this->CreateRootItem();
}
void QmitkPropertyItemModel::OnPropertyModified(const itk::Object *property, const itk::EventObject &)
{
QModelIndex index = this->FindProperty(static_cast<const mitk::BaseProperty *>(property));
if (index != QModelIndex())
emit dataChanged(index, index);
}
QModelIndex QmitkPropertyItemModel::parent(const QModelIndex &child) const
{
if (!child.isValid())
return QModelIndex();
QmitkPropertyItem *parentItem = static_cast<QmitkPropertyItem *>(child.internalPointer())->GetParent();
if (parentItem == m_RootItem.get())
return QModelIndex();
return this->createIndex(parentItem->GetRow(), 0, parentItem);
}
int QmitkPropertyItemModel::rowCount(const QModelIndex &parent) const
{
if (parent.column() > 0)
return 0;
QmitkPropertyItem *parentItem =
parent.isValid() ? static_cast<QmitkPropertyItem *>(parent.internalPointer()) : m_RootItem.get();
return parentItem->GetChildCount();
}
bool QmitkPropertyItemModel::setData(const QModelIndex &index, const QVariant &value, int role)
{
if (!index.isValid() || index.column() != 1 || (role != Qt::EditRole && role != Qt::CheckStateRole))
return false;
mitk::BaseProperty *property = GetBaseProperty(static_cast<QmitkPropertyItem *>(index.internalPointer())->GetData(1));
if (property == nullptr)
return false;
if (mitk::BoolProperty *boolProperty = dynamic_cast<mitk::BoolProperty *>(property))
{
boolProperty->SetValue(value.toInt() == Qt::Checked ? true : false);
}
else if (mitk::StringProperty *stringProperty = dynamic_cast<mitk::StringProperty *>(property))
{
stringProperty->SetValue(value.toString().toStdString());
}
else if (mitk::IntProperty *intProperty = dynamic_cast<mitk::IntProperty *>(property))
{
intProperty->SetValue(value.toInt());
}
else if (mitk::FloatProperty *floatProperty = dynamic_cast<mitk::FloatProperty *>(property))
{
floatProperty->SetValue(value.toFloat());
}
else if (mitk::DoubleProperty *doubleProperty = dynamic_cast<mitk::DoubleProperty *>(property))
{
doubleProperty->SetValue(value.toDouble());
}
else if (mitk::EnumerationProperty *enumProperty = dynamic_cast<mitk::EnumerationProperty *>(property))
{
std::string selection = value.toString().toStdString();
if (selection != enumProperty->GetValueAsString() && enumProperty->IsValidEnumerationValue(selection))
enumProperty->SetValue(selection);
}
else if (mitk::ColorProperty *colorProperty = dynamic_cast<mitk::ColorProperty *>(property))
{
colorProperty->SetValue(QtToMitk(value.value<QColor>()));
}
auto propertyList = m_PropertyList.Lock();
propertyList->Modified();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
return true;
}
void QmitkPropertyItemModel::SetNewPropertyList(mitk::PropertyList *newPropertyList)
{
typedef mitk::PropertyList::PropertyMap PropertyMap;
this->beginResetModel();
if (!m_PropertyList.IsExpired())
{
auto propertyList = m_PropertyList.Lock();
propertyList->RemoveObserver(m_PropertyListDeletedTag);
propertyList->RemoveObserver(m_PropertyListModifiedTag);
const PropertyMap *propertyMap = m_PropertyList.Lock()->GetMap();
for (PropertyMap::const_iterator propertyIt = propertyMap->begin(); propertyIt != propertyMap->end(); ++propertyIt)
{
std::map<std::string, unsigned long>::const_iterator tagIt = m_PropertyModifiedTags.find(propertyIt->first);
if (tagIt != m_PropertyModifiedTags.end())
propertyIt->second->RemoveObserver(tagIt->second);
tagIt = m_PropertyDeletedTags.find(propertyIt->first);
if (tagIt != m_PropertyDeletedTags.end())
propertyIt->second->RemoveObserver(tagIt->second);
}
m_PropertyModifiedTags.clear();
m_PropertyDeletedTags.clear();
}
m_PropertyList = newPropertyList;
if (!m_PropertyList.IsExpired())
{
auto onPropertyListModified = itk::SimpleMemberCommand<QmitkPropertyItemModel>::New();
onPropertyListModified->SetCallbackFunction(this, &QmitkPropertyItemModel::OnPropertyListModified);
m_PropertyListModifiedTag = m_PropertyList.Lock()->AddObserver(itk::ModifiedEvent(), onPropertyListModified);
auto onPropertyListDeleted = itk::SimpleMemberCommand<QmitkPropertyItemModel>::New();
onPropertyListDeleted->SetCallbackFunction(this, &QmitkPropertyItemModel::OnPropertyListDeleted);
m_PropertyListDeletedTag = m_PropertyList.Lock()->AddObserver(itk::DeleteEvent(), onPropertyListDeleted);
auto modifiedCommand = itk::MemberCommand<QmitkPropertyItemModel>::New();
modifiedCommand->SetCallbackFunction(this, &QmitkPropertyItemModel::OnPropertyModified);
const PropertyMap *propertyMap = m_PropertyList.Lock()->GetMap();
for (PropertyMap::const_iterator it = propertyMap->begin(); it != propertyMap->end(); ++it)
m_PropertyModifiedTags.insert(
std::make_pair(it->first, it->second->AddObserver(itk::ModifiedEvent(), modifiedCommand)));
}
this->CreateRootItem();
if (m_PropertyList != nullptr && !m_PropertyList.Lock()->IsEmpty())
{
mitk::PropertyList::PropertyMap filteredProperties;
bool filterProperties = false;
if (m_PropertyFilters->HasFilter() || m_PropertyFilters->HasFilter(m_ClassName.toStdString()))
{
filteredProperties = m_PropertyFilters->ApplyFilter(*m_PropertyList.Lock()->GetMap(), m_ClassName.toStdString());
filterProperties = true;
}
const mitk::PropertyList::PropertyMap *propertyMap =
!filterProperties ? m_PropertyList.Lock()->GetMap() : &filteredProperties;
mitk::PropertyList::PropertyMap::const_iterator end = propertyMap->end();
for (mitk::PropertyList::PropertyMap::const_iterator iter = propertyMap->begin(); iter != end; ++iter)
{
std::vector<std::string> aliases;
aliases = m_PropertyAliases->GetAliases(iter->first, m_ClassName.toStdString());
if (aliases.empty() && !m_ClassName.isEmpty())
aliases = m_PropertyAliases->GetAliases(iter->first);
if (aliases.empty())
{
QList<QVariant> data;
data << QString::fromStdString(iter->first)
<< QVariant::fromValue((reinterpret_cast<void *>(iter->second.GetPointer())));
m_RootItem->AppendChild(new QmitkPropertyItem(data));
}
else
{
std::vector<std::string>::const_iterator end = aliases.end();
for (std::vector<std::string>::const_iterator aliasIter = aliases.begin(); aliasIter != end; ++aliasIter)
{
QList<QVariant> data;
data << QString::fromStdString(*aliasIter)
<< QVariant::fromValue((reinterpret_cast<void *>(iter->second.GetPointer())));
m_RootItem->AppendChild(new QmitkPropertyItem(data));
}
}
}
}
this->endResetModel();
}
void QmitkPropertyItemModel::SetPropertyList(mitk::PropertyList *propertyList, const QString &className)
{
if (m_PropertyList != propertyList)
{
m_ClassName = className;
this->SetNewPropertyList(propertyList);
}
}
void QmitkPropertyItemModel::Update()
{
this->SetNewPropertyList(m_PropertyList.Lock());
}
diff --git a/Modules/QtWidgets/src/mitkDataStorageInspectorGenerator.cpp b/Modules/QtWidgets/src/mitkDataStorageInspectorGenerator.cpp
index fad908465e..9f1ab8d13c 100644
--- a/Modules/QtWidgets/src/mitkDataStorageInspectorGenerator.cpp
+++ b/Modules/QtWidgets/src/mitkDataStorageInspectorGenerator.cpp
@@ -1,57 +1,57 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "usModuleContext.h"
#include "usGetModuleContext.h"
#include "mitkLogMacros.h"
#include "mitkDataStorageInspectorGenerator.h"
mitk::IDataStorageInspectorProvider* mitk::DataStorageInspectorGenerator::GetProvider(const IDType& id)
{
mitk::IDataStorageInspectorProvider* result = nullptr;
std::string filter = "(" + mitk::IDataStorageInspectorProvider::PROP_INSPECTOR_ID() + "=" + id + ")";
std::vector<us::ServiceReference<mitk::IDataStorageInspectorProvider> > providerRegisters = us::GetModuleContext()->GetServiceReferences<mitk::IDataStorageInspectorProvider>(filter);
if (!providerRegisters.empty())
{
if (providerRegisters.size() > 1)
{
MITK_WARN << "Multiple provider for class id'" << id << "' found. Using just one.";
}
result = us::GetModuleContext()->GetService<mitk::IDataStorageInspectorProvider>(providerRegisters.front());
}
return result;
};
mitk::DataStorageInspectorGenerator::ProviderMapType mitk::DataStorageInspectorGenerator::GetProviders()
{
std::vector<us::ServiceReference<mitk::IDataStorageInspectorProvider> > providerRegisters = us::GetModuleContext()->GetServiceReferences<mitk::IDataStorageInspectorProvider>();
ProviderMapType result;
- for (auto regs : providerRegisters)
+ for (const auto ®s : providerRegisters)
{
auto provider = us::GetModuleContext()->GetService<mitk::IDataStorageInspectorProvider>(regs);
result.insert(std::make_pair(provider->GetInspectorID(), provider));
}
return result;
};
mitk::DataStorageInspectorGenerator::DataStorageInspectorGenerator()
= default;
mitk::DataStorageInspectorGenerator::~DataStorageInspectorGenerator()
= default;
diff --git a/Modules/RT/autoload/DICOMRTIO/mitkRTDoseReaderService.cpp b/Modules/RT/autoload/DICOMRTIO/mitkRTDoseReaderService.cpp
index 921e4d6556..50f4a52ad0 100644
--- a/Modules/RT/autoload/DICOMRTIO/mitkRTDoseReaderService.cpp
+++ b/Modules/RT/autoload/DICOMRTIO/mitkRTDoseReaderService.cpp
@@ -1,168 +1,171 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkRTDoseReaderService.h>
#include <mitkLexicalCast.h>
#include <mitkImageAccessByItk.h>
#include <mitkImageCast.h>
#include <mitkDICOMFileReaderSelector.h>
#include <mitkDICOMFileReader.h>
#include <mitkRTConstants.h>
#include <mitkImageStatisticsHolder.h>
#include <mitkDICOMTagPath.h>
#include <mitkDICOMDCMTKTagScanner.h>
#include <mitkDICOMRTMimeTypes.h>
#include <mitkDICOMIOHelper.h>
+#include <mitkProperties.h>
+#include <mitkDICOMProperty.h>
#include <dcmtk/dcmrt/drtdose.h>
#include <itkShiftScaleImageFilter.h>
#include <itkCastImageFilter.h>
namespace mitk
{
RTDoseReaderService::RTDoseReaderService() : AbstractFileReader(CustomMimeType(mitk::DICOMRTMimeTypes::DICOMRT_DOSE_MIMETYPE_NAME()), mitk::DICOMRTMimeTypes::DICOMRT_DOSE_MIMETYPE_DESCRIPTION()) {
m_FileReaderServiceReg = RegisterService();
}
RTDoseReaderService::RTDoseReaderService(const RTDoseReaderService& other) : mitk::AbstractFileReader(other)
{
}
RTDoseReaderService::~RTDoseReaderService() {}
template<typename TPixel, unsigned int VImageDimension>
void RTDoseReaderService::MultiplyGridScaling(itk::Image<TPixel, VImageDimension>* image, float gridscale)
{
typedef itk::Image<Float32, VImageDimension> OutputImageType;
typedef itk::Image<TPixel, VImageDimension> InputImageType;
typedef itk::CastImageFilter<InputImageType, OutputImageType> CastFilterType;
typedef itk::ShiftScaleImageFilter<OutputImageType, OutputImageType> ScaleFilterType;
typename CastFilterType::Pointer castFilter = CastFilterType::New();
typename ScaleFilterType::Pointer scaleFilter = ScaleFilterType::New();
castFilter->SetInput(image);
scaleFilter->SetInput(castFilter->GetOutput());
scaleFilter->SetScale(gridscale);
scaleFilter->Update();
typename OutputImageType::Pointer scaledOutput = scaleFilter->GetOutput();
this->scaledDoseImage = mitk::Image::New();
mitk::CastToMitkImage(scaledOutput, this->scaledDoseImage);
}
std::vector<itk::SmartPointer<BaseData> > RTDoseReaderService::DoRead()
{
std::vector<itk::SmartPointer<mitk::BaseData> > result;
mitk::IDICOMTagsOfInterest* toiSrv = GetDicomTagsOfInterestService();
auto tagsOfInterest = toiSrv->GetTagsOfInterest();
DICOMTagPathList tagsOfInterestList;
for (const auto& tag : tagsOfInterest) {
tagsOfInterestList.push_back(tag.first);
}
std::string location = GetInputLocation();
mitk::DICOMFileReaderSelector::Pointer selector = mitk::DICOMFileReaderSelector::New();
selector->LoadBuiltIn3DConfigs();
selector->SetInputFiles({ location });
mitk::DICOMFileReader::Pointer reader = selector->GetFirstReaderWithMinimumNumberOfOutputImages();
reader->SetAdditionalTagsOfInterest(toiSrv->GetTagsOfInterest());
+ reader->SetTagLookupTableToPropertyFunctor(mitk::GetDICOMPropertyForDICOMValuesFunctor);
reader->SetInputFiles({ location });
reader->AnalyzeInputFiles();
reader->LoadImages();
if (reader->GetNumberOfOutputs() == 0) {
MITK_ERROR << "Could not determine a DICOM reader for this file" << std::endl;
return result;
}
mitk::DICOMDCMTKTagScanner::Pointer scanner = mitk::DICOMDCMTKTagScanner::New();
scanner->SetInputFiles({ location });
scanner->AddTagPaths(tagsOfInterestList);
scanner->Scan();
mitk::DICOMDatasetAccessingImageFrameList frames = scanner->GetFrameInfoList();
if (frames.empty()) {
MITK_ERROR << "Error reading the RTDOSE file" << std::endl;
return result;
}
const mitk::DICOMImageBlockDescriptor& desc = reader->GetOutput(0);
mitk::Image::Pointer originalImage = desc.GetMitkImage();
if (originalImage.IsNull())
{
MITK_ERROR << "Error reading the RTDOSE file in mitk::DicomFileReader" << std::endl;
return result;
}
DcmFileFormat fileformat;
OFCondition outp = fileformat.loadFile(location.c_str(), EXS_Unknown);
if (outp.bad())
{
MITK_ERROR << "Error reading the RTDOSE file in DCMTK" << std::endl;
return result;
}
DcmDataset *dataset = fileformat.getDataset();
DRTDoseIOD doseObject;
OFCondition DCMTKresult = doseObject.read(*dataset);
if (DCMTKresult.bad())
{
MITK_ERROR << "Error reading the RTDOSE file in DCMTK" << std::endl;
return result;
}
auto findingsGridScaling = frames.front()->GetTagValueAsString(DICOMTagPath(0x3004, 0x000e)); //(0x3004, 0x000e) is grid scaling
double gridScaling;
if (findingsGridScaling.empty()) {
MITK_ERROR << "Could not find DoseGridScaling tag" << std::endl;
return result;
}
else {
gridScaling = boost::lexical_cast<double>(findingsGridScaling.front().value);
}
AccessByItk_1(originalImage, MultiplyGridScaling, gridScaling);
auto statistics = this->scaledDoseImage->GetStatistics();
double maxDose = statistics->GetScalarValueMax();
this->scaledDoseImage->SetPropertyList(originalImage->GetPropertyList());
- this->scaledDoseImage->SetProperty(mitk::RTConstants::PRESCRIBED_DOSE_PROPERTY_NAME.c_str(), mitk::GenericProperty<double>::New(0.8*maxDose));
+ this->scaledDoseImage->SetProperty(mitk::RTConstants::PRESCRIBED_DOSE_PROPERTY_NAME.c_str(), mitk::DoubleProperty::New(0.8*maxDose));
auto findings = ExtractPathsOfInterest(tagsOfInterestList, frames);
SetProperties(this->scaledDoseImage, findings);
result.push_back(this->scaledDoseImage.GetPointer());
return result;
}
RTDoseReaderService* RTDoseReaderService::Clone() const
{
return new RTDoseReaderService(*this);
}
}
diff --git a/Modules/RT/test/mitkRTDoseReaderServiceTest.cpp b/Modules/RT/test/mitkRTDoseReaderServiceTest.cpp
index f6d984d8f0..ac49052143 100644
--- a/Modules/RT/test/mitkRTDoseReaderServiceTest.cpp
+++ b/Modules/RT/test/mitkRTDoseReaderServiceTest.cpp
@@ -1,70 +1,70 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkTestingMacros.h>
#include <mitkTestFixture.h>
#include <mitkRTConstants.h>
-#include <mitkGenericProperty.h>
+#include <mitkProperties.h>
#include "mitkTemporoSpatialStringProperty.h"
#include <mitkIOUtil.h>
class mitkRTDoseReaderServiceTestSuite : public mitk::TestFixture
{
CPPUNIT_TEST_SUITE(mitkRTDoseReaderServiceTestSuite);
MITK_TEST(TestDoseImage);
MITK_TEST(TestProperties);
CPPUNIT_TEST_SUITE_END();
private:
mitk::Image::ConstPointer m_doseImage;
mitk::Image::ConstPointer m_referenceImage;
public:
void setUp() override
{
m_referenceImage = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("RT/Dose/RT_Dose.nrrd"));
m_doseImage = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("RT/Dose/RD.dcm"));
}
void TestDoseImage()
{
CPPUNIT_ASSERT_EQUAL_MESSAGE("image should not be null", m_doseImage.IsNotNull(), true);
CPPUNIT_ASSERT_EQUAL_MESSAGE("reference image and image should be equal", true, mitk::Equal(*m_doseImage, *m_referenceImage, mitk::eps, true));
}
void TestProperties() {
CheckStringProperty("DICOM.0008.0060", "RTDOSE"); //Modality
auto prescibedDoseProperty = m_doseImage->GetProperty(mitk::RTConstants::PRESCRIBED_DOSE_PROPERTY_NAME.c_str());
- auto prescribedDoseGenericProperty = dynamic_cast<mitk::GenericProperty<double>*>(prescibedDoseProperty.GetPointer());
+ auto prescribedDoseGenericProperty = dynamic_cast<mitk::DoubleProperty*>(prescibedDoseProperty.GetPointer());
double actualPrescribedDose = prescribedDoseGenericProperty->GetValue();
double expectedPrescribedDose = 65535 * 0.0010494648*0.8;
CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("prescribed dose property is not as expected", expectedPrescribedDose, actualPrescribedDose, 1e-5);
CheckStringProperty("DICOM.0020.000D", "1.2.826.0.1.3680043.8.176.2013826104517910.408.3433258507"); //StudyInstanceUID
CheckStringProperty("DICOM.3004.000E", "0.0010494648"); //DoseGridScaling
CheckStringProperty("DICOM.300C.0002.[0].0008.1155", "1.2.826.0.1.3680043.8.176.2013826104526987.672.1228523524"); //ReferencedRTPlanSequence.ReferencedSOPInstanceUID
}
void CheckStringProperty(const std::string& propertyName, const std::string& expectedPropertyValue)
{
auto actualProperty = m_doseImage->GetProperty(propertyName.c_str());
CPPUNIT_ASSERT_EQUAL_MESSAGE("Property not found: " + propertyName, actualProperty.IsNotNull(), true);
auto actualTemporoSpatialStringProperty = dynamic_cast<mitk::TemporoSpatialStringProperty*>(actualProperty.GetPointer());
CPPUNIT_ASSERT_EQUAL_MESSAGE("Property has not type string: " + propertyName, actualTemporoSpatialStringProperty != nullptr, true);
std::string actualStringProperty = actualTemporoSpatialStringProperty->GetValue();
CPPUNIT_ASSERT_EQUAL_MESSAGE(propertyName + " is not as expected", actualStringProperty, expectedPropertyValue);
}
};
MITK_TEST_SUITE_REGISTRATION(mitkRTDoseReaderService)
diff --git a/Modules/RenderWindowManagerUI/src/QmitkRenderWindowDataStorageListModel.cpp b/Modules/RenderWindowManagerUI/src/QmitkRenderWindowDataStorageListModel.cpp
index 52df4f37ec..67c0c79336 100644
--- a/Modules/RenderWindowManagerUI/src/QmitkRenderWindowDataStorageListModel.cpp
+++ b/Modules/RenderWindowManagerUI/src/QmitkRenderWindowDataStorageListModel.cpp
@@ -1,354 +1,354 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
// render window manager UI module
#include "QmitkRenderWindowDataStorageListModel.h"
// qt widgets module
#include "QmitkCustomVariants.h"
#include "QmitkEnums.h"
#include "QmitkMimeTypes.h"
#include "QmitkNodeDescriptorManager.h"
QmitkRenderWindowDataStorageListModel::QmitkRenderWindowDataStorageListModel(QObject* parent /*= nullptr*/)
: QmitkAbstractDataStorageModel(parent)
{
m_RenderWindowLayerController = std::make_unique<mitk::RenderWindowLayerController>();
}
void QmitkRenderWindowDataStorageListModel::DataStorageChanged()
{
m_RenderWindowLayerController->SetDataStorage(m_DataStorage.Lock());
UpdateModelData();
}
void QmitkRenderWindowDataStorageListModel::NodePredicateChanged()
{
UpdateModelData();
}
void QmitkRenderWindowDataStorageListModel::NodeAdded(const mitk::DataNode* node)
{
// add a node to each render window specific list (or to a global list initially)
AddDataNodeToAllRenderer(const_cast<mitk::DataNode*>(node));
UpdateModelData();
}
void QmitkRenderWindowDataStorageListModel::NodeChanged(const mitk::DataNode* /*node*/)
{
// nothing here, since the "'NodeChanged'-event is currently sent far too often
}
void QmitkRenderWindowDataStorageListModel::NodeRemoved(const mitk::DataNode* /*node*/)
{
// update model data to create a new list without the removed data node
UpdateModelData();
}
QModelIndex QmitkRenderWindowDataStorageListModel::index(int row, int column, const QModelIndex& parent) const
{
bool hasIndex = this->hasIndex(row, column, parent);
if (hasIndex)
{
return this->createIndex(row, column);
}
return QModelIndex();
}
QModelIndex QmitkRenderWindowDataStorageListModel::parent(const QModelIndex& /*child*/) const
{
return QModelIndex();
}
int QmitkRenderWindowDataStorageListModel::rowCount(const QModelIndex& parent /*= QModelIndex()*/) const
{
if (parent.isValid())
{
return 0;
}
return static_cast<int>(m_LayerStack.size());
}
int QmitkRenderWindowDataStorageListModel::columnCount(const QModelIndex& parent /*= QModelIndex()*/) const
{
if (parent.isValid())
{
return 0;
}
return 1;
}
QVariant QmitkRenderWindowDataStorageListModel::data(const QModelIndex& index, int role) const
{
if (m_BaseRenderer.IsExpired())
{
return QVariant();
}
auto baseRenderer = m_BaseRenderer.Lock();
if (!index.isValid() || this != index.model())
{
return QVariant();
}
if (index.row() < 0 || index.row() >= static_cast<int>(m_LayerStack.size()))
{
return QVariant();
}
mitk::RenderWindowLayerUtilities::LayerStack::const_iterator layerStackIt = m_LayerStack.begin();
std::advance(layerStackIt, index.row());
mitk::DataNode* dataNode = layerStackIt->second;
if (Qt::CheckStateRole == role)
{
bool visibility = false;
dataNode->GetVisibility(visibility, baseRenderer);
if (visibility)
{
return Qt::Checked;
}
else
{
return Qt::Unchecked;
}
}
else if (Qt::DisplayRole == role)
{
return QVariant(QString::fromStdString(dataNode->GetName()));
}
else if (Qt::ToolTipRole == role)
{
return QVariant("Name of the data node.");
}
else if (Qt::DecorationRole == role)
{
QmitkNodeDescriptor* nodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor(dataNode);
return nodeDescriptor->GetIcon(dataNode);
}
else if (Qt::UserRole == role || QmitkDataNodeRawPointerRole == role)
{
// user role always returns a reference to the data node,
// which can be used to modify the data node in the data storage
return QVariant::fromValue<mitk::DataNode*>(dataNode);
}
else if (QmitkDataNodeRole == role)
{
return QVariant::fromValue<mitk::DataNode::Pointer>(mitk::DataNode::Pointer(dataNode));
}
return QVariant();
}
bool QmitkRenderWindowDataStorageListModel::setData(const QModelIndex& index, const QVariant& value, int role /*= Qt::EditRole*/)
{
if (m_BaseRenderer.IsExpired())
{
return false;
}
auto baseRenderer = m_BaseRenderer.Lock();
if (!index.isValid() || this != index.model())
{
return false;
}
if (index.row() < 0 || index.row() >= static_cast<int>(m_LayerStack.size()))
{
return false;
}
mitk::RenderWindowLayerUtilities::LayerStack::const_iterator layerStackIt = m_LayerStack.begin();
std::advance(layerStackIt, index.row());
mitk::DataNode* dataNode = layerStackIt->second;
if (Qt::CheckStateRole == role)
{
Qt::CheckState newCheckState = static_cast<Qt::CheckState>(value.toInt());
bool isVisible = newCheckState;
dataNode->SetVisibility(isVisible, baseRenderer);
emit dataChanged(index, index);
mitk::RenderingManager::GetInstance()->RequestUpdate(baseRenderer->GetRenderWindow());
return true;
}
return false;
}
Qt::ItemFlags QmitkRenderWindowDataStorageListModel::flags(const QModelIndex &index) const
{
if (this != index.model())
{
return Qt::NoItemFlags;
}
if (!index.isValid())
{
return Qt::ItemIsDropEnabled;
}
return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled;
}
Qt::DropActions QmitkRenderWindowDataStorageListModel::supportedDropActions() const
{
return Qt::CopyAction | Qt::MoveAction;
}
Qt::DropActions QmitkRenderWindowDataStorageListModel::supportedDragActions() const
{
return Qt::CopyAction | Qt::MoveAction;
}
QStringList QmitkRenderWindowDataStorageListModel::mimeTypes() const
{
QStringList types = QAbstractItemModel::mimeTypes();
types << QmitkMimeTypes::DataNodePtrs;
return types;
}
QMimeData* QmitkRenderWindowDataStorageListModel::mimeData(const QModelIndexList& indexes) const
{
QMimeData* mimeData = new QMimeData();
QByteArray encodedData;
QDataStream stream(&encodedData, QIODevice::WriteOnly);
for (const auto& index : indexes)
{
if (index.isValid())
{
auto dataNode = data(index, QmitkDataNodeRawPointerRole).value<mitk::DataNode*>();
stream << reinterpret_cast<quintptr>(dataNode);
}
}
mimeData->setData(QmitkMimeTypes::DataNodePtrs, encodedData);
return mimeData;
}
bool QmitkRenderWindowDataStorageListModel::dropMimeData(const QMimeData* data, Qt::DropAction action, int /*row*/, int column, const QModelIndex& parent)
{
if (m_BaseRenderer.IsExpired())
{
return false;
}
auto baseRenderer = m_BaseRenderer.Lock();
if (action == Qt::IgnoreAction)
{
return true;
}
if (!data->hasFormat(QmitkMimeTypes::DataNodePtrs))
{
return false;
}
if (column > 0)
{
return false;
}
if (parent.isValid())
{
int layer = -1;
auto dataNode = this->data(parent, QmitkDataNodeRawPointerRole).value<mitk::DataNode*>();
if (nullptr != dataNode)
{
dataNode->GetIntProperty("layer", layer, baseRenderer);
}
auto dataNodeList = QmitkMimeTypes::ToDataNodePtrList(data);
- for (const auto& dataNode : dataNodeList)
+ for (const auto& dataNode : qAsConst(dataNodeList))
{
m_RenderWindowLayerController->MoveNodeToPosition(dataNode, layer, baseRenderer);
}
UpdateModelData();
return true;
}
return false;
}
void QmitkRenderWindowDataStorageListModel::SetControlledRenderer(mitk::RenderWindowLayerUtilities::RendererVector controlledRenderer)
{
m_RenderWindowLayerController->SetControlledRenderer(controlledRenderer);
if (!m_DataStorage.IsExpired())
{
auto dataStorage = m_DataStorage.Lock();
mitk::DataStorage::SetOfObjects::ConstPointer allDataNodes = dataStorage->GetAll();
for (mitk::DataStorage::SetOfObjects::ConstIterator it = allDataNodes->Begin(); it != allDataNodes->End(); ++it)
{
mitk::DataNode::Pointer dataNode = it->Value();
if (dataNode.IsNull())
{
continue;
}
AddDataNodeToAllRenderer(dataNode);
}
}
}
void QmitkRenderWindowDataStorageListModel::SetCurrentRenderer(mitk::BaseRenderer* baseRenderer)
{
if (m_BaseRenderer == baseRenderer)
{
return;
}
m_BaseRenderer = baseRenderer;
if (!m_BaseRenderer.IsExpired())
{
UpdateModelData();
}
}
mitk::BaseRenderer* QmitkRenderWindowDataStorageListModel::GetCurrentRenderer() const
{
if (m_BaseRenderer.IsExpired())
{
return nullptr;
}
return m_BaseRenderer.Lock().GetPointer();
}
void QmitkRenderWindowDataStorageListModel::AddDataNodeToAllRenderer(mitk::DataNode* dataNode)
{
m_RenderWindowLayerController->InsertLayerNode(dataNode);
}
void QmitkRenderWindowDataStorageListModel::UpdateModelData()
{
if (!m_DataStorage.IsExpired())
{
auto dataStorage = m_DataStorage.Lock();
if (!m_BaseRenderer.IsExpired())
{
auto baseRenderer = m_BaseRenderer.Lock();
// update the model, so that it will be filled with the nodes of the new data storage
beginResetModel();
// get the current layer stack of the given base renderer
m_LayerStack = mitk::RenderWindowLayerUtilities::GetLayerStack(dataStorage, baseRenderer, true);
endResetModel();
}
}
}
diff --git a/Modules/RenderWindowManagerUI/src/QmitkRenderWindowDataStorageTreeModel.cpp b/Modules/RenderWindowManagerUI/src/QmitkRenderWindowDataStorageTreeModel.cpp
index c453dbdc5c..8274403471 100644
--- a/Modules/RenderWindowManagerUI/src/QmitkRenderWindowDataStorageTreeModel.cpp
+++ b/Modules/RenderWindowManagerUI/src/QmitkRenderWindowDataStorageTreeModel.cpp
@@ -1,601 +1,601 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
// render window manager UI module
#include "QmitkRenderWindowDataStorageTreeModel.h"
// mitk core
#include <QmitkDataStorageTreeModelInternalItem.h>
// qt widgets module
#include "QmitkCustomVariants.h"
#include "QmitkEnums.h"
#include "QmitkMimeTypes.h"
#include "QmitkNodeDescriptorManager.h"
QmitkRenderWindowDataStorageTreeModel::QmitkRenderWindowDataStorageTreeModel(QObject* parent /*= nullptr*/)
: QmitkAbstractDataStorageModel(parent)
, m_Root(nullptr)
{
m_RenderWindowLayerController = std::make_unique<mitk::RenderWindowLayerController>();
ResetTree();
}
void QmitkRenderWindowDataStorageTreeModel::DataStorageChanged()
{
m_RenderWindowLayerController->SetDataStorage(m_DataStorage.Lock());
ResetTree();
UpdateModelData();
}
void QmitkRenderWindowDataStorageTreeModel::NodePredicateChanged()
{
ResetTree();
UpdateModelData();
}
void QmitkRenderWindowDataStorageTreeModel::NodeAdded(const mitk::DataNode* node)
{
for (const auto renderer : m_ControlledRenderer)
{
// add the node to each render window
mitk::RenderWindowLayerUtilities::SetRenderWindowProperties(const_cast<mitk::DataNode*>(node), renderer);
}
if (!m_BaseRenderer.IsExpired())
{
auto baseRenderer = m_BaseRenderer.Lock();
AddNodeInternal(node, baseRenderer);
}
}
void QmitkRenderWindowDataStorageTreeModel::NodeChanged(const mitk::DataNode* node)
{
auto item = m_Root->Find(node);
if (nullptr != item)
{
auto parentItem = item->GetParent();
// as the root node should not be removed one should always have a parent item
if (nullptr == parentItem)
{
return;
}
auto index = createIndex(item->GetIndex(), 0, item);
emit dataChanged(index, index);
}
}
void QmitkRenderWindowDataStorageTreeModel::NodeRemoved(const mitk::DataNode* node)
{
RemoveNodeInternal(node);
}
QModelIndex QmitkRenderWindowDataStorageTreeModel::index(int row, int column, const QModelIndex& parent) const
{
auto item = GetItemByIndex(parent);
if (nullptr != item)
{
item = item->GetChild(row);
}
if (nullptr == item)
{
return QModelIndex();
}
return createIndex(row, column, item);
}
QModelIndex QmitkRenderWindowDataStorageTreeModel::parent(const QModelIndex& parent) const
{
auto item = GetItemByIndex(parent);
if (nullptr != item)
{
item = item->GetParent();
}
if(nullptr == item)
{
return QModelIndex();
}
if (item == m_Root)
{
return QModelIndex();
}
return createIndex(item->GetIndex(), 0, item);
}
int QmitkRenderWindowDataStorageTreeModel::rowCount(const QModelIndex& parent /*= QModelIndex()*/) const
{
auto item = GetItemByIndex(parent);
if (nullptr == item)
{
return 0;
}
return item->GetChildCount();
}
int QmitkRenderWindowDataStorageTreeModel::columnCount(const QModelIndex&/* parent = QModelIndex()*/) const
{
if (0 == m_Root->GetChildCount())
{
// no items stored, no need to display columns
return 0;
}
return 1;
}
QVariant QmitkRenderWindowDataStorageTreeModel::data(const QModelIndex& index, int role) const
{
if (m_BaseRenderer.IsExpired())
{
return QVariant();
}
auto baseRenderer = m_BaseRenderer.Lock();
if (!index.isValid() || this != index.model())
{
return QVariant();
}
auto item = GetItemByIndex(index);
if (nullptr == item)
{
return QVariant();
}
auto dataNode = item->GetDataNode();
if (nullptr == dataNode)
{
return QVariant();
}
if (Qt::CheckStateRole == role)
{
bool visibility = false;
dataNode->GetVisibility(visibility, baseRenderer);
if (visibility)
{
return Qt::Checked;
}
else
{
return Qt::Unchecked;
}
}
else if (Qt::DisplayRole == role)
{
return QVariant(QString::fromStdString(dataNode->GetName()));
}
else if (Qt::ToolTipRole == role)
{
return QVariant("Name of the data node.");
}
else if (Qt::DecorationRole == role)
{
QmitkNodeDescriptor* nodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor(dataNode);
return nodeDescriptor->GetIcon(dataNode);
}
else if (Qt::UserRole == role || QmitkDataNodeRawPointerRole == role)
{
// user role always returns a reference to the data node,
// which can be used to modify the data node in the data storage
return QVariant::fromValue<mitk::DataNode*>(dataNode);
}
else if (QmitkDataNodeRole == role)
{
return QVariant::fromValue<mitk::DataNode::Pointer>(mitk::DataNode::Pointer(dataNode));
}
return QVariant();
}
bool QmitkRenderWindowDataStorageTreeModel::setData(const QModelIndex& index, const QVariant& value, int role /*= Qt::EditRole*/)
{
if (m_BaseRenderer.IsExpired())
{
return false;
}
auto baseRenderer = m_BaseRenderer.Lock();
if (!index.isValid() || this != index.model())
{
return false;
}
auto item = GetItemByIndex(index);
if (nullptr == item)
{
return false;
}
auto dataNode = item->GetDataNode();
if (nullptr == dataNode)
{
return false;
}
if (Qt::EditRole == role && !value.toString().isEmpty())
{
dataNode->SetName(value.toString().toStdString().c_str());
emit dataChanged(index, index);
return true;
}
if (Qt::CheckStateRole == role)
{
Qt::CheckState newCheckState = static_cast<Qt::CheckState>(value.toInt());
bool isVisible = newCheckState;
dataNode->SetVisibility(isVisible, baseRenderer);
emit dataChanged(index, index);
mitk::RenderingManager::GetInstance()->RequestUpdate(baseRenderer->GetRenderWindow());
return true;
}
return false;
}
Qt::ItemFlags QmitkRenderWindowDataStorageTreeModel::flags(const QModelIndex& index) const
{
if (this != index.model())
{
return Qt::NoItemFlags;
}
if (!index.isValid())
{
return Qt::ItemIsDropEnabled;
}
auto item = GetItemByIndex(index);
if (nullptr == item)
{
return Qt::NoItemFlags;
}
const auto dataNode = item->GetDataNode();
if (m_NodePredicate.IsNull() || m_NodePredicate->CheckNode(dataNode))
{
return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled;
}
return Qt::NoItemFlags;
}
Qt::DropActions QmitkRenderWindowDataStorageTreeModel::supportedDropActions() const
{
return Qt::CopyAction | Qt::MoveAction;
}
Qt::DropActions QmitkRenderWindowDataStorageTreeModel::supportedDragActions() const
{
return Qt::CopyAction | Qt::MoveAction;
}
QStringList QmitkRenderWindowDataStorageTreeModel::mimeTypes() const
{
QStringList types = QAbstractItemModel::mimeTypes();
types << QmitkMimeTypes::DataNodePtrs;
return types;
}
QMimeData* QmitkRenderWindowDataStorageTreeModel::mimeData(const QModelIndexList& indexes) const
{
QMimeData* mimeData = new QMimeData();
QByteArray encodedData;
QDataStream stream(&encodedData, QIODevice::WriteOnly);
for (const auto& index : indexes)
{
if (index.isValid())
{
auto dataNode = data(index, QmitkDataNodeRawPointerRole).value<mitk::DataNode*>();
stream << reinterpret_cast<quintptr>(dataNode);
}
}
mimeData->setData(QmitkMimeTypes::DataNodePtrs, encodedData);
return mimeData;
}
bool QmitkRenderWindowDataStorageTreeModel::dropMimeData(const QMimeData* data, Qt::DropAction action, int /*row*/, int /*column*/, const QModelIndex& parent)
{
if (m_BaseRenderer.IsExpired())
{
return false;
}
auto baseRenderer = m_BaseRenderer.Lock();
if (action == Qt::IgnoreAction)
{
return true;
}
if (!data->hasFormat(QmitkMimeTypes::DataNodePtrs))
{
return false;
}
if (!parent.isValid())
{
return false;
}
int layer = -1;
auto dataNode = this->data(parent, QmitkDataNodeRawPointerRole).value<mitk::DataNode*>();
if (nullptr != dataNode)
{
dataNode->GetIntProperty("layer", layer, baseRenderer);
}
auto dataNodeList = QmitkMimeTypes::ToDataNodePtrList(data);
- for (const auto& dataNode : dataNodeList)
+ for (const auto& dataNode : qAsConst(dataNodeList))
{
m_RenderWindowLayerController->MoveNodeToPosition(dataNode, layer, baseRenderer);
}
ResetTree();
UpdateModelData();
AdjustLayerProperty();
return true;
}
void QmitkRenderWindowDataStorageTreeModel::SetControlledRenderer(mitk::RenderWindowLayerUtilities::RendererVector controlledRenderer)
{
m_RenderWindowLayerController->SetControlledRenderer(controlledRenderer);
m_ControlledRenderer = controlledRenderer;
ResetTree();
if (m_DataStorage.IsExpired())
{
return;
}
auto dataStorage = m_DataStorage.Lock();
for (const auto& renderer : controlledRenderer)
{
if (nullptr == renderer)
{
continue;
}
auto allDataNodes = dataStorage->GetAll();
for (const auto& dataNode : *allDataNodes)
{
// add the node to each render window
mitk::RenderWindowLayerUtilities::SetRenderWindowProperties(dataNode, renderer);
}
}
}
void QmitkRenderWindowDataStorageTreeModel::SetCurrentRenderer(mitk::BaseRenderer* baseRenderer)
{
if (m_BaseRenderer == baseRenderer)
{
return;
}
// base renderer changed
// reset tree to build a new renderer-specific item hierarchy
m_BaseRenderer = baseRenderer;
ResetTree();
UpdateModelData();
}
mitk::BaseRenderer* QmitkRenderWindowDataStorageTreeModel::GetCurrentRenderer() const
{
if (m_BaseRenderer.IsExpired())
{
return nullptr;
}
return m_BaseRenderer.Lock().GetPointer();
}
void QmitkRenderWindowDataStorageTreeModel::ResetTree()
{
beginResetModel();
if (nullptr != m_Root)
{
m_Root->Delete();
}
mitk::DataNode::Pointer rootDataNode = mitk::DataNode::New();
rootDataNode->SetName("Data Storage");
m_Root = new QmitkDataStorageTreeModelInternalItem(rootDataNode);
endResetModel();
}
void QmitkRenderWindowDataStorageTreeModel::UpdateModelData()
{
if (!m_DataStorage.IsExpired())
{
auto dataStorage = m_DataStorage.Lock();
if (!m_BaseRenderer.IsExpired())
{
auto baseRenderer = m_BaseRenderer.Lock();
mitk::NodePredicateAnd::Pointer combinedNodePredicate = mitk::RenderWindowLayerUtilities::GetRenderWindowPredicate(baseRenderer);
auto filteredDataNodes = dataStorage->GetSubset(combinedNodePredicate);
for (const auto& dataNode : *filteredDataNodes)
{
AddNodeInternal(dataNode, baseRenderer);
}
}
}
}
void QmitkRenderWindowDataStorageTreeModel::AdjustLayerProperty()
{
if (m_BaseRenderer.IsExpired())
{
return;
}
auto baseRenderer = m_BaseRenderer.Lock();
std::vector<QmitkDataStorageTreeModelInternalItem*> treeAsVector;
TreeToVector(m_Root, treeAsVector);
int i = treeAsVector.size() - 1;
for (auto it = treeAsVector.begin(); it != treeAsVector.end(); ++it)
{
auto dataNode = (*it)->GetDataNode();
dataNode->SetIntProperty("layer", i, baseRenderer);
--i;
}
}
void QmitkRenderWindowDataStorageTreeModel::TreeToVector(QmitkDataStorageTreeModelInternalItem* parent, std::vector<QmitkDataStorageTreeModelInternalItem*>& treeAsVector) const
{
QmitkDataStorageTreeModelInternalItem* item;
for (int i = 0; i < parent->GetChildCount(); ++i)
{
item = parent->GetChild(i);
TreeToVector(item, treeAsVector);
treeAsVector.push_back(item);
}
}
void QmitkRenderWindowDataStorageTreeModel::AddNodeInternal(const mitk::DataNode* dataNode, const mitk::BaseRenderer* renderer)
{
if (nullptr == dataNode
|| m_DataStorage.IsExpired()
|| nullptr != m_Root->Find(dataNode))
{
return;
}
// find out if we have a root node
auto parentItem = m_Root;
QModelIndex index;
auto parentDataNode = GetParentNode(dataNode);
if (nullptr != parentDataNode) // no top level data node
{
parentItem = m_Root->Find(parentDataNode);
if (nullptr == parentItem)
{
// parent node not contained in the tree; add it
NodeAdded(parentDataNode);
parentItem = m_Root->Find(parentDataNode);
if (nullptr == parentItem)
{
// could not find and add the parent tree; abort
return;
}
}
// get the index of this parent with the help of the grand parent
index = createIndex(parentItem->GetIndex(), 0, parentItem);
}
int firstRowWithASiblingBelow = 0;
int nodeLayer = -1;
dataNode->GetIntProperty("layer", nodeLayer, renderer);
for (const auto& siblingItem : parentItem->GetChildren())
{
int siblingLayer = -1;
auto siblingNode = siblingItem->GetDataNode();
if (nullptr != siblingNode)
{
siblingNode->GetIntProperty("layer", siblingLayer, renderer);
}
if (nodeLayer > siblingLayer)
{
break;
}
++firstRowWithASiblingBelow;
}
beginInsertRows(index, firstRowWithASiblingBelow, firstRowWithASiblingBelow);
auto newNode = new QmitkDataStorageTreeModelInternalItem(const_cast<mitk::DataNode*>(dataNode));
parentItem->InsertChild(newNode, firstRowWithASiblingBelow);
endInsertRows();
}
void QmitkRenderWindowDataStorageTreeModel::RemoveNodeInternal(const mitk::DataNode* dataNode)
{
if (nullptr == dataNode
|| nullptr == m_Root)
{
return;
}
auto item = m_Root->Find(dataNode);
if (nullptr == item)
{
return;
}
auto parentItem = item->GetParent();
auto parentIndex = GetIndexByItem(parentItem);
auto children = item->GetChildren();
beginRemoveRows(parentIndex, item->GetIndex(), item->GetIndex());
parentItem->RemoveChild(item);
delete item;
endRemoveRows();
if (!children.empty())
{
// rebuild tree because children could not be at the top level
ResetTree();
UpdateModelData();
}
}
mitk::DataNode* QmitkRenderWindowDataStorageTreeModel::GetParentNode(const mitk::DataNode* node) const
{
mitk::DataNode* dataNode = nullptr;
if (m_DataStorage.IsExpired())
{
return dataNode;
}
auto sources = m_DataStorage.Lock()->GetSources(node);
if (sources->empty())
{
return dataNode;
}
return sources->front();
}
QmitkDataStorageTreeModelInternalItem* QmitkRenderWindowDataStorageTreeModel::GetItemByIndex(const QModelIndex& index) const
{
if (index.isValid())
{
return static_cast<QmitkDataStorageTreeModelInternalItem*>(index.internalPointer());
}
return m_Root;
}
QModelIndex QmitkRenderWindowDataStorageTreeModel::GetIndexByItem(QmitkDataStorageTreeModelInternalItem* item) const
{
if (item == m_Root)
{
return QModelIndex();
}
return createIndex(item->GetIndex(), 0, item);
}
diff --git a/Modules/SceneSerialization/src/mitkSceneIO.cpp b/Modules/SceneSerialization/src/mitkSceneIO.cpp
index 04db6cf399..888eda6c5c 100644
--- a/Modules/SceneSerialization/src/mitkSceneIO.cpp
+++ b/Modules/SceneSerialization/src/mitkSceneIO.cpp
@@ -1,575 +1,575 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <Poco/Delegate.h>
#include <Poco/Path.h>
#include <Poco/TemporaryFile.h>
#include <Poco/Zip/Compress.h>
#include <Poco/Zip/Decompress.h>
#include "mitkBaseDataSerializer.h"
#include "mitkPropertyListSerializer.h"
#include "mitkSceneIO.h"
#include "mitkSceneReader.h"
#include "mitkBaseRenderer.h"
#include "mitkProgressBar.h"
#include "mitkRenderingManager.h"
#include "mitkStandaloneDataStorage.h"
#include <mitkLocaleSwitch.h>
#include <mitkStandardFileLocations.h>
#include <itkObjectFactoryBase.h>
#include <fstream>
#include <mitkIOUtil.h>
#include <sstream>
#include "itksys/SystemTools.hxx"
#include <tinyxml2.h>
mitk::SceneIO::SceneIO() : m_WorkingDirectory(""), m_UnzipErrors(0)
{
}
mitk::SceneIO::~SceneIO()
{
}
std::string mitk::SceneIO::CreateEmptyTempDirectory()
{
mitk::UIDGenerator uidGen;
// std::string returnValue = mitk::StandardFileLocations::GetInstance()->GetOptionDirectory() +
// Poco::Path::separator() + "SceneIOTemp" + uidGen.GetUID();
std::string returnValue = Poco::Path::temp() + "SceneIOTemp" + uidGen.GetUID();
std::string uniquename = returnValue + Poco::Path::separator();
Poco::File tempdir(uniquename);
try
{
bool existsNot = tempdir.createDirectory();
if (!existsNot)
{
MITK_ERROR << "Warning: Directory already exitsts: " << uniquename << " (choosing another)";
returnValue = mitk::StandardFileLocations::GetInstance()->GetOptionDirectory() + Poco::Path::separator() +
"SceneIOTempDirectory" + uidGen.GetUID();
uniquename = returnValue + Poco::Path::separator();
Poco::File tempdir2(uniquename);
if (!tempdir2.createDirectory())
{
MITK_ERROR << "Warning: Second directory also already exitsts: " << uniquename;
}
}
}
catch (std::exception &e)
{
MITK_ERROR << "Could not create temporary directory " << uniquename << ":" << e.what();
return "";
}
return returnValue;
}
mitk::DataStorage::Pointer mitk::SceneIO::LoadScene(const std::string &filename,
DataStorage *pStorage,
bool clearStorageFirst)
{
mitk::LocaleSwitch localeSwitch("C");
// prepare data storage
DataStorage::Pointer storage = pStorage;
if (storage.IsNull())
{
storage = StandaloneDataStorage::New().GetPointer();
}
// test input filename
if (filename.empty())
{
MITK_ERROR << "No filename given. Not possible to load scene.";
return storage;
}
// test if filename can be read
std::ifstream file(filename.c_str(), std::ios::binary);
if (!file.good())
{
MITK_ERROR << "Cannot open '" << filename << "' for reading";
return storage;
}
// get new temporary directory
m_WorkingDirectory = CreateEmptyTempDirectory();
if (m_WorkingDirectory.empty())
{
MITK_ERROR << "Could not create temporary directory. Cannot open scene files.";
return storage;
}
// unzip all filenames contents to temp dir
m_UnzipErrors = 0;
Poco::Zip::Decompress unzipper(file, Poco::Path(m_WorkingDirectory));
unzipper.EError += Poco::Delegate<SceneIO, std::pair<const Poco::Zip::ZipLocalFileHeader, const std::string>>(
this, &SceneIO::OnUnzipError);
unzipper.EOk += Poco::Delegate<SceneIO, std::pair<const Poco::Zip::ZipLocalFileHeader, const Poco::Path>>(
this, &SceneIO::OnUnzipOk);
unzipper.decompressAllFiles();
unzipper.EError -= Poco::Delegate<SceneIO, std::pair<const Poco::Zip::ZipLocalFileHeader, const std::string>>(
this, &SceneIO::OnUnzipError);
unzipper.EOk -= Poco::Delegate<SceneIO, std::pair<const Poco::Zip::ZipLocalFileHeader, const Poco::Path>>(
this, &SceneIO::OnUnzipOk);
if (m_UnzipErrors)
{
MITK_ERROR << "There were " << m_UnzipErrors << " errors unzipping '" << filename
<< "'. Will attempt to read whatever could be unzipped.";
}
// transcode locale-dependent string
m_WorkingDirectory = Poco::Path::transcode (m_WorkingDirectory);
auto indexFile = m_WorkingDirectory + mitk::IOUtil::GetDirectorySeparator() + "index.xml";
storage = LoadSceneUnzipped(indexFile, storage, clearStorageFirst);
// delete temp directory
try
{
Poco::File deleteDir(m_WorkingDirectory);
deleteDir.remove(true); // recursive
}
catch (...)
{
MITK_ERROR << "Could not delete temporary directory " << m_WorkingDirectory;
}
// return new data storage, even if empty or uncomplete (return as much as possible but notify calling method)
return storage;
}
mitk::DataStorage::Pointer mitk::SceneIO::LoadSceneUnzipped(const std::string &indexfilename,
DataStorage *pStorage,
bool clearStorageFirst)
{
mitk::LocaleSwitch localeSwitch("C");
// prepare data storage
DataStorage::Pointer storage = pStorage;
if (storage.IsNull())
{
storage = StandaloneDataStorage::New().GetPointer();
}
if (clearStorageFirst)
{
try
{
storage->Remove(storage->GetAll());
}
catch (...)
{
MITK_ERROR << "DataStorage cannot be cleared properly.";
}
}
// test input filename
if (indexfilename.empty())
{
MITK_ERROR << "No filename given. Not possible to load scene.";
return storage;
}
// transcode locale-dependent string
std::string tempfilename;
std::string workingDir;
itksys::SystemTools::SplitProgramPath(indexfilename, workingDir, tempfilename);
// test if index.xml exists
// parse index.xml with TinyXML
tinyxml2::XMLDocument document;
if (tinyxml2::XML_SUCCESS != document.LoadFile(indexfilename.c_str()))
{
MITK_ERROR << "Could not open/read/parse " << workingDir << mitk::IOUtil::GetDirectorySeparator()
<< "index.xml\nTinyXML reports: " << document.ErrorStr() << std::endl;
return storage;
}
SceneReader::Pointer reader = SceneReader::New();
if (!reader->LoadScene(document, workingDir, storage))
{
MITK_ERROR << "There were errors while loading scene file " << indexfilename << ". Your data may be corrupted";
}
// return new data storage, even if empty or uncomplete (return as much as possible but notify calling method)
return storage;
}
bool mitk::SceneIO::SaveScene(DataStorage::SetOfObjects::ConstPointer sceneNodes,
const DataStorage *storage,
const std::string &filename)
{
if (!sceneNodes)
{
MITK_ERROR << "No set of nodes given. Not possible to save scene.";
return false;
}
if (!storage)
{
MITK_ERROR << "No data storage given. Not possible to save scene."; // \TODO: Technically, it would be possible to
// save the nodes without their relation
return false;
}
if (filename.empty())
{
MITK_ERROR << "No filename given. Not possible to save scene.";
return false;
}
mitk::LocaleSwitch localeSwitch("C");
try
{
m_FailedNodes = DataStorage::SetOfObjects::New();
m_FailedProperties = PropertyList::New();
// start XML DOM
tinyxml2::XMLDocument document;
document.InsertEndChild(document.NewDeclaration());
auto *version = document.NewElement("Version");
version->SetAttribute("Writer", __FILE__);
version->SetAttribute("Revision", "$Revision: 17055 $");
version->SetAttribute("FileVersion", 1);
document.InsertEndChild(version);
// DataStorage::SetOfObjects::ConstPointer sceneNodes = storage->GetSubset( predicate );
if (sceneNodes.IsNull())
{
MITK_WARN << "Saving empty scene to " << filename;
}
else
{
if (sceneNodes->size() == 0)
{
MITK_WARN << "Saving empty scene to " << filename;
}
MITK_INFO << "Storing scene with " << sceneNodes->size() << " objects to " << filename;
m_WorkingDirectory = CreateEmptyTempDirectory();
if (m_WorkingDirectory.empty())
{
MITK_ERROR << "Could not create temporary directory. Cannot create scene files.";
return false;
}
ProgressBar::GetInstance()->AddStepsToDo(sceneNodes->size());
// find out about dependencies
typedef std::map<DataNode *, std::string> UIDMapType;
typedef std::map<DataNode *, std::list<std::string>> SourcesMapType;
UIDMapType nodeUIDs; // for dependencies: ID of each node
SourcesMapType sourceUIDs; // for dependencies: IDs of a node's parent nodes
UIDGenerator nodeUIDGen("OBJECT_");
for (auto iter = sceneNodes->begin(); iter != sceneNodes->end(); ++iter)
{
DataNode *node = iter->GetPointer();
if (!node)
continue; // unlikely event that we get a nullptr pointer as an object for saving. just ignore
// generate UIDs for all source objects
DataStorage::SetOfObjects::ConstPointer sourceObjects = storage->GetSources(node);
for (auto sourceIter = sourceObjects->begin();
sourceIter != sourceObjects->end();
++sourceIter)
{
if (std::find(sceneNodes->begin(), sceneNodes->end(), *sourceIter) == sceneNodes->end())
continue; // source is not saved, so don't generate a UID for this source
// create a uid for the parent object
if (nodeUIDs[*sourceIter].empty())
{
nodeUIDs[*sourceIter] = nodeUIDGen.GetUID();
}
// store this dependency for writing
sourceUIDs[node].push_back(nodeUIDs[*sourceIter]);
}
if (nodeUIDs[node].empty())
{
nodeUIDs[node] = nodeUIDGen.GetUID();
}
}
// write out objects, dependencies and properties
for (auto iter = sceneNodes->begin(); iter != sceneNodes->end(); ++iter)
{
DataNode *node = iter->GetPointer();
if (node)
{
auto *nodeElement = document.NewElement("node");
std::string filenameHint(node->GetName());
filenameHint = itksys::SystemTools::MakeCindentifier(
filenameHint.c_str()); // escape filename <-- only allow [A-Za-z0-9_], replace everything else with _
// store dependencies
auto searchUIDIter = nodeUIDs.find(node);
if (searchUIDIter != nodeUIDs.end())
{
// store this node's ID
nodeElement->SetAttribute("UID", searchUIDIter->second.c_str());
}
auto searchSourcesIter = sourceUIDs.find(node);
if (searchSourcesIter != sourceUIDs.end())
{
// store all source IDs
for (auto sourceUIDIter = searchSourcesIter->second.begin();
sourceUIDIter != searchSourcesIter->second.end();
++sourceUIDIter)
{
auto *uidElement = document.NewElement("source");
uidElement->SetAttribute("UID", sourceUIDIter->c_str());
nodeElement->InsertEndChild(uidElement);
}
}
// store basedata
if (BaseData *data = node->GetData())
{
// std::string filenameHint( node->GetName() );
bool error(false);
auto *dataElement = SaveBaseData(document, data, filenameHint, error); // returns a reference to a file
if (error)
{
m_FailedNodes->push_back(node);
}
// store basedata properties
PropertyList *propertyList = data->GetPropertyList();
if (propertyList && !propertyList->IsEmpty())
{
auto *baseDataPropertiesElement =
SavePropertyList(document, propertyList, filenameHint + "-data"); // returns a reference to a file
dataElement->InsertEndChild(baseDataPropertiesElement);
}
nodeElement->InsertEndChild(dataElement);
}
// store all renderwindow specific propertylists
mitk::DataNode::PropertyListKeyNames propertyListKeys = node->GetPropertyListNames();
- for (auto renderWindowName : propertyListKeys)
+ for (const auto &renderWindowName : propertyListKeys)
{
PropertyList *propertyList = node->GetPropertyList(renderWindowName);
if (propertyList && !propertyList->IsEmpty())
{
auto *renderWindowPropertiesElement =
SavePropertyList(document, propertyList, filenameHint + "-" + renderWindowName); // returns a reference to a file
renderWindowPropertiesElement->SetAttribute("renderwindow", renderWindowName.c_str());
nodeElement->InsertEndChild(renderWindowPropertiesElement);
}
}
// don't forget the renderwindow independent list
PropertyList *propertyList = node->GetPropertyList();
if (propertyList && !propertyList->IsEmpty())
{
auto *propertiesElement =
SavePropertyList(document, propertyList, filenameHint + "-node"); // returns a reference to a file
nodeElement->InsertEndChild(propertiesElement);
}
document.InsertEndChild(nodeElement);
}
else
{
MITK_WARN << "Ignoring nullptr node during scene serialization.";
}
ProgressBar::GetInstance()->Progress();
} // end for all nodes
} // end if sceneNodes
std::string defaultLocale_WorkingDirectory = Poco::Path::transcode( m_WorkingDirectory );
auto xmlFilename = defaultLocale_WorkingDirectory + Poco::Path::separator() + "index.xml";
if (tinyxml2::XML_SUCCESS != document.SaveFile(xmlFilename.c_str()))
{
MITK_ERROR << "Could not write scene to " << defaultLocale_WorkingDirectory << Poco::Path::separator() << "index.xml"
<< "\nTinyXML reports '" << document.ErrorStr() << "'";
return false;
}
else
{
try
{
Poco::File deleteFile(filename.c_str());
if (deleteFile.exists())
{
deleteFile.remove();
}
// create zip at filename
std::ofstream file(filename.c_str(), std::ios::binary | std::ios::out);
if (!file.good())
{
MITK_ERROR << "Could not open a zip file for writing: '" << filename << "'";
return false;
}
else
{
Poco::Zip::Compress zipper(file, true);
Poco::Path tmpdir(m_WorkingDirectory);
zipper.addRecursive(tmpdir);
zipper.close();
}
try
{
Poco::File deleteDir(m_WorkingDirectory);
deleteDir.remove(true); // recursive
}
catch (...)
{
MITK_ERROR << "Could not delete temporary directory " << m_WorkingDirectory;
return false; // ok?
}
}
catch (std::exception &e)
{
MITK_ERROR << "Could not create ZIP file from " << m_WorkingDirectory << "\nReason: " << e.what();
return false;
}
return true;
}
}
catch (std::exception &e)
{
MITK_ERROR << "Caught exception during saving temporary files to disk. Error description: '" << e.what() << "'";
return false;
}
}
tinyxml2::XMLElement *mitk::SceneIO::SaveBaseData(tinyxml2::XMLDocument &doc, BaseData *data, const std::string &filenamehint, bool &error)
{
assert(data);
error = true;
// find correct serializer
// the serializer must
// - create a file containing all information to recreate the BaseData object --> needs to know where to put this
// file (and a filename?)
// - TODO what to do about writers that creates one file per timestep?
auto *element = doc.NewElement("data");
element->SetAttribute("type", data->GetNameOfClass());
// construct name of serializer class
std::string serializername(data->GetNameOfClass());
serializername += "Serializer";
std::list<itk::LightObject::Pointer> thingsThatCanSerializeThis =
itk::ObjectFactoryBase::CreateAllInstance(serializername.c_str());
if (thingsThatCanSerializeThis.size() < 1)
{
MITK_ERROR << "No serializer found for " << data->GetNameOfClass() << ". Skipping object";
}
for (auto iter = thingsThatCanSerializeThis.begin();
iter != thingsThatCanSerializeThis.end();
++iter)
{
if (auto *serializer = dynamic_cast<BaseDataSerializer *>(iter->GetPointer()))
{
serializer->SetData(data);
serializer->SetFilenameHint(filenamehint);
std::string defaultLocale_WorkingDirectory = Poco::Path::transcode( m_WorkingDirectory );
serializer->SetWorkingDirectory(defaultLocale_WorkingDirectory);
try
{
std::string writtenfilename = serializer->Serialize();
element->SetAttribute("file", writtenfilename.c_str());
error = false;
}
catch (std::exception &e)
{
MITK_ERROR << "Serializer " << serializer->GetNameOfClass() << " failed: " << e.what();
}
break;
}
}
element->SetAttribute("UID", data->GetUID().c_str());
return element;
}
tinyxml2::XMLElement *mitk::SceneIO::SavePropertyList(tinyxml2::XMLDocument &doc, PropertyList *propertyList, const std::string &filenamehint)
{
assert(propertyList);
// - TODO what to do about shared properties (same object in two lists or behind several keys)?
auto *element = doc.NewElement("properties");
// construct name of serializer class
PropertyListSerializer::Pointer serializer = PropertyListSerializer::New();
serializer->SetPropertyList(propertyList);
serializer->SetFilenameHint(filenamehint);
std::string defaultLocale_WorkingDirectory = Poco::Path::transcode( m_WorkingDirectory );
serializer->SetWorkingDirectory(defaultLocale_WorkingDirectory);
try
{
std::string writtenfilename = serializer->Serialize();
element->SetAttribute("file", writtenfilename.c_str());
PropertyList::Pointer failedProperties = serializer->GetFailedProperties();
if (failedProperties.IsNotNull())
{
// move failed properties to global list
m_FailedProperties->ConcatenatePropertyList(failedProperties, true);
}
}
catch (std::exception &e)
{
MITK_ERROR << "Serializer " << serializer->GetNameOfClass() << " failed: " << e.what();
}
return element;
}
const mitk::SceneIO::FailedBaseDataListType *mitk::SceneIO::GetFailedNodes()
{
return m_FailedNodes.GetPointer();
}
const mitk::PropertyList *mitk::SceneIO::GetFailedProperties()
{
return m_FailedProperties;
}
void mitk::SceneIO::OnUnzipError(const void * /*pSender*/,
std::pair<const Poco::Zip::ZipLocalFileHeader, const std::string> &info)
{
++m_UnzipErrors;
MITK_ERROR << "Error while unzipping: " << info.second;
}
void mitk::SceneIO::OnUnzipOk(const void * /*pSender*/,
std::pair<const Poco::Zip::ZipLocalFileHeader, const Poco::Path> & /*info*/)
{
// MITK_INFO << "Unzipped ok: " << info.second.toString();
}
diff --git a/Modules/SceneSerialization/test/mitkDataStorageCompare.cpp b/Modules/SceneSerialization/test/mitkDataStorageCompare.cpp
index 0bb249821c..b058f76d52 100644
--- a/Modules/SceneSerialization/test/mitkDataStorageCompare.cpp
+++ b/Modules/SceneSerialization/test/mitkDataStorageCompare.cpp
@@ -1,538 +1,538 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkDataStorageCompare.h"
#include "mitkBaseDataCompare.h"
#include "mitkBaseRenderer.h"
#include "mitkMapper.h"
#include "usGetModuleContext.h"
#include "usLDAPFilter.h"
#include "usModuleContext.h"
mitk::DataStorageCompare::DataStorageCompare(const mitk::DataStorage *reference,
const mitk::DataStorage *test,
Tests flags,
double eps)
: m_Eps(eps),
m_TestAspects(flags),
m_ReferenceDS(reference),
m_TestDS(test),
m_HierarchyPassed(true),
m_DataPassed(true),
m_PropertiesPassed(true),
m_MappersPassed(true),
m_InteractorsPassed(true),
m_AspectsFailed(0)
{
BaseDataCompare::RegisterCoreEquals();
}
bool mitk::DataStorageCompare::CompareVerbose()
{
return Compare(true);
}
bool mitk::DataStorageCompare::Compare(bool verbose)
{
DescribeHierarchyOfNodes(m_ReferenceDS, m_RefNodesByHierarchy);
DescribeHierarchyOfNodes(m_TestDS, m_TestNodesByHierarchy);
m_HierarchyPassed = true;
m_DataPassed = true;
m_PropertiesPassed = true;
m_MappersPassed = true;
m_InteractorsPassed = true;
m_AspectsFailed = 0;
if (m_TestAspects & CMP_Hierarchy)
m_HierarchyPassed = CompareHierarchy(verbose);
if (m_TestAspects != CMP_Nothing)
CompareDataNodes(verbose);
if ((m_TestAspects & CMP_Data) && !m_DataPassed)
++m_AspectsFailed;
if ((m_TestAspects & CMP_Properties) && !m_PropertiesPassed)
++m_AspectsFailed;
if ((m_TestAspects & CMP_Mappers) && !m_MappersPassed)
++m_AspectsFailed;
if ((m_TestAspects & CMP_Interactors) && !m_InteractorsPassed)
++m_AspectsFailed;
if (verbose)
Report();
return m_AspectsFailed == 0;
}
void mitk::DataStorageCompare::Report()
{
MITK_INFO << "Comparison results:";
MITK_INFO << " Hierarchy comparison: "
<< (m_TestAspects & CMP_Hierarchy ? (m_HierarchyPassed ? "pass" : "fail") : "skipped");
MITK_INFO << " Data comparison: "
<< (m_TestAspects & CMP_Data ? (m_DataPassed ? "pass" : "fail") : "skipped");
MITK_INFO << " Properties comparison: "
<< (m_TestAspects & CMP_Properties ? (m_PropertiesPassed ? "pass" : "fail") : "skipped");
MITK_INFO << " Mappers comparison: "
<< (m_TestAspects & CMP_Mappers ? (m_MappersPassed ? "pass" : "fail") : "skipped");
MITK_INFO << " Interactors comparison: "
<< (m_TestAspects & CMP_Interactors ? (m_InteractorsPassed ? "pass" : "fail") : "skipped");
if (m_AspectsFailed == 0)
MITK_INFO << " Summary: ALL PASSED";
else
MITK_INFO << " Summary: " << m_AspectsFailed << " failures";
}
void mitk::DataStorageCompare::DescribeHierarchyOfNodes(DataStorage::ConstPointer storage,
HierarchyDescriptorMap &result)
{
result.clear();
if (storage.IsNull())
return;
mitk::DataStorage::SetOfObjects::ConstPointer allNodes = storage->GetAll();
for (auto node : *allNodes)
{
std::string descriptor = GenerateHierarchyDescriptor(node, storage);
result.insert(std::make_pair(descriptor, node));
}
}
std::string mitk::DataStorageCompare::GenerateNodeDescriptor(mitk::DataNode::Pointer node)
{
if (node.IsNull())
return "nullptr";
std::string thisDataDescriptor = "nullptr";
mitk::BaseData *data = node->GetData();
if (data != nullptr)
thisDataDescriptor = data->GetNameOfClass();
std::string thisNodeName = node->GetName();
std::string thisNodesDescriptor = std::string("_") + thisDataDescriptor + "_(" + thisNodeName + ")";
return thisNodesDescriptor;
}
std::string mitk::DataStorageCompare::GenerateHierarchyDescriptor(mitk::DataNode::Pointer node,
mitk::DataStorage::ConstPointer storage)
{
std::string thisNodesDescriptor = GenerateNodeDescriptor(node);
mitk::DataStorage::SetOfObjects::ConstPointer parents =
storage->GetSources(node, nullptr, true); // direct sources without filter
// construct descriptors for parents
std::vector<std::string> parentDescriptors;
- for (auto parent : *parents)
+ for (const auto &parent : *parents)
parentDescriptors.push_back(GenerateHierarchyDescriptor(parent, storage));
// sort descriptors (we don't want to rely on potentially random order of parents)
std::sort(parentDescriptors.begin(), parentDescriptors.end());
// construct a string from all sorted parent descriptors
if (!parentDescriptors.empty())
{
thisNodesDescriptor += " <(";
- for (auto descriptor : parentDescriptors)
+ for (const auto &descriptor : parentDescriptors)
{
if (descriptor != parentDescriptors.front()) // join by '+'
{
thisNodesDescriptor += " + ";
}
thisNodesDescriptor += descriptor;
}
thisNodesDescriptor += ")";
}
return thisNodesDescriptor;
}
bool mitk::DataStorageCompare::CompareHierarchy(bool verbose)
{
int numberOfMisMatches = 0;
// check for each reference storage entry
// if it can be found in test storage with
// an identical hierarchy descriptor.
// Compare just counts because there might be
// multiple nodes that have the same name / type / etc.
- for (auto entry : m_RefNodesByHierarchy)
+ for (const auto &entry : m_RefNodesByHierarchy)
{
const std::string &key = entry.first;
const mitk::DataNode::Pointer &node = entry.second;
unsigned int timesInReference = m_RefNodesByHierarchy.count(key);
unsigned int timesInTest = m_TestNodesByHierarchy.count(key);
if (timesInTest != timesInReference)
{
++numberOfMisMatches;
if (verbose)
{
MITK_WARN << "### Hierarchy mismatch problem";
MITK_WARN << " Reference storage has " << timesInReference << " node(s), test storage " << timesInTest;
MITK_WARN << " Node name '" << node->GetName() << "'";
MITK_WARN << " Reference hierarchy descriptor: " << key;
}
}
}
// test also keys that are _only_ in test!
- for (auto entry : m_TestNodesByHierarchy)
+ for (const auto &entry : m_TestNodesByHierarchy)
{
const std::string &key = entry.first;
const mitk::DataNode::Pointer &node = entry.second;
unsigned int timesInReference = m_RefNodesByHierarchy.count(key);
unsigned int timesInTest = m_TestNodesByHierarchy.count(key);
// we already tested all items in reference storage.
// Here we want to test additional items in test storage.
if (timesInTest > timesInReference)
{
++numberOfMisMatches;
if (verbose)
{
MITK_WARN << "### Hierarchy mismatch problem";
MITK_WARN << " Test storage has more nodes (" << timesInReference << ") than reference storage ("
<< timesInTest << ")";
MITK_WARN << " Node name '" << node->GetName() << "'";
MITK_WARN << " Reference hierarchy descriptor: " << key;
}
}
}
// for debug purposes we provide a dump of the test storage
// in error cases. This can be compared to the test case
// by a programmer.
if (verbose && numberOfMisMatches > 0)
{
MITK_WARN << "Dumping test storage because there were errors:";
- for (auto entry : m_TestNodesByHierarchy)
+ for (const auto &entry : m_TestNodesByHierarchy)
{
const std::string &key = entry.first;
const mitk::DataNode::Pointer &node = entry.second;
MITK_WARN << " Test node '" << node->GetName() << "', hierarchy : " << key;
}
}
return numberOfMisMatches == 0;
}
bool mitk::DataStorageCompare::AreNodesEqual(const mitk::DataNode *reference, const mitk::DataNode *test, bool verbose)
{
if (reference == nullptr && test == nullptr)
return true;
if (reference == nullptr && test != nullptr)
{
if (verbose)
MITK_WARN << " Reference node is nullptr, test node is not (type " << test->GetNameOfClass() << ")";
return false;
}
if (reference != nullptr && test == nullptr)
{
if (verbose)
MITK_WARN << " Test node is nullptr, reference node is not (type " << reference->GetNameOfClass() << ")";
return false;
}
if (m_TestAspects & CMP_Data)
m_DataPassed &= IsDataEqual(reference->GetData(), test->GetData(), verbose);
if (m_TestAspects & CMP_Properties)
m_PropertiesPassed &= ArePropertyListsEqual(*reference, *test, verbose);
if (m_TestAspects & CMP_Mappers)
m_MappersPassed &= AreMappersEqual(*reference, *test, verbose);
// .. add interactors/mappers
// two real nodes, need to really compare
return m_AspectsFailed == 0;
}
bool mitk::DataStorageCompare::IsDataEqual(const mitk::BaseData *reference, const mitk::BaseData *test, bool verbose)
{
// early-out for nullptrs
if (reference == nullptr && test == nullptr)
return true;
if (reference == nullptr && test != nullptr)
{
if (verbose)
MITK_WARN << " Reference data is nullptr, test data is not (type " << test->GetNameOfClass() << ")";
return false;
}
if (reference != nullptr && test == nullptr)
{
if (verbose)
MITK_WARN << " Test data is nullptr, reference data is not (type " << reference->GetNameOfClass() << ")";
return false;
}
// two real BaseData objects, need to really compare
if (reference->GetNameOfClass() != test->GetNameOfClass())
{
if (verbose)
MITK_WARN << " Mismatch: Reference data is '" << reference->GetNameOfClass() << "', "
<< "test data is '" << test->GetNameOfClass() << "'";
return false;
}
try
{
std::string ldapFilter = std::string("(basedata=") + reference->GetNameOfClass() + "*)";
std::vector<us::ServiceReference<BaseDataCompare>> comparators =
us::GetModuleContext()->GetServiceReferences<BaseDataCompare>(ldapFilter);
if (comparators.empty())
{
// bad, no comparator found, cannot compare
MITK_ERROR << "Comparison error: no comparator for objects of type '" << reference->GetNameOfClass() << "'";
return false;
}
else if (comparators.size() > 1)
{
MITK_WARN << "Comparison warning: multiple comparisons possible for objects of type '"
<< reference->GetNameOfClass() << "'. Using just one.";
// bad, multiple comparators, need to add ranking or something
}
auto *comparator = us::GetModuleContext()->GetService<BaseDataCompare>(comparators.front());
if (!comparator)
{
MITK_ERROR << "Service lookup error, cannot get comparator for class " << reference->GetNameOfClass();
}
return comparator->AreEqual(reference, test, m_Eps, verbose);
}
catch (std::exception &e)
{
MITK_ERROR << "Exception during comparison: " << e.what();
return false;
}
}
bool mitk::DataStorageCompare::ArePropertyListsEqual(const mitk::DataNode &reference,
const mitk::DataNode &test,
bool verbose)
{
DataNode::PropertyListKeyNames refListNames = reference.GetPropertyListNames();
DataNode::PropertyListKeyNames testListNames = test.GetPropertyListNames();
// add the empty names to treat all lists equally
refListNames.push_back("");
testListNames.push_back("");
// verify that list names are identical
bool error = false;
if (refListNames.size() != testListNames.size())
{
- for (auto name : refListNames)
+ for (const auto &name : refListNames)
if (std::find(testListNames.begin(), testListNames.end(), name) == testListNames.end())
{
MITK_WARN << "Propertylist '" << name << "' from reference node (" << reference.GetName()
<< ") not found in test node.";
error = true;
}
- for (auto name : testListNames)
+ for (const auto &name : testListNames)
if (std::find(refListNames.begin(), refListNames.end(), name) == refListNames.end())
{
MITK_WARN << "Propertylist '" << name << "' did not exist in reference node (" << reference.GetName()
<< "), but is present in test node.";
error = true;
}
if (error)
return false;
}
// compare each list
- for (auto name : refListNames)
+ for (const auto &name : refListNames)
{
if (!ArePropertyListsEqual(*(reference.GetPropertyList(name)), *(test.GetPropertyList(name)), verbose))
{
MITK_WARN << "Property mismatch while comparing propertylist '" << name << "'. See messages above.";
error = true;
}
}
return !error;
}
bool mitk::DataStorageCompare::ArePropertyListsEqual(const mitk::PropertyList &reference,
const mitk::PropertyList &test,
bool verbose)
{
const mitk::PropertyList::PropertyMap *refMap = reference.GetMap();
bool error = false;
- for (auto refEntry : *refMap)
+ for (const auto &refEntry : *refMap)
{
std::string propertyKey = refEntry.first;
BaseProperty::Pointer refProperty = refEntry.second;
BaseProperty::Pointer testProperty = test.GetProperty(propertyKey);
if (testProperty.IsNull())
{
if (verbose)
MITK_WARN << "Property '" << propertyKey << "' not found in test, only in reference.";
error = true;
}
else
{
if (!(*refProperty == *testProperty))
{
if (verbose)
{
MITK_WARN << "Property '" << propertyKey << "' does not match original.";
MITK_WARN << "Reference was: " << refProperty->GetValueAsString();
MITK_WARN << "Test was:" << testProperty->GetValueAsString();
}
error = true;
}
}
}
return !error;
}
bool mitk::DataStorageCompare::AreMappersEqual(const mitk::DataNode &reference,
const mitk::DataNode &test,
bool verbose)
{
bool error = false;
mitk::Mapper *refMapper2D = reference.GetMapper(mitk::BaseRenderer::Standard2D);
mitk::Mapper *testMapper2D = test.GetMapper(mitk::BaseRenderer::Standard2D);
if (refMapper2D == nullptr && testMapper2D == nullptr)
{
; // ok
}
else if (refMapper2D != nullptr && testMapper2D == nullptr)
{
if (verbose)
{
MITK_WARN << "Mapper for 2D was '" << refMapper2D->GetNameOfClass() << "' in reference, is 'nullptr"
<< "' in test (DataNode '" << reference.GetName() << "')";
}
error = true;
}
else if (refMapper2D == nullptr && testMapper2D != nullptr)
{
if (verbose)
{
MITK_WARN << "Mapper for 2D was 'nullptr"
<< "' in reference, is '" << testMapper2D->GetNameOfClass() << "' in test (DataNode '"
<< reference.GetName() << "')";
}
error = true;
} // else both are valid pointers, we just compare the type
else if (refMapper2D->GetNameOfClass() != testMapper2D->GetNameOfClass())
{
if (verbose)
{
MITK_WARN << "Mapper for 2D was '" << refMapper2D->GetNameOfClass() << "' in reference, is '"
<< testMapper2D->GetNameOfClass() << "' in test (DataNode '" << reference.GetName() << "')";
}
error = true;
}
mitk::Mapper *refMapper3D = reference.GetMapper(mitk::BaseRenderer::Standard3D);
mitk::Mapper *testMapper3D = test.GetMapper(mitk::BaseRenderer::Standard3D);
if (refMapper3D == nullptr && testMapper3D == nullptr)
{
; // ok
}
else if (refMapper3D != nullptr && testMapper3D == nullptr)
{
if (verbose)
{
MITK_WARN << "Mapper for 3D was '" << refMapper3D->GetNameOfClass() << "' in reference, is 'nullptr"
<< "' in test (DataNode '" << reference.GetName() << "')";
}
error = true;
}
else if (refMapper3D == nullptr && testMapper3D != nullptr)
{
if (verbose)
{
MITK_WARN << "Mapper for 3D was 'nullptr"
<< "' in reference, is '" << testMapper3D->GetNameOfClass() << "' in test (DataNode '"
<< reference.GetName() << "')";
}
error = true;
} // else both are valid pointers, we just compare the type
else if (refMapper3D->GetNameOfClass() != testMapper3D->GetNameOfClass())
{
if (verbose)
{
MITK_WARN << "Mapper for 3D was '" << refMapper3D->GetNameOfClass() << "' in reference, is '"
<< testMapper3D->GetNameOfClass() << "' in test (DataNode '" << reference.GetName() << "')";
}
error = true;
}
return !error;
}
bool mitk::DataStorageCompare::CompareDataNodes(bool verbose)
{
int numberOfMisMatches = 0;
- for (auto entry : m_RefNodesByHierarchy)
+ for (const auto &entry : m_RefNodesByHierarchy)
{
const std::string &key = entry.first;
const mitk::DataNode::Pointer &refNode = entry.second;
unsigned int timesInReference = m_RefNodesByHierarchy.count(key);
unsigned int timesInTest = m_TestNodesByHierarchy.count(key);
if (timesInReference == 1 && timesInTest == 1)
{
// go on an compare those two
auto testEntry = m_TestNodesByHierarchy.find(key);
mitk::DataNode::Pointer testNode = testEntry->second;
if (!AreNodesEqual(refNode, testNode, verbose))
{
++numberOfMisMatches;
if (verbose)
{
MITK_WARN << "### DataNode mismatch problem";
MITK_WARN << " Node '" << key << "' did not compare to equal (see warnings above).";
}
}
}
else
{
++numberOfMisMatches;
if (verbose)
{
MITK_WARN << "### DataNode mismatch problem";
MITK_WARN << " Reference storage has " << timesInReference << " node(s), test storage " << timesInTest;
MITK_WARN << " This does not match or we don't know how to figure out comparison partners";
}
}
}
return numberOfMisMatches == 0;
}
diff --git a/Modules/Segmentation/Algorithms/mitkContourUtils.h b/Modules/Segmentation/Algorithms/mitkContourUtils.h
index 3040e042fa..66bb8b4a97 100644
--- a/Modules/Segmentation/Algorithms/mitkContourUtils.h
+++ b/Modules/Segmentation/Algorithms/mitkContourUtils.h
@@ -1,71 +1,73 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkContourUtilshIncludett
#define mitkContourUtilshIncludett
#include "mitkContour.h"
#include "mitkContourModel.h"
#include "mitkImage.h"
#include <MitkSegmentationExports.h>
namespace mitk
{
/**
* \brief Helpful methods for working with contours and images
*
* Legacy support for mitk::Contour
* TODO remove this class when mitk::Contour is removed
*/
class MITKSEGMENTATION_EXPORT ContourUtils : public itk::Object
{
public:
mitkClassMacroItkParent(ContourUtils, itk::Object);
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
/**
\brief Projects a contour onto an image point by point. Converts from world to index coordinates.
\param slice
\param contourIn3D
\param correctionForIpSegmentation adds 0.5 to x and y index coordinates (difference between ipSegmentation and
MITK contours)
\param constrainToInside
*/
ContourModel::Pointer ProjectContourTo2DSlice(Image *slice,
Contour *contourIn3D,
bool correctionForIpSegmentation,
bool constrainToInside);
/**
\brief Projects a slice index coordinates of a contour back into world coordinates.
- \param correctionForIpSegmentation subtracts 0.5 to x and y index coordinates (difference between
+ \param sliceGeometry
+ \param contourIn2D
+ \param correctionForIpSegmentation subtracts 0.5 to x and y index coordinates (difference between
ipSegmentation and MITK contours)
*/
ContourModel::Pointer BackProjectContourFrom2DSlice(const BaseGeometry *sliceGeometry,
Contour *contourIn2D,
bool correctionForIpSegmentation = false);
/**
\brief Fill a contour in a 2D slice with a specified pixel value.
*/
void FillContourInSlice(Contour *projectedContour, Image *sliceImage, int paintingPixelValue = 1);
protected:
ContourUtils();
~ContourUtils() override;
};
}
#endif
diff --git a/Modules/Segmentation/Algorithms/mitkDiffSliceOperation.cpp b/Modules/Segmentation/Algorithms/mitkDiffSliceOperation.cpp
index 1b0c4598da..bab4084f3e 100644
--- a/Modules/Segmentation/Algorithms/mitkDiffSliceOperation.cpp
+++ b/Modules/Segmentation/Algorithms/mitkDiffSliceOperation.cpp
@@ -1,100 +1,100 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkDiffSliceOperation.h"
#include <mitkImage.h>
#include <itkCommand.h>
mitk::DiffSliceOperation::DiffSliceOperation() : Operation(1)
{
m_TimeStep = 0;
m_zlibSliceContainer = nullptr;
m_Image = nullptr;
m_WorldGeometry = nullptr;
m_SliceGeometry = nullptr;
m_ImageIsValid = false;
m_DeleteObserverTag = 0;
}
-mitk::DiffSliceOperation::DiffSliceOperation(mitk::Image *imageVolume,
- Image *slice,
- SlicedGeometry3D *sliceGeometry,
- unsigned int timestep,
- BaseGeometry *currentWorldGeometry)
+mitk::DiffSliceOperation::DiffSliceOperation(Image *imageVolume,
+ const Image *slice,
+ const SlicedGeometry3D *sliceGeometry,
+ TimeStepType timestep,
+ const BaseGeometry *currentWorldGeometry)
: Operation(1)
{
m_WorldGeometry = currentWorldGeometry->Clone();
/*
Quick fix for bug 12338.
Guard object - fix this when clone method of PlaneGeometry is cloning the reference geometry (see bug 13392)*/
// xxxx m_GuardReferenceGeometry = mitk::BaseGeometry::New();
- m_GuardReferenceGeometry = dynamic_cast<mitk::PlaneGeometry *>(m_WorldGeometry.GetPointer())->GetReferenceGeometry();
+ m_GuardReferenceGeometry = dynamic_cast<const PlaneGeometry *>(m_WorldGeometry.GetPointer())->GetReferenceGeometry();
/*---------------------------------------------------------------------------------------------------*/
m_SliceGeometry = sliceGeometry->Clone();
m_TimeStep = timestep;
m_zlibSliceContainer = CompressedImageContainer::New();
m_zlibSliceContainer->SetImage(slice);
m_Image = imageVolume;
m_DeleteObserverTag = 0;
if (m_Image)
{
/*add an observer to listen to the delete event of the image, this is necessary because the operation is then
* invalid*/
itk::SimpleMemberCommand<DiffSliceOperation>::Pointer command = itk::SimpleMemberCommand<DiffSliceOperation>::New();
command->SetCallbackFunction(this, &DiffSliceOperation::OnImageDeleted);
// get the id of the observer, used to remove it later on
m_DeleteObserverTag = imageVolume->AddObserver(itk::DeleteEvent(), command);
m_ImageIsValid = true;
}
else
m_ImageIsValid = false;
}
mitk::DiffSliceOperation::~DiffSliceOperation()
{
m_WorldGeometry = nullptr;
m_zlibSliceContainer = nullptr;
if (m_ImageIsValid)
{
// if the image is still there, we have to remove the observer from it
m_Image->RemoveObserver(m_DeleteObserverTag);
}
m_Image = nullptr;
}
mitk::Image::Pointer mitk::DiffSliceOperation::GetSlice()
{
Image::Pointer image = m_zlibSliceContainer->GetImage();
return image;
}
bool mitk::DiffSliceOperation::IsValid()
{
return m_ImageIsValid && m_zlibSliceContainer.IsNotNull() && (m_WorldGeometry.IsNotNull()); // TODO improve
}
void mitk::DiffSliceOperation::OnImageDeleted()
{
// if our imageVolume is removed e.g. from the datastorage the operation is no lnger valid
m_ImageIsValid = false;
}
diff --git a/Modules/Segmentation/Algorithms/mitkDiffSliceOperation.h b/Modules/Segmentation/Algorithms/mitkDiffSliceOperation.h
index 1ed4d8aa0c..9647976b40 100644
--- a/Modules/Segmentation/Algorithms/mitkDiffSliceOperation.h
+++ b/Modules/Segmentation/Algorithms/mitkDiffSliceOperation.h
@@ -1,109 +1,101 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkDiffSliceOperation_h_Included
#define mitkDiffSliceOperation_h_Included
#include "mitkCompressedImageContainer.h"
#include <MitkSegmentationExports.h>
#include <mitkOperation.h>
#include <vtkSmartPointer.h>
namespace mitk
{
class Image;
/** \brief An Operation for applying an edited slice to the volume.
\sa DiffSliceOperationApplier
The information for the operation is specified by properties:
imageVolume the volume where the slice was extracted from.
slice the slice to be applied.
timestep the timestep in an 4D image.
currentWorldGeometry specifies the axis where the slice has to be applied in the volume.
This Operation can be used to realize undo-redo functionality for e.g. segmentation purposes.
*/
class MITKSEGMENTATION_EXPORT DiffSliceOperation : public Operation
{
public:
mitkClassMacro(DiffSliceOperation, OperationActor);
// itkFactorylessNewMacro(Self)
// itkCloneMacro(Self)
// mitkNewMacro4Param(DiffSliceOperation,mitk::Image,mitk::Image,unsigned int, mitk::PlaneGeometry);
/** \brief Creates an empty instance.
Note that it is not valid yet. The properties of the object have to be set.
*/
DiffSliceOperation();
/** \brief */
DiffSliceOperation(mitk::Image *imageVolume,
- mitk::Image *slice,
- SlicedGeometry3D *sliceGeometry,
- unsigned int timestep,
- BaseGeometry *currentWorldGeometry);
+ const mitk::Image *slice,
+ const SlicedGeometry3D *sliceGeometry,
+ const TimeStepType timestep,
+ const BaseGeometry *currentWorldGeometry);
/** \brief Check if it is a valid operation.*/
bool IsValid();
- /** \brief Set the image volume.*/
- void SetImage(mitk::Image *image) { this->m_Image = image; }
/** \brief Get th image volume.*/
mitk::Image *GetImage() { return this->m_Image; }
- /** \brief Set thee slice to be applied.*/
- void SetImage(vtkImageData *slice) { this->m_Slice = slice; }
+ const mitk::Image* GetImage() const { return this->m_Image; }
+
/** \brief Get the slice that is applied in the operation.*/
Image::Pointer GetSlice();
- /** \brief Get timeStep.*/
- void SetTimeStep(unsigned int timestep) { this->m_TimeStep = timestep; }
/** \brief Set timeStep*/
- unsigned int GetTimeStep() { return this->m_TimeStep; }
- /** \brief Set the axis where the slice has to be applied in the volume.*/
- void SetSliceGeometry(SlicedGeometry3D *sliceGeometry) { this->m_SliceGeometry = sliceGeometry; }
+ TimeStepType GetTimeStep() const { return this->m_TimeStep; }
/** \brief Get the axis where the slice has to be applied in the volume.*/
- SlicedGeometry3D *GetSliceGeometry() { return this->m_SliceGeometry; }
- /** \brief Set the axis where the slice has to be applied in the volume.*/
- void SetCurrentWorldGeometry(BaseGeometry *worldGeometry) { this->m_WorldGeometry = worldGeometry; }
+ const SlicedGeometry3D *GetSliceGeometry() const { return this->m_SliceGeometry; }
/** \brief Get the axis where the slice has to be applied in the volume.*/
- BaseGeometry *GetWorldGeometry() { return this->m_WorldGeometry; }
+ const BaseGeometry *GetWorldGeometry() const { return this->m_WorldGeometry; }
protected:
~DiffSliceOperation() override;
/** \brief Callback for image observer.*/
void OnImageDeleted();
CompressedImageContainer::Pointer m_zlibSliceContainer;
mitk::Image *m_Image;
vtkSmartPointer<vtkImageData> m_Slice;
- SlicedGeometry3D::Pointer m_SliceGeometry;
+ SlicedGeometry3D::ConstPointer m_SliceGeometry;
- unsigned int m_TimeStep;
+ TimeStepType m_TimeStep;
- BaseGeometry::Pointer m_WorldGeometry;
+ BaseGeometry::ConstPointer m_WorldGeometry;
bool m_ImageIsValid;
unsigned long m_DeleteObserverTag;
mitk::BaseGeometry::ConstPointer m_GuardReferenceGeometry;
};
}
#endif
diff --git a/Modules/Segmentation/Algorithms/mitkDiffSliceOperationApplier.cpp b/Modules/Segmentation/Algorithms/mitkDiffSliceOperationApplier.cpp
index b34a65bc09..6c666c1b36 100644
--- a/Modules/Segmentation/Algorithms/mitkDiffSliceOperationApplier.cpp
+++ b/Modules/Segmentation/Algorithms/mitkDiffSliceOperationApplier.cpp
@@ -1,89 +1,89 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkDiffSliceOperationApplier.h"
#include "mitkDiffSliceOperation.h"
#include "mitkRenderingManager.h"
#include "mitkSegTool2D.h"
#include <mitkExtractSliceFilter.h>
#include <mitkVtkImageOverwrite.h>
// VTK
#include <vtkSmartPointer.h>
mitk::DiffSliceOperationApplier::DiffSliceOperationApplier()
{
}
mitk::DiffSliceOperationApplier::~DiffSliceOperationApplier()
{
}
void mitk::DiffSliceOperationApplier::ExecuteOperation(Operation *operation)
{
auto *imageOperation = dynamic_cast<DiffSliceOperation *>(operation);
// as we only support DiffSliceOperation return if operation is not type of DiffSliceOperation
if (!imageOperation)
return;
// chak if the operation is valid
if (imageOperation->IsValid())
{
// the actual overwrite filter (vtk)
vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
mitk::Image::Pointer slice = imageOperation->GetSlice();
// Set the slice as 'input'
reslice->SetInputSlice(slice->GetVtkImageData());
// set overwrite mode to true to write back to the image volume
reslice->SetOverwriteMode(true);
reslice->Modified();
// a wrapper for vtkImageOverwrite
mitk::ExtractSliceFilter::Pointer extractor = mitk::ExtractSliceFilter::New(reslice);
extractor->SetInput(imageOperation->GetImage());
extractor->SetTimeStep(imageOperation->GetTimeStep());
- extractor->SetWorldGeometry(dynamic_cast<PlaneGeometry *>(imageOperation->GetWorldGeometry()));
+ extractor->SetWorldGeometry(dynamic_cast<const PlaneGeometry *>(imageOperation->GetWorldGeometry()));
extractor->SetVtkOutputRequest(true);
extractor->SetResliceTransformByGeometry(imageOperation->GetImage()->GetGeometry(imageOperation->GetTimeStep()));
extractor->Modified();
extractor->Update();
// make sure the modification is rendered
RenderingManager::GetInstance()->RequestUpdateAll();
imageOperation->GetImage()->Modified();
mitk::ExtractSliceFilter::Pointer extractor2 = mitk::ExtractSliceFilter::New();
extractor2->SetInput(imageOperation->GetImage());
extractor2->SetTimeStep(imageOperation->GetTimeStep());
- extractor2->SetWorldGeometry(dynamic_cast<PlaneGeometry *>(imageOperation->GetWorldGeometry()));
+ extractor2->SetWorldGeometry(dynamic_cast<const PlaneGeometry *>(imageOperation->GetWorldGeometry()));
extractor2->SetResliceTransformByGeometry(imageOperation->GetImage()->GetGeometry(imageOperation->GetTimeStep()));
extractor2->Modified();
extractor2->Update();
// TODO Move this code to SurfaceInterpolationController!
mitk::Image::Pointer slice2 = extractor2->GetOutput();
- mitk::PlaneGeometry::Pointer plane = dynamic_cast<PlaneGeometry *>(imageOperation->GetWorldGeometry());
+ mitk::PlaneGeometry::ConstPointer plane = dynamic_cast<const PlaneGeometry *>(imageOperation->GetWorldGeometry());
slice2->DisconnectPipeline();
mitk::SegTool2D::UpdateSurfaceInterpolation(slice2, imageOperation->GetImage(), plane, true);
}
}
mitk::DiffSliceOperationApplier *mitk::DiffSliceOperationApplier::GetInstance()
{
static auto *s_Instance = new DiffSliceOperationApplier();
return s_Instance;
}
diff --git a/Modules/Segmentation/Algorithms/mitkImageLiveWireContourModelFilter.h b/Modules/Segmentation/Algorithms/mitkImageLiveWireContourModelFilter.h
index 1b923b58b2..b3c2f482d5 100644
--- a/Modules/Segmentation/Algorithms/mitkImageLiveWireContourModelFilter.h
+++ b/Modules/Segmentation/Algorithms/mitkImageLiveWireContourModelFilter.h
@@ -1,162 +1,156 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef _mitkImageLiveWireContourModelFilter_h__
#define _mitkImageLiveWireContourModelFilter_h__
#include "mitkCommon.h"
#include "mitkContourModel.h"
#include "mitkContourModelSource.h"
#include <MitkSegmentationExports.h>
#include <mitkImage.h>
#include <mitkImageAccessByItk.h>
#include <mitkImageCast.h>
#include <itkShortestPathCostFunctionLiveWire.h>
#include <itkShortestPathImageFilter.h>
namespace mitk
{
/**
\brief Calculates a LiveWire contour between two points in an image.
For defining costs between two pixels specific features are extraced from the image and tranformed into a single cost
value.
\sa ShortestPathCostFunctionLiveWire
The filter is able to create dynamic cost tranfer map and thus use on the fly training.
\note On the fly training will only be used for next update.
The computation uses the last calculated segment to map cost according to features in the area of the segment.
- For time resolved purposes use ImageLiveWireContourModelFilter::SetTimestep( unsigned int ) to create the LiveWire
- contour
- at a specific timestep.
+ Caution: time support currently not available. Filter will always work on the first
+ timestep in its current implementation.
\ingroup ContourModelFilters
\ingroup Process
*/
class MITKSEGMENTATION_EXPORT ImageLiveWireContourModelFilter : public ContourModelSource
{
public:
mitkClassMacro(ImageLiveWireContourModelFilter, ContourModelSource);
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
typedef ContourModel OutputType;
typedef OutputType::Pointer OutputTypePointer;
typedef mitk::Image InputType;
typedef itk::Image<float, 2> InternalImageType;
typedef itk::ShortestPathImageFilter<InternalImageType, InternalImageType> ShortestPathImageFilterType;
typedef itk::ShortestPathCostFunctionLiveWire<InternalImageType> CostFunctionType;
typedef std::vector<itk::Index<2>> ShortestPathType;
/** \brief start point in world coordinates*/
itkSetMacro(StartPoint, mitk::Point3D);
itkGetMacro(StartPoint, mitk::Point3D);
/** \brief end point in woorld coordinates*/
itkSetMacro(EndPoint, mitk::Point3D);
itkGetMacro(EndPoint, mitk::Point3D);
/** \brief Create dynamic cost tranfer map - use on the fly training.
\note On the fly training will be used for next update only.
The computation uses the last calculated segment to map cost according to features in the area of the segment.
*/
itkSetMacro(UseDynamicCostMap, bool);
itkGetMacro(UseDynamicCostMap, bool);
- /** \brief Actual time step
- */
- itkSetMacro(TimeStep, unsigned int);
- itkGetMacro(TimeStep, unsigned int);
-
/** \brief Clear all repulsive points used in the cost function
*/
void ClearRepulsivePoints();
/** \brief Set a vector with repulsive points to use in the cost function
*/
void SetRepulsivePoints(const ShortestPathType &points);
/** \brief Add a single repulsive point to the cost function
*/
void AddRepulsivePoint(const itk::Index<2> &idx);
/** \brief Remove a single repulsive point from the cost function
*/
void RemoveRepulsivePoint(const itk::Index<2> &idx);
virtual void SetInput(const InputType *input);
using Superclass::SetInput;
virtual void SetInput(unsigned int idx, const InputType *input);
const InputType *GetInput(void);
const InputType *GetInput(unsigned int idx);
virtual OutputType *GetOutput();
virtual void DumpMaskImage();
/** \brief Create dynamic cost tranfer map - on the fly training*/
bool CreateDynamicCostMap(mitk::ContourModel *path = nullptr);
protected:
ImageLiveWireContourModelFilter();
~ImageLiveWireContourModelFilter() override;
void GenerateOutputInformation() override{};
void GenerateData() override;
void UpdateLiveWire();
/** \brief start point in worldcoordinates*/
mitk::Point3D m_StartPoint;
/** \brief end point in woorldcoordinates*/
mitk::Point3D m_EndPoint;
/** \brief Start point in index*/
mitk::Point3D m_StartPointInIndex;
/** \brief End point in index*/
mitk::Point3D m_EndPointInIndex;
/** \brief The cost function to compute costs between two pixels*/
CostFunctionType::Pointer m_CostFunction;
/** \brief Shortest path filter according to cost function m_CostFunction*/
ShortestPathImageFilterType::Pointer m_ShortestPathFilter;
/** \brief Flag to use a dynmic cost map or not*/
bool m_UseDynamicCostMap;
unsigned int m_TimeStep;
template <typename TPixel, unsigned int VImageDimension>
void ItkPreProcessImage(const itk::Image<TPixel, VImageDimension> *inputImage);
template <typename TPixel, unsigned int VImageDimension>
void CreateDynamicCostMapByITK(const itk::Image<TPixel, VImageDimension> *inputImage,
mitk::ContourModel *path = nullptr);
InternalImageType::Pointer m_InternalImage;
};
}
#endif
diff --git a/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.cpp b/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.cpp
index 96ba360d0f..647fa8b80d 100644
--- a/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.cpp
@@ -1,97 +1,130 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkAutoSegmentationTool.h"
#include "mitkImage.h"
#include "mitkToolManager.h"
#include <mitkImageTimeSelector.h>
mitk::AutoSegmentationTool::AutoSegmentationTool() : Tool("dummy"), m_OverwriteExistingSegmentation(false)
{
}
+mitk::AutoSegmentationTool::AutoSegmentationTool(const char* interactorType, const us::Module* interactorModule) : Tool(interactorType, interactorModule), m_OverwriteExistingSegmentation(false)
+{
+}
+
mitk::AutoSegmentationTool::~AutoSegmentationTool()
{
}
+void mitk::AutoSegmentationTool::Activated()
+{
+ Superclass::Activated();
+
+ m_NoneOverwriteTargetSegmentationNode = nullptr;
+}
+
+void mitk::AutoSegmentationTool::Deactivated()
+{
+ m_NoneOverwriteTargetSegmentationNode = nullptr;
+
+ Superclass::Deactivated();
+}
+
const char *mitk::AutoSegmentationTool::GetGroup() const
{
return "autoSegmentation";
}
mitk::Image::ConstPointer mitk::AutoSegmentationTool::GetImageByTimeStep(const mitk::Image* image, unsigned int timestep)
{
if (nullptr == image)
return image;
if (image->GetDimension() != 4)
return image;
mitk::ImageTimeSelector::Pointer imageTimeSelector = mitk::ImageTimeSelector::New();
imageTimeSelector->SetInput(image);
imageTimeSelector->SetTimeNr(static_cast<int>(timestep));
imageTimeSelector->UpdateLargestPossibleRegion();
return imageTimeSelector->GetOutput();
}
mitk::Image::ConstPointer mitk::AutoSegmentationTool::GetImageByTimePoint(const mitk::Image* image, TimePointType timePoint)
{
if (nullptr == image)
return image;
if (!image->GetTimeGeometry()->IsValidTimePoint(timePoint))
return nullptr;
return AutoSegmentationTool::GetImageByTimeStep(image, image->GetTimeGeometry()->TimePointToTimeStep(timePoint));
}
void mitk::AutoSegmentationTool::SetOverwriteExistingSegmentation(bool overwrite)
{
- m_OverwriteExistingSegmentation = overwrite;
+ if (m_OverwriteExistingSegmentation != overwrite)
+ {
+ m_OverwriteExistingSegmentation = overwrite;
+ m_NoneOverwriteTargetSegmentationNode = nullptr;
+ }
}
std::string mitk::AutoSegmentationTool::GetCurrentSegmentationName()
{
if (m_ToolManager->GetWorkingData(0))
return m_ToolManager->GetWorkingData(0)->GetName();
else
return "";
}
-mitk::DataNode *mitk::AutoSegmentationTool::GetTargetSegmentationNode()
+mitk::DataNode *mitk::AutoSegmentationTool::GetTargetSegmentationNode() const
{
mitk::DataNode::Pointer segmentationNode = m_ToolManager->GetWorkingData(0);
if (!m_OverwriteExistingSegmentation)
{
- mitk::DataNode::Pointer refNode = m_ToolManager->GetReferenceData(0);
- if (refNode.IsNull())
+ if (m_NoneOverwriteTargetSegmentationNode.IsNull())
{
- // TODO create and use segmentation exceptions instead!!
- MITK_ERROR << "No valid reference data!";
- return nullptr;
+ mitk::DataNode::Pointer refNode = m_ToolManager->GetReferenceData(0);
+ if (refNode.IsNull())
+ {
+ // TODO create and use segmentation exceptions instead!!
+ MITK_ERROR << "No valid reference data!";
+ return nullptr;
+ }
+
+ std::string nodename = refNode->GetName() + "_" + this->GetName();
+ mitk::Color color;
+ color.SetRed(1);
+ color.SetBlue(0);
+ color.SetGreen(0);
+ //create a new segmentation node based on the current segmentation as template
+ m_NoneOverwriteTargetSegmentationNode = CreateEmptySegmentationNode(dynamic_cast<mitk::Image*>(segmentationNode->GetData()), nodename, color);
}
-
- std::string nodename = refNode->GetName() + "_" + this->GetName();
- mitk::Color color;
- color.SetRed(1);
- color.SetBlue(0);
- color.SetGreen(0);
- //create a new segmentation node based on the current segmentation as template
- segmentationNode = CreateEmptySegmentationNode(dynamic_cast<mitk::Image *>(segmentationNode->GetData()), nodename, color);
-
- m_ToolManager->GetDataStorage()->Add(segmentationNode, refNode);
+ segmentationNode = m_NoneOverwriteTargetSegmentationNode;
}
return segmentationNode;
}
+
+void mitk::AutoSegmentationTool::EnsureTargetSegmentationNodeInDataStorage() const
+{
+ auto targetNode = this->GetTargetSegmentationNode();
+ if (!m_ToolManager->GetDataStorage()->Exists(targetNode))
+ {
+ m_ToolManager->GetDataStorage()->Add(targetNode, m_ToolManager->GetReferenceData(0));
+ }
+}
diff --git a/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.h b/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.h
index dfb36b908c..69624986c8 100644
--- a/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.h
+++ b/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.h
@@ -1,71 +1,84 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkAutoSegmentationTool_h_Included
#define mitkAutoSegmentationTool_h_Included
#include "mitkCommon.h"
#include "mitkTool.h"
#include <MitkSegmentationExports.h>
namespace mitk
{
class Image;
/**
\brief Superclass for tool that create a new segmentation without user interaction in render windows
This class is undocumented. Ask the creator ($Author$) to supply useful comments.
*/
class MITKSEGMENTATION_EXPORT AutoSegmentationTool : public Tool
{
public:
mitkClassMacro(AutoSegmentationTool, Tool);
+ void Activated() override;
+ void Deactivated() override;
+
/** This function controls wether a confirmed segmentation should replace the old
* segmentation/working node (true) or if it should be stored as new and additional
* node (false).
*/
void SetOverwriteExistingSegmentation(bool overwrite);
/**
* @brief Gets the name of the currently selected segmentation node
* @return the name of the segmentation node or an empty string if
* none is selected
*/
std::string GetCurrentSegmentationName();
/**
- * @brief Depending on the selected mode either returns the currently selected segmentation
- * or creates a new one from the selected reference data and adds the new segmentation
- * to the datastorage
+ * @brief Depending on the selected mode either returns the currently selected segmentation node
+ * or (if overwrite mode is false) creates a new one from the selected reference data.
+ * @remark Please keep in mind that new created nodes are not automatically added to the data storage.
+ * Derived tools can call EnsureTargetSegmentationNodeInDataStorage to ensure it as soon as it is clear
+ * that the target segmentation node will be/is confirmed.
* @return a mitk::DataNode which contains a segmentation image
*/
- virtual mitk::DataNode *GetTargetSegmentationNode();
+ virtual DataNode *GetTargetSegmentationNode() const;
protected:
AutoSegmentationTool(); // purposely hidden
+ AutoSegmentationTool(const char* interactorType, const us::Module* interactorModule = nullptr); // purposely hidden
~AutoSegmentationTool() override;
const char *GetGroup() const override;
/** Helper that extracts the image for the passed timestep, if the image has multiple time steps.*/
static Image::ConstPointer GetImageByTimeStep(const Image* image, unsigned int timestep);
/** Helper that extracts the image for the passed time point, if the image has multiple time steps.*/
static Image::ConstPointer GetImageByTimePoint(const Image* image, TimePointType timePoint);
+ void EnsureTargetSegmentationNodeInDataStorage() const;
+
bool m_OverwriteExistingSegmentation;
+
+ private:
+ /**Contains the node returned by GetTargetSementationNode if m_OverwriteExistingSegmentation == false. Then
+ * GetTargetSegmentation generates a new target segmentation node.*/
+ mutable DataNode::Pointer m_NoneOverwriteTargetSegmentationNode;
};
} // namespace
#endif
diff --git a/Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.cpp b/Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.cpp
index e8554c2228..1c52e44aad 100644
--- a/Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.cpp
@@ -1,478 +1,523 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkAutoSegmentationWithPreviewTool.h"
#include "mitkToolManager.h"
#include "mitkColorProperty.h"
#include "mitkLevelWindowProperty.h"
#include "mitkProperties.h"
#include "mitkDataStorage.h"
#include "mitkRenderingManager.h"
#include <mitkSliceNavigationController.h>
#include "mitkImageAccessByItk.h"
#include "mitkImageCast.h"
#include "mitkImageStatisticsHolder.h"
#include "mitkImageTimeSelector.h"
#include "mitkLabelSetImage.h"
#include "mitkMaskAndCutRoiImageFilter.h"
#include "mitkPadImageFilter.h"
#include "mitkNodePredicateGeometry.h"
+#include "mitkSegTool2D.h"
mitk::AutoSegmentationWithPreviewTool::AutoSegmentationWithPreviewTool(bool lazyDynamicPreviews): m_LazyDynamicPreviews(lazyDynamicPreviews)
{
m_ProgressCommand = mitk::ToolCommand::New();
}
+mitk::AutoSegmentationWithPreviewTool::AutoSegmentationWithPreviewTool(bool lazyDynamicPreviews, const char* interactorType, const us::Module* interactorModule) : AutoSegmentationTool(interactorType, interactorModule), m_LazyDynamicPreviews(lazyDynamicPreviews)
+{
+ m_ProgressCommand = mitk::ToolCommand::New();
+}
+
+
mitk::AutoSegmentationWithPreviewTool::~AutoSegmentationWithPreviewTool()
{
}
bool mitk::AutoSegmentationWithPreviewTool::CanHandle(const BaseData* referenceData, const BaseData* workingData) const
{
if (!Superclass::CanHandle(referenceData, workingData))
return false;
if (workingData == nullptr)
return true;
auto* labelSet = dynamic_cast<const LabelSetImage*>(workingData);
if (labelSet != nullptr)
return true;
auto* image = dynamic_cast<const Image*>(workingData);
if (image == nullptr)
return false;
//if it is a normal image and not a label set image is used as working data
//it must have the same pixel type as a label set.
return MakeScalarPixelType< DefaultSegmentationDataType >() == image->GetPixelType();
}
void mitk::AutoSegmentationWithPreviewTool::Activated()
{
Superclass::Activated();
m_ToolManager->RoiDataChanged +=
mitk::MessageDelegate<mitk::AutoSegmentationWithPreviewTool>(this, &mitk::AutoSegmentationWithPreviewTool::OnRoiDataChanged);
m_ToolManager->SelectedTimePointChanged +=
mitk::MessageDelegate<mitk::AutoSegmentationWithPreviewTool>(this, &mitk::AutoSegmentationWithPreviewTool::OnTimePointChanged);
m_ReferenceDataNode = m_ToolManager->GetReferenceData(0);
m_SegmentationInputNode = m_ReferenceDataNode;
- m_LastTimePointOfUpdate = 0;
+ m_LastTimePointOfUpdate = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
if (m_PreviewSegmentationNode.IsNull())
{
m_PreviewSegmentationNode = DataNode::New();
m_PreviewSegmentationNode->SetProperty("color", ColorProperty::New(0.0, 1.0, 0.0));
m_PreviewSegmentationNode->SetProperty("name", StringProperty::New(std::string(this->GetName())+" preview"));
m_PreviewSegmentationNode->SetProperty("opacity", FloatProperty::New(0.3));
m_PreviewSegmentationNode->SetProperty("binary", BoolProperty::New(true));
m_PreviewSegmentationNode->SetProperty("helper object", BoolProperty::New(true));
}
if (m_SegmentationInputNode.IsNotNull())
{
this->ResetPreviewNode();
this->InitiateToolByInput();
}
else
{
m_ToolManager->ActivateTool(-1);
}
}
void mitk::AutoSegmentationWithPreviewTool::Deactivated()
{
m_ToolManager->RoiDataChanged -=
mitk::MessageDelegate<mitk::AutoSegmentationWithPreviewTool>(this, &mitk::AutoSegmentationWithPreviewTool::OnRoiDataChanged);
m_ToolManager->SelectedTimePointChanged -=
mitk::MessageDelegate<mitk::AutoSegmentationWithPreviewTool>(this, &mitk::AutoSegmentationWithPreviewTool::OnTimePointChanged);
m_SegmentationInputNode = nullptr;
m_ReferenceDataNode = nullptr;
+ m_WorkingPlaneGeometry = nullptr;
try
{
if (DataStorage *storage = m_ToolManager->GetDataStorage())
{
storage->Remove(m_PreviewSegmentationNode);
RenderingManager::GetInstance()->RequestUpdateAll();
}
}
catch (...)
{
// don't care
}
if (m_PreviewSegmentationNode.IsNotNull())
{
m_PreviewSegmentationNode->SetData(nullptr);
}
Superclass::Deactivated();
}
void mitk::AutoSegmentationWithPreviewTool::ConfirmSegmentation()
{
if (m_LazyDynamicPreviews && m_CreateAllTimeSteps)
{ // The tool should create all time steps but is currently in lazy mode,
// thus ensure that a preview for all time steps is available.
this->UpdatePreview(true);
}
CreateResultSegmentationFromPreview();
RenderingManager::GetInstance()->RequestUpdateAll();
if (!m_KeepActiveAfterAccept)
{
m_ToolManager->ActivateTool(-1);
}
}
void mitk::AutoSegmentationWithPreviewTool::InitiateToolByInput()
{
//default implementation does nothing.
//implement in derived classes to change behavior
}
mitk::Image* mitk::AutoSegmentationWithPreviewTool::GetPreviewSegmentation()
{
if (m_PreviewSegmentationNode.IsNull())
{
return nullptr;
}
return dynamic_cast<Image*>(m_PreviewSegmentationNode->GetData());
}
mitk::DataNode* mitk::AutoSegmentationWithPreviewTool::GetPreviewSegmentationNode()
{
return m_PreviewSegmentationNode;
}
const mitk::Image* mitk::AutoSegmentationWithPreviewTool::GetSegmentationInput() const
{
if (m_SegmentationInputNode.IsNull())
{
return nullptr;
}
return dynamic_cast<const Image*>(m_SegmentationInputNode->GetData());
}
const mitk::Image* mitk::AutoSegmentationWithPreviewTool::GetReferenceData() const
{
if (m_ReferenceDataNode.IsNull())
{
return nullptr;
}
return dynamic_cast<const Image*>(m_ReferenceDataNode->GetData());
}
void mitk::AutoSegmentationWithPreviewTool::ResetPreviewNode()
{
itk::RGBPixel<float> previewColor;
previewColor[0] = 0.0f;
previewColor[1] = 1.0f;
previewColor[2] = 0.0f;
const auto image = this->GetSegmentationInput();
if (nullptr != image)
{
mitk::LabelSetImage::ConstPointer workingImage =
dynamic_cast<const mitk::LabelSetImage *>(m_ToolManager->GetWorkingData(0)->GetData());
if (workingImage.IsNotNull())
{
auto newPreviewImage = workingImage->Clone();
if (newPreviewImage.IsNull())
{
MITK_ERROR << "Cannot create preview helper objects. Unable to clone working image";
return;
}
m_PreviewSegmentationNode->SetData(newPreviewImage);
// Let's paint the feedback node green...
newPreviewImage->GetActiveLabel()->SetColor(previewColor);
newPreviewImage->GetActiveLabelSet()->UpdateLookupTable(newPreviewImage->GetActiveLabel()->GetValue());
}
else
{
mitk::Image::ConstPointer workingImageBin = dynamic_cast<const mitk::Image*>(m_ToolManager->GetWorkingData(0)->GetData());
if (workingImageBin.IsNotNull())
{
auto newPreviewImage = workingImageBin->Clone();
if (newPreviewImage.IsNull())
{
MITK_ERROR << "Cannot create preview helper objects. Unable to clone working image";
return;
}
m_PreviewSegmentationNode->SetData(newPreviewImage->Clone());
}
else
{
mitkThrow() << "Tool is an invalid state. Cannot setup preview node. Working data is an unsupported class and should have not been accepted by CanHandle().";
}
}
m_PreviewSegmentationNode->SetColor(previewColor);
m_PreviewSegmentationNode->SetOpacity(0.5);
int layer(50);
m_ReferenceDataNode->GetIntProperty("layer", layer);
m_PreviewSegmentationNode->SetIntProperty("layer", layer + 1);
if (DataStorage *ds = m_ToolManager->GetDataStorage())
{
if (!ds->Exists(m_PreviewSegmentationNode))
ds->Add(m_PreviewSegmentationNode, m_ReferenceDataNode);
}
}
}
template <typename TPixel, unsigned int VImageDimension>
static void ITKSetVolume(const itk::Image<TPixel, VImageDimension> *originalImage,
mitk::Image *segmentation,
unsigned int timeStep)
{
auto constPixelContainer = originalImage->GetPixelContainer();
//have to make a const cast because itk::PixelContainer does not provide a const correct access :(
auto pixelContainer = const_cast<typename itk::Image<TPixel, VImageDimension>::PixelContainer*>(constPixelContainer);
segmentation->SetVolume((void *)pixelContainer->GetBufferPointer(), timeStep);
}
void mitk::AutoSegmentationWithPreviewTool::TransferImageAtTimeStep(const Image* sourceImage, Image* destinationImage, const TimeStepType timeStep)
{
try
{
- Image::ConstPointer image3D = this->GetImageByTimeStep(sourceImage, timeStep);
+ Image::ConstPointer sourceImageAtTimeStep = this->GetImageByTimeStep(sourceImage, timeStep);
- if (image3D->GetPixelType() != destinationImage->GetPixelType())
+ if (sourceImageAtTimeStep->GetPixelType() != destinationImage->GetPixelType())
{
mitkThrow() << "Cannot transfer images. Tool is in an invalid state, source image and destination image do not have the same pixel type. "
<< "Source pixel type: " << sourceImage->GetPixelType().GetTypeAsString()
<< "; destination pixel type: " << destinationImage->GetPixelType().GetTypeAsString();
}
if (!Equal(*(sourceImage->GetGeometry(timeStep)), *(destinationImage->GetGeometry(timeStep)), NODE_PREDICATE_GEOMETRY_DEFAULT_CHECK_PRECISION, false))
{
mitkThrow() << "Cannot transfer images. Tool is in an invalid state, source image and destination image do not have the same geometry.";
}
- if (image3D->GetDimension() == 2)
+ if (nullptr != this->GetWorkingPlaneGeometry())
{
- AccessFixedDimensionByItk_2(
- image3D, ITKSetVolume, 2, destinationImage, timeStep);
+ auto sourceSlice = SegTool2D::GetAffectedImageSliceAs2DImage(this->GetWorkingPlaneGeometry(), sourceImage, timeStep);
+ SegTool2D::WriteBackSegmentationResult(this->GetTargetSegmentationNode(), m_WorkingPlaneGeometry, sourceSlice, timeStep);
}
else
- {
- AccessFixedDimensionByItk_2(
- image3D, ITKSetVolume, 3, destinationImage, timeStep);
+ { //take care of the full segmentation volume
+ if (sourceImageAtTimeStep->GetDimension() == 2)
+ {
+ AccessFixedDimensionByItk_2(
+ sourceImageAtTimeStep, ITKSetVolume, 2, destinationImage, timeStep);
+ }
+ else
+ {
+ AccessFixedDimensionByItk_2(
+ sourceImageAtTimeStep, ITKSetVolume, 3, destinationImage, timeStep);
+ }
}
}
catch (...)
{
Tool::ErrorMessage("Error accessing single time steps of the original image. Cannot create segmentation.");
throw;
}
}
void mitk::AutoSegmentationWithPreviewTool::CreateResultSegmentationFromPreview()
{
const auto segInput = this->GetSegmentationInput();
auto previewImage = this->GetPreviewSegmentation();
if (nullptr != segInput && nullptr != previewImage)
{
DataNode::Pointer resultSegmentationNode = GetTargetSegmentationNode();
if (resultSegmentationNode.IsNotNull())
{
const auto timePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
auto resultSegmentation = dynamic_cast<Image*>(resultSegmentationNode->GetData());
// REMARK: the following code in this scope assumes that previewImage and resultSegmentation
// are clones of the working image (segmentation provided to the tool). Therefore they have
// the same time geometry.
if (previewImage->GetTimeSteps() != resultSegmentation->GetTimeSteps())
{
mitkThrow() << "Cannot perform threshold. Internal tool state is invalid."
<< " Preview segmentation and segmentation result image have different time geometries.";
}
if (m_CreateAllTimeSteps)
{
for (unsigned int timeStep = 0; timeStep < previewImage->GetTimeSteps(); ++timeStep)
{
- TransferImageAtTimeStep(previewImage, resultSegmentation, timeStep);
+ this->TransferImageAtTimeStep(previewImage, resultSegmentation, timeStep);
}
}
else
{
const auto timeStep = resultSegmentation->GetTimeGeometry()->TimePointToTimeStep(timePoint);
- TransferImageAtTimeStep(previewImage, resultSegmentation, timeStep);
+ this->TransferImageAtTimeStep(previewImage, resultSegmentation, timeStep);
}
// since we are maybe working on a smaller image, pad it to the size of the original image
if (m_ReferenceDataNode.GetPointer() != m_SegmentationInputNode.GetPointer())
{
mitk::PadImageFilter::Pointer padFilter = mitk::PadImageFilter::New();
padFilter->SetInput(0, resultSegmentation);
padFilter->SetInput(1, dynamic_cast<mitk::Image*>(m_ReferenceDataNode->GetData()));
padFilter->SetBinaryFilter(true);
padFilter->SetUpperThreshold(1);
padFilter->SetLowerThreshold(1);
padFilter->Update();
resultSegmentationNode->SetData(padFilter->GetOutput());
}
m_ToolManager->SetWorkingData(resultSegmentationNode);
m_ToolManager->GetWorkingData(0)->Modified();
+ this->EnsureTargetSegmentationNodeInDataStorage();
}
}
}
void mitk::AutoSegmentationWithPreviewTool::OnRoiDataChanged()
{
mitk::DataNode::ConstPointer node = m_ToolManager->GetRoiData(0);
if (node.IsNotNull())
{
mitk::MaskAndCutRoiImageFilter::Pointer roiFilter = mitk::MaskAndCutRoiImageFilter::New();
mitk::Image::Pointer image = dynamic_cast<mitk::Image *>(m_SegmentationInputNode->GetData());
if (image.IsNull())
return;
roiFilter->SetInput(image);
roiFilter->SetRegionOfInterest(node->GetData());
roiFilter->Update();
mitk::DataNode::Pointer tmpNode = mitk::DataNode::New();
tmpNode->SetData(roiFilter->GetOutput());
m_SegmentationInputNode = tmpNode;
}
else
m_SegmentationInputNode = m_ReferenceDataNode;
this->ResetPreviewNode();
this->InitiateToolByInput();
this->UpdatePreview();
}
void mitk::AutoSegmentationWithPreviewTool::OnTimePointChanged()
{
if (m_IsTimePointChangeAware && m_PreviewSegmentationNode.IsNotNull() && m_SegmentationInputNode.IsNotNull())
{
const auto timePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
const bool isStaticSegOnDynamicImage = m_PreviewSegmentationNode->GetData()->GetTimeSteps() == 1 && m_SegmentationInputNode->GetData()->GetTimeSteps() > 1;
if (timePoint!=m_LastTimePointOfUpdate && (isStaticSegOnDynamicImage || m_LazyDynamicPreviews))
{ //we only need to update either because we are lazzy
//or because we have a static segmentation with a dynamic image
this->UpdatePreview();
}
}
}
void mitk::AutoSegmentationWithPreviewTool::UpdatePreview(bool ignoreLazyPreviewSetting)
{
const auto inputImage = this->GetSegmentationInput();
auto previewImage = this->GetPreviewSegmentation();
int progress_steps = 200;
this->CurrentlyBusy.Send(true);
+ m_IsUpdating = true;
this->UpdatePrepare();
const auto timePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
try
{
if (nullptr != inputImage && nullptr != previewImage)
{
m_ProgressCommand->AddStepsToDo(progress_steps);
if (previewImage->GetTimeSteps() > 1 && (ignoreLazyPreviewSetting || !m_LazyDynamicPreviews))
{
- for (unsigned int timeStep = 0; timeStep < inputImage->GetTimeSteps(); ++timeStep)
+ for (unsigned int timeStep = 0; timeStep < previewImage->GetTimeSteps(); ++timeStep)
{
- auto feedBackImage3D = this->GetImageByTimeStep(inputImage, timeStep);
-
- this->DoUpdatePreview(feedBackImage3D, previewImage, timeStep);
+ Image::ConstPointer feedBackImage;
+ auto previewTimePoint = previewImage->GetTimeGeometry()->TimeStepToTimePoint(timeStep);
+ auto inputTimeStep = inputImage->GetTimeGeometry()->TimePointToTimeStep(previewTimePoint);
+
+ if (nullptr != this->GetWorkingPlaneGeometry())
+ { //only extract a specific slice defined by the working plane as feedback image.
+ feedBackImage = SegTool2D::GetAffectedImageSliceAs2DImage(this->GetWorkingPlaneGeometry(), inputImage, inputTimeStep);
+ }
+ else
+ { //work on the whole feedback image
+ feedBackImage = this->GetImageByTimeStep(inputImage, inputTimeStep);
+ }
+
+ this->DoUpdatePreview(feedBackImage, previewImage, timeStep);
}
}
else
{
- auto feedBackImage3D = this->GetImageByTimePoint(inputImage, timePoint);
+ Image::ConstPointer feedBackImage;
+ if (nullptr != this->GetWorkingPlaneGeometry())
+ {
+ feedBackImage = SegTool2D::GetAffectedImageSliceAs2DImageByTimePoint(this->GetWorkingPlaneGeometry(), inputImage, timePoint);
+ }
+ else
+ {
+ feedBackImage = this->GetImageByTimePoint(inputImage, timePoint);
+ }
+
auto timeStep = previewImage->GetTimeGeometry()->TimePointToTimeStep(timePoint);
- this->DoUpdatePreview(feedBackImage3D, previewImage, timeStep);
+ this->DoUpdatePreview(feedBackImage, previewImage, timeStep);
}
RenderingManager::GetInstance()->RequestUpdateAll();
}
}
catch (itk::ExceptionObject & excep)
{
MITK_ERROR << "Exception caught: " << excep.GetDescription();
m_ProgressCommand->SetProgress(progress_steps);
std::string msg = excep.GetDescription();
ErrorMessage.Send(msg);
}
catch (...)
{
m_ProgressCommand->SetProgress(progress_steps);
+ m_IsUpdating = false;
CurrentlyBusy.Send(false);
throw;
}
this->UpdateCleanUp();
m_LastTimePointOfUpdate = timePoint;
m_ProgressCommand->SetProgress(progress_steps);
+ m_IsUpdating = false;
CurrentlyBusy.Send(false);
}
+bool mitk::AutoSegmentationWithPreviewTool::IsUpdating() const
+{
+ return m_IsUpdating;
+}
+
void mitk::AutoSegmentationWithPreviewTool::UpdatePrepare()
{
// default implementation does nothing
//reimplement in derived classes for special behavior
}
void mitk::AutoSegmentationWithPreviewTool::UpdateCleanUp()
{
// default implementation does nothing
//reimplement in derived classes for special behavior
}
mitk::TimePointType mitk::AutoSegmentationWithPreviewTool::GetLastTimePointOfUpdate() const
{
return m_LastTimePointOfUpdate;
}
diff --git a/Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.h b/Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.h
index 848ff0c005..b3cad84572 100644
--- a/Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.h
+++ b/Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.h
@@ -1,152 +1,169 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkAutoSegmentationWithPreviewTool_h_Included
#define mitkAutoSegmentationWithPreviewTool_h_Included
#include "mitkAutoSegmentationTool.h"
#include "mitkCommon.h"
#include "mitkDataNode.h"
#include "mitkToolCommand.h"
#include <MitkSegmentationExports.h>
namespace mitk
{
/**
\brief Base class for any auto segmentation tool that provides a preview of the new segmentation.
This tool class implements a lot basic logic to handle auto segmentation tools with preview,
Time point and ROI support. Derived classes will ask to update the segmentation preview if needed
(e.g. because the ROI or the current time point has changed) or because derived tools
indicated the need to update themselves.
This class also takes care to properly transfer a confirmed preview into the segementation
result.
\ingroup ToolManagerEtAl
\sa mitk::Tool
\sa QmitkInteractiveSegmentation
*/
class MITKSEGMENTATION_EXPORT AutoSegmentationWithPreviewTool : public AutoSegmentationTool
{
public:
mitkClassMacro(AutoSegmentationWithPreviewTool, AutoSegmentationTool);
void Activated() override;
void Deactivated() override;
void ConfirmSegmentation();
itkSetMacro(CreateAllTimeSteps, bool);
itkGetMacro(CreateAllTimeSteps, bool);
itkBooleanMacro(CreateAllTimeSteps);
itkSetMacro(KeepActiveAfterAccept, bool);
itkGetMacro(KeepActiveAfterAccept, bool);
itkBooleanMacro(KeepActiveAfterAccept);
itkSetMacro(IsTimePointChangeAware, bool);
itkGetMacro(IsTimePointChangeAware, bool);
itkBooleanMacro(IsTimePointChangeAware);
bool CanHandle(const BaseData* referenceData, const BaseData* workingData) const override;
/** Triggers the actualization of the preview
* @param ignoreLazyPreviewSetting If set true UpdatePreview will always
* generate the preview for all time steps. If set to false, UpdatePreview
* will regard the setting specified by the constructor.
* To define the update generation for time steps implement DoUpdatePreview.
* To alter what should be done directly before or after the update of the preview,
* reimplement UpdatePrepare() or UpdateCleanUp().*/
void UpdatePreview(bool ignoreLazyPreviewSetting = false);
+ /** Indicate if currently UpdatePreview is triggered (true) or not (false).*/
+ bool IsUpdating() const;
+
protected:
mitk::ToolCommand::Pointer m_ProgressCommand;
/** Member is always called if GetSegmentationInput() has changed
* (e.g. because a new ROI was defined, or on activation) to give derived
* classes the posibility to initiate their state accordingly.
* Reimplement this function to implement special behavior.
*/
virtual void InitiateToolByInput();
virtual void UpdatePrepare();
virtual void UpdateCleanUp();
/** This function does the real work. Here the preview for a given
* input image should be computed and stored in the also passed
* preview image at the passed time step.
*/
virtual void DoUpdatePreview(const Image* inputAtTimeStep, Image* previewImage, TimeStepType timeStep) = 0;
- AutoSegmentationWithPreviewTool(bool lazyDynamicPreviews = false);
+ AutoSegmentationWithPreviewTool(bool lazyDynamicPreviews = false); // purposely hidden
+ AutoSegmentationWithPreviewTool(bool lazyDynamicPreviews, const char* interactorType, const us::Module* interactorModule = nullptr); // purposely hidden
+
~AutoSegmentationWithPreviewTool() override;
/** Returns the image that contains the preview of the current segmentation.
* Returns null if the node is not set or does not contain an image.*/
Image* GetPreviewSegmentation();
DataNode* GetPreviewSegmentationNode();
/** Returns the input that should be used for any segmentation/preview or tool update.
* It is either the data of ReferenceDataNode itself or a part of it defined by a ROI mask
* provided by the tool manager. Derived classes should regard this as the relevant
* input data for any processing.
* Returns null if the node is not set or does not contain an image.*/
const Image* GetSegmentationInput() const;
/** Returns the image that is provided by the ReferenceDataNode.
* Returns null if the node is not set or does not contain an image.*/
const Image* GetReferenceData() const;
/** Resets the preview node so it is empty and ready to be filled by the tool*/
void ResetPreviewNode();
TimePointType GetLastTimePointOfUpdate() const;
+ itkSetObjectMacro(WorkingPlaneGeometry, PlaneGeometry);
+ itkGetConstObjectMacro(WorkingPlaneGeometry, PlaneGeometry);
+
private:
void TransferImageAtTimeStep(const Image* sourceImage, Image* destinationImage, const TimeStepType timeStep);
void CreateResultSegmentationFromPreview();
void OnRoiDataChanged();
void OnTimePointChanged();
/** Node that containes the preview data generated and managed by this class or derived ones.*/
DataNode::Pointer m_PreviewSegmentationNode;
/** The reference data recieved from ToolManager::GetReferenceData when tool was activated.*/
DataNode::Pointer m_ReferenceDataNode;
/** Node that containes the data that should be used as input for any auto segmentation. It might
* be the same like m_ReferenceDataNode (if no ROI is set) or a sub region (if ROI is set).*/
DataNode::Pointer m_SegmentationInputNode;
/** Indicates if Accepting the threshold should transfer/create the segmentations
of all time steps (true) or only of the currently selected timepoint (false).*/
bool m_CreateAllTimeSteps = false;
/** Indicates if the tool should kept active after accepting the segmentation or not.*/
bool m_KeepActiveAfterAccept = false;
/** Relevant if the working data / preview image has multiple time steps (dynamic segmentations).
* This flag has to be set by derived classes accordingly to there way to generate dynamic previews.
* If LazyDynamicPreview is true, the tool generates only the preview for the current time step.
* Therefore it always has to update the preview if current time point has changed and it has to (re)compute
* all timeframes if ConfirmSegmentation() is called.*/
bool m_LazyDynamicPreviews = false;
bool m_IsTimePointChangeAware = true;
TimePointType m_LastTimePointOfUpdate = 0.;
+
+ bool m_IsUpdating = false;
+
+ /** This variable indicates if for the tool a working plane geometry is defined.
+ * If a working plane is defined the tool will only work an the slice of the input
+ * and the segmentation. Thus only the relevant input slice will be passed to
+ * DoUpdatePreview(...) and only the relevant slice of the preview will be transfered when
+ * ConfirmSegmentation() is called.*/
+ PlaneGeometry::Pointer m_WorkingPlaneGeometry;
};
} // namespace
#endif
diff --git a/Modules/Segmentation/Interactions/mitkContourModelInteractor.cpp b/Modules/Segmentation/Interactions/mitkContourModelInteractor.cpp
index 92dba4c9a5..e608aaec13 100644
--- a/Modules/Segmentation/Interactions/mitkContourModelInteractor.cpp
+++ b/Modules/Segmentation/Interactions/mitkContourModelInteractor.cpp
@@ -1,164 +1,164 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkContourModelInteractor.h"
#include "mitkToolManager.h"
#include "mitkBaseRenderer.h"
#include "mitkRenderingManager.h"
#include <mitkInteractionPositionEvent.h>
#include <mitkInteractionConst.h>
mitk::ContourModelInteractor::ContourModelInteractor()
{
}
void mitk::ContourModelInteractor::ConnectActionsAndFunctions()
{
CONNECT_CONDITION("checkisOverPoint", OnCheckPointClick);
CONNECT_CONDITION("mouseMove", IsHovering);
CONNECT_FUNCTION("movePoints", OnMovePoint);
CONNECT_FUNCTION("deletePoint", OnDeletePoint);
CONNECT_FUNCTION("finish", OnFinishEditing);
}
mitk::ContourModelInteractor::~ContourModelInteractor()
{
}
bool mitk::ContourModelInteractor::OnCheckPointClick(const InteractionEvent *interactionEvent)
{
const auto *positionEvent =
dynamic_cast<const mitk::InteractionPositionEvent *>(interactionEvent);
if (!positionEvent)
return false;
- int timestep = positionEvent->GetSender()->GetTimeStep();
+ const auto timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
auto *contour = dynamic_cast<mitk::ContourModel *>(this->GetDataNode()->GetData());
contour->Deselect();
mitk::Point3D click = positionEvent->GetPositionInWorld();
- if (contour->SelectVertexAt(click, 1.5, timestep))
+ if (contour->SelectVertexAt(click, 1.5, timeStep))
{
contour->SetSelectedVertexAsControlPoint();
mitk::RenderingManager::GetInstance()->RequestUpdate(interactionEvent->GetSender()->GetRenderWindow());
m_lastMousePosition = click;
- auto *contourGeometry = dynamic_cast<Geometry3D *>(contour->GetGeometry(timestep));
+ auto *contourGeometry = dynamic_cast<Geometry3D *>(contour->GetGeometry(timeStep));
if (contourGeometry->IsInside(click))
{
m_lastMousePosition = click;
return true;
}
else
return false;
}
else
{
return false;
}
return true;
}
void mitk::ContourModelInteractor::OnDeletePoint(StateMachineAction *, InteractionEvent *)
{
auto *contour = dynamic_cast<mitk::ContourModel *>(this->GetDataNode()->GetData());
contour->RemoveVertex(contour->GetSelectedVertex());
}
bool mitk::ContourModelInteractor::IsHovering(const InteractionEvent *interactionEvent)
{
const auto *positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
if (!positionEvent)
return false;
- int timestep = positionEvent->GetSender()->GetTimeStep();
+ const auto timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
auto *contour = dynamic_cast<mitk::ContourModel *>(this->GetDataNode()->GetData());
mitk::Point3D currentPosition = positionEvent->GetPositionInWorld();
bool isHover = false;
this->GetDataNode()->GetBoolProperty("contour.hovering", isHover, positionEvent->GetSender());
- if (contour->IsNearContour(currentPosition, 1.5, timestep))
+ if (contour->IsNearContour(currentPosition, 1.5, timeStep))
{
if (isHover == false)
{
this->GetDataNode()->SetBoolProperty("contour.hovering", true);
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
}
else
{
if (isHover == true)
{
this->GetDataNode()->SetBoolProperty("contour.hovering", false);
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
}
return false;
}
void mitk::ContourModelInteractor::OnMovePoint(StateMachineAction *, InteractionEvent *interactionEvent)
{
const auto *positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
if (!positionEvent)
return;
auto *contour = dynamic_cast<mitk::ContourModel *>(this->GetDataNode()->GetData());
mitk::Vector3D translation;
mitk::Point3D currentPosition = positionEvent->GetPositionInWorld();
translation[0] = currentPosition[0] - this->m_lastMousePosition[0];
translation[1] = currentPosition[1] - this->m_lastMousePosition[1];
translation[2] = currentPosition[2] - this->m_lastMousePosition[2];
contour->ShiftSelectedVertex(translation);
this->m_lastMousePosition = positionEvent->GetPositionInWorld();
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
void mitk::ContourModelInteractor::OnMoveContour(StateMachineAction *, InteractionEvent *interactionEvent)
{
const auto *positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
if (!positionEvent)
return;
- int timestep = positionEvent->GetSender()->GetTimeStep();
+ const auto timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
auto *contour = dynamic_cast<mitk::ContourModel *>(this->GetDataNode()->GetData());
mitk::Vector3D translation;
mitk::Point3D currentPosition = positionEvent->GetPositionInWorld();
translation[0] = currentPosition[0] - this->m_lastMousePosition[0];
translation[1] = currentPosition[1] - this->m_lastMousePosition[1];
translation[2] = currentPosition[2] - this->m_lastMousePosition[2];
- contour->ShiftContour(translation, timestep);
+ contour->ShiftContour(translation, timeStep);
this->m_lastMousePosition = positionEvent->GetPositionInWorld();
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
void mitk::ContourModelInteractor::OnFinishEditing(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto *contour = dynamic_cast<mitk::ContourModel *>(this->GetDataNode()->GetData());
contour->Deselect();
mitk::RenderingManager::GetInstance()->RequestUpdate(interactionEvent->GetSender()->GetRenderWindow());
}
diff --git a/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.cpp b/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.cpp
index 695b2969ef..e2e0e95b68 100644
--- a/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.cpp
+++ b/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.cpp
@@ -1,482 +1,485 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkContourModelLiveWireInteractor.h"
#include "mitkInteractionPositionEvent.h"
#include "mitkToolManager.h"
#include "mitkBaseRenderer.h"
#include "mitkRenderingManager.h"
#include <mitkInteractionConst.h>
#include "mitkIOUtil.h"
mitk::ContourModelLiveWireInteractor::ContourModelLiveWireInteractor() : ContourModelInteractor()
{
m_LiveWireFilter = mitk::ImageLiveWireContourModelFilter::New();
m_NextActiveVertexDown.Fill(0);
m_NextActiveVertexUp.Fill(0);
}
mitk::ContourModelLiveWireInteractor::~ContourModelLiveWireInteractor()
{
}
void mitk::ContourModelLiveWireInteractor::ConnectActionsAndFunctions()
{
CONNECT_CONDITION("checkisOverPoint", OnCheckPointClick);
CONNECT_CONDITION("mouseMove", IsHovering);
CONNECT_FUNCTION("movePoint", OnMovePoint);
CONNECT_FUNCTION("deletePoint", OnDeletePoint);
CONNECT_FUNCTION("finish", OnFinishEditing);
}
bool mitk::ContourModelLiveWireInteractor::OnCheckPointClick(const InteractionEvent *interactionEvent)
{
const auto *positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
if (!positionEvent)
return false;
- int timestep = positionEvent->GetSender()->GetTimeStep();
+ const auto timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
auto *contour = dynamic_cast<mitk::ContourModel *>(this->GetDataNode()->GetData());
if (contour == nullptr)
{
MITK_ERROR << "Invalid Contour";
return false;
}
contour->Deselect();
// Check distance to any vertex.
// Transition YES if click close to a vertex
mitk::Point3D click = positionEvent->GetPositionInWorld();
- if (contour->SelectVertexAt(click, 1.5, timestep))
+ if (contour->SelectVertexAt(click, 1.5, timeStep))
{
contour->SetSelectedVertexAsControlPoint(false);
m_ContourLeft = mitk::ContourModel::New();
// get coordinates of next active vertex downwards from selected vertex
- int downIndex = this->SplitContourFromSelectedVertex(contour, m_ContourLeft, false, timestep);
+ int downIndex = this->SplitContourFromSelectedVertex(contour, m_ContourLeft, false, timeStep);
m_NextActiveVertexDownIter = contour->IteratorBegin() + downIndex;
m_NextActiveVertexDown = (*m_NextActiveVertexDownIter)->Coordinates;
m_ContourRight = mitk::ContourModel::New();
// get coordinates of next active vertex upwards from selected vertex
- int upIndex = this->SplitContourFromSelectedVertex(contour, m_ContourRight, true, timestep);
+ int upIndex = this->SplitContourFromSelectedVertex(contour, m_ContourRight, true, timeStep);
m_NextActiveVertexUpIter = contour->IteratorBegin() + upIndex;
m_NextActiveVertexUp = (*m_NextActiveVertexUpIter)->Coordinates;
// clear previous void positions
this->m_LiveWireFilter->ClearRepulsivePoints();
// set the current contour as void positions in the cost map
// start with down side
- auto iter = contour->IteratorBegin(timestep);
+ auto iter = contour->IteratorBegin(timeStep);
for (; iter != m_NextActiveVertexDownIter; iter++)
{
itk::Index<2> idx;
this->m_WorkingSlice->GetGeometry()->WorldToIndex((*iter)->Coordinates, idx);
this->m_LiveWireFilter->AddRepulsivePoint(idx);
}
// continue with upper side
iter = m_NextActiveVertexUpIter + 1;
- for (; iter != contour->IteratorEnd(timestep); iter++)
+ for (; iter != contour->IteratorEnd(timeStep); iter++)
{
itk::Index<2> idx;
this->m_WorkingSlice->GetGeometry()->WorldToIndex((*iter)->Coordinates, idx);
this->m_LiveWireFilter->AddRepulsivePoint(idx);
}
// clear container with void points between neighboring control points
m_ContourBeingModified.clear();
// let us have the selected point as a control point
contour->SetSelectedVertexAsControlPoint(true);
// finally, return true to pass this condition
return true;
}
else
{
// do not pass condition
return false;
}
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
return true;
}
void mitk::ContourModelLiveWireInteractor::SetEditingContourModelNode(mitk::DataNode *_arg)
{
if (this->m_EditingContourNode != _arg)
{
this->m_EditingContourNode = _arg;
}
}
void mitk::ContourModelLiveWireInteractor::SetWorkingImage(mitk::Image *_arg)
{
if (this->m_WorkingSlice != _arg)
{
this->m_WorkingSlice = _arg;
this->m_LiveWireFilter->SetInput(this->m_WorkingSlice);
}
}
void mitk::ContourModelLiveWireInteractor::OnDeletePoint(StateMachineAction *, InteractionEvent *interactionEvent)
{
- int timestep = interactionEvent->GetSender()->GetTimeStep();
+ const auto timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
auto *contour = dynamic_cast<mitk::ContourModel *>(this->GetDataNode()->GetData());
if (contour == nullptr)
{
MITK_ERROR << "Invalid Contour!";
return;
}
if (contour->GetSelectedVertex())
{
mitk::ContourModel::Pointer newContour = mitk::ContourModel::New();
newContour->Expand(contour->GetTimeSteps());
+ newContour->SetTimeGeometry(contour->GetTimeGeometry()->Clone());
- newContour->Concatenate(m_ContourLeft, timestep);
+ newContour->Concatenate(m_ContourLeft, timeStep);
// recompute contour between neighbored two active control points
this->m_LiveWireFilter->SetStartPoint(this->m_NextActiveVertexDown);
this->m_LiveWireFilter->SetEndPoint(this->m_NextActiveVertexUp);
// this->m_LiveWireFilter->ClearRepulsivePoints();
this->m_LiveWireFilter->Update();
mitk::ContourModel *liveWireContour = this->m_LiveWireFilter->GetOutput();
assert(liveWireContour);
- if (liveWireContour->IsEmpty(timestep))
+ if (liveWireContour->IsEmpty(timeStep))
return;
- liveWireContour->RemoveVertexAt(0, timestep);
- liveWireContour->RemoveVertexAt(liveWireContour->GetNumberOfVertices(timestep) - 1, timestep);
+ liveWireContour->RemoveVertexAt(0, timeStep);
+ liveWireContour->RemoveVertexAt(liveWireContour->GetNumberOfVertices(timeStep) - 1, timeStep);
// insert new live wire computed points
- newContour->Concatenate(liveWireContour, timestep);
+ newContour->Concatenate(liveWireContour, timeStep);
// insert right side of original contour
- newContour->Concatenate(this->m_ContourRight, timestep);
+ newContour->Concatenate(this->m_ContourRight, timeStep);
- newContour->SetClosed(contour->IsClosed(timestep), timestep);
+ newContour->SetClosed(contour->IsClosed(timeStep), timeStep);
// instead of leaving a single point, delete all points
- if (newContour->GetNumberOfVertices(timestep) <= 2)
+ if (newContour->GetNumberOfVertices(timeStep) <= 2)
{
- newContour->Clear(timestep);
+ newContour->Clear(timeStep);
}
this->GetDataNode()->SetData(newContour);
mitk::RenderingManager::GetInstance()->RequestUpdate(interactionEvent->GetSender()->GetRenderWindow());
}
}
void mitk::ContourModelLiveWireInteractor::OnMovePoint(StateMachineAction *, InteractionEvent *interactionEvent)
{
const auto *positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
if (!positionEvent)
return;
- int timestep = positionEvent->GetSender()->GetTimeStep();
+ const auto timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
mitk::Point3D currentPosition = positionEvent->GetPositionInWorld();
auto *contour = dynamic_cast<mitk::ContourModel *>(this->GetDataNode()->GetData());
if (contour == nullptr)
{
MITK_ERROR << "invalid contour";
return;
}
mitk::ContourModel::Pointer editingContour = mitk::ContourModel::New();
editingContour->Expand(contour->GetTimeSteps());
+ editingContour->SetTimeGeometry(contour->GetTimeGeometry()->Clone());
// recompute left live wire, i.e. the contour between previous active vertex and selected vertex
this->m_LiveWireFilter->SetStartPoint(this->m_NextActiveVertexDown);
this->m_LiveWireFilter->SetEndPoint(currentPosition);
// remove void positions between previous active vertex and next active vertex.
if (!m_ContourBeingModified.empty())
{
std::vector<itk::Index<2>>::const_iterator iter = m_ContourBeingModified.begin();
for (; iter != m_ContourBeingModified.end(); iter++)
{
this->m_LiveWireFilter->RemoveRepulsivePoint((*iter));
}
}
// update to get the left livewire. Remember that the points in the rest of the contour are already
// set as void positions in the filter
this->m_LiveWireFilter->Update();
mitk::ContourModel::Pointer leftLiveWire = this->m_LiveWireFilter->GetOutput();
assert(leftLiveWire);
- if (!leftLiveWire->IsEmpty(timestep))
- leftLiveWire->RemoveVertexAt(0, timestep);
+ if (!leftLiveWire->IsEmpty(timeStep))
+ leftLiveWire->RemoveVertexAt(0, timeStep);
- editingContour->Concatenate(leftLiveWire, timestep);
+ editingContour->Concatenate(leftLiveWire, timeStep);
// the new index of the selected vertex
unsigned int selectedVertexIndex =
- this->m_ContourLeft->GetNumberOfVertices(timestep) + leftLiveWire->GetNumberOfVertices(timestep) - 1;
+ this->m_ContourLeft->GetNumberOfVertices(timeStep) + leftLiveWire->GetNumberOfVertices(timeStep) - 1;
// at this point the container has to be empty
m_ContourBeingModified.clear();
// add points from left live wire contour
- auto iter = leftLiveWire->IteratorBegin(timestep);
- for (; iter != leftLiveWire->IteratorEnd(timestep); iter++)
+ auto iter = leftLiveWire->IteratorBegin(timeStep);
+ for (; iter != leftLiveWire->IteratorEnd(timeStep); iter++)
{
itk::Index<2> idx;
this->m_WorkingSlice->GetGeometry()->WorldToIndex((*iter)->Coordinates, idx);
this->m_LiveWireFilter->AddRepulsivePoint(idx);
// add indices
m_ContourBeingModified.push_back(idx);
}
// recompute right live wire, i.e. the contour between selected vertex and next active vertex
this->m_LiveWireFilter->SetStartPoint(currentPosition);
this->m_LiveWireFilter->SetEndPoint(m_NextActiveVertexUp);
// update filter with all contour points set as void but the right live wire portion to be calculated now
this->m_LiveWireFilter->Update();
mitk::ContourModel::Pointer rightLiveWire = this->m_LiveWireFilter->GetOutput();
assert(rightLiveWire);
// reject strange paths
- if (abs(rightLiveWire->GetNumberOfVertices(timestep) - leftLiveWire->GetNumberOfVertices(timestep)) > 50)
+ if (abs(rightLiveWire->GetNumberOfVertices(timeStep) - leftLiveWire->GetNumberOfVertices(timeStep)) > 50)
{
return;
}
- if (!leftLiveWire->IsEmpty(timestep))
- leftLiveWire->SetControlVertexAt(leftLiveWire->GetNumberOfVertices() - 1, timestep);
+ if (!leftLiveWire->IsEmpty(timeStep))
+ leftLiveWire->SetControlVertexAt(leftLiveWire->GetNumberOfVertices() - 1, timeStep);
- if (!rightLiveWire->IsEmpty(timestep))
- rightLiveWire->RemoveVertexAt(0, timestep);
+ if (!rightLiveWire->IsEmpty(timeStep))
+ rightLiveWire->RemoveVertexAt(0, timeStep);
- editingContour->Concatenate(rightLiveWire, timestep);
+ editingContour->Concatenate(rightLiveWire, timeStep);
m_EditingContourNode->SetData(editingContour);
mitk::ContourModel::Pointer newContour = mitk::ContourModel::New();
newContour->Expand(contour->GetTimeSteps());
+ newContour->SetTimeGeometry(contour->GetTimeGeometry()->Clone());
// concatenate left original contour
- newContour->Concatenate(this->m_ContourLeft, timestep);
+ newContour->Concatenate(this->m_ContourLeft, timeStep);
- newContour->Concatenate(editingContour, timestep, true);
+ newContour->Concatenate(editingContour, timeStep, true);
// set last inserted vertex as selected
- newContour->SelectVertexAt(selectedVertexIndex, timestep);
+ newContour->SelectVertexAt(selectedVertexIndex, timeStep);
// set as control point
newContour->SetSelectedVertexAsControlPoint(true);
// concatenate right original contour
- newContour->Concatenate(this->m_ContourRight, timestep);
+ newContour->Concatenate(this->m_ContourRight, timeStep);
- newContour->SetClosed(contour->IsClosed(timestep), timestep);
+ newContour->SetClosed(contour->IsClosed(timeStep), timeStep);
this->GetDataNode()->SetData(newContour);
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
bool mitk::ContourModelLiveWireInteractor::IsHovering(const InteractionEvent *interactionEvent)
{
const auto *positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
if (!positionEvent)
return false;
- int timestep = positionEvent->GetSender()->GetTimeStep();
+ const auto timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
auto *contour = dynamic_cast<mitk::ContourModel *>(this->GetDataNode()->GetData());
mitk::Point3D currentPosition = positionEvent->GetPositionInWorld();
bool isHover = false;
this->GetDataNode()->GetBoolProperty("contour.hovering", isHover, positionEvent->GetSender());
- if (contour->IsNearContour(currentPosition, 1.5, timestep))
+ if (contour->IsNearContour(currentPosition, 1.5, timeStep))
{
if (isHover == false)
{
this->GetDataNode()->SetBoolProperty("contour.hovering", true);
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
}
else
{
if (isHover == true)
{
this->GetDataNode()->SetBoolProperty("contour.hovering", false);
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
}
return false;
}
int mitk::ContourModelLiveWireInteractor::SplitContourFromSelectedVertex(mitk::ContourModel *srcContour,
mitk::ContourModel *destContour,
bool fromSelectedUpwards,
int timestep)
{
auto end = srcContour->IteratorEnd();
auto begin = srcContour->IteratorBegin();
// search next active control point to left and rigth and set as start and end point for filter
auto itSelected = begin;
// move iterator to position
while ((*itSelected) != srcContour->GetSelectedVertex())
{
itSelected++;
}
// CASE search upwards for next control point
if (fromSelectedUpwards)
{
auto itUp = itSelected;
if (itUp != end)
{
itUp++; // step once up otherwise the loop breaks immediately
}
while (itUp != end && !((*itUp)->IsControlPoint))
{
itUp++;
}
auto it = itUp;
if (itSelected != begin)
{
// copy the rest of the original contour
while (it != end)
{
destContour->AddVertex((*it)->Coordinates, (*it)->IsControlPoint, timestep);
it++;
}
}
// else do not copy the contour
// return the offset of iterator at one before next-vertex-upwards
if (itUp != begin)
{
return std::distance(begin, itUp) - 1;
}
else
{
return std::distance(begin, itUp);
}
}
else // CASE search downwards for next control point
{
auto itDown = itSelected;
auto it = srcContour->IteratorBegin();
if (itSelected != begin)
{
if (itDown != begin)
{
itDown--; // step once down otherwise the the loop breaks immediately
}
while (itDown != begin && !((*itDown)->IsControlPoint))
{
itDown--;
}
if (it != end) // if not empty
{
// always add the first vertex
destContour->AddVertex((*it)->Coordinates, (*it)->IsControlPoint, timestep);
it++;
}
// copy from begin to itDown
while (it <= itDown)
{
destContour->AddVertex((*it)->Coordinates, (*it)->IsControlPoint, timestep);
it++;
}
}
else
{
// if selected vertex is the first element search from end of contour downwards
itDown = end;
itDown--;
while (!((*itDown)->IsControlPoint) && itDown != begin)
{
itDown--;
}
// move one forward as we don't want the first control point
it++;
// move iterator to second control point
while ((it != end) && !((*it)->IsControlPoint))
{
it++;
}
// copy from begin to itDown
while (it <= itDown)
{
// copy the contour from second control point to itDown
destContour->AddVertex((*it)->Coordinates, (*it)->IsControlPoint, timestep);
it++;
}
}
/*
//add vertex at itDown - it's not considered during while loop
if( it != begin && it != end)
{
//destContour->AddVertex( (*it)->Coordinates, (*it)->IsControlPoint, timestep);
}
*/
// return the offset of iterator at one after next-vertex-downwards
if (itDown != end)
{
return std::distance(begin, itDown); // + 1;//index of next vertex
}
else
{
return std::distance(begin, itDown) - 1;
}
}
}
void mitk::ContourModelLiveWireInteractor::OnFinishEditing(StateMachineAction *, InteractionEvent *interactionEvent)
{
- int timestep = interactionEvent->GetSender()->GetTimeStep();
+ const auto timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
auto *editingContour = dynamic_cast<mitk::ContourModel *>(this->m_EditingContourNode->GetData());
- editingContour->Clear(timestep);
+ editingContour->Clear(timeStep);
mitk::RenderingManager::GetInstance()->RequestUpdate(interactionEvent->GetSender()->GetRenderWindow());
}
diff --git a/Modules/Segmentation/Interactions/mitkContourTool.cpp b/Modules/Segmentation/Interactions/mitkContourTool.cpp
index 3cc6e941fe..41ec690074 100644
--- a/Modules/Segmentation/Interactions/mitkContourTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkContourTool.cpp
@@ -1,180 +1,111 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkContourTool.h"
-#include "mitkAbstractTransformGeometry.h"
-#include "mitkOverwriteDirectedPlaneImageFilter.h"
-#include "mitkOverwriteSliceImageFilter.h"
-#include "mitkToolManager.h"
-
-#include "mitkBaseRenderer.h"
-#include "mitkRenderingManager.h"
-
-#include "mitkInteractionEvent.h"
-#include "mitkStateMachineAction.h"
-
mitk::ContourTool::ContourTool(int paintingPixelValue)
: FeedbackContourTool("PressMoveReleaseWithCTRLInversion"),
m_PaintingPixelValue(paintingPixelValue)
{
}
mitk::ContourTool::~ContourTool()
{
}
void mitk::ContourTool::ConnectActionsAndFunctions()
{
CONNECT_FUNCTION("PrimaryButtonPressed", OnMousePressed);
CONNECT_FUNCTION("Move", OnMouseMoved);
CONNECT_FUNCTION("Release", OnMouseReleased);
CONNECT_FUNCTION("InvertLogic", OnInvertLogic);
}
void mitk::ContourTool::Activated()
{
Superclass::Activated();
}
void mitk::ContourTool::Deactivated()
{
Superclass::Deactivated();
}
/**
Just show the contour, insert the first point.
*/
void mitk::ContourTool::OnMousePressed(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (!positionEvent)
return;
m_LastEventSender = positionEvent->GetSender();
m_LastEventSlice = m_LastEventSender->GetSlice();
- int timestep = positionEvent->GetSender()->GetTimeStep();
-
- ContourModel *contour = FeedbackContourTool::GetFeedbackContour();
- // Clear feedback contour
- contour->Initialize();
- // expand time bounds because our contour was initialized
- contour->Expand(timestep + 1);
- // draw as a closed contour
- contour->SetClosed(true, timestep);
- // add first mouse position
+ this->ClearsCurrentFeedbackContour(true);
mitk::Point3D point = positionEvent->GetPositionInWorld();
- contour->AddVertex(point, timestep);
+ this->AddVertexToCurrentFeedbackContour(point);
FeedbackContourTool::SetFeedbackContourVisible(true);
assert(positionEvent->GetSender()->GetRenderWindow());
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
/**
Insert the point to the feedback contour.
*/
void mitk::ContourTool::OnMouseMoved(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (!positionEvent)
return;
- int timestep = positionEvent->GetSender()->GetTimeStep();
-
- ContourModel *contour = FeedbackContourTool::GetFeedbackContour();
mitk::Point3D point = positionEvent->GetPositionInWorld();
- contour->AddVertex(point, timestep);
+ this->AddVertexToCurrentFeedbackContour(point);
assert(positionEvent->GetSender()->GetRenderWindow());
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
/**
Close the contour, project it to the image slice and fill it in 2D.
*/
void mitk::ContourTool::OnMouseReleased(StateMachineAction *, InteractionEvent *interactionEvent)
{
- // 1. Hide the feedback contour, find out which slice the user clicked, find out which slice of the toolmanager's
- // working image corresponds to that
- FeedbackContourTool::SetFeedbackContourVisible(false);
-
auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
- // const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
if (!positionEvent)
return;
assert(positionEvent->GetSender()->GetRenderWindow());
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
- DataNode *workingNode(m_ToolManager->GetWorkingData(0));
- if (!workingNode)
- return;
-
- auto workingImage = dynamic_cast<Image *>(workingNode->GetData());
- const PlaneGeometry *planeGeometry((positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()));
- if (!workingImage || !planeGeometry)
- return;
-
- const auto *abstractTransformGeometry(
- dynamic_cast<const AbstractTransformGeometry *>(positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()));
- if (!workingImage || abstractTransformGeometry)
- return;
-
- // 2. Slice is known, now we try to get it as a 2D image and project the contour into index coordinates of this slice
- Image::Pointer slice = SegTool2D::GetAffectedImageSliceAs2DImage(positionEvent, workingImage);
-
- if (slice.IsNull())
- {
- MITK_ERROR << "Unable to extract slice." << std::endl;
- return;
- }
-
- ContourModel *feedbackContour = FeedbackContourTool::GetFeedbackContour();
- ContourModel::Pointer projectedContour = FeedbackContourTool::ProjectContourTo2DSlice(
- slice, feedbackContour, true, false); // true: actually no idea why this is neccessary, but it works :-(
-
- if (projectedContour.IsNull())
- return;
-
- int timestep = positionEvent->GetSender()->GetTimeStep();
- int activePixelValue = ContourModelUtils::GetActivePixelValue(workingImage);
-
- // m_PaintingPixelValue only decides whether to paint or erase
- mitk::ContourModelUtils::FillContourInSlice(
- projectedContour, timestep, slice, workingImage, m_PaintingPixelValue * activePixelValue);
-
- // this->WriteBackSegmentationResult(positionEvent, slice);
- SegTool2D::WriteBackSegmentationResult(positionEvent, slice);
-
- // 4. Make sure the result is drawn again --> is visible then.
- assert(positionEvent->GetSender()->GetRenderWindow());
+ this->WriteBackFeedbackContourAsSegmentationResult(positionEvent, m_PaintingPixelValue);
}
/**
Called when the CTRL key is pressed. Will change the painting pixel value from 0 to 1 or from 1 to 0.
*/
void mitk::ContourTool::OnInvertLogic(StateMachineAction *, InteractionEvent *)
{
// Inversion only for 0 and 1 as painting values
if (m_PaintingPixelValue == 1)
{
m_PaintingPixelValue = 0;
FeedbackContourTool::SetFeedbackContourColor(1.0, 0.0, 0.0);
}
else if (m_PaintingPixelValue == 0)
{
m_PaintingPixelValue = 1;
FeedbackContourTool::SetFeedbackContourColorDefault();
}
}
diff --git a/Modules/Segmentation/Interactions/mitkCorrectorTool2D.cpp b/Modules/Segmentation/Interactions/mitkCorrectorTool2D.cpp
index 0e928ed279..4b761a8556 100644
--- a/Modules/Segmentation/Interactions/mitkCorrectorTool2D.cpp
+++ b/Modules/Segmentation/Interactions/mitkCorrectorTool2D.cpp
@@ -1,204 +1,181 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkCorrectorTool2D.h"
#include "mitkCorrectorAlgorithm.h"
#include "mitkAbstractTransformGeometry.h"
-#include "mitkBaseRenderer.h"
#include "mitkImageReadAccessor.h"
-#include "mitkLabelSetImage.h"
-#include "mitkRenderingManager.h"
#include "mitkToolManager.h"
#include "mitkCorrectorTool2D.xpm"
-#include "mitkLabelSetImage.h"
// us
#include <usGetModuleContext.h>
#include <usModule.h>
#include <usModuleContext.h>
#include <usModuleResource.h>
namespace mitk
{
MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, CorrectorTool2D, "Correction tool");
}
mitk::CorrectorTool2D::CorrectorTool2D(int paintingPixelValue)
: FeedbackContourTool("PressMoveRelease"), m_PaintingPixelValue(paintingPixelValue)
{
- GetFeedbackContour()->SetClosed(false); // don't close the contour to a polygon
}
mitk::CorrectorTool2D::~CorrectorTool2D()
{
}
void mitk::CorrectorTool2D::ConnectActionsAndFunctions()
{
CONNECT_FUNCTION("PrimaryButtonPressed", OnMousePressed);
CONNECT_FUNCTION("Move", OnMouseMoved);
CONNECT_FUNCTION("Release", OnMouseReleased);
}
const char **mitk::CorrectorTool2D::GetXPM() const
{
return mitkCorrectorTool2D_xpm;
}
us::ModuleResource mitk::CorrectorTool2D::GetIconResource() const
{
us::Module *module = us::GetModuleContext()->GetModule();
us::ModuleResource resource = module->GetResource("Correction_48x48.png");
return resource;
}
us::ModuleResource mitk::CorrectorTool2D::GetCursorIconResource() const
{
us::Module *module = us::GetModuleContext()->GetModule();
us::ModuleResource resource = module->GetResource("Correction_Cursor_32x32.png");
return resource;
}
const char *mitk::CorrectorTool2D::GetName() const
{
return "Correction";
}
void mitk::CorrectorTool2D::Activated()
{
Superclass::Activated();
}
void mitk::CorrectorTool2D::Deactivated()
{
Superclass::Deactivated();
}
void mitk::CorrectorTool2D::OnMousePressed(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (!positionEvent)
return;
m_LastEventSender = positionEvent->GetSender();
m_LastEventSlice = m_LastEventSender->GetSlice();
- int timestep = positionEvent->GetSender()->GetTimeStep();
- ContourModel *contour = FeedbackContourTool::GetFeedbackContour();
- contour->Initialize();
- contour->Expand(timestep + 1);
- contour->SetClosed(false, timestep);
+ this->ClearsCurrentFeedbackContour(false);
mitk::Point3D point = positionEvent->GetPositionInWorld();
- contour->AddVertex(point, timestep);
+ this->AddVertexToCurrentFeedbackContour(point);
FeedbackContourTool::SetFeedbackContourVisible(true);
}
void mitk::CorrectorTool2D::OnMouseMoved(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (!positionEvent)
return;
- int timestep = positionEvent->GetSender()->GetTimeStep();
- ContourModel *contour = FeedbackContourTool::GetFeedbackContour();
mitk::Point3D point = positionEvent->GetPositionInWorld();
- contour->AddVertex(point, timestep);
+ this->AddVertexToCurrentFeedbackContour(point);
assert(positionEvent->GetSender()->GetRenderWindow());
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
void mitk::CorrectorTool2D::OnMouseReleased(StateMachineAction *, InteractionEvent *interactionEvent)
{
// 1. Hide the feedback contour, find out which slice the user clicked, find out which slice of the toolmanager's
// working image corresponds to that
FeedbackContourTool::SetFeedbackContourVisible(false);
auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
// const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
if (!positionEvent)
return;
assert(positionEvent->GetSender()->GetRenderWindow());
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
DataNode *workingNode(m_ToolManager->GetWorkingData(0));
if (!workingNode)
return;
auto *workingImage = dynamic_cast<Image *>(workingNode->GetData());
const PlaneGeometry *planeGeometry((positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()));
if (!workingImage || !planeGeometry)
return;
const auto *abstractTransformGeometry(
dynamic_cast<const AbstractTransformGeometry *>(positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()));
if (!workingImage || abstractTransformGeometry)
return;
// 2. Slice is known, now we try to get it as a 2D image and project the contour into index coordinates of this slice
m_WorkingSlice = FeedbackContourTool::GetAffectedImageSliceAs2DImage(positionEvent, workingImage);
if (m_WorkingSlice.IsNull())
{
MITK_ERROR << "Unable to extract slice." << std::endl;
return;
}
- int timestep = positionEvent->GetSender()->GetTimeStep();
+ auto feedbackContour = this->GetFeedbackContour();
+ auto timestep = positionEvent->GetSender()->GetTimeStep(feedbackContour);
mitk::ContourModel::Pointer singleTimestepContour = mitk::ContourModel::New();
- auto it = FeedbackContourTool::GetFeedbackContour()->Begin(timestep);
- auto end = FeedbackContourTool::GetFeedbackContour()->End(timestep);
+ auto it = feedbackContour->Begin(timestep);
+ auto end = feedbackContour->End(timestep);
while (it != end)
{
singleTimestepContour->AddVertex((*it)->Coordinates);
it++;
}
CorrectorAlgorithm::Pointer algorithm = CorrectorAlgorithm::New();
algorithm->SetInput(m_WorkingSlice);
algorithm->SetContour(singleTimestepContour);
int activePixelValue = ContourModelUtils::GetActivePixelValue(workingImage);
algorithm->SetFillColor(activePixelValue);
try
{
algorithm->UpdateLargestPossibleRegion();
}
catch (std::exception &e)
{
MITK_ERROR << "Caught exception '" << e.what() << "'" << std::endl;
}
- mitk::Image::Pointer resultSlice = mitk::Image::New();
- resultSlice->Initialize(algorithm->GetOutput());
-
- auto* labelSetImage = dynamic_cast<LabelSetImage*>(workingImage);
- if (nullptr != labelSetImage)
- {
- mitk::Image::Pointer erg1 = FeedbackContourTool::GetAffectedImageSliceAs2DImage(positionEvent, workingImage);
- SegTool2D::WritePreviewOnWorkingImage(erg1, algorithm->GetOutput(), workingImage, activePixelValue, 0);
- SegTool2D::WriteBackSegmentationResult(positionEvent, erg1);
- }
- else
- {
- mitk::ImageReadAccessor imAccess(algorithm->GetOutput());
- resultSlice->SetVolume(imAccess.GetData());
- this->WriteBackSegmentationResult(positionEvent, resultSlice);
- }
+ mitk::Image::Pointer resultSlice = FeedbackContourTool::GetAffectedImageSliceAs2DImage(positionEvent, workingImage);
+ SegTool2D::WritePreviewOnWorkingImage(resultSlice, algorithm->GetOutput(), workingImage, activePixelValue);
+ SegTool2D::WriteBackSegmentationResult(positionEvent, resultSlice);
}
diff --git a/Modules/Segmentation/Interactions/mitkDrawPaintbrushTool.cpp b/Modules/Segmentation/Interactions/mitkDrawPaintbrushTool.cpp
index 9f15b3765d..644e2de507 100644
--- a/Modules/Segmentation/Interactions/mitkDrawPaintbrushTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkDrawPaintbrushTool.cpp
@@ -1,58 +1,59 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkDrawPaintbrushTool.h"
#include "mitkDrawPaintbrushTool.xpm"
// us
#include <usGetModuleContext.h>
#include <usModule.h>
#include <usModuleContext.h>
#include <usModuleResource.h>
namespace mitk
{
MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, DrawPaintbrushTool, "Paintbrush drawing tool");
}
mitk::DrawPaintbrushTool::DrawPaintbrushTool() : PaintbrushTool(1)
{
+ FeedbackContourTool::SetFeedbackContourColorDefault();
}
mitk::DrawPaintbrushTool::~DrawPaintbrushTool()
{
}
const char **mitk::DrawPaintbrushTool::GetXPM() const
{
return mitkDrawPaintbrushTool_xpm;
}
us::ModuleResource mitk::DrawPaintbrushTool::GetIconResource() const
{
us::Module *module = us::GetModuleContext()->GetModule();
us::ModuleResource resource = module->GetResource("Paint_48x48.png");
return resource;
}
us::ModuleResource mitk::DrawPaintbrushTool::GetCursorIconResource() const
{
us::Module *module = us::GetModuleContext()->GetModule();
us::ModuleResource resource = module->GetResource("Paint_Cursor_32x32.png");
return resource;
}
const char *mitk::DrawPaintbrushTool::GetName() const
{
return "Paint";
}
diff --git a/Modules/Segmentation/Interactions/mitkFastMarchingBaseTool.cpp b/Modules/Segmentation/Interactions/mitkFastMarchingBaseTool.cpp
new file mode 100644
index 0000000000..1ded558ddc
--- /dev/null
+++ b/Modules/Segmentation/Interactions/mitkFastMarchingBaseTool.cpp
@@ -0,0 +1,335 @@
+/*============================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center (DKFZ)
+All rights reserved.
+
+Use of this source code is governed by a 3-clause BSD license that can be
+found in the LICENSE file.
+
+============================================================================*/
+
+#include "mitkFastMarchingBaseTool.h"
+#include "mitkToolManager.h"
+
+#include "mitkBaseRenderer.h"
+#include "mitkInteractionConst.h"
+#include "mitkRenderingManager.h"
+#include "mitkInteractionPositionEvent.h"
+
+#include "mitkImageAccessByItk.h"
+
+#include "mitkSegTool2D.h"
+
+#include <mitkImageCast.h>
+
+// itk filter
+#include "itkBinaryThresholdImageFilter.h"
+#include "itkCurvatureAnisotropicDiffusionImageFilter.h"
+#include "itkGradientMagnitudeRecursiveGaussianImageFilter.h"
+#include "itkSigmoidImageFilter.h"
+
+// us
+#include <usGetModuleContext.h>
+#include <usModule.h>
+#include <usModuleContext.h>
+#include <usModuleResource.h>
+
+
+mitk::FastMarchingBaseTool::FastMarchingBaseTool(unsigned int toolDim)
+ : AutoSegmentationWithPreviewTool(false, "FastMarchingTool"),
+ m_LowerThreshold(0),
+ m_UpperThreshold(200),
+ m_StoppingValue(100),
+ m_Sigma(1.0),
+ m_Alpha(-0.5),
+ m_Beta(3.0),
+ m_ToolDimension(toolDim)
+{
+}
+
+mitk::FastMarchingBaseTool::~FastMarchingBaseTool()
+{
+}
+
+bool mitk::FastMarchingBaseTool::CanHandle(const BaseData* referenceData, const BaseData* workingData) const
+{
+ if(!Superclass::CanHandle(referenceData, workingData))
+ return false;
+
+ if (referenceData == nullptr)
+ return false;
+
+ auto *image = dynamic_cast<const Image *>(referenceData);
+
+ if (image == nullptr)
+ return false;
+
+ if (image->GetDimension() < 3)
+ return false;
+
+ return true;
+}
+
+const char **mitk::FastMarchingBaseTool::GetXPM() const
+{
+ return nullptr; // mitkFastMarchingBaseTool_xpm;
+}
+
+us::ModuleResource mitk::FastMarchingBaseTool::GetIconResource() const
+{
+ us::Module *module = us::GetModuleContext()->GetModule();
+ us::ModuleResource resource = module->GetResource("FastMarching_48x48.png");
+ return resource;
+}
+
+us::ModuleResource mitk::FastMarchingBaseTool::GetCursorIconResource() const
+{
+ us::Module* module = us::GetModuleContext()->GetModule();
+ us::ModuleResource resource = module->GetResource("FastMarching_Cursor_32x32.png");
+ return resource;
+}
+
+void mitk::FastMarchingBaseTool::SetUpperThreshold(double value)
+{
+ m_UpperThreshold = value / 10.0;
+}
+
+void mitk::FastMarchingBaseTool::SetLowerThreshold(double value)
+{
+ m_LowerThreshold = value / 10.0;
+}
+
+void mitk::FastMarchingBaseTool::SetBeta(double value)
+{
+ if (m_Beta != value)
+ {
+ m_Beta = value;
+ }
+}
+
+void mitk::FastMarchingBaseTool::SetSigma(double value)
+{
+ if (m_Sigma != value)
+ {
+ if (value > 0.0)
+ {
+ m_Sigma = value;
+ }
+ }
+}
+
+void mitk::FastMarchingBaseTool::SetAlpha(double value)
+{
+ if (m_Alpha != value)
+ {
+ m_Alpha = value;
+ }
+}
+
+void mitk::FastMarchingBaseTool::SetStoppingValue(double value)
+{
+ if (m_StoppingValue != value)
+ {
+ m_StoppingValue = value;
+ }
+}
+
+void mitk::FastMarchingBaseTool::Activated()
+{
+ Superclass::Activated();
+
+ m_SeedsAsPointSet = mitk::PointSet::New();
+ //ensure that the seed points are visible for all timepoints.
+ dynamic_cast<ProportionalTimeGeometry*>(m_SeedsAsPointSet->GetTimeGeometry())->SetStepDuration(std::numeric_limits<TimePointType>::max());
+
+ m_SeedsAsPointSetNode = mitk::DataNode::New();
+ m_SeedsAsPointSetNode->SetData(m_SeedsAsPointSet);
+ m_SeedsAsPointSetNode->SetName(std::string(this->GetName()) + "_PointSet");
+ m_SeedsAsPointSetNode->SetBoolProperty("helper object", true);
+ m_SeedsAsPointSetNode->SetColor(0.0, 1.0, 0.0);
+ m_SeedsAsPointSetNode->SetVisibility(true);
+
+ m_ToolManager->GetDataStorage()->Add(m_SeedsAsPointSetNode, m_ToolManager->GetWorkingData(0));
+}
+
+void mitk::FastMarchingBaseTool::Deactivated()
+{
+ this->ClearSeeds();
+
+ m_ToolManager->GetDataStorage()->Remove(m_SeedsAsPointSetNode);
+ m_SeedsAsPointSetNode = nullptr;
+ m_SeedsAsPointSet = nullptr;
+
+ Superclass::Deactivated();
+}
+
+void mitk::FastMarchingBaseTool::ConnectActionsAndFunctions()
+{
+ CONNECT_FUNCTION("ShiftSecondaryButtonPressed", OnAddPoint);
+ CONNECT_FUNCTION("ShiftPrimaryButtonPressed", OnAddPoint);
+ CONNECT_FUNCTION("DeletePoint", OnDelete);
+}
+
+void mitk::FastMarchingBaseTool::OnAddPoint(StateMachineAction*, InteractionEvent* interactionEvent)
+{
+ if (!this->IsUpdating() && m_SeedsAsPointSet.IsNotNull())
+ {
+ const auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>(interactionEvent);
+
+ if (positionEvent != nullptr)
+ {
+ auto workingPlaneGeometry = positionEvent->GetSender()->GetCurrentWorldPlaneGeometry();
+
+ // if click was on another plane and we are in 2D mode we should reset the seeds
+ if (m_ToolDimension == 2 && ( nullptr == this->GetWorkingPlaneGeometry() || !this->GetWorkingPlaneGeometry()->IsOnPlane(workingPlaneGeometry)))
+ {
+ this->ClearSeeds();
+ this->SetWorkingPlaneGeometry(workingPlaneGeometry->Clone());
+ }
+
+ m_SeedsAsPointSet->InsertPoint(m_SeedsAsPointSet->GetSize(), positionEvent->GetPositionInWorld());
+
+ mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+
+ this->UpdatePreview();
+ }
+ }
+}
+
+void mitk::FastMarchingBaseTool::OnDelete(StateMachineAction*, InteractionEvent* /*interactionEvent*/)
+{
+ if (!this->IsUpdating() && m_SeedsAsPointSet.IsNotNull())
+ {
+ // delete last seed point
+ if (this->m_SeedsAsPointSet->GetSize() > 0)
+ {
+ m_SeedsAsPointSet->RemovePointAtEnd(0);
+
+ mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+
+ this->UpdatePreview();
+ }
+ }
+}
+
+void mitk::FastMarchingBaseTool::ClearSeeds()
+{
+ if (this->m_SeedsAsPointSet.IsNotNull())
+ {
+ // renew pointset
+ this->m_SeedsAsPointSet = mitk::PointSet::New();
+ //ensure that the seed points are visible for all timepoints.
+ dynamic_cast<ProportionalTimeGeometry*>(m_SeedsAsPointSet->GetTimeGeometry())->SetStepDuration(std::numeric_limits<TimePointType>::max());
+ this->m_SeedsAsPointSetNode->SetData(this->m_SeedsAsPointSet);
+ }
+}
+
+template <typename TPixel, unsigned int VImageDimension>
+void mitk::FastMarchingBaseTool::DoITKFastMarching(const itk::Image<TPixel, VImageDimension>* inputImage,
+ Image* previewImage, unsigned int timeStep, const BaseGeometry* inputGeometry)
+{
+ // typedefs for itk pipeline
+ typedef itk::Image<TPixel, VImageDimension> InputImageType;
+
+ typedef float InternalPixelType;
+ typedef itk::Image<InternalPixelType, VImageDimension> InternalImageType;
+
+ typedef mitk::Tool::DefaultSegmentationDataType OutputPixelType;
+ typedef itk::Image<OutputPixelType, VImageDimension> OutputImageType;
+
+ typedef itk::CurvatureAnisotropicDiffusionImageFilter<InputImageType, InternalImageType> SmoothingFilterType;
+ typedef itk::GradientMagnitudeRecursiveGaussianImageFilter<InternalImageType, InternalImageType> GradientFilterType;
+ typedef itk::SigmoidImageFilter<InternalImageType, InternalImageType> SigmoidFilterType;
+ typedef itk::BinaryThresholdImageFilter<InternalImageType, OutputImageType> ThresholdingFilterType;
+
+ typedef itk::FastMarchingImageFilter<InternalImageType, InternalImageType> FastMarchingFilterType;
+ typedef typename FastMarchingFilterType::NodeContainer NodeContainer;
+ typedef typename FastMarchingFilterType::NodeType NodeType;
+
+ //convert point set seed into trialpoint
+ typename NodeContainer::Pointer trialPoints = NodeContainer::New();
+ trialPoints->Initialize();
+
+ for (auto pos = m_SeedsAsPointSet->Begin(); pos != m_SeedsAsPointSet->End(); ++pos)
+ {
+ mitk::Point3D clickInIndex;
+
+ inputGeometry->WorldToIndex(pos->Value(), clickInIndex);
+ itk::Index<VImageDimension> seedPosition;
+ for (unsigned int dim = 0; dim < VImageDimension; ++dim)
+ {
+ seedPosition[dim] = clickInIndex[dim];
+ }
+
+ NodeType node;
+ const double seedValue = 0.0;
+ node.SetValue(seedValue);
+ node.SetIndex(seedPosition);
+ trialPoints->InsertElement(trialPoints->Size(), node);
+ }
+
+ // assemble pipeline
+ auto smoothFilter = SmoothingFilterType::New();
+ smoothFilter->AddObserver(itk::ProgressEvent(), m_ProgressCommand);
+ smoothFilter->SetTimeStep(0.05);
+ smoothFilter->SetNumberOfIterations(2);
+ smoothFilter->SetConductanceParameter(9.0);
+
+ auto gradientMagnitudeFilter = GradientFilterType::New();
+ gradientMagnitudeFilter->AddObserver(itk::ProgressEvent(), m_ProgressCommand);
+ gradientMagnitudeFilter->SetSigma(m_Sigma);
+
+ auto sigmoidFilter = SigmoidFilterType::New();
+ sigmoidFilter->AddObserver(itk::ProgressEvent(), m_ProgressCommand);
+ sigmoidFilter->SetAlpha(m_Alpha);
+ sigmoidFilter->SetBeta(m_Beta);
+ sigmoidFilter->SetOutputMinimum(0.0);
+ sigmoidFilter->SetOutputMaximum(1.0);
+
+ auto fastMarchingFilter = FastMarchingFilterType::New();
+ fastMarchingFilter->AddObserver(itk::ProgressEvent(), m_ProgressCommand);
+ fastMarchingFilter->SetStoppingValue(m_StoppingValue);
+ fastMarchingFilter->SetTrialPoints(trialPoints);
+
+ auto thresholdFilter = ThresholdingFilterType::New();
+ thresholdFilter->SetLowerThreshold(m_LowerThreshold);
+ thresholdFilter->SetUpperThreshold(m_UpperThreshold);
+ thresholdFilter->SetOutsideValue(0);
+ thresholdFilter->SetInsideValue(1.0);
+
+ // set up pipeline
+ smoothFilter->SetInput(inputImage);
+ gradientMagnitudeFilter->SetInput(smoothFilter->GetOutput());
+ sigmoidFilter->SetInput(gradientMagnitudeFilter->GetOutput());
+ fastMarchingFilter->SetInput(sigmoidFilter->GetOutput());
+ thresholdFilter->SetInput(fastMarchingFilter->GetOutput());
+ thresholdFilter->Update();
+
+ if (nullptr == this->GetWorkingPlaneGeometry())
+ {
+ previewImage->SetVolume((void*)(thresholdFilter->GetOutput()->GetPixelContainer()->GetBufferPointer()), timeStep);
+ }
+ else
+ {
+ mitk::Image::Pointer sliceImage = mitk::Image::New();
+ mitk::CastToMitkImage(thresholdFilter->GetOutput(), sliceImage);
+ SegTool2D::WriteSliceToVolume(previewImage, this->GetWorkingPlaneGeometry(), sliceImage, timeStep, false);
+ }
+}
+
+void mitk::FastMarchingBaseTool::DoUpdatePreview(const Image* inputAtTimeStep, Image* previewImage, TimeStepType timeStep)
+{
+ if (nullptr != inputAtTimeStep && nullptr != previewImage && m_SeedsAsPointSet.IsNotNull() && m_SeedsAsPointSet->GetSize()>0)
+ {
+ if (nullptr == this->GetWorkingPlaneGeometry())
+ {
+ AccessFixedDimensionByItk_n(inputAtTimeStep, DoITKFastMarching, 3, (previewImage, timeStep, inputAtTimeStep->GetGeometry()));
+ }
+ else
+ {
+ AccessFixedDimensionByItk_n(inputAtTimeStep, DoITKFastMarching, 2, (previewImage, timeStep, inputAtTimeStep->GetGeometry()));
+ }
+ }
+}
diff --git a/Modules/Segmentation/Interactions/mitkFastMarchingTool3D.h b/Modules/Segmentation/Interactions/mitkFastMarchingBaseTool.h
similarity index 67%
copy from Modules/Segmentation/Interactions/mitkFastMarchingTool3D.h
copy to Modules/Segmentation/Interactions/mitkFastMarchingBaseTool.h
index 652e0d550b..ebec9fd0b2 100644
--- a/Modules/Segmentation/Interactions/mitkFastMarchingTool3D.h
+++ b/Modules/Segmentation/Interactions/mitkFastMarchingBaseTool.h
@@ -1,124 +1,118 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
-#ifndef mitkFastMarchingTool3D_h_Included
-#define mitkFastMarchingTool3D_h_Included
+#ifndef mitkFastMarchingBaseTool_h_Included
+#define mitkFastMarchingBaseTool_h_Included
#include "mitkAutoSegmentationWithPreviewTool.h"
#include "mitkDataNode.h"
#include "mitkPointSet.h"
#include "mitkPointSetDataInteractor.h"
#include "mitkToolCommand.h"
#include "itkImage.h"
#include "itkFastMarchingImageFilter.h"
#include <MitkSegmentationExports.h>
namespace us
{
class ModuleResource;
}
namespace mitk
{
/**
- \brief FastMarching semgentation tool.
+ \brief FastMarching semgentation tool base class.
The segmentation is done by setting one or more seed points on the image
and adapting the time range and threshold. The pipeline is:
Smoothing->GradientMagnitude->SigmoidFunction->FastMarching->Threshold
The resulting binary image is seen as a segmentation of an object.
For detailed documentation see ITK Software Guide section 9.3.1 Fast Marching Segmentation.
*/
- class MITKSEGMENTATION_EXPORT FastMarchingTool3D : public AutoSegmentationWithPreviewTool
+ class MITKSEGMENTATION_EXPORT FastMarchingBaseTool : public AutoSegmentationWithPreviewTool
{
public:
- mitkClassMacro(FastMarchingTool3D, AutoSegmentationWithPreviewTool);
- itkFactorylessNewMacro(Self);
- itkCloneMacro(Self);
+ mitkClassMacro(FastMarchingBaseTool, AutoSegmentationWithPreviewTool);
bool CanHandle(const BaseData* referenceData, const BaseData* workingData) const override;
/* icon stuff */
const char **GetXPM() const override;
- const char *GetName() const override;
+ us::ModuleResource GetCursorIconResource() const override;
us::ModuleResource GetIconResource() const override;
void Activated() override;
void Deactivated() override;
/// \brief Set parameter used in Threshold filter.
void SetUpperThreshold(double);
/// \brief Set parameter used in Threshold filter.
void SetLowerThreshold(double);
/// \brief Set parameter used in Fast Marching filter.
void SetStoppingValue(double);
/// \brief Set parameter used in Gradient Magnitude filter.
void SetSigma(double);
/// \brief Set parameter used in Fast Marching filter.
void SetAlpha(double);
/// \brief Set parameter used in Fast Marching filter.
void SetBeta(double);
/// \brief Clear all seed points.
void ClearSeeds();
+
protected:
- FastMarchingTool3D();
- ~FastMarchingTool3D() override;
+ FastMarchingBaseTool(unsigned int toolDim);
+ ~FastMarchingBaseTool() override;
+
+ void ConnectActionsAndFunctions() override;
/// \brief Add point action of StateMachine pattern
- virtual void OnAddPoint();
+ virtual void OnAddPoint(StateMachineAction*, InteractionEvent* interactionEvent);
/// \brief Delete action of StateMachine pattern
- virtual void OnDelete();
+ virtual void OnDelete(StateMachineAction*, InteractionEvent* interactionEvent);
- void UpdatePrepare() override;
- void UpdateCleanUp() override;
void DoUpdatePreview(const Image* inputAtTimeStep, Image* previewImage, TimeStepType timeStep) override;
template <typename TPixel, unsigned int VImageDimension>
void DoITKFastMarching(const itk::Image<TPixel, VImageDimension>* inputImage,
- mitk::Image* segmentation, unsigned int timeStep);
+ Image* segmentation, unsigned int timeStep, const BaseGeometry* inputGeometry);
float m_LowerThreshold; // used in Threshold filter
float m_UpperThreshold; // used in Threshold filter
float m_StoppingValue; // used in Fast Marching filter
float m_Sigma; // used in GradientMagnitude filter
float m_Alpha; // used in Sigmoid filter
float m_Beta; // used in Sigmoid filter
- typedef float InternalPixelType;
- typedef itk::Image<InternalPixelType, 3> InternalImageType;
- typedef itk::FastMarchingImageFilter<InternalImageType, InternalImageType> FastMarchingFilterType;
- typedef FastMarchingFilterType::NodeContainer NodeContainer;
- typedef FastMarchingFilterType::NodeType NodeType;
+ DataNode::Pointer m_SeedsAsPointSetNode; // used to visualize the seed points
+ PointSet::Pointer m_SeedsAsPointSet;
- NodeContainer::Pointer m_SeedContainer; // seed points for FastMarching
+ private:
+ /** Indicating if the tool is used in 2D mode (just segment the current slice)
+ * or 3D mode (segment the whole current volume),*/
+ unsigned int m_ToolDimension;
- mitk::DataNode::Pointer m_SeedsAsPointSetNode; // used to visualize the seed points
- mitk::PointSet::Pointer m_SeedsAsPointSet;
- mitk::PointSetDataInteractor::Pointer m_SeedPointInteractor;
- unsigned int m_PointSetAddObserverTag;
- unsigned int m_PointSetRemoveObserverTag;
};
} // namespace
#endif
diff --git a/Modules/Segmentation/Interactions/mitkFastMarchingTool.cpp b/Modules/Segmentation/Interactions/mitkFastMarchingTool.cpp
index b4220d6acb..95eb57c850 100644
--- a/Modules/Segmentation/Interactions/mitkFastMarchingTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkFastMarchingTool.cpp
@@ -1,483 +1,34 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkFastMarchingTool.h"
-#include "mitkToolManager.h"
-#include "mitkBaseRenderer.h"
-#include "mitkInteractionConst.h"
-#include "mitkRenderingManager.h"
-
-#include "itkOrImageFilter.h"
-#include "mitkImageTimeSelector.h"
-
-// us
-#include <usGetModuleContext.h>
-#include <usModule.h>
-#include <usModuleContext.h>
-#include <usModuleResource.h>
namespace mitk
{
MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, FastMarchingTool, "FastMarching2D tool");
}
mitk::FastMarchingTool::FastMarchingTool()
- : FeedbackContourTool("FastMarchingTool"),
- m_NeedUpdate(true),
- m_CurrentTimeStep(0),
- m_PositionEvent(nullptr),
- m_LowerThreshold(0),
- m_UpperThreshold(200),
- m_StoppingValue(100),
- m_Sigma(1.0),
- m_Alpha(-0.5),
- m_Beta(3.0)
+ : FastMarchingBaseTool(2)
{
}
mitk::FastMarchingTool::~FastMarchingTool()
{
- if (this->m_SmoothFilter.IsNotNull())
- this->m_SmoothFilter->RemoveAllObservers();
-
- if (this->m_SigmoidFilter.IsNotNull())
- this->m_SigmoidFilter->RemoveAllObservers();
-
- if (this->m_GradientMagnitudeFilter.IsNotNull())
- this->m_GradientMagnitudeFilter->RemoveAllObservers();
-
- if (this->m_FastMarchingFilter.IsNotNull())
- this->m_FastMarchingFilter->RemoveAllObservers();
-}
-
-void mitk::FastMarchingTool::ConnectActionsAndFunctions()
-{
- CONNECT_FUNCTION("ShiftSecondaryButtonPressed", OnAddPoint);
- CONNECT_FUNCTION("ShiftPrimaryButtonPressed", OnAddPoint);
- CONNECT_FUNCTION("DeletePoint", OnDelete);
-}
-
-const char **mitk::FastMarchingTool::GetXPM() const
-{
- return nullptr; // mitkFastMarchingTool_xpm;
-}
-
-us::ModuleResource mitk::FastMarchingTool::GetIconResource() const
-{
- us::Module *module = us::GetModuleContext()->GetModule();
- us::ModuleResource resource = module->GetResource("FastMarching_48x48.png");
- return resource;
-}
-
-us::ModuleResource mitk::FastMarchingTool::GetCursorIconResource() const
-{
- us::Module *module = us::GetModuleContext()->GetModule();
- us::ModuleResource resource = module->GetResource("FastMarching_Cursor_32x32.png");
- return resource;
}
const char *mitk::FastMarchingTool::GetName() const
{
return "2D Fast Marching";
}
-void mitk::FastMarchingTool::BuildITKPipeline()
-{
- m_ReferenceImageSliceAsITK = InternalImageType::New();
-
- m_ReferenceImageSlice = GetAffectedReferenceSlice(m_PositionEvent);
- CastToItkImage(m_ReferenceImageSlice, m_ReferenceImageSliceAsITK);
-
- m_ProgressCommand = mitk::ToolCommand::New();
-
- m_SmoothFilter = SmoothingFilterType::New();
- m_SmoothFilter->SetInput(m_ReferenceImageSliceAsITK);
- m_SmoothFilter->SetTimeStep(0.05);
- m_SmoothFilter->SetNumberOfIterations(2);
- m_SmoothFilter->SetConductanceParameter(9.0);
-
- m_GradientMagnitudeFilter = GradientFilterType::New();
- m_GradientMagnitudeFilter->SetSigma(m_Sigma);
-
- m_SigmoidFilter = SigmoidFilterType::New();
- m_SigmoidFilter->SetAlpha(m_Alpha);
- m_SigmoidFilter->SetBeta(m_Beta);
- m_SigmoidFilter->SetOutputMinimum(0.0);
- m_SigmoidFilter->SetOutputMaximum(1.0);
-
- m_FastMarchingFilter = FastMarchingFilterType::New();
- m_FastMarchingFilter->SetStoppingValue(m_StoppingValue);
-
- m_ThresholdFilter = ThresholdingFilterType::New();
- m_ThresholdFilter->SetLowerThreshold(m_LowerThreshold);
- m_ThresholdFilter->SetUpperThreshold(m_UpperThreshold);
- m_ThresholdFilter->SetOutsideValue(0);
- m_ThresholdFilter->SetInsideValue(1.0);
-
- m_SeedContainer = NodeContainer::New();
- m_SeedContainer->Initialize();
- m_FastMarchingFilter->SetTrialPoints(m_SeedContainer);
-
- if (this->m_SmoothFilter.IsNotNull())
- this->m_SmoothFilter->RemoveAllObservers();
-
- if (this->m_SigmoidFilter.IsNotNull())
- this->m_SigmoidFilter->RemoveAllObservers();
-
- if (this->m_GradientMagnitudeFilter.IsNotNull())
- this->m_GradientMagnitudeFilter->RemoveAllObservers();
-
- if (this->m_FastMarchingFilter.IsNotNull())
- this->m_FastMarchingFilter->RemoveAllObservers();
-
- m_SmoothFilter->AddObserver(itk::ProgressEvent(), m_ProgressCommand);
- m_GradientMagnitudeFilter->AddObserver(itk::ProgressEvent(), m_ProgressCommand);
- m_SigmoidFilter->AddObserver(itk::ProgressEvent(), m_ProgressCommand);
- m_FastMarchingFilter->AddObserver(itk::ProgressEvent(), m_ProgressCommand);
-
- m_SmoothFilter->SetInput(m_ReferenceImageSliceAsITK);
- m_GradientMagnitudeFilter->SetInput(m_SmoothFilter->GetOutput());
- m_SigmoidFilter->SetInput(m_GradientMagnitudeFilter->GetOutput());
- m_FastMarchingFilter->SetInput(m_SigmoidFilter->GetOutput());
- m_ThresholdFilter->SetInput(m_FastMarchingFilter->GetOutput());
- m_ReferenceImageSliceAsITK = InternalImageType::New();
-}
-
-void mitk::FastMarchingTool::SetUpperThreshold(double value)
-{
- if (m_UpperThreshold != value)
- {
- m_UpperThreshold = value / 10.0;
- m_ThresholdFilter->SetUpperThreshold(m_UpperThreshold);
- m_NeedUpdate = true;
- }
-}
-
-void mitk::FastMarchingTool::SetLowerThreshold(double value)
-{
- if (m_LowerThreshold != value)
- {
- m_LowerThreshold = value / 10.0;
- m_ThresholdFilter->SetLowerThreshold(m_LowerThreshold);
- m_NeedUpdate = true;
- }
-}
-
-void mitk::FastMarchingTool::SetBeta(double value)
-{
- if (m_Beta != value)
- {
- m_Beta = value;
- m_SigmoidFilter->SetBeta(m_Beta);
- m_NeedUpdate = true;
- }
-}
-
-void mitk::FastMarchingTool::SetSigma(double value)
-{
- if (m_Sigma != value)
- {
- m_Sigma = value;
- m_GradientMagnitudeFilter->SetSigma(m_Sigma);
- m_NeedUpdate = true;
- }
-}
-
-void mitk::FastMarchingTool::SetAlpha(double value)
-{
- if (m_Alpha != value)
- {
- m_Alpha = value;
- m_SigmoidFilter->SetAlpha(m_Alpha);
- m_NeedUpdate = true;
- }
-}
-
-void mitk::FastMarchingTool::SetStoppingValue(double value)
-{
- if (m_StoppingValue != value)
- {
- m_StoppingValue = value;
- m_FastMarchingFilter->SetStoppingValue(m_StoppingValue);
- m_NeedUpdate = true;
- }
-}
-
-void mitk::FastMarchingTool::Activated()
-{
- Superclass::Activated();
-
- m_ResultImageNode = mitk::DataNode::New();
- m_ResultImageNode->SetName("FastMarching_Preview");
- m_ResultImageNode->SetBoolProperty("helper object", true);
- m_ResultImageNode->SetColor(0.0, 1.0, 0.0);
- m_ResultImageNode->SetVisibility(true);
- m_ToolManager->GetDataStorage()->Add(this->m_ResultImageNode, m_ToolManager->GetReferenceData(0));
-
- m_SeedsAsPointSet = mitk::PointSet::New();
- m_SeedsAsPointSetNode = mitk::DataNode::New();
- m_SeedsAsPointSetNode->SetData(m_SeedsAsPointSet);
- m_SeedsAsPointSetNode->SetName("Seeds_Preview");
- m_SeedsAsPointSetNode->SetBoolProperty("helper object", true);
- m_SeedsAsPointSetNode->SetColor(0.0, 1.0, 0.0);
- m_SeedsAsPointSetNode->SetVisibility(true);
- m_ToolManager->GetDataStorage()->Add(this->m_SeedsAsPointSetNode, m_ToolManager->GetReferenceData(0));
-
- this->Initialize();
-}
-
-void mitk::FastMarchingTool::Deactivated()
-{
- m_ToolManager->GetDataStorage()->Remove(this->m_ResultImageNode);
- m_ToolManager->GetDataStorage()->Remove(this->m_SeedsAsPointSetNode);
- this->ClearSeeds();
- m_ResultImageNode = nullptr;
- m_SeedsAsPointSetNode = nullptr;
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();
-
- Superclass::Deactivated();
-}
-
-void mitk::FastMarchingTool::Initialize()
-{
- m_ReferenceImage = dynamic_cast<mitk::Image *>(m_ToolManager->GetReferenceData(0)->GetData());
- if (m_ReferenceImage->GetTimeGeometry()->CountTimeSteps() > 1)
- {
- mitk::ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
- timeSelector->SetInput(m_ReferenceImage);
- timeSelector->SetTimeNr(m_CurrentTimeStep);
- timeSelector->UpdateLargestPossibleRegion();
- m_ReferenceImage = timeSelector->GetOutput();
- }
- m_NeedUpdate = true;
-}
-
-void mitk::FastMarchingTool::ConfirmSegmentation()
-{
- // combine preview image with current working segmentation
- if (dynamic_cast<mitk::Image *>(m_ResultImageNode->GetData()))
- {
- // logical or combination of preview and segmentation slice
-
- Image::Pointer workingImageSlice;
-
- Image::Pointer workingImage = dynamic_cast<Image *>(this->m_ToolManager->GetWorkingData(0)->GetData());
- TimePointType referenceImageTimePoint = m_ReferenceImage->GetTimeGeometry()->TimeStepToTimePoint(m_CurrentTimeStep);
- TimeStepType workingImageTimeStep = workingImage->GetTimeGeometry()->TimePointToTimeStep(referenceImageTimePoint);
- workingImageSlice = GetAffectedImageSliceAs2DImage(m_WorkingPlane, workingImage, workingImageTimeStep);
-
- Image::Pointer segmentationResult = Image::New();
-
- bool isDeprecatedUnsignedCharSegmentation =
- (workingImage->GetPixelType().GetComponentType() == itk::ImageIOBase::UCHAR);
-
- if (isDeprecatedUnsignedCharSegmentation)
- {
- typedef itk::Image<unsigned char, 2> OutputUCharImageType;
- OutputUCharImageType::Pointer workingImageSliceInITK = OutputUCharImageType::New();
-
- CastToItkImage(workingImageSlice, workingImageSliceInITK);
-
- typedef itk::OrImageFilter<OutputImageType, OutputUCharImageType, OutputUCharImageType> OrImageFilterType;
- OrImageFilterType::Pointer orFilter = OrImageFilterType::New();
-
- orFilter->SetInput1(m_ThresholdFilter->GetOutput());
- orFilter->SetInput2(workingImageSliceInITK);
- orFilter->Update();
-
- mitk::CastToMitkImage(orFilter->GetOutput(), segmentationResult);
- }
- else
- {
- OutputImageType::Pointer workingImageSliceInITK = OutputImageType::New();
-
- CastToItkImage(workingImageSlice, workingImageSliceInITK);
-
- typedef itk::OrImageFilter<OutputImageType, OutputImageType> OrImageFilterType;
- OrImageFilterType::Pointer orFilter = OrImageFilterType::New();
-
- orFilter->SetInput(0, m_ThresholdFilter->GetOutput());
- orFilter->SetInput(1, workingImageSliceInITK);
- orFilter->Update();
-
- mitk::CastToMitkImage(orFilter->GetOutput(), segmentationResult);
- }
-
- segmentationResult->GetGeometry()->SetOrigin(workingImageSlice->GetGeometry()->GetOrigin());
- segmentationResult->GetGeometry()->SetIndexToWorldTransform(
- workingImageSlice->GetGeometry()->GetIndexToWorldTransform());
-
- // write to segmentation volume and hide preview image
- // again, current time step is not considered
- this->WriteBackSegmentationResult(m_WorkingPlane, segmentationResult, workingImageTimeStep);
- this->m_ResultImageNode->SetVisibility(false);
-
- this->ClearSeeds();
- }
-
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();
- m_ToolManager->ActivateTool(-1);
-}
-
-void mitk::FastMarchingTool::OnAddPoint(StateMachineAction *, InteractionEvent *interactionEvent)
-{
- // Add a new seed point for FastMarching algorithm
- auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
- // const PositionEvent* p = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
- if (positionEvent == nullptr)
- return;
-
- if (m_PositionEvent.IsNotNull())
- m_PositionEvent = nullptr;
-
- m_PositionEvent =
- InteractionPositionEvent::New(positionEvent->GetSender(), positionEvent->GetPointerPositionOnScreen());
-
- // if click was on another renderwindow or slice then reset pipeline and preview
- if ((m_LastEventSender != m_PositionEvent->GetSender()) ||
- (m_LastEventSlice != m_PositionEvent->GetSender()->GetSlice()))
- {
- this->BuildITKPipeline();
- this->ClearSeeds();
- }
-
- m_LastEventSender = m_PositionEvent->GetSender();
- m_LastEventSlice = m_LastEventSender->GetSlice();
- m_WorkingPlane = positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()->Clone();
-
- mitk::Point3D clickInIndex;
-
- m_ReferenceImageSlice->GetGeometry()->WorldToIndex(m_PositionEvent->GetPositionInWorld(), clickInIndex);
- itk::Index<2> seedPosition;
- seedPosition[0] = clickInIndex[0];
- seedPosition[1] = clickInIndex[1];
-
- NodeType node;
- const double seedValue = 0.0;
- node.SetValue(seedValue);
- node.SetIndex(seedPosition);
- this->m_SeedContainer->InsertElement(this->m_SeedContainer->Size(), node);
- m_FastMarchingFilter->Modified();
-
- m_SeedsAsPointSet->InsertPoint(m_SeedsAsPointSet->GetSize(), m_PositionEvent->GetPositionInWorld());
-
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();
-
- m_NeedUpdate = true;
-
- this->Update();
-
- m_ReadyMessage.Send();
-}
-
-void mitk::FastMarchingTool::OnDelete(StateMachineAction *, InteractionEvent *)
-{
- // delete last seed point
- if (!(this->m_SeedContainer->empty()))
- {
- // delete last element of seeds container
- this->m_SeedContainer->pop_back();
- m_FastMarchingFilter->Modified();
-
- // delete last point in pointset - somehow ugly
- m_SeedsAsPointSet->GetPointSet()->GetPoints()->DeleteIndex(m_SeedsAsPointSet->GetSize() - 1);
-
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();
-
- m_NeedUpdate = true;
-
- this->Update();
- }
-}
-
-void mitk::FastMarchingTool::Update()
-{
- const unsigned int progress_steps = 20;
-
- // update FastMarching pipeline and show result
- if (m_NeedUpdate)
- {
- m_ProgressCommand->AddStepsToDo(progress_steps);
- CurrentlyBusy.Send(true);
- try
- {
- m_ThresholdFilter->Update();
- }
- catch (itk::ExceptionObject &excep)
- {
- MITK_ERROR << "Exception caught: " << excep.GetDescription();
-
- // progress by max step count, will force
- m_ProgressCommand->SetProgress(progress_steps);
- CurrentlyBusy.Send(false);
-
- std::string msg = excep.GetDescription();
- ErrorMessage.Send(msg);
-
- return;
- }
- m_ProgressCommand->SetProgress(progress_steps);
- CurrentlyBusy.Send(false);
-
- // make output visible
- mitk::Image::Pointer result = mitk::Image::New();
- CastToMitkImage(m_ThresholdFilter->GetOutput(), result);
- result->GetGeometry()->SetOrigin(m_ReferenceImageSlice->GetGeometry()->GetOrigin());
- result->GetGeometry()->SetIndexToWorldTransform(m_ReferenceImageSlice->GetGeometry()->GetIndexToWorldTransform());
- m_ResultImageNode->SetData(result);
- m_ResultImageNode->SetVisibility(true);
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();
- }
-}
-
-void mitk::FastMarchingTool::ClearSeeds()
-{
- // clear seeds for FastMarching as well as the PointSet for visualization
- if (this->m_SeedContainer.IsNotNull())
- this->m_SeedContainer->Initialize();
-
- if (this->m_SeedsAsPointSet.IsNotNull())
- {
- this->m_SeedsAsPointSet = mitk::PointSet::New();
- this->m_SeedsAsPointSetNode->SetData(this->m_SeedsAsPointSet);
- m_SeedsAsPointSetNode->SetName("Seeds_Preview");
- m_SeedsAsPointSetNode->SetBoolProperty("helper object", true);
- m_SeedsAsPointSetNode->SetColor(0.0, 1.0, 0.0);
- m_SeedsAsPointSetNode->SetVisibility(true);
- }
-
- if (this->m_FastMarchingFilter.IsNotNull())
- m_FastMarchingFilter->Modified();
-
- this->m_NeedUpdate = true;
-}
-
-void mitk::FastMarchingTool::Reset()
-{
- // clear all seeds and preview empty result
- this->ClearSeeds();
-
- m_ResultImageNode->SetVisibility(false);
-
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();
-}
-
-void mitk::FastMarchingTool::SetCurrentTimeStep(int t)
-{
- if (m_CurrentTimeStep != t)
- {
- m_CurrentTimeStep = t;
-
- this->Initialize();
- }
-}
diff --git a/Modules/Segmentation/Interactions/mitkFastMarchingTool.h b/Modules/Segmentation/Interactions/mitkFastMarchingTool.h
index e98b2fba71..9aa06c0b1a 100644
--- a/Modules/Segmentation/Interactions/mitkFastMarchingTool.h
+++ b/Modules/Segmentation/Interactions/mitkFastMarchingTool.h
@@ -1,175 +1,48 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkFastMarchingTool_h_Included
#define mitkFastMarchingTool_h_Included
-#include "mitkDataNode.h"
-#include "mitkFeedbackContourTool.h"
-#include "mitkPointSet.h"
-#include "mitkToolCommand.h"
-#include <MitkSegmentationExports.h>
-
-#include "mitkMessage.h"
-
-#include "itkImage.h"
+#include "mitkFastMarchingBaseTool.h"
-// itk filter
-#include "itkBinaryThresholdImageFilter.h"
-#include "itkCurvatureAnisotropicDiffusionImageFilter.h"
-#include "itkFastMarchingImageFilter.h"
-#include "itkGradientMagnitudeRecursiveGaussianImageFilter.h"
-#include "itkSigmoidImageFilter.h"
-
-namespace us
-{
- class ModuleResource;
-}
+#include <MitkSegmentationExports.h>
namespace mitk
{
- class StateMachineAction;
- class InteractionEvent;
-
/**
\brief FastMarching semgentation tool.
The segmentation is done by setting one or more seed points on the image
and adapting the time range and threshold. The pipeline is:
Smoothing->GradientMagnitude->SigmoidFunction->FastMarching->Threshold
The resulting binary image is seen as a segmentation of an object.
For detailed documentation see ITK Software Guide section 9.3.1 Fast Marching Segmentation.
*/
- class MITKSEGMENTATION_EXPORT FastMarchingTool : public FeedbackContourTool
+ class MITKSEGMENTATION_EXPORT FastMarchingTool : public FastMarchingBaseTool
{
- mitkNewMessageMacro(Ready);
-
public:
- mitkClassMacro(FastMarchingTool, FeedbackContourTool);
+ mitkClassMacro(FastMarchingTool, FastMarchingBaseTool);
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
- /* typedefs for itk pipeline */
- typedef float InternalPixelType;
- typedef itk::Image<InternalPixelType, 2> InternalImageType;
- typedef mitk::Tool::DefaultSegmentationDataType OutputPixelType;
- typedef itk::Image<OutputPixelType, 2> OutputImageType;
-
- typedef itk::BinaryThresholdImageFilter<InternalImageType, OutputImageType> ThresholdingFilterType;
- typedef itk::CurvatureAnisotropicDiffusionImageFilter<InternalImageType, InternalImageType> SmoothingFilterType;
- typedef itk::GradientMagnitudeRecursiveGaussianImageFilter<InternalImageType, InternalImageType> GradientFilterType;
- typedef itk::SigmoidImageFilter<InternalImageType, InternalImageType> SigmoidFilterType;
- typedef itk::FastMarchingImageFilter<InternalImageType, InternalImageType> FastMarchingFilterType;
- typedef FastMarchingFilterType::NodeContainer NodeContainer;
- typedef FastMarchingFilterType::NodeType NodeType;
-
- /* icon stuff */
- const char **GetXPM() const override;
const char *GetName() const override;
- us::ModuleResource GetCursorIconResource() const override;
- us::ModuleResource GetIconResource() const override;
-
- /// \brief Set parameter used in Threshold filter.
- void SetUpperThreshold(double);
-
- /// \brief Set parameter used in Threshold filter.
- void SetLowerThreshold(double);
-
- /// \brief Set parameter used in Fast Marching filter.
- void SetStoppingValue(double);
-
- /// \brief Set parameter used in Gradient Magnitude filter.
- void SetSigma(double);
-
- /// \brief Set parameter used in Fast Marching filter.
- void SetAlpha(double);
-
- /// \brief Set parameter used in Fast Marching filter.
- void SetBeta(double);
-
- /// \brief Adds the feedback image to the current working image.
- virtual void ConfirmSegmentation();
-
- /// \brief Set the working time step.
- virtual void SetCurrentTimeStep(int t);
-
- /// \brief Clear all seed points.
- void ClearSeeds();
-
- /// \brief Updates the itk pipeline and shows the result of FastMarching.
- void Update();
-
protected:
FastMarchingTool();
~FastMarchingTool() override;
-
- void ConnectActionsAndFunctions() override;
-
- // virtual float CanHandleEvent( StateEvent const *stateEvent) const;
-
- void Activated() override;
- void Deactivated() override;
- virtual void Initialize();
-
- virtual void BuildITKPipeline();
-
- /// \brief Add point action of StateMachine pattern
- virtual void OnAddPoint(StateMachineAction *, InteractionEvent *interactionEvent);
-
- /// \brief Delete action of StateMachine pattern
- virtual void OnDelete(StateMachineAction *, InteractionEvent *interactionEvent);
-
- /// \brief Reset all relevant inputs of the itk pipeline.
- void Reset();
-
- mitk::ToolCommand::Pointer m_ProgressCommand;
-
- Image::Pointer m_ReferenceImage;
- Image::Pointer m_ReferenceImageSlice;
-
- bool m_NeedUpdate;
-
- int m_CurrentTimeStep;
-
- mitk::InteractionPositionEvent::Pointer m_PositionEvent;
-
- float m_LowerThreshold; // used in Threshold filter
- float m_UpperThreshold; // used in Threshold filter
- float m_StoppingValue; // used in Fast Marching filter
- float m_Sigma; // used in GradientMagnitude filter
- float m_Alpha; // used in Sigmoid filter
- float m_Beta; // used in Sigmoid filter
-
- NodeContainer::Pointer m_SeedContainer; // seed points for FastMarching
-
- InternalImageType::Pointer m_ReferenceImageSliceAsITK; // the reference image as itk::Image
-
- mitk::DataNode::Pointer m_ResultImageNode; // holds the result as a preview image
-
- mitk::DataNode::Pointer m_SeedsAsPointSetNode; // used to visualize the seed points
- mitk::PointSet::Pointer m_SeedsAsPointSet;
-
- ThresholdingFilterType::Pointer m_ThresholdFilter;
- SmoothingFilterType::Pointer m_SmoothFilter;
- GradientFilterType::Pointer m_GradientMagnitudeFilter;
- SigmoidFilterType::Pointer m_SigmoidFilter;
- FastMarchingFilterType::Pointer m_FastMarchingFilter;
-
- private:
- PlaneGeometry::Pointer m_WorkingPlane;
};
} // namespace
#endif
diff --git a/Modules/Segmentation/Interactions/mitkFastMarchingTool3D.cpp b/Modules/Segmentation/Interactions/mitkFastMarchingTool3D.cpp
index 8ada9faf2b..0de2aacf30 100644
--- a/Modules/Segmentation/Interactions/mitkFastMarchingTool3D.cpp
+++ b/Modules/Segmentation/Interactions/mitkFastMarchingTool3D.cpp
@@ -1,334 +1,32 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkFastMarchingTool3D.h"
-#include "mitkToolManager.h"
-
-#include "mitkBaseRenderer.h"
-#include "mitkInteractionConst.h"
-#include "mitkRenderingManager.h"
-
-#include "mitkImageAccessByItk.h"
-
-// itk filter
-#include "itkBinaryThresholdImageFilter.h"
-#include "itkCurvatureAnisotropicDiffusionImageFilter.h"
-#include "itkGradientMagnitudeRecursiveGaussianImageFilter.h"
-#include "itkSigmoidImageFilter.h"
-
-// us
-#include <usGetModuleContext.h>
-#include <usModule.h>
-#include <usModuleContext.h>
-#include <usModuleResource.h>
namespace mitk
{
MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, FastMarchingTool3D, "FastMarching3D tool");
}
mitk::FastMarchingTool3D::FastMarchingTool3D()
- : AutoSegmentationWithPreviewTool(),
- m_LowerThreshold(0),
- m_UpperThreshold(200),
- m_StoppingValue(100),
- m_Sigma(1.0),
- m_Alpha(-0.5),
- m_Beta(3.0),
- m_PointSetAddObserverTag(0),
- m_PointSetRemoveObserverTag(0)
+ : FastMarchingBaseTool(3)
{
}
mitk::FastMarchingTool3D::~FastMarchingTool3D()
{
}
-bool mitk::FastMarchingTool3D::CanHandle(const BaseData* referenceData, const BaseData* workingData) const
-{
- if(!Superclass::CanHandle(referenceData, workingData))
- return false;
-
- if (referenceData == nullptr)
- return false;
-
- auto *image = dynamic_cast<const Image *>(referenceData);
-
- if (image == nullptr)
- return false;
-
- if (image->GetDimension() < 3)
- return false;
-
- return true;
-}
-
-const char **mitk::FastMarchingTool3D::GetXPM() const
-{
- return nullptr; // mitkFastMarchingTool3D_xpm;
-}
-
-us::ModuleResource mitk::FastMarchingTool3D::GetIconResource() const
-{
- us::Module *module = us::GetModuleContext()->GetModule();
- us::ModuleResource resource = module->GetResource("FastMarching_48x48.png");
- return resource;
-}
-
const char *mitk::FastMarchingTool3D::GetName() const
{
return "Fast Marching 3D";
}
-
-void mitk::FastMarchingTool3D::SetUpperThreshold(double value)
-{
- m_UpperThreshold = value / 10.0;
-}
-
-void mitk::FastMarchingTool3D::SetLowerThreshold(double value)
-{
- m_LowerThreshold = value / 10.0;
-}
-
-void mitk::FastMarchingTool3D::SetBeta(double value)
-{
- if (m_Beta != value)
- {
- m_Beta = value;
- }
-}
-
-void mitk::FastMarchingTool3D::SetSigma(double value)
-{
- if (m_Sigma != value)
- {
- if (value > 0.0)
- {
- m_Sigma = value;
- }
- }
-}
-
-void mitk::FastMarchingTool3D::SetAlpha(double value)
-{
- if (m_Alpha != value)
- {
- m_Alpha = value;
- }
-}
-
-void mitk::FastMarchingTool3D::SetStoppingValue(double value)
-{
- if (m_StoppingValue != value)
- {
- m_StoppingValue = value;
- }
-}
-
-void mitk::FastMarchingTool3D::Activated()
-{
- Superclass::Activated();
-
- m_SeedsAsPointSet = mitk::PointSet::New();
- m_SeedsAsPointSetNode = mitk::DataNode::New();
- m_SeedsAsPointSetNode->SetData(m_SeedsAsPointSet);
- m_SeedsAsPointSetNode->SetName("3D_FastMarching_PointSet");
- m_SeedsAsPointSetNode->SetBoolProperty("helper object", true);
- m_SeedsAsPointSetNode->SetColor(0.0, 1.0, 0.0);
- m_SeedsAsPointSetNode->SetVisibility(true);
-
- // Create PointSetData Interactor
- m_SeedPointInteractor = mitk::PointSetDataInteractor::New();
- // Load the according state machine for regular point set interaction
- m_SeedPointInteractor->LoadStateMachine("PointSet.xml");
- // Set the configuration file that defines the triggers for the transitions
- m_SeedPointInteractor->SetEventConfig("PointSetConfig.xml");
- // set the DataNode (which already is added to the DataStorage
- m_SeedPointInteractor->SetDataNode(m_SeedsAsPointSetNode);
-
- m_ToolManager->GetDataStorage()->Add(m_SeedsAsPointSetNode, m_ToolManager->GetWorkingData(0));
-
- m_SeedContainer = NodeContainer::New();
- m_SeedContainer->Initialize();
-
- itk::SimpleMemberCommand<mitk::FastMarchingTool3D>::Pointer pointAddedCommand =
- itk::SimpleMemberCommand<mitk::FastMarchingTool3D>::New();
- pointAddedCommand->SetCallbackFunction(this, &mitk::FastMarchingTool3D::OnAddPoint);
- m_PointSetAddObserverTag = m_SeedsAsPointSet->AddObserver(mitk::PointSetAddEvent(), pointAddedCommand);
-
- itk::SimpleMemberCommand<mitk::FastMarchingTool3D>::Pointer pointRemovedCommand =
- itk::SimpleMemberCommand<mitk::FastMarchingTool3D>::New();
- pointRemovedCommand->SetCallbackFunction(this, &mitk::FastMarchingTool3D::OnDelete);
- m_PointSetRemoveObserverTag = m_SeedsAsPointSet->AddObserver(mitk::PointSetRemoveEvent(), pointRemovedCommand);
-}
-
-void mitk::FastMarchingTool3D::Deactivated()
-{
- this->ClearSeeds();
-
- // Deactivate Interaction
- m_SeedPointInteractor->SetDataNode(nullptr);
- m_ToolManager->GetDataStorage()->Remove(m_SeedsAsPointSetNode);
- m_SeedsAsPointSetNode = nullptr;
- m_SeedsAsPointSet->RemoveObserver(m_PointSetAddObserverTag);
- m_SeedsAsPointSet->RemoveObserver(m_PointSetRemoveObserverTag);
- m_SeedsAsPointSet = nullptr;
-
- Superclass::Deactivated();
-}
-
-void mitk::FastMarchingTool3D::OnAddPoint()
-{
- // Add a new seed point for FastMarching algorithm
- mitk::Point3D clickInIndex;
-
- this->GetReferenceData()->GetGeometry()->WorldToIndex(m_SeedsAsPointSet->GetPoint(m_SeedsAsPointSet->GetSize() - 1),
- clickInIndex);
- itk::Index<3> seedPosition;
- seedPosition[0] = clickInIndex[0];
- seedPosition[1] = clickInIndex[1];
- seedPosition[2] = clickInIndex[2];
-
- NodeType node;
- const double seedValue = 0.0;
- node.SetValue(seedValue);
- node.SetIndex(seedPosition);
- this->m_SeedContainer->InsertElement(this->m_SeedContainer->Size(), node);
-
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();
-
- this->UpdatePreview();
-}
-
-void mitk::FastMarchingTool3D::OnDelete()
-{
- // delete last seed point
- if (!(this->m_SeedContainer->empty()))
- {
- // delete last element of seeds container
- this->m_SeedContainer->pop_back();
-
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();
-
- this->UpdatePreview();
- }
-}
-
-void mitk::FastMarchingTool3D::ClearSeeds()
-{
- // clear seeds for FastMarching as well as the PointSet for visualization
- if (this->m_SeedContainer.IsNotNull())
- this->m_SeedContainer->Initialize();
-
- if (this->m_SeedsAsPointSet.IsNotNull())
- {
- // remove observers from current pointset
- m_SeedsAsPointSet->RemoveObserver(m_PointSetAddObserverTag);
- m_SeedsAsPointSet->RemoveObserver(m_PointSetRemoveObserverTag);
-
- // renew pointset
- this->m_SeedsAsPointSet = mitk::PointSet::New();
- this->m_SeedsAsPointSetNode->SetData(this->m_SeedsAsPointSet);
- m_SeedsAsPointSetNode->SetName("Seeds_Preview");
- m_SeedsAsPointSetNode->SetBoolProperty("helper object", true);
- m_SeedsAsPointSetNode->SetColor(0.0, 1.0, 0.0);
- m_SeedsAsPointSetNode->SetVisibility(true);
-
- // add callback function for adding and removing points
- itk::SimpleMemberCommand<mitk::FastMarchingTool3D>::Pointer pointAddedCommand =
- itk::SimpleMemberCommand<mitk::FastMarchingTool3D>::New();
- pointAddedCommand->SetCallbackFunction(this, &mitk::FastMarchingTool3D::OnAddPoint);
- m_PointSetAddObserverTag = m_SeedsAsPointSet->AddObserver(mitk::PointSetAddEvent(), pointAddedCommand);
-
- itk::SimpleMemberCommand<mitk::FastMarchingTool3D>::Pointer pointRemovedCommand =
- itk::SimpleMemberCommand<mitk::FastMarchingTool3D>::New();
- pointRemovedCommand->SetCallbackFunction(this, &mitk::FastMarchingTool3D::OnDelete);
- m_PointSetRemoveObserverTag = m_SeedsAsPointSet->AddObserver(mitk::PointSetRemoveEvent(), pointRemovedCommand);
- }
-}
-
-template <typename TPixel, unsigned int VImageDimension>
-void mitk::FastMarchingTool3D::DoITKFastMarching(const itk::Image<TPixel, VImageDimension>* inputImage,
- mitk::Image* segmentation, unsigned int timeStep)
-{
- typedef itk::Image<TPixel, VImageDimension> InputImageType;
-
- /* typedefs for itk pipeline */
-
- typedef mitk::Tool::DefaultSegmentationDataType OutputPixelType;
- typedef itk::Image<OutputPixelType, VImageDimension> OutputImageType;
-
- typedef itk::CurvatureAnisotropicDiffusionImageFilter<InputImageType, InternalImageType> SmoothingFilterType;
- typedef itk::GradientMagnitudeRecursiveGaussianImageFilter<InternalImageType, InternalImageType> GradientFilterType;
- typedef itk::SigmoidImageFilter<InternalImageType, InternalImageType> SigmoidFilterType;
- typedef itk::BinaryThresholdImageFilter<InternalImageType, OutputImageType> ThresholdingFilterType;
-
- auto smoothFilter = SmoothingFilterType::New();
- smoothFilter->AddObserver(itk::ProgressEvent(), m_ProgressCommand);
- smoothFilter->SetTimeStep(0.05);
- smoothFilter->SetNumberOfIterations(2);
- smoothFilter->SetConductanceParameter(9.0);
-
- auto gradientMagnitudeFilter = GradientFilterType::New();
- gradientMagnitudeFilter->AddObserver(itk::ProgressEvent(), m_ProgressCommand);
- gradientMagnitudeFilter->SetSigma(m_Sigma);
-
- auto sigmoidFilter = SigmoidFilterType::New();
- sigmoidFilter->AddObserver(itk::ProgressEvent(), m_ProgressCommand);
- sigmoidFilter->SetAlpha(m_Alpha);
- sigmoidFilter->SetBeta(m_Beta);
- sigmoidFilter->SetOutputMinimum(0.0);
- sigmoidFilter->SetOutputMaximum(1.0);
-
- auto fastMarchingFilter = FastMarchingFilterType::New();
- fastMarchingFilter->AddObserver(itk::ProgressEvent(), m_ProgressCommand);
- fastMarchingFilter->SetStoppingValue(m_StoppingValue);
- fastMarchingFilter->SetTrialPoints(m_SeedContainer);
-
- auto thresholdFilter = ThresholdingFilterType::New();
- thresholdFilter->SetLowerThreshold(m_LowerThreshold);
- thresholdFilter->SetUpperThreshold(m_UpperThreshold);
- thresholdFilter->SetOutsideValue(0);
- thresholdFilter->SetInsideValue(1.0);
-
- // set up pipeline
- smoothFilter->SetInput(inputImage);
- gradientMagnitudeFilter->SetInput(smoothFilter->GetOutput());
- sigmoidFilter->SetInput(gradientMagnitudeFilter->GetOutput());
- fastMarchingFilter->SetInput(sigmoidFilter->GetOutput());
- thresholdFilter->SetInput(fastMarchingFilter->GetOutput());
- thresholdFilter->Update();
-
- segmentation->SetVolume((void*)(thresholdFilter->GetOutput()->GetPixelContainer()->GetBufferPointer()), timeStep);
-}
-
-void mitk::FastMarchingTool3D::UpdatePrepare()
-{
- // remove interaction with poinset while updating
- if (m_SeedPointInteractor.IsNotNull())
- m_SeedPointInteractor->SetDataNode(nullptr);
-}
-
-void mitk::FastMarchingTool3D::UpdateCleanUp()
-{
- // add interaction with poinset again
- if (m_SeedPointInteractor.IsNotNull())
- m_SeedPointInteractor->SetDataNode(m_SeedsAsPointSetNode);
-}
-
-void mitk::FastMarchingTool3D::DoUpdatePreview(const Image* inputAtTimeStep, Image* previewImage, TimeStepType timeStep)
-{
- if (nullptr != inputAtTimeStep && nullptr != previewImage && m_SeedContainer.IsNotNull())
- {
- AccessFixedDimensionByItk_n(inputAtTimeStep, DoITKFastMarching, 3, (previewImage, timeStep));
- }
-}
diff --git a/Modules/Segmentation/Interactions/mitkFastMarchingTool3D.h b/Modules/Segmentation/Interactions/mitkFastMarchingTool3D.h
index 652e0d550b..88b82a6038 100644
--- a/Modules/Segmentation/Interactions/mitkFastMarchingTool3D.h
+++ b/Modules/Segmentation/Interactions/mitkFastMarchingTool3D.h
@@ -1,124 +1,49 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkFastMarchingTool3D_h_Included
#define mitkFastMarchingTool3D_h_Included
-#include "mitkAutoSegmentationWithPreviewTool.h"
-#include "mitkDataNode.h"
-#include "mitkPointSet.h"
-#include "mitkPointSetDataInteractor.h"
-#include "mitkToolCommand.h"
-
-#include "itkImage.h"
-#include "itkFastMarchingImageFilter.h"
+#include "mitkFastMarchingBaseTool.h"
#include <MitkSegmentationExports.h>
-namespace us
-{
- class ModuleResource;
-}
-
namespace mitk
{
/**
\brief FastMarching semgentation tool.
The segmentation is done by setting one or more seed points on the image
and adapting the time range and threshold. The pipeline is:
Smoothing->GradientMagnitude->SigmoidFunction->FastMarching->Threshold
The resulting binary image is seen as a segmentation of an object.
For detailed documentation see ITK Software Guide section 9.3.1 Fast Marching Segmentation.
*/
- class MITKSEGMENTATION_EXPORT FastMarchingTool3D : public AutoSegmentationWithPreviewTool
+ class MITKSEGMENTATION_EXPORT FastMarchingTool3D : public FastMarchingBaseTool
{
public:
- mitkClassMacro(FastMarchingTool3D, AutoSegmentationWithPreviewTool);
+ mitkClassMacro(FastMarchingTool3D, FastMarchingBaseTool);
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
- bool CanHandle(const BaseData* referenceData, const BaseData* workingData) const override;
-
/* icon stuff */
- const char **GetXPM() const override;
const char *GetName() const override;
- us::ModuleResource GetIconResource() const override;
-
- void Activated() override;
- void Deactivated() override;
-
- /// \brief Set parameter used in Threshold filter.
- void SetUpperThreshold(double);
-
- /// \brief Set parameter used in Threshold filter.
- void SetLowerThreshold(double);
-
- /// \brief Set parameter used in Fast Marching filter.
- void SetStoppingValue(double);
-
- /// \brief Set parameter used in Gradient Magnitude filter.
- void SetSigma(double);
-
- /// \brief Set parameter used in Fast Marching filter.
- void SetAlpha(double);
-
- /// \brief Set parameter used in Fast Marching filter.
- void SetBeta(double);
-
- /// \brief Clear all seed points.
- void ClearSeeds();
protected:
FastMarchingTool3D();
~FastMarchingTool3D() override;
-
- /// \brief Add point action of StateMachine pattern
- virtual void OnAddPoint();
-
- /// \brief Delete action of StateMachine pattern
- virtual void OnDelete();
-
- void UpdatePrepare() override;
- void UpdateCleanUp() override;
- void DoUpdatePreview(const Image* inputAtTimeStep, Image* previewImage, TimeStepType timeStep) override;
-
- template <typename TPixel, unsigned int VImageDimension>
- void DoITKFastMarching(const itk::Image<TPixel, VImageDimension>* inputImage,
- mitk::Image* segmentation, unsigned int timeStep);
-
- float m_LowerThreshold; // used in Threshold filter
- float m_UpperThreshold; // used in Threshold filter
- float m_StoppingValue; // used in Fast Marching filter
- float m_Sigma; // used in GradientMagnitude filter
- float m_Alpha; // used in Sigmoid filter
- float m_Beta; // used in Sigmoid filter
-
- typedef float InternalPixelType;
- typedef itk::Image<InternalPixelType, 3> InternalImageType;
- typedef itk::FastMarchingImageFilter<InternalImageType, InternalImageType> FastMarchingFilterType;
- typedef FastMarchingFilterType::NodeContainer NodeContainer;
- typedef FastMarchingFilterType::NodeType NodeType;
-
- NodeContainer::Pointer m_SeedContainer; // seed points for FastMarching
-
- mitk::DataNode::Pointer m_SeedsAsPointSetNode; // used to visualize the seed points
- mitk::PointSet::Pointer m_SeedsAsPointSet;
- mitk::PointSetDataInteractor::Pointer m_SeedPointInteractor;
- unsigned int m_PointSetAddObserverTag;
- unsigned int m_PointSetRemoveObserverTag;
};
} // namespace
#endif
diff --git a/Modules/Segmentation/Interactions/mitkFeedbackContourTool.cpp b/Modules/Segmentation/Interactions/mitkFeedbackContourTool.cpp
index 4cea251184..c6eb82b51a 100644
--- a/Modules/Segmentation/Interactions/mitkFeedbackContourTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkFeedbackContourTool.cpp
@@ -1,140 +1,278 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkFeedbackContourTool.h"
#include "mitkToolManager.h"
#include "mitkColorProperty.h"
#include "mitkProperties.h"
#include "mitkStringProperty.h"
#include "mitkBaseRenderer.h"
#include "mitkDataStorage.h"
#include "mitkRenderingManager.h"
+#include "mitkAbstractTransformGeometry.h"
+
mitk::FeedbackContourTool::FeedbackContourTool(const char *type) : SegTool2D(type), m_FeedbackContourVisible(false)
{
- m_FeedbackContour = ContourModel::New();
- m_FeedbackContour->SetClosed(true);
m_FeedbackContourNode = DataNode::New();
- m_FeedbackContourNode->SetData(m_FeedbackContour);
m_FeedbackContourNode->SetProperty("name", StringProperty::New("One of FeedbackContourTool's feedback nodes"));
m_FeedbackContourNode->SetProperty("visible", BoolProperty::New(true));
m_FeedbackContourNode->SetProperty("helper object", BoolProperty::New(true));
m_FeedbackContourNode->SetProperty("layer", IntProperty::New(1000));
m_FeedbackContourNode->SetProperty("contour.project-onto-plane", BoolProperty::New(false));
m_FeedbackContourNode->SetProperty("contour.width", FloatProperty::New(1.0));
// set to max short, max int doesn't work, max value somewhere hardcoded?
m_FeedbackContourNode->SetProperty("layer", IntProperty::New(std::numeric_limits<short>::max()));
m_FeedbackContourNode->SetProperty("fixedLayer", BoolProperty::New(true));
-
+ this->InitializeFeedbackContour(true);
SetFeedbackContourColorDefault();
}
mitk::FeedbackContourTool::~FeedbackContourTool()
{
}
void mitk::FeedbackContourTool::SetFeedbackContourColor(float r, float g, float b)
{
m_FeedbackContourNode->SetProperty("contour.color", ColorProperty::New(r, g, b));
}
void mitk::FeedbackContourTool::SetFeedbackContourColorDefault()
{
m_FeedbackContourNode->SetProperty("contour.color", ColorProperty::New(0.0 / 255.0, 255.0 / 255.0, 0.0 / 255.0));
}
void mitk::FeedbackContourTool::Deactivated()
{
Superclass::Deactivated();
DataStorage *storage = m_ToolManager->GetDataStorage();
if (storage && m_FeedbackContourNode.IsNotNull())
{
storage->Remove(m_FeedbackContourNode);
m_FeedbackContour->Clear();
SetFeedbackContourVisible(false);
}
}
void mitk::FeedbackContourTool::Activated()
{
Superclass::Activated();
-
- SetFeedbackContourVisible(true);
+ this->InitializeFeedbackContour(true);
+ this->SetFeedbackContourVisible(true);
}
-mitk::ContourModel *mitk::FeedbackContourTool::GetFeedbackContour()
+const mitk::ContourModel *mitk::FeedbackContourTool::GetFeedbackContour() const
{
return m_FeedbackContour;
}
-void mitk::FeedbackContourTool::SetFeedbackContour(ContourModel::Pointer contour)
+void mitk::FeedbackContourTool::InitializeFeedbackContour(bool isClosed)
{
- m_FeedbackContour = contour;
+ m_FeedbackContour = ContourModel::New();
+ m_FeedbackContour->SetClosed(isClosed);
+
+ auto workingImage = this->GetWorkingData();
+
+ if (nullptr != workingImage)
+ {
+ m_FeedbackContour->Expand(workingImage->GetTimeSteps());
+
+ auto contourTimeGeometry = workingImage->GetTimeGeometry()->Clone();
+ contourTimeGeometry->ReplaceTimeStepGeometries(m_FeedbackContour->GetGeometry());
+ m_FeedbackContour->SetTimeGeometry(contourTimeGeometry);
+
+ for (unsigned int t = 0; t < m_FeedbackContour->GetTimeSteps(); ++t)
+ {
+ m_FeedbackContour->SetClosed(isClosed, t);
+ }
+ }
+
m_FeedbackContourNode->SetData(m_FeedbackContour);
}
+void mitk::FeedbackContourTool::ClearsCurrentFeedbackContour(bool isClosed)
+{
+ if (!m_FeedbackContour->GetTimeGeometry()->IsValidTimePoint(this->GetLastTimePointTriggered()))
+ {
+ MITK_WARN << "Cannot clear feedback contour at current time step. Feedback contour is in invalid state as its time geometry does not support current selected time point. Invalid time point: " << this->GetLastTimePointTriggered();
+ return;
+ }
+
+ auto feedbackTimeStep = m_FeedbackContour->GetTimeGeometry()->TimePointToTimeStep(this->GetLastTimePointTriggered());
+ m_FeedbackContour->Clear(feedbackTimeStep);
+ m_FeedbackContour->SetClosed(isClosed, feedbackTimeStep);
+}
+
+void mitk::FeedbackContourTool::UpdateCurrentFeedbackContour(const ContourModel* sourceModel, TimeStepType sourceTimeStep)
+{
+ if (nullptr == sourceModel)
+ return;
+
+ if (!m_FeedbackContour->GetTimeGeometry()->IsValidTimePoint(this->GetLastTimePointTriggered()))
+ {
+ MITK_WARN << "Cannot update feedback contour. Feedback contour is in invalid state as its time geometry does not support current selected time point. Invalid time point: "<<this->GetLastTimePointTriggered();
+ return;
+ }
+
+ auto feedbackTimeStep = m_FeedbackContour->GetTimeGeometry()->TimePointToTimeStep(this->GetLastTimePointTriggered());
+ this->UpdateFeedbackContour(sourceModel, feedbackTimeStep, sourceTimeStep);
+}
+
+void mitk::FeedbackContourTool::UpdateFeedbackContour(const ContourModel* sourceModel, TimeStepType feedbackTimeStep, TimeStepType sourceTimeStep)
+{
+ if (nullptr == sourceModel)
+ return;
+
+ if (!sourceModel->GetTimeGeometry()->IsValidTimeStep(sourceTimeStep))
+ {
+ MITK_WARN << "Cannot update feedback contour. Source contour time geometry does not support passed time step. Invalid time step: " << sourceTimeStep;
+ return;
+ }
+
+ if (!m_FeedbackContour->GetTimeGeometry()->IsValidTimeStep(feedbackTimeStep))
+ {
+ MITK_WARN << "Cannot update feedback contour. Feedback contour time geometry does not support passed time step. Invalid time step: "<<feedbackTimeStep;
+ return;
+ }
+
+ m_FeedbackContour->UpdateContour(sourceModel, feedbackTimeStep, sourceTimeStep);
+}
+
+void mitk::FeedbackContourTool::AddVertexToCurrentFeedbackContour(const Point3D& point)
+{
+ if (!m_FeedbackContour->GetTimeGeometry()->IsValidTimePoint(this->GetLastTimePointTriggered()))
+ {
+ MITK_WARN << "Cannot add vertex to feedback contour. Feedback contour is in invalid state as its time geometry does not support current selected time point. Invalid time point: " << this->GetLastTimePointTriggered();
+ return;
+ }
+
+ auto feedbackTimeStep = m_FeedbackContour->GetTimeGeometry()->TimePointToTimeStep(this->GetLastTimePointTriggered());
+ this->AddVertexToFeedbackContour(point, feedbackTimeStep);
+};
+
+/** Adds a vertex to the feedback contour for the passed time step. If time step is invalid, nothing will be added.*/
+void mitk::FeedbackContourTool::AddVertexToFeedbackContour(const Point3D& point, TimeStepType feedbackTimeStep)
+{
+ if (!m_FeedbackContour->GetTimeGeometry()->IsValidTimeStep(feedbackTimeStep))
+ {
+ MITK_WARN << "Cannot add vertex to feedback contour. Feedback contour time geometry does not support passed time step. Invalid time step: " << feedbackTimeStep;
+ return;
+ }
+
+ m_FeedbackContour->AddVertex(point, feedbackTimeStep);
+}
+
+
void mitk::FeedbackContourTool::SetFeedbackContourVisible(bool visible)
{
if (m_FeedbackContourVisible == visible)
return; // nothing changed
if (DataStorage *storage = m_ToolManager->GetDataStorage())
{
if (visible)
{
// Add the feedback contour node as a derived node of the first working data.
// If there is no working data, the node is added at the top level.
- storage->Add(m_FeedbackContourNode, m_ToolManager->GetWorkingData(0));
+ storage->Add(m_FeedbackContourNode, this->GetWorkingDataNode());
}
else
{
storage->Remove(m_FeedbackContourNode);
}
}
m_FeedbackContourVisible = visible;
}
-mitk::ContourModel::Pointer mitk::FeedbackContourTool::ProjectContourTo2DSlice(Image *slice,
- ContourModel *contourIn3D,
+mitk::ContourModel::Pointer mitk::FeedbackContourTool::ProjectContourTo2DSlice(const Image *slice,
+ const ContourModel *contourIn3D,
bool correctionForIpSegmentation,
bool constrainToInside)
{
return mitk::ContourModelUtils::ProjectContourTo2DSlice(
slice, contourIn3D, correctionForIpSegmentation, constrainToInside);
}
mitk::ContourModel::Pointer mitk::FeedbackContourTool::BackProjectContourFrom2DSlice(const BaseGeometry *sliceGeometry,
- ContourModel *contourIn2D,
+ const ContourModel *contourIn2D,
bool correctionForIpSegmentation)
{
return mitk::ContourModelUtils::BackProjectContourFrom2DSlice(
sliceGeometry, contourIn2D, correctionForIpSegmentation);
}
+void mitk::FeedbackContourTool::WriteBackFeedbackContourAsSegmentationResult(const InteractionPositionEvent* positionEvent, int paintingPixelValue, bool setInvisibleAfterSuccess)
+{
+ if (!positionEvent)
+ return;
+
+ auto workingImage = this->GetWorkingData();
+ const auto planeGeometry((positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()));
+
+ if (!workingImage || !planeGeometry)
+ return;
+
+ const auto* abstractTransformGeometry(
+ dynamic_cast<const AbstractTransformGeometry*>(positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()));
+ if (nullptr != abstractTransformGeometry)
+ return;
+
+ Image::Pointer slice = FeedbackContourTool::GetAffectedWorkingSlice(positionEvent);
+
+ if (slice.IsNull())
+ {
+ MITK_ERROR << "Unable to extract slice." << std::endl;
+ return;
+ }
+
+ const auto feedbackContour = FeedbackContourTool::GetFeedbackContour();
+ auto contourTimeStep = positionEvent->GetSender()->GetTimeStep(feedbackContour);
+
+ ContourModel::Pointer projectedContour = FeedbackContourTool::ProjectContourTo2DSlice(
+ slice, feedbackContour, false, false); // false: don't add 0.5 (done by FillContourInSlice)
+ // false: don't constrain the contour to the image's inside
+
+ if (projectedContour.IsNull())
+ return;
+
+ auto activePixelValue = ContourModelUtils::GetActivePixelValue(workingImage);
+
+ mitk::ContourModelUtils::FillContourInSlice(
+ projectedContour, contourTimeStep, slice, workingImage, paintingPixelValue * activePixelValue);
+
+ this->WriteBackSegmentationResult(positionEvent, slice);
+
+ if (setInvisibleAfterSuccess)
+ {
+ this->SetFeedbackContourVisible(false);
+ }
+}
+
+
void mitk::FeedbackContourTool::FillContourInSlice(ContourModel *projectedContour,
Image *sliceImage,
int paintingPixelValue)
{
this->FillContourInSlice(projectedContour, 0, sliceImage, paintingPixelValue);
}
void mitk::FeedbackContourTool::FillContourInSlice(ContourModel *projectedContour,
unsigned int timeStep,
Image *sliceImage,
int paintingPixelValue)
{
mitk::ContourModelUtils::FillContourInSlice(projectedContour, timeStep, sliceImage, sliceImage, paintingPixelValue);
}
diff --git a/Modules/Segmentation/Interactions/mitkFeedbackContourTool.h b/Modules/Segmentation/Interactions/mitkFeedbackContourTool.h
index 945c4911fd..60c6b60f34 100644
--- a/Modules/Segmentation/Interactions/mitkFeedbackContourTool.h
+++ b/Modules/Segmentation/Interactions/mitkFeedbackContourTool.h
@@ -1,118 +1,149 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkFeedbackContourTool_h_Included
#define mitkFeedbackContourTool_h_Included
#include "mitkCommon.h"
#include "mitkContourModelUtils.h"
#include "mitkContourUtils.h" //TODO remove legacy support
#include "mitkImage.h"
#include "mitkSegTool2D.h"
#include <MitkSegmentationExports.h>
#include "mitkDataNode.h"
#include "mitkImageCast.h"
namespace mitk
{
/**
\brief Base class for tools that use a contour for feedback
\sa Tool
\sa ContourModel
\ingroup Interaction
\ingroup ToolManagerEtAl
Implements helper methods, that might be of use to all kind of 2D segmentation tools that use a contour for user
feedback.
- Providing a feedback contour that might be added or removed from the visible scene (SetFeedbackContourVisible).
- Filling of a contour into a 2D slice
These helper methods are actually implemented in ContourUtils now. FeedbackContourTool only forwards such requests.
\warning Only to be instantiated by mitk::ToolManager.
$Author: nolden $
*/
class MITKSEGMENTATION_EXPORT FeedbackContourTool : public SegTool2D
{
public:
mitkClassMacro(FeedbackContourTool, SegTool2D);
protected:
FeedbackContourTool(); // purposely hidden
FeedbackContourTool(const char *); // purposely hidden
~FeedbackContourTool() override;
- ContourModel *GetFeedbackContour();
- void SetFeedbackContour(ContourModel::Pointer);
+ const ContourModel *GetFeedbackContour() const;
+
+ /** (Re)initialize the feesback contour by creating a new instance.
+ * It is assured that the new instance as the same time geometry than
+ * the working image.*/
+ void InitializeFeedbackContour(bool isClosed);
+
+ /** Clears the current time step of the feedback contour and resets its closed state.*/
+ void ClearsCurrentFeedbackContour(bool isClosed);
+
+ /** Updates the feedback contour of the currently selected time point. The update will be done
+ * by clearing all existings vertices at the current time point and copying the vertics of the
+ * source model at the specified source time step.*/
+ void UpdateCurrentFeedbackContour(const ContourModel* sourceModel, TimeStepType sourceTimeStep = 0);
+ /** Updates the feedback contour at the time step specified by feedbackTimeStep. The update will be done
+ * by clearing all existings vertices at feedbackTimeStep and copying the vertics of the
+ * source model at the specified source time step.*/
+ void UpdateFeedbackContour(const ContourModel* sourceModel, TimeStepType feedbackTimeStep, TimeStepType sourceTimeStep = 0);
+
+ /** Adds a vertex to the feedback contour for the current time point. */
+ void AddVertexToCurrentFeedbackContour(const Point3D& point);
+
+ /** Adds a vertex to the feedback contour for the passed time step. If time step is invalid, nothing will be added.*/
+ void AddVertexToFeedbackContour(const Point3D& point, TimeStepType feedbackTimeStep);
void SetFeedbackContourVisible(bool);
/// Provide values from 0.0 (black) to 1.0 (full color)
void SetFeedbackContourColor(float r, float g, float b);
void SetFeedbackContourColorDefault();
void Deactivated() override;
void Activated() override;
/**
\brief Projects a contour onto an image point by point. Converts from world to index coordinates.
\param slice
\param contourIn3D
\param correctionForIpSegmentation adds 0.5 to x and y index coordinates (difference between ipSegmentation and
MITK contours)
\param constrainToInside
*/
- ContourModel::Pointer ProjectContourTo2DSlice(Image *slice,
- ContourModel *contourIn3D,
+ ContourModel::Pointer ProjectContourTo2DSlice(const Image *slice,
+ const ContourModel *contourIn3D,
bool correctionForIpSegmentation = false,
bool constrainToInside = true);
/**
\brief Projects a slice index coordinates of a contour back into world coordinates.
\param sliceGeometry
\param contourIn2D
\param correctionForIpSegmentation subtracts 0.5 to x and y index coordinates (difference between ipSegmentation
and MITK contours)
*/
ContourModel::Pointer BackProjectContourFrom2DSlice(const BaseGeometry *sliceGeometry,
- ContourModel *contourIn2D,
+ const ContourModel *contourIn2D,
bool correctionForIpSegmentation = false);
+ /** Helper methods that checks all precondition and if they are fullfilled does the following:
+ * 1. Gets the contour of the time point specified by positionEvent.
+ * 2. Gets the affacted working slice of the time point specified by positionEvent.
+ * 3. projects the contour onto the working slice and then fills it with the passed paintingPixelValue (adjusted by the current active lable value)
+ * to the slice.
+ * 4. writes the slice back into the working image using SegTool2D::WriteBackSegmentationResult().*/
+ void WriteBackFeedbackContourAsSegmentationResult(const InteractionPositionEvent* positionEvent, int paintingPixelValue, bool setInvisibleAfterSuccess = true);
+
/**
\brief Fill a contour in a 2D slice with a specified pixel value.
*/
void FillContourInSlice(ContourModel *projectedContour, Image *sliceImage, int paintingPixelValue = 1);
/**
\brief Fill a contour in a 2D slice with a specified pixel value at a given time step.
*/
void FillContourInSlice(ContourModel *projectedContour,
unsigned int timeStep,
Image *sliceImage,
int paintingPixelValue = 1);
+ private:
ContourModel::Pointer m_FeedbackContour;
DataNode::Pointer m_FeedbackContourNode;
bool m_FeedbackContourVisible;
};
} // namespace
#endif
diff --git a/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
index a75e5bd1ce..05a5088e3e 100644
--- a/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
+++ b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
@@ -1,593 +1,627 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkContourModelUtils.h>
#include <mitkLiveWireTool2D.h>
#include <mitkLiveWireTool2D.xpm>
#include <mitkToolManager.h>
#include <usGetModuleContext.h>
#include <usModuleResource.h>
#include <type_traits>
namespace mitk
{
MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, LiveWireTool2D, "LiveWire tool");
}
mitk::LiveWireTool2D::LiveWireTool2D()
: SegTool2D("LiveWireTool"), m_CreateAndUseDynamicCosts(false)
{
}
mitk::LiveWireTool2D::~LiveWireTool2D()
{
this->ClearSegmentation();
}
void mitk::LiveWireTool2D::RemoveHelperObjects()
{
auto dataStorage = m_ToolManager->GetDataStorage();
if (nullptr == dataStorage)
return;
for (const auto &editingContour : m_EditingContours)
dataStorage->Remove(editingContour.first);
for (const auto &workingContour : m_WorkingContours)
dataStorage->Remove(workingContour.first);
if (m_EditingContourNode.IsNotNull())
dataStorage->Remove(m_EditingContourNode);
if (m_LiveWireContourNode.IsNotNull())
dataStorage->Remove(m_LiveWireContourNode);
if (m_ContourNode.IsNotNull())
dataStorage->Remove(m_ContourNode);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void mitk::LiveWireTool2D::ReleaseHelperObjects()
{
this->RemoveHelperObjects();
m_EditingContours.clear();
m_WorkingContours.clear();
m_EditingContourNode = nullptr;
m_EditingContour = nullptr;
m_LiveWireContourNode = nullptr;
m_LiveWireContour = nullptr;
m_ContourNode = nullptr;
m_Contour = nullptr;
}
void mitk::LiveWireTool2D::ReleaseInteractors()
{
this->EnableContourLiveWireInteraction(false);
m_LiveWireInteractors.clear();
}
void mitk::LiveWireTool2D::ConnectActionsAndFunctions()
{
CONNECT_CONDITION("CheckContourClosed", OnCheckPoint);
CONNECT_FUNCTION("InitObject", OnInitLiveWire);
CONNECT_FUNCTION("AddPoint", OnAddPoint);
CONNECT_FUNCTION("CtrlAddPoint", OnAddPoint);
CONNECT_FUNCTION("MovePoint", OnMouseMoveNoDynamicCosts);
CONNECT_FUNCTION("FinishContour", OnFinish);
CONNECT_FUNCTION("DeletePoint", OnLastSegmentDelete);
CONNECT_FUNCTION("CtrlMovePoint", OnMouseMoved);
}
const char **mitk::LiveWireTool2D::GetXPM() const
{
return mitkLiveWireTool2D_xpm;
}
us::ModuleResource mitk::LiveWireTool2D::GetIconResource() const
{
return us::GetModuleContext()->GetModule()->GetResource("LiveWire_48x48.png");
}
us::ModuleResource mitk::LiveWireTool2D::GetCursorIconResource() const
{
return us::GetModuleContext()->GetModule()->GetResource("LiveWire_Cursor_32x32.png");
}
const char *mitk::LiveWireTool2D::GetName() const
{
return "Live Wire";
}
void mitk::LiveWireTool2D::Activated()
{
Superclass::Activated();
this->ResetToStartState();
this->EnableContourLiveWireInteraction(true);
}
void mitk::LiveWireTool2D::Deactivated()
{
this->ConfirmSegmentation();
Superclass::Deactivated();
}
+void mitk::LiveWireTool2D::UpdateLiveWireContour()
+{
+ if (m_Contour.IsNotNull())
+ {
+ auto timeGeometry = m_Contour->GetTimeGeometry()->Clone();
+ m_LiveWireContour = this->m_LiveWireFilter->GetOutput();
+ m_LiveWireContour->SetTimeGeometry(timeGeometry); //needed because the results of the filter are always from 0 ms to 1 ms and the filter also resets its outputs.
+ m_LiveWireContourNode->SetData(this->m_LiveWireContour);
+ }
+}
+
+void mitk::LiveWireTool2D::OnTimePointChanged()
+{
+ auto reference = this->GetReferenceData();
+ if (nullptr == reference || m_PlaneGeometry.IsNull() || m_LiveWireFilter.IsNull() || m_LiveWireContourNode.IsNull())
+ return;
+
+ auto timeStep = reference->GetTimeGeometry()->TimePointToTimeStep(this->GetLastTimePointTriggered());
+
+ m_ReferenceDataSlice = GetAffectedImageSliceAs2DImageByTimePoint(m_PlaneGeometry, reference, timeStep);
+ m_LiveWireFilter->SetInput(m_ReferenceDataSlice);
+
+ m_LiveWireFilter->Update();
+
+ this->UpdateLiveWireContour();
+
+ RenderingManager::GetInstance()->RequestUpdateAll();
+};
+
+
void mitk::LiveWireTool2D::EnableContourLiveWireInteraction(bool on)
{
for (const auto &interactor : m_LiveWireInteractors)
interactor->EnableInteraction(on);
}
void mitk::LiveWireTool2D::ConfirmSegmentation()
{
- auto referenceNode = m_ToolManager->GetReferenceData(0);
- auto workingNode = m_ToolManager->GetWorkingData(0);
-
- if (nullptr == referenceNode || nullptr == workingNode)
- return;
-
- auto referenceImage = dynamic_cast<Image *>(referenceNode->GetData());
- auto workingImage = dynamic_cast<Image *>(workingNode->GetData());
+ auto referenceImage = this->GetReferenceData();
+ auto workingImage = this->GetWorkingData();
if (nullptr == referenceImage || nullptr == workingImage)
return;
std::vector<SliceInformation> sliceInfos;
sliceInfos.reserve(m_WorkingContours.size());
+ const auto currentTimePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
+ TimeStepType workingImageTimeStep = workingImage->GetTimeGeometry()->TimePointToTimeStep(currentTimePoint);
+
for (const auto &workingContour : m_WorkingContours)
{
auto contour = dynamic_cast<ContourModel *>(workingContour.first->GetData());
- if (nullptr == contour)
+ if (nullptr == contour || contour->IsEmpty())
continue;
- const auto numberOfTimeSteps = contour->GetTimeSteps();
+ auto sameSlicePredicate = [&workingContour, workingImageTimeStep](const SliceInformation& si) { return workingContour.second->IsOnPlane(si.plane) && workingImageTimeStep == si.timestep; };
- for (std::remove_const_t<decltype(numberOfTimeSteps)> t = 0; t < numberOfTimeSteps; ++t)
+ auto finding = std::find_if(sliceInfos.begin(), sliceInfos.end(), sameSlicePredicate);
+ if (finding == sliceInfos.end())
{
- if (contour->IsEmptyTimeStep(t))
- continue;
-
- TimePointType referenceImageTimePoint = referenceImage->GetTimeGeometry()->TimeStepToTimePoint(t);
- TimeStepType workingImageTimeStep = workingImage->GetTimeGeometry()->TimePointToTimeStep(referenceImageTimePoint);
+ auto workingSlice = this->GetAffectedImageSliceAs2DImage(workingContour.second, workingImage, workingImageTimeStep)->Clone();
+ sliceInfos.emplace_back(workingSlice, workingContour.second, workingImageTimeStep);
+ finding = std::prev(sliceInfos.end());
+ }
- auto workingSlice = this->GetAffectedImageSliceAs2DImage(workingContour.second, workingImage, workingImageTimeStep);
- auto projectedContour = ContourModelUtils::ProjectContourTo2DSlice(workingSlice, contour, true, false);
- int activePixelValue = ContourModelUtils::GetActivePixelValue(workingImage);
+ //cast const away is OK in this case, because these are all slices created and manipulated
+ //localy in this function call. And we want to keep the high constness of SliceInformation for
+ //public interfaces.
+ auto workingSlice = const_cast<Image*>(finding->slice.GetPointer());
- ContourModelUtils::FillContourInSlice(
- projectedContour, referenceImageTimePoint, workingSlice, workingImage, activePixelValue);
+ auto projectedContour = ContourModelUtils::ProjectContourTo2DSlice(workingSlice, contour, true, false);
+ int activePixelValue = ContourModelUtils::GetActivePixelValue(workingImage);
- sliceInfos.emplace_back(workingSlice, workingContour.second, referenceImageTimePoint);
- this->WriteSliceToVolume(sliceInfos.back());
- }
+ ContourModelUtils::FillContourInSlice(
+ projectedContour, workingSlice, workingImage, activePixelValue);
}
- this->WriteBackSegmentationResult(sliceInfos, false);
+ this->WriteBackSegmentationResults(sliceInfos);
this->ClearSegmentation();
}
void mitk::LiveWireTool2D::ClearSegmentation()
{
this->ReleaseHelperObjects();
this->ReleaseInteractors();
this->ResetToStartState();
}
bool mitk::LiveWireTool2D::IsPositionEventInsideImageRegion(mitk::InteractionPositionEvent *positionEvent,
mitk::BaseData *data)
{
bool isPositionEventInsideImageRegion = nullptr != data && data->GetGeometry()->IsInside(positionEvent->GetPositionInWorld());
if (!isPositionEventInsideImageRegion)
MITK_WARN("LiveWireTool2D") << "PositionEvent is outside ImageRegion!";
return isPositionEventInsideImageRegion;
}
+mitk::ContourModel::Pointer mitk::LiveWireTool2D::CreateNewContour() const
+{
+ auto workingData = this->GetWorkingData();
+ if (nullptr == workingData)
+ {
+ this->InteractiveSegmentationBugMessage("Cannot create new contour. No valid working data is set. Application is in invalid state.");
+ mitkThrow() << "Cannot create new contour. No valid working data is set. Application is in invalid state.";
+ }
+
+ const auto minTime = workingData->GetTimeGeometry()->GetMinimumTimePoint();
+ auto duration = workingData->GetTimeGeometry()->GetMaximumTimePoint() - minTime;
+
+ if (duration <= 0)
+ {
+ duration = 1.;
+ };
+
+ auto contour = ContourModel::New();
+
+ //generate a time geometry that is always visible as the working contour should always be.
+ auto contourTimeGeometry = ProportionalTimeGeometry::New();
+ contourTimeGeometry->SetStepDuration(std::numeric_limits<TimePointType>::max());
+ contourTimeGeometry->SetTimeStepGeometry(contour->GetTimeGeometry()->GetGeometryForTimeStep(0)->Clone(), 0);
+ contour->SetTimeGeometry(contourTimeGeometry);
+
+ return contour;
+}
+
void mitk::LiveWireTool2D::OnInitLiveWire(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (nullptr == positionEvent)
return;
- auto workingDataNode = m_ToolManager->GetWorkingData(0);
+ auto workingDataNode = this->GetWorkingDataNode();
if (!IsPositionEventInsideImageRegion(positionEvent, workingDataNode->GetData()))
{
this->ResetToStartState();
return;
}
m_LastEventSender = positionEvent->GetSender();
m_LastEventSlice = m_LastEventSender->GetSlice();
- auto t = positionEvent->GetSender()->GetTimeStep();
-
- m_Contour = mitk::ContourModel::New();
- m_Contour->Expand(t + 1);
+ m_Contour = this->CreateNewContour();
m_ContourNode = mitk::DataNode::New();
m_ContourNode->SetData(m_Contour);
m_ContourNode->SetName("working contour node");
m_ContourNode->SetProperty("layer", IntProperty::New(100));
m_ContourNode->AddProperty("fixedLayer", BoolProperty::New(true));
m_ContourNode->SetProperty("helper object", mitk::BoolProperty::New(true));
m_ContourNode->AddProperty("contour.color", ColorProperty::New(1.0f, 1.0f, 0.0f), nullptr, true);
m_ContourNode->AddProperty("contour.points.color", ColorProperty::New(1.0f, 0.0f, 0.1f), nullptr, true);
m_ContourNode->AddProperty("contour.controlpoints.show", BoolProperty::New(true), nullptr, true);
- m_LiveWireContour = mitk::ContourModel::New();
- m_LiveWireContour->Expand(t + 1);
+ m_LiveWireContour = this->CreateNewContour();
m_LiveWireContourNode = mitk::DataNode::New();
m_LiveWireContourNode->SetData(m_LiveWireContour);
m_LiveWireContourNode->SetName("active livewire node");
m_LiveWireContourNode->SetProperty("layer", IntProperty::New(101));
m_LiveWireContourNode->AddProperty("fixedLayer", BoolProperty::New(true));
m_LiveWireContourNode->SetProperty("helper object", mitk::BoolProperty::New(true));
m_LiveWireContourNode->AddProperty("contour.color", ColorProperty::New(0.1f, 1.0f, 0.1f), nullptr, true);
m_LiveWireContourNode->AddProperty("contour.width", mitk::FloatProperty::New(4.0f), nullptr, true);
- m_EditingContour = mitk::ContourModel::New();
- m_EditingContour->Expand(t + 1);
+ m_EditingContour = this->CreateNewContour();
m_EditingContourNode = mitk::DataNode::New();
m_EditingContourNode->SetData(m_EditingContour);
m_EditingContourNode->SetName("editing node");
m_EditingContourNode->SetProperty("layer", IntProperty::New(102));
m_EditingContourNode->AddProperty("fixedLayer", BoolProperty::New(true));
m_EditingContourNode->SetProperty("helper object", mitk::BoolProperty::New(true));
m_EditingContourNode->AddProperty("contour.color", ColorProperty::New(0.1f, 1.0f, 0.1f), nullptr, true);
m_EditingContourNode->AddProperty("contour.points.color", ColorProperty::New(0.0f, 0.0f, 1.0f), nullptr, true);
m_EditingContourNode->AddProperty("contour.width", mitk::FloatProperty::New(4.0f), nullptr, true);
auto dataStorage = m_ToolManager->GetDataStorage();
dataStorage->Add(m_ContourNode, workingDataNode);
dataStorage->Add(m_LiveWireContourNode, workingDataNode);
dataStorage->Add(m_EditingContourNode, workingDataNode);
// Set current slice as input for ImageToLiveWireContourFilter
- m_WorkingSlice = this->GetAffectedReferenceSlice(positionEvent);
+ m_ReferenceDataSlice = this->GetAffectedReferenceSlice(positionEvent);
- auto origin = m_WorkingSlice->GetSlicedGeometry()->GetOrigin();
- m_WorkingSlice->GetSlicedGeometry()->WorldToIndex(origin, origin);
- m_WorkingSlice->GetSlicedGeometry()->IndexToWorld(origin, origin);
- m_WorkingSlice->GetSlicedGeometry()->SetOrigin(origin);
+ auto origin = m_ReferenceDataSlice->GetSlicedGeometry()->GetOrigin();
+ m_ReferenceDataSlice->GetSlicedGeometry()->WorldToIndex(origin, origin);
+ m_ReferenceDataSlice->GetSlicedGeometry()->IndexToWorld(origin, origin);
+ m_ReferenceDataSlice->GetSlicedGeometry()->SetOrigin(origin);
m_LiveWireFilter = ImageLiveWireContourModelFilter::New();
- m_LiveWireFilter->SetInput(m_WorkingSlice);
+ m_LiveWireFilter->SetInput(m_ReferenceDataSlice);
// Map click to pixel coordinates
auto click = positionEvent->GetPositionInWorld();
itk::Index<3> idx;
- m_WorkingSlice->GetGeometry()->WorldToIndex(click, idx);
+ m_ReferenceDataSlice->GetGeometry()->WorldToIndex(click, idx);
// Get the pixel with the highest gradient in a 7x7 region
itk::Index<3> indexWithHighestGradient;
- AccessFixedDimensionByItk_2(m_WorkingSlice, FindHighestGradientMagnitudeByITK, 2, idx, indexWithHighestGradient);
+ AccessFixedDimensionByItk_2(m_ReferenceDataSlice, FindHighestGradientMagnitudeByITK, 2, idx, indexWithHighestGradient);
click[0] = indexWithHighestGradient[0];
click[1] = indexWithHighestGradient[1];
click[2] = indexWithHighestGradient[2];
- m_WorkingSlice->GetGeometry()->IndexToWorld(click, click);
+ m_ReferenceDataSlice->GetGeometry()->IndexToWorld(click, click);
// Set initial start point
- m_Contour->AddVertex(click, true, t);
+ m_Contour->AddVertex(click, true);
m_LiveWireFilter->SetStartPoint(click);
// Remember PlaneGeometry to determine if events were triggered in the same plane
m_PlaneGeometry = interactionEvent->GetSender()->GetCurrentWorldPlaneGeometry();
m_CreateAndUseDynamicCosts = true;
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
void mitk::LiveWireTool2D::OnAddPoint(StateMachineAction *, InteractionEvent *interactionEvent)
{
// Complete LiveWire interaction for the last segment. Add current LiveWire contour to
// the finished contour and reset to start a new segment and computation.
auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (nullptr == positionEvent)
return;
if (m_PlaneGeometry.IsNotNull())
{
// Check if the point is in the correct slice
if (m_PlaneGeometry->DistanceFromPlane(positionEvent->GetPositionInWorld()) > mitk::sqrteps)
return;
}
- auto t = static_cast<int>(positionEvent->GetSender()->GetTimeStep());
-
// Add repulsive points to avoid getting the same path again
std::for_each(m_LiveWireContour->IteratorBegin(), m_LiveWireContour->IteratorEnd(), [this](ContourElement::VertexType *vertex) {
ImageLiveWireContourModelFilter::InternalImageType::IndexType idx;
- this->m_WorkingSlice->GetGeometry()->WorldToIndex(vertex->Coordinates, idx);
+ this->m_ReferenceDataSlice->GetGeometry()->WorldToIndex(vertex->Coordinates, idx);
this->m_LiveWireFilter->AddRepulsivePoint(idx);
});
// Remove duplicate first vertex, it's already contained in m_Contour
- m_LiveWireContour->RemoveVertexAt(0, t);
+ m_LiveWireContour->RemoveVertexAt(0);
// Set last point as control point
- m_LiveWireContour->SetControlVertexAt(m_LiveWireContour->GetNumberOfVertices(t) - 1, t);
+ m_LiveWireContour->SetControlVertexAt(m_LiveWireContour->GetNumberOfVertices() - 1);
// Merge contours
- m_Contour->Concatenate(m_LiveWireContour, t);
+ m_Contour->Concatenate(m_LiveWireContour);
// Clear the LiveWire contour and reset the corresponding DataNode
- m_LiveWireContour->Clear(t);
+ m_LiveWireContour->Clear();
// Set new start point
m_LiveWireFilter->SetStartPoint(positionEvent->GetPositionInWorld());
if (m_CreateAndUseDynamicCosts)
{
// Use dynamic cost map for next update
m_LiveWireFilter->CreateDynamicCostMap(m_Contour);
m_LiveWireFilter->SetUseDynamicCostMap(true);
}
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
void mitk::LiveWireTool2D::OnMouseMoved(StateMachineAction *, InteractionEvent *interactionEvent)
{
// Compute LiveWire segment from last control point to current mouse position
auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (nullptr == positionEvent)
return;
- auto t = positionEvent->GetSender()->GetTimeStep();
-
m_LiveWireFilter->SetEndPoint(positionEvent->GetPositionInWorld());
- m_LiveWireFilter->SetTimeStep(t);
m_LiveWireFilter->Update();
- m_LiveWireContour = this->m_LiveWireFilter->GetOutput();
- m_LiveWireContourNode->SetData(this->m_LiveWireContour);
+ this->UpdateLiveWireContour();
RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
void mitk::LiveWireTool2D::OnMouseMoveNoDynamicCosts(StateMachineAction *, InteractionEvent *interactionEvent)
{
m_LiveWireFilter->SetUseDynamicCostMap(false);
this->OnMouseMoved(nullptr, interactionEvent);
m_LiveWireFilter->SetUseDynamicCostMap(true);
}
bool mitk::LiveWireTool2D::OnCheckPoint(const InteractionEvent *interactionEvent)
{
// Check double click on first control point to finish the LiveWire tool
auto positionEvent = dynamic_cast<const mitk::InteractionPositionEvent *>(interactionEvent);
if (nullptr == positionEvent)
return false;
- auto t = static_cast<int>(positionEvent->GetSender()->GetTimeStep());
-
mitk::Point3D click = positionEvent->GetPositionInWorld();
- mitk::Point3D first = this->m_Contour->GetVertexAt(0, t)->Coordinates;
+ mitk::Point3D first = this->m_Contour->GetVertexAt(0)->Coordinates;
return first.EuclideanDistanceTo(click) < 4.5;
}
void mitk::LiveWireTool2D::OnFinish(StateMachineAction *, InteractionEvent *interactionEvent)
{
// Finish LiveWire tool interaction
auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (nullptr == positionEvent)
return;
- // Have to do that here so that the m_LastEventSender is set correctly
- mitk::SegTool2D::AddContourmarker();
-
- auto t = static_cast<int>(positionEvent->GetSender()->GetTimeStep());
-
// Remove last control point added by double click
- m_Contour->RemoveVertexAt(m_Contour->GetNumberOfVertices(t) - 1, t);
+ m_Contour->RemoveVertexAt(m_Contour->GetNumberOfVertices() - 1);
// Save contour and corresponding plane geometry to list
this->m_WorkingContours.emplace_back(std::make_pair(m_ContourNode, positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()->Clone()));
this->m_EditingContours.emplace_back(std::make_pair(m_EditingContourNode, positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()->Clone()));
m_LiveWireFilter->SetUseDynamicCostMap(false);
this->FinishTool();
}
void mitk::LiveWireTool2D::FinishTool()
{
- auto numberOfTimesteps = static_cast<int>(m_Contour->GetTimeGeometry()->CountTimeSteps());
+ auto numberOfTimesteps = static_cast<int>(m_Contour->GetTimeSteps());
for (int i = 0; i <= numberOfTimesteps; ++i)
m_Contour->Close(i);
m_ToolManager->GetDataStorage()->Remove(m_LiveWireContourNode);
m_LiveWireContourNode = nullptr;
m_LiveWireContour = nullptr;
m_ContourInteractor = mitk::ContourModelLiveWireInteractor::New();
m_ContourInteractor->SetDataNode(m_ContourNode);
m_ContourInteractor->LoadStateMachine("ContourModelModificationInteractor.xml", us::GetModuleContext()->GetModule());
m_ContourInteractor->SetEventConfig("ContourModelModificationConfig.xml", us::GetModuleContext()->GetModule());
- m_ContourInteractor->SetWorkingImage(this->m_WorkingSlice);
+ m_ContourInteractor->SetWorkingImage(this->m_ReferenceDataSlice);
m_ContourInteractor->SetEditingContourModelNode(this->m_EditingContourNode);
m_ContourNode->SetDataInteractor(m_ContourInteractor.GetPointer());
this->m_LiveWireInteractors.push_back(m_ContourInteractor);
}
void mitk::LiveWireTool2D::OnLastSegmentDelete(StateMachineAction *, InteractionEvent *interactionEvent)
{
- int t = static_cast<int>(interactionEvent->GetSender()->GetTimeStep());
-
// If last point of current contour will be removed go to start state and remove nodes
- if (m_Contour->GetNumberOfVertices(t) <= 1)
+ if (m_Contour->GetNumberOfVertices() <= 1)
{
auto dataStorage = m_ToolManager->GetDataStorage();
dataStorage->Remove(m_LiveWireContourNode);
dataStorage->Remove(m_ContourNode);
dataStorage->Remove(m_EditingContourNode);
- m_LiveWireContour = mitk::ContourModel::New();
+ m_LiveWireContour = this->CreateNewContour();
m_LiveWireContourNode->SetData(m_LiveWireContour);
- m_Contour = mitk::ContourModel::New();
+ m_Contour = this->CreateNewContour();
m_ContourNode->SetData(m_Contour);
this->ResetToStartState();
}
else // Remove last segment from contour and reset LiveWire contour
{
- m_LiveWireContour = mitk::ContourModel::New();
+ m_LiveWireContour = this->CreateNewContour();
m_LiveWireContourNode->SetData(m_LiveWireContour);
- auto newContour = mitk::ContourModel::New();
- newContour->Expand(m_Contour->GetTimeSteps());
+ auto newContour = this->CreateNewContour();
auto begin = m_Contour->IteratorBegin();
// Iterate from last point to next active point
auto newLast = m_Contour->IteratorBegin() + (m_Contour->GetNumberOfVertices() - 1);
// Go at least one down
if (newLast != begin)
--newLast;
// Search next active control point
while (newLast != begin && !((*newLast)->IsControlPoint))
--newLast;
// Set position of start point for LiveWire filter to coordinates of the new last point
m_LiveWireFilter->SetStartPoint((*newLast)->Coordinates);
auto it = m_Contour->IteratorBegin();
// Fll new Contour
while (it <= newLast)
{
- newContour->AddVertex((*it)->Coordinates, (*it)->IsControlPoint, t);
+ newContour->AddVertex((*it)->Coordinates, (*it)->IsControlPoint);
++it;
}
newContour->SetClosed(m_Contour->IsClosed());
m_ContourNode->SetData(newContour);
m_Contour = newContour;
mitk::RenderingManager::GetInstance()->RequestUpdate(interactionEvent->GetSender()->GetRenderWindow());
}
}
template <typename TPixel, unsigned int VImageDimension>
void mitk::LiveWireTool2D::FindHighestGradientMagnitudeByITK(itk::Image<TPixel, VImageDimension> *inputImage,
itk::Index<3> &index,
itk::Index<3> &returnIndex)
{
typedef itk::Image<TPixel, VImageDimension> InputImageType;
typedef typename InputImageType::IndexType IndexType;
const auto MAX_X = inputImage->GetLargestPossibleRegion().GetSize()[0];
const auto MAX_Y = inputImage->GetLargestPossibleRegion().GetSize()[1];
returnIndex[0] = index[0];
returnIndex[1] = index[1];
returnIndex[2] = 0.0;
double gradientMagnitude = 0.0;
double maxGradientMagnitude = 0.0;
// The size and thus the region of 7x7 is only used to calculate the gradient magnitude in that region,
// not for searching the maximum value.
// Maximum value in each direction for size
typename InputImageType::SizeType size;
size[0] = 7;
size[1] = 7;
// Minimum value in each direction for startRegion
IndexType startRegion;
startRegion[0] = index[0] - 3;
startRegion[1] = index[1] - 3;
if (startRegion[0] < 0)
startRegion[0] = 0;
if (startRegion[1] < 0)
startRegion[1] = 0;
if (MAX_X - index[0] < 7)
startRegion[0] = MAX_X - 7;
if (MAX_Y - index[1] < 7)
startRegion[1] = MAX_Y - 7;
index[0] = startRegion[0] + 3;
index[1] = startRegion[1] + 3;
typename InputImageType::RegionType region;
region.SetSize(size);
region.SetIndex(startRegion);
typedef typename itk::GradientMagnitudeImageFilter<InputImageType, InputImageType> GradientMagnitudeFilterType;
typename GradientMagnitudeFilterType::Pointer gradientFilter = GradientMagnitudeFilterType::New();
gradientFilter->SetInput(inputImage);
gradientFilter->GetOutput()->SetRequestedRegion(region);
gradientFilter->Update();
typename InputImageType::Pointer gradientMagnitudeImage;
gradientMagnitudeImage = gradientFilter->GetOutput();
IndexType currentIndex;
currentIndex[0] = 0;
currentIndex[1] = 0;
// Search max (approximate) gradient magnitude
for (int x = -1; x <= 1; ++x)
{
currentIndex[0] = index[0] + x;
for (int y = -1; y <= 1; ++y)
{
currentIndex[1] = index[1] + y;
gradientMagnitude = gradientMagnitudeImage->GetPixel(currentIndex);
// Check for new max
if (maxGradientMagnitude < gradientMagnitude)
{
maxGradientMagnitude = gradientMagnitude;
returnIndex[0] = currentIndex[0];
returnIndex[1] = currentIndex[1];
returnIndex[2] = 0.0;
}
}
currentIndex[1] = index[1];
}
}
diff --git a/Modules/Segmentation/Interactions/mitkLiveWireTool2D.h b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.h
index 45ebf5f865..dff07f7a0b 100644
--- a/Modules/Segmentation/Interactions/mitkLiveWireTool2D.h
+++ b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.h
@@ -1,125 +1,139 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkLiveWireTool2D_h
#define mitkLiveWireTool2D_h
#include <mitkSegTool2D.h>
#include <mitkContourModelLiveWireInteractor.h>
namespace mitk
{
/**
\brief A 2D segmentation tool based on a LiveWire approach.
The contour between the last point and the current mouse position is
computed by searching the shortest path according to specific features of
the image. The contour thus tends to snap to the boundary of objects.
+ The tool always assumes that unconfirmed contours are always defined for the
+ current time point. So the time step in which the contours will be stored as
+ segmentations will be determined when the contours got confirmed. Then they
+ will be transfered to the slices of the currently selected time step.
+ Changing the time point/time step while tool is active will updated the working
+ slice the live wire filter. So the behavior of the active live wire contour is
+ always WYSIWYG (What you see is what you get).
+
\sa SegTool2D
\sa ImageLiveWireContourModelFilter
\ingroup Interaction
\ingroup ToolManagerEtAl
\warning Only to be instantiated by mitk::ToolManager.
*/
class MITKSEGMENTATION_EXPORT LiveWireTool2D : public SegTool2D
{
public:
mitkClassMacro(LiveWireTool2D, SegTool2D);
itkFactorylessNewMacro(Self);
us::ModuleResource GetCursorIconResource() const override;
us::ModuleResource GetIconResource() const override;
const char *GetName() const override;
const char **GetXPM() const override;
/// \brief Convert all current contours to binary segmentations.
void ConfirmSegmentation();
/// \brief Delete all current contours.
void ClearSegmentation();
protected:
LiveWireTool2D();
~LiveWireTool2D() override;
void ConnectActionsAndFunctions() override;
void Activated() override;
void Deactivated() override;
+ void UpdateLiveWireContour();
+ void OnTimePointChanged() override;
private:
/// \brief Initialize tool.
void OnInitLiveWire(StateMachineAction *, InteractionEvent *interactionEvent);
/// \brief Add a control point and finish current segment.
void OnAddPoint(StateMachineAction *, InteractionEvent *interactionEvent);
/// \brief Actual LiveWire computation.
void OnMouseMoved(StateMachineAction *, InteractionEvent *interactionEvent);
/// \brief Check double click on first control point to finish the LiveWire tool.
bool OnCheckPoint(const InteractionEvent *interactionEvent);
/// \brief Finish LiveWire tool.
void OnFinish(StateMachineAction *, InteractionEvent *interactionEvent);
/// \brief Close the contour.
void OnLastSegmentDelete(StateMachineAction *, InteractionEvent *interactionEvent);
/// \brief Don't use dynamic cost map for LiveWire calculation.
void OnMouseMoveNoDynamicCosts(StateMachineAction *, InteractionEvent *interactionEvent);
/// \brief Finish contour interaction.
void FinishTool();
void EnableContourLiveWireInteraction(bool on);
bool IsPositionEventInsideImageRegion(InteractionPositionEvent *positionEvent, BaseData *data);
void ReleaseInteractors();
void ReleaseHelperObjects();
void RemoveHelperObjects();
template <typename TPixel, unsigned int VImageDimension>
void FindHighestGradientMagnitudeByITK(itk::Image<TPixel, VImageDimension> *inputImage,
itk::Index<3> &index,
itk::Index<3> &returnIndex);
+ ContourModel::Pointer CreateNewContour() const;
+
mitk::ContourModel::Pointer m_Contour;
mitk::DataNode::Pointer m_ContourNode;
mitk::ContourModel::Pointer m_LiveWireContour;
mitk::DataNode::Pointer m_LiveWireContourNode;
mitk::ContourModel::Pointer m_EditingContour;
mitk::DataNode::Pointer m_EditingContourNode;
mitk::ContourModelLiveWireInteractor::Pointer m_ContourInteractor;
- mitk::Image::Pointer m_WorkingSlice;
+ /** Slice of the reference data the tool is currently actively working on to
+ define contours.*/
+ mitk::Image::Pointer m_ReferenceDataSlice;
mitk::ImageLiveWireContourModelFilter::Pointer m_LiveWireFilter;
bool m_CreateAndUseDynamicCosts;
std::vector<std::pair<mitk::DataNode::Pointer, mitk::PlaneGeometry::Pointer>> m_WorkingContours;
std::vector<std::pair<mitk::DataNode::Pointer, mitk::PlaneGeometry::Pointer>> m_EditingContours;
std::vector<mitk::ContourModelLiveWireInteractor::Pointer> m_LiveWireInteractors;
PlaneGeometry::ConstPointer m_PlaneGeometry;
};
}
#endif
diff --git a/Modules/Segmentation/Interactions/mitkPaintbrushTool.cpp b/Modules/Segmentation/Interactions/mitkPaintbrushTool.cpp
index de9837ba8d..54231db23f 100644
--- a/Modules/Segmentation/Interactions/mitkPaintbrushTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkPaintbrushTool.cpp
@@ -1,587 +1,566 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkPaintbrushTool.h"
-#include "ipSegmentation.h"
#include "mitkAbstractTransformGeometry.h"
#include "mitkBaseRenderer.h"
-#include "mitkImageDataItem.h"
-#include "mitkOverwriteSliceImageFilter.h"
#include "mitkToolManager.h"
#include "mitkContourModelUtils.h"
#include "mitkLevelWindowProperty.h"
int mitk::PaintbrushTool::m_Size = 1;
mitk::PaintbrushTool::PaintbrushTool(int paintingPixelValue)
: FeedbackContourTool("PressMoveReleaseWithCTRLInversionAllMouseMoves"),
m_PaintingPixelValue(paintingPixelValue),
m_LastContourSize(0) // other than initial mitk::PaintbrushTool::m_Size (around l. 28)
{
m_MasterContour = ContourModel::New();
m_MasterContour->Initialize();
m_CurrentPlane = nullptr;
m_WorkingNode = DataNode::New();
m_WorkingNode->SetProperty("levelwindow", mitk::LevelWindowProperty::New(mitk::LevelWindow(0, 1)));
m_WorkingNode->SetProperty("binary", mitk::BoolProperty::New(true));
}
mitk::PaintbrushTool::~PaintbrushTool()
{
}
void mitk::PaintbrushTool::ConnectActionsAndFunctions()
{
CONNECT_FUNCTION("PrimaryButtonPressed", OnMousePressed);
CONNECT_FUNCTION("Move", OnPrimaryButtonPressedMoved);
CONNECT_FUNCTION("MouseMove", OnMouseMoved);
CONNECT_FUNCTION("Release", OnMouseReleased);
CONNECT_FUNCTION("InvertLogic", OnInvertLogic);
}
void mitk::PaintbrushTool::Activated()
{
Superclass::Activated();
FeedbackContourTool::SetFeedbackContourVisible(true);
SizeChanged.Send(m_Size);
m_ToolManager->WorkingDataChanged +=
mitk::MessageDelegate<mitk::PaintbrushTool>(this, &mitk::PaintbrushTool::OnToolManagerWorkingDataModified);
}
void mitk::PaintbrushTool::Deactivated()
{
FeedbackContourTool::SetFeedbackContourVisible(false);
if (m_ToolManager->GetDataStorage()->Exists(m_WorkingNode))
m_ToolManager->GetDataStorage()->Remove(m_WorkingNode);
m_WorkingSlice = nullptr;
m_CurrentPlane = nullptr;
m_ToolManager->WorkingDataChanged -=
mitk::MessageDelegate<mitk::PaintbrushTool>(this, &mitk::PaintbrushTool::OnToolManagerWorkingDataModified);
Superclass::Deactivated();
}
void mitk::PaintbrushTool::SetSize(int value)
{
m_Size = value;
}
mitk::Point2D mitk::PaintbrushTool::upperLeft(mitk::Point2D p)
{
p[0] -= 0.5;
p[1] += 0.5;
return p;
}
void mitk::PaintbrushTool::UpdateContour(const InteractionPositionEvent *positionEvent)
{
// MITK_INFO<<"Update...";
// examine stateEvent and create a contour that matches the pixel mask that we are going to draw
// mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
// const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
if (!positionEvent)
return;
// Get Spacing of current Slice
// mitk::Vector3D vSpacing = m_WorkingSlice->GetSlicedGeometry()->GetPlaneGeometry(0)->GetSpacing();
//
// Draw a contour in Square according to selected brush size
//
int radius = (m_Size) / 2;
float fradius = static_cast<float>(m_Size) / 2.0f;
ContourModel::Pointer contourInImageIndexCoordinates = ContourModel::New();
// estimate center point of the brush ( relative to the pixel the mouse points on )
// -- left upper corner for even sizes,
// -- midpoint for uneven sizes
mitk::Point2D centerCorrection;
centerCorrection.Fill(0);
// even --> correction of [+0.5, +0.5]
bool evenSize = ((m_Size % 2) == 0);
if (evenSize)
{
centerCorrection[0] += 0.5;
centerCorrection[1] += 0.5;
}
// we will compute the control points for the upper left quarter part of a circle contour
std::vector<mitk::Point2D> quarterCycleUpperRight;
std::vector<mitk::Point2D> quarterCycleLowerRight;
std::vector<mitk::Point2D> quarterCycleLowerLeft;
std::vector<mitk::Point2D> quarterCycleUpperLeft;
mitk::Point2D curPoint;
bool curPointIsInside = true;
curPoint[0] = 0;
curPoint[1] = radius;
quarterCycleUpperRight.push_back(upperLeft(curPoint));
// to estimate if a pixel is inside the circle, we need to compare against the 'outer radius'
// i.e. the distance from the midpoint [0,0] to the border of the pixel [0,radius]
// const float outer_radius = static_cast<float>(radius) + 0.5;
while (curPoint[1] > 0)
{
// Move right until pixel is outside circle
float curPointX_squared = 0.0f;
float curPointY_squared = (curPoint[1] - centerCorrection[1]) * (curPoint[1] - centerCorrection[1]);
while (curPointIsInside)
{
// increment posX and chec
curPoint[0]++;
curPointX_squared = (curPoint[0] - centerCorrection[0]) * (curPoint[0] - centerCorrection[0]);
const float len = sqrt(curPointX_squared + curPointY_squared);
if (len > fradius)
{
// found first Pixel in this horizontal line, that is outside the circle
curPointIsInside = false;
}
}
quarterCycleUpperRight.push_back(upperLeft(curPoint));
// Move down until pixel is inside circle
while (!curPointIsInside)
{
// increment posX and chec
curPoint[1]--;
curPointY_squared = (curPoint[1] - centerCorrection[1]) * (curPoint[1] - centerCorrection[1]);
const float len = sqrt(curPointX_squared + curPointY_squared);
if (len <= fradius)
{
// found first Pixel in this horizontal line, that is outside the circle
curPointIsInside = true;
quarterCycleUpperRight.push_back(upperLeft(curPoint));
}
// Quarter cycle is full, when curPoint y position is 0
if (curPoint[1] <= 0)
break;
}
}
// QuarterCycle is full! Now copy quarter cycle to other quarters.
if (!evenSize)
{
std::vector<mitk::Point2D>::const_iterator it = quarterCycleUpperRight.begin();
while (it != quarterCycleUpperRight.end())
{
mitk::Point2D p;
p = *it;
// the contour points in the lower right corner have same position but with negative y values
p[1] *= -1;
quarterCycleLowerRight.push_back(p);
// the contour points in the lower left corner have same position
// but with both x,y negative
p[0] *= -1;
quarterCycleLowerLeft.push_back(p);
// the contour points in the upper left corner have same position
// but with x negative
p[1] *= -1;
quarterCycleUpperLeft.push_back(p);
it++;
}
}
else
{
std::vector<mitk::Point2D>::const_iterator it = quarterCycleUpperRight.begin();
while (it != quarterCycleUpperRight.end())
{
mitk::Point2D p, q;
p = *it;
q = p;
// the contour points in the lower right corner have same position but with negative y values
q[1] *= -1;
// correct for moved offset if size even = the midpoint is not the midpoint of the current pixel
// but its upper rigt corner
q[1] += 1;
quarterCycleLowerRight.push_back(q);
q = p;
// the contour points in the lower left corner have same position
// but with both x,y negative
q[1] = -1.0f * q[1] + 1;
q[0] = -1.0f * q[0] + 1;
quarterCycleLowerLeft.push_back(q);
// the contour points in the upper left corner have same position
// but with x negative
q = p;
q[0] *= -1;
q[0] += 1;
quarterCycleUpperLeft.push_back(q);
it++;
}
}
// fill contour with poins in right ordering, starting with the upperRight block
mitk::Point3D tempPoint;
for (unsigned int i = 0; i < quarterCycleUpperRight.size(); i++)
{
tempPoint[0] = quarterCycleUpperRight[i][0];
tempPoint[1] = quarterCycleUpperRight[i][1];
tempPoint[2] = 0;
contourInImageIndexCoordinates->AddVertex(tempPoint);
}
// the lower right has to be parsed in reverse order
for (int i = quarterCycleLowerRight.size() - 1; i >= 0; i--)
{
tempPoint[0] = quarterCycleLowerRight[i][0];
tempPoint[1] = quarterCycleLowerRight[i][1];
tempPoint[2] = 0;
contourInImageIndexCoordinates->AddVertex(tempPoint);
}
for (unsigned int i = 0; i < quarterCycleLowerLeft.size(); i++)
{
tempPoint[0] = quarterCycleLowerLeft[i][0];
tempPoint[1] = quarterCycleLowerLeft[i][1];
tempPoint[2] = 0;
contourInImageIndexCoordinates->AddVertex(tempPoint);
}
// the upper left also has to be parsed in reverse order
for (int i = quarterCycleUpperLeft.size() - 1; i >= 0; i--)
{
tempPoint[0] = quarterCycleUpperLeft[i][0];
tempPoint[1] = quarterCycleUpperLeft[i][1];
tempPoint[2] = 0;
contourInImageIndexCoordinates->AddVertex(tempPoint);
}
m_MasterContour = contourInImageIndexCoordinates;
}
/**
Just show the contour, get one point as the central point and add surrounding points to the contour.
*/
void mitk::PaintbrushTool::OnMousePressed(StateMachineAction *, InteractionEvent *interactionEvent)
{
if (m_WorkingSlice.IsNull())
return;
auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (!positionEvent)
return;
m_WorkingSlice->GetGeometry()->WorldToIndex(positionEvent->GetPositionInWorld(), m_LastPosition);
// create new working node
// a fresh node is needed to only display the actual drawing process for
// the undo function
if (m_ToolManager->GetDataStorage()->Exists(m_WorkingNode))
m_ToolManager->GetDataStorage()->Remove(m_WorkingNode);
m_WorkingSlice = nullptr;
m_CurrentPlane = nullptr;
m_WorkingNode = DataNode::New();
m_WorkingNode->SetProperty("levelwindow", mitk::LevelWindowProperty::New(mitk::LevelWindow(0, 1)));
m_WorkingNode->SetProperty("binary", mitk::BoolProperty::New(true));
this->m_WorkingNode->SetVisibility(true);
m_LastEventSender = positionEvent->GetSender();
m_LastEventSlice = m_LastEventSender->GetSlice();
m_MasterContour->SetClosed(true);
this->MouseMoved(interactionEvent, true);
}
void mitk::PaintbrushTool::OnMouseMoved(StateMachineAction *, InteractionEvent *interactionEvent)
{
MouseMoved(interactionEvent, false);
}
void mitk::PaintbrushTool::OnPrimaryButtonPressedMoved(StateMachineAction *, InteractionEvent *interactionEvent)
{
MouseMoved(interactionEvent, true);
}
/**
Insert the point to the feedback contour,finish to build the contour and at the same time the painting function
*/
void mitk::PaintbrushTool::MouseMoved(mitk::InteractionEvent *interactionEvent, bool leftMouseButtonPressed)
{
auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
CheckIfCurrentSliceHasChanged(positionEvent);
if (m_LastContourSize != m_Size)
{
UpdateContour(positionEvent);
m_LastContourSize = m_Size;
}
Point3D worldCoordinates = positionEvent->GetPositionInWorld();
Point3D indexCoordinates;
m_WorkingSlice->GetGeometry()->WorldToIndex(worldCoordinates, indexCoordinates);
// round to nearest voxel center (abort if this hasn't changed)
if (m_Size % 2 == 0) // even
{
indexCoordinates[0] = std::round(indexCoordinates[0]);
indexCoordinates[1] = std::round(indexCoordinates[1]);
}
else // odd
{
indexCoordinates[0] = std::round(indexCoordinates[0]);
indexCoordinates[1] = std::round(indexCoordinates[1]);
}
static Point3D lastPos; // uninitialized: if somebody finds out how this can be initialized in a one-liner, tell me
if (fabs(indexCoordinates[0] - lastPos[0]) > mitk::eps || fabs(indexCoordinates[1] - lastPos[1]) > mitk::eps ||
fabs(indexCoordinates[2] - lastPos[2]) > mitk::eps || leftMouseButtonPressed)
{
lastPos = indexCoordinates;
}
else
{
return;
}
- int t = positionEvent->GetSender()->GetTimeStep();
-
auto contour = ContourModel::New();
contour->SetClosed(true);
auto it = m_MasterContour->Begin();
auto end = m_MasterContour->End();
while (it != end)
{
auto point = (*it)->Coordinates;
point[0] += indexCoordinates[0];
point[1] += indexCoordinates[1];
contour->AddVertex(point);
++it;
}
if (leftMouseButtonPressed)
{
const double dist = indexCoordinates.EuclideanDistanceTo(m_LastPosition);
const double radius = static_cast<double>(m_Size) / 2.0;
DataNode *workingNode(m_ToolManager->GetWorkingData(0));
auto workingImage = dynamic_cast<Image*>(workingNode->GetData());
int activePixelValue = ContourModelUtils::GetActivePixelValue(workingImage);
// m_PaintingPixelValue only decides whether to paint or erase
mitk::ContourModelUtils::FillContourInSlice(
contour, m_WorkingSlice, workingImage, m_PaintingPixelValue * activePixelValue);
m_WorkingNode->SetData(m_WorkingSlice);
m_WorkingNode->Modified();
// if points are >= radius away draw rectangle to fill empty holes
// in between the 2 points
if (dist > radius)
{
const mitk::Point3D ¤tPos = indexCoordinates;
mitk::Point3D direction;
mitk::Point3D vertex;
mitk::Point3D normal;
direction[0] = indexCoordinates[0] - m_LastPosition[0];
direction[1] = indexCoordinates[1] - m_LastPosition[1];
direction[2] = indexCoordinates[2] - m_LastPosition[2];
direction[0] = direction.GetVnlVector().normalize()[0];
direction[1] = direction.GetVnlVector().normalize()[1];
direction[2] = direction.GetVnlVector().normalize()[2];
// 90 degrees rotation of direction
normal[0] = -1.0 * direction[1];
normal[1] = direction[0];
contour->Clear();
// upper left corner
vertex[0] = m_LastPosition[0] + (normal[0] * radius);
vertex[1] = m_LastPosition[1] + (normal[1] * radius);
contour->AddVertex(vertex);
// upper right corner
vertex[0] = currentPos[0] + (normal[0] * radius);
vertex[1] = currentPos[1] + (normal[1] * radius);
contour->AddVertex(vertex);
// lower right corner
vertex[0] = currentPos[0] - (normal[0] * radius);
vertex[1] = currentPos[1] - (normal[1] * radius);
contour->AddVertex(vertex);
// lower left corner
vertex[0] = m_LastPosition[0] - (normal[0] * radius);
vertex[1] = m_LastPosition[1] - (normal[1] * radius);
contour->AddVertex(vertex);
mitk::ContourModelUtils::FillContourInSlice(contour, m_WorkingSlice, workingImage, m_PaintingPixelValue * activePixelValue);
m_WorkingNode->SetData(m_WorkingSlice);
m_WorkingNode->Modified();
}
}
else
{
// switched from different renderwindow
// no activate hover highlighting. Otherwise undo / redo wont work
this->m_WorkingNode->SetVisibility(false);
}
m_LastPosition = indexCoordinates;
// visualize contour
- ContourModel::Pointer displayContour = FeedbackContourTool::GetFeedbackContour();
- displayContour->Clear();
-
ContourModel::Pointer tmp =
FeedbackContourTool::BackProjectContourFrom2DSlice(m_WorkingSlice->GetGeometry(), contour);
- // copy transformed contour into display contour
- it = tmp->Begin();
- end = tmp->End();
-
- while (it != end)
- {
- Point3D point = (*it)->Coordinates;
-
- displayContour->AddVertex(point, t);
- it++;
- }
-
- m_FeedbackContourNode->GetData()->Modified();
+ this->UpdateCurrentFeedbackContour(tmp);
assert(positionEvent->GetSender()->GetRenderWindow());
-
RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
void mitk::PaintbrushTool::OnMouseReleased(StateMachineAction *, InteractionEvent *interactionEvent)
{
// When mouse is released write segmentationresult back into image
auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (!positionEvent)
return;
this->WriteBackSegmentationResult(positionEvent, m_WorkingSlice->Clone());
// deactivate visibility of helper node
m_WorkingNode->SetVisibility(false);
RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
/**
Called when the CTRL key is pressed. Will change the painting pixel value from 0 to 1 or from 1 to 0.
*/
void mitk::PaintbrushTool::OnInvertLogic(StateMachineAction *, InteractionEvent *)
{
// Inversion only for 0 and 1 as painting values
if (m_PaintingPixelValue == 1)
{
m_PaintingPixelValue = 0;
FeedbackContourTool::SetFeedbackContourColor(1.0, 0.0, 0.0);
}
else if (m_PaintingPixelValue == 0)
{
m_PaintingPixelValue = 1;
FeedbackContourTool::SetFeedbackContourColorDefault();
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void mitk::PaintbrushTool::CheckIfCurrentSliceHasChanged(const InteractionPositionEvent *event)
{
const PlaneGeometry *planeGeometry((event->GetSender()->GetCurrentWorldPlaneGeometry()));
const auto *abstractTransformGeometry(
dynamic_cast<const AbstractTransformGeometry *>(event->GetSender()->GetCurrentWorldPlaneGeometry()));
DataNode *workingNode(m_ToolManager->GetWorkingData(0));
if (!workingNode)
return;
Image::Pointer image = dynamic_cast<Image *>(workingNode->GetData());
if (!image || !planeGeometry || abstractTransformGeometry)
return;
if (m_CurrentPlane.IsNull() || m_WorkingSlice.IsNull())
{
m_CurrentPlane = planeGeometry;
m_WorkingSlice = SegTool2D::GetAffectedImageSliceAs2DImage(event, image)->Clone();
m_WorkingNode->ReplaceProperty("color", workingNode->GetProperty("color"));
m_WorkingNode->SetData(m_WorkingSlice);
}
else
{
bool isSameSlice(false);
isSameSlice = mitk::MatrixEqualElementWise(planeGeometry->GetIndexToWorldTransform()->GetMatrix(),
m_CurrentPlane->GetIndexToWorldTransform()->GetMatrix());
isSameSlice = mitk::Equal(planeGeometry->GetIndexToWorldTransform()->GetOffset(),
m_CurrentPlane->GetIndexToWorldTransform()->GetOffset());
if (!isSameSlice)
{
m_ToolManager->GetDataStorage()->Remove(m_WorkingNode);
m_CurrentPlane = nullptr;
m_WorkingSlice = nullptr;
m_WorkingNode = nullptr;
m_CurrentPlane = planeGeometry;
m_WorkingSlice = SegTool2D::GetAffectedImageSliceAs2DImage(event, image)->Clone();
m_WorkingNode = mitk::DataNode::New();
m_WorkingNode->SetProperty("levelwindow", mitk::LevelWindowProperty::New(mitk::LevelWindow(0, 1)));
m_WorkingNode->SetProperty("binary", mitk::BoolProperty::New(true));
m_WorkingNode->SetData(m_WorkingSlice);
// So that the paintbrush contour vanished in the previous render window
RenderingManager::GetInstance()->RequestUpdateAll();
}
}
if (!m_ToolManager->GetDataStorage()->Exists(m_WorkingNode))
{
m_WorkingNode->SetProperty("outline binary", mitk::BoolProperty::New(true));
m_WorkingNode->SetProperty("color", workingNode->GetProperty("color"));
m_WorkingNode->SetProperty("name", mitk::StringProperty::New("Paintbrush_Node"));
m_WorkingNode->SetProperty("helper object", mitk::BoolProperty::New(true));
m_WorkingNode->SetProperty("opacity", mitk::FloatProperty::New(0.8));
m_WorkingNode->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
m_WorkingNode->SetVisibility(
false, mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3")));
m_ToolManager->GetDataStorage()->Add(m_WorkingNode);
}
}
void mitk::PaintbrushTool::OnToolManagerWorkingDataModified()
{
// Here we simply set the current working slice to null. The next time the mouse is moved
// within a renderwindow a new slice will be extracted from the new working data
m_WorkingSlice = nullptr;
}
diff --git a/Modules/Segmentation/Interactions/mitkPaintbrushTool.h b/Modules/Segmentation/Interactions/mitkPaintbrushTool.h
index b63fdfc0a5..b8c4074376 100644
--- a/Modules/Segmentation/Interactions/mitkPaintbrushTool.h
+++ b/Modules/Segmentation/Interactions/mitkPaintbrushTool.h
@@ -1,103 +1,101 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkPaintbrushTool_h_Included
#define mitkPaintbrushTool_h_Included
#include "mitkCommon.h"
#include "mitkFeedbackContourTool.h"
-#include "mitkPointOperation.h"
-#include "mitkPointSet.h"
#include <MitkSegmentationExports.h>
namespace mitk
{
class StateMachineAction;
class InteractionEvent;
class InteractionPositionEvent;
/**
\brief Paintbrush tool for InteractiveSegmentation
\sa FeedbackContourTool
\sa ExtractImageFilter
\sa OverwriteSliceImageFilter
\ingroup Interaction
\ingroup ToolManagerEtAl
Simple paintbrush drawing tool. Right now there are only circular pens of varying size.
\warning Only to be instantiated by mitk::ToolManager.
$Author: maleike $
*/
class MITKSEGMENTATION_EXPORT PaintbrushTool : public FeedbackContourTool
{
public:
// sent when the pen size is changed or should be updated in a GUI.
Message1<int> SizeChanged;
mitkClassMacro(PaintbrushTool, FeedbackContourTool);
void SetSize(int value);
protected:
PaintbrushTool(int paintingPixelValue = 1); // purposely hidden
~PaintbrushTool() override;
void ConnectActionsAndFunctions() override;
void Activated() override;
void Deactivated() override;
virtual void OnMousePressed(StateMachineAction *, InteractionEvent *);
virtual void OnMouseMoved(StateMachineAction *, InteractionEvent *);
virtual void OnPrimaryButtonPressedMoved(StateMachineAction *, InteractionEvent *);
virtual void MouseMoved(mitk::InteractionEvent *interactionEvent, bool leftMouseButtonPressed);
virtual void OnMouseReleased(StateMachineAction *, InteractionEvent *);
virtual void OnInvertLogic(StateMachineAction *, InteractionEvent *);
/**
* \todo This is a possible place where to introduce
* different types of pens
*/
void UpdateContour(const InteractionPositionEvent *);
/**
* Little helper function. Returns the upper left corner of the given pixel.
*/
mitk::Point2D upperLeft(mitk::Point2D p);
/**
* Checks if the current slice has changed
*/
void CheckIfCurrentSliceHasChanged(const InteractionPositionEvent *event);
void OnToolManagerWorkingDataModified();
int m_PaintingPixelValue;
static int m_Size;
ContourModel::Pointer m_MasterContour;
int m_LastContourSize;
Image::Pointer m_WorkingSlice;
PlaneGeometry::ConstPointer m_CurrentPlane;
DataNode::Pointer m_WorkingNode;
mitk::Point3D m_LastPosition;
};
} // namespace
#endif
diff --git a/Modules/Segmentation/Interactions/mitkRegionGrowingTool.cpp b/Modules/Segmentation/Interactions/mitkRegionGrowingTool.cpp
index 7a46716569..3e2617f963 100644
--- a/Modules/Segmentation/Interactions/mitkRegionGrowingTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkRegionGrowingTool.cpp
@@ -1,650 +1,573 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#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>
#include <itkImageDuplicator.h>
#include <limits>
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_MouseDistanceScaleFactor(0.5),
m_PaintingPixelValue(0),
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(const itk::Image<TPixel, imageDimension> *itkImage,
const itk::Index<imageDimension>& index,
ScalarType *result,
unsigned int neighborhood)
{
// maybe assert that image dimension is only 2 or 3?
auto 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(const itk::Image<TPixel, imageDimension> *itkImage,
const 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(const itk::Image<TPixel, imageDimension> *inputImage,
const itk::Index<imageDimension>& seedIndex,
const 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->SetSeed(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?
typedef itk::ImageDuplicator< OutputImageType > DuplicatorType;
typename DuplicatorType::Pointer duplicator = DuplicatorType::New();
duplicator->SetInputImage(resultImage);
duplicator->Update();
typename OutputImageType::Pointer resultDup = duplicator->GetOutput();
NeighborhoodIteratorType neighborhoodIterator(radius, resultDup, resultDup->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);
}
template <typename TPixel, unsigned int imageDimension>
void mitk::RegionGrowingTool::CalculateInitialThresholds(const itk::Image<TPixel, imageDimension>*)
{
LevelWindow levelWindow;
m_ToolManager->GetReferenceData(0)->GetLevelWindow(levelWindow);
m_ThresholdExtrema[0] = static_cast<ScalarType>(std::numeric_limits<TPixel>::lowest());
m_ThresholdExtrema[1] = static_cast<ScalarType>(std::numeric_limits<TPixel>::max());
const ScalarType lowerWindowBound = std::max(m_ThresholdExtrema[0], levelWindow.GetLowerWindowBound());
const ScalarType upperWindowBound = std::min(m_ThresholdExtrema[1], levelWindow.GetUpperWindowBound());
if (m_SeedValue < lowerWindowBound)
{
m_InitialThresholds = { m_ThresholdExtrema[0], lowerWindowBound };
}
else if (m_SeedValue > upperWindowBound)
{
m_InitialThresholds = { upperWindowBound, m_ThresholdExtrema[1] };
}
else
{
const ScalarType range = 0.1 * (upperWindowBound - lowerWindowBound); // 10% of the visible window
m_InitialThresholds[0] = std::min(std::max(lowerWindowBound, m_SeedValue - 0.5 * range), upperWindowBound - range);
m_InitialThresholds[1] = m_InitialThresholds[0] + range;
}
}
void mitk::RegionGrowingTool::OnMousePressed(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (!positionEvent)
return;
m_LastEventSender = positionEvent->GetSender();
m_LastEventSlice = m_LastEventSender->GetSlice();
- m_LastScreenPosition = positionEvent->GetPointerPositionOnScreen();
+ m_LastScreenPosition = Point2I(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)
{
// 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->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 = nullptr so nothing will happen during mouse move
// // remember to fill the contour with 0 in mouserelease
// mitkIpPicDescriptor* segmentationHistory = ipMITKSegmentationCreateGrowerHistory( workingPicSlice,
// m_LastWorkingSeed, nullptr ); // 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 = nullptr;
// return true;
}
void mitk::RegionGrowingTool::OnMousePressedOutside(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (positionEvent)
{
// Get geometry and indices
mitk::BaseGeometry::Pointer workingSliceGeometry;
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->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;
// Calculate initial thresholds
AccessFixedDimensionByItk(m_ReferenceSlice, CalculateInitialThresholds, 2);
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)
{
float isoOffset = 0.33;
mitk::ImageToContourModelFilter::Pointer contourExtractor = mitk::ImageToContourModelFilter::New();
contourExtractor->SetInput(resultImage);
contourExtractor->SetContourValue(m_ConnectedComponentValue - isoOffset);
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));
- // this is not a beautiful solution, just one that works, check T22412 for details
- auto t = positionEvent->GetSender()->GetTimeStep();
-
- FeedbackContourTool::SetFeedbackContour(0 != t
- ? ContourModelUtils::MoveZerothContourTimeStep(resultContourWorld, t)
- : resultContourWorld);
+ FeedbackContourTool::UpdateCurrentFeedbackContour(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;
}
auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (m_ReferenceSlice.IsNotNull() && positionEvent)
{
// Get geometry and indices
mitk::BaseGeometry::Pointer workingSliceGeometry;
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();
+ m_LastScreenPosition = Point2I(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(m_SeedValue, m_InitialThresholds[0] - (m_ScreenYDifference - m_ScreenXDifference) * m_MouseDistanceScaleFactor);
m_Thresholds[1] = std::max(m_SeedValue, m_InitialThresholds[1] + (m_ScreenYDifference + m_ScreenXDifference) * m_MouseDistanceScaleFactor);
// Do not exceed the pixel type extrema of the reference slice, though
m_Thresholds[0] = std::max(m_ThresholdExtrema[0], m_Thresholds[0]);
m_Thresholds[1] = std::min(m_ThresholdExtrema[1], m_Thresholds[1]);
// 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)
{
float isoOffset = 0.33;
mitk::ImageToContourModelFilter::Pointer contourExtractor = mitk::ImageToContourModelFilter::New();
contourExtractor->SetInput(resultImage);
contourExtractor->SetContourValue(m_ConnectedComponentValue - isoOffset);
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));
- // 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::UpdateCurrentFeedbackContour(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;
}
auto *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;
-
- // 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())
- {
- mitk::DataNode *workingNode(m_ToolManager->GetWorkingData(0));
- if (nullptr == workingNode)
- {
- return;
- }
-
- auto workingImage = dynamic_cast<Image*>(workingNode->GetData());
- if (nullptr == workingImage)
- {
- return;
- }
-
- // m_PaintingPixelValue only decides whether to paint or erase
- int activePixelValue = ContourModelUtils::GetActivePixelValue(workingImage);
- mitk::ContourModelUtils::FillContourInSlice(
- projectedContour, 0, m_WorkingSlice, workingImage, m_PaintingPixelValue * activePixelValue);
-
- this->WriteBackSegmentationResult(positionEvent, m_WorkingSlice);
- FeedbackContourTool::SetFeedbackContourVisible(false);
- }
+ this->WriteBackFeedbackContourAsSegmentationResult(positionEvent, m_PaintingPixelValue);
m_ScreenYDifference = 0;
m_ScreenXDifference = 0;
}
}
diff --git a/Modules/Segmentation/Interactions/mitkSegTool2D.cpp b/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
index cd83b0f699..1258f041f5 100644
--- a/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
+++ b/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
@@ -1,629 +1,818 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#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"
+#include "mitkContourModelUtils.h"
+
+#include "itkImageRegionIterator.h"
+
#define ROUND(a) ((a) > 0 ? (int)((a) + 0.5) : -(int)(0.5 - (a)))
bool mitk::SegTool2D::m_SurfaceInterpolationEnabled = true;
+mitk::SegTool2D::SliceInformation::SliceInformation(const mitk::Image* aSlice, const mitk::PlaneGeometry* aPlane, mitk::TimeStepType aTimestep) :
+ slice(aSlice), plane(aPlane), timestep(aTimestep)
+{
+}
+
mitk::SegTool2D::SegTool2D(const char *type, const us::Module *interactorModule)
- : Tool(type, interactorModule), m_LastEventSender(nullptr), m_LastEventSlice(0), m_Contourmarkername("Position"), m_ShowMarkerNodes(false)
+ : Tool(type, interactorModule), m_Contourmarkername("Position")
{
Tool::m_EventConfig = "DisplayConfigMITKNoCrosshair.xml";
}
mitk::SegTool2D::~SegTool2D()
{
}
bool mitk::SegTool2D::FilterEvents(InteractionEvent *interactionEvent, DataNode *)
{
const auto *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)
+{
+ std::vector<SliceInformation> slices = { SliceInformation(slice, plane, 0)};
+ Self::UpdateSurfaceInterpolation(slices, workingImage, detectIntersection);
+}
+
+void mitk::SegTool2D::RemoveContourFromInterpolator(const SliceInformation& sliceInfo)
+{
+ mitk::SurfaceInterpolationController::ContourPositionInformation contourInfo;
+ contourInfo.contourNormal = sliceInfo.plane->GetNormal();
+ contourInfo.contourPoint = sliceInfo.plane->GetOrigin();
+ mitk::SurfaceInterpolationController::GetInstance()->RemoveContour(contourInfo);
+}
+
+void mitk::SegTool2D::UpdateSurfaceInterpolation(const std::vector<SliceInformation>& sliceInfos,
+ const Image* workingImage,
+ bool detectIntersection)
{
if (!m_SurfaceInterpolationEnabled)
return;
+ //Remark: the ImageTimeSelector is just needed to extract a timestep/channel of
+ //the image in order to get the image dimension (time dimension and channel dimension
+ //stripped away). Therfore it is OK to always use time step 0 and channel 0
+ mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
+ timeSelector->SetInput(workingImage);
+ timeSelector->SetTimeNr(0);
+ timeSelector->SetChannelNr(0);
+ timeSelector->Update();
+ const auto dimRefImg = timeSelector->GetOutput()->GetDimension();
+
+ if (dimRefImg != 3)
+ return;
+
+ std::vector<mitk::Surface::Pointer> contourList;
+ contourList.reserve(sliceInfos.size());
+
ImageToContourFilter::Pointer contourExtractor = ImageToContourFilter::New();
- mitk::Surface::Pointer contour;
+
+ std::vector<SliceInformation> relevantSlices = sliceInfos;
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();
+ relevantSlices.clear();
- if (contour->GetVtkPolyData()->GetNumberOfPoints() == 0)
+ for (const auto& sliceInfo : sliceInfos)
{
- // Remove contour!
- mitk::SurfaceInterpolationController::ContourPositionInformation contourInfo;
- contourInfo.contourNormal = plane->GetNormal();
- contourInfo.contourPoint = plane->GetOrigin();
- mitk::SurfaceInterpolationController::GetInstance()->RemoveContour(contourInfo);
- return;
+ // Test whether there is something to extract or whether the slice just contains intersections of others
+ mitk::Image::Pointer slice2 = sliceInfo.slice->Clone();
+ mitk::MorphologicalOperations::Erode(slice2, 2, mitk::MorphologicalOperations::Ball);
+
+ contourExtractor->SetInput(slice2);
+ contourExtractor->Update();
+ mitk::Surface::Pointer contour = contourExtractor->GetOutput();
+
+ if (contour->GetVtkPolyData()->GetNumberOfPoints() == 0)
+ {
+ Self::RemoveContourFromInterpolator(sliceInfo);
+ }
+ else
+ {
+ relevantSlices.push_back(sliceInfo);
+ }
}
}
- 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 (relevantSlices.empty())
+ return;
- if (contour->GetVtkPolyData()->GetNumberOfPoints() != 0 && dimRefImg->GetDimension() == 3)
- {
- mitk::SurfaceInterpolationController::GetInstance()->AddNewContour(contour);
- contour->DisconnectPipeline();
- }
- else
+ for (const auto& sliceInfo : relevantSlices)
{
- // Remove contour!
- mitk::SurfaceInterpolationController::ContourPositionInformation contourInfo;
- contourInfo.contourNormal = plane->GetNormal();
- contourInfo.contourPoint = plane->GetOrigin();
- mitk::SurfaceInterpolationController::GetInstance()->RemoveContour(contourInfo);
+
+ contourExtractor->SetInput(sliceInfo.slice);
+ contourExtractor->Update();
+ mitk::Surface::Pointer contour = contourExtractor->GetOutput();
+
+ if (contour->GetVtkPolyData()->GetNumberOfPoints() == 0)
+ {
+ Self::RemoveContourFromInterpolator(sliceInfo);
+ }
+ else
+ {
+ contour->DisconnectPipeline();
+ contourList.push_back(contour);
+ }
}
+ mitk::SurfaceInterpolationController::GetInstance()->AddNewContours(contourList);
}
+
+
mitk::Image::Pointer mitk::SegTool2D::GetAffectedImageSliceAs2DImage(const InteractionPositionEvent *positionEvent, const Image *image, unsigned int component /*= 0*/)
{
if (!positionEvent)
{
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
+ const auto timeStep = positionEvent->GetSender()->GetTimeStep(image); // get the timestep of the visible part (time-wise) of the image
return GetAffectedImageSliceAs2DImage(positionEvent->GetSender()->GetCurrentWorldPlaneGeometry(), image, timeStep, component);
}
-mitk::Image::Pointer mitk::SegTool2D::GetAffectedImageSliceAs2DImage(const PlaneGeometry *planeGeometry, const Image *image, unsigned int timeStep, unsigned int component /*= 0*/)
+mitk::Image::Pointer mitk::SegTool2D::GetAffectedImageSliceAs2DImageByTimePoint(const PlaneGeometry* planeGeometry, const Image* image, TimePointType timePoint, unsigned int component /*= 0*/)
+{
+ if (!image || !planeGeometry)
+ {
+ return nullptr;
+ }
+
+ if (!image->GetTimeGeometry()->IsValidTimePoint(timePoint))
+ return nullptr;
+
+ return SegTool2D::GetAffectedImageSliceAs2DImage(planeGeometry, image, image->GetTimeGeometry()->TimePointToTimeStep(timePoint), component);
+}
+
+
+mitk::Image::Pointer mitk::SegTool2D::GetAffectedImageSliceAs2DImage(const PlaneGeometry *planeGeometry, const Image *image, TimeStepType timeStep, unsigned int component /*= 0*/)
{
if (!image || !planeGeometry)
{
return nullptr;
}
// 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)
+mitk::Image::Pointer mitk::SegTool2D::GetAffectedWorkingSlice(const InteractionPositionEvent *positionEvent) const
{
- DataNode *workingNode(m_ToolManager->GetWorkingData(0));
+ const auto workingNode = this->GetWorkingDataNode();
if (!workingNode)
{
return nullptr;
}
- auto *workingImage = dynamic_cast<Image *>(workingNode->GetData());
+ const auto *workingImage = dynamic_cast<Image *>(workingNode->GetData());
if (!workingImage)
{
return nullptr;
}
return GetAffectedImageSliceAs2DImage(positionEvent, workingImage);
}
-mitk::Image::Pointer mitk::SegTool2D::GetAffectedReferenceSlice(const InteractionPositionEvent *positionEvent)
+mitk::Image::Pointer mitk::SegTool2D::GetAffectedReferenceSlice(const InteractionPositionEvent *positionEvent) const
{
- DataNode *referenceNode(m_ToolManager->GetReferenceData(0));
+ DataNode* referenceNode = this->GetReferenceDataNode();
if (!referenceNode)
{
return nullptr;
}
auto *referenceImage = dynamic_cast<Image *>(referenceNode->GetData());
if (!referenceImage)
{
return nullptr;
}
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)
+mitk::Image::Pointer mitk::SegTool2D::GetAffectedReferenceSlice(const PlaneGeometry* planeGeometry, TimeStepType timeStep) const
+{
+ DataNode* referenceNode = this->GetReferenceDataNode();
+ if (!referenceNode)
+ {
+ return nullptr;
+ }
+
+ auto* referenceImage = dynamic_cast<Image*>(referenceNode->GetData());
+ if (!referenceImage)
+ {
+ return nullptr;
+ }
+
+ int displayedComponent = 0;
+ if (referenceNode->GetIntProperty("Image.Displayed Component", displayedComponent))
+ {
+ // found the displayed component
+ return GetAffectedImageSliceAs2DImage(planeGeometry, referenceImage, timeStep, displayedComponent);
+ }
+ else
+ {
+ return GetAffectedImageSliceAs2DImage(planeGeometry, referenceImage, timeStep);
+ }
+}
+
+void mitk::SegTool2D::Activated()
+{
+ Superclass::Activated();
+
+ m_ToolManager->SelectedTimePointChanged +=
+ mitk::MessageDelegate<mitk::SegTool2D>(this, &mitk::SegTool2D::OnTimePointChangedInternal);
+
+ m_LastTimePointTriggered = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
+}
+
+void mitk::SegTool2D::Deactivated()
+{
+ m_ToolManager->SelectedTimePointChanged -=
+ mitk::MessageDelegate<mitk::SegTool2D>(this, &mitk::SegTool2D::OnTimePointChangedInternal);
+ Superclass::Deactivated();
+}
+
+void mitk::SegTool2D::OnTimePointChangedInternal()
+{
+ if (m_IsTimePointChangeAware && nullptr != this->GetWorkingDataNode())
+ {
+ const auto timePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
+
+ if (timePoint != m_LastTimePointTriggered)
+ {
+ m_LastTimePointTriggered = timePoint;
+ this->OnTimePointChanged();
+ }
+ }
+}
+
+void mitk::SegTool2D::OnTimePointChanged()
+{
+ //default implementation does nothing
+}
+
+mitk::DataNode* mitk::SegTool2D::GetWorkingDataNode() const
+{
+ if (nullptr != m_ToolManager)
+ {
+ return m_ToolManager->GetWorkingData(0);
+ }
+ return nullptr;
+}
+
+mitk::Image* mitk::SegTool2D::GetWorkingData() const
+{
+ auto node = this->GetWorkingDataNode();
+ if (nullptr != node)
+ {
+ return dynamic_cast<Image*>(node->GetData());
+ }
+ return nullptr;
+}
+
+mitk::DataNode* mitk::SegTool2D::GetReferenceDataNode() const
+{
+ if (nullptr != m_ToolManager)
+ {
+ return m_ToolManager->GetReferenceData(0);
+ }
+ return nullptr;
+}
+
+mitk::Image* mitk::SegTool2D::GetReferenceData() const
+{
+ auto node = this->GetReferenceDataNode();
+ if (nullptr != node)
+ {
+ return dynamic_cast<Image*>(node->GetData());
+ }
+ return nullptr;
+}
+
+
+void mitk::SegTool2D::WriteBackSegmentationResult(const InteractionPositionEvent *positionEvent, const Image * segmentationResult)
{
if (!positionEvent)
return;
const PlaneGeometry *planeGeometry((positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()));
const auto *abstractTransformGeometry(
dynamic_cast<const AbstractTransformGeometry *>(positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()));
- if (planeGeometry && slice && !abstractTransformGeometry)
+ if (planeGeometry && segmentationResult && !abstractTransformGeometry)
{
- DataNode *workingNode(m_ToolManager->GetWorkingData(0));
+ const auto workingNode = this->GetWorkingDataNode();
auto *image = dynamic_cast<Image *>(workingNode->GetData());
- unsigned int timeStep = positionEvent->GetSender()->GetTimeStep(image);
- this->WriteBackSegmentationResult(planeGeometry, slice, timeStep);
+ const auto timeStep = positionEvent->GetSender()->GetTimeStep(image);
+ this->WriteBackSegmentationResult(planeGeometry, segmentationResult, timeStep);
}
}
+void mitk::SegTool2D::WriteBackSegmentationResult(const DataNode* workingNode, const PlaneGeometry* planeGeometry, const Image* segmentationResult, TimeStepType timeStep)
+{
+ if (!planeGeometry || !segmentationResult)
+ return;
+
+ SliceInformation sliceInfo(segmentationResult, const_cast<mitk::PlaneGeometry*>(planeGeometry), timeStep);
+ Self::WriteBackSegmentationResults(workingNode, { sliceInfo }, true);
+}
+
void mitk::SegTool2D::WriteBackSegmentationResult(const PlaneGeometry *planeGeometry,
- Image *slice,
- unsigned int timeStep)
+ const Image * segmentationResult,
+ TimeStepType timeStep)
{
- if (!planeGeometry || !slice)
+ if (!planeGeometry || !segmentationResult)
return;
- SliceInformation sliceInfo(slice, const_cast<mitk::PlaneGeometry *>(planeGeometry), timeStep);
- this->WriteSliceToVolume(sliceInfo);
- DataNode *workingNode(m_ToolManager->GetWorkingData(0));
- auto *image = dynamic_cast<Image *>(workingNode->GetData());
+ SliceInformation sliceInfo(segmentationResult, const_cast<mitk::PlaneGeometry *>(planeGeometry), timeStep);
+ WriteBackSegmentationResults({ sliceInfo }, true);
+}
- this->UpdateSurfaceInterpolation(slice, image, planeGeometry, false);
+void mitk::SegTool2D::WriteBackSegmentationResults(const std::vector<SegTool2D::SliceInformation> &sliceList,
+ bool writeSliceToVolume)
+{
+ const auto workingNode = this->GetWorkingDataNode();
- if (m_SurfaceInterpolationEnabled)
- this->AddContourmarker();
+ mitk::SegTool2D::WriteBackSegmentationResults(workingNode, sliceList, writeSliceToVolume);
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+ // the first geometry is needed otherwise restoring the position is not working
+ const auto* plane3 =
+ dynamic_cast<const PlaneGeometry*>(dynamic_cast<const mitk::SlicedGeometry3D*>(
+ m_LastEventSender->GetSliceNavigationController()->GetCurrentGeometry3D())
+ ->GetPlaneGeometry(0));
+ unsigned int slicePosition = m_LastEventSender->GetSliceNavigationController()->GetSlice()->GetPos();
+
+ /* A cleaner solution would be to add a contour marker for each slice info. It currently
+ does not work as the contour markers expect that the plane is always the plane of slice 0.
+ Had not the time to do it properly no. Should be solved by T28146*/
+ this->AddContourmarker(plane3, slicePosition);
}
-void mitk::SegTool2D::WriteBackSegmentationResult(const std::vector<SegTool2D::SliceInformation> &sliceList,
- bool writeSliceToVolume)
+void mitk::SegTool2D::WriteBackSegmentationResults(const DataNode* workingNode, const std::vector<SliceInformation>& sliceList, bool writeSliceToVolume)
{
- std::vector<mitk::Surface::Pointer> contourList;
- contourList.reserve(sliceList.size());
- ImageToContourFilter::Pointer contourExtractor = ImageToContourFilter::New();
+ if (nullptr == workingNode)
+ {
+ mitkThrow() << "Cannot write slice to working node. Working node is invalid.";
+ }
- DataNode *workingNode(m_ToolManager->GetWorkingData(0));
- auto *image = dynamic_cast<Image *>(workingNode->GetData());
+ auto* 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();
+ if (nullptr == image)
+ {
+ mitkThrow() << "Cannot write slice to working node. Working node does not contain an image.";
+ }
- for (unsigned int i = 0; i < sliceList.size(); ++i)
+ for (const auto& sliceInfo : sliceList)
{
- SliceInformation currentSliceInfo = sliceList.at(i);
- if (writeSliceToVolume)
- this->WriteSliceToVolume(currentSliceInfo);
- if (m_SurfaceInterpolationEnabled && dimRefImg->GetDimension() == 3)
+ if (writeSliceToVolume && nullptr != sliceInfo.plane && sliceInfo.slice.IsNotNull())
{
- currentSliceInfo.slice->DisconnectPipeline();
- contourExtractor->SetInput(currentSliceInfo.slice);
- contourExtractor->Update();
- mitk::Surface::Pointer contour = contourExtractor->GetOutput();
- contour->DisconnectPipeline();
-
- contourList.push_back(contour);
+ mitk::SegTool2D::WriteSliceToVolume(image, sliceInfo, true);
}
}
- mitk::SurfaceInterpolationController::GetInstance()->AddNewContours(contourList);
+
+ mitk::SegTool2D::UpdateSurfaceInterpolation(sliceList, image, false);
+
+ // also mark its node as modified (T27308). Can be removed if T27307
+ // is properly solved
+ if (workingNode != nullptr) workingNode->Modified();
+
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
-void mitk::SegTool2D::WriteSliceToVolume(const mitk::SegTool2D::SliceInformation &sliceInfo)
+void mitk::SegTool2D::WriteSliceToVolume(Image* workingImage, const PlaneGeometry* planeGeometry, const Image* slice, TimeStepType timeStep, bool allowUndo)
+{
+ SliceInformation sliceInfo(slice, planeGeometry, timeStep);
+ WriteSliceToVolume(workingImage, sliceInfo , allowUndo);
+}
+
+void mitk::SegTool2D::WriteSliceToVolume(Image* workingImage, const SliceInformation &sliceInfo, bool allowUndo)
{
- DataNode *workingNode(m_ToolManager->GetWorkingData(0));
- auto *image = dynamic_cast<Image *>(workingNode->GetData());
+ if (nullptr == workingImage)
+ {
+ mitkThrow() << "Cannot write slice to working node. Working node does not contain an image.";
+ }
+
+ DiffSliceOperation* undoOperation = nullptr;
- /*============= 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);
- auto *undoOperation =
- new DiffSliceOperation(image,
- originalSlice,
- dynamic_cast<SlicedGeometry3D *>(originalSlice->GetGeometry()),
- sliceInfo.timestep,
- sliceInfo.plane);
- /*============= END undo/redo feature block ========================*/
+ if (allowUndo)
+ {
+ /*============= BEGIN undo/redo feature block ========================*/
+ // Create undo operation by caching the not yet modified slices
+ mitk::Image::Pointer originalSlice = GetAffectedImageSliceAs2DImage(sliceInfo.plane, workingImage, sliceInfo.timestep);
+ undoOperation =
+ new DiffSliceOperation(workingImage,
+ 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());
+ // casting const away is needed and OK as long the OverwriteMode of
+ // mitkVTKImageOverwrite is true.
+ // Reason: because then the input slice is not touched but
+ // used to overwrite the input of the ExtractSliceFilter.
+ auto noneConstSlice = const_cast<Image*>(sliceInfo.slice.GetPointer());
+ reslice->SetInputSlice(noneConstSlice->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->SetInput(workingImage);
extractor->SetTimeStep(sliceInfo.timestep);
extractor->SetWorldGeometry(sliceInfo.plane);
extractor->SetVtkOutputRequest(false);
- extractor->SetResliceTransformByGeometry(image->GetGeometry(sliceInfo.timestep));
+ extractor->SetResliceTransformByGeometry(workingImage->GetGeometry(sliceInfo.timestep));
extractor->Modified();
extractor->Update();
// the image was modified within the pipeline, but not marked so
- image->Modified();
- image->GetVtkImageData()->Modified();
+ workingImage->Modified();
+ workingImage->GetVtkImageData()->Modified();
- // also mark its node as modified (T27308). Can be removed if T27307
- // is properly solved
- if (workingNode != nullptr) workingNode->Modified();
-
- /*============= BEGIN undo/redo feature block ========================*/
- // specify the undo operation with the edited slice
- auto *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);
+ if (allowUndo)
+ {
+ /*============= BEGIN undo/redo feature block ========================*/
+ // specify the redo operation with the edited slice
+ auto* doOperation =
+ new DiffSliceOperation(workingImage,
+ 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);
+ /*============= END undo/redo feature block ========================*/
+ }
- // clear the pointers as the operation are stored in the undocontroller and also deleted from there
- undoOperation = nullptr;
- doOperation = nullptr;
- /*============= 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()
+
+int mitk::SegTool2D::AddContourmarker(const PlaneGeometry* planeGeometry, unsigned int sliceIndex)
{
- if (m_LastEventSender == nullptr)
+ if (planeGeometry == nullptr)
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 auto *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);
+ unsigned int id = service->AddNewPlanePosition(planeGeometry, sliceIndex);
mitk::PlanarCircle::Pointer contourMarker = mitk::PlanarCircle::New();
mitk::Point2D p1;
- plane->Map(plane->GetCenter(), p1);
+ planeGeometry->Map(planeGeometry->GetCenter(), p1);
mitk::Point2D p2 = p1;
- p2[0] -= plane->GetSpacing()[0];
- p2[1] -= plane->GetSpacing()[1];
+ p2[0] -= planeGeometry->GetSpacing()[0];
+ p2[1] -= planeGeometry->GetSpacing()[1];
contourMarker->PlaceFigure(p1);
contourMarker->SetCurrentControlPoint(p1);
- contourMarker->SetPlaneGeometry(const_cast<PlaneGeometry *>(plane));
+ contourMarker->SetPlaneGeometry(planeGeometry->Clone());
std::stringstream markerStream;
- mitk::DataNode *workingNode(m_ToolManager->GetWorkingData(0));
+ auto workingNode = this->GetWorkingDataNode();
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 (planeGeometry)
{
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 (auto 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)
+void mitk::SegTool2D::InteractiveSegmentationBugMessage(const std::string &message) const
{
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();
auto *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())
{
auto 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)
+ Image *targetSlice, const Image *sourceSlice, const Image *workingImage, int paintingPixelValue)
{
- if ((!targetSlice) || (!sourceSlice))
- return;
- AccessFixedDimensionByItk_3(
- targetSlice, InternalWritePreviewOnWorkingImage, 2, sourceSlice, workingImage, paintingPixelValue);
+ if (nullptr == targetSlice)
+ {
+ mitkThrow() << "Cannot write preview on working image. Target slice does not point to a valid instance.";
+ }
+
+ if (nullptr == sourceSlice)
+ {
+ mitkThrow() << "Cannot write preview on working image. Source slice does not point to a valid instance.";
+ }
+
+ if (nullptr == workingImage)
+ {
+ mitkThrow() << "Cannot write preview on working image. Working image does not point to a valid instance.";
+ }
+
+ auto constVtkSource = sourceSlice->GetVtkImageData();
+ /*Need to const cast because Vtk interface does not support const correctly.
+ (or I am not experienced enough to use it correctly)*/
+ auto nonConstVtkSource = const_cast<vtkImageData*>(constVtkSource);
+
+ ContourModelUtils::FillSliceInSlice(nonConstVtkSource, targetSlice->GetVtkImageData(), workingImage, paintingPixelValue);
}
diff --git a/Modules/Segmentation/Interactions/mitkSegTool2D.h b/Modules/Segmentation/Interactions/mitkSegTool2D.h
index 474b90fae7..a95831ba38 100644
--- a/Modules/Segmentation/Interactions/mitkSegTool2D.h
+++ b/Modules/Segmentation/Interactions/mitkSegTool2D.h
@@ -1,199 +1,293 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#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 image
\param plane
\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);
+ /**
+ * \brief Extract the slice of an image that the user just scribbles on. The given component denotes the vector component of an vector image.
+ *
+ * \param positionEvent Event that specifies the plane that should be used to slice
+ * \param image Image that should be sliced
+ * \param timeStep TimeStep of the image that shold be sliced
+ * \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.
+ */
+ static Image::Pointer GetAffectedImageSliceAs2DImage(const InteractionPositionEvent* positionEvent, const Image* image, unsigned int component = 0);
+
+ /**
+ * \brief Extract the slice of an image cut by given plane. The given component denotes the vector component of a vector image.
+ *
+ * \param planeGeometry Geometry defining the slice that should be cut out.
+ * \param image Image that should be sliced
+ * \param timeStep TimeStep of the image that shold be sliced
+ * \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.
+ */
+ static Image::Pointer GetAffectedImageSliceAs2DImage(const PlaneGeometry* planeGeometry,
+ const Image* image,
+ TimeStepType timeStep,
+ unsigned int component = 0);
+ static Image::Pointer GetAffectedImageSliceAs2DImageByTimePoint(const PlaneGeometry* planeGeometry,
+ const Image* image,
+ TimePointType timePoint,
+ unsigned int component = 0);
+
+ /** Convenience overloaded version that can be called for a given planeGeometry, slice image and time step.
+ * Calls static WriteBackSegmentationResults*/
+ static void WriteBackSegmentationResult(const DataNode* workingNode, const PlaneGeometry* planeGeometry, const Image* segmentationResult, TimeStepType timeStep);
+
+ /** Convenience overloaded version that can be called for a given planeGeometry, slice image and time step.
+ * For more details see protected WriteSliceToVolume version.*/
+ static void WriteSliceToVolume(Image* workingImage, const PlaneGeometry* planeGeometry, const Image* slice, TimeStepType timeStep, bool allowUndo);
+
void SetShowMarkerNodes(bool);
/**
* \brief Enables or disables the 3D interpolation after writing back the 2D segmentation result, and defaults to
* true.
*/
void SetEnable3DInterpolation(bool);
+ void Activated() override;
+ void Deactivated() override;
+
+ itkSetMacro(IsTimePointChangeAware, bool);
+ itkGetMacro(IsTimePointChangeAware, bool);
+ itkBooleanMacro(IsTimePointChangeAware);
+
protected:
SegTool2D(); // purposely hidden
SegTool2D(const char *, const us::Module *interactorModule = nullptr); // purposely hidden
~SegTool2D() override;
+ /**
+ * @brief returns the segmentation node that should be modified by the tool.
+ */
+ DataNode* GetWorkingDataNode() const;
+ Image* GetWorkingData() const;
+
+ DataNode* GetReferenceDataNode() const;
+ Image* GetReferenceData() const;
+
+ /**
+ * This function can be reimplemented by derived classes to react on changes of the current
+ * time point. Default implementation does nothing.*/
+ virtual void OnTimePointChanged();
+
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;
- }
+ mitk::Image::ConstPointer slice;
+ const mitk::PlaneGeometry *plane = nullptr;
+ mitk::TimeStepType timestep = 0;
+
+ SliceInformation() = default;
+ SliceInformation(const mitk::Image* aSlice, const mitk::PlaneGeometry* aPlane, mitk::TimeStepType aTimestep);
};
/**
- * \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
- */
- bool FilterEvents(InteractionEvent *interactionEvent, DataNode *dataNode) override;
+ * @brief Updates the surface interpolation by extracting the contour form the given slice.
+ * @param sliceInfos vector of slice information instances from which the contours should be extracted
+ * @param workingImage the segmentation image
+ * @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 std::vector<SliceInformation>& sliceInfos,
+ const Image* workingImage,
+ bool detectIntersection);
- /**
- * \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 positionEvent
- * \param 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 *positionEvent, const Image *image, unsigned int component = 0);
/**
- * \brief Extract the slice of an image cut by given plane. The given component denotes the vector component of a dwi-image.
- *
- * \param planeGeometry
- * \param image
- * \param timeStep
- * \param component The component to be extracted of a given multi-component image. -1 is the default parameter to denote an invalid component.
+ * \brief Filters events that cannot be handled by 2D segmentation tools
*
- * \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.
+ * Currently an event is discarded if it was not sent by a 2D renderwindow and if it is
+ * not of type InteractionPositionEvent
*/
- Image::Pointer GetAffectedImageSliceAs2DImage(const PlaneGeometry *planeGeometry,
- const Image *image,
- unsigned int timeStep,
- unsigned int component = 0);
+ bool FilterEvents(InteractionEvent *interactionEvent, DataNode *dataNode) override;
/**
\brief Extract the slice of the currently selected working image that the user just scribbles on.
\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,
or just no working image is selected.
*/
- Image::Pointer GetAffectedWorkingSlice(const InteractionPositionEvent *);
+ Image::Pointer GetAffectedWorkingSlice(const InteractionPositionEvent *) const;
/**
\brief Extract the slice of the currently selected reference image that the user just scribbles on.
\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,
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);
+ Image::Pointer GetAffectedReferenceSlice(const InteractionPositionEvent *) const;
+ /** Overload version that gets the reference slice passed on the passed plane geometry and timestep.*/
+ Image::Pointer GetAffectedReferenceSlice(const PlaneGeometry* planeGeometry, TimeStepType timeStep) const;
+
+ /** Convenience version that can be called for a given event (which is used to deduce timepoint and plane) and a slice image.
+ * Calls non static WriteBackSegmentationResults*/
+ void WriteBackSegmentationResult(const InteractionPositionEvent *, const Image* segmentationResult);
+
+ /** Convenience version that can be called for a given planeGeometry, slice image and time step.
+ * Calls non static WriteBackSegmentationResults*/
+ void WriteBackSegmentationResult(const PlaneGeometry *planeGeometry, const Image* segmentationResult, TimeStepType timeStep);
+
+ /** Overloaded version that calls the static version and also adds the contour markers.*/
+ void WriteBackSegmentationResults(const std::vector<SliceInformation> &sliceList, bool writeSliceToVolume = true);
+
+ /** \brief Writes all provided source slices into the data of the passed workingNode.
+ * The function does the following: 1) for every passed slice write it to workingNode (and generate and undo/redo step);
+ * 2) update the surface interpolation and 3) marke the node as modified.
+ * @param workingNode Pointer to the node that contains the working image.
+ * @param sliceList Vector of all slices that should be written into the workingNode.
+ * @param writeSliceToVolume If set to false the write operation (WriteSliceToVolume will be skipped)
+ * and only the surface interpolation will be updated.
+ * @pre workingNode must point to a valid instance and contain an image instance as data.*/
+ static void WriteBackSegmentationResults(const DataNode* workingNode, const std::vector<SliceInformation>& sliceList, bool writeSliceToVolume = true);
+
+ /** Writes the provided source slice into the target slice with the given pixel value.
+ * If passed workingImage is a LabelSetImage the label set rules will be applied when
+ * writing all non zero source pixels into the target slice (e.g. locked lables will not be touched)
+ * with the given paintingPixelValue.
+ * @param targetSlice Pointer to the slice that should be filled with the content of the sourceSlice.
+ * @param sourceSlice Pointer to the slice that is the source/preview every pixel will be (tried to be) transfered .
+ * @param workingImage Will be used to check if LabeSetImageRules have to be applied and the label set state.
+ * @param paintingPixelValue Value that will be used to paint onto target slice.
+ * @pre targetSlice must point to a valid instance.
+ * @pre sourceSlice must point to a valid instance.
+ * @pre workingImage must point to a valid instance.*/
+ static void WritePreviewOnWorkingImage(
+ Image *targetSlice, const Image *sourceSlice, const Image *workingImage, int paintingPixelValue);
+
+ /** Writes a provided slice into the passed working image. The content of working image that is covered
+ * by the slice will be completly overwritten. If asked for it also generates the needed
+ * undo/redo steps.
+ * @param workingImage Pointer to the image that is the target of the write operation.
+ * @param sliceInfo SliceInfo instance that containes the slice image, the defining plane geometry and time step.
+ * @param allowUndo Indicates if undo/redo operations should be registered for the write operation
+ * performed by this call. true: undo/redo will be generated; false: no undo/redo will be generated, so
+ * this operation cannot be revoked by the user.
+ * @pre workingImage must point to a valid instance.*/
+ static void WriteSliceToVolume(Image* workingImage, const SliceInformation &sliceInfo, bool allowUndo);
- void WriteBackSegmentationResult(const std::vector<SliceInformation> &sliceList, bool writeSliceToVolume = true);
-
- void WritePreviewOnWorkingImage(
- Image *targetSlice, Image *sourceSlice, Image *workingImage, int paintingPixelValue, int timestep);
-
- void WriteSliceToVolume(const 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
+ By selecting this node the slicestack will be reoriented according to the passed
+ PlanarFigure's Geometry
*/
- int AddContourmarker();
+ int AddContourmarker(const PlaneGeometry* planeGeometry, unsigned int sliceIndex);
- void InteractiveSegmentationBugMessage(const std::string &message);
+ void InteractiveSegmentationBugMessage(const std::string &message) const;
- BaseRenderer *m_LastEventSender;
- unsigned int m_LastEventSlice;
+ BaseRenderer *m_LastEventSender = nullptr;
+ unsigned int m_LastEventSlice = 0;
+
+ itkGetMacro(LastTimePointTriggered, TimePointType);
private:
+ /** Internal method that gets triggered as soon as the tool manager indicates a
+ * time point change. If the time point has changed since last time and tool
+ * is set to be time point change aware, OnTimePointChanged() will be called.*/
+ void OnTimePointChangedInternal();
+
+ static void RemoveContourFromInterpolator(const SliceInformation& sliceInfo);
+
// The prefix of the contourmarkername. Suffix is a consecutive number
const std::string m_Contourmarkername;
- bool m_ShowMarkerNodes;
+ bool m_ShowMarkerNodes = false;
static bool m_SurfaceInterpolationEnabled;
+
+ bool m_IsTimePointChangeAware = true;
+
+ TimePointType m_LastTimePointTriggered = 0.;
};
} // namespace
#endif
diff --git a/Modules/Segmentation/Interactions/mitkSegmentationInteractor.cpp b/Modules/Segmentation/Interactions/mitkSegmentationInteractor.cpp
index 4aec82aba5..1b67d32f1f 100644
--- a/Modules/Segmentation/Interactions/mitkSegmentationInteractor.cpp
+++ b/Modules/Segmentation/Interactions/mitkSegmentationInteractor.cpp
@@ -1,63 +1,63 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkSegmentationInteractor.h"
#include "mitkInteractionPositionEvent.h"
#include "mitkLabelSetImage.h"
#include "mitkToolManager.h"
#include "mitkToolManagerProvider.h"
#include <mitkImagePixelReadAccessor.h>
#include <cstring>
void mitk::SegmentationInteractor::ConnectActionsAndFunctions()
{
Superclass::ConnectActionsAndFunctions();
// CONNECT_FUNCTION("change_active_label", ChangeActiveLabel);
}
bool mitk::SegmentationInteractor::ChangeActiveLabel(StateMachineAction *, InteractionEvent *interactionEvent)
{
BaseRenderer::Pointer sender = interactionEvent->GetSender();
auto *positionEvent = static_cast<InteractionPositionEvent *>(interactionEvent);
// MLI TODO
// m_LastDisplayCoordinate = m_CurrentDisplayCoordinate;
// m_CurrentDisplayCoordinate = positionEvent->GetPointerPositionOnScreen();
auto *toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager(
mitk::ToolManagerProvider::MULTILABEL_SEGMENTATION);
assert(toolManager);
DataNode *workingNode(toolManager->GetWorkingData(0));
if (workingNode)
{
auto *workingImage = dynamic_cast<mitk::LabelSetImage *>(workingNode->GetData());
assert(workingImage);
- int timestep = positionEvent->GetSender()->GetTimeStep();
+ const auto timestep = positionEvent->GetSender()->GetTimeStep(workingImage);
int pixelValue = static_cast<int>(workingImage->GetPixelValueByWorldCoordinate(positionEvent->GetPositionInWorld(), timestep));
workingImage->GetActiveLabelSet()->SetActiveLabel(pixelValue); // can be the background
// Call Events
// workingImage->ActiveLabelEvent.Send(pixelValue);
// MLI TODO
// toolManager->WorkingDataModified.Send();
}
RenderingManager::GetInstance()->RequestUpdateAll();
return true;
}
diff --git a/Modules/Segmentation/Interactions/mitkSetRegionTool.cpp b/Modules/Segmentation/Interactions/mitkSetRegionTool.cpp
index bf0bbfe459..da8a94ed20 100644
--- a/Modules/Segmentation/Interactions/mitkSetRegionTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkSetRegionTool.cpp
@@ -1,176 +1,138 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkSetRegionTool.h"
#include "mitkToolManager.h"
#include "mitkBaseRenderer.h"
-#include "mitkImageDataItem.h"
-#include "mitkLabelSetImage.h"
#include <mitkITKImageImport.h>
-#include <mitkImagePixelReadAccessor.h>
#include <mitkImageToContourModelFilter.h>
#include <itkBinaryFillholeImageFilter.h>
#include <itkConnectedThresholdImageFilter.h>
mitk::SetRegionTool::SetRegionTool(int paintingPixelValue)
: FeedbackContourTool("PressMoveRelease"), m_PaintingPixelValue(paintingPixelValue)
{
}
mitk::SetRegionTool::~SetRegionTool()
{
}
void mitk::SetRegionTool::ConnectActionsAndFunctions()
{
CONNECT_FUNCTION("PrimaryButtonPressed", OnMousePressed);
CONNECT_FUNCTION("Release", OnMouseReleased);
CONNECT_FUNCTION("Move", OnMouseMoved);
}
void mitk::SetRegionTool::Activated()
{
Superclass::Activated();
}
void mitk::SetRegionTool::Deactivated()
{
Superclass::Deactivated();
}
void mitk::SetRegionTool::OnMousePressed(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (!positionEvent)
return;
m_LastEventSender = positionEvent->GetSender();
m_LastEventSlice = m_LastEventSender->GetSlice();
// 1. Get the working image
Image::Pointer workingSlice = FeedbackContourTool::GetAffectedWorkingSlice(positionEvent);
if (workingSlice.IsNull())
return; // can't do anything without the segmentation
// if click was outside the image, don't continue
const BaseGeometry *sliceGeometry = workingSlice->GetGeometry();
itk::Index<3> projectedPointIn2D;
sliceGeometry->WorldToIndex(positionEvent->GetPositionInWorld(), projectedPointIn2D);
if (!sliceGeometry->IsIndexInside(projectedPointIn2D))
{
MITK_WARN << "Point outside of segmentation slice." << std::endl;
return; // can't use that as a seed point
}
typedef itk::Image<DefaultSegmentationDataType, 2> InputImageType;
typedef InputImageType::IndexType IndexType;
typedef itk::ConnectedThresholdImageFilter<InputImageType, InputImageType> RegionGrowingFilterType;
RegionGrowingFilterType::Pointer regionGrower = RegionGrowingFilterType::New();
// convert world coordinates to image indices
IndexType seedIndex;
sliceGeometry->WorldToIndex(positionEvent->GetPositionInWorld(), seedIndex);
// perform region growing in desired segmented region
InputImageType::Pointer itkImage = InputImageType::New();
CastToItkImage(workingSlice, itkImage);
regionGrower->SetInput(itkImage);
regionGrower->AddSeed(seedIndex);
InputImageType::PixelType bound = itkImage->GetPixel(seedIndex);
regionGrower->SetLower(bound);
regionGrower->SetUpper(bound);
regionGrower->SetReplaceValue(1);
itk::BinaryFillholeImageFilter<InputImageType>::Pointer fillHolesFilter =
itk::BinaryFillholeImageFilter<InputImageType>::New();
fillHolesFilter->SetInput(regionGrower->GetOutput());
fillHolesFilter->SetForegroundValue(1);
// Store result and preview
mitk::Image::Pointer resultImage = mitk::GrabItkImageMemory(fillHolesFilter->GetOutput());
resultImage->SetGeometry(workingSlice->GetGeometry());
// Get the current working color
DataNode *workingNode(m_ToolManager->GetWorkingData(0));
if (!workingNode)
return;
mitk::ImageToContourModelFilter::Pointer contourextractor = mitk::ImageToContourModelFilter::New();
contourextractor->SetInput(resultImage);
contourextractor->Update();
mitk::ContourModel::Pointer awesomeContour = contourextractor->GetOutput();
- auto t = positionEvent->GetSender()->GetTimeStep();
- FeedbackContourTool::SetFeedbackContour(0 != t
- ? ContourModelUtils::MoveZerothContourTimeStep(awesomeContour, t)
- : awesomeContour);
+ this->UpdateCurrentFeedbackContour(awesomeContour);
FeedbackContourTool::SetFeedbackContourVisible(true);
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
void mitk::SetRegionTool::OnMouseReleased(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (!positionEvent)
return;
assert(positionEvent->GetSender()->GetRenderWindow());
// 1. Hide the feedback contour, find out which slice the user clicked, find out which slice of the toolmanager's
// working image corresponds to that
- FeedbackContourTool::SetFeedbackContourVisible(false);
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
- int timeStep = positionEvent->GetSender()->GetTimeStep();
-
- DataNode *workingNode(m_ToolManager->GetWorkingData(0));
- if (!workingNode)
- return;
-
- auto *image = dynamic_cast<Image *>(workingNode->GetData());
- const PlaneGeometry *planeGeometry((positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()));
- if (!image || !planeGeometry)
- return;
-
- Image::Pointer slice = FeedbackContourTool::GetAffectedImageSliceAs2DImage(positionEvent, image);
-
- if (slice.IsNull())
- {
- MITK_ERROR << "Unable to extract slice." << std::endl;
- return;
- }
-
- ContourModel *feedbackContour(FeedbackContourTool::GetFeedbackContour());
- ContourModel::Pointer projectedContour = FeedbackContourTool::ProjectContourTo2DSlice(
- slice, feedbackContour, false, false); // false: don't add 0.5 (done by FillContourInSlice)
- // false: don't constrain the contour to the image's inside
- if (projectedContour.IsNull())
- return;
-
- int activePixelValue = ContourModelUtils::GetActivePixelValue(image);
-
- mitk::ContourModelUtils::FillContourInSlice(
- projectedContour, timeStep, slice, image, m_PaintingPixelValue * activePixelValue);
-
- this->WriteBackSegmentationResult(positionEvent, slice);
+ this->WriteBackFeedbackContourAsSegmentationResult(positionEvent, m_PaintingPixelValue);
}
void mitk::SetRegionTool::OnMouseMoved(mitk::StateMachineAction *, mitk::InteractionEvent *)
{
}
diff --git a/Modules/Segmentation/Interactions/mitkTool.cpp b/Modules/Segmentation/Interactions/mitkTool.cpp
index 2c2f32e1e5..5f15bc5dbf 100644
--- a/Modules/Segmentation/Interactions/mitkTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkTool.cpp
@@ -1,333 +1,333 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkTool.h"
#include <mitkAnatomicalStructureColorPresets.h>
#include "mitkDisplayInteractor.h"
#include "mitkDisplayActionEventBroadcast.h"
#include "mitkImageReadAccessor.h"
#include "mitkImageWriteAccessor.h"
#include "mitkLevelWindowProperty.h"
#include "mitkLookupTableProperty.h"
#include "mitkProperties.h"
#include "mitkVtkResliceInterpolationProperty.h"
#include <mitkDICOMSegmentationPropertyHelper.cpp>
// us
#include <usGetModuleContext.h>
#include <usModuleResource.h>
// itk
#include <itkObjectFactory.h>
mitk::Tool::Tool(const char *type, const us::Module *interactorModule)
: m_EventConfig("DisplayConfigMITK.xml"),
m_ToolManager(nullptr),
m_PredicateImages(NodePredicateDataType::New("Image")), // for reference images
m_PredicateDim3(NodePredicateDimension::New(3, 1)),
m_PredicateDim4(NodePredicateDimension::New(4, 1)),
m_PredicateDimension(mitk::NodePredicateOr::New(m_PredicateDim3, m_PredicateDim4)),
m_PredicateImage3D(NodePredicateAnd::New(m_PredicateImages, m_PredicateDimension)),
m_PredicateBinary(NodePredicateProperty::New("binary", BoolProperty::New(true))),
m_PredicateNotBinary(NodePredicateNot::New(m_PredicateBinary)),
m_PredicateSegmentation(NodePredicateProperty::New("segmentation", BoolProperty::New(true))),
m_PredicateNotSegmentation(NodePredicateNot::New(m_PredicateSegmentation)),
m_PredicateHelper(NodePredicateProperty::New("helper object", BoolProperty::New(true))),
m_PredicateNotHelper(NodePredicateNot::New(m_PredicateHelper)),
m_PredicateImageColorful(NodePredicateAnd::New(m_PredicateNotBinary, m_PredicateNotSegmentation)),
m_PredicateImageColorfulNotHelper(NodePredicateAnd::New(m_PredicateImageColorful, m_PredicateNotHelper)),
m_PredicateReference(NodePredicateAnd::New(m_PredicateImage3D, m_PredicateImageColorfulNotHelper)),
m_IsSegmentationPredicate(
NodePredicateAnd::New(NodePredicateOr::New(m_PredicateBinary, m_PredicateSegmentation), m_PredicateNotHelper)),
m_InteractorType(type),
m_DisplayInteractorConfigs(),
m_InteractorModule(interactorModule)
{
}
mitk::Tool::~Tool()
{
}
bool mitk::Tool::CanHandle(const BaseData* referenceData, const BaseData* /*workingData*/) const
{
if (referenceData == nullptr)
return false;
return true;
}
void mitk::Tool::InitializeStateMachine()
{
if (m_InteractorType.empty())
return;
try
{
auto isThisModule = nullptr == m_InteractorModule;
auto module = isThisModule
? us::GetModuleContext()->GetModule()
: m_InteractorModule;
LoadStateMachine(m_InteractorType + ".xml", module);
SetEventConfig(isThisModule ? "SegmentationToolsConfig.xml" : m_InteractorType + "Config.xml", module);
}
catch (const std::exception &e)
{
MITK_ERROR << "Could not load statemachine pattern " << m_InteractorType << ".xml with exception: " << e.what();
}
}
void mitk::Tool::Notify(InteractionEvent *interactionEvent, bool isHandled)
{
// to use the state machine pattern,
// the event is passed to the state machine interface to be handled
if (!isHandled)
{
this->HandleEvent(interactionEvent, nullptr);
}
}
void mitk::Tool::ConnectActionsAndFunctions()
{
}
bool mitk::Tool::FilterEvents(InteractionEvent *, DataNode *)
{
return true;
}
const char *mitk::Tool::GetGroup() const
{
return "default";
}
void mitk::Tool::SetToolManager(ToolManager *manager)
{
m_ToolManager = manager;
}
void mitk::Tool::Activated()
{
// As a legacy solution the display interaction of the new interaction framework is disabled here to avoid conflicts
// with tools
// Note: this only affects InteractionEventObservers (formerly known as Listeners) all DataNode specific interaction
// will still be enabled
m_DisplayInteractorConfigs.clear();
std::vector<us::ServiceReference<InteractionEventObserver>> listEventObserver =
us::GetModuleContext()->GetServiceReferences<InteractionEventObserver>();
for (auto it = listEventObserver.begin(); it != listEventObserver.end(); ++it)
{
auto displayInteractor = dynamic_cast<DisplayInteractor*>(us::GetModuleContext()->GetService<InteractionEventObserver>(*it));
if (displayInteractor != nullptr)
{
// remember the original configuration
m_DisplayInteractorConfigs.insert(std::make_pair(*it, displayInteractor->GetEventConfig()));
// here the alternative configuration is loaded
displayInteractor->SetEventConfig(m_EventConfig.c_str());
}
auto displayActionEventBroadcast = dynamic_cast<DisplayActionEventBroadcast*>(us::GetModuleContext()->GetService<InteractionEventObserver>(*it));
if (displayActionEventBroadcast != nullptr)
{
// remember the original configuration
m_DisplayInteractorConfigs.insert(std::make_pair(*it, displayActionEventBroadcast->GetEventConfig()));
// here the alternative configuration is loaded
displayActionEventBroadcast->SetEventConfig(m_EventConfig.c_str());
}
}
}
void mitk::Tool::Deactivated()
{
// Re-enabling InteractionEventObservers that have been previously disabled for legacy handling of Tools
// in new interaction framework
for (auto it = m_DisplayInteractorConfigs.begin(); it != m_DisplayInteractorConfigs.end(); ++it)
{
if (it->first)
{
auto displayInteractor = static_cast<DisplayInteractor*>(us::GetModuleContext()->GetService<InteractionEventObserver>(it->first));
if (displayInteractor != nullptr)
{
// here the regular configuration is loaded again
displayInteractor->SetEventConfig(it->second);
}
auto displayActionEventBroadcast = dynamic_cast<DisplayActionEventBroadcast*>(us::GetModuleContext()->GetService<InteractionEventObserver>(it->first));
if (displayActionEventBroadcast != nullptr)
{
// here the regular configuration is loaded again
displayActionEventBroadcast->SetEventConfig(it->second);
}
}
}
m_DisplayInteractorConfigs.clear();
}
itk::Object::Pointer mitk::Tool::GetGUI(const std::string &toolkitPrefix, const std::string &toolkitPostfix)
{
itk::Object::Pointer object;
std::string classname = this->GetNameOfClass();
std::string guiClassname = toolkitPrefix + classname + toolkitPostfix;
std::list<itk::LightObject::Pointer> allGUIs = itk::ObjectFactoryBase::CreateAllInstance(guiClassname.c_str());
for (auto iter = allGUIs.begin(); iter != allGUIs.end(); ++iter)
{
if (object.IsNull())
{
object = dynamic_cast<itk::Object *>(iter->GetPointer());
}
else
{
MITK_ERROR << "There is more than one GUI for " << classname << " (several factories claim ability to produce a "
<< guiClassname << " ) " << std::endl;
return nullptr; // people should see and fix this error
}
}
return object;
}
mitk::NodePredicateBase::ConstPointer mitk::Tool::GetReferenceDataPreference() const
{
return m_PredicateReference.GetPointer();
}
mitk::NodePredicateBase::ConstPointer mitk::Tool::GetWorkingDataPreference() const
{
return m_IsSegmentationPredicate.GetPointer();
}
mitk::DataNode::Pointer mitk::Tool::CreateEmptySegmentationNode(const Image *original,
const std::string &organName,
- const mitk::Color &color)
+ const mitk::Color &color) const
{
// we NEED a reference image for size etc.
if (!original)
return nullptr;
// actually create a new empty segmentation
PixelType pixelType(mitk::MakeScalarPixelType<DefaultSegmentationDataType>());
LabelSetImage::Pointer segmentation = LabelSetImage::New();
if (original->GetDimension() == 2)
{
const unsigned int dimensions[] = {original->GetDimension(0), original->GetDimension(1), 1};
segmentation->Initialize(pixelType, 3, dimensions);
segmentation->AddLayer();
}
else
{
segmentation->Initialize(original);
}
mitk::Label::Pointer label = mitk::Label::New();
label->SetName(organName);
label->SetColor(color);
label->SetValue(1);
segmentation->GetActiveLabelSet()->AddLabel(label);
segmentation->GetActiveLabelSet()->SetActiveLabel(1);
unsigned int byteSize = sizeof(mitk::Label::PixelType);
if (segmentation->GetDimension() < 4)
{
for (unsigned int dim = 0; dim < segmentation->GetDimension(); ++dim)
{
byteSize *= segmentation->GetDimension(dim);
}
mitk::ImageWriteAccessor writeAccess(segmentation.GetPointer(), segmentation->GetVolumeData(0));
memset(writeAccess.GetData(), 0, byteSize);
}
else
{
// if we have a time-resolved image we need to set memory to 0 for each time step
for (unsigned int dim = 0; dim < 3; ++dim)
{
byteSize *= segmentation->GetDimension(dim);
}
for (unsigned int volumeNumber = 0; volumeNumber < segmentation->GetDimension(3); volumeNumber++)
{
mitk::ImageWriteAccessor writeAccess(segmentation.GetPointer(), segmentation->GetVolumeData(volumeNumber));
memset(writeAccess.GetData(), 0, byteSize);
}
}
if (original->GetTimeGeometry())
{
TimeGeometry::Pointer originalGeometry = original->GetTimeGeometry()->Clone();
segmentation->SetTimeGeometry(originalGeometry);
}
else
{
Tool::ErrorMessage("Original image does not have a 'Time sliced geometry'! Cannot create a segmentation.");
return nullptr;
}
return CreateSegmentationNode(segmentation, organName, color);
}
mitk::DataNode::Pointer mitk::Tool::CreateSegmentationNode(Image *image,
const std::string &organName,
- const mitk::Color &color)
+ const mitk::Color &color) const
{
if (!image)
return nullptr;
// decorate the datatreenode with some properties
DataNode::Pointer segmentationNode = DataNode::New();
segmentationNode->SetData(image);
// name
segmentationNode->SetProperty("name", StringProperty::New(organName));
// visualization properties
segmentationNode->SetProperty("binary", BoolProperty::New(true));
segmentationNode->SetProperty("color", ColorProperty::New(color));
mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
lut->SetType(mitk::LookupTable::MULTILABEL);
mitk::LookupTableProperty::Pointer lutProp = mitk::LookupTableProperty::New();
lutProp->SetLookupTable(lut);
segmentationNode->SetProperty("LookupTable", lutProp);
segmentationNode->SetProperty("texture interpolation", BoolProperty::New(false));
segmentationNode->SetProperty("layer", IntProperty::New(10));
segmentationNode->SetProperty("levelwindow", LevelWindowProperty::New(LevelWindow(0.5, 1)));
segmentationNode->SetProperty("opacity", FloatProperty::New(0.3));
segmentationNode->SetProperty("segmentation", BoolProperty::New(true));
segmentationNode->SetProperty("reslice interpolation",
VtkResliceInterpolationProperty::New()); // otherwise -> segmentation appears in 2
// slices sometimes (only visual effect, not
// different data)
// For MITK-3M3 release, the volume of all segmentations should be shown
segmentationNode->SetProperty("showVolume", BoolProperty::New(true));
return segmentationNode;
}
us::ModuleResource mitk::Tool::GetIconResource() const
{
// Each specific tool should load its own resource. This one will be invalid
return us::ModuleResource();
}
us::ModuleResource mitk::Tool::GetCursorIconResource() const
{
// Each specific tool should load its own resource. This one will be invalid
return us::ModuleResource();
}
diff --git a/Modules/Segmentation/Interactions/mitkTool.h b/Modules/Segmentation/Interactions/mitkTool.h
index 16b2cf15a9..ddc998b8d0 100644
--- a/Modules/Segmentation/Interactions/mitkTool.h
+++ b/Modules/Segmentation/Interactions/mitkTool.h
@@ -1,270 +1,269 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkTool_h_Included
#define mitkTool_h_Included
#include "itkObjectFactoryBase.h"
#include "itkVersion.h"
#include "mitkCommon.h"
#include "mitkDataNode.h"
#include "mitkEventStateMachine.h"
#include "mitkInteractionEventObserver.h"
#include "mitkLabelSetImage.h"
#include "mitkMessage.h"
#include "mitkNodePredicateAnd.h"
#include "mitkNodePredicateDataType.h"
#include "mitkNodePredicateDimension.h"
#include "mitkNodePredicateNot.h"
#include "mitkNodePredicateOr.h"
#include "mitkNodePredicateProperty.h"
#include "mitkToolEvents.h"
#include "mitkToolFactoryMacro.h"
#include <MitkSegmentationExports.h>
#include <mitkLabel.h>
#include <iostream>
#include <map>
#include <string>
#include <itkObject.h>
#include "usServiceRegistration.h"
namespace us
{
class ModuleResource;
}
namespace mitk
{
class ToolManager;
/**
\brief Base class of all tools used by mitk::ToolManager.
\sa ToolManager
\sa SegTool2D
\ingroup Interaction
\ingroup ToolManagerEtAl
Every tool is a mitk::StateMachine, which can follow any transition pattern that it likes. One important thing to know
is, that
every derived tool should always call SuperClass::Deactivated() at the end of its own implementation of Deactivated,
because mitk::Tool
resets the StateMachine in this method. Only if you are very sure that you covered all possible things that might
happen to your
own tool, you should consider not to reset the StateMachine from time to time.
To learn about the MITK implementation of state machines in general, have a look at \ref InteractionPage.
To derive a non-abstract tool, you inherit from mitk::Tool (or some other base class further down the inheritance
tree), and in your
own parameterless constructor (that is called from the itkFactorylessNewMacro that you use) you pass a StateMachine
pattern name to the superclass.
Names for valid patterns can be found in StateMachine.xml (which might be enhanced by you).
You have to implement at least GetXPM() and GetName() to provide some identification.
Each Tool knows its ToolManager, which can provide the data that the tool should work on.
\warning Only to be instantiated by mitk::ToolManager (because SetToolManager has to be called). All other uses are
unsupported.
$Author$
*/
class MITKSEGMENTATION_EXPORT Tool : public EventStateMachine, public InteractionEventObserver
{
public:
typedef mitk::Label::PixelType DefaultSegmentationDataType;
/**
* \brief To let GUI process new events (e.g. qApp->processEvents() )
*/
Message<> GUIProcessEventsMessage;
/**
* \brief To send error messages (to be shown by some GUI)
*/
Message1<std::string> ErrorMessage;
/**
* \brief To send whether the tool is busy (to be shown by some GUI)
*/
Message1<bool> CurrentlyBusy;
/**
* \brief To send general messages (to be shown by some GUI)
*/
Message1<std::string> GeneralMessage;
mitkClassMacro(Tool, EventStateMachine);
// no New(), there should only be subclasses
/**
\brief Returns an icon in the XPM format.
This icon has to fit into some kind of button in most applications, so make it smaller than 25x25 pixels.
XPM is e.g. supported by The Gimp. But if you open any XPM file in your text editor, you will see that you could
also "draw" it with an editor.
*/
virtual const char **GetXPM() const = 0;
/**
* \brief Returns the path of an icon.
*
* This icon is preferred to the XPM icon.
*/
virtual std::string GetIconPath() const { return ""; }
/**
* \brief Returns the path of a cursor icon.
*
*/
virtual us::ModuleResource GetCursorIconResource() const;
/**
* @brief Returns the tool button icon of the tool wrapped by a usModuleResource
* @return a valid ModuleResource or an invalid if this function
* is not reimplemented
*/
virtual us::ModuleResource GetIconResource() const;
/**
\brief Returns the name of this tool. Make it short!
This name has to fit into some kind of button in most applications, so take some time to think of a good name!
*/
virtual const char *GetName() const = 0;
/**
\brief Name of a group.
You can group several tools by assigning a group name. Graphical tool selectors might use this information to group
tools. (What other reason could there be?)
*/
virtual const char *GetGroup() const;
virtual void InitializeStateMachine();
/**
* \brief Interface for GUI creation.
*
* This is the basic interface for creation of a GUI object belonging to one tool.
*
* Tools that support a GUI (e.g. for display/editing of parameters) should follow some rules:
*
* - A Tool and its GUI are two separate classes
* - There may be several instances of a GUI at the same time.
* - mitk::Tool is toolkit (Qt, wxWidgets, etc.) independent, the GUI part is of course dependent
* - The GUI part inherits both from itk::Object and some GUI toolkit class
* - The GUI class name HAS to be constructed like "toolkitPrefix" tool->GetClassName() + "toolkitPostfix", e.g.
* MyTool -> wxMyToolGUI
* - For each supported toolkit there is a base class for tool GUIs, which contains some convenience methods
* - Tools notify the GUI about changes using ITK events. The GUI must observe interesting events.
* - The GUI base class may convert all ITK events to the GUI toolkit's favoured messaging system (Qt -> signals)
* - Calling methods of a tool by its GUI is done directly.
* In some cases GUIs don't want to be notified by the tool when they cause a change in a tool.
* There is a macro CALL_WITHOUT_NOTICE(method()), which will temporarily disable all notifications during a
* method call.
*/
virtual itk::Object::Pointer GetGUI(const std::string &toolkitPrefix, const std::string &toolkitPostfix);
virtual NodePredicateBase::ConstPointer GetReferenceDataPreference() const;
virtual NodePredicateBase::ConstPointer GetWorkingDataPreference() const;
DataNode::Pointer CreateEmptySegmentationNode(const Image *original,
const std::string &organName,
- const mitk::Color &color);
- DataNode::Pointer CreateSegmentationNode(Image *image, const std::string &organName, const mitk::Color &color);
+ const mitk::Color &color) const;
+ DataNode::Pointer CreateSegmentationNode(Image *image, const std::string &organName, const mitk::Color &color) const;
/** Function used to check if a tool can handle the referenceData and (if specified) the working data.
@pre referenceData must be a valid pointer
@param referenceData Pointer to the data that should be checked as valid reference for the tool.
@param workingData Pointer to the data that should be checked as valid working data for this tool.
This parameter can be null if no working data is specified so far.*/
virtual bool CanHandle(const BaseData *referenceData, const BaseData *workingData) const;
protected:
friend class ToolManager;
virtual void SetToolManager(ToolManager *);
void ConnectActionsAndFunctions() override;
/**
\brief Called when the tool gets activated.
Derived tools should call their parents implementation at the beginning of the overriding function.
*/
virtual void Activated();
/**
\brief Called when the tool gets deactivated.
Derived tools should call their parents implementation at the end of the overriding function.
*/
virtual void Deactivated();
/**
\brief Let subclasses change their event configuration.
*/
std::string m_EventConfig;
- Tool(); // purposely hidden
Tool(const char *, const us::Module *interactorModule = nullptr); // purposely hidden
~Tool() override;
void Notify(InteractionEvent *interactionEvent, bool isHandled) override;
bool FilterEvents(InteractionEvent *, DataNode *) override;
ToolManager *m_ToolManager;
private:
// for reference data
NodePredicateDataType::Pointer m_PredicateImages;
NodePredicateDimension::Pointer m_PredicateDim3;
NodePredicateDimension::Pointer m_PredicateDim4;
NodePredicateOr::Pointer m_PredicateDimension;
NodePredicateAnd::Pointer m_PredicateImage3D;
NodePredicateProperty::Pointer m_PredicateBinary;
NodePredicateNot::Pointer m_PredicateNotBinary;
NodePredicateProperty::Pointer m_PredicateSegmentation;
NodePredicateNot::Pointer m_PredicateNotSegmentation;
NodePredicateProperty::Pointer m_PredicateHelper;
NodePredicateNot::Pointer m_PredicateNotHelper;
NodePredicateAnd::Pointer m_PredicateImageColorful;
NodePredicateAnd::Pointer m_PredicateImageColorfulNotHelper;
NodePredicateAnd::Pointer m_PredicateReference;
// for working data
NodePredicateAnd::Pointer m_IsSegmentationPredicate;
std::string m_InteractorType;
std::map<us::ServiceReferenceU, EventConfig> m_DisplayInteractorConfigs;
const us::Module *m_InteractorModule;
};
} // namespace
#endif
diff --git a/Modules/Segmentation/files.cmake b/Modules/Segmentation/files.cmake
index 3bce31c9b5..e54cc10e02 100644
--- a/Modules/Segmentation/files.cmake
+++ b/Modules/Segmentation/files.cmake
@@ -1,118 +1,119 @@
set(CPP_FILES
Algorithms/mitkCalculateSegmentationVolume.cpp
Algorithms/mitkContourModelSetToImageFilter.cpp
Algorithms/mitkContourSetToPointSetFilter.cpp
Algorithms/mitkContourUtils.cpp
Algorithms/mitkCorrectorAlgorithm.cpp
Algorithms/mitkDiffImageApplier.cpp
Algorithms/mitkDiffSliceOperation.cpp
Algorithms/mitkDiffSliceOperationApplier.cpp
Algorithms/mitkFeatureBasedEdgeDetectionFilter.cpp
Algorithms/mitkImageLiveWireContourModelFilter.cpp
Algorithms/mitkImageToContourFilter.cpp
#Algorithms/mitkImageToContourModelFilter.cpp
Algorithms/mitkImageToLiveWireContourFilter.cpp
Algorithms/mitkManualSegmentationToSurfaceFilter.cpp
Algorithms/mitkOtsuSegmentationFilter.cpp
Algorithms/mitkOverwriteDirectedPlaneImageFilter.cpp
Algorithms/mitkOverwriteSliceImageFilter.cpp
Algorithms/mitkSegmentationObjectFactory.cpp
Algorithms/mitkShapeBasedInterpolationAlgorithm.cpp
Algorithms/mitkShowSegmentationAsSmoothedSurface.cpp
Algorithms/mitkShowSegmentationAsSurface.cpp
Algorithms/mitkVtkImageOverwrite.cpp
Controllers/mitkSegmentationInterpolationController.cpp
Controllers/mitkToolManager.cpp
Controllers/mitkSegmentationModuleActivator.cpp
Controllers/mitkToolManagerProvider.cpp
DataManagement/mitkContour.cpp
DataManagement/mitkContourSet.cpp
DataManagement/mitkExtrudedContour.cpp
Interactions/mitkAdaptiveRegionGrowingTool.cpp
Interactions/mitkAddContourTool.cpp
Interactions/mitkAutoCropTool.cpp
Interactions/mitkAutoSegmentationTool.cpp
Interactions/mitkAutoSegmentationWithPreviewTool.cpp
Interactions/mitkAutoMLSegmentationWithPreviewTool.cpp
Interactions/mitkBinaryThresholdBaseTool.cpp
Interactions/mitkBinaryThresholdTool.cpp
Interactions/mitkBinaryThresholdULTool.cpp
Interactions/mitkCalculateGrayValueStatisticsTool.cpp
Interactions/mitkCalculateVolumetryTool.cpp
Interactions/mitkContourModelInteractor.cpp
Interactions/mitkContourModelLiveWireInteractor.cpp
Interactions/mitkLiveWireTool2D.cpp
Interactions/mitkContourTool.cpp
Interactions/mitkCorrectorTool2D.cpp
Interactions/mitkCreateSurfaceTool.cpp
Interactions/mitkDrawPaintbrushTool.cpp
Interactions/mitkErasePaintbrushTool.cpp
Interactions/mitkEraseRegionTool.cpp
+ Interactions/mitkFastMarchingBaseTool.cpp
Interactions/mitkFastMarchingTool.cpp
Interactions/mitkFastMarchingTool3D.cpp
Interactions/mitkFeedbackContourTool.cpp
Interactions/mitkFillRegionTool.cpp
Interactions/mitkOtsuTool3D.cpp
Interactions/mitkPaintbrushTool.cpp
Interactions/mitkPixelManipulationTool.cpp
Interactions/mitkRegionGrowingTool.cpp
Interactions/mitkSegmentationsProcessingTool.cpp
Interactions/mitkSetRegionTool.cpp
Interactions/mitkSegTool2D.cpp
Interactions/mitkSubtractContourTool.cpp
Interactions/mitkTool.cpp
Interactions/mitkToolCommand.cpp
Interactions/mitkWatershedTool.cpp
Interactions/mitkPickingTool.cpp
Interactions/mitkSegmentationInteractor.cpp #SO
Rendering/mitkContourMapper2D.cpp
Rendering/mitkContourSetMapper2D.cpp
Rendering/mitkContourSetVtkMapper3D.cpp
Rendering/mitkContourVtkMapper3D.cpp
SegmentationUtilities/BooleanOperations/mitkBooleanOperation.cpp
SegmentationUtilities/MorphologicalOperations/mitkMorphologicalOperations.cpp
#Added from ML
Controllers/mitkSliceBasedInterpolationController.cpp
Algorithms/mitkSurfaceStampImageFilter.cpp
)
set(RESOURCE_FILES
Add_48x48.png
Add_Cursor_32x32.png
Correction_48x48.png
Correction_Cursor_32x32.png
Erase_48x48.png
Erase_Cursor_32x32.png
FastMarching_48x48.png
FastMarching_Cursor_32x32.png
Fill_48x48.png
Fill_Cursor_32x32.png
LiveWire_48x48.png
LiveWire_Cursor_32x32.png
Otsu_48x48.png
Paint_48x48.png
Paint_Cursor_32x32.png
Pick_48x48.png
RegionGrowing_48x48.png
RegionGrowing_Cursor_32x32.png
Subtract_48x48.png
Subtract_Cursor_32x32.png
Threshold_48x48.png
TwoThresholds_48x48.png
Watershed_48x48.png
Watershed_Cursor_32x32.png
Wipe_48x48.png
Wipe_Cursor_32x32.png
Interactions/dummy.xml
Interactions/LiveWireTool.xml
Interactions/FastMarchingTool.xml
Interactions/PressMoveRelease.xml
Interactions/PressMoveReleaseAndPointSetting.xml
Interactions/PressMoveReleaseWithCTRLInversion.xml
Interactions/PressMoveReleaseWithCTRLInversionAllMouseMoves.xml
Interactions/SegmentationToolsConfig.xml
Interactions/ContourModelModificationConfig.xml
Interactions/ContourModelModificationInteractor.xml
)
diff --git a/Modules/SegmentationUI/Qmitk/QmitkAutoMLSegmentationToolGUIBase.cpp b/Modules/SegmentationUI/Qmitk/QmitkAutoMLSegmentationToolGUIBase.cpp
new file mode 100644
index 0000000000..b332866f6f
--- /dev/null
+++ b/Modules/SegmentationUI/Qmitk/QmitkAutoMLSegmentationToolGUIBase.cpp
@@ -0,0 +1,95 @@
+/*============================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center (DKFZ)
+All rights reserved.
+
+Use of this source code is governed by a 3-clause BSD license that can be
+found in the LICENSE file.
+
+============================================================================*/
+
+#include "QmitkAutoMLSegmentationToolGUIBase.h"
+#include "mitkAutoMLSegmentationWithPreviewTool.h"
+
+#include <qboxlayout.h>
+
+QmitkAutoMLSegmentationToolGUIBase::QmitkAutoMLSegmentationToolGUIBase() : QmitkAutoSegmentationToolGUIBase(false)
+{
+ auto enableOtsuDelegate = [this](bool enabled)
+ {
+ bool result = enabled;
+ auto tool = this->GetConnectedToolAs<mitk::AutoMLSegmentationWithPreviewTool>();
+ if (nullptr != tool)
+ {
+ result = !tool->GetSelectedLabels().empty() && enabled;
+ }
+ else
+ {
+ result = false;
+ }
+
+ return result;
+ };
+
+ m_EnableConfirmSegBtnFnc = enableOtsuDelegate;
+}
+
+void QmitkAutoMLSegmentationToolGUIBase::ConnectNewTool(mitk::AutoSegmentationWithPreviewTool* newTool)
+{
+ Superclass::ConnectNewTool(newTool);
+ this->EnableWidgets(true);
+}
+
+void QmitkAutoMLSegmentationToolGUIBase::InitializeUI(QBoxLayout* mainLayout)
+{
+ m_LabelSelectionList = new QmitkSimpleLabelSetListWidget(this);
+ m_LabelSelectionList->setObjectName(QString::fromUtf8("m_LabelSelectionList"));
+ QSizePolicy sizePolicy2(QSizePolicy::Minimum, QSizePolicy::MinimumExpanding);
+ sizePolicy2.setHorizontalStretch(0);
+ sizePolicy2.setVerticalStretch(0);
+ sizePolicy2.setHeightForWidth(m_LabelSelectionList->sizePolicy().hasHeightForWidth());
+ m_LabelSelectionList->setSizePolicy(sizePolicy2);
+ m_LabelSelectionList->setMaximumSize(QSize(10000000, 10000000));
+
+ mainLayout->addWidget(m_LabelSelectionList);
+
+ connect(m_LabelSelectionList, &QmitkSimpleLabelSetListWidget::SelectedLabelsChanged, this, &QmitkAutoMLSegmentationToolGUIBase::OnLabelSelectionChanged);
+
+ Superclass::InitializeUI(mainLayout);
+}
+
+void QmitkAutoMLSegmentationToolGUIBase::OnLabelSelectionChanged(const QmitkSimpleLabelSetListWidget::LabelVectorType& selectedLabels)
+{
+ auto tool = this->GetConnectedToolAs<mitk::AutoMLSegmentationWithPreviewTool>();
+ if (nullptr != tool)
+ {
+ mitk::AutoMLSegmentationWithPreviewTool::SelectedLabelVectorType labelIDs;
+ for (const auto& label : selectedLabels)
+ {
+ labelIDs.push_back(label->GetValue());
+ }
+
+ tool->SetSelectedLabels(labelIDs);
+ tool->UpdatePreview();
+ this->EnableWidgets(true); //used to actualize the ConfirmSeg btn via the delegate;
+ }
+}
+
+void QmitkAutoMLSegmentationToolGUIBase::EnableWidgets(bool enabled)
+{
+ Superclass::EnableWidgets(enabled);
+ if (nullptr != m_LabelSelectionList)
+ {
+ m_LabelSelectionList->setEnabled(enabled);
+ }
+}
+
+void QmitkAutoMLSegmentationToolGUIBase::SetLabelSetPreview(const mitk::LabelSetImage* preview)
+{
+ if (nullptr != m_LabelSelectionList)
+ {
+ m_LabelSelectionList->SetLabelSetImage(preview);
+ }
+}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkAutoMLSegmentationToolGUIBase.h b/Modules/SegmentationUI/Qmitk/QmitkAutoMLSegmentationToolGUIBase.h
new file mode 100644
index 0000000000..76bf69cea8
--- /dev/null
+++ b/Modules/SegmentationUI/Qmitk/QmitkAutoMLSegmentationToolGUIBase.h
@@ -0,0 +1,53 @@
+/*============================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center (DKFZ)
+All rights reserved.
+
+Use of this source code is governed by a 3-clause BSD license that can be
+found in the LICENSE file.
+
+============================================================================*/
+
+#ifndef QmitkAutoMLSegmentationToolGUIBase_h_Included
+#define QmitkAutoMLSegmentationToolGUIBase_h_Included
+
+#include "QmitkAutoSegmentationToolGUIBase.h"
+
+#include "QmitkSimpleLabelSetListWidget.h"
+
+#include <MitkSegmentationUIExports.h>
+
+/**
+ \ingroup org_mitk_gui_qt_interactivesegmentation_internal
+ \brief GUI for tools based on mitk::AutoMLSegmentationWithPreviewTool.
+
+ This GUI offers an additional list to select the label that should be confirmed.
+*/
+class MITKSEGMENTATIONUI_EXPORT QmitkAutoMLSegmentationToolGUIBase : public QmitkAutoSegmentationToolGUIBase
+{
+ Q_OBJECT
+
+public:
+ mitkClassMacro(QmitkAutoMLSegmentationToolGUIBase, QmitkAutoSegmentationToolGUIBase);
+
+protected slots :
+
+ void OnLabelSelectionChanged(const QmitkSimpleLabelSetListWidget::LabelVectorType& selectedLabels);
+
+protected:
+ QmitkAutoMLSegmentationToolGUIBase();
+ ~QmitkAutoMLSegmentationToolGUIBase() = default;
+
+ void InitializeUI(QBoxLayout* mainLayout) override;
+ void ConnectNewTool(mitk::AutoSegmentationWithPreviewTool* newTool) override;
+
+ void EnableWidgets(bool enabled) override;
+ void SetLabelSetPreview(const mitk::LabelSetImage* preview);
+
+private:
+ QmitkSimpleLabelSetListWidget* m_LabelSelectionList = nullptr;
+};
+
+#endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkAutoSegmentationToolGUIBase.cpp b/Modules/SegmentationUI/Qmitk/QmitkAutoSegmentationToolGUIBase.cpp
new file mode 100644
index 0000000000..19e7da115e
--- /dev/null
+++ b/Modules/SegmentationUI/Qmitk/QmitkAutoSegmentationToolGUIBase.cpp
@@ -0,0 +1,155 @@
+/*============================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center (DKFZ)
+All rights reserved.
+
+Use of this source code is governed by a 3-clause BSD license that can be
+found in the LICENSE file.
+
+============================================================================*/
+
+#include "QmitkAutoSegmentationToolGUIBase.h"
+
+#include <qcheckbox.h>
+#include <qpushbutton.h>
+#include <qboxlayout.h>
+#include <qlabel.h>
+#include <QApplication>
+
+bool DefaultEnableConfirmSegBtnFunction(bool enabled)
+{
+ return enabled;
+}
+
+QmitkAutoSegmentationToolGUIBase::QmitkAutoSegmentationToolGUIBase(bool mode2D) : QmitkToolGUI(), m_EnableConfirmSegBtnFnc(DefaultEnableConfirmSegBtnFunction), m_Mode2D(mode2D)
+{
+ connect(this, SIGNAL(NewToolAssociated(mitk::Tool *)), this, SLOT(OnNewToolAssociated(mitk::Tool *)));
+}
+
+QmitkAutoSegmentationToolGUIBase::~QmitkAutoSegmentationToolGUIBase()
+{
+ if (m_Tool.IsNotNull())
+ {
+ m_Tool->CurrentlyBusy -= mitk::MessageDelegate1<QmitkAutoSegmentationToolGUIBase, bool>(this, &QmitkAutoSegmentationToolGUIBase::BusyStateChanged);
+ }
+}
+
+void QmitkAutoSegmentationToolGUIBase::OnNewToolAssociated(mitk::Tool *tool)
+{
+ if (m_Tool.IsNotNull())
+ {
+ this->DisconnectOldTool(m_Tool);
+ }
+
+ m_Tool = dynamic_cast<mitk::AutoSegmentationWithPreviewTool*>(tool);
+
+ if (nullptr == m_MainLayout)
+ {
+ // create the visible widgets
+ m_MainLayout = new QVBoxLayout(this);
+ m_ConfirmSegBtn = new QPushButton("Confirm Segmentation", this);
+ connect(m_ConfirmSegBtn, SIGNAL(clicked()), this, SLOT(OnAcceptPreview()));
+
+ m_CheckProcessAll = new QCheckBox("Process all time steps", this);
+ m_CheckProcessAll->setChecked(false);
+ m_CheckProcessAll->setToolTip("Process all time steps of the dynamic segmentation and not just the currently visible time step.");
+ m_CheckProcessAll->setVisible(!m_Mode2D);
+ //remark: keept m_CheckProcessAll deactivated in 2D because in this refactoring
+ //it should be kept to the status quo and it was not clear how interpolation
+ //would behave. As soon as it is sorted out we can remove that "feature switch"
+ //or the comment.
+
+ m_CheckCreateNew = new QCheckBox("Create as new segmentation", this);
+ m_CheckCreateNew->setChecked(false);
+ m_CheckCreateNew->setToolTip("Add the confirmed segmentation as a new segmentation instead of overwriting the currently selected.");
+ m_CheckCreateNew->setVisible(!m_Mode2D);
+ //remark: keept m_CheckCreateNew deactivated in 2D because in this refactoring
+ //it should be kept to the status quo and it was not clear how interpolation
+ //would behave. As soon as it is sorted out we can remove that "feature switch"
+ //or the comment.
+
+ this->InitializeUI(m_MainLayout);
+
+ m_MainLayout->addWidget(m_ConfirmSegBtn);
+ m_MainLayout->addWidget(m_CheckProcessAll);
+ m_MainLayout->addWidget(m_CheckCreateNew);
+ }
+
+ if (m_Tool.IsNotNull())
+ {
+ this->ConnectNewTool(m_Tool);
+ }
+}
+
+void QmitkAutoSegmentationToolGUIBase::OnAcceptPreview()
+{
+ if (m_Tool.IsNotNull())
+ {
+ if (m_CheckCreateNew->isChecked())
+ {
+ m_Tool->SetOverwriteExistingSegmentation(false);
+ }
+ else
+ {
+ m_Tool->SetOverwriteExistingSegmentation(true);
+ }
+
+ m_Tool->SetCreateAllTimeSteps(m_CheckProcessAll->isChecked());
+
+ m_ConfirmSegBtn->setEnabled(false);
+ m_Tool->ConfirmSegmentation();
+ }
+}
+
+void QmitkAutoSegmentationToolGUIBase::DisconnectOldTool(mitk::AutoSegmentationWithPreviewTool* oldTool)
+{
+ oldTool->CurrentlyBusy -= mitk::MessageDelegate1<QmitkAutoSegmentationToolGUIBase, bool>(this, &QmitkAutoSegmentationToolGUIBase::BusyStateChanged);
+}
+
+void QmitkAutoSegmentationToolGUIBase::ConnectNewTool(mitk::AutoSegmentationWithPreviewTool* newTool)
+{
+ newTool->CurrentlyBusy +=
+ mitk::MessageDelegate1<QmitkAutoSegmentationToolGUIBase, bool>(this, &QmitkAutoSegmentationToolGUIBase::BusyStateChanged);
+
+ newTool->SetOverwriteExistingSegmentation(true);
+ m_CheckProcessAll->setVisible(newTool->GetTargetSegmentationNode()->GetData()->GetTimeSteps() > 1);
+}
+
+void QmitkAutoSegmentationToolGUIBase::InitializeUI(QBoxLayout* /*mainLayout*/)
+{
+ //default implementation does nothing
+}
+
+void QmitkAutoSegmentationToolGUIBase::BusyStateChanged(bool isBusy)
+{
+ if (isBusy)
+ {
+ QApplication::setOverrideCursor(QCursor(Qt::BusyCursor));
+ }
+ else
+ {
+ QApplication::restoreOverrideCursor();
+ }
+ this->EnableWidgets(!isBusy);
+ }
+
+void QmitkAutoSegmentationToolGUIBase::EnableWidgets(bool enabled)
+{
+ if (nullptr != m_MainLayout)
+ {
+ if (nullptr != m_ConfirmSegBtn)
+ {
+ m_ConfirmSegBtn->setEnabled(m_EnableConfirmSegBtnFnc(enabled));
+ }
+ if (nullptr != m_CheckProcessAll)
+ {
+ m_CheckProcessAll->setEnabled(enabled);
+ }
+ if (nullptr != m_CheckCreateNew)
+ {
+ m_CheckCreateNew->setEnabled(enabled);
+ }
+ }
+}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkAutoSegmentationToolGUIBase.h b/Modules/SegmentationUI/Qmitk/QmitkAutoSegmentationToolGUIBase.h
new file mode 100644
index 0000000000..6501a2e1b5
--- /dev/null
+++ b/Modules/SegmentationUI/Qmitk/QmitkAutoSegmentationToolGUIBase.h
@@ -0,0 +1,81 @@
+/*============================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center (DKFZ)
+All rights reserved.
+
+Use of this source code is governed by a 3-clause BSD license that can be
+found in the LICENSE file.
+
+============================================================================*/
+
+#ifndef QmitkAutoSegmentationToolGUIBase_h_Included
+#define QmitkAutoSegmentationToolGUIBase_h_Included
+
+#include "QmitkToolGUI.h"
+
+#include "mitkAutoSegmentationWithPreviewTool.h"
+
+#include <MitkSegmentationUIExports.h>
+
+class QCheckBox;
+class QPushButton;
+class QBoxLayout;
+
+/**
+ \ingroup org_mitk_gui_qt_interactivesegmentation_internal
+ \brief GUI base clase for tools derived from mitk::AutoSegmentationTool.
+*/
+class MITKSEGMENTATIONUI_EXPORT QmitkAutoSegmentationToolGUIBase : public QmitkToolGUI
+{
+ Q_OBJECT
+
+public:
+ mitkClassMacro(QmitkAutoSegmentationToolGUIBase, QmitkToolGUI);
+ itkCloneMacro(Self);
+
+ itkGetConstMacro(Mode2D, bool);
+
+protected slots:
+
+ void OnNewToolAssociated(mitk::Tool *);
+
+ void OnAcceptPreview();
+
+protected:
+ QmitkAutoSegmentationToolGUIBase(bool mode2D);
+ ~QmitkAutoSegmentationToolGUIBase() override;
+
+ virtual void DisconnectOldTool(mitk::AutoSegmentationWithPreviewTool* oldTool);
+ virtual void ConnectNewTool(mitk::AutoSegmentationWithPreviewTool* newTool);
+ virtual void InitializeUI(QBoxLayout* mainLayout);
+
+ void BusyStateChanged(bool isBusy) override;
+
+ using EnableConfirmSegBtnFunctionType = std::function<bool(bool)>;
+ EnableConfirmSegBtnFunctionType m_EnableConfirmSegBtnFnc;
+
+ virtual void EnableWidgets(bool enabled);
+
+ template <class TTool>
+ TTool* GetConnectedToolAs()
+ {
+ return dynamic_cast<TTool*>(m_Tool.GetPointer());
+ };
+
+
+
+private:
+ QCheckBox* m_CheckProcessAll = nullptr;
+ QCheckBox* m_CheckCreateNew = nullptr;
+ QPushButton* m_ConfirmSegBtn = nullptr;
+ QBoxLayout* m_MainLayout = nullptr;
+
+ /**Indicates if the tool is in 2D or 3D mode.*/
+ bool m_Mode2D;
+
+ mitk::AutoSegmentationWithPreviewTool::Pointer m_Tool;
+};
+
+#endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUI.cpp b/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUI.cpp
index 7c720d4a58..fc1cdf2592 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUI.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUI.cpp
@@ -1,168 +1,31 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkBinaryThresholdToolGUI.h"
#include <qlabel.h>
#include <qlayout.h>
#include <qpushbutton.h>
#include <qslider.h>
#include <QApplication>
MITK_TOOL_GUI_MACRO(MITKSEGMENTATIONUI_EXPORT, QmitkBinaryThresholdToolGUI, "")
QmitkBinaryThresholdToolGUI::QmitkBinaryThresholdToolGUI()
- : QmitkToolGUI()
+ : QmitkBinaryThresholdToolGUIBase(false)
{
- // create the visible widgets
- QBoxLayout *mainLayout = new QVBoxLayout(this);
-
- QLabel *label = new QLabel("Threshold :", this);
- QFont f = label->font();
- f.setBold(false);
- label->setFont(f);
- mainLayout->addWidget(label);
-
- QBoxLayout *layout = new QHBoxLayout();
-
- m_ThresholdSlider = new ctkSliderWidget();
- connect(
- m_ThresholdSlider, SIGNAL(valueChanged(double)), this, SLOT(OnSliderValueChanged(double)));
- layout->addWidget(m_ThresholdSlider);
- mainLayout->addLayout(layout);
- m_ThresholdSlider->setSingleStep(0.01);
-
- QPushButton *okButton = new QPushButton("Confirm Segmentation", this);
- connect(okButton, SIGNAL(clicked()), this, SLOT(OnAcceptThresholdPreview()));
- okButton->setFont(f);
- mainLayout->addWidget(okButton);
-
- m_CheckProcessAll = new QCheckBox("Process all time steps", this);
- m_CheckProcessAll->setChecked(false);
- m_CheckProcessAll->setToolTip("Process/overwrite all time steps of the dynamic segmentation and not just the currently visible time step.");
-
- mainLayout->addWidget(m_CheckProcessAll);
-
- m_CheckCreateNew = new QCheckBox("Create as new segmentation", this);
- m_CheckCreateNew->setChecked(false);
- m_CheckCreateNew->setToolTip("Add the confirmed segmentation as a new segmentation instead of overwriting the currently selected.");
- mainLayout->addWidget(m_CheckCreateNew);
-
- connect(this, SIGNAL(NewToolAssociated(mitk::Tool *)), this, SLOT(OnNewToolAssociated(mitk::Tool *)));
}
QmitkBinaryThresholdToolGUI::~QmitkBinaryThresholdToolGUI()
{
- if (m_BinaryThresholdTool.IsNotNull())
- {
- m_BinaryThresholdTool->CurrentlyBusy -=
- mitk::MessageDelegate1<QmitkBinaryThresholdToolGUI, bool>(this, &QmitkBinaryThresholdToolGUI::BusyStateChanged);
- m_BinaryThresholdTool->IntervalBordersChanged -=
- mitk::MessageDelegate3<QmitkBinaryThresholdToolGUI, double, double, bool>(
- this, &QmitkBinaryThresholdToolGUI::OnThresholdingIntervalBordersChanged);
- m_BinaryThresholdTool->ThresholdingValuesChanged -= mitk::MessageDelegate2<QmitkBinaryThresholdToolGUI, mitk::ScalarType, mitk::ScalarType>(
- this, &QmitkBinaryThresholdToolGUI::OnThresholdingValuesChanged);
- }
}
-void QmitkBinaryThresholdToolGUI::OnNewToolAssociated(mitk::Tool *tool)
-{
- if (m_BinaryThresholdTool.IsNotNull())
- {
- m_BinaryThresholdTool->CurrentlyBusy -=
- mitk::MessageDelegate1<QmitkBinaryThresholdToolGUI, bool>(this, &QmitkBinaryThresholdToolGUI::BusyStateChanged);
- m_BinaryThresholdTool->IntervalBordersChanged -=
- mitk::MessageDelegate3<QmitkBinaryThresholdToolGUI, double, double, bool>(
- this, &QmitkBinaryThresholdToolGUI::OnThresholdingIntervalBordersChanged);
- m_BinaryThresholdTool->ThresholdingValuesChanged -= mitk::MessageDelegate2<QmitkBinaryThresholdToolGUI, mitk::ScalarType, mitk::ScalarType>(
- this, &QmitkBinaryThresholdToolGUI::OnThresholdingValuesChanged);
- }
-
- m_BinaryThresholdTool = dynamic_cast<mitk::BinaryThresholdTool *>(tool);
-
- if (m_BinaryThresholdTool.IsNotNull())
- {
- m_BinaryThresholdTool->CurrentlyBusy +=
- mitk::MessageDelegate1<QmitkBinaryThresholdToolGUI, bool>(this, &QmitkBinaryThresholdToolGUI::BusyStateChanged);
- m_BinaryThresholdTool->IntervalBordersChanged +=
- mitk::MessageDelegate3<QmitkBinaryThresholdToolGUI, double, double, bool>(
- this, &QmitkBinaryThresholdToolGUI::OnThresholdingIntervalBordersChanged);
- m_BinaryThresholdTool->ThresholdingValuesChanged += mitk::MessageDelegate2<QmitkBinaryThresholdToolGUI, mitk::ScalarType, mitk::ScalarType>(
- this, &QmitkBinaryThresholdToolGUI::OnThresholdingValuesChanged);
-
- m_BinaryThresholdTool->SetOverwriteExistingSegmentation(true);
- m_CheckProcessAll->setVisible(m_BinaryThresholdTool->GetTargetSegmentationNode()->GetData()->GetTimeSteps()>1);
- }
-}
-
-void QmitkBinaryThresholdToolGUI::OnAcceptThresholdPreview()
-{
- if (m_BinaryThresholdTool.IsNotNull())
- {
- if (m_CheckCreateNew->isChecked())
- {
- m_BinaryThresholdTool->SetOverwriteExistingSegmentation(false);
- }
- else
- {
- m_BinaryThresholdTool->SetOverwriteExistingSegmentation(true);
- }
-
- m_BinaryThresholdTool->SetCreateAllTimeSteps(m_CheckProcessAll->isChecked());
-
- this->thresholdAccepted();
- m_BinaryThresholdTool->ConfirmSegmentation();
- }
-}
-
-void QmitkBinaryThresholdToolGUI::OnThresholdingIntervalBordersChanged(double lower, double upper, bool isFloat)
-{
- m_InternalUpdate = true;
- if (!isFloat)
- {
- m_ThresholdSlider->setRange(int(lower), int(upper));
- m_ThresholdSlider->setSingleStep(1);
- m_ThresholdSlider->setDecimals(0);
- }
- else
- {
- m_ThresholdSlider->setRange(lower, upper);
- }
- m_InternalUpdate = false;
-}
-
-void QmitkBinaryThresholdToolGUI::OnThresholdingValuesChanged(mitk::ScalarType lower, mitk::ScalarType /*upper*/)
-{
- m_ThresholdSlider->setValue(lower);
-}
-
-void QmitkBinaryThresholdToolGUI::OnSliderValueChanged(double value)
-{
- if (m_BinaryThresholdTool.IsNotNull() && !m_InternalUpdate)
- {
- m_BinaryThresholdTool->SetThresholdValue(value);
- }
-}
-
-void QmitkBinaryThresholdToolGUI::BusyStateChanged(bool value)
-{
- if (value)
- {
- QApplication::setOverrideCursor(QCursor(Qt::BusyCursor));
- }
- else
- {
- QApplication::restoreOverrideCursor();
- }
-
- m_ThresholdSlider->setEnabled(!value);
-}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUI.h b/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUI.h
index 5696c1ff98..e62d8fc8fc 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUI.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUI.h
@@ -1,80 +1,50 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkBinaryThresholdToolGUI_h_Included
#define QmitkBinaryThresholdToolGUI_h_Included
-#include "QmitkToolGUI.h"
+#include "QmitkBinaryThresholdToolGUIBase.h"
#include "mitkBinaryThresholdTool.h"
#include <MitkSegmentationUIExports.h>
#include "ctkSliderWidget.h"
#include <qcheckbox.h>
/**
\ingroup org_mitk_gui_qt_interactivesegmentation_internal
\brief GUI for mitk::BinaryThresholdTool.
This GUI shows a slider to change the tool's threshold and an OK button to accept a preview for actual thresholding.
There is only a slider for INT values in QT. So, if the working image has a float/double pixeltype, we need to convert
the original float intensity into a respective int value for the slider. The slider range is then between 0 and 99.
If the pixeltype is INT, then we do not need any conversion.
Last contributor: $Author$
*/
-class MITKSEGMENTATIONUI_EXPORT QmitkBinaryThresholdToolGUI : public QmitkToolGUI
+class MITKSEGMENTATIONUI_EXPORT QmitkBinaryThresholdToolGUI : public QmitkBinaryThresholdToolGUIBase
{
Q_OBJECT
public:
- mitkClassMacro(QmitkBinaryThresholdToolGUI, QmitkToolGUI);
+ mitkClassMacro(QmitkBinaryThresholdToolGUI, QmitkBinaryThresholdToolGUIBase);
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
- void OnThresholdingIntervalBordersChanged(double lower, double upper, bool isFloat);
- void OnThresholdingValuesChanged(mitk::ScalarType lower, mitk::ScalarType upper);
-
-signals:
-
- /// \brief Emitted when threshold Accepted
- void thresholdAccepted();
-
- /// \brief Emitted when threshold Canceled
- void thresholdCanceled();
-
-public slots:
-
-protected slots:
-
- void OnNewToolAssociated(mitk::Tool *);
- void OnAcceptThresholdPreview();
-
- void OnSliderValueChanged(double value);
-
protected:
QmitkBinaryThresholdToolGUI();
~QmitkBinaryThresholdToolGUI() override;
-
- void BusyStateChanged(bool) override;
-
- ctkSliderWidget* m_ThresholdSlider = nullptr;
- QCheckBox* m_CheckProcessAll = nullptr;
- QCheckBox* m_CheckCreateNew = nullptr;
-
- bool m_InternalUpdate = false;
-
- mitk::BinaryThresholdTool::Pointer m_BinaryThresholdTool;
};
#endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUIBase.cpp b/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUIBase.cpp
new file mode 100644
index 0000000000..930eacadb7
--- /dev/null
+++ b/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUIBase.cpp
@@ -0,0 +1,187 @@
+/*============================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center (DKFZ)
+All rights reserved.
+
+Use of this source code is governed by a 3-clause BSD license that can be
+found in the LICENSE file.
+
+============================================================================*/
+
+#include "QmitkBinaryThresholdToolGUIBase.h"
+
+#include "mitkBinaryThresholdBaseTool.h"
+#include "mitkBinaryThresholdTool.h"
+
+#include <qlabel.h>
+#include <qlayout.h>
+#include <qslider.h>
+#include <QApplication>
+
+QmitkBinaryThresholdToolGUIBase::QmitkBinaryThresholdToolGUIBase(bool ulMode) : QmitkAutoSegmentationToolGUIBase(false), m_ULMode(ulMode)
+{
+}
+
+QmitkBinaryThresholdToolGUIBase::~QmitkBinaryThresholdToolGUIBase()
+{
+ auto tool = this->GetConnectedToolAs<mitk::BinaryThresholdBaseTool>();
+
+ if (nullptr != tool)
+ {
+ tool->IntervalBordersChanged -=
+ mitk::MessageDelegate3<QmitkBinaryThresholdToolGUIBase, double, double, bool>(
+ this, &QmitkBinaryThresholdToolGUIBase::OnThresholdingIntervalBordersChanged);
+ tool->ThresholdingValuesChanged -=
+ mitk::MessageDelegate2<QmitkBinaryThresholdToolGUIBase, mitk::ScalarType, mitk::ScalarType>(
+ this, &QmitkBinaryThresholdToolGUIBase::OnThresholdingValuesChanged);
+ }
+}
+
+void QmitkBinaryThresholdToolGUIBase::OnThresholdingIntervalBordersChanged(double lower, double upper, bool isFloat)
+{
+ m_InternalUpdate = true;
+
+ if (m_ULMode)
+ {
+ if (!isFloat)
+ {
+ m_ThresholdRange->setRange(int(lower), int(upper));
+ m_ThresholdRange->setSingleStep(1);
+ m_ThresholdRange->setDecimals(0);
+ }
+ else
+ {
+ m_ThresholdRange->setRange(lower, upper);
+ }
+ }
+ else
+ {
+ if (!isFloat)
+ {
+ m_ThresholdSlider->setRange(int(lower), int(upper));
+ m_ThresholdSlider->setSingleStep(1);
+ m_ThresholdSlider->setDecimals(0);
+ }
+ else
+ {
+ m_ThresholdSlider->setRange(lower, upper);
+ }
+ }
+
+ m_InternalUpdate = false;
+}
+
+void QmitkBinaryThresholdToolGUIBase::OnThresholdingValuesChanged(mitk::ScalarType lower, mitk::ScalarType upper)
+{
+ if (m_ULMode)
+ {
+ m_ThresholdRange->setValues(lower, upper);
+ }
+ else
+ {
+ m_ThresholdSlider->setValue(lower);
+ }
+}
+
+void QmitkBinaryThresholdToolGUIBase::OnThresholdRangeChanged(double min, double max)
+{
+ auto tool = this->GetConnectedToolAs<mitk::BinaryThresholdBaseTool>();
+
+ if (nullptr != tool && !m_InternalUpdate)
+ {
+ tool->SetThresholdValues(min, max);
+ }
+}
+
+void QmitkBinaryThresholdToolGUIBase::OnThresholdSliderChanged(double value)
+{
+ auto tool = this->GetConnectedToolAs<mitk::BinaryThresholdTool>();
+
+ if (nullptr != tool && !m_InternalUpdate)
+ {
+ tool->SetThresholdValue(value);
+ }
+}
+
+void QmitkBinaryThresholdToolGUIBase::DisconnectOldTool(mitk::AutoSegmentationWithPreviewTool* oldTool)
+{
+ Superclass::DisconnectOldTool(oldTool);
+
+ auto tool = dynamic_cast<mitk::BinaryThresholdBaseTool*>(oldTool);
+
+ if (nullptr != tool)
+ {
+ tool->IntervalBordersChanged -=
+ mitk::MessageDelegate3<QmitkBinaryThresholdToolGUIBase, double, double, bool>(
+ this, &QmitkBinaryThresholdToolGUIBase::OnThresholdingIntervalBordersChanged);
+ tool->ThresholdingValuesChanged -=
+ mitk::MessageDelegate2<QmitkBinaryThresholdToolGUIBase, mitk::ScalarType, mitk::ScalarType>(
+ this, &QmitkBinaryThresholdToolGUIBase::OnThresholdingValuesChanged);
+ }
+}
+
+void QmitkBinaryThresholdToolGUIBase::ConnectNewTool(mitk::AutoSegmentationWithPreviewTool* newTool)
+{
+ Superclass::ConnectNewTool(newTool);
+
+ auto tool = dynamic_cast<mitk::BinaryThresholdBaseTool*>(newTool);
+
+ if (nullptr != tool)
+ {
+ tool->IntervalBordersChanged +=
+ mitk::MessageDelegate3<QmitkBinaryThresholdToolGUIBase, double, double, bool>(
+ this, &QmitkBinaryThresholdToolGUIBase::OnThresholdingIntervalBordersChanged);
+ tool->ThresholdingValuesChanged +=
+ mitk::MessageDelegate2<QmitkBinaryThresholdToolGUIBase, mitk::ScalarType, mitk::ScalarType>(
+ this, &QmitkBinaryThresholdToolGUIBase::OnThresholdingValuesChanged);
+ }
+}
+
+void QmitkBinaryThresholdToolGUIBase::InitializeUI(QBoxLayout* mainLayout)
+{
+ QLabel* label = new QLabel("Threshold :", this);
+ QFont f = label->font();
+ f.setBold(false);
+ label->setFont(f);
+ mainLayout->addWidget(label);
+
+ QBoxLayout* layout = new QHBoxLayout();
+
+ if (m_ULMode)
+ {
+ m_ThresholdRange = new ctkRangeWidget();
+ connect(
+ m_ThresholdRange, SIGNAL(valuesChanged(double, double)), this, SLOT(OnThresholdRangeChanged(double, double)));
+ layout->addWidget(m_ThresholdRange);
+ m_ThresholdRange->setSingleStep(0.01);
+ }
+ else
+ {
+ m_ThresholdSlider = new ctkSliderWidget();
+ connect(
+ m_ThresholdSlider, SIGNAL(valueChanged(double)), this, SLOT(OnThresholdSliderChanged(double)));
+ layout->addWidget(m_ThresholdSlider);
+ m_ThresholdSlider->setSingleStep(0.01);
+ }
+
+ mainLayout->addLayout(layout);
+
+ Superclass::InitializeUI(mainLayout);
+}
+
+void QmitkBinaryThresholdToolGUIBase::BusyStateChanged(bool value)
+{
+ Superclass::BusyStateChanged(value);
+
+ if (m_ThresholdRange)
+ {
+ m_ThresholdRange->setEnabled(!value);
+ }
+
+ if (m_ThresholdSlider)
+ {
+ m_ThresholdSlider->setEnabled(!value);
+ }
+}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUIBase.h b/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUIBase.h
new file mode 100644
index 0000000000..47f25dd544
--- /dev/null
+++ b/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUIBase.h
@@ -0,0 +1,63 @@
+/*============================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center (DKFZ)
+All rights reserved.
+
+Use of this source code is governed by a 3-clause BSD license that can be
+found in the LICENSE file.
+
+============================================================================*/
+
+#ifndef QmitkBinaryThresholdToolGUIBase_h_Included
+#define QmitkBinaryThresholdToolGUIBase_h_Included
+
+#include "QmitkAutoSegmentationToolGUIBase.h"
+#include "ctkRangeWidget.h"
+#include "ctkSliderWidget.h"
+
+#include <MitkSegmentationUIExports.h>
+
+/**
+ \ingroup org_mitk_gui_qt_interactivesegmentation_internal
+ \brief Base GUI for mitk::BinaryThresholdTool.
+
+ This GUI shows a slider to change the tool's threshold and an OK button to accept a preview for actual thresholding.
+*/
+class MITKSEGMENTATIONUI_EXPORT QmitkBinaryThresholdToolGUIBase : public QmitkAutoSegmentationToolGUIBase
+{
+ Q_OBJECT
+
+public:
+ mitkClassMacro(QmitkBinaryThresholdToolGUIBase, QmitkAutoSegmentationToolGUIBase);
+
+ void OnThresholdingIntervalBordersChanged(double lower, double upper, bool isFloat);
+ void OnThresholdingValuesChanged(mitk::ScalarType lower, mitk::ScalarType upper);
+
+protected slots:
+
+ void OnThresholdRangeChanged(double min, double max);
+ void OnThresholdSliderChanged(double value);
+
+protected:
+ QmitkBinaryThresholdToolGUIBase(bool ulMode);
+ ~QmitkBinaryThresholdToolGUIBase() override;
+
+ void DisconnectOldTool(mitk::AutoSegmentationWithPreviewTool* oldTool) override;
+ void ConnectNewTool(mitk::AutoSegmentationWithPreviewTool* newTool) override;
+ void InitializeUI(QBoxLayout* mainLayout) override;
+
+ void BusyStateChanged(bool) override;
+
+ ctkRangeWidget* m_ThresholdRange = nullptr;
+ ctkSliderWidget* m_ThresholdSlider = nullptr;
+
+ /** Indicates if the tool UI is used for a tool with upper an lower threshold (true)
+ ore only with one threshold (false)*/
+ bool m_ULMode;
+
+ bool m_InternalUpdate = false;
+};
+
+#endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdULToolGUI.cpp b/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdULToolGUI.cpp
index 5954acff4c..1eab27a6fb 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdULToolGUI.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdULToolGUI.cpp
@@ -1,163 +1,30 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkBinaryThresholdULToolGUI.h"
#include <qlabel.h>
#include <qlayout.h>
#include <qpushbutton.h>
#include <qslider.h>
#include <QApplication>
MITK_TOOL_GUI_MACRO(MITKSEGMENTATIONUI_EXPORT, QmitkBinaryThresholdULToolGUI, "")
-QmitkBinaryThresholdULToolGUI::QmitkBinaryThresholdULToolGUI() : QmitkToolGUI()
+QmitkBinaryThresholdULToolGUI::QmitkBinaryThresholdULToolGUI() : QmitkBinaryThresholdToolGUIBase(true)
{
- // create the visible widgets
- QBoxLayout *mainLayout = new QVBoxLayout(this);
-
- QLabel *label = new QLabel("Threshold :", this);
- QFont f = label->font();
- f.setBold(false);
- label->setFont(f);
- mainLayout->addWidget(label);
-
- QBoxLayout *layout = new QHBoxLayout();
-
- m_DoubleThresholdSlider = new ctkRangeWidget();
- connect(
- m_DoubleThresholdSlider, SIGNAL(valuesChanged(double, double)), this, SLOT(OnThresholdsChanged(double, double)));
- layout->addWidget(m_DoubleThresholdSlider);
- mainLayout->addLayout(layout);
- m_DoubleThresholdSlider->setSingleStep(0.01);
-
- QPushButton *okButton = new QPushButton("Confirm Segmentation", this);
- connect(okButton, SIGNAL(clicked()), this, SLOT(OnAcceptThresholdPreview()));
- okButton->setFont(f);
- mainLayout->addWidget(okButton);
-
- m_CheckProcessAll = new QCheckBox("Process all time steps", this);
- m_CheckProcessAll->setChecked(false);
- m_CheckProcessAll->setToolTip("Process/overwrite all time steps of the dynamic segmentation and not just the currently visible time step.");
- mainLayout->addWidget(m_CheckProcessAll);
-
- m_CheckCreateNew = new QCheckBox("Create as new segmentation", this);
- m_CheckCreateNew->setChecked(false);
- m_CheckCreateNew->setToolTip("Add the confirmed segmentation as a new segmentation instead of overwriting the currently selected.");
- mainLayout->addWidget(m_CheckCreateNew);
-
- connect(this, SIGNAL(NewToolAssociated(mitk::Tool *)), this, SLOT(OnNewToolAssociated(mitk::Tool *)));
}
QmitkBinaryThresholdULToolGUI::~QmitkBinaryThresholdULToolGUI()
{
- if (m_BinaryThresholdULTool.IsNotNull())
- {
- m_BinaryThresholdULTool->CurrentlyBusy -=
- mitk::MessageDelegate1<QmitkBinaryThresholdULToolGUI, bool>(this, &QmitkBinaryThresholdULToolGUI::BusyStateChanged);
- m_BinaryThresholdULTool->IntervalBordersChanged -=
- mitk::MessageDelegate3<QmitkBinaryThresholdULToolGUI, double, double, bool>(
- this, &QmitkBinaryThresholdULToolGUI::OnThresholdingIntervalBordersChanged);
- m_BinaryThresholdULTool->ThresholdingValuesChanged -=
- mitk::MessageDelegate2<QmitkBinaryThresholdULToolGUI, mitk::ScalarType, mitk::ScalarType>(
- this, &QmitkBinaryThresholdULToolGUI::OnThresholdingValuesChanged);
- }
-}
-
-void QmitkBinaryThresholdULToolGUI::OnNewToolAssociated(mitk::Tool *tool)
-{
- if (m_BinaryThresholdULTool.IsNotNull())
- {
- m_BinaryThresholdULTool->CurrentlyBusy -=
- mitk::MessageDelegate1<QmitkBinaryThresholdULToolGUI, bool>(this, &QmitkBinaryThresholdULToolGUI::BusyStateChanged);
- m_BinaryThresholdULTool->IntervalBordersChanged -=
- mitk::MessageDelegate3<QmitkBinaryThresholdULToolGUI, double, double, bool>(
- this, &QmitkBinaryThresholdULToolGUI::OnThresholdingIntervalBordersChanged);
- m_BinaryThresholdULTool->ThresholdingValuesChanged -=
- mitk::MessageDelegate2<QmitkBinaryThresholdULToolGUI, mitk::ScalarType, mitk::ScalarType>(
- this, &QmitkBinaryThresholdULToolGUI::OnThresholdingValuesChanged);
- }
-
- m_BinaryThresholdULTool = dynamic_cast<mitk::BinaryThresholdULTool *>(tool);
-
- if (m_BinaryThresholdULTool.IsNotNull())
- {
- m_BinaryThresholdULTool->CurrentlyBusy +=
- mitk::MessageDelegate1<QmitkBinaryThresholdULToolGUI, bool>(this, &QmitkBinaryThresholdULToolGUI::BusyStateChanged);
- m_BinaryThresholdULTool->IntervalBordersChanged +=
- mitk::MessageDelegate3<QmitkBinaryThresholdULToolGUI, double, double, bool>(
- this, &QmitkBinaryThresholdULToolGUI::OnThresholdingIntervalBordersChanged);
- m_BinaryThresholdULTool->ThresholdingValuesChanged +=
- mitk::MessageDelegate2<QmitkBinaryThresholdULToolGUI, mitk::ScalarType, mitk::ScalarType>(
- this, &QmitkBinaryThresholdULToolGUI::OnThresholdingValuesChanged);
-
- m_BinaryThresholdULTool->SetOverwriteExistingSegmentation(true);
- m_CheckProcessAll->setVisible(m_BinaryThresholdULTool->GetTargetSegmentationNode()->GetData()->GetTimeSteps() > 1);
- }
-}
-
-void QmitkBinaryThresholdULToolGUI::OnAcceptThresholdPreview()
-{
- if (m_BinaryThresholdULTool.IsNotNull())
- {
- if (m_CheckCreateNew->isChecked())
- {
- m_BinaryThresholdULTool->SetOverwriteExistingSegmentation(false);
- }
- else
- {
- m_BinaryThresholdULTool->SetOverwriteExistingSegmentation(true);
- }
-
- m_BinaryThresholdULTool->SetCreateAllTimeSteps(m_CheckProcessAll->isChecked());
-
- m_BinaryThresholdULTool->ConfirmSegmentation();
- }
-}
-
-void QmitkBinaryThresholdULToolGUI::OnThresholdingIntervalBordersChanged(double lower, double upper, bool isFloat)
-{
- if (!isFloat)
- {
- m_DoubleThresholdSlider->setRange(int(lower), int(upper));
- m_DoubleThresholdSlider->setSingleStep(1);
- m_DoubleThresholdSlider->setDecimals(0);
- }
- else
- {
- m_DoubleThresholdSlider->setRange(lower, upper);
- }
}
-void QmitkBinaryThresholdULToolGUI::OnThresholdingValuesChanged(mitk::ScalarType lower, mitk::ScalarType upper)
-{
- m_DoubleThresholdSlider->setValues(lower, upper);
-}
-
-void QmitkBinaryThresholdULToolGUI::OnThresholdsChanged(double min, double max)
-{
- m_BinaryThresholdULTool->SetThresholdValues(min, max);
-}
-
-void QmitkBinaryThresholdULToolGUI::BusyStateChanged(bool value)
-{
- if (value)
- {
- QApplication::setOverrideCursor(QCursor(Qt::BusyCursor));
- }
- else
- {
- QApplication::restoreOverrideCursor();
- }
-
- m_DoubleThresholdSlider->setEnabled(!value);
-}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdULToolGUI.h b/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdULToolGUI.h
index ec0c130821..b903df1e58 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdULToolGUI.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdULToolGUI.h
@@ -1,68 +1,42 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkBinaryThresholdULToolGUI_h_Included
#define QmitkBinaryThresholdULToolGUI_h_Included
-#include "QmitkToolGUI.h"
-#include "ctkRangeWidget.h"
-#include <qcheckbox.h>
-#include "mitkBinaryThresholdULTool.h"
+#include "QmitkBinaryThresholdToolGUIBase.h"
#include <MitkSegmentationUIExports.h>
/**
\ingroup org_mitk_gui_qt_interactivesegmentation_internal
\brief GUI for mitk::BinaryThresholdTool.
This GUI shows a slider to change the tool's threshold and an OK button to accept a preview for actual thresholding.
Last contributor: $Author$
*/
-class MITKSEGMENTATIONUI_EXPORT QmitkBinaryThresholdULToolGUI : public QmitkToolGUI
+class MITKSEGMENTATIONUI_EXPORT QmitkBinaryThresholdULToolGUI : public QmitkBinaryThresholdToolGUIBase
{
Q_OBJECT
public:
- mitkClassMacro(QmitkBinaryThresholdULToolGUI, QmitkToolGUI);
+ mitkClassMacro(QmitkBinaryThresholdULToolGUI, QmitkBinaryThresholdToolGUIBase);
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
- void OnThresholdingIntervalBordersChanged(double lower, double upper, bool isFloat);
- void OnThresholdingValuesChanged(mitk::ScalarType lower, mitk::ScalarType upper);
-
-signals:
-
-public slots:
-
-protected slots:
-
- void OnNewToolAssociated(mitk::Tool *);
-
- void OnAcceptThresholdPreview();
-
- void OnThresholdsChanged(double min, double max);
-
protected:
QmitkBinaryThresholdULToolGUI();
~QmitkBinaryThresholdULToolGUI() override;
-
- void BusyStateChanged(bool) override;
-
- ctkRangeWidget *m_DoubleThresholdSlider;
- QCheckBox* m_CheckProcessAll = nullptr;
- QCheckBox* m_CheckCreateNew = nullptr;
-
- mitk::BinaryThresholdULTool::Pointer m_BinaryThresholdULTool;
};
#endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkFastMarchingTool3DGUI.cpp b/Modules/SegmentationUI/Qmitk/QmitkFastMarchingTool3DGUI.cpp
index b83f50a5eb..165cd8bde0 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkFastMarchingTool3DGUI.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkFastMarchingTool3DGUI.cpp
@@ -1,361 +1,20 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkFastMarchingTool3DGUI.h"
-#include "QmitkConfirmSegmentationDialog.h"
-
-#include "mitkBaseRenderer.h"
-#include "mitkStepper.h"
-#include <QApplication>
-#include <QGroupBox>
-#include <QMessageBox>
-#include <ctkRangeWidget.h>
-#include <ctkSliderWidget.h>
-#include <qlabel.h>
-#include <qlayout.h>
-#include <qpushbutton.h>
-#include <qcheckbox.h>
-
MITK_TOOL_GUI_MACRO(MITKSEGMENTATIONUI_EXPORT, QmitkFastMarchingTool3DGUI, "")
-QmitkFastMarchingTool3DGUI::QmitkFastMarchingTool3DGUI() : QmitkToolGUI()
-{
- this->setContentsMargins(0, 0, 0, 0);
-
- // create the visible widgets
- QVBoxLayout *widgetLayout = new QVBoxLayout(this);
- widgetLayout->setContentsMargins(0, 0, 0, 0);
-
- QFont fntHelp;
- fntHelp.setBold(true);
-
- QLabel *lblHelp = new QLabel(this);
- lblHelp->setText("Press shift-click to add seeds repeatedly.");
- lblHelp->setFont(fntHelp);
-
- widgetLayout->addWidget(lblHelp);
-
- // Sigma controls
- {
- QHBoxLayout *hlayout = new QHBoxLayout();
- hlayout->setSpacing(2);
-
- QLabel *lbl = new QLabel(this);
- lbl->setText("Sigma: ");
- hlayout->addWidget(lbl);
-
- QSpacerItem *sp2 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
- hlayout->addItem(sp2);
-
- widgetLayout->addItem(hlayout);
- }
-
- m_slSigma = new ctkSliderWidget(this);
- m_slSigma->setMinimum(0.1);
- m_slSigma->setMaximum(5.0);
- m_slSigma->setPageStep(0.1);
- m_slSigma->setSingleStep(0.01);
- m_slSigma->setValue(1.0);
- m_slSigma->setTracking(false);
- m_slSigma->setToolTip("The \"sigma\" parameter in the Gradient Magnitude filter.");
- connect(m_slSigma, SIGNAL(valueChanged(double)), this, SLOT(OnSigmaChanged(double)));
- widgetLayout->addWidget(m_slSigma);
-
- // Alpha controls
- {
- QHBoxLayout *hlayout = new QHBoxLayout();
- hlayout->setSpacing(2);
-
- QLabel *lbl = new QLabel(this);
- lbl->setText("Alpha: ");
- hlayout->addWidget(lbl);
-
- QSpacerItem *sp2 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
- hlayout->addItem(sp2);
-
- widgetLayout->addItem(hlayout);
- }
-
- m_slAlpha = new ctkSliderWidget(this);
- m_slAlpha->setMinimum(-10);
- m_slAlpha->setMaximum(0);
- m_slAlpha->setPageStep(0.1);
- m_slAlpha->setSingleStep(0.01);
- m_slAlpha->setValue(-2.5);
- m_slAlpha->setTracking(false);
- m_slAlpha->setToolTip("The \"alpha\" parameter in the Sigmoid mapping filter.");
- connect(m_slAlpha, SIGNAL(valueChanged(double)), this, SLOT(OnAlphaChanged(double)));
- widgetLayout->addWidget(m_slAlpha);
-
- // Beta controls
- {
- QHBoxLayout *hlayout = new QHBoxLayout();
- hlayout->setSpacing(2);
-
- QLabel *lbl = new QLabel(this);
- lbl->setText("Beta: ");
- hlayout->addWidget(lbl);
-
- QSpacerItem *sp2 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
- hlayout->addItem(sp2);
-
- widgetLayout->addLayout(hlayout);
- }
-
- m_slBeta = new ctkSliderWidget(this);
- m_slBeta->setMinimum(0);
- m_slBeta->setMaximum(100);
- m_slBeta->setPageStep(0.1);
- m_slBeta->setSingleStep(0.01);
- m_slBeta->setValue(3.5);
- m_slBeta->setTracking(false);
- m_slBeta->setToolTip("The \"beta\" parameter in the Sigmoid mapping filter.");
- connect(m_slBeta, SIGNAL(valueChanged(double)), this, SLOT(OnBetaChanged(double)));
- widgetLayout->addWidget(m_slBeta);
-
- // stopping value controls
- {
- QHBoxLayout *hlayout = new QHBoxLayout();
- hlayout->setSpacing(2);
-
- QLabel *lbl = new QLabel(this);
- lbl->setText("Stopping value: ");
- hlayout->addWidget(lbl);
-
- QSpacerItem *sp2 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
- hlayout->addItem(sp2);
-
- widgetLayout->addLayout(hlayout);
- }
-
- m_slStoppingValue = new ctkSliderWidget(this);
- m_slStoppingValue->setMinimum(0);
- m_slStoppingValue->setMaximum(10000);
- m_slStoppingValue->setPageStep(10);
- m_slStoppingValue->setSingleStep(1);
- m_slStoppingValue->setValue(2000);
- m_slStoppingValue->setDecimals(0);
- m_slStoppingValue->setTracking(false);
- m_slStoppingValue->setToolTip("The \"stopping value\" parameter in the fast marching 3D algorithm");
- connect(m_slStoppingValue, SIGNAL(valueChanged(double)), this, SLOT(OnStoppingValueChanged(double)));
- widgetLayout->addWidget(m_slStoppingValue);
-
- // threshold controls
- {
- QHBoxLayout *hlayout = new QHBoxLayout();
- hlayout->setSpacing(2);
-
- QLabel *lbl = new QLabel(this);
- lbl->setText("Threshold: ");
- hlayout->addWidget(lbl);
-
- QSpacerItem *sp2 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
- hlayout->addItem(sp2);
-
- widgetLayout->addLayout(hlayout);
- }
-
- m_slwThreshold = new ctkRangeWidget(this);
- m_slwThreshold->setMinimum(-100);
- m_slwThreshold->setMaximum(5000);
- m_slwThreshold->setMinimumValue(-100);
- m_slwThreshold->setMaximumValue(2000);
- m_slwThreshold->setDecimals(0);
- m_slwThreshold->setTracking(false);
- m_slwThreshold->setToolTip("The lower and upper thresholds for the final thresholding");
- connect(m_slwThreshold, SIGNAL(valuesChanged(double, double)), this, SLOT(OnThresholdChanged(double, double)));
- widgetLayout->addWidget(m_slwThreshold);
-
- m_btClearSeeds = new QPushButton("Clear");
- m_btClearSeeds->setToolTip("Clear current result and start over again");
- m_btClearSeeds->setEnabled(false);
- widgetLayout->addWidget(m_btClearSeeds);
- connect(m_btClearSeeds, SIGNAL(clicked()), this, SLOT(OnClearSeeds()));
-
- m_btConfirm = new QPushButton("Confirm Segmentation");
- m_btConfirm->setToolTip("Incorporate current result in your working session.");
- m_btConfirm->setEnabled(false);
- widgetLayout->addWidget(m_btConfirm);
- connect(m_btConfirm, SIGNAL(clicked()), this, SLOT(OnConfirmSegmentation()));
-
- m_CheckProcessAll = new QCheckBox("Process all time steps", this);
- m_CheckProcessAll->setChecked(false);
- m_CheckProcessAll->setToolTip("Process/overwrite all time steps of the dynamic segmentation and not just the currently visible time step.");
- widgetLayout->addWidget(m_CheckProcessAll);
-
- m_CheckCreateNew = new QCheckBox("Create as new segmentation", this);
- m_CheckCreateNew->setChecked(false);
- m_CheckCreateNew->setToolTip("Add the confirmed segmentation as a new segmentation instead of overwriting the currently selected.");
- widgetLayout->addWidget(m_CheckCreateNew);
-
- connect(this, SIGNAL(NewToolAssociated(mitk::Tool *)), this, SLOT(OnNewToolAssociated(mitk::Tool *)));
-
- m_slSigma->setDecimals(2);
- m_slBeta->setDecimals(2);
- m_slAlpha->setDecimals(2);
-
- this->EnableWidgets(false);
-}
-
-QmitkFastMarchingTool3DGUI::~QmitkFastMarchingTool3DGUI()
-{
- if (m_FastMarchingTool.IsNotNull())
- {
- m_FastMarchingTool->CurrentlyBusy -=
- mitk::MessageDelegate1<QmitkFastMarchingTool3DGUI, bool>(this, &QmitkFastMarchingTool3DGUI::BusyStateChanged);
- }
-}
-
-void QmitkFastMarchingTool3DGUI::OnNewToolAssociated(mitk::Tool *tool)
-{
- if (m_FastMarchingTool.IsNotNull())
- {
- m_FastMarchingTool->CurrentlyBusy -=
- mitk::MessageDelegate1<QmitkFastMarchingTool3DGUI, bool>(this, &QmitkFastMarchingTool3DGUI::BusyStateChanged);
- }
-
- m_FastMarchingTool = dynamic_cast<mitk::FastMarchingTool3D *>(tool);
-
- if (m_FastMarchingTool.IsNotNull())
- {
- m_FastMarchingTool->CurrentlyBusy +=
- mitk::MessageDelegate1<QmitkFastMarchingTool3DGUI, bool>(this, &QmitkFastMarchingTool3DGUI::BusyStateChanged);
-
- m_FastMarchingTool->SetLowerThreshold(m_slwThreshold->minimumValue());
- m_FastMarchingTool->SetUpperThreshold(m_slwThreshold->maximumValue());
- m_FastMarchingTool->SetStoppingValue(m_slStoppingValue->value());
- m_FastMarchingTool->SetSigma(m_slSigma->value());
- m_FastMarchingTool->SetAlpha(m_slAlpha->value());
- m_FastMarchingTool->SetBeta(m_slBeta->value());
- m_FastMarchingTool->SetOverwriteExistingSegmentation(true);
- m_FastMarchingTool->ClearSeeds();
- m_CheckProcessAll->setVisible(m_FastMarchingTool->GetTargetSegmentationNode()->GetData()->GetTimeSteps() > 1);
- }
-}
-
-void QmitkFastMarchingTool3DGUI::Update()
-{
- if (m_FastMarchingTool.IsNotNull())
- {
- m_FastMarchingTool->SetLowerThreshold(m_slwThreshold->minimumValue());
- m_FastMarchingTool->SetUpperThreshold(m_slwThreshold->maximumValue());
- m_FastMarchingTool->SetStoppingValue(m_slStoppingValue->value());
- m_FastMarchingTool->SetSigma(m_slSigma->value());
- m_FastMarchingTool->SetAlpha(m_slAlpha->value());
- m_FastMarchingTool->SetBeta(m_slBeta->value());
- m_FastMarchingTool->UpdatePreview();
- }
-}
-
-void QmitkFastMarchingTool3DGUI::OnThresholdChanged(double lower, double upper)
-{
- if (m_FastMarchingTool.IsNotNull())
- {
- m_FastMarchingTool->SetLowerThreshold(lower);
- m_FastMarchingTool->SetUpperThreshold(upper);
- this->Update();
- }
-}
-
-void QmitkFastMarchingTool3DGUI::OnBetaChanged(double value)
-{
- if (m_FastMarchingTool.IsNotNull())
- {
- m_FastMarchingTool->SetBeta(value);
- this->Update();
- }
-}
-
-void QmitkFastMarchingTool3DGUI::OnSigmaChanged(double value)
+QmitkFastMarchingTool3DGUI::QmitkFastMarchingTool3DGUI() : QmitkFastMarchingToolGUIBase(false)
{
- if (m_FastMarchingTool.IsNotNull())
- {
- m_FastMarchingTool->SetSigma(value);
- this->Update();
- }
}
-void QmitkFastMarchingTool3DGUI::OnAlphaChanged(double value)
-{
- if (m_FastMarchingTool.IsNotNull())
- {
- m_FastMarchingTool->SetAlpha(value);
- this->Update();
- }
-}
-
-void QmitkFastMarchingTool3DGUI::OnStoppingValueChanged(double value)
-{
- if (m_FastMarchingTool.IsNotNull())
- {
- m_FastMarchingTool->SetStoppingValue(value);
- this->Update();
- }
-}
-
-void QmitkFastMarchingTool3DGUI::OnConfirmSegmentation()
-{
- if (m_FastMarchingTool.IsNotNull())
- {
- if (m_CheckCreateNew->isChecked())
- {
- m_FastMarchingTool->SetOverwriteExistingSegmentation(false);
- }
- else
- {
- m_FastMarchingTool->SetOverwriteExistingSegmentation(true);
- }
-
- m_FastMarchingTool->SetCreateAllTimeSteps(m_CheckProcessAll->isChecked());
-
- m_btConfirm->setEnabled(false);
- m_FastMarchingTool->ConfirmSegmentation();
- }
-}
-
-void QmitkFastMarchingTool3DGUI::OnClearSeeds()
-{
- // event from image navigator recieved - timestep has changed
- m_FastMarchingTool->ClearSeeds();
- m_btClearSeeds->setEnabled(false);
- m_btConfirm->setEnabled(false);
- this->EnableWidgets(false);
- this->Update();
-}
-
-void QmitkFastMarchingTool3DGUI::BusyStateChanged(bool value)
-{
- if (value)
- {
- QApplication::setOverrideCursor(QCursor(Qt::BusyCursor));
- this->EnableWidgets(false);
- }
- else
- {
- QApplication::restoreOverrideCursor();
- this->EnableWidgets(true);
- }
-}
-
-void QmitkFastMarchingTool3DGUI::EnableWidgets(bool enable)
-{
- m_slSigma->setEnabled(enable);
- m_slAlpha->setEnabled(enable);
- m_slBeta->setEnabled(enable);
- m_slStoppingValue->setEnabled(enable);
- m_slwThreshold->setEnabled(enable);
- m_btClearSeeds->setEnabled(enable);
- m_btConfirm->setEnabled(enable);
- m_CheckCreateNew->setEnabled(enable);
- m_CheckProcessAll->setEnabled(enable);
-}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkFastMarchingTool3DGUI.h b/Modules/SegmentationUI/Qmitk/QmitkFastMarchingTool3DGUI.h
index a02b18de12..42f2c60ecb 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkFastMarchingTool3DGUI.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkFastMarchingTool3DGUI.h
@@ -1,79 +1,38 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkFastMarchingTool3DGUI_h_Included
#define QmitkFastMarchingTool3DGUI_h_Included
-#include "QmitkToolGUI.h"
-#include "mitkFastMarchingTool3D.h"
+#include "QmitkFastMarchingToolGUIBase.h"
#include <MitkSegmentationUIExports.h>
-class ctkSliderWidget;
-class ctkRangeWidget;
-class QPushButton;
-class QCheckBox;
-
/**
\ingroup org_mitk_gui_qt_interactivesegmentation_internal
-\brief GUI for mitk::FastMarchingTool.
+\brief GUI for mitk::FastMarchingTool3D.
\sa mitk::FastMarchingTool
*/
-class MITKSEGMENTATIONUI_EXPORT QmitkFastMarchingTool3DGUI : public QmitkToolGUI
+class MITKSEGMENTATIONUI_EXPORT QmitkFastMarchingTool3DGUI : public QmitkFastMarchingToolGUIBase
{
Q_OBJECT
public:
- mitkClassMacro(QmitkFastMarchingTool3DGUI, QmitkToolGUI);
+ mitkClassMacro(QmitkFastMarchingTool3DGUI, QmitkFastMarchingToolGUIBase);
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
- void OnThresholdChanged(int current);
-
-protected slots:
-
- void OnNewToolAssociated(mitk::Tool *);
-
- void OnThresholdChanged(double, double);
- void OnAlphaChanged(double);
- void OnBetaChanged(double);
- void OnSigmaChanged(double);
- void OnStoppingValueChanged(double);
- void OnConfirmSegmentation();
- void OnClearSeeds();
-
protected:
QmitkFastMarchingTool3DGUI();
- ~QmitkFastMarchingTool3DGUI() override;
-
- void BusyStateChanged(bool) override;
-
- void Update();
-
- ctkRangeWidget *m_slwThreshold;
- ctkSliderWidget *m_slStoppingValue;
- ctkSliderWidget *m_slSigma;
- ctkSliderWidget *m_slAlpha;
- ctkSliderWidget *m_slBeta;
-
- QPushButton *m_btConfirm;
- QPushButton *m_btClearSeeds;
-
- QCheckBox* m_CheckProcessAll = nullptr;
- QCheckBox* m_CheckCreateNew = nullptr;
-
- mitk::FastMarchingTool3D::Pointer m_FastMarchingTool;
-
-private:
- void EnableWidgets(bool);
+ ~QmitkFastMarchingTool3DGUI() = default;
};
#endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkFastMarchingToolGUI.cpp b/Modules/SegmentationUI/Qmitk/QmitkFastMarchingToolGUI.cpp
index f02ff0523b..08670906f7 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkFastMarchingToolGUI.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkFastMarchingToolGUI.cpp
@@ -1,350 +1,31 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkFastMarchingToolGUI.h"
#include "QmitkNewSegmentationDialog.h"
#include "mitkBaseRenderer.h"
#include "mitkStepper.h"
#include <QApplication>
#include <QGroupBox>
#include <QMessageBox>
#include <ctkRangeWidget.h>
#include <ctkSliderWidget.h>
#include <qlabel.h>
#include <qlayout.h>
#include <qpushbutton.h>
MITK_TOOL_GUI_MACRO(MITKSEGMENTATIONUI_EXPORT, QmitkFastMarchingToolGUI, "")
-QmitkFastMarchingToolGUI::QmitkFastMarchingToolGUI() : QmitkToolGUI(), m_TimeIsConnected(false)
-{
- this->setContentsMargins(0, 0, 0, 0);
-
- // create the visible widgets
- QVBoxLayout *widgetLayout = new QVBoxLayout(this);
- widgetLayout->setContentsMargins(0, 0, 0, 0);
-
- QFont fntHelp;
- fntHelp.setBold(true);
-
- QLabel *lblHelp = new QLabel(this);
- lblHelp->setText("Press shift-click to add seeds repeatedly.");
- lblHelp->setFont(fntHelp);
-
- widgetLayout->addWidget(lblHelp);
-
- // Sigma controls
- {
- QHBoxLayout *hlayout = new QHBoxLayout();
- hlayout->setSpacing(2);
-
- QLabel *lbl = new QLabel(this);
- lbl->setText("Sigma: ");
- hlayout->addWidget(lbl);
-
- QSpacerItem *sp2 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
- hlayout->addItem(sp2);
-
- widgetLayout->addItem(hlayout);
- }
-
- m_slSigma = new ctkSliderWidget(this);
- m_slSigma->setMinimum(0.1);
- m_slSigma->setMaximum(5.0);
- m_slSigma->setPageStep(0.1);
- m_slSigma->setSingleStep(0.01);
- m_slSigma->setValue(1.0);
- m_slSigma->setTracking(false);
- m_slSigma->setToolTip("The \"sigma\" parameter in the Gradient Magnitude filter.");
- connect(m_slSigma, SIGNAL(valueChanged(double)), this, SLOT(OnSigmaChanged(double)));
- widgetLayout->addWidget(m_slSigma);
-
- // Alpha controls
- {
- QHBoxLayout *hlayout = new QHBoxLayout();
- hlayout->setSpacing(2);
-
- QLabel *lbl = new QLabel(this);
- lbl->setText("Alpha: ");
- hlayout->addWidget(lbl);
-
- QSpacerItem *sp2 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
- hlayout->addItem(sp2);
-
- widgetLayout->addItem(hlayout);
- }
-
- m_slAlpha = new ctkSliderWidget(this);
- m_slAlpha->setMinimum(-10);
- m_slAlpha->setMaximum(0);
- m_slAlpha->setPageStep(0.1);
- m_slAlpha->setSingleStep(0.01);
- m_slAlpha->setValue(-2.5);
- m_slAlpha->setTracking(false);
- m_slAlpha->setToolTip("The \"alpha\" parameter in the Sigmoid mapping filter.");
- connect(m_slAlpha, SIGNAL(valueChanged(double)), this, SLOT(OnAlphaChanged(double)));
- widgetLayout->addWidget(m_slAlpha);
-
- // Beta controls
- {
- QHBoxLayout *hlayout = new QHBoxLayout();
- hlayout->setSpacing(2);
-
- QLabel *lbl = new QLabel(this);
- lbl->setText("Beta: ");
- hlayout->addWidget(lbl);
-
- QSpacerItem *sp2 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
- hlayout->addItem(sp2);
-
- widgetLayout->addLayout(hlayout);
- }
-
- m_slBeta = new ctkSliderWidget(this);
- m_slBeta->setMinimum(0);
- m_slBeta->setMaximum(100);
- m_slBeta->setPageStep(0.1);
- m_slBeta->setSingleStep(0.01);
- m_slBeta->setValue(3.5);
- m_slBeta->setTracking(false);
- m_slBeta->setToolTip("The \"beta\" parameter in the Sigmoid mapping filter.");
- connect(m_slBeta, SIGNAL(valueChanged(double)), this, SLOT(OnBetaChanged(double)));
- widgetLayout->addWidget(m_slBeta);
-
- // stopping value controls
- {
- QHBoxLayout *hlayout = new QHBoxLayout();
- hlayout->setSpacing(2);
-
- QLabel *lbl = new QLabel(this);
- lbl->setText("Stopping value: ");
- hlayout->addWidget(lbl);
-
- QSpacerItem *sp2 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
- hlayout->addItem(sp2);
-
- widgetLayout->addLayout(hlayout);
- }
-
- m_slStoppingValue = new ctkSliderWidget(this);
- m_slStoppingValue->setMinimum(0);
- m_slStoppingValue->setMaximum(10000);
- m_slStoppingValue->setPageStep(10);
- m_slStoppingValue->setSingleStep(1);
- m_slStoppingValue->setValue(2000);
- m_slStoppingValue->setDecimals(0);
- m_slStoppingValue->setTracking(false);
- m_slStoppingValue->setToolTip("The \"stopping value\" parameter in the fast marching 3D algorithm");
- connect(m_slStoppingValue, SIGNAL(valueChanged(double)), this, SLOT(OnStoppingValueChanged(double)));
- widgetLayout->addWidget(m_slStoppingValue);
-
- // threshold controls
- {
- QHBoxLayout *hlayout = new QHBoxLayout();
- hlayout->setSpacing(2);
-
- QLabel *lbl = new QLabel(this);
- lbl->setText("Threshold: ");
- hlayout->addWidget(lbl);
-
- QSpacerItem *sp2 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
- hlayout->addItem(sp2);
-
- widgetLayout->addLayout(hlayout);
- }
-
- m_slwThreshold = new ctkRangeWidget(this);
- m_slwThreshold->setMinimum(-100);
- m_slwThreshold->setMaximum(5000);
- m_slwThreshold->setMinimumValue(-100);
- m_slwThreshold->setMaximumValue(2000);
- m_slwThreshold->setDecimals(0);
- m_slwThreshold->setTracking(false);
- m_slwThreshold->setToolTip("The lower and upper thresholds for the final thresholding");
- connect(m_slwThreshold, SIGNAL(valuesChanged(double, double)), this, SLOT(OnThresholdChanged(double, double)));
- widgetLayout->addWidget(m_slwThreshold);
-
- m_btClearSeeds = new QPushButton("Clear");
- m_btClearSeeds->setToolTip("Clear current result and start over again");
- m_btClearSeeds->setEnabled(false);
- widgetLayout->addWidget(m_btClearSeeds);
- connect(m_btClearSeeds, SIGNAL(clicked()), this, SLOT(OnClearSeeds()));
-
- m_btConfirm = new QPushButton("Confirm Segmentation");
- m_btConfirm->setToolTip("Incorporate current result in your working session.");
- m_btConfirm->setEnabled(false);
- widgetLayout->addWidget(m_btConfirm);
- connect(m_btConfirm, SIGNAL(clicked()), this, SLOT(OnConfirmSegmentation()));
-
- connect(this, SIGNAL(NewToolAssociated(mitk::Tool *)), this, SLOT(OnNewToolAssociated(mitk::Tool *)));
-
- m_slAlpha->setDecimals(2);
- m_slSigma->setDecimals(2);
- m_slBeta->setDecimals(2);
-
- this->EnableWidgets(false);
-}
-
-QmitkFastMarchingToolGUI::~QmitkFastMarchingToolGUI()
-{
- if (m_FastMarchingTool.IsNotNull())
- {
- m_FastMarchingTool->CurrentlyBusy -=
- mitk::MessageDelegate1<QmitkFastMarchingToolGUI, bool>(this, &QmitkFastMarchingToolGUI::BusyStateChanged);
- m_FastMarchingTool->RemoveReadyListener(
- mitk::MessageDelegate<QmitkFastMarchingToolGUI>(this, &QmitkFastMarchingToolGUI::OnFastMarchingToolReady));
- }
-}
-
-void QmitkFastMarchingToolGUI::OnNewToolAssociated(mitk::Tool *tool)
-{
- if (m_FastMarchingTool.IsNotNull())
- {
- m_FastMarchingTool->CurrentlyBusy -=
- mitk::MessageDelegate1<QmitkFastMarchingToolGUI, bool>(this, &QmitkFastMarchingToolGUI::BusyStateChanged);
- m_FastMarchingTool->RemoveReadyListener(
- mitk::MessageDelegate<QmitkFastMarchingToolGUI>(this, &QmitkFastMarchingToolGUI::OnFastMarchingToolReady));
- }
-
- m_FastMarchingTool = dynamic_cast<mitk::FastMarchingTool *>(tool);
-
- if (m_FastMarchingTool.IsNotNull())
- {
- m_FastMarchingTool->CurrentlyBusy +=
- mitk::MessageDelegate1<QmitkFastMarchingToolGUI, bool>(this, &QmitkFastMarchingToolGUI::BusyStateChanged);
- m_FastMarchingTool->AddReadyListener(
- mitk::MessageDelegate<QmitkFastMarchingToolGUI>(this, &QmitkFastMarchingToolGUI::OnFastMarchingToolReady));
-
- // listen to timestep change events
- mitk::BaseRenderer::Pointer renderer;
- renderer = mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget0"));
- if (renderer.IsNotNull() && !m_TimeIsConnected)
- {
- new QmitkStepperAdapter(this, renderer->GetSliceNavigationController()->GetTime(), "stepper");
- // connect(m_TimeStepper, SIGNAL(Refetch()), this, SLOT(Refetch()));
- m_TimeIsConnected = true;
- }
- }
-}
-
-void QmitkFastMarchingToolGUI::Update()
-{
- m_FastMarchingTool->SetLowerThreshold(this->m_slwThreshold->minimumValue());
- m_FastMarchingTool->SetUpperThreshold(this->m_slwThreshold->maximumValue());
- m_FastMarchingTool->SetStoppingValue(this->m_slStoppingValue->value());
- m_FastMarchingTool->SetSigma(this->m_slSigma->value());
- m_FastMarchingTool->SetAlpha(this->m_slAlpha->value());
- m_FastMarchingTool->SetBeta(this->m_slBeta->value());
- m_FastMarchingTool->Update();
-}
-
-void QmitkFastMarchingToolGUI::OnThresholdChanged(double lower, double upper)
-{
- if (m_FastMarchingTool.IsNotNull())
- {
- m_FastMarchingTool->SetLowerThreshold(lower);
- m_FastMarchingTool->SetUpperThreshold(upper);
- this->Update();
- }
-}
-
-void QmitkFastMarchingToolGUI::OnBetaChanged(double value)
-{
- if (m_FastMarchingTool.IsNotNull())
- {
- m_FastMarchingTool->SetBeta(value);
- this->Update();
- }
-}
-
-void QmitkFastMarchingToolGUI::OnSigmaChanged(double value)
-{
- if (m_FastMarchingTool.IsNotNull())
- {
- m_FastMarchingTool->SetSigma(value);
- this->Update();
- }
-}
-
-void QmitkFastMarchingToolGUI::OnAlphaChanged(double value)
-{
- if (m_FastMarchingTool.IsNotNull())
- {
- m_FastMarchingTool->SetAlpha(value);
- this->Update();
- }
-}
-
-void QmitkFastMarchingToolGUI::OnStoppingValueChanged(double value)
-{
- if (m_FastMarchingTool.IsNotNull())
- {
- m_FastMarchingTool->SetStoppingValue(value);
- this->Update();
- }
-}
-
-void QmitkFastMarchingToolGUI::OnConfirmSegmentation()
-{
- if (m_FastMarchingTool.IsNotNull())
- {
- m_btConfirm->setEnabled(false);
- m_FastMarchingTool->ConfirmSegmentation();
- }
-}
-
-void QmitkFastMarchingToolGUI::SetStepper(mitk::Stepper *stepper)
-{
- this->m_TimeStepper = stepper;
-}
-
-void QmitkFastMarchingToolGUI::Refetch()
-{
- // event from image navigator recieved - timestep has changed
- m_FastMarchingTool->SetCurrentTimeStep(m_TimeStepper->GetPos());
-}
-
-void QmitkFastMarchingToolGUI::OnClearSeeds()
-{
- // event from image navigator recieved - timestep has changed
- m_FastMarchingTool->ClearSeeds();
- m_btClearSeeds->setEnabled(false);
- m_btConfirm->setEnabled(false);
- this->EnableWidgets(false);
- this->Update();
-}
-
-void QmitkFastMarchingToolGUI::BusyStateChanged(bool value)
-{
- if (value)
- QApplication::setOverrideCursor(QCursor(Qt::BusyCursor));
- else
- QApplication::restoreOverrideCursor();
-}
-
-void QmitkFastMarchingToolGUI::OnFastMarchingToolReady()
-{
- this->EnableWidgets(true);
- this->m_btClearSeeds->setEnabled(true);
- this->m_btConfirm->setEnabled(true);
-}
-
-void QmitkFastMarchingToolGUI::EnableWidgets(bool enable)
-{
- m_slSigma->setEnabled(enable);
- m_slAlpha->setEnabled(enable);
- m_slBeta->setEnabled(enable);
- m_slStoppingValue->setEnabled(enable);
- m_slwThreshold->setEnabled(enable);
-}
+QmitkFastMarchingToolGUI::QmitkFastMarchingToolGUI() : QmitkFastMarchingToolGUIBase(true)
+{}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkFastMarchingToolGUI.h b/Modules/SegmentationUI/Qmitk/QmitkFastMarchingToolGUI.h
index 6d1ede7b3d..72340f6114 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkFastMarchingToolGUI.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkFastMarchingToolGUI.h
@@ -1,84 +1,38 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkFastMarchingToolGUI_h_Included
#define QmitkFastMarchingToolGUI_h_Included
-#include "QmitkToolGUI.h"
-#include "mitkFastMarchingTool.h"
+#include "QmitkFastMarchingToolGUIBase.h"
#include <MitkSegmentationUIExports.h>
-class ctkSliderWidget;
-class ctkRangeWidget;
-class QPushButton;
-
-#include "QmitkStepperAdapter.h"
-
/**
\ingroup org_mitk_gui_qt_interactivesegmentation_internal
-\brief GUI for mitk::FastMarchingTool.
+\brief GUI for mitk::FastMarchingTool in 2D.
\sa mitk::FastMarchingTool
*/
-class MITKSEGMENTATIONUI_EXPORT QmitkFastMarchingToolGUI : public QmitkToolGUI
+class MITKSEGMENTATIONUI_EXPORT QmitkFastMarchingToolGUI : public QmitkFastMarchingToolGUIBase
{
Q_OBJECT
public:
- mitkClassMacro(QmitkFastMarchingToolGUI, QmitkToolGUI);
+ mitkClassMacro(QmitkFastMarchingToolGUI, QmitkFastMarchingToolGUIBase);
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
- void OnThresholdChanged(int current);
-
-protected slots:
-
- void OnNewToolAssociated(mitk::Tool *);
-
- void OnThresholdChanged(double, double);
- void OnAlphaChanged(double);
- void OnBetaChanged(double);
- void OnSigmaChanged(double);
- void OnStoppingValueChanged(double);
- void OnConfirmSegmentation();
- void Refetch();
- void SetStepper(mitk::Stepper *);
- void OnClearSeeds();
-
protected:
QmitkFastMarchingToolGUI();
- ~QmitkFastMarchingToolGUI() override;
-
- void Update();
-
- void BusyStateChanged(bool) override;
-
- ctkRangeWidget *m_slwThreshold;
- ctkSliderWidget *m_slStoppingValue;
- ctkSliderWidget *m_slSigma;
- ctkSliderWidget *m_slAlpha;
- ctkSliderWidget *m_slBeta;
-
- QPushButton *m_btConfirm;
- QPushButton *m_btClearSeeds;
-
- mitk::FastMarchingTool::Pointer m_FastMarchingTool;
-
- bool m_TimeIsConnected;
- mitk::Stepper::Pointer m_TimeStepper;
-
- void OnFastMarchingToolReady();
-
-private:
- void EnableWidgets(bool);
+ ~QmitkFastMarchingToolGUI() = default;
};
#endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkFastMarchingToolGUIBase.cpp b/Modules/SegmentationUI/Qmitk/QmitkFastMarchingToolGUIBase.cpp
new file mode 100644
index 0000000000..1bd272c0f5
--- /dev/null
+++ b/Modules/SegmentationUI/Qmitk/QmitkFastMarchingToolGUIBase.cpp
@@ -0,0 +1,296 @@
+/*============================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center (DKFZ)
+All rights reserved.
+
+Use of this source code is governed by a 3-clause BSD license that can be
+found in the LICENSE file.
+
+============================================================================*/
+
+#include "QmitkFastMarchingToolGUIBase.h"
+
+#include "mitkBaseRenderer.h"
+#include "mitkStepper.h"
+#include <QApplication>
+#include <QGroupBox>
+#include <QMessageBox>
+#include <ctkRangeWidget.h>
+#include <ctkSliderWidget.h>
+#include <qlabel.h>
+#include <qlayout.h>
+#include <qpushbutton.h>
+
+QmitkFastMarchingToolGUIBase::QmitkFastMarchingToolGUIBase(bool mode2D) : QmitkAutoSegmentationToolGUIBase(mode2D)
+{
+}
+
+QmitkFastMarchingToolGUIBase::~QmitkFastMarchingToolGUIBase()
+{
+}
+
+void QmitkFastMarchingToolGUIBase::Update()
+{
+ auto tool = this->GetConnectedToolAs<mitk::FastMarchingBaseTool>();
+ if (nullptr != tool)
+ {
+ tool->SetLowerThreshold(m_slwThreshold->minimumValue());
+ tool->SetUpperThreshold(m_slwThreshold->maximumValue());
+ tool->SetStoppingValue(m_slStoppingValue->value());
+ tool->SetSigma(m_slSigma->value());
+ tool->SetAlpha(m_slAlpha->value());
+ tool->SetBeta(m_slBeta->value());
+ tool->UpdatePreview();
+ }
+}
+
+void QmitkFastMarchingToolGUIBase::OnThresholdChanged(double lower, double upper)
+{
+ auto tool = this->GetConnectedToolAs<mitk::FastMarchingBaseTool>();
+ if (nullptr != tool)
+ {
+ tool->SetLowerThreshold(lower);
+ tool->SetUpperThreshold(upper);
+ this->Update();
+ }
+}
+
+void QmitkFastMarchingToolGUIBase::OnBetaChanged(double value)
+{
+ auto tool = this->GetConnectedToolAs<mitk::FastMarchingBaseTool>();
+ if (nullptr != tool)
+ {
+ tool->SetBeta(value);
+ this->Update();
+ }
+}
+
+void QmitkFastMarchingToolGUIBase::OnSigmaChanged(double value)
+{
+ auto tool = this->GetConnectedToolAs<mitk::FastMarchingBaseTool>();
+ if (nullptr != tool)
+ {
+ tool->SetSigma(value);
+ this->Update();
+ }
+}
+
+void QmitkFastMarchingToolGUIBase::OnAlphaChanged(double value)
+{
+ auto tool = this->GetConnectedToolAs<mitk::FastMarchingBaseTool>();
+ if (nullptr != tool)
+ {
+ tool->SetAlpha(value);
+ this->Update();
+ }
+}
+
+void QmitkFastMarchingToolGUIBase::OnStoppingValueChanged(double value)
+{
+ auto tool = this->GetConnectedToolAs<mitk::FastMarchingBaseTool>();
+ if (nullptr != tool)
+ {
+ tool->SetStoppingValue(value);
+ this->Update();
+ }
+}
+
+void QmitkFastMarchingToolGUIBase::OnClearSeeds()
+{
+ auto tool = this->GetConnectedToolAs<mitk::FastMarchingBaseTool>();
+ if (nullptr != tool)
+ {
+ tool->ClearSeeds();
+ this->EnableWidgets(false);
+ this->Update();
+ }
+}
+
+void QmitkFastMarchingToolGUIBase::ConnectNewTool(mitk::AutoSegmentationWithPreviewTool* newTool)
+{
+ Superclass::ConnectNewTool(newTool);
+
+ auto tool = dynamic_cast<mitk::FastMarchingBaseTool*>(newTool);
+ if (nullptr != tool)
+ {
+ tool->SetLowerThreshold(m_slwThreshold->minimumValue());
+ tool->SetUpperThreshold(m_slwThreshold->maximumValue());
+ tool->SetStoppingValue(m_slStoppingValue->value());
+ tool->SetSigma(m_slSigma->value());
+ tool->SetAlpha(m_slAlpha->value());
+ tool->SetBeta(m_slBeta->value());
+ tool->ClearSeeds();
+ }
+}
+
+void QmitkFastMarchingToolGUIBase::InitializeUI(QBoxLayout* mainLayout)
+{
+ mainLayout->setContentsMargins(0, 0, 0, 0);
+
+ QFont fntHelp;
+ fntHelp.setBold(true);
+
+ QLabel* lblHelp = new QLabel(this);
+ lblHelp->setText("Press shift-click to add seeds repeatedly.");
+ lblHelp->setFont(fntHelp);
+
+ mainLayout->addWidget(lblHelp);
+
+ // Sigma controls
+ {
+ QHBoxLayout* hlayout = new QHBoxLayout();
+ hlayout->setSpacing(2);
+
+ QLabel* lbl = new QLabel(this);
+ lbl->setText("Sigma: ");
+ hlayout->addWidget(lbl);
+
+ QSpacerItem* sp2 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
+ hlayout->addItem(sp2);
+
+ mainLayout->addItem(hlayout);
+ }
+
+ m_slSigma = new ctkSliderWidget(this);
+ m_slSigma->setMinimum(0.1);
+ m_slSigma->setMaximum(5.0);
+ m_slSigma->setPageStep(0.1);
+ m_slSigma->setSingleStep(0.01);
+ m_slSigma->setValue(1.0);
+ m_slSigma->setTracking(false);
+ m_slSigma->setToolTip("The \"sigma\" parameter in the Gradient Magnitude filter.");
+ connect(m_slSigma, SIGNAL(valueChanged(double)), this, SLOT(OnSigmaChanged(double)));
+ mainLayout->addWidget(m_slSigma);
+
+ // Alpha controls
+ {
+ QHBoxLayout* hlayout = new QHBoxLayout();
+ hlayout->setSpacing(2);
+
+ QLabel* lbl = new QLabel(this);
+ lbl->setText("Alpha: ");
+ hlayout->addWidget(lbl);
+
+ QSpacerItem* sp2 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
+ hlayout->addItem(sp2);
+
+ mainLayout->addItem(hlayout);
+ }
+
+ m_slAlpha = new ctkSliderWidget(this);
+ m_slAlpha->setMinimum(-10);
+ m_slAlpha->setMaximum(0);
+ m_slAlpha->setPageStep(0.1);
+ m_slAlpha->setSingleStep(0.01);
+ m_slAlpha->setValue(-2.5);
+ m_slAlpha->setTracking(false);
+ m_slAlpha->setToolTip("The \"alpha\" parameter in the Sigmoid mapping filter.");
+ connect(m_slAlpha, SIGNAL(valueChanged(double)), this, SLOT(OnAlphaChanged(double)));
+ mainLayout->addWidget(m_slAlpha);
+
+ // Beta controls
+ {
+ QHBoxLayout* hlayout = new QHBoxLayout();
+ hlayout->setSpacing(2);
+
+ QLabel* lbl = new QLabel(this);
+ lbl->setText("Beta: ");
+ hlayout->addWidget(lbl);
+
+ QSpacerItem* sp2 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
+ hlayout->addItem(sp2);
+
+ mainLayout->addLayout(hlayout);
+ }
+
+ m_slBeta = new ctkSliderWidget(this);
+ m_slBeta->setMinimum(0);
+ m_slBeta->setMaximum(100);
+ m_slBeta->setPageStep(0.1);
+ m_slBeta->setSingleStep(0.01);
+ m_slBeta->setValue(3.5);
+ m_slBeta->setTracking(false);
+ m_slBeta->setToolTip("The \"beta\" parameter in the Sigmoid mapping filter.");
+ connect(m_slBeta, SIGNAL(valueChanged(double)), this, SLOT(OnBetaChanged(double)));
+ mainLayout->addWidget(m_slBeta);
+
+ // stopping value controls
+ {
+ QHBoxLayout* hlayout = new QHBoxLayout();
+ hlayout->setSpacing(2);
+
+ QLabel* lbl = new QLabel(this);
+ lbl->setText("Stopping value: ");
+ hlayout->addWidget(lbl);
+
+ QSpacerItem* sp2 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
+ hlayout->addItem(sp2);
+
+ mainLayout->addLayout(hlayout);
+ }
+
+ m_slStoppingValue = new ctkSliderWidget(this);
+ m_slStoppingValue->setMinimum(0);
+ m_slStoppingValue->setMaximum(10000);
+ m_slStoppingValue->setPageStep(10);
+ m_slStoppingValue->setSingleStep(1);
+ m_slStoppingValue->setValue(2000);
+ m_slStoppingValue->setDecimals(0);
+ m_slStoppingValue->setTracking(false);
+ m_slStoppingValue->setToolTip("The \"stopping value\" parameter in the fast marching 3D algorithm");
+ connect(m_slStoppingValue, SIGNAL(valueChanged(double)), this, SLOT(OnStoppingValueChanged(double)));
+ mainLayout->addWidget(m_slStoppingValue);
+
+ // threshold controls
+ {
+ QHBoxLayout* hlayout = new QHBoxLayout();
+ hlayout->setSpacing(2);
+
+ QLabel* lbl = new QLabel(this);
+ lbl->setText("Threshold: ");
+ hlayout->addWidget(lbl);
+
+ QSpacerItem* sp2 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
+ hlayout->addItem(sp2);
+
+ mainLayout->addLayout(hlayout);
+ }
+
+ m_slwThreshold = new ctkRangeWidget(this);
+ m_slwThreshold->setMinimum(-100);
+ m_slwThreshold->setMaximum(5000);
+ m_slwThreshold->setMinimumValue(-100);
+ m_slwThreshold->setMaximumValue(2000);
+ m_slwThreshold->setDecimals(0);
+ m_slwThreshold->setTracking(false);
+ m_slwThreshold->setToolTip("The lower and upper thresholds for the final thresholding");
+ connect(m_slwThreshold, SIGNAL(valuesChanged(double, double)), this, SLOT(OnThresholdChanged(double, double)));
+ mainLayout->addWidget(m_slwThreshold);
+
+ m_btClearSeeds = new QPushButton("Clear");
+ m_btClearSeeds->setToolTip("Clear current result and start over again");
+ m_btClearSeeds->setEnabled(false);
+ mainLayout->addWidget(m_btClearSeeds);
+ connect(m_btClearSeeds, SIGNAL(clicked()), this, SLOT(OnClearSeeds()));
+
+ m_slSigma->setDecimals(2);
+ m_slBeta->setDecimals(2);
+ m_slAlpha->setDecimals(2);
+
+ this->EnableWidgets(false);
+
+ Superclass::InitializeUI(mainLayout);
+}
+
+void QmitkFastMarchingToolGUIBase::EnableWidgets(bool enable)
+{
+ Superclass::EnableWidgets(enable);
+ m_slSigma->setEnabled(enable);
+ m_slAlpha->setEnabled(enable);
+ m_slBeta->setEnabled(enable);
+ m_slStoppingValue->setEnabled(enable);
+ m_slwThreshold->setEnabled(enable);
+ m_btClearSeeds->setEnabled(enable);
+}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkFastMarchingTool3DGUI.h b/Modules/SegmentationUI/Qmitk/QmitkFastMarchingToolGUIBase.h
similarity index 58%
copy from Modules/SegmentationUI/Qmitk/QmitkFastMarchingTool3DGUI.h
copy to Modules/SegmentationUI/Qmitk/QmitkFastMarchingToolGUIBase.h
index a02b18de12..669ef27155 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkFastMarchingTool3DGUI.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkFastMarchingToolGUIBase.h
@@ -1,79 +1,67 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
-#ifndef QmitkFastMarchingTool3DGUI_h_Included
-#define QmitkFastMarchingTool3DGUI_h_Included
+#ifndef QmitkFastMarchingToolGUIBase_h_Included
+#define QmitkFastMarchingToolGUIBase_h_Included
-#include "QmitkToolGUI.h"
+#include "QmitkAutoSegmentationToolGUIBase.h"
#include "mitkFastMarchingTool3D.h"
#include <MitkSegmentationUIExports.h>
class ctkSliderWidget;
class ctkRangeWidget;
class QPushButton;
-class QCheckBox;
/**
\ingroup org_mitk_gui_qt_interactivesegmentation_internal
-\brief GUI for mitk::FastMarchingTool.
+\brief Base GUI for mitk::FastMarchingTool (2D and 3D).
\sa mitk::FastMarchingTool
*/
-class MITKSEGMENTATIONUI_EXPORT QmitkFastMarchingTool3DGUI : public QmitkToolGUI
+class MITKSEGMENTATIONUI_EXPORT QmitkFastMarchingToolGUIBase : public QmitkAutoSegmentationToolGUIBase
{
Q_OBJECT
public:
- mitkClassMacro(QmitkFastMarchingTool3DGUI, QmitkToolGUI);
- itkFactorylessNewMacro(Self);
- itkCloneMacro(Self);
-
- void OnThresholdChanged(int current);
+ mitkClassMacro(QmitkFastMarchingToolGUIBase, QmitkAutoSegmentationToolGUIBase);
protected slots:
- void OnNewToolAssociated(mitk::Tool *);
-
void OnThresholdChanged(double, double);
void OnAlphaChanged(double);
void OnBetaChanged(double);
void OnSigmaChanged(double);
void OnStoppingValueChanged(double);
- void OnConfirmSegmentation();
void OnClearSeeds();
protected:
- QmitkFastMarchingTool3DGUI();
- ~QmitkFastMarchingTool3DGUI() override;
+ QmitkFastMarchingToolGUIBase(bool mode2D);
+ ~QmitkFastMarchingToolGUIBase() override;
+
+ void ConnectNewTool(mitk::AutoSegmentationWithPreviewTool* newTool) override;
+ void InitializeUI(QBoxLayout* mainLayout) override;
- void BusyStateChanged(bool) override;
+ void EnableWidgets(bool) override;
void Update();
ctkRangeWidget *m_slwThreshold;
ctkSliderWidget *m_slStoppingValue;
ctkSliderWidget *m_slSigma;
ctkSliderWidget *m_slAlpha;
ctkSliderWidget *m_slBeta;
- QPushButton *m_btConfirm;
QPushButton *m_btClearSeeds;
- QCheckBox* m_CheckProcessAll = nullptr;
- QCheckBox* m_CheckCreateNew = nullptr;
-
- mitk::FastMarchingTool3D::Pointer m_FastMarchingTool;
-
private:
- void EnableWidgets(bool);
};
#endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkOtsuTool3DGUI.cpp b/Modules/SegmentationUI/Qmitk/QmitkOtsuTool3DGUI.cpp
index 9e925b66ba..a752782207 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkOtsuTool3DGUI.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkOtsuTool3DGUI.cpp
@@ -1,194 +1,129 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkOtsuTool3DGUI.h"
+#include "mitkOtsuTool3D.h"
#include <QMessageBox>
MITK_TOOL_GUI_MACRO(MITKSEGMENTATIONUI_EXPORT, QmitkOtsuTool3DGUI, "")
-QmitkOtsuTool3DGUI::QmitkOtsuTool3DGUI() : QmitkToolGUI(), m_NumberOfRegions(0)
+QmitkOtsuTool3DGUI::QmitkOtsuTool3DGUI() : QmitkAutoMLSegmentationToolGUIBase()
+{
+}
+
+void QmitkOtsuTool3DGUI::ConnectNewTool(mitk::AutoSegmentationWithPreviewTool* newTool)
+{
+ Superclass::ConnectNewTool(newTool);
+
+ newTool->IsTimePointChangeAwareOff();
+ m_FirstPreviewComputation = true;
+}
+
+void QmitkOtsuTool3DGUI::InitializeUI(QBoxLayout* mainLayout)
{
m_Controls.setupUi(this);
+ mainLayout->addLayout(m_Controls.verticalLayout);
- connect(m_Controls.previewButton, SIGNAL(clicked()), this, SLOT(OnSpinboxValueAccept()));
- connect(m_Controls.m_selectionListWidget, &QmitkSimpleLabelSetListWidget::SelectedLabelsChanged, this, &QmitkOtsuTool3DGUI::OnRegionSelectionChanged);
+ connect(m_Controls.previewButton, SIGNAL(clicked()), this, SLOT(OnPreviewBtnClicked()));
connect(m_Controls.m_Spinbox, SIGNAL(valueChanged(int)), this, SLOT(OnRegionSpinboxChanged(int)));
- connect(m_Controls.m_ConfSegButton, SIGNAL(clicked()), this, SLOT(OnSegmentationRegionAccept()));
- connect(this, SIGNAL(NewToolAssociated(mitk::Tool *)), this, SLOT(OnNewToolAssociated(mitk::Tool *)));
connect(m_Controls.advancedSettingsButton, SIGNAL(toggled(bool)), this, SLOT(OnAdvancedSettingsButtonToggled(bool)));
this->OnAdvancedSettingsButtonToggled(false);
-}
-QmitkOtsuTool3DGUI::~QmitkOtsuTool3DGUI()
-{
- if (m_OtsuTool3DTool.IsNotNull())
- {
- m_OtsuTool3DTool->CurrentlyBusy -=
- mitk::MessageDelegate1<QmitkOtsuTool3DGUI, bool>(this, &QmitkOtsuTool3DGUI::BusyStateChanged);
- }
+ Superclass::InitializeUI(mainLayout);
}
void QmitkOtsuTool3DGUI::OnRegionSpinboxChanged(int numberOfRegions)
{
// we have to change to minimum number of histogram bins accordingly
int curBinValue = m_Controls.m_BinsSpinBox->value();
if (curBinValue < numberOfRegions)
m_Controls.m_BinsSpinBox->setValue(numberOfRegions);
}
-void QmitkOtsuTool3DGUI::OnRegionSelectionChanged(const QmitkSimpleLabelSetListWidget::LabelVectorType& selectedLabels)
-{
- if (m_OtsuTool3DTool.IsNotNull())
- {
- mitk::AutoMLSegmentationWithPreviewTool::SelectedLabelVectorType labelIDs;
- for (const auto& label : selectedLabels)
- {
- labelIDs.push_back(label->GetValue());
- }
-
- m_OtsuTool3DTool->SetSelectedLabels(labelIDs);
- m_OtsuTool3DTool->UpdatePreview();
-
- m_Controls.m_ConfSegButton->setEnabled(!labelIDs.empty());
- }
-}
-
void QmitkOtsuTool3DGUI::OnAdvancedSettingsButtonToggled(bool toggled)
{
m_Controls.m_ValleyCheckbox->setVisible(toggled);
m_Controls.binLabel->setVisible(toggled);
m_Controls.m_BinsSpinBox->setVisible(toggled);
- if (toggled)
+ auto tool = this->GetConnectedToolAs<mitk::OtsuTool3D>();
+ if (toggled && nullptr != tool)
{
- int max = m_OtsuTool3DTool->GetMaxNumberOfBins();
+ int max = tool->GetMaxNumberOfBins();
if (max >= m_Controls.m_BinsSpinBox->minimum())
{
m_Controls.m_BinsSpinBox->setMaximum(max);
}
}
}
-void QmitkOtsuTool3DGUI::OnNewToolAssociated(mitk::Tool *tool)
+void QmitkOtsuTool3DGUI::OnPreviewBtnClicked()
{
- if (m_OtsuTool3DTool.IsNotNull())
- {
- m_OtsuTool3DTool->CurrentlyBusy -=
- mitk::MessageDelegate1<QmitkOtsuTool3DGUI, bool>(this, &QmitkOtsuTool3DGUI::BusyStateChanged);
- }
-
- m_OtsuTool3DTool = dynamic_cast<mitk::OtsuTool3D *>(tool);
-
- if (m_OtsuTool3DTool.IsNotNull())
+ auto tool = this->GetConnectedToolAs<mitk::OtsuTool3D>();
+ if (nullptr != tool)
{
- m_OtsuTool3DTool->CurrentlyBusy +=
- mitk::MessageDelegate1<QmitkOtsuTool3DGUI, bool>(this, &QmitkOtsuTool3DGUI::BusyStateChanged);
-
- m_OtsuTool3DTool->SetOverwriteExistingSegmentation(true);
- m_OtsuTool3DTool->IsTimePointChangeAwareOff();
- m_Controls.m_CheckProcessAll->setVisible(m_OtsuTool3DTool->GetTargetSegmentationNode()->GetData()->GetTimeSteps() > 1);
- }
-}
-
-void QmitkOtsuTool3DGUI::OnSegmentationRegionAccept()
-{
- QString segName = QString::fromStdString(m_OtsuTool3DTool->GetCurrentSegmentationName());
-
- if (m_OtsuTool3DTool.IsNotNull())
- {
- if (this->m_Controls.m_CheckCreateNew->isChecked())
- {
- m_OtsuTool3DTool->SetOverwriteExistingSegmentation(false);
- }
- else
- {
- m_OtsuTool3DTool->SetOverwriteExistingSegmentation(true);
- }
-
- m_OtsuTool3DTool->SetCreateAllTimeSteps(this->m_Controls.m_CheckProcessAll->isChecked());
-
- this->m_Controls.m_ConfSegButton->setEnabled(false);
- m_OtsuTool3DTool->ConfirmSegmentation();
- }
-}
+ if (!m_FirstPreviewComputation ||
+ (tool->GetNumberOfRegions() == static_cast<unsigned int>(m_Controls.m_Spinbox->value()) &&
+ tool->GetUseValley() == m_Controls.m_ValleyCheckbox->isChecked() &&
+ tool->GetNumberOfBins() == static_cast<unsigned int>(m_Controls.m_BinsSpinBox->value())))
+ return;
-void QmitkOtsuTool3DGUI::OnSpinboxValueAccept()
-{
- if (m_NumberOfRegions == m_Controls.m_Spinbox->value() &&
- m_UseValleyEmphasis == m_Controls.m_ValleyCheckbox->isChecked() &&
- m_NumberOfBins == m_Controls.m_BinsSpinBox->value())
- return;
+ m_FirstPreviewComputation = false;
- if (m_OtsuTool3DTool.IsNotNull())
- {
try
{
int proceed;
QMessageBox *messageBox = new QMessageBox(QMessageBox::Question,
nullptr,
"The otsu segmentation computation may take several minutes depending "
"on the number of Regions you selected. Proceed anyway?",
QMessageBox::Ok | QMessageBox::Cancel);
if (m_Controls.m_Spinbox->value() >= 5)
{
proceed = messageBox->exec();
if (proceed != QMessageBox::Ok)
return;
}
- m_NumberOfRegions = m_Controls.m_Spinbox->value();
- m_UseValleyEmphasis = m_Controls.m_ValleyCheckbox->isChecked();
- m_NumberOfBins = m_Controls.m_BinsSpinBox->value();
- m_OtsuTool3DTool->SetNumberOfRegions(m_NumberOfRegions);
- m_OtsuTool3DTool->SetUseValley(m_UseValleyEmphasis);
- m_OtsuTool3DTool->SetNumberOfBins(m_NumberOfBins);
+ tool->SetNumberOfRegions(static_cast<unsigned int>(m_Controls.m_Spinbox->value()));
+ tool->SetUseValley(m_Controls.m_ValleyCheckbox->isChecked());
+ tool->SetNumberOfBins(static_cast<unsigned int>(m_Controls.m_BinsSpinBox->value()));
- m_OtsuTool3DTool->UpdatePreview();
+ tool->UpdatePreview();
}
catch (...)
{
this->setCursor(Qt::ArrowCursor);
QMessageBox *messageBox =
new QMessageBox(QMessageBox::Critical,
nullptr,
"itkOtsuFilter error: image dimension must be in {2, 3} and no RGB images can be handled.");
messageBox->exec();
delete messageBox;
return;
}
- m_Controls.m_selectionListWidget->SetLabelSetImage(m_OtsuTool3DTool->GetMLPreview());
- m_OtsuTool3DTool->IsTimePointChangeAwareOn();
+ this->SetLabelSetPreview(tool->GetMLPreview());
+ tool->IsTimePointChangeAwareOn();
}
}
-void QmitkOtsuTool3DGUI::BusyStateChanged(bool value)
+void QmitkOtsuTool3DGUI::EnableWidgets(bool enabled)
{
- if (value)
- {
- QApplication::setOverrideCursor(QCursor(Qt::BusyCursor));
- }
- else
- {
- QApplication::restoreOverrideCursor();
- }
-
- m_Controls.m_ValleyCheckbox->setEnabled(!value);
- m_Controls.binLabel->setEnabled(!value);
- m_Controls.m_BinsSpinBox->setEnabled(!value);
- m_Controls.m_ConfSegButton->setEnabled(!m_OtsuTool3DTool->GetSelectedLabels().empty() && !value);
- m_Controls.m_CheckProcessAll->setEnabled(!value);
- m_Controls.m_CheckCreateNew->setEnabled(!value);
- m_Controls.previewButton->setEnabled(!value);
+ Superclass::EnableWidgets(enabled);
+ m_Controls.m_ValleyCheckbox->setEnabled(enabled);
+ m_Controls.binLabel->setEnabled(enabled);
+ m_Controls.m_BinsSpinBox->setEnabled(enabled);
+ m_Controls.previewButton->setEnabled(enabled);
}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkOtsuTool3DGUI.h b/Modules/SegmentationUI/Qmitk/QmitkOtsuTool3DGUI.h
index e7a3762c43..f9d87fd615 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkOtsuTool3DGUI.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkOtsuTool3DGUI.h
@@ -1,75 +1,64 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkOtsuTool3DGUI_h_Included
#define QmitkOtsuTool3DGUI_h_Included
-#include "QmitkToolGUI.h"
-#include "mitkOtsuTool3D.h"
+#include "QmitkAutoMLSegmentationToolGUIBase.h"
#include "ui_QmitkOtsuToolWidgetControls.h"
#include <MitkSegmentationUIExports.h>
-#include <QPushButton>
/**
\ingroup org_mitk_gui_qt_interactivesegmentation_internal
\brief GUI for mitk::.
\sa mitk::
This GUI shows ...
Last contributor: $Author$
*/
-class MITKSEGMENTATIONUI_EXPORT QmitkOtsuTool3DGUI : public QmitkToolGUI
+class MITKSEGMENTATIONUI_EXPORT QmitkOtsuTool3DGUI : public QmitkAutoMLSegmentationToolGUIBase
{
Q_OBJECT
public:
- mitkClassMacro(QmitkOtsuTool3DGUI, QmitkToolGUI);
+ mitkClassMacro(QmitkOtsuTool3DGUI, QmitkAutoMLSegmentationToolGUIBase);
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
protected slots :
- void OnNewToolAssociated(mitk::Tool *);
-
- void OnSpinboxValueAccept();
-
- void OnSegmentationRegionAccept();
-
- void OnRegionSelectionChanged(const QmitkSimpleLabelSetListWidget::LabelVectorType& selectedLabels);
+ void OnPreviewBtnClicked();
void OnRegionSpinboxChanged(int);
private slots:
void OnAdvancedSettingsButtonToggled(bool toggled);
protected:
QmitkOtsuTool3DGUI();
- ~QmitkOtsuTool3DGUI() override;
+ ~QmitkOtsuTool3DGUI() = default;
- void BusyStateChanged(bool value) override;
+ void ConnectNewTool(mitk::AutoSegmentationWithPreviewTool* newTool) override;
+ void InitializeUI(QBoxLayout* mainLayout) override;
- mitk::OtsuTool3D::Pointer m_OtsuTool3DTool;
+ void EnableWidgets(bool enabled) override;
Ui_QmitkOtsuToolWidgetControls m_Controls;
- int m_NumberOfRegions;
-
- bool m_UseValleyEmphasis;
-
- int m_NumberOfBins;
+ bool m_FirstPreviewComputation = true;
};
#endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkOtsuToolWidgetControls.ui b/Modules/SegmentationUI/Qmitk/QmitkOtsuToolWidgetControls.ui
index d01d26178d..8137fb2d3f 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkOtsuToolWidgetControls.ui
+++ b/Modules/SegmentationUI/Qmitk/QmitkOtsuToolWidgetControls.ui
@@ -1,253 +1,205 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>QmitkOtsuToolWidgetControls</class>
<widget class="QWidget" name="QmitkOtsuToolWidgetControls">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>699</width>
<height>352</height>
</rect>
</property>
<property name="sizePolicy">
<sizepolicy hsizetype="Ignored" vsizetype="Minimum">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="minimumSize">
<size>
<width>100</width>
<height>0</height>
</size>
</property>
<property name="maximumSize">
<size>
<width>100000</width>
<height>100000</height>
</size>
</property>
<property name="windowTitle">
<string>QmitkOtsuToolWidget</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
+ <property name="spacing">
+ <number>0</number>
+ </property>
+ <property name="leftMargin">
+ <number>0</number>
+ </property>
+ <property name="topMargin">
+ <number>0</number>
+ </property>
+ <property name="rightMargin">
+ <number>0</number>
+ </property>
+ <property name="bottomMargin">
+ <number>0</number>
+ </property>
<item>
<layout class="QHBoxLayout" name="horizontalLayout">
<property name="sizeConstraint">
<enum>QLayout::SetNoConstraint</enum>
</property>
<item>
<widget class="QLabel" name="numberOfRegionsLabel">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="text">
<string>Number of Regions:</string>
</property>
</widget>
</item>
<item>
<widget class="QSpinBox" name="m_Spinbox">
<property name="sizePolicy">
<sizepolicy hsizetype="Minimum" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="maximumSize">
<size>
<width>40</width>
<height>16777215</height>
</size>
</property>
<property name="minimum">
<number>2</number>
</property>
<property name="maximum">
<number>32</number>
</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="ctkExpandButton" name="advancedSettingsButton">
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="minimumSize">
<size>
<width>0</width>
<height>32</height>
</size>
</property>
<property name="text">
<string>Advanced settings</string>
</property>
<property name="toolButtonStyle">
<enum>Qt::ToolButtonTextBesideIcon</enum>
</property>
<property name="mirrorOnExpand" stdset="0">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<layout class="QGridLayout" name="advancedSettingsLayout" rowstretch="0,0" columnstretch="0,0,0">
<item row="1" column="1">
<widget class="QSpinBox" name="m_BinsSpinBox">
<property name="minimum">
<number>2</number>
</property>
<property name="maximum">
<number>4096</number>
</property>
<property name="value">
<number>128</number>
</property>
</widget>
</item>
<item row="0" column="0">
<widget class="QCheckBox" name="m_ValleyCheckbox">
<property name="text">
<string>Use Valley Emphasis</string>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QLabel" name="binLabel">
<property name="text">
<string>Number of Histogram Bins:</string>
</property>
</widget>
</item>
<item row="1" column="2">
<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>
</layout>
</item>
- <item>
- <widget class="QmitkSimpleLabelSetListWidget" name="m_selectionListWidget" native="true">
- <property name="sizePolicy">
- <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
- <horstretch>0</horstretch>
- <verstretch>0</verstretch>
- </sizepolicy>
- </property>
- <property name="maximumSize">
- <size>
- <width>10000000</width>
- <height>10000000</height>
- </size>
- </property>
- </widget>
- </item>
<item>
<widget class="QPushButton" name="previewButton">
<property name="sizePolicy">
<sizepolicy hsizetype="Minimum" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="maximumSize">
<size>
<width>100000</width>
<height>16777215</height>
</size>
</property>
<property name="text">
<string>Preview</string>
</property>
</widget>
</item>
- <item>
- <widget class="QPushButton" name="m_ConfSegButton">
- <property name="enabled">
- <bool>false</bool>
- </property>
- <property name="sizePolicy">
- <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
- <horstretch>0</horstretch>
- <verstretch>0</verstretch>
- </sizepolicy>
- </property>
- <property name="maximumSize">
- <size>
- <width>100000</width>
- <height>16777215</height>
- </size>
- </property>
- <property name="text">
- <string>Confirm Segmentation</string>
- </property>
- </widget>
- </item>
- <item>
- <widget class="QCheckBox" name="m_CheckProcessAll">
- <property name="toolTip">
- <string>Process/overwrite all time steps of the dynamic segmentation and not just the currently visible time step.</string>
- </property>
- <property name="text">
- <string>Process all time steps</string>
- </property>
- </widget>
- </item>
- <item>
- <widget class="QCheckBox" name="m_CheckCreateNew">
- <property name="toolTip">
- <string>Add the confirmed segmentation as a new segmentation instead of overwriting the currently selected.</string>
- </property>
- <property name="text">
- <string>Create as new segmentation</string>
- </property>
- </widget>
- </item>
</layout>
</widget>
<layoutdefault spacing="6" margin="11"/>
<customwidgets>
<customwidget>
<class>ctkExpandButton</class>
<extends>QToolButton</extends>
<header>ctkExpandButton.h</header>
</customwidget>
- <customwidget>
- <class>QmitkSimpleLabelSetListWidget</class>
- <extends>QWidget</extends>
- <header>QmitkSimpleLabelSetListWidget.h</header>
- </customwidget>
</customwidgets>
<resources/>
<connections/>
</ui>
diff --git a/Modules/SegmentationUI/Qmitk/QmitkToolSelectionBox.cpp b/Modules/SegmentationUI/Qmitk/QmitkToolSelectionBox.cpp
index 2036ea6b67..2d42898731 100755
--- a/Modules/SegmentationUI/Qmitk/QmitkToolSelectionBox.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkToolSelectionBox.cpp
@@ -1,683 +1,683 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
//#define MBILOG_ENABLE_DEBUG 1
#include <QmitkStyleManager.h>
#include "QmitkToolSelectionBox.h"
#include "QmitkToolGUI.h"
#include "mitkBaseRenderer.h"
#include <QList>
#include <qapplication.h>
#include <qlayout.h>
#include <qmessagebox.h>
#include <qtoolbutton.h>
#include <qtooltip.h>
#include <queue>
#include "usModuleResource.h"
#include "usModuleResourceStream.h"
#include "mitkToolManagerProvider.h"
QmitkToolSelectionBox::QmitkToolSelectionBox(QWidget *parent, mitk::DataStorage *)
: QWidget(parent),
m_SelfCall(false),
m_DisplayedGroups("default"),
m_LayoutColumns(2),
m_ShowNames(true),
m_GenerateAccelerators(false),
m_ToolGUIWidget(nullptr),
m_LastToolGUI(nullptr),
m_ToolButtonGroup(nullptr),
m_ButtonLayout(nullptr),
m_EnabledMode(EnabledWithReferenceAndWorkingDataVisible)
{
QFont currentFont = QWidget::font();
currentFont.setBold(true);
QWidget::setFont(currentFont);
m_ToolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
// QButtonGroup
m_ToolButtonGroup = new QButtonGroup(this);
// some features of QButtonGroup
m_ToolButtonGroup->setExclusive(false); // mutually exclusive toggle buttons
RecreateButtons();
QWidget::setContentsMargins(0, 0, 0, 0);
if (layout() != nullptr)
{
layout()->setContentsMargins(0, 0, 0, 0);
}
// reactions to signals
connect(m_ToolButtonGroup, SIGNAL(buttonClicked(int)), this, SLOT(toolButtonClicked(int)));
// reactions to ToolManager events
m_ToolManager->ActiveToolChanged +=
mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerToolModified);
m_ToolManager->ReferenceDataChanged +=
mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerReferenceDataModified);
m_ToolManager->WorkingDataChanged +=
mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerWorkingDataModified);
// show active tool
SetOrUnsetButtonForActiveTool();
QWidget::setEnabled(false);
}
QmitkToolSelectionBox::~QmitkToolSelectionBox()
{
m_ToolManager->ActiveToolChanged -=
mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerToolModified);
m_ToolManager->ReferenceDataChanged -=
mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerReferenceDataModified);
m_ToolManager->WorkingDataChanged -=
mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerWorkingDataModified);
}
void QmitkToolSelectionBox::SetEnabledMode(EnabledMode mode)
{
m_EnabledMode = mode;
SetGUIEnabledAccordingToToolManagerState();
}
mitk::ToolManager *QmitkToolSelectionBox::GetToolManager()
{
return m_ToolManager;
}
void QmitkToolSelectionBox::SetToolManager(
mitk::ToolManager &newManager) // no nullptr pointer allowed here, a manager is required
{
// say bye to the old manager
m_ToolManager->ActiveToolChanged -=
mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerToolModified);
m_ToolManager->ReferenceDataChanged -=
mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerReferenceDataModified);
m_ToolManager->WorkingDataChanged -=
mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerWorkingDataModified);
if (QWidget::isEnabled())
{
m_ToolManager->UnregisterClient();
}
m_ToolManager = &newManager;
RecreateButtons();
// greet the new one
m_ToolManager->ActiveToolChanged +=
mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerToolModified);
m_ToolManager->ReferenceDataChanged +=
mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerReferenceDataModified);
m_ToolManager->WorkingDataChanged +=
mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerWorkingDataModified);
if (QWidget::isEnabled())
{
m_ToolManager->RegisterClient();
}
// ask the new one what the situation is like
SetOrUnsetButtonForActiveTool();
}
void QmitkToolSelectionBox::toolButtonClicked(int id)
{
if (!QWidget::isEnabled())
return; // this method could be triggered from the constructor, when we are still disabled
MITK_DEBUG << "toolButtonClicked(" << id << "): id translates to tool ID " << m_ToolIDForButtonID[id];
QToolButton *toolButton = dynamic_cast<QToolButton *>(m_ToolButtonGroup->buttons().at(id));
if (toolButton)
{
if ((m_ButtonIDForToolID.find(m_ToolManager->GetActiveToolID()) !=
m_ButtonIDForToolID.end()) // if we have this tool in our box
&&
(m_ButtonIDForToolID[m_ToolManager->GetActiveToolID()] ==
id)) // the tool corresponding to this button is already active
{
// disable this button, disable all tools
toolButton->setChecked(false);
m_ToolManager->ActivateTool(-1); // disable everything
}
else
{
// enable the corresponding tool
m_SelfCall = true;
m_ToolManager->ActivateTool(m_ToolIDForButtonID[id]);
m_SelfCall = false;
}
}
}
void QmitkToolSelectionBox::OnToolManagerToolModified()
{
SetOrUnsetButtonForActiveTool();
}
void QmitkToolSelectionBox::SetOrUnsetButtonForActiveTool()
{
// we want to emit a signal in any case, whether we selected ourselves or somebody else changes "our" tool manager.
// --> emit before check on m_SelfCall
int id = m_ToolManager->GetActiveToolID();
// don't emit signal for shape model tools
bool emitSignal = true;
mitk::Tool *tool = m_ToolManager->GetActiveTool();
if (tool && std::string(tool->GetGroup()) == "organ_segmentation")
emitSignal = false;
if (emitSignal)
emit ToolSelected(id);
// delete old GUI (if any)
if (m_LastToolGUI && m_ToolGUIWidget)
{
if (m_ToolGUIWidget->layout())
{
m_ToolGUIWidget->layout()->removeWidget(m_LastToolGUI);
}
m_LastToolGUI->setParent(nullptr);
delete m_LastToolGUI; // will hopefully notify parent and layouts
m_LastToolGUI = nullptr;
QLayout *layout = m_ToolGUIWidget->layout();
if (layout)
{
layout->activate();
}
}
QToolButton *toolButton(nullptr);
if (m_ButtonIDForToolID.find(id) != m_ButtonIDForToolID.end()) // if this tool is in our box
{
toolButton = dynamic_cast<QToolButton *>(m_ToolButtonGroup->buttons().at(m_ButtonIDForToolID[id]));
}
if (toolButton)
{
// mmueller
// uncheck all other buttons
QAbstractButton *tmpBtn = nullptr;
QList<QAbstractButton *>::iterator it;
for (int i = 0; i < m_ToolButtonGroup->buttons().size(); ++i)
{
tmpBtn = m_ToolButtonGroup->buttons().at(i);
if (tmpBtn != toolButton)
dynamic_cast<QToolButton *>(tmpBtn)->setChecked(false);
}
toolButton->setChecked(true);
if (m_ToolGUIWidget && tool)
{
// create and reparent new GUI (if any)
itk::Object::Pointer possibleGUI = tool->GetGUI("Qmitk", "GUI").GetPointer(); // prefix and postfix
if (possibleGUI.IsNull())
possibleGUI = tool->GetGUI("", "GUI").GetPointer();
QmitkToolGUI *gui = dynamic_cast<QmitkToolGUI *>(possibleGUI.GetPointer());
//!
m_LastToolGUI = gui;
if (gui)
{
gui->SetTool(tool);
gui->setParent(m_ToolGUIWidget);
gui->move(gui->geometry().topLeft());
gui->show();
QLayout *layout = m_ToolGUIWidget->layout();
if (!layout)
{
layout = new QVBoxLayout(m_ToolGUIWidget);
}
if (layout)
{
layout->addWidget(gui);
layout->activate();
}
}
}
}
else
{
// disable all buttons
QToolButton *selectedToolButton = dynamic_cast<QToolButton *>(m_ToolButtonGroup->checkedButton());
if (selectedToolButton)
{
selectedToolButton->setChecked(false);
}
}
}
void QmitkToolSelectionBox::OnToolManagerReferenceDataModified()
{
if (m_SelfCall)
return;
MITK_DEBUG << "OnToolManagerReferenceDataModified()";
this->UpdateButtonsEnabledState();
this->SetGUIEnabledAccordingToToolManagerState();
}
void QmitkToolSelectionBox::OnToolManagerWorkingDataModified()
{
if (m_SelfCall)
return;
MITK_DEBUG << "OnToolManagerWorkingDataModified()";
this->UpdateButtonsEnabledState();
this->SetGUIEnabledAccordingToToolManagerState();
}
/**
Implementes the logic, which decides, when tools are activated/deactivated.
*/
void QmitkToolSelectionBox::SetGUIEnabledAccordingToToolManagerState()
{
mitk::DataNode *referenceNode = m_ToolManager->GetReferenceData(0);
mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
bool enabled = true;
switch (m_EnabledMode)
{
default:
case EnabledWithReferenceAndWorkingDataVisible:
enabled = referenceNode && workingNode &&
referenceNode->IsVisible(
mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget0"))) &&
workingNode->IsVisible(
mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget0"))) &&
isVisible();
break;
case EnabledWithReferenceData:
enabled = referenceNode && isVisible();
break;
case EnabledWithWorkingData:
enabled = workingNode && isVisible();
break;
case AlwaysEnabled:
enabled = isVisible();
break;
}
if (QWidget::isEnabled() == enabled)
return; // nothing to change
QWidget::setEnabled(enabled);
if (enabled)
{
m_ToolManager->RegisterClient();
int id = m_ToolManager->GetActiveToolID();
emit ToolSelected(id);
}
else
{
m_ToolManager->ActivateTool(-1);
m_ToolManager->UnregisterClient();
emit ToolSelected(-1);
}
}
/**
External enableization...
*/
void QmitkToolSelectionBox::setEnabled(bool /*enable*/)
{
SetGUIEnabledAccordingToToolManagerState();
}
void QmitkToolSelectionBox::UpdateButtonsEnabledState()
{
auto buttons = m_ToolButtonGroup->buttons();
const auto refDataNode = m_ToolManager->GetReferenceData(0);
const mitk::BaseData* refData = nullptr;
if (nullptr != refDataNode)
{
refData = refDataNode->GetData();
}
const auto workingDataNode = m_ToolManager->GetWorkingData(0);
const mitk::BaseData* workingData = nullptr;
if (nullptr != workingDataNode)
{
workingData = workingDataNode->GetData();
}
- for (const auto& button : buttons)
+ for (const auto& button : qAsConst(buttons))
{
const auto buttonID = m_ToolButtonGroup->id(button);
const auto toolID = m_ToolIDForButtonID[buttonID];
const auto tool = m_ToolManager->GetToolById(toolID);
button->setEnabled(tool->CanHandle(refData, workingData));
}
}
void QmitkToolSelectionBox::RecreateButtons()
{
if (m_ToolManager.IsNull())
return;
QList<QAbstractButton *> l = m_ToolButtonGroup->buttons();
// remove all buttons that are there
QList<QAbstractButton *>::iterator it;
QAbstractButton *btn;
for (it = l.begin(); it != l.end(); ++it)
{
btn = *it;
m_ToolButtonGroup->removeButton(btn);
delete btn;
}
mitk::ToolManager::ToolVectorTypeConst allPossibleTools = m_ToolManager->GetTools();
mitk::ToolManager::ToolVectorTypeConst allTools;
typedef std::pair<std::string::size_type, const mitk::Tool *> SortPairType;
typedef std::priority_queue<SortPairType> SortedToolQueueType;
SortedToolQueueType toolPositions;
// clear and sort all tools
// step one: find name/group of all tools in m_DisplayedGroups string. remember these positions for all tools.
for (mitk::ToolManager::ToolVectorTypeConst::const_iterator iter = allPossibleTools.begin();
iter != allPossibleTools.end();
++iter)
{
const mitk::Tool *tool = *iter;
std::string::size_type namePos = m_DisplayedGroups.find(std::string("'") + tool->GetName() + "'");
std::string::size_type groupPos = m_DisplayedGroups.find(std::string("'") + tool->GetGroup() + "'");
if (!m_DisplayedGroups.empty() && namePos == std::string::npos && groupPos == std::string::npos)
continue; // skip
if (m_DisplayedGroups.empty() && std::string(tool->GetName()).length() > 0)
{
namePos = static_cast<std::string::size_type>(tool->GetName()[0]);
}
SortPairType thisPair = std::make_pair(namePos < groupPos ? namePos : groupPos, *iter);
toolPositions.push(thisPair);
}
// step two: sort tools according to previously found positions in m_DisplayedGroups
MITK_DEBUG << "Sorting order of tools (lower number --> earlier in button group)";
while (!toolPositions.empty())
{
SortPairType thisPair = toolPositions.top();
MITK_DEBUG << "Position " << thisPair.first << " : " << thisPair.second->GetName();
allTools.push_back(thisPair.second);
toolPositions.pop();
}
std::reverse(allTools.begin(), allTools.end());
MITK_DEBUG << "Sorted tools:";
for (mitk::ToolManager::ToolVectorTypeConst::const_iterator iter = allTools.begin(); iter != allTools.end(); ++iter)
{
MITK_DEBUG << (*iter)->GetName();
}
if (m_ButtonLayout == nullptr)
m_ButtonLayout = new QGridLayout;
int row(0);
int column(-1);
int currentButtonID(0);
m_ButtonIDForToolID.clear();
m_ToolIDForButtonID.clear();
QToolButton *button = nullptr;
MITK_DEBUG << "Creating buttons for tools";
// fill group box with buttons
for (mitk::ToolManager::ToolVectorTypeConst::const_iterator iter = allTools.begin(); iter != allTools.end(); ++iter)
{
const mitk::Tool *tool = *iter;
int currentToolID(m_ToolManager->GetToolID(tool));
++column;
// new line if we are at the maximum columns
if (column == m_LayoutColumns)
{
++row;
column = 0;
}
button = new QToolButton;
button->setSizePolicy(QSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum));
// add new button to the group
MITK_DEBUG << "Adding button with ID " << currentToolID;
m_ToolButtonGroup->addButton(button, currentButtonID);
// ... and to the layout
MITK_DEBUG << "Adding button in row/column " << row << "/" << column;
m_ButtonLayout->addWidget(button, row, column);
if (m_LayoutColumns == 1)
{
button->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
}
else
{
button->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
}
button->setCheckable(true);
if (currentToolID == m_ToolManager->GetActiveToolID())
button->setChecked(true);
QString label;
if (m_GenerateAccelerators)
{
label += "&";
}
label += tool->GetName();
QString tooltip = tool->GetName();
MITK_DEBUG << tool->GetName() << ", " << label.toLocal8Bit().constData() << ", '"
<< tooltip.toLocal8Bit().constData();
if (m_ShowNames)
{
button->setText(label); // a label
button->setToolTip(tooltip);
QFont currentFont = button->font();
currentFont.setBold(false);
button->setFont(currentFont);
}
us::ModuleResource iconResource = tool->GetIconResource();
if (!iconResource.IsValid())
{
button->setIcon(QIcon(QPixmap(tool->GetXPM())));
}
else
{
auto isSVG = "svg" == iconResource.GetSuffix();
auto openmode = isSVG ? std::ios_base::in : std::ios_base::binary;
us::ModuleResourceStream resourceStream(iconResource, openmode);
resourceStream.seekg(0, std::ios::end);
std::ios::pos_type length = resourceStream.tellg();
resourceStream.seekg(0, std::ios::beg);
char *data = new char[length];
resourceStream.read(data, length);
if (isSVG)
{
button->setIcon(QmitkStyleManager::ThemeIcon(QByteArray::fromRawData(data, length)));
}
else
{
QPixmap pixmap;
pixmap.loadFromData(QByteArray::fromRawData(data, length));
button->setIcon(QIcon(pixmap));
}
delete[] data;
if (m_ShowNames)
{
if (m_LayoutColumns == 1)
button->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
else
button->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
button->setIconSize(QSize(24, 24));
}
else
{
button->setToolButtonStyle(Qt::ToolButtonIconOnly);
button->setIconSize(QSize(32, 32));
button->setToolTip(tooltip);
}
}
if (m_GenerateAccelerators)
{
QString firstLetter = QString(tool->GetName());
firstLetter.truncate(1);
button->setShortcut(
firstLetter); // a keyboard shortcut (just the first letter of the given name w/o any CTRL or something)
}
m_ButtonIDForToolID[currentToolID] = currentButtonID;
m_ToolIDForButtonID[currentButtonID] = currentToolID;
MITK_DEBUG << "m_ButtonIDForToolID[" << currentToolID << "] == " << currentButtonID;
MITK_DEBUG << "m_ToolIDForButtonID[" << currentButtonID << "] == " << currentToolID;
tool->GUIProcessEventsMessage += mitk::MessageDelegate<QmitkToolSelectionBox>(
this, &QmitkToolSelectionBox::OnToolGUIProcessEventsMessage); // will never add a listener twice, so we don't have
// to check here
tool->ErrorMessage += mitk::MessageDelegate1<QmitkToolSelectionBox, std::string>(
this,
&QmitkToolSelectionBox::OnToolErrorMessage); // will never add a listener twice, so we don't have to check here
tool->GeneralMessage +=
mitk::MessageDelegate1<QmitkToolSelectionBox, std::string>(this, &QmitkToolSelectionBox::OnGeneralToolMessage);
++currentButtonID;
}
// setting grid layout for this groupbox
this->setLayout(m_ButtonLayout);
this->UpdateButtonsEnabledState();
// this->update();
}
void QmitkToolSelectionBox::OnToolGUIProcessEventsMessage()
{
qApp->processEvents();
}
void QmitkToolSelectionBox::OnToolErrorMessage(std::string s)
{
QMessageBox::critical(
this, "MITK", QString(s.c_str()), QMessageBox::Ok, QMessageBox::NoButton, QMessageBox::NoButton);
}
void QmitkToolSelectionBox::OnGeneralToolMessage(std::string s)
{
QMessageBox::information(
this, "MITK", QString(s.c_str()), QMessageBox::Ok, QMessageBox::NoButton, QMessageBox::NoButton);
}
void QmitkToolSelectionBox::SetDisplayedToolGroups(const std::string &toolGroups)
{
if (m_DisplayedGroups != toolGroups)
{
QString q_DisplayedGroups = toolGroups.c_str();
// quote all unquoted single words
q_DisplayedGroups = q_DisplayedGroups.replace(QRegExp("\\b(\\w+)\\b|'([^']+)'"), "'\\1\\2'");
MITK_DEBUG << "m_DisplayedGroups was \"" << toolGroups << "\"";
m_DisplayedGroups = q_DisplayedGroups.toLocal8Bit().constData();
MITK_DEBUG << "m_DisplayedGroups is \"" << m_DisplayedGroups << "\"";
RecreateButtons();
SetOrUnsetButtonForActiveTool();
}
}
void QmitkToolSelectionBox::SetLayoutColumns(int columns)
{
if (columns > 0 && columns != m_LayoutColumns)
{
m_LayoutColumns = columns;
RecreateButtons();
}
}
void QmitkToolSelectionBox::SetShowNames(bool show)
{
if (show != m_ShowNames)
{
m_ShowNames = show;
RecreateButtons();
}
}
void QmitkToolSelectionBox::SetGenerateAccelerators(bool accel)
{
if (accel != m_GenerateAccelerators)
{
m_GenerateAccelerators = accel;
RecreateButtons();
}
}
void QmitkToolSelectionBox::SetToolGUIArea(QWidget *parentWidget)
{
m_ToolGUIWidget = parentWidget;
}
void QmitkToolSelectionBox::setTitle(const QString & /*title*/)
{
}
void QmitkToolSelectionBox::showEvent(QShowEvent *e)
{
QWidget::showEvent(e);
SetGUIEnabledAccordingToToolManagerState();
}
void QmitkToolSelectionBox::hideEvent(QHideEvent *e)
{
QWidget::hideEvent(e);
SetGUIEnabledAccordingToToolManagerState();
}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkWatershedToolGUI.cpp b/Modules/SegmentationUI/Qmitk/QmitkWatershedToolGUI.cpp
index 41c3151292..fda699f8d4 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkWatershedToolGUI.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkWatershedToolGUI.cpp
@@ -1,199 +1,139 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkWatershedToolGUI.h"
+#include "mitkWatershedTool.h"
#include <QMessageBox>
MITK_TOOL_GUI_MACRO(MITKSEGMENTATIONUI_EXPORT, QmitkWatershedToolGUI, "")
-QmitkWatershedToolGUI::QmitkWatershedToolGUI() : QmitkToolGUI()
+QmitkWatershedToolGUI::QmitkWatershedToolGUI() : QmitkAutoMLSegmentationToolGUIBase()
+{
+}
+
+void QmitkWatershedToolGUI::ConnectNewTool(mitk::AutoSegmentationWithPreviewTool* newTool)
+{
+ Superclass::ConnectNewTool(newTool);
+
+ auto tool = dynamic_cast<mitk::WatershedTool*>(newTool);
+ if (nullptr != tool)
+ {
+ tool->SetLevel(m_Level);
+ tool->SetThreshold(m_Threshold);
+ }
+
+ newTool->IsTimePointChangeAwareOff();
+}
+
+void QmitkWatershedToolGUI::InitializeUI(QBoxLayout* mainLayout)
{
m_Controls.setupUi(this);
m_Controls.thresholdSlider->setMinimum(0);
//We set the threshold maximum to 0.5 to avoid crashes in the watershed filter
//see T27703 for more details.
m_Controls.thresholdSlider->setMaximum(0.5);
m_Controls.thresholdSlider->setValue(m_Threshold);
m_Controls.thresholdSlider->setPageStep(0.01);
m_Controls.thresholdSlider->setSingleStep(0.001);
m_Controls.thresholdSlider->setDecimals(4);
m_Controls.levelSlider->setMinimum(0);
m_Controls.levelSlider->setMaximum(1);
m_Controls.levelSlider->setValue(m_Level);
m_Controls.levelSlider->setPageStep(0.1);
m_Controls.levelSlider->setSingleStep(0.01);
connect(m_Controls.previewButton, SIGNAL(clicked()), this, SLOT(OnSettingsAccept()));
- connect(m_Controls.m_selectionListWidget, &QmitkSimpleLabelSetListWidget::SelectedLabelsChanged, this, &QmitkWatershedToolGUI::OnRegionSelectionChanged);
connect(m_Controls.levelSlider, SIGNAL(valueChanged(double)), this, SLOT(OnLevelChanged(double)));
connect(m_Controls.thresholdSlider, SIGNAL(valueChanged(double)), this, SLOT(OnThresholdChanged(double)));
- connect(m_Controls.m_ConfSegButton, SIGNAL(clicked()), this, SLOT(OnSegmentationRegionAccept()));
- connect(this, SIGNAL(NewToolAssociated(mitk::Tool *)), this, SLOT(OnNewToolAssociated(mitk::Tool *)));
-}
-
-QmitkWatershedToolGUI::~QmitkWatershedToolGUI()
-{
- if (m_WatershedTool.IsNotNull())
- {
- m_WatershedTool->CurrentlyBusy -=
- mitk::MessageDelegate1<QmitkWatershedToolGUI, bool>(this, &QmitkWatershedToolGUI::BusyStateChanged);
- }
-}
-
-void QmitkWatershedToolGUI::OnRegionSelectionChanged(const QmitkSimpleLabelSetListWidget::LabelVectorType& selectedLabels)
-{
- if (m_WatershedTool.IsNotNull())
- {
- mitk::AutoMLSegmentationWithPreviewTool::SelectedLabelVectorType labelIDs;
- for (const auto& label : selectedLabels)
- {
- labelIDs.push_back(label->GetValue());
- }
-
- m_WatershedTool->SetSelectedLabels(labelIDs);
- m_WatershedTool->UpdatePreview();
-
- m_Controls.m_ConfSegButton->setEnabled(!labelIDs.empty());
- }
-}
-void QmitkWatershedToolGUI::OnNewToolAssociated(mitk::Tool *tool)
-{
- if (m_WatershedTool.IsNotNull())
- {
- m_WatershedTool->CurrentlyBusy -=
- mitk::MessageDelegate1<QmitkWatershedToolGUI, bool>(this, &QmitkWatershedToolGUI::BusyStateChanged);
- }
-
- m_WatershedTool = dynamic_cast<mitk::WatershedTool *>(tool);
-
- if (m_WatershedTool.IsNotNull())
- {
- m_WatershedTool->CurrentlyBusy +=
- mitk::MessageDelegate1<QmitkWatershedToolGUI, bool>(this, &QmitkWatershedToolGUI::BusyStateChanged);
-
- m_WatershedTool->SetLevel(m_Level);
- m_WatershedTool->SetThreshold(m_Threshold);
+ mainLayout->addLayout(m_Controls.verticalLayout);
- m_WatershedTool->SetOverwriteExistingSegmentation(true);
- m_WatershedTool->IsTimePointChangeAwareOff();
- m_Controls.m_CheckProcessAll->setVisible(m_WatershedTool->GetTargetSegmentationNode()->GetData()->GetTimeSteps() > 1);
- }
-}
-
-void QmitkWatershedToolGUI::OnSegmentationRegionAccept()
-{
- QString segName = QString::fromStdString(m_WatershedTool->GetCurrentSegmentationName());
-
- if (m_WatershedTool.IsNotNull())
- {
- if (this->m_Controls.m_CheckCreateNew->isChecked())
- {
- m_WatershedTool->SetOverwriteExistingSegmentation(false);
- }
- else
- {
- m_WatershedTool->SetOverwriteExistingSegmentation(true);
- }
-
- m_WatershedTool->SetCreateAllTimeSteps(this->m_Controls.m_CheckProcessAll->isChecked());
-
- this->m_Controls.m_ConfSegButton->setEnabled(false);
- m_WatershedTool->ConfirmSegmentation();
- }
+ Superclass::InitializeUI(mainLayout);
}
void QmitkWatershedToolGUI::OnSettingsAccept()
{
- if (m_WatershedTool.IsNotNull())
+ auto tool = this->GetConnectedToolAs<mitk::WatershedTool>();
+ if (nullptr != tool)
{
try
{
m_Threshold = m_Controls.thresholdSlider->value();
m_Level = m_Controls.levelSlider->value();
- m_WatershedTool->SetThreshold(m_Threshold);
- m_WatershedTool->SetLevel(m_Level);
+ tool->SetThreshold(m_Threshold);
+ tool->SetLevel(m_Level);
- m_WatershedTool->UpdatePreview();
+ tool->UpdatePreview();
}
catch (const std::exception& e)
{
this->setCursor(Qt::ArrowCursor);
std::stringstream stream;
stream << "Error while generation watershed segmentation. Reason: " << e.what();
QMessageBox* messageBox =
new QMessageBox(QMessageBox::Critical,
nullptr, stream.str().c_str());
messageBox->exec();
delete messageBox;
MITK_ERROR << stream.str();
return;
}
catch (...)
{
this->setCursor(Qt::ArrowCursor);
std::stringstream stream;
stream << "Unkown error occured while generation watershed segmentation.";
QMessageBox* messageBox =
new QMessageBox(QMessageBox::Critical,
nullptr, stream.str().c_str());
messageBox->exec();
delete messageBox;
MITK_ERROR << stream.str();
return;
}
- m_Controls.m_selectionListWidget->SetLabelSetImage(m_WatershedTool->GetMLPreview());
- m_WatershedTool->IsTimePointChangeAwareOn();
+ this->SetLabelSetPreview(tool->GetMLPreview());
+ tool->IsTimePointChangeAwareOn();
}
}
-void QmitkWatershedToolGUI::BusyStateChanged(bool value)
+void QmitkWatershedToolGUI::EnableWidgets(bool enabled)
{
- if (value)
- {
- QApplication::setOverrideCursor(QCursor(Qt::BusyCursor));
- }
- else
- {
- QApplication::restoreOverrideCursor();
- }
-
- m_Controls.levelSlider->setEnabled(!value);
- m_Controls.thresholdSlider->setEnabled(!value);
- m_Controls.m_ConfSegButton->setEnabled(!m_WatershedTool->GetSelectedLabels().empty() && !value);
- m_Controls.m_CheckProcessAll->setEnabled(!value);
- m_Controls.m_CheckCreateNew->setEnabled(!value);
- m_Controls.previewButton->setEnabled(!value);
+ Superclass::EnableWidgets(enabled);
+ m_Controls.levelSlider->setEnabled(enabled);
+ m_Controls.thresholdSlider->setEnabled(enabled);
+ m_Controls.previewButton->setEnabled(enabled);
}
void QmitkWatershedToolGUI::OnLevelChanged(double value)
{
- if (m_WatershedTool.IsNotNull())
+ auto tool = this->GetConnectedToolAs<mitk::WatershedTool>();
+ if (nullptr != tool)
{
- m_WatershedTool->SetLevel(value);
+ tool->SetLevel(value);
}
}
void QmitkWatershedToolGUI::OnThresholdChanged(double value)
{
- if (m_WatershedTool.IsNotNull())
+ auto tool = this->GetConnectedToolAs<mitk::WatershedTool>();
+ if (nullptr != tool)
{
- m_WatershedTool->SetThreshold(value);
+ tool->SetThreshold(value);
}
}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkWatershedToolGUI.h b/Modules/SegmentationUI/Qmitk/QmitkWatershedToolGUI.h
index c5b8bbe5f1..193257e01f 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkWatershedToolGUI.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkWatershedToolGUI.h
@@ -1,71 +1,66 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkWatershedToolGUI_h_Included
#define QmitkWatershedToolGUI_h_Included
-#include "QmitkToolGUI.h"
-#include "mitkWatershedTool.h"
+#include "QmitkAutoMLSegmentationToolGUIBase.h"
#include "ui_QmitkWatershedToolGUIControls.h"
#include <MitkSegmentationUIExports.h>
/**
\ingroup org_mitk_gui_qt_interactivesegmentation_internal
\brief GUI for mitk::WatershedTool.
\sa mitk::WatershedTool
This GUI shows two sliders to change the watershed parameters. It executes the watershed algorithm by clicking on the
button.
*/
-class MITKSEGMENTATIONUI_EXPORT QmitkWatershedToolGUI : public QmitkToolGUI
+class MITKSEGMENTATIONUI_EXPORT QmitkWatershedToolGUI : public QmitkAutoMLSegmentationToolGUIBase
{
Q_OBJECT
public:
- mitkClassMacro(QmitkWatershedToolGUI, QmitkToolGUI);
+ mitkClassMacro(QmitkWatershedToolGUI, QmitkAutoMLSegmentationToolGUIBase);
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
protected slots :
- void OnNewToolAssociated(mitk::Tool *);
-
void OnSettingsAccept();
- void OnSegmentationRegionAccept();
-
- void OnRegionSelectionChanged(const QmitkSimpleLabelSetListWidget::LabelVectorType& selectedLabels);
-
void OnLevelChanged(double value);
void OnThresholdChanged(double value);
protected:
QmitkWatershedToolGUI();
- ~QmitkWatershedToolGUI() override;
+ ~QmitkWatershedToolGUI() = default;
+
+ void ConnectNewTool(mitk::AutoSegmentationWithPreviewTool* newTool) override;
+ void InitializeUI(QBoxLayout* mainLayout) override;
- void BusyStateChanged(bool value) override;
+ void EnableWidgets(bool enabled) override;
//Recommendation from ITK is to have a threshold:level ration around 1:100
//we set Level a bit higher. This provokes more oversegmentation,
//but produces less objects in the first run and profits form the fact that
//decreasing level is quite fast in the filter.
double m_Level = 0.6;
double m_Threshold = 0.004;
Ui_QmitkWatershedToolGUIControls m_Controls;
- mitk::WatershedTool::Pointer m_WatershedTool;
};
#endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkWatershedToolGUIControls.ui b/Modules/SegmentationUI/Qmitk/QmitkWatershedToolGUIControls.ui
index 4c4931c08a..4ce970d215 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkWatershedToolGUIControls.ui
+++ b/Modules/SegmentationUI/Qmitk/QmitkWatershedToolGUIControls.ui
@@ -1,160 +1,109 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>QmitkWatershedToolGUIControls</class>
<widget class="QWidget" name="QmitkWatershedToolGUIControls">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>192</width>
<height>352</height>
</rect>
</property>
<property name="sizePolicy">
<sizepolicy hsizetype="Ignored" vsizetype="Minimum">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="minimumSize">
<size>
<width>100</width>
<height>0</height>
</size>
</property>
<property name="maximumSize">
<size>
<width>100000</width>
<height>100000</height>
</size>
</property>
<property name="windowTitle">
<string>QmitkOtsuToolWidget</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
+ <property name="leftMargin">
+ <number>0</number>
+ </property>
+ <property name="topMargin">
+ <number>0</number>
+ </property>
+ <property name="rightMargin">
+ <number>0</number>
+ </property>
+ <property name="bottomMargin">
+ <number>0</number>
+ </property>
<item>
<layout class="QGridLayout" name="advancedSettingsLayout">
<item row="1" column="0">
<widget class="QLabel" name="levelLabel">
<property name="text">
<string>Level:</string>
</property>
</widget>
</item>
<item row="0" column="0">
<widget class="QLabel" name="thresholdLabel">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Preferred">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="text">
<string>Threshold:</string>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="ctkSliderWidget" name="thresholdSlider" native="true"/>
</item>
<item row="1" column="1">
<widget class="ctkSliderWidget" name="levelSlider" native="true"/>
</item>
</layout>
</item>
- <item>
- <widget class="QmitkSimpleLabelSetListWidget" name="m_selectionListWidget" native="true">
- <property name="sizePolicy">
- <sizepolicy hsizetype="Minimum" vsizetype="MinimumExpanding">
- <horstretch>0</horstretch>
- <verstretch>0</verstretch>
- </sizepolicy>
- </property>
- <property name="maximumSize">
- <size>
- <width>10000000</width>
- <height>10000000</height>
- </size>
- </property>
- </widget>
- </item>
<item>
<widget class="QPushButton" name="previewButton">
<property name="sizePolicy">
<sizepolicy hsizetype="Minimum" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="maximumSize">
<size>
<width>100000</width>
<height>16777215</height>
</size>
</property>
<property name="text">
<string>Preview</string>
</property>
</widget>
</item>
- <item>
- <widget class="QPushButton" name="m_ConfSegButton">
- <property name="enabled">
- <bool>false</bool>
- </property>
- <property name="sizePolicy">
- <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
- <horstretch>0</horstretch>
- <verstretch>0</verstretch>
- </sizepolicy>
- </property>
- <property name="maximumSize">
- <size>
- <width>100000</width>
- <height>16777215</height>
- </size>
- </property>
- <property name="text">
- <string>Confirm Segmentation</string>
- </property>
- </widget>
- </item>
- <item>
- <widget class="QCheckBox" name="m_CheckProcessAll">
- <property name="toolTip">
- <string>Process/overwrite all time steps of the dynamic segmentation and not just the currently visible time step.</string>
- </property>
- <property name="text">
- <string>Process all time steps</string>
- </property>
- </widget>
- </item>
- <item>
- <widget class="QCheckBox" name="m_CheckCreateNew">
- <property name="toolTip">
- <string>Add the confirmed segmentation as a new segmentation instead of overwriting the currently selected.</string>
- </property>
- <property name="text">
- <string>Create as new segmentation</string>
- </property>
- </widget>
- </item>
</layout>
</widget>
<layoutdefault spacing="6" margin="11"/>
<customwidgets>
- <customwidget>
- <class>QmitkSimpleLabelSetListWidget</class>
- <extends>QWidget</extends>
- <header>QmitkSimpleLabelSetListWidget.h</header>
- </customwidget>
<customwidget>
<class>ctkSliderWidget</class>
<extends>QWidget</extends>
<header location="global">ctkSliderWidget.h</header>
<container>1</container>
</customwidget>
</customwidgets>
<resources/>
<connections/>
</ui>
diff --git a/Modules/SegmentationUI/files.cmake b/Modules/SegmentationUI/files.cmake
index d84231e8a4..fb35d7707a 100644
--- a/Modules/SegmentationUI/files.cmake
+++ b/Modules/SegmentationUI/files.cmake
@@ -1,84 +1,91 @@
set( CPP_FILES
Qmitk/QmitkAdaptiveRegionGrowingToolGUI.cpp
+Qmitk/QmitkAutoSegmentationToolGUIBase.cpp
+Qmitk/QmitkAutoMLSegmentationToolGUIBase.cpp
+Qmitk/QmitkBinaryThresholdToolGUIBase.cpp
Qmitk/QmitkBinaryThresholdToolGUI.cpp
Qmitk/QmitkBinaryThresholdULToolGUI.cpp
Qmitk/QmitkCalculateGrayValueStatisticsToolGUI.cpp
Qmitk/QmitkConfirmSegmentationDialog.cpp
Qmitk/QmitkCopyToClipBoardDialog.cpp
Qmitk/QmitkDrawPaintbrushToolGUI.cpp
Qmitk/QmitkErasePaintbrushToolGUI.cpp
+Qmitk/QmitkFastMarchingToolGUIBase.cpp
Qmitk/QmitkFastMarchingTool3DGUI.cpp
Qmitk/QmitkFastMarchingToolGUI.cpp
-
Qmitk/QmitkLiveWireTool2DGUI.cpp
Qmitk/QmitkNewSegmentationDialog.cpp
Qmitk/QmitkOtsuTool3DGUI.cpp
Qmitk/QmitkPaintbrushToolGUI.cpp
Qmitk/QmitkPickingToolGUI.cpp
Qmitk/QmitkPixelManipulationToolGUI.cpp
Qmitk/QmitkSlicesInterpolator.cpp
Qmitk/QmitkToolGUI.cpp
Qmitk/QmitkToolGUIArea.cpp
Qmitk/QmitkToolSelectionBox.cpp
Qmitk/QmitkWatershedToolGUI.cpp
#Added from ML
Qmitk/QmitkLabelSetWidget.cpp
Qmitk/QmitkSurfaceStampWidget.cpp
Qmitk/QmitkMaskStampWidget.cpp
Qmitk/QmitkSliceBasedInterpolatorWidget.cpp
Qmitk/QmitkSurfaceBasedInterpolatorWidget.cpp
Qmitk/QmitkSearchLabelDialog.cpp
Qmitk/QmitkSimpleLabelSetListWidget.cpp
)
set(MOC_H_FILES
Qmitk/QmitkAdaptiveRegionGrowingToolGUI.h
+Qmitk/QmitkAutoSegmentationToolGUIBase.h
+Qmitk/QmitkAutoMLSegmentationToolGUIBase.h
+Qmitk/QmitkBinaryThresholdToolGUIBase.h
Qmitk/QmitkBinaryThresholdToolGUI.h
Qmitk/QmitkBinaryThresholdULToolGUI.h
Qmitk/QmitkCalculateGrayValueStatisticsToolGUI.h
Qmitk/QmitkConfirmSegmentationDialog.h
Qmitk/QmitkCopyToClipBoardDialog.h
Qmitk/QmitkDrawPaintbrushToolGUI.h
Qmitk/QmitkErasePaintbrushToolGUI.h
+Qmitk/QmitkFastMarchingToolGUIBase.h
Qmitk/QmitkFastMarchingTool3DGUI.h
Qmitk/QmitkFastMarchingToolGUI.h
Qmitk/QmitkLiveWireTool2DGUI.h
Qmitk/QmitkNewSegmentationDialog.h
Qmitk/QmitkOtsuTool3DGUI.h
Qmitk/QmitkPaintbrushToolGUI.h
Qmitk/QmitkPickingToolGUI.h
Qmitk/QmitkPixelManipulationToolGUI.h
Qmitk/QmitkSlicesInterpolator.h
Qmitk/QmitkToolGUI.h
Qmitk/QmitkToolGUIArea.h
Qmitk/QmitkToolSelectionBox.h
Qmitk/QmitkWatershedToolGUI.h
#Added from ML
Qmitk/QmitkLabelSetWidget.h
Qmitk/QmitkSurfaceStampWidget.h
Qmitk/QmitkMaskStampWidget.h
Qmitk/QmitkSliceBasedInterpolatorWidget.h
Qmitk/QmitkSurfaceBasedInterpolatorWidget.h
Qmitk/QmitkSearchLabelDialog.h
Qmitk/QmitkSimpleLabelSetListWidget.h
)
set(UI_FILES
Qmitk/QmitkAdaptiveRegionGrowingToolGUIControls.ui
Qmitk/QmitkConfirmSegmentationDialog.ui
Qmitk/QmitkOtsuToolWidgetControls.ui
Qmitk/QmitkPickingToolGUIControls.ui
Qmitk/QmitkLiveWireTool2DGUIControls.ui
Qmitk/QmitkWatershedToolGUIControls.ui
#Added from ML
Qmitk/QmitkLabelSetWidgetControls.ui
Qmitk/QmitkSurfaceStampWidgetGUIControls.ui
Qmitk/QmitkMaskStampWidgetGUIControls.ui
Qmitk/QmitkSliceBasedInterpolatorWidgetGUIControls.ui
Qmitk/QmitkSurfaceBasedInterpolatorWidgetGUIControls.ui
Qmitk/QmitkSearchLabelDialogGUI.ui
)
set(QRC_FILES
resources/SegmentationUI.qrc
)
diff --git a/Modules/SemanticRelationsUI/src/QmitkLesionTreeModel.cpp b/Modules/SemanticRelationsUI/src/QmitkLesionTreeModel.cpp
index c4f1dbb551..c4f2923b2e 100644
--- a/Modules/SemanticRelationsUI/src/QmitkLesionTreeModel.cpp
+++ b/Modules/SemanticRelationsUI/src/QmitkLesionTreeModel.cpp
@@ -1,298 +1,298 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
// semantic relations UI module
#include "QmitkLesionTreeModel.h"
// semantic relations module
#include <mitkControlPointManager.h>
#include <mitkLesionManager.h>
#include <mitkNodePredicates.h>
#include <mitkSemanticRelationException.h>
#include <mitkSemanticRelationsInference.h>
#include <mitkRelationStorage.h>
// qt
#include <QColor>
QmitkLesionTreeModel::QmitkLesionTreeModel(QObject* parent/* = nullptr*/)
: QmitkAbstractSemanticRelationsStorageModel(parent)
, m_LastSegmentation(nullptr)
, m_RootItem(std::make_shared<QmitkLesionTreeItem>(mitk::LesionData()))
{
// nothing here
}
//////////////////////////////////////////////////////////////////////////
// overridden virtual functions from QAbstractItemModel
//////////////////////////////////////////////////////////////////////////
QModelIndex QmitkLesionTreeModel::index(int row, int column, const QModelIndex& itemIndex) const
{
if (!hasIndex(row, column, itemIndex))
{
return QModelIndex();
}
auto childItem = GetItemByIndex(itemIndex)->GetChildInRow(row);
if (nullptr == childItem)
{
return QModelIndex();
}
return createIndex(row, column, childItem.get());
}
QModelIndex QmitkLesionTreeModel::parent(const QModelIndex& itemIndex) const
{
if (!itemIndex.isValid())
{
return QModelIndex();
}
auto parentItem = GetItemByIndex(itemIndex)->GetParent();
if (parentItem.expired())
{
return QModelIndex();
}
auto sharedParent = parentItem.lock();
if (sharedParent == m_RootItem)
{
return QModelIndex();
}
return createIndex(sharedParent->GetRow(), 0, sharedParent.get());
}
int QmitkLesionTreeModel::rowCount(const QModelIndex& itemIndex/* = QModelIndex()*/) const
{
return GetItemByIndex(itemIndex)->ChildCount();
}
int QmitkLesionTreeModel::columnCount(const QModelIndex&/* itemIndex = QModelIndex() */) const
{
if (0 == m_RootItem->ChildCount())
{
// no lesion items stored, no need to display columns
return 0;
}
return m_ControlPoints.size() + 1;
}
QVariant QmitkLesionTreeModel::data(const QModelIndex& index, int role) const
{
if (!index.isValid())
{
return QVariant();
}
if (index.column() < 0 || index.column() > static_cast<int>(m_ControlPoints.size()))
{
return QVariant();
}
QmitkLesionTreeItem* currentItem = GetItemByIndex(index);
if (Qt::DisplayRole == role)
{
if (currentItem->GetParent().expired())
{
return QVariant();
}
auto parentItem = currentItem->GetParent().lock();
// parent exists and is the root item -> 1. item of a lesion entry
if (m_RootItem == parentItem)
{
// display role fills the first columns with the lesion UID / name
if (0 == index.column())
{
std::string itemString = currentItem->GetData().GetLesionName();
if (itemString.empty())
{
itemString = currentItem->GetData().GetLesionUID();
}
return QString::fromStdString(itemString);
}
else
{
// display role fills other columns with the lesion presence info
const auto lesionPresence = currentItem->GetData().GetLesionPresence();
if (index.column() - 1 > static_cast<int>(lesionPresence.size()))
{
return "N/A";
}
if (lesionPresence.at(index.column() - 1))
{
return QString::fromStdString("present");
}
return QString::fromStdString("not present");
}
}
}
if (Qt::BackgroundColorRole == role)
{
auto it = m_DataNodePresence.find(currentItem->GetData().GetLesion().UID);
if (it != m_DataNodePresence.end())
{
return it->second ? QVariant(QColor(Qt::darkGreen)) : QVariant(QColor(Qt::transparent));
}
return QVariant(QColor(Qt::transparent));
}
if (Qt::UserRole == role)
{
return QVariant::fromValue(currentItem);
}
return QVariant();
}
QVariant QmitkLesionTreeModel::headerData(int section, Qt::Orientation orientation, int role) const
{
if (0 == m_RootItem->ChildCount())
{
// no lesion items stored, no need to display the header
return QVariant();
}
if (Qt::Horizontal == orientation && Qt::DisplayRole == role)
{
if (0 == section)
{
return QVariant("Lesion");
}
if (static_cast<int>(m_ControlPoints.size()) >= section)
{
mitk::SemanticTypes::ControlPoint currentControlPoint = m_ControlPoints.at(section-1);
return QVariant(QString::fromStdString(currentControlPoint.ToString()));
}
}
return QVariant();
}
const mitk::DataNode* QmitkLesionTreeModel::GetLastSegmentation() const
{
return m_LastSegmentation;
}
void QmitkLesionTreeModel::NodeAdded(const mitk::DataNode* dataNode)
{
if (mitk::NodePredicates::GetSegmentationPredicate()->CheckNode(dataNode))
{
m_LastSegmentation = dataNode;
}
}
void QmitkLesionTreeModel::SetData()
{
m_RootItem = std::make_shared<QmitkLesionTreeItem>(mitk::LesionData());
// get all control points of current case
m_ControlPoints = mitk::RelationStorage::GetAllControlPointsOfCase(m_CaseID);
// sort the vector of control points for the timeline
std::sort(m_ControlPoints.begin(), m_ControlPoints.end());
SetLesionData();
SetSelectedDataNodesPresence();
}
void QmitkLesionTreeModel::SetLesionData()
{
m_CurrentLesions = mitk::RelationStorage::GetAllLesionsOfCase(m_CaseID);
for (auto& lesion : m_CurrentLesions)
{
AddLesion(lesion);
}
}
void QmitkLesionTreeModel::AddLesion(const mitk::SemanticTypes::Lesion& lesion)
{
if (m_DataStorage.IsExpired())
{
return;
}
auto dataStorage = m_DataStorage.Lock();
// create new lesion tree item data and modify it according to the control point data
mitk::LesionData lesionData(lesion);
mitk::ComputeLesionPresence(lesionData, m_CaseID);
// add the top-level lesion item to the root item
std::shared_ptr<QmitkLesionTreeItem> newLesionTreeItem = std::make_shared<QmitkLesionTreeItem>(lesionData);
m_RootItem->AddChild(newLesionTreeItem);
}
void QmitkLesionTreeModel::SetSelectedDataNodesPresence()
{
m_DataNodePresence.clear();
- for (const auto& dataNode : m_SelectedDataNodes)
+ for (const auto& dataNode : qAsConst(m_SelectedDataNodes))
{
if (!mitk::SemanticRelationsInference::InstanceExists(dataNode))
{
continue;
}
for (const auto& lesion : m_CurrentLesions)
{
if (!mitk::SemanticRelationsInference::InstanceExists(m_CaseID, lesion))
{
continue;
}
try
{
// set the lesion presence for the current node
bool dataNodePresence = mitk::SemanticRelationsInference::IsLesionPresent(lesion, dataNode);
SetDataNodePresenceOfLesion(&lesion, dataNodePresence);
}
catch (const mitk::SemanticRelationException&)
{
continue;
}
}
}
}
void QmitkLesionTreeModel::SetDataNodePresenceOfLesion(const mitk::SemanticTypes::Lesion* lesion, bool dataNodePresence)
{
std::map<mitk::SemanticTypes::ID, bool>::iterator iter = m_DataNodePresence.find(lesion->UID);
if (iter != m_DataNodePresence.end())
{
// key already existing, overwrite already stored bool value
iter->second = dataNodePresence;
}
else
{
m_DataNodePresence.insert(std::make_pair(lesion->UID, dataNodePresence));
}
}
QmitkLesionTreeItem* QmitkLesionTreeModel::GetItemByIndex(const QModelIndex& index) const
{
if (index.isValid())
{
auto item = static_cast<QmitkLesionTreeItem*>(index.internalPointer());
if (nullptr != item)
{
return item;
}
}
return m_RootItem.get();
}
diff --git a/Modules/SemanticRelationsUI/src/QmitkPatientTableHeaderView.cpp b/Modules/SemanticRelationsUI/src/QmitkPatientTableHeaderView.cpp
index 4c053d9b93..7348ebcfda 100644
--- a/Modules/SemanticRelationsUI/src/QmitkPatientTableHeaderView.cpp
+++ b/Modules/SemanticRelationsUI/src/QmitkPatientTableHeaderView.cpp
@@ -1,240 +1,240 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
// semantic relations UI module
#include "QmitkPatientTableHeaderView.h"
// qt
#include <QPainter>
#include <QSize>
QmitkPatientTableHeaderView::QmitkPatientTableHeaderView(QWidget* parent/* = nullptr*/)
: QHeaderView(Qt::Horizontal, parent)
, m_HeaderModel(nullptr)
{
// nothing here
}
QmitkPatientTableHeaderView::~QmitkPatientTableHeaderView()
{
// nothing here
}
void QmitkPatientTableHeaderView::setModel(QAbstractItemModel* model)
{
// retrieve the header model from the given table model
QVariant variant = model->data(QModelIndex(), HorizontalHeaderDataRole);
if (variant.isValid() && variant.canConvert<QStandardItemModel*>())
{
m_HeaderModel = variant.value<QStandardItemModel*>();
}
QHeaderView::setModel(model);
}
void QmitkPatientTableHeaderView::paintSection(QPainter* painter, const QRect& rect, int logicalIndex) const
{
if (rect.isValid())
{
int top = rect.y();
QModelIndex leafIndex = HeaderIndex(logicalIndex);
QModelIndexList indexes = ParentIndexList(leafIndex);
- for (const auto& index : indexes)
+ for (const auto& index : qAsConst(indexes))
{
top = PaintHeader(painter, index, logicalIndex, rect, top);
}
return;
}
QHeaderView::paintSection(painter, rect, logicalIndex);
}
QSize QmitkPatientTableHeaderView::sectionSizeFromContents(int logicalIndex) const
{
if (nullptr != m_HeaderModel)
{
QModelIndex headerIndex = HeaderIndex(logicalIndex);
if (headerIndex.isValid())
{
QSize headerSize = HeaderSize(headerIndex);
headerIndex = headerIndex.parent();
while (headerIndex.isValid())
{
QSize currentHeaderSize = HeaderSize(headerIndex);
headerSize.rheight() += currentHeaderSize.height();
if (currentHeaderSize.width() > headerSize.width())
{
headerSize.rwidth() = currentHeaderSize.width();
}
headerIndex = headerIndex.parent();
}
return headerSize;
}
}
return QHeaderView::sectionSizeFromContents(logicalIndex);
}
int QmitkPatientTableHeaderView::PaintHeader(QPainter* painter, const QModelIndex& currentIndex, int logicalIndex, const QRect& sectionRect, int top) const
{
QModelIndex headerIndex = HeaderIndex(logicalIndex);
int height = HeaderSize(currentIndex).height();
if (currentIndex == headerIndex)
{
height = sectionRect.height() - top;
}
int left = CurrentHeaderLeft(currentIndex, headerIndex, logicalIndex, sectionRect.left());
int width = CurrentHeaderWidth(currentIndex, headerIndex, logicalIndex);
QStyleOptionHeader headerStyleOptions;
initStyleOption(&headerStyleOptions);
headerStyleOptions.text = currentIndex.data(Qt::DisplayRole).toString();
headerStyleOptions.textAlignment = Qt::AlignCenter;
painter->save();
QRect rect(left, top, width, height);
headerStyleOptions.rect = rect;
style()->drawControl(QStyle::CE_Header, &headerStyleOptions, painter, this);
painter->restore();
return top + height;
}
QSize QmitkPatientTableHeaderView::HeaderSize(const QModelIndex& index) const
{
QFont font = this->font();
font.setBold(true);
QFontMetrics fontMetrics(font);
QSize fontSize = fontMetrics.size(0, index.data(Qt::DisplayRole).toString());
QSize emptyFontSize = fontMetrics.size(0, "");
return fontSize + emptyFontSize;
}
int QmitkPatientTableHeaderView::CurrentHeaderLeft(const QModelIndex& currentIndex, const QModelIndex& headerIndex, int sectionIndex, int left) const
{
QModelIndexList headerList = ListHeader(currentIndex);
if (!headerList.empty())
{
int index = headerList.indexOf(headerIndex);
int firstHeaderSectionIndex = sectionIndex - index;
--index;
for (; index >= 0; --index)
{
left -= sectionSize(firstHeaderSectionIndex + index);
}
}
return left;
}
int QmitkPatientTableHeaderView::CurrentHeaderWidth(const QModelIndex& currentIndex, const QModelIndex& headerIndex, int sectionIndex) const
{
QModelIndexList headerList = ListHeader(currentIndex);
if (headerList.empty())
{
return sectionSize(sectionIndex);
}
int width = 0;
int index = headerList.indexOf(headerIndex);
int firstHeaderSectionIndex = sectionIndex - index;
for (int i = 0; i < headerList.size(); ++i)
{
width += sectionSize(firstHeaderSectionIndex + i);
}
return width;
}
QModelIndexList QmitkPatientTableHeaderView::ParentIndexList(QModelIndex index) const
{
QModelIndexList indexList;
while (index.isValid())
{
indexList.push_front(index);
index = index.parent();
}
return indexList;
}
QModelIndex QmitkPatientTableHeaderView::HeaderIndex(int sectionIndex) const
{
if (nullptr != m_HeaderModel)
{
int currentHeaderIndex = -1;
for (int i = 0; i < m_HeaderModel->columnCount(); ++i)
{
QModelIndex modelIndex = FindHeader(m_HeaderModel->index(0, i), sectionIndex, currentHeaderIndex);
if (modelIndex.isValid())
{
return modelIndex;
}
}
}
return QModelIndex();
}
QModelIndex QmitkPatientTableHeaderView::FindHeader(const QModelIndex& currentIndex, int sectionIndex, int& currentHeaderIndex) const
{
if (currentIndex.isValid())
{
int childCount = currentIndex.model()->columnCount(currentIndex);
if (childCount > 0)
{
for (int i = 0; i < childCount; ++i)
{
QModelIndex modelIndex = FindHeader(currentIndex.child(0, i), sectionIndex, currentHeaderIndex);
if (modelIndex.isValid())
{
return modelIndex;
}
}
}
else
{
++currentHeaderIndex;
if (currentHeaderIndex == sectionIndex)
{
return currentIndex;
}
}
}
return QModelIndex();
}
QModelIndexList QmitkPatientTableHeaderView::ListHeader(const QModelIndex& currentIndex) const
{
QModelIndexList headerList;
if (currentIndex.isValid())
{
int childCount = currentIndex.model()->columnCount(currentIndex);
if (childCount > 0)
{
for (int i = 0; i < childCount; ++i)
{
headerList += ListHeader(currentIndex.child(0, i));
}
}
else
{
headerList.push_back(currentIndex);
}
}
return headerList;
}
diff --git a/Modules/ToFHardware/PMD/mitkToFCameraPMDCamBoardController.h b/Modules/ToFHardware/PMD/mitkToFCameraPMDCamBoardController.h
index 99902033e7..f8d6258c4b 100644
--- a/Modules/ToFHardware/PMD/mitkToFCameraPMDCamBoardController.h
+++ b/Modules/ToFHardware/PMD/mitkToFCameraPMDCamBoardController.h
@@ -1,95 +1,94 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef __mitkToFCameraPMDCamBoardController_h
#define __mitkToFCameraPMDCamBoardController_h
#include "MitkPMDExports.h"
#include "mitkCommon.h"
#include "mitkToFCameraPMDController.h"
#include "itkObject.h"
#include "itkObjectFactory.h"
namespace mitk
{
/**
* @brief Interface to the Time-of-Flight (ToF) camera PMD CamBoard
*
*
* @ingroup ToFHardware
*/
class MITKPMD_EXPORT ToFCameraPMDCamBoardController : public ToFCameraPMDController
{
public:
mitkClassMacro( ToFCameraPMDCamBoardController , ToFCameraPMDController );
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
/*!
\brief opens a connection to the ToF camera and initializes the hardware specific members
\return returns whether the connection was successful (true) or not (false)
*/
virtual bool OpenCameraConnection();
/*!
\brief sets an additional distance offset which will be added to all distance values.
\param offset offset in m
*/
bool SetDistanceOffset( float offset );
/*!
\brief returns the currently applied distance offset in m
- \param offset offset in m
*/
float GetDistanceOffset();
/*!
\brief Setting the region of interest, the camera is configured to only output a certain area of the image.
\param leftUpperCornerX x value of left upper corner of region
\param leftUpperCornerY y value of left upper corner of region
\param width width of region
\param height height of region
*/
bool SetRegionOfInterest( unsigned int leftUpperCornerX, unsigned int leftUpperCornerY, unsigned int width, unsigned int height );
/*!
\brief Setting the region of interest, the camera is configured to only output a certain area of the image.
\param roi region of interest. roi[0]: x value of left upper corner, roi[1]: y value of left upper corner, roi[2]: width, roi[3]: height
*/
bool SetRegionOfInterest( unsigned int roi[4] );
/*!
\brief returns the region of interest currently set
\return currently set region of interest.
*/
unsigned int* GetRegionOfInterest();
/*!
\brief Sets the field of view of the camera lens.
\param fov field of view in degrees. The default value is 40 degrees.
*/
bool SetFieldOfView( float fov );
protected:
ToFCameraPMDCamBoardController();
~ToFCameraPMDCamBoardController();
/*
\brief Transform the output of the camera, i.e. cut invalid pixels, and rotate 90 degrees
counterclockwise
\param input data array of original size (207x204)
\param rotated output data array of reduced size (200x200)
*/
virtual void TransformCameraOutput(float* in, float* out, bool isDist);
};
} //END mitk namespace
#endif
diff --git a/Modules/ToFHardware/PMD/mitkToFCameraPMDCamCubeController.h b/Modules/ToFHardware/PMD/mitkToFCameraPMDCamCubeController.h
index b0c00d5d6a..6c83db4255 100644
--- a/Modules/ToFHardware/PMD/mitkToFCameraPMDCamCubeController.h
+++ b/Modules/ToFHardware/PMD/mitkToFCameraPMDCamCubeController.h
@@ -1,126 +1,125 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef __mitkToFCameraPMDCamCubeController_h
#define __mitkToFCameraPMDCamCubeController_h
#include <MitkPMDExports.h>
#include "mitkCommon.h"
#include "mitkToFCameraPMDController.h"
#include "itkObject.h"
#include "itkObjectFactory.h"
namespace mitk
{
/**
* @brief Interface to the Time-of-Flight (ToF) camera PMD CamCube
*
*
* @ingroup ToFHardware
*/
class MITKPMD_EXPORT ToFCameraPMDCamCubeController : public ToFCameraPMDController
{
public:
mitkClassMacro( ToFCameraPMDCamCubeController , ToFCameraPMDController );
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
/*!
\brief opens a connection to the ToF camera and initializes the hardware specific members
\return returns whether the connection was successful (true) or not (false)
*/
virtual bool OpenCameraConnection();
/*!
\brief sets an additional distance offset which will be added to all distance values.
\param offset offset in m
\return returns whether set operation was successful (true) or not (false)
*/
bool SetDistanceOffset( float offset );
/*!
\brief returns the currently applied distance offset in m
- \param offset offset in m
*/
float GetDistanceOffset();
/*!
\brief Setting the region of interest, the camera is configured to only output a certain area of the image.
\param leftUpperCornerX x value of left upper corner of region
\param leftUpperCornerY y value of left upper corner of region
\param width width of region
\param height height of region
\return returns whether set operation was successful (true) or not (false)
*/
bool SetRegionOfInterest( unsigned int leftUpperCornerX, unsigned int leftUpperCornerY, unsigned int width, unsigned int height );
/*!
\brief Setting the region of interest, the camera is configured to only output a certain area of the image.
\param roi region of interest. roi[0]: x value of left upper corner, roi[1]: y value of left upper corner, roi[2]: width, roi[3]: height
\return returns whether set operation was successful (true) or not (false)
*/
bool SetRegionOfInterest( unsigned int roi[4] );
/*!
\brief returns the region of interest currently set
\return currently set region of interest.
*/
unsigned int* GetRegionOfInterest();
/*!
\brief sets the exposure mode of the CamCube
\param mode exposure mode. 0: normal mode (one exposure), 1: Suppression of motion blur (SMB), minimizes the time needed to capture
a distance image from the camera which results in a reduced amount of motion artifact but may lead to increased noise.
\return returns whether set operation was successful (true) or not (false)
*/
bool SetExposureMode( int mode );
/*!
\brief Sets the field of view of the camera lens.
\param fov field of view in degrees. The default value is 40 degrees.
\return returns whether set operation was successful (true) or not (false)
*/
bool SetFieldOfView( float fov );
/*!
\brief Enable/Disable PMD fixed pattern noise (FPN) calibration
\param on enabled (true), disabled (false)
\return returns whether set operation was successful (true) or not (false)
*/
bool SetFPNCalibration( bool on );
/*!
\brief Enable/Disable PMD fixed pattern phase noise (FPPN) calibration
\param on enabled (true), disabled (false)
\return returns whether set operation was successful (true) or not (false)
*/
bool SetFPPNCalibration( bool on );
/*!
\brief Enable/Disable PMD linearity calibration
\param on enabled (true), disabled (false)
\return returns whether set operation was successful (true) or not (false)
*/
bool SetLinearityCalibration( bool on );
/*!
\brief Enable/Disable PMD lens calibration
\param on enabled (true), disabled (false)
\return returns whether set operation was successful (true) or not (false)
*/
bool SetLensCalibration( bool on );
protected:
virtual void TransformCameraOutput(float* in, float* out, bool isDist);
ToFCameraPMDCamCubeController();
~ToFCameraPMDCamCubeController();
private:
};
} //END mitk namespace
#endif
diff --git a/Plugins/org.blueberry.core.commands/src/berryParameterizedCommand.h b/Plugins/org.blueberry.core.commands/src/berryParameterizedCommand.h
index 1b4bc39516..acaf8bf4ff 100755
--- a/Plugins/org.blueberry.core.commands/src/berryParameterizedCommand.h
+++ b/Plugins/org.blueberry.core.commands/src/berryParameterizedCommand.h
@@ -1,334 +1,334 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef BERRYPARAMETERIZEDCOMMAND_H_
#define BERRYPARAMETERIZEDCOMMAND_H_
#include <berryObject.h>
#include <berryMacros.h>
#include "common/berryCommandExceptions.h"
#include <org_blueberry_core_commands_Export.h>
#include <list>
#include <map>
namespace berry
{
struct IParameter;
class Command;
class Parameterization;
/**
* <p>
* A command that has had one or more of its parameters specified. This class
* serves as a utility class for developers that need to manipulate commands
* with parameters. It handles the behaviour of generating a parameter map and a
* human-readable name.
* </p>
*/
class BERRY_COMMANDS ParameterizedCommand: public Object
{ //implements Comparable {
public:
berryObjectMacro(ParameterizedCommand);
/**
* The index of the parameter id in the parameter values.
*
* @deprecated no longer used
*/
static const int INDEX_PARAMETER_ID; // = 0;
/**
* The index of the human-readable name of the parameter itself, in the
* parameter values.
*
* @deprecated no longer used
*/
static const int INDEX_PARAMETER_NAME; // = 1;
/**
* The index of the human-readable name of the value of the parameter for
* this command.
*
* @deprecated no longer used
*/
static const int INDEX_PARAMETER_VALUE_NAME; // = 2;
/**
* The index of the value of the parameter that the command can understand.
*
* @deprecated no longer used
*/
static const int INDEX_PARAMETER_VALUE_VALUE; // = 3;
/**
* Constructs a new instance of <code>ParameterizedCommand</code> with
* specific values for zero or more of its parameters.
*
* @param command
* The command that is parameterized; must not be
* <code>null</code>.
* @param parameterizations
* An array of parameterizations binding parameters to values for
* the command. This value may be <code>null</code>.
*/
ParameterizedCommand(const SmartPointer<Command>& command,
const QList<Parameterization>& parameterizations);
bool operator<(const Object* object) const override;
bool operator==(const Object* object) const override;
/**
* Executes this command with its parameters. This does extra checking to
* see if the command is enabled and defined. If it is not both enabled and
* defined, then the execution listeners will be notified and an exception
* thrown.
*
* @param trigger
* The object that triggered the execution; may be
* <code>null</code>.
* @param applicationContext
* The state of the application at the time the execution was
* triggered; may be <code>null</code>.
* @return The result of the execution; may be <code>null</code>.
* @throws ExecutionException
* If the handler has problems executing this command.
* @throws NotDefinedException
* If the command you are trying to execute is not defined.
* @throws NotEnabledException
* If the command you are trying to execute is not enabled.
* @throws NotHandledException
* If there is no handler.
*/
Object::Pointer ExecuteWithChecks(const Object::ConstPointer& trigger,
const Object::Pointer& applicationContext);
/**
* Returns the base command. It is possible for more than one parameterized
* command to have the same identifier.
*
* @return The command; never <code>null</code>, but may be undefined.
*/
SmartPointer<Command> GetCommand() const;
/**
* Returns the command's base identifier. It is possible for more than one
* parameterized command to have the same identifier.
*
* @return The command id; never <code>null</code>.
*/
QString GetId() const;
/**
* Returns a human-readable representation of this command with all of its
* parameterizations.
*
* @return The human-readable representation of this parameterized command;
* never <code>null</code>.
* @throws NotDefinedException
* If the underlying command is not defined.
*/
QString GetName() const;
/**
* Returns the parameter map, as can be used to construct an
* <code>ExecutionEvent</code>.
*
* @return The map of parameter ids (<code>String</code>) to parameter
* values (<code>String</code>). This map is never
* <code>null</code>, but may be empty.
*/
QHash<QString, QString> GetParameterMap() const;
uint HashCode() const override;
/**
* Returns a \c String containing the command id, parameter ids and
* parameter values for this \c ParameterizedCommand . The returned
* \c String can be stored by a client and later used to reconstruct an
* equivalent {@link ParameterizedCommand} using the
* \c CommandManager.deserialize(String) method.
* <p>
* The syntax of the returned \c String is as follows:
* </p>
*
* <blockquote>
- * <code>serialization = <u>commandId</u> [ '(' parameters ')' ]</code><br>
+ * <code>serialization = commandId [ '(' parameters ')' ]</code><br>
* <code>parameters = parameter [ ',' parameters ]</code><br>
- * <code>parameter = <u>parameterId</u> [ '=' <u>parameterValue</u> ]</code>
+ * <code>parameter = parameterId [ '=' parameterValue ]</code>
* </blockquote>
*
* <p>
* In the syntax above, sections inside square-brackets are optional. The
* characters in single quotes (<code>(</code>, <code>)</code>,
* <code>,</code> and <code>=</code>) indicate literal characters.
* </p>
* <p>
- * <code><u>commandId</u></code> represents the command id encoded with
- * separator characters escaped. <code><u>parameterId</u></code> and
- * <code><u>parameterValue</u></code> represent the parameter ids and
+ * <code>commandId</code> represents the command id encoded with
+ * separator characters escaped. <code>parameterId</code> and
+ * <code>parameterValue</code> represent the parameter ids and
* values encoded with separator characters escaped. The separator
* characters <code>(</code>, <code>)</code>, <code>,</code> and
* <code>=</code> are escaped by prepending a <code>%</code>. This
* requires <code>%</code> to be escaped, which is also done by prepending
* a <code>%</code>.
* </p>
* <p>
* The order of the parameters is not defined (and not important). A missing
- * <code><u>parameterValue</u></code> indicates that the value of the
+ * <code>parameterValue</code> indicates that the value of the
* parameter is <code>null</code>.
* </p>
* <p>
* For example, the string shown below represents a serialized parameterized
* command that can be used to show the Resource perspective:
* </p>
* <p>
* <code>org.eclipse.ui.perspectives.showPerspective(org.eclipse.ui.perspectives.showPerspective.perspectiveId=org.eclipse.ui.resourcePerspective)</code>
* </p>
* <p>
* This example shows the more general form with multiple parameters,
* <code>null</code> value parameters, and escaped <code>=</code> in the
* third parameter value.
* </p>
* <p>
* <code>command.id(param1.id=value1,param2.id,param3.id=esc%=val3)</code>
* </p>
*
* @return A string containing the escaped command id, parameter ids and
* parameter values; never <code>null</code>.
* @see CommandManager#deserialize(String)
*/
QString Serialize();
QString ToString() const override;
/**
* <p>
* Generates all the possible combinations of command parameterizations for
* the given command. If the command has no parameters, then this is simply
* a parameterized version of that command. If a parameter is optional, both
* the included and not included cases are considered.
* </p>
* <p>
* If one of the parameters cannot be loaded due to a
* <code>ParameterValuesException</code>, then it is simply ignored.
* </p>
*
* @param command
* The command for which the parameter combinations should be
* generated; must not be <code>null</code>.
* @return A collection of <code>ParameterizedCommand</code> instances
* representing all of the possible combinations. This value is
* never empty and it is never <code>null</code>.
* @throws NotDefinedException
* If the command is not defined.
*/
static QList<ParameterizedCommand::Pointer>
GenerateCombinations(const SmartPointer<Command> command);
/**
* Take a command and a map of parameter IDs to values, and generate the
* appropriate parameterized command.
*
* @param command
* The command object. Must not be <code>null</code>.
* @param parameters
* A map of String parameter ids to objects. May be
* <code>null</code>.
* @return the parameterized command, or <code>null</code> if it could not
* be generated
*/
static ParameterizedCommand::Pointer GenerateCommand(const SmartPointer<Command> command,
const QHash<QString, Object::Pointer>& parameters);
private:
/**
* The constant integer hash code value meaning the hash code has not yet
* been computed.
*/
static const uint HASH_CODE_NOT_COMPUTED; // = 0;
/**
* A factor for computing the hash code for all parameterized commands.
*/
static const uint HASH_FACTOR; // = 89;
/**
* The seed for the hash code for all parameterized commands.
*/
static const uint HASH_INITIAL;
/**
* Escapes special characters in the command id, parameter ids and parameter
* values for {@link #serialize()}. The special characters
* {@link CommandManager#PARAMETER_START_CHAR},
* {@link CommandManager#PARAMETER_END_CHAR},
* {@link CommandManager#ID_VALUE_CHAR},
* {@link CommandManager#PARAMETER_SEPARATOR_CHAR} and
* {@link CommandManager#ESCAPE_CHAR} are escaped by prepending a
* {@link CommandManager#ESCAPE_CHAR} character.
*
* @param rawText
* a <code>String</code> to escape special characters in for
* serialization.
* @return a <code>String</code> representing <code>rawText</code> with
* special serialization characters escaped
*/
static QString Escape(const QString& rawText);
/**
* Generates every possible combination of parameter values for the given
* parameters. Parameters values that cannot be initialized are just
* ignored. Optional parameters are considered.
*
* @param startIndex
* The index in the <code>parameters</code> that we should
* process. This must be a valid index.
* @param parameters
* The parameters in to process; must not be <code>null</code>.
* @return A collection (<code>Collection</code>) of combinations (<code>List</code>
* of <code>Parameterization</code>).
*/
static QList<QList<Parameterization> > ExpandParameters(unsigned int startIndex,
const QList<SmartPointer<IParameter> >& parameters);
/**
* The base command which is being parameterized. This value is never
* <code>null</code>.
*/
const SmartPointer<Command> command;
/**
* The hash code for this object. This value is computed lazily, and marked
* as invalid when one of the values on which it is based changes.
*/
mutable uint hashCode;
/**
* This is an array of parameterization defined for this command. This value
* may be <code>null</code> if the command has no parameters.
*/
QList<Parameterization> parameterizations;
mutable QString name;
};
}
#endif /* BERRYPARAMETERIZEDCOMMAND_H_ */
diff --git a/Plugins/org.blueberry.core.runtime/src/berryDebugUtil.cpp b/Plugins/org.blueberry.core.runtime/src/berryDebugUtil.cpp
index f0802f513c..7490b5cb8a 100755
--- a/Plugins/org.blueberry.core.runtime/src/berryDebugUtil.cpp
+++ b/Plugins/org.blueberry.core.runtime/src/berryDebugUtil.cpp
@@ -1,537 +1,537 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "berryIDebugObjectListener.h"
#include "berryDebugUtil.h"
#include "berryObject.h"
#include "berryLog.h"
#include "berryPlatform.h"
#include "berryDebugBreakpointManager.h"
#include "internal/berryCTKPluginActivator.h"
#include <QDir>
#include <QDebug>
#include <Poco/Bugcheck.h>
#include <Poco/NumberParser.h>
#include <Poco/DOM/NodeList.h>
#include <Poco/DOM/DOMParser.h>
#include <Poco/DOM/Document.h>
#include <Poco/DOM/Element.h>
#include <Poco/DOM/DOMWriter.h>
#include <Poco/SAX/InputSource.h>
#include <Poco/SAX/SAXException.h>
#include <Poco/FileStream.h>
#include <sstream>
#include <numeric>
namespace berry
{
static IDebugObjectListener::Events _G_ObjectEvents;
const QString DebugUtil::DEBUG_UTIL_XML = "debugutil.xml";
const QString DebugUtil::DEBUGUTIL_TAG = "debugutil";
const QString DebugUtil::TRACEOBJECT_TAG = "traceObject";
const QString DebugUtil::TRACECLASS_TAG = "traceClass";
const QString DebugUtil::ID_ATTR = "id";
const QString DebugUtil::NAME_ATTR = "name";
QHash<quint32, QList<unsigned int> > DebugUtil::m_TraceIdToSmartPointerMap;
QHash<quint32, const Object*> DebugUtil::m_TraceIdToObjectMap;
QSet<unsigned int> DebugUtil::m_TracedObjects;
QSet<QString> DebugUtil::m_TracedClasses;
class NotClassName: public std::unary_function<const Object*, bool>
{
QString name;
public:
NotClassName(const QString& s) :
name(s)
{
}
bool operator()(const Object* entry) const
{
return name != entry->GetClassName();
}
};
DebugBreakpointManager* DebugUtil::GetBreakpointManager()
{
static DebugBreakpointManager breakpointManager;
return &breakpointManager;
}
#ifdef BLUEBERRY_DEBUG_SMARTPOINTER
void DebugUtil::TraceObject(const Object* object)
{
BERRY_INFO << "Tracing enabled for: " << object->GetTraceId() << std::endl;
m_TracedObjects.insert(object->GetTraceId());
_G_ObjectEvents.objTracingEvent(object->GetTraceId(), true, object);
}
#else
void DebugUtil::TraceObject(const Object* /*object*/)
{
}
#endif
#ifdef BLUEBERRY_DEBUG_SMARTPOINTER
void DebugUtil::TraceObject(unsigned int traceId)
{
BERRY_INFO << "Tracing enabled for: " << traceId << std::endl;
m_TracedObjects.insert(traceId);
TraceIdToObjectType::ConstIterator i = m_TraceIdToObjectMap.find(traceId);
if (i != m_TraceIdToObjectMap.end())
_G_ObjectEvents.objTracingEvent(traceId, true, i.value());
else
_G_ObjectEvents.objTracingEvent(traceId, true, 0);
}
#else
void DebugUtil::TraceObject(unsigned int /*traceId*/)
{
}
#endif
#ifdef BLUEBERRY_DEBUG_SMARTPOINTER
void DebugUtil::TraceClass(const QString& className)
{
BERRY_INFO << "Tracing enabled for: " << className << std::endl;
m_TracedClasses.insert(className);
//_G_ObjectEvents.objTracingEvent(object->GetTraceId(), true, object);
}
#else
void DebugUtil::TraceClass(const QString& /*className*/)
{
}
#endif
#ifdef BLUEBERRY_DEBUG_SMARTPOINTER
void DebugUtil::StopTracing(unsigned int traceId)
{
BERRY_INFO << "Tracing stopped for: " << traceId << std::endl;
m_TracedObjects.remove(traceId);
TraceIdToObjectType::ConstIterator i = m_TraceIdToObjectMap.find(traceId);
if (i != m_TraceIdToObjectMap.end())
_G_ObjectEvents.objTracingEvent(traceId, false, i.value());
else
_G_ObjectEvents.objTracingEvent(traceId, false, 0);
}
#else
void DebugUtil::StopTracing(unsigned int /*traceId*/)
{
}
#endif
#ifdef BLUEBERRY_DEBUG_SMARTPOINTER
void DebugUtil::StopTracing(const Object* obj)
{
BERRY_INFO << "Tracing stopped for: " << obj->GetTraceId() << std::endl;
m_TracedObjects.remove(obj->GetTraceId());
_G_ObjectEvents.objTracingEvent(obj->GetTraceId(), false, obj);
}
#else
void DebugUtil::StopTracing(const Object* /*obj*/)
{
}
#endif
#ifdef BLUEBERRY_DEBUG_SMARTPOINTER
void DebugUtil::StopTracing(const QString& className)
{
BERRY_INFO << "Tracing stopped for: " << className << std::endl;
m_TracedClasses.remove(className);
//_G_ObjectEvents.objTracingEvent(obj->GetTraceId(), false, obj);
}
#else
void DebugUtil::StopTracing(const QString& /*className*/)
{
}
#endif
#ifdef BLUEBERRY_DEBUG_SMARTPOINTER
bool DebugUtil::IsTraced(const Object* object)
{
if (m_TracedObjects.find(object->GetTraceId()) != m_TracedObjects.end())
return true;
if (m_TracedClasses.find(object->GetClassName()) != m_TracedClasses.end())
return true;
return false;
}
#else
bool DebugUtil::IsTraced(const Object* /*object*/)
{
return false;
}
#endif
#ifdef BLUEBERRY_DEBUG_SMARTPOINTER
bool DebugUtil::IsTraced(unsigned int traceId)
{
if (m_TracedObjects.find(traceId) != m_TracedObjects.end())
return true;
TraceIdToObjectType::Iterator it = m_TraceIdToObjectMap.find(traceId);
if (it != m_TraceIdToObjectMap.end())
{
if (m_TracedClasses.find(it.value()->GetClassName()) != m_TracedClasses.end())
return true;
}
return false;
}
#else
bool DebugUtil::IsTraced(unsigned int /*traceId*/)
{
return false;
}
#endif
#ifdef BLUEBERRY_DEBUG_SMARTPOINTER
bool DebugUtil::IsTraced(const QString& className)
{
return m_TracedClasses.find(className) != m_TracedClasses.end();
}
#else
bool DebugUtil::IsTraced(const QString& /*className*/)
{
return false;
}
#endif
QSet<unsigned int> DebugUtil::GetTracedObjects()
{
return m_TracedObjects;
}
const Object* DebugUtil::GetObject(unsigned int traceId)
{
return m_TraceIdToObjectMap[traceId];
}
#ifdef BLUEBERRY_DEBUG_SMARTPOINTER
QList<unsigned int> DebugUtil::GetSmartPointerIDs(
const Object* objectPointer, const QList<unsigned int>& excludeList)
{
Q_ASSERT(objectPointer != 0);
QList<unsigned int> ids = m_TraceIdToSmartPointerMap[objectPointer->GetTraceId()];
for (QList<unsigned int>::const_iterator iter = excludeList.begin();
iter != excludeList.end(); ++iter)
ids.removeAll(*iter);
return ids;
}
#else
QList<unsigned int> DebugUtil::GetSmartPointerIDs(
const Object* /*objectPointer*/, const QList<unsigned int>& /*excludeList*/)
{
return QList<unsigned int>();
}
#endif
QList<const Object*> DebugUtil::GetRegisteredObjects()
{
return m_TraceIdToObjectMap.values();
}
void DebugUtil::PrintSmartPointerIDs(const Object* objectPointer, const QList<unsigned int>& excludeList)
{
qDebug() << "SmartPointer IDs [ ";
if (IsTraced(objectPointer))
{
QList<unsigned int> ids = GetSmartPointerIDs(objectPointer, excludeList);
for (QList<unsigned int>::const_iterator iter = ids.begin();
iter != ids.end(); ++iter)
{
qDebug() << *iter << " ";
}
}
else
{
qDebug() << "n/a ";
}
qDebug() << "]\n";
}
void DebugUtil::AddObjectListener(IDebugObjectListener* listener)
{
_G_ObjectEvents.AddListener(listener);
}
void DebugUtil::RemoveObjectListener(IDebugObjectListener* listener)
{
_G_ObjectEvents.RemoveListener(listener);
}
void DebugUtil::ResetObjectSummary()
{
m_TraceIdToObjectMap.clear();
m_TraceIdToSmartPointerMap.clear();
m_TracedObjects.clear();
}
bool DebugUtil::PrintObjectSummary(bool details)
{
QSet<QString> names;
- for (auto object : m_TraceIdToObjectMap)
+ for (auto object : qAsConst(m_TraceIdToObjectMap))
names.insert(object->GetClassName());
if (!names.isEmpty())
{
std::cout << std::endl << std::endl << "#########################################################" << std::endl;
std::cout << "######## berry::Object leakage summary: ########" << std::endl << std::endl;
for (QSet<QString>::const_iterator i = names.begin();
i != names.end(); ++i)
{
PrintObjectSummary(*i, details);
if (details) std::cout << std::endl;
}
std::cout << std::endl << "#########################################################" << std::endl << std::endl;
}
return !names.isEmpty();
}
bool DebugUtil::PrintObjectSummary(const QString& className, bool details)
{
TraceIdToObjectType::ConstIterator endIter =
std::remove_if(m_TraceIdToObjectMap.begin(), m_TraceIdToObjectMap.end(), NotClassName(className));
qDebug() << "Class:" << className;
if (details) std::cout << std::endl;
std::size_t count = 0;
for (TraceIdToObjectType::ConstIterator iter = m_TraceIdToObjectMap.begin();
iter != endIter; ++iter, ++count)
{
if (details)
{
qDebug() << (*(iter.value()));
PrintSmartPointerIDs(iter.value());
}
}
qDebug() << "(" << count << " instances)\n";
return (count!=0);
}
unsigned int& DebugUtil::GetSmartPointerCounter()
{
static unsigned int counter = 0;
return counter;
}
#ifdef BLUEBERRY_DEBUG_SMARTPOINTER
void DebugUtil::UnregisterSmartPointer(unsigned int smartPointerId, const Object* objectPointer)
{
poco_assert(objectPointer != 0);
m_TraceIdToSmartPointerMap[objectPointer->GetTraceId()].removeAll(smartPointerId);
_G_ObjectEvents.spDestroyedEvent(smartPointerId, objectPointer);
}
#else
void DebugUtil::UnregisterSmartPointer(unsigned int /*smartPointerId*/, const Object* /*objectPointer*/)
{
}
#endif
#ifdef BLUEBERRY_DEBUG_SMARTPOINTER
void DebugUtil::RegisterSmartPointer(unsigned int smartPointerId, const Object* objectPointer, bool /*recordStack*/)
{
poco_assert(objectPointer != 0);
if (m_TracedClasses.find(objectPointer->GetClassName()) != m_TracedClasses.end() ||
m_TracedObjects.find(objectPointer->GetTraceId()) != m_TracedObjects.end())
{
m_TraceIdToSmartPointerMap[objectPointer->GetTraceId()].push_back(smartPointerId);
_G_ObjectEvents.spCreatedEvent(smartPointerId, objectPointer);
}
if (GetBreakpointManager()->BreakAtSmartpointer(smartPointerId))
poco_debugger_msg("SmartPointer Breakpoint reached");
}
#else
void DebugUtil::RegisterSmartPointer(unsigned int /*smartPointerId*/, const Object* /*objectPointer*/, bool /*recordStack*/)
{
}
#endif
#ifdef BLUEBERRY_DEBUG_SMARTPOINTER
void DebugUtil::RegisterObject(const Object* objectPointer)
{
m_TraceIdToObjectMap.insert(objectPointer->GetTraceId(), objectPointer);
_G_ObjectEvents.objCreatedEvent(objectPointer);
if (GetBreakpointManager()->BreakAtObject(objectPointer->GetTraceId()))
{
std::string msg = "SmartPointer Breakpoint reached for ";
msg += objectPointer->GetClassName().toStdString();
poco_debugger_msg(msg.c_str());
}
}
#else
void DebugUtil::RegisterObject(const Object* /*objectPointer*/)
{
}
#endif
#ifdef BLUEBERRY_DEBUG_SMARTPOINTER
void DebugUtil::UnregisterObject(const Object* objectPointer)
{
m_TraceIdToObjectMap.remove(objectPointer->GetTraceId());
_G_ObjectEvents.objDestroyedEvent(objectPointer);
}
#else
void DebugUtil::UnregisterObject(const Object* /*objectPointer*/)
{
}
#endif
bool DebugUtil::GetPersistencePath(QDir& path)
{
QFileInfo statePath = CTKPluginActivator::getPluginContext()->getDataFile(QString());
path = statePath.absoluteFilePath();
return true;
}
void DebugUtil::SaveState(const QDir& path)
{
QString saveFile = path.absoluteFilePath(DEBUG_UTIL_XML);
auto doc = new Poco::XML::Document();
Poco::XML::Element* debugutil = doc->createElement(DEBUGUTIL_TAG.toStdString());
doc->appendChild(debugutil)->release();
for (QSet<unsigned int>::const_iterator i = m_TracedObjects.begin();
i != m_TracedObjects.end(); ++i)
{
Poco::XML::Element* traceObject = doc->createElement(TRACEOBJECT_TAG.toStdString());
debugutil->appendChild(traceObject)->release();
traceObject->setAttribute(ID_ATTR.toStdString(), QString::number(*i).toStdString());
}
for (QSet<QString>::const_iterator i = m_TracedClasses.begin();
i != m_TracedClasses.end(); ++i)
{
Poco::XML::Element* traceClass = doc->createElement(TRACECLASS_TAG.toStdString());
debugutil->appendChild(traceClass)->release();
traceClass->setAttribute(NAME_ATTR.toStdString(), i->toStdString());
}
try
{
Poco::FileOutputStream writer(saveFile.toStdString());
Poco::XML::DOMWriter out;
out.setOptions(3); //write declaration and pretty print
out.writeNode(writer, doc);
doc->release();
// save BreakpointManager
QString saveBM = path.absoluteFilePath(QString::fromStdString(DebugBreakpointManager::BREAKPOINTS_XML));
GetBreakpointManager()->SaveState(saveBM);
}
catch (Poco::FileException& e)
{
BERRY_WARN << e.displayText();
}
}
void DebugUtil::RestoreState(const QDir& path)
{
QString restoreFile = path.absoluteFilePath(DEBUG_UTIL_XML);
try
{
Poco::XML::DOMParser parser;
Poco::FileInputStream reader(restoreFile.toStdString());
Poco::XML::InputSource source(reader);
//source.setSystemId(baseDir);
Poco::XML::Document* doc = parser.parse(&source);
Poco::XML::Element* debugutil = doc->documentElement();
if (debugutil)
{
// restore traced objects
Poco::XML::NodeList* elementList = debugutil->getElementsByTagName(TRACEOBJECT_TAG.toStdString());
for (std::size_t i = 0; i < elementList->length(); i++)
{
Poco::XML::Element* elem =
dynamic_cast<Poco::XML::Element*> (elementList->item(static_cast<unsigned long>(i)));
if (!elem->hasAttribute(ID_ATTR.toStdString())) continue;
const std::string& attr = elem->getAttribute(ID_ATTR.toStdString());
int traceId = 0;
try
{
traceId = Poco::NumberParser::parse(attr);
}
catch (const Poco::SyntaxException& e)
{
BERRY_WARN << e.displayText();
}
DebugUtil::TraceObject(traceId);
}
elementList->release();
// restore traced classes
elementList = debugutil->getElementsByTagName(TRACECLASS_TAG.toStdString());
for (std::size_t i = 0; i < elementList->length(); i++)
{
Poco::XML::Element* elem =
dynamic_cast<Poco::XML::Element*> (elementList->item(static_cast<unsigned long>(i)));
if (!elem->hasAttribute(NAME_ATTR.toStdString())) continue;
const std::string& traceClass = elem->getAttribute(NAME_ATTR.toStdString());
if (!traceClass.empty())
DebugUtil::TraceClass(QString::fromStdString(traceClass));
}
elementList->release();
}
doc->release();
}
catch (Poco::XML::SAXParseException& e)
{
BERRY_WARN << e.displayText();
}
catch (Poco::FileNotFoundException&)
{
}
catch (Poco::FileException& e)
{
BERRY_WARN << e.displayText();
}
// restore BreakpointManager
GetBreakpointManager()->RestoreState(path.absoluteFilePath(QString::fromStdString(DebugBreakpointManager::BREAKPOINTS_XML)));
}
}
diff --git a/Plugins/org.blueberry.core.runtime/src/internal/berryApplicationContainer.cpp b/Plugins/org.blueberry.core.runtime/src/internal/berryApplicationContainer.cpp
index 62a92d5cf4..3d58e4de79 100644
--- a/Plugins/org.blueberry.core.runtime/src/internal/berryApplicationContainer.cpp
+++ b/Plugins/org.blueberry.core.runtime/src/internal/berryApplicationContainer.cpp
@@ -1,718 +1,718 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "berryApplicationContainer.h"
#include <berryIConfigurationElement.h>
#include <berryIContributor.h>
#include <berryIExtensionRegistry.h>
#include <berryIExtension.h>
#include <berryIExtensionPoint.h>
#include <berryIProductProvider.h>
#include <berryIProduct.h>
#include "berryApplicationHandle.h"
#include "berryApplicationDescriptor.h"
#include "berryCoreException.h"
#include "berryErrorApplication.h"
#include "berryMainApplicationLauncher.h"
#include "berryProductExtensionBranding.h"
#include "berryProviderExtensionBranding.h"
#include <berryLog.h>
#include "berryCTKPluginActivator.h"
#include <service/application/ctkApplicationException.h>
#include <service/application/ctkApplicationLauncher.h>
namespace berry {
static const QString PI_OSGI = "org.blueberry.osgi";
const QString ApplicationContainer::PI_RUNTIME = "org.blueberry.core.runtime";
const QString ApplicationContainer::PT_APPLICATIONS = "applications";
const QString ApplicationContainer::PT_APP_VISIBLE = "visible";
const QString ApplicationContainer::PT_APP_THREAD = "thread";
const QString ApplicationContainer::PT_APP_THREAD_ANY = "any";
const QString ApplicationContainer::PT_APP_CARDINALITY = "cardinality";
const QString ApplicationContainer::PT_APP_CARDINALITY_SINGLETON_GLOBAL = "singleton-global";
const QString ApplicationContainer::PT_APP_CARDINALITY_SINGLETON_SCOPED = "singleton-scoped";
const QString ApplicationContainer::PT_APP_CARDINALITY_UNLIMITED = "*";
const QString ApplicationContainer::PT_APP_ICON = "icon";
const QString ApplicationContainer::PT_PRODUCTS = "products";
const QString ApplicationContainer::EXT_ERROR_APP = "org.blueberry.core.runtime.app.error";
const QString ApplicationContainer::PROP_PRODUCT = "blueberry.product";
const QString ApplicationContainer::PROP_BLUEBERRY_APPLICATION = "blueberry.application";
const QString ApplicationContainer::PROP_BLUEBERRY_APPLICATION_LAUNCH_DEFAULT = "blueberry.application.launchDefault";
const int ApplicationContainer::NOT_LOCKED = 0;
const int ApplicationContainer::LOCKED_SINGLETON_GLOBAL_RUNNING = 1;
const int ApplicationContainer::LOCKED_SINGLETON_GLOBAL_APPS_RUNNING = 2;
const int ApplicationContainer::LOCKED_SINGLETON_SCOPED_RUNNING = 3;
const int ApplicationContainer::LOCKED_SINGLETON_LIMITED_RUNNING = 4;
const int ApplicationContainer::LOCKED_MAIN_THREAD_RUNNING = 5;
ApplicationContainer::ApplicationContainer(ctkPluginContext* context, IExtensionRegistry* extensionRegistry)
: context(context)
, extensionRegistry(extensionRegistry)
, launcherTracker(new ctkServiceTracker<ctkApplicationLauncher*>(context, this))
, branding(nullptr)
, missingProductReported(false)
, defaultMainThreadAppHandle(nullptr)
, missingApp(false)
{
}
ApplicationContainer::~ApplicationContainer()
{
}
void ApplicationContainer::Start()
{
launcherTracker->open();
extensionRegistry->AddListener(this, PI_OSGI + '.' + PT_APPLICATIONS);
// need to listen for system bundle stopping
context->connectPluginListener(this, SLOT(PluginChanged(ctkPluginEvent)), Qt::DirectConnection);
// register all the descriptors
RegisterAppDescriptors();
QVariant startDefaultProp = context->getProperty(ApplicationContainer::PROP_BLUEBERRY_APPLICATION_LAUNCH_DEFAULT);
if (startDefaultProp.isNull() || startDefaultProp.toBool())
{
// Start the default application
try
{
StartDefaultApp(true);
}
catch (const ctkApplicationException& e)
{
BERRY_ERROR << "An error occurred while starting the application:" << e.message();
}
}
}
void ApplicationContainer::Stop()
{
// stop all applications
StopAllApps();
context->disconnectPluginListener(this);
extensionRegistry->RemoveListener(this);
// flush the apps
apps.clear();
branding.reset();
missingProductReported = false;
launcherTracker->close();
}
IBranding* ApplicationContainer::GetBranding() const
{
if (branding)
{
return branding.data();
}
// try pluginContext properties
if (context == nullptr) return nullptr;
QString productId = context->getProperty(PROP_PRODUCT).toString();
if (productId.isEmpty()) return nullptr;
QList<IConfigurationElement::Pointer> entries = extensionRegistry->GetConfigurationElementsFor(PI_RUNTIME, PT_PRODUCTS, productId);
if (!entries.isEmpty())
{
// There should only be one product with the given id so just take the first element
branding.reset(new ProductExtensionBranding(productId, entries[0]));
return branding.data();
}
QList<IConfigurationElement::Pointer> elements = extensionRegistry->GetConfigurationElementsFor(PI_RUNTIME, PT_PRODUCTS);
- for (auto element : elements)
+ for (const auto &element : qAsConst(elements))
{
if (element->GetName().compare("provider", Qt::CaseInsensitive) == 0)
{
try
{
IProductProvider* provider = element->CreateExecutableExtension<IProductProvider>("run");
QList<IProduct::Pointer> products = provider->GetProducts();
- for (auto product : products)
+ for (const auto &product : qAsConst(products))
{
if (productId.compare(product->GetId(), Qt::CaseInsensitive) == 0)
{
branding.reset(new ProviderExtensionBranding(product));
return branding.data();
}
}
}
catch (const CoreException&)
{
BERRY_WARN << "Problem creating the provider registered by " << element->GetParent()->ToString() << ".";
}
}
}
if (!missingProductReported)
{
BERRY_WARN << "Product " << productId << " could not be found.";
missingProductReported = true;
}
return nullptr;
}
ctkPluginContext* ApplicationContainer::GetContext() const
{
return context;
}
ApplicationDescriptor* ApplicationContainer::GetAppDescriptor(const QString& applicationId)
{
ApplicationDescriptor* result = nullptr;
{
QMutexLocker l(&lock);
auto iter = apps.find(applicationId);
result = iter == apps.end() ? nullptr : iter.value();
}
if (result == nullptr)
{
RegisterAppDescriptor(applicationId); // try again just in case we are waiting for an event
{
QMutexLocker l(&lock);
auto iter = apps.find(applicationId);
result = iter == apps.end() ? nullptr : iter.value();
}
}
return result;
}
ApplicationDescriptor* ApplicationContainer::CreateAppDescriptor(const SmartPointer<IExtension>& appExtension)
{
if (org_blueberry_core_runtime_Activator::DEBUG)
{
BERRY_INFO << "Creating application descriptor: " << appExtension->GetUniqueIdentifier();
}
QString iconPath;
{
QMutexLocker l(&lock);
auto iter = apps.find(appExtension->GetUniqueIdentifier());
ApplicationDescriptor* appDescriptor = iter == apps.end() ? nullptr : iter.value();
if (appDescriptor != nullptr)
{
return appDescriptor;
}
// the appDescriptor does not exist for the app ID; create it
QList<IConfigurationElement::Pointer> configs = appExtension->GetConfigurationElements();
ApplicationDescriptor::Flags flags = ApplicationDescriptor::FLAG_CARD_SINGLETON_GLOGAL | ApplicationDescriptor::FLAG_VISIBLE |
ApplicationDescriptor::FLAG_TYPE_MAIN_THREAD;
int cardinality = 0;
if (!configs.isEmpty())
{
QString sVisible = configs[0]->GetAttribute(PT_APP_VISIBLE);
if (!sVisible.isEmpty() && sVisible.compare("true", Qt::CaseInsensitive) != 0)
{
flags &= ~(ApplicationDescriptor::FLAG_VISIBLE);
}
QString sThread = configs[0]->GetAttribute(PT_APP_THREAD);
if (PT_APP_THREAD_ANY == sThread)
{
flags |= ApplicationDescriptor::FLAG_TYPE_ANY_THREAD;
flags &= ~(ApplicationDescriptor::FLAG_TYPE_MAIN_THREAD);
}
QString sCardinality = configs[0]->GetAttribute(PT_APP_CARDINALITY);
if (!sCardinality.isEmpty())
{
flags &= ~(ApplicationDescriptor::FLAG_CARD_SINGLETON_GLOGAL); // clear the global bit
if (PT_APP_CARDINALITY_SINGLETON_SCOPED == sCardinality)
{
flags |= ApplicationDescriptor::FLAG_CARD_SINGLETON_SCOPED;
}
else if (PT_APP_CARDINALITY_UNLIMITED == sCardinality)
{
flags |= ApplicationDescriptor::FLAG_CARD_UNLIMITED;
}
else if (PT_APP_CARDINALITY_SINGLETON_GLOBAL == sCardinality)
{
flags |= ApplicationDescriptor::FLAG_CARD_SINGLETON_GLOGAL;
}
else
{
bool okay = false;
cardinality = sCardinality.toInt(&okay);
if (okay)
{
flags |= ApplicationDescriptor::FLAG_CARD_LIMITED;
}
else
{
// TODO should we log this?
// just fall back to the default
flags |= ApplicationDescriptor::FLAG_CARD_SINGLETON_GLOGAL;
}
}
}
QString defaultApp = GetDefaultAppId();
QString appId = appExtension->GetUniqueIdentifier();
if (defaultApp == appId)
{
flags |= ApplicationDescriptor::FLAG_DEFAULT_APP;
}
iconPath = configs[0]->GetAttribute(PT_APP_ICON);
}
appDescriptor = new ApplicationDescriptor(org_blueberry_core_runtime_Activator::GetPlugin(appExtension->GetContributor()),
appExtension->GetUniqueIdentifier(), appExtension->GetLabel(), iconPath, flags, cardinality, this);
// register the appDescriptor as a service
ctkServiceRegistration sr = context->registerService<ctkApplicationDescriptor>(appDescriptor, appDescriptor->GetServiceProperties());
appDescriptor->SetServiceRegistration(sr);
// save the app descriptor in the cache
apps.insert(appExtension->GetUniqueIdentifier(), appDescriptor);
return appDescriptor;
}
}
ApplicationDescriptor*ApplicationContainer::RemoveAppDescriptor(const QString& applicationId)
{
if (org_blueberry_core_runtime_Activator::DEBUG)
{
BERRY_INFO << "Removing application descriptor: " << applicationId;
}
{
QMutexLocker l(&lock);
ApplicationDescriptor* appDescriptor = apps.take(applicationId);
if (appDescriptor == nullptr)
{
return nullptr;
}
appDescriptor->Unregister();
return appDescriptor;
}
}
void ApplicationContainer::StartDefaultApp(bool delayError)
{
// find the default application
QString applicationId = GetDefaultAppId();
ApplicationDescriptor* defaultDesc = nullptr;
QHash<QString, QVariant> args;
args.insert(ApplicationDescriptor::APP_DEFAULT, true);
if (applicationId.isEmpty() && !delayError)
{
// the application id is not set; use a descriptor that will throw an exception
args.insert(ErrorApplication::ERROR_EXCEPTION, QString("No application id has been found."));
defaultDesc = GetAppDescriptor(EXT_ERROR_APP);
}
else
{
defaultDesc = GetAppDescriptor(applicationId);
if (defaultDesc == nullptr && !delayError)
{
// the application id is not available in the registry; use a descriptor that will throw an exception
args.insert(ErrorApplication::ERROR_EXCEPTION, QString("Application \"%1\" could not be found in the registry. The applications available are: %2.")
.arg(applicationId)
.arg(GetAvailableAppsMsg()));
defaultDesc = GetAppDescriptor(EXT_ERROR_APP);
}
}
if (delayError && defaultDesc == nullptr)
{
// could not find the application; but we want to delay the error.
// another bundle may get installed that provides the application
// before we actually try to launch it.
missingApp = true;
return;
}
if (defaultDesc != nullptr)
{
defaultDesc->launch(args);
}
else
{
throw ctkApplicationException(ctkApplicationException::APPLICATION_INTERNAL_ERROR, "No application id has been found.");
}
}
void ApplicationContainer::RegisterAppDescriptors()
{
QList<IExtension::Pointer> availableApps = GetAvailableAppExtensions();
for (int i = 0; i < availableApps.size(); i++)
{
CreateAppDescriptor(availableApps[i]);
}
}
void ApplicationContainer::RegisterAppDescriptor(const QString& applicationId)
{
IExtension::Pointer appExtension = GetAppExtension(applicationId);
if (appExtension.IsNotNull())
{
CreateAppDescriptor(appExtension);
}
}
QList<SmartPointer<IExtension> > ApplicationContainer::GetAvailableAppExtensions() const
{
IExtensionPoint::Pointer point = extensionRegistry->GetExtensionPoint(PI_OSGI + '.' + PT_APPLICATIONS);
if (point.IsNull())
{
return QList<IExtension::Pointer>();
}
return point->GetExtensions();
}
QString ApplicationContainer::GetAvailableAppsMsg() const
{
QList<IExtension::Pointer> availableApps = GetAvailableAppExtensions();
QString availableAppsMsg = "<NONE>";
if (!availableApps.isEmpty())
{
availableAppsMsg = availableApps.front()->GetUniqueIdentifier();
- for (auto availableApp : availableApps)
+ for (const auto &availableApp : qAsConst(availableApps))
{
availableAppsMsg = availableAppsMsg + ", " + availableApp->GetUniqueIdentifier();
}
}
return availableAppsMsg;
}
SmartPointer<IExtension> ApplicationContainer::GetAppExtension(const QString& applicationId) const
{
return extensionRegistry->GetExtension(PI_OSGI, PT_APPLICATIONS, applicationId);
}
void ApplicationContainer::Launch(ApplicationHandle* appHandle)
{
bool isDefault = appHandle->IsDefault();
if (appHandle->getApplicationDescriptor()->GetThreadType() == ApplicationDescriptor::FLAG_TYPE_MAIN_THREAD)
{
// use the ApplicationLauncher provided by the framework to ensure it is launched on the main thread
//DefaultApplicationListener curDefaultApplicationListener = null;
MainApplicationLauncher* curMissingAppLauncher = nullptr;
ctkApplicationLauncher* appLauncher = nullptr;
{
QMutexLocker l(this);
appLauncher = launcherTracker->getService();
if (appLauncher == nullptr)
{
if (isDefault)
{
// we need to wait to allow the ApplicationLauncher to get registered;
// save the handle to be launched as soon as the ApplicationLauncher is available
defaultMainThreadAppHandle = appHandle;
return;
}
throw ctkApplicationException(ctkApplicationException::APPLICATION_INTERNAL_ERROR,
QString("The main thread is not available to launch the application: %1").arg(appHandle->getInstanceId()));
}
//curDefaultApplicationListener = defaultAppListener;
curMissingAppLauncher = missingAppLauncher.data();
}
//if (curDefaultApplicationListener != nullptr)
//{
// curDefaultApplicationListener->launch(appHandle);
//}
//else
if (curMissingAppLauncher != nullptr)
{
curMissingAppLauncher->Launch(appHandle);
}
else
{
appLauncher->launch(appHandle, appHandle->GetArguments()[IApplicationContext::APPLICATION_ARGS]);
}
}
else
{
if (isDefault)
{
//DefaultApplicationListener curDefaultApplicationListener = null;
MainApplicationLauncher* curMissingAppLauncher = nullptr;
ctkApplicationLauncher* appLauncher = nullptr;
{
QMutexLocker l(this);
appLauncher = launcherTracker->getService();
//if (defaultAppListener == nullptr)
//{
// defaultAppListener = new DefaultApplicationListener(appHandle);
//}
//curDefaultApplicationListener = defaultAppListener;
if (appLauncher == nullptr)
{
// we need to wait to allow the ApplicationLauncher to get registered;
// save the default app listener to be launched as soon as the ApplicationLauncher is available
//defaultMainThreadAppHandle = curDefaultApplicationListener;
return;
}
curMissingAppLauncher = missingAppLauncher.data();
}
if (curMissingAppLauncher != nullptr)
{
//curMissingAppLauncher->Launch(curDefaultApplicationListener);
}
else
{
//appLauncher->Launch(curDefaultApplicationListener, QVariant());
}
}
else
{
//AnyThreadAppLauncher.launchEclipseApplication(appHandle);
}
}
}
void ApplicationContainer::PluginChanged(const ctkPluginEvent& event)
{
// if this is not the system bundle stopping then ignore the event
if ((ctkPluginEvent::STOPPING & event.getType()) == 0 || event.getPlugin()->getPluginId() != 0)
{
return;
}
// The system bundle is stopping; better stop all applications and containers now
StopAllApps();
}
void ApplicationContainer::StopAllApps()
{
// get a stapshot of running applications
QList<ctkServiceReference> runningRefs = context->getServiceReferences<ctkApplicationHandle>("(!(application.state=STOPPING))");
- for (auto runningRef : runningRefs)
+ for (const auto &runningRef : qAsConst(runningRefs))
{
ctkApplicationHandle* handle = context->getService<ctkApplicationHandle>(runningRef);
try
{
if (handle != nullptr)
{
handle->destroy();
}
}
catch (const std::exception&)
{
BERRY_WARN << QString("An error occurred while stopping the application: %1").arg(handle->getInstanceId());
}
if (handle != nullptr)
{
context->ungetService(runningRef);
}
}
}
QString ApplicationContainer::GetDefaultAppId() const
{
if (!defaultAppId.isNull())
{
return defaultAppId;
}
// try plugin context properties
defaultAppId = context->getProperty(ApplicationContainer::PROP_BLUEBERRY_APPLICATION).toString();
if (!defaultAppId.isEmpty())
{
return defaultAppId;
}
//Derive the application from the product information
defaultAppId = GetBranding() == nullptr ? QString("") : GetBranding()->GetApplication();
return defaultAppId;
}
void ApplicationContainer::Lock(ApplicationHandle* /*appHandle*/)
{
/*
ApplicationDescriptor eclipseApp = (ApplicationDescriptor) appHandle.getApplicationDescriptor();
{
QMutexLocker l(&lock);
switch (isLocked(eclipseApp))
{
case NOT_LOCKED :
break;
case LOCKED_SINGLETON_GLOBAL_RUNNING :
throw new ApplicationException(ApplicationException.APPLICATION_NOT_LAUNCHABLE, NLS.bind(Messages.singleton_running, activeGlobalSingleton.getInstanceId()));
case LOCKED_SINGLETON_GLOBAL_APPS_RUNNING :
throw new ApplicationException(ApplicationException.APPLICATION_NOT_LAUNCHABLE, Messages.apps_running);
case LOCKED_SINGLETON_SCOPED_RUNNING :
throw new ApplicationException(ApplicationException.APPLICATION_NOT_LAUNCHABLE, NLS.bind(Messages.singleton_running, activeScopedSingleton.getInstanceId()));
case LOCKED_SINGLETON_LIMITED_RUNNING :
throw new ApplicationException(ApplicationException.APPLICATION_NOT_LAUNCHABLE, NLS.bind(Messages.max_running, eclipseApp.getApplicationId()));
case LOCKED_MAIN_THREAD_RUNNING :
throw new ApplicationException(ApplicationException.APPLICATION_NOT_LAUNCHABLE, NLS.bind(Messages.main_running, activeMain.getInstanceId()));
default :
break;
}
// ok we can now successfully lock the container
switch (eclipseApp.getCardinalityType())
{
case ApplicationDescriptor::FLAG_CARD_SINGLETON_GLOGAL :
activeGlobalSingleton = appHandle;
break;
case ApplicationDescriptor::FLAG_CARD_SINGLETON_SCOPED :
activeScopedSingleton = appHandle;
break;
case ApplicationDescriptor::FLAG_CARD_LIMITED :
if (activeLimited == null)
activeLimited = new HashMap(3);
ArrayList limited = (ArrayList) activeLimited.get(eclipseApp.getApplicationId());
if (limited == null)
{
limited = new ArrayList(eclipseApp.getCardinality());
activeLimited.put(eclipseApp.getApplicationId(), limited);
}
limited.add(appHandle);
break;
case ApplicationDescriptor::FLAG_CARD_UNLIMITED :
break;
default :
break;
}
if (eclipseApp.getThreadType() == ApplicationDescriptor::FLAG_TYPE_MAIN_THREAD)
{
activeMain = appHandle;
}
activeHandles.add(appHandle);
refreshAppDescriptors();
}
*/
}
void ApplicationContainer::Unlock(ApplicationHandle* /*appHandle*/)
{
/*
QMutexLocker l(&lock);
if (activeGlobalSingleton == appHandle)
activeGlobalSingleton = null;
else if (activeScopedSingleton == appHandle)
activeScopedSingleton = null;
else if (((ApplicationDescriptor) appHandle.getApplicationDescriptor()).getCardinalityType() == ApplicationDescriptor::FLAG_CARD_LIMITED) {
if (activeLimited != null) {
ArrayList limited = (ArrayList) activeLimited.get(((ApplicationDescriptor) appHandle.getApplicationDescriptor()).getApplicationId());
if (limited != null)
limited.remove(appHandle);
}
}
if (activeMain == appHandle)
activeMain = null;
if (activeHandles.remove(appHandle))
refreshAppDescriptors(); // only refresh descriptors if we really unlocked something
*/
}
int ApplicationContainer::IsLocked(const ApplicationDescriptor* /*eclipseApp*/) const
{
/*
{
QMutexLocker l(&lock);
if (activeGlobalSingleton != null)
return LOCKED_SINGLETON_GLOBAL_RUNNING;
switch (eclipseApp.getCardinalityType()) {
case ApplicationDescriptor::FLAG_CARD_SINGLETON_GLOGAL :
if (activeHandles.size() > 0)
return LOCKED_SINGLETON_GLOBAL_APPS_RUNNING;
break;
case ApplicationDescriptor::FLAG_CARD_SINGLETON_SCOPED :
if (activeScopedSingleton != null)
return LOCKED_SINGLETON_SCOPED_RUNNING;
break;
case ApplicationDescriptor::FLAG_CARD_LIMITED :
if (activeLimited != null) {
ArrayList limited = (ArrayList) activeLimited.get(eclipseApp.getApplicationId());
if (limited != null && limited.size() >= eclipseApp.getCardinality())
return LOCKED_SINGLETON_LIMITED_RUNNING;
}
break;
case ApplicationDescriptor::FLAG_CARD_UNLIMITED :
break;
default :
break;
}
if (eclipseApp.getThreadType() == ApplicationDescriptor::FLAG_TYPE_MAIN_THREAD && activeMain != null)
return LOCKED_MAIN_THREAD_RUNNING;
return NOT_LOCKED;
}
*/
return NOT_LOCKED;
}
ctkApplicationLauncher* ApplicationContainer::addingService(const ctkServiceReference& reference)
{
ctkApplicationLauncher* appLauncher = nullptr;
ctkApplicationRunnable* appRunnable = nullptr;
{
QMutexLocker l(this);
appLauncher = context->getService<ctkApplicationLauncher>(reference);
// see if there is a default main threaded application waiting to run
appRunnable = defaultMainThreadAppHandle;
// null out so we do not attempt to start this handle again
defaultMainThreadAppHandle = nullptr;
if (appRunnable == nullptr && missingApp)
{
missingAppLauncher.reset(new MainApplicationLauncher(this));
appRunnable = missingAppLauncher.data();
missingApp = false;
}
}
if (appRunnable != nullptr)
{
// found a main threaded app; start it now that the app launcher is available
ApplicationHandle* handle = dynamic_cast<ApplicationHandle*>(appRunnable);
appLauncher->launch(appRunnable, handle ? handle->GetArguments()[IApplicationContext::APPLICATION_ARGS] : QVariant());
}
return appLauncher;
}
void ApplicationContainer::modifiedService(const ctkServiceReference& /*reference*/, ctkApplicationLauncher* /*service*/)
{
// Do nothing
}
void ApplicationContainer::removedService(const ctkServiceReference& /*reference*/, ctkApplicationLauncher* /*service*/)
{
// Do nothing
}
void ApplicationContainer::Added(const QList<SmartPointer<IExtension> >& extensions)
{
- for (IExtension::Pointer extension : extensions)
+ for (const IExtension::Pointer &extension : extensions)
{
CreateAppDescriptor(extension);
}
}
void ApplicationContainer::Added(const QList<SmartPointer<IExtensionPoint> >& /*extensionPoints*/)
{
// nothing
}
void ApplicationContainer::Removed(const QList<SmartPointer<IExtension> >& extensions)
{
- for (IExtension::Pointer extension : extensions)
+ for (const IExtension::Pointer &extension : extensions)
{
RemoveAppDescriptor(extension->GetUniqueIdentifier());
}
}
void ApplicationContainer::Removed(const QList<SmartPointer<IExtensionPoint> >& /*extensionPoints*/)
{
// nothing
}
void ApplicationContainer::RefreshAppDescriptors()
{
QMutexLocker l(&lock);
for (ApplicationDescriptor* app : apps.values())
{
app->RefreshProperties();
}
}
}
diff --git a/Plugins/org.blueberry.core.runtime/src/internal/berryCTKPluginActivator.cpp b/Plugins/org.blueberry.core.runtime/src/internal/berryCTKPluginActivator.cpp
index 54b412b2b2..1db15fcebf 100755
--- a/Plugins/org.blueberry.core.runtime/src/internal/berryCTKPluginActivator.cpp
+++ b/Plugins/org.blueberry.core.runtime/src/internal/berryCTKPluginActivator.cpp
@@ -1,293 +1,293 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef NOMINMAX
#define NOMINMAX
#endif
#include "berryCTKPluginActivator.h"
#include <berryIApplication.h>
#include <berryIConfigurationElement.h>
#include <berryIContributor.h>
#include "berryApplicationContainer.h"
#include "berryPlatform.h"
#include "berryInternalPlatform.h"
#include "berryErrorApplication.h"
#include "berryPreferencesService.h"
#include "berryExtensionRegistry.h"
#include "berryRegistryConstants.h"
#include "berryRegistryProperties.h"
#include "berryRegistryStrategy.h"
#include "berryRegistryContributor.h"
#include <QCoreApplication>
#include <QDebug>
namespace berry {
static const QString XP_APPLICATIONS = "org.blueberry.osgi.applications";
ctkPluginContext* org_blueberry_core_runtime_Activator::context = nullptr;
QScopedPointer<ApplicationContainer> org_blueberry_core_runtime_Activator::appContainer;
const bool org_blueberry_core_runtime_Activator::DEBUG = false;
void org_blueberry_core_runtime_Activator::start(ctkPluginContext* context)
{
this->context = context;
BERRY_REGISTER_EXTENSION_CLASS(ErrorApplication, context)
RegistryProperties::SetContext(context);
//ProcessCommandLine();
this->startRegistry();
preferencesService.reset(new PreferencesService(context->getDataFile("").absolutePath()));
prefServiceReg = context->registerService<IPreferencesService>(preferencesService.data());
// // register a listener to catch new plugin installations/resolutions.
// pluginListener.reset(new CTKPluginListener(m_ExtensionPointService));
// context->connectPluginListener(pluginListener.data(), SLOT(pluginChanged(ctkPluginEvent)), Qt::DirectConnection);
// // populate the registry with all the currently installed plugins.
// // There is a small window here while processPlugins is being
// // called where the pluginListener may receive a ctkPluginEvent
// // to add/remove a plugin from the registry. This is ok since
// // the registry is a synchronized object and will not add the
// // same bundle twice.
// pluginListener->processPlugins(context->getPlugins());
this->startAppContainer();
InternalPlatform::GetInstance()->Start(context);
}
void org_blueberry_core_runtime_Activator::stop(ctkPluginContext* context)
{
InternalPlatform::GetInstance()->Stop(context);
//pluginListener.reset();
//Platform::GetServiceRegistry().UnRegisterService(IExtensionPointService::SERVICE_ID);
prefServiceReg.unregister();
preferencesService->ShutDown();
preferencesService.reset();
prefServiceReg = 0;
this->stopRegistry();
RegistryProperties::SetContext(nullptr);
stopAppContainer();
this->context = nullptr;
}
ctkPluginContext* org_blueberry_core_runtime_Activator::getPluginContext()
{
return context;
}
ApplicationContainer* org_blueberry_core_runtime_Activator::GetContainer()
{
return appContainer.data();
}
#if defined(Q_OS_LINUX) || defined(Q_OS_DARWIN)
#include <dlfcn.h>
QString org_blueberry_core_runtime_Activator::getPluginId(void *symbol)
{
if (symbol == nullptr) return QString();
Dl_info info = {nullptr,nullptr,nullptr,nullptr};
if(dladdr(symbol, &info) == 0)
{
return QString();
}
else if(info.dli_fname)
{
QFile soPath(info.dli_fname);
int index = soPath.fileName().lastIndexOf('.');
QString pluginId = soPath.fileName().left(index);
if (pluginId.startsWith("lib"))
pluginId = pluginId.mid(3);
return pluginId.replace('_', '.');
}
return QString();
}
#elif defined(Q_CC_MSVC)
#include <ctkBackTrace.h>
#include <windows.h>
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4091)
#endif
#include <dbghelp.h>
#ifdef _MSC_VER
# pragma warning(pop)
#endif
QString org_blueberry_core_runtime_Activator::getPluginId(void *symbol)
{
if (symbol == nullptr) return QString();
if (ctk::DebugSymInitialize())
{
std::vector<char> moduleBuffer(sizeof(IMAGEHLP_MODULE64));
PIMAGEHLP_MODULE64 pModuleInfo = (PIMAGEHLP_MODULE64)&moduleBuffer.front();
pModuleInfo->SizeOfStruct = sizeof(IMAGEHLP_MODULE64);
if (SymGetModuleInfo64(GetCurrentProcess(), (DWORD64)symbol, pModuleInfo))
{
QString pluginId = pModuleInfo->ModuleName;
return pluginId.replace('_', '.');
}
}
return QString();
}
#endif
QSharedPointer<ctkPlugin> org_blueberry_core_runtime_Activator::GetPlugin(const SmartPointer<IContributor>& contributor)
{
if (RegistryContributor::Pointer regContributor = contributor.Cast<RegistryContributor>())
{
bool okay = false;
long id = regContributor->GetActualId().toLong(&okay);
if (okay)
{
if (context != nullptr)
{
return context->getPlugin(id);
}
}
else
{
// try using the name of the contributor below
}
}
auto plugins = context->getPlugins();
//Return the first plugin that is not installed or uninstalled
- for (auto plugin : plugins)
+ for (auto plugin : qAsConst(plugins))
{
if (!(plugin->getState() == ctkPlugin::INSTALLED ||
plugin->getState() == ctkPlugin::UNINSTALLED))
{
return plugin;
}
}
return QSharedPointer<ctkPlugin>();
}
org_blueberry_core_runtime_Activator::org_blueberry_core_runtime_Activator()
: userRegistryKey(new QObject())
, masterRegistryKey(new QObject())
{
}
org_blueberry_core_runtime_Activator::~org_blueberry_core_runtime_Activator()
{
}
void org_blueberry_core_runtime_Activator::startRegistry()
{
// see if the customer suppressed the creation of default registry
QString property = context->getProperty(RegistryConstants::PROP_DEFAULT_REGISTRY).toString();
if (property.compare("false", Qt::CaseInsensitive) == 0) return;
// check to see if we need to use null as a userToken
if (context->getProperty(RegistryConstants::PROP_REGISTRY_nullptr_USER_TOKEN).toString().compare("true", Qt::CaseInsensitive) == 0)
{
userRegistryKey.reset(nullptr);
}
// Determine primary and alternative registry locations. BlueBerry extension registry cache
// can be found in one of the two locations:
// a) in the local configuration area (standard location passed in by the platform) -> priority
// b) in the shared configuration area (typically, shared install is used)
QList<QString> registryLocations;
QList<bool> readOnlyLocations;
RegistryStrategy* strategy = nullptr;
//Location configuration = OSGIUtils.getDefault().getConfigurationLocation();
QString configuration = context->getDataFile("").absoluteFilePath();
if (configuration.isEmpty())
{
RegistryProperties::SetProperty(RegistryConstants::PROP_NO_REGISTRY_CACHE, "true");
RegistryProperties::SetProperty(RegistryConstants::PROP_NO_LAZY_REGISTRY_CACHE_LOADING, "true");
strategy = new RegistryStrategy(QList<QString>(), QList<bool>(), masterRegistryKey.data());
}
else
{
//File primaryDir = new File(configuration.getURL().getPath() + '/' + STORAGE_DIR);
//bool primaryReadOnly = configuration.isReadOnly();
QString primaryDir = configuration;
bool primaryReadOnly = false;
//Location parentLocation = configuration.getParentLocation();
QString parentLocation;
if (!parentLocation.isEmpty())
{
// File secondaryDir = new File(parentLocation.getURL().getFile() + '/' + IRegistryConstants.RUNTIME_NAME);
// registryLocations << primaryDir << secondaryDir;
// readOnlyLocations << primaryReadOnly << true; // secondary BlueBerry location is always read only
}
else
{
registryLocations << primaryDir;
readOnlyLocations << primaryReadOnly;
}
strategy = new RegistryStrategy(registryLocations, readOnlyLocations, masterRegistryKey.data());
}
auto registry = new ExtensionRegistry(strategy, masterRegistryKey.data(), userRegistryKey.data());
defaultRegistry.reset(registry);
registryServiceReg = context->registerService<IExtensionRegistry>(registry);
//commandRegistration = EquinoxUtils.registerCommandProvider(Activator.getContext());
}
void org_blueberry_core_runtime_Activator::stopRegistry()
{
if (!defaultRegistry.isNull())
{
registryServiceReg.unregister();
defaultRegistry->Stop(masterRegistryKey.data());
}
// if (!commandRegistration.isNull())
// {
// commandRegistration.unregister();
// }
}
void org_blueberry_core_runtime_Activator::startAppContainer()
{
appContainer.reset(new ApplicationContainer(context, defaultRegistry.data()));
appContainer->Start();
}
void org_blueberry_core_runtime_Activator::stopAppContainer()
{
appContainer->Stop();
}
}
diff --git a/Plugins/org.blueberry.core.runtime/src/internal/berryProductExtensionBranding.cpp b/Plugins/org.blueberry.core.runtime/src/internal/berryProductExtensionBranding.cpp
index d48c39fc52..629c2b1da7 100644
--- a/Plugins/org.blueberry.core.runtime/src/internal/berryProductExtensionBranding.cpp
+++ b/Plugins/org.blueberry.core.runtime/src/internal/berryProductExtensionBranding.cpp
@@ -1,92 +1,92 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "berryProductExtensionBranding.h"
#include <berryIConfigurationElement.h>
#include <berryIContributor.h>
#include <berryIProduct.h>
#include "berryCTKPluginActivator.h"
namespace berry {
const QString ProductExtensionBranding::ATTR_DESCRIPTION = "description";
const QString ProductExtensionBranding::ATTR_NAME = "name";
const QString ProductExtensionBranding::ATTR_APPLICATION = "application";
const QString ProductExtensionBranding::ATTR_VALUE = "value";
ProductExtensionBranding::ProductExtensionBranding(const QString& id, const SmartPointer<IConfigurationElement>& element)
: id(id)
{
if (element.IsNull()) return;
application = element->GetAttribute(ATTR_APPLICATION);
name = element->GetAttribute(ATTR_NAME);
description = element->GetAttribute(ATTR_DESCRIPTION);
LoadProperties(element);
}
QSharedPointer<ctkPlugin> ProductExtensionBranding::GetDefiningPlugin() const
{
return definingPlugin;
}
QString ProductExtensionBranding::GetApplication() const
{
return application;
}
QString ProductExtensionBranding::GetName() const
{
return name;
}
QString ProductExtensionBranding::GetDescription() const
{
return description;
}
QString ProductExtensionBranding::GetId() const
{
return id;
}
QString ProductExtensionBranding::GetProperty(const QString& key) const
{
auto iter = properties.find(key);
return iter != properties.end() ? iter.value() : QString::null;
}
SmartPointer<IProduct> ProductExtensionBranding::GetProduct() const
{
return IProduct::Pointer();
}
void ProductExtensionBranding::LoadProperties(const SmartPointer<IConfigurationElement>& element)
{
QList<IConfigurationElement::Pointer> children = element->GetChildren();
properties.clear();
- for (auto child : children)
+ for (const auto &child : qAsConst(children))
{
QString key = child->GetAttribute(ATTR_NAME);
QString value = child->GetAttribute(ATTR_VALUE);
if (!key.isEmpty() && !value.isEmpty())
{
properties.insert(key, value);
}
}
definingPlugin = org_blueberry_core_runtime_Activator::GetPlugin(element->GetContributor());
}
}
diff --git a/Plugins/org.blueberry.ui.qt/src/berryISaveablePart.h b/Plugins/org.blueberry.ui.qt/src/berryISaveablePart.h
index 32e813c202..340b20e17a 100644
--- a/Plugins/org.blueberry.ui.qt/src/berryISaveablePart.h
+++ b/Plugins/org.blueberry.ui.qt/src/berryISaveablePart.h
@@ -1,117 +1,115 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef BERRYISAVEABLEPART_H_
#define BERRYISAVEABLEPART_H_
#include <berryMacros.h>
#include <berryObject.h>
#include <org_blueberry_ui_qt_Export.h>
#include <QtPlugin>
namespace berry {
/**
* Workbench parts implement or adapt to this interface to participate
* in the enablement and execution of the <code>Save</code> and
* <code>Save As</code> actions.
*
* @see IEditorPart
*/
struct BERRY_UI_QT ISaveablePart : public virtual Object
{
berryObjectMacro(berry::ISaveablePart);
/**
* The property id for <code>isDirty</code>.
*/
static const int PROP_DIRTY; // = IWorkbenchPartConstants.PROP_DIRTY;
/**
* Saves the contents of this part.
* <p>
* If the save is successful, the part should fire a property changed event
* reflecting the new dirty state (<code>PROP_DIRTY</code> property).
* </p>
* <p>
* If the save is cancelled through user action, or for any other reason, the
* part should invoke <code>setCancelled</code> on the <code>IProgressMonitor</code>
* to inform the caller.
* </p>
* <p>
* This method is long-running; progress and cancellation are provided
* by the given progress monitor.
* </p>
- *
- * @param monitor the progress monitor
*/
virtual void DoSave(/*IProgressMonitor monitor*/) = 0;
/**
* Saves the contents of this part to another object.
* <p>
* Implementors are expected to open a "Save As" dialog where the user will
* be able to select a new name for the contents. After the selection is made,
* the contents should be saved to that new name. During this operation a
* <code>IProgressMonitor</code> should be used to indicate progress.
* </p>
* <p>
* If the save is successful, the part fires a property changed event
* reflecting the new dirty state (<code>PROP_DIRTY</code> property).
* </p>
*/
virtual void DoSaveAs() = 0;
/**
* Returns whether the contents of this part have changed since the last save
* operation. If this value changes the part must fire a property listener
* event with <code>PROP_DIRTY</code>.
* <p>
* <b>Note:</b> this method is called often on a part open or part
* activation switch, for example by actions to determine their
* enabled status.
* </p>
*
* @return <code>true</code> if the contents have been modified and need
* saving, and <code>false</code> if they have not changed since the last
* save
*/
virtual bool IsDirty() const = 0;
/**
* Returns whether the "Save As" operation is supported by this part.
*
* @return <code>true</code> if "Save As" is supported, and <code>false</code>
* if not supported
*/
virtual bool IsSaveAsAllowed() const = 0;
/**
* Returns whether the contents of this part should be saved when the part
* is closed.
*
* @return <code>true</code> if the contents of the part should be saved on
* close, and <code>false</code> if the contents are expendable
*/
virtual bool IsSaveOnCloseNeeded() const = 0;
};
}
Q_DECLARE_INTERFACE(berry::ISaveablePart, "org.blueberry.ui.ISaveablePart")
#endif /* BERRYISAVEABLEPART_H_ */
diff --git a/Plugins/org.blueberry.ui.qt/src/berrySaveable.h b/Plugins/org.blueberry.ui.qt/src/berrySaveable.h
index 1657c74af5..33b3627e5a 100644
--- a/Plugins/org.blueberry.ui.qt/src/berrySaveable.h
+++ b/Plugins/org.blueberry.ui.qt/src/berrySaveable.h
@@ -1,225 +1,223 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef BERRYSAVEABLE_H_
#define BERRYSAVEABLE_H_
#include <berryMacros.h>
#include <berryObject.h>
#include <berryIAdaptable.h>
#include <org_blueberry_ui_qt_Export.h>
namespace berry {
struct IWorkbenchPage;
struct IWorkbenchPart;
/**
* A <code>Saveable</code> represents a unit of saveability, e.g. an editable
* subset of the underlying domain model that may contain unsaved changes.
* Different workbench parts (editors and views) may present the same saveables
* in different ways. This interface allows the workbench to provide more
* appropriate handling of operations such as saving and closing workbench
* parts. For example, if two editors sharing the same saveable with unsaved
* changes are closed simultaneously, the user is only prompted to save the
* changes once for the shared saveable, rather than once for each editor.
* <p>
* Workbench parts that work in terms of saveables should implement
* {@link ISaveablesSource}.
* </p>
*
* @see ISaveablesSource
*/
class BERRY_UI_QT Saveable : /*public InternalSaveable*/ public virtual Object, public IAdaptable
{
public:
berryObjectMacro(Saveable);
typedef QSet<Saveable::Pointer> Set;
/**
* Attempts to show this saveable in the given page and returns
* <code>true</code> on success. The default implementation does nothing
* and returns <code>false</code>.
*
* @param page
* the workbench page in which to show this saveable
* @return <code>true</code> if this saveable is now visible to the user
* @since 3.3
*/
virtual bool Show(SmartPointer<IWorkbenchPage> page);
/**
* Returns the name of this saveable for display purposes.
*
* @return the model's name; never <code>null</code>.
*/
virtual QString GetName() const = 0;
/**
* Returns the tool tip text for this saveable. This text is used to
* differentiate between two inputs with the same name. For instance,
* MyClass.java in folder X and MyClass.java in folder Y. The format of the
* text varies between input types.
*
* @return the tool tip text; never <code>null</code>
*/
virtual QString GetToolTipText() const = 0;
/**
* Returns the image descriptor for this saveable.
*
* @return the image descriptor for this model; may be <code>null</code>
* if there is no image
*/
virtual QIcon GetImageDescriptor() const = 0;
/**
* Saves the contents of this saveable.
* <p>
* If the save is cancelled through user action, or for any other reason,
* the part should invoke <code>setCancelled</code> on the
* <code>IProgressMonitor</code> to inform the caller.
* </p>
* <p>
* This method is long-running; progress and cancellation are provided by
* the given progress monitor.
* </p>
*
- * @param monitor
- * the progress monitor
* @throws CoreException
* if the save fails; it is the caller's responsibility to
* report the failure to the user
*/
virtual void DoSave(/*IProgressMonitor monitor*/) = 0;
/**
* Returns whether the contents of this saveable have changed since the last
* save operation.
* <p>
* <b>Note:</b> this method is called frequently, for example by actions to
* determine their enabled status.
* </p>
*
* @return <code>true</code> if the contents have been modified and need
* saving, and <code>false</code> if they have not changed since
* the last save
*/
virtual bool IsDirty() const = 0;
/**
* Clients must implement equals and hashCode as defined in
* \c Object.equals(Object) and \c Object.hashCode() . Two
* saveables should be equal if their dirty state is shared, and saving one
* will save the other. If two saveables are equal, their names, tooltips,
* and images should be the same because only one of them will be shown when
* prompting the user to save.
*
* @param object
* @return true if this Saveable is equal to the given object
*/
bool operator<(const Object* object) const override = 0;
/**
* Clients must implement equals and hashCode as defined in
* \c Object.equals(Object) and \c Object.hashCode() . Two
* saveables should be equal if their dirty state is shared, and saving one
* will save the other. If two saveables are equal, their hash codes MUST be
* the same, and their names, tooltips, and images should be the same
* because only one of them will be shown when prompting the user to save.
* <p>
* IMPORTANT: Implementers should ensure that the hashCode returned is
* sufficiently unique so as not to collide with hashCodes returned by other
* implementations. It is suggested that the defining plug-in's ID be used
* as part of the returned hashCode, as in the following example:
* </p>
*
* <pre>
* int PRIME = 31;
* int hash = ...; // compute the "normal" hash code, e.g. based on some identifier unique within the defining plug-in
* return hash * PRIME + MY_PLUGIN_ID.hashCode();
* </pre>
*
* @return a hash code
*/
uint HashCode() const override = 0;
/**
* Disables the UI of the given parts containing this saveable if necessary.
* This method is not intended to be called by clients. A corresponding call
* to
* <p>
* Saveables that can be saved in the background should ensure that the user
* cannot make changes to their data from the UI, for example by disabling
* controls, unless they are prepared to handle this case. This method is
* called on the UI thread after a job runnable has been returned from
* <code>doSave(IProgressMonitor, IShellProvider)</code> and before
* spinning the event loop. The <code>closing</code> flag indicates that
* this saveable is currently being saved in response to closing a workbench
* part, in which case further changes to this saveable through the UI must
* be prevented.
* </p>
* <p>
* The default implementation calls setEnabled(false) on the given parts'
* composites.
* </p>
*
* @param parts
* the workbench parts containing this saveable
* @param closing
* a boolean flag indicating whether the save was triggered by a
* request to close a workbench part, and all of the given parts
* will be closed after the save operation finishes successfully.
*
* @since 3.3
*/
virtual void DisableUI(const QList<SmartPointer<IWorkbenchPart> >& parts, bool closing);
/**
* Enables the UI of the given parts containing this saveable after a
* background save operation has finished. This method is not intended to be
* called by clients.
* <p>
* The default implementation calls setEnabled(true) on the given parts'
* composites.
* </p>
*
* @param parts
* the workbench parts containing this saveable
*
* @since 3.3
*/
virtual void EnableUI(QList<SmartPointer<IWorkbenchPart> >& parts);
protected:
/**
* This implementation of <code>IAdaptable.GetAdapterImpl(const std::type_info&)</code> returns
* <code>null</code>. Subclasses may override. This allows two unrelated
* subclasses of Saveable to implement \c equals(Object) and
* \c hashCode() based on an underlying implementation class that is
* shared by both Saveable subclasses.
*
* @since 3.3
*/
Object* GetAdapter(const QString& adapter) const override;
};
}
#endif /* BERRYSAVEABLE_H_ */
diff --git a/Plugins/org.blueberry.ui.qt/src/berryWorkbenchPlugin.h b/Plugins/org.blueberry.ui.qt/src/berryWorkbenchPlugin.h
index 978e3ff5be..2b49a0e0f8 100644
--- a/Plugins/org.blueberry.ui.qt/src/berryWorkbenchPlugin.h
+++ b/Plugins/org.blueberry.ui.qt/src/berryWorkbenchPlugin.h
@@ -1,470 +1,469 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef BERRYWORKBENCHPLUGIN_H_
#define BERRYWORKBENCHPLUGIN_H_
#include <Poco/Path.h>
#include <berryIExtensionPoint.h>
#include <berryIExtensionRegistry.h>
#include <berryPlatform.h>
#include <berryCoreException.h>
#include "berryAbstractUICTKPlugin.h"
#include "berryPlatformUI.h"
#include "presentations/berryIPresentationFactory.h"
#include "internal/berryViewRegistry.h"
#include "internal/berryEditorRegistry.h"
#include "internal/berryPerspectiveRegistry.h"
#include "internal/intro/berryIntroRegistry.h"
namespace berry {
class QtStyleManager;
/**
* \ingroup org_blueberry_ui_internal
*
* This class represents the TOP of the workbench UI world
* A plugin class is effectively an application wrapper
* for a plugin & its classes. This class should be thought
* of as the workbench UI's application class.
*
* This class is responsible for tracking various registries
* font, preference, graphics, dialog store.
*
* This class is explicitly referenced by the
* workbench plugin's "plugin.xml" and places it
* into the UI start extension point of the main
* overall application harness
*
* When is this class started?
* When the Application
* calls createExecutableExtension to create an executable
* instance of our workbench class.
*/
class BERRY_UI_QT WorkbenchPlugin : public AbstractUICTKPlugin
{
Q_OBJECT
Q_PLUGIN_METADATA(IID "org_blueberry_ui_qt")
Q_INTERFACES(ctkPluginActivator)
private:
//static const QString UI_BUNDLE_ACTIVATOR = "org.blueberry.ui.internal.UIPlugin"; //$NON-NLS-1$
// Default instance of the receiver
static WorkbenchPlugin* inst;
// The presentation factory
IPresentationFactory* presentationFactory;
// Manager that maps resources to descriptors of editors to use
EditorRegistry* editorRegistry;
// The context within which this plugin was started.
ctkPluginContext* bundleContext;
// Other data.
//WorkbenchPreferenceManager preferenceManager;
ViewRegistry* viewRegistry;
PerspectiveRegistry* perspRegistry;
IntroRegistry* introRegistry;
//SharedImages sharedImages;
QScopedPointer<QtStyleManager> styleManager;
public:
/**
* Global workbench ui plugin flag. Only workbench implementation is allowed to use this flag
* All other plugins, examples, or test cases must *not* use this flag.
*/
static bool DEBUG;
/**
* The character used to separate preference page category ids
*/
static char PREFERENCE_PAGE_CATEGORY_SEPARATOR;
/**
* Create an instance of the WorkbenchPlugin. The workbench plugin is
* effectively the "application" for the workbench UI. The entire UI
* operates as a good plugin citizen.
*/
WorkbenchPlugin();
~WorkbenchPlugin() override;
/*
* Creates an extension. If the extension plugin has not
* been loaded a busy cursor will be activated during the duration of
* the load.
*
* @param element the config element defining the extension
* @param classAttribute the name of the attribute carrying the class
* @return the extension object
* @throws CoreException if the extension cannot be created
*/
// template<class E>
// static E* CreateExtension(IConfigurationElement::ConstPointer element,
// const QString& classAttribute) {
// try {
// // If plugin has been loaded create extension.
// // Otherwise, show busy cursor then create extension.
// if (BundleUtility.isActivated(element.getDeclaringExtension()
// .getNamespace())) {
// return element.createExecutableExtension(classAttribute);
// }
// final Object[] ret = new Object[1];
// final CoreException[] exc = new CoreException[1];
// BusyIndicator.showWhile(null, new Runnable() {
// public void run() {
// try {
// ret[0] = element
// .createExecutableExtension(classAttribute);
// } catch (CoreException e) {
// exc[0] = e;
// }
// }
// });
// if (exc[0] != null) {
// throw exc[0];
// }
// return ret[0];
//
// } catch (CoreException core) {
// throw core;
// } catch (Exception e) {
// throw new CoreException(new Status(IStatus.ERR, PI_WORKBENCH,
// IStatus.ERR, WorkbenchMessages.WorkbenchPlugin_extension,e));
// }
// }
/**
* Answers whether the provided element either has an attribute with the
* given name or a child element with the given name with an attribute
* called class.
*
* @param element
* the element to test
* @param extensionName
* the name of the extension to test for
* @return whether or not the extension is declared
*/
static bool HasExecutableExtension(const IConfigurationElement::Pointer& element,
const QString& extensionName);
/**
* Checks to see if the provided element has the syntax for an executable
* extension with a given name that resides in a bundle that is already
* active. Determining the bundle happens in one of two ways:<br/>
* <ul>
* <li>The element has an attribute with the specified name or element text
* in the form <code>bundle.id/class.name[:optional attributes]</code></li>
* <li>The element has a child element with the specified name that has a
* <code>plugin</code> attribute</li>
* </ul>
*
* @param element
* the element to test
* @param extensionName
* the name of the extension to test for
* @return whether or not the bundle expressed by the above criteria is
* active. If the bundle cannot be determined then the state of the
* bundle that declared the element is returned.
*/
static bool IsBundleLoadedForExecutableExtension(
const IConfigurationElement::Pointer& element, const QString& extensionName);
/**
* Returns the bundle that contains the class referenced by an executable
* extension. Determining the bundle happens in one of two ways:<br/>
* <ul>
* <li>The element has an attribute with the specified name or element text
* in the form <code>bundle.id/class.name[:optional attributes]</code></li>
* <li>The element has a child element with the specified name that has a
* <code>plugin</code> attribute</li>
* </ul>
*
* @param element
* the element to test
* @param extensionName
* the name of the extension to test for
* @return the bundle referenced by the extension. If that bundle cannot be
* determined the bundle that declared the element is returned. Note
* that this may be <code>null</code>.
*/
static QSharedPointer<ctkPlugin> GetBundleForExecutableExtension(
const IConfigurationElement::Pointer& element, const QString& extensionName);
/**
* Return the default instance of the receiver. This represents the runtime plugin.
* @return WorkbenchPlugin
* @see AbstractUICTKPlugin for the typical implementation pattern for plugin classes.
*/
static WorkbenchPlugin* GetDefault();
std::size_t GetBundleCount();
/**
* Answer the manager that maps resource types to a the
* description of the editor to use
* @return IEditorRegistry the editor registry used
* by this plug-in.
*/
IEditorRegistry* GetEditorRegistry();
/**
* Answer the element factory for an id, or <code>null</code>. if not found.
* @param targetID
* @return IElementFactory
*/
IElementFactory* GetElementFactory(const QString& targetID) const;
/**
* Returns the presentation factory with the given id, or <code>null</code> if not found.
- * @param targetID The id of the presentation factory to use.
* @return IPresentationFactory or <code>null</code>
* if not factory matches that id.
*/
IPresentationFactory* GetPresentationFactory();
private:
/**
* Looks up the configuration element with the given id on the given extension point
* and instantiates the class specified by the class attributes.
*
* @param extensionPointId the extension point id (simple id)
* @param elementName the name of the configuration element, or <code>null</code>
* to match any element
* @param targetID the target id
* @return the instantiated extension object, or <code>null</code> if not found
*/
template<class C>
C* CreateExtension(const QString& extensionPointId, const QString& elementName,
const QString& targetID)
{
IExtensionPoint::Pointer extensionPoint = Platform::GetExtensionRegistry()
->GetExtensionPoint(PlatformUI::PLUGIN_ID() + "." + extensionPointId);
if (extensionPoint == 0)
{
WorkbenchPlugin::Log("Unable to find extension. Extension point: " +
extensionPointId + " not found");
return nullptr;
}
// Loop through the config elements.
IConfigurationElement::Pointer targetElement(nullptr);
QList<IConfigurationElement::Pointer> elements(
Platform::GetExtensionRegistry()->GetConfigurationElementsFor(PlatformUI::PLUGIN_ID() + "." + extensionPointId));
for (int j = 0; j < elements.size(); j++)
{
if (elementName == "" || elementName == elements[j]->GetName())
{
QString strID = elements[j]->GetAttribute("id");
if (targetID == strID)
{
targetElement = elements[j];
break;
}
}
}
if (targetElement.IsNull())
{
// log it since we cannot safely display a dialog.
WorkbenchPlugin::Log("Unable to find extension: " + targetID
+ " in extension point: " + extensionPointId);
return nullptr;
}
// Create the extension.
try
{
return targetElement->CreateExecutableExtension<C>("class");
}
catch (const CoreException& /*e*/)
{
// log it since we cannot safely display a dialog.
WorkbenchPlugin::Log("Unable to create extension: " + targetID
+ " in extension point: " + extensionPointId);
}
return nullptr;
}
public:
/**
* Return the perspective registry.
* @return IPerspectiveRegistry. The registry for the receiver.
*/
IPerspectiveRegistry* GetPerspectiveRegistry();
/**
* Returns the introduction registry.
*
* @return the introduction registry.
*/
IIntroRegistry* GetIntroRegistry();
/*
* Get the preference manager.
* @return PreferenceManager the preference manager for
* the receiver.
*/
//PreferenceManager getPreferenceManager();
/**
* Answer the view registry.
* @return IViewRegistry the view registry for the
* receiver.
*/
IViewRegistry* GetViewRegistry();
/**
* Logs the given message to the platform log.
*
* If you have an exception in hand, call log(String, Throwable) instead.
*
* If you have a status object in hand call log(String, IStatus) instead.
*
* This convenience method is for internal use by the Workbench only and
* must not be called outside the Workbench.
*
* @param message
* A high level UI message describing when the problem happened.
*/
static void Log(const QString &message);
/**
* Log the throwable.
* @param exc
*/
static void Log(const ctkException& exc);
/**
* Logs the given message and throwable to the platform log.
*
* If you have a status object in hand call log(String, IStatus) instead.
*
* This convenience method is for internal use by the Workbench only and
* must not be called outside the Workbench.
*
* @param message
* A high level UI message describing when the problem happened.
* @param t
* The throwable from where the problem actually occurred.
*/
static void Log(const QString &message, const ctkException& t);
/**
* Logs the given throwable to the platform log, indicating the class and
* method from where it is being logged (this is not necessarily where it
* occurred).
*
* This convenience method is for internal use by the Workbench only and
* must not be called outside the Workbench.
*
* @param clazz
* The calling class.
* @param methodName
* The calling method name.
* @param t
* The throwable from where the problem actually occurred.
*/
static void Log(const QString &clazz, const QString &methodName, const ctkException& t);
/**
* Logs the given message and status to the platform log.
*
* This convenience method is for internal use by the Workbench only and
* must not be called outside the Workbench.
*
* @param message
* A high level UI message describing when the problem happened.
* May be <code>null</code>.
* @param status
* The status describing the problem. Must not be null.
*/
static void Log(const QString& message, const SmartPointer<IStatus>& status);
/**
* Log the status to the default log.
* @param status
*/
static void Log(const SmartPointer<IStatus>& status);
/*
* (non-Javadoc)
* @see org.osgi.framework.BundleActivator#start(org.osgi.framework.BundleContext)
*/
void start(ctkPluginContext* context) override;
/*
* Return an array of all bundles contained in this workbench.
*
* @return an array of bundles in the workbench or an empty array if none
*/
//const QList<IBundle::Pointer> GetBundles();
/**
* Returns the bundle context associated with the workbench plug-in.
*
* @return the bundle context
*/
ctkPluginContext* GetPluginContext();
/* (non-Javadoc)
* @see org.blueberry.ui.plugin.AbstractUICTKPlugin#stop(org.osgi.framework.BundleContext)
*/
void stop(ctkPluginContext* context) override;
/**
* FOR INTERNAL WORKBENCH USE ONLY.
*
* Returns the path to a location in the file system that can be used
* to persist/restore state between workbench invocations.
* If the location did not exist prior to this call it will be created.
* Returns <code>null</code> if no such location is available.
*
* @return path to a location in the file system where this plug-in can
* persist data between sessions, or <code>null</code> if no such
* location is available.
*/
QString GetDataLocation() const;
};
}
#endif /*BERRYWORKBENCHPLUGIN_H_*/
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryChangeToPerspectiveMenu.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryChangeToPerspectiveMenu.cpp
index ee560fc4bd..6c63eb5ac5 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryChangeToPerspectiveMenu.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryChangeToPerspectiveMenu.cpp
@@ -1,251 +1,251 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "berryChangeToPerspectiveMenu.h"
#include <berryMenuManager.h>
#include <berryIWorkbenchWindow.h>
#include <berryIWorkbenchPage.h>
#include <berryCommandContributionItem.h>
#include <berrySeparator.h>
#include <berryIPluginContribution.h>
#include <berryIPerspectiveRegistry.h>
#include <berryIPreferences.h>
#include <berryIWorkbenchCommandConstants.h>
#include <berryObjectString.h>
#include <berryObjects.h>
#include "berryCommandContributionItemParameter.h"
#include "berryWorkbenchPlugin.h"
#include "berryWorkbenchPreferenceConstants.h"
#include "berryPreferenceConstants.h"
#include <QMenu>
namespace berry {
const QString ChangeToPerspectiveMenu::NO_TARGETS_MSG = "<No Applicable Perspectives>";
bool PerspectiveComparator(const IPerspectiveDescriptor::Pointer& d1,
const IPerspectiveDescriptor::Pointer& d2)
{
return d1->GetLabel() < d2->GetLabel();
}
ChangeToPerspectiveMenu::ChangeToPerspectiveMenu(IWorkbenchWindow* window, const QString& id)
: ContributionItem(id)
, window(window)
, reg(window->GetWorkbench()->GetPerspectiveRegistry())
, showActive(true)
, dirty(true)
{
CommandContributionItemParameter::Pointer showDlgItemParms(
new CommandContributionItemParameter(
window, QString::null, IWorkbenchCommandConstants::PERSPECTIVES_SHOW_PERSPECTIVE,
CommandContributionItem::STYLE_PUSH));
showDlgItemParms->label = "&Other...";
showDlgItem = new CommandContributionItem(showDlgItemParms);
// indicate that a open perspectives submenu has been created
/*
if (WorkbenchWindow* window = dynamic_cast<WorkbenchWindow*>(window))
{
window->AddSubmenu(WorkbenchWindow::OPEN_PERSPECTIVE_SUBMENU);
}
*/
}
void ChangeToPerspectiveMenu::Fill(QMenu* menu, QAction* before)
{
if (MenuManager* mm = dynamic_cast<MenuManager*>(GetParent()))
{
this->connect(mm, SIGNAL(AboutToShow(IMenuManager*)), SLOT(AboutToShow(IMenuManager*)));
}
if (!dirty)
{
return;
}
MenuManager::Pointer manager(new MenuManager());
FillMenu(manager.GetPointer());
QList<IContributionItem::Pointer> items = manager->GetItems();
if (items.isEmpty())
{
auto action = new QAction(NO_TARGETS_MSG, menu);
action->setEnabled(false);
menu->insertAction(before, action);
}
else
{
foreach (IContributionItem::Pointer item, items)
{
item->Fill(menu, before);
}
}
dirty = false;
}
bool ChangeToPerspectiveMenu::IsDirty() const
{
return dirty;
}
bool ChangeToPerspectiveMenu::IsDynamic() const
{
return true;
}
void ChangeToPerspectiveMenu::AboutToShow(IMenuManager* manager)
{
manager->MarkDirty();
dirty = true;
}
void ChangeToPerspectiveMenu::FillMenu(IMenuManager* manager)
{
// Clear out the manager so that we have a blank slate.
manager->RemoveAll();
// Collect and sort perspective descriptors.
QList<IPerspectiveDescriptor::Pointer> persps = GetPerspectiveShortcuts();
qSort(persps.begin(), persps.end(), PerspectiveComparator);
/*
* Convert the perspective descriptors to command parameters, and filter
* using the activity/capability mechanism.
*/
- for (IPerspectiveDescriptor::Pointer descriptor : persps)
+ for (const IPerspectiveDescriptor::Pointer &descriptor : qAsConst(persps))
{
CommandContributionItemParameter::Pointer ccip = GetItem(descriptor);
// if (WorkbenchActivityHelper.filterItem(ccip)) {
// continue;
// }
CommandContributionItem::Pointer item(new CommandContributionItem(ccip));
manager->Add(item);
}
IPreferences::Pointer prefs = WorkbenchPlugin::GetDefault()->GetPreferences();
bool showOther = true;
prefs->GetBool(WorkbenchPreferenceConstants::SHOW_OTHER_IN_PERSPECTIVE_MENU, showOther);
if (showOther)
{
// Add a separator and then "Other..."
if (!manager->IsEmpty())
{
IContributionItem::Pointer separator(new Separator());
manager->Add(separator);
}
manager->Add(showDlgItem);
}
}
SmartPointer<CommandContributionItemParameter> ChangeToPerspectiveMenu::GetItem(const IPerspectiveDescriptor::Pointer& desc) const
{
IPreferences::Pointer prefs = WorkbenchPlugin::GetDefault()->GetPreferences();
int mode = prefs->GetInt(PreferenceConstants::OPEN_PERSP_MODE, PreferenceConstants::OPM_ACTIVE_PAGE);
IWorkbenchPage::Pointer page = window->GetActivePage();
IPerspectiveDescriptor::Pointer persp;
if (page.IsNotNull())
{
persp = page->GetPerspective();
}
QString perspId = desc->GetId();
class PluginCCIP : public CommandContributionItemParameter, public IPluginContribution
{
QString localId;
QString pluginId;
public:
typedef PluginCCIP Self;
static const char* GetStaticClassName() { return "PluginCCIP"; }
berryObjectTypeInfo(CommandContributionItemParameter, IPluginContribution)
PluginCCIP(const IPerspectiveDescriptor::Pointer& v, IServiceLocator* serviceLocator,
const QString& id, const QString& commandId, CommandContributionItem::Style style)
: CommandContributionItemParameter(serviceLocator, id, commandId, style)
{
PerspectiveDescriptor::Pointer vd = v.Cast<PerspectiveDescriptor>();
localId = vd->GetLocalId();
pluginId = vd->GetPluginId();
}
QString GetLocalId() const override
{
return localId;
}
QString GetPluginId() const override
{
return pluginId;
}
};
CommandContributionItemParameter::Pointer parms(new PluginCCIP(desc,
window, perspId, IWorkbenchCommandConstants::PERSPECTIVES_SHOW_PERSPECTIVE,
CommandContributionItem::STYLE_PUSH));
parms->label = desc->GetLabel();
parms->icon = desc->GetImageDescriptor();
Object::Pointer strId(new ObjectString(perspId));
parms->parameters.insert(IWorkbenchCommandConstants::PERSPECTIVES_SHOW_PERSPECTIVE_PARM_ID, strId);
// Only open a new window if user preference is set and the window
// has an active perspective.
if (PreferenceConstants::OPM_NEW_WINDOW == mode && persp.IsNotNull())
{
Object::Pointer bNewWnd(new ObjectBool(true));
parms->parameters.insert(IWorkbenchCommandConstants::PERSPECTIVES_SHOW_PERSPECTIVE_PARM_NEWWINDOW,
bNewWnd);
}
return parms;
}
QList<SmartPointer<IPerspectiveDescriptor> > ChangeToPerspectiveMenu::GetPerspectiveShortcuts() const
{
QList<IPerspectiveDescriptor::Pointer> list;
IWorkbenchPage::Pointer page = window->GetActivePage();
if (page.IsNull())
{
return list;
}
QList<QString> ids = page->GetPerspectiveShortcuts();
for (int i = 0; i < ids.size(); i++)
{
IPerspectiveDescriptor::Pointer desc = reg->FindPerspectiveWithId(ids[i]);
if (desc.IsNotNull() && !list.contains(desc))
{
/*
if (WorkbenchActivityHelper::FilterItem(desc))
{
continue;
}
*/
list.push_back(desc);
}
}
return list;
}
}
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryKeywordRegistry.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryKeywordRegistry.cpp
index e2d5a3bdd1..bea2f397df 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryKeywordRegistry.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryKeywordRegistry.cpp
@@ -1,88 +1,88 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "berryKeywordRegistry.h"
#include "berryIConfigurationElement.h"
#include "berryIExtension.h"
#include "berryIExtensionPoint.h"
#include "berryIExtensionPointFilter.h"
#include "berryIExtensionRegistry.h"
#include "berryExtensionTracker.h"
#include "berryObjectString.h"
#include "berryPlatform.h"
#include "berryPlatformUI.h"
#include "berryWorkbenchRegistryConstants.h"
namespace berry {
const QString KeywordRegistry::ATT_ID = "id";
const QString KeywordRegistry::ATT_LABEL = "label";
const QString KeywordRegistry::TAG_KEYWORD = "keyword";
KeywordRegistry::KeywordRegistry()
{
IExtensionTracker* tracker = PlatformUI::GetWorkbench()->GetExtensionTracker();
tracker->RegisterHandler(this, ExtensionTracker::CreateExtensionPointFilter(GetExtensionPointFilter()));
QList<IExtension::Pointer> extensions = GetExtensionPointFilter()->GetExtensions();
for (auto& extension : extensions)
{
AddExtension(tracker, extension);
}
}
SmartPointer<IExtensionPoint> KeywordRegistry::GetExtensionPointFilter() const
{
return Platform::GetExtensionRegistry()->GetExtensionPoint(
PlatformUI::PLUGIN_ID(), WorkbenchRegistryConstants::PL_KEYWORDS);
}
KeywordRegistry*KeywordRegistry::GetInstance()
{
static KeywordRegistry instance;
return &instance;
}
void KeywordRegistry::AddExtension(IExtensionTracker* tracker, const SmartPointer<IExtension>& extension)
{
- for (auto element : extension->GetConfigurationElements())
+ for (const auto &element : extension->GetConfigurationElements())
{
if (element->GetName() == TAG_KEYWORD)
{
QString name = element->GetAttribute(ATT_LABEL);
QString id = element->GetAttribute(ATT_ID);
internalKeywordMap.insert(id, name);
Object::Pointer trackedObject(new ObjectString(id));
tracker->RegisterObject(extension, trackedObject, IExtensionTracker::REF_STRONG);
}
}
}
QString KeywordRegistry::GetKeywordLabel(const QString& id)
{
auto it = internalKeywordMap.find(id);
return it == internalKeywordMap.end() ? QString::null : *it;
}
void KeywordRegistry::RemoveExtension(const SmartPointer<IExtension>& /*extension*/, const QList<SmartPointer<Object> >& objects)
{
- for (auto object : objects)
+ for (const auto &object : objects)
{
if (ObjectString::Pointer objString = object.Cast<ObjectString>())
{
internalKeywordMap.remove(*objString);
}
}
}
}
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryPreferencePageParameterValues.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryPreferencePageParameterValues.cpp
index d35b99bf88..2c1c25354e 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryPreferencePageParameterValues.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryPreferencePageParameterValues.cpp
@@ -1,74 +1,74 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "berryPreferencePageParameterValues.h"
#include "berryPlatform.h"
#include "berryPlatformUI.h"
#include "berryWorkbenchRegistryConstants.h"
#include "berryIConfigurationElement.h"
#include "berryIExtensionRegistry.h"
#include "berryIWorkbench.h"
namespace berry {
PreferencePageParameterValues::PreferencePageParameterValues()
{
QString xpId = PlatformUI::PLUGIN_ID() + "." + WorkbenchRegistryConstants::PL_PREFERENCES;
Platform::GetExtensionRegistry()->AddListener(this, xpId);
}
QHash<QString, QString> PreferencePageParameterValues::GetParameterValues() const
{
if (preferenceMap.empty())
{
IExtensionRegistry* registry = Platform::GetExtensionRegistry();
if (registry)
{
QList<IConfigurationElement::Pointer> configElements =
registry->GetConfigurationElementsFor(PlatformUI::PLUGIN_ID(),
WorkbenchRegistryConstants::PL_PREFERENCES);
- for (auto configElement : configElements)
+ for (const auto &configElement : qAsConst(configElements))
{
if(configElement->GetName() == "page")
{
preferenceMap.insert(configElement->GetAttribute("name"), configElement->GetAttribute("id"));
}
}
}
}
return preferenceMap;
}
void PreferencePageParameterValues::Added(const QList<SmartPointer<IExtension> >& /*extensions*/)
{
preferenceMap.clear();
}
void berry::PreferencePageParameterValues::Removed(const QList<SmartPointer<berry::IExtension> >& /*extensions*/)
{
preferenceMap.clear();
}
void PreferencePageParameterValues::Added(const QList<SmartPointer<IExtensionPoint> >& /*extensionPoints*/)
{
preferenceMap.clear();
}
void PreferencePageParameterValues::Removed(const QList<SmartPointer<IExtensionPoint> >& /*extensionPoints*/)
{
preferenceMap.clear();
}
}
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryQtShowViewDialog.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryQtShowViewDialog.cpp
index c7e8913037..ae564734bc 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryQtShowViewDialog.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryQtShowViewDialog.cpp
@@ -1,327 +1,327 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "berryQtShowViewDialog.h"
#include <berryIViewDescriptor.h>
#include <berryIPreferences.h>
#include <berryViewTreeModel.h>
#include "berryWorkbenchPlugin.h"
#include "berryXMLMemento.h"
#include <QSortFilterProxyModel>
#include <QPushButton>
namespace berry {
static const QString TAG_SHOWVIEWDIALOG = "ShowViewDialog";
static const QString TAG_CATEGORY = "category";
static const QString TAG_SELECTION = "selection";
static const QString TAG_GEOMETRY = "geometry";
class ViewFilterProxyModel : public QSortFilterProxyModel
{
public:
ViewFilterProxyModel(QObject* parent = nullptr)
: QSortFilterProxyModel(parent)
, m_FilterOnKeywords(true)
{
this->setFilterCaseSensitivity(Qt::CaseInsensitive);
}
bool filterOnKeywords() const
{
return m_FilterOnKeywords;
}
void setFilterOnKeywords(bool filterOnKeywords)
{
if (m_FilterOnKeywords != filterOnKeywords)
{
m_FilterOnKeywords = filterOnKeywords;
this->filterChanged();
}
}
protected:
bool filterAcceptsRow(int sourceRow, const QModelIndex& sourceParent) const override
{
QRegExp regExp = filterRegExp();
if (!regExp.isValid() || regExp.isEmpty()) return true;
QModelIndex sourceIndex = sourceModel()->index(sourceRow, 0, sourceParent);
QStringList keywords;
if (m_FilterOnKeywords)
{
keywords = sourceModel()->data(sourceIndex, ViewTreeModel::Keywords).toStringList();
}
else
{
if (sourceModel()->hasChildren(sourceIndex))
{
// this is a category item
int numChildren = sourceModel()->rowCount(sourceIndex);
for (int i = 0; i < numChildren; ++i)
{
keywords.push_back(sourceModel()->data(sourceIndex.child(i, 0)).toString());
}
}
else
{
// this is a view item
keywords.push_back(sourceModel()->data(sourceIndex).toString());
}
}
for(auto& keyword : keywords)
{
if (keyword.contains(regExp)) return true;
}
return false;
}
private:
bool m_FilterOnKeywords;
};
QtShowViewDialog::QtShowViewDialog(const IWorkbenchWindow* window, IViewRegistry* registry,
QWidget* parent, Qt::WindowFlags f)
: QDialog(parent, f)
, m_Window(window)
, m_ViewReg(registry)
, m_FilterModel(nullptr)
{
m_UserInterface.setupUi(this);
m_UserInterface.m_TreeView->header()->setVisible(false);
m_UserInterface.m_TreeView->setSelectionMode(QAbstractItemView::ExtendedSelection);
m_FilterModel = new ViewFilterProxyModel(this);
auto sourceModel = new ViewTreeModel(window, m_FilterModel);
m_FilterModel->setSourceModel(sourceModel);
m_UserInterface.m_TreeView->setModel(m_FilterModel);
connect(m_UserInterface.m_Filter, SIGNAL(textChanged(QString)), this, SLOT(setFilter(QString)));
connect(m_UserInterface.m_TreeView, SIGNAL(clicked(QModelIndex)), this, SLOT(setDescription(QModelIndex)));
connect(m_UserInterface.m_TreeView, SIGNAL(collapsed(QModelIndex)), this, SLOT(categoryCollapsed(QModelIndex)));
connect(m_UserInterface.m_TreeView, SIGNAL(expanded(QModelIndex)), this, SLOT(categoryExpanded(QModelIndex)));
connect(m_UserInterface.m_TreeView, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(accept()));
connect(m_UserInterface.m_TreeView, SIGNAL(activated(QModelIndex)), this, SLOT(accept()));
connect(m_UserInterface.m_TreeView->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)), this, SLOT(selectionChanged(QItemSelection,QItemSelection)));
connect(m_UserInterface.m_KeywordFilter, SIGNAL(clicked(bool)), this, SLOT(enableKeywordFilter(bool)));
this->RestoreState();
m_UserInterface.m_Filter->selectAll();
this->UpdateButtons();
}
void QtShowViewDialog::setDescription(const QModelIndex& index)
{
QString description = m_UserInterface.m_TreeView->model()->data(index, Qt::WhatsThisRole).toString();
m_UserInterface.m_Description->setText(description);
}
void QtShowViewDialog::enableKeywordFilter(bool enable)
{
m_FilterModel->setFilterOnKeywords(enable);
this->RestoreExpandedState();
}
void QtShowViewDialog::setFilter(const QString& filter)
{
m_FilterModel->setFilterWildcard(filter);
this->RestoreExpandedState();
}
void QtShowViewDialog::categoryCollapsed(const QModelIndex& index)
{
m_ExpandedCategories.removeAll(m_FilterModel->mapToSource(index));
}
void QtShowViewDialog::categoryExpanded(const QModelIndex& index)
{
m_ExpandedCategories.push_back(m_FilterModel->mapToSource(index));
}
void QtShowViewDialog::selectionChanged(const QItemSelection& /*selected*/, const QItemSelection& /*deselected*/)
{
UpdateButtons();
}
void QtShowViewDialog::RestoreExpandedState()
{
int rowCount = m_FilterModel->rowCount();
for (int i = 0; i < rowCount; ++i)
{
QModelIndex index = m_FilterModel->index(i, 0);
if (m_ExpandedCategories.contains(m_FilterModel->mapToSource(index)))
{
m_UserInterface.m_TreeView->expand(index);
}
}
}
void QtShowViewDialog::UpdateButtons()
{
QPushButton* okBtn = m_UserInterface.m_ButtonBox->button(QDialogButtonBox::Ok);
if (okBtn)
{
okBtn->setEnabled(!m_UserInterface.m_TreeView->selectionModel()->selection().isEmpty());
}
}
void QtShowViewDialog::RestoreState()
{
IPreferences::Pointer prefs = WorkbenchPlugin::GetDefault()->GetPreferences();
QString str = prefs->Get(TAG_SHOWVIEWDIALOG, QString::null);
if (str.isEmpty()) return;
std::stringstream ss(str.toStdString());
XMLMemento::Pointer memento = XMLMemento::CreateReadRoot(ss);
bool keywordFilter = false;
if (memento->GetBoolean("keywordFilter", keywordFilter))
{
m_UserInterface.m_KeywordFilter->setChecked(keywordFilter);
m_FilterModel->setFilterOnKeywords(keywordFilter);
}
QString filter;
if (memento->GetString("filter", filter))
{
m_UserInterface.m_Filter->setText(filter);
}
IMemento::Pointer geomChild = memento->GetChild(TAG_GEOMETRY);
if (geomChild.IsNotNull())
{
QString geom = geomChild->GetTextData();
if (!geom.isEmpty())
{
QByteArray ba = QByteArray::fromBase64(geom.toLatin1());
this->restoreGeometry(ba);
}
}
QHash<QString, QModelIndex> rootIndices;
int rowCount = m_FilterModel->sourceModel()->rowCount();
for (int i = 0; i < rowCount; ++i)
{
QModelIndex sourceIndex = m_FilterModel->sourceModel()->index(i, 0);
QString id = sourceIndex.data(ViewTreeModel::Id).toString();
if (!id.isEmpty())
{
rootIndices[id] = sourceIndex;
}
}
- for (IMemento::Pointer categoryChild : memento->GetChildren(TAG_CATEGORY))
+ for (const IMemento::Pointer &categoryChild : memento->GetChildren(TAG_CATEGORY))
{
QString id = categoryChild->GetID();
if (!id.isEmpty())
{
if (rootIndices.contains(id))
{
m_ExpandedCategories.push_back(rootIndices[id]);
}
}
}
this->RestoreExpandedState();
QItemSelection itemSelection;
- for (IMemento::Pointer selectionChild : memento->GetChildren(TAG_SELECTION))
+ for (const IMemento::Pointer &selectionChild : memento->GetChildren(TAG_SELECTION))
{
QString id = selectionChild->GetID();
if (!id.isEmpty())
{
QModelIndexList indexList = m_FilterModel->match(m_FilterModel->index(0, 0), ViewTreeModel::Id, QVariant::fromValue(id),
1, Qt::MatchExactly | Qt::MatchRecursive);
if (!indexList.isEmpty())
{
QItemSelection subSelection(indexList.front(), indexList.front());
itemSelection.merge(subSelection, QItemSelectionModel::SelectCurrent);
}
}
}
m_UserInterface.m_TreeView->selectionModel()->select(itemSelection, QItemSelectionModel::ClearAndSelect);
}
void QtShowViewDialog::SaveState()
{
XMLMemento::Pointer memento = XMLMemento::CreateWriteRoot(TAG_SHOWVIEWDIALOG);
memento->PutString("filter", m_UserInterface.m_Filter->text());
memento->PutBoolean("keywordFilter", m_UserInterface.m_KeywordFilter->isChecked());
// dialog geometry
QByteArray geom = this->saveGeometry();
IMemento::Pointer geomChild = memento->CreateChild(TAG_GEOMETRY);
geomChild->PutTextData(geom.toBase64().constData());
// expanded categories
- for (QPersistentModelIndex index : m_ExpandedCategories)
+ for (const QPersistentModelIndex &index : qAsConst(m_ExpandedCategories))
{
if (index.isValid())
{
QString id = index.data(ViewTreeModel::Id).toString();
if (!id.isEmpty())
{
memento->CreateChild(TAG_CATEGORY, id);
}
}
}
// we only record a single selected item. restoring a multi-selection might be
// confusing for the user
QModelIndexList selectedIndices = m_UserInterface.m_TreeView->selectionModel()->selectedIndexes();
if (!selectedIndices.isEmpty())
{
QString id = selectedIndices.back().data(ViewTreeModel::Id).toString();
if (!id.isEmpty())
{
memento->CreateChild(TAG_SELECTION, id);
}
}
std::stringstream ss;
memento->Save(ss);
IPreferences::Pointer prefs = WorkbenchPlugin::GetDefault()->GetPreferences();
prefs->Put(TAG_SHOWVIEWDIALOG, QString::fromStdString(ss.str()));
prefs->Sync();
}
void QtShowViewDialog::done(int r)
{
this->SaveState();
QDialog::done(r);
}
QList<QString>
QtShowViewDialog::GetSelection() const
{
QList<QString> selected;
QModelIndexList indices = m_UserInterface.m_TreeView->selectionModel()->selectedIndexes();
- for(QModelIndex index : indices)
+ for(QModelIndex index : qAsConst(indices))
{
QString id = m_FilterModel->data(index, ViewTreeModel::Id).toString();
selected.push_back(id);
}
return selected;
}
}
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryReopenEditorMenu.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryReopenEditorMenu.cpp
index 7ef43c54f0..8309f352a7 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryReopenEditorMenu.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryReopenEditorMenu.cpp
@@ -1,299 +1,299 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "berryReopenEditorMenu.h"
#include <berryIPreferences.h>
#include <berryIWorkbench.h>
#include <berryIWorkbenchPage.h>
#include <berryMenuManager.h>
#include <berrySafeRunner.h>
#include "berryEditorHistory.h"
#include "berryEditorHistoryItem.h"
#include "berryWorkbench.h"
#include "berryWorkbenchPlugin.h"
#include "berryPreferenceConstants.h"
#include <QAction>
#include <QMenu>
#include <QMessageBox>
namespace berry {
ReopenEditorMenu::ReopenEditorMenu(IWorkbenchWindow* window, const QString& id, bool showSeparator)
: ContributionItem(id)
, window(window)
, history(nullptr)
, showSeparator(showSeparator)
, dirty(true)
{
IWorkbench* workbench = window->GetWorkbench();
if (Workbench* w = dynamic_cast<Workbench*>(workbench))
{
history = w->GetEditorHistory();
}
}
QString ReopenEditorMenu::CalcText(int index, const QString& name, const QString& toolTip, bool rtl)
{
QString sb;
int mnemonic = index + 1;
QString nm = QString::number(mnemonic);
if (mnemonic <= MAX_MNEMONIC_SIZE)
{
nm.prepend('&');
}
QString fileName = name;
QString pathName = toolTip;
if (pathName == fileName)
{
// tool tip text isn't necessarily a path;
// sometimes it's the same as name, so it shouldn't be treated as a path then
pathName.clear();
}
QFileInfo path(pathName);
// if last segment in path is the fileName, remove it
if (path.fileName() == fileName)
{
path.setFile(path.path());
pathName = path.absoluteFilePath();
}
if ((fileName.size() + pathName.size()) <= (MAX_TEXT_LENGTH - 4))
{
// entire item name fits within maximum length
sb += fileName;
if (!pathName.isEmpty())
{
sb += " [" + pathName + "]";
}
}
else
{
// need to shorten the item name
int length = fileName.size();
if (length > MAX_TEXT_LENGTH)
{
// file name does not fit within length, truncate it
- sb += fileName.left(MAX_TEXT_LENGTH - 3);
+ sb += fileName.leftRef(MAX_TEXT_LENGTH - 3);
sb += "...";
}
else if (length > MAX_TEXT_LENGTH - 7)
{
sb += fileName;
}
else
{
sb += fileName;
QStringList pathSegments = path.absoluteFilePath().split('/', QString::SkipEmptyParts);
int segmentCount = pathSegments.size();
if (segmentCount > 0)
{
length += 7; // 7 chars are taken for " [...]"
sb += " [";
// Add first n segments that fit
int i = 0;
while (i < segmentCount && length < MAX_TEXT_LENGTH)
{
const QString& segment = pathSegments[i];
if (length + segment.size() < MAX_TEXT_LENGTH)
{
sb += segment + QDir::separator();
length += segment.size() + 1;
i++;
}
else if (i == 0)
{
// append at least part of the first segment
- sb += segment.left(MAX_TEXT_LENGTH - length);
+ sb += segment.leftRef(MAX_TEXT_LENGTH - length);
length = MAX_TEXT_LENGTH;
break;
}
else
{
break;
}
}
sb += "...";
i = segmentCount - 1;
// Add last n segments that fit
while (i > 0 && length < MAX_TEXT_LENGTH)
{
const QString& segment = pathSegments[i];
if (length + segment.size() < MAX_TEXT_LENGTH)
{
sb += QDir::separator();
sb += segment;
length += segment.size() + 1;
i--;
}
else
{
break;
}
}
sb.append("]");
}
}
}
QString process;
if (rtl)
{
process = sb + " " + nm;
}
else
{
process = nm + " " + sb;
}
//return TextProcessor.process(process, TextProcessor.getDefaultDelimiters() + "[]");
return process;
}
void ReopenEditorMenu::Fill(QMenu* menu, QAction* before)
{
if (window->GetActivePage() == nullptr
|| window->GetActivePage()->GetPerspective().IsNull())
{
return;
}
if (MenuManager* mm = dynamic_cast<MenuManager*>(this->GetParent()))
{
mm->connect(mm, SIGNAL(AboutToShow(IMenuManager*)), this, SLOT(MenuAboutToShow(IMenuManager*)));
}
int itemsToShow = WorkbenchPlugin::GetDefault()->GetPreferences()->GetInt(PreferenceConstants::RECENT_FILES, 6);
if (itemsToShow == 0 || history == nullptr)
{
return;
}
// Get items.
QList<EditorHistoryItem::Pointer> historyItems = history->GetItems();
int n = std::min(itemsToShow, historyItems.size());
if (n <= 0)
{
return;
}
if (showSeparator)
{
menu->addSeparator();
}
struct _SafeRunnable : public ISafeRunnable
{
QMenu* menu;
QAction* before;
EditorHistoryItem::Pointer item;
const int historyIndex;
_SafeRunnable(QMenu* menu, QAction* before, EditorHistoryItem::Pointer item, int index)
: menu(menu), before(before), item(item), historyIndex(index) {}
void Run() override
{
QString text = ReopenEditorMenu::CalcText(historyIndex, item);
auto mi = new QAction(text, nullptr);
menu->insertAction(before, mi);
mi->setData(QVariant::fromValue(item));
}
void HandleException(const ctkException& e) override
{
// just skip the item if there's an error,
// e.g. in the calculation of the shortened name
WorkbenchPlugin::Log(this->GetClassName(), "Fill", e);
}
};
for (int i = 0; i < n; i++)
{
EditorHistoryItem::Pointer item = historyItems[i];
ISafeRunnable::Pointer runnable(new _SafeRunnable(menu, before, item, i));
SafeRunner::Run(runnable);
}
dirty = false;
}
bool ReopenEditorMenu::IsDirty() const
{
return dirty;
}
bool ReopenEditorMenu::IsDynamic() const
{
return true;
}
void ReopenEditorMenu::Open(const EditorHistoryItem::Pointer& item)
{
IWorkbenchPage::Pointer page = window->GetActivePage();
if (page.IsNotNull())
{
try
{
QString itemName = item->GetName();
if (!item->IsRestored())
{
item->RestoreState();
}
IEditorInput::Pointer input = item->GetInput();
IEditorDescriptor::Pointer desc = item->GetDescriptor();
if (!input || !desc)
{
QString title = "Problems opening editor";
QString msg = QString("Unable to open %1.").arg(itemName);
QMessageBox::warning(window->GetShell()->GetControl(), title, msg);
history->Remove(item);
}
else
{
page->OpenEditor(input, desc->GetId());
}
}
catch (const PartInitException& e2)
{
QString title = "Problems opening editor";
QMessageBox::warning(window->GetShell()->GetControl(), title, e2.what());
history->Remove(item);
}
}
}
QString ReopenEditorMenu::CalcText(int index, const EditorHistoryItem::Pointer& item)
{
// IMPORTANT: avoid accessing the item's input since
// this can require activating plugins.
// Instead, ask the item for the info, which can
// consult its memento if it is not restored yet.
return CalcText(index, item->GetName(), item->GetToolTipText(), false);
// Window::GetDefaultOrientation() == SWT.RIGHT_TO_LEFT);
}
void ReopenEditorMenu::MenuAboutToShow(IMenuManager* manager)
{
manager->MarkDirty();
dirty = true;
}
}
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berrySwitchToWindowMenu.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berrySwitchToWindowMenu.cpp
index 9622cd5b32..18425006a8 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/berrySwitchToWindowMenu.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berrySwitchToWindowMenu.cpp
@@ -1,155 +1,155 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "berrySwitchToWindowMenu.h"
#include <berryMenuManager.h>
#include <berryShell.h>
#include <berryIWorkbench.h>
#include <berryIWorkbenchWindow.h>
#include <QAction>
#include <QActionGroup>
#include <QMenu>
#include <QSignalMapper>
namespace berry {
void SwitchToWindowMenu::AboutToShow(IMenuManager* manager)
{
manager->MarkDirty();
dirty = true;
}
void SwitchToWindowMenu::MenuItemTriggered(int index)
{
if (index < 0 || index >= windows.size()) return;
IWorkbenchWindow* window = windows[index];
Shell::Pointer windowShell = window->GetShell();
if (windowShell->GetMinimized())
{
windowShell->SetMinimized(false);
}
windowShell->SetActive();
windowShell->GetControl()->raise();
}
QString SwitchToWindowMenu::CalcText(int number, IWorkbenchWindow* window)
{
QString suffix = window->GetShell()->GetText();
if (suffix.isEmpty())
{
return QString::null;
}
QString sb;
if (number < 10)
{
sb.append('&');
}
sb.append(QString::number(number));
sb.append(' ');
if (suffix.size() <= MAX_TEXT_LENGTH)
{
sb.append(suffix);
}
else
{
- sb.append(suffix.left(MAX_TEXT_LENGTH));
+ sb.append(suffix.leftRef(MAX_TEXT_LENGTH));
sb.append("...");
}
return sb;
}
SwitchToWindowMenu::SwitchToWindowMenu(IWorkbenchWindow* window, const QString& id, bool showSeparator)
: ContributionItem(id)
, workbenchWindow(window)
, showSeparator(showSeparator)
, dirty(true)
{
}
void SwitchToWindowMenu::Fill(QMenu* menu, QAction* before)
{
// Get workbench windows.
IWorkbench* workbench = workbenchWindow->GetWorkbench();
windows.clear();
- for (auto window : workbench->GetWorkbenchWindows())
+ for (const auto &window : workbench->GetWorkbenchWindows())
{
windows.push_back(window.GetPointer());
}
// avoid showing the separator and list for 0 or 1 items
if (windows.size() < 2)
{
return;
}
if (MenuManager* mm = dynamic_cast<MenuManager*>(GetParent()))
{
this->connect(mm, SIGNAL(AboutToShow(IMenuManager*)), SLOT(AboutToShow(IMenuManager*)));
}
if (!dirty)
{
return;
}
// Add separator.
if (showSeparator)
{
menu->insertSeparator(before);
}
// Add one item for each window.
auto actionGroup = new QActionGroup(menu);
actionGroup->setExclusive(true);
auto signalMapper = new QSignalMapper(menu);
connect(signalMapper, SIGNAL(mapped(int)), SLOT(MenuItemTriggered(int)));
int count = 0;
- for (auto window : windows)
+ for (auto window : qAsConst(windows))
{
// can encounter disposed shells if this update is in response to a shell closing
//if (!window->GetShell()->IsDisposed())
//{
QString name = CalcText(count, window);
if (!name.isEmpty())
{
auto mi = new QAction(name, menu);
mi->setCheckable(true);
mi->setChecked(window == workbenchWindow);
actionGroup->addAction(mi);
menu->insertAction(before, mi);
signalMapper->setMapping(mi, count);
connect(mi, SIGNAL(triggered()), signalMapper, SLOT(map()));
}
++count;
}
//}
dirty = false;
}
bool SwitchToWindowMenu::IsDirty() const
{
return dirty;
}
bool SwitchToWindowMenu::IsDynamic() const
{
return true;
}
}
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/dialogs/berryPerspectivesPreferencePage.cpp b/Plugins/org.blueberry.ui.qt/src/internal/dialogs/berryPerspectivesPreferencePage.cpp
index ea3d0eabd9..b1050da66d 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/dialogs/berryPerspectivesPreferencePage.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/dialogs/berryPerspectivesPreferencePage.cpp
@@ -1,284 +1,284 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "berryPerspectivesPreferencePage.h"
#include "ui_berryPerspectivesPreferencePage.h"
#include <berryIPreferencesService.h>
#include <berryIPreferences.h>
#include <berryIWorkbenchPage.h>
#include "internal/berryPerspective.h"
#include "internal/berryPerspectiveRegistry.h"
#include "internal/berryPreferenceConstants.h"
#include "internal/berryWorkbenchPage.h"
#include "berryWorkbenchPlugin.h"
#include <QListWidgetItem>
#include <QMessageBox>
namespace berry {
bool PerspectiveComparator(const PerspectiveDescriptor::Pointer& p1, const PerspectiveDescriptor::Pointer& p2)
{
return p1->GetLabel() < p2->GetLabel();
}
PerspectivesPreferencePage::PerspectivesPreferencePage()
: ui(nullptr)
, pageWidget(nullptr)
, workbench(nullptr)
, perspRegistry(nullptr)
{
}
PerspectivesPreferencePage::~PerspectivesPreferencePage()
{
delete ui;
}
void PerspectivesPreferencePage::Init(berry::IWorkbench::Pointer workbench)
{
ui = new Ui::PerspectivesPreferencePage;
this->workbench = workbench.GetPointer();
perspRegistry = dynamic_cast<PerspectiveRegistry*>(workbench->GetPerspectiveRegistry());
}
void PerspectivesPreferencePage::CreateQtControl(QWidget* parent)
{
pageWidget = new QWidget(parent);
ui->setupUi(pageWidget);
ui->perspectivesListWidget->setSelectionMode(QAbstractItemView::SingleSelection);
ui->perspectivesListWidget->setIconSize(QSize(16, 16));
connect(ui->sameWindowButton, SIGNAL(clicked()), this, SLOT(OpenPerspInSameWindow()));
connect(ui->newWindowButton, SIGNAL(clicked()), this, SLOT(OpenPerspInNewWindow()));
connect(ui->perspectivesListWidget, SIGNAL(itemSelectionChanged()), this, SLOT(PerspectiveSelectionChanged()));
connect(ui->revertButton, SIGNAL(clicked()), this, SLOT(RevertPerspective()));
connect(ui->makeDefaultButton, SIGNAL(clicked()), this, SLOT(MakeDefaultPerspective()));
connect(ui->deleteButton, SIGNAL(clicked()), this, SLOT(DeletePerspective()));
this->Update();
}
QWidget* PerspectivesPreferencePage::GetQtControl() const
{
return pageWidget;
}
bool PerspectivesPreferencePage::PerformOk()
{
// Set the default perspective
if (defaultPerspectiveId != perspRegistry->GetDefaultPerspective())
{
perspRegistry->SetDefaultPerspective(defaultPerspectiveId);
}
//Delete the perspective
if(perspectives.size() < perspRegistry->GetPerspectives().size())
{
QList<IWorkbenchWindow::Pointer> windows = workbench->GetWorkbenchWindows();
// close any perspectives that are about to be deleted
for (int i = 0; i < windows.size(); i++)
{
QList<IWorkbenchPage::Pointer> pages = windows[i]->GetPages();
for (int j = 0; j < pages.size(); j++)
{
WorkbenchPage::Pointer page = pages[j].Cast<WorkbenchPage>();
for (int k = 0; k < perspToDelete.size(); k++)
{
IPerspectiveDescriptor::Pointer desc(perspToDelete[k].GetPointer());
if (page->FindPerspective(desc).IsNotNull())
{
page->ClosePerspective(desc, true, true);
}
}
}
}
perspRegistry->DeletePerspectives(perspToDelete);
}
// Revert the perspectives
perspRegistry->RevertPerspectives(perspToRevert);
// store the open perspective mode setting
preferences->PutInt(PreferenceConstants::OPEN_PERSP_MODE, openPerspMode);
return true;
}
void PerspectivesPreferencePage::PerformCancel()
{
}
void PerspectivesPreferencePage::Update()
{
preferences = WorkbenchPlugin::GetDefault()->GetPreferences();
openPerspMode = preferences->GetInt(PreferenceConstants::OPEN_PERSP_MODE, PreferenceConstants::OPM_ACTIVE_PAGE);
ui->sameWindowButton->setChecked(openPerspMode == PreferenceConstants::OPM_ACTIVE_PAGE);
ui->newWindowButton->setChecked(openPerspMode == PreferenceConstants::OPM_NEW_WINDOW);
// Populate the perspectivesTable
perspectives.clear();
perspToRevert.clear();
perspToDelete.clear();
QList<IPerspectiveDescriptor::Pointer> persps = perspRegistry->GetPerspectives();
for (int i = 0; i < persps.size(); i++)
{
perspectives.push_back(persps[i].Cast<PerspectiveDescriptor>());
}
qSort(perspectives.begin(), perspectives.end(), PerspectiveComparator);
defaultPerspectiveId = perspRegistry->GetDefaultPerspective();
UpdatePerspectivesTable();
}
void PerspectivesPreferencePage::OpenPerspInSameWindow()
{
openPerspMode = PreferenceConstants::OPM_ACTIVE_PAGE;
}
void PerspectivesPreferencePage::OpenPerspInNewWindow()
{
openPerspMode = PreferenceConstants::OPM_NEW_WINDOW;
}
void PerspectivesPreferencePage::PerspectiveSelectionChanged()
{
UpdateButtons();
}
void PerspectivesPreferencePage::RevertPerspective()
{
PerspectiveDescriptor::Pointer desc = GetSelectedPerspective();
if (desc.IsNotNull() && !perspToRevert.contains(desc))
{
perspToRevert.push_back(desc);
}
UpdateButtons();
}
void PerspectivesPreferencePage::DeletePerspective()
{
PerspectiveDescriptor::Pointer desc = GetSelectedPerspective();
if (desc.IsNotNull() && !perspToDelete.contains(desc))
{
if (!FindOpenInstance(desc))
{
perspToDelete.push_back(desc);
perspToRevert.removeAll(desc);
perspectives.removeAll(desc);
UpdatePerspectivesTable();
}
}
UpdateButtons();
}
void PerspectivesPreferencePage::MakeDefaultPerspective()
{
PerspectiveDescriptor::Pointer desc = GetSelectedPerspective();
if (desc.IsNotNull() && !perspToDelete.contains(desc))
{
int row = perspectives.indexOf(desc);
defaultPerspectiveId = desc->GetId();
UpdatePerspectivesTable();
ui->perspectivesListWidget->item(row)->setSelected(true);
}
UpdateButtons();
}
void PerspectivesPreferencePage::UpdateButtons()
{
PerspectiveDescriptor::Pointer desc = GetSelectedPerspective();
if (desc)
{
ui->revertButton->setEnabled(desc->IsPredefined() && desc->HasCustomDefinition() && !perspToRevert.contains(desc));
ui->deleteButton->setEnabled(!desc->IsPredefined());
ui->makeDefaultButton->setEnabled(true);
}
else
{
ui->revertButton->setEnabled(false);
ui->deleteButton->setEnabled(false);
ui->makeDefaultButton->setEnabled(false);
}
}
void PerspectivesPreferencePage::UpdatePerspectivesTable()
{
ui->perspectivesListWidget->clear();
- for (PerspectiveDescriptor::Pointer desc : perspectives)
+ for (const PerspectiveDescriptor::Pointer &desc : qAsConst(perspectives))
{
NewPerspectivesTableItem(desc);
}
}
void PerspectivesPreferencePage::NewPerspectivesTableItem(const SmartPointer<PerspectiveDescriptor>& desc)
{
QString label = desc->GetLabel();
if (desc->GetId() == defaultPerspectiveId)
{
label += " (default)";
}
new QListWidgetItem(desc->GetImageDescriptor(), label, ui->perspectivesListWidget);
}
bool PerspectivesPreferencePage::FindOpenInstance(const PerspectiveDescriptor::Pointer& desc)
{
QList<IWorkbenchWindow::Pointer> windows = workbench->GetWorkbenchWindows();
//find all active perspectives currently
for (int i = 0; i < windows.size(); i++)
{
QList<IWorkbenchPage::Pointer> pages = windows[i]->GetPages();
for (int j = 0; j < pages.size(); j++)
{
WorkbenchPage::Pointer page = pages[j].Cast<WorkbenchPage>();
if (page->FindPerspective(desc).IsNotNull())
{
QMessageBox::StandardButton returnCode =
QMessageBox::question(workbench->GetActiveWorkbenchWindow()->GetShell()->GetControl(),
"Delete Perspective",
QString("Are you sure you want to delete the \"%1\" perspective? It has open instances.").arg(desc->GetLabel()),
QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
return (returnCode != QMessageBox::Yes);
}
}
}
return false;
}
SmartPointer<PerspectiveDescriptor> PerspectivesPreferencePage::GetSelectedPerspective() const
{
PerspectiveDescriptor::Pointer desc;
QList<QListWidgetItem*> selection = ui->perspectivesListWidget->selectedItems();
if (!selection.isEmpty())
{
int row = ui->perspectivesListWidget->row(selection.back());
if (row > -1)
{
desc = perspectives.at(row);
}
}
return desc;
}
}
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/handlers/berryShowViewHandler.cpp b/Plugins/org.blueberry.ui.qt/src/internal/handlers/berryShowViewHandler.cpp
index 3422f36133..bee11dae60 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/handlers/berryShowViewHandler.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/handlers/berryShowViewHandler.cpp
@@ -1,112 +1,112 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "berryShowViewHandler.h"
#include "berryIWorkbenchCommandConstants.h"
#include "berryHandlerUtil.h"
#include "berryUIException.h"
#include "berryIWorkbenchPage.h"
#include "berryIViewDescriptor.h"
#include "berryPlatformUI.h"
#include "berryWorkbenchPlugin.h"
#include "internal/berryQtShowViewDialog.h"
#include <berryCommandExceptions.h>
#include <vector>
namespace berry
{
ShowViewHandler::ShowViewHandler()
{
}
Object::Pointer ShowViewHandler::Execute(const ExecutionEvent::ConstPointer& event)
{
IWorkbenchWindow::Pointer window = HandlerUtil::GetActiveWorkbenchWindowChecked(event);
// Get the view identifier, if any.
const ExecutionEvent::ParameterMap& parameters = event->GetParameters();
ExecutionEvent::ParameterMap::const_iterator result = parameters.find(IWorkbenchCommandConstants::VIEWS_SHOW_VIEW_PARM_ID);
QString viewId = result != parameters.end() ? result.value() : QString::null;
result = parameters.find(IWorkbenchCommandConstants::VIEWS_SHOW_VIEW_SECONDARY_ID);
QString secondary = result != parameters.end() ? result.value() : QString::null;
if (viewId.isEmpty())
{
this->OpenOther(window);
}
else
{
try
{
this->OpenView(viewId, secondary, window);
}
catch (const PartInitException& e)
{
throw ExecutionException("Part could not be initialized", e);
}
}
return Object::Pointer(nullptr);
}
void ShowViewHandler::OpenOther(IWorkbenchWindow::Pointer window)
{
const IWorkbenchPage::Pointer page = window->GetActivePage();
if (page.IsNull())
{
return;
}
QtShowViewDialog dialog(window.GetPointer(), WorkbenchPlugin::GetDefault()->GetViewRegistry());
int returnCode = dialog.exec();
if (returnCode == QDialog::Rejected)
{
return;
}
const QList<QString> descriptors = dialog.GetSelection();
- for (QString id : descriptors)
+ for (const QString &id : descriptors)
{
try
{
this->OpenView(id, QString(), window);
}
catch (const PartInitException& e)
{
BERRY_WARN << e.what();
// StatusUtil.handleStatus(e.getStatus(),
// WorkbenchMessages.ShowView_errorTitle
// + ": " + e.getMessage(), //$NON-NLS-1$
// StatusManager.SHOW);
}
}
}
void ShowViewHandler::OpenView(const QString& viewId, const QString& secondaryId, IWorkbenchWindow::Pointer activeWorkbenchWindow)
{
const IWorkbenchPage::Pointer activePage = activeWorkbenchWindow->GetActivePage();
if (activePage.IsNull())
{
return;
}
activePage->ShowView(viewId, secondaryId, IWorkbenchPage::VIEW_ACTIVATE);
}
}
diff --git a/Plugins/org.blueberry.ui.qt/src/model/berryViewTreeModel.cpp b/Plugins/org.blueberry.ui.qt/src/model/berryViewTreeModel.cpp
index 5911366970..790bb57380 100644
--- a/Plugins/org.blueberry.ui.qt/src/model/berryViewTreeModel.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/model/berryViewTreeModel.cpp
@@ -1,460 +1,460 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "berryViewTreeModel.h"
#include "berryIViewRegistry.h"
#include "berryIViewCategory.h"
#include "berryIWorkbench.h"
#include "berryIWorkbenchWindow.h"
#include "berryIWorkbenchPage.h"
#include "internal/intro/berryIntroConstants.h"
#include "internal/berryKeywordRegistry.h"
#include <QIcon>
#include <QBrush>
namespace berry {
// --------------------------- Tree Item Classes ---------------------------
struct ViewTreeItem;
bool CompareViewTreeItem(ViewTreeItem* item1, ViewTreeItem* item2);
struct ViewTreeItem
{
ViewTreeItem(ViewTreeModel* model)
: m_parent(nullptr)
, m_model(model)
{}
virtual ~ViewTreeItem()
{
QList<ViewTreeItem*> children = m_children;
if (m_parent) m_parent->removeChild(this);
qDeleteAll(children);
}
virtual QVariant data(int role)
{
if (role == ViewTreeModel::Keywords)
{
if (m_keywordCache.isEmpty())
{
m_keywordCache = QStringList(keywordLabels().toList());
}
return m_keywordCache;
}
return QVariant();
}
virtual Qt::ItemFlags flags() const
{
return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
}
virtual QSet<QString> keywordLabels() const
{
return QSet<QString>();
}
void appendChild(ViewTreeItem* child)
{
m_children.push_back(child);
child->m_parent = this;
qSort(m_children.begin(), m_children.end(), CompareViewTreeItem);
}
void removeChild(ViewTreeItem* child)
{
m_children.removeAll(child);
}
QList<ViewTreeItem*> takeChildren()
{
QList<ViewTreeItem*> children = m_children;
m_children.clear();
return children;
}
ViewTreeItem* childItem(int row) const
{
if (row < 0 || row >= m_children.size()) return nullptr;
return m_children.at(row);
}
ViewTreeItem* parentItem() const
{
return m_parent;
}
int childCount() const
{
return m_children.size();
}
int row() const
{
if (m_parent) return m_parent->rowIndex(this);
return 0;
}
int rowIndex(const ViewTreeItem* child) const
{
return m_children.indexOf(const_cast<ViewTreeItem*>(child));
}
QList<ViewTreeItem*> m_children;
ViewTreeItem* m_parent;
ViewTreeModel* m_model;
private:
QStringList m_keywordCache;
};
bool CompareViewTreeItem(ViewTreeItem* item1, ViewTreeItem* item2)
{
return item1->data(Qt::DisplayRole).toString() < item2->data(Qt::DisplayRole).toString();
}
struct RootTreeItem : ViewTreeItem
{
RootTreeItem(ViewTreeModel* model) : ViewTreeItem(model) {}
QVariant data(int /*role*/) override { return QVariant(); }
};
struct DescriptorTreeItem : ViewTreeItem
{
DescriptorTreeItem(ViewTreeModel* model, IViewDescriptor::Pointer descriptor, ViewTreeItem* parent = nullptr);
QVariant data(int role) override;
protected:
QSet<QString> keywordLabels() const override;
IViewDescriptor::Pointer m_descriptor;
};
struct CategoryTreeItem : ViewTreeItem
{
CategoryTreeItem(ViewTreeModel* model, IViewCategory::Pointer category, ViewTreeItem* parent = nullptr);
QVariant data(int role) override;
Qt::ItemFlags flags() const override;
protected:
QSet<QString> keywordLabels() const override;
/**
* Removes the temporary intro view from the list so that it cannot be activated except through
* the introduction command.
*/
void RemoveIntroView(QList<IViewDescriptor::Pointer>& list);
private:
void CreateChildren();
IViewCategory::Pointer m_category;
};
// --------------------------- Tree Model Classes ---------------------------
struct ViewTreeModel::Impl
{
Impl(const IWorkbenchWindow* window)
: window(window)
, viewRegistry(*window->GetWorkbench()->GetViewRegistry())
{
}
const IWorkbenchWindow* window;
IViewRegistry& viewRegistry;
QScopedPointer<RootTreeItem> rootItem;
};
ViewTreeModel::ViewTreeModel(const IWorkbenchWindow* window, QObject* parent)
: QAbstractItemModel(parent)
, d(new Impl(window))
{
d->rootItem.reset(new RootTreeItem(this));
QList<CategoryTreeItem*> categoryItems;
QList<IViewCategory::Pointer> categories = d->viewRegistry.GetCategories();
- for (auto category : categories)
+ for (const auto &category : qAsConst(categories))
{
if (category->GetViews().isEmpty()) continue;
CategoryTreeItem* categoryItem = new CategoryTreeItem(this, category);
if (categoryItem->childCount() == 0)
{
delete categoryItem;
}
else
{
categoryItems.push_back(categoryItem);
}
}
// if there is only one category, return it's children directly
if (categoryItems.size() == 1)
{
QList<ViewTreeItem*> items = categoryItems.front()->takeChildren();
- for (auto item : items)
+ for (auto item : qAsConst(items))
{
d->rootItem->appendChild(item);
}
qDeleteAll(categoryItems);
}
else
{
- for (auto category : categoryItems)
+ for (auto category : qAsConst(categoryItems))
{
d->rootItem->appendChild(category);
}
}
}
ViewTreeModel::~ViewTreeModel()
{
}
QVariant ViewTreeModel::data(const QModelIndex& index, int role) const
{
if (!index.isValid()) return QVariant();
return static_cast<ViewTreeItem*>(index.internalPointer())->data(role);
}
Qt::ItemFlags ViewTreeModel::flags(const QModelIndex& index) const
{
if (!index.isValid()) return nullptr;
return static_cast<ViewTreeItem*>(index.internalPointer())->flags();
}
QVariant ViewTreeModel::headerData(int section, Qt::Orientation /*orientation*/, int role) const
{
if (role == Qt::DisplayRole && section == 0)
{
return "View";
}
return QVariant();
}
QModelIndex ViewTreeModel::index(int row, int column, const QModelIndex& parent) const
{
if (!hasIndex(row, column, parent))
{
return QModelIndex();
}
ViewTreeItem* parentItem = nullptr;
if (!parent.isValid())
{
parentItem = d->rootItem.data();
}
else
{
parentItem = static_cast<ViewTreeItem*>(parent.internalPointer());
}
ViewTreeItem* childItem = parentItem->childItem(row);
if (childItem)
{
return createIndex(row, column, childItem);
}
return QModelIndex();
}
QModelIndex ViewTreeModel::parent(const QModelIndex& child) const
{
if (!child.isValid())
{
return QModelIndex();
}
ViewTreeItem* childItem = static_cast<ViewTreeItem*>(child.internalPointer());
ViewTreeItem* parentItem = childItem->parentItem();
if (parentItem == d->rootItem.data())
{
return QModelIndex();
}
return createIndex(parentItem->row(), 0, parentItem);
}
int ViewTreeModel::rowCount(const QModelIndex& parent) const
{
ViewTreeItem* parentItem = nullptr;
if (parent.column() > 0) return 0;
if (!parent.isValid())
{
parentItem = d->rootItem.data();
}
else
{
parentItem = static_cast<ViewTreeItem*>(parent.internalPointer());
}
return parentItem->childCount();
}
int ViewTreeModel::columnCount(const QModelIndex& /*parent*/) const
{
return 1;
}
const IWorkbenchWindow*ViewTreeModel::GetWorkbenchWindow() const
{
return d->window;
}
// --------------------------- DescriptorTreeItem ---------------------------
DescriptorTreeItem::DescriptorTreeItem(ViewTreeModel* model, IViewDescriptor::Pointer descriptor, ViewTreeItem* parent)
: ViewTreeItem(model)
, m_descriptor(descriptor)
{
if (parent) parent->appendChild(this);
}
QVariant DescriptorTreeItem::data(int role)
{
if (role == Qt::DisplayRole)
{
return m_descriptor->GetLabel();
}
else if (role == Qt::DecorationRole)
{
return m_descriptor->GetImageDescriptor();
}
else if (role == Qt::ForegroundRole)
{
IWorkbenchPage::Pointer page = this->m_model->GetWorkbenchWindow()->GetActivePage();
if (page.IsNotNull())
{
if (page->FindViewReference(m_descriptor->GetId()).IsNotNull())
{
return QBrush(QColor(Qt::gray));
}
}
}
else if (role == ViewTreeModel::Description)
{
return m_descriptor->GetDescription();
}
else if (role == ViewTreeModel::Id)
{
return m_descriptor->GetId();
}
return ViewTreeItem::data(role);
}
QSet<QString> DescriptorTreeItem::keywordLabels() const
{
KeywordRegistry* registry = KeywordRegistry::GetInstance();
QStringList ids = m_descriptor->GetKeywordReferences();
QSet<QString> keywords;
keywords.insert(m_descriptor->GetLabel());
- for(auto id : ids)
+ for(const auto &id : qAsConst(ids))
{
QString label = registry->GetKeywordLabel(id);
- for (auto keyword : label.split(' ', QString::SkipEmptyParts))
+ for (const auto &keyword : label.split(' ', QString::SkipEmptyParts))
{
keywords.insert(keyword);
}
}
return keywords;
}
// --------------------------- CategoryTreeItem ---------------------------
CategoryTreeItem::CategoryTreeItem(ViewTreeModel* model, IViewCategory::Pointer category, ViewTreeItem* parent)
: ViewTreeItem(model)
, m_category(category)
{
if (parent) parent->appendChild(this);
this->CreateChildren();
}
QVariant CategoryTreeItem::data(int role)
{
if (role == Qt::DisplayRole)
{
return m_category->GetLabel();
}
else if (role == Qt::DecorationRole)
{
return QIcon::fromTheme("folder");
}
else if (role == ViewTreeModel::Id)
{
return m_category->GetId();
}
return ViewTreeItem::data(role);
}
Qt::ItemFlags CategoryTreeItem::flags() const
{
return Qt::ItemIsEnabled;
}
QSet<QString> CategoryTreeItem::keywordLabels() const
{
QSet<QString> keywords;
for(auto child : this->m_children)
{
- for (auto keyword : child->data(ViewTreeModel::Keywords).toStringList())
+ for (const auto &keyword : child->data(ViewTreeModel::Keywords).toStringList())
{
keywords.insert(keyword);
}
}
return keywords;
}
void CategoryTreeItem::CreateChildren()
{
auto viewDescriptors = m_category->GetViews();
RemoveIntroView(viewDescriptors);
- for(auto viewDescriptor : viewDescriptors)
+ for(const auto &viewDescriptor : qAsConst(viewDescriptors))
{
new DescriptorTreeItem(this->m_model, viewDescriptor, this);
}
}
void CategoryTreeItem::RemoveIntroView(QList<IViewDescriptor::Pointer>& list)
{
for (auto view = list.begin(); view != list.end();)
{
if ((*view)->GetId() == IntroConstants::INTRO_VIEW_ID)
{
view = list.erase(view);
}
else ++view;
}
}
}
diff --git a/Plugins/org.blueberry.ui.qt/src/presentations/berryIPresentationFactory.h b/Plugins/org.blueberry.ui.qt/src/presentations/berryIPresentationFactory.h
index 710933f8c7..d343d2f512 100755
--- a/Plugins/org.blueberry.ui.qt/src/presentations/berryIPresentationFactory.h
+++ b/Plugins/org.blueberry.ui.qt/src/presentations/berryIPresentationFactory.h
@@ -1,181 +1,158 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef BERRYIPRESENTATIONFACTORY_H_
#define BERRYIPRESENTATIONFACTORY_H_
#include <berryMacros.h>
#include "berryStackPresentation.h"
#include <QObject>
namespace berry
{
/**
* This is a factory for presentation objects that control the appearance of
* editors, views and other components in the workbench.
*
* @since 3.0
*/
class BERRY_UI_QT IPresentationFactory {
public:
virtual ~IPresentationFactory();
/**
* Bit value for the createSash method's 'style' parameter.
* @since 3.4
*/
static int SASHTYPE_NORMAL; // = 0;
/**
* Bit value for the createSash method's 'style' parameter.
* @since 3.4
*/
static int SASHTYPE_FLOATING; // = 1<<1;
/**
* Bit value for the createSash method's 'style' parameter.
* @since 3.4
*/
static int SASHORIENTATION_HORIZONTAL; // = SWT.HORIZONTAL; // 1<<8
/**
* Bit value for the createSash method's 'style' parameter.
* @since 3.4
*/
static int SASHORIENTATION_VERTICAL; // = SWT.VERTICAL; // 1<<9
/**
* Creates an editor presentation for presenting editors.
* <p>
* The presentation creates its controls under the given parent composite.
* </p>
*
* @param parent
* the parent composite to use for the presentation's controls
* @param site
* the site used for communication between the presentation and
* the workbench
* @return a newly created part presentation
*/
virtual StackPresentation::Pointer CreateEditorPresentation(
QWidget* parent, IStackPresentationSite::Pointer site) = 0;
/**
* Creates a stack presentation for presenting regular docked views.
* <p>
* The presentation creates its controls under the given parent composite.
* </p>
*
* @param parent
* the parent composite to use for the presentation's controls
* @param site
* the site used for communication between the presentation and
* the workbench
* @return a newly created part presentation
*/
virtual StackPresentation::Pointer CreateViewPresentation(QWidget* parent,
IStackPresentationSite::Pointer site) = 0;
/**
* Creates a standalone stack presentation for presenting a standalone view.
* A standalone view cannot be docked together with other views. The title
* of a standalone view may be hidden.
* <p>
* The presentation creates its controls under the given parent composite.
* </p>
*
* @param parent
* the parent composite to use for the presentation's controls
* @param site
* the site used for communication between the presentation and
* the workbench
* @param showTitle
* <code>true</code> to show the title for the view,
* <code>false</code> to hide it
* @return a newly created part presentation
*/
virtual StackPresentation::Pointer CreateStandaloneViewPresentation(
QWidget* parent, IStackPresentationSite::Pointer site, bool showTitle) = 0;
- /**
- * Creates the status line manager for the window.
- * Subclasses may override.
- *
- * @return the window's status line manager
- */
-// public IStatusLineManager createStatusLineManager() {
-// return new StatusLineManager();
-// }
-
- /**
- * Creates the control for the window's status line.
- * Subclasses may override.
- *
- * @param statusLine the window's status line manager
- * @param parent the parent composite
- * @return the window's status line control
- */
-// public Control createStatusLineControl(IStatusLineManager statusLine,
-// Composite parent) {
-// return ((StatusLineManager) statusLine).createControl(parent, SWT.NONE);
-// }
-
/**
* Returns a globally unique identifier for this type of presentation factory. This is used
* to ensure that one presentation is not restored from mementos saved by a different
* presentation.
*
* @return a globally unique identifier for this type of presentation factory.
*/
virtual QString GetId() = 0;
/**
* Creates the Sash control that is used to separate view and editor parts.
*
* @param parent the parent composite
* @param style A bit set giving both the 'type' of the desired sash and
* its orientation (i.e. one 'SASHTYPE' value and one "SASHORIENTATION" value).
* @return the sash control
* @since 3.4
*/
virtual QWidget* CreateSash(QWidget* parent, int style) = 0;
// {
// int orientation = style & (SASHORIENTATION_HORIZONTAL
// | SASHORIENTATION_VERTICAL);
// Sash sash = new Sash(parent, orientation | SWT.SMOOTH);
// return sash;
// }
/**
* Returns the size of the Sash control that is used to separate view and editor parts.
*
* @param style A bit set giving both the 'type' of the desired sash and
* its orientation.
* @return the sash size
* @since 3.4
*/
virtual int GetSashSize(int style) = 0;
/**
* Applies changes of the current theme to the user interface.
*/
virtual void UpdateTheme() = 0;
};
}
Q_DECLARE_INTERFACE(berry::IPresentationFactory, "org.blueberry.ui.IPresentationFactory")
#endif /* BERRYABSTRACTPRESENTATIONFACTORY_H_ */
diff --git a/Plugins/org.blueberry.ui.qt/src/presentations/berryIStackPresentationSite.h b/Plugins/org.blueberry.ui.qt/src/presentations/berryIStackPresentationSite.h
index 089152e7c4..c32e544487 100755
--- a/Plugins/org.blueberry.ui.qt/src/presentations/berryIStackPresentationSite.h
+++ b/Plugins/org.blueberry.ui.qt/src/presentations/berryIStackPresentationSite.h
@@ -1,187 +1,172 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef BERRYISTACKPRESENTATIONSITE_H_
#define BERRYISTACKPRESENTATIONSITE_H_
#include <berryMacros.h>
#include <list>
#include "berryIPresentablePart.h"
#include <org_blueberry_ui_qt_Export.h>
namespace berry
{
/**
* Represents the main interface between a StackPresentation and the workbench.
*
* Not intended to be implemented by clients.
*
* @since 3.0
*/
struct BERRY_UI_QT IStackPresentationSite : public Object
{
berryObjectMacro(berry::IStackPresentationSite);
static int STATE_MINIMIZED; // = 0;
static int STATE_MAXIMIZED; // = 1;
static int STATE_RESTORED; // = 2;
~IStackPresentationSite() override;
/**
* Sets the state of the container. Called by the presentation when the
* user causes the the container to be minimized, maximized, etc.
*
* @param newState one of the STATE_* constants
*/
virtual void SetState(int newState) = 0;
/**
* Returns the current state of the site (one of the STATE_* constants)
*
* @return the current state of the site (one of the STATE_* constants)
*/
virtual int GetState() = 0;
/**
* Returns true iff the site supports the given state
*
* @param state one of the STATE_* constants, above
* @return true iff the site supports the given state
*/
virtual bool SupportsState(int state) = 0;
/**
* Begins dragging the given part
*
* @param beingDragged the part to drag (not null)
* @param initialPosition the mouse position at the time of the initial mousedown
* (display coordinates, not null)
* @param keyboard true iff the drag was initiated via mouse dragging,
* and false if the drag may be using the keyboard
*/
virtual void DragStart(IPresentablePart::Pointer beingDragged,
QPoint& initialPosition, bool keyboard) = 0;
/**
* Closes the given set of parts.
*
* @param toClose the set of parts to close (Not null. All of the entries must be non-null)
*/
virtual void Close(const QList<IPresentablePart::Pointer>& toClose) = 0;
/**
* Begins dragging the entire stack of parts
*
* @param initialPosition the mouse position at the time of the initial mousedown (display coordinates,
* not null)
* @param keyboard true iff the drag was initiated via mouse dragging,
* and false if the drag may be using the keyboard
*/
virtual void DragStart(QPoint& initialPosition, bool keyboard) = 0;
/**
* Returns true iff this site will allow the given part to be closed
*
* @param toClose part to test (not null)
* @return true iff the part may be closed
*/
virtual bool IsCloseable(IPresentablePart::Pointer toClose) = 0;
/**
* Returns true iff the given part can be dragged. If this
* returns false, the given part should not trigger a drag.
*
* @param toMove part to test (not null)
* @return true iff this part is a valid drag source
*/
virtual bool IsPartMoveable(IPresentablePart::Pointer toMove) = 0;
/**
* Returns true iff this entire stack can be dragged
*
* @return true iff the stack can be dragged
*/
virtual bool IsStackMoveable() = 0;
/**
* Makes the given part active
*
* @param toSelect
*/
virtual void SelectPart(IPresentablePart::Pointer toSelect) = 0;
/**
* Returns the currently selected part or null if the stack is empty
*
* @return the currently selected part or null if the stack is empty
*/
virtual IPresentablePart::Pointer GetSelectedPart() = 0;
- /**
- * Adds system actions to the given menu manager. The site may
- * make use of the following group ids:
- * <ul>
- * <li><code>close</code>, for close actions</li>
- * <li><code>size</code>, for resize actions</li>
- * <li><code>misc</code>, for miscellaneous actions</li>
- * </ul>
- * The presentation can control the insertion position by creating
- * these group IDs where appropriate.
- *
- * @param menuManager the menu manager to populate
- */
- //virtual void AddSystemActions(IMenuManager menuManager);
-
/**
* Notifies the workbench that the preferred size of the presentation has
* changed. Hints to the workbench that it should trigger a layout at the
* next opportunity.
*
* @since 3.1
*/
virtual void FlushLayout() = 0;
/**
* Returns the list of presentable parts currently in this site
*
* @return the list of presentable parts currently in this site
* @since 3.1
*/
virtual QList<IPresentablePart::Pointer> GetPartList() = 0;
/**
* Returns the property with the given id or <code>null</code>. Folder
* properties are an extensible mechanism for perspective authors to
* customize the appearance of view stacks. The list of customizable
* properties is determined by the presentation factory, and set in the
* perspective factory.
*
* @param id
* Must not be <code>null</code>.
* @return property value, or <code>null</code> if the property is not
* set.
* @since 3.3
*/
virtual QString GetProperty(const QString& id) = 0;
};
}
#endif /* BERRYISTACKPRESENTATIONSITE_H_ */
diff --git a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeContextMenu.cpp b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeContextMenu.cpp
index de2ccb87e7..a8a7e00ce6 100644
--- a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeContextMenu.cpp
+++ b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeContextMenu.cpp
@@ -1,480 +1,480 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <QmitkDataNodeContextMenu.h>
#include <QmitkCustomVariants.h>
#include <QmitkFileSaveAction.h>
#include <QmitkNodeDescriptorManager.h>
#include <mitkDataNodeSelection.h>
#include <mitkIContextMenuAction.h>
#include <berryAbstractUICTKPlugin.h>
#include <berryIContributor.h>
#include <berryIExtensionRegistry.h>
#include <berryISelectionService.h>
#include <berryPlatform.h>
QmitkDataNodeContextMenu::QmitkDataNodeContextMenu(berry::IWorkbenchPartSite::Pointer workbenchPartSite, QWidget* parent)
: QMenu(parent),
m_Parent(parent),
m_WorkbenchPartSite(workbenchPartSite)
{
this->InitNodeDescriptors();
this->InitDefaultActions();
this->InitExtensionPointActions();
}
QmitkDataNodeContextMenu::~QmitkDataNodeContextMenu()
{
for (auto& descriptorActionPair : m_DescriptorActionList)
descriptorActionPair.first->RemoveAction(descriptorActionPair.second);
}
void QmitkDataNodeContextMenu::SetDataStorage(mitk::DataStorage* dataStorage)
{
m_DataStorage = dataStorage;
for (auto& descriptorActionPair : m_DescriptorActionList)
{
auto dataNodeAction = dynamic_cast<QmitkAbstractDataNodeAction*>(descriptorActionPair.second);
if (nullptr != dataNodeAction)
dataNodeAction->SetDataStorage(dataStorage);
}
}
void QmitkDataNodeContextMenu::SetBaseRenderer(mitk::BaseRenderer* baseRenderer)
{
m_BaseRenderer = baseRenderer;
for (auto& descriptorActionPair : m_DescriptorActionList)
{
auto dataNodeAction = dynamic_cast<QmitkAbstractDataNodeAction*>(descriptorActionPair.second);
if (nullptr != dataNodeAction)
dataNodeAction->SetBaseRenderer(baseRenderer);
}
}
void QmitkDataNodeContextMenu::SetSurfaceDecimation(bool surfaceDecimation)
{
m_SurfaceDecimation = surfaceDecimation;
}
void QmitkDataNodeContextMenu::SetSelectedNodes(const QList<mitk::DataNode::Pointer>& selectedNodes)
{
m_SelectedNodes = selectedNodes;
}
void QmitkDataNodeContextMenu::InitNodeDescriptors()
{
auto nodeDescriptorManager = QmitkNodeDescriptorManager::GetInstance();
m_UnknownDataNodeDescriptor = nodeDescriptorManager->GetUnknownDataNodeDescriptor();
m_ImageDataNodeDescriptor = nodeDescriptorManager->GetDescriptor("Image");
m_MultiComponentImageDataNodeDescriptor = nodeDescriptorManager->GetDescriptor("MultiComponentImage");
m_DiffusionImageDataNodeDescriptor = nodeDescriptorManager->GetDescriptor("DiffusionImage");
m_FiberBundleDataNodeDescriptor = nodeDescriptorManager->GetDescriptor("FiberBundle");
m_PeakImageDataNodeDescriptor = nodeDescriptorManager->GetDescriptor("PeakImage");
m_SegmentDataNodeDescriptor = nodeDescriptorManager->GetDescriptor("Segment");
m_SurfaceDataNodeDescriptor = nodeDescriptorManager->GetDescriptor("Surface");
m_PointSetNodeDescriptor = nodeDescriptorManager->GetDescriptor("PointSet");
m_PlanarLineNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarLine");
m_PlanarCircleNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarCircle");
m_PlanarEllipseNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarEllipse");
m_PlanarAngleNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarAngle");
m_PlanarFourPointAngleNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarFourPointAngle");
m_PlanarRectangleNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarRectangle");
m_PlanarPolygonNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarPolygon");
m_PlanarPathNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarPath");
m_PlanarDoubleEllipseNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarDoubleEllipse");
m_PlanarBezierCurveNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarBezierCurve");
m_PlanarSubdivisionPolygonNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarSubdivisionPolygon");
}
void QmitkDataNodeContextMenu::InitDefaultActions()
{
auto workbenchPartSite = m_WorkbenchPartSite.Lock();
m_GlobalReinitAction = new QmitkDataNodeGlobalReinitAction(m_Parent, workbenchPartSite);
m_GlobalReinitAction->setIcon(QIcon(":/org.mitk.gui.qt.datamanager/Refresh_48.png"));
m_UnknownDataNodeDescriptor->AddAction(m_GlobalReinitAction, true);
m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, m_GlobalReinitAction));
m_ReinitAction = new QmitkDataNodeReinitAction(m_Parent, workbenchPartSite);
m_ReinitAction->setIcon(QIcon(":/org.mitk.gui.qt.datamanager/Refresh_48.png"));
m_UnknownDataNodeDescriptor->AddAction(m_ReinitAction, true);
m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, m_ReinitAction));
QAction* saveAction = new QmitkFileSaveAction(QIcon(":/org.mitk.gui.qt.datamanager/Save_48.png"), workbenchPartSite->GetWorkbenchWindow());
m_UnknownDataNodeDescriptor->AddAction(saveAction, true);
m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, saveAction));
m_RemoveAction = new QmitkDataNodeRemoveAction(m_Parent, workbenchPartSite);
m_RemoveAction->setIcon(QIcon(":/org.mitk.gui.qt.datamanager/Remove_48.png"));
m_UnknownDataNodeDescriptor->AddAction(m_RemoveAction, true);
m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, m_RemoveAction));
m_ShowSelectedNodesAction = new QmitkDataNodeShowSelectedNodesAction(m_Parent, workbenchPartSite);
m_RemoveAction->setIcon(QIcon(":/org.mitk.gui.qt.datamanager/ShowSelectedNode_48.png"));
m_UnknownDataNodeDescriptor->AddAction(m_ShowSelectedNodesAction, true);
m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, m_ShowSelectedNodesAction));
m_ToggleVisibilityAction = new QmitkDataNodeToggleVisibilityAction(m_Parent, workbenchPartSite);
m_ToggleVisibilityAction->setIcon(QIcon(":/org.mitk.gui.qt.datamanager/InvertShowSelectedNode_48.png"));
m_UnknownDataNodeDescriptor->AddAction(m_ToggleVisibilityAction, true);
m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, m_ToggleVisibilityAction));
m_ShowDetailsAction = new QmitkDataNodeShowDetailsAction(m_Parent, workbenchPartSite);
m_ShowDetailsAction->setIcon(QIcon(":/org.mitk.gui.qt.datamanager/ShowDataInfo_48.png"));
m_UnknownDataNodeDescriptor->AddAction(m_ShowDetailsAction, true);
m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, m_ShowDetailsAction));
m_OpacityAction = new QmitkDataNodeOpacityAction(m_Parent, workbenchPartSite);
m_UnknownDataNodeDescriptor->AddAction(m_OpacityAction, false);
m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, m_OpacityAction));
m_ColorAction = new QmitkDataNodeColorAction(m_Parent, workbenchPartSite);
this->AddColorAction(m_ColorAction);
m_ColormapAction = new QmitkDataNodeColorMapAction(m_Parent, workbenchPartSite);
m_ImageDataNodeDescriptor->AddAction(m_ColormapAction);
m_DescriptorActionList.push_back(std::make_pair(m_ImageDataNodeDescriptor, m_ColormapAction));
if (nullptr != m_DiffusionImageDataNodeDescriptor)
{
m_DiffusionImageDataNodeDescriptor->AddAction(m_ColormapAction, false);
m_DescriptorActionList.push_back(std::make_pair(m_DiffusionImageDataNodeDescriptor, m_ColormapAction));
}
m_ComponentAction = new QmitkDataNodeComponentAction(m_Parent, workbenchPartSite);
m_MultiComponentImageDataNodeDescriptor->AddAction(m_ComponentAction, false);
m_DescriptorActionList.push_back(std::make_pair(m_MultiComponentImageDataNodeDescriptor, m_ComponentAction));
if (nullptr != m_DiffusionImageDataNodeDescriptor)
{
m_DiffusionImageDataNodeDescriptor->AddAction(m_ComponentAction, false);
m_DescriptorActionList.push_back(std::make_pair(m_DiffusionImageDataNodeDescriptor, m_ComponentAction));
}
m_TextureInterpolationAction = new QmitkDataNodeTextureInterpolationAction(m_Parent, workbenchPartSite);
m_ImageDataNodeDescriptor->AddAction(m_TextureInterpolationAction, false);
m_DescriptorActionList.push_back(std::make_pair(m_ImageDataNodeDescriptor, m_TextureInterpolationAction));
if (nullptr != m_DiffusionImageDataNodeDescriptor)
{
m_DiffusionImageDataNodeDescriptor->AddAction(m_TextureInterpolationAction, false);
m_DescriptorActionList.push_back(std::make_pair(m_DiffusionImageDataNodeDescriptor, m_TextureInterpolationAction));
}
if (nullptr != m_SegmentDataNodeDescriptor)
{
m_SegmentDataNodeDescriptor->AddAction(m_TextureInterpolationAction, false);
m_DescriptorActionList.push_back(std::make_pair(m_SegmentDataNodeDescriptor, m_TextureInterpolationAction));
}
m_SurfaceRepresentationAction = new QmitkDataNodeSurfaceRepresentationAction(m_Parent, workbenchPartSite);
m_SurfaceDataNodeDescriptor->AddAction(m_SurfaceRepresentationAction, false);
m_DescriptorActionList.push_back(std::make_pair(m_SurfaceDataNodeDescriptor, m_SurfaceRepresentationAction));
}
void QmitkDataNodeContextMenu::InitExtensionPointActions()
{
auto extensionPointService = berry::Platform::GetExtensionRegistry();
auto customMenuConfigs = extensionPointService->GetConfigurationElementsFor("org.mitk.gui.qt.datamanager.contextMenuActions");
DescriptorActionListType descriptorActionList;
m_ConfigElements.clear();
- for (const auto& customMenuConfig : customMenuConfigs)
+ for (const auto& customMenuConfig : qAsConst(customMenuConfigs))
{
auto descriptorName = customMenuConfig->GetAttribute("nodeDescriptorName");
auto actionLabel = customMenuConfig->GetAttribute("label");
auto actionClass = customMenuConfig->GetAttribute("class");
if (descriptorName.isEmpty() || actionLabel.isEmpty() || actionClass.isEmpty())
continue;
auto descriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor(descriptorName);
if (nullptr == descriptor)
{
MITK_WARN << "Cannot add action \"" << actionLabel << "\" to non-existent descriptor \"" << descriptorName << "\".";
continue;
}
QAction* action = nullptr;
auto actionIcon = customMenuConfig->GetAttribute("icon");
if (!actionIcon.isEmpty())
{
QIcon icon = !QFile::exists(actionIcon)
? berry::AbstractUICTKPlugin::ImageDescriptorFromPlugin(customMenuConfig->GetContributor()->GetName(), actionIcon)
: QIcon(actionIcon);
action = new QAction(icon, actionLabel, m_Parent);
}
else
{
action = new QAction(actionLabel, m_Parent);
}
if (nullptr != action)
{
// See T26938. We do not know why but without the lambda function indirection, the
// connection is lost after the content menu was shown for the first time.
connect(action, &QAction::triggered, [action, this]()
{
this->OnExtensionPointActionTriggered(action);
});
m_ConfigElements[action] = customMenuConfig;
descriptorActionList.push_back(std::make_pair(descriptor, action));
}
}
this->AddDescriptorActionList(descriptorActionList);
}
void QmitkDataNodeContextMenu::InitServiceActions()
{
}
void QmitkDataNodeContextMenu::OnContextMenuRequested(const QPoint& /*pos*/)
{
if (m_WorkbenchPartSite.Expired())
return;
auto selection = m_WorkbenchPartSite.Lock()->GetWorkbenchWindow()->GetSelectionService()->GetSelection()
.Cast<const mitk::DataNodeSelection>();
if (selection.IsNull() || selection->IsEmpty())
return;
m_SelectedNodes = QList<mitk::DataNode::Pointer>::fromStdList(selection->GetSelectedDataNodes());
if (!m_SelectedNodes.isEmpty())
{
this->clear();
auto actions = m_SelectedNodes.size() == 1
? this->GetActions(m_SelectedNodes.front())
: this->GetActions(m_SelectedNodes);
for (auto& action : actions)
{
auto dataNodeAction = dynamic_cast<QmitkAbstractDataNodeAction*>(action);
if (nullptr != dataNodeAction)
dataNodeAction->SetSelectedNodes(m_SelectedNodes);
}
this->addActions(actions);
this->popup(QCursor::pos());
}
}
void QmitkDataNodeContextMenu::OnExtensionPointActionTriggered(QAction* action)
{
auto configElementIter = m_ConfigElements.find(action);
if (m_ConfigElements.end() == configElementIter)
{
MITK_WARN << "Associated configuration element for action \"" << action->text() << "\" not found.";
return;
}
auto configElement = configElementIter->second;
auto contextMenuAction = configElement->CreateExecutableExtension<mitk::IContextMenuAction>("class");
if (!m_DataStorage.IsExpired())
contextMenuAction->SetDataStorage(m_DataStorage.Lock());
if ("QmitkCreatePolygonModelAction" == configElement->GetAttribute("class"))
{
contextMenuAction->SetSmoothed("true" == configElement->GetAttribute("smoothed"));
contextMenuAction->SetDecimated(m_SurfaceDecimation);
}
contextMenuAction->Run(m_SelectedNodes);
}
void QmitkDataNodeContextMenu::AddColorAction(QWidgetAction* colorAction)
{
if (nullptr != m_ImageDataNodeDescriptor)
{
m_ImageDataNodeDescriptor->AddAction(colorAction, true);
m_DescriptorActionList.push_back(std::make_pair(m_ImageDataNodeDescriptor, colorAction));
}
if (nullptr != m_MultiComponentImageDataNodeDescriptor)
{
m_MultiComponentImageDataNodeDescriptor->AddAction(colorAction, true);
m_DescriptorActionList.push_back(std::make_pair(m_MultiComponentImageDataNodeDescriptor, colorAction));
}
if (nullptr != m_DiffusionImageDataNodeDescriptor)
{
m_DiffusionImageDataNodeDescriptor->AddAction(colorAction, true);
m_DescriptorActionList.push_back(std::make_pair(m_DiffusionImageDataNodeDescriptor, colorAction));
}
if (nullptr != m_FiberBundleDataNodeDescriptor)
{
m_FiberBundleDataNodeDescriptor->AddAction(colorAction, false);
m_DescriptorActionList.push_back(std::make_pair(m_FiberBundleDataNodeDescriptor, colorAction));
}
if (nullptr != m_PeakImageDataNodeDescriptor)
{
m_PeakImageDataNodeDescriptor->AddAction(colorAction, false);
m_DescriptorActionList.push_back(std::make_pair(m_PeakImageDataNodeDescriptor, colorAction));
}
if (nullptr != m_SegmentDataNodeDescriptor)
{
m_SegmentDataNodeDescriptor->AddAction(colorAction, false);
m_DescriptorActionList.push_back(std::make_pair(m_SegmentDataNodeDescriptor, colorAction));
}
if (nullptr != m_SurfaceDataNodeDescriptor)
{
m_SurfaceDataNodeDescriptor->AddAction(colorAction, true);
m_DescriptorActionList.push_back(std::make_pair(m_SurfaceDataNodeDescriptor, colorAction));
}
if (nullptr != m_PointSetNodeDescriptor)
{
m_PointSetNodeDescriptor->AddAction(colorAction, true);
m_DescriptorActionList.push_back(std::make_pair(m_PointSetNodeDescriptor, colorAction));
}
if (nullptr != m_PlanarLineNodeDescriptor)
{
m_PlanarLineNodeDescriptor->AddAction(colorAction, true);
m_DescriptorActionList.push_back(std::make_pair(m_PlanarLineNodeDescriptor, colorAction));
}
if (nullptr != m_PlanarCircleNodeDescriptor)
{
m_PlanarCircleNodeDescriptor->AddAction(colorAction, true);
m_DescriptorActionList.push_back(std::make_pair(m_PlanarCircleNodeDescriptor, colorAction));
}
if (nullptr != m_PlanarEllipseNodeDescriptor)
{
m_PlanarEllipseNodeDescriptor->AddAction(colorAction, true);
m_DescriptorActionList.push_back(std::make_pair(m_PlanarEllipseNodeDescriptor, colorAction));
}
if (nullptr != m_PlanarAngleNodeDescriptor)
{
m_PlanarAngleNodeDescriptor->AddAction(colorAction, true);
m_DescriptorActionList.push_back(std::make_pair(m_PlanarAngleNodeDescriptor, colorAction));
}
if (nullptr != m_PlanarFourPointAngleNodeDescriptor)
{
m_PlanarFourPointAngleNodeDescriptor->AddAction(colorAction, true);
m_DescriptorActionList.push_back(std::make_pair(m_PlanarFourPointAngleNodeDescriptor, colorAction));
}
if (nullptr != m_PlanarRectangleNodeDescriptor)
{
m_PlanarRectangleNodeDescriptor->AddAction(colorAction, true);
m_DescriptorActionList.push_back(std::make_pair(m_PlanarRectangleNodeDescriptor, colorAction));
}
if (nullptr != m_PlanarPolygonNodeDescriptor)
{
m_PlanarPolygonNodeDescriptor->AddAction(colorAction, true);
m_DescriptorActionList.push_back(std::make_pair(m_PlanarPolygonNodeDescriptor, colorAction));
}
if (nullptr != m_PlanarPathNodeDescriptor)
{
m_PlanarPathNodeDescriptor->AddAction(colorAction, true);
m_DescriptorActionList.push_back(std::make_pair(m_PlanarPathNodeDescriptor, colorAction));
}
if (nullptr != m_PlanarDoubleEllipseNodeDescriptor)
{
m_PlanarDoubleEllipseNodeDescriptor->AddAction(colorAction, true);
m_DescriptorActionList.push_back(std::make_pair(m_PlanarDoubleEllipseNodeDescriptor, colorAction));
}
if (nullptr != m_PlanarBezierCurveNodeDescriptor)
{
m_PlanarBezierCurveNodeDescriptor->AddAction(colorAction, true);
m_DescriptorActionList.push_back(std::make_pair(m_PlanarBezierCurveNodeDescriptor, colorAction));
}
if (nullptr != m_PlanarSubdivisionPolygonNodeDescriptor)
{
m_PlanarSubdivisionPolygonNodeDescriptor->AddAction(colorAction, true);
m_DescriptorActionList.push_back(std::make_pair(m_PlanarSubdivisionPolygonNodeDescriptor, colorAction));
}
}
void QmitkDataNodeContextMenu::AddDescriptorActionList(DescriptorActionListType& descriptorActionList)
{
using ListItem = std::pair<QmitkNodeDescriptor*, QAction*>;
std::sort(descriptorActionList.begin(), descriptorActionList.end(), [](const ListItem& left, const ListItem& right) -> bool
{
return left.second->text() < right.second->text();
});
for (auto& descriptorActionPair : descriptorActionList)
{
descriptorActionPair.first->AddAction(descriptorActionPair.second);
m_DescriptorActionList.push_back(descriptorActionPair);
}
}
QList<QAction*> QmitkDataNodeContextMenu::GetActions(const mitk::DataNode* node)
{
QList<QAction*> actions;
for(const auto& descriptorActionPair : m_DescriptorActionList)
{
if (descriptorActionPair.first->CheckNode(node) || "Unknown" == descriptorActionPair.first->GetNameOfClass())
actions.append(descriptorActionPair.second);
}
return actions;
}
QList<QAction*> QmitkDataNodeContextMenu::GetActions(const QList<mitk::DataNode::Pointer>& nodes)
{
QList<QAction*> actions;
for (const auto& descriptorActionPair : m_DescriptorActionList)
{
for (const auto& node : nodes)
{
if (descriptorActionPair.first->CheckNode(node) || "Unknown" == descriptorActionPair.first->GetNameOfClass())
{
auto batchActions = descriptorActionPair.first->GetBatchActions();
if (std::find(batchActions.begin(), batchActions.end(), descriptorActionPair.second) != batchActions.end())
actions.append(descriptorActionPair.second);
break;
}
}
}
return actions;
}
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionDialog.cpp b/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionDialog.cpp
index 979715cd2d..7d0b21faf0 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionDialog.cpp
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionDialog.cpp
@@ -1,291 +1,291 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkNodeSelectionDialog.h"
#include <berryQtStyleManager.h>
#include <mitkDataStorageInspectorGenerator.h>
#include <QmitkNodeSelectionPreferenceHelper.h>
#include <QmitkDataStorageSelectionHistoryInspector.h>
#include <QmitkDataStorageFavoriteNodesInspector.h>
QmitkNodeSelectionDialog::QmitkNodeSelectionDialog(QWidget* parent, QString title, QString hint)
: QDialog(parent)
, m_NodePredicate(nullptr)
, m_SelectOnlyVisibleNodes(false)
, m_SelectedNodes(NodeList())
, m_SelectionMode(QAbstractItemView::SingleSelection)
{
m_Controls.setupUi(this);
m_CheckFunction = [](const NodeList &) { return ""; };
auto providers = mitk::DataStorageInspectorGenerator::GetProviders();
auto visibleProviders = mitk::GetVisibleDataStorageInspectors();
auto preferredID = mitk::GetPreferredDataStorageInspector();
if (visibleProviders.empty())
{
MITK_DEBUG << "No presets for visible node selection inspectors available. Use fallback (show all available inspectors)";
unsigned int order = 0;
- for (auto proIter : providers)
+ for (const auto &proIter : providers)
{
visibleProviders.insert(std::make_pair(order, proIter.first));
++order;
}
}
int preferredIndex = 0;
bool preferredFound = false;
- for (auto proIter : visibleProviders)
+ for (const auto &proIter : visibleProviders)
{
auto finding = providers.find(proIter.second);
if (finding != providers.end())
{
if (finding->second->GetInspectorID() != QmitkDataStorageFavoriteNodesInspector::INSPECTOR_ID() && finding->second->GetInspectorID() != QmitkDataStorageSelectionHistoryInspector::INSPECTOR_ID())
{
auto provider = finding->second;
this->AddPanel(provider, preferredID, preferredFound, preferredIndex);
}
}
else
{
MITK_DEBUG << "No provider registered for inspector that is defined as visible in the preferences. Illegal inspector ID: " << proIter.second;
}
}
if (mitk::GetShowFavoritesInspector())
{
auto favoritesPorvider = mitk::DataStorageInspectorGenerator::GetProvider(QmitkDataStorageFavoriteNodesInspector::INSPECTOR_ID());
if (favoritesPorvider != nullptr)
{
this->AddPanel(favoritesPorvider, preferredID, preferredFound, preferredIndex);
}
}
if (mitk::GetShowHistoryInspector())
{
auto historyPorvider = mitk::DataStorageInspectorGenerator::GetProvider(QmitkDataStorageSelectionHistoryInspector::INSPECTOR_ID());
if (historyPorvider != nullptr)
{
this->AddPanel(historyPorvider, preferredID, preferredFound, preferredIndex);
}
}
m_Controls.tabWidget->setCurrentIndex(preferredIndex);
this->setWindowTitle(title);
this->setToolTip(hint);
m_Controls.hint->setText(hint);
m_Controls.hint->setVisible(!hint.isEmpty());
if(hint.isEmpty())
{
m_Controls.layoutHint->setContentsMargins(0, 0, 0, 0);
}
else
{
m_Controls.layoutHint->setContentsMargins(6, 6, 6, 6);
}
this->SetErrorText("");
m_Controls.btnAddToFav->setIcon(berry::QtStyleManager::ThemeIcon(QStringLiteral(":/Qmitk/favorite_add.svg")));
connect(m_Controls.btnAddToFav, &QPushButton::clicked, this, &QmitkNodeSelectionDialog::OnFavoriteNodesButtonClicked);
connect(m_Controls.buttonBox, &QDialogButtonBox::accepted, this, &QmitkNodeSelectionDialog::OnOK);
connect(m_Controls.buttonBox, &QDialogButtonBox::rejected, this, &QmitkNodeSelectionDialog::OnCancel);
}
void QmitkNodeSelectionDialog::SetDataStorage(mitk::DataStorage* dataStorage)
{
if (m_DataStorage != dataStorage)
{
m_DataStorage = dataStorage;
if (!m_DataStorage.IsExpired())
{
for (auto panel : m_Panels)
{
panel->SetDataStorage(dataStorage);
}
}
}
}
void QmitkNodeSelectionDialog::SetNodePredicate(const mitk::NodePredicateBase* nodePredicate)
{
if (m_NodePredicate != nodePredicate)
{
m_NodePredicate = nodePredicate;
for (auto panel : m_Panels)
{
panel->SetNodePredicate(m_NodePredicate);
}
}
}
const mitk::NodePredicateBase* QmitkNodeSelectionDialog::GetNodePredicate() const
{
return m_NodePredicate;
}
QmitkNodeSelectionDialog::NodeList QmitkNodeSelectionDialog::GetSelectedNodes() const
{
return m_SelectedNodes;
}
void QmitkNodeSelectionDialog::SetSelectionCheckFunction(const SelectionCheckFunctionType &checkFunction)
{
m_CheckFunction = checkFunction;
auto checkResponse = m_CheckFunction(m_SelectedNodes);
SetErrorText(checkResponse);
m_Controls.buttonBox->button(QDialogButtonBox::Ok)->setEnabled(checkResponse.empty());
}
void QmitkNodeSelectionDialog::SetErrorText(const std::string& checkResponse)
{
m_Controls.error->setText(QString::fromStdString(checkResponse));
m_Controls.error->setVisible(!checkResponse.empty());
if (checkResponse.empty())
{
m_Controls.layoutError->setContentsMargins(0, 0, 0, 0);
}
else
{
m_Controls.layoutError->setContentsMargins(6, 6, 6, 6);
}
}
bool QmitkNodeSelectionDialog::GetSelectOnlyVisibleNodes() const
{
return m_SelectOnlyVisibleNodes;
}
void QmitkNodeSelectionDialog::SetSelectionMode(SelectionMode mode)
{
m_SelectionMode = mode;
for (auto panel : m_Panels)
{
panel->SetSelectionMode(mode);
}
}
QmitkNodeSelectionDialog::SelectionMode QmitkNodeSelectionDialog::GetSelectionMode() const
{
return m_SelectionMode;
}
void QmitkNodeSelectionDialog::SetSelectOnlyVisibleNodes(bool selectOnlyVisibleNodes)
{
if (m_SelectOnlyVisibleNodes != selectOnlyVisibleNodes)
{
m_SelectOnlyVisibleNodes = selectOnlyVisibleNodes;
for (auto panel : m_Panels)
{
panel->SetSelectOnlyVisibleNodes(m_SelectOnlyVisibleNodes);
}
}
}
void QmitkNodeSelectionDialog::SetCurrentSelection(NodeList selectedNodes)
{
m_SelectedNodes = selectedNodes;
auto checkResponse = m_CheckFunction(m_SelectedNodes);
SetErrorText(checkResponse);
m_Controls.buttonBox->button(QDialogButtonBox::Ok)->setEnabled(checkResponse.empty());
for (auto panel : m_Panels)
{
panel->SetCurrentSelection(selectedNodes);
}
}
void QmitkNodeSelectionDialog::OnSelectionChanged(NodeList selectedNodes)
{
SetCurrentSelection(selectedNodes);
emit CurrentSelectionChanged(selectedNodes);
}
void QmitkNodeSelectionDialog::OnFavoriteNodesButtonClicked()
{
- for (auto node : m_SelectedNodes)
+ for (auto node : qAsConst(m_SelectedNodes))
{
node->SetBoolProperty("org.mitk.selection.favorite", true);
}
}
void QmitkNodeSelectionDialog::OnOK()
{
- for (auto node : m_SelectedNodes)
+ for (const auto &node : qAsConst(m_SelectedNodes))
{
QmitkDataStorageSelectionHistoryInspector::AddNodeToHistory(node);
}
this->accept();
}
void QmitkNodeSelectionDialog::OnCancel()
{
this->reject();
}
void QmitkNodeSelectionDialog::AddPanel(const mitk::IDataStorageInspectorProvider * provider, const mitk::IDataStorageInspectorProvider::InspectorIDType& preferredID, bool &preferredFound, int &preferredIndex)
{
auto inspector = provider->CreateInspector();
QString name = QString::fromStdString(provider->GetInspectorDisplayName());
QString desc = QString::fromStdString(provider->GetInspectorDescription());
inspector->setParent(this);
inspector->SetSelectionMode(m_SelectionMode);
auto tabPanel = new QWidget();
tabPanel->setObjectName(QString("tab_") + name);
tabPanel->setToolTip(desc);
auto verticalLayout = new QVBoxLayout(tabPanel);
verticalLayout->setSpacing(0);
verticalLayout->setContentsMargins(0, 0, 0, 0);
verticalLayout->addWidget(inspector);
auto panelPos = m_Controls.tabWidget->insertTab(m_Controls.tabWidget->count(), tabPanel, name);
auto icon = provider->GetInspectorIcon();
if (!icon.isNull())
{
m_Controls.tabWidget->setTabIcon(panelPos, icon);
}
m_Panels.push_back(inspector);
connect(inspector, &QmitkAbstractDataStorageInspector::CurrentSelectionChanged, this, &QmitkNodeSelectionDialog::OnSelectionChanged);
connect(inspector->GetView(), &QAbstractItemView::doubleClicked, this, &QmitkNodeSelectionDialog::OnDoubleClicked);
preferredFound = preferredFound || provider->GetInspectorID() == preferredID;
if (!preferredFound)
{
++preferredIndex;
}
}
void QmitkNodeSelectionDialog::OnDoubleClicked(const QModelIndex& /*index*/)
{
if (!m_SelectedNodes.empty())
{
this->OnOK();
}
}
diff --git a/Plugins/org.mitk.gui.qt.common/src/internal/QmitkNodeSelectionPreferencePage.cpp b/Plugins/org.mitk.gui.qt.common/src/internal/QmitkNodeSelectionPreferencePage.cpp
index 9ccc92dc20..0d1d483d1b 100644
--- a/Plugins/org.mitk.gui.qt.common/src/internal/QmitkNodeSelectionPreferencePage.cpp
+++ b/Plugins/org.mitk.gui.qt.common/src/internal/QmitkNodeSelectionPreferencePage.cpp
@@ -1,215 +1,215 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkNodeSelectionPreferencePage.h"
#include "QmitkNodeSelectionPreferenceHelper.h"
#include <QmitkDataStorageSelectionHistoryInspector.h>
#include <QmitkDataStorageFavoriteNodesInspector.h>
//-----------------------------------------------------------------------------
QmitkNodeSelectionPreferencePage::QmitkNodeSelectionPreferencePage()
: m_MainControl(nullptr), m_Controls(nullptr)
{
}
//-----------------------------------------------------------------------------
QmitkNodeSelectionPreferencePage::~QmitkNodeSelectionPreferencePage()
{
delete m_Controls;
}
//-----------------------------------------------------------------------------
void QmitkNodeSelectionPreferencePage::Init(berry::IWorkbench::Pointer )
{
}
//-----------------------------------------------------------------------------
void QmitkNodeSelectionPreferencePage::CreateQtControl(QWidget* parent)
{
m_MainControl = new QWidget(parent);
m_Controls = new Ui::QmitkNodeSelectionPreferencePage;
m_Controls->setupUi( m_MainControl );
connect(m_Controls->comboPreferred, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateWidgets()));
connect(m_Controls->btnUp, SIGNAL(clicked(bool)), this, SLOT(MoveUp()));
connect(m_Controls->btnDown, SIGNAL(clicked(bool)), this, SLOT(MoveDown()));
connect(m_Controls->listInspectors, &QListWidget::itemSelectionChanged, this, &QmitkNodeSelectionPreferencePage::UpdateWidgets);
this->Update();
}
//-----------------------------------------------------------------------------
QWidget* QmitkNodeSelectionPreferencePage::GetQtControl() const
{
return m_MainControl;
}
//-----------------------------------------------------------------------------
bool QmitkNodeSelectionPreferencePage::PerformOk()
{
//store preferred
auto id = m_Controls->comboPreferred->currentData().toString();
mitk::PutPreferredDataStorageInspector(id.toStdString());
//store visible
mitk::VisibleDataStorageInspectorMapType visibles;
unsigned int visiblePos = 0;
for (int i = 0; i < m_Controls->listInspectors->count(); ++i)
{
auto item = m_Controls->listInspectors->item(i);
if (item->checkState() == Qt::Checked)
{
visibles.insert(std::make_pair(visiblePos++, item->data(Qt::UserRole).toString().toStdString()));
}
}
mitk::PutVisibleDataStorageInspectors(visibles);
mitk::PutShowFavoritesInspector(m_Controls->checkShowFav->isChecked());
mitk::PutShowHistoryInspector(m_Controls->checkShowHistory->isChecked());
return true;
}
//-----------------------------------------------------------------------------
void QmitkNodeSelectionPreferencePage::PerformCancel()
{
}
//-----------------------------------------------------------------------------
void QmitkNodeSelectionPreferencePage::Update()
{
m_Providers = mitk::DataStorageInspectorGenerator::GetProviders();
auto visibleProviders = mitk::GetVisibleDataStorageInspectors();
auto allProviders = mitk::DataStorageInspectorGenerator::GetProviders();
auto preferredInspectorID = mitk::GetPreferredDataStorageInspector();
//fill preferred combo
int index = 0;
int currentIndex = 0;
m_Controls->comboPreferred->clear();
- for (auto iter : m_Providers)
+ for (const auto &iter : m_Providers)
{
m_Controls->comboPreferred->addItem(QString::fromStdString(iter.second->GetInspectorDisplayName()), QVariant::fromValue(QString::fromStdString(iter.first)));
if (iter.first == preferredInspectorID)
{
currentIndex = index;
};
++index;
}
m_Controls->comboPreferred->setCurrentIndex(currentIndex);
//fill inspector list
m_Controls->listInspectors->clear();
for (const auto& iter : allProviders)
{
if (iter.first != QmitkDataStorageFavoriteNodesInspector::INSPECTOR_ID() && iter.first != QmitkDataStorageSelectionHistoryInspector::INSPECTOR_ID())
{
auto currentID = iter.first;
QListWidgetItem* item = new QListWidgetItem;
item->setText(QString::fromStdString(iter.second->GetInspectorDisplayName()));
item->setData(Qt::UserRole, QVariant::fromValue(QString::fromStdString(currentID)));
item->setToolTip(QString::fromStdString(iter.second->GetInspectorDescription()));
auto finding = std::find_if(visibleProviders.cbegin(), visibleProviders.cend(), [¤tID](auto v) {return v.second == currentID; });
if (finding == visibleProviders.cend())
{
item->setCheckState(Qt::Unchecked);
m_Controls->listInspectors->addItem(item);
}
else
{
item->setCheckState(Qt::Checked);
m_Controls->listInspectors->insertItem(finding->first, item);
}
}
}
m_Controls->checkShowFav->setChecked(mitk::GetShowFavoritesInspector());
m_Controls->checkShowHistory->setChecked(mitk::GetShowHistoryInspector());
this->UpdateWidgets();
}
void QmitkNodeSelectionPreferencePage::UpdateWidgets()
{
int currentIndex = m_Controls->listInspectors->currentRow();
m_Controls->btnUp->setEnabled(!m_Controls->listInspectors->selectedItems().empty() && currentIndex > 0);
m_Controls->btnDown->setEnabled(!m_Controls->listInspectors->selectedItems().empty() && currentIndex + 1 < m_Controls->listInspectors->count());
for (int i = 0; i < m_Controls->listInspectors->count(); ++i)
{
auto item = m_Controls->listInspectors->item(i);
if (item->data(Qt::UserRole).toString() == m_Controls->comboPreferred->currentData().toString())
{
//preferred inspector is always visible.
item->setCheckState(Qt::Checked);
item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled);
}
else
{
item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled | Qt::ItemIsUserCheckable);
}
}
auto isFavSelected =
QmitkDataStorageFavoriteNodesInspector::INSPECTOR_ID() == m_Controls->comboPreferred->currentData().toString();
if (isFavSelected)
{
m_Controls->checkShowFav->setChecked(true);
}
m_Controls->checkShowFav->setEnabled(!isFavSelected);
auto isHistorySelected =
QmitkDataStorageSelectionHistoryInspector::INSPECTOR_ID() == m_Controls->comboPreferred->currentData().toString();
if (isHistorySelected)
{
m_Controls->checkShowHistory->setChecked(true);
}
m_Controls->checkShowHistory->setEnabled(!isHistorySelected);
}
void QmitkNodeSelectionPreferencePage::MoveDown()
{
int currentIndex = m_Controls->listInspectors->currentRow();
if (currentIndex+1 < m_Controls->listInspectors->count())
{
QListWidgetItem *currentItem = m_Controls->listInspectors->takeItem(currentIndex);
m_Controls->listInspectors->insertItem(currentIndex + 1, currentItem);
m_Controls->listInspectors->setCurrentRow(currentIndex + 1);
}
this->UpdateWidgets();
}
void QmitkNodeSelectionPreferencePage::MoveUp()
{
int currentIndex = m_Controls->listInspectors->currentRow();
if (currentIndex > 0)
{
QListWidgetItem *currentItem = m_Controls->listInspectors->takeItem(currentIndex);
m_Controls->listInspectors->insertItem(currentIndex - 1, currentItem);
m_Controls->listInspectors->setCurrentRow(currentIndex - 1);
}
this->UpdateWidgets();
}
diff --git a/Plugins/org.mitk.gui.qt.common/src/internal/QmitkViewCoordinator.cpp b/Plugins/org.mitk.gui.qt.common/src/internal/QmitkViewCoordinator.cpp
index 76604ed003..2a6a403d21 100644
--- a/Plugins/org.mitk.gui.qt.common/src/internal/QmitkViewCoordinator.cpp
+++ b/Plugins/org.mitk.gui.qt.common/src/internal/QmitkViewCoordinator.cpp
@@ -1,234 +1,234 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkViewCoordinator.h"
#include "QmitkAbstractView.h"
#include <mitkIRenderWindowPart.h>
#include <mitkIRenderWindowPartListener.h>
#include <mitkIZombieViewPart.h>
#include <berryPlatformUI.h>
#include <berryIWorkbenchPage.h>
QmitkViewCoordinator::QmitkViewCoordinator()
: m_ActiveZombieView(nullptr)
, m_ActiveRenderWindowPart(nullptr)
, m_VisibleRenderWindowPart(nullptr)
{
}
QmitkViewCoordinator::~QmitkViewCoordinator()
{
}
void QmitkViewCoordinator::Start()
{
berry::PlatformUI::GetWorkbench()->AddWindowListener(this);
QList<berry::IWorkbenchWindow::Pointer> wnds(berry::PlatformUI::GetWorkbench()->GetWorkbenchWindows());
for (QList<berry::IWorkbenchWindow::Pointer>::iterator i = wnds.begin(); i != wnds.end(); ++i)
{
(*i)->GetPartService()->AddPartListener(this);
}
}
void QmitkViewCoordinator::Stop()
{
if (!berry::PlatformUI::IsWorkbenchRunning()) return;
berry::PlatformUI::GetWorkbench()->RemoveWindowListener(this);
QList<berry::IWorkbenchWindow::Pointer> wnds(berry::PlatformUI::GetWorkbench()->GetWorkbenchWindows());
for (QList<berry::IWorkbenchWindow::Pointer>::iterator i = wnds.begin(); i != wnds.end(); ++i)
{
(*i)->GetPartService()->RemovePartListener(this);
}
}
berry::IPartListener::Events::Types QmitkViewCoordinator::GetPartEventTypes() const
{
return berry::IPartListener::Events::ACTIVATED | berry::IPartListener::Events::DEACTIVATED
| berry::IPartListener::Events::CLOSED | berry::IPartListener::Events::HIDDEN
| berry::IPartListener::Events::VISIBLE | berry::IPartListener::Events::OPENED
| berry::IPartListener::Events::INPUT_CHANGED;
}
void QmitkViewCoordinator::PartActivated(const berry::IWorkbenchPartReference::Pointer& partRef)
{
//MITK_INFO << "*** PartActivated (" << partRef->GetPart(false)->GetPartName() << ")";
berry::IWorkbenchPart* part = partRef->GetPart(false).GetPointer();
// Check for a render window part and inform IRenderWindowPartListener views
// that it was activated
if (mitk::IRenderWindowPart* renderPart = dynamic_cast<mitk::IRenderWindowPart*>(part))
{
if (m_VisibleRenderWindowPart != renderPart)
{
RenderWindowPartActivated(renderPart);
m_ActiveRenderWindowPart = renderPart;
m_VisibleRenderWindowPart = renderPart;
}
}
// Check if the activated part wants to be notified
if (mitk::ILifecycleAwarePart* lifecycleAwarePart = dynamic_cast<mitk::ILifecycleAwarePart*>(part))
{
lifecycleAwarePart->Activated();
}
// Check if a zombie view has been activated.
if (mitk::IZombieViewPart* zombieView = dynamic_cast<mitk::IZombieViewPart*>(part))
{
if (m_ActiveZombieView && (m_ActiveZombieView != zombieView))
{
// Another zombie view has been activated. Tell the old one about it.
m_ActiveZombieView->ActivatedZombieView(partRef);
m_ActiveZombieView = zombieView;
}
}
}
void QmitkViewCoordinator::PartDeactivated(const berry::IWorkbenchPartReference::Pointer& partRef)
{
//MITK_INFO << "*** PartDeactivated (" << partRef->GetPart(false)->GetPartName() << ")";
berry::IWorkbenchPart* part = partRef->GetPart(false).GetPointer();
// Check for a render window part and inform IRenderWindowPartListener views
// that it was deactivated
if (mitk::IRenderWindowPart* renderPart = dynamic_cast<mitk::IRenderWindowPart*>(part))
{
if (m_ActiveRenderWindowPart == renderPart)
{
this->RenderWindowPartDeactivated(renderPart);
m_ActiveRenderWindowPart = nullptr;
m_VisibleRenderWindowPart = nullptr;
}
}
if (mitk::ILifecycleAwarePart* lifecycleAwarePart = dynamic_cast<mitk::ILifecycleAwarePart*>(part))
{
lifecycleAwarePart->Deactivated();
}
}
void QmitkViewCoordinator::PartOpened(const berry::IWorkbenchPartReference::Pointer& partRef)
{
//MITK_INFO << "*** PartOpened (" << partRef->GetPart(false)->GetPartName() << ")";
berry::IWorkbenchPart* part = partRef->GetPart(false).GetPointer();
if (mitk::IRenderWindowPartListener* renderWindowListener = dynamic_cast<mitk::IRenderWindowPartListener*>(part))
{
m_RenderWindowListeners.insert(renderWindowListener);
}
}
void QmitkViewCoordinator::PartClosed(const berry::IWorkbenchPartReference::Pointer& partRef)
{
//MITK_INFO << "*** PartClosed (" << partRef->GetPart(false)->GetPartName() << ")";
berry::IWorkbenchPart* part = partRef->GetPart(false).GetPointer();
if (mitk::IRenderWindowPartListener* renderWindowListener = dynamic_cast<mitk::IRenderWindowPartListener*>(part))
{
m_RenderWindowListeners.remove(renderWindowListener);
}
}
void QmitkViewCoordinator::PartHidden(const berry::IWorkbenchPartReference::Pointer& partRef)
{
//MITK_INFO << "*** PartHidden (" << partRef->GetPart(false)->GetPartName() << ")";
berry::IWorkbenchPart* part = partRef->GetPart(false).GetPointer();
// Check for a render window part and if it is the currently active on.
// Inform IRenderWindowPartListener views that it has been hidden.
if (mitk::IRenderWindowPart* renderPart = dynamic_cast<mitk::IRenderWindowPart*>(part))
{
if (!m_ActiveRenderWindowPart && m_VisibleRenderWindowPart == renderPart)
{
RenderWindowPartDeactivated(renderPart);
m_VisibleRenderWindowPart = nullptr;
}
}
if (mitk::ILifecycleAwarePart* lifecycleAwarePart = dynamic_cast<mitk::ILifecycleAwarePart*>(part))
{
lifecycleAwarePart->Hidden();
}
}
void QmitkViewCoordinator::PartVisible(const berry::IWorkbenchPartReference::Pointer& partRef)
{
//MITK_INFO << "*** PartVisible (" << partRef->GetPart(false)->GetPartName() << ")";
berry::IWorkbenchPart* part = partRef->GetPart(false).GetPointer();
// Check for a render window part and inform IRenderWindowPartListener views
// that it was activated
if (mitk::IRenderWindowPart* renderPart = dynamic_cast<mitk::IRenderWindowPart*>(part))
{
if (!m_ActiveRenderWindowPart)
{
RenderWindowPartActivated(renderPart);
m_VisibleRenderWindowPart = renderPart;
}
}
if (mitk::ILifecycleAwarePart* lifecycleAwarePart = dynamic_cast<mitk::ILifecycleAwarePart*>(part))
{
lifecycleAwarePart->Visible();
}
}
void QmitkViewCoordinator::PartInputChanged(const berry::IWorkbenchPartReference::Pointer& partRef)
{
berry::IWorkbenchPart* part = partRef->GetPart(false).GetPointer();
// Check for a render window part and inform IRenderWindowPartListener views
// that it was changed
if (mitk::IRenderWindowPart* renderPart = dynamic_cast<mitk::IRenderWindowPart*>(part))
{
if (!m_ActiveRenderWindowPart)
{
RenderWindowPartInputChanged(renderPart);
}
}
}
void QmitkViewCoordinator::WindowOpened(const berry::IWorkbenchWindow::Pointer& window)
{
window->GetPartService()->AddPartListener(this);
}
void QmitkViewCoordinator::WindowClosed(const berry::IWorkbenchWindow::Pointer& /*window*/)
{
}
void QmitkViewCoordinator::RenderWindowPartActivated(mitk::IRenderWindowPart* renderPart)
{
- for (auto& listener : m_RenderWindowListeners)
+ for (auto& listener : qAsConst(m_RenderWindowListeners))
{
listener->RenderWindowPartActivated(renderPart);
}
}
void QmitkViewCoordinator::RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderPart)
{
- for (auto& listener : m_RenderWindowListeners)
+ for (auto& listener : qAsConst(m_RenderWindowListeners))
{
listener->RenderWindowPartDeactivated(renderPart);
}
}
void QmitkViewCoordinator::RenderWindowPartInputChanged(mitk::IRenderWindowPart* renderPart)
{
- for (auto& listener : m_RenderWindowListeners)
+ for (auto& listener : qAsConst(m_RenderWindowListeners))
{
listener->RenderWindowPartInputChanged(renderPart);
}
}
diff --git a/Plugins/org.mitk.gui.qt.datamanager/plugin.xml b/Plugins/org.mitk.gui.qt.datamanager/plugin.xml
index 703cfb91f8..fac19121f7 100644
--- a/Plugins/org.mitk.gui.qt.datamanager/plugin.xml
+++ b/Plugins/org.mitk.gui.qt.datamanager/plugin.xml
@@ -1,26 +1,28 @@
<?xml version="1.0" encoding="UTF-8"?>
<?eclipse version="3.0"?>
<plugin>
<extension point="org.blueberry.ui.views">
<view
id="org.mitk.views.datamanager"
name="Data Manager"
category="Data"
icon="resources/data-manager.svg"
class="QmitkDataManagerView" />
</extension>
<extension point="org.blueberry.ui.preferencePages">
<page id="org.mitk.gui.qt.application.DataManagerPreferencePage" name="Data Manager" class="QmitkDataManagerPreferencePage">
<keywordreference id="org.mitk.gui.qt.application.DataManagerPreferencePageKeywords"></keywordreference>
</page>
<page id="org.mitk.gui.qt.application.DataManagerHotkeysPrefPage" name="Hotkeys" class="QmitkDataManagerHotkeysPrefPage" category="org.mitk.gui.qt.application.DataManagerPreferencePage">
<keywordreference id="org.mitk.gui.qt.application.DataManagerHotkeysPrefPageKeywords"></keywordreference>
</page>
</extension>
<extension point="org.blueberry.ui.keywords">
<keyword id="org.mitk.gui.qt.application.DataManagerPreferencePageKeywords" label="data manager global reinit surface decimation parent helper objects single click property editing nodes top show containing data deleted added call"></keyword>
<keyword id="org.mitk.gui.qt.application.DataManagerHotkeysPrefPageKeywords" label="data manager hotkeys delete selected nodes global reinit invisible show information toggle visibility selected"></keyword>
</extension>
+
+ <extension-point id="contextMenuActions" name="Context menu actions"/>
</plugin>
diff --git a/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp b/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp
index d1ac5f23f5..27b424aafd 100644
--- a/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp
+++ b/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp
@@ -1,272 +1,272 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkDataManagerView.h"
// mitk gui qt datamanager
#include "internal/QmitkDataManagerItemDelegate.h"
#include "internal/QmitkNodeTableViewKeyFilter.h"
// mitk core
#include <mitkCommon.h>
#include <mitkCoreObjectFactory.h>
#include <mitkEnumerationProperty.h>
#include <mitkImageCast.h>
#include <mitkITKImageImport.h>
#include <mitkLookupTableProperty.h>
#include <mitkNodePredicateAnd.h>
#include <mitkNodePredicateData.h>
#include <mitkNodePredicateDataType.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateOr.h>
#include <mitkNodePredicateProperty.h>
#include <mitkProperties.h>
#include <mitkRenderingModeProperty.h>
// qt widgets module
#include <QmitkCustomVariants.h>
#include <QmitkDataStorageFilterProxyModel.h>
#include <QmitkDataStorageTreeModel.h>
#include <QmitkIOUtil.h>
#include <QmitkNodeDescriptorManager.h>
// beery plugins
#include <berryAbstractUICTKPlugin.h>
#include <berryIContributor.h>
#include <berryIEditorPart.h>
#include <berryIEditorRegistry.h>
#include <berryIExtensionRegistry.h>
#include <berryIPreferencesService.h>
#include <berryIWorkbenchPage.h>
#include <berryPlatform.h>
#include <berryPlatformUI.h>
// mitk core services plugin
#include <mitkIDataStorageReference.h>
#include <mitkIDataStorageService.h>
// mitk gui common plugin
#include <mitkDataNodeObject.h>
#include <mitkDataStorageEditorInput.h>
#include <mitkIRenderingManager.h>
// mitk gui qt application plugin
#include <QmitkDataNodeGlobalReinitAction.h>
#include <QmitkDataNodeToggleVisibilityAction.h>
// mitk gui qt common plugin
#include <QmitkDnDFrameWidget.h>
// qt
#include <QGridLayout>
#include <QVBoxLayout>
#include <QAction>
#include <QTreeView>
#include <QSignalMapper>
const QString QmitkDataManagerView::VIEW_ID = "org.mitk.views.datamanager";
QmitkDataManagerView::QmitkDataManagerView()
: m_ItemDelegate(nullptr)
{
}
QmitkDataManagerView::~QmitkDataManagerView()
{
// nothing here
}
void QmitkDataManagerView::CreateQtPartControl(QWidget* parent)
{
m_CurrentRowCount = 0;
m_Parent = parent;
berry::IBerryPreferences::Pointer prefs = this->GetPreferences().Cast<berry::IBerryPreferences>();
assert(prefs);
//# GUI
m_NodeTreeModel = new QmitkDataStorageTreeModel(GetDataStorage(), prefs->GetBool("Place new nodes on top", true));
m_NodeTreeModel->setParent(parent);
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(nullptr);
m_FilterModel = new QmitkDataStorageFilterProxyModel();
m_FilterModel->setSourceModel(m_NodeTreeModel);
m_FilterModel->AddFilterPredicate(m_HelperObjectFilterPredicate);
m_FilterModel->AddFilterPredicate(m_NodeWithNoDataFilterPredicate);
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, GetDataStorage()));
m_ItemDelegate = new QmitkDataManagerItemDelegate(m_NodeTreeView);
m_NodeTreeView->setItemDelegate(m_ItemDelegate);
connect(m_NodeTreeModel, SIGNAL(rowsInserted(const QModelIndex&, int, int)), this, SLOT(NodeTreeViewRowsInserted(const QModelIndex&, int, int)));
connect(m_NodeTreeModel, SIGNAL(rowsRemoved(const QModelIndex&, int, int)), this, SLOT(NodeTreeViewRowsRemoved(const QModelIndex&, int, int)));
connect(m_NodeTreeView->selectionModel(), SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection &)), this, SLOT(NodeSelectionChanged(const QItemSelection &, const QItemSelection &)));
connect(m_NodeTreeModel, &QmitkDataStorageTreeModel::nodeVisibilityChanged, this, &QmitkDataManagerView::OnNodeVisibilityChanged);
// data node context menu and menu actions
m_DataNodeContextMenu = new QmitkDataNodeContextMenu(GetSite(), m_NodeTreeView);
m_DataNodeContextMenu->SetDataStorage(GetDataStorage());
m_DataNodeContextMenu->SetSurfaceDecimation(m_SurfaceDecimation);
connect(m_NodeTreeView, SIGNAL(customContextMenuRequested(const QPoint&)), m_DataNodeContextMenu, SLOT(OnContextMenuRequested(const QPoint&)));
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)));
}
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()
{
}
//////////////////////////////////////////////////////////////////////////
// Node tree modification
//////////////////////////////////////////////////////////////////////////
void QmitkDataManagerView::NodeTreeViewRowsInserted(const QModelIndex& parent, int /*start*/, int /*end*/)
{
QModelIndex viewIndex = m_FilterModel->mapFromSource(parent);
m_NodeTreeView->setExpanded(viewIndex, true);
// a new row was inserted
if (m_CurrentRowCount == 0 && m_NodeTreeModel->rowCount() == 1)
{
mitk::WorkbenchUtil::OpenRenderWindowPart(GetSite()->GetPage());
m_CurrentRowCount = m_NodeTreeModel->rowCount();
}
}
void QmitkDataManagerView::NodeTreeViewRowsRemoved(const QModelIndex& /*parent*/, int /*start*/, int /*end*/)
{
m_CurrentRowCount = m_NodeTreeModel->rowCount();
}
void QmitkDataManagerView::NodeSelectionChanged(const QItemSelection& /*selected*/, const QItemSelection& /*deselected*/)
{
auto selectedNodes = GetCurrentSelection();
auto nodeSet = m_NodeTreeModel->GetNodeSet();
- for (auto node : nodeSet)
+ for (auto node : qAsConst(nodeSet))
{
if (node.IsNotNull())
{
node->SetSelected(selectedNodes.contains(node));
}
}
m_DataNodeContextMenu->SetSelectedNodes(selectedNodes);
}
void QmitkDataManagerView::OnNodeVisibilityChanged()
{
ToggleVisibilityAction::Run(GetSite(), GetDataStorage(), QList<mitk::DataNode::Pointer>());
}
void QmitkDataManagerView::ShowIn(const QString& editorId)
{
berry::IWorkbenchPage::Pointer page = GetSite()->GetPage();
berry::IEditorInput::Pointer input(new mitk::DataStorageEditorInput(GetDataStorageReference()));
page->OpenEditor(input, editorId, false, berry::IWorkbenchPage::MATCH_ID);
}
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);
}
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_NodeTreeView->expandAll();
m_SurfaceDecimation = prefs->GetBool("Use surface decimation", false);
m_DataNodeContextMenu->SetSurfaceDecimation(m_SurfaceDecimation);
m_NodeTreeModel->SetAllowHierarchyChange(prefs->GetBool("Allow changing of parent node", false));
GlobalReinitAction::Run(GetSite(), GetDataStorage());
}
QItemSelectionModel* QmitkDataManagerView::GetDataNodeSelectionModel() const
{
return m_NodeTreeView->selectionModel();
}
diff --git a/Plugins/org.mitk.gui.qt.dosevisualization/src/internal/RTDoseVisualizer.cpp b/Plugins/org.mitk.gui.qt.dosevisualization/src/internal/RTDoseVisualizer.cpp
index 675f3bdfe6..4b5b2ff5f4 100644
--- a/Plugins/org.mitk.gui.qt.dosevisualization/src/internal/RTDoseVisualizer.cpp
+++ b/Plugins/org.mitk.gui.qt.dosevisualization/src/internal/RTDoseVisualizer.cpp
@@ -1,821 +1,821 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
// Qt
#include <QMessageBox>
#include <QMenu>
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// MITK
#include <mitkNodePredicateDataProperty.h>
#include <mitkNodePredicateProperty.h>
#include <mitkNodePredicateAnd.h>
#include <mitkNodePredicateNot.h>
#include <mitkDoseNodeHelper.h>
#include <mitkPropertyNameHelper.h>
#include <mitkRTConstants.h>
#include <mitkIsoDoseLevelSetProperty.h>
#include <mitkIsoDoseLevelVectorProperty.h>
#include <mitkIsoLevelsGenerator.h>
#include <mitkRTUIConstants.h>
#include <mitkTransferFunction.h>
#include <mitkTransferFunctionProperty.h>
#include <service/event/ctkEventAdmin.h>
#include <service/event/ctkEventConstants.h>
// Qmitk
#include "RTDoseVisualizer.h"
#include <QmitkDoseColorDelegate.h>
#include <QmitkDoseValueDelegate.h>
#include <QmitkDoseVisualStyleDelegate.h>
#include <QmitkIsoDoseLevelSetModel.h>
#include <QmitkFreeIsoDoseLevelWidget.h>
#include "QmitkRenderWindow.h"
#include "org_mitk_gui_qt_dosevisualization_Activator.h"
#include <vtkMath.h>
#include "vtkDecimatePro.h"
const std::string RTDoseVisualizer::VIEW_ID = "org.mitk.views.rt.dosevisualization";
const std::string RTDoseVisualizer::ISO_LINE_NODE_NAME = "dose iso lines";
namespace mitk
{
/** @brief Predicate to identify dose nodes. Didn't use NodePredicateeDataProperty, because we want only depend
on the property value ('RTDOSE') and not on the property type (e.g. StringProperty or mitkTemperoSpatialStringProperty).*/
class NodePredicateDose : public NodePredicateBase
{
public:
mitkClassMacro(NodePredicateDose, NodePredicateBase);
itkNewMacro(NodePredicateDose);
~NodePredicateDose() override
{};
bool CheckNode(const mitk::DataNode *node) const override
{
if (!node) return false;
auto data = node->GetData();
if (!data) {
return false;
}
auto modalityProperty = data->GetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0008, 0x0060).c_str());
if (modalityProperty.IsNull())
{
return false;
}
std::string modality = modalityProperty->GetValueAsString();
return modality == "RTDOSE";
};
protected:
NodePredicateDose()
{};
};
} // namespace mitk
RTDoseVisualizer::RTDoseVisualizer()
{
m_selectedNode = nullptr;
m_selectedPresetName = "";
m_PrescribedDose_Data = 0.0;
m_freeIsoValuesCount = 0;
m_internalUpdate = false;
m_isDoseOrIsoPredicate = mitk::NodePredicateDose::New();
m_isIsoPredicate = mitk::NodePredicateProperty::New("name", mitk::StringProperty::New(ISO_LINE_NODE_NAME));
m_isDosePredicate = mitk::NodePredicateAnd::New(m_isDoseOrIsoPredicate, mitk::NodePredicateNot::New(m_isIsoPredicate));
}
RTDoseVisualizer::~RTDoseVisualizer()
{
mitk::DataStorage::SetOfObjects::ConstPointer isoNodes = this->GetDataStorage()->GetSubset(m_isIsoPredicate);
this->GetDataStorage()->Remove(isoNodes);
delete m_LevelSetModel;
delete m_DoseColorDelegate;
delete m_DoseValueDelegate;
delete m_DoseVisualDelegate;
}
void RTDoseVisualizer::SetFocus(){}
void RTDoseVisualizer::CreateQtPartControl( QWidget *parent )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls.setupUi( parent );
m_LevelSetModel = new QmitkIsoDoseLevelSetModel(this);
m_LevelSetModel->setVisibilityEditOnly(true);
m_DoseColorDelegate = new QmitkDoseColorDelegate(this);
m_DoseValueDelegate = new QmitkDoseValueDelegate(this);
m_DoseVisualDelegate = new QmitkDoseVisualStyleDelegate(this);
this->UpdateByPreferences();
auto doseNodes = this->GetDataStorage()->GetSubset(this->m_isDosePredicate);
auto doseNodeIter = doseNodes->begin();
while (doseNodeIter != doseNodes->end())
{
PrepareDoseNode(*doseNodeIter);
++doseNodeIter;
}
this->ActualizeIsoLevelsForAllDoseDataNodes();
this->ActualizeReferenceDoseForAllDoseDataNodes();
this->ActualizeDisplayStyleForAllDoseDataNodes();
this->m_Controls.isoLevelSetView->setModel(m_LevelSetModel);
this->m_Controls.isoLevelSetView->setItemDelegateForColumn(0,m_DoseColorDelegate);
this->m_Controls.isoLevelSetView->setItemDelegateForColumn(1,m_DoseValueDelegate);
this->m_Controls.isoLevelSetView->setItemDelegateForColumn(2,m_DoseVisualDelegate);
this->m_Controls.isoLevelSetView->setItemDelegateForColumn(3,m_DoseVisualDelegate);
this->m_Controls.isoLevelSetView->setContextMenuPolicy(Qt::CustomContextMenu);
this->m_Controls.btnRemoveFreeValue->setDisabled(true);
this->m_Controls.doseBtn->setVisible(false);
connect(m_Controls.spinReferenceDose, SIGNAL(valueChanged(double)), this, SLOT(OnReferenceDoseChanged(double)));
connect(m_Controls.spinReferenceDose, SIGNAL(valueChanged(double)), m_LevelSetModel, SLOT(setReferenceDose(double)));
connect(m_Controls.radioAbsDose, SIGNAL(toggled(bool)), m_LevelSetModel, SLOT(setShowAbsoluteDose(bool)));
connect(m_Controls.radioAbsDose, SIGNAL(toggled(bool)), this, SLOT(OnAbsDoseToggled(bool)));
connect(m_Controls.btnAddFreeValue, SIGNAL(clicked()), this, SLOT(OnAddFreeValueClicked()));
connect(m_Controls.btnRemoveFreeValue, SIGNAL(clicked()), this, SLOT(OnRemoveFreeValueClicked()));
connect(m_Controls.checkGlobalVisColorWash, SIGNAL(toggled(bool)), this, SLOT(OnGlobalVisColorWashToggled(bool)));
connect(m_Controls.checkGlobalVisIsoLine, SIGNAL(toggled(bool)), this, SLOT(OnGlobalVisIsoLineToggled(bool)));
connect(m_Controls.isoLevelSetView, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(OnShowContextMenuIsoSet(const QPoint&)));
connect(m_Controls.comboPresets, SIGNAL(currentIndexChanged ( const QString&)), this, SLOT(OnCurrentPresetChanged(const QString&)));
connect(m_Controls.btnUsePrescribedDose, SIGNAL(clicked()), this, SLOT(OnUsePrescribedDoseClicked()));
connect(m_Controls.isoLevelSetView->model(), SIGNAL( modelReset()), this, SLOT(OnDataChangedInIsoLevelSetView()));
ctkServiceReference ref = mitk::org_mitk_gui_qt_dosevisualization_Activator::GetContext()->getServiceReference<ctkEventAdmin>();
ctkDictionary propsForSlot;
if (ref)
{
ctkEventAdmin* eventAdmin = mitk::org_mitk_gui_qt_dosevisualization_Activator::GetContext()->getService<ctkEventAdmin>(ref);
propsForSlot[ctkEventConstants::EVENT_TOPIC] = mitk::RTCTKEventConstants::TOPIC_ISO_DOSE_LEVEL_PRESETS_CHANGED.c_str();
eventAdmin->subscribeSlot(this, SLOT(OnHandleCTKEventPresetsChanged(ctkEvent)), propsForSlot);
propsForSlot[ctkEventConstants::EVENT_TOPIC] = mitk::RTCTKEventConstants::TOPIC_REFERENCE_DOSE_CHANGED.c_str();
eventAdmin->subscribeSlot(this, SLOT(OnHandleCTKEventReferenceDoseChanged(ctkEvent)), propsForSlot);
propsForSlot[ctkEventConstants::EVENT_TOPIC] = mitk::RTCTKEventConstants::TOPIC_GLOBAL_VISIBILITY_CHANGED.c_str();
eventAdmin->subscribeSlot(this, SLOT(OnHandleCTKEventGlobalVisChanged(ctkEvent)), propsForSlot);
}
this->UpdateBySelectedNode();
}
void RTDoseVisualizer::OnReferenceDoseChanged(double value)
{
if (! m_internalUpdate)
{
mitk::DoseValueAbs referenceDose = 0.0;
bool globalSync = mitk::GetReferenceDoseValue(referenceDose);
if (globalSync)
{
mitk::SetReferenceDoseValue(globalSync, value);
this->ActualizeReferenceDoseForAllDoseDataNodes();
}
else
{
if (this->m_selectedNode.IsNotNull())
{
this->m_selectedNode->SetFloatProperty(mitk::RTConstants::REFERENCE_DOSE_PROPERTY_NAME.c_str(), value);
mitk::DataNode::Pointer isoDoseNode = this->GetIsoDoseNode(m_selectedNode);
if (isoDoseNode.IsNotNull()) isoDoseNode->SetFloatProperty(mitk::RTConstants::REFERENCE_DOSE_PROPERTY_NAME.c_str(), value);
}
}
if (this->m_selectedNode.IsNotNull())
{
this->UpdateColorWashTransferFunction();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
}
void RTDoseVisualizer::OnAddFreeValueClicked()
{
QColor newColor;
//Use HSV schema of QColor to calculate a different color depending on the
//number of already existing free iso lines.
newColor.setHsv((m_freeIsoValuesCount*85)%360,255,255);
mitk::IsoDoseLevel::ColorType mColor;
mColor[0]=newColor.redF();
mColor[1]=newColor.greenF();
mColor[2]=newColor.blueF();
mitk::IsoDoseLevelVector::Pointer freeIsoDoseVector;
mitk::IsoDoseLevelVectorProperty::Pointer propIsoVector;
mitk::DataNode::Pointer isoDoseNode = this->GetIsoDoseNode(m_selectedNode);
if (isoDoseNode.IsNotNull())
{
propIsoVector = dynamic_cast<mitk::IsoDoseLevelVectorProperty*>(isoDoseNode->GetProperty(mitk::RTConstants::DOSE_FREE_ISO_VALUES_PROPERTY_NAME.c_str()));
freeIsoDoseVector = propIsoVector->GetValue();
if (freeIsoDoseVector.IsNull())
mitk::IsoDoseLevelVector::Pointer freeIsoDoseVector = mitk::IsoDoseLevelVector::New();
mitk::IsoDoseLevel::Pointer newLevel = mitk::IsoDoseLevel::New(0.5, mColor, true, false);
freeIsoDoseVector->InsertElement(m_freeIsoValuesCount, newLevel);
propIsoVector = mitk::IsoDoseLevelVectorProperty::New(freeIsoDoseVector);
isoDoseNode->SetProperty(mitk::RTConstants::DOSE_FREE_ISO_VALUES_PROPERTY_NAME.c_str(), propIsoVector);
m_freeIsoValuesCount++;
this->m_Controls.btnRemoveFreeValue->setEnabled(true);
//Update Widget
this->UpdateFreeIsoValues();
//Update Rendering
this->ActualizeFreeIsoLine();
}
}
void RTDoseVisualizer::OnRemoveFreeValueClicked()
{
int index = this->m_Controls.listFreeValues->currentRow();
if (index > static_cast<int>(m_freeIsoValuesCount) || index < 0)
return;
mitk::IsoDoseLevelVectorProperty::Pointer propfreeIsoVec;
mitk::DataNode::Pointer isoDoseNode = this->GetIsoDoseNode(m_selectedNode);
propfreeIsoVec = dynamic_cast<mitk::IsoDoseLevelVectorProperty*>(isoDoseNode->GetProperty(mitk::RTConstants::DOSE_FREE_ISO_VALUES_PROPERTY_NAME.c_str()));
mitk::IsoDoseLevelVector::Pointer freeIsoDoseLevelVec = propfreeIsoVec->GetValue();
if(freeIsoDoseLevelVec->IndexExists(index))
{
//freeIsoDoseLevelVec->DeleteIndex(index);
freeIsoDoseLevelVec->erase(freeIsoDoseLevelVec->begin()+index);
--m_freeIsoValuesCount;
if(m_freeIsoValuesCount == 0)
this->m_Controls.btnRemoveFreeValue->setEnabled(true);
this->UpdateFreeIsoValues();
this->ActualizeFreeIsoLine();
}
}
void RTDoseVisualizer::OnUsePrescribedDoseClicked()
{
m_Controls.spinReferenceDose->setValue(this->m_PrescribedDose_Data);
}
void RTDoseVisualizer::OnDataChangedInIsoLevelSetView()
{
//colorwash visibility changed, update the colorwash
this->UpdateColorWashTransferFunction();
if(m_selectedNode.IsNotNull())
{
//Hack: This is a dirty hack to reinit the isodose contour node. Only if the node (or property) has changed the rendering process register the RequestUpdateAll
//Only way to render the isoline by changes without a global reinit
mitk::DataNode::Pointer isoDoseNode = this->GetIsoDoseNode(m_selectedNode);
if (isoDoseNode.IsNotNull()) isoDoseNode->Modified();
// Reinit if visibility of colorwash or isodoselevel changed
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void RTDoseVisualizer::OnShowContextMenuIsoSet(const QPoint& pos)
{
QPoint globalPos = m_Controls.isoLevelSetView->viewport()->mapToGlobal(pos);
QMenu viewMenu;
QAction* invertIsoLineAct = viewMenu.addAction("Invert iso line visibility");
QAction* activateIsoLineAct = viewMenu.addAction("Activate all iso lines");
QAction* deactivateIsoLineAct = viewMenu.addAction("Deactivate all iso lines");
viewMenu.addSeparator();
QAction* invertColorWashAct = viewMenu.addAction("Invert color wash visibility");
QAction* activateColorWashAct = viewMenu.addAction("Activate all color wash levels");
QAction* deactivateColorWashAct = viewMenu.addAction("Deactivate all color wash levels");
viewMenu.addSeparator();
QAction* swapAct = viewMenu.addAction("Swap iso line/color wash visibility");
// ...
QAction* selectedItem = viewMenu.exec(globalPos);
if (selectedItem == invertIsoLineAct)
{
this->m_LevelSetModel->invertVisibilityIsoLines();
}
else if (selectedItem == activateIsoLineAct)
{
this->m_LevelSetModel->switchVisibilityIsoLines(true);
}
else if (selectedItem == deactivateIsoLineAct)
{
this->m_LevelSetModel->switchVisibilityIsoLines(false);
}
else if (selectedItem == invertColorWashAct)
{
this->m_LevelSetModel->invertVisibilityColorWash();
}
else if (selectedItem == activateColorWashAct)
{
this->m_LevelSetModel->switchVisibilityColorWash(true);
}
else if (selectedItem == deactivateColorWashAct)
{
this->m_LevelSetModel->switchVisibilityColorWash(false);
}
else if (selectedItem == swapAct)
{
this->m_LevelSetModel->swapVisibility();
}
}
void RTDoseVisualizer::UpdateFreeIsoValues()
{
this->m_Controls.listFreeValues->clear();
mitk::DataNode::Pointer isoDoseNode = this->GetIsoDoseNode(m_selectedNode);
if (isoDoseNode.IsNotNull())
{
mitk::IsoDoseLevelVectorProperty::Pointer propfreeIsoVec;
propfreeIsoVec = dynamic_cast<mitk::IsoDoseLevelVectorProperty*>(isoDoseNode->GetProperty(mitk::RTConstants::DOSE_FREE_ISO_VALUES_PROPERTY_NAME.c_str()));
mitk::IsoDoseLevelVector::Pointer freeIsoDoseLevelVec = propfreeIsoVec->GetValue();
for (mitk::IsoDoseLevelVector::Iterator pos = freeIsoDoseLevelVec->Begin(); pos != freeIsoDoseLevelVec->End(); ++pos)
{
QListWidgetItem* item = new QListWidgetItem;
item->setSizeHint(QSize(0, 25));
QmitkFreeIsoDoseLevelWidget* widget = new QmitkFreeIsoDoseLevelWidget;
float pref;
m_selectedNode->GetFloatProperty(mitk::RTConstants::REFERENCE_DOSE_PROPERTY_NAME.c_str(), pref);
widget->setIsoDoseLevel(pos.Value());
widget->setReferenceDose(pref);
connect(m_Controls.spinReferenceDose, SIGNAL(valueChanged(double)), widget, SLOT(setReferenceDose(double)));
connect(widget, SIGNAL(ColorChanged(mitk::IsoDoseLevel*)), this, SLOT(ActualizeFreeIsoLine()));
connect(widget, SIGNAL(ValueChanged(mitk::IsoDoseLevel*, mitk::DoseValueRel)), this, SLOT(ActualizeFreeIsoLine()));
connect(widget, SIGNAL(VisualizationStyleChanged(mitk::IsoDoseLevel*)), this, SLOT(ActualizeFreeIsoLine()));
this->m_Controls.listFreeValues->addItem(item);
this->m_Controls.listFreeValues->setItemWidget(item, widget);
}
}
}
void RTDoseVisualizer::ActualizeFreeIsoLine()
{
if(m_selectedNode.IsNotNull())
{
//Hack: This is a dirty hack to reinit the isodose contour node. Only if the node (or property) has changed the rendering process register the RequestUpdateAll
//Only way to render the isoline by changes without a global reinit
mitk::DataNode::Pointer isoDoseNode = this->GetIsoDoseNode(m_selectedNode);
if (isoDoseNode.IsNotNull()) isoDoseNode->Modified();
// Reinit if visibility of colorwash or isodoselevel changed
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void RTDoseVisualizer::OnAbsDoseToggled(bool showAbs)
{
if (! m_internalUpdate)
{
mitk::SetDoseDisplayAbsolute(showAbs);
this->ActualizeDisplayStyleForAllDoseDataNodes();
}
}
void RTDoseVisualizer::OnGlobalVisColorWashToggled(bool showColorWash)
{
if (m_selectedNode.IsNotNull())
{
m_selectedNode->SetBoolProperty(mitk::RTConstants::DOSE_SHOW_COLORWASH_PROPERTY_NAME.c_str(), showColorWash);
//The rendering mode could be set in the dose mapper: Refactoring!
mitk::RenderingModeProperty::Pointer renderingMode = mitk::RenderingModeProperty::New();
if(showColorWash)
renderingMode->SetValue(mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_COLOR);
else
renderingMode->SetValue(mitk::RenderingModeProperty::LOOKUPTABLE_LEVELWINDOW_COLOR);
m_selectedNode->SetProperty("Image Rendering.Mode", renderingMode);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void RTDoseVisualizer::OnGlobalVisIsoLineToggled(bool showIsoLines)
{
if (m_selectedNode.IsNotNull())
{
mitk::DataNode::Pointer isoDoseNode = this->GetIsoDoseNode(m_selectedNode);
if (isoDoseNode.IsNotNull())
{
isoDoseNode->SetBoolProperty(mitk::RTConstants::DOSE_SHOW_ISOLINES_PROPERTY_NAME.c_str(), showIsoLines);
//toggle the visibility of the free isolevel sliders
this->m_Controls.listFreeValues->setEnabled(showIsoLines);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
}
void RTDoseVisualizer::UpdateColorWashTransferFunction()
{
//Generating the Colorwash
vtkSmartPointer<vtkColorTransferFunction> transferFunction = vtkSmartPointer<vtkColorTransferFunction>::New();
if(m_selectedNode.IsNotNull())
{
mitk::IsoDoseLevelSetProperty::Pointer propIsoSet = dynamic_cast<mitk::IsoDoseLevelSetProperty* >(m_selectedNode->GetProperty(mitk::RTConstants::DOSE_ISO_LEVELS_PROPERTY_NAME.c_str()));
mitk::IsoDoseLevelSet::Pointer isoDoseLevelSet = propIsoSet->GetValue();
float referenceDose;
m_selectedNode->GetFloatProperty(mitk::RTConstants::REFERENCE_DOSE_PROPERTY_NAME.c_str(),referenceDose);
mitk::TransferFunction::ControlPoints scalarOpacityPoints;
scalarOpacityPoints.push_back( std::make_pair(0, 1 ) );
//Backgroud
transferFunction->AddHSVPoint(((isoDoseLevelSet->Begin())->GetDoseValue()*referenceDose)-0.001,0,0,0,1.0,1.0);
for(mitk::IsoDoseLevelSet::ConstIterator itIsoDoseLevel = isoDoseLevelSet->Begin(); itIsoDoseLevel != isoDoseLevelSet->End(); ++itIsoDoseLevel)
{
float *hsv = new float[3];
//used for transfer rgb to hsv
vtkSmartPointer<vtkMath> cCalc = vtkSmartPointer<vtkMath>::New();
if(itIsoDoseLevel->GetVisibleColorWash())
{
cCalc->RGBToHSV(itIsoDoseLevel->GetColor()[0],itIsoDoseLevel->GetColor()[1],itIsoDoseLevel->GetColor()[2],&hsv[0],&hsv[1],&hsv[2]);
transferFunction->AddHSVPoint(itIsoDoseLevel->GetDoseValue()*referenceDose,hsv[0],hsv[1],hsv[2],1.0,1.0);
}
else
{
scalarOpacityPoints.push_back( std::make_pair(itIsoDoseLevel->GetDoseValue()*referenceDose, 1 ) );
}
}
mitk::TransferFunction::Pointer mitkTransFunc = mitk::TransferFunction::New();
mitk::TransferFunctionProperty::Pointer mitkTransFuncProp = mitk::TransferFunctionProperty::New();
mitkTransFunc->SetColorTransferFunction(transferFunction);
mitkTransFunc->SetScalarOpacityPoints(scalarOpacityPoints);
mitkTransFuncProp->SetValue(mitkTransFunc);
m_selectedNode->SetProperty("Image Rendering.Transfer Function", mitkTransFuncProp);
}
}
/**Simple check if the passed node has dose visualization properties set.*/
bool hasDoseVisProperties(mitk::DataNode::Pointer doseNode)
{
return doseNode->GetProperty(mitk::RTConstants::REFERENCE_DOSE_PROPERTY_NAME.c_str()) != nullptr;
}
void RTDoseVisualizer::OnSelectionChanged( berry::IWorkbenchPart::Pointer,
const QList<mitk::DataNode::Pointer>&)
{
QList<mitk::DataNode::Pointer> dataNodes = this->GetDataManagerSelection();
mitk::DataNode* selectedNode = nullptr;
if (!dataNodes.empty())
{
bool isDoseNode = m_isDosePredicate->CheckNode(dataNodes[0].GetPointer());
if (isDoseNode)
{
selectedNode = dataNodes[0];
}
}
if (selectedNode != m_selectedNode.GetPointer())
{
m_selectedNode = selectedNode;
if (selectedNode)
{
PrepareDoseNode(m_selectedNode);
}
}
UpdateBySelectedNode();
}
void RTDoseVisualizer::PrepareDoseNode( mitk::DataNode* doseNode ) const
{
mitk::DoseValueAbs dose;
mitk::GetReferenceDoseValue(dose);
auto presetMap = mitk::LoadPresetsMap();
auto colorPreset = mitk::GenerateIsoLevels_Virtuos();
auto finding = presetMap.find(mitk::GetSelectedPresetName());
if (finding != presetMap.end())
{
colorPreset = finding->second;
}
if (!hasDoseVisProperties(doseNode))
{
mitk::ConfigureNodeAsDoseNode(doseNode, colorPreset, dose, true);
}
mitk::DataNode::Pointer doseOutlineNode = this->GetIsoDoseNode(doseNode);
if (doseOutlineNode.IsNull())
{
doseOutlineNode = mitk::DataNode::New();
doseOutlineNode->SetData(doseNode->GetData());
doseOutlineNode->SetName(ISO_LINE_NODE_NAME);
mitk::ConfigureNodeAsIsoLineNode(doseOutlineNode, colorPreset, dose, true);
this->GetDataStorage()->Add(doseOutlineNode, doseNode);
}
}
void RTDoseVisualizer::UpdateBySelectedNode()
{
m_Controls.groupNodeSpecific->setEnabled(m_selectedNode.IsNotNull());
m_Controls.groupFreeValues->setEnabled(m_selectedNode.IsNotNull());
m_Controls.checkGlobalVisColorWash->setEnabled(m_selectedNode.IsNotNull());
m_Controls.checkGlobalVisIsoLine->setEnabled(m_selectedNode.IsNotNull());
m_Controls.isoLevelSetView->setEnabled(m_selectedNode.IsNotNull());
if(m_selectedNode.IsNull())
{
m_Controls.NrOfFractions->setText(QString("N/A. No dose selected"));
m_Controls.prescribedDoseSpecific->setText(QString("N/A. No dose selected"));
}
else
{
//dose specific information
int fracCount = 1;
m_selectedNode->GetIntProperty(mitk::RTConstants::DOSE_FRACTION_COUNT_PROPERTY_NAME.c_str(), fracCount);
m_Controls.NrOfFractions->setText(QString::number(fracCount));
m_PrescribedDose_Data = 0.0;
auto prescibedDoseProperty = m_selectedNode->GetData()->GetProperty(mitk::RTConstants::PRESCRIBED_DOSE_PROPERTY_NAME.c_str());
- auto prescribedDoseGenericProperty = dynamic_cast<mitk::GenericProperty<double>*>(prescibedDoseProperty.GetPointer());
+ auto prescribedDoseGenericProperty = dynamic_cast<mitk::DoubleProperty*>(prescibedDoseProperty.GetPointer());
m_PrescribedDose_Data = prescribedDoseGenericProperty->GetValue();
m_Controls.prescribedDoseSpecific->setText(QString::number(m_PrescribedDose_Data));
//free iso lines
mitk::DataNode::Pointer isoDoseNode = this->GetIsoDoseNode(m_selectedNode);
if (isoDoseNode)
{
mitk::IsoDoseLevelVectorProperty::Pointer propIsoVector;
propIsoVector = dynamic_cast<mitk::IsoDoseLevelVectorProperty*>(isoDoseNode->GetProperty(mitk::RTConstants::DOSE_FREE_ISO_VALUES_PROPERTY_NAME.c_str()));
if (propIsoVector.IsNull())
{
mitk::IsoDoseLevelVector::Pointer freeIsoValues = mitk::IsoDoseLevelVector::New();
propIsoVector = mitk::IsoDoseLevelVectorProperty::New(freeIsoValues);
isoDoseNode->SetProperty(mitk::RTConstants::DOSE_FREE_ISO_VALUES_PROPERTY_NAME.c_str(), propIsoVector);
}
UpdateFreeIsoValues();
//global dose issues
//ATM the IsoDoseContours have an own (helper) node which is a child of dose node; Will be fixed with the doseMapper refactoring
bool showIsoLine = mitk::GetGlobalIsolineVis();
isoDoseNode->GetBoolProperty(mitk::RTConstants::DOSE_SHOW_ISOLINES_PROPERTY_NAME.c_str(), showIsoLine);
m_Controls.checkGlobalVisIsoLine->setChecked(showIsoLine);
}
bool showColorWash = mitk::GetGlobalColorwashVis();
m_selectedNode->GetBoolProperty(mitk::RTConstants::DOSE_SHOW_COLORWASH_PROPERTY_NAME.c_str(),showColorWash);
m_Controls.checkGlobalVisColorWash->setChecked(showColorWash);
float referenceDose = 0.0;
m_selectedNode->GetFloatProperty(mitk::RTConstants::REFERENCE_DOSE_PROPERTY_NAME.c_str(),referenceDose);
m_Controls.spinReferenceDose->setValue(referenceDose);
mitk::IsoDoseLevelSetProperty::Pointer propIsoSet =
dynamic_cast<mitk::IsoDoseLevelSetProperty* >(m_selectedNode->GetProperty(mitk::RTConstants::DOSE_ISO_LEVELS_PROPERTY_NAME.c_str()));
if (propIsoSet)
{
this->m_LevelSetModel->setIsoDoseLevelSet(propIsoSet->GetValue());
}
}
}
void RTDoseVisualizer::NodeRemoved(const mitk::DataNode* node)
{
/**@TODO This removal seems to be needed because of the current dose rendering approach (additional sub node for iso dose lines).
As soon as we have a better and sound single node rendering mechanism for doses. This method should be removed.*/
bool isdose = m_isDosePredicate->CheckNode(node);
if (isdose)
{
mitk::DataStorage::SetOfObjects::ConstPointer childNodes = this->GetDataStorage()->GetDerivations(node, m_isIsoPredicate);
auto iterChildNodes = childNodes->begin();
while (iterChildNodes != childNodes->end())
{
this->GetDataStorage()->Remove((*iterChildNodes));
++iterChildNodes;
}
}
}
void RTDoseVisualizer::NodeChanged(const mitk::DataNode *node)
{
/**@TODO This event seems to be needed because of the current dose rendering approach (additional sub node for iso dose lines).
As soon as we have a better and sound single node rendering mechanism for doses. This method should be removed.*/
bool isdose = m_isDosePredicate->CheckNode(node);
if(isdose)
{
bool isvisible = true;
if(node->GetBoolProperty("visible", isvisible))
{
mitk::DataStorage::SetOfObjects::ConstPointer childNodes = this->GetDataStorage()->GetDerivations(node, m_isIsoPredicate);
mitk::DataStorage::SetOfObjects::const_iterator iterChildNodes = childNodes->begin();
while (iterChildNodes != childNodes->end())
{
(*iterChildNodes)->SetVisibility(isvisible);
++iterChildNodes;
}
}
}
}
void RTDoseVisualizer::UpdateByPreferences()
{
m_Presets = mitk::LoadPresetsMap();
m_internalUpdate = true;
m_Controls.comboPresets->clear();
this->m_selectedPresetName = mitk::GetSelectedPresetName();
m_Controls.checkGlobalVisIsoLine->setChecked(mitk::GetGlobalIsolineVis());
m_Controls.checkGlobalVisColorWash->setChecked(mitk::GetGlobalColorwashVis());
if(m_Presets.empty())
return;
int index = 0;
int selectedIndex = -1;
for (mitk::PresetMapType::const_iterator pos = m_Presets.begin(); pos != m_Presets.end(); ++pos, ++index)
{
m_Controls.comboPresets->addItem(QString(pos->first.c_str()));
if (this->m_selectedPresetName == pos->first)
{
selectedIndex = index;
}
}
if (selectedIndex == -1)
{
selectedIndex = 0;
MITK_WARN << "Error. Iso dose level preset specified in preferences does not exist. Preset name: "<<this->m_selectedPresetName;
this->m_selectedPresetName = m_Presets.begin()->first;
mitk::SetSelectedPresetName(this->m_selectedPresetName);
MITK_INFO << "Changed selected iso dose level preset to first existing preset. New preset name: "<<this->m_selectedPresetName;
}
m_Controls.comboPresets->setCurrentIndex(selectedIndex);
this->m_LevelSetModel->setIsoDoseLevelSet(this->m_Presets[this->m_selectedPresetName]);
mitk::DoseValueAbs referenceDose = 0.0;
bool globalSync = mitk::GetReferenceDoseValue(referenceDose);
if (globalSync || this->m_selectedNode.IsNull())
{
m_Controls.spinReferenceDose->setValue(referenceDose);
}
bool displayAbsoluteDose = mitk::GetDoseDisplayAbsolute();
m_Controls.radioAbsDose->setChecked(displayAbsoluteDose);
m_Controls.radioRelDose->setChecked(!displayAbsoluteDose);
this->m_LevelSetModel->setShowAbsoluteDose(displayAbsoluteDose);
m_internalUpdate = false;
}
void RTDoseVisualizer::OnCurrentPresetChanged(const QString& presetName)
{
if (! m_internalUpdate)
{
mitk::SetSelectedPresetName(presetName.toStdString());
this->UpdateByPreferences();
this->ActualizeIsoLevelsForAllDoseDataNodes();
this->UpdateBySelectedNode();
}
}
void RTDoseVisualizer::ActualizeIsoLevelsForAllDoseDataNodes()
{
std::string presetName = mitk::GetSelectedPresetName();
mitk::PresetMapType presetMap = mitk::LoadPresetsMap();
mitk::DataStorage::SetOfObjects::ConstPointer nodes = this->GetDataStorage()->GetSubset(m_isDoseOrIsoPredicate);
if(presetMap.empty())
return;
mitk::IsoDoseLevelSet* selectedPreset = presetMap[presetName];
if (!selectedPreset)
{
mitkThrow() << "Error. Cannot actualize iso dose level preset. Selected preset does not exist. Preset name: "<<presetName;
}
for(mitk::DataStorage::SetOfObjects::const_iterator pos = nodes->begin(); pos != nodes->end(); ++pos)
{
mitk::IsoDoseLevelSet::Pointer clonedPreset = selectedPreset->Clone();
mitk::IsoDoseLevelSetProperty::Pointer propIsoSet = mitk::IsoDoseLevelSetProperty::New(clonedPreset);
(*pos)->SetProperty(mitk::RTConstants::DOSE_ISO_LEVELS_PROPERTY_NAME.c_str(),propIsoSet);
}
}
void RTDoseVisualizer::ActualizeReferenceDoseForAllDoseDataNodes()
{
mitk::DoseValueAbs value = 0;
bool sync = mitk::GetReferenceDoseValue(value);
if (sync)
{
mitk::DataStorage::SetOfObjects::ConstPointer nodes = this->GetDataStorage()->GetSubset(m_isDoseOrIsoPredicate);
for(mitk::DataStorage::SetOfObjects::const_iterator pos = nodes->begin(); pos != nodes->end(); ++pos)
{
(*pos)->SetFloatProperty(mitk::RTConstants::REFERENCE_DOSE_PROPERTY_NAME.c_str(), value);
/**@TODO: ATM the IsoDoseContours have an own (helper) node which is a child of dose node; Will be fixed with the doseMapper refactoring*/
mitk::DataStorage::SetOfObjects::ConstPointer childNodes = this->GetDataStorage()->GetDerivations(*pos);
mitk::DataStorage::SetOfObjects::const_iterator iterChildNodes = childNodes->begin();
while (iterChildNodes != childNodes->end())
{
(*iterChildNodes)->SetFloatProperty(mitk::RTConstants::REFERENCE_DOSE_PROPERTY_NAME.c_str(), value);
++iterChildNodes;
}
}
}
}
void RTDoseVisualizer::ActualizeDisplayStyleForAllDoseDataNodes()
{
/** @TODO Klären ob diese präsentations info global oder auch per node gespeichert wird*/
}
void RTDoseVisualizer::OnHandleCTKEventReferenceDoseChanged(const ctkEvent&)
{
mitk::DoseValueAbs referenceDose = 0.0;
mitk::GetReferenceDoseValue(referenceDose);
this->m_Controls.spinReferenceDose->setValue(referenceDose);
}
void RTDoseVisualizer::OnHandleCTKEventGlobalVisChanged(const ctkEvent&)
{
this->m_Controls.checkGlobalVisIsoLine->setChecked(mitk::GetGlobalIsolineVis());
this->m_Controls.checkGlobalVisColorWash->setChecked(mitk::GetGlobalColorwashVis());
}
void RTDoseVisualizer::OnHandleCTKEventPresetsChanged(const ctkEvent&)
{
std::string currentPresetName = mitk::GetSelectedPresetName();
this->OnCurrentPresetChanged(QString::fromStdString(currentPresetName));
}
/**@TODO ATM the IsoDoseContours have an own (helper) node which is a child of dose node; Will be fixed with the doseMapper refactoring*/
mitk::DataNode::Pointer RTDoseVisualizer::GetIsoDoseNode(mitk::DataNode::Pointer doseNode) const
{
mitk::DataStorage::SetOfObjects::ConstPointer childNodes = this->GetDataStorage()->GetDerivations(doseNode, m_isIsoPredicate);
if (childNodes->empty())
{
return nullptr;
}
else
{
return (*childNodes->begin());
}
}
diff --git a/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.cpp b/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.cpp
index c6fb743873..f3a4196c61 100644
--- a/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.cpp
+++ b/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.cpp
@@ -1,1432 +1,1432 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkExtWorkbenchWindowAdvisor.h"
#include "QmitkExtActionBarAdvisor.h"
#include <QMenu>
#include <QMenuBar>
#include <QMainWindow>
#include <QStatusBar>
#include <QString>
#include <QFile>
#include <QRegExp>
#include <QTextStream>
#include <QSettings>
#include <ctkPluginException.h>
#include <service/event/ctkEventAdmin.h>
#include <berryPlatform.h>
#include <berryPlatformUI.h>
#include <berryIActionBarConfigurer.h>
#include <berryIWorkbenchWindow.h>
#include <berryIWorkbenchPage.h>
#include <berryIPreferencesService.h>
#include <berryIPerspectiveRegistry.h>
#include <berryIPerspectiveDescriptor.h>
#include <berryIProduct.h>
#include <berryIWorkbenchPartConstants.h>
#include <berryQtPreferences.h>
#include <berryQtStyleManager.h>
#include <berryWorkbenchPlugin.h>
#include <internal/berryQtShowViewAction.h>
#include <internal/berryQtOpenPerspectiveAction.h>
#include <QmitkFileOpenAction.h>
#include <QmitkFileSaveAction.h>
#include <QmitkExtFileSaveProjectAction.h>
#include <QmitkFileExitAction.h>
#include <QmitkCloseProjectAction.h>
#include <QmitkUndoAction.h>
#include <QmitkRedoAction.h>
#include <QmitkDefaultDropTargetListener.h>
#include <QmitkStatusBar.h>
#include <QmitkProgressBar.h>
#include <QmitkMemoryUsageIndicatorView.h>
#include <QmitkPreferencesDialog.h>
#include <QmitkOpenDicomEditorAction.h>
#include <QmitkOpenMxNMultiWidgetEditorAction.h>
#include <QmitkOpenStdMultiWidgetEditorAction.h>
#include <itkConfigure.h>
#include <vtkConfigure.h>
#include <mitkVersion.h>
#include <mitkIDataStorageService.h>
#include <mitkIDataStorageReference.h>
#include <mitkDataStorageEditorInput.h>
#include <mitkWorkbenchUtil.h>
#include <vtkVersionMacros.h>
// UGLYYY
#include "internal/QmitkExtWorkbenchWindowAdvisorHack.h"
#include "internal/QmitkCommonExtPlugin.h"
#include "mitkUndoController.h"
#include "mitkVerboseLimitedLinearUndo.h"
#include <QToolBar>
#include <QToolButton>
#include <QMessageBox>
#include <QMouseEvent>
#include <QLabel>
#include <QmitkAboutDialog.h>
QmitkExtWorkbenchWindowAdvisorHack* QmitkExtWorkbenchWindowAdvisorHack::undohack =
new QmitkExtWorkbenchWindowAdvisorHack();
QString QmitkExtWorkbenchWindowAdvisor::QT_SETTINGS_FILENAME = "QtSettings.ini";
static bool USE_EXPERIMENTAL_COMMAND_CONTRIBUTIONS = false;
class PartListenerForTitle: public berry::IPartListener
{
public:
PartListenerForTitle(QmitkExtWorkbenchWindowAdvisor* wa)
: windowAdvisor(wa)
{
}
Events::Types GetPartEventTypes() const override
{
return Events::ACTIVATED | Events::BROUGHT_TO_TOP | Events::CLOSED
| Events::HIDDEN | Events::VISIBLE;
}
void PartActivated(const berry::IWorkbenchPartReference::Pointer& ref) override
{
if (ref.Cast<berry::IEditorReference> ())
{
windowAdvisor->UpdateTitle(false);
}
}
void PartBroughtToTop(const berry::IWorkbenchPartReference::Pointer& ref) override
{
if (ref.Cast<berry::IEditorReference> ())
{
windowAdvisor->UpdateTitle(false);
}
}
void PartClosed(const berry::IWorkbenchPartReference::Pointer& /*ref*/) override
{
windowAdvisor->UpdateTitle(false);
}
void PartHidden(const berry::IWorkbenchPartReference::Pointer& ref) override
{
if (!windowAdvisor->lastActiveEditor.Expired() &&
ref->GetPart(false) == windowAdvisor->lastActiveEditor.Lock())
{
windowAdvisor->UpdateTitle(true);
}
}
void PartVisible(const berry::IWorkbenchPartReference::Pointer& ref) override
{
if (!windowAdvisor->lastActiveEditor.Expired() &&
ref->GetPart(false) == windowAdvisor->lastActiveEditor.Lock())
{
windowAdvisor->UpdateTitle(false);
}
}
private:
QmitkExtWorkbenchWindowAdvisor* windowAdvisor;
};
class PartListenerForViewNavigator: public berry::IPartListener
{
public:
PartListenerForViewNavigator(QAction* act)
: viewNavigatorAction(act)
{
}
Events::Types GetPartEventTypes() const override
{
return Events::OPENED | Events::CLOSED | Events::HIDDEN |
Events::VISIBLE;
}
void PartOpened(const berry::IWorkbenchPartReference::Pointer& ref) override
{
if (ref->GetId()=="org.mitk.views.viewnavigatorview")
{
viewNavigatorAction->setChecked(true);
}
}
void PartClosed(const berry::IWorkbenchPartReference::Pointer& ref) override
{
if (ref->GetId()=="org.mitk.views.viewnavigatorview")
{
viewNavigatorAction->setChecked(false);
}
}
void PartVisible(const berry::IWorkbenchPartReference::Pointer& ref) override
{
if (ref->GetId()=="org.mitk.views.viewnavigatorview")
{
viewNavigatorAction->setChecked(true);
}
}
void PartHidden(const berry::IWorkbenchPartReference::Pointer& ref) override
{
if (ref->GetId()=="org.mitk.views.viewnavigatorview")
{
viewNavigatorAction->setChecked(false);
}
}
private:
QAction* viewNavigatorAction;
};
class PartListenerForImageNavigator: public berry::IPartListener
{
public:
PartListenerForImageNavigator(QAction* act)
: imageNavigatorAction(act)
{
}
Events::Types GetPartEventTypes() const override
{
return Events::OPENED | Events::CLOSED | Events::HIDDEN |
Events::VISIBLE;
}
void PartOpened(const berry::IWorkbenchPartReference::Pointer& ref) override
{
if (ref->GetId()=="org.mitk.views.imagenavigator")
{
imageNavigatorAction->setChecked(true);
}
}
void PartClosed(const berry::IWorkbenchPartReference::Pointer& ref) override
{
if (ref->GetId()=="org.mitk.views.imagenavigator")
{
imageNavigatorAction->setChecked(false);
}
}
void PartVisible(const berry::IWorkbenchPartReference::Pointer& ref) override
{
if (ref->GetId()=="org.mitk.views.imagenavigator")
{
imageNavigatorAction->setChecked(true);
}
}
void PartHidden(const berry::IWorkbenchPartReference::Pointer& ref) override
{
if (ref->GetId()=="org.mitk.views.imagenavigator")
{
imageNavigatorAction->setChecked(false);
}
}
private:
QAction* imageNavigatorAction;
};
class PerspectiveListenerForTitle: public berry::IPerspectiveListener
{
public:
PerspectiveListenerForTitle(QmitkExtWorkbenchWindowAdvisor* wa)
: windowAdvisor(wa)
, perspectivesClosed(false)
{
}
Events::Types GetPerspectiveEventTypes() const override
{
if (USE_EXPERIMENTAL_COMMAND_CONTRIBUTIONS)
{
return Events::ACTIVATED | Events::SAVED_AS | Events::DEACTIVATED;
}
else
{
return Events::ACTIVATED | Events::SAVED_AS | Events::DEACTIVATED
| Events::CLOSED | Events::OPENED;
}
}
void PerspectiveActivated(const berry::IWorkbenchPage::Pointer& /*page*/,
const berry::IPerspectiveDescriptor::Pointer& /*perspective*/) override
{
windowAdvisor->UpdateTitle(false);
}
void PerspectiveSavedAs(const berry::IWorkbenchPage::Pointer& /*page*/,
const berry::IPerspectiveDescriptor::Pointer& /*oldPerspective*/,
const berry::IPerspectiveDescriptor::Pointer& /*newPerspective*/) override
{
windowAdvisor->UpdateTitle(false);
}
void PerspectiveDeactivated(const berry::IWorkbenchPage::Pointer& /*page*/,
const berry::IPerspectiveDescriptor::Pointer& /*perspective*/) override
{
windowAdvisor->UpdateTitle(false);
}
void PerspectiveOpened(const berry::IWorkbenchPage::Pointer& /*page*/,
const berry::IPerspectiveDescriptor::Pointer& /*perspective*/) override
{
if (perspectivesClosed)
{
QListIterator<QAction*> i(windowAdvisor->viewActions);
while (i.hasNext())
{
i.next()->setEnabled(true);
}
//GetViewRegistry()->Find("org.mitk.views.imagenavigator");
if(windowAdvisor->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.dicombrowser"))
{
windowAdvisor->openDicomEditorAction->setEnabled(true);
}
if (windowAdvisor->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.stdmultiwidget"))
{
windowAdvisor->openStdMultiWidgetEditorAction->setEnabled(true);
}
if (windowAdvisor->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.mxnmultiwidget"))
{
windowAdvisor->openMxNMultiWidgetEditorAction->setEnabled(true);
}
windowAdvisor->fileSaveProjectAction->setEnabled(true);
windowAdvisor->closeProjectAction->setEnabled(true);
windowAdvisor->undoAction->setEnabled(true);
windowAdvisor->redoAction->setEnabled(true);
windowAdvisor->imageNavigatorAction->setEnabled(true);
windowAdvisor->viewNavigatorAction->setEnabled(true);
windowAdvisor->resetPerspAction->setEnabled(true);
if( windowAdvisor->GetShowClosePerspectiveMenuItem() )
{
windowAdvisor->closePerspAction->setEnabled(true);
}
}
perspectivesClosed = false;
}
void PerspectiveClosed(const berry::IWorkbenchPage::Pointer& /*page*/,
const berry::IPerspectiveDescriptor::Pointer& /*perspective*/) override
{
berry::IWorkbenchWindow::Pointer wnd = windowAdvisor->GetWindowConfigurer()->GetWindow();
bool allClosed = true;
if (wnd->GetActivePage())
{
QList<berry::IPerspectiveDescriptor::Pointer> perspectives(wnd->GetActivePage()->GetOpenPerspectives());
allClosed = perspectives.empty();
}
if (allClosed)
{
perspectivesClosed = true;
QListIterator<QAction*> i(windowAdvisor->viewActions);
while (i.hasNext())
{
i.next()->setEnabled(false);
}
if(windowAdvisor->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.dicombrowser"))
{
windowAdvisor->openDicomEditorAction->setEnabled(false);
}
if (windowAdvisor->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.stdmultiwidget"))
{
windowAdvisor->openStdMultiWidgetEditorAction->setEnabled(false);
}
if (windowAdvisor->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.mxnmultiwidget"))
{
windowAdvisor->openMxNMultiWidgetEditorAction->setEnabled(false);
}
windowAdvisor->fileSaveProjectAction->setEnabled(false);
windowAdvisor->closeProjectAction->setEnabled(false);
windowAdvisor->undoAction->setEnabled(false);
windowAdvisor->redoAction->setEnabled(false);
windowAdvisor->imageNavigatorAction->setEnabled(false);
windowAdvisor->viewNavigatorAction->setEnabled(false);
windowAdvisor->resetPerspAction->setEnabled(false);
if( windowAdvisor->GetShowClosePerspectiveMenuItem() )
{
windowAdvisor->closePerspAction->setEnabled(false);
}
}
}
private:
QmitkExtWorkbenchWindowAdvisor* windowAdvisor;
bool perspectivesClosed;
};
class PerspectiveListenerForMenu: public berry::IPerspectiveListener
{
public:
PerspectiveListenerForMenu(QmitkExtWorkbenchWindowAdvisor* wa)
: windowAdvisor(wa)
{
}
Events::Types GetPerspectiveEventTypes() const override
{
return Events::ACTIVATED | Events::DEACTIVATED;
}
void PerspectiveActivated(const berry::IWorkbenchPage::Pointer& /*page*/,
const berry::IPerspectiveDescriptor::Pointer& perspective) override
{
QAction* action = windowAdvisor->mapPerspIdToAction[perspective->GetId()];
if (action)
{
action->setChecked(true);
}
}
void PerspectiveDeactivated(const berry::IWorkbenchPage::Pointer& /*page*/,
const berry::IPerspectiveDescriptor::Pointer& perspective) override
{
QAction* action = windowAdvisor->mapPerspIdToAction[perspective->GetId()];
if (action)
{
action->setChecked(false);
}
}
private:
QmitkExtWorkbenchWindowAdvisor* windowAdvisor;
};
QmitkExtWorkbenchWindowAdvisor::QmitkExtWorkbenchWindowAdvisor(berry::WorkbenchAdvisor* wbAdvisor,
berry::IWorkbenchWindowConfigurer::Pointer configurer)
: berry::WorkbenchWindowAdvisor(configurer)
, lastInput(nullptr)
, wbAdvisor(wbAdvisor)
, showViewToolbar(true)
, showPerspectiveToolbar(false)
, showVersionInfo(true)
, showMitkVersionInfo(true)
, showViewMenuItem(true)
, showNewWindowMenuItem(false)
, showClosePerspectiveMenuItem(true)
, viewNavigatorFound(false)
, showMemoryIndicator(true)
, dropTargetListener(new QmitkDefaultDropTargetListener)
{
productName = QCoreApplication::applicationName();
viewExcludeList.push_back("org.mitk.views.viewnavigatorview");
}
QmitkExtWorkbenchWindowAdvisor::~QmitkExtWorkbenchWindowAdvisor()
{
}
berry::ActionBarAdvisor::Pointer QmitkExtWorkbenchWindowAdvisor::CreateActionBarAdvisor(berry::IActionBarConfigurer::Pointer configurer)
{
if (USE_EXPERIMENTAL_COMMAND_CONTRIBUTIONS)
{
berry::ActionBarAdvisor::Pointer actionBarAdvisor(new QmitkExtActionBarAdvisor(configurer));
return actionBarAdvisor;
}
else
{
return berry::WorkbenchWindowAdvisor::CreateActionBarAdvisor(configurer);
}
}
QWidget* QmitkExtWorkbenchWindowAdvisor::CreateEmptyWindowContents(QWidget* parent)
{
QWidget* parentWidget = static_cast<QWidget*>(parent);
auto label = new QLabel(parentWidget);
label->setText("<b>No perspectives are open. Open a perspective in the <i>Window->Open Perspective</i> menu.</b>");
label->setContentsMargins(10,10,10,10);
label->setAlignment(Qt::AlignTop);
label->setEnabled(false);
parentWidget->layout()->addWidget(label);
return label;
}
void QmitkExtWorkbenchWindowAdvisor::ShowClosePerspectiveMenuItem(bool show)
{
showClosePerspectiveMenuItem = show;
}
bool QmitkExtWorkbenchWindowAdvisor::GetShowClosePerspectiveMenuItem()
{
return showClosePerspectiveMenuItem;
}
void QmitkExtWorkbenchWindowAdvisor::ShowMemoryIndicator(bool show)
{
showMemoryIndicator = show;
}
bool QmitkExtWorkbenchWindowAdvisor::GetShowMemoryIndicator()
{
return showMemoryIndicator;
}
void QmitkExtWorkbenchWindowAdvisor::ShowNewWindowMenuItem(bool show)
{
showNewWindowMenuItem = show;
}
void QmitkExtWorkbenchWindowAdvisor::ShowViewToolbar(bool show)
{
showViewToolbar = show;
}
void QmitkExtWorkbenchWindowAdvisor::ShowViewMenuItem(bool show)
{
showViewMenuItem = show;
}
void QmitkExtWorkbenchWindowAdvisor::ShowPerspectiveToolbar(bool show)
{
showPerspectiveToolbar = show;
}
void QmitkExtWorkbenchWindowAdvisor::ShowVersionInfo(bool show)
{
showVersionInfo = show;
}
void QmitkExtWorkbenchWindowAdvisor::ShowMitkVersionInfo(bool show)
{
showMitkVersionInfo = show;
}
void QmitkExtWorkbenchWindowAdvisor::SetProductName(const QString& product)
{
productName = product;
}
void QmitkExtWorkbenchWindowAdvisor::SetWindowIcon(const QString& wndIcon)
{
windowIcon = wndIcon;
}
void QmitkExtWorkbenchWindowAdvisor::PostWindowCreate()
{
// very bad hack...
berry::IWorkbenchWindow::Pointer window = this->GetWindowConfigurer()->GetWindow();
QMainWindow* mainWindow = qobject_cast<QMainWindow*> (window->GetShell()->GetControl());
if (!windowIcon.isEmpty())
{
mainWindow->setWindowIcon(QIcon(windowIcon));
}
mainWindow->setContextMenuPolicy(Qt::PreventContextMenu);
// Load icon theme
QIcon::setThemeSearchPaths(QStringList() << QStringLiteral(":/org_mitk_icons/icons/"));
QIcon::setThemeName(QStringLiteral("awesome"));
// ==== Application menu ============================
QMenuBar* menuBar = mainWindow->menuBar();
menuBar->setContextMenuPolicy(Qt::PreventContextMenu);
#ifdef __APPLE__
menuBar->setNativeMenuBar(true);
#else
menuBar->setNativeMenuBar(false);
#endif
auto basePath = QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/actions/");
auto fileOpenAction = new QmitkFileOpenAction(berry::QtStyleManager::ThemeIcon(basePath + "document-open.svg"), window);
fileOpenAction->setShortcut(QKeySequence::Open);
auto fileSaveAction = new QmitkFileSaveAction(berry::QtStyleManager::ThemeIcon(basePath + "document-save.svg"), window);
fileSaveAction->setShortcut(QKeySequence::Save);
fileSaveProjectAction = new QmitkExtFileSaveProjectAction(window);
fileSaveProjectAction->setIcon(berry::QtStyleManager::ThemeIcon(basePath + "document-save.svg"));
closeProjectAction = new QmitkCloseProjectAction(window);
closeProjectAction->setIcon(berry::QtStyleManager::ThemeIcon(basePath + "edit-delete.svg"));
auto perspGroup = new QActionGroup(menuBar);
std::map<QString, berry::IViewDescriptor::Pointer> VDMap;
// sort elements (converting vector to map...)
QList<berry::IViewDescriptor::Pointer>::const_iterator iter;
berry::IViewRegistry* viewRegistry =
berry::PlatformUI::GetWorkbench()->GetViewRegistry();
const QList<berry::IViewDescriptor::Pointer> viewDescriptors = viewRegistry->GetViews();
bool skip = false;
for (iter = viewDescriptors.begin(); iter != viewDescriptors.end(); ++iter)
{
// if viewExcludeList is set, it contains the id-strings of view, which
// should not appear as an menu-entry in the menu
if (viewExcludeList.size() > 0)
{
for (int i=0; i<viewExcludeList.size(); i++)
{
if (viewExcludeList.at(i) == (*iter)->GetId())
{
skip = true;
break;
}
}
if (skip)
{
skip = false;
continue;
}
}
if ((*iter)->GetId() == "org.blueberry.ui.internal.introview")
continue;
if ((*iter)->GetId() == "org.mitk.views.imagenavigator")
continue;
if ((*iter)->GetId() == "org.mitk.views.viewnavigatorview")
continue;
std::pair<QString, berry::IViewDescriptor::Pointer> p((*iter)->GetLabel(), (*iter));
VDMap.insert(p);
}
std::map<QString, berry::IViewDescriptor::Pointer>::const_iterator MapIter;
for (MapIter = VDMap.begin(); MapIter != VDMap.end(); ++MapIter)
{
berry::QtShowViewAction* viewAction = new berry::QtShowViewAction(window, (*MapIter).second);
viewActions.push_back(viewAction);
}
if (!USE_EXPERIMENTAL_COMMAND_CONTRIBUTIONS)
{
QMenu* fileMenu = menuBar->addMenu("&File");
fileMenu->setObjectName("FileMenu");
fileMenu->addAction(fileOpenAction);
fileMenu->addAction(fileSaveAction);
fileMenu->addAction(fileSaveProjectAction);
fileMenu->addAction(closeProjectAction);
fileMenu->addSeparator();
QAction* fileExitAction = new QmitkFileExitAction(window);
fileExitAction->setIcon(berry::QtStyleManager::ThemeIcon(basePath + "system-log-out.svg"));
fileExitAction->setShortcut(QKeySequence::Quit);
fileExitAction->setObjectName("QmitkFileExitAction");
fileMenu->addAction(fileExitAction);
// another bad hack to get an edit/undo menu...
QMenu* editMenu = menuBar->addMenu("&Edit");
undoAction = editMenu->addAction(berry::QtStyleManager::ThemeIcon(basePath + "edit-undo.svg"),
"&Undo",
QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onUndo()),
QKeySequence("CTRL+Z"));
undoAction->setToolTip("Undo the last action (not supported by all modules)");
redoAction = editMenu->addAction(berry::QtStyleManager::ThemeIcon(basePath + "edit-redo.svg"),
"&Redo",
QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onRedo()),
QKeySequence("CTRL+Y"));
redoAction->setToolTip("execute the last action that was undone again (not supported by all modules)");
// ==== Window Menu ==========================
QMenu* windowMenu = menuBar->addMenu("Window");
if (showNewWindowMenuItem)
{
windowMenu->addAction("&New Window", QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onNewWindow()));
windowMenu->addSeparator();
}
QMenu* perspMenu = windowMenu->addMenu("&Open Perspective");
QMenu* viewMenu = nullptr;
if (showViewMenuItem)
{
viewMenu = windowMenu->addMenu("Show &View");
viewMenu->setObjectName("Show View");
}
windowMenu->addSeparator();
resetPerspAction = windowMenu->addAction("&Reset Perspective",
QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onResetPerspective()));
if(showClosePerspectiveMenuItem)
closePerspAction = windowMenu->addAction("&Close Perspective", QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onClosePerspective()));
windowMenu->addSeparator();
windowMenu->addAction("&Preferences...",
QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onEditPreferences()),
QKeySequence("CTRL+P"));
// fill perspective menu
berry::IPerspectiveRegistry* perspRegistry =
window->GetWorkbench()->GetPerspectiveRegistry();
QList<berry::IPerspectiveDescriptor::Pointer> perspectives(
perspRegistry->GetPerspectives());
skip = false;
for (QList<berry::IPerspectiveDescriptor::Pointer>::iterator perspIt =
perspectives.begin(); perspIt != perspectives.end(); ++perspIt)
{
// if perspectiveExcludeList is set, it contains the id-strings of perspectives, which
// should not appear as an menu-entry in the perspective menu
if (perspectiveExcludeList.size() > 0)
{
for (int i=0; i<perspectiveExcludeList.size(); i++)
{
if (perspectiveExcludeList.at(i) == (*perspIt)->GetId())
{
skip = true;
break;
}
}
if (skip)
{
skip = false;
continue;
}
}
QAction* perspAction = new berry::QtOpenPerspectiveAction(window, *perspIt, perspGroup);
mapPerspIdToAction.insert((*perspIt)->GetId(), perspAction);
}
perspMenu->addActions(perspGroup->actions());
if (showViewMenuItem)
{
- for (auto viewAction : viewActions)
+ for (auto viewAction : qAsConst(viewActions))
{
viewMenu->addAction(viewAction);
}
}
// ===== Help menu ====================================
QMenu* helpMenu = menuBar->addMenu("&Help");
helpMenu->addAction("&Welcome",this, SLOT(onIntro()));
helpMenu->addAction("&Open Help Perspective", this, SLOT(onHelpOpenHelpPerspective()));
helpMenu->addAction("&Context Help",this, SLOT(onHelp()), QKeySequence("F1"));
helpMenu->addAction("&About",this, SLOT(onAbout()));
// =====================================================
}
else
{
undoAction = new QmitkUndoAction(berry::QtStyleManager::ThemeIcon(basePath + "edit-undo.svg"), nullptr);
undoAction->setShortcut(QKeySequence::Undo);
redoAction = new QmitkRedoAction(berry::QtStyleManager::ThemeIcon(basePath + "edit-redo.svg"), nullptr);
redoAction->setShortcut(QKeySequence::Redo);
}
// toolbar for showing file open, undo, redo and other main actions
auto mainActionsToolBar = new QToolBar;
mainActionsToolBar->setObjectName("mainActionsToolBar");
mainActionsToolBar->setContextMenuPolicy(Qt::PreventContextMenu);
#ifdef __APPLE__
mainActionsToolBar->setToolButtonStyle ( Qt::ToolButtonTextUnderIcon );
#else
mainActionsToolBar->setToolButtonStyle ( Qt::ToolButtonTextBesideIcon );
#endif
basePath = QStringLiteral(":/org.mitk.gui.qt.ext/");
imageNavigatorAction = new QAction(berry::QtStyleManager::ThemeIcon(basePath + "image_navigator.svg"), "&Image Navigator", nullptr);
bool imageNavigatorViewFound = window->GetWorkbench()->GetViewRegistry()->Find("org.mitk.views.imagenavigator");
if (this->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.dicombrowser"))
{
openDicomEditorAction = new QmitkOpenDicomEditorAction(berry::QtStyleManager::ThemeIcon(basePath + "dicom.svg"), window);
}
if (this->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.stdmultiwidget"))
{
openStdMultiWidgetEditorAction = new QmitkOpenStdMultiWidgetEditorAction(QIcon(":/org.mitk.gui.qt.ext/Editor.png"), window);
}
if (this->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.mxnmultiwidget"))
{
openMxNMultiWidgetEditorAction = new QmitkOpenMxNMultiWidgetEditorAction(QIcon(":/org.mitk.gui.qt.ext/Editor.png"), window);
}
if (imageNavigatorViewFound)
{
QObject::connect(imageNavigatorAction, SIGNAL(triggered(bool)), QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onImageNavigator()));
imageNavigatorAction->setCheckable(true);
// add part listener for image navigator
imageNavigatorPartListener.reset(new PartListenerForImageNavigator(imageNavigatorAction));
window->GetPartService()->AddPartListener(imageNavigatorPartListener.data());
berry::IViewPart::Pointer imageNavigatorView = window->GetActivePage()->FindView("org.mitk.views.imagenavigator");
imageNavigatorAction->setChecked(false);
if (imageNavigatorView)
{
bool isImageNavigatorVisible = window->GetActivePage()->IsPartVisible(imageNavigatorView);
if (isImageNavigatorVisible)
imageNavigatorAction->setChecked(true);
}
imageNavigatorAction->setToolTip("Toggle image navigator for navigating through image");
}
viewNavigatorAction = new QAction(berry::QtStyleManager::ThemeIcon(QStringLiteral(":/org.mitk.gui.qt.ext/view-manager.svg")),"&View Navigator", nullptr);
viewNavigatorFound = window->GetWorkbench()->GetViewRegistry()->Find("org.mitk.views.viewnavigatorview");
if (viewNavigatorFound)
{
QObject::connect(viewNavigatorAction, SIGNAL(triggered(bool)), QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onViewNavigator()));
viewNavigatorAction->setCheckable(true);
// add part listener for view navigator
viewNavigatorPartListener.reset(new PartListenerForViewNavigator(viewNavigatorAction));
window->GetPartService()->AddPartListener(viewNavigatorPartListener.data());
berry::IViewPart::Pointer viewnavigatorview = window->GetActivePage()->FindView("org.mitk.views.viewnavigatorview");
viewNavigatorAction->setChecked(false);
if (viewnavigatorview)
{
bool isViewNavigatorVisible = window->GetActivePage()->IsPartVisible(viewnavigatorview);
if (isViewNavigatorVisible)
viewNavigatorAction->setChecked(true);
}
viewNavigatorAction->setToolTip("Toggle View Navigator");
}
mainActionsToolBar->addAction(fileOpenAction);
mainActionsToolBar->addAction(fileSaveProjectAction);
mainActionsToolBar->addAction(closeProjectAction);
mainActionsToolBar->addAction(undoAction);
mainActionsToolBar->addAction(redoAction);
if(this->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.dicombrowser"))
{
mainActionsToolBar->addAction(openDicomEditorAction);
}
if (this->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.stdmultiwidget"))
{
mainActionsToolBar->addAction(openStdMultiWidgetEditorAction);
}
if (this->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.mxnmultiwidget"))
{
mainActionsToolBar->addAction(openMxNMultiWidgetEditorAction);
}
if (imageNavigatorViewFound)
{
mainActionsToolBar->addAction(imageNavigatorAction);
}
if (viewNavigatorFound)
{
mainActionsToolBar->addAction(viewNavigatorAction);
}
mainWindow->addToolBar(mainActionsToolBar);
// ==== Perspective Toolbar ==================================
auto qPerspectiveToolbar = new QToolBar;
qPerspectiveToolbar->setObjectName("perspectiveToolBar");
if (showPerspectiveToolbar)
{
qPerspectiveToolbar->addActions(perspGroup->actions());
mainWindow->addToolBar(qPerspectiveToolbar);
}
else
delete qPerspectiveToolbar;
if (showViewToolbar)
{
auto prefService = berry::WorkbenchPlugin::GetDefault()->GetPreferencesService();
berry::IPreferences::Pointer stylePrefs = prefService->GetSystemPreferences()->Node(berry::QtPreferences::QT_STYLES_NODE);
bool showCategoryNames = stylePrefs->GetBool(berry::QtPreferences::QT_SHOW_TOOLBAR_CATEGORY_NAMES, true);
// Order view descriptors by category
QMultiMap<QString, berry::IViewDescriptor::Pointer> categoryViewDescriptorMap;
- for (auto labelViewDescriptorPair : VDMap)
+ for (const auto &labelViewDescriptorPair : VDMap)
{
auto viewDescriptor = labelViewDescriptorPair.second;
auto category = !viewDescriptor->GetCategoryPath().isEmpty()
? viewDescriptor->GetCategoryPath().back()
: QString();
categoryViewDescriptorMap.insert(category, viewDescriptor);
}
// Create a separate toolbar for each category
- for (auto category : categoryViewDescriptorMap.uniqueKeys())
+ for (const auto &category : categoryViewDescriptorMap.uniqueKeys())
{
auto viewDescriptorsInCurrentCategory = categoryViewDescriptorMap.values(category);
if (!viewDescriptorsInCurrentCategory.isEmpty())
{
auto toolbar = new QToolBar;
toolbar->setObjectName(category + " View Toolbar");
mainWindow->addToolBar(toolbar);
if (showCategoryNames && !category.isEmpty())
{
auto categoryButton = new QToolButton;
categoryButton->setToolButtonStyle(Qt::ToolButtonTextOnly);
categoryButton->setText(category);
categoryButton->setStyleSheet("background: transparent; margin: 0; padding: 0;");
toolbar->addWidget(categoryButton);
connect(categoryButton, &QToolButton::clicked, [toolbar]()
{
for (QWidget* widget : toolbar->findChildren<QWidget*>())
{
if (QStringLiteral("qt_toolbar_ext_button") == widget->objectName() && widget->isVisible())
{
QMouseEvent pressEvent(QEvent::MouseButtonPress, QPointF(0.0f, 0.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
QMouseEvent releaseEvent(QEvent::MouseButtonRelease, QPointF(0.0f, 0.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
QApplication::sendEvent(widget, &pressEvent);
QApplication::sendEvent(widget, &releaseEvent);
}
}
});
}
- for (auto viewDescriptor : viewDescriptorsInCurrentCategory)
+ for (const auto &viewDescriptor : qAsConst(viewDescriptorsInCurrentCategory))
{
auto viewAction = new berry::QtShowViewAction(window, viewDescriptor);
toolbar->addAction(viewAction);
}
}
}
}
QSettings settings(GetQSettingsFile(), QSettings::IniFormat);
mainWindow->restoreState(settings.value("ToolbarPosition").toByteArray());
auto qStatusBar = new QStatusBar();
//creating a QmitkStatusBar for Output on the QStatusBar and connecting it with the MainStatusBar
auto statusBar = new QmitkStatusBar(qStatusBar);
//disabling the SizeGrip in the lower right corner
statusBar->SetSizeGripEnabled(false);
auto progBar = new QmitkProgressBar();
qStatusBar->addPermanentWidget(progBar, 0);
progBar->hide();
// progBar->AddStepsToDo(2);
// progBar->Progress(1);
mainWindow->setStatusBar(qStatusBar);
if (showMemoryIndicator)
{
auto memoryIndicator = new QmitkMemoryUsageIndicatorView();
qStatusBar->addPermanentWidget(memoryIndicator, 0);
}
}
void QmitkExtWorkbenchWindowAdvisor::PreWindowOpen()
{
berry::IWorkbenchWindowConfigurer::Pointer configurer = GetWindowConfigurer();
// show the shortcut bar and progress indicator, which are hidden by
// default
//configurer->SetShowPerspectiveBar(true);
//configurer->SetShowFastViewBars(true);
//configurer->SetShowProgressIndicator(true);
// // add the drag and drop support for the editor area
// configurer.addEditorAreaTransfer(EditorInputTransfer.getInstance());
// configurer.addEditorAreaTransfer(ResourceTransfer.getInstance());
// configurer.addEditorAreaTransfer(FileTransfer.getInstance());
// configurer.addEditorAreaTransfer(MarkerTransfer.getInstance());
// configurer.configureEditorAreaDropListener(new EditorAreaDropAdapter(
// configurer.getWindow()));
this->HookTitleUpdateListeners(configurer);
menuPerspectiveListener.reset(new PerspectiveListenerForMenu(this));
configurer->GetWindow()->AddPerspectiveListener(menuPerspectiveListener.data());
configurer->AddEditorAreaTransfer(QStringList("text/uri-list"));
configurer->ConfigureEditorAreaDropListener(dropTargetListener.data());
}
void QmitkExtWorkbenchWindowAdvisor::PostWindowOpen()
{
berry::WorkbenchWindowAdvisor::PostWindowOpen();
// Force Rendering Window Creation on startup.
berry::IWorkbenchWindowConfigurer::Pointer configurer = GetWindowConfigurer();
ctkPluginContext* context = QmitkCommonExtPlugin::getContext();
ctkServiceReference serviceRef = context->getServiceReference<mitk::IDataStorageService>();
if (serviceRef)
{
mitk::IDataStorageService *dsService = context->getService<mitk::IDataStorageService>(serviceRef);
if (dsService)
{
mitk::IDataStorageReference::Pointer dsRef = dsService->GetDataStorage();
mitk::DataStorageEditorInput::Pointer dsInput(new mitk::DataStorageEditorInput(dsRef));
mitk::WorkbenchUtil::OpenEditor(configurer->GetWindow()->GetActivePage(),dsInput);
}
}
auto introPart = configurer->GetWindow()->GetWorkbench()->GetIntroManager()->GetIntro();
if (introPart.IsNotNull())
{
configurer->GetWindow()->GetWorkbench()->GetIntroManager()->ShowIntro(GetWindowConfigurer()->GetWindow(), false);
}
}
void QmitkExtWorkbenchWindowAdvisor::onIntro()
{
QmitkExtWorkbenchWindowAdvisorHack::undohack->onIntro();
}
void QmitkExtWorkbenchWindowAdvisor::onHelp()
{
QmitkExtWorkbenchWindowAdvisorHack::undohack->onHelp();
}
void QmitkExtWorkbenchWindowAdvisor::onHelpOpenHelpPerspective()
{
QmitkExtWorkbenchWindowAdvisorHack::undohack->onHelpOpenHelpPerspective();
}
void QmitkExtWorkbenchWindowAdvisor::onAbout()
{
QmitkExtWorkbenchWindowAdvisorHack::undohack->onAbout();
}
//--------------------------------------------------------------------------------
// Ugly hack from here on. Feel free to delete when command framework
// and undo buttons are done.
//--------------------------------------------------------------------------------
QmitkExtWorkbenchWindowAdvisorHack::QmitkExtWorkbenchWindowAdvisorHack()
: QObject()
{
}
QmitkExtWorkbenchWindowAdvisorHack::~QmitkExtWorkbenchWindowAdvisorHack()
{
}
void QmitkExtWorkbenchWindowAdvisorHack::onUndo()
{
mitk::UndoModel* model = mitk::UndoController::GetCurrentUndoModel();
if (model)
{
if (mitk::VerboseLimitedLinearUndo* verboseundo = dynamic_cast<mitk::VerboseLimitedLinearUndo*>( model ))
{
mitk::VerboseLimitedLinearUndo::StackDescription descriptions = verboseundo->GetUndoDescriptions();
if (descriptions.size() >= 1)
{
MITK_INFO << "Undo " << descriptions.front().second;
}
}
model->Undo();
}
else
{
MITK_ERROR << "No undo model instantiated";
}
}
void QmitkExtWorkbenchWindowAdvisorHack::onRedo()
{
mitk::UndoModel* model = mitk::UndoController::GetCurrentUndoModel();
if (model)
{
if (mitk::VerboseLimitedLinearUndo* verboseundo = dynamic_cast<mitk::VerboseLimitedLinearUndo*>( model ))
{
mitk::VerboseLimitedLinearUndo::StackDescription descriptions = verboseundo->GetRedoDescriptions();
if (descriptions.size() >= 1)
{
MITK_INFO << "Redo " << descriptions.front().second;
}
}
model->Redo();
}
else
{
MITK_ERROR << "No undo model instantiated";
}
}
// safe calls to the complete chain
// berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->FindView("org.mitk.views.imagenavigator");
// to cover for all possible cases of closed pages etc.
static void SafeHandleNavigatorView(QString view_query_name)
{
berry::IWorkbench* wbench = berry::PlatformUI::GetWorkbench();
if( wbench == nullptr )
return;
berry::IWorkbenchWindow::Pointer wbench_window = wbench->GetActiveWorkbenchWindow();
if( wbench_window.IsNull() )
return;
berry::IWorkbenchPage::Pointer wbench_page = wbench_window->GetActivePage();
if( wbench_page.IsNull() )
return;
auto wbench_view = wbench_page->FindView( view_query_name );
if( wbench_view.IsNotNull() )
{
bool isViewVisible = wbench_page->IsPartVisible( wbench_view );
if( isViewVisible )
{
wbench_page->HideView( wbench_view );
return;
}
}
wbench_page->ShowView( view_query_name );
}
void QmitkExtWorkbenchWindowAdvisorHack::onImageNavigator()
{
// show/hide ImageNavigatorView
SafeHandleNavigatorView("org.mitk.views.imagenavigator");
}
void QmitkExtWorkbenchWindowAdvisorHack::onViewNavigator()
{
// show/hide viewnavigatorView
SafeHandleNavigatorView("org.mitk.views.viewnavigatorview");
}
void QmitkExtWorkbenchWindowAdvisorHack::onEditPreferences()
{
QmitkPreferencesDialog _PreferencesDialog(QApplication::activeWindow());
_PreferencesDialog.exec();
}
void QmitkExtWorkbenchWindowAdvisorHack::onQuit()
{
berry::PlatformUI::GetWorkbench()->Close();
}
void QmitkExtWorkbenchWindowAdvisorHack::onResetPerspective()
{
berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->ResetPerspective();
}
void QmitkExtWorkbenchWindowAdvisorHack::onClosePerspective()
{
berry::IWorkbenchPage::Pointer page =
berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage();
page->ClosePerspective(page->GetPerspective(), true, true);
}
void QmitkExtWorkbenchWindowAdvisorHack::onNewWindow()
{
berry::PlatformUI::GetWorkbench()->OpenWorkbenchWindow(nullptr);
}
void QmitkExtWorkbenchWindowAdvisorHack::onIntro()
{
bool hasIntro =
berry::PlatformUI::GetWorkbench()->GetIntroManager()->HasIntro();
if (!hasIntro)
{
QRegExp reg("(.*)<title>(\\n)*");
QRegExp reg2("(\\n)*</title>(.*)");
QFile file(":/org.mitk.gui.qt.ext/index.html");
file.open(QIODevice::ReadOnly | QIODevice::Text); //text file only for reading
QString text = QString(file.readAll());
file.close();
QString title = text;
title.replace(reg, "");
title.replace(reg2, "");
std::cout << title.toStdString() << std::endl;
QMessageBox::information(nullptr, title,
text, "Close");
}
else
{
berry::PlatformUI::GetWorkbench()->GetIntroManager()->ShowIntro(
berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow(), false);
}
}
void QmitkExtWorkbenchWindowAdvisorHack::onHelp()
{
ctkPluginContext* context = QmitkCommonExtPlugin::getContext();
if (context == nullptr)
{
MITK_WARN << "Plugin context not set, unable to open context help";
return;
}
// Check if the org.blueberry.ui.qt.help plug-in is installed and started
QList<QSharedPointer<ctkPlugin> > plugins = context->getPlugins();
foreach(QSharedPointer<ctkPlugin> p, plugins)
{
if (p->getSymbolicName() == "org.blueberry.ui.qt.help")
{
if (p->getState() != ctkPlugin::ACTIVE)
{
// try to activate the plug-in explicitly
try
{
p->start(ctkPlugin::START_TRANSIENT);
}
catch (const ctkPluginException& pe)
{
MITK_ERROR << "Activating org.blueberry.ui.qt.help failed: " << pe.what();
return;
}
}
}
}
ctkServiceReference eventAdminRef = context->getServiceReference<ctkEventAdmin>();
ctkEventAdmin* eventAdmin = nullptr;
if (eventAdminRef)
{
eventAdmin = context->getService<ctkEventAdmin>(eventAdminRef);
}
if (eventAdmin == nullptr)
{
MITK_WARN << "ctkEventAdmin service not found. Unable to open context help";
}
else
{
ctkEvent ev("org/blueberry/ui/help/CONTEXTHELP_REQUESTED");
eventAdmin->postEvent(ev);
}
}
void QmitkExtWorkbenchWindowAdvisorHack::onHelpOpenHelpPerspective()
{
berry::PlatformUI::GetWorkbench()->ShowPerspective("org.blueberry.perspectives.help",
berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow());
}
void QmitkExtWorkbenchWindowAdvisorHack::onAbout()
{
auto aboutDialog = new QmitkAboutDialog(QApplication::activeWindow(),nullptr);
aboutDialog->open();
}
void QmitkExtWorkbenchWindowAdvisor::HookTitleUpdateListeners(berry::IWorkbenchWindowConfigurer::Pointer configurer)
{
// hook up the listeners to update the window title
titlePartListener.reset(new PartListenerForTitle(this));
titlePerspectiveListener.reset(new PerspectiveListenerForTitle(this));
editorPropertyListener.reset(new berry::PropertyChangeIntAdapter<
QmitkExtWorkbenchWindowAdvisor>(this,
&QmitkExtWorkbenchWindowAdvisor::PropertyChange));
// configurer.getWindow().addPageListener(new IPageListener() {
// public void pageActivated(IWorkbenchPage page) {
// updateTitle(false);
// }
//
// public void pageClosed(IWorkbenchPage page) {
// updateTitle(false);
// }
//
// public void pageOpened(IWorkbenchPage page) {
// // do nothing
// }
// });
configurer->GetWindow()->AddPerspectiveListener(titlePerspectiveListener.data());
configurer->GetWindow()->GetPartService()->AddPartListener(titlePartListener.data());
}
QString QmitkExtWorkbenchWindowAdvisor::ComputeTitle()
{
berry::IWorkbenchWindowConfigurer::Pointer configurer = GetWindowConfigurer();
berry::IWorkbenchPage::Pointer currentPage = configurer->GetWindow()->GetActivePage();
berry::IEditorPart::Pointer activeEditor;
if (currentPage)
{
activeEditor = lastActiveEditor.Lock();
}
QString title;
berry::IProduct::Pointer product = berry::Platform::GetProduct();
if (product.IsNotNull())
{
title = product->GetName();
}
if (title.isEmpty())
{
// instead of the product name, we use a custom variable for now
title = productName;
}
if(showMitkVersionInfo)
{
QString mitkVersionInfo = MITK_REVISION_DESC;
if(mitkVersionInfo.isEmpty())
mitkVersionInfo = MITK_VERSION_STRING;
title += " " + mitkVersionInfo;
}
if (showVersionInfo)
{
// add version informatioin
QString versions = QString(" (ITK %1.%2.%3 | VTK %4.%5.%6 | Qt %7)")
.arg(ITK_VERSION_MAJOR).arg(ITK_VERSION_MINOR).arg(ITK_VERSION_PATCH)
.arg(VTK_MAJOR_VERSION).arg(VTK_MINOR_VERSION).arg(VTK_BUILD_VERSION)
.arg(QT_VERSION_STR);
title += versions;
}
if (currentPage)
{
if (activeEditor)
{
lastEditorTitle = activeEditor->GetTitleToolTip();
if (!lastEditorTitle.isEmpty())
title = lastEditorTitle + " - " + title;
}
berry::IPerspectiveDescriptor::Pointer persp = currentPage->GetPerspective();
QString label = "";
if (persp)
{
label = persp->GetLabel();
}
berry::IAdaptable* input = currentPage->GetInput();
if (input && input != wbAdvisor->GetDefaultPageInput())
{
label = currentPage->GetLabel();
}
if (!label.isEmpty())
{
title = label + " - " + title;
}
}
title += " (Not for use in diagnosis or treatment of patients)";
return title;
}
void QmitkExtWorkbenchWindowAdvisor::RecomputeTitle()
{
berry::IWorkbenchWindowConfigurer::Pointer configurer = GetWindowConfigurer();
QString oldTitle = configurer->GetTitle();
QString newTitle = ComputeTitle();
if (newTitle != oldTitle)
{
configurer->SetTitle(newTitle);
}
}
void QmitkExtWorkbenchWindowAdvisor::UpdateTitle(bool editorHidden)
{
berry::IWorkbenchWindowConfigurer::Pointer configurer = GetWindowConfigurer();
berry::IWorkbenchWindow::Pointer window = configurer->GetWindow();
berry::IEditorPart::Pointer activeEditor;
berry::IWorkbenchPage::Pointer currentPage = window->GetActivePage();
berry::IPerspectiveDescriptor::Pointer persp;
berry::IAdaptable* input = nullptr;
if (currentPage)
{
activeEditor = currentPage->GetActiveEditor();
persp = currentPage->GetPerspective();
input = currentPage->GetInput();
}
if (editorHidden)
{
activeEditor = nullptr;
}
// Nothing to do if the editor hasn't changed
if (activeEditor == lastActiveEditor.Lock() && currentPage == lastActivePage.Lock()
&& persp == lastPerspective.Lock() && input == lastInput)
{
return;
}
if (!lastActiveEditor.Expired())
{
lastActiveEditor.Lock()->RemovePropertyListener(editorPropertyListener.data());
}
lastActiveEditor = activeEditor;
lastActivePage = currentPage;
lastPerspective = persp;
lastInput = input;
if (activeEditor)
{
activeEditor->AddPropertyListener(editorPropertyListener.data());
}
RecomputeTitle();
}
void QmitkExtWorkbenchWindowAdvisor::PropertyChange(const berry::Object::Pointer& /*source*/, int propId)
{
if (propId == berry::IWorkbenchPartConstants::PROP_TITLE)
{
if (!lastActiveEditor.Expired())
{
QString newTitle = lastActiveEditor.Lock()->GetPartName();
if (lastEditorTitle != newTitle)
{
RecomputeTitle();
}
}
}
}
void QmitkExtWorkbenchWindowAdvisor::SetPerspectiveExcludeList(const QList<QString>& v)
{
this->perspectiveExcludeList = v;
}
QList<QString> QmitkExtWorkbenchWindowAdvisor::GetPerspectiveExcludeList()
{
return this->perspectiveExcludeList;
}
void QmitkExtWorkbenchWindowAdvisor::SetViewExcludeList(const QList<QString>& v)
{
this->viewExcludeList = v;
}
QList<QString> QmitkExtWorkbenchWindowAdvisor::GetViewExcludeList()
{
return this->viewExcludeList;
}
void QmitkExtWorkbenchWindowAdvisor::PostWindowClose()
{
berry::IWorkbenchWindow::Pointer window = this->GetWindowConfigurer()->GetWindow();
QMainWindow* mainWindow = static_cast<QMainWindow*> (window->GetShell()->GetControl());
QSettings settings(GetQSettingsFile(), QSettings::IniFormat);
settings.setValue("ToolbarPosition", mainWindow->saveState());
}
QString QmitkExtWorkbenchWindowAdvisor::GetQSettingsFile() const
{
QFileInfo settingsInfo = QmitkCommonExtPlugin::getContext()->getDataFile(QT_SETTINGS_FILENAME);
return settingsInfo.canonicalFilePath();
}
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCtUsRegistration.cpp b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCtUsRegistration.cpp
index 456093d420..16b5a9a3b8 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCtUsRegistration.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCtUsRegistration.cpp
@@ -1,2014 +1,2014 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkUSNavigationStepCtUsRegistration.h"
#include "ui_QmitkUSNavigationStepCtUsRegistration.h"
#include <QMessageBox>
#include "mitkNodeDisplacementFilter.h"
#include "../Filter/mitkFloatingImageToUltrasoundRegistrationFilter.h"
#include "../QmitkUSNavigationMarkerPlacement.h"
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.h>
#include <mitkLabelSetImage.h>
#include "mitkProperties.h"
#include <mitkImage.h>
#include <mitkImageCast.h>
#include <mitkRenderingManager.h>
#include <mitkStaticIGTHelperFunctions.h>
#include <vtkLandmarkTransform.h>
#include <vtkPoints.h>
#include <itkImageRegionIterator.h>
#include <itkGeometryUtilities.h>
#include <mitkImagePixelReadAccessor.h>
#include <itkZeroCrossingImageFilter.h>
#include <itkSimpleContourExtractorImageFilter.h>
#include <itkCannyEdgeDetectionImageFilter.h>
static const int NUMBER_FIDUCIALS_NEEDED = 8;
QmitkUSNavigationStepCtUsRegistration::QmitkUSNavigationStepCtUsRegistration(QWidget *parent) :
QmitkUSAbstractNavigationStep(parent),
ui(new Ui::QmitkUSNavigationStepCtUsRegistration),
m_PerformingGroundTruthProtocolEvaluation(false),
m_FloatingImageToUltrasoundRegistrationFilter(nullptr),
m_FreezeCombinedModality(false)
{
this->UnsetFloatingImageGeometry();
this->DefineDataStorageImageFilter();
this->CreateQtPartControl(this);
}
QmitkUSNavigationStepCtUsRegistration::~QmitkUSNavigationStepCtUsRegistration()
{
delete ui;
}
bool QmitkUSNavigationStepCtUsRegistration::OnStartStep()
{
MITK_INFO << "OnStartStep()";
return true;
}
bool QmitkUSNavigationStepCtUsRegistration::OnStopStep()
{
MITK_INFO << "OnStopStep()";
return true;
}
bool QmitkUSNavigationStepCtUsRegistration::OnFinishStep()
{
MITK_INFO << "OnFinishStep()";
return true;
}
bool QmitkUSNavigationStepCtUsRegistration::OnActivateStep()
{
MITK_INFO << "OnActivateStep()";
ui->floatingImageComboBox->SetDataStorage(this->GetDataStorage());
ui->ctImagesToChooseComboBox->SetDataStorage(this->GetDataStorage());
ui->segmentationComboBox->SetDataStorage(this->GetDataStorage());
ui->selectedSurfaceComboBox->SetDataStorage(this->GetDataStorage());
ui->pointSetComboBox->SetDataStorage(this->GetDataStorage());
m_FloatingImageToUltrasoundRegistrationFilter =
mitk::FloatingImageToUltrasoundRegistrationFilter::New();
return true;
}
bool QmitkUSNavigationStepCtUsRegistration::OnDeactivateStep()
{
MITK_INFO << "OnDeactivateStep()";
return true;
}
void QmitkUSNavigationStepCtUsRegistration::OnUpdate()
{
if (m_NavigationDataSource.IsNull()) { return; }
m_NavigationDataSource->Update();
m_FloatingImageToUltrasoundRegistrationFilter->Update();
}
void QmitkUSNavigationStepCtUsRegistration::OnSettingsChanged(const itk::SmartPointer<mitk::DataNode> settingsNode)
{
Q_UNUSED(settingsNode);
}
QString QmitkUSNavigationStepCtUsRegistration::GetTitle()
{
return "CT-to-US registration";
}
QmitkUSAbstractNavigationStep::FilterVector QmitkUSNavigationStepCtUsRegistration::GetFilter()
{
return FilterVector();
}
void QmitkUSNavigationStepCtUsRegistration::OnSetCombinedModality()
{
mitk::AbstractUltrasoundTrackerDevice::Pointer combinedModality = this->GetCombinedModality(false);
if (combinedModality.IsNotNull())
{
m_NavigationDataSource = combinedModality->GetNavigationDataSource();
}
}
void QmitkUSNavigationStepCtUsRegistration::UnsetFloatingImageGeometry()
{
m_ImageDimension[0] = 0;
m_ImageDimension[1] = 0;
m_ImageDimension[2] = 0;
m_ImageSpacing[0] = 1;
m_ImageSpacing[1] = 1;
m_ImageSpacing[2] = 1;
}
void QmitkUSNavigationStepCtUsRegistration::SetFloatingImageGeometryInformation(mitk::Image * image)
{
m_ImageDimension[0] = image->GetDimension(0);
m_ImageDimension[1] = image->GetDimension(1);
m_ImageDimension[2] = image->GetDimension(2);
m_ImageSpacing[0] = image->GetGeometry()->GetSpacing()[0];
m_ImageSpacing[1] = image->GetGeometry()->GetSpacing()[1];
m_ImageSpacing[2] = image->GetGeometry()->GetSpacing()[2];
}
double QmitkUSNavigationStepCtUsRegistration::GetVoxelVolume()
{
if (m_FloatingImage.IsNull())
{
return 0.0;
}
MITK_INFO << "ImageSpacing = " << m_ImageSpacing;
return m_ImageSpacing[0] * m_ImageSpacing[1] * m_ImageSpacing[2];
}
double QmitkUSNavigationStepCtUsRegistration::GetFiducialVolume(double radius)
{
return 1.333333333 * 3.141592 * (radius * radius * radius);
}
bool QmitkUSNavigationStepCtUsRegistration::FilterFloatingImage()
{
if (m_FloatingImage.IsNull())
{
return false;
}
ImageType::Pointer itkImage1 = ImageType::New();
mitk::CastToItkImage(m_FloatingImage, itkImage1);
this->InitializeImageFilters();
m_ThresholdFilter->SetInput(itkImage1);
m_LaplacianFilter1->SetInput(m_ThresholdFilter->GetOutput());
m_LaplacianFilter2->SetInput(m_LaplacianFilter1->GetOutput());
m_BinaryThresholdFilter->SetInput(m_LaplacianFilter2->GetOutput());
m_HoleFillingFilter->SetInput(m_BinaryThresholdFilter->GetOutput());
m_BinaryImageToShapeLabelMapFilter->SetInput(m_HoleFillingFilter->GetOutput());
m_BinaryImageToShapeLabelMapFilter->Update();
ImageType::Pointer binaryImage = ImageType::New();
binaryImage = m_HoleFillingFilter->GetOutput();
this->EliminateTooSmallLabeledObjects(binaryImage);
//mitk::CastToMitkImage(binaryImage, m_FloatingImage);
return true;
}
void QmitkUSNavigationStepCtUsRegistration::InitializeImageFilters()
{
//Initialize threshold filters
m_ThresholdFilter = itk::ThresholdImageFilter<ImageType>::New();
m_ThresholdFilter->SetOutsideValue(0);
m_ThresholdFilter->SetLower(500);
m_ThresholdFilter->SetUpper(3200);
//Initialize binary threshold filter 1
m_BinaryThresholdFilter = BinaryThresholdImageFilterType::New();
m_BinaryThresholdFilter->SetOutsideValue(0);
m_BinaryThresholdFilter->SetInsideValue(1);
m_BinaryThresholdFilter->SetLowerThreshold(350);
m_BinaryThresholdFilter->SetUpperThreshold(10000);
//Initialize laplacian recursive gaussian image filter
m_LaplacianFilter1 = LaplacianRecursiveGaussianImageFilterType::New();
m_LaplacianFilter2 = LaplacianRecursiveGaussianImageFilterType::New();
//Initialize binary hole filling filter
m_HoleFillingFilter = VotingBinaryIterativeHoleFillingImageFilterType::New();
VotingBinaryIterativeHoleFillingImageFilterType::InputSizeType radius;
radius.Fill(1);
m_HoleFillingFilter->SetRadius(radius);
m_HoleFillingFilter->SetBackgroundValue(0);
m_HoleFillingFilter->SetForegroundValue(1);
m_HoleFillingFilter->SetMaximumNumberOfIterations(5);
//Initialize binary image to shape label map filter
m_BinaryImageToShapeLabelMapFilter = BinaryImageToShapeLabelMapFilterType::New();
m_BinaryImageToShapeLabelMapFilter->SetInputForegroundValue(1);
}
double QmitkUSNavigationStepCtUsRegistration::GetCharacteristicDistanceAWithUpperMargin()
{
switch (ui->fiducialMarkerConfigurationComboBox->currentIndex())
{
// case 0 is equal to fiducial marker configuration A (10mm distance)
case 0:
return 12.07;
// case 1 is equal to fiducial marker configuration B (15mm distance)
case 1:
return 18.105;
// case 2 is equal to fiducial marker configuration C (20mm distance)
case 2:
return 24.14;
}
return 0.0;
}
double QmitkUSNavigationStepCtUsRegistration::GetCharacteristicDistanceBWithLowerMargin()
{
switch (ui->fiducialMarkerConfigurationComboBox->currentIndex())
{
// case 0 is equal to fiducial marker configuration A (10mm distance)
case 0:
return 12.07;
// case 1 is equal to fiducial marker configuration B (15mm distance)
case 1:
return 18.105;
// case 2 is equal to fiducial marker configuration C (20mm distance)
case 2:
return 24.14;
}
return 0.0;
}
double QmitkUSNavigationStepCtUsRegistration::GetCharacteristicDistanceBWithUpperMargin()
{
switch (ui->fiducialMarkerConfigurationComboBox->currentIndex())
{
// case 0 is equal to fiducial marker configuration A (10mm distance)
case 0:
return 15.73;
// case 1 is equal to fiducial marker configuration B (15mm distance)
case 1:
return 23.595;
// case 2 is equal to fiducial marker configuration C (20mm distance)
case 2:
return 31.46;
}
return 0.0;
}
double QmitkUSNavigationStepCtUsRegistration::GetMinimalFiducialConfigurationDistance()
{
switch (ui->fiducialMarkerConfigurationComboBox->currentIndex())
{
// case 0 is equal to fiducial marker configuration A (10mm distance)
case 0:
return 10.0;
// case 1 is equal to fiducial marker configuration B (15mm distance)
case 1:
return 15.0;
// case 2 is equal to fiducial marker configuration C (20mm distance)
case 2:
return 20.0;
}
return 0.0;
}
void QmitkUSNavigationStepCtUsRegistration::CreateMarkerModelCoordinateSystemPointSet()
{
if (m_MarkerModelCoordinateSystemPointSet.IsNull())
{
m_MarkerModelCoordinateSystemPointSet = mitk::PointSet::New();
}
else
{
m_MarkerModelCoordinateSystemPointSet->Clear();
}
mitk::Point3D fiducial1;
mitk::Point3D fiducial2;
mitk::Point3D fiducial3;
mitk::Point3D fiducial4;
mitk::Point3D fiducial5;
mitk::Point3D fiducial6;
mitk::Point3D fiducial7;
mitk::Point3D fiducial8;
switch (ui->fiducialMarkerConfigurationComboBox->currentIndex())
{
// case 0 is equal to fiducial marker configuration A (10mm distance)
case 0:
fiducial1[0] = 0;
fiducial1[1] = 0;
fiducial1[2] = 0;
fiducial2[0] = 0;
fiducial2[1] = 10;
fiducial2[2] = 0;
fiducial3[0] = 10;
fiducial3[1] = 0;
fiducial3[2] = 0;
fiducial4[0] = 20;
fiducial4[1] = 20;
fiducial4[2] = 0;
fiducial5[0] = 0;
fiducial5[1] = 20;
fiducial5[2] = 10;
fiducial6[0] = 10;
fiducial6[1] = 20;
fiducial6[2] = 10;
fiducial7[0] = 20;
fiducial7[1] = 10;
fiducial7[2] = 10;
fiducial8[0] = 20;
fiducial8[1] = 0;
fiducial8[2] = 10;
break;
// case 1 is equal to fiducial marker configuration B (15mm distance)
case 1:
fiducial1[0] = 0;
fiducial1[1] = 0;
fiducial1[2] = 0;
fiducial2[0] = 0;
fiducial2[1] = 15;
fiducial2[2] = 0;
fiducial3[0] = 15;
fiducial3[1] = 0;
fiducial3[2] = 0;
fiducial4[0] = 30;
fiducial4[1] = 30;
fiducial4[2] = 0;
fiducial5[0] = 0;
fiducial5[1] = 30;
fiducial5[2] = 15;
fiducial6[0] = 15;
fiducial6[1] = 30;
fiducial6[2] = 15;
fiducial7[0] = 30;
fiducial7[1] = 15;
fiducial7[2] = 15;
fiducial8[0] = 30;
fiducial8[1] = 0;
fiducial8[2] = 15;
break;
// case 2 is equal to fiducial marker configuration C (20mm distance)
case 2:
fiducial1[0] = 0;
fiducial1[1] = 0;
fiducial1[2] = 0;
fiducial2[0] = 0;
fiducial2[1] = 20;
fiducial2[2] = 0;
fiducial3[0] = 20;
fiducial3[1] = 0;
fiducial3[2] = 0;
fiducial4[0] = 40;
fiducial4[1] = 40;
fiducial4[2] = 0;
fiducial5[0] = 0;
fiducial5[1] = 40;
fiducial5[2] = 20;
fiducial6[0] = 20;
fiducial6[1] = 40;
fiducial6[2] = 20;
fiducial7[0] = 40;
fiducial7[1] = 20;
fiducial7[2] = 20;
fiducial8[0] = 40;
fiducial8[1] = 0;
fiducial8[2] = 20;
break;
}
m_MarkerModelCoordinateSystemPointSet->InsertPoint(0, fiducial1);
m_MarkerModelCoordinateSystemPointSet->InsertPoint(1, fiducial2);
m_MarkerModelCoordinateSystemPointSet->InsertPoint(2, fiducial3);
m_MarkerModelCoordinateSystemPointSet->InsertPoint(3, fiducial4);
m_MarkerModelCoordinateSystemPointSet->InsertPoint(4, fiducial5);
m_MarkerModelCoordinateSystemPointSet->InsertPoint(5, fiducial6);
m_MarkerModelCoordinateSystemPointSet->InsertPoint(6, fiducial7);
m_MarkerModelCoordinateSystemPointSet->InsertPoint(7, fiducial8);
/*mitk::DataNode::Pointer node = this->GetDataStorage()->GetNamedNode("Marker Model Coordinate System Point Set");
if (node == nullptr)
{
node = mitk::DataNode::New();
node->SetName("Marker Model Coordinate System Point Set");
node->SetData(m_MarkerModelCoordinateSystemPointSet);
this->GetDataStorage()->Add(node);
}
else
{
node->SetData(m_MarkerModelCoordinateSystemPointSet);
this->GetDataStorage()->Modified();
}*/
}
void QmitkUSNavigationStepCtUsRegistration::InitializePointsToTransformForGroundTruthProtocol()
{
m_PointsToTransformGroundTruthProtocol.clear();
mitk::Point3D point0mm;
mitk::Point3D point20mm;
mitk::Point3D point40mm;
mitk::Point3D point60mm;
mitk::Point3D point80mm;
mitk::Point3D point100mm;
point0mm[0] = 0.0;
point0mm[1] = 0.0;
point0mm[2] = 0.0;
point20mm[0] = 0.0;
point20mm[1] = 0.0;
point20mm[2] = 0.0;
point40mm[0] = 0.0;
point40mm[1] = 0.0;
point40mm[2] = 0.0;
point60mm[0] = 0.0;
point60mm[1] = 0.0;
point60mm[2] = 0.0;
point80mm[0] = 0.0;
point80mm[1] = 0.0;
point80mm[2] = 0.0;
point100mm[0] = 0.0;
point100mm[1] = 0.0;
point100mm[2] = 0.0;
m_PointsToTransformGroundTruthProtocol.insert(std::pair<int, mitk::Point3D>(0, point0mm));
m_PointsToTransformGroundTruthProtocol.insert(std::pair<int, mitk::Point3D>(20, point20mm));
m_PointsToTransformGroundTruthProtocol.insert(std::pair<int, mitk::Point3D>(40, point40mm));
m_PointsToTransformGroundTruthProtocol.insert(std::pair<int, mitk::Point3D>(60, point60mm));
m_PointsToTransformGroundTruthProtocol.insert(std::pair<int, mitk::Point3D>(80, point80mm));
m_PointsToTransformGroundTruthProtocol.insert(std::pair<int, mitk::Point3D>(100, point100mm));
}
void QmitkUSNavigationStepCtUsRegistration::CreatePointsToTransformForGroundTruthProtocol()
{
this->InitializePointsToTransformForGroundTruthProtocol();
switch (ui->fiducialMarkerConfigurationComboBox->currentIndex())
{
// case 0 is equal to fiducial marker configuration A (10mm distance)
case 0:
MITK_WARN << "For this marker configuration (10mm) there does not exist a point to transform.";
break;
// case 1 is equal to fiducial marker configuration B (15mm distance)
case 1:
m_PointsToTransformGroundTruthProtocol.at(0)[0] = 130; // = 30mm to end of clipping plate + 100 mm to middle axis of measurement plate
m_PointsToTransformGroundTruthProtocol.at(0)[1] = 15;
m_PointsToTransformGroundTruthProtocol.at(0)[2] = -7; // = 5mm distance to clipping plate + 2mm to base
m_PointsToTransformGroundTruthProtocol.at(20)[0] = 130;
m_PointsToTransformGroundTruthProtocol.at(20)[1] = 15;
m_PointsToTransformGroundTruthProtocol.at(20)[2] = -27; // = 5mm distance to clipping plate + 2mm to base + 20mm depth
m_PointsToTransformGroundTruthProtocol.at(40)[0] = 130;
m_PointsToTransformGroundTruthProtocol.at(40)[1] = 15;
m_PointsToTransformGroundTruthProtocol.at(40)[2] = -47; // = 5mm distance to clipping plate + 2mm to base + 40mm depth
m_PointsToTransformGroundTruthProtocol.at(60)[0] = 130;
m_PointsToTransformGroundTruthProtocol.at(60)[1] = 15;
m_PointsToTransformGroundTruthProtocol.at(60)[2] = -67; // = 5mm distance to clipping plate + 2mm to base + 60mm depth
m_PointsToTransformGroundTruthProtocol.at(80)[0] = 130;
m_PointsToTransformGroundTruthProtocol.at(80)[1] = 15;
m_PointsToTransformGroundTruthProtocol.at(80)[2] = -87; // = 5mm distance to clipping plate + 2mm to base + 80mm depth
m_PointsToTransformGroundTruthProtocol.at(100)[0] = 130;
m_PointsToTransformGroundTruthProtocol.at(100)[1] = 15;
m_PointsToTransformGroundTruthProtocol.at(100)[2] = -107; // = 5mm distance to clipping plate + 2mm to base + 100mm depth
break;
// case 2 is equal to fiducial marker configuration C (20mm distance)
case 2:
m_PointsToTransformGroundTruthProtocol.at(0)[0] = 135; // = 20 + 15mm to end of clipping plate + 100 mm to middle axis of measurement plate
m_PointsToTransformGroundTruthProtocol.at(0)[1] = 20;
m_PointsToTransformGroundTruthProtocol.at(0)[2] = -9; // = 7mm distance to clipping plate + 2mm to base
m_PointsToTransformGroundTruthProtocol.at(20)[0] = 135;
m_PointsToTransformGroundTruthProtocol.at(20)[1] = 20;
m_PointsToTransformGroundTruthProtocol.at(20)[2] = -29; // = 7mm distance to clipping plate + 2mm to base + 20mm depth
m_PointsToTransformGroundTruthProtocol.at(40)[0] = 135;
m_PointsToTransformGroundTruthProtocol.at(40)[1] = 20;
m_PointsToTransformGroundTruthProtocol.at(40)[2] = -49; // = 7mm distance to clipping plate + 2mm to base + 40mm depth
m_PointsToTransformGroundTruthProtocol.at(60)[0] = 135;
m_PointsToTransformGroundTruthProtocol.at(60)[1] = 20;
m_PointsToTransformGroundTruthProtocol.at(60)[2] = -69; // = 7mm distance to clipping plate + 2mm to base + 60mm depth
m_PointsToTransformGroundTruthProtocol.at(80)[0] = 135;
m_PointsToTransformGroundTruthProtocol.at(80)[1] = 20;
m_PointsToTransformGroundTruthProtocol.at(80)[2] = -89; // = 7mm distance to clipping plate + 2mm to base + 80mm depth
m_PointsToTransformGroundTruthProtocol.at(100)[0] = 135;
m_PointsToTransformGroundTruthProtocol.at(100)[1] = 20;
m_PointsToTransformGroundTruthProtocol.at(100)[2] = -109; // = 7mm distance to clipping plate + 2mm to base + 100mm depth
break;
}
}
void QmitkUSNavigationStepCtUsRegistration::TransformPointsGroundTruthProtocol()
{
if (m_GroundTruthProtocolTransformedPoints.find(0) == m_GroundTruthProtocolTransformedPoints.end())
{
mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
pointSet->InsertPoint(m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(0)));
m_GroundTruthProtocolTransformedPoints.insert(std::pair<int, mitk::PointSet::Pointer>(0, pointSet));
}
else
{
m_GroundTruthProtocolTransformedPoints.at(0)->InsertPoint(m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(0)));
}
if (m_GroundTruthProtocolTransformedPoints.find(20) == m_GroundTruthProtocolTransformedPoints.end())
{
mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
pointSet->InsertPoint(m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(20)));
m_GroundTruthProtocolTransformedPoints.insert(std::pair<int, mitk::PointSet::Pointer>(20, pointSet));
}
else
{
m_GroundTruthProtocolTransformedPoints.at(20)->InsertPoint(m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(20)));
}
if (m_GroundTruthProtocolTransformedPoints.find(40) == m_GroundTruthProtocolTransformedPoints.end())
{
mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
pointSet->InsertPoint(m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(40)));
m_GroundTruthProtocolTransformedPoints.insert(std::pair<int, mitk::PointSet::Pointer>(40, pointSet));
}
else
{
m_GroundTruthProtocolTransformedPoints.at(40)->InsertPoint(m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(40)));
}
if (m_GroundTruthProtocolTransformedPoints.find(60) == m_GroundTruthProtocolTransformedPoints.end())
{
mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
pointSet->InsertPoint(m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(60)));
m_GroundTruthProtocolTransformedPoints.insert(std::pair<int, mitk::PointSet::Pointer>(60, pointSet));
}
else
{
m_GroundTruthProtocolTransformedPoints.at(60)->InsertPoint(m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(60)));
}
if (m_GroundTruthProtocolTransformedPoints.find(80) == m_GroundTruthProtocolTransformedPoints.end())
{
mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
pointSet->InsertPoint(m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(80)));
m_GroundTruthProtocolTransformedPoints.insert(std::pair<int, mitk::PointSet::Pointer>(80, pointSet));
}
else
{
m_GroundTruthProtocolTransformedPoints.at(80)->InsertPoint(m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(80)));
}
if (m_GroundTruthProtocolTransformedPoints.find(100) == m_GroundTruthProtocolTransformedPoints.end())
{
mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
pointSet->InsertPoint(m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(100)));
m_GroundTruthProtocolTransformedPoints.insert(std::pair<int, mitk::PointSet::Pointer>(100, pointSet));
}
else
{
m_GroundTruthProtocolTransformedPoints.at(100)->InsertPoint(m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(100)));
}
}
void QmitkUSNavigationStepCtUsRegistration::AddTransformedPointsToDataStorage()
{
if (m_GroundTruthProtocolTransformedPoints.find(0) == m_GroundTruthProtocolTransformedPoints.end() ||
m_GroundTruthProtocolTransformedPoints.find(20) == m_GroundTruthProtocolTransformedPoints.end() ||
m_GroundTruthProtocolTransformedPoints.find(40) == m_GroundTruthProtocolTransformedPoints.end() ||
m_GroundTruthProtocolTransformedPoints.find(60) == m_GroundTruthProtocolTransformedPoints.end() ||
m_GroundTruthProtocolTransformedPoints.find(80) == m_GroundTruthProtocolTransformedPoints.end() ||
m_GroundTruthProtocolTransformedPoints.find(100) == m_GroundTruthProtocolTransformedPoints.end())
{
QMessageBox msgBox;
msgBox.setText("Cannot add transformed Points to DataStorage because they do not exist.\
Stopping evaluation the protocol.");
msgBox.exec();
return;
}
std::string nameNode0mm = "GroundTruthProt-Depth0mm";
std::string nameNode20mm = "GroundTruthProt-Depth20mm";
std::string nameNode40mm = "GroundTruthProt-Depth40mm";
std::string nameNode60mm = "GroundTruthProt-Depth60mm";
std::string nameNode80mm = "GroundTruthProt-Depth80mm";
std::string nameNode100mm = "GroundTruthProt-Depth100mm";
//Add transformed points of depth 0mm to the data storage
mitk::DataNode::Pointer node0mm = this->GetDataStorage()->GetNamedNode(nameNode0mm);
if (node0mm.IsNull())
{
node0mm = mitk::DataNode::New();
node0mm->SetName(nameNode0mm);
node0mm->SetData(m_GroundTruthProtocolTransformedPoints.at(0));
this->GetDataStorage()->Add(node0mm);
}
else
{
node0mm->SetData(m_GroundTruthProtocolTransformedPoints.at(0));
this->GetDataStorage()->Modified();
}
if(ui->protocolEvaluationTypeComboBox->currentText().compare("PLANE") == 0 )
{
//Add transformed points of depth 20mm to the data storage
mitk::DataNode::Pointer node20mm = this->GetDataStorage()->GetNamedNode(nameNode20mm);
if (node20mm.IsNull())
{
node20mm = mitk::DataNode::New();
node20mm->SetName(nameNode20mm);
node20mm->SetData(m_GroundTruthProtocolTransformedPoints.at(20));
this->GetDataStorage()->Add(node20mm);
}
else
{
node20mm->SetData(m_GroundTruthProtocolTransformedPoints.at(20));
this->GetDataStorage()->Modified();
}
//Add transformed points of depth 40mm to the data storage
mitk::DataNode::Pointer node40mm = this->GetDataStorage()->GetNamedNode(nameNode40mm);
if (node40mm.IsNull())
{
node40mm = mitk::DataNode::New();
node40mm->SetName(nameNode40mm);
node40mm->SetData(m_GroundTruthProtocolTransformedPoints.at(40));
this->GetDataStorage()->Add(node40mm);
}
else
{
node40mm->SetData(m_GroundTruthProtocolTransformedPoints.at(40));
this->GetDataStorage()->Modified();
}
//Add transformed points of depth 60mm to the data storage
mitk::DataNode::Pointer node60mm = this->GetDataStorage()->GetNamedNode(nameNode60mm);
if (node60mm.IsNull())
{
node60mm = mitk::DataNode::New();
node60mm->SetName(nameNode60mm);
node60mm->SetData(m_GroundTruthProtocolTransformedPoints.at(60));
this->GetDataStorage()->Add(node60mm);
}
else
{
node60mm->SetData(m_GroundTruthProtocolTransformedPoints.at(60));
this->GetDataStorage()->Modified();
}
//Add transformed points of depth 80mm to the data storage
mitk::DataNode::Pointer node80mm = this->GetDataStorage()->GetNamedNode(nameNode80mm);
if (node80mm.IsNull())
{
node80mm = mitk::DataNode::New();
node80mm->SetName(nameNode80mm);
node80mm->SetData(m_GroundTruthProtocolTransformedPoints.at(80));
this->GetDataStorage()->Add(node80mm);
}
else
{
node80mm->SetData(m_GroundTruthProtocolTransformedPoints.at(80));
this->GetDataStorage()->Modified();
}
//Add transformed points of depth 100mm to the data storage
mitk::DataNode::Pointer node100mm = this->GetDataStorage()->GetNamedNode(nameNode100mm);
if (node100mm.IsNull())
{
node100mm = mitk::DataNode::New();
node100mm->SetName(nameNode100mm);
node100mm->SetData(m_GroundTruthProtocolTransformedPoints.at(100));
this->GetDataStorage()->Add(node100mm);
}
else
{
node100mm->SetData(m_GroundTruthProtocolTransformedPoints.at(100));
this->GetDataStorage()->Modified();
}
}
//Do a global reinit
mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(this->GetDataStorage());
}
double QmitkUSNavigationStepCtUsRegistration::CalculateMeanFRE()
{
double meanFRE = 0.0;
for (unsigned int counter = 0; counter < m_GroundTruthProtocolFRE.size(); ++counter)
{
meanFRE += m_GroundTruthProtocolFRE[counter];
}
return meanFRE / m_GroundTruthProtocolFRE.size();
}
double QmitkUSNavigationStepCtUsRegistration::CalculateStandardDeviationOfFRE(double meanFRE)
{
double variance = 0.0;
for (unsigned int counter = 0; counter < m_GroundTruthProtocolFRE.size(); ++counter)
{
variance += ((meanFRE - m_GroundTruthProtocolFRE[counter]) * (meanFRE - m_GroundTruthProtocolFRE[counter]));
}
variance /= m_GroundTruthProtocolFRE.size(); // calculate the empirical variance (n) and not the sampling variance (n-1)
return sqrt(variance);
}
void QmitkUSNavigationStepCtUsRegistration::CalculateGroundTruthProtocolTRE()
{
if (m_GroundTruthProtocolTransformedPoints.find(0) == m_GroundTruthProtocolTransformedPoints.end() ||
m_GroundTruthProtocolTransformedPoints.find(20) == m_GroundTruthProtocolTransformedPoints.end() ||
m_GroundTruthProtocolTransformedPoints.find(40) == m_GroundTruthProtocolTransformedPoints.end() ||
m_GroundTruthProtocolTransformedPoints.find(60) == m_GroundTruthProtocolTransformedPoints.end() ||
m_GroundTruthProtocolTransformedPoints.find(80) == m_GroundTruthProtocolTransformedPoints.end() ||
m_GroundTruthProtocolTransformedPoints.find(100) == m_GroundTruthProtocolTransformedPoints.end())
{
QMessageBox msgBox;
msgBox.setText("Cannot calculate TRE of Ground-Truth-Protocol because points were not transformed.");
msgBox.exec();
return;
}
// clear the std::map containing possibly data of earlier TRE calculations
m_GroundTruthProtocolTRE.clear();
// loop through all existing point sets containing the transformed points
for (int counter = 0;
m_GroundTruthProtocolTransformedPoints.find(counter) != m_GroundTruthProtocolTransformedPoints.end();
counter += 20)
{
//calculate the middle point of the point set
mitk::PointSet::Pointer pointSet = m_GroundTruthProtocolTransformedPoints.at(counter);
mitk::Point3D middlePoint;
middlePoint[0] = 0.0;
middlePoint[1] = 0.0;
middlePoint[2] = 0.0;
for (int position = 0; position < pointSet->GetSize(); ++position)
{
middlePoint[0] += pointSet->GetPoint(position)[0];
middlePoint[1] += pointSet->GetPoint(position)[1];
middlePoint[2] += pointSet->GetPoint(position)[2];
}
middlePoint[0] /= pointSet->GetSize();
middlePoint[1] /= pointSet->GetSize();
middlePoint[2] /= pointSet->GetSize();
MITK_INFO << "Calculated MiddlePoint: " << middlePoint;
//sum up the euclidean distances between the middle point and each transformed point
double meanDistance = 0.0;
for (int position = 0; position < pointSet->GetSize(); ++position)
{
meanDistance += middlePoint.SquaredEuclideanDistanceTo(pointSet->GetPoint(position));
MITK_INFO << "SquaredEuclideanDistance: " << middlePoint.SquaredEuclideanDistanceTo(pointSet->GetPoint(position));
}
meanDistance /= pointSet->GetSize(); // this can be interpreted as empirical variance
// the root of the empirical variance can be interpreted as the protocols registration TRE
m_GroundTruthProtocolTRE.insert(std::pair<int, double>(counter, sqrt(meanDistance)));
MITK_INFO << "Ground-Truth-Protocol TRE: " << sqrt(meanDistance);
}
}
void QmitkUSNavigationStepCtUsRegistration::EliminateTooSmallLabeledObjects(
ImageType::Pointer binaryImage)
{
BinaryImageToShapeLabelMapFilterType::OutputImageType::Pointer labelMap =
m_BinaryImageToShapeLabelMapFilter->GetOutput();
double voxelVolume = this->GetVoxelVolume();
double fiducialVolume;
unsigned int numberOfPixels;
if (ui->fiducialDiameter3mmRadioButton->isChecked())
{
fiducialVolume = this->GetFiducialVolume(1.5);
numberOfPixels = ceil(fiducialVolume / voxelVolume);
}
else
{
fiducialVolume = this->GetFiducialVolume(2.5);
numberOfPixels = ceil(fiducialVolume / voxelVolume);
}
MITK_INFO << "Voxel Volume = " << voxelVolume << "; Fiducial Volume = " << fiducialVolume;
MITK_INFO << "Number of pixels = " << numberOfPixels;
labelMap = m_BinaryImageToShapeLabelMapFilter->GetOutput();
// The output of this filter is an itk::LabelMap, which contains itk::LabelObject's
MITK_INFO << "There are " << labelMap->GetNumberOfLabelObjects() << " objects.";
// Loop over each region
for (int i = labelMap->GetNumberOfLabelObjects() - 1; i >= 0; --i)
{
// Get the ith region
BinaryImageToShapeLabelMapFilterType::OutputImageType::LabelObjectType* labelObject = labelMap->GetNthLabelObject(i);
MITK_INFO << "Object " << i << " contains " << labelObject->Size() << " pixel";
//TODO: Threshold-Wert evtl. experimentell besser abstimmen,
// um zu verhindern, dass durch Threshold wahre Fiducial-Kandidaten elimiert werden.
if (labelObject->Size() < numberOfPixels * 0.8)
{
for (unsigned int pixelId = 0; pixelId < labelObject->Size(); pixelId++)
{
binaryImage->SetPixel(labelObject->GetIndex(pixelId), 0);
}
labelMap->RemoveLabelObject(labelObject);
}
}
}
bool QmitkUSNavigationStepCtUsRegistration::EliminateFiducialCandidatesByEuclideanDistances()
{
if (m_CentroidsOfFiducialCandidates.size() < NUMBER_FIDUCIALS_NEEDED)
{
return false;
}
for (unsigned int counter = 0; counter < m_CentroidsOfFiducialCandidates.size(); ++counter)
{
int amountOfAcceptedFiducials = 0;
mitk::Point3D fiducialCentroid(m_CentroidsOfFiducialCandidates.at(counter));
//Loop through all fiducial candidates and calculate the distance between the chosen fiducial
// candidate and the other candidates. For each candidate with a right distance between
// Configuration A: 7.93mm and 31.0mm (10 mm distance between fiducial centers) or
// Configuration B: 11.895mm and 45.0mm (15 mm distance between fiducial centers) or
// Configuration C: 15.86mm and 59.0mm (20 mm distance between fiducial centers)
//
// increase the amountOfAcceptedFiducials.
for (unsigned int position = 0; position < m_CentroidsOfFiducialCandidates.size(); ++position)
{
if (position == counter)
{
continue;
}
mitk::Point3D otherCentroid(m_CentroidsOfFiducialCandidates.at(position));
double distance = fiducialCentroid.EuclideanDistanceTo(otherCentroid);
switch (ui->fiducialMarkerConfigurationComboBox->currentIndex())
{
// case 0 is equal to fiducial marker configuration A (10mm distance)
case 0:
if (distance > 7.93 && distance < 31.0)
{
++amountOfAcceptedFiducials;
}
break;
// case 1 is equal to fiducial marker configuration B (15mm distance)
case 1:
if (distance > 11.895 && distance < 45.0)
{
++amountOfAcceptedFiducials;
}
break;
// case 2 is equal to fiducial marker configuration C (20mm distance)
case 2:
if (distance > 15.86 && distance < 59.0)
{
++amountOfAcceptedFiducials;
}
break;
}
}
//The amountOfAcceptedFiducials must be at least 7. Otherwise delete the fiducial candidate
// from the list of candidates.
if (amountOfAcceptedFiducials < NUMBER_FIDUCIALS_NEEDED - 1)
{
MITK_INFO << "Deleting fiducial candidate at position: " <<
m_CentroidsOfFiducialCandidates.at(counter);
m_CentroidsOfFiducialCandidates.erase(m_CentroidsOfFiducialCandidates.begin() + counter);
if (m_CentroidsOfFiducialCandidates.size() < NUMBER_FIDUCIALS_NEEDED )
{
return false;
}
counter = -1;
}
}
//Classify the rested fiducial candidates by its characteristic Euclidean distances
// between the canidates and remove all candidates with a false distance configuration:
this->ClassifyFiducialCandidates();
return true;
}
void QmitkUSNavigationStepCtUsRegistration::ClassifyFiducialCandidates()
{
MITK_INFO << "ClassifyFiducialCandidates()";
std::vector<int> fiducialCandidatesToBeRemoved;
std::vector<std::vector<double>> distanceVectorsFiducials;
this->CalculateDistancesBetweenFiducials(distanceVectorsFiducials);
for (unsigned int counter = 0; counter < distanceVectorsFiducials.size(); ++counter)
{
int distanceA = 0; // => 10,00mm distance
int distanceB = 0; // => 14,14mm distance
int distanceC = 0; // => 17,32mm distance
int distanceD = 0; // => 22,36mm distance
int distanceE = 0; // => 24,49mm distance
int distanceF = 0; // => 28,28mm distance
std::vector<double> &distances = distanceVectorsFiducials.at(counter);
for (unsigned int number = 0; number < distances.size(); ++number)
{
double &distance = distances.at(number);
switch (ui->fiducialMarkerConfigurationComboBox->currentIndex())
{
// case 0 is equal to fiducial marker configuration A (10mm distance)
case 0:
if (distance > 7.93 && distance <= 12.07)
{
++distanceA;
}
else if (distance > 12.07 && distance <= 15.73)
{
++distanceB;
}
else if (distance > 15.73 && distance <= 19.84)
{
++distanceC;
}
else if (distance > 19.84 && distance <= 23.425)
{
++distanceD;
}
else if (distance > 23.425 && distance <= 26.385)
{
++distanceE;
}
else if (distance > 26.385 && distance <= 31.00)
{
++distanceF;
}
break;
// case 1 is equal to fiducial marker configuration B (15mm distance)
case 1:
if (distance > 11.895 && distance <= 18.105)
{
++distanceA;
}
else if (distance > 18.105 && distance <= 23.595)
{
++distanceB;
}
else if (distance > 23.595 && distance <= 29.76)
{
++distanceC;
}
else if (distance > 29.76 && distance <= 35.1375)
{
++distanceD;
if (distance > 33.54)
{
++distanceE;
}
}
else if (distance > 35.1375 && distance <= 39.5775)
{
++distanceE;
if (distance < 36.735)
{
++distanceD;
}
}
else if (distance > 39.5775 && distance <= 45.00)
{
++distanceF;
}
break;
// case 2 is equal to fiducial marker configuration C (20mm distance)
case 2:
if (distance > 15.86 && distance <= 24.14)
{
++distanceA;
}
else if (distance > 24.14 && distance <= 31.46)
{
++distanceB;
}
else if (distance > 31.46 && distance <= 39.68)
{
++distanceC;
}
else if (distance > 39.68 && distance <= 46.85)
{
++distanceD;
}
else if (distance > 46.85 && distance <= 52.77)
{
++distanceE;
}
else if (distance > 52.77 && distance <= 59.00)
{
++distanceF;
}
break;
}
}// End for-loop distances-vector
//Now, having looped through all distances of one fiducial candidate, check
// if the combination of different distances is known. The >= is due to the
// possible occurrence of other fiducial candidates that have an distance equal to
// one of the distances A - E. However, false fiducial candidates outside
// the fiducial marker does not have the right distance configuration:
if (((distanceA >= 2 && distanceD >= 2 && distanceE >= 2 && distanceF >= 1) ||
(distanceA >= 1 && distanceB >= 2 && distanceC >= 1 && distanceD >= 2 && distanceE >= 1) ||
(distanceB >= 2 && distanceD >= 4 && distanceF >= 1) ||
(distanceA >= 1 && distanceB >= 1 && distanceD >= 3 && distanceE >= 1 && distanceF >= 1)) == false)
{
MITK_INFO << "Detected fiducial candidate with unknown distance configuration.";
fiducialCandidatesToBeRemoved.push_back(counter);
}
}
for (int count = fiducialCandidatesToBeRemoved.size() - 1; count >= 0; --count)
{
MITK_INFO << "Removing fiducial candidate " << fiducialCandidatesToBeRemoved.at(count);
m_CentroidsOfFiducialCandidates.erase(m_CentroidsOfFiducialCandidates.begin()
+ fiducialCandidatesToBeRemoved.at(count));
}
}
void QmitkUSNavigationStepCtUsRegistration::GetCentroidsOfLabeledObjects()
{
MITK_INFO << "GetCentroidsOfLabeledObjects()";
BinaryImageToShapeLabelMapFilterType::OutputImageType::Pointer labelMap =
m_BinaryImageToShapeLabelMapFilter->GetOutput();
for (int i = labelMap->GetNumberOfLabelObjects() - 1; i >= 0; --i)
{
// Get the ith region
BinaryImageToShapeLabelMapFilterType::OutputImageType::LabelObjectType* labelObject = labelMap->GetNthLabelObject(i);
MITK_INFO << "Object " << i << " contains " << labelObject->Size() << " pixel";
mitk::Vector3D centroid;
centroid[0] = labelObject->GetCentroid()[0];
centroid[1] = labelObject->GetCentroid()[1];
centroid[2] = labelObject->GetCentroid()[2];
m_CentroidsOfFiducialCandidates.push_back(centroid);
}
//evtl. for later: itk::LabelMapOverlayImageFilter
}
void QmitkUSNavigationStepCtUsRegistration::NumerateFiducialMarks()
{
MITK_INFO << "NumerateFiducialMarks()";
bool successFiducialNo1;
bool successFiducialNo4;
bool successFiducialNo2And3;
bool successFiducialNo5;
bool successFiducialNo8;
bool successFiducialNo6;
bool successFiducialNo7;
std::vector<std::vector<double>> distanceVectorsFiducials;
this->CalculateDistancesBetweenFiducials(distanceVectorsFiducials);
successFiducialNo1 = this->FindFiducialNo1(distanceVectorsFiducials);
successFiducialNo4 = this->FindFiducialNo4(distanceVectorsFiducials);
successFiducialNo2And3 = this->FindFiducialNo2And3();
successFiducialNo5 = this->FindFiducialNo5();
successFiducialNo8 = this->FindFiducialNo8();
successFiducialNo6 = this->FindFiducialNo6();
successFiducialNo7 = this->FindFiducialNo7();
if (!successFiducialNo1 || !successFiducialNo4 || !successFiducialNo2And3 ||
!successFiducialNo5 || !successFiducialNo8 || !successFiducialNo6 || !successFiducialNo7)
{
QMessageBox msgBox;
msgBox.setText("Cannot numerate/localize all fiducials successfully.");
msgBox.exec();
return;
}
if (m_MarkerFloatingImageCoordinateSystemPointSet.IsNull())
{
m_MarkerFloatingImageCoordinateSystemPointSet = mitk::PointSet::New();
}
else if (m_MarkerFloatingImageCoordinateSystemPointSet->GetSize() != 0)
{
m_MarkerFloatingImageCoordinateSystemPointSet->Clear();
}
for (unsigned int counter = 1; counter <= m_FiducialMarkerCentroids.size(); ++counter)
{
- m_MarkerFloatingImageCoordinateSystemPointSet->InsertPoint(counter - 1, m_FiducialMarkerCentroids.at(counter));
+ m_MarkerFloatingImageCoordinateSystemPointSet->InsertPoint(counter - 1, mitk::Point3D(m_FiducialMarkerCentroids.at(counter)));
}
if( !m_PerformingGroundTruthProtocolEvaluation )
{
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(m_MarkerFloatingImageCoordinateSystemPointSet);
node->SetName("MarkerFloatingImageCSPointSet");
//node->SetFloatProperty("pointsize", 5.0);
this->GetDataStorage()->Add(node);
}
}
void QmitkUSNavigationStepCtUsRegistration::CalculateDistancesBetweenFiducials(std::vector<std::vector<double>>& distanceVectorsFiducials)
{
std::vector<double> distancesBetweenFiducials;
for (unsigned int i = 0; i < m_CentroidsOfFiducialCandidates.size(); ++i)
{
distancesBetweenFiducials.clear();
mitk::Point3D fiducialCentroid(m_CentroidsOfFiducialCandidates.at(i));
for (unsigned int n = 0; n < m_CentroidsOfFiducialCandidates.size(); ++n)
{
mitk::Point3D otherCentroid(m_CentroidsOfFiducialCandidates.at(n));
distancesBetweenFiducials.push_back(fiducialCentroid.EuclideanDistanceTo(otherCentroid));
}
//Sort the distances from low to big numbers
std::sort(distancesBetweenFiducials.begin(), distancesBetweenFiducials.end());
//First entry of the distance vector must be 0, so erase it
if (distancesBetweenFiducials.at(0) == 0.0)
{
distancesBetweenFiducials.erase(distancesBetweenFiducials.begin());
}
//Add the distance vector to the collecting distances vector
distanceVectorsFiducials.push_back(distancesBetweenFiducials);
}
for (unsigned int i = 0; i < distanceVectorsFiducials.size(); ++i)
{
MITK_INFO << "Vector " << i << ":";
for (unsigned int k = 0; k < distanceVectorsFiducials.at(i).size(); ++k)
{
MITK_INFO << distanceVectorsFiducials.at(i).at(k);
}
}
}
bool QmitkUSNavigationStepCtUsRegistration::FindFiducialNo1(std::vector<std::vector<double>>& distanceVectorsFiducials)
{
for (unsigned int i = 0; i < distanceVectorsFiducials.size(); ++i)
{
std::vector<double> &distances = distanceVectorsFiducials.at(i);
if (distances.size() < NUMBER_FIDUCIALS_NEEDED - 1 )
{
MITK_WARN << "Cannot find fiducial 1, there aren't found enough fiducial candidates.";
return false;
}
double characteristicDistanceAWithUpperMargin = this->GetCharacteristicDistanceAWithUpperMargin();
if (distances.at(0) <= characteristicDistanceAWithUpperMargin &&
distances.at(1) <= characteristicDistanceAWithUpperMargin)
{
MITK_INFO << "Found Fiducial 1 (PointSet number " << i << ")";
m_FiducialMarkerCentroids.insert( std::pair<int,mitk::Vector3D>(1, m_CentroidsOfFiducialCandidates.at(i)));
distanceVectorsFiducials.erase(distanceVectorsFiducials.begin() + i);
m_CentroidsOfFiducialCandidates.erase(m_CentroidsOfFiducialCandidates.begin() + i);
return true;
}
}
return false;
}
bool QmitkUSNavigationStepCtUsRegistration::FindFiducialNo2And3()
{
if (m_FiducialMarkerCentroids.find(1) == m_FiducialMarkerCentroids.end() )
{
MITK_WARN << "Cannot find fiducial No 2 and 3. Before must be found fiducial No 1.";
return false;
}
mitk::Point3D fiducialNo1(m_FiducialMarkerCentroids.at(1));
mitk::Vector3D fiducialVectorA;
mitk::Vector3D fiducialVectorB;
mitk::Point3D fiducialPointA;
mitk::Point3D fiducialPointB;
bool foundFiducialA = false;
bool foundFiducialB = false;
mitk::Vector3D vectorFiducial1ToFiducialA;
mitk::Vector3D vectorFiducial1ToFiducialB;
for (unsigned int i = 0; i < m_CentroidsOfFiducialCandidates.size(); ++i)
{
mitk::Point3D fiducialCentroid(m_CentroidsOfFiducialCandidates.at(i));
double distance = fiducialNo1.EuclideanDistanceTo(fiducialCentroid);
if (distance <= this->GetCharacteristicDistanceAWithUpperMargin())
{
fiducialVectorA = m_CentroidsOfFiducialCandidates.at(i);
fiducialPointA = fiducialCentroid;
m_CentroidsOfFiducialCandidates.erase(m_CentroidsOfFiducialCandidates.begin() + i);
foundFiducialA = true;
break;
}
}
for (unsigned int i = 0; i < m_CentroidsOfFiducialCandidates.size(); ++i)
{
mitk::Point3D fiducialCentroid(m_CentroidsOfFiducialCandidates.at(i));
double distance = fiducialNo1.EuclideanDistanceTo(fiducialCentroid);
if (distance <= this->GetCharacteristicDistanceAWithUpperMargin())
{
fiducialVectorB = m_CentroidsOfFiducialCandidates.at(i);
fiducialPointB = fiducialCentroid;
m_CentroidsOfFiducialCandidates.erase(m_CentroidsOfFiducialCandidates.begin() + i);
foundFiducialB = true;
break;
}
}
if (!foundFiducialA || !foundFiducialB)
{
MITK_WARN << "Cannot identify fiducial candidates 2 and 3";
return false;
}
else if (m_CentroidsOfFiducialCandidates.size() == 0)
{
MITK_WARN << "Too less fiducials detected. Cannot identify fiducial candidates 2 and 3";
return false;
}
vectorFiducial1ToFiducialA = fiducialVectorA - m_FiducialMarkerCentroids.at(1);
vectorFiducial1ToFiducialB = fiducialVectorB - m_FiducialMarkerCentroids.at(1);
vnl_vector<double> crossProductVnl = vnl_cross_3d(vectorFiducial1ToFiducialA.GetVnlVector(), vectorFiducial1ToFiducialB.GetVnlVector());
mitk::Vector3D crossProduct;
crossProduct.SetVnlVector(crossProductVnl);
mitk::Vector3D vectorFiducial1ToRandomLeftFiducial = m_CentroidsOfFiducialCandidates.at(0) - m_FiducialMarkerCentroids.at(1);
double scalarProduct = (crossProduct * vectorFiducial1ToRandomLeftFiducial) /
(crossProduct.GetNorm() * vectorFiducial1ToRandomLeftFiducial.GetNorm());
double alpha = acos(scalarProduct) * 57.29578; //Transform into degree
MITK_INFO << "Scalar Product = " << alpha;
if (alpha <= 90)
{
m_FiducialMarkerCentroids[3] = fiducialVectorA;
m_FiducialMarkerCentroids[2] = fiducialVectorB;
}
else
{
m_FiducialMarkerCentroids[2] = fiducialVectorA;
m_FiducialMarkerCentroids[3] = fiducialVectorB;
}
MITK_INFO << "Found Fiducial 2, PointSet: " << m_FiducialMarkerCentroids.at(2);
MITK_INFO << "Found Fiducial 3, PointSet: " << m_FiducialMarkerCentroids.at(3);
return true;
}
bool QmitkUSNavigationStepCtUsRegistration::FindFiducialNo4(std::vector<std::vector<double>>& distanceVectorsFiducials)
{
double characteristicDistanceBWithLowerMargin = this->GetCharacteristicDistanceBWithLowerMargin();
double characteristicDistanceBWithUpperMargin = this->GetCharacteristicDistanceBWithUpperMargin();
for (unsigned int i = 0; i < distanceVectorsFiducials.size(); ++i)
{
std::vector<double> &distances = distanceVectorsFiducials.at(i);
if (distances.size() < NUMBER_FIDUCIALS_NEEDED - 1)
{
MITK_WARN << "Cannot find fiducial 4, there aren't found enough fiducial candidates.";
return false;
}
if (distances.at(0) > characteristicDistanceBWithLowerMargin &&
distances.at(0) <= characteristicDistanceBWithUpperMargin &&
distances.at(1) > characteristicDistanceBWithLowerMargin &&
distances.at(1) <= characteristicDistanceBWithUpperMargin)
{
MITK_INFO << "Found Fiducial 4 (PointSet number " << i << ")";
m_FiducialMarkerCentroids.insert(std::pair<int, mitk::Vector3D>(4, m_CentroidsOfFiducialCandidates.at(i)));
distanceVectorsFiducials.erase(distanceVectorsFiducials.begin() + i);
m_CentroidsOfFiducialCandidates.erase(m_CentroidsOfFiducialCandidates.begin() + i);
return true;
}
}
return false;
}
bool QmitkUSNavigationStepCtUsRegistration::FindFiducialNo5()
{
if (m_FiducialMarkerCentroids.find(2) == m_FiducialMarkerCentroids.end())
{
MITK_WARN << "To find fiducial No 5, fiducial No 2 has to be found before.";
return false;
}
double characteristicDistanceBWithUpperMargin = this->GetCharacteristicDistanceBWithUpperMargin();
mitk::Point3D fiducialNo2(m_FiducialMarkerCentroids.at(2));
for (unsigned int counter = 0; counter < m_CentroidsOfFiducialCandidates.size(); ++counter)
{
mitk::Point3D fiducialCentroid(m_CentroidsOfFiducialCandidates.at(counter));
double distance = fiducialNo2.EuclideanDistanceTo(fiducialCentroid);
if (distance <= characteristicDistanceBWithUpperMargin)
{
m_FiducialMarkerCentroids[5] = m_CentroidsOfFiducialCandidates.at(counter);
m_CentroidsOfFiducialCandidates.erase(m_CentroidsOfFiducialCandidates.begin() + counter);
MITK_INFO << "Found Fiducial No 5, PointSet: " << m_FiducialMarkerCentroids[5];
return true;
}
}
MITK_WARN << "Cannot find fiducial No 5.";
return false;
}
bool QmitkUSNavigationStepCtUsRegistration::FindFiducialNo6()
{
if (m_FiducialMarkerCentroids.find(5) == m_FiducialMarkerCentroids.end())
{
MITK_WARN << "To find fiducial No 6, fiducial No 5 has to be found before.";
return false;
}
double characteristicDistanceAWithUpperMargin = this->GetCharacteristicDistanceAWithUpperMargin();
mitk::Point3D fiducialNo5(m_FiducialMarkerCentroids.at(5));
for (unsigned int counter = 0; counter < m_CentroidsOfFiducialCandidates.size(); ++counter)
{
mitk::Point3D fiducialCentroid(m_CentroidsOfFiducialCandidates.at(counter));
double distance = fiducialNo5.EuclideanDistanceTo(fiducialCentroid);
if (distance <= characteristicDistanceAWithUpperMargin)
{
m_FiducialMarkerCentroids[6] = m_CentroidsOfFiducialCandidates.at(counter);
m_CentroidsOfFiducialCandidates.erase(m_CentroidsOfFiducialCandidates.begin() + counter);
MITK_INFO << "Found Fiducial No 6, PointSet: " << m_FiducialMarkerCentroids[6];
return true;
}
}
MITK_WARN << "Cannot find fiducial No 6.";
return false;
}
bool QmitkUSNavigationStepCtUsRegistration::FindFiducialNo7()
{
if (m_FiducialMarkerCentroids.find(8) == m_FiducialMarkerCentroids.end())
{
MITK_WARN << "To find fiducial No 7, fiducial No 8 has to be found before.";
return false;
}
double characteristicDistanceAWithUpperMargin = this->GetCharacteristicDistanceAWithUpperMargin();
mitk::Point3D fiducialNo8(m_FiducialMarkerCentroids.at(8));
for (unsigned int counter = 0; counter < m_CentroidsOfFiducialCandidates.size(); ++counter)
{
mitk::Point3D fiducialCentroid(m_CentroidsOfFiducialCandidates.at(counter));
double distance = fiducialNo8.EuclideanDistanceTo(fiducialCentroid);
if (distance <= characteristicDistanceAWithUpperMargin)
{
m_FiducialMarkerCentroids[7] = m_CentroidsOfFiducialCandidates.at(counter);
m_CentroidsOfFiducialCandidates.erase(m_CentroidsOfFiducialCandidates.begin() + counter);
MITK_INFO << "Found Fiducial No 7, PointSet: " << m_FiducialMarkerCentroids[7];
return true;
}
}
MITK_WARN << "Cannot find fiducial No 7.";
return false;
}
bool QmitkUSNavigationStepCtUsRegistration::FindFiducialNo8()
{
if (m_FiducialMarkerCentroids.find(3) == m_FiducialMarkerCentroids.end())
{
MITK_WARN << "To find fiducial No 8, fiducial No 3 has to be found before.";
return false;
}
double characteristicDistanceBWithUpperMargin = this->GetCharacteristicDistanceBWithUpperMargin();
mitk::Point3D fiducialNo3(m_FiducialMarkerCentroids.at(3));
for (unsigned int counter = 0; counter < m_CentroidsOfFiducialCandidates.size(); ++counter)
{
mitk::Point3D fiducialCentroid(m_CentroidsOfFiducialCandidates.at(counter));
double distance = fiducialNo3.EuclideanDistanceTo(fiducialCentroid);
if (distance <= characteristicDistanceBWithUpperMargin)
{
m_FiducialMarkerCentroids[8] = m_CentroidsOfFiducialCandidates.at(counter);
m_CentroidsOfFiducialCandidates.erase(m_CentroidsOfFiducialCandidates.begin() + counter);
MITK_INFO << "Found Fiducial No 8, PointSet: " << m_FiducialMarkerCentroids[8];
return true;
}
}
MITK_WARN << "Cannot find fiducial No 8.";
return false;
}
void QmitkUSNavigationStepCtUsRegistration::DefineDataStorageImageFilter()
{
m_IsAPointSetPredicate = mitk::TNodePredicateDataType<mitk::PointSet>::New();
mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
auto isSegmentation = mitk::NodePredicateDataType::New("Segment");
m_IsASurfacePredicate = mitk::NodePredicateDataType::New("Surface");
mitk::NodePredicateOr::Pointer validImages = mitk::NodePredicateOr::New();
validImages->AddPredicate(mitk::NodePredicateAnd::New(isImage, mitk::NodePredicateNot::New(isSegmentation)));
mitk::NodePredicateNot::Pointer isNotAHelperObject = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object", mitk::BoolProperty::New(true)));
m_IsOfTypeImagePredicate = mitk::NodePredicateAnd::New(validImages, isNotAHelperObject);
mitk::NodePredicateProperty::Pointer isBinaryPredicate = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
mitk::NodePredicateNot::Pointer isNotBinaryPredicate = mitk::NodePredicateNot::New(isBinaryPredicate);
mitk::NodePredicateAnd::Pointer isABinaryImagePredicate = mitk::NodePredicateAnd::New(m_IsOfTypeImagePredicate, isBinaryPredicate);
mitk::NodePredicateAnd::Pointer isNotABinaryImagePredicate = mitk::NodePredicateAnd::New(m_IsOfTypeImagePredicate, isNotBinaryPredicate);
m_IsASegmentationImagePredicate = mitk::NodePredicateOr::New(isABinaryImagePredicate, mitk::TNodePredicateDataType<mitk::LabelSetImage>::New());
m_IsAPatientImagePredicate = mitk::NodePredicateAnd::New(isNotABinaryImagePredicate, mitk::NodePredicateNot::New(mitk::TNodePredicateDataType<mitk::LabelSetImage>::New()));
}
void QmitkUSNavigationStepCtUsRegistration::CreateQtPartControl(QWidget *parent)
{
ui->setupUi(parent);
ui->floatingImageComboBox->SetPredicate(m_IsAPatientImagePredicate);
ui->ctImagesToChooseComboBox->SetPredicate(m_IsAPatientImagePredicate);
ui->segmentationComboBox->SetPredicate(m_IsASegmentationImagePredicate);
ui->selectedSurfaceComboBox->SetPredicate(m_IsASurfacePredicate);
ui->pointSetComboBox->SetPredicate(m_IsAPointSetPredicate);
// create signal/slot connections
connect(ui->floatingImageComboBox, SIGNAL(OnSelectionChanged(const mitk::DataNode*)),
this, SLOT(OnFloatingImageComboBoxSelectionChanged(const mitk::DataNode*)));
connect(ui->doRegistrationMarkerToImagePushButton, SIGNAL(clicked()),
this, SLOT(OnRegisterMarkerToFloatingImageCS()));
connect(ui->localizeFiducialMarkerPushButton, SIGNAL(clicked()),
this, SLOT(OnLocalizeFiducials()));
connect(ui->visualizeCTtoUSregistrationPushButton, SIGNAL(clicked()),
this, SLOT(OnVisualizeCTtoUSregistration()));
connect(ui->freezeUnfreezePushButton, SIGNAL(clicked()),
this, SLOT(OnFreeze()));
connect(ui->addCtImagePushButton, SIGNAL(clicked()),
this, SLOT(OnAddCtImageClicked()));
connect(ui->removeCtImagePushButton, SIGNAL(clicked()),
this, SLOT(OnRemoveCtImageClicked()));
connect(ui->evaluateProtocolPushButton, SIGNAL(clicked()),
this, SLOT(OnEvaluateGroundTruthFiducialLocalizationProtocol()));
connect(ui->actualizeSegmentationSurfacePSetDataPushButton, SIGNAL(clicked()),
this, SLOT(OnActualizeSegmentationSurfacePointSetData()));
connect(ui->calculateTREPushButton, SIGNAL(clicked()),
this, SLOT(OnGetCursorPosition()));
connect(ui->calculateCenterPushButton, SIGNAL(clicked()),
this, SLOT(OnCalculateCenter()));
}
void QmitkUSNavigationStepCtUsRegistration::OnFloatingImageComboBoxSelectionChanged(const mitk::DataNode* node)
{
MITK_INFO << "OnFloatingImageComboBoxSelectionChanged()";
if (m_FloatingImage.IsNotNull())
{
//TODO: Define, what will happen if the imageCT is not null...
}
if (node == nullptr)
{
this->UnsetFloatingImageGeometry();
m_FloatingImage = nullptr;
return;
}
mitk::DataNode* selectedFloatingImage = ui->floatingImageComboBox->GetSelectedNode();
if (selectedFloatingImage == nullptr)
{
this->UnsetFloatingImageGeometry();
m_FloatingImage = nullptr;
return;
}
mitk::Image::Pointer floatingImage = dynamic_cast<mitk::Image*>(selectedFloatingImage->GetData());
if (floatingImage.IsNull())
{
MITK_WARN << "Failed to cast selected segmentation node to mitk::Image*";
this->UnsetFloatingImageGeometry();
m_FloatingImage = nullptr;
return;
}
m_FloatingImage = floatingImage;
this->SetFloatingImageGeometryInformation(floatingImage.GetPointer());
}
void QmitkUSNavigationStepCtUsRegistration::OnRegisterMarkerToFloatingImageCS()
{
this->CreateMarkerModelCoordinateSystemPointSet();
//Check for initialization
if( m_MarkerModelCoordinateSystemPointSet.IsNull() ||
m_MarkerFloatingImageCoordinateSystemPointSet.IsNull() )
{
MITK_WARN << "Fiducial Landmarks are not initialized yet, cannot register";
return;
}
//Retrieve fiducials
if (m_MarkerFloatingImageCoordinateSystemPointSet->GetSize() != m_MarkerModelCoordinateSystemPointSet->GetSize())
{
MITK_WARN << "Not the same number of fiducials, cannot register";
return;
}
else if (m_MarkerFloatingImageCoordinateSystemPointSet->GetSize() < 3)
{
MITK_WARN << "Need at least 3 fiducials, cannot register";
return;
}
//############### conversion to vtk data types (we will use the vtk landmark based transform) ##########################
//convert point sets to vtk poly data
vtkSmartPointer<vtkPoints> sourcePoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkPoints> targetPoints = vtkSmartPointer<vtkPoints>::New();
for (int i = 0; i<m_MarkerModelCoordinateSystemPointSet->GetSize(); i++)
{
double point[3] = { m_MarkerModelCoordinateSystemPointSet->GetPoint(i)[0],
m_MarkerModelCoordinateSystemPointSet->GetPoint(i)[1],
m_MarkerModelCoordinateSystemPointSet->GetPoint(i)[2] };
sourcePoints->InsertNextPoint(point);
double point_targets[3] = { m_MarkerFloatingImageCoordinateSystemPointSet->GetPoint(i)[0],
m_MarkerFloatingImageCoordinateSystemPointSet->GetPoint(i)[1],
m_MarkerFloatingImageCoordinateSystemPointSet->GetPoint(i)[2] };
targetPoints->InsertNextPoint(point_targets);
}
//########################### here, the actual transform is computed ##########################
//compute transform
vtkSmartPointer<vtkLandmarkTransform> transform = vtkSmartPointer<vtkLandmarkTransform>::New();
transform->SetSourceLandmarks(sourcePoints);
transform->SetTargetLandmarks(targetPoints);
transform->SetModeToRigidBody();
transform->Modified();
transform->Update();
//compute FRE of transform
double FRE = mitk::StaticIGTHelperFunctions::ComputeFRE(m_MarkerModelCoordinateSystemPointSet, m_MarkerFloatingImageCoordinateSystemPointSet, transform);
MITK_INFO << "FRE: " << FRE << " mm";
if (m_PerformingGroundTruthProtocolEvaluation)
{
m_GroundTruthProtocolFRE.push_back(FRE);
}
//#############################################################################################
//############### conversion back to itk/mitk data types ##########################
//convert from vtk to itk data types
itk::Matrix<float, 3, 3> rotationFloat = itk::Matrix<float, 3, 3>();
itk::Vector<float, 3> translationFloat = itk::Vector<float, 3>();
itk::Matrix<double, 3, 3> rotationDouble = itk::Matrix<double, 3, 3>();
itk::Vector<double, 3> translationDouble = itk::Vector<double, 3>();
vtkSmartPointer<vtkMatrix4x4> m = transform->GetMatrix();
for (int k = 0; k<3; k++) for (int l = 0; l<3; l++)
{
rotationFloat[k][l] = m->GetElement(k, l);
rotationDouble[k][l] = m->GetElement(k, l);
}
for (int k = 0; k<3; k++)
{
translationFloat[k] = m->GetElement(k, 3);
translationDouble[k] = m->GetElement(k, 3);
}
//create mitk affine transform 3D and save it to the class member
m_TransformMarkerCSToFloatingImageCS = mitk::AffineTransform3D::New();
m_TransformMarkerCSToFloatingImageCS->SetMatrix(rotationDouble);
m_TransformMarkerCSToFloatingImageCS->SetOffset(translationDouble);
MITK_INFO << m_TransformMarkerCSToFloatingImageCS;
//################################################################
//############### object is transformed ##########################
//transform surface/image
//only move image if we have one. Sometimes, this widget is used just to register point sets without images.
/*if (m_ImageNode.IsNotNull())
{
//first we have to store the original ct image transform to compose it with the new transform later
mitk::AffineTransform3D::Pointer imageTransform = m_ImageNode->GetData()->GetGeometry()->GetIndexToWorldTransform();
imageTransform->Compose(mitkTransform);
mitk::AffineTransform3D::Pointer newImageTransform = mitk::AffineTransform3D::New(); //create new image transform... setting the composed directly leads to an error
itk::Matrix<mitk::ScalarType, 3, 3> rotationFloatNew = imageTransform->GetMatrix();
itk::Vector<mitk::ScalarType, 3> translationFloatNew = imageTransform->GetOffset();
newImageTransform->SetMatrix(rotationFloatNew);
newImageTransform->SetOffset(translationFloatNew);
m_ImageNode->GetData()->GetGeometry()->SetIndexToWorldTransform(newImageTransform);
}*/
//If this option is set, each point will be transformed and the acutal coordinates of the points change.
if( !m_PerformingGroundTruthProtocolEvaluation )
{
mitk::PointSet* pointSet_orig = m_MarkerModelCoordinateSystemPointSet;
mitk::PointSet::Pointer pointSet_moved = mitk::PointSet::New();
for (int i = 0; i < pointSet_orig->GetSize(); i++)
{
pointSet_moved->InsertPoint(m_TransformMarkerCSToFloatingImageCS->TransformPoint(pointSet_orig->GetPoint(i)));
}
pointSet_orig->Clear();
for (int i = 0; i < pointSet_moved->GetSize(); i++)
pointSet_orig->InsertPoint(pointSet_moved->GetPoint(i));
//Do a global reinit
mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(this->GetDataStorage());
}
}
void QmitkUSNavigationStepCtUsRegistration::OnLocalizeFiducials()
{
m_FiducialMarkerCentroids.clear();
m_CentroidsOfFiducialCandidates.clear();
if (m_MarkerFloatingImageCoordinateSystemPointSet.IsNotNull())
{
m_MarkerFloatingImageCoordinateSystemPointSet->Clear();
}
if (!this->FilterFloatingImage())
{
QMessageBox msgBox;
msgBox.setText("Cannot perform filtering of the image. The floating image = nullptr.");
msgBox.exec();
return;
}
mitk::AffineTransform3D::Pointer transform = m_FloatingImage->GetGeometry()->GetIndexToWorldTransform();
MITK_WARN << "IndexToWorldTransform_CTimage = " << transform;
this->GetCentroidsOfLabeledObjects();
if (!this->EliminateFiducialCandidatesByEuclideanDistances() ||
m_CentroidsOfFiducialCandidates.size() != NUMBER_FIDUCIALS_NEEDED)
{
QMessageBox msgBox;
QString text = QString("Have found %1 instead of 8 fiducial candidates.\
Cannot perform fiducial localization procedure.").arg(m_CentroidsOfFiducialCandidates.size());
msgBox.setText(text);
msgBox.exec();
return;
}
//Before calling NumerateFiducialMarks it must be sure,
// that there rested only 8 fiducial candidates.
this->NumerateFiducialMarks();
}
void QmitkUSNavigationStepCtUsRegistration::OnVisualizeCTtoUSregistration()
{
emit this->ActualizeCtToUsRegistrationWidget();
mitk::DataNode* segmentationNode = ui->segmentationComboBox->GetSelectedNode();
if (segmentationNode == nullptr)
{
QMessageBox msgBox;
msgBox.setText("Cannot visualize CT-to-US registration. There is no segmentation selected.");
msgBox.exec();
return;
}
mitk::AffineTransform3D::Pointer transform = segmentationNode->GetData()->GetGeometry()->GetIndexToWorldTransform();
MITK_WARN << "IndexToWorldTransform_segmentation = " << transform;
mitk::DataNode* surfaceNode = ui->selectedSurfaceComboBox->GetSelectedNode();
if (surfaceNode == nullptr)
{
QMessageBox msgBox;
msgBox.setText("Cannot visualize CT-to-US registration. There is no surface selected.");
msgBox.exec();
return;
}
mitk::DataNode* pointSetNode = ui->pointSetComboBox->GetSelectedNode();
if (pointSetNode == nullptr)
{
QMessageBox msgBox;
msgBox.setText("Cannot visualize CT-to-US registration. There is no pointSet selected.");
msgBox.exec();
return;
}
if (this->GetCombinedModality(false).IsNull())
{
QMessageBox msgBox;
msgBox.setText("CombinedModality not yet set.\nPlease try again and click on the button.");
msgBox.exec();
return;
}
if (m_FloatingImageToUltrasoundRegistrationFilter.IsNull())
{
QMessageBox msgBox;
msgBox.setText("Cannot visualize CT-to-US registration.\
The FloatingImageToUltrasoundRegistrationFilter is not initialized.");
msgBox.exec();
return;
}
//Set the transformation from marker-CS to the sensor-CS accordingly to the chosen user-option
m_FloatingImageToUltrasoundRegistrationFilter
->InitializeTransformationMarkerCSToSensorCS(ui->useNdiTrackerCheckBox->isChecked());
m_FloatingImageToUltrasoundRegistrationFilter->SetPointSet(pointSetNode);
m_FloatingImageToUltrasoundRegistrationFilter->SetSegmentation(segmentationNode, m_FloatingImage);
m_FloatingImageToUltrasoundRegistrationFilter->SetSurface(surfaceNode);
m_FloatingImageToUltrasoundRegistrationFilter
->SetTransformMarkerCSToFloatingImageCS(m_TransformMarkerCSToFloatingImageCS);
m_FloatingImageToUltrasoundRegistrationFilter
->SetTransformUSimageCSToTrackingCS(this->GetCombinedModality()->GetCalibration());
m_FloatingImageToUltrasoundRegistrationFilter
->ConnectTo(this->GetCombinedModality()->GetNavigationDataSource());
}
void QmitkUSNavigationStepCtUsRegistration::OnFreeze()
{
if (this->GetCombinedModality(false).IsNull())
{
return;
}
if (!m_FreezeCombinedModality)
{
m_FreezeCombinedModality = true;
ui->freezeUnfreezePushButton->setText("Unfreeze");
this->GetCombinedModality()->SetIsFreezed(true);
}
else
{
m_FreezeCombinedModality = false;
ui->freezeUnfreezePushButton->setText("Freeze");
this->GetCombinedModality()->SetIsFreezed(false);
}
}
void QmitkUSNavigationStepCtUsRegistration::OnActualizeSegmentationSurfacePointSetData()
{
mitk::DataNode* segmentationNode = ui->segmentationComboBox->GetSelectedNode();
if (segmentationNode == nullptr)
{
QMessageBox msgBox;
msgBox.setText("Cannot actualize segmentation + surface + pointset data. There is no segmentation selected.");
msgBox.exec();
return;
}
mitk::DataNode* surfaceNode = ui->selectedSurfaceComboBox->GetSelectedNode();
if (surfaceNode == nullptr)
{
QMessageBox msgBox;
msgBox.setText("Cannot actualize segmentation + surface + pointset data. There is no surface selected.");
msgBox.exec();
return;
}
mitk::DataNode* pointSetNode = ui->pointSetComboBox->GetSelectedNode();
if (pointSetNode == nullptr)
{
QMessageBox msgBox;
msgBox.setText("Cannot actualize segmentation + surface + pointset data. There is no pointSet selected.");
msgBox.exec();
return;
}
m_FloatingImageToUltrasoundRegistrationFilter->SetPointSet(pointSetNode);
m_FloatingImageToUltrasoundRegistrationFilter->SetSegmentation(segmentationNode, m_FloatingImage);
m_FloatingImageToUltrasoundRegistrationFilter->SetSurface(surfaceNode);
}
void QmitkUSNavigationStepCtUsRegistration::OnGetCursorPosition()
{
emit GetCursorPosition();
}
void QmitkUSNavigationStepCtUsRegistration::OnCalculateTRE(mitk::Point3D centroidOfTargetInUSImage)
{
mitk::DataNode::Pointer pointSetNode = ui->pointSetComboBox->GetSelectedNode();
if (pointSetNode.IsNull())
{
QMessageBox msgBox;
msgBox.setText("Cannot calculate TRE. The pointSetComboBox node returned a nullptr.");
msgBox.exec();
return;
}
mitk::PointSet::Pointer pointSet = dynamic_cast<mitk::PointSet*>(pointSetNode->GetData());
if (pointSet.IsNull())
{
ui->distanceTREValue->setText(QString("Unknown"));
return;
}
double distance = pointSet->GetPoint(0).EuclideanDistanceTo(centroidOfTargetInUSImage);
ui->distanceTREValue->setText(QString("%1").arg(distance));
}
void QmitkUSNavigationStepCtUsRegistration::OnCalculateCenter()
{
mitk::DataNode::Pointer node = ui->segmentationComboBox->GetSelectedNode();
if (node.IsNull())
{
QMessageBox msgBox;
msgBox.setText("Cannot calculate the centroid of the segmentation."\
"The segmentationComboBox node returned a nullptr.");
msgBox.exec();
return;
}
mitk::LabelSetImage::Pointer image = dynamic_cast<mitk::LabelSetImage*>(node->GetData());
if (image.IsNull())
{
MITK_WARN << "Cannot CalculateCenter - the segmentation cannot be converted to mitk::Image";
return;
}
ImageType::Pointer itkImage = ImageType::New();
mitk::CastToItkImage(image, itkImage);
//Initialize binary image to shape label map filter
BinaryImageToShapeLabelMapFilterType::Pointer shapeLabelMapFilter = BinaryImageToShapeLabelMapFilterType::New();
shapeLabelMapFilter->SetInputForegroundValue(1);
shapeLabelMapFilter->SetInput(itkImage);
shapeLabelMapFilter->Update();
BinaryImageToShapeLabelMapFilterType::OutputImageType::Pointer labelMap =
shapeLabelMapFilter->GetOutput();
for (int i = labelMap->GetNumberOfLabelObjects() - 1; i >= 0; --i)
{
// Get the ith region
BinaryImageToShapeLabelMapFilterType::OutputImageType::LabelObjectType* labelObject = labelMap->GetNthLabelObject(i);
mitk::Vector3D centroid;
centroid[0] = labelObject->GetCentroid()[0];
centroid[1] = labelObject->GetCentroid()[1];
centroid[2] = labelObject->GetCentroid()[2];
MITK_INFO << "Centroid of segmentation = " << centroid;
}
}
void QmitkUSNavigationStepCtUsRegistration::OnAddCtImageClicked()
{
mitk::DataNode* selectedCtImage = ui->ctImagesToChooseComboBox->GetSelectedNode();
if (selectedCtImage == nullptr)
{
return;
}
mitk::Image::Pointer ctImage = dynamic_cast<mitk::Image*>(selectedCtImage->GetData());
if (ctImage.IsNull())
{
MITK_WARN << "Failed to cast selected segmentation node to mitk::Image*";
return;
}
QString name = QString::fromStdString(selectedCtImage->GetName());
for( int counter = 0; counter < ui->chosenCtImagesListWidget->count(); ++counter)
{
MITK_INFO << ui->chosenCtImagesListWidget->item(counter)->text() << " - " << counter;
MITK_INFO << m_ImagesGroundTruthProtocol.at(counter).GetPointer();
if (ui->chosenCtImagesListWidget->item(counter)->text().compare(name) == 0)
{
MITK_INFO << "CT image already exist in list of chosen CT images. Do not add the image.";
return;
}
}
ui->chosenCtImagesListWidget->addItem(name);
m_ImagesGroundTruthProtocol.push_back(ctImage);
}
void QmitkUSNavigationStepCtUsRegistration::OnRemoveCtImageClicked()
{
int position = ui->chosenCtImagesListWidget->currentRow();
if (ui->chosenCtImagesListWidget->count() == 0 || position < 0)
{
return;
}
m_ImagesGroundTruthProtocol.erase(m_ImagesGroundTruthProtocol.begin() + position);
QListWidgetItem *item = ui->chosenCtImagesListWidget->currentItem();
ui->chosenCtImagesListWidget->removeItemWidget(item);
delete item;
}
void QmitkUSNavigationStepCtUsRegistration::OnEvaluateGroundTruthFiducialLocalizationProtocol()
{
m_GroundTruthProtocolFRE.clear();
if (m_ImagesGroundTruthProtocol.size() != 6)
{
QMessageBox msgBox;
msgBox.setText("For evaluating the Ground-Truth-Fiducial-Localization-Protocol there must be loaded 6 different CT images.");
msgBox.exec();
return;
}
m_PerformingGroundTruthProtocolEvaluation = true;
this->CreatePointsToTransformForGroundTruthProtocol();
m_GroundTruthProtocolTransformedPoints.clear();
for (unsigned int cycleNo = 0; cycleNo < m_ImagesGroundTruthProtocol.size(); ++cycleNo)
{
m_FloatingImage = m_ImagesGroundTruthProtocol.at(cycleNo);
this->SetFloatingImageGeometryInformation(m_FloatingImage.GetPointer());
this->OnLocalizeFiducials();
this->OnRegisterMarkerToFloatingImageCS();
this->TransformPointsGroundTruthProtocol();
}
this->AddTransformedPointsToDataStorage();
double meanFRE = this->CalculateMeanFRE();
double sdOfFRE = this->CalculateStandardDeviationOfFRE(meanFRE);
this->CalculateGroundTruthProtocolTRE();
ui->meanFREValue->setText(QString("%1").arg(meanFRE));
ui->sdFREValue->setText(QString("%1").arg(sdOfFRE));
if (ui->protocolEvaluationTypeComboBox->currentText().compare("ANGLE") == 0)
{
if (m_GroundTruthProtocolTRE.find(0) != m_GroundTruthProtocolTRE.end())
{
ui->TREValue->setText(QString("%1").arg(m_GroundTruthProtocolTRE.at(0)));
}
}
else if (ui->protocolEvaluationTypeComboBox->currentText().compare("PLANE") == 0)
{
if (m_GroundTruthProtocolTRE.find(0) != m_GroundTruthProtocolTRE.end() &&
m_GroundTruthProtocolTRE.find(20) != m_GroundTruthProtocolTRE.end() &&
m_GroundTruthProtocolTRE.find(40) != m_GroundTruthProtocolTRE.end() &&
m_GroundTruthProtocolTRE.find(60) != m_GroundTruthProtocolTRE.end() &&
m_GroundTruthProtocolTRE.find(80) != m_GroundTruthProtocolTRE.end() &&
m_GroundTruthProtocolTRE.find(100) != m_GroundTruthProtocolTRE.end())
{
ui->TREValue->setText(QString("Depth 0mm: %1\nDepth 20mm: %2\nDepth 40mm: %3\
\nDepth 60mm: %4\nDepth 80mm: %5\nDepth 100mm: %6")
.arg(m_GroundTruthProtocolTRE.at(0))
.arg(m_GroundTruthProtocolTRE.at(20))
.arg(m_GroundTruthProtocolTRE.at(40))
.arg(m_GroundTruthProtocolTRE.at(60))
.arg(m_GroundTruthProtocolTRE.at(80))
.arg(m_GroundTruthProtocolTRE.at(100)));
}
}
m_PerformingGroundTruthProtocolEvaluation = false;
}
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.cpp b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.cpp
index 14450e93af..7fd7430f85 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.cpp
@@ -1,290 +1,290 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkUSNavigationStepPunctuationIntervention.h"
#include "ui_QmitkUSNavigationStepPunctuationIntervention.h"
#include "mitkNeedleProjectionFilter.h"
#include "../Widgets/QmitkZoneProgressBar.h"
#include "../QmitkUSNavigationMarkerPlacement.h"
#include "usModuleRegistry.h"
#include <mitkTrackingTypes.h>
QmitkUSNavigationStepPunctuationIntervention::QmitkUSNavigationStepPunctuationIntervention(QWidget *parent) :
QmitkUSAbstractNavigationStep(parent),
m_Ui(new Ui::QmitkUSNavigationStepPunctuationIntervention),
m_ZoneNodes(nullptr),
m_NeedleProjectionFilter(mitk::NeedleProjectionFilter::New()),
m_NeedleNavigationTool(mitk::NavigationTool::New()),
m_OldColors(),
m_SphereSource(vtkSmartPointer<vtkSphereSource>::New()),
m_OBBTree(vtkSmartPointer<vtkOBBTree>::New()),
m_IntersectPoints(vtkSmartPointer<vtkPoints>::New())
{
m_Ui->setupUi(this);
connect(m_Ui->m_AddNewAblationZone, SIGNAL(clicked()), this, SLOT(OnAddAblationZoneClicked()));
connect(m_Ui->m_ShowToolAxisN, SIGNAL(stateChanged(int)), this, SLOT(OnShowToolAxisEnabled(int)));
connect(m_Ui->m_EnableAblationMarking, SIGNAL(clicked()), this, SLOT(OnEnableAblationZoneMarkingClicked()));
connect(m_Ui->m_AblationZoneSizeSlider, SIGNAL(valueChanged(int)), this, SLOT(OnAblationZoneSizeSliderChanged(int)));
m_Ui->m_AblationZonesBox->setVisible(false);
}
void QmitkUSNavigationStepPunctuationIntervention::SetNeedleMetaData(mitk::NavigationTool::Pointer needleNavigationTool)
{
this->m_NeedleNavigationTool = needleNavigationTool;
}
void QmitkUSNavigationStepPunctuationIntervention::OnEnableAblationZoneMarkingClicked()
{
if(m_Ui->m_EnableAblationMarking->isChecked())
m_Ui->m_AblationZonesBox->setVisible(true);
else
m_Ui->m_AblationZonesBox->setVisible(false);
}
void QmitkUSNavigationStepPunctuationIntervention::OnAblationZoneSizeSliderChanged(int size)
{
int id = m_Ui->m_AblationZonesList->currentRow();
if (id!=-1) {emit AblationZoneChanged(id,size);}
}//
void QmitkUSNavigationStepPunctuationIntervention::OnAddAblationZoneClicked()
{
QListWidgetItem* newItem = new QListWidgetItem("Ablation Zone (initial size: " + QString::number(m_Ui->m_AblationZoneSizeSlider->value()) + " mm)", m_Ui->m_AblationZonesList);
newItem->setSelected(true);
emit AddAblationZoneClicked(m_Ui->m_AblationZoneSizeSlider->value());
}
QmitkUSNavigationStepPunctuationIntervention::~QmitkUSNavigationStepPunctuationIntervention()
{
mitk::DataStorage::Pointer dataStorage = this->GetDataStorage(false);
if ( dataStorage.IsNotNull() )
{
// remove needle path from data storage if it is there
mitk::DataNode::Pointer node = this->GetNamedDerivedNode
("Needle Path", QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
if ( node.IsNotNull() ) { dataStorage->Remove(node); }
}
delete m_Ui;
}
bool QmitkUSNavigationStepPunctuationIntervention::OnStartStep()
{
// create node for Needle Projection
mitk::DataNode::Pointer node = this->GetNamedDerivedNodeAndCreate
("Needle Path", QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
node->SetData(m_NeedleProjectionFilter->GetProjection());
node->SetBoolProperty("show contour", true);
//m_NeedleProjectionFilter->SetToolAxisForFilter(m_NeedleNavigationTool->GetToolAxis());
return true;
}
bool QmitkUSNavigationStepPunctuationIntervention::OnRestartStep()
{
return this->OnActivateStep();
}
bool QmitkUSNavigationStepPunctuationIntervention::OnFinishStep()
{
mitk::DataNode::Pointer finishPunctionResult = mitk::DataNode::New();
finishPunctionResult->SetName("PunctionResult");
mitk::Point3D needlePos = m_NeedleProjectionFilter->GetOutput(0)->GetPosition();
mitk::Quaternion needleRot = m_NeedleProjectionFilter->GetOutput(0)->GetOrientation();
finishPunctionResult->SetProperty("USNavigation::TipPositionEnd", mitk::Point3dProperty::New(needlePos));
MITK_INFO("USNavigationLogging") << "Instrument tip at end: " <<needlePos<< " / " << needleRot;
emit SignalIntermediateResult(finishPunctionResult);
return true;
}
bool QmitkUSNavigationStepPunctuationIntervention::OnActivateStep()
{
this->ClearZones();
mitk::DataStorage::Pointer dataStorage = this->GetDataStorage();
// add progress bars for risk zone nodes
m_ZoneNodes = dataStorage->GetDerivations(dataStorage->GetNamedNode(QmitkUSNavigationMarkerPlacement::DATANAME_ZONES));
// add zones to the widgets for risk structures
for (mitk::DataStorage::SetOfObjects::ConstIterator it = m_ZoneNodes->Begin();
it != m_ZoneNodes->End(); ++it)
{
m_Ui->riskStructuresRangeWidget->AddZone(it->Value());
float rgb[3];
it->Value()->GetColor(rgb);
mitk::Color color;
color.SetRed(rgb[0]);
color.SetGreen(rgb[1]);
color.SetBlue(rgb[2]);
m_OldColors[it->Value()] = color;
}
m_NeedleProjectionFilter->SelectInput(0);
return true;
}
void QmitkUSNavigationStepPunctuationIntervention::OnShowToolAxisEnabled(int enabled)
{
if (enabled == 0) { m_NeedleProjectionFilter->ShowToolAxis(false); }
else { m_NeedleProjectionFilter->ShowToolAxis(true); }
}
void QmitkUSNavigationStepPunctuationIntervention::OnUpdate()
{
if (this->GetCombinedModality(false).IsNull()) return;
// get navigation data source and make sure that it is not null
mitk::NavigationDataSource::Pointer navigationDataSource =
this->GetCombinedModality()->GetNavigationDataSource();
if ( navigationDataSource.IsNull() )
{
MITK_ERROR("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepPunctuationIntervention")
<< "Navigation Data Source of Combined Modality must not be null.";
mitkThrow() << "Navigation Data Source of Combined Modality must not be null.";
}
// update body marker
this->UpdateBodyMarkerStatus(navigationDataSource->GetOutput(1));
// update critical structures
this->UpdateCriticalStructures(navigationDataSource->GetOutput(0),m_NeedleProjectionFilter->GetProjection());
m_NeedleProjectionFilter->Update();
//Update Distance to US image
mitk::Point3D point1 = m_NeedleProjectionFilter->GetProjection()->GetPoint(0);
mitk::Point3D point2 = m_NeedleProjectionFilter->GetProjection()->GetPoint(1);
double distance = point1.EuclideanDistanceTo(point2);
m_Ui->m_DistanceToUSPlane->setText(QString::number(distance) + " mm");
}
void QmitkUSNavigationStepPunctuationIntervention::OnSettingsChanged(const itk::SmartPointer<mitk::DataNode> settingsNode)
{
if ( settingsNode.IsNull() ) { return; }
}
QString QmitkUSNavigationStepPunctuationIntervention::GetTitle()
{
return "Computer-assisted Intervention";
}
bool QmitkUSNavigationStepPunctuationIntervention::GetIsRestartable()
{
return false;
}
QmitkUSNavigationStepPunctuationIntervention::FilterVector QmitkUSNavigationStepPunctuationIntervention::GetFilter()
{
return FilterVector(1, m_NeedleProjectionFilter.GetPointer());
}
void QmitkUSNavigationStepPunctuationIntervention::OnSetCombinedModality()
{
mitk::AbstractUltrasoundTrackerDevice::Pointer combinedModality = this->GetCombinedModality(false);
if ( combinedModality.IsNotNull() )
{
m_NeedleProjectionFilter->ConnectTo(combinedModality->GetNavigationDataSource());
// set calibration of the combined modality to the needle projection filter
mitk::AffineTransform3D::Pointer usPlaneTransform = combinedModality->GetUSPlaneTransform();
if (usPlaneTransform.IsNotNull())
{
m_NeedleProjectionFilter->SetTargetPlane(usPlaneTransform);
}
}
else
{
MITK_WARN << "CombinedModality is null!";
}
}
void QmitkUSNavigationStepPunctuationIntervention::ClearZones()
{
m_Ui->riskStructuresRangeWidget->ClearZones();
}
void QmitkUSNavigationStepPunctuationIntervention::UpdateBodyMarkerStatus(mitk::NavigationData::Pointer bodyMarker)
{
if ( bodyMarker.IsNull() )
{
MITK_ERROR("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepPunctuationIntervention")
<< "Current Navigation Data for body marker of Combined Modality must not be null.";
mitkThrow() << "Current Navigation Data for body marker of Combined Modality must not be null.";
}
bool valid = bodyMarker->IsDataValid();
// update body marker status label
if (valid)
{
m_Ui->bodyMarkerTrackingStatusLabel->setStyleSheet(
"background-color: #8bff8b; margin-right: 1em; margin-left: 1em; border: 1px solid grey");
m_Ui->bodyMarkerTrackingStatusLabel->setText("Body marker is inside the tracking volume.");
}
else
{
m_Ui->bodyMarkerTrackingStatusLabel->setStyleSheet(
"background-color: #ff7878; margin-right: 1em; margin-left: 1em; border: 1px solid grey");
m_Ui->bodyMarkerTrackingStatusLabel->setText("Body marker is not inside the tracking volume.");
}
m_Ui->riskStructuresRangeGroupBox->setEnabled(valid);
}
void QmitkUSNavigationStepPunctuationIntervention::UpdateCriticalStructures(mitk::NavigationData::Pointer needle, mitk::PointSet::Pointer path)
{
// update the distances for the risk structures widget
m_Ui->riskStructuresRangeWidget->UpdateDistancesToNeedlePosition(needle);
//iterate through all zones
for (mitk::DataStorage::SetOfObjects::ConstIterator it = m_ZoneNodes->Begin();
it != m_ZoneNodes->End(); ++it)
{
mitk::DataNode::Pointer currentNode = it->Value();
//get center point and radius
float radius = -1;
mitk::Point3D center;
currentNode->GetFloatProperty("zone.size", radius);
- center = currentNode->GetData()->GetGeometry()->GetIndexToWorldTransform()->GetTranslation();
+ center = mitk::Point3D(currentNode->GetData()->GetGeometry()->GetIndexToWorldTransform()->GetTranslation());
mitk::Point3D point0 = path->GetPoint(0);
mitk::Point3D point1 = path->GetPoint(1);
if (CheckSphereLineIntersection(center,radius,point0,point1))
{currentNode->SetColor(mitk::IGTColor_WARNING);}
else
{currentNode->SetColor(m_OldColors[currentNode]);}
}
}
bool QmitkUSNavigationStepPunctuationIntervention::CheckSphereLineIntersection(mitk::Point3D& sphereOrigin, float& sphereRadius, mitk::Point3D& lineStart, mitk::Point3D& lineEnd)
{
double center[3] = {sphereOrigin[0],sphereOrigin[1],sphereOrigin[2]};
m_SphereSource->SetCenter(center);
m_SphereSource->SetRadius(sphereRadius);
m_SphereSource->Update();
m_OBBTree->SetDataSet(m_SphereSource->GetOutput());
m_OBBTree->BuildLocator();
double lineP0[3] = {lineStart[0], lineStart[1], lineStart[2]};
double lineP1[3] = {lineEnd[0], lineEnd[1], lineEnd[2]};
m_OBBTree->IntersectWithLine(lineP0, lineP1, m_IntersectPoints, nullptr);
if (m_IntersectPoints->GetNumberOfPoints() > 0) {return true;}
else {return false;}
}
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkIGTNavigationToolCalibration.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkIGTNavigationToolCalibration.cpp
index 9b73b74a67..74ac043b7c 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkIGTNavigationToolCalibration.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkIGTNavigationToolCalibration.cpp
@@ -1,756 +1,756 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <numeric>
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "QmitkIGTNavigationToolCalibration.h"
// mitk
#include <mitkNavigationToolWriter.h>
#include <mitkTrackingDeviceSource.h>
#include <mitkTrackingDevice.h>
#include <mitkTrackingTool.h>
#include <mitkQuaternionAveraging.h>
#include <mitkPivotCalibration.h>
#include <mitkNavigationData.h>
// Qt
#include <QMessageBox>
#include <QFileDialog>
#include <QFileInfo>
// vtk
#include <vtkSphereSource.h>
const std::string QmitkIGTNavigationToolCalibration::VIEW_ID = "org.mitk.views.igtnavigationtoolcalibration";
QmitkIGTNavigationToolCalibration::QmitkIGTNavigationToolCalibration()
{
m_ToolTransformationWidget = new QmitkInteractiveTransformationWidget();
}
QmitkIGTNavigationToolCalibration::~QmitkIGTNavigationToolCalibration()
{
//The following code is required due to a bug in the point list widget.
//If this is removed, MITK crashes when closing the view:
m_Controls.m_RegistrationLandmarkWidget->SetPointSetNode(nullptr);
m_Controls.m_CalibrationLandmarkWidget->SetPointSetNode(nullptr);
//clean up data storage
this->GetDataStorage()->Remove(m_ToolTipPointPreview);
delete m_ToolTransformationWidget;
}
void QmitkIGTNavigationToolCalibration::SetFocus()
{
}
void QmitkIGTNavigationToolCalibration::OnToolCalibrationMethodChanged(int index)
{
//if pivot calibration (3) or manual(0) is chosen only calibration pointer is needed
if (index == 0 || index == 3) {
if (!CheckInitialization(false)) {
return;
}
}
else{
if (!CheckInitialization()) { return; }
}
UpdateManualToolTipCalibrationView();
m_Controls.m_CalibrationMethodsWidget->setCurrentIndex(index);
m_IndexCurrentCalibrationMethod = index;
}
void QmitkIGTNavigationToolCalibration::CreateQtPartControl(QWidget *parent)
{
m_TrackingTimer = new QTimer(this);
// create GUI widgets from the Qt Designer's .ui file
m_Controls.setupUi(parent);
connect(m_Controls.m_SetToolToCalibrate, SIGNAL(clicked()), this, SLOT(SetToolToCalibrate()));
connect(m_Controls.m_SetPointer, SIGNAL(clicked()), this, SLOT(SetCalibrationPointer()));
connect(m_TrackingTimer, SIGNAL(timeout()), this, SLOT(UpdateTrackingTimer()));
connect(m_Controls.m_AddLandmark, SIGNAL(clicked()), this, SLOT(AddLandmark()));
connect(m_Controls.m_SaveCalibratedTool, SIGNAL(clicked()), this, SLOT(SaveCalibratedTool()));
connect(m_Controls.m_AddPivotPose, SIGNAL(clicked()), this, SLOT(OnAddPivotPose()));
connect(m_Controls.m_ComputePivot, SIGNAL(clicked()), this, SLOT(OnComputePivot()));
connect(m_Controls.m_UseComputedPivotPoint, SIGNAL(clicked()), this, SLOT(OnUseComputedPivotPoint()));
connect(m_Controls.m_StartEditTooltipManually, SIGNAL(clicked()), this, SLOT(OnStartManualToolTipCalibration()));
connect(m_Controls.m_GetPositions, SIGNAL(clicked()), this, SLOT(OnGetPositions()));
connect(m_Controls.m_ToolAxis_X, SIGNAL(valueChanged(double)), this, SLOT(OnToolAxisSpinboxChanged()));
connect(m_Controls.m_ToolAxis_Y, SIGNAL(valueChanged(double)), this, SLOT(OnToolAxisSpinboxChanged()));
connect(m_Controls.m_ToolAxis_Z, SIGNAL(valueChanged(double)), this, SLOT(OnToolAxisSpinboxChanged()));
connect(m_Controls.m_CalibrateToolAxis, SIGNAL(clicked()), this, SLOT(OnCalibrateToolAxis()));
connect((QObject*)(m_ToolTransformationWidget), SIGNAL(EditToolTipFinished(mitk::AffineTransform3D::Pointer)), this,
SLOT(OnManualEditToolTipFinished(mitk::AffineTransform3D::Pointer)));
connect(m_Controls.m_CalibrationMethodComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnToolCalibrationMethodChanged(int)));
connect((QObject*)(m_Controls.m_RunCalibrationButton), SIGNAL(clicked()), (QObject*) this, SLOT(OnRunSingleRefToolCalibrationClicked()));
connect((QObject*)(m_Controls.m_CollectNavigationDataButton), SIGNAL(clicked()), (QObject*) this, SLOT(OnLoginSingleRefToolNavigationDataClicked()));
connect((QObject*)(m_Controls.m_SetNewToolTipPosButton), SIGNAL(clicked()), (QObject*) this, SLOT(OnSetNewToolTipPosButtonClicked()));
m_IDToolToCalibrate = -1;
m_IDCalibrationPointer = -1;
m_IndexCurrentCalibrationMethod = -1;
m_OnLoginSingleRefToolNavigationDataClicked = false;
m_NumberOfNavigationDataCounter = 0;
m_NumberOfNavigationData = -1;
//for pivot calibration
m_OnAddPivotPoseClicked = false;
PivotCount = 0;
m_PivotPoses = std::vector<mitk::NavigationData::Pointer>();
m_CalibrationLandmarks = mitk::PointSet::New();
m_CalibrationLandmarksNode = mitk::DataNode::New();
m_CalibrationLandmarksNode->SetData(m_CalibrationLandmarks);
m_Controls.m_CalibrationLandmarkWidget->SetPointSetNode(m_CalibrationLandmarksNode);
m_RegistrationLandmarks = mitk::PointSet::New();
m_RegistrationLandmarksNode = mitk::DataNode::New();
m_RegistrationLandmarksNode->SetData(m_RegistrationLandmarks);
m_Controls.m_RegistrationLandmarkWidget->SetPointSetNode(m_RegistrationLandmarksNode);
m_ToolSurfaceInToolCoordinatesDataNode = mitk::DataNode::New();
m_ToolSurfaceInToolCoordinatesDataNode->SetName("ToolSurface(ToolCoordinates)");
m_LoggedNavigationDataDifferences = std::vector< mitk::NavigationData::Pointer >();
}
void QmitkIGTNavigationToolCalibration::OnRunSingleRefToolCalibrationClicked()
{
if (!CheckInitialization()) { return; }
mitk::NavigationData::Pointer ToolTipTransform = mitk::NavigationData::New();
if (m_Controls.m_CalibratePosition->isChecked())
{
//1: Compute mean translational offset vector
m_ResultOffsetVector.Fill(0);
for (std::vector<mitk::Point3D>::iterator vecIter = m_LoggedNavigationDataOffsets.begin(); vecIter != m_LoggedNavigationDataOffsets.end(); vecIter++)
{
m_ResultOffsetVector[0] = m_ResultOffsetVector[0] + (*vecIter)[0];
m_ResultOffsetVector[1] = m_ResultOffsetVector[1] + (*vecIter)[1];
m_ResultOffsetVector[2] = m_ResultOffsetVector[2] + (*vecIter)[2];
}
m_ResultOffsetVector[0] = m_ResultOffsetVector[0] / m_LoggedNavigationDataOffsets.size();
m_ResultOffsetVector[1] = m_ResultOffsetVector[1] / m_LoggedNavigationDataOffsets.size();
m_ResultOffsetVector[2] = m_ResultOffsetVector[2] / m_LoggedNavigationDataOffsets.size();
this->m_Controls.m_ResultOfCalibration->setText(
QString("x: ") + QString(QString::number(m_ResultOffsetVector[0], 103, 3)) +
QString("; y: ") + (QString::number(m_ResultOffsetVector[1], 103, 3)) +
QString("; z: ") + (QString::number(m_ResultOffsetVector[2], 103, 3)));
ToolTipTransform->SetPosition(m_ResultOffsetVector);
}
if (m_Controls.m_CalibrateOrientation->isChecked())
{
//2: Compute mean orientation
mitk::Quaternion meanOrientation;
std::vector <mitk::Quaternion> allOrientations = std::vector <mitk::Quaternion>();
for (std::size_t i = 0; i < m_LoggedNavigationDataDifferences.size(); i++) { allOrientations.push_back(m_LoggedNavigationDataDifferences.at(i)->GetOrientation()); }
meanOrientation = mitk::QuaternionAveraging::CalcAverage(allOrientations);
this->m_Controls.m_ResultOfCalibrationOrientation->setText(
QString("qx: ") + QString(QString::number(meanOrientation.x(), 103, 3)) +
QString("; qy: ") + (QString::number(meanOrientation.y(), 103, 3)) +
QString("; qz: ") + (QString::number(meanOrientation.z(), 103, 3)) +
QString("; qr: ") + (QString::number(meanOrientation.r(), 103, 3)));
ToolTipTransform->SetOrientation(meanOrientation);
}
MITK_INFO << "Computed calibration: ";
MITK_INFO << "Translation Vector: " << ToolTipTransform->GetPosition();
MITK_INFO << "Quaternion: (" << ToolTipTransform->GetOrientation() << ")";
MITK_INFO << "Euler Angles [rad]: (" << ToolTipTransform->GetOrientation().rotation_euler_angles() << ")";
MITK_INFO << "Matrix:";
vnl_matrix_fixed<double, 3, 3> rotMatrix = ToolTipTransform->GetOrientation().rotation_matrix_transpose();
MITK_INFO << rotMatrix[0][0] << " " << rotMatrix[0][1] << " " << rotMatrix[0][2] << std::endl;
MITK_INFO << rotMatrix[1][0] << " " << rotMatrix[1][1] << " " << rotMatrix[1][2] << std::endl;
MITK_INFO << rotMatrix[2][0] << " " << rotMatrix[2][1] << " " << rotMatrix[2][2] << std::endl;
//3: write everything into the final tool tip transform and save it as member (it will be written to the tool later on)
mitk::NavigationData::Pointer ToolTipInTrackingCoordinates = mitk::NavigationData::New();
ToolTipInTrackingCoordinates->Compose(ToolTipTransform);
ToolTipInTrackingCoordinates->Compose(m_NavigationDataSourceOfToolToCalibrate->GetOutput(m_IDToolToCalibrate));
ShowToolTipPreview(ToolTipInTrackingCoordinates);
m_Controls.m_SetNewToolTipPosButton->setEnabled(true);
m_ComputedToolTipTransformation = ToolTipTransform;
}
void QmitkIGTNavigationToolCalibration::OnLoginSingleRefToolNavigationDataClicked()
{
if (!CheckInitialization()) { return; }
//reset old data
m_LoggedNavigationDataOffsets.clear();
m_LoggedNavigationDataDifferences.clear();
m_OnLoginSingleRefToolNavigationDataClicked = true;
m_Controls.m_CollectNavigationDataButton->setEnabled(false);
m_NumberOfNavigationData = m_Controls.m_NumberOfNavigationDataToCollect->value();
MITK_INFO << "Collecting " << m_NumberOfNavigationData << " NavigationData ... " << endl;
}
void QmitkIGTNavigationToolCalibration::LoginSingleRefToolNavigationData()
{
if (!CheckInitialization()) { return; }
if (m_NumberOfNavigationDataCounter < m_NumberOfNavigationData)
{
//update label text
QString labelText = "Collecting Data: " + QString::number(m_NumberOfNavigationDataCounter);
m_Controls.m_CollectionStatus->setText(labelText);
mitk::NavigationData::Pointer referenceTool = m_NavigationDataSourceOfCalibrationPointer->GetOutput(m_IDCalibrationPointer);
mitk::NavigationData::Pointer toolToCalibrate = m_NavigationDataSourceOfToolToCalibrate->GetOutput(m_IDToolToCalibrate);
//compute difference:
// differenceND = toolToCalibrate^-1 * referenceTool
mitk::NavigationData::Pointer differenceND = mitk::NavigationData::New();
differenceND->Compose(referenceTool);
differenceND->Compose(toolToCalibrate->GetInverse());
//inverse mode...
if (m_Controls.m_InvertQuaternions->isChecked())
{
// negate identity matrix to directly show parameters that will set up in NDI 6D Software Architect
differenceND = differenceND->GetInverse();
}
//save difference in member
m_LoggedNavigationDataOffsets.push_back(differenceND->GetPosition());
m_LoggedNavigationDataDifferences.push_back(differenceND);
m_NumberOfNavigationDataCounter++;
}
if (m_NumberOfNavigationDataCounter == m_NumberOfNavigationData)
{
m_NumberOfNavigationDataCounter = 0;
m_OnLoginSingleRefToolNavigationDataClicked = false;
m_Controls.m_CollectNavigationDataButton->setEnabled(true);
m_Controls.m_RunCalibrationButton->setEnabled(true);
MITK_INFO << "Collecting " << m_NumberOfNavigationData << " NavigationData ... Finished" << endl;
QString labelText = "Collected " + QString::number(m_NumberOfNavigationData) + " data samples!";
m_Controls.m_CollectionStatus->setText(labelText);
}
}
void QmitkIGTNavigationToolCalibration::OnSetNewToolTipPosButtonClicked()
{
ApplyToolTipTransform(m_ComputedToolTipTransformation);
RemoveToolTipPreview();
}
void QmitkIGTNavigationToolCalibration::ClearOldPivot()
{
mitk::NavigationData::Pointer tempND = mitk::NavigationData::New();
this->ApplyToolTipTransform(tempND);
UpdateManualToolTipCalibrationView();
//m_ManualToolTipEditWidget->hide(); //TODO
this->GetDataStorage()->Remove(m_ToolSurfaceInToolCoordinatesDataNode);
}
void QmitkIGTNavigationToolCalibration::OnAddPivotPose()
{
ClearOldPivot();
//When the collect Poses Button is Clicked
m_OnAddPivotPoseClicked = true;
m_NumberOfNavigationData = m_Controls.m_PosesToCollect->value();
}
void QmitkIGTNavigationToolCalibration::AddPivotPose()
{
//Save the poses to be used in computation
if (PivotCount < m_NumberOfNavigationData)
{
mitk::NavigationData::Pointer currentPose = mitk::NavigationData::New();
currentPose->Graft(m_Controls.m_SelectionWidget->GetSelectedNavigationDataSource()->GetOutput(m_IDToolToCalibrate));
m_PivotPoses.push_back(currentPose);
m_Controls.m_PoseNumber->setText(QString::number(m_PivotPoses.size()));
PivotCount++;
}
if (PivotCount == m_NumberOfNavigationData)
{
m_OnAddPivotPoseClicked = false;
}
}
void QmitkIGTNavigationToolCalibration::OnComputePivot()
{
mitk::PivotCalibration::Pointer myPivotCalibration = mitk::PivotCalibration::New();
for (std::size_t i = 0; i < this->m_PivotPoses.size(); i++)
{
myPivotCalibration->AddNavigationData(m_PivotPoses.at(i));
}
QString resultString;
if (myPivotCalibration->ComputePivotResult())
{
mitk::NavigationData::Pointer markerTransformationTrackingCoordinates = m_PivotPoses.at(0);
//Get computed pivot transfromation in tool coordinates
mitk::NavigationData::Pointer ToolTipToTool = mitk::NavigationData::New();
ToolTipToTool->SetPosition(myPivotCalibration->GetResultPivotPoint());
ToolTipToTool->SetOrientation(mitk::Quaternion(0,0,0,1));
mitk::NavigationData::Pointer TrackerToTool = mitk::NavigationData::New();
TrackerToTool->SetOrientation(markerTransformationTrackingCoordinates->GetOrientation());
TrackerToTool->SetPosition(markerTransformationTrackingCoordinates->GetPosition());
TrackerToTool->Compose(ToolTipToTool);
// Compute pivot point in relation to marker transformation for preview
mitk::NavigationData::Pointer ToolTipToTracker = mitk::NavigationData::New();
ToolTipToTracker->Compose(ToolTipToTool);
ToolTipToTracker->Compose(markerTransformationTrackingCoordinates);
//add the preview node to the data storage
ShowToolTipPreview(ToolTipToTracker);
//parse result string
resultString = QString("Pivot computation succeeded!\n")
+ QString("RMS Error: ") + QString::number(myPivotCalibration->GetResultRMSError()) + QString("\n")
+ QString("Pivot Point: ") + QString::number(myPivotCalibration->GetResultPivotPoint()[0]) + ";" + QString::number(myPivotCalibration->GetResultPivotPoint()[1]) + ";" + QString::number(myPivotCalibration->GetResultPivotPoint()[2]) + QString("\n");
//finally: save results to member variable
m_ComputedToolTipTransformation = ToolTipToTool;
//enable button to use the computed point with the tool
m_Controls.m_UseComputedPivotPoint->setEnabled(true);
}
else
{
resultString = "Pivot computation failed!";
}
MITK_INFO << resultString.toStdString().c_str();
m_Controls.m_ResultText->setText(resultString);
}
void QmitkIGTNavigationToolCalibration::UpdatePivotCount()
{
PivotCount = 0;
while (!m_PivotPoses.empty())
{
m_PivotPoses.pop_back();
}
m_Controls.m_PoseNumber->setText(QString::number(PivotCount));
}
void QmitkIGTNavigationToolCalibration::OnUseComputedPivotPoint()
{
RemoveToolTipPreview();
QString resultString = QString("Pivoted tool tip transformation was written to the tool ") + m_ToolToCalibrate->GetToolName().c_str();
ApplyToolTipTransform(m_ComputedToolTipTransformation, resultString.toStdString());
m_Controls.m_ResultText->setText(resultString);
UpdatePivotCount();
}
void QmitkIGTNavigationToolCalibration::ApplyToolTipTransform(mitk::NavigationData::Pointer ToolTipTransformInToolCoordinates, std::string message)
{
if (!CheckInitialization(false)) { return; }
//Update tool in tool storage
m_ToolToCalibrate->SetToolTipPosition(ToolTipTransformInToolCoordinates->GetPosition());
m_ToolToCalibrate->SetToolAxisOrientation(ToolTipTransformInToolCoordinates->GetOrientation());
//And also update tracking device, so the transform is directly used
mitk::TrackingDeviceSource::Pointer trackingDeviceSource;
try
{
trackingDeviceSource = dynamic_cast<mitk::TrackingDeviceSource*>(m_NavigationDataSourceOfToolToCalibrate.GetPointer());
mitk::TrackingTool::Pointer TrackingToolToCalibrate = trackingDeviceSource->GetTrackingDevice()->GetTool(m_IDToolToCalibrate);
TrackingToolToCalibrate->SetToolTipPosition(ToolTipTransformInToolCoordinates->GetPosition(), ToolTipTransformInToolCoordinates->GetOrientation());
}
catch (std::exception& e)
{
MITK_ERROR << "Error while trying to set the tool tip to the running tracking device. Aborting! (" << e.what() << ")";
}
MITK_INFO << message;
}
void QmitkIGTNavigationToolCalibration::ShowToolTipPreview(mitk::NavigationData::Pointer ToolTipInTrackingCoordinates)
{
if(m_ToolTipPointPreview.IsNull())
{
m_ToolTipPointPreview = mitk::DataNode::New();
m_ToolTipPointPreview->SetName("Modified Tool Tip Preview");
mitk::Color blue;
blue.SetBlue(1);
m_ToolTipPointPreview->SetColor(blue);
mitk::Surface::Pointer mySphere = mitk::Surface::New();
vtkSmartPointer<vtkSphereSource> vtkData = vtkSmartPointer<vtkSphereSource>::New();
vtkData->SetRadius(3.0f);
vtkData->SetCenter(0.0, 0.0, 0.0);
vtkData->Update();
mySphere->SetVtkPolyData(vtkData->GetOutput());
m_ToolTipPointPreview->SetData(mySphere);
this->GetDataStorage()->Add(m_ToolTipPointPreview);
}
m_ToolTipPointPreview->GetData()->GetGeometry()->SetIndexToWorldTransform(ToolTipInTrackingCoordinates->GetAffineTransform3D());
}
void QmitkIGTNavigationToolCalibration::RemoveToolTipPreview()
{
this->GetDataStorage()->Remove(m_ToolTipPointPreview.GetPointer());
}
void QmitkIGTNavigationToolCalibration::UpdateManualToolTipCalibrationView()
{
if (m_ToolToCalibrate.IsNull()) { return; }
//parse human readable transformation data and display it
std::stringstream translation;
std::stringstream orientation;
translation << m_ToolToCalibrate->GetToolTipPosition();
orientation << "Quaternion: (" << m_ToolToCalibrate->GetToolAxisOrientation() << ")" << std::endl;
orientation << std::endl;
orientation << "Euler Angles [rad]: (" << m_ToolToCalibrate->GetToolAxisOrientation().rotation_euler_angles() << ")" << std::endl;
orientation << std::endl;
orientation << "Matrix:" << std::endl;
vnl_matrix_fixed<double, 3, 3> rotMatrix = m_ToolToCalibrate->GetToolAxisOrientation().rotation_matrix_transpose();
orientation << rotMatrix[0][0] << " " << rotMatrix[0][1] << " " << rotMatrix[0][2] << std::endl;
orientation << rotMatrix[1][0] << " " << rotMatrix[1][1] << " " << rotMatrix[1][2] << std::endl;
orientation << rotMatrix[2][0] << " " << rotMatrix[2][1] << " " << rotMatrix[2][2] << std::endl;
m_Controls.m_ManualCurrentTranslation->setText(translation.str().c_str());
m_Controls.m_ManualCurrentOrientation->setPlainText(orientation.str().c_str());
}
void QmitkIGTNavigationToolCalibration::OnStartManualToolTipCalibration()
{
if (!CheckInitialization(false)) { return; }
m_ToolTransformationWidget->SetToolToEdit(m_ToolToCalibrate);
m_ToolTransformationWidget->SetDefaultOffset(m_ToolToCalibrate->GetToolTipPosition());
m_ToolTransformationWidget->SetDefaultRotation(m_ToolToCalibrate->GetToolAxisOrientation());
m_ToolTransformationWidget->open();
}
void QmitkIGTNavigationToolCalibration::OnManualEditToolTipFinished(mitk::AffineTransform3D::Pointer toolTip)
{
//This function is called, when the toolTipEdit view is closed.
//if user pressed cancle, nullptr is returned. Do nothing. Else, set values.
if (toolTip)
{
mitk::NavigationData::Pointer tempND = mitk::NavigationData::New(toolTip);//Convert to Navigation data for simple transversion to quaternion
QString resultString = QString("Manual edited values are written to ") + m_ToolToCalibrate->GetToolName().c_str();
ApplyToolTipTransform(tempND, resultString.toStdString());
m_Controls.m_ResultText->setText(resultString);
m_ComputedToolTipTransformation = tempND;
}
UpdateManualToolTipCalibrationView();
}
void QmitkIGTNavigationToolCalibration::OnGetPositions()
{
if (!CheckInitialization(true)) { return; }
//Navigation Data from Tool which should be calibrated
if (!m_AxisCalibration_ToolToCalibrate)
m_AxisCalibration_ToolToCalibrate = mitk::NavigationData::New();
m_AxisCalibration_ToolToCalibrate->Graft(m_Controls.m_SelectionWidget->GetSelectedNavigationDataSource()->GetOutput(m_IDToolToCalibrate));
//Navigation Data from calibration pointer tool
if (!m_AxisCalibration_NavDataCalibratingTool)
m_AxisCalibration_NavDataCalibratingTool = mitk::NavigationData::New();
m_AxisCalibration_NavDataCalibratingTool->Graft(m_Controls.m_SelectionWidget->GetSelectedNavigationDataSource()->GetOutput(m_IDCalibrationPointer));
MITK_DEBUG << "Positions for tool axis calibration:";
MITK_DEBUG << " ToolTip: " << m_AxisCalibration_ToolToCalibrate->GetPosition() << ",";
MITK_DEBUG << " Rotation: \n" << m_AxisCalibration_ToolToCalibrate->GetRotationMatrix();
MITK_DEBUG << " End of the tool: " << m_AxisCalibration_NavDataCalibratingTool->GetPosition();
QString _label = "Position recorded: " + QString::number(m_AxisCalibration_NavDataCalibratingTool->GetPosition()[0], 'f', 1) + ", "
+ QString::number(m_AxisCalibration_NavDataCalibratingTool->GetPosition()[1], 'f', 1) + ", "
+ QString::number(m_AxisCalibration_NavDataCalibratingTool->GetPosition()[2], 'f', 1);
m_Controls.m_ToolAxisPositionLabel->setText(_label);
}
void QmitkIGTNavigationToolCalibration::OnCalibrateToolAxis()
{
if (!m_ComputedToolTipTransformation)
{
MITK_ERROR << "Please compute tool tip first.";
QMessageBox::information(nullptr, "Error", "Please compute / specifiy tool tip first");
return;
}
if (!m_AxisCalibration_ToolToCalibrate || !m_AxisCalibration_NavDataCalibratingTool)
{
MITK_ERROR << "Please record position first.";
QMessageBox::information(nullptr, "Error", "Please record position first");
return;
}
//Calculate the tool tip
//here is an explanation, what is happening here:
/*
The axis is equal to the (tool tip) minus the (end of the tool) in tool coordinates of the tool which should be calibrated.
The tool tip is defined as the origin of the tool coordinate system.
The end of the tool is recorded by the calibration pointer's position and is transformed into the coordinate system of the tool to be calibrated
Normalize it.
*/
//m_CalibratedToolAxis = -m_AxisCalibration_ToolToCalibrate->TransformPoint(m_AxisCalibration_NavDataCalibratingTool->GetPosition()).GetVectorFromOrigin();
m_CalibratedToolAxis = -m_AxisCalibration_ToolToCalibrate->GetInverse()->TransformPoint(m_AxisCalibration_NavDataCalibratingTool->GetPosition()).GetVectorFromOrigin();
MITK_DEBUG << "Tool Endpoint in Tool coordinates: " << m_CalibratedToolAxis;
m_CalibratedToolAxis.Normalize();
MITK_DEBUG << "Tool Axis: " << m_CalibratedToolAxis;
- m_ToolToCalibrate->SetToolAxis(m_CalibratedToolAxis);
+ m_ToolToCalibrate->SetToolAxis(mitk::Point3D(m_CalibratedToolAxis));
// Update TrackingTool
m_ComputedToolTipTransformation->SetPosition(m_ToolToCalibrate->GetToolTipPosition());
m_ComputedToolTipTransformation->SetOrientation(m_ToolToCalibrate->GetToolAxisOrientation());
ApplyToolTipTransform(m_ComputedToolTipTransformation);
//Update GUI
QString calibratedToolAxisString = "Tool Axis: " + QString::number(m_CalibratedToolAxis.GetElement(0), 'f', 3) + ", " +
QString::number(m_CalibratedToolAxis.GetElement(1), 'f', 3) + ", " + QString::number(m_CalibratedToolAxis.GetElement(2), 'f', 3);
m_Controls.m_ToolAxisCalibrationLabel->setText(calibratedToolAxisString);
//Block QT signals, we don't want to emit SpinboxChanged on the first value to overwrite the next ones
m_Controls.m_ToolAxis_X->blockSignals(true); m_Controls.m_ToolAxis_Y->blockSignals(true); m_Controls.m_ToolAxis_Z->blockSignals(true);
m_Controls.m_ToolAxis_X->setValue(m_CalibratedToolAxis[0]);
m_Controls.m_ToolAxis_Y->setValue(m_CalibratedToolAxis[1]);
m_Controls.m_ToolAxis_Z->setValue(m_CalibratedToolAxis[2]);
m_Controls.m_ToolAxis_X->blockSignals(false); m_Controls.m_ToolAxis_Y->blockSignals(false); m_Controls.m_ToolAxis_Z->blockSignals(false);
}
void QmitkIGTNavigationToolCalibration::OnToolAxisSpinboxChanged()
{
m_CalibratedToolAxis.SetElement(0, m_Controls.m_ToolAxis_X->value());
m_CalibratedToolAxis.SetElement(1, m_Controls.m_ToolAxis_Y->value());
m_CalibratedToolAxis.SetElement(2, m_Controls.m_ToolAxis_Z->value());
- m_ToolToCalibrate->SetToolAxis(m_CalibratedToolAxis);
+ m_ToolToCalibrate->SetToolAxis(mitk::Point3D(m_CalibratedToolAxis));
// Update TrackingTool
if (m_ComputedToolTipTransformation.IsNull())
{
m_ComputedToolTipTransformation = mitk::NavigationData::New();
}
m_ComputedToolTipTransformation->SetPosition(m_ToolToCalibrate->GetToolTipPosition());
m_ComputedToolTipTransformation->SetOrientation(m_ToolToCalibrate->GetToolAxisOrientation());
ApplyToolTipTransform(m_ComputedToolTipTransformation);
MITK_INFO << "Tool axis changed to " << m_CalibratedToolAxis;
}
void QmitkIGTNavigationToolCalibration::SetToolToCalibrate()
{
m_IDToolToCalibrate = m_Controls.m_SelectionWidget->GetSelectedToolID();
if (m_IDToolToCalibrate == -1) //no valid tool to calibrate
{
m_Controls.m_CalToolLabel->setText("<none>");
m_Controls.m_StatusWidgetToolToCalibrate->RemoveStatusLabels();
m_TrackingTimer->stop();
}
else
{
m_ToolToCalibrate = m_Controls.m_SelectionWidget->GetSelectedNavigationTool();
m_NavigationDataSourceOfToolToCalibrate = m_Controls.m_SelectionWidget->GetSelectedNavigationDataSource();
m_Controls.m_CalToolLabel->setText(m_NavigationDataSourceOfToolToCalibrate->GetOutput(m_IDToolToCalibrate)->GetName());
//initialize widget
m_Controls.m_StatusWidgetToolToCalibrate->RemoveStatusLabels();
m_Controls.m_StatusWidgetToolToCalibrate->SetShowPositions(true);
m_Controls.m_StatusWidgetToolToCalibrate->SetTextAlignment(Qt::AlignLeft);
m_Controls.m_StatusWidgetToolToCalibrate->AddNavigationData(m_NavigationDataSourceOfToolToCalibrate->GetOutput(m_IDToolToCalibrate));
m_Controls.m_StatusWidgetToolToCalibrate->ShowStatusLabels();
//initialize manual tool tip calibration view
UpdateManualToolTipCalibrationView();
//save tool surface in tool coordinates for further editing
mitk::Surface::Pointer ToolSurface = dynamic_cast<mitk::Surface*>(m_ToolToCalibrate->GetDataNode()->GetData())->Clone();
m_ToolSurfaceInToolCoordinatesDataNode->SetData(ToolSurface);
m_ToolSurfaceInToolCoordinatesDataNode->GetData()->GetGeometry()->SetIdentity();
// update tool tip and rotation information for tool tip calibration tab
UpdateManualToolTipCalibrationView();
// update tool axis information for tool axis calibration tab
mitk::Point3D toolAxis = m_ToolToCalibrate->GetToolAxis();
m_CalibratedToolAxis[0] = toolAxis[0];
m_CalibratedToolAxis[1] = toolAxis[1];
m_CalibratedToolAxis[2] = toolAxis[2];
m_Controls.m_ToolAxis_X->blockSignals(true); m_Controls.m_ToolAxis_Y->blockSignals(true); m_Controls.m_ToolAxis_Z->blockSignals(true);
m_Controls.m_ToolAxis_X->setValue(m_CalibratedToolAxis[0]);
m_Controls.m_ToolAxis_Y->setValue(m_CalibratedToolAxis[1]);
m_Controls.m_ToolAxis_Z->setValue(m_CalibratedToolAxis[2]);
m_Controls.m_ToolAxis_X->blockSignals(false); m_Controls.m_ToolAxis_Y->blockSignals(false); m_Controls.m_ToolAxis_Z->blockSignals(false);
//start updating timer for status widgets, etc.
if (!m_TrackingTimer->isActive()) m_TrackingTimer->start(100);
}
}
void QmitkIGTNavigationToolCalibration::SetCalibrationPointer()
{
m_IDCalibrationPointer = m_Controls.m_SelectionWidget->GetSelectedToolID();
if (m_IDCalibrationPointer == -1)
{
m_Controls.m_PointerLabel->setText("<none>");
m_Controls.m_StatusWidgetCalibrationPointer->RemoveStatusLabels();
m_TrackingTimer->stop();
}
else
{
m_NavigationDataSourceOfCalibrationPointer = m_Controls.m_SelectionWidget->GetSelectedNavigationDataSource();
m_Controls.m_PointerLabel->setText(m_NavigationDataSourceOfCalibrationPointer->GetOutput(m_IDCalibrationPointer)->GetName());
//initialize widget
m_Controls.m_StatusWidgetCalibrationPointer->RemoveStatusLabels();
m_Controls.m_StatusWidgetCalibrationPointer->SetShowPositions(true);
m_Controls.m_StatusWidgetCalibrationPointer->SetTextAlignment(Qt::AlignLeft);
m_Controls.m_StatusWidgetCalibrationPointer->AddNavigationData(m_NavigationDataSourceOfCalibrationPointer->GetOutput(m_IDCalibrationPointer));
m_Controls.m_StatusWidgetCalibrationPointer->ShowStatusLabels();
if (!m_TrackingTimer->isActive()) m_TrackingTimer->start(100);
}
}
void QmitkIGTNavigationToolCalibration::UpdateOffsetCoordinates()
{
if (m_NavigationDataSourceOfCalibrationPointer.IsNull() || m_NavigationDataSourceOfToolToCalibrate.IsNull())
{
return;
}
mitk::NavigationData::Pointer referenceToolND = m_NavigationDataSourceOfCalibrationPointer->GetOutput(m_IDCalibrationPointer);
mitk::NavigationData::Pointer toolToCalibrateND = m_NavigationDataSourceOfToolToCalibrate->GetOutput(m_IDToolToCalibrate);
if (referenceToolND->IsDataValid() && toolToCalibrateND->IsDataValid())
{
//computation: difference between both tools (in tool coordinates)
//differenceND = toolToCalibrateND^-1 * referenceToolND
mitk::NavigationData::Pointer differenceND = mitk::NavigationData::New();
differenceND->Compose(referenceToolND);
differenceND->Compose(toolToCalibrateND->GetInverse());
//display this orientation in the UI
m_Controls.m_OffsetCoordinates->setText(
QString("x: ") + QString(QString::number(differenceND->GetPosition()[0], 103, 3)) +
QString("; y: ") + (QString::number(differenceND->GetPosition()[1], 103, 3)) +
QString("; z: ") + (QString::number(differenceND->GetPosition()[2], 103, 3)));
m_Controls.m_OrientationOffsetCoordinates->setText(
QString("qx: ") + QString(QString::number(differenceND->GetOrientation().x(), 103, 3)) +
QString("; qy: ") + (QString::number(differenceND->GetOrientation().y(), 103, 3)) +
QString("; qz: ") + (QString::number(differenceND->GetOrientation().z(), 103, 3)) +
QString("; qr: ") + (QString::number(differenceND->GetOrientation().r(), 103, 3)));
//also update preview if active
if (m_ToolTipPointPreview.IsNotNull()) //NOT WORKING! TODO: fix or remove!
{
mitk::NavigationData::Pointer ToolTipTransform = mitk::NavigationData::New();
ToolTipTransform->SetPosition(m_ResultOffsetVector);
mitk::NavigationData::Pointer ToolTipInTrackingCoordinates = mitk::NavigationData::New(); //maybe store as for better peformance...
ToolTipInTrackingCoordinates->Compose(m_NavigationDataSourceOfToolToCalibrate->GetOutput(m_IDToolToCalibrate));
ToolTipInTrackingCoordinates->Compose(ToolTipTransform);
m_ToolTipPointPreview->GetData()->GetGeometry()->SetIndexToWorldTransform(ToolTipInTrackingCoordinates->GetAffineTransform3D());
}
}
}
void QmitkIGTNavigationToolCalibration::UpdateTrackingTimer()
{
m_Controls.m_StatusWidgetToolToCalibrate->Refresh();
m_Controls.m_StatusWidgetCalibrationPointer->Refresh();
if (m_OnLoginSingleRefToolNavigationDataClicked) LoginSingleRefToolNavigationData();
if (m_OnAddPivotPoseClicked) AddPivotPose();
// 1 == Single Reference Calibration Method
if (m_IndexCurrentCalibrationMethod == 1) UpdateOffsetCoordinates();
}
void QmitkIGTNavigationToolCalibration::AddLandmark()
{
if (!CheckInitialization()) { return; }
mitk::NavigationData::Pointer navDataTool = m_NavigationDataSourceOfToolToCalibrate->GetOutput(m_IDToolToCalibrate);
mitk::Point3D landmark = m_NavigationDataSourceOfCalibrationPointer->GetOutput(m_IDCalibrationPointer)->GetPosition();
//convert to itk transform
itk::Vector<double, 3> translation;
for (int k = 0; k < 3; k++) translation[k] = navDataTool->GetPosition()[k];
itk::Matrix<double, 3, 3> rotation;
for (int k = 0; k < 3; k++) for (int l = 0; l < 3; l++) rotation[k][l] = navDataTool->GetOrientation().rotation_matrix_transpose()[k][l];
rotation = rotation.GetTranspose();
itk::Vector<double> landmarkItk;
landmarkItk[0] = landmark[0];
landmarkItk[1] = landmark[1];
landmarkItk[2] = landmark[2];
//compute landmark in tool coordinates
itk::Matrix<double, 3, 3> rotationInverse;
for (int k = 0; k < 3; k++) for (int l = 0; l < 3; l++) rotationInverse[k][l] = rotation.GetInverse()[k][l];
landmarkItk = rotationInverse * (landmarkItk - translation);
//convert back and add landmark to pointset
landmark[0] = landmarkItk[0];
landmark[1] = landmarkItk[1];
landmark[2] = landmarkItk[2];
m_RegistrationLandmarks->InsertPoint(m_RegistrationLandmarks->GetSize(), landmark);
}
void QmitkIGTNavigationToolCalibration::SaveCalibratedTool()
{
if (m_ToolToCalibrate.IsNotNull())
{
mitk::NavigationTool::Pointer calibratedTool = m_ToolToCalibrate;
calibratedTool->SetToolControlPoints(this->m_CalibrationLandmarks);
calibratedTool->SetToolLandmarks(this->m_RegistrationLandmarks);
mitk::NavigationToolWriter::Pointer myWriter = mitk::NavigationToolWriter::New();
QString filename = QFileDialog::getSaveFileName(nullptr,tr("Save Navigation Tool"), "/", "*.IGTTool");
if (filename.isEmpty()) return;
// ensure that file suffix is set
QFileInfo file(filename);
if (file.suffix().isEmpty())
{
filename += ".IGTTool";
}
if (myWriter->DoWrite(filename.toStdString(), calibratedTool)) MITK_INFO << "Saved calibrated tool to file " << filename;
else MITK_WARN << "Can't write tool to file " << filename;
}
else
{
MITK_ERROR << "Did not find navigation tool storage of calibrated tool, aborting!";
}
}
bool QmitkIGTNavigationToolCalibration::CheckInitialization(bool CalibrationPointerRequired)
{
if ((m_IDToolToCalibrate == -1) ||
((CalibrationPointerRequired) &&
(m_IDCalibrationPointer == -1)
)
)
{
QMessageBox msgBox;
msgBox.setText("Tool to calibrate and/or calibration pointer not initialized, cannot proceed!");
msgBox.exec();
return false;
}
else { return true; }
}
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.evaluator/src/internal/QmitkMatchPointRegistrationEvaluator.cpp b/Plugins/org.mitk.gui.qt.matchpoint.evaluator/src/internal/QmitkMatchPointRegistrationEvaluator.cpp
index 5da7f6c349..46c3272a68 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.evaluator/src/internal/QmitkMatchPointRegistrationEvaluator.cpp
+++ b/Plugins/org.mitk.gui.qt.matchpoint.evaluator/src/internal/QmitkMatchPointRegistrationEvaluator.cpp
@@ -1,309 +1,310 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Mitk
#include <mitkStatusBar.h>
#include <mitkNodePredicateDataProperty.h>
#include <mitkMAPRegistrationWrapper.h>
#include "mitkRegVisPropertyTags.h"
#include "mitkMatchPointPropertyTags.h"
#include "mitkRegEvaluationObject.h"
#include "mitkRegistrationHelper.h"
#include "mitkRegEvaluationMapper2D.h"
#include <mitkMAPAlgorithmHelper.h>
+#include "mitkProperties.h"
// Qmitk
#include "QmitkRenderWindow.h"
#include "QmitkMatchPointRegistrationEvaluator.h"
// Qt
#include <QMessageBox>
#include <QErrorMessage>
#include <QTimer>
const std::string QmitkMatchPointRegistrationEvaluator::VIEW_ID =
"org.mitk.views.matchpoint.registration.evaluator";
const std::string QmitkMatchPointRegistrationEvaluator::HelperNodeName =
"RegistrationEvaluationHelper";
QmitkMatchPointRegistrationEvaluator::QmitkMatchPointRegistrationEvaluator()
: m_Parent(nullptr), m_activeEvaluation(false), m_currentSelectedTimePoint(0.)
{
m_currentSelectedPosition.Fill(0.0);
}
QmitkMatchPointRegistrationEvaluator::~QmitkMatchPointRegistrationEvaluator()
{
if (this->m_selectedEvalNode.IsNotNull() && this->GetDataStorage().IsNotNull())
{
this->GetDataStorage()->Remove(this->m_selectedEvalNode);
}
}
void QmitkMatchPointRegistrationEvaluator::SetFocus()
{
}
void QmitkMatchPointRegistrationEvaluator::Error(QString msg)
{
mitk::StatusBar::GetInstance()->DisplayErrorText(msg.toLatin1());
MITK_ERROR << msg.toStdString().c_str();
}
void QmitkMatchPointRegistrationEvaluator::CreateQtPartControl(QWidget* parent)
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls.setupUi(parent);
m_Parent = parent;
this->m_Controls.registrationNodeSelector->SetDataStorage(this->GetDataStorage());
this->m_Controls.registrationNodeSelector->SetSelectionIsOptional(true);
this->m_Controls.movingNodeSelector->SetDataStorage(this->GetDataStorage());
this->m_Controls.movingNodeSelector->SetSelectionIsOptional(false);
this->m_Controls.targetNodeSelector->SetDataStorage(this->GetDataStorage());
this->m_Controls.targetNodeSelector->SetSelectionIsOptional(false);
this->m_Controls.registrationNodeSelector->SetInvalidInfo("Select valid registration.");
this->m_Controls.registrationNodeSelector->SetEmptyInfo("Assuming identity. Select registration to change.");
this->m_Controls.registrationNodeSelector->SetPopUpTitel("Select registration.");
this->m_Controls.registrationNodeSelector->SetPopUpHint("Select a registration object that should be evaluated. If no registration is selected, identity will be assumed for evaluation.");
this->m_Controls.movingNodeSelector->SetInvalidInfo("Select moving image.");
this->m_Controls.movingNodeSelector->SetPopUpTitel("Select moving image.");
this->m_Controls.movingNodeSelector->SetPopUpHint("Select the moving image for the evaluation. This is the image that will be mapped by the registration.");
this->m_Controls.targetNodeSelector->SetInvalidInfo("Select target image.");
this->m_Controls.targetNodeSelector->SetPopUpTitel("Select target image.");
this->m_Controls.targetNodeSelector->SetPopUpHint("Select the target image for the evaluation.");
this->m_Controls.checkAutoSelect->setChecked(true);
this->ConfigureNodePredicates();
connect(m_Controls.pbEval, SIGNAL(clicked()), this, SLOT(OnEvalBtnPushed()));
connect(m_Controls.pbStop, SIGNAL(clicked()), this, SLOT(OnStopBtnPushed()));
connect(m_Controls.evalSettings, SIGNAL(SettingsChanged(mitk::DataNode*)), this, SLOT(OnSettingsChanged(mitk::DataNode*)));
connect(m_Controls.registrationNodeSelector, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged, this, &QmitkMatchPointRegistrationEvaluator::OnNodeSelectionChanged);
connect(m_Controls.movingNodeSelector, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged, this, &QmitkMatchPointRegistrationEvaluator::OnNodeSelectionChanged);
connect(m_Controls.targetNodeSelector, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged, this, &QmitkMatchPointRegistrationEvaluator::OnNodeSelectionChanged);
this->m_SliceChangeListener.RenderWindowPartActivated(this->GetRenderWindowPart());
connect(&m_SliceChangeListener, SIGNAL(SliceChanged()), this, SLOT(OnSliceChanged()));
m_selectedEvalNode = this->GetDataStorage()->GetNamedNode(HelperNodeName);
this->CheckInputs();
this->ConfigureControls();
}
void QmitkMatchPointRegistrationEvaluator::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
{
this->m_SliceChangeListener.RenderWindowPartActivated(renderWindowPart);
}
void QmitkMatchPointRegistrationEvaluator::RenderWindowPartDeactivated(
mitk::IRenderWindowPart* renderWindowPart)
{
this->m_SliceChangeListener.RenderWindowPartDeactivated(renderWindowPart);
}
void QmitkMatchPointRegistrationEvaluator::ConfigureNodePredicates()
{
this->m_Controls.registrationNodeSelector->SetNodePredicate(mitk::MITKRegistrationHelper::RegNodePredicate());
this->m_Controls.movingNodeSelector->SetNodePredicate(mitk::MITKRegistrationHelper::ImageNodePredicate());
this->m_Controls.targetNodeSelector->SetNodePredicate(mitk::MITKRegistrationHelper::ImageNodePredicate());
}
void QmitkMatchPointRegistrationEvaluator::CheckInputs()
{
if (!m_activeEvaluation)
{
bool autoSelectInput = m_Controls.checkAutoSelect->isChecked() && this->m_spSelectedRegNode != this->m_Controls.registrationNodeSelector->GetSelectedNode();
this->m_spSelectedRegNode = this->m_Controls.registrationNodeSelector->GetSelectedNode();
this->m_spSelectedMovingNode = this->m_Controls.movingNodeSelector->GetSelectedNode();
this->m_spSelectedTargetNode = this->m_Controls.targetNodeSelector->GetSelectedNode();
if (this->m_spSelectedRegNode.IsNotNull() && (this->m_spSelectedMovingNode.IsNull() || autoSelectInput))
{
mitk::BaseProperty* uidProp = m_spSelectedRegNode->GetData()->GetProperty(mitk::Prop_RegAlgMovingData);
if (uidProp)
{
//search for the moving node
mitk::NodePredicateDataProperty::Pointer predicate = mitk::NodePredicateDataProperty::New(mitk::Prop_UID,
uidProp);
mitk::DataNode::Pointer movingNode = this->GetDataStorage()->GetNode(predicate);
if (movingNode.IsNotNull())
{
this->m_spSelectedMovingNode = movingNode;
QmitkSingleNodeSelectionWidget::NodeList selection({ movingNode });
this->m_Controls.movingNodeSelector->SetCurrentSelection(selection);
}
}
}
if (this->m_spSelectedRegNode.IsNotNull() && (this->m_spSelectedTargetNode.IsNull() || autoSelectInput))
{
mitk::BaseProperty* uidProp = m_spSelectedRegNode->GetData()->GetProperty(mitk::Prop_RegAlgTargetData);
if (uidProp)
{
//search for the target node
mitk::NodePredicateDataProperty::Pointer predicate = mitk::NodePredicateDataProperty::New(mitk::Prop_UID,
uidProp);
mitk::DataNode::Pointer targetNode = this->GetDataStorage()->GetNode(predicate);
if (targetNode.IsNotNull())
{
this->m_spSelectedTargetNode = targetNode;
QmitkSingleNodeSelectionWidget::NodeList selection({ targetNode });
this->m_Controls.targetNodeSelector->SetCurrentSelection(selection);
}
}
}
}
}
void QmitkMatchPointRegistrationEvaluator::OnNodeSelectionChanged(QList<mitk::DataNode::Pointer> /*nodes*/)
{
this->CheckInputs();
this->ConfigureControls();
}
void QmitkMatchPointRegistrationEvaluator::NodeRemoved(const mitk::DataNode* node)
{
if (node == this->m_spSelectedMovingNode
|| node == this->m_spSelectedRegNode
|| node == this->m_spSelectedTargetNode
|| node == this->m_selectedEvalNode)
{
if (node == this->m_selectedEvalNode)
{
this->m_selectedEvalNode = nullptr;
}
this->OnStopBtnPushed();
MITK_INFO << "Stopped current MatchPoint evaluation session, because at least one relevant node was removed from storage.";
}
}
void QmitkMatchPointRegistrationEvaluator::ConfigureControls()
{
//config settings widget
this->m_Controls.evalSettings->setVisible(m_activeEvaluation);
this->m_Controls.pbEval->setEnabled(this->m_spSelectedMovingNode.IsNotNull()
&& this->m_spSelectedTargetNode.IsNotNull());
this->m_Controls.pbEval->setVisible(!m_activeEvaluation);
this->m_Controls.pbStop->setVisible(m_activeEvaluation);
this->m_Controls.registrationNodeSelector->setEnabled(!m_activeEvaluation);
this->m_Controls.movingNodeSelector->setEnabled(!m_activeEvaluation);
this->m_Controls.targetNodeSelector->setEnabled(!m_activeEvaluation);
}
void QmitkMatchPointRegistrationEvaluator::OnSliceChanged()
{
mitk::Point3D currentSelectedPosition = GetRenderWindowPart()->GetSelectedPosition(nullptr);
auto currentTimePoint = GetRenderWindowPart()->GetSelectedTimePoint();
if (m_currentSelectedPosition != currentSelectedPosition
|| m_currentSelectedTimePoint != currentTimePoint
|| m_selectedNodeTime > m_currentPositionTime)
{
//the current position has been changed or the selected node has been changed since the last position validation -> check position
m_currentSelectedPosition = currentSelectedPosition;
m_currentSelectedTimePoint = currentTimePoint;
m_currentPositionTime.Modified();
if (this->m_selectedEvalNode.IsNotNull())
{
- this->m_selectedEvalNode->SetProperty(mitk::nodeProp_RegEvalCurrentPosition, mitk::GenericProperty<mitk::Point3D>::New(currentSelectedPosition));
+ this->m_selectedEvalNode->SetProperty(mitk::nodeProp_RegEvalCurrentPosition, mitk::Point3dProperty::New(currentSelectedPosition));
}
}
}
void QmitkMatchPointRegistrationEvaluator::OnSettingsChanged(mitk::DataNode*)
{
this->GetRenderWindowPart()->RequestUpdate();
}
void QmitkMatchPointRegistrationEvaluator::OnEvalBtnPushed()
{
//reinit view
mitk::RenderingManager::GetInstance()->InitializeViews(m_spSelectedTargetNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
mitk::RegEvaluationObject::Pointer regEval = mitk::RegEvaluationObject::New();
mitk::MAPRegistrationWrapper::Pointer reg;
if (m_spSelectedRegNode.IsNotNull())
{
reg = dynamic_cast<mitk::MAPRegistrationWrapper*>(this->m_spSelectedRegNode->GetData());
}
else
{
//generate a dymme reg to use
reg = mitk::GenerateIdentityRegistration3D();
}
regEval->SetRegistration(reg);
regEval->SetTargetNode(this->m_spSelectedTargetNode);
regEval->SetMovingNode(this->m_spSelectedMovingNode);
if (this->m_selectedEvalNode.IsNotNull())
{
this->GetDataStorage()->Remove(this->m_selectedEvalNode);
}
this->m_selectedEvalNode = mitk::DataNode::New();
this->m_selectedEvalNode->SetData(regEval);
mitk::RegEvaluationMapper2D::SetDefaultProperties(this->m_selectedEvalNode);
this->m_selectedEvalNode->SetName(HelperNodeName);
this->m_selectedEvalNode->SetBoolProperty("helper object", true);
this->GetDataStorage()->Add(this->m_selectedEvalNode);
this->m_Controls.evalSettings->SetNode(this->m_selectedEvalNode);
this->OnSliceChanged();
this->GetRenderWindowPart()->RequestUpdate();
this->m_activeEvaluation = true;
this->CheckInputs();
this->ConfigureControls();
}
void QmitkMatchPointRegistrationEvaluator::OnStopBtnPushed()
{
this->m_activeEvaluation = false;
if (this->m_selectedEvalNode.IsNotNull())
{
this->GetDataStorage()->Remove(this->m_selectedEvalNode);
}
this->m_selectedEvalNode = nullptr;
this->m_Controls.evalSettings->SetNode(this->m_selectedEvalNode);
this->CheckInputs();
this->ConfigureControls();
if (nullptr != this->GetRenderWindowPart())
{
this->GetRenderWindowPart()->RequestUpdate();
}
}
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.manipulator/src/internal/QmitkMatchPointRegistrationManipulator.cpp b/Plugins/org.mitk.gui.qt.matchpoint.manipulator/src/internal/QmitkMatchPointRegistrationManipulator.cpp
index 1205c3929e..ac29f25c5d 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.manipulator/src/internal/QmitkMatchPointRegistrationManipulator.cpp
+++ b/Plugins/org.mitk.gui.qt.matchpoint.manipulator/src/internal/QmitkMatchPointRegistrationManipulator.cpp
@@ -1,495 +1,496 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Mitk
#include <mitkStatusBar.h>
#include <mitkNodePredicateDataProperty.h>
#include <mitkMAPRegistrationWrapper.h>
#include "mitkRegVisPropertyTags.h"
#include "mitkMatchPointPropertyTags.h"
#include "mitkRegEvaluationObject.h"
#include "mitkRegistrationHelper.h"
#include "mitkRegEvaluationMapper2D.h"
#include <mitkMAPAlgorithmHelper.h>
#include <mitkResultNodeGenerationHelper.h>
#include <mitkUIDHelper.h>
+#include "mitkProperties.h"
// Qmitk
#include "QmitkRenderWindow.h"
#include "QmitkMatchPointRegistrationManipulator.h"
#include <QmitkMappingJob.h>
// Qt
#include <QMessageBox>
#include <QErrorMessage>
#include <QTimer>
#include <QThreadPool>
//MatchPoint
#include <mapRegistrationManipulator.h>
#include <mapPreCachedRegistrationKernel.h>
#include <mapCombinedRegistrationKernel.h>
#include <mapNullRegistrationKernel.h>
#include <mapRegistrationCombinator.h>
#include <itkCompositeTransform.h>
#include <boost/math/constants/constants.hpp>
const std::string QmitkMatchPointRegistrationManipulator::VIEW_ID =
"org.mitk.views.matchpoint.registration.manipulator";
const std::string QmitkMatchPointRegistrationManipulator::HelperNodeName =
"RegistrationManipulationEvaluationHelper";
QmitkMatchPointRegistrationManipulator::QmitkMatchPointRegistrationManipulator()
: m_Parent(nullptr), m_activeManipulation(false),
m_currentSelectedTimePoint(0.), m_internalUpdate(false)
{
m_currentSelectedPosition.Fill(0.0);
}
QmitkMatchPointRegistrationManipulator::~QmitkMatchPointRegistrationManipulator()
{
if (this->m_EvalNode.IsNotNull() && this->GetDataStorage().IsNotNull())
{
this->GetDataStorage()->Remove(this->m_EvalNode);
}
}
void QmitkMatchPointRegistrationManipulator::SetFocus()
{
}
void QmitkMatchPointRegistrationManipulator::Error(QString msg)
{
mitk::StatusBar::GetInstance()->DisplayErrorText(msg.toLatin1());
MITK_ERROR << msg.toStdString().c_str();
}
void QmitkMatchPointRegistrationManipulator::CreateQtPartControl(QWidget* parent)
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls.setupUi(parent);
m_Parent = parent;
this->m_Controls.registrationNodeSelector->SetDataStorage(this->GetDataStorage());
this->m_Controls.registrationNodeSelector->SetSelectionIsOptional(false);
this->m_Controls.movingNodeSelector->SetDataStorage(this->GetDataStorage());
this->m_Controls.movingNodeSelector->SetSelectionIsOptional(false);
this->m_Controls.targetNodeSelector->SetDataStorage(this->GetDataStorage());
this->m_Controls.targetNodeSelector->SetSelectionIsOptional(false);
this->m_Controls.registrationNodeSelector->SetInvalidInfo("Select base registration.");
this->m_Controls.registrationNodeSelector->SetPopUpTitel("Select registration.");
this->m_Controls.registrationNodeSelector->SetPopUpHint("Select a registration object that should be used as starting point for the manual manipulation.");
this->m_Controls.movingNodeSelector->SetInvalidInfo("Select moving image.");
this->m_Controls.movingNodeSelector->SetPopUpTitel("Select moving image.");
this->m_Controls.movingNodeSelector->SetPopUpHint("Select the moving image for the evaluation. This is the image that will be mapped by the registration.");
this->m_Controls.targetNodeSelector->SetInvalidInfo("Select target image.");
this->m_Controls.targetNodeSelector->SetPopUpTitel("Select target image.");
this->m_Controls.targetNodeSelector->SetPopUpHint("Select the target image for the evaluation.");
this->m_Controls.checkAutoSelect->setChecked(true);
this->ConfigureNodePredicates();
connect(m_Controls.pbStart, SIGNAL(clicked()), this, SLOT(OnStartBtnPushed()));
connect(m_Controls.pbCancel, SIGNAL(clicked()), this, SLOT(OnCancelBtnPushed()));
connect(m_Controls.pbStore, SIGNAL(clicked()), this, SLOT(OnStoreBtnPushed()));
connect(m_Controls.evalSettings, SIGNAL(SettingsChanged(mitk::DataNode*)), this, SLOT(OnSettingsChanged(mitk::DataNode*)));
connect(m_Controls.radioSelectedReg, SIGNAL(toggled(bool)), this, SLOT(OnRegSourceChanged()));
connect(m_Controls.comboCenter, SIGNAL(currentIndexChanged(int)), this, SLOT(OnCenterTypeChanged(int)));
connect(m_Controls.manipulationWidget, SIGNAL(RegistrationChanged(map::core::RegistrationBase*)), this, SLOT(OnRegistrationChanged()));
connect(m_Controls.registrationNodeSelector, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged, this, &QmitkMatchPointRegistrationManipulator::OnNodeSelectionChanged);
connect(m_Controls.movingNodeSelector, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged, this, &QmitkMatchPointRegistrationManipulator::OnNodeSelectionChanged);
connect(m_Controls.targetNodeSelector, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged, this, &QmitkMatchPointRegistrationManipulator::OnNodeSelectionChanged);
this->m_SliceChangeListener.RenderWindowPartActivated(this->GetRenderWindowPart());
connect(&m_SliceChangeListener, SIGNAL(SliceChanged()), this, SLOT(OnSliceChanged()));
m_Controls.radioNewReg->setChecked(true);
m_EvalNode = this->GetDataStorage()->GetNamedNode(HelperNodeName);
this->CheckInputs();
this->StopSession();
this->ConfigureControls();
}
void QmitkMatchPointRegistrationManipulator::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
{
this->m_SliceChangeListener.RenderWindowPartActivated(renderWindowPart);
}
void QmitkMatchPointRegistrationManipulator::RenderWindowPartDeactivated(
mitk::IRenderWindowPart* renderWindowPart)
{
this->m_SliceChangeListener.RenderWindowPartDeactivated(renderWindowPart);
}
void QmitkMatchPointRegistrationManipulator::ConfigureNodePredicates()
{
this->m_Controls.registrationNodeSelector->SetNodePredicate(mitk::MITKRegistrationHelper::RegNodePredicate());
this->m_Controls.movingNodeSelector->SetNodePredicate(mitk::MITKRegistrationHelper::ImageNodePredicate());
this->m_Controls.targetNodeSelector->SetNodePredicate(mitk::MITKRegistrationHelper::ImageNodePredicate());
}
void QmitkMatchPointRegistrationManipulator::CheckInputs()
{
if (!m_activeManipulation)
{
bool autoSelectInput = m_Controls.checkAutoSelect->isChecked() && this->m_SelectedPreRegNode != this->m_Controls.registrationNodeSelector->GetSelectedNode();
this->m_SelectedPreRegNode = this->m_Controls.registrationNodeSelector->GetSelectedNode();
this->m_SelectedMovingNode = this->m_Controls.movingNodeSelector->GetSelectedNode();
this->m_SelectedTargetNode = this->m_Controls.targetNodeSelector->GetSelectedNode();
if (this->m_SelectedPreRegNode.IsNotNull())
{
mitk::MAPRegistrationWrapper* regWrapper = dynamic_cast<mitk::MAPRegistrationWrapper*>(m_SelectedPreRegNode->GetData());
if (regWrapper)
{
this->m_SelectedPreReg = dynamic_cast<MAPRegistrationType*>(regWrapper->GetRegistration());
}
}
if (this->m_SelectedPreRegNode.IsNotNull() && (this->m_SelectedMovingNode.IsNull() || autoSelectInput))
{
mitk::BaseProperty* uidProp = m_SelectedPreRegNode->GetData()->GetProperty(mitk::Prop_RegAlgMovingData);
if (uidProp)
{
//search for the moving node
mitk::NodePredicateDataProperty::Pointer predicate = mitk::NodePredicateDataProperty::New(mitk::Prop_UID,
uidProp);
mitk::DataNode::Pointer movingNode = this->GetDataStorage()->GetNode(predicate);
if (movingNode.IsNotNull())
{
this->m_SelectedMovingNode = movingNode;
QmitkSingleNodeSelectionWidget::NodeList selection({ movingNode });
this->m_Controls.movingNodeSelector->SetCurrentSelection(selection);
}
}
}
if (this->m_SelectedPreRegNode.IsNotNull() && (this->m_SelectedTargetNode.IsNull() || autoSelectInput))
{
mitk::BaseProperty* uidProp = m_SelectedPreRegNode->GetData()->GetProperty(mitk::Prop_RegAlgTargetData);
if (uidProp)
{
//search for the target node
mitk::NodePredicateDataProperty::Pointer predicate = mitk::NodePredicateDataProperty::New(mitk::Prop_UID,
uidProp);
mitk::DataNode::Pointer targetNode = this->GetDataStorage()->GetNode(predicate);
if (targetNode.IsNotNull())
{
this->m_SelectedTargetNode = targetNode;
QmitkSingleNodeSelectionWidget::NodeList selection({ targetNode });
this->m_Controls.targetNodeSelector->SetCurrentSelection(selection);
}
}
}
}
}
void QmitkMatchPointRegistrationManipulator::OnRegSourceChanged()
{
this->CheckInputs();
this->ConfigureControls();
}
void QmitkMatchPointRegistrationManipulator::OnNodeSelectionChanged(QList<mitk::DataNode::Pointer> /*nodes*/)
{
this->CheckInputs();
this->ConfigureControls();
}
void QmitkMatchPointRegistrationManipulator::NodeRemoved(const mitk::DataNode* node)
{
if (node == this->m_SelectedMovingNode
|| node == this->m_SelectedTargetNode
|| node == this->m_EvalNode)
{
if (node == this->m_EvalNode)
{
this->m_EvalNode = nullptr;
}
if (this->m_activeManipulation)
{
MITK_INFO << "Stopped current MatchPoint manual registration session, because at least one relevant node was removed from storage.";
}
this->OnCancelBtnPushed();
}
}
void QmitkMatchPointRegistrationManipulator::ConfigureControls()
{
if (!m_activeManipulation)
{
QString name = "ManuelRegistration";
if (m_SelectedPreRegNode.IsNotNull())
{
name = QString::fromStdString(m_SelectedPreRegNode->GetName()) + " manual refined";
}
this->m_Controls.lbNewRegName->setText(name);
}
//config settings widget
this->m_Controls.groupReg->setEnabled(!m_activeManipulation);
this->m_Controls.pbStart->setEnabled(this->m_SelectedMovingNode.IsNotNull()
&& this->m_SelectedTargetNode.IsNotNull()
&& !m_activeManipulation
&& (this->m_Controls.radioNewReg->isChecked() || this->m_SelectedPreReg.IsNotNull()));
this->m_Controls.lbNewRegName->setEnabled(m_activeManipulation);
this->m_Controls.checkMapEntity->setEnabled(m_activeManipulation);
this->m_Controls.tabWidget->setEnabled(m_activeManipulation);
this->m_Controls.pbCancel->setEnabled(m_activeManipulation);
this->m_Controls.pbStore->setEnabled(m_activeManipulation);
this->m_Controls.registrationNodeSelector->setEnabled(!m_activeManipulation && this->m_Controls.radioSelectedReg->isChecked());
this->m_Controls.checkAutoSelect->setEnabled(!m_activeManipulation && this->m_Controls.radioSelectedReg->isChecked());
this->m_Controls.movingNodeSelector->setEnabled(!m_activeManipulation);
this->m_Controls.targetNodeSelector->setEnabled(!m_activeManipulation);
}
void QmitkMatchPointRegistrationManipulator::InitSession()
{
if (this->m_Controls.radioNewReg->isChecked())
{ //init to map the image centers
auto movingCenter = m_SelectedMovingNode->GetData()->GetTimeGeometry()->GetCenterInWorld();
auto targetCenter = m_SelectedTargetNode->GetData()->GetTimeGeometry()->GetCenterInWorld();
this->m_Controls.manipulationWidget->Initialize(movingCenter, targetCenter);
}
else
{ //use selected pre registration as baseline
m_Controls.manipulationWidget->Initialize(m_SelectedPreReg);
}
this->m_CurrentRegistration = m_Controls.manipulationWidget->GetInterimRegistration();
this->m_CurrentRegistrationWrapper = mitk::MAPRegistrationWrapper::New(m_CurrentRegistration);
this->m_Controls.comboCenter->setCurrentIndex(0);
this->OnCenterTypeChanged(0);
//reinit view
mitk::RenderingManager::GetInstance()->InitializeViews(m_SelectedTargetNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
//generate evaluation node
mitk::RegEvaluationObject::Pointer regEval = mitk::RegEvaluationObject::New();
regEval->SetRegistration(this->m_CurrentRegistrationWrapper);
regEval->SetTargetNode(this->m_SelectedTargetNode);
regEval->SetMovingNode(this->m_SelectedMovingNode);
this->m_EvalNode = mitk::DataNode::New();
this->m_EvalNode->SetData(regEval);
mitk::RegEvaluationMapper2D::SetDefaultProperties(this->m_EvalNode);
this->m_EvalNode->SetName(HelperNodeName);
this->m_EvalNode->SetBoolProperty("helper object", true);
this->GetDataStorage()->Add(this->m_EvalNode);
this->m_Controls.evalSettings->SetNode(this->m_EvalNode);
this->m_activeManipulation = true;
}
void QmitkMatchPointRegistrationManipulator::StopSession()
{
this->m_activeManipulation = false;
if (this->m_EvalNode.IsNotNull())
{
this->GetDataStorage()->Remove(this->m_EvalNode);
}
this->m_EvalNode = nullptr;
this->m_CurrentRegistration = nullptr;
this->m_CurrentRegistrationWrapper = nullptr;
m_Controls.manipulationWidget->Initialize();
}
void QmitkMatchPointRegistrationManipulator::OnRegistrationChanged()
{
if (this->m_EvalNode.IsNotNull())
{
this->m_EvalNode->Modified();
}
if (this->m_CurrentRegistrationWrapper.IsNotNull())
{
this->m_CurrentRegistrationWrapper->Modified();
}
this->GetRenderWindowPart()->RequestUpdate();
}
void QmitkMatchPointRegistrationManipulator::OnSliceChanged()
{
mitk::Point3D currentSelectedPosition = GetRenderWindowPart()->GetSelectedPosition(nullptr);
auto currentTimePoint = GetRenderWindowPart()->GetSelectedTimePoint();
if (m_currentSelectedPosition != currentSelectedPosition
|| m_currentSelectedTimePoint != currentTimePoint
|| m_selectedNodeTime > m_currentPositionTime)
{
//the current position has been changed or the selected node has been changed since the last position validation -> check position
m_currentSelectedPosition = currentSelectedPosition;
m_currentSelectedTimePoint = currentTimePoint;
m_currentPositionTime.Modified();
if (this->m_EvalNode.IsNotNull())
{
- this->m_EvalNode->SetProperty(mitk::nodeProp_RegEvalCurrentPosition, mitk::GenericProperty<mitk::Point3D>::New(currentSelectedPosition));
+ this->m_EvalNode->SetProperty(mitk::nodeProp_RegEvalCurrentPosition, mitk::Point3dProperty::New(currentSelectedPosition));
}
if (m_activeManipulation && m_Controls.comboCenter->currentIndex() == 2)
{ //update transform with the current position.
m_Controls.manipulationWidget->SetCenterOfRotation(m_currentSelectedPosition);
}
}
}
void QmitkMatchPointRegistrationManipulator::OnSettingsChanged(mitk::DataNode*)
{
this->GetRenderWindowPart()->RequestUpdate();
}
void QmitkMatchPointRegistrationManipulator::OnStartBtnPushed()
{
this->InitSession();
this->OnSliceChanged();
this->GetRenderWindowPart()->RequestUpdate();
this->CheckInputs();
this->ConfigureControls();
}
void QmitkMatchPointRegistrationManipulator::OnCancelBtnPushed()
{
this->StopSession();
this->CheckInputs();
this->ConfigureControls();
if (this->GetRenderWindowPart())
{
this->GetRenderWindowPart()->RequestUpdate();
}
}
void QmitkMatchPointRegistrationManipulator::OnStoreBtnPushed()
{
map::core::RegistrationBase::Pointer newReg = this->m_Controls.manipulationWidget->GenerateRegistration();
auto newRegWrapper = mitk::MAPRegistrationWrapper::New(newReg);
mitk::DataNode::Pointer spResultRegistrationNode = mitk::generateRegistrationResultNode(
this->m_Controls.lbNewRegName->text().toStdString(), newRegWrapper, "org.mitk::manual_registration",
mitk::EnsureUID(m_SelectedMovingNode->GetData()), mitk::EnsureUID(m_SelectedTargetNode->GetData()));
this->GetDataStorage()->Add(spResultRegistrationNode);
if (m_Controls.checkMapEntity->checkState() == Qt::Checked)
{
QmitkMappingJob* pMapJob = new QmitkMappingJob();
pMapJob->setAutoDelete(true);
pMapJob->m_spInputData = this->m_SelectedMovingNode->GetData();
pMapJob->m_InputDataUID = mitk::EnsureUID(m_SelectedMovingNode->GetData());
pMapJob->m_spRegNode = spResultRegistrationNode;
pMapJob->m_doGeometryRefinement = false;
pMapJob->m_spRefGeometry = this->m_SelectedTargetNode->GetData()->GetGeometry()->Clone().GetPointer();
pMapJob->m_MappedName = this->m_Controls.lbNewRegName->text().toStdString() + std::string(" mapped moving data");
pMapJob->m_allowUndefPixels = true;
pMapJob->m_paddingValue = 100;
pMapJob->m_allowUnregPixels = true;
pMapJob->m_errorValue = 200;
pMapJob->m_InterpolatorLabel = "Linear Interpolation";
pMapJob->m_InterpolatorType = mitk::ImageMappingInterpolator::Linear;
connect(pMapJob, SIGNAL(Error(QString)), this, SLOT(Error(QString)));
connect(pMapJob, SIGNAL(MapResultIsAvailable(mitk::BaseData::Pointer, const QmitkMappingJob*)),
this, SLOT(OnMapResultIsAvailable(mitk::BaseData::Pointer, const QmitkMappingJob*)),
Qt::BlockingQueuedConnection);
QThreadPool* threadPool = QThreadPool::globalInstance();
threadPool->start(pMapJob);
}
this->StopSession();
this->CheckInputs();
this->ConfigureControls();
this->GetRenderWindowPart()->RequestUpdate();
}
void QmitkMatchPointRegistrationManipulator::OnMapResultIsAvailable(mitk::BaseData::Pointer spMappedData,
const QmitkMappingJob* job)
{
mitk::DataNode::Pointer spMappedNode = mitk::generateMappedResultNode(job->m_MappedName,
spMappedData, job->GetRegistration()->getRegistrationUID(), job->m_InputDataUID,
job->m_doGeometryRefinement, job->m_InterpolatorLabel);
this->GetDataStorage()->Add(spMappedNode);
this->GetRenderWindowPart()->RequestUpdate();
}
void QmitkMatchPointRegistrationManipulator::OnCenterTypeChanged(int index)
{
ConfigureTransformCenter(index);
if (this->m_EvalNode.IsNotNull())
{
this->m_EvalNode->Modified();
}
if (this->m_CurrentRegistrationWrapper.IsNotNull())
{
this->m_CurrentRegistrationWrapper->Modified();
}
this->GetRenderWindowPart()->RequestUpdate();
}
void QmitkMatchPointRegistrationManipulator::ConfigureTransformCenter(int centerType)
{
if (centerType == 0)
{ //image center
auto center = m_SelectedMovingNode->GetData()->GetTimeGeometry()->GetCenterInWorld();
m_Controls.manipulationWidget->SetCenterOfRotationIsRelativeToTarget(false);
m_Controls.manipulationWidget->SetCenterOfRotation(center);
}
else if (centerType == 1)
{ //world origin
mitk::Point3D center;
center.Fill(0.0);
m_Controls.manipulationWidget->SetCenterOfRotationIsRelativeToTarget(false);
m_Controls.manipulationWidget->SetCenterOfRotation(center);
}
else
{ //current selected point
m_Controls.manipulationWidget->SetCenterOfRotationIsRelativeToTarget(true);
m_Controls.manipulationWidget->SetCenterOfRotation(m_currentSelectedPosition);
}
}
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkConvertToMultiLabelSegmentationAction.cpp b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkConvertToMultiLabelSegmentationAction.cpp
index 4cb6bfe1ce..2e334747df 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkConvertToMultiLabelSegmentationAction.cpp
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkConvertToMultiLabelSegmentationAction.cpp
@@ -1,83 +1,83 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkConvertToMultiLabelSegmentationAction.h"
#include "mitkLabelSetImage.h"
#include "mitkRenderingManager.h"
//needed for qApp
#include <qcoreapplication.h>
QmitkConvertToMultiLabelSegmentationAction::QmitkConvertToMultiLabelSegmentationAction()
{
}
QmitkConvertToMultiLabelSegmentationAction::~QmitkConvertToMultiLabelSegmentationAction()
{
}
void QmitkConvertToMultiLabelSegmentationAction::Run( const QList<mitk::DataNode::Pointer> &selectedNodes )
{
- for (auto referenceNode : selectedNodes)
+ for (const auto &referenceNode : selectedNodes)
{
if (referenceNode.IsNotNull())
{
mitk::Image* referenceImage = dynamic_cast<mitk::Image*>(referenceNode->GetData());
if (nullptr == referenceImage)
{
MITK_WARN << "Could not convert to multi label segmentation for non-image node - skipping action.";
continue;
}
mitk::LabelSetImage::Pointer lsImage = mitk::LabelSetImage::New();
try
{
lsImage->InitializeByLabeledImage(referenceImage);
}
catch (mitk::Exception &e)
{
MITK_ERROR << "Exception caught: " << e.GetDescription();
return;
}
if (m_DataStorage.IsNotNull())
{
mitk::DataNode::Pointer newNode = mitk::DataNode::New();
std::string newName = referenceNode->GetName();
newName += "-labels";
newNode->SetName(newName);
newNode->SetData(lsImage);
m_DataStorage->Add(newNode,referenceNode);
}
lsImage->Modified();
}
}
}
void QmitkConvertToMultiLabelSegmentationAction::SetDataStorage(mitk::DataStorage* dataStorage)
{
m_DataStorage = dataStorage;
}
void QmitkConvertToMultiLabelSegmentationAction::SetFunctionality(berry::QtViewPart* /*functionality*/)
{
//not needed
}
void QmitkConvertToMultiLabelSegmentationAction::SetSmoothed(bool)
{
//not needed
}
void QmitkConvertToMultiLabelSegmentationAction::SetDecimated(bool)
{
//not needed
}
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkCreateMultiLabelPresetAction.cpp b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkCreateMultiLabelPresetAction.cpp
index 37facd0558..5c245ed824 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkCreateMultiLabelPresetAction.cpp
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkCreateMultiLabelPresetAction.cpp
@@ -1,63 +1,63 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkCreateMultiLabelPresetAction.h"
#include <mitkLabelSetImage.h>
#include <mitkLabelSetIOHelper.h>
#include <QFileDialog>
#include <QMessageBox>
void QmitkCreateMultiLabelPresetAction::Run(const QList<mitk::DataNode::Pointer> &selectedNodes)
{
- for (auto node : selectedNodes)
+ for (const auto &node : selectedNodes)
{
if (node.IsNull())
continue;
mitk::LabelSetImage::Pointer image = dynamic_cast<mitk::LabelSetImage*>(node->GetData());
if (image.IsNull())
continue;
const auto filename = QFileDialog::getSaveFileName(nullptr, QStringLiteral("Save LabelSet Preset"),
QString(), QStringLiteral("LabelSet Preset (*.lsetp)")).toStdString();
if (filename.empty())
continue;
if(!mitk::LabelSetIOHelper::SaveLabelSetImagePreset(filename, image))
{
QMessageBox::critical(nullptr, QStringLiteral("Save LabelSetImage Preset"),
QString("Could not save \"%1\" as preset.").arg(QString::fromStdString(node->GetName())));
continue;
}
}
}
void QmitkCreateMultiLabelPresetAction::SetDataStorage(mitk::DataStorage*)
{
}
void QmitkCreateMultiLabelPresetAction::SetFunctionality(berry::QtViewPart*)
{
}
void QmitkCreateMultiLabelPresetAction::SetSmoothed(bool)
{
}
void QmitkCreateMultiLabelPresetAction::SetDecimated(bool)
{
}
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkCreateMultiLabelSegmentationAction.cpp b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkCreateMultiLabelSegmentationAction.cpp
index 723f3b00eb..d476aa0b44 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkCreateMultiLabelSegmentationAction.cpp
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkCreateMultiLabelSegmentationAction.cpp
@@ -1,120 +1,120 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkCreateMultiLabelSegmentationAction.h"
#include "mitkLabelSetImage.h"
#include "mitkRenderingManager.h"
#include "QInputDialog"
#include "QMessageBox"
#include "QmitkNewSegmentationDialog.h"
#include "QmitkMultiLabelSegmentationView.h"
#include "QmitkSegmentationOrganNamesHandling.cpp"
//needed for qApp
#include <qcoreapplication.h>
QmitkCreateMultiLabelSegmentationAction::QmitkCreateMultiLabelSegmentationAction()
{
}
QmitkCreateMultiLabelSegmentationAction::~QmitkCreateMultiLabelSegmentationAction()
{
}
void QmitkCreateMultiLabelSegmentationAction::Run( const QList<mitk::DataNode::Pointer> &selectedNodes )
{
if (m_DataStorage.IsNull())
{
auto message = tr("Data storage not set.");
MITK_ERROR << message;
QMessageBox::warning(nullptr, "New Segmentation Session", message);
return;
}
- for ( auto referenceNode : selectedNodes )
+ for ( const auto &referenceNode : selectedNodes )
{
if (referenceNode.IsNotNull())
{
mitk::Image* referenceImage = dynamic_cast<mitk::Image*>( referenceNode->GetData() );
if (nullptr == referenceImage)
{
MITK_WARN << "Could not create multi label segmentation for non-image node - skipping action.";
continue;
}
QString newName = QString::fromStdString(referenceNode->GetName());
newName.append("-labels");
bool ok = false;
newName = QInputDialog::getText(nullptr, "New Segmentation Session", "New name:", QLineEdit::Normal, newName, &ok);
if(!ok) return;
mitk::LabelSetImage::Pointer workingImage = mitk::LabelSetImage::New();
try
{
workingImage->Initialize(referenceImage);
}
catch ( mitk::Exception& e )
{
MITK_ERROR << "Exception caught: " << e.GetDescription();
QMessageBox::warning(nullptr, "New Segmentation Session", "Could not create a new segmentation session.");
return;
}
mitk::DataNode::Pointer workingNode = mitk::DataNode::New();
workingNode->SetData(workingImage);
workingNode->SetName(newName.toStdString());
// set additional image information
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 (!m_DataStorage->Exists(workingNode))
m_DataStorage->Add(workingNode, referenceNode);
QmitkNewSegmentationDialog* dialog = new QmitkNewSegmentationDialog( );
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());
}
}
}
void QmitkCreateMultiLabelSegmentationAction::SetDataStorage(mitk::DataStorage* dataStorage)
{
m_DataStorage = dataStorage;
}
void QmitkCreateMultiLabelSegmentationAction::SetFunctionality(berry::QtViewPart*)
{
//not needed
}
void QmitkCreateMultiLabelSegmentationAction::SetSmoothed(bool)
{
//not needed
}
void QmitkCreateMultiLabelSegmentationAction::SetDecimated(bool)
{
//not needed
}
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkLoadMultiLabelPresetAction.cpp b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkLoadMultiLabelPresetAction.cpp
index b5ab7769e2..b013a31949 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkLoadMultiLabelPresetAction.cpp
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkLoadMultiLabelPresetAction.cpp
@@ -1,56 +1,56 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkLoadMultiLabelPresetAction.h"
#include <mitkLabelSetImage.h>
#include <mitkLabelSetIOHelper.h>
#include <QFileDialog>
void QmitkLoadMultiLabelPresetAction::Run(const QList<mitk::DataNode::Pointer> &selectedNodes)
{
const auto filename = QFileDialog::getOpenFileName(nullptr, QStringLiteral("Load LabelSet Preset"),
QString(), QStringLiteral("LabelSet Preset (*.lsetp)")).toStdString();
if (filename.empty())
return;
- for (auto node : selectedNodes)
+ for (const auto &node : selectedNodes)
{
if (node.IsNull())
continue;
mitk::LabelSetImage::Pointer image = dynamic_cast<mitk::LabelSetImage*>(node->GetData());
if (image.IsNull())
continue;
mitk::LabelSetIOHelper::LoadLabelSetImagePreset(filename, image);
}
}
void QmitkLoadMultiLabelPresetAction::SetDataStorage(mitk::DataStorage*)
{
}
void QmitkLoadMultiLabelPresetAction::SetFunctionality(berry::QtViewPart*)
{
}
void QmitkLoadMultiLabelPresetAction::SetSmoothed(bool)
{
}
void QmitkLoadMultiLabelPresetAction::SetDecimated(bool)
{
}
diff --git a/README.md b/README.md
index ff95bb0ea0..8e65813fa5 100644
--- a/README.md
+++ b/README.md
@@ -1,93 +1,108 @@
![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
+Supported platforms
-------------------
MITK is a cross-platform C++ toolkit and officially supports:
- Windows
- Linux
- macOS
For details, please read the [Supported Platforms][platforms] page.
+### Build status of develop branch
+
+[![Windows][windows-build-status]][cdash]
+[![Ubuntu 18.04][ubuntu-18.04-build-status]][cdash]
+[![Ubuntu 20.04][ubuntu-20.04-build-status]][cdash]
+[![macOS 10.14 Mojave][macos-10.14-build-status]][cdash]
+
+We highly recommend to use the stable **master** branch instead. It is updated 1-2 times per month accompanied by curated [changelogs][changelog] and [snapshot installers][snapshot-installers].
+
License
-------
Copyright (c) [German Cancer Research Center (DKFZ)][dkfz]. All rights reserved.
MITK is available as free open-source software under a [3-clause BSD 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][phab_repo]. The Git clone command is
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.
+Active development takes place in the MITK develop branch and its usage is advised for advanced users only.
-How to Contribute
+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
+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/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
+Useful links
------------
- [Homepage][mitk]
- [Download][download]
- [Mailing list][mailinglist]
- [Issue tracker][bugs]
[logo]: https://github.com/MITK/MITK/raw/master/mitk.png
[mitk]: http://mitk.org
[itk]: https://itk.org
[vtk]: https://vtk.org
[mitk-overview]: http://docs.mitk.org/nightly/Overview.html
[mitk-usermanual]: http://docs.mitk.org/nightly/UserManualPortal.html
[mitk-devmanual]: http://docs.mitk.org/nightly/DeveloperManualPortal.html
[mitk-apiref]: http://docs.mitk.org/nightly/usergroup0.html
[platforms]: http://docs.mitk.org/nightly/SupportedPlatformsPage.html
[dkfz]: https://www.dkfz.de
[license]: https://github.com/MITK/MITK/blob/master/LICENSE
[release-cycle]: http://mitk.org/MitkReleaseCycle
[download]: http://mitk.org/Download
[phab_repo]: https://phabricator.mitk.org/source/mitk/
[contribute]: http://mitk.org/How_to_contribute
[cmake]: https://www.cmake.org
[build]: http://docs.mitk.org/nightly/BuildInstructionsPage.html
[mailinglist]: http://mitk.org/Mailinglist
[bugs]: https://phabricator.mitk.org/maniphest/
+[cdash]: https://cdash.mitk.org/index.php?project=MITK
+[changelog]: https://phabricator.mitk.org/w/mitk/changelog/
+[snapshot-installers]: https://www.mitk.org/download/ci/snapshots/
+[windows-build-status]: https://ci.mitk.org/buildStatus/icon?job=MITK%2FContinuous%2FWindows&subject=Windows
+[ubuntu-18.04-build-status]: https://ci.mitk.org/buildStatus/icon?job=MITK%2FContinuous%2FUbuntu+18.04&subject=Ubuntu+18.04
+[ubuntu-20.04-build-status]: https://ci.mitk.org/buildStatus/icon?job=MITK%2FContinuous%2FUbuntu+20.04&subject=Ubuntu+20.04
+[macOS-10.14-build-status]: https://ci.mitk.org/buildStatus/icon?job=MITK%2FContinuous%2FmacOS+Mojave&subject=macOS+10.14+Mojave
diff --git a/Utilities/IpPic/ipFRead.c b/Utilities/IpPic/ipFRead.c
index 40fe74aad5..19a42042c0 100755
--- a/Utilities/IpPic/ipFRead.c
+++ b/Utilities/IpPic/ipFRead.c
@@ -1,172 +1,174 @@
/*============================================================================
Copyright (c) German Cancer Research Center (DKFZ)
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.
- All advertising materials mentioning features or use of this software must
display the following acknowledgement:
"This product includes software developed by the German Cancer Research
Center (DKFZ)."
- Neither the name of the German Cancer Research Center (DKFZ) 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 GERMAN CANCER RESEARCH CENTER (DKFZ) 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 GERMAN
CANCER RESEARCH CENTER (DKFZ) 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.
============================================================================*/
/*
* $RCSfile$
*--------------------------------------------------------------------
* DESCRIPTION
* reads big- and litle- endian from disk
* and swaps to the other endianess
*
* $Log$
* Revision 1.14 2005/09/09 09:14:45 ivo
* FIX: warnings on windows
*
* Revision 1.13 2003/03/06 10:53:08 andre
* *** empty log message ***
*
* Revision 1.12 2002/11/13 17:52:59 ivo
* new ipPic added.
*
* Revision 1.10 2002/02/27 08:54:43 andre
* zlib changes
*
* Revision 1.9 2000/05/04 12:52:35 ivo
* inserted BSD style license
*
* Revision 1.8 2000/01/17 18:31:59 andre
* *** empty log message ***
*
* Revision 1.7 1999/12/09 19:12:09 andre
* *** empty log message ***
*
* Revision 1.5 1999/11/29 09:34:34 andre
* *** empty log message ***
*
* Revision 1.4 1999/11/28 16:27:20 andre
* *** empty log message ***
*
* Revision 1.3 1999/11/27 19:15:08 andre
* *** empty log message ***
*
* Revision 1.2 1997/09/15 13:21:08 andre
* switched to new what string format
*
* Revision 1.1.1.1 1997/09/06 19:09:58 andre
* initial import
*
* Revision 0.1 1993/04/02 16:18:39 andre
* now works on PC, SUN and DECstation
*
* Revision 0.0 1993/03/26 12:56:26 andre
* Initial revision, NO error checking
*
*
*--------------------------------------------------------------------
*
*/
#ifndef lint
static char *what = { "@(#)_ipFRead\t\tGerman Cancer Research Center (DKFZ)\t"__DATE__"\t$Revision$" };
#endif
#include <stdio.h>
#include <stdlib.h>
#ifdef WIN32
#include <io.h>
+#else
+#include <unistd.h>
#endif
#include "mitkIpPic.h"
size_t
mitkIpFReadCvt( void *ptr, size_t size, size_t nitems, FILE *stream )
{
size_t bytes_return;
bytes_return = fread( ptr, size, nitems, stream );
_mitkIpCvtEndian( ptr, size*nitems, size );
return( bytes_return );
}
#ifdef USE_ZLIB
mitkIpBool_t _mitkIpPicCanReadCompressed = mitkIpTrue;
#else
mitkIpBool_t _mitkIpPicCanReadCompressed = mitkIpFalse;
#endif
size_t
mitkIpPicFReadCvt( void *ptr, size_t size, size_t nitems, mitkIpPicFile_t stream )
{
size_t bytes_return;
bytes_return = mitkIpPicFRead( ptr, size, nitems, stream );
_mitkIpCvtEndian( ptr, size*nitems, size );
return( bytes_return );
}
int
mitkIpPicAccess( const char *path, int mode )
{
int status;
status = access( path, mode );
if( status == -1 )
{
char buff[1024];
sprintf( buff, "%s.gz", path );
status = access( buff, mode );
}
return( status );
}
int
mitkIpPicRemoveFile( const char *path )
{
int status;
status = remove( path );
if( status != 0 )
{
char buff[1024];
sprintf( buff, "%s.gz", path );
status = remove( buff );
}
return( status );
}