diff --git a/CMake/FindDCMTK.cmake b/CMake/FindDCMTK.cmake deleted file mode 100644 index ccdd2ce106..0000000000 --- a/CMake/FindDCMTK.cmake +++ /dev/null @@ -1,186 +0,0 @@ -# adapted version of FindDCMTK, better suited for super-builds - -# - find DCMTK libraries and applications -# - -# 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 -# -# DCMTK_DIR can be used to make it simpler to find the various include -# directories and compiled libraries if you've just compiled it in the -# source tree. Just set it to the root of the tree where you extracted -# the source (default to /usr/include/dcmtk/) - -#============================================================================= -# Copyright 2004-2009 Kitware, Inc. -# Copyright 2009-2010 Mathieu Malaterre -# Copyright 2010 Thomas Sondergaard -# -# 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 distributed 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. -# - -# prefer DCMTK_DIR over default system paths like /usr/lib -set(CMAKE_PREFIX_PATH ${DCMTK_DIR}/lib ${CMAKE_PREFIX_PATH}) # this is given to FIND_LIBRARY or FIND_PATH - -if(NOT DCMTK_FOUND AND NOT DCMTK_DIR) - set(DCMTK_DIR - "/usr/include/dcmtk/" - CACHE - PATH - "Root of DCMTK source tree (optional).") - mark_as_advanced(DCMTK_DIR) -endif() - -# Find all libraries, store debug and release separately -foreach(lib - dcmpstat - dcmsr - dcmsign - dcmtls - dcmqrdb - dcmnet - dcmjpeg - dcmimage - dcmimgle - dcmdata - dcmrt - 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 - set(DCMTK_${lib}_LIBRARY) - if(DCMTK_${lib}_LIBRARY_RELEASE) - list(APPEND DCMTK_LIBRARIES optimized ${DCMTK_${lib}_LIBRARY_RELEASE}) - list(APPEND DCMTK_${lib}_LIBRARY optimized ${DCMTK_${lib}_LIBRARY_RELEASE}) - endif() - - if(DCMTK_${lib}_LIBRARY_DEBUG) - list(APPEND DCMTK_LIBRARIES debug ${DCMTK_${lib}_LIBRARY_DEBUG}) - list(APPEND DCMTK_${lib}_LIBRARY debug ${DCMTK_${lib}_LIBRARY_DEBUG}) - endif() - -endforeach() - -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_dcmrt_TEST_HEADER drtstrct.h) - -foreach(dir - config - dcmdata - dcmimage - dcmimgle - dcmjpeg - dcmnet - dcmpstat - dcmqrdb - dcmsign - dcmsr - dcmtls - dcmrt - ofstd) - 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}/include/${dir}) - - mark_as_advanced(DCMTK_${dir}_INCLUDE_DIR) - #message("** DCMTKs ${dir} found at ${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() - -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() - -include(FindPackageHandleStandardArgs) -find_package_handle_standard_args(DCMTK DEFAULT_MSG - DCMTK_config_INCLUDE_DIR - DCMTK_ofstd_INCLUDE_DIR - DCMTK_ofstd_LIBRARY - DCMTK_dcmdata_INCLUDE_DIR - DCMTK_dcmdata_LIBRARY - DCMTK_dcmimgle_INCLUDE_DIR - DCMTK_dcmimgle_LIBRARY - ) - -# Compatibility: This variable is deprecated -set(DCMTK_INCLUDE_DIR ${DCMTK_INCLUDE_DIRS}) diff --git a/CMake/PackageDepends/MITK_DCMTK_Config.cmake b/CMake/PackageDepends/MITK_DCMTK_Config.cmake index 7be335f38f..f06720f125 100644 --- a/CMake/PackageDepends/MITK_DCMTK_Config.cmake +++ b/CMake/PackageDepends/MITK_DCMTK_Config.cmake @@ -1,39 +1,8 @@ if( NOT WIN32 AND NOT APPLE ) set(MISSING_LIBS_REQUIRED_BY_DCMTK wrap tiff z) endif( NOT WIN32 AND NOT APPLE ) set(QT_USE_QTSQL 1) -if(EXISTS ${DCMTK_config_INCLUDE_DIR}/osconfig.h) - - file(READ ${DCMTK_config_INCLUDE_DIR}/osconfig.h _osconfig_h) - if(NOT _osconfig_h MATCHES "PACKAGE_VERSION_NUMBER \"354\"") - # message(STATUS "Found DCMTK newer that 3.5.4 ...") - set(MITK_USE_DCMTK_NEWER_THAN_3_5_4 TRUE) - # assume the new oflog library is located next to the others - # this can be removed if FindDCMTK is adapted for 3.5.5 - # treat Debug and Release separately - get_filename_component(_DCMTK_lib_dir_release ${DCMTK_ofstd_LIBRARY_RELEASE} PATH) - get_filename_component(_DCMTK_lib_dir_debug ${DCMTK_ofstd_LIBRARY_DEBUG} PATH) - set(DCMTK_oflog_LIBRARY_RELEASE ) - set(DCMTK_oflog_LIBRARY_DEBUG ) - if(_DCMTK_lib_dir_release) - find_library(DCMTK_oflog_LIBRARY_RELEASE oflog ${_DCMTK_lib_dir_release} ) - list(APPEND DCMTK_LIBRARIES optimized ${DCMTK_oflog_LIBRARY_RELEASE} ) - endif() - if(_DCMTK_lib_dir_debug) - find_library(DCMTK_oflog_LIBRARY_DEBUG oflog ${_DCMTK_lib_dir_debug} ) - list(APPEND DCMTK_LIBRARIES debug ${DCMTK_oflog_LIBRARY_DEBUG} ) - endif() - endif() -endif() - -# -# Usually all code should be adapted to DCMTK 3.6 -# If necessary you could configure the MITK_USE_DCMTK_NEWER_THAN_3_5_4 variable -# to configure a header file for ifdefs: -# configure_file( mitkDCMTKConfig.h.in mitkDCMTKConfig.h ) - list(APPEND ALL_INCLUDE_DIRECTORIES ${DCMTK_INCLUDE_DIR}) list(APPEND ALL_LIBRARIES ${DCMTK_LIBRARIES} ${MISSING_LIBS_REQUIRED_BY_DCMTK}) - diff --git a/CMakeLists.txt b/CMakeLists.txt index 3083185199..a3709f9483 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,1390 +1,1373 @@ set(MITK_CMAKE_MINIMUM_REQUIRED_VERSION 3.5) cmake_minimum_required(VERSION ${MITK_CMAKE_MINIMUM_REQUIRED_VERSION}) #----------------------------------------------------------------------------- # See http://www.cmake.org/cmake/help/v3.5/manual/cmake-policies.7.html for details #----------------------------------------------------------------------------- set(project_policies ) foreach(policy ${project_policies}) if(POLICY ${policy}) cmake_policy(SET ${policy} NEW) endif() endforeach() #----------------------------------------------------------------------------- # Superbuild Option - Enabled by default #----------------------------------------------------------------------------- option(MITK_USE_SUPERBUILD "Build MITK and the projects it depends on via SuperBuild.cmake." ON) if(MITK_USE_SUPERBUILD) project(MITK-superbuild) set(MITK_SOURCE_DIR ${PROJECT_SOURCE_DIR}) set(MITK_BINARY_DIR ${PROJECT_BINARY_DIR}) else() project(MITK VERSION 2016.11.00) endif() #----------------------------------------------------------------------------- # Update CMake module path #------------------------------------------------------------------------------ set(MITK_CMAKE_DIR ${MITK_SOURCE_DIR}/CMake) set(CMAKE_MODULE_PATH ${MITK_CMAKE_DIR} ${CMAKE_MODULE_PATH} ) #----------------------------------------------------------------------------- # CMake function(s) and macro(s) #----------------------------------------------------------------------------- # Standard CMake macros include(FeatureSummary) include(CTestUseLaunchers) include(CMakeParseArguments) include(FindPackageHandleStandardArgs) # MITK macros include(mitkFunctionGetGccVersion) include(mitkFunctionCheckCompilerFlags) include(mitkFunctionSuppressWarnings) # includes several functions include(mitkMacroEmptyExternalProject) include(mitkFunctionGenerateProjectXml) include(mitkFunctionEnableBuildConfiguration) include(mitkFunctionWhitelists) include(mitkFunctionAddExternalProject) SUPPRESS_VC_DEPRECATED_WARNINGS() #----------------------------------------------------------------------------- # Set a default build type if none was specified #----------------------------------------------------------------------------- if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) message(STATUS "Setting build type to 'Debug' as none was specified.") set(CMAKE_BUILD_TYPE Debug CACHE STRING "Choose the type of build." FORCE) # Set the possible values of build type for cmake-gui set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo") endif() #----------------------------------------------------------------------------- # Check miminum Mac OS X version #----------------------------------------------------------------------------- # The minimum supported Mac OS X version is 10.9. If you use a version less than 10.9, there is no guarantee that the build still works. if(APPLE) exec_program(sw_vers ARGS -productVersion OUTPUT_VARIABLE osx_version) if (osx_version VERSION_LESS "10.9") message(WARNING "Detected OS X version \"${osx_version}\" is not supported anymore. Minimum required OS X version is 10.9 or greater.") endif() if (CMAKE_OSX_DEPLOYMENT_TARGET AND CMAKE_OSX_DEPLOYMENT_TARGET VERSION_LESS 10.9) message(WARNING "Detected OS X deployment target \"${CMAKE_OSX_DEPLOYMENT_TARGET}\" is not supported anymore. Minimum required OS X version is 10.9 or greater.") endif() endif() #----------------------------------------------------------------------------- # Check miminum compiler versions #----------------------------------------------------------------------------- if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") # require at least gcc 4.9 as provided by ppa:ubuntu-toolchain-r/test for Ubuntu 12.04 if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.9) message(FATAL_ERROR "GCC version must be at least 4.9 If you are using Ubuntu 12.04, you can easily install gcc and g++ 4.9 (or any later version available) in addition to your version ${CMAKE_CXX_COMPILER_VERSION}: sudo add-apt-repository ppa:ubuntu-toolchain-r/test sudo apt-get update sudo apt-get install gcc-4.9 g++-4.9 Make sure to explicitly specify these compilers when configuring MITK: CMAKE_C_COMPILER:FILEPATH=/usr/bin/gcc-4.9 CMAKE_CXX_COMPILER:FILEPATH=/usr/bin/g++-4.9 For more information on the proposed PPA see the Toolchain Updates section of https://wiki.ubuntu.com/ToolChain.") endif() elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") # require at least clang 3.4 as provided by Ubuntu 12.04 if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.4) message(FATAL_ERROR "Clang version must be at least 3.4") endif() elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang") # require at least clang 5.0 if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0) message(FATAL_ERROR "Apple Clang version must be at least 5.0") endif() elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") # require at least Visual Studio 2013 if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 18.0.40629.0) message(FATAL_ERROR "Microsoft Visual Studio 2013 Update 5 or newer required (MSVC 18.0.40629.0)") endif() else() message(WARNING "You are using an unsupported compiler! Compilation has only been tested with Clang (Linux or Apple), GCC and MSVC.") endif() if(CMAKE_COMPILER_IS_GNUCXX) mitkFunctionGetGccVersion(${CMAKE_CXX_COMPILER} GCC_VERSION) else() set(GCC_VERSION 0) endif() set(MITK_CXX_STANDARD 11) set(CMAKE_CXX_EXTENSIONS 0) set(CMAKE_CXX_STANDARD ${MITK_CXX_STANDARD}) set(CMAKE_CXX_STANDARD_REQUIRED 1) # This is necessary to avoid problems with compile feature checks. # CMAKE_CXX_STANDARD seems to only set the -std=c++11 flag for targets. # However, compile flag checks also need to be done with -std=c++11. # The MITK_CXX11_FLAG variable is also used for external projects # build during the MITK super-build. mitkFunctionCheckCompilerFlags("-std=c++11" MITK_CXX11_FLAG) if(NOT MITK_CXX11_FLAG) # Older gcc compilers use -std=c++0x mitkFunctionCheckCompilerFlags("-std=c++0x" MITK_CXX11_FLAG) endif() #----------------------------------------------------------------------------- # Warn if source or build path is too long #----------------------------------------------------------------------------- if(WIN32) set(_src_dir_length_max 50) set(_bin_dir_length_max 50) if(MITK_USE_SUPERBUILD) set(_src_dir_length_max 34) # _src_dir_length_max - strlen(ep/src/ITK-build) set(_bin_dir_length_max 40) # _bin_dir_length_max - strlen(MITK-build) endif() string(LENGTH "${MITK_SOURCE_DIR}" _src_n) string(LENGTH "${MITK_BINARY_DIR}" _bin_n) # The warnings should be converted to errors if(_src_n GREATER _src_dir_length_max) message(WARNING "MITK source code directory path length is too long (${_src_n} > ${_src_dir_length_max})." "Please move the MITK source code directory to a directory with a shorter path." ) endif() if(_bin_n GREATER _bin_dir_length_max) message(WARNING "MITK build directory path length is too long (${_bin_n} > ${_bin_dir_length_max})." "Please move the MITK build directory to a directory with a shorter path." ) endif() endif() #----------------------------------------------------------------------------- # Additional MITK Options (also shown during superbuild) #----------------------------------------------------------------------------- macro(env_option name doc value) set(_value $ENV{${name}}) if("${_value}" STREQUAL "") set(_value ${value}) endif() option(${name} "${doc}" ${_value}) endmacro() # ----------------------------------------- # General build options option(BUILD_SHARED_LIBS "Build MITK with shared libraries" ON) option(WITH_COVERAGE "Enable/Disable coverage" OFF) option(BUILD_TESTING "Test the project" ON) env_option(MITK_BUILD_ALL_APPS "Build all MITK applications" OFF) env_option(MITK_BUILD_EXAMPLES "Build the MITK Examples" OFF) option(MITK_ENABLE_PIC_READER "Enable support for reading the DKFZ pic file format." ON) mark_as_advanced(MITK_BUILD_ALL_APPS MITK_ENABLE_PIC_READER ) # ----------------------------------------- # Qt version related variables env_option(MITK_USE_Qt5 "Use Qt 5 library" ON) env_option(MITK_USE_Qt5_WebEngine "Use Qt 5 WebEngine library" ON) if(MITK_USE_Qt5) set(MITK_QT5_MINIMUM_VERSION 5.6.0) set(MITK_QT5_COMPONENTS Concurrent OpenGL PrintSupport Script Sql Svg Widgets Xml XmlPatterns UiTools Help LinguistTools) if(MITK_USE_Qt5_WebEngine) set(MITK_QT5_COMPONENTS ${MITK_QT5_COMPONENTS} WebEngineWidgets) endif() if(APPLE) set(MITK_QT5_COMPONENTS ${MITK_QT5_COMPONENTS} DBus) endif() find_package(Qt5 ${MITK_QT5_MINIMUM_VERSION} COMPONENTS ${MITK_QT5_COMPONENTS} REQUIRED) if(Qt5_DIR) get_filename_component(_Qt5_DIR "${Qt5_DIR}/../../../" ABSOLUTE) list(FIND CMAKE_PREFIX_PATH "${_Qt5_DIR}" _result) if(_result LESS 0) set(CMAKE_PREFIX_PATH "${_Qt5_DIR};${CMAKE_PREFIX_PATH}" CACHE PATH "" FORCE) endif() endif() elseif(MITK_USE_Qt5_WebEngine) set(MITK_USE_Qt5_WebEngine OFF) endif() # ------------------------------------------------------------------------ # Register external projects which can be build with the MITK superbuild # system. Each mitkFunctionAddExternalProject() call registers an external # project for which a CMakeExternals/.cmake file must exist. The # call also creates a MITK_USE_ variable (appearing in the CMake # UI if the NO_CACHE option is *not* given). # ----------------------------------------- # Optional external projects with no # inter-dependencies set_property(GLOBAL PROPERTY MITK_EXTERNAL_PROJECTS "") mitkFunctionAddExternalProject(NAME Poco ON COMPONENTS Foundation Net Util XML Zip) mitkFunctionAddExternalProject(NAME DCMTK ON DOC "EXPERIMENTAL, superbuild only: Use DCMTK in MITK") mitkFunctionAddExternalProject(NAME OpenIGTLink OFF) mitkFunctionAddExternalProject(NAME tinyxml ON ADVANCED) mitkFunctionAddExternalProject(NAME GDCM ON ADVANCED) mitkFunctionAddExternalProject(NAME GLUT OFF ADVANCED) mitkFunctionAddExternalProject(NAME Raptor2 OFF ADVANCED) mitkFunctionAddExternalProject(NAME Eigen ON ADVANCED DOC "Use the Eigen library") mitkFunctionAddExternalProject(NAME GLEW ON ADVANCED DOC "Use the GLEW library") mitkFunctionAddExternalProject(NAME ANN ON ADVANCED DOC "Use Approximate Nearest Neighbor Library") mitkFunctionAddExternalProject(NAME CppUnit ON ADVANCED DOC "Use CppUnit for unit tests") mitkFunctionAddExternalProject(NAME PCRE OFF ADVANCED NO_PACKAGE) mitkFunctionAddExternalProject(NAME ZLIB OFF ADVANCED NO_PACKAGE NO_CACHE) mitkFunctionAddExternalProject(NAME HDF5 OFF ADVANCED) # ----------------------------------------- # The following external projects must be # ordered according to their # inter-dependencies mitkFunctionAddExternalProject(NAME SWIG OFF ADVANCED NO_PACKAGE DEPENDS PCRE) mitkFunctionAddExternalProject(NAME Python OFF NO_PACKAGE DEPENDS SWIG DOC "Use Python wrapping in MITK") mitkFunctionAddExternalProject(NAME Numpy OFF ADVANCED NO_PACKAGE) mitkFunctionAddExternalProject(NAME OpenCV OFF) mitkFunctionAddExternalProject(NAME Vigra OFF DEPENDS HDF5) # These are "hard" dependencies and always set to ON mitkFunctionAddExternalProject(NAME ITK ON NO_CACHE) mitkFunctionAddExternalProject(NAME VTK ON NO_CACHE) mitkFunctionAddExternalProject(NAME Boost ON NO_CACHE) mitkFunctionAddExternalProject(NAME SimpleITK OFF DEPENDS ITK GDCM SWIG) mitkFunctionAddExternalProject(NAME ACVD OFF DOC "Use Approximated Centroidal Voronoi Diagrams") mitkFunctionAddExternalProject(NAME CTK ON DEPENDS QT DCMTK DOC "Use CTK in MITK") mitkFunctionAddExternalProject(NAME Rasqal OFF DEPENDS Raptor2 PCRE ADVANCED) mitkFunctionAddExternalProject(NAME Redland OFF DEPENDS Rasqal DOC "Use the Redland RDF library") mitkFunctionAddExternalProject(NAME SOFA OFF DEPENDS GLUT Boost DOC "Use Simulation Open Framework Architecture") mitkFunctionAddExternalProject(NAME VMTK OFF DEPENDS ITK VTK) mitkFunctionAddExternalProject(NAME MatchPoint OFF ADVANCED DEPENDS ITK DOC "Use the MatchPoint translation image registration library") if(MITK_USE_Qt5) mitkFunctionAddExternalProject(NAME Qwt ON ADVANCED DEPENDS QT) endif() # ----------------------------------------- # Other MITK_USE_* options not related to # external projects build via the # MITK superbuild env_option(MITK_USE_BLUEBERRY "Build the BlueBerry platform" ON) env_option(MITK_USE_OpenCL "Use OpenCL GPU-Computing library" OFF) #----------------------------------------------------------------------------- # Build configurations #----------------------------------------------------------------------------- set(_buildConfigs "Custom") file(GLOB _buildConfigFiles CMake/BuildConfigurations/*.cmake) foreach(_buildConfigFile ${_buildConfigFiles}) get_filename_component(_buildConfigFile ${_buildConfigFile} NAME_WE) list(APPEND _buildConfigs ${_buildConfigFile}) endforeach() set(MITK_BUILD_CONFIGURATION "Custom" CACHE STRING "Use pre-defined MITK configurations") set_property(CACHE MITK_BUILD_CONFIGURATION PROPERTY STRINGS ${_buildConfigs}) mitkFunctionEnableBuildConfiguration() mitkFunctionCreateWhitelistPaths(MITK) mitkFunctionFindWhitelists(MITK) # ----------------------------------------- # Custom dependency logic option(MITK_USE_SYSTEM_Boost "Use the system Boost" OFF) set(MITK_USE_Boost_LIBRARIES "" CACHE STRING "A semi-colon separated list of required Boost libraries") if(MITK_USE_SOFA) # SOFA requires boost system library list(FIND MITK_USE_Boost_LIBRARIES system _result) if(_result LESS 0) message("> Adding 'system' to MITK_USE_Boost_LIBRARIES.") list(APPEND MITK_USE_Boost_LIBRARIES system) endif() # SOFA requires boost thread library list(FIND MITK_USE_Boost_LIBRARIES thread _result) if(_result LESS 0) message("> Adding 'thread' to MITK_USE_Boost_LIBRARIES.") list(APPEND MITK_USE_Boost_LIBRARIES thread) endif() # Simulation plugin requires boost chrono library list(FIND MITK_USE_Boost_LIBRARIES chrono _result) if(_result LESS 0) message("> Adding 'chrono' to MITK_USE_Boost_LIBRARIES.") list(APPEND MITK_USE_Boost_LIBRARIES chrono) endif() set(MITK_USE_Boost_LIBRARIES ${MITK_USE_Boost_LIBRARIES} CACHE STRING "" FORCE) # Allow setting external SOFA plugins directory and SOFA plugins set(MITK_USE_SOFA_PLUGINS_DIR ${MITK_USE_SOFA_PLUGINS_DIR} CACHE PATH "External SOFA plugins directory" FORCE) set(MITK_USE_SOFA_PLUGINS ${MITK_USE_SOFA_PLUGINS} CACHE PATH "List of semicolon-separated plugin names" FORCE) endif() # only windows can't build python in debug mode if(MITK_USE_Python AND "${CMAKE_BUILD_TYPE}" STREQUAL "Debug" AND WIN32) message(WARNING "Disabling Python support. Building MITK Python in debug mode on Windowsis not supported!") set(MITK_USE_Python OFF CACHE BOOL "Use python wrapping in MITK" FORCE) set(MITK_USE_Numpy OFF CACHE BOOL "Use Numpy" FORCE) set(MITK_USE_SimpleITK OFF CACHE BOOL "Use SimpleITK" FORCE) elseif(MITK_USE_Python) set(MITK_USE_ZLIB ON) if(NOT MITK_USE_Numpy) message("> Forcing MITK_USE_Numpy to ON because of MITK_USE_Python") set(MITK_USE_Numpy ON CACHE BOOL "Use Numpy" FORCE) endif() if(NOT MITK_USE_SimpleITK) message("> Forcing MITK_USE_SimpleITK to ON because of MITK_USE_Python") set(MITK_USE_SimpleITK ON CACHE BOOL "Use SimpleITK" FORCE) endif() option(MITK_USE_SYSTEM_PYTHON "Use the system python runtime" OFF) if(MITK_USE_SYSTEM_PYTHON) find_package(PythonLibs REQUIRED) find_package(PythonInterp REQUIRED) endif() elseif(MITK_USE_Python AND "${CMAKE_BUILD_TYPE}" STREQUAL "Debug" AND WIN32) message(WARNING "Disabling Python support. Building MITK Python in debug mode on Windowsis not supported!") set(MITK_USE_Python OFF CACHE BOOL "Use python wrapping in MITK" FORCE) endif() if(BUILD_TESTING AND NOT MITK_USE_CppUnit) message("> Forcing MITK_USE_CppUnit to ON because BUILD_TESTING=ON") set(MITK_USE_CppUnit ON CACHE BOOL "Use CppUnit for unit tests" FORCE) endif() if(MITK_USE_BLUEBERRY) option(MITK_BUILD_ALL_PLUGINS "Build all MITK plugins" OFF) mark_as_advanced(MITK_BUILD_ALL_PLUGINS) if(NOT MITK_USE_CTK) message("> Forcing MITK_USE_CTK to ON because of MITK_USE_BLUEBERRY") set(MITK_USE_CTK ON CACHE BOOL "Use CTK in MITK" FORCE) endif() endif() #----------------------------------------------------------------------------- # Pixel type multiplexing #----------------------------------------------------------------------------- # Customize the default pixel types for multiplex macros set(MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES "int, unsigned int, short, unsigned short, char, unsigned char" CACHE STRING "List of integral pixel types used in AccessByItk and InstantiateAccessFunction macros") set(MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES "double, float" CACHE STRING "List of floating pixel types used in AccessByItk and InstantiateAccessFunction macros") set(MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES "itk::RGBPixel, itk::RGBAPixel" 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, itk::RGBAPixel" CACHE STRING "List of composite pixel types used in AccessByItk and InstantiateAccessFunction macros" FORCE) endif() if(NOT MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES) string(REPLACE "," ";" _integral_types ${MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES}) string(REPLACE "," ";" _floating_types ${MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES}) foreach(_scalar_type ${_integral_types} ${_floating_types}) set(MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES "${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}itk::VariableLengthVector<${_scalar_type}>,") endforeach() string(LENGTH "${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}" _length) math(EXPR _length "${_length} - 1") string(SUBSTRING "${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}" 0 ${_length} MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES) set(MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES ${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES} CACHE STRING "List of vector pixel types used in AccessByItk and InstantiateAccessFunction macros for itk::VectorImage types" FORCE) endif() if(NOT MITK_ACCESSBYITK_DIMENSIONS) set(MITK_ACCESSBYITK_DIMENSIONS "2,3" CACHE STRING "List of dimensions used in AccessByItk and InstantiateAccessFunction macros") endif() #----------------------------------------------------------------------------- # Project.xml #----------------------------------------------------------------------------- # A list of topologically ordered targets set(CTEST_PROJECT_SUBPROJECTS) list(APPEND CTEST_PROJECT_SUBPROJECTS MITK-Core MITK-CoreUI MITK-IGT MITK-ToF MITK-DTI MITK-Registration MITK-Modules # all modules not contained in a specific subproject MITK-Plugins # all plugins not contained in a specific subproject MITK-Examples Unlabeled # special "subproject" catching all unlabeled targets and tests ) # Configure CTestConfigSubProject.cmake that could be used by CTest scripts configure_file(${MITK_SOURCE_DIR}/CTestConfigSubProject.cmake.in ${MITK_BINARY_DIR}/CTestConfigSubProject.cmake) if(CTEST_PROJECT_ADDITIONAL_TARGETS) # those targets will be executed at the end of the ctest driver script # and they also get their own subproject label set(subproject_list "${CTEST_PROJECT_SUBPROJECTS};${CTEST_PROJECT_ADDITIONAL_TARGETS}") else() set(subproject_list "${CTEST_PROJECT_SUBPROJECTS}") endif() # Generate Project.xml file expected by the CTest driver script mitkFunctionGenerateProjectXml(${MITK_BINARY_DIR} MITK "${subproject_list}" ${MITK_USE_SUPERBUILD}) #----------------------------------------------------------------------------- # Superbuild script #----------------------------------------------------------------------------- if(MITK_USE_SUPERBUILD) include("${CMAKE_CURRENT_SOURCE_DIR}/SuperBuild.cmake") # Print configuration summary message("\n\n") feature_summary( DESCRIPTION "------- FEATURE SUMMARY FOR ${PROJECT_NAME} -------" WHAT ALL) return() endif() #***************************************************************************** #**************************** END OF SUPERBUILD **************************** #***************************************************************************** #----------------------------------------------------------------------------- # CMake function(s) and macro(s) #----------------------------------------------------------------------------- include(WriteBasicConfigVersionFile) include(CheckCXXSourceCompiles) include(GenerateExportHeader) include(mitkFunctionAddCustomModuleTest) include(mitkFunctionCheckModuleDependencies) include(mitkFunctionCompileSnippets) include(mitkFunctionConfigureVisualStudioUserProjectFile) include(mitkFunctionConvertXPSchema) include(mitkFunctionCreateBlueBerryApplication) include(mitkFunctionCreateCommandLineApp) include(mitkFunctionCreateModule) include(mitkFunctionCreatePlugin) include(mitkFunctionCreateProvisioningFile) include(mitkFunctionGetLibrarySearchPaths) include(mitkFunctionGetVersion) include(mitkFunctionGetVersionDescription) include(mitkFunctionInstallAutoLoadModules) include(mitkFunctionInstallCTKPlugin) include(mitkFunctionInstallProvisioningFiles) include(mitkFunctionInstallThirdPartyCTKPlugins) include(mitkFunctionOrganizeSources) include(mitkFunctionTestPlugin) include(mitkFunctionUseModules) if( ${MITK_USE_MatchPoint} ) include(mitkFunctionCreateMatchPointDeployedAlgorithm) endif() include(mitkMacroConfigureItkPixelTypes) include(mitkMacroCreateExecutable) include(mitkMacroCreateModuleTests) include(mitkMacroGenerateToolsLibrary) include(mitkMacroGetLinuxDistribution) include(mitkMacroGetPMDPlatformString) include(mitkMacroInstall) include(mitkMacroInstallHelperApp) include(mitkMacroInstallTargets) include(mitkMacroMultiplexPicType) # Deprecated include(mitkMacroCreateCTKPlugin) #----------------------------------------------------------------------------- # Global CMake variables #----------------------------------------------------------------------------- # Required and enabled C++11 features for all MITK code. # These are added as PUBLIC compile features to all MITK modules. set(MITK_CXX_FEATURES cxx_auto_type cxx_decltype cxx_enum_forward_declarations cxx_extended_friend_declarations cxx_extern_templates cxx_final cxx_lambdas cxx_local_type_template_args cxx_long_long_type cxx_nullptr cxx_override cxx_range_for cxx_right_angle_brackets cxx_rvalue_references cxx_static_assert cxx_strong_enums cxx_template_template_parameters cxx_trailing_return_types cxx_variadic_macros ) if(NOT DEFINED CMAKE_DEBUG_POSTFIX) # We can't do this yet because the CTK Plugin Framework # cannot cope with a postfix yet. #set(CMAKE_DEBUG_POSTFIX d) endif() #----------------------------------------------------------------------------- # Output directories. #----------------------------------------------------------------------------- set(_default_LIBRARY_output_dir lib) set(_default_RUNTIME_output_dir bin) set(_default_ARCHIVE_output_dir lib) foreach(type LIBRARY RUNTIME ARCHIVE) # Make sure the directory exists if(MITK_CMAKE_${type}_OUTPUT_DIRECTORY AND NOT EXISTS ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY}) message("Creating directory MITK_CMAKE_${type}_OUTPUT_DIRECTORY: ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY}") file(MAKE_DIRECTORY "${MITK_CMAKE_${type}_OUTPUT_DIRECTORY}") endif() if(MITK_CMAKE_${type}_OUTPUT_DIRECTORY) set(CMAKE_${type}_OUTPUT_DIRECTORY ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY}) else() set(CMAKE_${type}_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/${_default_${type}_output_dir}) set(MITK_CMAKE_${type}_OUTPUT_DIRECTORY ${CMAKE_${type}_OUTPUT_DIRECTORY}) endif() set(CMAKE_${type}_OUTPUT_DIRECTORY ${CMAKE_${type}_OUTPUT_DIRECTORY} CACHE INTERNAL "Output directory for ${type} files.") mark_as_advanced(CMAKE_${type}_OUTPUT_DIRECTORY) endforeach() #----------------------------------------------------------------------------- # Set MITK specific options and variables (NOT available during superbuild) #----------------------------------------------------------------------------- # Look for optional Doxygen package find_package(Doxygen) option(BLUEBERRY_DEBUG_SMARTPOINTER "Enable code for debugging smart pointers" OFF) mark_as_advanced(BLUEBERRY_DEBUG_SMARTPOINTER) # ASK THE USER TO SHOW THE CONSOLE WINDOW FOR CoreApp and mitkWorkbench option(MITK_SHOW_CONSOLE_WINDOW "Use this to enable or disable the console window when starting MITK GUI Applications" ON) mark_as_advanced(MITK_SHOW_CONSOLE_WINDOW) # TODO: check if necessary option(USE_ITKZLIB "Use the ITK zlib for pic compression." ON) mark_as_advanced(USE_ITKZLIB) if(NOT MITK_FAST_TESTING) if(DEFINED MITK_CTEST_SCRIPT_MODE AND (MITK_CTEST_SCRIPT_MODE STREQUAL "continuous" OR MITK_CTEST_SCRIPT_MODE STREQUAL "experimental") ) set(MITK_FAST_TESTING 1) endif() endif() if(NOT UNIX AND NOT MINGW) set(MITK_WIN32_FORCE_STATIC "STATIC" CACHE INTERNAL "Use this variable to always build static libraries on non-unix platforms") endif() if(MITK_BUILD_ALL_PLUGINS) set(MITK_BUILD_ALL_PLUGINS_OPTION "FORCE_BUILD_ALL") endif() # Configure pixel types used for ITK image access multiplexing mitkMacroConfigureItkPixelTypes() # Configure module naming conventions set(MITK_MODULE_NAME_REGEX_MATCH "^[A-Z].*$") set(MITK_MODULE_NAME_REGEX_NOT_MATCH "^[Mm][Ii][Tt][Kk].*$") set(MITK_MODULE_NAME_PREFIX "Mitk") set(MITK_MODULE_NAME_DEFAULTS_TO_DIRECTORY_NAME 1) #----------------------------------------------------------------------------- # Get MITK version info #----------------------------------------------------------------------------- mitkFunctionGetVersion(${MITK_SOURCE_DIR} MITK) mitkFunctionGetVersionDescription(${MITK_SOURCE_DIR} MITK) # MITK_VERSION set(MITK_VERSION_STRING "${MITK_VERSION_MAJOR}.${MITK_VERSION_MINOR}.${MITK_VERSION_PATCH}") if(MITK_VERSION_PATCH STREQUAL "99") set(MITK_VERSION_STRING "${MITK_VERSION_STRING}-${MITK_REVISION_SHORTID}") endif() #----------------------------------------------------------------------------- # Installation preparation # # These should be set before any MITK install macros are used #----------------------------------------------------------------------------- # on Mac OSX all BlueBerry plugins get copied into every # application bundle (.app directory) specified here if(MITK_USE_BLUEBERRY AND APPLE) include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/AppList.cmake") foreach(mitk_app ${MITK_APPS}) # extract option_name string(REPLACE "^^" "\\;" target_info ${mitk_app}) set(target_info_list ${target_info}) list(GET target_info_list 1 option_name) list(GET target_info_list 0 app_name) # check if the application is enabled if(${option_name} OR MITK_BUILD_ALL_APPS) set(MACOSX_BUNDLE_NAMES ${MACOSX_BUNDLE_NAMES} Mitk${app_name}) endif() endforeach() endif() #----------------------------------------------------------------------------- # Set coverage Flags #----------------------------------------------------------------------------- if(WITH_COVERAGE) if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") set(coverage_flags "-g -fprofile-arcs -ftest-coverage -O0 -DNDEBUG") set(COVERAGE_CXX_FLAGS ${coverage_flags}) set(COVERAGE_C_FLAGS ${coverage_flags}) endif() endif() #----------------------------------------------------------------------------- # MITK C/CXX Flags #----------------------------------------------------------------------------- set(MITK_C_FLAGS "${COVERAGE_C_FLAGS}") set(MITK_C_FLAGS_DEBUG ) set(MITK_C_FLAGS_RELEASE ) set(MITK_CXX_FLAGS "${COVERAGE_CXX_FLAGS} ${MITK_CXX11_FLAG}") set(MITK_CXX_FLAGS_DEBUG ) set(MITK_CXX_FLAGS_RELEASE ) set(MITK_EXE_LINKER_FLAGS ) set(MITK_SHARED_LINKER_FLAGS ) find_package(OpenMP) if (OPENMP_FOUND) set(MITK_C_FLAGS "${MITK_C_FLAGS} ${OpenMP_C_FLAGS}") set(MITK_CXX_FLAGS "${MITK_CXX_FLAGS} ${OpenMP_CXX_FLAGS}") endif() if(WIN32) set(MITK_CXX_FLAGS "${MITK_CXX_FLAGS} -D_WIN32_WINNT=0x0501 -DPOCO_NO_UNWINDOWS -DWIN32_LEAN_AND_MEAN -DNOMINMAX") mitkFunctionCheckCompilerFlags("/wd4005" MITK_CXX_FLAGS) # warning C4005: macro redefinition mitkFunctionCheckCompilerFlags("/wd4231" MITK_CXX_FLAGS) # warning C4231: nonstandard extension used : 'extern' before template explicit instantiation # the following line should be removed after fixing bug 17637 mitkFunctionCheckCompilerFlags("/wd4316" MITK_CXX_FLAGS) # warning C4316: object alignment on heap mitkFunctionCheckCompilerFlags("/wd4180" MITK_CXX_FLAGS) # warning C4180: qualifier applied to function type has no meaning endif() if(NOT MSVC_VERSION) foreach(_flag -Wall -Wextra -Wpointer-arith -Winvalid-pch -Wcast-align -Wwrite-strings -Wno-error=gnu -Wno-error=unknown-pragmas # The strict-overflow warning is generated by ITK template code -Wno-error=strict-overflow -Woverloaded-virtual -Wstrict-null-sentinel #-Wold-style-cast #-Wsign-promo -Wno-array-bounds -fdiagnostics-show-option ) mitkFunctionCheckCAndCXXCompilerFlags(${_flag} MITK_C_FLAGS MITK_CXX_FLAGS) endforeach() endif() if(CMAKE_COMPILER_IS_GNUCXX AND NOT APPLE) mitkFunctionCheckCompilerFlags("-Wl,--no-undefined" MITK_SHARED_LINKER_FLAGS) mitkFunctionCheckCompilerFlags("-Wl,--as-needed" MITK_SHARED_LINKER_FLAGS) endif() if(CMAKE_COMPILER_IS_GNUCXX) mitkFunctionCheckCAndCXXCompilerFlags("-fstack-protector-all" MITK_C_FLAGS MITK_CXX_FLAGS) if(MINGW) # suppress warnings about auto imported symbols set(MITK_SHARED_LINKER_FLAGS "-Wl,--enable-auto-import ${MITK_SHARED_LINKER_FLAGS}") endif() set(MITK_CXX_FLAGS_RELEASE "-U_FORTIFY_SOURCES -D_FORTIFY_SOURCE=2 ${MITK_CXX_FLAGS_RELEASE}") endif() if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") mitkFunctionCheckCompilerFlags("-stdlib=libc++" MITK_CXX_FLAGS) # T20092 endif() set(MITK_MODULE_LINKER_FLAGS ${MITK_SHARED_LINKER_FLAGS}) set(MITK_EXE_LINKER_FLAGS ${MITK_SHARED_LINKER_FLAGS}) #----------------------------------------------------------------------------- # MITK Packages #----------------------------------------------------------------------------- set(MITK_MODULES_PACKAGE_DEPENDS_DIR ${MITK_SOURCE_DIR}/CMake/PackageDepends) set(MODULES_PACKAGE_DEPENDS_DIRS ${MITK_MODULES_PACKAGE_DEPENDS_DIR}) if(NOT MITK_USE_SYSTEM_Boost) set(Boost_NO_SYSTEM_PATHS 1) endif() set(Boost_USE_MULTITHREADED 1) set(Boost_USE_STATIC_LIBS 0) set(Boost_USE_STATIC_RUNTIME 0) set(Boost_ADDITIONAL_VERSIONS "1.60" "1.60.0") -# 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 # Config.cmake files pointed at by _DIR variables. # Otherwise, existing Find.cmake files could fail. # (e.g. in the case of GLEW and the FindGLEW.cmake file shipped # with CMake). find_package(${_package} QUIET CONFIG) string(TOUPPER "${_package}" _package_uc) if(NOT (${_package}_FOUND OR ${_package_uc}_FOUND)) find_package(${_package} REQUIRED) endif() endif() endif() endforeach() # Ensure that the MITK CMake module path comes first set(CMAKE_MODULE_PATH ${MITK_CMAKE_DIR} ${CMAKE_MODULE_PATH} ) -if(MITK_USE_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_Python) find_package(PythonLibs REQUIRED) find_package(PythonInterp REQUIRED) if(MITK_USE_Numpy) find_package(Numpy REQUIRED) endif() endif() if(MITK_USE_SOFA) # The SOFAConfig.cmake file does not provide exported targets or # libraries with absolute paths, hence we need to make the link # directories globally available until the SOFAConfig.cmake file # supports a proper mechanism for handling targets. # The same code is needed in MITKConfig.cmake. link_directories(${SOFA_LIBRARY_DIRS}) endif() # Same as SOFA above link_directories(${Boost_LIBRARY_DIRS}) if(MITK_USE_OpenIGTLink) # Same as SOFA above link_directories(${OpenIGTLink_LIBRARY_DIRS}) endif() if(MITK_USE_SimpleITK) link_directories(${SimpleITK_LIBRARY_DIRS}) endif() if(MITK_USE_OpenCL) find_package(OpenCL REQUIRED) endif() # Qt support if(MITK_USE_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_WebEngine) message("> Forcing BLUEBERRY_USE_QT_HELP to OFF because MITK_USE_Qt5_WebEngine is OFF.") set(_force_blueberry_use_qt_help_to_off 1) endif() if(NOT QT_XMLPATTERNS_EXECUTABLE) message("You have enabled Qt Help support, but QT_XMLPATTERNS_EXECUTABLE is empty") set(_force_blueberry_use_qt_help_to_off 1) endif() if(_force_blueberry_use_qt_help_to_off) set(BLUEBERRY_USE_QT_HELP OFF CACHE BOOL "Enable support for integrating plugin documentation into Qt Help" FORCE) endif() endif() if(BLUEBERRY_QT_HELP_REQUIRED AND NOT BLUEBERRY_USE_QT_HELP) message(FATAL_ERROR "BLUEBERRY_USE_QT_HELP is required to be set to ON") endif() endif() endif() #----------------------------------------------------------------------------- # Testing #----------------------------------------------------------------------------- if(BUILD_TESTING) enable_testing() include(CTest) mark_as_advanced(TCL_TCLSH DART_ROOT) option(MITK_ENABLE_RENDERING_TESTING OFF "Enable the MITK rendering tests. Requires x-server in Linux.") #Rendering testing does not work for Linux nightlies, thus it is disabled per default #and activated for Mac and Windows. if(WIN32 OR APPLE) set(MITK_ENABLE_RENDERING_TESTING ON) endif() mark_as_advanced( MITK_ENABLE_RENDERING_TESTING ) # Setup file for setting custom ctest vars configure_file( CMake/CTestCustom.cmake.in ${MITK_BINARY_DIR}/CTestCustom.cmake @ONLY ) # Initial cache for ProjectTemplate and PluginGenerator tests configure_file( CMake/mitkTestInitialCache.txt.in ${MITK_BINARY_DIR}/mitkTestInitialCache.txt @ONLY ) # Configuration for the CMake-generated test driver set(CMAKE_TESTDRIVER_EXTRA_INCLUDES "#include ") set(CMAKE_TESTDRIVER_BEFORE_TESTMAIN " try {") set(CMAKE_TESTDRIVER_AFTER_TESTMAIN " } catch( std::exception & excp ) { fprintf(stderr,\"%s\\n\",excp.what()); return EXIT_FAILURE; } catch( ... ) { printf(\"Exception caught in the test driver\\n\"); return EXIT_FAILURE; } ") set(MITK_TEST_OUTPUT_DIR "${MITK_BINARY_DIR}/test_output") if(NOT EXISTS ${MITK_TEST_OUTPUT_DIR}) file(MAKE_DIRECTORY ${MITK_TEST_OUTPUT_DIR}) endif() # Test the external project template if(MITK_USE_BLUEBERRY) include(mitkTestProjectTemplate) endif() # Test the package target include(mitkPackageTest) endif() configure_file(mitkTestingConfig.h.in ${MITK_BINARY_DIR}/mitkTestingConfig.h) #----------------------------------------------------------------------------- # MITK_SUPERBUILD_BINARY_DIR #----------------------------------------------------------------------------- # If MITK_SUPERBUILD_BINARY_DIR isn't defined, it means MITK is *NOT* build using Superbuild. # In that specific case, MITK_SUPERBUILD_BINARY_DIR should default to MITK_BINARY_DIR if(NOT DEFINED MITK_SUPERBUILD_BINARY_DIR) set(MITK_SUPERBUILD_BINARY_DIR ${MITK_BINARY_DIR}) endif() #----------------------------------------------------------------------------- # Set C/CXX and linker flags for MITK code #----------------------------------------------------------------------------- set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${MITK_CXX_FLAGS}") set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${MITK_CXX_FLAGS_DEBUG}") set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${MITK_CXX_FLAGS_RELEASE}") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${MITK_C_FLAGS}") set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${MITK_C_FLAGS_DEBUG}") set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${MITK_C_FLAGS_RELEASE}") set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${MITK_EXE_LINKER_FLAGS}") set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${MITK_SHARED_LINKER_FLAGS}") set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${MITK_MODULE_LINKER_FLAGS}") #----------------------------------------------------------------------------- # Add custom targets representing CDash subprojects #----------------------------------------------------------------------------- foreach(subproject ${CTEST_PROJECT_SUBPROJECTS}) if(NOT TARGET ${subproject} AND NOT subproject MATCHES "Unlabeled") add_custom_target(${subproject}) endif() endforeach() #----------------------------------------------------------------------------- # Add subdirectories #----------------------------------------------------------------------------- add_subdirectory(Utilities) add_subdirectory(Modules) if(MITK_USE_BLUEBERRY) set(BLUEBERRY_XPDOC_OUTPUT_DIR ${MITK_DOXYGEN_OUTPUT_DIR}/html/extension-points/html/) set(MITK_DEFAULT_SUBPROJECTS MITK-Plugins) # Plug-in testing (needs some work to be enabled again) if(BUILD_TESTING) set(BLUEBERRY_UI_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/CoreApp") if(TARGET CoreApp) get_target_property(_is_macosx_bundle CoreApp MACOSX_BUNDLE) if(APPLE AND _is_macosx_bundle) set(BLUEBERRY_UI_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/CoreApp.app/Contents/MacOS/CoreApp") endif() endif() set(BLUEBERRY_TEST_APP_ID "org.mitk.qt.coreapplication") endif() include("${CMAKE_CURRENT_SOURCE_DIR}/Plugins/PluginList.cmake") mitkFunctionWhitelistPlugins(MITK MITK_PLUGINS) set(mitk_plugins_fullpath "") foreach(mitk_plugin ${MITK_PLUGINS}) list(APPEND mitk_plugins_fullpath Plugins/${mitk_plugin}) endforeach() if(EXISTS ${MITK_PRIVATE_MODULES}/PluginList.cmake) include(${MITK_PRIVATE_MODULES}/PluginList.cmake) foreach(mitk_plugin ${MITK_PRIVATE_PLUGINS}) list(APPEND mitk_plugins_fullpath ${MITK_PRIVATE_MODULES}/${mitk_plugin}) endforeach() endif() if(MITK_BUILD_EXAMPLES) include("${CMAKE_CURRENT_SOURCE_DIR}/Examples/Plugins/PluginList.cmake") set(mitk_example_plugins_fullpath ) foreach(mitk_example_plugin ${MITK_EXAMPLE_PLUGINS}) list(APPEND mitk_example_plugins_fullpath Examples/Plugins/${mitk_example_plugin}) list(APPEND mitk_plugins_fullpath Examples/Plugins/${mitk_example_plugin}) endforeach() endif() # Specify which plug-ins belong to this project macro(GetMyTargetLibraries all_target_libraries varname) set(re_ctkplugin_mitk "^org_mitk_[a-zA-Z0-9_]+$") set(re_ctkplugin_bb "^org_blueberry_[a-zA-Z0-9_]+$") set(_tmp_list) list(APPEND _tmp_list ${all_target_libraries}) ctkMacroListFilter(_tmp_list re_ctkplugin_mitk re_ctkplugin_bb OUTPUT_VARIABLE ${varname}) endmacro() # Get infos about application directories and build options include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/AppList.cmake") set(mitk_apps_fullpath ) foreach(mitk_app ${MITK_APPS}) # extract option_name string(REPLACE "^^" "\\;" target_info ${mitk_app}) set(target_info_list ${target_info}) list(GET target_info_list 0 directory_name) list(GET target_info_list 1 option_name) if(${option_name}) list(APPEND mitk_apps_fullpath "${CMAKE_CURRENT_SOURCE_DIR}/Applications/${directory_name}^^${option_name}") endif() endforeach() if (mitk_plugins_fullpath) ctkMacroSetupPlugins(${mitk_plugins_fullpath} BUILD_OPTION_PREFIX MITK_BUILD_ APPS ${mitk_apps_fullpath} BUILD_ALL ${MITK_BUILD_ALL_PLUGINS} COMPACT_OPTIONS) endif() set(MITK_PLUGIN_USE_FILE "${MITK_BINARY_DIR}/MitkPluginUseFile.cmake") if(${PROJECT_NAME}_PLUGIN_LIBRARIES) ctkFunctionGeneratePluginUseFile(${MITK_PLUGIN_USE_FILE}) else() file(REMOVE ${MITK_PLUGIN_USE_FILE}) set(MITK_PLUGIN_USE_FILE ) endif() endif() #----------------------------------------------------------------------------- # Documentation #----------------------------------------------------------------------------- if(DOXYGEN_FOUND) add_subdirectory(Documentation) endif() #----------------------------------------------------------------------------- # Installation #----------------------------------------------------------------------------- # set MITK cpack variables # These are the default variables, which can be overwritten ( see below ) include(mitkSetupCPack) set(use_default_config ON) # MITK_APPS is set in Applications/AppList.cmake (included somewhere above # if MITK_USE_BLUEBERRY is set to ON). if(MITK_APPS) set(activated_apps_no 0) list(LENGTH MITK_APPS app_count) # Check how many apps have been enabled # If more than one app has been activated, the we use the # default CPack configuration. Otherwise that apps configuration # will be used, if present. foreach(mitk_app ${MITK_APPS}) # extract option_name string(REPLACE "^^" "\\;" target_info ${mitk_app}) set(target_info_list ${target_info}) list(GET target_info_list 1 option_name) # check if the application is enabled if(${option_name} OR MITK_BUILD_ALL_APPS) MATH(EXPR activated_apps_no "${activated_apps_no} + 1") endif() endforeach() if(app_count EQUAL 1 AND (activated_apps_no EQUAL 1 OR MITK_BUILD_ALL_APPS)) # Corner case if there is only one app in total set(use_project_cpack ON) elseif(activated_apps_no EQUAL 1 AND NOT MITK_BUILD_ALL_APPS) # Only one app is enabled (no "build all" flag set) set(use_project_cpack ON) else() # Less or more then one app is enabled set(use_project_cpack OFF) endif() foreach(mitk_app ${MITK_APPS}) # extract target_dir and option_name string(REPLACE "^^" "\\;" target_info ${mitk_app}) set(target_info_list ${target_info}) list(GET target_info_list 0 target_dir) list(GET target_info_list 1 option_name) list(GET target_info_list 2 executable_name) # check if the application is enabled if(${option_name} OR MITK_BUILD_ALL_APPS) # check whether application specific configuration files will be used if(use_project_cpack) # use files if they exist if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/Applications/${target_dir}/CPackOptions.cmake") include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/${target_dir}/CPackOptions.cmake") endif() if(EXISTS "${PROJECT_SOURCE_DIR}/Applications/${target_dir}/CPackConfig.cmake.in") set(CPACK_PROJECT_CONFIG_FILE "${PROJECT_BINARY_DIR}/Applications/${target_dir}/CPackConfig.cmake") configure_file(${PROJECT_SOURCE_DIR}/Applications/${target_dir}/CPackConfig.cmake.in ${CPACK_PROJECT_CONFIG_FILE} @ONLY) set(use_default_config OFF) endif() endif() # add link to the list list(APPEND CPACK_CREATE_DESKTOP_LINKS "${executable_name}") endif() endforeach() endif() # if no application specific configuration file was used, use default if(use_default_config) configure_file(${MITK_SOURCE_DIR}/MITKCPackOptions.cmake.in ${MITK_BINARY_DIR}/MITKCPackOptions.cmake @ONLY) set(CPACK_PROJECT_CONFIG_FILE "${MITK_BINARY_DIR}/MITKCPackOptions.cmake") endif() # include CPack model once all variables are set include(CPack) # Additional installation rules include(mitkInstallRules) #----------------------------------------------------------------------------- # Last configuration steps #----------------------------------------------------------------------------- # ---------------- Export targets ----------------- set(MITK_EXPORTS_FILE "${MITK_BINARY_DIR}/MitkExports.cmake") file(REMOVE ${MITK_EXPORTS_FILE}) set(targets_to_export) get_property(module_targets GLOBAL PROPERTY MITK_MODULE_TARGETS) if(module_targets) list(APPEND targets_to_export ${module_targets}) endif() if(MITK_USE_BLUEBERRY) if(MITK_PLUGIN_LIBRARIES) list(APPEND targets_to_export ${MITK_PLUGIN_LIBRARIES}) endif() endif() export(TARGETS ${targets_to_export} APPEND FILE ${MITK_EXPORTS_FILE}) set(MITK_EXPORTED_TARGET_PROPERTIES ) foreach(target_to_export ${targets_to_export}) get_target_property(autoload_targets ${target_to_export} MITK_AUTOLOAD_TARGETS) if(autoload_targets) set(MITK_EXPORTED_TARGET_PROPERTIES "${MITK_EXPORTED_TARGET_PROPERTIES} set_target_properties(${target_to_export} PROPERTIES MITK_AUTOLOAD_TARGETS \"${autoload_targets}\")") endif() get_target_property(autoload_dir ${target_to_export} MITK_AUTOLOAD_DIRECTORY) if(autoload_dir) set(MITK_EXPORTED_TARGET_PROPERTIES "${MITK_EXPORTED_TARGET_PROPERTIES} set_target_properties(${target_to_export} PROPERTIES MITK_AUTOLOAD_DIRECTORY \"${autoload_dir}\")") endif() get_target_property(deprecated_module ${target_to_export} MITK_MODULE_DEPRECATED_SINCE) if(deprecated_module) set(MITK_EXPORTED_TARGET_PROPERTIES "${MITK_EXPORTED_TARGET_PROPERTIES} set_target_properties(${target_to_export} PROPERTIES MITK_MODULE_DEPRECATED_SINCE \"${deprecated_module}\")") endif() endforeach() # ---------------- External projects ----------------- get_property(MITK_ADDITIONAL_LIBRARY_SEARCH_PATHS_CONFIG GLOBAL PROPERTY MITK_ADDITIONAL_LIBRARY_SEARCH_PATHS) set(MITK_CONFIG_EXTERNAL_PROJECTS ) #string(REPLACE "^^" ";" _mitk_external_projects ${MITK_EXTERNAL_PROJECTS}) foreach(ep ${MITK_EXTERNAL_PROJECTS}) get_property(_components GLOBAL PROPERTY MITK_${ep}_COMPONENTS) set(MITK_CONFIG_EXTERNAL_PROJECTS "${MITK_CONFIG_EXTERNAL_PROJECTS} set(MITK_USE_${ep} ${MITK_USE_${ep}}) set(MITK_${ep}_DIR \"${${ep}_DIR}\") set(MITK_${ep}_COMPONENTS ${_components}) ") endforeach() foreach(ep ${MITK_EXTERNAL_PROJECTS}) get_property(_package GLOBAL PROPERTY MITK_${ep}_PACKAGE) get_property(_components GLOBAL PROPERTY MITK_${ep}_COMPONENTS) if(_components) set(_components_arg COMPONENTS \${_components}) else() set(_components_arg) endif() if(_package) set(MITK_CONFIG_EXTERNAL_PROJECTS "${MITK_CONFIG_EXTERNAL_PROJECTS} if(MITK_USE_${ep}) set(${ep}_DIR \${MITK_${ep}_DIR}) if(MITK_${ep}_COMPONENTS) mitkMacroFindDependency(${_package} COMPONENTS \${MITK_${ep}_COMPONENTS}) else() mitkMacroFindDependency(${_package}) endif() endif()") endif() endforeach() # ---------------- Tools ----------------- configure_file(${MITK_SOURCE_DIR}/CMake/ToolExtensionITKFactory.cpp.in ${MITK_BINARY_DIR}/ToolExtensionITKFactory.cpp.in COPYONLY) configure_file(${MITK_SOURCE_DIR}/CMake/ToolExtensionITKFactoryLoader.cpp.in ${MITK_BINARY_DIR}/ToolExtensionITKFactoryLoader.cpp.in COPYONLY) configure_file(${MITK_SOURCE_DIR}/CMake/ToolGUIExtensionITKFactory.cpp.in ${MITK_BINARY_DIR}/ToolGUIExtensionITKFactory.cpp.in COPYONLY) # ---------------- Configure files ----------------- configure_file(mitkVersion.h.in ${MITK_BINARY_DIR}/mitkVersion.h) configure_file(mitkConfig.h.in ${MITK_BINARY_DIR}/mitkConfig.h) set(IPFUNC_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/ipFunc) set(UTILITIES_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities) configure_file(mitkConfig.h.in ${MITK_BINARY_DIR}/mitkConfig.h) configure_file(MITKConfig.cmake.in ${MITK_BINARY_DIR}/MITKConfig.cmake @ONLY) write_basic_config_version_file(${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake VERSION ${MITK_VERSION_STRING} COMPATIBILITY AnyNewerVersion) #----------------------------------------------------------------------------- # MITK Applications #----------------------------------------------------------------------------- # This must come after MITKConfig.h was generated, since applications # might do a find_package(MITK REQUIRED). add_subdirectory(Applications) #----------------------------------------------------------------------------- # MITK Examples #----------------------------------------------------------------------------- if(MITK_BUILD_EXAMPLES) # This must come after MITKConfig.h was generated, since applications # might do a find_package(MITK REQUIRED). add_subdirectory(Examples) endif() #----------------------------------------------------------------------------- # Print configuration summary #----------------------------------------------------------------------------- message("\n\n") feature_summary( DESCRIPTION "------- FEATURE SUMMARY FOR ${PROJECT_NAME} -------" WHAT ALL ) diff --git a/Documentation/Doxygen/3-DeveloperManual/Concepts/Annotation.dox b/Documentation/Doxygen/3-DeveloperManual/Concepts/Annotation.dox new file mode 100644 index 0000000000..b75fbd7a25 --- /dev/null +++ b/Documentation/Doxygen/3-DeveloperManual/Concepts/Annotation.dox @@ -0,0 +1,51 @@ +/** +\page AnnotationPage Annotation Concept + +\tableofcontents + +\section AnnotationPage_Introduction Annotations + +The annotations in MITK are a simple way to display additional information on the render windows. A class, deriving from mitk::Annotation represents an arbitrary +2D or 3D object that can be rendered as an Annotation. This can for example be used for the annotation of 3D points or to Annotation despriptions in the window corners. +Instances of the MicroService mitk::AbstractAnnotationRenderer are used to add the annotations to the renderwindows, updating them and depending on their implementation, organize them in a layout. +This module contains implementations for mitk::AbstractAnnotationRenderer as well as mitk::Annotation. Currently, the following features are realized within the Annotation module. +
    +
  1. 2D and 3D textelements are already defined in the Annotation module and are using VTK to create custom annotations. +
  2. 2D and 3D annotations can be placed freely by providing a display position +
  3. 2D annotations can be placed in a layout, which organizes the annotations in the display corners. +
+\section AnnotationPage_ArchitectureSection General Architecture + +The mitk::Annotation can be implemented using a custom rendering framework like VTK. In this diagram, the vtkAnnotation is shown as the superclass for all Annotations which use the vtk framework for rendering. +The AnnotationManager can be registered to several BaseRenderer instances in order to call the update method of each Annotation during the rendering phase of the renderer. +It also manages the respective Layouters which are used to manage the placement of a group of Annotations. + +\subsection AnnotationPage_AnnotationSubsection Annotation + +The mitk::Annotation is an abstract class that can manage property lists like the mitk::DataNode and provides the interfaces to the methods +AddToBaseRenderer, AddToRenderer, RemoveFromBaseRenderer RemoveFromRenderer and Update. The subclasses of the mitk::Annotation have to implement these methods +in order to provide the functionallity of an Annotation. There are already a few implementations of mitk::Annotation which are using VTK as a rendering +framework to display the Annotations. In order to show an Annotation, it has to be registered as a MicroService. + +\subsection AnnotationPage_AnnotationRendererSubsection AbstractAnnotationRenderer + +The AbstractAnnotationRenderer is the base class for all types of AnnotationRenderers, which are used for the management of multiple annotations in a specific BaseRenderer. +For each BaseRenderer, an AnnotationRenderer is registerered as a MicroService, using the type and the renderer name as a unique identifier. This way it is possible to keep the Annotations for a specific BaseRenderer +even if this renderer is temporarilly not existent (e.g. when a RenderWindow was closed). + +Implementations of the AbstractAnnotationRenderer are using the us::ServiceTracker in order to manage all registered Annotations and to listen to the events which are thrown if a new Annotation is registered, +if an Annotation was unregistered or if it was modified. + +\subsubsection AnnotationPage_ManualPlacementAnnotationRendererSubsection ManualPlacementAnnotationRenderer + +Using the ManualPlacementAnnotationRenderer, allows for a simple placement of Annotations. The Annotation manages its placement internally or using the Position2D / Position3D properties. + +\subsubsection AnnotationPage_LayoutAnnotationRendererSubsection LayoutAnnotationRenderer + +The LayoutAnnotationRenderer allows automatic placement in the RenderWindow corners and sorts the Annotations by a specified priority. + +\subsection AnnotationPage_AnnotationUtilsSubsection AnnotationUtils + +mitk::AnnotationUtils is a collection of static convenience functions, for the registration of AnnotationRenderers and to request certain registered Annotations. + +*/ diff --git a/Documentation/Doxygen/3-DeveloperManual/Concepts/Concepts.dox b/Documentation/Doxygen/3-DeveloperManual/Concepts/Concepts.dox index 5a0594d3fe..f7ec5a8bc5 100644 --- a/Documentation/Doxygen/3-DeveloperManual/Concepts/Concepts.dox +++ b/Documentation/Doxygen/3-DeveloperManual/Concepts/Concepts.dox @@ -1,33 +1,33 @@ /** \page Concepts MITK Concepts -The following items describe some issues about MITK on a more abstract level. +The following items describe some issues about MITK on a more abstract level. -# \subpage OverviewPage -# \subpage CodingPage "Coding Concepts" -# \ref CodingPageGeneral -# \ref CodingPageStyle -# \ref CodingPageMITKMacros -# \subpage MicroServices_Overview -# Data Concepts -# \subpage BasicDataTypesPage -# \subpage DataManagementPage -# \subpage ReaderWriterPage -# \subpage MitkImagePage -# \subpage PropertiesPage -# \subpage GeometryOverviewPage -# \subpage PipelineingConceptPage - -# \subpage OverlaysPage + -# \subpage AnnotationPage -# \subpage PersistenceConceptPage -# \subpage QVTKRendering -# Interaction -# \subpage DataInteractionPage -# \subpage InteractionPage -# \subpage LoggingPage -# \subpage ExceptionPage -# \subpage ModularizationPage "Modularization Concept" -# \ref ModularizationPageOverview -# \ref ModularizationPageHowTo If you want to start using MITK, you also want to see the chapter \ref Development. */ diff --git a/Documentation/Doxygen/3-DeveloperManual/Concepts/Overlays.dox b/Documentation/Doxygen/3-DeveloperManual/Concepts/Overlays.dox deleted file mode 100644 index 38e8b8d1e1..0000000000 --- a/Documentation/Doxygen/3-DeveloperManual/Concepts/Overlays.dox +++ /dev/null @@ -1,123 +0,0 @@ -/** -\page OverlaysPage Overlays and Annotations Concepts - -\tableofcontents - -\section OverlaysPage_Introduction Overlays and Annotations - -The overlays in MITK are a simple way to display additional information on the render windows. A class, deriving from mitk::Overlay represents an arbitrary -2D or 3D object that can be rendered as an overlay. This can for example be used for the annotation of 3D points or to overlay despriptions in the window corners. -The mitk::OverlayManager is used to add the overlays to the renderwindows, updating them and manage the respective layout managers. -The following features are implemented in this framework. -
    -
  1. Definition of graphical elements that can be displayed in the render windows. -
  2. It is possible to manage multiple elements in each window. -
  3. A single Overlay can be rendered on any number of available render windows. -
  4. 2D and 3D textelements are already defined in the Overlay module and are using VTK to create custom annotations. -
  5. The mitk::BaseLayouter interface enables the implementation of layout managers, to handle the placement of the overlays. -
- -\section OverlaysPage_ArchitectureSection General Architecture - -\dot -digraph linker_deps { - node [shape=record, fontname=Helvetica, fontsize=10]; - BR [ label="BaseRenderer" ]; - BL [ label="{BaseLayouter|+ArrangeOverlays()}" ]; - O [ label="{Overlay|-PropertyList|+RemoveOverlay(BaseRenderer*)\n+UpdateOverlay(BaseRenderer*)\n+RemoveOverlay(BaseRenderer*)}" ]; - OM [ label="{OverlayManager|+AddOverlay(Overlay*)\n+RemoveOverlay(Overlay*)}" ]; - TO [ label="TextOverlay" ]; - VTKO [ label="{vtkOverlay|#GetVtkActor()}" ]; - TO -> VTKO; - VTKO -> O; - OM -> O [style="dashed",label="manages"]; - OM -> BL [style="dashed"]; - OM -> BR [style="dashed"]; - BR -> OM [style="dashed"]; -} -\enddot - -The mitk::Overlay can be implemented using a custom rendering framework like VTK. In this diagram, the vtkOverlay is shown as the superclass for all Overlays which use the vtk framework for rendering. -The OverlayManager can be registered to several BaseRenderer instances in order to call the update method of each Overlay during the rendering phase of the renderer. -It also manages the respective Layouters which are used to manage the placement of a group of Overlays. - -\subsection OverlaysPage_OverlaySubsection Overlay - -The mitk::Overlay is an abstract class that can manage property lists like the mitk::DataNode and provides the interfaces to thr three methods -mitk::Overlay::AddOverlay, mitk::Overlay::UpdateOverlay and mitk::Overlay::RemoveOverlay. The subclasses of the mitk::Overlay have to implement these methods -in order to provide the functionallity of an overlay. There are already a few implementations of mitk::Overlay which are using VTK as a rendering -framework to display the Overlays. However the mitk::Overlay can also be implemented using OpenGL to draw the Overlay on the renderwindows. - -\subsection OverlaysPage_OverlayManagerSubsection OverlayManager - -The mitk::OverlayManager is the manager for a set of Overlays and the respective Layouters. -Before the manager can be used, all mitk::BaseRenderer have to be registered to the mitk::OverlayManager instance like this: - -\snippet OverlayExample.cpp CreateOverlayManager - -The mitk::OverlayManager can then be used anywhere in the program by fetching it as follows: - -\snippet OverlayExample.cpp GetOverlayManagerInstance - -All mitk::Overlay instances can now be added to the OverlayManager by calling mitk::OverlayManager::AddOverlay. - -\subsection OverlaysPage_LayouterSubsection Layouter - -In order to use Layouters for the positioning -of the Overlays, each Layouter object that has been created has to be added to an internal list in the OverlayManager: - -\snippet OverlayExample.cpp AddLayouter - -The mitk::OverlayManager::SetLayouter method can then be used to configure an Overlay to be positioned by a certain Layouter: - -\snippet OverlayExample.cpp SetLayouterToOverlay - -\subsection OverlaysPage_NotManagedSubsection Manually Managed Overlays -In order to integrate an Overlay into an mitk::Mapper, it is advised not to use the OverlayManager but to manually manage the Overlay. -To do so, the update methods of the overlays have to be called manually before the start of each rendering procedure. It must only be called if the Properties have changed or if your custom overlay implements its own rendering mechanism. - -\section OverlaysPage_CustomOverlaySection Implement a Custom Overlay - -A new custom Overlay should derive from mitkOverlay or one of the later mentioned subclasses VtkOverlay2D oder VtkOverlay3D. There should always be an implementation for the methods -AddOverlay, RemoveOverlay and Update Overlay. -UpdateOverlay is the procedure that is called in each rendering step. If the Overlay is rendered by VTK, this method only applies the properties to the representation. -If the custom Overlay requires additional properties, they should be made accessible by getters and setters for a better usability: -\code -void mitk::VtkOverlay3D::SetPosition3D(Point3D position3D, mitk::BaseRenderer *renderer) -{ - mitk::Point3dProperty::Pointer position3dProperty = mitk::Point3dProperty::New(position3D); - SetProperty("Position3D", position3dProperty,renderer); -} - -mitk::Point3D mitk::VtkOverlay3D::GetPosition3D(mitk::BaseRenderer *renderer) -{ - mitk::Point3D position3D; - GetPropertyValue("Position3D", position3D, renderer); - return position3D; -} -\endcode - -\subsection OverlaysPage_CustomVTK2DOverlaySubsection VTK 2D Overlay - -VTK based overlays which are meant to be displayed in 2D over the render window should derive from the mitk::VtkOverlay2D. -The mitk::VtkOverlay2D is a subclass of Vtk::Overlay, that uses VTK to render the overlay. This class creates the Overlay representation as a vtkActor2D, and is very easy to implement -because only UpdateVtkOverlay2D and GetVtkActor2D have to be implemented. The add, update and remove methods are implemented in the superclasses. -UpdateVtkOverlay2D only needs to apply the specific properties and GetVtkActor2D simply returns the created vtkActor. - -\subsection OverlaysPage_CustomVTK3DOverlaySubsection VTK 3D Overlay - -The mitkVtkOverlay3D works just like mitkVtkOverlay2D, but it is designed for arbitrary 3D objects which derive from vtkProp, - -\section OverlaysPage_CustomLayouterSection Implement a Custom Layouter - -A Layouter is used for an automatic positioning of a group of Overlays and is derived from mitkBaseLayouter. Every Layouter that manages a group of Layouts should have a unique identifier -which is used to register the Layouter in the OverlayManager. A Layouter is always uniquely defined by the identifier and one BaseRenderer. Before a Layouter can be used by the -OverlayManager it has to be added, using the AddLayouter Method. An Overlay can then be added to a Layout as follows: - -\code -overlayManager->SetLayouter(textOverlay.GetPointer(),mitk::Overlay2DLayouter::STANDARD_2D_TOPLEFT,axialRenderer); -\endcode - -A new Layouter has to implement PrepareLayout which should parse the internal Overlay list and set their position as required. - -*/ diff --git a/Documentation/Doxygen/3-DeveloperManual/Concepts/images/annotation/annotationArchitecture.png b/Documentation/Doxygen/3-DeveloperManual/Concepts/images/annotation/annotationArchitecture.png new file mode 100644 index 0000000000..da11554093 Binary files /dev/null and b/Documentation/Doxygen/3-DeveloperManual/Concepts/images/annotation/annotationArchitecture.png differ diff --git a/Documentation/Doxygen/3-DeveloperManual/Toolkit/ModuleManuals/MITKModuleManualsList.dox b/Documentation/Doxygen/3-DeveloperManual/Toolkit/ModuleManuals/MITKModuleManualsList.dox index 015179e6e2..9e69f81b3e 100644 --- a/Documentation/Doxygen/3-DeveloperManual/Toolkit/ModuleManuals/MITKModuleManualsList.dox +++ b/Documentation/Doxygen/3-DeveloperManual/Toolkit/ModuleManuals/MITKModuleManualsList.dox @@ -1,28 +1,29 @@ /** \page MITKModuleManualsListPage MITK Module Manuals \section MITKModuleManualsListPageOverview Overview The modules are shared libraries that provide functionality that can be used by developers. \section MITKModuleManualsListPageModuleManualList List of Module Manuals \li \subpage NavigationGeneralModulePage \li \subpage MitkOpenCL_Overview \li \subpage LegacyGLModule \li \subpage GeneratingDeviceModulesPage \li \subpage mitkPython_Overview \li \subpage USModulePage - \li \subpage OverlaysModulePage + \li \subpage AnnotationModulePage \section MITKModuleManualsListPageAdditionalInformation Additional Information on Certain Modules \li \ref PlanarPropertiesPage \li \subpage DiffusionImagingPropertiesPage \li \subpage ConnectomicsRenderingPropertiesPage \section MITKMigrationGuides Migration Guides \li \subpage InteractionMigration \li \subpage GeometryMigration + \li \subpage OverlayMigration */ diff --git a/Documentation/Doxygen/3-DeveloperManual/Toolkit/ModuleManuals/OverlayMigration.dox b/Documentation/Doxygen/3-DeveloperManual/Toolkit/ModuleManuals/OverlayMigration.dox new file mode 100644 index 0000000000..2f3abc81bd --- /dev/null +++ b/Documentation/Doxygen/3-DeveloperManual/Toolkit/ModuleManuals/OverlayMigration.dox @@ -0,0 +1,37 @@ +/** + +\page OverlayMigration Migration Guide from Overlays to the new Annotation concept + +\tableofcontents + +\section Howto How to adapt your code +All classes have been renamed from "Overlay" to "Annotation", e.g. the mitk::TextOverlay2D is now mitk::TextAnnotation2D. Most of the interface of mitk::Overlay remains unchanged in +mitk::Annotation, but it is no longer registered at the mitk::OverlayManager. Instead, mitk::ManualPlacementAnnotationRenderer and mitk::LayoutAnnotationRenderer are used the register an annotation. + +\code + // Old Overlay registration: + overlayManager->AddOverlay(textOverlay3D.GetPointer(), renderer); +\endcode +\code + // New Annotation registration: + mitk::ManualPlacementAnnotationRenderer::AddAnnotation(textAnnotation3D, renderer); +\endcode + +A single mitk::Annotation is no longer automatically registered in all available RenderWindows. Each mitk::Annotation is shown only once. The user is also responsible for the memory management. +When a created mitk::Annotation has no more SmartPointer references, it disappears. + +The Layouter concept was implemented in the mitk::LayoutAnnotationRenderer: +\code + // Old way to layout an mitk::Overlay: + verlayManager->AddOverlay(textOverlay.GetPointer()); + overlayManager->AddLayouter( + mitk::Overlay2DLayouter::CreateLayouter(mitk::Overlay2DLayouter::STANDARD_2D_TOPLEFT(), renderer2D).GetPointer()); + overlayManager->SetLayouter(textOverlay.GetPointer(), mitk::Overlay2DLayouter::STANDARD_2D_TOPLEFT(), renderer2D); +\endcode +\code + // New way to layout an mitk::Annotation: + mitk::LayoutAnnotationRenderer::AddAnnotation(textAnnotation, rendererID, mitk::LayoutAnnotationRenderer::TopLeft, 5, 5, 1); + // The layouter gets parameters for margins and the priority for the placement in the RenderWindow corners. +\endcode + +*/ diff --git a/Examples/Annotation/AnnotationExample.cpp b/Examples/Annotation/AnnotationExample.cpp new file mode 100644 index 0000000000..a419c4bef3 --- /dev/null +++ b/Examples/Annotation/AnnotationExample.cpp @@ -0,0 +1,147 @@ +/*=================================================================== + +The Medical Imaging Interaction Toolkit (MITK) + +Copyright (c) German Cancer Research Center, +Division of Medical and Biological Informatics. +All rights reserved. + +This software is distributed WITHOUT ANY WARRANTY; without +even the implied warranty of MERCHANTABILITY or FITNESS FOR +A PARTICULAR PURPOSE. + +See LICENSE.txt or http://www.mitk.org for details. + +===================================================================*/ + +#include "QmitkRegisterClasses.h" +#include "QmitkRenderWindow.h" + +#include + +#include +#include + +#include +#include +#include +#include +#include + +#include + +//##Documentation +//## @brief Load image (nrrd format) and display it in a 2D view +int main(int argc, char *argv[]) +{ + QApplication qtapplication(argc, argv); + + if (argc < 2) + { + fprintf(stderr, "Usage: %s [filename] \n\n", itksys::SystemTools::GetFilenameName(argv[0]).c_str()); + return 1; + } + + // Register Qmitk-dependent global instances + QmitkRegisterClasses(); + + mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New(); + + // Load datanode (eg. many image formats, surface formats, etc.) + mitk::IOUtil::Load(argv[1], *ds); + + // Create a RenderWindow + QmitkRenderWindow renderWindow; + + // Tell the RenderWindow which (part of) the datastorage to render + renderWindow.GetRenderer()->SetDataStorage(ds); + + // Initialize the RenderWindow + mitk::TimeGeometry::Pointer geo = ds->ComputeBoundingGeometry3D(ds->GetAll()); + mitk::RenderingManager::GetInstance()->InitializeViews(geo); + // mitk::RenderingManager::GetInstance()->InitializeViews(); + + // Add Overlays + //![TextAnnotation2D] + // Create a textAnnotation2D + mitk::TextAnnotation2D::Pointer textAnnotation = mitk::TextAnnotation2D::New(); + + textAnnotation->SetText("Test!"); // set UTF-8 encoded text to render + textAnnotation->SetFontSize(40); + textAnnotation->SetColor(1, 0, 0); // Set text color to red + textAnnotation->SetOpacity(1); + + // The position of the Annotation can be set to a fixed coordinate on the display. + mitk::Point2D pos; + pos[0] = 10; + pos[1] = 20; + textAnnotation->SetPosition2D(pos); + + std::string rendererID = renderWindow.GetRenderer()->GetName(); + + // The LayoutAnnotationRenderer can place the TextAnnotation2D at some defined corner positions + mitk::LayoutAnnotationRenderer::AddAnnotation( + textAnnotation, rendererID, mitk::LayoutAnnotationRenderer::TopLeft, 5, 5, 1); + //![TextAnnotation2D] + + //![TextAnnotation3D] + mitk::PointSet::Pointer pointset = mitk::PointSet::New(); + + // This vector is used to define an offset for the annotations, in order to show them with a margin to the actual + // coordinate. + mitk::Point3D offset; + offset[0] = .5; + offset[1] = .5; + offset[2] = .5; + + // save references to Annotations so that they do not get deregistered + std::vector annotationReferences; + + // Just a loop to create some points + for (unsigned long i = 0; i < 10; i++) + { + // To each point, a TextAnnotation3D is created + mitk::TextAnnotation3D::Pointer textAnnotation3D = mitk::TextAnnotation3D::New(); + mitk::Point3D point; + point[0] = i * 20; + point[1] = i * 30; + point[2] = -i * 50; + pointset->InsertPoint(i, point); + textAnnotation3D->SetText("A Point"); + + // The Position is set to the point coordinate to create an annotation to the point in the PointSet. + textAnnotation3D->SetPosition3D(point); + + // move the annotation away from the actual point + textAnnotation3D->SetOffsetVector(offset); + + annotationReferences.push_back(textAnnotation3D); + mitk::ManualPlacementAnnotationRenderer::AddAnnotation(textAnnotation3D, rendererID); + } + + // Get the MicroserviceID of the registered textAnnotation + std::string serviceID = textAnnotation->GetMicroserviceID(); + + // The AnnotationUtils can retrieve any registered annotations by their microservice ID + mitk::Annotation *annotation = mitk::AnnotationUtils::GetAnnotation(serviceID); + // This way, it is possible to change the properties of Annotations without knowing their implementation + annotation->SetText("changed text!"); + + // also show the created pointset + mitk::DataNode::Pointer datanode = mitk::DataNode::New(); + datanode->SetData(pointset); + datanode->SetName("pointSet"); + ds->Add(datanode); + //! [TextAnnotation3D] + renderWindow.show(); + renderWindow.resize(256, 256); + + renderWindow.show(); + renderWindow.resize(256, 256); + + // cleanup: Remove References to DataStorage. This will delete the object + ds = NULL; +} +/** +\example Step1.cpp +*/ diff --git a/Examples/Annotation/CMakeLists.txt b/Examples/Annotation/CMakeLists.txt new file mode 100644 index 0000000000..9b47f2ab52 --- /dev/null +++ b/Examples/Annotation/CMakeLists.txt @@ -0,0 +1,4 @@ +project(AnnotationExample) + +mitk_create_executable(${PROJECT_NAME} DEPENDS MitkQtWidgetsExt MitkAnnotation) + diff --git a/Examples/Annotation/files.cmake b/Examples/Annotation/files.cmake new file mode 100644 index 0000000000..b2a623392a --- /dev/null +++ b/Examples/Annotation/files.cmake @@ -0,0 +1 @@ +set(CPP_FILES AnnotationExample.cpp) diff --git a/Examples/CMakeLists.txt b/Examples/CMakeLists.txt index 9db1edf188..957751fe99 100644 --- a/Examples/CMakeLists.txt +++ b/Examples/CMakeLists.txt @@ -1,53 +1,53 @@ set(MITK_DEFAULT_SUBPROJECTS MITK-Examples) #----------------------------------------------------------------------------- # Set-up example plugins #----------------------------------------------------------------------------- if(MITK_USE_BLUEBERRY) # Specify which plug-ins belong to this project macro(GetMyTargetLibraries all_target_libraries varname) set(re_ctkplugin_mitk "^org_mitk_example_[a-zA-Z0-9_]+$") set(_tmp_list) list(APPEND _tmp_list ${all_target_libraries}) ctkMacroListFilter(_tmp_list re_ctkplugin_mitk OUTPUT_VARIABLE ${varname}) endmacro() set(MITK_EXAMPLE_PLUGIN_TARGETS ) foreach(mitk_example_plugin ${MITK_EXAMPLE_PLUGINS}) ctkFunctionExtractOptionNameAndValue(${mitk_example_plugin} plugin_name plugin_value) string(REPLACE "." "_" _plugin_target ${plugin_name}) list(APPEND MITK_EXAMPLE_PLUGIN_TARGETS ${_plugin_target}) mark_as_advanced(${${_plugin_target}_option_name}) endforeach() endif() #----------------------------------------------------------------------------- # Add example executables #----------------------------------------------------------------------------- set(MITK_DIR ${PROJECT_BINARY_DIR}) set(MITK_EXPORTS_FILE_INCLUDED 1) set(_example_dirs Dump MbiLog QtFreeRender Tutorial FirstSteps QuickRender -# Overlays# depends on MitkQtWidgetsExt.. + Annotation ) if(MITK_USE_BLUEBERRY) list(APPEND _example_dirs BlueBerryExampleLauncher ) endif() foreach(_example_dir ${_example_dirs}) add_subdirectory(${_example_dir}) endforeach() diff --git a/Examples/Overlays/CMakeLists.txt b/Examples/Overlays/CMakeLists.txt deleted file mode 100644 index 4479c0f8b4..0000000000 --- a/Examples/Overlays/CMakeLists.txt +++ /dev/null @@ -1,4 +0,0 @@ -project(OverlayExample) - -mitk_create_executable(${PROJECT_NAME} DEPENDS MitkQtWidgets) - diff --git a/Examples/Overlays/OverlayExample.cpp b/Examples/Overlays/OverlayExample.cpp deleted file mode 100644 index 6470f9a135..0000000000 --- a/Examples/Overlays/OverlayExample.cpp +++ /dev/null @@ -1,209 +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. - -===================================================================*/ - -//! [includes] -#include "QmitkRegisterClasses.h" -#include "QmitkRenderWindow.h" - -#include -#include -#include - -#include -#include -#include -#include -#include -#include -//! [includes] - -//##Documentation -//## @brief Load image (nrrd format) and display it in a 2D view -int main(int argc, char *argv[]) -{ - QApplication qtapplication(argc, argv); - - if (argc < 2) - { - fprintf(stderr, "Usage: %s [filename] \n\n", itksys::SystemTools::GetFilenameName(argv[0]).c_str()); - return 1; - } - - // Register Qmitk-dependent global instances - QmitkRegisterClasses(); - - //************************************************************************* - // Part I: Basic initialization - //************************************************************************* - - // Create a DataStorage - // The DataStorage manages all data objects. It is used by the - // rendering mechanism to render all data objects - // We use the standard implementation mitk::StandaloneDataStorage. - mitk::StandaloneDataStorage::Pointer dataStorage = mitk::StandaloneDataStorage::New(); - - //************************************************************************* - // Part II: Create some data by reading a file - //************************************************************************* - - // Create a DataNodeFactory to read a data format supported - // by the DataNodeFactory (many image formats, surface formats, etc.) - mitk::DataNodeFactory::Pointer reader = mitk::DataNodeFactory::New(); - const char *filename = argv[1]; - try - { - reader->SetFileName(filename); - reader->Update(); - //************************************************************************* - // Part III: Put the data into the datastorage - //************************************************************************* - - // Add the node to the DataStorage - dataStorage->Add(reader->GetOutput()); - } - catch (...) - { - fprintf(stderr, "Could not open file %s \n\n", filename); - exit(2); - } - - //************************************************************************* - // Part IV: Create window and pass the datastorage to it - //************************************************************************* - - // Create a RenderWindow - QmitkRenderWindow renderWindow; - - // Tell the RenderWindow which (part of) the datastorage to render - renderWindow.GetRenderer()->SetDataStorage(dataStorage); - - // Initialize the RenderWindow - mitk::TimeGeometry::Pointer geo = dataStorage->ComputeBoundingGeometry3D(dataStorage->GetAll()); - mitk::RenderingManager::GetInstance()->InitializeViews(geo); - // mitk::RenderingManager::GetInstance()->InitializeViews(); - - // Select a slice - mitk::SliceNavigationController::Pointer sliceNaviController = renderWindow.GetSliceNavigationController(); - if (sliceNaviController) - sliceNaviController->GetSlice()->SetPos(0); - - //************************************************************************* - // Part V: Qt-specific initialization - //************************************************************************* - - //! [CreateOverlayManager] - mitk::OverlayManager::Pointer OverlayManagerInstance = mitk::OverlayManager::New(); - mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(renderWindow.GetVtkRenderWindow()); - renderer->SetOverlayManager(OverlayManagerInstance); - //! [CreateOverlayManager] - - //! [GetOverlayManagerInstance] - // The id that is passed identifies the correct mitk::OverlayManager and is '0' by default. - mitk::BaseRenderer *renderer2D = mitk::BaseRenderer::GetInstance(renderWindow.GetVtkRenderWindow()); - mitk::OverlayManager::Pointer overlayManager = renderer2D->GetOverlayManager(); - //! [GetOverlayManagerInstance] - - //! [AddLayouter] - // This creates a 2DLayouter that is only active for the recently fetched axialRenderer and positione - mitk::Overlay2DLayouter::Pointer topleftLayouter = - mitk::Overlay2DLayouter::CreateLayouter(mitk::Overlay2DLayouter::STANDARD_2D_TOPLEFT(), renderer2D); - - // Now, the created Layouter is added to the OverlayManager and can be referred to by its identification string. - overlayManager->AddLayouter(topleftLayouter.GetPointer()); - - // Several other Layouters can be added to the overlayManager - mitk::Overlay2DLayouter::Pointer bottomLayouter = - mitk::Overlay2DLayouter::CreateLayouter(mitk::Overlay2DLayouter::STANDARD_2D_BOTTOM(), renderer2D); - overlayManager->AddLayouter(bottomLayouter.GetPointer()); - //! [AddLayouter] - - //! [TextOverlay2D] - // Create a textOverlay2D - mitk::TextOverlay2D::Pointer textOverlay = mitk::TextOverlay2D::New(); - - textOverlay->SetText("Test!"); // set UTF-8 encoded text to render - textOverlay->SetFontSize(40); - textOverlay->SetColor(1, 0, 0); // Set text color to red - textOverlay->SetOpacity(1); - - // The position of the Overlay can be set to a fixed coordinate on the display. - mitk::Point2D pos; - pos[0] = 10, pos[1] = 20; - textOverlay->SetPosition2D(pos); - - // Add the overlay to the overlayManager. It is added to all registered renderers automaticly - overlayManager->AddOverlay(textOverlay.GetPointer()); - - // Alternatively, a layouter can be used to manage the position of the overlay. If a layouter is set, the absolute - // position of the overlay is not used anymore - // The Standard TopLeft Layouter has to be registered to the OverlayManager first - overlayManager->AddLayouter( - mitk::Overlay2DLayouter::CreateLayouter(mitk::Overlay2DLayouter::STANDARD_2D_TOPLEFT(), renderer2D).GetPointer()); - //! [TextOverlay2D] - - //! [SetLayouterToOverlay] - // Because a Layouter is specified by the identification string AND the Renderer, both have to be passed to the call. - overlayManager->SetLayouter(textOverlay.GetPointer(), mitk::Overlay2DLayouter::STANDARD_2D_TOPLEFT(), renderer2D); - //! [SetLayouterToOverlay] - - //! [TextOverlay3D] - mitk::PointSet::Pointer pointset = mitk::PointSet::New(); - - // This vector is used to define an offset for the annotations, in order to show them with a margin to the actual - // coordinate. - mitk::Point3D offset; - offset[0] = .5; - offset[1] = .5; - offset[2] = .5; - - // Just a loop to create some points - for (int i = 0; i < 10; i++) - { - // To each point, a TextOverlay3D is created - mitk::TextOverlay3D::Pointer textOverlay3D = mitk::TextOverlay3D::New(); - mitk::Point3D point; - point[0] = i * 20; - point[1] = i * 30; - point[2] = -i * 50; - pointset->InsertPoint(i, point); - textOverlay3D->SetText("A Point"); - - // The Position is set to the point coordinate to create an annotation to the point in the PointSet. - textOverlay3D->SetPosition3D(point); - - // move the annotation away from the actual point - textOverlay3D->SetOffsetVector(offset); - - overlayManager->AddOverlay(textOverlay3D.GetPointer()); - } - - // also show the created pointset - mitk::DataNode::Pointer datanode = mitk::DataNode::New(); - datanode->SetData(pointset); - datanode->SetName("pointSet"); - dataStorage->Add(datanode); - //! [TextOverlay3D] - renderWindow.show(); - renderWindow.resize(256, 256); - - return qtapplication.exec(); - - // cleanup: Remove References to DataStorage. This will delete the object - dataStorage = NULL; -} -/** -\example Step1.cpp -*/ \ No newline at end of file diff --git a/Examples/Overlays/files.cmake b/Examples/Overlays/files.cmake deleted file mode 100644 index 3bcefd36f6..0000000000 --- a/Examples/Overlays/files.cmake +++ /dev/null @@ -1 +0,0 @@ -set(CPP_FILES OverlayExample.cpp) diff --git a/MITKConfig.cmake.in b/MITKConfig.cmake.in index cc3dbd92b3..35451d3879 100644 --- a/MITKConfig.cmake.in +++ b/MITKConfig.cmake.in @@ -1,327 +1,307 @@ if(CMAKE_VERSION VERSION_LESS @MITK_CMAKE_MINIMUM_REQUIRED_VERSION@) message(FATAL_ERROR "MITK requires at least CMake Version @MITK_CMAKE_MINIMUM_REQUIRED_VERSION@") endif() # The MITK version number set(MITK_VERSION_MAJOR "@MITK_VERSION_MAJOR@") set(MITK_VERSION_MINOR "@MITK_VERSION_MINOR@") set(MITK_VERSION_PATCH "@MITK_VERSION_PATCH@") set(MITK_VERSION_STRING "@MITK_VERSION_STRING@") #----------------------------------------------------------------------------- # C++ language standard #----------------------------------------------------------------------------- set(MITK_CXX_STANDARD @MITK_CXX_STANDARD@) #----------------------------------------------------------------------------- # Include required CMake scripts #----------------------------------------------------------------------------- # Update the CMake module path set(MITK_CMAKE_MODULE_PATH "@MITK_SOURCE_DIR@/CMake") list(APPEND CMAKE_MODULE_PATH ${MITK_CMAKE_MODULE_PATH}) # Standard CMake macros include(CMakeParseArguments) include(FeatureSummary) include(FindPackageHandleStandardArgs) include(GenerateExportHeader) # Include MITK macros include(MacroParseArguments) include(mitkFunctionAddCustomModuleTest) include(mitkFunctionCheckMitkCompatibility) include(mitkFunctionCheckModuleDependencies) include(mitkFunctionConfigureVisualStudioUserProjectFile) include(mitkFunctionCreateBlueBerryApplication) include(mitkFunctionCreateCommandLineApp) include(mitkFunctionCreateModule) include(mitkFunctionCreatePlugin) include(mitkFunctionCreateProvisioningFile) include(mitkFunctionCreateWindowsBatchScript) include(mitkFunctionGetLibrarySearchPaths) include(mitkFunctionInstallAutoLoadModules) include(mitkFunctionInstallCTKPlugin) include(mitkFunctionInstallProvisioningFiles) include(mitkFunctionInstallThirdPartyCTKPlugins) include(mitkFunctionOrganizeSources) include(mitkFunctionUseModules) include(mitkMacroCreateExecutable) include(mitkMacroCreateModuleTests) include(mitkMacroFindDependency) include(mitkMacroGenerateToolsLibrary) include(mitkMacroGetPMDPlatformString) include(mitkMacroInstall) include(mitkMacroInstallHelperApp) include(mitkMacroInstallTargets) include(mitkMacroMultiplexPicType) #----------------------------------------------------------------------------- # MITK flags and directories #----------------------------------------------------------------------------- # MITK compiler flags set(MITK_C_FLAGS "@MITK_C_FLAGS@") set(MTTK_C_FLAGS_DEBUG "@MITK_C_FLAGS_DEBUG@") set(MITK_C_FLAGS_RELEASE "@MITK_C_FLAGS_RELEASE@") set(MITK_CXX_FLAGS "@MITK_CXX_FLAGS@") set(MTTK_CXX_FLAGS_DEBUG "@MITK_CXX_FLAGS_DEBUG@") set(MITK_CXX_FLAGS_RELEASE "@MITK_CXX_FLAGS_RELEASE@") # MITK linker flags set(MITK_EXE_LINKER_FLAGS "@MITK_EXE_LINKER_FLAGS@") set(MITK_SHARED_LINKER_FLAGS "@MITK_SHARED_LINKER_FLAGS@") set(MITK_MODULE_LINKER_FLAGS "@MITK_MODULE_LINKER_FLAGS@") # MITK specific directories set(MITK_SOURCE_DIR "@MITK_SOURCE_DIR@") set(MITK_BINARY_DIR "@MITK_BINARY_DIR@") set(MITK_CMAKE_DIR "@MITK_CMAKE_DIR@") # MITK output directories set(MITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY "@MITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY@") set(MITK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY "@MITK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY@") set(MITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY "@MITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY@") #----------------------------------------------------------------------------- # Miscellaneous variables #----------------------------------------------------------------------------- # Internal version numbers, used for approximate compatibility checks # of a MITK development version (non-release). set(MITK_VERSION_PLUGIN_SYSTEM 2) # dropped legacy BlueBerry plug-in CMake support set(MITK_DATA_DIR "@MITK_DATA_DIR@") set(UTILITIES_DIR "@UTILITIES_DIR@") set(REGISTER_QFUNCTIONALITY_CPP_IN "@REGISTER_QFUNCTIONALITY_CPP_IN@") set(MITK_DOXYGEN_TAGFILE_NAME "@MITK_DOXYGEN_TAGFILE_NAME@") set(MITK_LEGACY_EXPORT_MACRO_NAME 1) set(DCMTK_CMAKE_DEBUG_POSTFIX @DCMTK_CMAKE_DEBUG_POSTFIX@) # Get the canonical name of the directory to avoid potential case mismatch, # e.g. in the drive letter on Windows. get_filename_component(CMAKE_CURRENT_LIST_DIR_REALPATH ${CMAKE_CURRENT_LIST_DIR} REALPATH) if(CMAKE_CURRENT_LIST_DIR_REALPATH STREQUAL MITK_BINARY_DIR) set(MITK_EXTERNAL_PROJECT_PREFIX @MITK_EXTERNAL_PROJECT_PREFIX@) endif() set(MITK_MODULES_PACKAGE_DEPENDS_DIR "@MITK_MODULES_PACKAGE_DEPENDS_DIR@") if(MODULES_PACKAGE_DEPENDS_DIRS) list(APPEND MODULES_PACKAGE_DEPENDS_DIRS ${MITK_MODULES_PACKAGE_DEPENDS_DIR}) list(REMOVE_DUPLICATES MODULES_PACKAGE_DEPENDS_DIRS) else() set(MODULES_PACKAGE_DEPENDS_DIRS ${MITK_MODULES_PACKAGE_DEPENDS_DIR}) endif() #----------------------------------------------------------------------------- # External dependencies #----------------------------------------------------------------------------- list(APPEND CMAKE_PREFIX_PATH "@MITK_EXTERNAL_PROJECT_PREFIX@") # ----------------------------------------- # Qt variables and dependencies set(MITK_USE_Qt5 @MITK_USE_Qt5@) set(MITK_USE_Qt5_WebEngine @MITK_USE_Qt5_WebEngine@) if(MITK_USE_Qt5) set(MITK_QT5_MINIMUM_VERSION @MITK_QT5_MINIMUM_VERSION@) set(MITK_QT5_COMPONENTS @MITK_QT5_COMPONENTS@) mitkMacroFindDependency(Qt5 ${MITK_QT5_MINIMUM_VERSION} COMPONENTS ${MITK_QT5_COMPONENTS}) endif() # ----------------------------------------- # Special Python variables set(MITK_USE_Python @MITK_USE_Python@) set(MITK_USE_SYSTEM_PYTHON @MITK_USE_SYSTEM_PYTHON@) if(MITK_USE_Python) set(PYTHON_EXECUTABLE "@PYTHON_EXECUTABLE@" CACHE FILEPATH "") set(PYTHON_INCLUDE_DIR "@PYTHON_INCLUDE_DIR@" CACHE PATH "") set(PYTHON_LIBRARY "@PYTHON_LIBRARY@" CACHE FILEPATH "") set(PYTHON_INCLUDE_DIR2 "@PYTHON_INCLUDE_DIR2@" CACHE PATH "") mitkMacroFindDependency(PythonLibs) mitkMacroFindDependency(PythonInterp) endif() # ----------------------------------------- # Special Boost variables set(MITK_USE_Boost_LIBRARIES @MITK_USE_Boost_LIBRARIES@) set(MITK_USE_SYSTEM_Boost @MITK_USE_SYSTEM_Boost@) set(BOOST_ROOT "@BOOST_ROOT@" CACHE PATH "") set(BOOST_LIBRARYDIR "@BOOST_LIBRARYDIR@" CACHE PATH "") set(Boost_ADDITIONAL_VERSIONS "1.60" "1.60.0") -# We need this later for a DCMTK workaround -set(_dcmtk_dir_orig "@DCMTK_DIR@") - # ----------------------------------------- # External dependencies from the superbuild # or injected from somewhere else via # _DIR variables. @MITK_CONFIG_EXTERNAL_PROJECTS@ # Ensure the MITK module path comes first set(CMAKE_MODULE_PATH ${MITK_CMAKE_MODULE_PATH} ${CMAKE_MODULE_PATH}) -# ----------------------------------------- -# Special handling for DCMTK - -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() - # ----------------------------------------- # Special handling for SOFA if(MITK_USE_SOFA) # The SOFAConfig.cmake file does not provide exported targets or # libraries with absolute paths, hence we need to make the link # directories globally available until the SOFAConfig.cmake file # supports a proper mechanism for handling targets. # find_package(SOFA PATHS ${SOFA_DIR} CONFIG REQUIRED) link_directories(${SOFA_LIBRARY_DIRS}) endif() # ----------------------------------------- # Special handling for VMTK if(MITK_USE_VMTK) # Same as SOFA above link_directories(${VMTK_LIBRARY_DIRS}) endif() # ----------------------------------------- # Special handling for Boost if(MITK_USE_Boost) # Same as SOFA above link_directories(${Boost_LIBRARY_DIRS}) endif() # ----------------------------------------- # Special handling for OpenIGTLink if(MITK_USE_OpenIGTLink) # Same as SOFA above link_directories(${OpenIGTLink_LIBRARY_DIRS}) endif() # ----------------------------------------- # Internal project dependencies set(CppMicroServices_DIR "@CppMicroServices_DIR@") mitkMacroFindDependency(CppMicroServices) set(MITK_USE_BLUEBERRY @MITK_USE_BLUEBERRY@) if(MITK_USE_BLUEBERRY) set(MITK_PLUGIN_USE_FILE "@MITK_PLUGIN_USE_FILE@") if(MITK_PLUGIN_USE_FILE) if(EXISTS "${MITK_PLUGIN_USE_FILE}") include("${MITK_PLUGIN_USE_FILE}") endif() endif() set(MITK_PLUGIN_PROVISIONING_FILE "@MITK_EXTAPP_PROVISIONING_FILE@") set(MITK_PROVISIONING_FILES "${BLUEBERRY_PLUGIN_PROVISIONING_FILE}" "${MITK_PLUGIN_PROVISIONING_FILE}") endif() set(BLUEBERRY_USE_QT_HELP @BLUEBERRY_USE_QT_HELP@) if(BLUEBERRY_USE_QT_HELP AND DOXYGEN_VERSION VERSION_LESS "1.8.7") message("Setting BLUEBERRY_USE_QT_HELP to OFF because Doxygen version 1.8.7 or newer not found.") set(BLUEBERRY_USE_QT_HELP OFF) endif() set(BLUEBERRY_QTPLUGIN_PATH "@BLUEBERRY_QTPLUGIN_PATH@") set(QT_HELPGENERATOR_EXECUTABLE "@QT_HELPGENERATOR_EXECUTABLE@") set(QT_COLLECTIONGENERATOR_EXECUTABLE "@QT_COLLECTIONGENERATOR_EXECUTABLE@") set(QT_ASSISTANT_EXECUTABLE "@QT_ASSISTANT_EXECUTABLE@") set(QT_XMLPATTERNS_EXECUTABLE "@QT_XMLPATTERNS_EXECUTABLE@") #----------------------------------------------------------------------------- # MITK sub-project variables #----------------------------------------------------------------------------- # External SDK directories set(MITK_PMD_SDK_DIR @MITK_PMD_SDK_DIR@) # MITK ToF use variables set(MITK_TOF_PMDCAMCUBE_AVAILABLE @MITK_USE_TOF_PMDCAMCUBE@) if(MITK_TOF_PMDCAMCUBE_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK") option(MITK_USE_TOF_PMDCAMCUBE "Enable support for PMD Cam Cube" @MITK_USE_TOF_PMDCAMCUBE@) mark_as_advanced(MITK_USE_TOF_PMDCAMCUBE) endif() set(MITK_TOF_PMDCAMBOARD_AVAILABLE @MITK_USE_TOF_PMDCAMBOARD@) if(MITK_TOF_PMDCAMBOARD_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK") option(MITK_USE_TOF_PMDCAMBOARD "Enable support for PMD Cam Board" @MITK_USE_TOF_PMDCAMBOARD@) mark_as_advanced(MITK_USE_TOF_PMDCAMBOARD) endif() set(MITK_TOF_PMDO3_AVAILABLE @MITK_USE_TOF_PMDO3@) if(MITK_TOF_PMDO3_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK") option(MITK_USE_TOF_PMDO3 "Enable support for PMD =3" @MITK_USE_TOF_PMDO3@) mark_as_advanced(MITK_USE_TOF_PMDO3) endif() set(MITK_TOF_KINECT_AVAILABLE @MITK_USE_TOF_KINECT@) if(MITK_TOF_KINECT_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK") option(MITK_USE_TOF_KINECT "Enable support for Kinect" @MITK_USE_TOF_KINECT@) mark_as_advanced(MITK_USE_TOF_KINECT) endif() set(MITK_TOF_MESASR4000_AVAILABLE @MITK_USE_TOF_MESASR4000@) if(MITK_TOF_MESASR4000_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK") option(MITK_USE_TOF_MESASR4000 "Enable support for MESA SR4000" @MITK_USE_TOF_MESASR4000@) mark_as_advanced(MITK_USE_TOF_MESASR4000) endif() if(MITK_USE_IGT) #include("${MITK_DIR}/mitkIGTConfig.cmake") endif() #----------------------------------------------------------------------------- # Import MITK targets and set custom properties #----------------------------------------------------------------------------- if(NOT MITK_EXPORTS_FILE_INCLUDED) if(EXISTS "@MITK_EXPORTS_FILE@") set(MITK_EXPORTS_FILE_INCLUDED 1) include("@MITK_EXPORTS_FILE@") endif() endif() # Set properties on exported targets @MITK_EXPORTED_TARGET_PROPERTIES@ #----------------------------------------------------------------------------- # Install rules #----------------------------------------------------------------------------- # Install rules for ToF libraries loaded at runtime if(EXISTS "@MITK_BINARY_DIR@/mitkToFHardwareInstallRules.cmake") include("@MITK_BINARY_DIR@/mitkToFHardwareInstallRules.cmake") endif() diff --git a/Modules/Annotation/CMakeLists.txt b/Modules/Annotation/CMakeLists.txt new file mode 100644 index 0000000000..8d9aa53868 --- /dev/null +++ b/Modules/Annotation/CMakeLists.txt @@ -0,0 +1,6 @@ +MITK_CREATE_MODULE( + DEPENDS MitkCore + WARNINGS_AS_ERRORS +) + +add_subdirectory(test) diff --git a/Modules/Annotation/doc/doxygen/AnnotationModule.dox b/Modules/Annotation/doc/doxygen/AnnotationModule.dox new file mode 100644 index 0000000000..962d3a73b0 --- /dev/null +++ b/Modules/Annotation/doc/doxygen/AnnotationModule.dox @@ -0,0 +1,61 @@ +/** +\page AnnotationModulePage Annotation Module + +\tableofcontents + +\section AnnotationModulePage_Introduction Annotations + +The annotations in MITK are a simple way to display additional information on the render windows. A class, deriving from mitk::Annotation represents an arbitrary +2D or 3D object that can be rendered as an Annotation. This can for example be used for the annotation of 3D points or to Annotation despriptions in the window corners. +Instances of the MicroService mitk::AbstractAnnotationRenderer are used to add the annotations to the renderwindows, updating them and depending on their implementation, organize them in a layout. +This module contains implementations for mitk::AbstractAnnotationRenderer as well as mitk::Annotation. Currently, the following features are realized within the Annotation module. +
    +
  1. 2D and 3D textelements are already defined in the Annotation module and are using VTK to create custom annotations. +
  2. 2D and 3D annotations can be placed freely by providing a display position +
  3. 2D annotations can be placed in a layout, which organizes the annotations in the display corners. +
+ +\section AnnotationModulePage_UsageSection Usage of Predefined Annotations + +\subsection AnnotationModulePage_TextWidget2DUsageSubsection mitkTextAnnotation2D +This exemplary Annotation can render text as a 2D Annotation which can be placed with the LayoutAnnotationRenderer +\snippet AnnotationExample.cpp TextAnnotation2D + +\subsection AnnotationModulePage_TextWidget3DUsageSubsection mitkTextAnnotation3D +This Annotation displays labels in 3D coordinates. The labels always face the camera. + +\snippet AnnotationExample.cpp TextAnnotation3D + +\section AnnotationModulePage_CustomAnnotationSection Implement a Custom Annotation + +A new custom Annotation should derive from mitkAnnotation or one of the later mentioned subclasses VtkAnnotation2D oder VtkAnnotation3D. There should always be an implementation for the methods +AddToBaseRenderer, AddToRenderer, RemoveFromBaseRenderer RemoveFromRenderer and Update. +UpdateAnnotation is the procedure that is called when the Annotation properties have changed. If the Annotation is rendered by VTK, this method only applies the properties to the representation. +If the custom Annotation requires additional properties, they should be made accessible by getters and setters for a better usability: +\code +void mitk::VtkAnnotation3D::SetPosition3D(Point3D position3D, mitk::BaseRenderer *renderer) +{ + mitk::Point3dProperty::Pointer position3dProperty = mitk::Point3dProperty::New(position3D); + SetProperty("Position3D", position3dProperty,renderer); +} + +mitk::Point3D mitk::VtkAnnotation3D::GetPosition3D(mitk::BaseRenderer *renderer) +{ + mitk::Point3D position3D; + GetPropertyValue("Position3D", position3D, renderer); + return position3D; +} +\endcode + +\subsection AnnotationModulePage_CustomVTK2DAnnotationSubsection VTK 2D Annotation + +VTK based Annotations which are meant to be displayed in 2D over the render window should derive from the mitk::VtkAnnotation2D. +The mitk::VtkAnnotation2D is a subclass of Vtk::Annotation, that uses VTK to render the Annotation. This class creates the Annotation representation as a vtkActor2D, and is very easy to implement +because only UpdateVtkAnnotation2D and GetVtkActor2D have to be implemented. The add, update and remove methods are implemented in the superclasses. +UpdateVtkAnnotation2D only needs to apply the specific properties and GetVtkActor2D simply returns the created vtkActor. + +\subsection AnnotationModulePage_CustomVTK3DAnnotationSubsection VTK 3D Annotation + +The mitkVtkAnnotation3D works just like mitkVtkAnnotation2D, but it is designed for arbitrary 3D objects which derive from vtkProp, + +*/ diff --git a/Modules/Annotation/files.cmake b/Modules/Annotation/files.cmake new file mode 100644 index 0000000000..22111606ce --- /dev/null +++ b/Modules/Annotation/files.cmake @@ -0,0 +1,17 @@ +file(GLOB_RECURSE H_FILES RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/include/*") + +set(CPP_FILES + mitkManualPlacementAnnotationRenderer.cpp + mitkColorBarAnnotation.cpp + mitkLabelAnnotation3D.cpp + mitkLogoAnnotation.cpp + mitkLayoutAnnotationRenderer.cpp + mitkScaleLegendAnnotation.cpp + mitkTextAnnotation2D.cpp + mitkTextAnnotation3D.cpp + mitkVtkLogoRepresentation.cxx + mitkVtkAnnotation.cpp + mitkVtkAnnotation2D.cpp + mitkVtkAnnotation3D.cpp +) + diff --git a/Modules/Overlays/mitkColorBarOverlay.h b/Modules/Annotation/include/mitkColorBarAnnotation.h similarity index 79% rename from Modules/Overlays/mitkColorBarOverlay.h rename to Modules/Annotation/include/mitkColorBarAnnotation.h index 10df36efd8..760efe568c 100644 --- a/Modules/Overlays/mitkColorBarOverlay.h +++ b/Modules/Annotation/include/mitkColorBarAnnotation.h @@ -1,97 +1,97 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ -#ifndef COLORBAROVERLAY_H -#define COLORBAROVERLAY_H +#ifndef COLORBARAnnotation_H +#define COLORBARAnnotation_H -#include "MitkOverlaysExports.h" +#include "MitkAnnotationExports.h" #include -#include +#include #include #include class vtkScalarBarActor; namespace mitk { /** \brief Displays configurable scales on the renderwindow. The scale is determined by the image spacing. */ - class MITKOVERLAYS_EXPORT ColorBarOverlay : public mitk::VtkOverlay + class MITKANNOTATION_EXPORT ColorBarAnnotation : public mitk::VtkAnnotation { public: - class LocalStorage : public mitk::Overlay::BaseLocalStorage + class LocalStorage : public mitk::Annotation::BaseLocalStorage { public: /** \brief Actor of a 2D render window. */ vtkSmartPointer m_ScalarBarActor; /** \brief Timestamp of last update of stored data. */ itk::TimeStamp m_LastUpdateTime; /** \brief Default constructor of the local storage. */ LocalStorage(); /** \brief Default deconstructor of the local storage. */ ~LocalStorage(); }; - mitkClassMacro(ColorBarOverlay, mitk::VtkOverlay); + mitkClassMacro(ColorBarAnnotation, mitk::VtkAnnotation); itkFactorylessNewMacro(Self) itkCloneMacro(Self) void SetDrawAnnotations(bool annotations); bool GetDrawAnnotations() const; void SetOrientationToHorizontal(); void SetOrientationToVertical(); void SetOrientation(int orientation); int GetOrientation() const; void SetMaxNumberOfColors(int numberOfColors); int GetMaxNumberOfColors() const; void SetNumberOfLabels(int numberOfLabels); int GetNumberOfLabels() const; void SetLookupTable(vtkSmartPointer table); vtkSmartPointer GetLookupTable() const; void SetDrawTickLabels(bool ticks); bool GetDrawTickLabels() const; void SetAnnotationTextScaling(bool scale); bool GetAnnotationTextScaling() const; protected: /** \brief The LocalStorageHandler holds all LocalStorages for the render windows. */ mutable mitk::LocalStorageHandler m_LSH; virtual vtkProp *GetVtkProp(BaseRenderer *renderer) const override; - virtual void UpdateVtkOverlay(BaseRenderer *renderer) override; + virtual void UpdateVtkAnnotation(BaseRenderer *renderer) override; /** \brief explicit constructor which disallows implicit conversions */ - explicit ColorBarOverlay(); + explicit ColorBarAnnotation(); /** \brief virtual destructor in order to derive from this class */ - virtual ~ColorBarOverlay(); + virtual ~ColorBarAnnotation(); private: /** \brief copy constructor */ - ColorBarOverlay(const ColorBarOverlay &); + ColorBarAnnotation(const ColorBarAnnotation &); /** \brief assignment operator */ - ColorBarOverlay &operator=(const ColorBarOverlay &); + ColorBarAnnotation &operator=(const ColorBarAnnotation &); }; } // namespace mitk -#endif // COLORBAROVERLAY_H +#endif // COLORBARAnnotation_H diff --git a/Modules/Overlays/mitkLabelOverlay3D.h b/Modules/Annotation/include/mitkLabelAnnotation3D.h similarity index 84% rename from Modules/Overlays/mitkLabelOverlay3D.h rename to Modules/Annotation/include/mitkLabelAnnotation3D.h index 34ce6b7aaf..a059c90a8d 100644 --- a/Modules/Overlays/mitkLabelOverlay3D.h +++ b/Modules/Annotation/include/mitkLabelAnnotation3D.h @@ -1,112 +1,112 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ -#ifndef LabelOverlay3D_H -#define LabelOverlay3D_H +#ifndef LabelAnnotation3D_H +#define LabelAnnotation3D_H -#include "MitkOverlaysExports.h" +#include "MitkAnnotationExports.h" #include -#include +#include #include class vtkStringArray; class vtkPolyDataMapper; class vtkPolyData; class vtkActor2D; class vtkProperty2D; class vtkPointSetToLabelHierarchy; class vtkLabelPlacementMapper; class vtkIntArray; namespace mitk { class PointSet; /** \brief Can display a high amount of 3D labels to a PointSet */ - class MITKOVERLAYS_EXPORT LabelOverlay3D : public mitk::VtkOverlay3D + class MITKANNOTATION_EXPORT LabelAnnotation3D : public mitk::VtkAnnotation3D { public: /** \brief Internal class holding the vtkActor, etc. for each of the render windows */ - class LocalStorage : public mitk::Overlay::BaseLocalStorage + class LocalStorage : public mitk::Annotation::BaseLocalStorage { public: vtkSmartPointer m_Points; vtkSmartPointer m_LabelsActor; vtkSmartPointer m_Sizes; vtkSmartPointer m_Labels; vtkSmartPointer m_LabelMapper; vtkSmartPointer m_PointSetToLabelHierarchyFilter; /** \brief Timestamp of last update of stored data. */ itk::TimeStamp m_LastUpdateTime; /** \brief Default constructor of the local storage. */ LocalStorage(); /** \brief Default deconstructor of the local storage. */ ~LocalStorage(); }; - mitkClassMacro(LabelOverlay3D, mitk::VtkOverlay3D); + mitkClassMacro(LabelAnnotation3D, mitk::VtkAnnotation3D); itkFactorylessNewMacro(Self) itkCloneMacro(Self) /** \brief Set the vector of labels that are shown to each corresponding point3D. The size has to be equal to the provided LabelCoordinates. */ void SetLabelVector(const std::vector &LabelVector); /** \brief Optional: Provide a vector of priorities. The labels with higher priorities will be visible in lower LOD */ void SetPriorityVector(const std::vector &PriorityVector); /** \brief Coordinates of the labels */ void SetLabelCoordinates(itk::SmartPointer LabelCoordinates); void PointSetModified(const itk::Object *, const itk::EventObject &); protected: /** \brief The LocalStorageHandler holds all LocalStorages for the render windows. */ mutable mitk::LocalStorageHandler m_LSH; virtual vtkProp *GetVtkProp(BaseRenderer *renderer) const override; - void UpdateVtkOverlay(mitk::BaseRenderer *renderer) override; + void UpdateVtkAnnotation(mitk::BaseRenderer *renderer) override; /** \brief explicit constructor which disallows implicit conversions */ - explicit LabelOverlay3D(); + explicit LabelAnnotation3D(); /** \brief virtual destructor in order to derive from this class */ - virtual ~LabelOverlay3D(); + virtual ~LabelAnnotation3D(); private: /** \brief The char arrays in this vector are displayed at the corresponding coordinates.*/ std::vector m_LabelVector; /** \brief values in this array set a priority to each label. Higher priority labels are not covert by labels with * lower priority.*/ std::vector m_PriorityVector; /** \brief The coordinates of the labels. Indices must match the labelVector and the priorityVector.*/ itk::SmartPointer m_LabelCoordinates; unsigned long m_PointSetModifiedObserverTag; /** \brief copy constructor */ - LabelOverlay3D(const LabelOverlay3D &); + LabelAnnotation3D(const LabelAnnotation3D &); /** \brief assignment operator */ - LabelOverlay3D &operator=(const LabelOverlay3D &); + LabelAnnotation3D &operator=(const LabelAnnotation3D &); }; } // namespace mitk -#endif // LabelOverlay3D_H +#endif // LabelAnnotation3D_H diff --git a/Modules/Annotation/include/mitkLayoutAnnotationRenderer.h b/Modules/Annotation/include/mitkLayoutAnnotationRenderer.h new file mode 100644 index 0000000000..7b2059ca33 --- /dev/null +++ b/Modules/Annotation/include/mitkLayoutAnnotationRenderer.h @@ -0,0 +1,107 @@ +/*=================================================================== + +The Medical Imaging Interaction Toolkit (MITK) + +Copyright (c) German Cancer Research Center, +Division of Medical and Biological Informatics. +All rights reserved. + +This software is distributed WITHOUT ANY WARRANTY; without +even the implied warranty of MERCHANTABILITY or FITNESS FOR +A PARTICULAR PURPOSE. + +See LICENSE.txt or http://www.mitk.org for details. + +===================================================================*/ + +#ifndef LayoutAnnotationRenderer_H +#define LayoutAnnotationRenderer_H + +#include "MitkAnnotationExports.h" +#include "mitkAbstractAnnotationRenderer.h" + +namespace mitk +{ + class BaseRenderer; + + /** \brief The LayoutAnnotationRenderer is used for the layouted placement of mitk::Annotation Objects. + * + * An instance of this service is registered for a specific Baserenderer and is used to manage all annotations which + * are added to it. + * The static function AddAnnotation is used to register an annotation to a specific service and to create this + * service if it does not exist yet. The position of the layouted annotation can be passed as a parameter. + * + * See \ref AnnotationPage for more info. + **/ + class MITKANNOTATION_EXPORT LayoutAnnotationRenderer : public AbstractAnnotationRenderer + { + public: + static const std::string PROP_LAYOUT; + static const std::string PROP_LAYOUT_PRIORITY; + static const std::string PROP_LAYOUT_ALIGNMENT; + static const std::string PROP_LAYOUT_MARGIN; + enum Alignment + { + TopLeft, + Top, + TopRight, + BottomLeft, + Bottom, + BottomRight, + Left, + Right + }; + typedef std::multimap AnnotationRankedMap; + typedef std::map AnnotationLayouterContainerMap; + + /** \brief virtual destructor in order to derive from this class */ + virtual ~LayoutAnnotationRenderer(); + + const std::string GetID() const; + + static LayoutAnnotationRenderer *GetAnnotationRenderer(const std::string &rendererID); + + void OnRenderWindowModified(); + + static void AddAnnotation(Annotation *annotation, + const std::string &rendererID, + Alignment alignment = TopLeft, + double marginX = 5, + double marginY = 5, + int priority = -1); + + static void AddAnnotation(Annotation *annotation, + BaseRenderer *renderer, + Alignment alignment = TopLeft, + double marginX = 5, + double marginY = 5, + int priority = -1); + + void PrepareLayout(); + + private: + LayoutAnnotationRenderer(const std::string &rendererId); + + static void AddAlignmentProperty(Annotation *annotation, Alignment activeAlignment, Point2D margin, int priority); + + void PrepareTopLeftLayout(int *displaySize); + void PrepareTopLayout(int *displaySize); + void PrepareTopRightLayout(int *displaySize); + void PrepareBottomLeftLayout(int *displaySize); + void PrepareBottomLayout(int *displaySize); + void PrepareBottomRightLayout(int *displaySize); + void PrepareLeftLayout(int *displaySize); + void PrepareRightLayout(int *displaySize); + + static double GetHeight(AnnotationRankedMap &annotations, BaseRenderer *renderer); + + virtual void OnAnnotationRenderersChanged(); + static const std::string ANNOTATIONRENDERER_ID; + AnnotationLayouterContainerMap m_AnnotationContainerMap; + static void SetMargin2D(Annotation *annotation, const Point2D &OffsetVector); + static Point2D GetMargin2D(Annotation *annotation); + }; + +} // namespace mitk + +#endif // LayoutAnnotationRenderer_H diff --git a/Modules/Overlays/mitkLogoOverlay.h b/Modules/Annotation/include/mitkLogoAnnotation.h similarity index 69% rename from Modules/Overlays/mitkLogoOverlay.h rename to Modules/Annotation/include/mitkLogoAnnotation.h index 57528421d0..b0080ad9ad 100644 --- a/Modules/Overlays/mitkLogoOverlay.h +++ b/Modules/Annotation/include/mitkLogoAnnotation.h @@ -1,102 +1,102 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ -#ifndef LOGOOVERLAY_H -#define LOGOOVERLAY_H +#ifndef LOGOAnnotation_H +#define LOGOAnnotation_H -#include "MitkOverlaysExports.h" +#include "MitkAnnotationExports.h" #include -#include +#include #include class mitkVtkLogoRepresentation; class vtkImageData; class vtkImageReader2Factory; class vtkImageImport; namespace mitk { /** \brief Displays a logo on the renderwindow */ - class MITKOVERLAYS_EXPORT LogoOverlay : public mitk::VtkOverlay + class MITKANNOTATION_EXPORT LogoAnnotation : public mitk::VtkAnnotation { public: - class LocalStorage : public mitk::Overlay::BaseLocalStorage + class LocalStorage : public mitk::Annotation::BaseLocalStorage { public: /** \brief Actor of a 2D render window. */ vtkSmartPointer m_LogoImage; vtkSmartPointer m_LogoRep; /** \brief Timestamp of last update of stored data. */ itk::TimeStamp m_LastUpdateTime; /** \brief Default constructor of the local storage. */ LocalStorage(); /** \brief Default deconstructor of the local storage. */ ~LocalStorage(); }; - mitkClassMacro(LogoOverlay, mitk::VtkOverlay); + mitkClassMacro(LogoAnnotation, mitk::VtkAnnotation); itkFactorylessNewMacro(Self) itkCloneMacro(Self) vtkSmartPointer m_readerFactory; void SetLogoImagePath(std::string text); std::string GetLogoImagePath() const; /** \brief The relative offset to the corner position */ - void SetOffsetVector(const Point2D &OffsetVector, BaseRenderer *renderer = NULL); - Point2D GetOffsetVector(mitk::BaseRenderer *renderer = NULL) const; + void SetOffsetVector(const Point2D &OffsetVector); + Point2D GetOffsetVector() const; /** \brief The corner where the logo is displayed. 0 = Bottom left 1 = Bottom right 2 = Top right 3 = Top left 4 = Center*/ - void SetCornerPosition(const int &corner, BaseRenderer *renderer = NULL); - int GetCornerPosition(mitk::BaseRenderer *renderer = NULL) const; + void SetCornerPosition(const int &corner); + int GetCornerPosition() const; - void SetRelativeSize(const float &size, BaseRenderer *renderer = NULL); - float GetRelativeSize(mitk::BaseRenderer *renderer = NULL) const; + void SetRelativeSize(const float &size); + float GetRelativeSize() const; protected: /** \brief The LocalStorageHandler holds all LocalStorages for the render windows. */ mutable mitk::LocalStorageHandler m_LSH; virtual vtkProp *GetVtkProp(BaseRenderer *renderer) const override; - void UpdateVtkOverlay(mitk::BaseRenderer *renderer) override; + void UpdateVtkAnnotation(mitk::BaseRenderer *renderer) override; vtkImageData *CreateMbiLogo(); /** \brief explicit constructor which disallows implicit conversions */ - explicit LogoOverlay(); + explicit LogoAnnotation(); /** \brief virtual destructor in order to derive from this class */ - virtual ~LogoOverlay(); + virtual ~LogoAnnotation(); private: vtkSmartPointer m_VtkImageImport; /** \brief copy constructor */ - LogoOverlay(const LogoOverlay &); + LogoAnnotation(const LogoAnnotation &); /** \brief assignment operator */ - LogoOverlay &operator=(const LogoOverlay &); + LogoAnnotation &operator=(const LogoAnnotation &); }; } // namespace mitk -#endif // LOGOOVERLAY_H +#endif // LOGOAnnotation_H diff --git a/Modules/Annotation/include/mitkManualPlacementAnnotationRenderer.h b/Modules/Annotation/include/mitkManualPlacementAnnotationRenderer.h new file mode 100644 index 0000000000..b25410768e --- /dev/null +++ b/Modules/Annotation/include/mitkManualPlacementAnnotationRenderer.h @@ -0,0 +1,57 @@ +/*=================================================================== + +The Medical Imaging Interaction Toolkit (MITK) + +Copyright (c) German Cancer Research Center, +Division of Medical and Biological Informatics. +All rights reserved. + +This software is distributed WITHOUT ANY WARRANTY; without +even the implied warranty of MERCHANTABILITY or FITNESS FOR +A PARTICULAR PURPOSE. + +See LICENSE.txt or http://www.mitk.org for details. + +===================================================================*/ + +#ifndef ManualPlacementAnnotationRenderer_H +#define ManualPlacementAnnotationRenderer_H + +#include "MitkAnnotationExports.h" +#include "mitkAbstractAnnotationRenderer.h" +#include "mitkAnnotation.h" + +namespace mitk +{ + class BaseRenderer; + + /** \brief The ManualPlacementAnnotationRenderer is used for the simple placement of mitk::Annotation Objects. + * + * An instance of this service is registered for a specific Baserenderer and is used to manage all annotations which + * are added to it. + * The static function AddAnnotation is used to register an annotation to a specific service and to create this + * service if it does not exist yet. + * + * See \ref AnnotationPage for more info. + **/ + class MITKANNOTATION_EXPORT ManualPlacementAnnotationRenderer : public AbstractAnnotationRenderer + { + public: + /** \brief virtual destructor in order to derive from this class */ + virtual ~ManualPlacementAnnotationRenderer(); + + static ManualPlacementAnnotationRenderer *GetAnnotationRenderer(const std::string &rendererID); + + static void AddAnnotation(Annotation *Annotation, const std::string &rendererID); + + static void AddAnnotation(Annotation *Annotation, BaseRenderer *renderer); + + private: + ManualPlacementAnnotationRenderer(const std::string &rendererId); + + static const std::string ANNOTATIONRENDERER_ID; + }; + +} // namespace mitk + +#endif // ManualPlacementAnnotationRenderer_H diff --git a/Modules/Overlays/mitkScaleLegendOverlay.h b/Modules/Annotation/include/mitkScaleLegendAnnotation.h similarity index 67% rename from Modules/Overlays/mitkScaleLegendOverlay.h rename to Modules/Annotation/include/mitkScaleLegendAnnotation.h index 93e404e3ef..db3bc511a7 100644 --- a/Modules/Overlays/mitkScaleLegendOverlay.h +++ b/Modules/Annotation/include/mitkScaleLegendAnnotation.h @@ -1,94 +1,106 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ -#ifndef SCALELEGENDOVERLAY_H -#define SCALELEGENDOVERLAY_H +#ifndef SCALELEGENDAnnotation_H +#define SCALELEGENDAnnotation_H -#include "MitkOverlaysExports.h" +#include "MitkAnnotationExports.h" #include -#include +#include #include class vtkLegendScaleActor; namespace mitk { /** \brief Displays configurable scales on the renderwindow. The scale is determined by the image spacing. */ - class MITKOVERLAYS_EXPORT ScaleLegendOverlay : public mitk::VtkOverlay + class MITKANNOTATION_EXPORT ScaleLegendAnnotation : public mitk::VtkAnnotation { public: - class LocalStorage : public mitk::Overlay::BaseLocalStorage + class LocalStorage : public mitk::Annotation::BaseLocalStorage { public: /** \brief Actor of a 2D render window. */ vtkSmartPointer m_legendScaleActor; /** \brief Timestamp of last update of stored data. */ itk::TimeStamp m_LastUpdateTime; /** \brief Default constructor of the local storage. */ LocalStorage(); /** \brief Default deconstructor of the local storage. */ ~LocalStorage(); }; - mitkClassMacro(ScaleLegendOverlay, mitk::VtkOverlay); + mitkClassMacro(ScaleLegendAnnotation, mitk::VtkAnnotation); itkFactorylessNewMacro(Self) itkCloneMacro(Self) void SetRightAxisVisibility(bool visibility); bool GetRightAxisVisibility() const; void SetLeftAxisVisibility(bool visibility); bool GetLeftAxisVisibility() const; void SetTopAxisVisibility(bool visibility); bool GetTopAxisVisibility() const; void SetBottomAxisVisibility(bool visibility); bool GetBottomAxisVisibility() const; void SetLegendVisibility(bool visibility); bool GetLegendVisibility() const; void SetRightBorderOffset(int offset); int GetRightBorderOffset() const; - void SetCornerOffsetFactor(float offsetFactor); - float GetCornerOffsetFactor() const; + void SetLeftBorderOffset(int offset); + int GetLeftBorderOffset() const; + + void SetTopBorderOffset(int offset); + int GetTopBorderOffset() const; + + void SetBottomBorderOffset(int offset); + int GetBottomBorderOffset() const; + + void SetFontFactor(double fontFactor); + double GetFontFactor() const; + + void SetCornerOffsetFactor(double offsetFactor); + double GetCornerOffsetFactor() const; protected: /** \brief The LocalStorageHandler holds all LocalStorages for the render windows. */ mutable mitk::LocalStorageHandler m_LSH; virtual vtkProp *GetVtkProp(BaseRenderer *renderer) const override; - virtual void UpdateVtkOverlay(BaseRenderer *renderer) override; + virtual void UpdateVtkAnnotation(BaseRenderer *renderer) override; /** \brief explicit constructor which disallows implicit conversions */ - explicit ScaleLegendOverlay(); + explicit ScaleLegendAnnotation(); /** \brief virtual destructor in order to derive from this class */ - virtual ~ScaleLegendOverlay(); + virtual ~ScaleLegendAnnotation(); private: /** \brief copy constructor */ - ScaleLegendOverlay(const ScaleLegendOverlay &); + ScaleLegendAnnotation(const ScaleLegendAnnotation &); /** \brief assignment operator */ - ScaleLegendOverlay &operator=(const ScaleLegendOverlay &); + ScaleLegendAnnotation &operator=(const ScaleLegendAnnotation &); }; } // namespace mitk -#endif // SCALELEGENDOVERLAY_H +#endif // SCALELEGENDAnnotation_H diff --git a/Modules/Overlays/mitkTextOverlay2D.h b/Modules/Annotation/include/mitkTextAnnotation2D.h similarity index 74% rename from Modules/Overlays/mitkTextOverlay2D.h rename to Modules/Annotation/include/mitkTextAnnotation2D.h index c4ccedcfe0..cac8c9ada3 100644 --- a/Modules/Overlays/mitkTextOverlay2D.h +++ b/Modules/Annotation/include/mitkTextAnnotation2D.h @@ -1,86 +1,86 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ -#ifndef TEXTOVERLAY2D_H -#define TEXTOVERLAY2D_H +#ifndef TEXTAnnotation2D_H +#define TEXTAnnotation2D_H -#include "MitkOverlaysExports.h" +#include "MitkAnnotationExports.h" #include -#include +#include #include class vtkTextActor; class vtkPropAssembly; namespace mitk { /** \brief Displays text on the renderwindow */ - class MITKOVERLAYS_EXPORT TextOverlay2D : public mitk::VtkOverlay2D + class MITKANNOTATION_EXPORT TextAnnotation2D : public mitk::VtkAnnotation2D { public: - class LocalStorage : public mitk::Overlay::BaseLocalStorage + class LocalStorage : public mitk::Annotation::BaseLocalStorage { public: /** \brief Actor of a 2D render window. */ vtkSmartPointer m_TextActor; vtkSmartPointer m_TextProp; vtkSmartPointer m_STextActor; vtkSmartPointer m_STextProp; vtkSmartPointer m_Assembly; /** \brief Timestamp of last update of stored data. */ itk::TimeStamp m_LastUpdateTime; /** \brief Default constructor of the local storage. */ LocalStorage(); /** \brief Default deconstructor of the local storage. */ ~LocalStorage(); }; - mitkClassMacro(TextOverlay2D, mitk::VtkOverlay2D); + mitkClassMacro(TextAnnotation2D, mitk::VtkAnnotation2D); itkFactorylessNewMacro(Self) itkCloneMacro(Self) - virtual Overlay::Bounds GetBoundsOnDisplay(BaseRenderer *renderer) const override; + virtual Annotation::Bounds GetBoundsOnDisplay(BaseRenderer *renderer) const override; virtual void SetBoundsOnDisplay(BaseRenderer *renderer, const Bounds &bounds) override; protected: /** \brief The LocalStorageHandler holds all LocalStorages for the render windows. */ mutable mitk::LocalStorageHandler m_LSH; vtkProp *GetVtkProp(BaseRenderer *renderer) const override; virtual vtkActor2D *GetVtkActor2D(BaseRenderer *renderer) const override; - void UpdateVtkOverlay2D(mitk::BaseRenderer *renderer) override; + void UpdateVtkAnnotation2D(mitk::BaseRenderer *renderer) override; /** \brief explicit constructor which disallows implicit conversions */ - explicit TextOverlay2D(); + explicit TextAnnotation2D(); /** \brief virtual destructor in order to derive from this class */ - virtual ~TextOverlay2D(); + virtual ~TextAnnotation2D(); private: /** \brief copy constructor */ - TextOverlay2D(const TextOverlay2D &); + TextAnnotation2D(const TextAnnotation2D &); /** \brief assignment operator */ - TextOverlay2D &operator=(const TextOverlay2D &); + TextAnnotation2D &operator=(const TextAnnotation2D &); }; } // namespace mitk -#endif // TEXTOVERLAY2D_H +#endif // TEXTAnnotation2D_H diff --git a/Modules/Overlays/mitkTextOverlay3D.h b/Modules/Annotation/include/mitkTextAnnotation3D.h similarity index 72% rename from Modules/Overlays/mitkTextOverlay3D.h rename to Modules/Annotation/include/mitkTextAnnotation3D.h index 7f4d4aa32f..832f7b6f60 100644 --- a/Modules/Overlays/mitkTextOverlay3D.h +++ b/Modules/Annotation/include/mitkTextAnnotation3D.h @@ -1,84 +1,84 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ -#ifndef TextOverlay3D_H -#define TextOverlay3D_H +#ifndef TextAnnotation3D_H +#define TextAnnotation3D_H -#include "MitkOverlaysExports.h" +#include "MitkAnnotationExports.h" #include -#include +#include class vtkFollower; class vtkVectorText; class vtkTextActor3D; namespace mitk { /** \brief Displays at 3D position, always facing the camera */ - class MITKOVERLAYS_EXPORT TextOverlay3D : public mitk::VtkOverlay3D + class MITKANNOTATION_EXPORT TextAnnotation3D : public mitk::VtkAnnotation3D { public: /** \brief Internal class holding the mapper, actor, etc. for each of the render windows */ /** - * To render the Overlay on transveral, coronal, and sagittal, the update method + * To render the Annotation on transveral, coronal, and sagittal, the update method * is called for each renderwindow. For performance reasons, the corresponding data * for each view is saved in the internal helper class LocalStorage. - * This allows rendering n views with just 1 mitkOverlay using n vtkMapper. + * This allows rendering n views with just 1 mitkAnnotation using n vtkMapper. * */ - class LocalStorage : public mitk::Overlay::BaseLocalStorage + class LocalStorage : public mitk::Annotation::BaseLocalStorage { public: /** \brief Actor of a 2D render window. */ vtkSmartPointer m_follower; vtkSmartPointer m_textSource; /** \brief Timestamp of last update of stored data. */ itk::TimeStamp m_LastUpdateTime; /** \brief Default constructor of the local storage. */ LocalStorage(); /** \brief Default deconstructor of the local storage. */ ~LocalStorage(); }; - mitkClassMacro(TextOverlay3D, mitk::VtkOverlay3D); + mitkClassMacro(TextAnnotation3D, mitk::VtkAnnotation3D); itkFactorylessNewMacro(Self) itkCloneMacro(Self) protected : /** \brief The LocalStorageHandler holds all LocalStorages for the render windows. */ mutable mitk::LocalStorageHandler m_LSH; virtual vtkProp *GetVtkProp(BaseRenderer *renderer) const override; - void UpdateVtkOverlay(mitk::BaseRenderer *renderer) override; + void UpdateVtkAnnotation(mitk::BaseRenderer *renderer) override; /** \brief explicit constructor which disallows implicit conversions */ - explicit TextOverlay3D(); + explicit TextAnnotation3D(); /** \brief virtual destructor in order to derive from this class */ - virtual ~TextOverlay3D(); + virtual ~TextAnnotation3D(); private: /** \brief copy constructor */ - TextOverlay3D(const TextOverlay3D &); + TextAnnotation3D(const TextAnnotation3D &); /** \brief assignment operator */ - TextOverlay3D &operator=(const TextOverlay3D &); + TextAnnotation3D &operator=(const TextAnnotation3D &); }; } // namespace mitk -#endif // TextOverlay3D_H +#endif // TextAnnotation3D_H diff --git a/Modules/Core/include/mitkVtkOverlay.h b/Modules/Annotation/include/mitkVtkAnnotation.h similarity index 62% rename from Modules/Core/include/mitkVtkOverlay.h rename to Modules/Annotation/include/mitkVtkAnnotation.h index c16a46b5c3..9543c9449c 100644 --- a/Modules/Core/include/mitkVtkOverlay.h +++ b/Modules/Annotation/include/mitkVtkAnnotation.h @@ -1,75 +1,75 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ -#ifndef VTKOVERLAY_H -#define VTKOVERLAY_H +#ifndef VTKAnnotation_H +#define VTKAnnotation_H -#include "mitkOverlay.h" -#include +#include "mitkAnnotation.h" +#include #include class vtkProp; namespace mitk { /** - * @brief The VtkOverlay class is the base for all Overlays which are using the VTK framework to render + * @brief The VtkAnnotation class is the base for all Annotation which are using the VTK framework to render *the elements. */ - class MITKCORE_EXPORT VtkOverlay : public Overlay + class MITKANNOTATION_EXPORT VtkAnnotation : public Annotation { public: - mitkClassMacro(VtkOverlay, Overlay); + mitkClassMacro(VtkAnnotation, Annotation); void Update(BaseRenderer *renderer) override; void AddToBaseRenderer(BaseRenderer *renderer) override; void AddToRenderer(BaseRenderer *renderer, vtkRenderer *vtkrenderer) override; void RemoveFromRenderer(BaseRenderer *renderer, vtkRenderer *vtkrenderer) override; void RemoveFromBaseRenderer(BaseRenderer *renderer) override; /** - * \brief Paints the overlay. + * \brief Paints the Annotation. * - * This method forces a paint of the overlay as it is configured at the moment. - * \warn Should only be used as alternative to the OverlayManager mechanism + * This method forces a paint of the Annotation as it is configured at the moment. + * \warn Should only be used as alternative to the AnnotationManager mechanism * in GL-Mappers. */ void Paint(BaseRenderer *renderer); protected: /** - * @brief This method is implemented by the specific VTKOverlays in order to create the element as a vtkProp + * @brief This method is implemented by the specific VTKAnnotation in order to create the element as a vtkProp * @param renderer * @return The element that was created by the subclasses as a vtkProp. */ virtual vtkProp *GetVtkProp(BaseRenderer *renderer) const = 0; - virtual void UpdateVtkOverlay(BaseRenderer *renderer) = 0; + virtual void UpdateVtkAnnotation(BaseRenderer *renderer) = 0; /** \brief explicit constructor which disallows implicit conversions */ - explicit VtkOverlay(); + explicit VtkAnnotation(); /** \brief virtual destructor in order to derive from this class */ - virtual ~VtkOverlay(); + virtual ~VtkAnnotation(); private: /** \brief copy constructor */ - VtkOverlay(const VtkOverlay &); + VtkAnnotation(const VtkAnnotation &); /** \brief assignment operator */ - VtkOverlay &operator=(const VtkOverlay &); + VtkAnnotation &operator=(const VtkAnnotation &); }; } // namespace mitk -#endif // OVERLAY_H +#endif // Annotation_H diff --git a/Modules/Core/include/mitkVtkOverlay2D.h b/Modules/Annotation/include/mitkVtkAnnotation2D.h similarity index 54% rename from Modules/Core/include/mitkVtkOverlay2D.h rename to Modules/Annotation/include/mitkVtkAnnotation2D.h index 04f6be06bc..0d6aa50f3c 100644 --- a/Modules/Core/include/mitkVtkOverlay2D.h +++ b/Modules/Annotation/include/mitkVtkAnnotation2D.h @@ -1,69 +1,69 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ -#ifndef VTKOVERLAY2D_H -#define VTKOVERLAY2D_H +#ifndef VTKAnnotation2D_H +#define VTKAnnotation2D_H -#include "mitkVtkOverlay.h" -#include +#include "mitkVtkAnnotation.h" +#include #include class vtkActor2D; class vtkProperty2D; namespace mitk { /** - * @brief The VtkOverlay2D class is the basis for all VTK based Overlays which create + * @brief The VtkAnnotation2D class is the basis for all VTK based Annotation which create * a vtkActor2D element that will be drawn on the renderer. */ - class MITKCORE_EXPORT VtkOverlay2D : public VtkOverlay + class MITKANNOTATION_EXPORT VtkAnnotation2D : public VtkAnnotation { public: - mitkClassMacro(VtkOverlay2D, VtkOverlay); - virtual Overlay::Bounds GetBoundsOnDisplay(BaseRenderer *renderer) const override; + mitkClassMacro(VtkAnnotation2D, VtkAnnotation); + virtual Annotation::Bounds GetBoundsOnDisplay(BaseRenderer *renderer) const override; virtual void SetBoundsOnDisplay(BaseRenderer *renderer, const Bounds &bounds) override; - void SetPosition2D(const Point2D &position2D, mitk::BaseRenderer *renderer = NULL); + void SetPosition2D(const Point2D &position2D); - Point2D GetPosition2D(mitk::BaseRenderer *renderer = NULL) const; + Point2D GetPosition2D() const; - void SetOffsetVector(const Point2D &OffsetVector, BaseRenderer *renderer = NULL); + void SetOffsetVector(const Point2D &OffsetVector); - Point2D GetOffsetVector(mitk::BaseRenderer *renderer = NULL) const; + Point2D GetOffsetVector() const; protected: virtual vtkProp *GetVtkProp(BaseRenderer *renderer) const override; - virtual void UpdateVtkOverlay(BaseRenderer *renderer) override; - virtual void UpdateVtkOverlay2D(BaseRenderer *renderer) = 0; + virtual void UpdateVtkAnnotation(BaseRenderer *renderer) override; + virtual void UpdateVtkAnnotation2D(BaseRenderer *renderer) = 0; virtual vtkActor2D *GetVtkActor2D(BaseRenderer *renderer) const = 0; /** \brief explicit constructor which disallows implicit conversions */ - explicit VtkOverlay2D(); + explicit VtkAnnotation2D(); /** \brief virtual destructor in order to derive from this class */ - virtual ~VtkOverlay2D(); + virtual ~VtkAnnotation2D(); private: /** \brief copy constructor */ - VtkOverlay2D(const VtkOverlay2D &); + VtkAnnotation2D(const VtkAnnotation2D &); /** \brief assignment operator */ - VtkOverlay2D &operator=(const VtkOverlay2D &); + VtkAnnotation2D &operator=(const VtkAnnotation2D &); }; } // namespace mitk -#endif // VTKOVERLAY2D_H +#endif // VTKAnnotation2D_H diff --git a/Modules/Core/include/mitkVtkOverlay3D.h b/Modules/Annotation/include/mitkVtkAnnotation3D.h similarity index 51% rename from Modules/Core/include/mitkVtkOverlay3D.h rename to Modules/Annotation/include/mitkVtkAnnotation3D.h index c299323ee6..65a3d8cb4d 100644 --- a/Modules/Core/include/mitkVtkOverlay3D.h +++ b/Modules/Annotation/include/mitkVtkAnnotation3D.h @@ -1,61 +1,61 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ -#ifndef VTKOVERLAY3D_H -#define VTKOVERLAY3D_H +#ifndef VTKAnnotation3D_H +#define VTKAnnotation3D_H -#include "mitkVtkOverlay.h" -#include +#include "mitkVtkAnnotation.h" +#include #include namespace mitk { /** - * @brief The VtkOverlay3D class is the basis for all VTK based Overlays which create + * @brief The VtkAnnotation3D class is the basis for all VTK based Annotation which create * any 3D element as a vtkProp that will be drawn on the renderer. */ - class MITKCORE_EXPORT VtkOverlay3D : public VtkOverlay + class MITKANNOTATION_EXPORT VtkAnnotation3D : public VtkAnnotation { public: - void SetPosition3D(const Point3D &position3D, mitk::BaseRenderer *renderer = NULL); + void SetPosition3D(const Point3D &position3D); - Point3D GetPosition3D(mitk::BaseRenderer *renderer = NULL) const; + Point3D GetPosition3D() const; - void SetOffsetVector(const Point3D &OffsetVector, mitk::BaseRenderer *renderer = NULL); + void SetOffsetVector(const Point3D &OffsetVector); - Point3D GetOffsetVector(mitk::BaseRenderer *renderer = NULL) const; + Point3D GetOffsetVector() const; - mitkClassMacro(VtkOverlay3D, VtkOverlay); + mitkClassMacro(VtkAnnotation3D, VtkAnnotation); protected: - virtual void UpdateVtkOverlay(BaseRenderer *renderer) override = 0; + virtual void UpdateVtkAnnotation(BaseRenderer *renderer) override = 0; /** \brief explicit constructor which disallows implicit conversions */ - explicit VtkOverlay3D(); + explicit VtkAnnotation3D(); /** \brief virtual destructor in order to derive from this class */ - virtual ~VtkOverlay3D(); + virtual ~VtkAnnotation3D(); private: /** \brief copy constructor */ - VtkOverlay3D(const VtkOverlay3D &); + VtkAnnotation3D(const VtkAnnotation3D &); /** \brief assignment operator */ - VtkOverlay3D &operator=(const VtkOverlay3D &); + VtkAnnotation3D &operator=(const VtkAnnotation3D &); }; } // namespace mitk -#endif // OVERLAY_H +#endif // Annotation_H diff --git a/Modules/Overlays/mitkVtkLogoRepresentation.h b/Modules/Annotation/include/mitkVtkLogoRepresentation.h similarity index 100% rename from Modules/Overlays/mitkVtkLogoRepresentation.h rename to Modules/Annotation/include/mitkVtkLogoRepresentation.h diff --git a/Modules/Overlays/mitkColorBarOverlay.cpp b/Modules/Annotation/src/mitkColorBarAnnotation.cpp similarity index 51% rename from Modules/Overlays/mitkColorBarOverlay.cpp rename to Modules/Annotation/src/mitkColorBarAnnotation.cpp index 20a2cf9653..6d854a7e34 100644 --- a/Modules/Overlays/mitkColorBarOverlay.cpp +++ b/Modules/Annotation/src/mitkColorBarAnnotation.cpp @@ -1,183 +1,190 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ -#include "mitkColorBarOverlay.h" +#include "mitkColorBarAnnotation.h" #include "mitkLookupTable.h" #include "mitkLookupTableProperty.h" #include -mitk::ColorBarOverlay::ColorBarOverlay() +mitk::ColorBarAnnotation::ColorBarAnnotation() { SetDrawAnnotations(true); SetDrawTickLabels(true); SetOrientationToVertical(); SetMaxNumberOfColors(100); SetNumberOfLabels(4); SetAnnotationTextScaling(false); SetLookupTable(NULL); } -mitk::ColorBarOverlay::~ColorBarOverlay() +mitk::ColorBarAnnotation::~ColorBarAnnotation() { + for (BaseRenderer *renderer : m_LSH.GetRegisteredBaseRenderer()) + { + if (renderer) + { + this->RemoveFromBaseRenderer(renderer); + } + } } -mitk::ColorBarOverlay::LocalStorage::~LocalStorage() +mitk::ColorBarAnnotation::LocalStorage::~LocalStorage() { } -mitk::ColorBarOverlay::LocalStorage::LocalStorage() +mitk::ColorBarAnnotation::LocalStorage::LocalStorage() { m_ScalarBarActor = vtkSmartPointer::New(); } -void mitk::ColorBarOverlay::UpdateVtkOverlay(mitk::BaseRenderer *renderer) +void mitk::ColorBarAnnotation::UpdateVtkAnnotation(mitk::BaseRenderer *renderer) { LocalStorage *ls = this->m_LSH.GetLocalStorage(renderer); if (ls->IsGenerateDataRequired(renderer, this)) { ls->m_ScalarBarActor->SetDrawAnnotations(this->GetDrawAnnotations()); ls->m_ScalarBarActor->SetLookupTable(this->GetLookupTable()); ls->m_ScalarBarActor->SetOrientation(this->GetOrientation()); ls->m_ScalarBarActor->SetDrawTickLabels(this->GetDrawTickLabels()); ls->m_ScalarBarActor->SetMaximumNumberOfColors(this->GetMaxNumberOfColors()); ls->m_ScalarBarActor->SetNumberOfLabels(this->GetNumberOfLabels()); ls->m_ScalarBarActor->SetAnnotationTextScaling(this->GetAnnotationTextScaling()); // manually set position so there is no overlap with mitk logo in 3d renderwindow if (this->GetOrientation() == 1) { ls->m_ScalarBarActor->SetPosition(0.80, 0.15); ls->m_ScalarBarActor->SetWidth(0.15); ls->m_ScalarBarActor->SetHeight(0.85); } else { ls->m_ScalarBarActor->SetPosition(0.03, 0.03); ls->m_ScalarBarActor->SetWidth(0.8); ls->m_ScalarBarActor->SetHeight(0.15); } } } -vtkProp *mitk::ColorBarOverlay::GetVtkProp(BaseRenderer *renderer) const +vtkProp *mitk::ColorBarAnnotation::GetVtkProp(BaseRenderer *renderer) const { LocalStorage *ls = this->m_LSH.GetLocalStorage(renderer); return ls->m_ScalarBarActor; } -void mitk::ColorBarOverlay::SetDrawAnnotations(bool annotations) +void mitk::ColorBarAnnotation::SetDrawAnnotations(bool annotations) { - SetBoolProperty("ColorBarOverlay.DrawAnnotations", annotations); + SetBoolProperty("ColorBarAnnotation.DrawAnnotations", annotations); } -bool mitk::ColorBarOverlay::GetDrawAnnotations() const +bool mitk::ColorBarAnnotation::GetDrawAnnotations() const { bool annotations; - GetPropertyList()->GetBoolProperty("ColorBarOverlay.DrawAnnotations", annotations); + GetPropertyList()->GetBoolProperty("ColorBarAnnotation.DrawAnnotations", annotations); return annotations; } -void mitk::ColorBarOverlay::SetLookupTable(vtkSmartPointer table) +void mitk::ColorBarAnnotation::SetLookupTable(vtkSmartPointer table) { mitk::LookupTable::Pointer lut = mitk::LookupTable::New(); mitk::LookupTableProperty::Pointer prop = mitk::LookupTableProperty::New(lut); lut->SetVtkLookupTable(table); prop->SetLookupTable(lut); - SetProperty("ColorBarOverlay.LookupTable", prop.GetPointer()); + SetProperty("ColorBarAnnotation.LookupTable", prop.GetPointer()); } -vtkSmartPointer mitk::ColorBarOverlay::GetLookupTable() const +vtkSmartPointer mitk::ColorBarAnnotation::GetLookupTable() const { mitk::LookupTable::Pointer lut = mitk::LookupTable::New(); - lut = dynamic_cast(GetPropertyList()->GetProperty("ColorBarOverlay.LookupTable")) + lut = dynamic_cast(GetPropertyList()->GetProperty("ColorBarAnnotation.LookupTable")) ->GetLookupTable(); return lut->GetVtkLookupTable(); } -void mitk::ColorBarOverlay::SetOrientation(int orientation) +void mitk::ColorBarAnnotation::SetOrientation(int orientation) { - SetIntProperty("ColorBarOverlay.Orientation", orientation); + SetIntProperty("ColorBarAnnotation.Orientation", orientation); } -int mitk::ColorBarOverlay::GetOrientation() const +int mitk::ColorBarAnnotation::GetOrientation() const { int orientation; - GetPropertyList()->GetIntProperty("ColorBarOverlay.Orientation", orientation); + GetPropertyList()->GetIntProperty("ColorBarAnnotation.Orientation", orientation); return orientation; } -void mitk::ColorBarOverlay::SetDrawTickLabels(bool ticks) +void mitk::ColorBarAnnotation::SetDrawTickLabels(bool ticks) { - SetBoolProperty("ColorBarOverlay.DrawTicks", ticks); + SetBoolProperty("ColorBarAnnotation.DrawTicks", ticks); } -bool mitk::ColorBarOverlay::GetDrawTickLabels() const +bool mitk::ColorBarAnnotation::GetDrawTickLabels() const { bool ticks; - GetPropertyList()->GetBoolProperty("ColorBarOverlay.DrawTicks", ticks); + GetPropertyList()->GetBoolProperty("ColorBarAnnotation.DrawTicks", ticks); return ticks; } -void mitk::ColorBarOverlay::SetOrientationToHorizontal() +void mitk::ColorBarAnnotation::SetOrientationToHorizontal() { SetOrientation(0); } -void mitk::ColorBarOverlay::SetOrientationToVertical() +void mitk::ColorBarAnnotation::SetOrientationToVertical() { SetOrientation(1); } -void mitk::ColorBarOverlay::SetMaxNumberOfColors(int numberOfColors) +void mitk::ColorBarAnnotation::SetMaxNumberOfColors(int numberOfColors) { - SetIntProperty("ColorBarOverlay.MaximumNumberOfColors", numberOfColors); + SetIntProperty("ColorBarAnnotation.MaximumNumberOfColors", numberOfColors); } -int mitk::ColorBarOverlay::GetMaxNumberOfColors() const +int mitk::ColorBarAnnotation::GetMaxNumberOfColors() const { int numberOfColors; - GetPropertyList()->GetIntProperty("ColorBarOverlay.MaximumNumberOfColors", numberOfColors); + GetPropertyList()->GetIntProperty("ColorBarAnnotation.MaximumNumberOfColors", numberOfColors); return numberOfColors; } -void mitk::ColorBarOverlay::SetNumberOfLabels(int numberOfLabels) +void mitk::ColorBarAnnotation::SetNumberOfLabels(int numberOfLabels) { - SetIntProperty("ColorBarOverlay.NumberOfLabels", numberOfLabels); + SetIntProperty("ColorBarAnnotation.NumberOfLabels", numberOfLabels); } -int mitk::ColorBarOverlay::GetNumberOfLabels() const +int mitk::ColorBarAnnotation::GetNumberOfLabels() const { int numberOfLabels; - GetPropertyList()->GetIntProperty("ColorBarOverlay.NumberOfLabels", numberOfLabels); + GetPropertyList()->GetIntProperty("ColorBarAnnotation.NumberOfLabels", numberOfLabels); return numberOfLabels; } -void mitk::ColorBarOverlay::SetAnnotationTextScaling(bool scale) +void mitk::ColorBarAnnotation::SetAnnotationTextScaling(bool scale) { - SetBoolProperty("ColorBarOverlay.ScaleAnnotationText", scale); + SetBoolProperty("ColorBarAnnotation.ScaleAnnotationText", scale); } -bool mitk::ColorBarOverlay::GetAnnotationTextScaling() const +bool mitk::ColorBarAnnotation::GetAnnotationTextScaling() const { bool scale; - GetPropertyList()->GetBoolProperty("ColorBarOverlay.ScaleAnnotationText", scale); + GetPropertyList()->GetBoolProperty("ColorBarAnnotation.ScaleAnnotationText", scale); return scale; } diff --git a/Modules/Overlays/mitkLabelOverlay3D.cpp b/Modules/Annotation/src/mitkLabelAnnotation3D.cpp similarity index 73% rename from Modules/Overlays/mitkLabelOverlay3D.cpp rename to Modules/Annotation/src/mitkLabelAnnotation3D.cpp index 68882570fa..f3c0bb0ff7 100644 --- a/Modules/Overlays/mitkLabelOverlay3D.cpp +++ b/Modules/Annotation/src/mitkLabelAnnotation3D.cpp @@ -1,163 +1,170 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ -#include "mitkLabelOverlay3D.h" +#include "mitkLabelAnnotation3D.h" #include #include #include #include #include #include #include #include #include #include #include -mitk::LabelOverlay3D::LabelOverlay3D() : m_PointSetModifiedObserverTag(0) +mitk::LabelAnnotation3D::LabelAnnotation3D() : m_PointSetModifiedObserverTag(0) { } -mitk::LabelOverlay3D::~LabelOverlay3D() +mitk::LabelAnnotation3D::~LabelAnnotation3D() { if (m_LabelCoordinates.IsNotNull()) m_LabelCoordinates->RemoveObserver(m_PointSetModifiedObserverTag); + for (BaseRenderer *renderer : m_LSH.GetRegisteredBaseRenderer()) + { + if (renderer) + { + this->RemoveFromBaseRenderer(renderer); + } + } } -mitk::LabelOverlay3D::LocalStorage::~LocalStorage() +mitk::LabelAnnotation3D::LocalStorage::~LocalStorage() { } -mitk::LabelOverlay3D::LocalStorage::LocalStorage() +mitk::LabelAnnotation3D::LocalStorage::LocalStorage() { m_Points = vtkSmartPointer::New(); // Add label array. m_Labels = vtkSmartPointer::New(); m_Labels->SetNumberOfValues(0); m_Labels->SetName("labels"); // Add priority array. m_Sizes = vtkSmartPointer::New(); m_Sizes->SetNumberOfValues(0); m_Sizes->SetName("sizes"); m_Points->GetPointData()->AddArray(m_Sizes); m_Points->GetPointData()->AddArray(m_Labels); m_PointSetToLabelHierarchyFilter = vtkSmartPointer::New(); m_PointSetToLabelHierarchyFilter->SetInputData(m_Points); m_PointSetToLabelHierarchyFilter->SetLabelArrayName("labels"); m_PointSetToLabelHierarchyFilter->SetPriorityArrayName("sizes"); m_PointSetToLabelHierarchyFilter->Update(); m_LabelMapper = vtkSmartPointer::New(); m_LabelMapper->SetInputConnection(m_PointSetToLabelHierarchyFilter->GetOutputPort()); m_LabelsActor = vtkSmartPointer::New(); m_LabelsActor->SetMapper(m_LabelMapper); } -void mitk::LabelOverlay3D::UpdateVtkOverlay(mitk::BaseRenderer *renderer) +void mitk::LabelAnnotation3D::UpdateVtkAnnotation(mitk::BaseRenderer *renderer) { if (m_LabelCoordinates.IsNull()) { MITK_WARN << "No pointset defined to print labels!"; return; } LocalStorage *ls = this->m_LSH.GetLocalStorage(renderer); if (ls->IsGenerateDataRequired(renderer, this)) { vtkSmartPointer points = vtkSmartPointer::New(); size_t pointsetsize = (size_t)m_LabelCoordinates->GetSize(); ls->m_Labels->SetNumberOfValues(pointsetsize); ls->m_Sizes->SetNumberOfValues(pointsetsize); for (size_t i = 0; i < pointsetsize; i++) { mitk::Point3D coordinate = m_LabelCoordinates->GetPoint(i); - points->InsertNextPoint(coordinate[0] + GetOffsetVector(renderer)[0], - coordinate[1] + GetOffsetVector(renderer)[1], - coordinate[2] + GetOffsetVector(renderer)[2]); + points->InsertNextPoint(coordinate[0] + GetOffsetVector()[0], + coordinate[1] + GetOffsetVector()[1], + coordinate[2] + GetOffsetVector()[2]); if (m_LabelVector.size() > i) ls->m_Labels->SetValue(i, m_LabelVector[i]); else ls->m_Labels->SetValue(i, ""); if (m_PriorityVector.size() > i) ls->m_Sizes->SetValue(i, m_PriorityVector[i]); else ls->m_Sizes->SetValue(i, 1); } ls->m_Points->SetPoints(points); ls->m_PointSetToLabelHierarchyFilter->Update(); ls->m_LabelMapper->Update(); float color[3] = {1, 1, 1}; float opacity = 1.0; - GetColor(color, renderer); - GetOpacity(opacity, renderer); + GetColor(color); + GetOpacity(opacity); ls->m_LabelsActor->GetProperty()->SetColor(color[0], color[1], color[2]); ls->m_LabelsActor->GetProperty()->SetOpacity(opacity); ls->UpdateGenerateDataTime(); } } -vtkProp *mitk::LabelOverlay3D::GetVtkProp(BaseRenderer *renderer) const +vtkProp *mitk::LabelAnnotation3D::GetVtkProp(BaseRenderer *renderer) const { LocalStorage *ls = this->m_LSH.GetLocalStorage(renderer); return ls->m_LabelsActor; } -void mitk::LabelOverlay3D::SetLabelVector(const std::vector &LabelVector) +void mitk::LabelAnnotation3D::SetLabelVector(const std::vector &LabelVector) { m_LabelVector = LabelVector; this->Modified(); } -void mitk::LabelOverlay3D::SetPriorityVector(const std::vector &PriorityVector) +void mitk::LabelAnnotation3D::SetPriorityVector(const std::vector &PriorityVector) { m_PriorityVector = PriorityVector; this->Modified(); } -void mitk::LabelOverlay3D::SetLabelCoordinates(mitk::PointSet::Pointer LabelCoordinates) +void mitk::LabelAnnotation3D::SetLabelCoordinates(mitk::PointSet::Pointer LabelCoordinates) { if (m_LabelCoordinates.IsNotNull()) { m_LabelCoordinates->RemoveObserver(m_PointSetModifiedObserverTag); m_PointSetModifiedObserverTag = 0; m_LabelCoordinates = NULL; } if (LabelCoordinates.IsNull()) { return; } m_LabelCoordinates = LabelCoordinates; - itk::MemberCommand::Pointer _PropertyListModifiedCommand = - itk::MemberCommand::New(); - _PropertyListModifiedCommand->SetCallbackFunction(this, &mitk::LabelOverlay3D::PointSetModified); + itk::MemberCommand::Pointer _PropertyListModifiedCommand = + itk::MemberCommand::New(); + _PropertyListModifiedCommand->SetCallbackFunction(this, &mitk::LabelAnnotation3D::PointSetModified); m_PointSetModifiedObserverTag = m_LabelCoordinates->AddObserver(itk::ModifiedEvent(), _PropertyListModifiedCommand); this->Modified(); } -void mitk::LabelOverlay3D::PointSetModified(const itk::Object * /*caller*/, const itk::EventObject &) +void mitk::LabelAnnotation3D::PointSetModified(const itk::Object * /*caller*/, const itk::EventObject &) { this->Modified(); } diff --git a/Modules/Annotation/src/mitkLayoutAnnotationRenderer.cpp b/Modules/Annotation/src/mitkLayoutAnnotationRenderer.cpp new file mode 100644 index 0000000000..8fa1049f9e --- /dev/null +++ b/Modules/Annotation/src/mitkLayoutAnnotationRenderer.cpp @@ -0,0 +1,346 @@ +/*=================================================================== + +The Medical Imaging Interaction Toolkit (MITK) + +Copyright (c) German Cancer Research Center, +Division of Medical and Biological Informatics. +All rights reserved. + +This software is distributed WITHOUT ANY WARRANTY; without +even the implied warranty of MERCHANTABILITY or FITNESS FOR +A PARTICULAR PURPOSE. + +See LICENSE.txt or http://www.mitk.org for details. + +===================================================================*/ + +#include "mitkLayoutAnnotationRenderer.h" +#include "mitkBaseRenderer.h" + +#include "mitkAnnotationUtils.h" +#include "mitkEnumerationProperty.h" +#include + +namespace mitk +{ + const std::string LayoutAnnotationRenderer::ANNOTATIONRENDERER_ID = "LayoutAnnotationRenderer"; + + const std::string LayoutAnnotationRenderer::PROP_LAYOUT = "Layout"; + const std::string LayoutAnnotationRenderer::PROP_LAYOUT_PRIORITY = PROP_LAYOUT + ".priority"; + const std::string LayoutAnnotationRenderer::PROP_LAYOUT_ALIGNMENT = PROP_LAYOUT + ".alignment"; + const std::string LayoutAnnotationRenderer::PROP_LAYOUT_MARGIN = PROP_LAYOUT + ".margin"; + + void LayoutAnnotationRenderer::SetMargin2D(Annotation *Annotation, const Point2D &OffsetVector) + { + mitk::Point2dProperty::Pointer OffsetVectorProperty = mitk::Point2dProperty::New(OffsetVector); + Annotation->SetProperty(PROP_LAYOUT_MARGIN, OffsetVectorProperty.GetPointer()); + } + + Point2D LayoutAnnotationRenderer::GetMargin2D(Annotation *Annotation) + { + mitk::Point2D OffsetVector; + OffsetVector.Fill(0); + Annotation->GetPropertyValue(PROP_LAYOUT_MARGIN, OffsetVector); + return OffsetVector; + } + + LayoutAnnotationRenderer::LayoutAnnotationRenderer(const std::string &rendererId) + : AbstractAnnotationRenderer(rendererId, LayoutAnnotationRenderer::ANNOTATIONRENDERER_ID) + { + } + + void LayoutAnnotationRenderer::AddAlignmentProperty(Annotation *Annotation, + Alignment activeAlignment, + Point2D margin, + int priority) + { + EnumerationProperty::Pointer alignmentProperty(mitk::EnumerationProperty::New()); + alignmentProperty->AddEnum("TopLeft", TopLeft); + alignmentProperty->AddEnum("Top", Top); + alignmentProperty->AddEnum("TopRight", TopRight); + alignmentProperty->AddEnum("BottomLeft ", BottomLeft); + alignmentProperty->AddEnum("Bottom", Bottom); + alignmentProperty->AddEnum("BottomRight", BottomRight); + alignmentProperty->AddEnum("Left", Left); + alignmentProperty->AddEnum("Right", Right); + alignmentProperty->SetValue(activeAlignment); + Annotation->AddProperty(PROP_LAYOUT_ALIGNMENT, alignmentProperty.GetPointer()); + Annotation->SetIntProperty(PROP_LAYOUT_PRIORITY, priority); + SetMargin2D(Annotation, margin); + } + + void LayoutAnnotationRenderer::OnAnnotationRenderersChanged() + { + if (!this->GetCurrentBaseRenderer()) + return; + m_AnnotationContainerMap.clear(); + for (Annotation *annotation : this->GetServices()) + { + if (!annotation) + continue; + BaseProperty *prop = annotation->GetProperty(PROP_LAYOUT_ALIGNMENT); + EnumerationProperty *enumProb = dynamic_cast(prop); + Alignment currentAlignment = TopLeft; + Point2D margin; + margin.Fill(5); + int priority = -1; + annotation->GetIntProperty(PROP_LAYOUT_PRIORITY, priority); + if (!enumProb) + { + AddAlignmentProperty(annotation, currentAlignment, margin, priority); + } + else + { // TODO19786 insert + currentAlignment = static_cast(enumProb->GetValueAsId()); + } + AnnotationRankedMap &AnnotationVec = m_AnnotationContainerMap[currentAlignment]; + if (!AnnotationVec.empty() && priority < 0) + { + int max = AnnotationVec.rbegin()->first; + if (max < 100) + priority = 100; + else + priority = max + 1; + } + AnnotationVec.insert(std::pair(priority, annotation)); + } + this->PrepareLayout(); + } + + LayoutAnnotationRenderer::~LayoutAnnotationRenderer() {} + const std::string LayoutAnnotationRenderer::GetID() const { return ANNOTATIONRENDERER_ID; } + LayoutAnnotationRenderer *LayoutAnnotationRenderer::GetAnnotationRenderer(const std::string &rendererID) + { + LayoutAnnotationRenderer *result = nullptr; + AbstractAnnotationRenderer *registeredService = + AnnotationUtils::GetAnnotationRenderer(ANNOTATIONRENDERER_ID, rendererID); + if (registeredService) + result = dynamic_cast(registeredService); + if (!result) + { + result = new LayoutAnnotationRenderer(rendererID); + AnnotationUtils::RegisterAnnotationRenderer(result); + } + return result; + } + + void LayoutAnnotationRenderer::OnRenderWindowModified() { PrepareLayout(); } + void LayoutAnnotationRenderer::AddAnnotation(Annotation *Annotation, + const std::string &rendererID, + Alignment alignment, + double marginX, + double marginY, + int priority) + { + GetAnnotationRenderer(rendererID); + us::ServiceProperties props; + props[Annotation::US_PROPKEY_AR_ID] = ANNOTATIONRENDERER_ID; + props[Annotation::US_PROPKEY_RENDERER_ID] = rendererID; + Annotation->RegisterAsMicroservice(props); + Point2D margin; + margin[0] = marginX; + margin[1] = marginY; + AddAlignmentProperty(Annotation, alignment, margin, priority); + } + + void LayoutAnnotationRenderer::AddAnnotation( + Annotation *Annotation, BaseRenderer *renderer, Alignment alignment, double marginX, double marginY, int priority) + { + AddAnnotation(Annotation, renderer->GetName(), alignment, marginX, marginY, priority); + } + + void LayoutAnnotationRenderer::PrepareLayout() + { + if (!this->GetCurrentBaseRenderer()) + return; + int *size = this->GetCurrentBaseRenderer()->GetVtkRenderer()->GetSize(); + PrepareTopLeftLayout(size); + PrepareTopLayout(size); + PrepareTopRightLayout(size); + PrepareBottomLeftLayout(size); + PrepareBottomLayout(size); + PrepareBottomRightLayout(size); + PrepareLeftLayout(size); + PrepareRightLayout(size); + } + void LayoutAnnotationRenderer::PrepareTopLeftLayout(int *displaySize) + { + double posX, posY; + Point2D margin; + posX = 0; + posY = displaySize[1]; + mitk::Annotation::Bounds bounds; + AnnotationRankedMap &AnnotationMap = m_AnnotationContainerMap[TopLeft]; + for (auto it = AnnotationMap.cbegin(); it != AnnotationMap.cend(); ++it) + { + Annotation *Annotation = it->second; + margin = GetMargin2D(Annotation); + bounds = Annotation->GetBoundsOnDisplay(this->GetCurrentBaseRenderer()); + + posY -= bounds.Size[1] + margin[1]; + bounds.Position[0] = posX + margin[0]; + bounds.Position[1] = posY; + Annotation->SetBoundsOnDisplay(this->GetCurrentBaseRenderer(), bounds); + } + } + void LayoutAnnotationRenderer::PrepareTopLayout(int *displaySize) + { + double posX, posY; + Point2D margin; + posX = 0; + posY = displaySize[1]; + mitk::Annotation::Bounds bounds; + AnnotationRankedMap &AnnotationMap = m_AnnotationContainerMap[Top]; + for (auto it = AnnotationMap.cbegin(); it != AnnotationMap.cend(); ++it) + { + Annotation *Annotation = it->second; + margin = GetMargin2D(Annotation); + bounds = Annotation->GetBoundsOnDisplay(this->GetCurrentBaseRenderer()); + + posX = displaySize[0] / 2 - bounds.Size[0] / 2; + posY -= bounds.Size[1] + margin[1]; + bounds.Position[0] = posX; + bounds.Position[1] = posY; + Annotation->SetBoundsOnDisplay(this->GetCurrentBaseRenderer(), bounds); + } + } + void LayoutAnnotationRenderer::PrepareTopRightLayout(int *displaySize) + { + double posX, posY; + Point2D margin; + posX = 0; + posY = displaySize[1]; + mitk::Annotation::Bounds bounds; + AnnotationRankedMap &AnnotationMap = m_AnnotationContainerMap[TopRight]; + for (auto it = AnnotationMap.cbegin(); it != AnnotationMap.cend(); ++it) + { + Annotation *Annotation = it->second; + margin = GetMargin2D(Annotation); + bounds = Annotation->GetBoundsOnDisplay(this->GetCurrentBaseRenderer()); + + posX = displaySize[0] - (bounds.Size[0] + margin[0]); + posY -= bounds.Size[1] + margin[1]; + bounds.Position[0] = posX; + bounds.Position[1] = posY; + Annotation->SetBoundsOnDisplay(this->GetCurrentBaseRenderer(), bounds); + } + } + + void LayoutAnnotationRenderer::PrepareRightLayout(int *displaySize) + { + double posY; + Point2D margin; + double height = GetHeight(m_AnnotationContainerMap[Right], GetCurrentBaseRenderer()); + posY = (height / 2.0 + displaySize[1]) / 2.0; + mitk::Annotation::Bounds bounds; + AnnotationRankedMap &AnnotationMap = m_AnnotationContainerMap[Right]; + for (auto it = AnnotationMap.cbegin(); it != AnnotationMap.cend(); ++it) + { + Annotation *Annotation = it->second; + margin = GetMargin2D(Annotation); + bounds = Annotation->GetBoundsOnDisplay(this->GetCurrentBaseRenderer()); + + posY -= bounds.Size[1] + margin[1]; + bounds.Position[0] = displaySize[0] - (bounds.Size[0] + margin[0]); + bounds.Position[1] = posY + margin[1]; + Annotation->SetBoundsOnDisplay(this->GetCurrentBaseRenderer(), bounds); + } + } + + void LayoutAnnotationRenderer::PrepareLeftLayout(int *displaySize) + { + double posY; + Point2D margin; + double height = GetHeight(m_AnnotationContainerMap[Left], GetCurrentBaseRenderer()); + posY = (height / 2.0 + displaySize[1]) / 2.0; + mitk::Annotation::Bounds bounds; + AnnotationRankedMap &AnnotationMap = m_AnnotationContainerMap[Left]; + for (auto it = AnnotationMap.cbegin(); it != AnnotationMap.cend(); ++it) + { + Annotation *Annotation = it->second; + margin = GetMargin2D(Annotation); + bounds = Annotation->GetBoundsOnDisplay(this->GetCurrentBaseRenderer()); + + posY -= bounds.Size[1] + margin[1]; + bounds.Position[0] = margin[0]; + bounds.Position[1] = posY; + Annotation->SetBoundsOnDisplay(this->GetCurrentBaseRenderer(), bounds); + } + } + + void LayoutAnnotationRenderer::PrepareBottomLeftLayout(int * /*displaySize*/) + { + double posX, posY; + Point2D margin; + posX = 0; + posY = 0; + mitk::Annotation::Bounds bounds; + AnnotationRankedMap &AnnotationMap = m_AnnotationContainerMap[BottomLeft]; + for (auto it = AnnotationMap.cbegin(); it != AnnotationMap.cend(); ++it) + { + Annotation *Annotation = it->second; + margin = GetMargin2D(Annotation); + bounds = Annotation->GetBoundsOnDisplay(this->GetCurrentBaseRenderer()); + + bounds.Position[0] = posX + margin[0]; + bounds.Position[1] = posY + margin[1]; + Annotation->SetBoundsOnDisplay(this->GetCurrentBaseRenderer(), bounds); + posY += bounds.Size[1] + margin[1]; + } + } + void LayoutAnnotationRenderer::PrepareBottomLayout(int *displaySize) + { + double posX, posY; + Point2D margin; + posX = 0; + posY = 0; + mitk::Annotation::Bounds bounds; + AnnotationRankedMap &AnnotationMap = m_AnnotationContainerMap[Bottom]; + for (auto it = AnnotationMap.cbegin(); it != AnnotationMap.cend(); ++it) + { + Annotation *Annotation = it->second; + margin = GetMargin2D(Annotation); + bounds = Annotation->GetBoundsOnDisplay(this->GetCurrentBaseRenderer()); + + posX = displaySize[0] / 2 - bounds.Size[0] / 2; + bounds.Position[0] = posX; + bounds.Position[1] = posY + margin[1]; + Annotation->SetBoundsOnDisplay(this->GetCurrentBaseRenderer(), bounds); + posY += bounds.Size[1] + margin[1]; + } + } + void LayoutAnnotationRenderer::PrepareBottomRightLayout(int *displaySize) + { + double posX, posY; + Point2D margin; + posX = 0; + posY = 0; + mitk::Annotation::Bounds bounds; + AnnotationRankedMap &AnnotationMap = m_AnnotationContainerMap[BottomRight]; + for (auto it = AnnotationMap.cbegin(); it != AnnotationMap.cend(); ++it) + { + Annotation *Annotation = it->second; + margin = GetMargin2D(Annotation); + bounds = Annotation->GetBoundsOnDisplay(this->GetCurrentBaseRenderer()); + + posX = displaySize[0] - (bounds.Size[0] + margin[0]); + bounds.Position[0] = posX; + bounds.Position[1] = posY + margin[1]; + Annotation->SetBoundsOnDisplay(this->GetCurrentBaseRenderer(), bounds); + posY += bounds.Size[1] + margin[1]; + } + } + + double LayoutAnnotationRenderer::GetHeight(AnnotationRankedMap &annotations, BaseRenderer *renderer) + { + double height = 0; + for (auto it = annotations.cbegin(); it != annotations.cend(); ++it) + { + Annotation *annotation = it->second; + Annotation::Bounds bounds = annotation->GetBoundsOnDisplay(renderer); + height += bounds.Size[0]; + height += GetMargin2D(annotation)[0]; + } + return height; + } +} diff --git a/Modules/Overlays/mitkLogoOverlay.cpp b/Modules/Annotation/src/mitkLogoAnnotation.cpp similarity index 69% rename from Modules/Overlays/mitkLogoOverlay.cpp rename to Modules/Annotation/src/mitkLogoAnnotation.cpp index 3c5d6ae241..d27d5b96ba 100644 --- a/Modules/Overlays/mitkLogoOverlay.cpp +++ b/Modules/Annotation/src/mitkLogoAnnotation.cpp @@ -1,196 +1,204 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ -#include "mitkLogoOverlay.h" +#include "mitkLogoAnnotation.h" #include "vtkUnicodeString.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include -mitk::LogoOverlay::LogoOverlay() +mitk::LogoAnnotation::LogoAnnotation() { m_readerFactory = vtkSmartPointer::New(); mitk::Point2D offset; offset.Fill(0.03); SetOffsetVector(offset); SetRelativeSize(0.2); + SetLogoImagePath("mbiLogo"); SetCornerPosition(3); m_VtkImageImport = vtkSmartPointer::New(); } -mitk::LogoOverlay::~LogoOverlay() +mitk::LogoAnnotation::~LogoAnnotation() { + for (BaseRenderer *renderer : m_LSH.GetRegisteredBaseRenderer()) + { + if (renderer) + { + this->RemoveFromBaseRenderer(renderer); + } + } } -mitk::LogoOverlay::LocalStorage::~LocalStorage() +mitk::LogoAnnotation::LocalStorage::~LocalStorage() { } -mitk::LogoOverlay::LocalStorage::LocalStorage() +mitk::LogoAnnotation::LocalStorage::LocalStorage() { m_LogoRep = vtkSmartPointer::New(); } -void mitk::LogoOverlay::UpdateVtkOverlay(mitk::BaseRenderer *renderer) +void mitk::LogoAnnotation::UpdateVtkAnnotation(mitk::BaseRenderer *renderer) { LocalStorage *ls = this->m_LSH.GetLocalStorage(renderer); if (ls->IsGenerateDataRequired(renderer, this)) { if (GetLogoImagePath().empty()) { ls->m_LogoRep->SetVisibility(0); return; } vtkImageReader2 *imageReader = m_readerFactory->CreateImageReader2(GetLogoImagePath().c_str()); if (imageReader) { imageReader->SetFileName(GetLogoImagePath().c_str()); imageReader->Update(); ls->m_LogoImage = imageReader->GetOutput(); imageReader->Delete(); } else { ls->m_LogoImage = CreateMbiLogo(); } ls->m_LogoRep->SetImage(ls->m_LogoImage); ls->m_LogoRep->SetDragable(false); ls->m_LogoRep->SetMoving(false); ls->m_LogoRep->SetPickable(false); ls->m_LogoRep->SetShowBorder(true); ls->m_LogoRep->SetRenderer(renderer->GetVtkRenderer()); - float size = GetRelativeSize(renderer); + float size = GetRelativeSize(); ls->m_LogoRep->SetPosition2(size, size); - int corner = GetCornerPosition(renderer); + int corner = GetCornerPosition(); ls->m_LogoRep->SetCornerPosition(corner); - mitk::Point2D offset = GetOffsetVector(renderer); + mitk::Point2D offset = GetOffsetVector(); ls->m_LogoRep->SetPosition(offset[0], offset[1]); float opacity = 1.0; - GetOpacity(opacity, renderer); + GetOpacity(opacity); ls->m_LogoRep->GetImageProperty()->SetOpacity(opacity); ls->m_LogoRep->BuildRepresentation(); ls->UpdateGenerateDataTime(); } } -vtkImageData *mitk::LogoOverlay::CreateMbiLogo() +vtkImageData *mitk::LogoAnnotation::CreateMbiLogo() { m_VtkImageImport->SetDataScalarTypeToUnsignedChar(); m_VtkImageImport->SetNumberOfScalarComponents(mbiLogo_NumberOfScalars); m_VtkImageImport->SetWholeExtent(0, mbiLogo_Width - 1, 0, mbiLogo_Height - 1, 0, 1 - 1); m_VtkImageImport->SetDataExtentToWholeExtent(); char *ImageData; // flip mbi logo around y axis and change color order ImageData = new char[mbiLogo_Height * mbiLogo_Width * mbiLogo_NumberOfScalars]; unsigned int column, row; char *dest = ImageData; char *source = (char *)&mbiLogo_Data[0]; ; char r, g, b, a; for (column = 0; column < mbiLogo_Height; column++) for (row = 0; row < mbiLogo_Width; row++) { // change r with b b = *source++; g = *source++; r = *source++; a = *source++; *dest++ = r; *dest++ = g; *dest++ = b; *dest++ = a; } m_VtkImageImport->SetImportVoidPointer(ImageData); m_VtkImageImport->Modified(); m_VtkImageImport->Update(); return m_VtkImageImport->GetOutput(); } -void mitk::LogoOverlay::SetLogoImagePath(std::string path) +void mitk::LogoAnnotation::SetLogoImagePath(std::string path) { - SetStringProperty("Overlay.LogoImagePath", path.c_str()); + SetStringProperty("Annotation.LogoImagePath", path.c_str()); Modified(); } -std::string mitk::LogoOverlay::GetLogoImagePath() const +std::string mitk::LogoAnnotation::GetLogoImagePath() const { std::string path; - GetPropertyList()->GetStringProperty("Overlay.LogoImagePath", path); + GetPropertyList()->GetStringProperty("Annotation.LogoImagePath", path); return path; } -void mitk::LogoOverlay::SetOffsetVector(const Point2D &OffsetVector, mitk::BaseRenderer *renderer) +void mitk::LogoAnnotation::SetOffsetVector(const Point2D &OffsetVector) { mitk::Point2dProperty::Pointer OffsetVectorProperty = mitk::Point2dProperty::New(OffsetVector); - SetProperty("Overlay.OffsetVector", OffsetVectorProperty.GetPointer(), renderer); + SetProperty("Annotation.OffsetVector", OffsetVectorProperty.GetPointer()); Modified(); } -mitk::Point2D mitk::LogoOverlay::GetOffsetVector(mitk::BaseRenderer *renderer) const +mitk::Point2D mitk::LogoAnnotation::GetOffsetVector() const { mitk::Point2D OffsetVector; OffsetVector.Fill(0); - GetPropertyValue("Overlay.OffsetVector", OffsetVector, renderer); + GetPropertyValue("Annotation.OffsetVector", OffsetVector); return OffsetVector; } -void mitk::LogoOverlay::SetCornerPosition(const int &corner, mitk::BaseRenderer *renderer) +void mitk::LogoAnnotation::SetCornerPosition(const int &corner) { - SetIntProperty("Overlay.CornerPosition", corner, renderer); + SetIntProperty("Annotation.CornerPosition", corner); Modified(); } -int mitk::LogoOverlay::GetCornerPosition(mitk::BaseRenderer *renderer) const +int mitk::LogoAnnotation::GetCornerPosition() const { int corner = 0; - GetIntProperty("Overlay.CornerPosition", corner, renderer); + GetIntProperty("Annotation.CornerPosition", corner); return corner; } -void mitk::LogoOverlay::SetRelativeSize(const float &size, mitk::BaseRenderer *renderer) +void mitk::LogoAnnotation::SetRelativeSize(const float &size) { - SetFloatProperty("Overlay.RelativeSize", size, renderer); + SetFloatProperty("Annotation.RelativeSize", size); Modified(); } -float mitk::LogoOverlay::GetRelativeSize(mitk::BaseRenderer *renderer) const +float mitk::LogoAnnotation::GetRelativeSize() const { float size = 0; - GetFloatProperty("Overlay.RelativeSize", size, renderer); + GetFloatProperty("Annotation.RelativeSize", size); return size; } -vtkProp *mitk::LogoOverlay::GetVtkProp(BaseRenderer *renderer) const +vtkProp *mitk::LogoAnnotation::GetVtkProp(BaseRenderer *renderer) const { LocalStorage *ls = this->m_LSH.GetLocalStorage(renderer); return ls->m_LogoRep; } diff --git a/Modules/Annotation/src/mitkManualPlacementAnnotationRenderer.cpp b/Modules/Annotation/src/mitkManualPlacementAnnotationRenderer.cpp new file mode 100644 index 0000000000..14926d0e7d --- /dev/null +++ b/Modules/Annotation/src/mitkManualPlacementAnnotationRenderer.cpp @@ -0,0 +1,60 @@ +/*=================================================================== + +The Medical Imaging Interaction Toolkit (MITK) + +Copyright (c) German Cancer Research Center, +Division of Medical and Biological Informatics. +All rights reserved. + +This software is distributed WITHOUT ANY WARRANTY; without +even the implied warranty of MERCHANTABILITY or FITNESS FOR +A PARTICULAR PURPOSE. + +See LICENSE.txt or http://www.mitk.org for details. + +===================================================================*/ + +#include "mitkManualPlacementAnnotationRenderer.h" +#include "mitkBaseRenderer.h" + +#include "mitkAnnotationUtils.h" +#include + +namespace mitk +{ + const std::string ManualPlacementAnnotationRenderer::ANNOTATIONRENDERER_ID = "ManualPlacementAnnotationRenderer"; + + ManualPlacementAnnotationRenderer::ManualPlacementAnnotationRenderer(const std::string &rendererId) + : AbstractAnnotationRenderer(rendererId, ManualPlacementAnnotationRenderer::ANNOTATIONRENDERER_ID) + { + } + ManualPlacementAnnotationRenderer::~ManualPlacementAnnotationRenderer() {} + ManualPlacementAnnotationRenderer *ManualPlacementAnnotationRenderer::GetAnnotationRenderer(const std::string &rendererID) + { + ManualPlacementAnnotationRenderer *result = nullptr; + AbstractAnnotationRenderer *registeredService = + AnnotationUtils::GetAnnotationRenderer(ANNOTATIONRENDERER_ID, rendererID); + if (registeredService) + result = dynamic_cast(registeredService); + if (!result) + { + result = new ManualPlacementAnnotationRenderer(rendererID); + AnnotationUtils::RegisterAnnotationRenderer(result); + } + return result; + } + + void ManualPlacementAnnotationRenderer::AddAnnotation(Annotation *Annotation, const std::string &rendererID) + { + GetAnnotationRenderer(rendererID); // rename ?? + us::ServiceProperties props; + props[Annotation::US_PROPKEY_AR_ID] = ANNOTATIONRENDERER_ID; + props[Annotation::US_PROPKEY_RENDERER_ID] = rendererID; + Annotation->RegisterAsMicroservice(props); + } + + void ManualPlacementAnnotationRenderer::AddAnnotation(Annotation *Annotation, BaseRenderer *renderer) + { + AddAnnotation(Annotation, renderer->GetName()); + } +} diff --git a/Modules/Annotation/src/mitkScaleLegendAnnotation.cpp b/Modules/Annotation/src/mitkScaleLegendAnnotation.cpp new file mode 100644 index 0000000000..9e4926da1d --- /dev/null +++ b/Modules/Annotation/src/mitkScaleLegendAnnotation.cpp @@ -0,0 +1,216 @@ +/*=================================================================== + +The Medical Imaging Interaction Toolkit (MITK) + +Copyright (c) German Cancer Research Center, +Division of Medical and Biological Informatics. +All rights reserved. + +This software is distributed WITHOUT ANY WARRANTY; without +even the implied warranty of MERCHANTABILITY or FITNESS FOR +A PARTICULAR PURPOSE. + +See LICENSE.txt or http://www.mitk.org for details. + +===================================================================*/ + +#include "mitkScaleLegendAnnotation.h" +#include +#include +#include + +mitk::ScaleLegendAnnotation::ScaleLegendAnnotation() +{ + SetRightAxisVisibility(true); + SetLeftAxisVisibility(true); + SetTopAxisVisibility(true); + SetBottomAxisVisibility(true); + SetLegendVisibility(true); + SetRightBorderOffset(50); + SetLeftBorderOffset(50); + SetTopBorderOffset(30); + SetBottomBorderOffset(30); + SetCornerOffsetFactor(2.0); + SetFontFactor(1.0); +} + +mitk::ScaleLegendAnnotation::~ScaleLegendAnnotation() +{ + for (BaseRenderer *renderer : m_LSH.GetRegisteredBaseRenderer()) + { + if (renderer) + { + this->RemoveFromBaseRenderer(renderer); + } + } +} + +mitk::ScaleLegendAnnotation::LocalStorage::~LocalStorage() +{ +} + +mitk::ScaleLegendAnnotation::LocalStorage::LocalStorage() +{ + m_legendScaleActor = vtkSmartPointer::New(); +} + +void mitk::ScaleLegendAnnotation::UpdateVtkAnnotation(mitk::BaseRenderer *renderer) +{ + LocalStorage *ls = this->m_LSH.GetLocalStorage(renderer); + + if (ls->IsGenerateDataRequired(renderer, this)) + { + ls->m_legendScaleActor->SetRightAxisVisibility(this->GetRightAxisVisibility()); + ls->m_legendScaleActor->SetTopAxisVisibility(this->GetTopAxisVisibility()); + ls->m_legendScaleActor->SetLeftAxisVisibility(this->GetLeftAxisVisibility()); + ls->m_legendScaleActor->SetBottomAxisVisibility(this->GetBottomAxisVisibility()); + ls->m_legendScaleActor->SetLegendVisibility(this->GetLegendVisibility()); + ls->m_legendScaleActor->SetRightBorderOffset(this->GetRightBorderOffset()); + ls->m_legendScaleActor->SetLeftBorderOffset(this->GetLeftBorderOffset()); + ls->m_legendScaleActor->SetTopBorderOffset(this->GetTopBorderOffset()); + ls->m_legendScaleActor->SetBottomBorderOffset(this->GetBottomBorderOffset()); + ls->m_legendScaleActor->SetCornerOffsetFactor(this->GetCornerOffsetFactor()); + ls->m_legendScaleActor->GetLeftAxis()->SetFontFactor(this->GetFontFactor()); + ls->m_legendScaleActor->GetRightAxis()->SetFontFactor(this->GetFontFactor()); + ls->m_legendScaleActor->GetTopAxis()->SetFontFactor(this->GetFontFactor()); + ls->m_legendScaleActor->GetBottomAxis()->SetFontFactor(this->GetFontFactor()); + } +} + +vtkProp *mitk::ScaleLegendAnnotation::GetVtkProp(BaseRenderer *renderer) const +{ + LocalStorage *ls = this->m_LSH.GetLocalStorage(renderer); + return ls->m_legendScaleActor; +} + +void mitk::ScaleLegendAnnotation::SetRightAxisVisibility(bool visibility) +{ + SetBoolProperty("ScaleLegendAnnotation.RightAxisVisibility", visibility); +} + +bool mitk::ScaleLegendAnnotation::GetRightAxisVisibility() const +{ + bool visibility; + GetPropertyList()->GetBoolProperty("ScaleLegendAnnotation.RightAxisVisibility", visibility); + return visibility; +} + +void mitk::ScaleLegendAnnotation::SetLeftAxisVisibility(bool visibility) +{ + SetBoolProperty("ScaleLegendAnnotation.LeftAxisVisibility", visibility); +} + +bool mitk::ScaleLegendAnnotation::GetLeftAxisVisibility() const +{ + bool visibility; + GetPropertyList()->GetBoolProperty("ScaleLegendAnnotation.LeftAxisVisibility", visibility); + return visibility; +} + +void mitk::ScaleLegendAnnotation::SetTopAxisVisibility(bool visibility) +{ + SetBoolProperty("ScaleLegendAnnotation.TopAxisVisibility", visibility); +} + +bool mitk::ScaleLegendAnnotation::GetTopAxisVisibility() const +{ + bool visibility; + GetPropertyList()->GetBoolProperty("ScaleLegendAnnotation.TopAxisVisibility", visibility); + return visibility; +} + +void mitk::ScaleLegendAnnotation::SetBottomAxisVisibility(bool visibility) +{ + SetBoolProperty("ScaleLegendAnnotation.BottomAxisVisibility", visibility); +} + +bool mitk::ScaleLegendAnnotation::GetBottomAxisVisibility() const +{ + bool visibility; + GetPropertyList()->GetBoolProperty("ScaleLegendAnnotation.BottomAxisVisibility", visibility); + return visibility; +} + +void mitk::ScaleLegendAnnotation::SetLegendVisibility(bool visibility) +{ + SetBoolProperty("ScaleLegendAnnotation.SetLegendVisibility", visibility); +} + +bool mitk::ScaleLegendAnnotation::GetLegendVisibility() const +{ + bool visibility; + GetPropertyList()->GetBoolProperty("ScaleLegendAnnotation.SetLegendVisibility", visibility); + return visibility; +} + +void mitk::ScaleLegendAnnotation::SetRightBorderOffset(int offset) +{ + SetIntProperty("ScaleLegendAnnotation.RightBorderOffset", offset); +} + +int mitk::ScaleLegendAnnotation::GetRightBorderOffset() const +{ + int offset; + GetPropertyList()->GetIntProperty("ScaleLegendAnnotation.RightBorderOffset", offset); + return offset; +} + +void mitk::ScaleLegendAnnotation::SetLeftBorderOffset(int offset) +{ + SetIntProperty("ScaleLegendAnnotation.LeftBorderOffset", offset); +} + +int mitk::ScaleLegendAnnotation::GetLeftBorderOffset() const +{ + int offset; + GetPropertyList()->GetIntProperty("ScaleLegendAnnotation.LeftBorderOffset", offset); + return offset; +} + +void mitk::ScaleLegendAnnotation::SetTopBorderOffset(int offset) +{ + SetIntProperty("ScaleLegendAnnotation.TopBorderOffset", offset); +} + +int mitk::ScaleLegendAnnotation::GetTopBorderOffset() const +{ + int offset; + GetPropertyList()->GetIntProperty("ScaleLegendAnnotation.TopBorderOffset", offset); + return offset; +} + +void mitk::ScaleLegendAnnotation::SetBottomBorderOffset(int offset) +{ + SetIntProperty("ScaleLegendAnnotation.BottomBorderOffset", offset); +} + +int mitk::ScaleLegendAnnotation::GetBottomBorderOffset() const +{ + int offset; + GetPropertyList()->GetIntProperty("ScaleLegendAnnotation.BottomBorderOffset", offset); + return offset; +} + +void mitk::ScaleLegendAnnotation::SetCornerOffsetFactor(double offsetFactor) +{ + SetDoubleProperty("ScaleLegendAnnotation.CornerOffsetFactor", offsetFactor); +} + +double mitk::ScaleLegendAnnotation::GetCornerOffsetFactor() const +{ + double offsetFactor; + GetPropertyList()->GetDoubleProperty("ScaleLegendAnnotation.CornerOffsetFactor", offsetFactor); + return offsetFactor; +} + +void mitk::ScaleLegendAnnotation::SetFontFactor(double fontFactor) +{ + SetDoubleProperty("ScaleLegendAnnotation.FontFactor", fontFactor); +} + +double mitk::ScaleLegendAnnotation::GetFontFactor() const +{ + double offsetFactor; + GetPropertyList()->GetDoubleProperty("ScaleLegendAnnotation.FontFactor", offsetFactor); + return offsetFactor; +} diff --git a/Modules/Overlays/mitkTextOverlay2D.cpp b/Modules/Annotation/src/mitkTextAnnotation2D.cpp similarity index 78% rename from Modules/Overlays/mitkTextOverlay2D.cpp rename to Modules/Annotation/src/mitkTextAnnotation2D.cpp index b1807b2d5f..c7d9107b58 100644 --- a/Modules/Overlays/mitkTextOverlay2D.cpp +++ b/Modules/Annotation/src/mitkTextAnnotation2D.cpp @@ -1,152 +1,159 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ -#include "mitkTextOverlay2D.h" +#include "mitkTextAnnotation2D.h" #include "vtkUnicodeString.h" #include #include #include -mitk::TextOverlay2D::TextOverlay2D() +mitk::TextAnnotation2D::TextAnnotation2D() { mitk::Point2D position; position[0] = position[1] = 0; this->SetPosition2D(position); this->SetOffsetVector(position); this->SetText(""); this->SetFontSize(20); this->SetColor(1.0, 1.0, 1.0); this->SetStringProperty("font.family", "Arial"); this->SetBoolProperty("font.bold", false); this->SetBoolProperty("font.italic", false); this->SetBoolProperty("drawShadow", false); } -mitk::TextOverlay2D::~TextOverlay2D() +mitk::TextAnnotation2D::~TextAnnotation2D() { + for (BaseRenderer *renderer : m_LSH.GetRegisteredBaseRenderer()) + { + if (renderer) + { + this->RemoveFromBaseRenderer(renderer); + } + } } -mitk::Overlay::Bounds mitk::TextOverlay2D::GetBoundsOnDisplay(mitk::BaseRenderer *renderer) const +mitk::Annotation::Bounds mitk::TextAnnotation2D::GetBoundsOnDisplay(mitk::BaseRenderer *renderer) const { LocalStorage *ls = this->m_LSH.GetLocalStorage(renderer); - mitk::Overlay::Bounds bounds; + mitk::Annotation::Bounds bounds; bounds.Position = ls->m_TextActor->GetPosition(); double size[2]; ls->m_TextActor->GetSize(renderer->GetVtkRenderer(), size); bounds.Size[0] = size[0]; bounds.Size[1] = size[1]; return bounds; } -void mitk::TextOverlay2D::SetBoundsOnDisplay(mitk::BaseRenderer *renderer, const mitk::Overlay::Bounds &bounds) +void mitk::TextAnnotation2D::SetBoundsOnDisplay(mitk::BaseRenderer *renderer, const mitk::Annotation::Bounds &bounds) { LocalStorage *ls = this->m_LSH.GetLocalStorage(renderer); mitk::Point2D posT, posS; posT[0] = bounds.Position[0]; posT[1] = bounds.Position[1]; posS[0] = posT[0] + 1; posS[1] = posT[1] - 1; ls->m_TextActor->SetDisplayPosition(posT[0], posT[1]); ls->m_STextActor->SetDisplayPosition(posS[0], posS[1]); } -mitk::TextOverlay2D::LocalStorage::~LocalStorage() +mitk::TextAnnotation2D::LocalStorage::~LocalStorage() { } -mitk::TextOverlay2D::LocalStorage::LocalStorage() +mitk::TextAnnotation2D::LocalStorage::LocalStorage() { m_TextActor = vtkSmartPointer::New(); m_TextProp = vtkSmartPointer::New(); m_STextActor = vtkSmartPointer::New(); m_STextProp = vtkSmartPointer::New(); m_TextActor->SetTextProperty(m_TextProp); m_STextActor->SetTextProperty(m_STextProp); m_Assembly = vtkSmartPointer::New(); m_Assembly->AddPart(m_STextActor); m_Assembly->AddPart(m_TextActor); } -void mitk::TextOverlay2D::UpdateVtkOverlay2D(mitk::BaseRenderer *renderer) +void mitk::TextAnnotation2D::UpdateVtkAnnotation2D(mitk::BaseRenderer *renderer) { LocalStorage *ls = this->m_LSH.GetLocalStorage(renderer); if (ls->IsGenerateDataRequired(renderer, this)) { float color[3] = {0.0, 1.0, 0.0}; float opacity = 1.0; - GetColor(color, renderer); - GetOpacity(opacity, renderer); + GetColor(color); + GetOpacity(opacity); ls->m_TextProp->SetColor(color[0], color[1], color[2]); ls->m_STextProp->SetColor(0, 0, 0); ls->m_TextProp->SetFontSize(GetFontSize()); ls->m_TextProp->SetOpacity(opacity); ls->m_STextProp->SetFontSize(GetFontSize()); ls->m_STextProp->SetOpacity(opacity); std::string fontFamilyAsString; if (GetStringProperty("font.family", fontFamilyAsString) == false) { fontFamilyAsString = "Arial"; } ls->m_TextProp->SetFontFamilyAsString(fontFamilyAsString.c_str()); ls->m_STextProp->SetFontFamilyAsString(fontFamilyAsString.c_str()); bool boldFont(false); GetBoolProperty("font.bold", boldFont); ls->m_TextProp->SetBold(boldFont); ls->m_STextProp->SetBold(boldFont); bool italicFont(false); GetBoolProperty("font.italic", italicFont); ls->m_TextProp->SetBold(italicFont); ls->m_STextProp->SetBold(italicFont); bool drawShadow; GetBoolProperty("drawShadow", drawShadow); ls->m_TextProp->SetShadow(false); ls->m_STextProp->SetShadow(false); ls->m_STextActor->SetVisibility(drawShadow); ls->m_TextActor->SetInput(GetText().c_str()); ls->m_STextActor->SetInput(GetText().c_str()); mitk::Point2D posT, posS; - posT[0] = GetPosition2D(renderer)[0] + GetOffsetVector(renderer)[0]; - posT[1] = GetPosition2D(renderer)[1] + GetOffsetVector(renderer)[1]; + posT[0] = GetPosition2D()[0] + GetOffsetVector()[0]; + posT[1] = GetPosition2D()[1] + GetOffsetVector()[1]; posS[0] = posT[0] + 1; posS[1] = posT[1] - 1; ls->m_TextActor->SetDisplayPosition(posT[0], posT[1]); ls->m_STextActor->SetDisplayPosition(posS[0], posS[1]); ls->UpdateGenerateDataTime(); } } -vtkProp *mitk::TextOverlay2D::GetVtkProp(mitk::BaseRenderer *renderer) const +vtkProp *mitk::TextAnnotation2D::GetVtkProp(mitk::BaseRenderer *renderer) const { LocalStorage *ls = this->m_LSH.GetLocalStorage(renderer); return ls->m_Assembly; } -vtkActor2D *mitk::TextOverlay2D::GetVtkActor2D(BaseRenderer *renderer) const +vtkActor2D *mitk::TextAnnotation2D::GetVtkActor2D(BaseRenderer *renderer) const { LocalStorage *ls = this->m_LSH.GetLocalStorage(renderer); return ls->m_TextActor; } diff --git a/Modules/Overlays/mitkTextOverlay3D.cpp b/Modules/Annotation/src/mitkTextAnnotation3D.cpp similarity index 80% rename from Modules/Overlays/mitkTextOverlay3D.cpp rename to Modules/Annotation/src/mitkTextAnnotation3D.cpp index 71cdb11cae..1f4e571766 100644 --- a/Modules/Overlays/mitkTextOverlay3D.cpp +++ b/Modules/Annotation/src/mitkTextAnnotation3D.cpp @@ -1,105 +1,112 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ -#include "mitkTextOverlay3D.h" +#include "mitkTextAnnotation3D.h" #include #include #include #include #include #include #include #include -mitk::TextOverlay3D::TextOverlay3D() +mitk::TextAnnotation3D::TextAnnotation3D() { mitk::Point3D position; position.Fill(0); this->SetPosition3D(position); this->SetOffsetVector(position); this->SetText(""); this->SetFontSize(20); this->SetColor(1.0, 1.0, 1.0); } -mitk::TextOverlay3D::~TextOverlay3D() +mitk::TextAnnotation3D::~TextAnnotation3D() { + for (BaseRenderer *renderer : m_LSH.GetRegisteredBaseRenderer()) + { + if (renderer) + { + this->RemoveFromBaseRenderer(renderer); + } + } } -mitk::TextOverlay3D::LocalStorage::~LocalStorage() +mitk::TextAnnotation3D::LocalStorage::~LocalStorage() { } -mitk::TextOverlay3D::LocalStorage::LocalStorage() +mitk::TextAnnotation3D::LocalStorage::LocalStorage() { // Create some text m_textSource = vtkSmartPointer::New(); // Create a mapper vtkSmartPointer mapper = vtkSmartPointer::New(); mapper->SetInputConnection(m_textSource->GetOutputPort()); // Create a subclass of vtkActor: a vtkFollower that remains facing the camera m_follower = vtkSmartPointer::New(); m_follower->SetMapper(mapper); m_follower->GetProperty()->SetColor(1, 0, 0); // red m_follower->SetScale(1); } -void mitk::TextOverlay3D::UpdateVtkOverlay(mitk::BaseRenderer *renderer) +void mitk::TextAnnotation3D::UpdateVtkAnnotation(mitk::BaseRenderer *renderer) { LocalStorage *ls = this->m_LSH.GetLocalStorage(renderer); if (ls->IsGenerateDataRequired(renderer, this)) { - Point3D pos3d = GetPosition3D(renderer); + Point3D pos3d = GetPosition3D(); vtkRenderer *vtkRender = renderer->GetVtkRenderer(); if (vtkRender) { vtkCamera *camera = vtkRender->GetActiveCamera(); ls->m_follower->SetCamera(camera); if (camera != nullptr) { // calculate the offset relative to the camera's view direction - Point3D offset = GetOffsetVector(renderer); + Point3D offset = GetOffsetVector(); Vector3D viewUp; camera->GetViewUp(viewUp.GetDataPointer()); Vector3D cameraDirection; camera->GetDirectionOfProjection(cameraDirection.GetDataPointer()); Vector3D viewRight; vtkMath::Cross(cameraDirection.GetDataPointer(), viewUp.GetDataPointer(), viewRight.GetDataPointer()); pos3d = pos3d + viewRight * offset[0] + viewUp * offset[1] + cameraDirection * offset[2]; } } ls->m_follower->SetPosition(pos3d.GetDataPointer()); ls->m_textSource->SetText(GetText().c_str()); float color[3] = {1, 1, 1}; float opacity = 1.0; - GetColor(color, renderer); - GetOpacity(opacity, renderer); + GetColor(color); + GetOpacity(opacity); ls->m_follower->GetProperty()->SetColor(color[0], color[1], color[2]); ls->m_follower->GetProperty()->SetOpacity(opacity); ls->m_follower->SetScale(this->GetFontSize()); ls->UpdateGenerateDataTime(); } } -vtkProp *mitk::TextOverlay3D::GetVtkProp(BaseRenderer *renderer) const +vtkProp *mitk::TextAnnotation3D::GetVtkProp(BaseRenderer *renderer) const { LocalStorage *ls = this->m_LSH.GetLocalStorage(renderer); return ls->m_follower; } diff --git a/Modules/Core/src/Rendering/mitkVtkOverlay.cpp b/Modules/Annotation/src/mitkVtkAnnotation.cpp similarity index 72% rename from Modules/Core/src/Rendering/mitkVtkOverlay.cpp rename to Modules/Annotation/src/mitkVtkAnnotation.cpp index 3ea51f2241..07b7ce68ea 100644 --- a/Modules/Core/src/Rendering/mitkVtkOverlay.cpp +++ b/Modules/Annotation/src/mitkVtkAnnotation.cpp @@ -1,87 +1,87 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ -#include "mitkVtkOverlay.h" +#include "mitkVtkAnnotation.h" #include #include -mitk::VtkOverlay::VtkOverlay() +mitk::VtkAnnotation::VtkAnnotation() { } -mitk::VtkOverlay::~VtkOverlay() +mitk::VtkAnnotation::~VtkAnnotation() { } -void mitk::VtkOverlay::Update(mitk::BaseRenderer *renderer) +void mitk::VtkAnnotation::Update(mitk::BaseRenderer *renderer) { vtkSmartPointer prop = GetVtkProp(renderer); - if (!IsVisible(renderer)) + if (!IsVisible()) { prop->SetVisibility(false); return; } else { prop->SetVisibility(true); - UpdateVtkOverlay(renderer); + UpdateVtkAnnotation(renderer); } } -void mitk::VtkOverlay::AddToBaseRenderer(mitk::BaseRenderer *renderer) +void mitk::VtkAnnotation::AddToBaseRenderer(mitk::BaseRenderer *renderer) { if (!renderer) return; AddToRenderer(renderer, renderer->GetVtkRenderer()); } -void mitk::VtkOverlay::AddToRenderer(mitk::BaseRenderer *renderer, vtkRenderer *vtkrenderer) +void mitk::VtkAnnotation::AddToRenderer(mitk::BaseRenderer *renderer, vtkRenderer *vtkrenderer) { if (!renderer || !vtkrenderer) return; Update(renderer); vtkSmartPointer vtkProp = GetVtkProp(renderer); if (renderer && vtkrenderer && !vtkrenderer->HasViewProp(vtkProp)) { vtkrenderer->AddViewProp(vtkProp); mitk::RenderingManager::GetInstance()->RequestUpdate(vtkrenderer->GetRenderWindow()); } } -void mitk::VtkOverlay::RemoveFromBaseRenderer(mitk::BaseRenderer *renderer) +void mitk::VtkAnnotation::RemoveFromBaseRenderer(mitk::BaseRenderer *renderer) { if (!renderer) return; RemoveFromRenderer(renderer, renderer->GetVtkRenderer()); } -void mitk::VtkOverlay::RemoveFromRenderer(mitk::BaseRenderer *renderer, vtkRenderer *vtkrenderer) +void mitk::VtkAnnotation::RemoveFromRenderer(mitk::BaseRenderer *renderer, vtkRenderer *vtkrenderer) { if (!renderer || !vtkrenderer) return; vtkSmartPointer vtkProp = GetVtkProp(renderer); if (vtkrenderer->HasViewProp(vtkProp)) { vtkrenderer->RemoveViewProp(vtkProp); mitk::RenderingManager::GetInstance()->RequestUpdate(vtkrenderer->GetRenderWindow()); } } -void mitk::VtkOverlay::Paint(BaseRenderer *renderer) +void mitk::VtkAnnotation::Paint(BaseRenderer *renderer) { GetVtkProp(renderer)->RenderOpaqueGeometry(renderer->GetVtkRenderer()); GetVtkProp(renderer)->RenderOverlay(renderer->GetVtkRenderer()); } diff --git a/Modules/Core/src/Rendering/mitkVtkOverlay2D.cpp b/Modules/Annotation/src/mitkVtkAnnotation2D.cpp similarity index 54% rename from Modules/Core/src/Rendering/mitkVtkOverlay2D.cpp rename to Modules/Annotation/src/mitkVtkAnnotation2D.cpp index 1f3fa7cbfc..ebbdc2b12e 100644 --- a/Modules/Core/src/Rendering/mitkVtkOverlay2D.cpp +++ b/Modules/Annotation/src/mitkVtkAnnotation2D.cpp @@ -1,90 +1,90 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ -#include "mitkVtkOverlay2D.h" +#include "mitkVtkAnnotation2D.h" #include #include #include -mitk::VtkOverlay2D::VtkOverlay2D() +mitk::VtkAnnotation2D::VtkAnnotation2D() { } -mitk::VtkOverlay2D::~VtkOverlay2D() +mitk::VtkAnnotation2D::~VtkAnnotation2D() { } -mitk::Overlay::Bounds mitk::VtkOverlay2D::GetBoundsOnDisplay(mitk::BaseRenderer *renderer) const +mitk::Annotation::Bounds mitk::VtkAnnotation2D::GetBoundsOnDisplay(mitk::BaseRenderer *renderer) const { - mitk::Overlay::Bounds bounds; + mitk::Annotation::Bounds bounds; vtkSmartPointer actor = GetVtkActor2D(renderer); bounds.Position = actor->GetPosition(); bounds.Size = actor->GetPosition2(); return bounds; } -void mitk::VtkOverlay2D::SetBoundsOnDisplay(mitk::BaseRenderer *renderer, const mitk::Overlay::Bounds &bounds) +void mitk::VtkAnnotation2D::SetBoundsOnDisplay(mitk::BaseRenderer *renderer, const mitk::Annotation::Bounds &bounds) { vtkSmartPointer actor = GetVtkActor2D(renderer); actor->SetDisplayPosition(bounds.Position[0], bounds.Position[1]); actor->SetWidth(bounds.Size[0]); actor->SetHeight(bounds.Size[1]); } -void mitk::VtkOverlay2D::UpdateVtkOverlay(mitk::BaseRenderer *renderer) +void mitk::VtkAnnotation2D::UpdateVtkAnnotation(mitk::BaseRenderer *renderer) { vtkActor2D *prop = GetVtkActor2D(renderer); float color[3] = {1, 1, 1}; float opacity = 1.0; - GetColor(color, renderer); - GetOpacity(opacity, renderer); + GetColor(color); + GetOpacity(opacity); prop->GetProperty()->SetColor(color[0], color[1], color[2]); prop->GetProperty()->SetOpacity(opacity); - UpdateVtkOverlay2D(renderer); + UpdateVtkAnnotation2D(renderer); } -void mitk::VtkOverlay2D::SetPosition2D(const Point2D &position2D, mitk::BaseRenderer *renderer) +void mitk::VtkAnnotation2D::SetPosition2D(const Point2D &position2D) { mitk::Point2dProperty::Pointer position2dProperty = mitk::Point2dProperty::New(position2D); - SetProperty("VtkOverlay2D.Position2D", position2dProperty.GetPointer(), renderer); + SetProperty("VtkAnnotation2D.Position2D", position2dProperty.GetPointer()); } -mitk::Point2D mitk::VtkOverlay2D::GetPosition2D(mitk::BaseRenderer *renderer) const +mitk::Point2D mitk::VtkAnnotation2D::GetPosition2D() const { mitk::Point2D position2D; position2D.Fill(0); - GetPropertyValue("VtkOverlay2D.Position2D", position2D, renderer); + GetPropertyValue("VtkAnnotation2D.Position2D", position2D); return position2D; } -void mitk::VtkOverlay2D::SetOffsetVector(const Point2D &OffsetVector, mitk::BaseRenderer *renderer) +void mitk::VtkAnnotation2D::SetOffsetVector(const Point2D &OffsetVector) { mitk::Point2dProperty::Pointer OffsetVectorProperty = mitk::Point2dProperty::New(OffsetVector); - SetProperty("VtkOverlay2D.OffsetVector", OffsetVectorProperty.GetPointer(), renderer); + SetProperty("VtkAnnotation2D.OffsetVector", OffsetVectorProperty.GetPointer()); } -mitk::Point2D mitk::VtkOverlay2D::GetOffsetVector(mitk::BaseRenderer *renderer) const +mitk::Point2D mitk::VtkAnnotation2D::GetOffsetVector() const { mitk::Point2D OffsetVector; OffsetVector.Fill(0); - GetPropertyValue("VtkOverlay2D.OffsetVector", OffsetVector, renderer); + GetPropertyValue("VtkAnnotation2D.OffsetVector", OffsetVector); return OffsetVector; } -vtkProp *mitk::VtkOverlay2D::GetVtkProp(mitk::BaseRenderer *renderer) const +vtkProp *mitk::VtkAnnotation2D::GetVtkProp(mitk::BaseRenderer *renderer) const { return GetVtkActor2D(renderer); } diff --git a/Modules/Core/src/Rendering/mitkVtkOverlay3D.cpp b/Modules/Annotation/src/mitkVtkAnnotation3D.cpp similarity index 54% rename from Modules/Core/src/Rendering/mitkVtkOverlay3D.cpp rename to Modules/Annotation/src/mitkVtkAnnotation3D.cpp index c4cabd1036..d6fc4d25a2 100644 --- a/Modules/Core/src/Rendering/mitkVtkOverlay3D.cpp +++ b/Modules/Annotation/src/mitkVtkAnnotation3D.cpp @@ -1,56 +1,56 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ -#include "mitkVtkOverlay3D.h" +#include "mitkVtkAnnotation3D.h" -mitk::VtkOverlay3D::VtkOverlay3D() +mitk::VtkAnnotation3D::VtkAnnotation3D() { mitk::Point3D offsetVector; offsetVector.Fill(0); SetOffsetVector(offsetVector); } -mitk::VtkOverlay3D::~VtkOverlay3D() +mitk::VtkAnnotation3D::~VtkAnnotation3D() { } -void mitk::VtkOverlay3D::SetPosition3D(const Point3D &position3D, mitk::BaseRenderer *renderer) +void mitk::VtkAnnotation3D::SetPosition3D(const Point3D &position3D) { mitk::Point3dProperty::Pointer position3dProperty = mitk::Point3dProperty::New(position3D); - SetProperty("VtkOverlay3D.Position3D", position3dProperty.GetPointer(), renderer); + SetProperty("VtkAnnotation3D.Position3D", position3dProperty.GetPointer()); } -mitk::Point3D mitk::VtkOverlay3D::GetPosition3D(mitk::BaseRenderer *renderer) const +mitk::Point3D mitk::VtkAnnotation3D::GetPosition3D() const { mitk::Point3D position3D; position3D.Fill(0); - GetPropertyValue("VtkOverlay3D.Position3D", position3D, renderer); + GetPropertyValue("VtkAnnotation3D.Position3D", position3D); return position3D; } -void mitk::VtkOverlay3D::SetOffsetVector(const Point3D &OffsetVector, mitk::BaseRenderer *renderer) +void mitk::VtkAnnotation3D::SetOffsetVector(const Point3D &OffsetVector) { mitk::Point3dProperty::Pointer OffsetVectorProperty = mitk::Point3dProperty::New(OffsetVector); - SetProperty("VtkOverlay3D.OffsetVector", OffsetVectorProperty.GetPointer(), renderer); + SetProperty("VtkAnnotation3D.OffsetVector", OffsetVectorProperty.GetPointer()); } -mitk::Point3D mitk::VtkOverlay3D::GetOffsetVector(mitk::BaseRenderer *renderer) const +mitk::Point3D mitk::VtkAnnotation3D::GetOffsetVector() const { mitk::Point3D OffsetVector; OffsetVector.Fill(0); - GetPropertyValue("VtkOverlay3D.OffsetVector", OffsetVector, renderer); + GetPropertyValue("VtkAnnotation3D.OffsetVector", OffsetVector); return OffsetVector; } diff --git a/Modules/Overlays/mitkVtkLogoRepresentation.cxx b/Modules/Annotation/src/mitkVtkLogoRepresentation.cxx similarity index 100% rename from Modules/Overlays/mitkVtkLogoRepresentation.cxx rename to Modules/Annotation/src/mitkVtkLogoRepresentation.cxx diff --git a/Modules/Annotation/test/CMakeLists.txt b/Modules/Annotation/test/CMakeLists.txt new file mode 100644 index 0000000000..153cd81e2e --- /dev/null +++ b/Modules/Annotation/test/CMakeLists.txt @@ -0,0 +1 @@ +MITK_CREATE_MODULE_TESTS() diff --git a/Modules/Annotation/test/files.cmake b/Modules/Annotation/test/files.cmake new file mode 100644 index 0000000000..8b6efdd163 --- /dev/null +++ b/Modules/Annotation/test/files.cmake @@ -0,0 +1,18 @@ + +set(MODULE_TESTS + mitkAnnotationTest.cpp +) + +if(MITK_ENABLE_RENDERING_TESTING) +set(MODULE_TESTS + ${MODULE_TESTS} + mitkManualPlacementAnnotationRendererTest.cpp + mitkColorBarAnnotationTest.cpp + mitkLabelAnnotation3DTest.cpp + mitkLogoAnnotationTest.cpp + mitkLayoutAnnotationRendererTest.cpp + mitkScaleLegendAnnotationTest.cpp + mitkTextAnnotation2DTest.cpp + mitkTextAnnotation3DTest.cpp +) +endif() diff --git a/Modules/Annotation/test/mitkAnnotationTest.cpp b/Modules/Annotation/test/mitkAnnotationTest.cpp new file mode 100644 index 0000000000..d59b7e2296 --- /dev/null +++ b/Modules/Annotation/test/mitkAnnotationTest.cpp @@ -0,0 +1,59 @@ +/*=================================================================== + +The Medical Imaging Interaction Toolkit (MITK) + +Copyright (c) German Cancer Research Center, +Division of Medical and Biological Informatics. +All rights reserved. + +This software is distributed WITHOUT ANY WARRANTY; without +even the implied warranty of MERCHANTABILITY or FITNESS FOR +A PARTICULAR PURPOSE. + +See LICENSE.txt or http://www.mitk.org for details. + +===================================================================*/ +#include +#include +#include +#include +#include +#include +#include + +#include "mitkManualPlacementAnnotationRenderer.h" +#include "mitkLayoutAnnotationRenderer.h" + +class mitkAnnotationTestSuite : public mitk::TestFixture +{ + CPPUNIT_TEST_SUITE(mitkAnnotationTestSuite); + MITK_TEST(AnnotationUtilsTest); + CPPUNIT_TEST_SUITE_END(); + +private: +public: + void setUp() override {} + void AnnotationUtilsTest() + { + mitk::ManualPlacementAnnotationRenderer *ap1_test1 = mitk::ManualPlacementAnnotationRenderer::GetAnnotationRenderer("test1"); + CPPUNIT_ASSERT_MESSAGE("Testing availability of ManualPlacementAnnotationRenderer service", ap1_test1); + mitk::ManualPlacementAnnotationRenderer *ap2_test1 = mitk::ManualPlacementAnnotationRenderer::GetAnnotationRenderer("test1"); + CPPUNIT_ASSERT_MESSAGE("Testing if ManualPlacementAnnotationRenderer of same kind stays avaliable", ap1_test1 == ap2_test1); + mitk::ManualPlacementAnnotationRenderer *ap1_test2 = mitk::ManualPlacementAnnotationRenderer::GetAnnotationRenderer("test2"); + CPPUNIT_ASSERT_MESSAGE("Testing if new instance can be created by using different ID", ap1_test2 != ap1_test1); + + mitk::LayoutAnnotationRenderer *ol1_test1 = mitk::LayoutAnnotationRenderer::GetAnnotationRenderer("test1"); + CPPUNIT_ASSERT_MESSAGE("Testing availability of LayoutAnnotationRenderer service", ol1_test1); + mitk::LayoutAnnotationRenderer *ol2_test1 = mitk::LayoutAnnotationRenderer::GetAnnotationRenderer("test1"); + CPPUNIT_ASSERT_MESSAGE("Testing if LayoutAnnotationRenderer of same kind stays avaliable", ol2_test1 == ol1_test1); + mitk::LayoutAnnotationRenderer *ol1_test2 = mitk::LayoutAnnotationRenderer::GetAnnotationRenderer("test2"); + CPPUNIT_ASSERT_MESSAGE("Testing if new instance can be created by using different ID", ol1_test2 != ol1_test1); + + CPPUNIT_ASSERT_MESSAGE( + "Testing if LayoutAnnotationRenderer and ManualPlacementAnnotationRenderer services are different", + (mitk::AbstractAnnotationRenderer *)ol1_test1 != (mitk::AbstractAnnotationRenderer *)ap1_test1); + } + + void AnnotationTest() {} +}; +MITK_TEST_SUITE_REGISTRATION(mitkAnnotation) diff --git a/Modules/Annotation/test/mitkColorBarAnnotationTest.cpp b/Modules/Annotation/test/mitkColorBarAnnotationTest.cpp new file mode 100644 index 0000000000..4c3ed07466 --- /dev/null +++ b/Modules/Annotation/test/mitkColorBarAnnotationTest.cpp @@ -0,0 +1,99 @@ +/*=================================================================== + +The Medical Imaging Interaction Toolkit (MITK) + +Copyright (c) German Cancer Research Center, +Division of Medical and Biological Informatics. +All rights reserved. + +This software is distributed WITHOUT ANY WARRANTY; without +even the implied warranty of MERCHANTABILITY or FITNESS FOR +A PARTICULAR PURPOSE. + +See LICENSE.txt or http://www.mitk.org for details. + +===================================================================*/ + +// MITK +#include + +#include +#include +#include +#include +#include + +class mitkColorBarAnnotationTestSuite : public mitk::TestFixture +{ + CPPUNIT_TEST_SUITE(mitkColorBarAnnotationTestSuite); + MITK_TEST(RenderColorBarAnnotation); + + CPPUNIT_TEST_SUITE_END(); + +private: + /** Members used inside the different test methods. All members are initialized via setUp().*/ + mitk::RenderingTestHelper m_RenderingTestHelper; + std::vector m_CommandlineArgs; + std::string m_PathToBall; + std::string m_PathToImage; + std::string m_ReferenceImagePath; + +public: + /** + * @brief mitkManualPlacementAnnotationRendererTestSuite Because the RenderingTestHelper does not have an + * empty default constructor, we need this constructor to initialize the helper with a + * resolution. + */ + mitkColorBarAnnotationTestSuite() : m_RenderingTestHelper(300, 300) {} + /** + * @brief Setup Initialize a fresh rendering test helper and a vector of strings + * to simulate commandline arguments for vtkTesting::Test. + */ + void setUp() + { + m_RenderingTestHelper = mitk::RenderingTestHelper(300, 300); + + m_PathToBall = GetTestDataFilePath("ball.stl"); + m_PathToImage = GetTestDataFilePath("Pic3D.nrrd"); + m_ReferenceImagePath = "RenderingTestData/ReferenceScreenshots/Annotation/"; + + // Build a command line for the vtkTesting::Test method. + // See VTK documentation and RenderingTestHelper for more information. + // Use the following command line option to save the difference image + // and the test image in some tmp folder + // m_CommandlineArgs.push_back("-T"); + // m_CommandlineArgs.push_back("/path/to/save/tmp/difference/images/"); + m_CommandlineArgs.push_back("-V"); + } + + void tearDown() {} + void RenderColorBarAnnotation() + { + mitk::DataNode::Pointer ballnode = mitk::DataNode::New(); + ballnode->SetData(mitk::IOUtil::Load(m_PathToBall)[0]); + m_RenderingTestHelper.AddNodeToStorage(ballnode); + + mitk::DataNode::Pointer imagenode = mitk::DataNode::New(); + imagenode->SetData(mitk::IOUtil::Load(m_PathToImage)[0]); + m_RenderingTestHelper.AddNodeToStorage(imagenode); + + std::string refImagePath = GetTestDataFilePath(m_ReferenceImagePath + "mitkColorBarAnnotation.png"); + + // reference screenshot for this test + m_CommandlineArgs.push_back(refImagePath); + // Convert vector of strings to argc/argv + mitk::RenderingTestHelper::ArgcHelperClass arg(m_CommandlineArgs); + m_RenderingTestHelper.SetViewDirection(mitk::SliceNavigationController::Sagittal); + + mitk::ColorBarAnnotation::Pointer colorbar = mitk::ColorBarAnnotation::New(); + + mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(m_RenderingTestHelper.GetVtkRenderWindow()); + mitk::ManualPlacementAnnotationRenderer::AddAnnotation(colorbar.GetPointer(), renderer); + + m_RenderingTestHelper.Render(); + m_RenderingTestHelper.SaveReferenceScreenShot(refImagePath); + m_RenderingTestHelper.SetAutomaticallyCloseRenderWindow(true); + CPPUNIT_ASSERT(m_RenderingTestHelper.CompareRenderWindowAgainstReference(arg.GetArgc(), arg.GetArgv()) == true); + } +}; +MITK_TEST_SUITE_REGISTRATION(mitkColorBarAnnotation) diff --git a/Modules/Annotation/test/mitkLabelAnnotation3DTest.cpp b/Modules/Annotation/test/mitkLabelAnnotation3DTest.cpp new file mode 100644 index 0000000000..7efcd56cf6 --- /dev/null +++ b/Modules/Annotation/test/mitkLabelAnnotation3DTest.cpp @@ -0,0 +1,169 @@ +/*=================================================================== + +The Medical Imaging Interaction Toolkit (MITK) + +Copyright (c) German Cancer Research Center, +Division of Medical and Biological Informatics. +All rights reserved. + +This software is distributed WITHOUT ANY WARRANTY; without +even the implied warranty of MERCHANTABILITY or FITNESS FOR +A PARTICULAR PURPOSE. + +See LICENSE.txt or http://www.mitk.org for details. + +===================================================================*/ + +// MITK +#include + +#include +#include +#include +#include +#include + +class mitkLabelAnnotation3DTestSuite : public mitk::TestFixture +{ + CPPUNIT_TEST_SUITE(mitkLabelAnnotation3DTestSuite); + MITK_TEST(Render2DAnnotation); + MITK_TEST(Render3DAnnotation); + + CPPUNIT_TEST_SUITE_END(); + +private: + /** Members used inside the different test methods. All members are initialized via setUp().*/ + mitk::RenderingTestHelper m_RenderingTestHelper; + std::vector m_CommandlineArgs; + std::string m_PathToBall; + std::string m_PathToImage; + std::string m_ReferenceImagePath; + +public: + /** + * @brief mitkManualPlacementAnnotationRendererTestSuite Because the RenderingTestHelper does not have an + * empty default constructor, we need this constructor to initialize the helper with a + * resolution. + */ + mitkLabelAnnotation3DTestSuite() : m_RenderingTestHelper(300, 300) {} + /** + * @brief Setup Initialize a fresh rendering test helper and a vector of strings + * to simulate commandline arguments for vtkTesting::Test. + */ + void setUp() + { + m_RenderingTestHelper = mitk::RenderingTestHelper(300, 300); + + m_PathToBall = GetTestDataFilePath("ball.stl"); + m_PathToImage = GetTestDataFilePath("Pic3D.nrrd"); + m_ReferenceImagePath = "RenderingTestData/ReferenceScreenshots/Annotation/"; + + // Build a command line for the vtkTesting::Test method. + // See VTK documentation and RenderingTestHelper for more information. + // Use the following command line option to save the difference image + // and the test image in some tmp folder + // m_CommandlineArgs.push_back("-T"); + // m_CommandlineArgs.push_back("/path/to/save/tmp/difference/images/"); + m_CommandlineArgs.push_back("-V"); + } + + void tearDown() {} + void Render2DAnnotation() + { + std::string refImagePath = GetTestDataFilePath(m_ReferenceImagePath + "mitkLabelAnnotation3D.png"); + // reference screenshot for this test + m_CommandlineArgs.push_back(refImagePath); + // Convert vector of strings to argc/argv + mitk::RenderingTestHelper::ArgcHelperClass arg(m_CommandlineArgs); + m_RenderingTestHelper.SetViewDirection(mitk::SliceNavigationController::Sagittal); + + mitk::PointSet::Pointer pointset = mitk::PointSet::New(); + mitk::LabelAnnotation3D::Pointer label3d = mitk::LabelAnnotation3D::New(); + mitk::Point3D offset; + offset[0] = .5; + offset[1] = .5; + offset[2] = .5; + + std::vector labels; + unsigned long idx = 0; + for (int i = -10; i < 10; i += 4) + { + for (int j = -10; j < 10; j += 4) + { + mitk::Point3D point; + point[0] = i; + point[1] = j; + point[2] = (i * j) / 10; + pointset->InsertPoint(idx++, point); + labels.push_back("test"); + } + } + + label3d->SetLabelCoordinates(pointset); + label3d->SetLabelVector(labels); + label3d->SetOffsetVector(offset); + + mitk::DataNode::Pointer datanode = mitk::DataNode::New(); + datanode->SetData(pointset); + datanode->SetName("pointSet"); + m_RenderingTestHelper.AddNodeToStorage(datanode); + + mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(m_RenderingTestHelper.GetVtkRenderWindow()); + mitk::ManualPlacementAnnotationRenderer::AddAnnotation(label3d.GetPointer(), renderer); + + m_RenderingTestHelper.Render(); + m_RenderingTestHelper.SaveReferenceScreenShot(refImagePath); + m_RenderingTestHelper.SetAutomaticallyCloseRenderWindow(true); + CPPUNIT_ASSERT(m_RenderingTestHelper.CompareRenderWindowAgainstReference(arg.GetArgc(), arg.GetArgv()) == true); + } + + void Render3DAnnotation() + { + std::string refImagePath = GetTestDataFilePath(m_ReferenceImagePath + "mitkLabelAnnotation3D.png"); + // reference screenshot for this test + m_CommandlineArgs.push_back(refImagePath); + // Convert vector of strings to argc/argv + mitk::RenderingTestHelper::ArgcHelperClass arg(m_CommandlineArgs); + m_RenderingTestHelper.SetMapperIDToRender3D(); + + mitk::PointSet::Pointer pointset = mitk::PointSet::New(); + mitk::LabelAnnotation3D::Pointer label3d = mitk::LabelAnnotation3D::New(); + mitk::Point3D offset; + offset[0] = .5; + offset[1] = .5; + offset[2] = .5; + + std::vector labels; + unsigned long idx = 0; + for (int i = -10; i < 10; i += 4) + { + for (int j = -10; j < 10; j += 4) + { + mitk::Point3D point; + point[0] = i; + point[1] = j; + point[2] = (i * j) / 10; + pointset->InsertPoint(idx++, point); + labels.push_back("test"); + } + } + + label3d->SetLabelCoordinates(pointset); + label3d->SetLabelVector(labels); + label3d->SetOffsetVector(offset); + + mitk::DataNode::Pointer datanode = mitk::DataNode::New(); + datanode->SetData(pointset); + datanode->SetName("pointSet"); + m_RenderingTestHelper.AddNodeToStorage(datanode); + + mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(m_RenderingTestHelper.GetVtkRenderWindow()); + mitk::ManualPlacementAnnotationRenderer::AddAnnotation(label3d.GetPointer(), renderer); + + m_RenderingTestHelper.Render(); + m_RenderingTestHelper.SaveReferenceScreenShot(refImagePath); + m_RenderingTestHelper.SetAutomaticallyCloseRenderWindow(true); + CPPUNIT_ASSERT(m_RenderingTestHelper.CompareRenderWindowAgainstReference(arg.GetArgc(), arg.GetArgv()) == true); + } +}; +MITK_TEST_SUITE_REGISTRATION(mitkLabelAnnotation3D) diff --git a/Modules/Annotation/test/mitkLayoutAnnotationRendererTest.cpp b/Modules/Annotation/test/mitkLayoutAnnotationRendererTest.cpp new file mode 100644 index 0000000000..68ff4bceb7 --- /dev/null +++ b/Modules/Annotation/test/mitkLayoutAnnotationRendererTest.cpp @@ -0,0 +1,162 @@ +/*=================================================================== + +The Medical Imaging Interaction Toolkit (MITK) + +Copyright (c) German Cancer Research Center, +Division of Medical and Biological Informatics. +All rights reserved. + +This software is distributed WITHOUT ANY WARRANTY; without +even the implied warranty of MERCHANTABILITY or FITNESS FOR +A PARTICULAR PURPOSE. + +See LICENSE.txt or http://www.mitk.org for details. + +===================================================================*/ + +// MITK +#include + +#include +#include +#include +#include +#include + +void createTextAnnotationWithLayouter(std::vector &Annotation, + mitk::LayoutAnnotationRenderer::Alignment align, + mitk::BaseRenderer *renderer, + int fontsize, + float red, + float green, + float blue, + int prio, + std::string text) +{ + // Create a textAnnotation2D + mitk::TextAnnotation2D::Pointer textAnnotation = mitk::TextAnnotation2D::New(); + + textAnnotation->SetText(text); + textAnnotation->SetFontSize(fontsize); + textAnnotation->SetColor(red, green, blue); + textAnnotation->SetOpacity(1); + + mitk::LayoutAnnotationRenderer::AddAnnotation(textAnnotation, renderer, align, 5, 5, prio); + Annotation.push_back(textAnnotation); +} + +class mitkLayoutAnnotationRendererTestSuite : public mitk::TestFixture +{ + CPPUNIT_TEST_SUITE(mitkLayoutAnnotationRendererTestSuite); + MITK_TEST(Render2DAnnotation); + + CPPUNIT_TEST_SUITE_END(); + +private: + /** Members used inside the different test methods. All members are initialized via setUp().*/ + mitk::RenderingTestHelper m_RenderingTestHelper; + std::vector m_CommandlineArgs; + std::string m_PathToBall; + std::string m_PathToImage; + std::string m_ReferenceImagePath; + +public: + /** + * @brief mitkManualPlacementAnnotationRendererTestSuite Because the RenderingTestHelper does not have an + * empty default constructor, we need this constructor to initialize the helper with a + * resolution. + */ + mitkLayoutAnnotationRendererTestSuite() : m_RenderingTestHelper(500, 500) {} + /** + * @brief Setup Initialize a fresh rendering test helper and a vector of strings + * to simulate commandline arguments for vtkTesting::Test. + */ + void setUp() + { + m_RenderingTestHelper = mitk::RenderingTestHelper(500, 500); + + m_PathToBall = GetTestDataFilePath("ball.stl"); + m_PathToImage = GetTestDataFilePath("Pic3D.nrrd"); + m_ReferenceImagePath = "RenderingTestData/ReferenceScreenshots/Annotation/"; + + // Build a command line for the vtkTesting::Test method. + // See VTK documentation and RenderingTestHelper for more information. + // Use the following command line option to save the difference image + // and the test image in some tmp folder + // m_CommandlineArgs.push_back("-T"); + // m_CommandlineArgs.push_back("/path/to/save/tmp/difference/images/"); + m_CommandlineArgs.push_back("-V"); + } + + void tearDown() {} + void Render2DAnnotation() + { + mitk::DataNode::Pointer ballnode = mitk::DataNode::New(); + ballnode->SetData(mitk::IOUtil::Load(m_PathToBall)[0]); + m_RenderingTestHelper.AddNodeToStorage(ballnode); + + mitk::DataNode::Pointer imagenode = mitk::DataNode::New(); + imagenode->SetData(mitk::IOUtil::Load(m_PathToImage)[0]); + m_RenderingTestHelper.AddNodeToStorage(imagenode); + + std::string refImagePath = GetTestDataFilePath(m_ReferenceImagePath + "LayoutAnnotationRenderer.png"); + // reference screenshot for this test + m_CommandlineArgs.push_back(refImagePath); + // Convert vector of strings to argc/argv + mitk::RenderingTestHelper::ArgcHelperClass arg(m_CommandlineArgs); + m_RenderingTestHelper.SetViewDirection(mitk::SliceNavigationController::Sagittal); + + std::vector Annotation; + mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(m_RenderingTestHelper.GetVtkRenderWindow()); + + createTextAnnotationWithLayouter( + Annotation, mitk::LayoutAnnotationRenderer::TopLeft, renderer, 20, 1.0, 1.0, 1.0, 1, "TopLeft1"); + createTextAnnotationWithLayouter( + Annotation, mitk::LayoutAnnotationRenderer::TopLeft, renderer, 15, 1.0, 1.0, 1.0, 3, "TopLeft3"); + createTextAnnotationWithLayouter( + Annotation, mitk::LayoutAnnotationRenderer::TopLeft, renderer, 25, 1.0, 0.0, 1.0, 2, "TopLeft2"); + + createTextAnnotationWithLayouter(Annotation, mitk::LayoutAnnotationRenderer::Top, renderer, 15, 1.0, 1.0, 1.0, 3, "Top3"); + createTextAnnotationWithLayouter(Annotation, mitk::LayoutAnnotationRenderer::Top, renderer, 20, 1.0, 1.0, 1.0, 1, "Top1"); + createTextAnnotationWithLayouter(Annotation, mitk::LayoutAnnotationRenderer::Top, renderer, 25, 1.0, 0.0, 1.0, 2, "Top2"); + + createTextAnnotationWithLayouter( + Annotation, mitk::LayoutAnnotationRenderer::TopRight, renderer, 20, 1.0, 1.0, 1.0, 1, "TopRight1"); + createTextAnnotationWithLayouter( + Annotation, mitk::LayoutAnnotationRenderer::TopRight, renderer, 15, 1.0, 1.0, 1.0, 3, "TopRight3"); + createTextAnnotationWithLayouter( + Annotation, mitk::LayoutAnnotationRenderer::TopRight, renderer, 25, 1.0, 0.0, 1.0, 2, "TopRight2"); + + createTextAnnotationWithLayouter(Annotation, mitk::LayoutAnnotationRenderer::Left, renderer, 20, 1.0, 1.0, 1.0, 1, "Left1"); + createTextAnnotationWithLayouter(Annotation, mitk::LayoutAnnotationRenderer::Left, renderer, 15, 1.0, 1.0, 1.0, 3, "Left3"); + createTextAnnotationWithLayouter(Annotation, mitk::LayoutAnnotationRenderer::Left, renderer, 25, 1.0, 0.0, 1.0, 2, "Left2"); + + createTextAnnotationWithLayouter(Annotation, mitk::LayoutAnnotationRenderer::Right, renderer, 25, 1.0, 0.0, 1.0, 2, "Right2"); + createTextAnnotationWithLayouter(Annotation, mitk::LayoutAnnotationRenderer::Right, renderer, 20, 1.0, 1.0, 1.0, 1, "Right1"); + createTextAnnotationWithLayouter(Annotation, mitk::LayoutAnnotationRenderer::Right, renderer, 15, 1.0, 1.0, 1.0, 3, "Right3"); + + createTextAnnotationWithLayouter( + Annotation, mitk::LayoutAnnotationRenderer::BottomLeft, renderer, 25, 1.0, 0.0, 1.0, 2, "BottomLeft2"); + createTextAnnotationWithLayouter( + Annotation, mitk::LayoutAnnotationRenderer::BottomLeft, renderer, 20, 1.0, 1.0, 1.0, 1, "BottomLeft1"); + createTextAnnotationWithLayouter( + Annotation, mitk::LayoutAnnotationRenderer::BottomLeft, renderer, 15, 1.0, 1.0, 1.0, 3, "BottomLeft3"); + + createTextAnnotationWithLayouter(Annotation, mitk::LayoutAnnotationRenderer::Bottom, renderer, 15, 1.0, 1.0, 1.0, 3, "Bottom3"); + createTextAnnotationWithLayouter(Annotation, mitk::LayoutAnnotationRenderer::Bottom, renderer, 20, 1.0, 1.0, 1.0, 1, "Bottom1"); + createTextAnnotationWithLayouter(Annotation, mitk::LayoutAnnotationRenderer::Bottom, renderer, 25, 1.0, 0.0, 1.0, 2, "Bottom2"); + + createTextAnnotationWithLayouter( + Annotation, mitk::LayoutAnnotationRenderer::BottomRight, renderer, 25, 1.0, 0.0, 1.0, 2, "BottomRight2"); + createTextAnnotationWithLayouter( + Annotation, mitk::LayoutAnnotationRenderer::BottomRight, renderer, 20, 1.0, 1.0, 1.0, 1, "BottomRight1"); + createTextAnnotationWithLayouter( + Annotation, mitk::LayoutAnnotationRenderer::BottomRight, renderer, 15, 1.0, 1.0, 1.0, 3, "BottomRight3"); + + m_RenderingTestHelper.Render(); + m_RenderingTestHelper.SaveReferenceScreenShot(refImagePath); + m_RenderingTestHelper.SetAutomaticallyCloseRenderWindow(true); + CPPUNIT_ASSERT(m_RenderingTestHelper.CompareRenderWindowAgainstReference(arg.GetArgc(), arg.GetArgv()) == true); + } +}; +MITK_TEST_SUITE_REGISTRATION(mitkLayoutAnnotationRenderer) diff --git a/Modules/Annotation/test/mitkLogoAnnotationTest.cpp b/Modules/Annotation/test/mitkLogoAnnotationTest.cpp new file mode 100644 index 0000000000..c5c9c56581 --- /dev/null +++ b/Modules/Annotation/test/mitkLogoAnnotationTest.cpp @@ -0,0 +1,136 @@ +/*=================================================================== + +The Medical Imaging Interaction Toolkit (MITK) + +Copyright (c) German Cancer Research Center, +Division of Medical and Biological Informatics. +All rights reserved. + +This software is distributed WITHOUT ANY WARRANTY; without +even the implied warranty of MERCHANTABILITY or FITNESS FOR +A PARTICULAR PURPOSE. + +See LICENSE.txt or http://www.mitk.org for details. + +===================================================================*/ + +// MITK +#include + +#include +#include +#include +#include +#include + +class mitkLogoAnnotationTestSuite : public mitk::TestFixture +{ + CPPUNIT_TEST_SUITE(mitkLogoAnnotationTestSuite); + MITK_TEST(RenderMbiLogo); + MITK_TEST(RenderLogo); + + CPPUNIT_TEST_SUITE_END(); + +private: + /** Members used inside the different test methods. All members are initialized via setUp().*/ + mitk::RenderingTestHelper m_RenderingTestHelper; + std::vector m_CommandlineArgs; + std::string m_PathToBall; + std::string m_PathToImage; + std::string m_PathToLogo; + std::string m_ReferenceImagePath; + +public: + /** + * @brief mitkManualPlacementAnnotationRendererTestSuite Because the RenderingTestHelper does not have an + * empty default constructor, we need this constructor to initialize the helper with a + * resolution. + */ + mitkLogoAnnotationTestSuite() : m_RenderingTestHelper(300, 300) {} + /** + * @brief Setup Initialize a fresh rendering test helper and a vector of strings + * to simulate commandline arguments for vtkTesting::Test. + */ + void setUp() + { + m_RenderingTestHelper = mitk::RenderingTestHelper(300, 300); + + m_PathToBall = GetTestDataFilePath("ball.stl"); + m_PathToImage = GetTestDataFilePath("Pic3D.nrrd"); + m_PathToLogo = GetTestDataFilePath("RenderingTestData/rgbaImage.png"); + m_ReferenceImagePath = "RenderingTestData/ReferenceScreenshots/Annotation/"; + + // Build a command line for the vtkTesting::Test method. + // See VTK documentation and RenderingTestHelper for more information. + // Use the following command line option to save the difference image + // and the test image in some tmp folder + // m_CommandlineArgs.push_back("-T"); + // m_CommandlineArgs.push_back("/path/to/save/tmp/difference/images/"); + m_CommandlineArgs.push_back("-V"); + } + + void tearDown() {} + void RenderMbiLogo() + { + mitk::DataNode::Pointer ballnode = mitk::DataNode::New(); + ballnode->SetData(mitk::IOUtil::Load(m_PathToBall)[0]); + m_RenderingTestHelper.AddNodeToStorage(ballnode); + + mitk::DataNode::Pointer imagenode = mitk::DataNode::New(); + imagenode->SetData(mitk::IOUtil::Load(m_PathToImage)[0]); + m_RenderingTestHelper.AddNodeToStorage(imagenode); + + std::string refImagePath = GetTestDataFilePath(m_ReferenceImagePath + "LogoAnnotation_mbiLogo.png"); + + // reference screenshot for this test + m_CommandlineArgs.push_back(refImagePath); + // Convert vector of strings to argc/argv + mitk::RenderingTestHelper::ArgcHelperClass arg(m_CommandlineArgs); + m_RenderingTestHelper.SetViewDirection(mitk::SliceNavigationController::Sagittal); + + mitk::LogoAnnotation::Pointer logoAnnotation = mitk::LogoAnnotation::New(); + + logoAnnotation->SetLogoImagePath("mbilogo"); + + mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(m_RenderingTestHelper.GetVtkRenderWindow()); + mitk::ManualPlacementAnnotationRenderer::AddAnnotation(logoAnnotation.GetPointer(), renderer); + + m_RenderingTestHelper.Render(); + m_RenderingTestHelper.SaveReferenceScreenShot(refImagePath); + m_RenderingTestHelper.SetAutomaticallyCloseRenderWindow(true); + CPPUNIT_ASSERT(m_RenderingTestHelper.CompareRenderWindowAgainstReference(arg.GetArgc(), arg.GetArgv()) == true); + } + + void RenderLogo() + { + mitk::DataNode::Pointer ballnode = mitk::DataNode::New(); + ballnode->SetData(mitk::IOUtil::Load(m_PathToBall)[0]); + m_RenderingTestHelper.AddNodeToStorage(ballnode); + + mitk::DataNode::Pointer imagenode = mitk::DataNode::New(); + imagenode->SetData(mitk::IOUtil::Load(m_PathToImage)[0]); + m_RenderingTestHelper.AddNodeToStorage(imagenode); + + std::string refImagePath = GetTestDataFilePath(m_ReferenceImagePath + "LogoAnnotation.png"); + + // reference screenshot for this test + m_CommandlineArgs.push_back(refImagePath); + // Convert vector of strings to argc/argv + mitk::RenderingTestHelper::ArgcHelperClass arg(m_CommandlineArgs); + m_RenderingTestHelper.SetViewDirection(mitk::SliceNavigationController::Sagittal); + + mitk::LogoAnnotation::Pointer logoAnnotation = mitk::LogoAnnotation::New(); + + logoAnnotation->SetLogoImagePath(m_PathToLogo); + + mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(m_RenderingTestHelper.GetVtkRenderWindow()); + mitk::ManualPlacementAnnotationRenderer::AddAnnotation(logoAnnotation.GetPointer(), renderer); + + m_RenderingTestHelper.Render(); + m_RenderingTestHelper.SaveReferenceScreenShot(refImagePath); + m_RenderingTestHelper.SetAutomaticallyCloseRenderWindow(true); + CPPUNIT_ASSERT(m_RenderingTestHelper.CompareRenderWindowAgainstReference(arg.GetArgc(), arg.GetArgv()) == true); + } +}; + +MITK_TEST_SUITE_REGISTRATION(mitkLogoAnnotation) diff --git a/Modules/Annotation/test/mitkManualPlacementAnnotationRendererTest.cpp b/Modules/Annotation/test/mitkManualPlacementAnnotationRendererTest.cpp new file mode 100644 index 0000000000..5bb1bfe995 --- /dev/null +++ b/Modules/Annotation/test/mitkManualPlacementAnnotationRendererTest.cpp @@ -0,0 +1,142 @@ +/*=================================================================== + +The Medical Imaging Interaction Toolkit (MITK) + +Copyright (c) German Cancer Research Center, +Division of Medical and Biological Informatics. +All rights reserved. + +This software is distributed WITHOUT ANY WARRANTY; without +even the implied warranty of MERCHANTABILITY or FITNESS FOR +A PARTICULAR PURPOSE. + +See LICENSE.txt or http://www.mitk.org for details. + +===================================================================*/ + +// MITK +#include + +#include +#include +#include +#include +#include +#include + +class mitkManualPlacementAnnotationRendererTestSuite : public mitk::TestFixture +{ + CPPUNIT_TEST_SUITE(mitkManualPlacementAnnotationRendererTestSuite); + MITK_TEST(Render2DAnnotation); + MITK_TEST(Render3DAnnotation); + + CPPUNIT_TEST_SUITE_END(); + +private: + /** Members used inside the different test methods. All members are initialized via setUp().*/ + mitk::RenderingTestHelper m_RenderingTestHelper; + std::vector m_CommandlineArgs; + std::string m_PathToBall; + std::string m_PathToImage; + std::string m_ReferenceImagePath; + +public: + /** + * @brief mitkManualPlacementAnnotationRendererTestSuite Because the RenderingTestHelper does not have an + * empty default constructor, we need this constructor to initialize the helper with a + * resolution. + */ + mitkManualPlacementAnnotationRendererTestSuite() : m_RenderingTestHelper(300, 300) {} + /** + * @brief Setup Initialize a fresh rendering test helper and a vector of strings + * to simulate commandline arguments for vtkTesting::Test. + */ + void setUp() + { + m_RenderingTestHelper = mitk::RenderingTestHelper(300, 300); + + m_PathToBall = GetTestDataFilePath("ball.stl"); + m_PathToImage = GetTestDataFilePath("Pic3D.nrrd"); + m_ReferenceImagePath = "RenderingTestData/ReferenceScreenshots/Annotation/"; + + // Build a command line for the vtkTesting::Test method. + // See VTK documentation and RenderingTestHelper for more information. + // Use the following command line option to save the difference image + // and the test image in some tmp folder + // m_CommandlineArgs.push_back("-T"); + // m_CommandlineArgs.push_back("/path/to/save/tmp/difference/images/"); + m_CommandlineArgs.push_back("-V"); + } + + void tearDown() {} + void Render2DAnnotation() + { + mitk::DataNode::Pointer ballnode = mitk::DataNode::New(); + ballnode->SetData(mitk::IOUtil::Load(m_PathToBall)[0]); + m_RenderingTestHelper.AddNodeToStorage(ballnode); + + mitk::DataNode::Pointer imagenode = mitk::DataNode::New(); + imagenode->SetData(mitk::IOUtil::Load(m_PathToImage)[0]); + m_RenderingTestHelper.AddNodeToStorage(imagenode); + + std::string refImagePath = GetTestDataFilePath(m_ReferenceImagePath + "ManualPlacementAnnotationRenderer2DAnnotation.png"); + + // reference screenshot for this test + m_CommandlineArgs.push_back(refImagePath); + // Convert vector of strings to argc/argv + mitk::RenderingTestHelper::ArgcHelperClass arg(m_CommandlineArgs); + m_RenderingTestHelper.SetViewDirection(mitk::SliceNavigationController::Sagittal); + + mitk::TextAnnotation2D::Pointer textAnnotation2D = mitk::TextAnnotation2D::New(); + + textAnnotation2D->SetText("TEST ManualPlacementAnnotationRenderer2DAnnotation"); + mitk::Point2D pos; + pos[0] = 0; + pos[1] = 0; + textAnnotation2D->SetPosition2D(pos); + + mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(m_RenderingTestHelper.GetVtkRenderWindow()); + mitk::ManualPlacementAnnotationRenderer::AddAnnotation(textAnnotation2D.GetPointer(), renderer); + + m_RenderingTestHelper.Render(); + m_RenderingTestHelper.SaveReferenceScreenShot(refImagePath); + m_RenderingTestHelper.SetAutomaticallyCloseRenderWindow(true); + CPPUNIT_ASSERT(m_RenderingTestHelper.CompareRenderWindowAgainstReference(arg.GetArgc(), arg.GetArgv()) == true); + } + + void Render3DAnnotation() + { + mitk::DataNode::Pointer ballnode = mitk::DataNode::New(); + ballnode->SetData(mitk::IOUtil::Load(m_PathToBall)[0]); + m_RenderingTestHelper.AddNodeToStorage(ballnode); + + mitk::DataNode::Pointer imagenode = mitk::DataNode::New(); + imagenode->SetData(mitk::IOUtil::Load(m_PathToImage)[0]); + m_RenderingTestHelper.AddNodeToStorage(imagenode); + + std::string refImagePath = GetTestDataFilePath(m_ReferenceImagePath + "ManualPlacementAnnotationRenderer3DAnnotation.png"); + // reference screenshot for this test + m_CommandlineArgs.push_back(refImagePath); + // Convert vector of strings to argc/argv + mitk::RenderingTestHelper::ArgcHelperClass arg(m_CommandlineArgs); + m_RenderingTestHelper.SetMapperIDToRender3D(); + + mitk::TextAnnotation3D::Pointer textAnnotation3D = mitk::TextAnnotation3D::New(); + + textAnnotation3D->SetText("TEST ManualPlacementAnnotationRenderer3DAnnotation"); + mitk::Point3D pos; + pos[0] = 10; + pos[1] = 10; + pos[2] = 10; + textAnnotation3D->SetPosition3D(pos); + + mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(m_RenderingTestHelper.GetVtkRenderWindow()); + mitk::ManualPlacementAnnotationRenderer::AddAnnotation(textAnnotation3D.GetPointer(), renderer); + + m_RenderingTestHelper.Render(); + m_RenderingTestHelper.SaveReferenceScreenShot(refImagePath); + m_RenderingTestHelper.SetAutomaticallyCloseRenderWindow(true); + CPPUNIT_ASSERT(m_RenderingTestHelper.CompareRenderWindowAgainstReference(arg.GetArgc(), arg.GetArgv()) == true); + } +}; +MITK_TEST_SUITE_REGISTRATION(mitkManualPlacementAnnotationRenderer) diff --git a/Modules/Annotation/test/mitkScaleLegendAnnotationTest.cpp b/Modules/Annotation/test/mitkScaleLegendAnnotationTest.cpp new file mode 100644 index 0000000000..87df330b17 --- /dev/null +++ b/Modules/Annotation/test/mitkScaleLegendAnnotationTest.cpp @@ -0,0 +1,99 @@ +/*=================================================================== + +The Medical Imaging Interaction Toolkit (MITK) + +Copyright (c) German Cancer Research Center, +Division of Medical and Biological Informatics. +All rights reserved. + +This software is distributed WITHOUT ANY WARRANTY; without +even the implied warranty of MERCHANTABILITY or FITNESS FOR +A PARTICULAR PURPOSE. + +See LICENSE.txt or http://www.mitk.org for details. + +===================================================================*/ + +// MITK +#include + +#include +#include +#include +#include +#include + +class mitkScaleLegendAnnotationTestSuite : public mitk::TestFixture +{ + CPPUNIT_TEST_SUITE(mitkScaleLegendAnnotationTestSuite); + MITK_TEST(RenderScaleLegendAnnotation); + + CPPUNIT_TEST_SUITE_END(); + +private: + /** Members used inside the different test methods. All members are initialized via setUp().*/ + mitk::RenderingTestHelper m_RenderingTestHelper; + std::vector m_CommandlineArgs; + std::string m_PathToBall; + std::string m_PathToImage; + std::string m_ReferenceImagePath; + +public: + /** + * @brief mitkManualPlacementAnnotationRendererTestSuite Because the RenderingTestHelper does not have an + * empty default constructor, we need this constructor to initialize the helper with a + * resolution. + */ + mitkScaleLegendAnnotationTestSuite() : m_RenderingTestHelper(300, 300) {} + /** + * @brief Setup Initialize a fresh rendering test helper and a vector of strings + * to simulate commandline arguments for vtkTesting::Test. + */ + void setUp() + { + m_RenderingTestHelper = mitk::RenderingTestHelper(300, 300); + + m_PathToBall = GetTestDataFilePath("ball.stl"); + m_PathToImage = GetTestDataFilePath("Pic3D.nrrd"); + m_ReferenceImagePath = "RenderingTestData/ReferenceScreenshots/Annotation/"; + + // Build a command line for the vtkTesting::Test method. + // See VTK documentation and RenderingTestHelper for more information. + // Use the following command line option to save the difference image + // and the test image in some tmp folder + // m_CommandlineArgs.push_back("-T"); + // m_CommandlineArgs.push_back("/path/to/save/tmp/difference/images/"); + m_CommandlineArgs.push_back("-V"); + } + + void tearDown() {} + void RenderScaleLegendAnnotation() + { + mitk::DataNode::Pointer ballnode = mitk::DataNode::New(); + ballnode->SetData(mitk::IOUtil::Load(m_PathToBall)[0]); + m_RenderingTestHelper.AddNodeToStorage(ballnode); + + mitk::DataNode::Pointer imagenode = mitk::DataNode::New(); + imagenode->SetData(mitk::IOUtil::Load(m_PathToImage)[0]); + m_RenderingTestHelper.AddNodeToStorage(imagenode); + + std::string refImagePath = GetTestDataFilePath(m_ReferenceImagePath + "mitkScaleLegendAnnotation.png"); + + // reference screenshot for this test + m_CommandlineArgs.push_back(refImagePath); + // Convert vector of strings to argc/argv + mitk::RenderingTestHelper::ArgcHelperClass arg(m_CommandlineArgs); + m_RenderingTestHelper.SetViewDirection(mitk::SliceNavigationController::Sagittal); + + mitk::ScaleLegendAnnotation::Pointer colorbar = mitk::ScaleLegendAnnotation::New(); + + mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(m_RenderingTestHelper.GetVtkRenderWindow()); + mitk::ManualPlacementAnnotationRenderer::AddAnnotation(colorbar.GetPointer(), renderer); + + m_RenderingTestHelper.Render(); + m_RenderingTestHelper.SaveReferenceScreenShot(refImagePath); + m_RenderingTestHelper.SetAutomaticallyCloseRenderWindow(true); + CPPUNIT_ASSERT(m_RenderingTestHelper.CompareRenderWindowAgainstReference(arg.GetArgc(), arg.GetArgv()) == true); + } +}; +MITK_TEST_SUITE_REGISTRATION(mitkScaleLegendAnnotation) diff --git a/Modules/Annotation/test/mitkTextAnnotation2DTest.cpp b/Modules/Annotation/test/mitkTextAnnotation2DTest.cpp new file mode 100644 index 0000000000..9ec55990c2 --- /dev/null +++ b/Modules/Annotation/test/mitkTextAnnotation2DTest.cpp @@ -0,0 +1,105 @@ +/*=================================================================== + +The Medical Imaging Interaction Toolkit (MITK) + +Copyright (c) German Cancer Research Center, +Division of Medical and Biological Informatics. +All rights reserved. + +This software is distributed WITHOUT ANY WARRANTY; without +even the implied warranty of MERCHANTABILITY or FITNESS FOR +A PARTICULAR PURPOSE. + +See LICENSE.txt or http://www.mitk.org for details. + +===================================================================*/ + +// MITK +#include + +#include +#include +#include +#include +#include + +class mitkTextAnnotation2DTestSuite : public mitk::TestFixture +{ + CPPUNIT_TEST_SUITE(mitkTextAnnotation2DTestSuite); + MITK_TEST(Render2DAnnotation); + + CPPUNIT_TEST_SUITE_END(); + +private: + /** Members used inside the different test methods. All members are initialized via setUp().*/ + mitk::RenderingTestHelper m_RenderingTestHelper; + std::vector m_CommandlineArgs; + std::string m_PathToBall; + std::string m_PathToImage; + std::string m_ReferenceImagePath; + +public: + /** + * @brief mitkTextAnnotation2DTestSuite Because the RenderingTestHelper does not have an + * empty default constructor, we need this constructor to initialize the helper with a + * resolution. + */ + mitkTextAnnotation2DTestSuite() : m_RenderingTestHelper(300, 300) {} + /** + * @brief Setup Initialize a fresh rendering test helper and a vector of strings + * to simulate commandline arguments for vtkTesting::Test. + */ + void setUp() + { + m_RenderingTestHelper = mitk::RenderingTestHelper(300, 300); + + m_PathToBall = GetTestDataFilePath("ball.stl"); + m_PathToImage = GetTestDataFilePath("Pic3D.nrrd"); + m_ReferenceImagePath = "RenderingTestData/ReferenceScreenshots/Annotation/"; + + // Build a command line for the vtkTesting::Test method. + // See VTK documentation and RenderingTestHelper for more information. + // Use the following command line option to save the difference image + // and the test image in some tmp folder + // m_CommandlineArgs.push_back("-T"); + // m_CommandlineArgs.push_back("/path/to/save/tmp/difference/images/"); + m_CommandlineArgs.push_back("-V"); + } + + void tearDown() {} + void Render2DAnnotation() + { + mitk::DataNode::Pointer ballnode = mitk::DataNode::New(); + ballnode->SetData(mitk::IOUtil::Load(m_PathToBall)[0]); + m_RenderingTestHelper.AddNodeToStorage(ballnode); + + mitk::DataNode::Pointer imagenode = mitk::DataNode::New(); + imagenode->SetData(mitk::IOUtil::Load(m_PathToImage)[0]); + m_RenderingTestHelper.AddNodeToStorage(imagenode); + + std::string refImagePath = GetTestDataFilePath(m_ReferenceImagePath + "TextAnnotation2D.png"); + + // reference screenshot for this test + m_CommandlineArgs.push_back(refImagePath); + // Convert vector of strings to argc/argv + mitk::RenderingTestHelper::ArgcHelperClass arg(m_CommandlineArgs); + m_RenderingTestHelper.SetViewDirection(mitk::SliceNavigationController::Sagittal); + + mitk::TextAnnotation2D::Pointer textAnnotation2D = mitk::TextAnnotation2D::New(); + + textAnnotation2D->SetText("TEST TextAnnotation2D2DAnnotation"); + mitk::Point2D pos; + pos[0] = 0; + pos[1] = 0; + textAnnotation2D->SetPosition2D(pos); + + mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(m_RenderingTestHelper.GetVtkRenderWindow()); + mitk::ManualPlacementAnnotationRenderer::AddAnnotation(textAnnotation2D.GetPointer(), renderer); + + m_RenderingTestHelper.Render(); + m_RenderingTestHelper.SaveReferenceScreenShot(refImagePath); + m_RenderingTestHelper.SetAutomaticallyCloseRenderWindow(true); + CPPUNIT_ASSERT(m_RenderingTestHelper.CompareRenderWindowAgainstReference(arg.GetArgc(), arg.GetArgv()) == true); + } +}; +MITK_TEST_SUITE_REGISTRATION(mitkTextAnnotation2D) diff --git a/Modules/Annotation/test/mitkTextAnnotation3DTest.cpp b/Modules/Annotation/test/mitkTextAnnotation3DTest.cpp new file mode 100644 index 0000000000..2f0a969216 --- /dev/null +++ b/Modules/Annotation/test/mitkTextAnnotation3DTest.cpp @@ -0,0 +1,105 @@ +/*=================================================================== + +The Medical Imaging Interaction Toolkit (MITK) + +Copyright (c) German Cancer Research Center, +Division of Medical and Biological Informatics. +All rights reserved. + +This software is distributed WITHOUT ANY WARRANTY; without +even the implied warranty of MERCHANTABILITY or FITNESS FOR +A PARTICULAR PURPOSE. + +See LICENSE.txt or http://www.mitk.org for details. + +===================================================================*/ + +// MITK +#include + +#include +#include +#include +#include +#include + +class mitkTextAnnotation3DTestSuite : public mitk::TestFixture +{ + CPPUNIT_TEST_SUITE(mitkTextAnnotation3DTestSuite); + MITK_TEST(Render3DAnnotation); + + CPPUNIT_TEST_SUITE_END(); + +private: + /** Members used inside the different test methods. All members are initialized via setUp().*/ + mitk::RenderingTestHelper m_RenderingTestHelper; + std::vector m_CommandlineArgs; + std::string m_PathToBall; + std::string m_PathToImage; + std::string m_ReferenceImagePath; + +public: + /** + * @brief mitkTextAnnotation3DTestSuite Because the RenderingTestHelper does not have an + * empty default constructor, we need this constructor to initialize the helper with a + * resolution. + */ + mitkTextAnnotation3DTestSuite() : m_RenderingTestHelper(300, 300) {} + /** + * @brief Setup Initialize a fresh rendering test helper and a vector of strings + * to simulate commandline arguments for vtkTesting::Test. + */ + void setUp() + { + m_RenderingTestHelper = mitk::RenderingTestHelper(300, 300); + + m_PathToBall = GetTestDataFilePath("ball.stl"); + m_PathToImage = GetTestDataFilePath("Pic3D.nrrd"); + m_ReferenceImagePath = "RenderingTestData/ReferenceScreenshots/Annotation/"; + + // Build a command line for the vtkTesting::Test method. + // See VTK documentation and RenderingTestHelper for more information. + // Use the following command line option to save the difference image + // and the test image in some tmp folder + // m_CommandlineArgs.push_back("-T"); + // m_CommandlineArgs.push_back("/path/to/save/tmp/difference/images/"); + m_CommandlineArgs.push_back("-V"); + } + + void tearDown() {} + void Render3DAnnotation() + { + mitk::DataNode::Pointer ballnode = mitk::DataNode::New(); + ballnode->SetData(mitk::IOUtil::Load(m_PathToBall)[0]); + m_RenderingTestHelper.AddNodeToStorage(ballnode); + + mitk::DataNode::Pointer imagenode = mitk::DataNode::New(); + imagenode->SetData(mitk::IOUtil::Load(m_PathToImage)[0]); + m_RenderingTestHelper.AddNodeToStorage(imagenode); + + std::string refImagePath = GetTestDataFilePath(m_ReferenceImagePath + "TextAnnotation3D.png"); + // reference screenshot for this test + m_CommandlineArgs.push_back(refImagePath); + // Convert vector of strings to argc/argv + mitk::RenderingTestHelper::ArgcHelperClass arg(m_CommandlineArgs); + m_RenderingTestHelper.SetMapperIDToRender3D(); + + mitk::TextAnnotation3D::Pointer textAnnotation3D = mitk::TextAnnotation3D::New(); + + textAnnotation3D->SetText("TESTManualPlacementAnnotationRenderer3DAnnotation"); + mitk::Point3D pos; + pos[0] = 10; + pos[1] = 10; + pos[2] = 10; + textAnnotation3D->SetPosition3D(pos); + + mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(m_RenderingTestHelper.GetVtkRenderWindow()); + mitk::ManualPlacementAnnotationRenderer::AddAnnotation(textAnnotation3D.GetPointer(), renderer); + + m_RenderingTestHelper.Render(); + m_RenderingTestHelper.SaveReferenceScreenShot(refImagePath); + m_RenderingTestHelper.SetAutomaticallyCloseRenderWindow(true); + CPPUNIT_ASSERT(m_RenderingTestHelper.CompareRenderWindowAgainstReference(arg.GetArgc(), arg.GetArgv()) == true); + } +}; +MITK_TEST_SUITE_REGISTRATION(mitkTextAnnotation3D) diff --git a/Modules/ContourModel/CMakeLists.txt b/Modules/ContourModel/CMakeLists.txt index 82cdb04801..dd431cf295 100644 --- a/Modules/ContourModel/CMakeLists.txt +++ b/Modules/ContourModel/CMakeLists.txt @@ -1,9 +1,9 @@ MITK_CREATE_MODULE( INCLUDE_DIRS Algorithms DataManagement IO Rendering - DEPENDS MitkCore MitkSceneSerializationBase MitkLegacyGL MitkOverlays MitkMultilabel + DEPENDS MitkCore MitkSceneSerializationBase MitkLegacyGL MitkAnnotation MitkMultilabel PACKAGE_DEPENDS ITK|ITKReview # AUTOLOAD_WITH MitkCore TODO: Create IO Submodule and autoload that one instead. WARNINGS_AS_ERRORS ) add_subdirectory(Testing) diff --git a/Modules/ContourModel/Rendering/mitkContourModelGLMapper2DBase.cpp b/Modules/ContourModel/Rendering/mitkContourModelGLMapper2DBase.cpp index 357c69b567..912e0806d8 100644 --- a/Modules/ContourModel/Rendering/mitkContourModelGLMapper2DBase.cpp +++ b/Modules/ContourModel/Rendering/mitkContourModelGLMapper2DBase.cpp @@ -1,367 +1,370 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "mitkContourModelSetGLMapper2D.h" #include "mitkColorProperty.h" #include "mitkContourModelSet.h" #include "mitkPlaneGeometry.h" #include "mitkProperties.h" #include +#include "mitkManualPlacementAnnotationRenderer.h" #include "mitkBaseRenderer.h" #include "mitkContourModel.h" -#include "mitkOverlayManager.h" -#include "mitkTextOverlay2D.h" +#include "mitkTextAnnotation2D.h" #include "mitkGL.h" mitk::ContourModelGLMapper2DBase::ContourModelGLMapper2DBase() { - m_PointNumbersOverlay = mitk::TextOverlay2D::New(); - m_ControlPointNumbersOverlay = mitk::TextOverlay2D::New(); + m_PointNumbersAnnotation = mitk::TextAnnotation2D::New(); + m_ControlPointNumbersAnnotation = mitk::TextAnnotation2D::New(); } mitk::ContourModelGLMapper2DBase::~ContourModelGLMapper2DBase() { } 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); } - renderer->GetOverlayManager()->AddOverlay(m_PointNumbersOverlay.GetPointer(), renderer); - m_PointNumbersOverlay->SetVisibility(false, renderer); + mitk::ManualPlacementAnnotationRenderer::AddAnnotation(m_PointNumbersAnnotation.GetPointer(), renderer); + m_PointNumbersAnnotation->SetVisibility(false); - renderer->GetOverlayManager()->AddOverlay(m_ControlPointNumbersOverlay.GetPointer(), renderer); - m_ControlPointNumbersOverlay->SetVisibility(false, renderer); + 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; mitk::DataNode *dataNode = this->GetDataNode(); renderingContour->UpdateOutputInformation(); unsigned int timestep = renderer->GetTimeStep(); if (!renderingContour->IsEmptyTimeStep(timestep)) { // apply color and opacity read from the PropertyList ApplyColorAndOpacityProperties(renderer); mitk::ColorProperty::Pointer colorprop = dynamic_cast(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(); glColor4f(red, green, blue, opacity); } mitk::ColorProperty::Pointer selectedcolor = dynamic_cast(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"); mitk::ContourModel::VertexIterator 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->WorldToDisplay(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))) { glLineWidth(lineWidth); glBegin(GL_LINES); glVertex2f(pt2d[0], pt2d[1]); glVertex2f(lastPt2d[0], lastPt2d[1]); glEnd(); glLineWidth(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; glColor3f(selectedcolor->GetColor().GetRed(), selectedcolor->GetColor().GetBlue(), selectedcolor->GetColor().GetGreen()); glLineWidth(1); // a rectangle around the point with the selected color glBegin(GL_LINE_LOOP); tmp = pt2d - horz; glVertex2dv(&tmp[0]); tmp = pt2d + vert; glVertex2dv(&tmp[0]); tmp = pt2d + horz; glVertex2dv(&tmp[0]); tmp = pt2d - vert; glVertex2dv(&tmp[0]); glEnd(); glLineWidth(1); // the actual point in the specified color to see the usual color of the point glColor3f( colorprop->GetColor().GetRed(), colorprop->GetColor().GetGreen(), colorprop->GetColor().GetBlue()); glPointSize(1); glBegin(GL_POINTS); tmp = pt2d; glVertex2dv(&tmp[0]); glEnd(); } } if (showPoints) { float pointsize = 3; Point2D tmp; Vector2D horz, vert; horz[1] = 0; vert[0] = 0; horz[0] = pointsize; vert[1] = pointsize; glColor3f(0.0, 0.0, 0.0); glLineWidth(1); // a rectangle around the point with the selected color glBegin(GL_LINE_LOOP); tmp = pt2d - horz; glVertex2dv(&tmp[0]); tmp = pt2d + vert; glVertex2dv(&tmp[0]); tmp = pt2d + horz; glVertex2dv(&tmp[0]); tmp = pt2d - vert; glVertex2dv(&tmp[0]); glEnd(); glLineWidth(1); // the actual point in the specified color to see the usual color of the point glColor3f(colorprop->GetColor().GetRed(), colorprop->GetColor().GetGreen(), colorprop->GetColor().GetBlue()); glPointSize(1); glBegin(GL_POINTS); tmp = pt2d; glVertex2dv(&tmp[0]); glEnd(); } 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; - WriteTextWithOverlay(m_PointNumbersOverlay, l.c_str(), rgb, pt2d, renderer); + 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; - WriteTextWithOverlay(m_ControlPointNumbersOverlay, l.c_str(), rgb, pt2d, renderer); + 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); glLineWidth(lineWidth); glBegin(GL_LINES); glVertex2f(lastPt2d[0], lastPt2d[1]); glVertex2f(pt2d[0], pt2d[1]); glEnd(); glLineWidth(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; glColor3f(0.0, 1.0, 0.0); glLineWidth(1); // a diamond around the point glBegin(GL_LINE_LOOP); // begin from upper left corner and paint clockwise tmp[0] = pt2d[0] - pointsize; tmp[1] = pt2d[1] + pointsize; glVertex2dv(&tmp[0]); tmp[0] = pt2d[0] + pointsize; tmp[1] = pt2d[1] + pointsize; glVertex2dv(&tmp[0]); tmp[0] = pt2d[0] + pointsize; tmp[1] = pt2d[1] - pointsize; glVertex2dv(&tmp[0]); tmp[0] = pt2d[0] - pointsize; tmp[1] = pt2d[1] - pointsize; glVertex2dv(&tmp[0]); glEnd(); } //------------------------------------ } } } -void mitk::ContourModelGLMapper2DBase::WriteTextWithOverlay( - TextOverlayPointerType textOverlay, const char *text, float rgb[3], Point2D /*pt2d*/, mitk::BaseRenderer *renderer) +void mitk::ContourModelGLMapper2DBase::WriteTextWithAnnotation(TextAnnotationPointerType textAnnotation, + const char *text, + float rgb[3], + Point2D /*pt2d*/, + mitk::BaseRenderer * /*renderer*/) { - textOverlay->SetText(text); - textOverlay->SetColor(rgb); - textOverlay->SetOpacity(1); - textOverlay->SetFontSize(16); - textOverlay->SetBoolProperty("drawShadow", false); - textOverlay->SetVisibility(true, 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/mitkContourModelGLMapper2DBase.h b/Modules/ContourModel/Rendering/mitkContourModelGLMapper2DBase.h index 4e7bb4170c..05688ae45b 100644 --- a/Modules/ContourModel/Rendering/mitkContourModelGLMapper2DBase.h +++ b/Modules/ContourModel/Rendering/mitkContourModelGLMapper2DBase.h @@ -1,64 +1,64 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef MITK_ContourModelGLMapper2DBase_H_ #define MITK_ContourModelGLMapper2DBase_H_ #include "mitkCommon.h" #include "mitkGLMapper.h" -#include "mitkTextOverlay2D.h" +#include "mitkTextAnnotation2D.h" #include namespace mitk { class BaseRenderer; class ContourModel; /** * @brief Base class for OpenGL based 2D mappers. * Provides functionality to draw a contour. * * @ingroup MitkContourModelModule */ class MITKCONTOURMODEL_EXPORT ContourModelGLMapper2DBase : public GLMapper { public: mitkClassMacro(ContourModelGLMapper2DBase, GLMapper); protected: - typedef TextOverlay2D::Pointer TextOverlayPointerType; + typedef TextAnnotation2D::Pointer TextAnnotationPointerType; ContourModelGLMapper2DBase(); virtual ~ContourModelGLMapper2DBase(); void DrawContour(mitk::ContourModel *contour, mitk::BaseRenderer *renderer); - void WriteTextWithOverlay( - TextOverlayPointerType textOverlay, const char *text, float rgb[3], Point2D pt2d, mitk::BaseRenderer *renderer); + void WriteTextWithAnnotation( + TextAnnotationPointerType textAnnotation, const char *text, float rgb[3], Point2D pt2d, mitk::BaseRenderer *); virtual void InternalDrawContour(mitk::ContourModel *renderingContour, mitk::BaseRenderer *renderer); - TextOverlayPointerType m_PointNumbersOverlay; - TextOverlayPointerType m_ControlPointNumbersOverlay; + TextAnnotationPointerType m_PointNumbersAnnotation; + TextAnnotationPointerType m_ControlPointNumbersAnnotation; typedef std::vector RendererListType; RendererListType m_RendererList; }; } // namespace mitk #endif diff --git a/Modules/ContourModel/Rendering/mitkContourModelSetGLMapper2D.cpp b/Modules/ContourModel/Rendering/mitkContourModelSetGLMapper2D.cpp index 5a2ca84385..bb03f3dd64 100644 --- a/Modules/ContourModel/Rendering/mitkContourModelSetGLMapper2D.cpp +++ b/Modules/ContourModel/Rendering/mitkContourModelSetGLMapper2D.cpp @@ -1,389 +1,389 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "mitkContourModelSetGLMapper2D.h" #include "mitkColorProperty.h" #include "mitkContourModelSet.h" #include "mitkPlaneGeometry.h" #include "mitkProperties.h" #include #include "mitkGL.h" mitk::ContourModelSetGLMapper2D::ContourModelSetGLMapper2D() { } mitk::ContourModelSetGLMapper2D::~ContourModelSetGLMapper2D() { } void mitk::ContourModelSetGLMapper2D::Paint(mitk::BaseRenderer *renderer) { BaseLocalStorage *ls = m_LSH.GetLocalStorage(renderer); mitk::DataNode *dataNode = this->GetDataNode(); bool visible = true; dataNode->GetVisibility(visible, renderer, "visible"); if (!visible) return; mitk::ContourModelSet *input = this->GetInput(); mitk::ContourModelSet::ContourModelSetIterator it = input->Begin(); mitk::ContourModelSet::ContourModelSetIterator end = input->End(); while (it != end) { this->DrawContour(it->GetPointer(), renderer); ++it; } if (input->GetSize() < 1) return; ls->UpdateGenerateDataTime(); } mitk::ContourModelSet *mitk::ContourModelSetGLMapper2D::GetInput(void) { return const_cast(static_cast(GetDataNode()->GetData())); } void mitk::ContourModelSetGLMapper2D::InternalDrawContour(mitk::ContourModel *renderingContour, mitk::BaseRenderer *renderer) { if (!renderingContour) return; mitk::DataNode *dataNode = this->GetDataNode(); renderingContour->UpdateOutputInformation(); unsigned int timestep = renderer->GetTimeStep(); if (!renderingContour->IsEmptyTimeStep(timestep)) { // apply color and opacity read from the PropertyList ApplyColorAndOpacityProperties(renderer); mitk::ColorProperty::Pointer colorprop = dynamic_cast(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(); glColor4f(red, green, blue, opacity); } mitk::ColorProperty::Pointer selectedcolor = dynamic_cast(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"); mitk::ContourModel::VertexIterator 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->WorldToDisplay(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))) { glLineWidth(lineWidth); glBegin(GL_LINES); glVertex2f(pt2d[0], pt2d[1]); glVertex2f(lastPt2d[0], lastPt2d[1]); glEnd(); glLineWidth(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; glColor3f(selectedcolor->GetColor().GetRed(), selectedcolor->GetColor().GetBlue(), selectedcolor->GetColor().GetGreen()); glLineWidth(1); // a rectangle around the point with the selected color glBegin(GL_LINE_LOOP); tmp = pt2d - horz; glVertex2dv(&tmp[0]); tmp = pt2d + vert; glVertex2dv(&tmp[0]); tmp = pt2d + horz; glVertex2dv(&tmp[0]); tmp = pt2d - vert; glVertex2dv(&tmp[0]); glEnd(); glLineWidth(1); // the actual point in the specified color to see the usual color of the point glColor3f( colorprop->GetColor().GetRed(), colorprop->GetColor().GetGreen(), colorprop->GetColor().GetBlue()); glPointSize(1); glBegin(GL_POINTS); tmp = pt2d; glVertex2dv(&tmp[0]); glEnd(); } } if (showPoints) { float pointsize = 3; Point2D tmp; Vector2D horz, vert; horz[1] = 0; vert[0] = 0; horz[0] = pointsize; vert[1] = pointsize; glColor3f(0.0, 0.0, 0.0); glLineWidth(1); // a rectangle around the point with the selected color glBegin(GL_LINE_LOOP); tmp = pt2d - horz; glVertex2dv(&tmp[0]); tmp = pt2d + vert; glVertex2dv(&tmp[0]); tmp = pt2d + horz; glVertex2dv(&tmp[0]); tmp = pt2d - vert; glVertex2dv(&tmp[0]); glEnd(); glLineWidth(1); // the actual point in the specified color to see the usual color of the point glColor3f(colorprop->GetColor().GetRed(), colorprop->GetColor().GetGreen(), colorprop->GetColor().GetBlue()); glPointSize(1); glBegin(GL_POINTS); tmp = pt2d; glVertex2dv(&tmp[0]); glEnd(); } 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; - WriteTextWithOverlay(m_PointNumbersOverlay, l.c_str(), rgb, pt2d, renderer); + 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; - WriteTextWithOverlay(m_ControlPointNumbersOverlay, l.c_str(), rgb, pt2d, renderer); + 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); glLineWidth(lineWidth); glBegin(GL_LINES); glVertex2f(lastPt2d[0], lastPt2d[1]); glVertex2f(pt2d[0], pt2d[1]); glEnd(); glLineWidth(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; glColor3f(0.0, 1.0, 0.0); glLineWidth(1); // a diamond around the point glBegin(GL_LINE_LOOP); // begin from upper left corner and paint clockwise tmp[0] = pt2d[0] - pointsize; tmp[1] = pt2d[1] + pointsize; glVertex2dv(&tmp[0]); tmp[0] = pt2d[0] + pointsize; tmp[1] = pt2d[1] + pointsize; glVertex2dv(&tmp[0]); tmp[0] = pt2d[0] + pointsize; tmp[1] = pt2d[1] - pointsize; glVertex2dv(&tmp[0]); tmp[0] = pt2d[0] - pointsize; tmp[1] = pt2d[1] - pointsize; glVertex2dv(&tmp[0]); glEnd(); } //------------------------------------ } } } void mitk::ContourModelSetGLMapper2D::SetDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer, bool overwrite) { node->AddProperty("contour.color", ColorProperty::New(0.9, 1.0, 0.1), renderer, overwrite); node->AddProperty("contour.points.color", ColorProperty::New(1.0, 0.0, 0.1), renderer, overwrite); node->AddProperty("contour.points.show", mitk::BoolProperty::New(false), renderer, overwrite); node->AddProperty("contour.segments.show", mitk::BoolProperty::New(true), renderer, overwrite); node->AddProperty("contour.controlpoints.show", mitk::BoolProperty::New(false), renderer, overwrite); node->AddProperty("contour.width", mitk::FloatProperty::New(1.0), renderer, overwrite); node->AddProperty("contour.hovering.width", mitk::FloatProperty::New(3.0), renderer, overwrite); node->AddProperty("contour.hovering", mitk::BoolProperty::New(false), renderer, overwrite); node->AddProperty("contour.points.text", mitk::BoolProperty::New(false), renderer, overwrite); node->AddProperty("contour.controlpoints.text", mitk::BoolProperty::New(false), renderer, overwrite); node->AddProperty("contour.project-onto-plane", mitk::BoolProperty::New(false), renderer, overwrite); node->AddProperty("opacity", mitk::FloatProperty::New(1.0f), renderer, overwrite); Superclass::SetDefaultProperties(node, renderer, overwrite); } diff --git a/Modules/Core/TestingHelper/src/mitkRenderingTestHelper.cpp b/Modules/Core/TestingHelper/src/mitkRenderingTestHelper.cpp index 25263cc7e9..e06da30756 100644 --- a/Modules/Core/TestingHelper/src/mitkRenderingTestHelper.cpp +++ b/Modules/Core/TestingHelper/src/mitkRenderingTestHelper.cpp @@ -1,307 +1,308 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ // VTK #include #include #include #include #include // MITK #include #include #include #include #include // include gl to read out properties #include #include #include #if defined _MSC_VER #if _MSC_VER >= 1700 #define RESIZE_WORKAROUND #endif #endif #ifdef RESIZE_WORKAROUND #include "vtkWin32OpenGLRenderWindow.h" #endif // VTK Testing to compare the rendered image pixel-wise against a reference screen shot #include "vtkTesting.h" mitk::RenderingTestHelper::RenderingTestHelper(int width, int height, mitk::BaseRenderer::RenderingMode::Type renderingMode) : m_AutomaticallyCloseRenderWindow(true) { this->Initialize(width, height, renderingMode); } mitk::RenderingTestHelper::RenderingTestHelper( int width, int height, int argc, char *argv[], mitk::BaseRenderer::RenderingMode::Type renderingMode) : m_AutomaticallyCloseRenderWindow(true) { this->Initialize(width, height, renderingMode); this->SetInputFileNames(argc, argv); } void mitk::RenderingTestHelper::Initialize(int width, int height, mitk::BaseRenderer::RenderingMode::Type renderingMode) { - m_RenderWindow = mitk::RenderWindow::New(NULL, "unnamed renderer", NULL, renderingMode); + mitk::UIDGenerator uidGen = mitk::UIDGenerator("UnnamedRenderer_", 8); + m_RenderWindow = mitk::RenderWindow::New(NULL, uidGen.GetUID().c_str(), NULL, renderingMode); m_DataStorage = mitk::StandaloneDataStorage::New(); m_RenderWindow->GetRenderer()->SetDataStorage(m_DataStorage); this->SetMapperIDToRender2D(); this->GetVtkRenderWindow()->SetSize(width, height); #ifdef RESIZE_WORKAROUND HWND hWnd = static_cast(this->GetVtkRenderWindow())->GetWindowId(); RECT r; r.left = 10; r.top = 10; r.right = r.left + width; r.bottom = r.top + height; LONG style = GetWindowLong(hWnd, GWL_STYLE); AdjustWindowRect(&r, style, FALSE); MITK_INFO << "WANTED:"; MITK_INFO << r.right - r.left; MITK_INFO << r.bottom - r.top; RECT rect; if (GetWindowRect(hWnd, &rect)) { int width = rect.right - rect.left; int height = rect.bottom - rect.top; MITK_INFO << "ACTUAL:"; MITK_INFO << width; MITK_INFO << height; } SetWindowPos(hWnd, HWND_TOP, 0, 0, r.right - r.left, r.bottom - r.top, SWP_NOZORDER); GetWindowRect(hWnd, &rect); int width2 = rect.right - rect.left; int height2 = rect.bottom - rect.top; MITK_INFO << "ACTUAL2:"; MITK_INFO << width2; MITK_INFO << height2; SetWindowPos(hWnd, HWND_TOP, 0, 0, 2 * (r.right - r.left) - width2, 2 * (r.bottom - r.top) - height2, SWP_NOZORDER); #endif m_RenderWindow->GetRenderer()->Resize(width, height); // Prints the glinfo after creation of the vtkrenderwindow, we always want to do this for debugging. this->PrintGLInfo(); } mitk::RenderingTestHelper::~RenderingTestHelper() { } bool mitk::RenderingTestHelper::IsAdvancedOpenGL() { const GLubyte *version = glGetString(GL_VERSION); if (!version) return false; return *version >= '2'; } void mitk::RenderingTestHelper::PrintGLInfo() { GLint maxTextureSize; glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize); ; MITK_INFO << "OpenGL Render Context Information: \n" << "- GL_VENDOR: " << glGetString(GL_VENDOR) << "\n" << "- GL_RENDERER: " << glGetString(GL_RENDERER) << "\n" << "- GL_VERSION: " << glGetString(GL_VERSION) << "\n" << "- GL_MAX_TEXTURE_SIZE: " << maxTextureSize << "\n" << "- GL_EXTENSIONS: " << glGetString(GL_EXTENSIONS); } void mitk::RenderingTestHelper::SetMapperID(mitk::BaseRenderer::StandardMapperSlot id) { m_RenderWindow->GetRenderer()->SetMapperID(id); } void mitk::RenderingTestHelper::SetMapperIDToRender3D() { this->SetMapperID(mitk::BaseRenderer::Standard3D); mitk::RenderingManager::GetInstance()->InitializeViews( this->GetDataStorage()->ComputeBoundingGeometry3D(this->GetDataStorage()->GetAll())); } void mitk::RenderingTestHelper::SetMapperIDToRender2D() { this->SetMapperID(mitk::BaseRenderer::Standard2D); } void mitk::RenderingTestHelper::Render() { // if the datastorage is initialized and at least 1 image is loaded render it if (m_DataStorage.IsNotNull() || m_DataStorage->GetAll()->Size() >= 1) { // Prepare the VTK camera before rendering. m_RenderWindow->GetRenderer()->PrepareRender(); this->GetVtkRenderWindow()->Render(); this->GetVtkRenderWindow()->WaitForCompletion(); if (m_AutomaticallyCloseRenderWindow == false) { // Use interaction to stop the test this->GetVtkRenderWindow()->GetInteractor()->Start(); } } else { MITK_ERROR << "No images loaded in data storage!"; } } mitk::DataStorage::Pointer mitk::RenderingTestHelper::GetDataStorage() { return m_DataStorage; } void mitk::RenderingTestHelper::SetInputFileNames(int argc, char *argv[]) { // i is set 1, because 0 is the testname as string // parse parameters for (int i = 1; i < argc; ++i) { // add everything to a list but -T and -V std::string tmp = argv[i]; if ((tmp.compare("-T")) && (tmp.compare("-V"))) { this->AddToStorage(tmp); } else { break; } } } void mitk::RenderingTestHelper::SetViewDirection(mitk::SliceNavigationController::ViewDirection viewDirection) { mitk::BaseRenderer::GetInstance(m_RenderWindow->GetVtkRenderWindow()) ->GetSliceNavigationController() ->SetDefaultViewDirection(viewDirection); mitk::RenderingManager::GetInstance()->InitializeViews( m_DataStorage->ComputeBoundingGeometry3D(m_DataStorage->GetAll())); } void mitk::RenderingTestHelper::ReorientSlices(mitk::Point3D origin, mitk::Vector3D rotation) { mitk::SliceNavigationController::Pointer sliceNavigationController = mitk::BaseRenderer::GetInstance(m_RenderWindow->GetVtkRenderWindow())->GetSliceNavigationController(); sliceNavigationController->ReorientSlices(origin, rotation); } vtkRenderer *mitk::RenderingTestHelper::GetVtkRenderer() { return m_RenderWindow->GetRenderer()->GetVtkRenderer(); } void mitk::RenderingTestHelper::SetImageProperty(const char *propertyKey, mitk::BaseProperty *property) { this->m_DataStorage->GetNode(mitk::NodePredicateDataType::New("Image"))->SetProperty(propertyKey, property); } vtkRenderWindow *mitk::RenderingTestHelper::GetVtkRenderWindow() { return m_RenderWindow->GetVtkRenderWindow(); } bool mitk::RenderingTestHelper::CompareRenderWindowAgainstReference(int argc, char *argv[], double threshold) { this->Render(); // retVal meanings: (see VTK/Rendering/vtkTesting.h) // 0 = test failed // 1 = test passed // 2 = test not run // 3 = something with vtkInteraction if (vtkTesting::Test(argc, argv, this->GetVtkRenderWindow(), threshold) == 1) return true; else return false; } // method to save a screenshot of the renderwindow (e.g. create a reference screenshot) void mitk::RenderingTestHelper::SaveAsPNG(std::string fileName) { vtkSmartPointer renderer = this->GetVtkRenderer(); bool doubleBuffering(renderer->GetRenderWindow()->GetDoubleBuffer()); renderer->GetRenderWindow()->DoubleBufferOff(); vtkSmartPointer magnifier = vtkSmartPointer::New(); magnifier->SetInput(renderer); magnifier->SetMagnification(1); vtkSmartPointer fileWriter = vtkSmartPointer::New(); fileWriter->SetInputConnection(magnifier->GetOutputPort()); fileWriter->SetFileName(fileName.c_str()); fileWriter->Write(); renderer->GetRenderWindow()->SetDoubleBuffer(doubleBuffering); } void mitk::RenderingTestHelper::SetAutomaticallyCloseRenderWindow(bool automaticallyCloseRenderWindow) { m_AutomaticallyCloseRenderWindow = automaticallyCloseRenderWindow; } void mitk::RenderingTestHelper::SaveReferenceScreenShot(std::string fileName) { this->SaveAsPNG(fileName); } void mitk::RenderingTestHelper::AddToStorage(const std::string &filename) { try { mitk::IOUtil::Load(filename, *m_DataStorage.GetPointer()); mitk::RenderingManager::GetInstance()->InitializeViews( m_DataStorage->ComputeBoundingGeometry3D(m_DataStorage->GetAll())); } catch (itk::ExceptionObject &e) { MITK_ERROR << "Failed loading test data '" << filename << "': " << e.what(); } } void mitk::RenderingTestHelper::AddNodeToStorage(mitk::DataNode::Pointer node) { this->m_DataStorage->Add(node); mitk::RenderingManager::GetInstance()->InitializeViews( m_DataStorage->ComputeBoundingGeometry3D(m_DataStorage->GetAll())); } diff --git a/Modules/Core/files.cmake b/Modules/Core/files.cmake index 44bd777c6e..a9ef533bff 100644 --- a/Modules/Core/files.cmake +++ b/Modules/Core/files.cmake @@ -1,316 +1,312 @@ file(GLOB_RECURSE H_FILES RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/include/*") set(CPP_FILES mitkCoreActivator.cpp mitkCoreObjectFactoryBase.cpp mitkCoreObjectFactory.cpp mitkCoreServices.cpp mitkException.cpp Algorithms/mitkBaseDataSource.cpp Algorithms/mitkClippedSurfaceBoundsCalculator.cpp Algorithms/mitkCompareImageDataFilter.cpp Algorithms/mitkCompositePixelValueToString.cpp Algorithms/mitkConvert2Dto3DImageFilter.cpp Algorithms/mitkDataNodeSource.cpp Algorithms/mitkExtractSliceFilter.cpp Algorithms/mitkHistogramGenerator.cpp Algorithms/mitkImageChannelSelector.cpp Algorithms/mitkImageSliceSelector.cpp Algorithms/mitkImageSource.cpp Algorithms/mitkImageTimeSelector.cpp Algorithms/mitkImageToImageFilter.cpp Algorithms/mitkImageToSurfaceFilter.cpp Algorithms/mitkMultiComponentImageDataComparisonFilter.cpp Algorithms/mitkPlaneGeometryDataToSurfaceFilter.cpp Algorithms/mitkPointSetSource.cpp Algorithms/mitkPointSetToPointSetFilter.cpp Algorithms/mitkRGBToRGBACastImageFilter.cpp Algorithms/mitkSubImageSelector.cpp Algorithms/mitkSurfaceSource.cpp Algorithms/mitkSurfaceToImageFilter.cpp Algorithms/mitkSurfaceToSurfaceFilter.cpp Algorithms/mitkUIDGenerator.cpp Algorithms/mitkVolumeCalculator.cpp Controllers/mitkBaseController.cpp Controllers/mitkCallbackFromGUIThread.cpp Controllers/mitkCameraController.cpp Controllers/mitkCameraRotationController.cpp Controllers/mitkLimitedLinearUndo.cpp Controllers/mitkOperationEvent.cpp Controllers/mitkPlanePositionManager.cpp Controllers/mitkProgressBar.cpp Controllers/mitkRenderingManager.cpp Controllers/mitkSliceNavigationController.cpp Controllers/mitkSlicesCoordinator.cpp Controllers/mitkStatusBar.cpp Controllers/mitkStepper.cpp Controllers/mitkTestManager.cpp Controllers/mitkUndoController.cpp Controllers/mitkVerboseLimitedLinearUndo.cpp Controllers/mitkVtkLayerController.cpp DataManagement/mitkAnatomicalStructureColorPresets.cpp DataManagement/mitkArbitraryTimeGeometry.cpp DataManagement/mitkAbstractTransformGeometry.cpp DataManagement/mitkAnnotationProperty.cpp DataManagement/mitkApplicationCursor.cpp DataManagement/mitkApplyTransformMatrixOperation.cpp DataManagement/mitkBaseData.cpp DataManagement/mitkBaseGeometry.cpp DataManagement/mitkBaseProperty.cpp DataManagement/mitkChannelDescriptor.cpp DataManagement/mitkClippingProperty.cpp DataManagement/mitkColorProperty.cpp DataManagement/mitkDataNode.cpp DataManagement/mitkDataStorage.cpp DataManagement/mitkEnumerationProperty.cpp DataManagement/mitkFloatPropertyExtension.cpp DataManagement/mitkGeometry3D.cpp DataManagement/mitkGeometryData.cpp DataManagement/mitkGeometryTransformHolder.cpp DataManagement/mitkGroupTagProperty.cpp DataManagement/mitkImageAccessorBase.cpp DataManagement/mitkImageCaster.cpp DataManagement/mitkImageCastPart1.cpp DataManagement/mitkImageCastPart2.cpp DataManagement/mitkImageCastPart3.cpp DataManagement/mitkImageCastPart4.cpp DataManagement/mitkImage.cpp DataManagement/mitkImageDataItem.cpp DataManagement/mitkImageDescriptor.cpp DataManagement/mitkImageReadAccessor.cpp DataManagement/mitkImageStatisticsHolder.cpp DataManagement/mitkImageVtkAccessor.cpp DataManagement/mitkImageVtkReadAccessor.cpp DataManagement/mitkImageVtkWriteAccessor.cpp DataManagement/mitkImageWriteAccessor.cpp DataManagement/mitkIntPropertyExtension.cpp DataManagement/mitkIPersistenceService.cpp DataManagement/mitkIPropertyAliases.cpp DataManagement/mitkIPropertyDescriptions.cpp DataManagement/mitkIPropertyExtensions.cpp DataManagement/mitkIPropertyFilters.cpp DataManagement/mitkIPropertyPersistence.cpp DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.cpp DataManagement/mitkLandmarkProjector.cpp DataManagement/mitkLevelWindow.cpp DataManagement/mitkLevelWindowManager.cpp DataManagement/mitkLevelWindowPreset.cpp DataManagement/mitkLevelWindowProperty.cpp DataManagement/mitkLine.cpp DataManagement/mitkLookupTable.cpp DataManagement/mitkLookupTableProperty.cpp DataManagement/mitkLookupTables.cpp # specializations of GenericLookupTable DataManagement/mitkMaterial.cpp DataManagement/mitkMemoryUtilities.cpp DataManagement/mitkModalityProperty.cpp DataManagement/mitkModifiedLock.cpp DataManagement/mitkNodePredicateAnd.cpp DataManagement/mitkNodePredicateBase.cpp DataManagement/mitkNodePredicateCompositeBase.cpp DataManagement/mitkNodePredicateData.cpp DataManagement/mitkNodePredicateDataType.cpp DataManagement/mitkNodePredicateDimension.cpp DataManagement/mitkNodePredicateFirstLevel.cpp DataManagement/mitkNodePredicateNot.cpp DataManagement/mitkNodePredicateOr.cpp DataManagement/mitkNodePredicateProperty.cpp DataManagement/mitkNodePredicateDataProperty.cpp DataManagement/mitkNodePredicateSource.cpp DataManagement/mitkNumericConstants.cpp DataManagement/mitkPlaneGeometry.cpp DataManagement/mitkPlaneGeometryData.cpp DataManagement/mitkPlaneOperation.cpp DataManagement/mitkPlaneOrientationProperty.cpp DataManagement/mitkPointOperation.cpp DataManagement/mitkPointSet.cpp DataManagement/mitkPointSetShapeProperty.cpp DataManagement/mitkProperties.cpp DataManagement/mitkPropertyAliases.cpp DataManagement/mitkPropertyDescriptions.cpp DataManagement/mitkPropertyExtension.cpp DataManagement/mitkPropertyExtensions.cpp DataManagement/mitkPropertyFilter.cpp DataManagement/mitkPropertyFilters.cpp DataManagement/mitkPropertyList.cpp DataManagement/mitkPropertyListReplacedObserver.cpp DataManagement/mitkPropertyNameHelper.cpp DataManagement/mitkPropertyObserver.cpp DataManagement/mitkPropertyPersistence.cpp DataManagement/mitkPropertyPersistenceInfo.cpp DataManagement/mitkProportionalTimeGeometry.cpp DataManagement/mitkRenderingModeProperty.cpp DataManagement/mitkResliceMethodProperty.cpp DataManagement/mitkRestorePlanePositionOperation.cpp DataManagement/mitkRotationOperation.cpp DataManagement/mitkScaleOperation.cpp DataManagement/mitkShaderProperty.cpp DataManagement/mitkSlicedData.cpp DataManagement/mitkSlicedGeometry3D.cpp DataManagement/mitkSmartPointerProperty.cpp DataManagement/mitkStandaloneDataStorage.cpp DataManagement/mitkStringProperty.cpp DataManagement/mitkSurface.cpp DataManagement/mitkSurfaceOperation.cpp DataManagement/mitkThinPlateSplineCurvedGeometry.cpp DataManagement/mitkTimeGeometry.cpp DataManagement/mitkTransferFunction.cpp DataManagement/mitkTransferFunctionInitializer.cpp DataManagement/mitkTransferFunctionProperty.cpp DataManagement/mitkTemporoSpatialStringProperty.cpp DataManagement/mitkVector.cpp DataManagement/mitkVectorProperty.cpp DataManagement/mitkVtkInterpolationProperty.cpp DataManagement/mitkVtkRepresentationProperty.cpp DataManagement/mitkVtkResliceInterpolationProperty.cpp DataManagement/mitkVtkScalarModeProperty.cpp DataManagement/mitkVtkVolumeRenderingProperty.cpp DataManagement/mitkWeakPointerProperty.cpp Interactions/mitkAction.cpp Interactions/mitkBindDispatcherInteractor.cpp Interactions/mitkCrosshairPositionEvent.cpp Interactions/mitkDataInteractor.cpp Interactions/mitkDispatcher.cpp Interactions/mitkDisplayCoordinateOperation.cpp Interactions/mitkDisplayInteractor.cpp Interactions/mitkEventConfig.cpp Interactions/mitkEventFactory.cpp Interactions/mitkEventRecorder.cpp Interactions/mitkEventStateMachine.cpp Interactions/mitkInteractionEventConst.cpp Interactions/mitkInteractionEvent.cpp Interactions/mitkInteractionEventHandler.cpp Interactions/mitkInteractionEventObserver.cpp Interactions/mitkInteractionKeyEvent.cpp Interactions/mitkInteractionPositionEvent.cpp Interactions/mitkInternalEvent.cpp Interactions/mitkMouseDoubleClickEvent.cpp Interactions/mitkMouseModeSwitcher.cpp Interactions/mitkMouseMoveEvent.cpp Interactions/mitkMousePressEvent.cpp Interactions/mitkMouseReleaseEvent.cpp Interactions/mitkMouseWheelEvent.cpp Interactions/mitkPointSetDataInteractor.cpp Interactions/mitkSinglePointDataInteractor.cpp Interactions/mitkStateMachineAction.cpp Interactions/mitkStateMachineCondition.cpp Interactions/mitkStateMachineContainer.cpp Interactions/mitkStateMachineState.cpp Interactions/mitkStateMachineTransition.cpp Interactions/mitkVtkEventAdapter.cpp Interactions/mitkVtkInteractorStyle.cxx Interactions/mitkXML2EventParser.cpp IO/mitkAbstractFileIO.cpp IO/mitkAbstractFileReader.cpp IO/mitkAbstractFileWriter.cpp IO/mitkCustomMimeType.cpp IO/mitkDicomSeriesReader.cpp IO/mitkDicomSeriesReaderService.cpp IO/mitkDicomSR_GantryTiltInformation.cpp IO/mitkDicomSR_ImageBlockDescriptor.cpp IO/mitkDicomSR_LoadDICOMRGBPixel4D.cpp IO/mitkDicomSR_LoadDICOMRGBPixel.cpp IO/mitkDicomSR_LoadDICOMScalar4D.cpp IO/mitkDicomSR_LoadDICOMScalar.cpp IO/mitkDicomSR_SliceGroupingResult.cpp IO/mitkFileReader.cpp IO/mitkFileReaderRegistry.cpp IO/mitkFileReaderSelector.cpp IO/mitkFileReaderWriterBase.cpp IO/mitkFileWriter.cpp IO/mitkFileWriterRegistry.cpp IO/mitkFileWriterSelector.cpp IO/mitkGeometry3DToXML.cpp IO/mitkIFileIO.cpp IO/mitkIFileReader.cpp IO/mitkIFileWriter.cpp IO/mitkGeometryDataReaderService.cpp IO/mitkGeometryDataWriterService.cpp IO/mitkImageGenerator.cpp IO/mitkImageVtkLegacyIO.cpp IO/mitkImageVtkXmlIO.cpp IO/mitkIMimeTypeProvider.cpp IO/mitkIOConstants.cpp IO/mitkIOMimeTypes.cpp IO/mitkIOUtil.cpp IO/mitkItkImageIO.cpp IO/mitkItkLoggingAdapter.cpp IO/mitkLegacyFileReaderService.cpp IO/mitkLegacyFileWriterService.cpp IO/mitkLocaleSwitch.cpp IO/mitkLog.cpp IO/mitkMimeType.cpp IO/mitkMimeTypeProvider.cpp IO/mitkOperation.cpp IO/mitkPixelType.cpp IO/mitkPointSetReaderService.cpp IO/mitkPointSetWriterService.cpp IO/mitkProportionalTimeGeometryToXML.cpp IO/mitkRawImageFileReader.cpp IO/mitkStandardFileLocations.cpp IO/mitkSurfaceStlIO.cpp IO/mitkSurfaceVtkIO.cpp IO/mitkSurfaceVtkLegacyIO.cpp IO/mitkSurfaceVtkXmlIO.cpp IO/mitkVtkLoggingAdapter.cpp - Rendering/mitkAbstractOverlayLayouter.cpp + Rendering/mitkAbstractAnnotationRenderer.cpp + Rendering/mitkAnnotationUtils.cpp Rendering/mitkBaseRenderer.cpp #Rendering/mitkGLMapper.cpp Moved to deprecated LegacyGL Module Rendering/mitkGradientBackground.cpp Rendering/mitkImageVtkMapper2D.cpp Rendering/mitkIShaderRepository.cpp - Rendering/mitkManufacturerLogo.cpp Rendering/mitkMapper.cpp - Rendering/mitkOverlay.cpp - Rendering/mitkOverlayManager.cpp + Rendering/mitkAnnotation.cpp Rendering/mitkPlaneGeometryDataMapper2D.cpp Rendering/mitkPlaneGeometryDataVtkMapper3D.cpp Rendering/mitkPointSetVtkMapper2D.cpp Rendering/mitkPointSetVtkMapper3D.cpp Rendering/mitkRenderWindowBase.cpp Rendering/mitkRenderWindow.cpp Rendering/mitkRenderWindowFrame.cpp #Rendering/mitkSurfaceGLMapper2D.cpp Moved to deprecated LegacyGL Module Rendering/mitkSurfaceVtkMapper2D.cpp Rendering/mitkSurfaceVtkMapper3D.cpp Rendering/mitkVtkEventProvider.cpp Rendering/mitkVtkMapper.cpp - Rendering/mitkVtkOverlay2D.cpp - Rendering/mitkVtkOverlay3D.cpp - Rendering/mitkVtkOverlay.cpp Rendering/mitkVtkPropRenderer.cpp Rendering/mitkVtkWidgetRendering.cpp Rendering/vtkMitkLevelWindowFilter.cpp Rendering/vtkMitkRectangleProp.cpp Rendering/vtkMitkRenderProp.cpp Rendering/vtkMitkThickSlicesFilter.cpp Rendering/vtkNeverTranslucentTexture.cpp ) set(RESOURCE_FILES Interactions/globalConfig.xml Interactions/DisplayInteraction.xml Interactions/DisplayConfig.xml Interactions/DisplayConfigPACS.xml Interactions/DisplayConfigPACSPan.xml Interactions/DisplayConfigPACSScroll.xml Interactions/DisplayConfigPACSZoom.xml Interactions/DisplayConfigPACSLevelWindow.xml Interactions/DisplayConfigMITK.xml Interactions/DisplayConfigMITKNoCrosshair.xml Interactions/DisplayConfigMITKRotation.xml Interactions/DisplayConfigMITKRotationUnCoupled.xml Interactions/DisplayConfigMITKSwivel.xml Interactions/DisplayConfigMITKLimited.xml Interactions/PointSet.xml Interactions/Legacy/StateMachine.xml Interactions/Legacy/DisplayConfigMITKTools.xml Interactions/PointSetConfig.xml mitkLevelWindowPresets.xml mitkAnatomicalStructureColorPresets.xml ) diff --git a/Modules/Core/include/mitkAbstractAnnotationRenderer.h b/Modules/Core/include/mitkAbstractAnnotationRenderer.h new file mode 100644 index 0000000000..8747bb0b7d --- /dev/null +++ b/Modules/Core/include/mitkAbstractAnnotationRenderer.h @@ -0,0 +1,82 @@ +/*=================================================================== + * +The Medical Imaging Interaction Toolkit (MITK) + +Copyright (c) German Cancer Research Center, +Division of Medical and Biological Informatics. +All rights reserved. + +This software is distributed WITHOUT ANY WARRANTY; without +even the implied warranty of MERCHANTABILITY or FITNESS FOR +A PARTICULAR PURPOSE. + +See LICENSE.txt or http://www.mitk.org for details. + +===================================================================*/ + +#ifndef ABSTRACTANNOTATIONRENDERER_H +#define ABSTRACTANNOTATIONRENDERER_H + +#include "mitkAnnotation.h" +#include "mitkServiceInterface.h" +#include "usGetModuleContext.h" +#include "usServiceTracker.h" +#include +#include + +namespace mitk +{ + class BaseRenderer; + + /** @brief Baseclass of Annotation layouters + * An AbstractAnnotationRenderer can be implemented to control a set of Annotation by means of position and size. + * @ingroup Annotation + */ + class MITKCORE_EXPORT AbstractAnnotationRenderer : public us::ServiceTracker + { + public: + typedef us::ServiceTracker Superclass; + AbstractAnnotationRenderer(const std::string &rendererID, const std::string &arID); + + /** \brief virtual destructor in order to derive from this class */ + virtual ~AbstractAnnotationRenderer(); + + const std::string GetID() const; + const std::string GetRendererID() const; + + void CurrentBaseRendererChanged(); + + virtual void OnRenderWindowModified() {} + void RemoveAllAnnotation(); + + void Update(); + static const std::string US_INTERFACE_NAME; + static const std::string US_PROPKEY_ID; + static const std::string US_PROPKEY_RENDERER_ID; + + protected: + BaseRenderer *GetCurrentBaseRenderer(); + + private: + /** \brief copy constructor */ + AbstractAnnotationRenderer(const AbstractAnnotationRenderer &); + + /** \brief assignment operator */ + AbstractAnnotationRenderer &operator=(const AbstractAnnotationRenderer &); + + TrackedType AddingService(const ServiceReferenceType &reference) override; + + void ModifiedService(const ServiceReferenceType & /*reference*/, TrackedType tracked) override; + + void RemovedService(const ServiceReferenceType & /*reference*/, TrackedType tracked) override; + + virtual void OnAnnotationRenderersChanged() {} + const std::string m_RendererID; + const std::string m_ID; + }; + +} // namespace mitk + +MITK_DECLARE_SERVICE_INTERFACE(mitk::AbstractAnnotationRenderer, "org.mitk.services.AbstractAnnotationRenderer") + +#endif // ABSTRACTANNOTATIONRENDERER_H diff --git a/Modules/Core/include/mitkAbstractOverlayLayouter.h b/Modules/Core/include/mitkAbstractOverlayLayouter.h deleted file mode 100644 index 6e297bb679..0000000000 --- a/Modules/Core/include/mitkAbstractOverlayLayouter.h +++ /dev/null @@ -1,93 +0,0 @@ -/*=================================================================== - * -The Medical Imaging Interaction Toolkit (MITK) - -Copyright (c) German Cancer Research Center, -Division of Medical and Biological Informatics. -All rights reserved. - -This software is distributed WITHOUT ANY WARRANTY; without -even the implied warranty of MERCHANTABILITY or FITNESS FOR -A PARTICULAR PURPOSE. - -See LICENSE.txt or http://www.mitk.org for details. - -===================================================================*/ - -#ifndef ABSTRACTOVERLAYLAYOUTER_H -#define ABSTRACTOVERLAYLAYOUTER_H - -#include "mitkOverlay.h" -#include -#include -#include - -namespace mitk -{ - class BaseRenderer; - - /** @brief Baseclass of Overlay layouters */ - /** - *A AbstractOverlayLayouter can be implemented to control a set of Overlays by means of position and size. - *AbstractOverlayLayouter::PrepareLayout() should be implemented with a routine to set the position of the internal - *m_ManagedOverlays List. - *A layouter is always connected to one BaseRenderer, so there is one instance of the layouter for each BaseRenderer. - *One type of layouter should always have a unique identifier. - *@ingroup Overlays - */ - class MITKCORE_EXPORT AbstractOverlayLayouter : public itk::LightObject - { - public: - mitkClassMacroItkParent(AbstractOverlayLayouter, itk::LightObject); - - void SetBaseRenderer(BaseRenderer *renderer); - BaseRenderer *GetBaseRenderer(); - - /** \brief Adds an Overlay to the internal list of managed Overlays.*/ - /** By calling this, the previous Layouter of the passed Overlays is called to remove this overlay from its internal - * list.*/ - void AddOverlay(Overlay *Overlay); - - /** \brief Removes the passed Overlay from the m_ManagedOverlays List */ - void RemoveOverlay(Overlay *Overlay); - - /** \brief Returns a unique identifier for one specific kind of layouter.*/ - std::string GetIdentifier() const; - - /** \brief Sets the positions of each managed overlay according to the layouter role*/ - /** This has to be implemented in order to provide a layouting procedure for the list of managed Overlays. - * The method has to provide a layouting for each identifier.*/ - virtual void PrepareLayout() = 0; - - protected: - /** \brief explicit constructor which disallows implicit conversions */ - explicit AbstractOverlayLayouter(); - - /** \brief virtual destructor in order to derive from this class */ - virtual ~AbstractOverlayLayouter(); - - /** \brief returns a list of the overlays that is managed by this Layouter. */ - std::list GetManagedOverlays() const; - - /** \brief A unique identifier for one specific kind of layouter.*/ - /** If the implementation of the layouter can manage the overlay positions in different ways, each instance has to - have - its own unique identifier.*/ - std::string m_Identifier; - - private: - /** \brief The baserenderer on which this layouter is active. */ - mitk::BaseRenderer *m_BaseRenderer; - - /** \brief List of the overlays managed by this layouter. */ - std::list m_ManagedOverlays; - - /** \brief copy constructor */ - AbstractOverlayLayouter(const AbstractOverlayLayouter &); - - /** \brief assignment operator */ - AbstractOverlayLayouter &operator=(const AbstractOverlayLayouter &); - }; - -} // namespace mitk -#endif // ABSTRACTOVERLAYLAYOUTER_H diff --git a/Modules/Core/include/mitkOverlay.h b/Modules/Core/include/mitkAnnotation.h similarity index 64% rename from Modules/Core/include/mitkOverlay.h rename to Modules/Core/include/mitkAnnotation.h index 2826c3668a..0c8b1f4ef3 100644 --- a/Modules/Core/include/mitkOverlay.h +++ b/Modules/Core/include/mitkAnnotation.h @@ -1,458 +1,462 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ -#ifndef OVERLAY_H -#define OVERLAY_H +#ifndef Annotation_H +#define Annotation_H +#include "mitkServiceInterface.h" +#include "usServiceRegistration.h" #include #include #include namespace mitk { - class AbstractOverlayLayouter; - - /** \brief Base class for all overlays */ - /** This class is to be implemented in order to create overlays which are managed by the OverlayManager and can be - placed by a AbstractOverlayLayouter. - This class contains an internal Propertylist, and another PropertyList for each BaseRenderer. - A property that is specified for a specific renderer always overrides the general internal property of the same name. - AddOverlay, RemoveOverlay and UpdateOverlay methods have to be implemented.*/ - class MITKCORE_EXPORT Overlay : public itk::Object + /** \brief Base class for all Annotation + * This class is to be implemented in order to create Annotation which are managed by a AbstractAnnotationRenderer. + * This class contains an internal Propertylist for configuring the appearance of the implemented Overlay. */ + class MITKCORE_EXPORT Annotation : public itk::Object { - friend class AbstractOverlayLayouter; - public: /** \brief Container for position and size on the display.*/ struct Bounds { itk::Point Position; itk::Point Size; }; - typedef std::map MapOfPropertyLists; - /** \brief Base class for mapper specific rendering ressources. */ class MITKCORE_EXPORT BaseLocalStorage { public: - bool IsGenerateDataRequired(mitk::BaseRenderer *renderer, mitk::Overlay *overlay); + bool IsGenerateDataRequired(mitk::BaseRenderer *renderer, mitk::Annotation *Annotation); inline void UpdateGenerateDataTime() { m_LastGenerateDataTime.Modified(); } inline itk::TimeStamp &GetLastGenerateDataTime() { return m_LastGenerateDataTime; } protected: /** \brief timestamp of last update of stored data */ itk::TimeStamp m_LastGenerateDataTime; }; /** * @brief Set the property (instance of BaseProperty) with key @a propertyKey in the PropertyList * of the @a renderer (if NULL, use BaseRenderer-independent PropertyList). This is set-by-value. * * @warning Change in semantics since Aug 25th 2006. Check your usage of this method if you do * more with properties than just call SetProperty( "key", new SomeProperty("value") ). * * @sa GetProperty * @sa m_PropertyList * @sa m_MapOfPropertyLists */ - void SetProperty(const std::string &propertyKey, - const BaseProperty::Pointer &property, - const mitk::BaseRenderer *renderer = nullptr); + void SetProperty(const std::string &propertyKey, const BaseProperty::Pointer &property); /** * @brief Replace the property (instance of BaseProperty) with key @a propertyKey in the PropertyList * of the @a renderer (if NULL, use BaseRenderer-independent PropertyList). This is set-by-reference. * * If @a renderer is @a NULL the property is set in the BaseRenderer-independent - * PropertyList of this Overlay. + * PropertyList of this Annotation. * @sa GetProperty * @sa m_PropertyList * @sa m_MapOfPropertyLists */ - void ReplaceProperty(const std::string &propertyKey, - const BaseProperty::Pointer &property, - const mitk::BaseRenderer *renderer = nullptr); + void ReplaceProperty(const std::string &propertyKey, const BaseProperty::Pointer &property); /** * @brief Add the property (instance of BaseProperty) if it does * not exist (or always if \a overwrite is \a true) * with key @a propertyKey in the PropertyList * of the @a renderer (if NULL, use BaseRenderer-independent * PropertyList). This is set-by-value. * * For \a overwrite == \a false the property is \em not changed * if it already exists. For \a overwrite == \a true the method * is identical to SetProperty. * * @sa SetProperty * @sa GetProperty * @sa m_PropertyList * @sa m_MapOfPropertyLists */ - void AddProperty(const std::string &propertyKey, - const BaseProperty::Pointer &property, - const mitk::BaseRenderer *renderer = nullptr, - bool overwrite = false); - - /** - * @brief Get the PropertyList of the @a renderer. If @a renderer is @a - * NULL, the BaseRenderer-independent PropertyList of this Overlay - * is returned. - * @sa GetProperty - * @sa m_PropertyList - * @sa m_MapOfPropertyLists - */ - mitk::PropertyList *GetPropertyList(const mitk::BaseRenderer *renderer = nullptr) const; + void AddProperty(const std::string &propertyKey, const BaseProperty::Pointer &property, bool overwrite = false); /** * @brief Add values from another PropertyList. * * Overwrites values in m_PropertyList only when possible (i.e. when types are compatible). * If you want to allow for object type changes (replacing a "visible":BoolProperty with "visible":IntProperty, * set the @param replace. * * @param replace true: if @param pList contains a property "visible" of type ColorProperty and our m_PropertyList - * also - * has a "visible" property of a different type (e.g. BoolProperty), change the type, i.e. replace the objects behind - * the pointer. + * also has a "visible" property of a different type (e.g. BoolProperty), change the type, i.e. replace the objects + * behind the pointer. * * @sa SetProperty * @sa ReplaceProperty * @sa m_PropertyList */ void ConcatenatePropertyList(PropertyList *pList, bool replace = false); /** * @brief Get the property (instance of BaseProperty) with key @a propertyKey from the PropertyList * of the @a renderer, if available there, otherwise use the BaseRenderer-independent PropertyList. * * If @a renderer is @a NULL or the @a propertyKey cannot be found * in the PropertyList specific to @a renderer or is disabled there, the BaseRenderer-independent - * PropertyList of this Overlay is queried. + * PropertyList of this Annotation is queried. * @sa GetPropertyList * @sa m_PropertyList * @sa m_MapOfPropertyLists */ - mitk::BaseProperty *GetProperty(const std::string &propertyKey, const mitk::BaseRenderer *renderer = nullptr) const; + mitk::BaseProperty *GetProperty(const std::string &propertyKey) const; /** * @brief Get the property of type T with key @a propertyKey from the PropertyList * of the @a renderer, if available there, otherwise use the BaseRenderer-independent PropertyList. * * If @a renderer is @a NULL or the @a propertyKey cannot be found * in the PropertyList specific to @a renderer or is disabled there, the BaseRenderer-independent - * PropertyList of this Overlay is queried. + * PropertyList of this Annotation is queried. * @sa GetPropertyList * @sa m_PropertyList * @sa m_MapOfPropertyLists */ template - bool GetProperty(itk::SmartPointer &property, - const std::string &propertyKey, - const mitk::BaseRenderer *renderer = nullptr) const + bool GetProperty(itk::SmartPointer &property, const std::string &propertyKey) const { - property = dynamic_cast(GetProperty(propertyKey, renderer)); + property = dynamic_cast(GetProperty(propertyKey)); return property.IsNotNull(); } /** * @brief Get the property of type T with key @a propertyKey from the PropertyList * of the @a renderer, if available there, otherwise use the BaseRenderer-independent PropertyList. * * If @a renderer is @a NULL or the @a propertyKey cannot be found * in the PropertyList specific to @a renderer or is disabled there, the BaseRenderer-independent - * PropertyList of this Overlay is queried. + * PropertyList of this Annotation is queried. * @sa GetPropertyList * @sa m_PropertyList * @sa m_MapOfPropertyLists */ template - bool GetProperty(T *&property, const std::string &propertyKey, const mitk::BaseRenderer *renderer = nullptr) const + bool GetProperty(T *&property, const std::string &propertyKey) const { - property = dynamic_cast(GetProperty(propertyKey, renderer)); + property = dynamic_cast(GetProperty(propertyKey)); return property != nullptr; } /** * @brief Convenience access method for GenericProperty properties * (T being the type of the second parameter) * @return @a true property was found */ template - bool GetPropertyValue(const std::string &propertyKey, T &value, mitk::BaseRenderer *renderer = nullptr) const + bool GetPropertyValue(const std::string &propertyKey, T &value) const { - GenericProperty *gp = dynamic_cast *>(GetProperty(propertyKey, renderer)); + GenericProperty *gp = dynamic_cast *>(GetProperty(propertyKey)); if (gp != nullptr) { value = gp->GetValue(); return true; } return false; } /** * @brief Convenience access method for bool properties (instances of * BoolProperty) * @return @a true property was found */ - bool GetBoolProperty(const std::string &propertyKey, bool &boolValue, mitk::BaseRenderer *renderer = nullptr) const; + bool GetBoolProperty(const std::string &propertyKey, bool &boolValue) const; /** * @brief Convenience access method for int properties (instances of * IntProperty) * @return @a true property was found */ - bool GetIntProperty(const std::string &propertyKey, int &intValue, mitk::BaseRenderer *renderer = nullptr) const; + bool GetIntProperty(const std::string &propertyKey, int &intValue) const; /** * @brief Convenience access method for float properties (instances of * FloatProperty) * @return @a true property was found */ - bool GetFloatProperty(const std::string &propertyKey, - float &floatValue, - mitk::BaseRenderer *renderer = nullptr) const; + bool GetFloatProperty(const std::string &propertyKey, float &floatValue) const; + + /** + * @brief Convenience access method for double properties (instances of + * DoubleProperty) + * @return @a true property was found + */ + bool GetDoubleProperty(const std::string &propertyKey, double &doubleValue) const; /** * @brief Convenience access method for string properties (instances of * StringProperty) * @return @a true property was found */ - bool GetStringProperty(const std::string &propertyKey, - std::string &string, - mitk::BaseRenderer *renderer = nullptr) const; + bool GetStringProperty(const std::string &propertyKey, std::string &string) const; + + /** + * @brief Convenience method for setting int properties (instances of + * IntProperty) + */ + void SetIntProperty(const std::string &propertyKey, int intValue); /** * @brief Convenience method for setting int properties (instances of * IntProperty) */ - void SetIntProperty(const std::string &propertyKey, int intValue, mitk::BaseRenderer *renderer = nullptr); + void SetBoolProperty(const std::string &propertyKey, bool boolValue); /** * @brief Convenience method for setting int properties (instances of * IntProperty) */ - void SetBoolProperty(const std::string &propertyKey, bool boolValue, mitk::BaseRenderer *renderer = nullptr); + void SetFloatProperty(const std::string &propertyKey, float floatValue); /** * @brief Convenience method for setting int properties (instances of * IntProperty) */ - void SetFloatProperty(const std::string &propertyKey, float floatValue, mitk::BaseRenderer *renderer = nullptr); + void SetDoubleProperty(const std::string &propertyKey, double doubleValue); /** * @brief Convenience method for setting int properties (instances of * IntProperty) */ - void SetStringProperty(const std::string &propertyKey, - const std::string &string, - mitk::BaseRenderer *renderer = nullptr); + void SetStringProperty(const std::string &propertyKey, const std::string &string); /** * @brief Convenience access method for boolean properties (instances * of BoolProperty). Return value is the value of the property. If the property is * not found, the value of @a defaultIsOn is returned. * * Thus, the return value has a different meaning than in the * GetBoolProperty method! * @sa GetBoolProperty */ - bool IsOn(const std::string &propertyKey, mitk::BaseRenderer *renderer, bool defaultIsOn = true) const + bool IsOn(const std::string &propertyKey, bool defaultIsOn = true) const { - GetBoolProperty(propertyKey, defaultIsOn, renderer); + GetBoolProperty(propertyKey, defaultIsOn); return defaultIsOn; } /** * @brief Convenience access method for accessing the name of an object (instance of * StringProperty with property-key "name") * @return @a true property was found */ - bool GetName(std::string &nodeName, - mitk::BaseRenderer *renderer = nullptr, - const std::string &propertyKey = "name") const; + bool GetName(std::string &nodeName, const std::string &propertyKey = "name") const; /** * @brief Extra convenience access method for accessing the name of an object (instance of * StringProperty with property-key "name"). * * This method does not take the renderer specific * propertylists into account, because the name of an object should never be renderer specific. * @returns a std::string with the name of the object (content of "name" Property). * If there is no "name" Property, an empty string will be returned. */ virtual std::string GetName() const; /** * @brief Extra convenience access method to set the name of an object. * * The name will be stored in the non-renderer-specific PropertyList in a StringProperty named "name". */ virtual void SetName(const std::string &name); /** * @brief Convenience access method for color properties (instances of * ColorProperty) * @return @a true property was found */ - bool GetColor(float rgb[], mitk::BaseRenderer *renderer = nullptr, const std::string &propertyKey = "color") const; + bool GetColor(float rgb[], const std::string &propertyKey = "color") const; /** * @brief Convenience method for setting color properties (instances of * ColorProperty) */ - void SetColor(const mitk::Color &color, - mitk::BaseRenderer *renderer = nullptr, - const std::string &propertyKey = "color"); + void SetColor(const mitk::Color &color, const std::string &propertyKey = "color"); /** * @brief Convenience method for setting color properties (instances of * ColorProperty) */ - void SetColor(float red, - float green, - float blue, - mitk::BaseRenderer *renderer = nullptr, - const std::string &propertyKey = "color"); + void SetColor(float red, float green, float blue, const std::string &propertyKey = "color"); /** * @brief Convenience method for setting color properties (instances of * ColorProperty) */ - void SetColor(const float rgb[], mitk::BaseRenderer *renderer = nullptr, const std::string &propertyKey = "color"); + void SetColor(const float rgb[], const std::string &propertyKey = "color"); /** * @brief Convenience access method for opacity properties (instances of * FloatProperty) * @return @a true property was found */ - bool GetOpacity(float &opacity, mitk::BaseRenderer *renderer, const std::string &propertyKey = "opacity") const; + bool GetOpacity(float &opacity, const std::string &propertyKey = "opacity") const; /** * @brief Convenience method for setting opacity properties (instances of * FloatProperty) */ - void SetOpacity(float opacity, mitk::BaseRenderer *renderer = nullptr, const std::string &propertyKey = "opacity"); + void SetOpacity(float opacity, const std::string &propertyKey = "opacity"); - void SetText(std::string text, mitk::BaseRenderer *renderer = nullptr); + void SetText(std::string text); - std::string GetText(mitk::BaseRenderer *renderer = nullptr) const; + std::string GetText() const; - void SetFontSize(int fontSize, mitk::BaseRenderer *renderer = nullptr); + void SetFontSize(int fontSize); - int GetFontSize(mitk::BaseRenderer *renderer = nullptr) const; + int GetFontSize() const; /** * @brief Convenience access method for visibility properties (instances * of BoolProperty with property-key "visible") * @return @a true property was found * @sa IsVisible */ - bool GetVisibility(bool &visible, mitk::BaseRenderer *renderer, const std::string &propertyKey = "visible") const; + bool GetVisibility(bool &visible, const std::string &propertyKey = "visible") const; /** * @brief Convenience access method for visibility properties (instances * of BoolProperty). Return value is the visibility. Default is * visible==true, i.e., true is returned even if the property (@a * propertyKey) is not found. * * Thus, the return value has a different meaning than in the * GetVisibility method! * @sa GetVisibility * @sa IsOn */ - bool IsVisible(mitk::BaseRenderer *renderer, - const std::string &propertyKey = "visible", - bool defaultIsOn = true) const; + bool IsVisible(const std::string &propertyKey = "visible", bool defaultIsOn = true) const; /** * @brief Convenience method for setting visibility properties (instances * of BoolProperty) * @param visible If set to true, the data will be rendered. If false, the render will skip this data. * @param renderer Specify a renderer if the visibility shall be specific to a renderer * @param propertykey Can be used to specify a user defined name of the visibility propery. */ - void SetVisibility(bool visible, - mitk::BaseRenderer *renderer = nullptr, - const std::string &propertyKey = "visible"); + void SetVisibility(bool visible, const std::string &propertyKey = "visible"); - /** \brief Adds the overlay to the specified renderer. Update Overlay should be called soon in order to apply all + /** \brief Adds the Annotation to the specified renderer. Update Annotation should be called soon in order to apply + * all * properties*/ virtual void AddToBaseRenderer(BaseRenderer *renderer) = 0; - /** \brief Adds the overlay to the specified renderer. Update Overlay should be called soon in order to apply all + /** \brief Adds the Annotation to the specified renderer. Update Annotation should be called soon in order to apply + * all * properties*/ virtual void AddToRenderer(BaseRenderer *renderer, vtkRenderer *vtkrenderer) = 0; - /** \brief Removes the overlay from the specified renderer. It is not visible anymore then.*/ + /** \brief Removes the Annotation from the specified renderer. It is not visible anymore then.*/ virtual void RemoveFromBaseRenderer(BaseRenderer *renderer) = 0; - /** \brief Removes the overlay from the specified renderer. It is not visible anymore then.*/ + /** \brief Removes the Annotation from the specified renderer. It is not visible anymore then.*/ virtual void RemoveFromRenderer(BaseRenderer *renderer, vtkRenderer *vtkrenderer) = 0; /** \brief Applies all properties and should be called before the rendering procedure.*/ virtual void Update(BaseRenderer *renderer) = 0; - /** \brief Returns position and size of the overlay on the display.*/ + /** \brief Returns position and size of the Annotation on the display.*/ virtual Bounds GetBoundsOnDisplay(BaseRenderer *renderer) const; - /** \brief Sets position and size of the overlay on the display.*/ + /** \brief Sets position and size of the Annotation on the display.*/ virtual void SetBoundsOnDisplay(BaseRenderer *renderer, const Bounds &); void SetForceInForeground(bool forceForeground); bool IsForceInForeground() const; - mitkClassMacroItkParent(Overlay, itk::Object); + PropertyList *GetPropertyList() const; + + /** + *\brief Returns the id that this device is registered with. The id will only be valid, if the + * Annotation has been registered using RegisterAsMicroservice(). + */ + std::string GetMicroserviceID(); + + /** + *\brief These Constants are used in conjunction with Microservices + */ + static const std::string US_INTERFACE_NAME; + static const std::string US_PROPKEY_AnnotationNAME; + static const std::string US_PROPKEY_ID; + static const std::string US_PROPKEY_MODIFIED; + static const std::string US_PROPKEY_RENDERER_ID; + static const std::string US_PROPKEY_AR_ID; + + /** + *\brief Registers this object as a Microservice, making it available to every module and/or plugin. + * To unregister, call UnregisterMicroservice(). + */ + virtual void RegisterAsMicroservice(us::ServiceProperties props); + + /** + *\brief Registers this object as a Microservice, making it available to every module and/or plugin. + */ + virtual void UnRegisterMicroservice(); + + void AnnotationModified(); + + mitkClassMacroItkParent(Annotation, itk::Object); protected: /** \brief explicit constructor which disallows implicit conversions */ - Overlay(); + Annotation(); /** \brief virtual destructor in order to derive from this class */ - virtual ~Overlay(); + virtual ~Annotation(); /** * @brief BaseRenderer-independent PropertyList * * Properties herein can be overwritten specifically for each BaseRenderer * by the BaseRenderer-specific properties defined in m_MapOfPropertyLists. */ PropertyList::Pointer m_PropertyList; - /** - * @brief Map associating each BaseRenderer with its own PropertyList - */ - mutable MapOfPropertyLists m_MapOfPropertyLists; - /** * @brief Timestamp of the last change of m_Data */ itk::TimeStamp m_DataReferenceChangedTime; + void SetUSProperty(const std::string &propertyKey, us::Any value); + private: - /** \brief render this overlay on a foreground renderer */ + /** \brief render this Annotation on a foreground renderer */ bool m_ForceInForeground; /** \brief copy constructor */ - Overlay(const Overlay &); + Annotation(const Annotation &); /** \brief assignment operator */ - Overlay &operator=(const Overlay &); + Annotation &operator=(const Annotation &); - /** \brief Reference to the layouter in which this overlay is managed. */ - AbstractOverlayLayouter *m_LayoutedBy; + private: + us::ServiceRegistration m_ServiceRegistration; + + unsigned long m_PropertyListModifiedObserverTag; + void PropertyListModified(const itk::Object *, const itk::EventObject &); }; } // namespace mitk -#endif // OVERLAY_H + +MITK_DECLARE_SERVICE_INTERFACE(mitk::Annotation, "org.mitk.services.Annotation") + +#endif // Annotation_H diff --git a/Modules/Core/include/mitkAnnotationUtils.h b/Modules/Core/include/mitkAnnotationUtils.h new file mode 100644 index 0000000000..ee4a42f2cf --- /dev/null +++ b/Modules/Core/include/mitkAnnotationUtils.h @@ -0,0 +1,95 @@ +/*=================================================================== + +The Medical Imaging Interaction Toolkit (MITK) + +Copyright (c) German Cancer Research Center, +Division of Medical and Biological Informatics. +All rights reserved. + +This software is distributed WITHOUT ANY WARRANTY; without +even the implied warranty of MERCHANTABILITY or FITNESS FOR +A PARTICULAR PURPOSE. + +See LICENSE.txt or http://www.mitk.org for details. + +===================================================================*/ + +#ifndef mitkAnnotationUtils_h +#define mitkAnnotationUtils_h + +#include +#include +#include + +class vtkObject; + +namespace mitk +{ + class AbstractAnnotationRenderer; + class Annotation; + class BaseRenderer; + + /** + * @brief The AnnotationUtils class provides static functions for accsessing registered AnnotationRenderers and + * Annotations + */ + class MITKCORE_EXPORT AnnotationUtils + { + public: + typedef std::vector> AnnotationRendererServices; + AnnotationUtils(); + ~AnnotationUtils(); + + /** + * @brief GetAnnotationRenderer returns a registered AnnotationRenderer of a specific type and for a BaseRenderer + * @param arTypeID name specifier of the AnnotationRenderer + * @param rendererID name specifier of the BaseRenderer + * @return + */ + static AbstractAnnotationRenderer *GetAnnotationRenderer(const std::string &arTypeID, + const std::string &rendererID); + + /** + * @brief RegisterAnnotationRenderer registers an AnnotationRenderer as a microservice and saves a reference to it + * in a local static list. + * @param annotationRenderer + */ + static void RegisterAnnotationRenderer(AbstractAnnotationRenderer *annotationRenderer); + + /** + * @brief GetAnnotationRenderer returns a list of registered AnnotationRenderers for a specified BaseRenderer + * @param rendererID name specifier of the BaseRenderer + * @return + */ + static std::vector GetAnnotationRenderer(const std::string &rendererID); + + /** + * @brief UpdateAnnotationRenderer is a convenience function which calls AbstractAnnotationRenderer::Update for each + * registered AnnotationRenderer of a specific BaseRenderer. + * @param rendererID + */ + static void UpdateAnnotationRenderer(const std::string &rendererID); + + /** + * @brief BaseRendererChanged has to be called in the case that the actual BaseRenderer object for a BaseRenderer ID + * has changed. E.g. if a RenderWindow was closed and reopened. + * @param renderer The new BaseRenderer + */ + static void BaseRendererChanged(BaseRenderer *renderer); + + /** + * @brief GetAnnotation returns a registered Annotation for a specified ID. + * @param AnnotationID + * @return + */ + static mitk::Annotation *GetAnnotation(const std::string &AnnotationID); + + private: + AnnotationUtils(const AnnotationUtils &); + AnnotationUtils &operator=(const AnnotationUtils &); + + static void RenderWindowCallback(vtkObject *caller, unsigned long, void *, void *); + }; +} + +#endif diff --git a/Modules/Core/include/mitkBaseRenderer.h b/Modules/Core/include/mitkBaseRenderer.h index 749d64c33d..10c62e84af 100644 --- a/Modules/Core/include/mitkBaseRenderer.h +++ b/Modules/Core/include/mitkBaseRenderer.h @@ -1,565 +1,547 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #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 #include #include #include // DEPRECATED #include namespace mitk { class NavigationController; class SliceNavigationController; class CameraRotationController; class CameraController; class DataStorage; class Mapper; class BaseLocalStorageHandler; - class OverlayManager; 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: /** \brief This rendering mode enumeration is specified at various constructors * of the Renderer and RenderWindow classes, which autoconfigures the * respective VTK objects. This has to be done at construction time because later * configuring turns out to be not working on most platforms. */ struct RenderingMode { enum Type { Standard = 0, // no multi-sampling, no depth-peeling MultiSampling, // multi-sampling (antialiasing), no depth-peeling DepthPeeling // no multi-sampling, depth-peeling is on (order-independant transparency) }; }; typedef std::map 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, mitk::RenderingManager *rm = nullptr, RenderingMode::Type mode = RenderingMode::Standard); //##Documentation //## @brief MapperSlotId defines which kind of mapper (e.g., 2D or 3D) shoud be used. typedef int MapperSlotId; enum StandardMapperSlot { Standard2D = 1, Standard3D = 2 }; 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 NULL. //## \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 NULL. //## @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(BaseGeometry *geometry); virtual void SetWorldTimeGeometry(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) itkGetObjectMacro(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. //## \warn 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); - //##Documentation - //## @brief Sets an OverlayManager which is used to add various Overlays to this - //## renderer. If an OverlayManager was already set it will be overwritten. - void SetOverlayManager(itk::SmartPointer overlayManager); - - //##Documentation - //## @brief Get the OverlayManager registered with this renderer - //## if none was set, it will be created at this point. - itk::SmartPointer GetOverlayManager(); - 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; //##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. itkSetMacro(MapperID, MapperSlotId) 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; ///** //* \brief Setter for the RenderingManager that handles this instance of BaseRenderer //*/ // void SetRenderingManager( mitk::RenderingManager* ); /** * \brief Getter for the RenderingManager that handles this instance of BaseRenderer */ virtual mitk::RenderingManager *GetRenderingManager() 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 2D plane coordinate to the display point //## using the geometry of the renderWindow. void PlaneToDisplay(const Point2D &planePointInMM, Point2D &displayPoint) 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: virtual ~BaseRenderer(); //##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 The RenderingManager that manages this instance RenderingManager::Pointer m_RenderingManager; //##Documentation //## @brief Timestamp of last call of Update(). unsigned long m_LastUpdateTime; //##Documentation //## @brief CameraController for 3D rendering //## @note preliminary. itk::SmartPointer m_CameraController; SliceNavigationController::Pointer m_SliceNavigationController; CameraRotationController::Pointer m_CameraRotationController; //##Documentation //## @brief Sets m_CurrentWorldPlaneGeometry virtual void SetCurrentWorldPlaneGeometry(PlaneGeometry *geometry2d); /** * \deprecatedSince{2014_10} Please use SetCurrentWorldPlaneGeometry */ DEPRECATED(void SetCurrentWorldGeometry2D(PlaneGeometry *geometry2d)) { SetCurrentWorldPlaneGeometry(geometry2d); }; //##Documentation //## @brief Sets m_CurrentWorldGeometry virtual void SetCurrentWorldGeometry(BaseGeometry *geometry); - //##Documentation - //## @brief This method is called during the rendering process to update or render the Overlays - //## which are stored in the OverlayManager - void UpdateOverlays(); - private: - itk::SmartPointer m_OverlayManager; - //##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::Pointer m_WorldTimeGeometry; //##Documentation //## Pointer to the current 3D-worldgeometry. BaseGeometry::Pointer 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: virtual 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 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 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/mitkLocalStorageHandler.h b/Modules/Core/include/mitkLocalStorageHandler.h index bb8d900477..a47e30d2e8 100644 --- a/Modules/Core/include/mitkLocalStorageHandler.h +++ b/Modules/Core/include/mitkLocalStorageHandler.h @@ -1,108 +1,119 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef LOCALSTORAGEHANDLER_H_HEADER_INCLUDED_C1E6EA08 #define LOCALSTORAGEHANDLER_H_HEADER_INCLUDED_C1E6EA08 #include "mitkBaseRenderer.h" #include "mitkCommon.h" #include "mitkLevelWindow.h" #include "mitkVtkPropRenderer.h" #include #include #include // Just included to get VTK version #include class vtkWindow; class vtkProp; namespace mitk { /** \brief Interface for accessing (templated) LocalStorageHandler instances. */ class BaseLocalStorageHandler { public: virtual ~BaseLocalStorageHandler() {} virtual void ClearLocalStorage(mitk::BaseRenderer *renderer, bool unregisterFromBaseRenderer = true) = 0; }; /** \brief Templated class for management of LocalStorage implementations in Mappers. * * The LocalStorageHandler is responsible for providing a LocalStorage to a * concrete mitk::Mapper subclass. Each RenderWindow / mitk::BaseRenderer is * assigned its own LocalStorage instance so that all contained ressources * (actors, shaders, textures, ...) are provided individually per window. * */ template class LocalStorageHandler : public mitk::BaseLocalStorageHandler { protected: std::map m_BaseRenderer2LS; public: /** \brief deallocates a local storage for a specifc BaseRenderer (if the * BaseRenderer is itself deallocating it in its destructor, it has to set * unregisterFromBaseRenderer=false) */ virtual void ClearLocalStorage(mitk::BaseRenderer *renderer, bool unregisterFromBaseRenderer = true) override { // MITK_INFO << "deleting a localstorage on a mapper request"; if (unregisterFromBaseRenderer) renderer->UnregisterLocalStorageHandler(this); L *l = m_BaseRenderer2LS[renderer]; m_BaseRenderer2LS.erase(renderer); delete l; } + std::vector GetRegisteredBaseRenderer() + { + std::vector baserenderers; + typename std::map::iterator it; + for (it = m_BaseRenderer2LS.begin(); it != m_BaseRenderer2LS.end(); ++it) + { + baserenderers.push_back(it->first); + } + return baserenderers; + } + /** \brief Retrieves a LocalStorage for a specific BaseRenderer. * * Should be used by mappers in GenerateDataForRenderer() */ L *GetLocalStorage(mitk::BaseRenderer *forRenderer) { L *l = m_BaseRenderer2LS[forRenderer]; if (!l) { // MITK_INFO << "creating new localstorage"; l = new L; m_BaseRenderer2LS[forRenderer] = l; forRenderer->RegisterLocalStorageHandler(this); } return l; } ~LocalStorageHandler() { typename std::map::iterator it; for (it = m_BaseRenderer2LS.begin(); it != m_BaseRenderer2LS.end(); it++) { (*it).first->UnregisterLocalStorageHandler(this); delete (*it).second; } m_BaseRenderer2LS.clear(); } }; } // namespace mitk #endif /* LOCALSTORAGEHANDLER_H_HEADER_INCLUDED_C1E6EA08 */ diff --git a/Modules/Core/include/mitkManufacturerLogo.h b/Modules/Core/include/mitkManufacturerLogo.h deleted file mode 100644 index ec62062e2b..0000000000 --- a/Modules/Core/include/mitkManufacturerLogo.h +++ /dev/null @@ -1,183 +0,0 @@ -/*=================================================================== - -The Medical Imaging Interaction Toolkit (MITK) - -Copyright (c) German Cancer Research Center, -Division of Medical and Biological Informatics. -All rights reserved. - -This software is distributed WITHOUT ANY WARRANTY; without -even the implied warranty of MERCHANTABILITY or FITNESS FOR -A PARTICULAR PURPOSE. - -See LICENSE.txt or http://www.mitk.org for details. - -===================================================================*/ - -#ifndef _vtk_Logo_Rendering_h_ -#define _vtk_Logo_Rendering_h_ - -#include - -class vtkRenderer; -class vtkRenderWindow; -class vtkMapper; -class vtkCamera; -class vtkImageActor; -class vtkImageMapper; -class vtkLookupTable; -class vtkPolyData; -class vtkPNGReader; -class vtkImageImport; - -namespace mitk -{ - class RenderWindow; - /** - * Renders a company logo in the foreground - * of a vtkRenderWindow. - * @deprecatedSince{2015_05} Use mitk::LogoOverlay instead - */ - class MITKCORE_EXPORT ManufacturerLogo : public BaseData - { - public: - mitkClassMacro(ManufacturerLogo, BaseData); - - itkFactorylessNewMacro(Self) itkCloneMacro(Self) - - enum LogoPosition { - UpperLeft, - UpperRight, - LowerLeft, - LowerRight, - Middle - }; - - /** - * Sets the renderwindow, in which the logo - * will be shown. Make sure, you have called this function - * before calling Enable() - */ - virtual void SetRenderWindow(vtkRenderWindow *renderWindow); - - /** - * Sets the source file for the logo. - */ - virtual void SetLogoSource(const char *filename); - /** - * Sets the opacity level of the logo. - */ - virtual void SetOpacity(double opacity); - /** - * Specifies the logo size, values from 0...10, - * where 1 is a nice little logo - */ - virtual void SetZoomFactor(double factor); - - /** - * Enables drawing of the logo. - * If you want to disable it, call the Disable() function. - */ - virtual void Enable(); - - /** - * Disables drawing of the logo. - * If you want to enable it, call the Enable() function. - */ - virtual void Disable(); - - /** - * Checks, if the logo is currently - * enabled (visible) - */ - virtual bool IsEnabled(); - - /** - * Empty implementation, since the ManufacturerLogo doesn't - * support the requested region concept - */ - virtual void SetRequestedRegionToLargestPossibleRegion() override; - - /** - * Empty implementation, since the ManufacturerLogo doesn't - * support the requested region concept - */ - virtual bool RequestedRegionIsOutsideOfTheBufferedRegion() override; - - /** - * Empty implementation, since the ManufacturerLogo doesn't - * support the requested region concept - */ - virtual bool VerifyRequestedRegion() override; - - /** - * Empty implementation, since the ManufacturerLogo doesn't - * support the requested region concept - */ - virtual void SetRequestedRegion(const itk::DataObject *) override; - - /** - * Returns the vtkRenderWindow, which is used - * for displaying the logo - */ - virtual vtkRenderWindow *GetRenderWindow(); - - /** - * Returns the renderer responsible for - * rendering the logo into the - * vtkRenderWindow - */ - virtual vtkRenderer *GetVtkRenderer(); - - /** - * Returns the actor associated with the logo - */ - virtual vtkImageActor *GetActor(); - - /** - * Returns the mapper associated with the logo - */ - virtual vtkImageMapper *GetMapper(); - - /** - * If set true, this method forces the logo rendering mechanism that it always - * renders the MBI department logo, independent from mainapp option settings. - */ - virtual void ForceMBILogoVisible(bool visible); - - protected: - void SetupCamera(); - void SetupPosition(); - - /** - * Constructor - */ - ManufacturerLogo(); - - /** - * Destructor - */ - ~ManufacturerLogo(); - - vtkRenderWindow *m_RenderWindow; - vtkRenderer *m_Renderer; - vtkImageActor *m_Actor; - vtkImageMapper *m_Mapper; - vtkPNGReader *m_PngReader; - vtkCamera *m_Camera; - vtkImageImport *m_VtkImageImport; - - std::string m_FileName; - - bool m_IsEnabled; - bool m_ForceShowMBIDepartmentLogo; - - LogoPosition m_LogoPosition; - double m_ZoomFactor; - double m_Opacity; - - char *m_ImageData; - }; - -} // end of namespace mitk -#endif diff --git a/Modules/Core/include/mitkMapper.h b/Modules/Core/include/mitkMapper.h index acefa74528..aeffb56e6b 100644 --- a/Modules/Core/include/mitkMapper.h +++ b/Modules/Core/include/mitkMapper.h @@ -1,215 +1,212 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef MAPPER_H_HEADER_INCLUDED_C1E6EA08 #define MAPPER_H_HEADER_INCLUDED_C1E6EA08 #include "mitkBaseRenderer.h" #include "mitkCommon.h" #include "mitkLevelWindow.h" #include "mitkLocalStorageHandler.h" #include "mitkVtkPropRenderer.h" #include #include #include // Just included to get VTK version #include class vtkWindow; class vtkProp; namespace mitk { class BaseRenderer; class BaseData; class DataNode; - class OverlayManager; /** \brief Base class of all mappers, Vtk as well as OpenGL mappers * * By the help of mappers, the input data is transformed to tangible primitives, * such as surfaces, points, lines, etc. * This is the base class of all mappers, Vtk as well as OpenGL mappers. * Subclasses of mitk::Mapper control the creation of rendering primitives * that interface to the graphics library (e.g., OpenGL, vtk). * * \todo Should Mapper be a subclass of ImageSource? * \ingroup Mapper */ class MITKCORE_EXPORT Mapper : public itk::Object { public: mitkClassMacroItkParent(Mapper, itk::Object); /** \brief Set the DataNode containing the data to map */ itkSetObjectMacro(DataNode, DataNode); /** \brief Get the DataNode containing the data to map. * Method only returns valid DataNode Pointer if the mapper belongs to a data node. * Otherwise, the returned DataNode Pointer might be invalid. */ virtual DataNode *GetDataNode() const; /**\brief Get the data to map * * Returns the mitk::BaseData object associated with this mapper. * \return the mitk::BaseData associated with this mapper. * \deprecatedSince{2013_03} Use GetDataNode()->GetData() instead to access the data */ DEPRECATED(BaseData *GetData() const); /** \brief Convenience access method for color properties (instances of * ColorProperty) * \return \a true property was found * \deprecatedSince{2013_03} Use GetDataNode()->GetColor(...) instead to get the color */ DEPRECATED(virtual bool GetColor(float rgb[3], BaseRenderer *renderer, const char *name = "color") const); /** \brief Convenience access method for visibility properties (instances * of BoolProperty) * \return \a true property was found * \sa IsVisible * \deprecatedSince{2013_03} Use GetDataNode()->GetVisibility(...) instead to get the visibility */ DEPRECATED(virtual bool GetVisibility(bool &visible, BaseRenderer *renderer, const char *name = "visible") const); /** \brief Convenience access method for opacity properties (instances of * FloatProperty) * \return \a true property was found * \deprecatedSince{2013_03} Use GetDataNode()->GetOpacity(...) instead to get the opacity */ DEPRECATED(virtual bool GetOpacity(float &opacity, BaseRenderer *renderer, const char *name = "opacity") const); /** \brief Convenience access method for color properties (instances of * LevelWindoProperty) * \return \a true property was found * \deprecatedSince{2013_03} Use GetDataNode->GetLevelWindow(...) instead to get the levelwindow */ DEPRECATED(virtual bool GetLevelWindow(LevelWindow &levelWindow, BaseRenderer *renderer, const char *name = "levelwindow") const); /** \brief Convenience access method for visibility properties (instances * of BoolProperty). Return value is the visibility. Default is * visible==true, i.e., true is returned even if the property (\a * propertyKey) is not found. * * Thus, the return value has a different meaning than in the * GetVisibility method! * \sa GetVisibility * \deprecatedSince{2013_03} Use GetDataNode()->GetVisibility(...) instead */ DEPRECATED(virtual bool IsVisible(BaseRenderer *renderer, const char *name = "visible") const); /** \brief Returns whether this is an vtk-based mapper * \deprecatedSince{2013_03} All mappers of superclass VTKMapper are vtk based, use a dynamic_cast instead */ virtual bool IsVtkBased() const = 0; /** \brief Calls the time step of the input data for the specified renderer and checks * whether the time step is valid and calls method GenerateDataForRenderer() */ virtual void Update(BaseRenderer *renderer); /** \brief Responsible for calling the appropriate render functions. * To be implemented in sub-classes. */ virtual void MitkRender(mitk::BaseRenderer *renderer, mitk::VtkPropRenderer::RenderType type) = 0; /** * \brief Apply specific color and opacity properties read from the PropertyList. * Reimplemented in GLmapper (does not use the actor) and the VtkMapper class. * The function is called by the individual mapper (mostly in the ApplyProperties() or ApplyAllProperties() * method). */ virtual void ApplyColorAndOpacityProperties(mitk::BaseRenderer *renderer, vtkActor *actor = nullptr) = 0; /** \brief Set default values of properties used by this mapper * to \a node * * \param node The node for which the properties are set * \param overwrite overwrite existing properties (default: \a false) * \param renderer defines which property list of node is used * (default: \a NULL, i.e. default property list) */ static void SetDefaultProperties(DataNode *node, BaseRenderer *renderer = nullptr, bool overwrite = false); /** \brief Returns the current time step as calculated from the renderer */ int GetTimestep() const { return m_TimeStep; } /** Returns true if this Mapper currently allows for Level-of-Detail rendering. * This reflects whether this Mapper currently invokes StartEvent, EndEvent, and * ProgressEvent on BaseRenderer. */ virtual bool IsLODEnabled(BaseRenderer * /*renderer*/) const { return false; } protected: /** \brief explicit constructor which disallows implicit conversions */ explicit Mapper(); /** \brief virtual destructor in order to derive from this class */ virtual ~Mapper(); /** \brief Generate the data needed for rendering (independent of a specific renderer) * \deprecatedSince{2013_03} Use GenerateDataForRenderer(BaseRenderer* renderer) instead. */ DEPRECATED(virtual void GenerateData()) {} /** \brief Generate the data needed for rendering into \a renderer */ virtual void GenerateDataForRenderer(BaseRenderer * /* renderer */) {} /** \brief Updates the time step, which is sometimes needed in subclasses */ virtual void CalculateTimeStep(BaseRenderer *renderer); /** \brief Reset the mapper (i.e., make sure that nothing is displayed) if no * valid data is present. In most cases the reimplemented function * disables the according actors (toggling visibility off) * * To be implemented in sub-classes. */ virtual void ResetMapper(BaseRenderer * /*renderer*/) {} - virtual OverlayManager *GetOverlayManager() const; - mitk::DataNode *m_DataNode; private: /** \brief The current time step of the dataset to be rendered, * for use in subclasses. * The current timestep can be accessed via the GetTimestep() method. */ int m_TimeStep; /** \brief copy constructor */ Mapper(const Mapper &); /** \brief assignment operator */ Mapper &operator=(const Mapper &); public: /** \brief Base class for mapper specific rendering ressources. */ class MITKCORE_EXPORT BaseLocalStorage { public: bool IsGenerateDataRequired(mitk::BaseRenderer *renderer, mitk::Mapper *mapper, mitk::DataNode *dataNode) const; inline void UpdateGenerateDataTime() { m_LastGenerateDataTime.Modified(); } inline itk::TimeStamp &GetLastGenerateDataTime() { return m_LastGenerateDataTime; } protected: /** \brief timestamp of last update of stored data */ itk::TimeStamp m_LastGenerateDataTime; }; }; } // namespace mitk #endif /* MAPPER_H_HEADER_INCLUDED_C1E6EA08 */ diff --git a/Modules/Core/include/mitkOverlayManager.h b/Modules/Core/include/mitkOverlayManager.h deleted file mode 100644 index 1d0c4050b9..0000000000 --- a/Modules/Core/include/mitkOverlayManager.h +++ /dev/null @@ -1,106 +0,0 @@ -/*=================================================================== - -The Medical Imaging Interaction Toolkit (MITK) - -Copyright (c) German Cancer Research Center, -Division of Medical and Biological Informatics. -All rights reserved. - -This software is distributed WITHOUT ANY WARRANTY; without -even the implied warranty of MERCHANTABILITY or FITNESS FOR -A PARTICULAR PURPOSE. - -See LICENSE.txt or http://www.mitk.org for details. - -===================================================================*/ - -#ifndef OVERLAYMANAGER_H -#define OVERLAYMANAGER_H - -#include "MitkCoreExports.h" -#include "itkEventObject.h" -#include "mitkAbstractOverlayLayouter.h" -#include "mitkLocalStorageHandler.h" -#include "mitkOverlay.h" -#include -#include - -namespace mitk -{ - itkEventMacroDeclaration(OverlayAddEvent, itk::AnyEvent) - - class BaseRenderer; - - /** \brief The OverlayManager updates and manages Overlays and the respective Layouters. */ - /** An Instance of the OverlayManager can be registered to several BaseRenderer instances in order to - * call the update method of each Overlay during the rendering phase of the renderer. - * See \ref OverlaysPage for more info. - */ - class MITKCORE_EXPORT OverlayManager : public itk::Object - { - public: - typedef std::set BaseRendererSet; - typedef std::set OverlaySet; - typedef std::map LayouterMap; - typedef std::map LayouterRendererMap; - typedef std::map> ForegroundRendererMap; - - mitkClassMacroItkParent(OverlayManager, itk::Object) itkFactorylessNewMacro(Self) itkCloneMacro(Self) - - void AddOverlay(const Overlay::Pointer &overlay, bool ForceInForeground = true); - void AddOverlay(const Overlay::Pointer &overlay, BaseRenderer *renderer, bool ForceInForeground = true); - void RemoveOverlay(const Overlay::Pointer &overlay); - - /** \brief Clears the manager of all Overlays.*/ - void RemoveAllOverlays(); - - /** \brief Adds the overlay to the layouter specified by identifier and renderer*/ - void SetLayouter(Overlay *overlay, const std::string &identifier, BaseRenderer *renderer); - - /** \brief Calls all layouters to update the position and size of the registered Overlays*/ - void UpdateLayouts(BaseRenderer *renderer); - - /** \brief Returns the Layouter specified by renderer and the identifier*/ - AbstractOverlayLayouter::Pointer GetLayouter(BaseRenderer *renderer, const std::string &identifier); - - /** \brief Add a layouter to provide it with the use of the SetLayouter method*/ - void AddLayouter(const AbstractOverlayLayouter::Pointer &layouter); - - void AddBaseRenderer(BaseRenderer *renderer); - - /** \brief The layout of each Overlay will be prepared and the properties of each Overlay is updated.*/ - void UpdateOverlays(BaseRenderer *baseRenderer); - - void RemoveBaseRenderer(mitk::BaseRenderer *renderer); - - void RemoveAllBaseRenderers(); - - const OverlaySet &GetAllOverlays(); - - static OverlayManager *GetInstance(); - - protected: - /** \brief explicit constructor which disallows implicit conversions */ - explicit OverlayManager(); - - ~OverlayManager(); - - private: - OverlaySet m_OverlaySet; - - BaseRendererSet m_BaseRendererSet; - - LayouterRendererMap m_LayouterMap; - - ForegroundRendererMap m_ForegroundRenderer; - - /** \brief copy constructor */ - OverlayManager(const OverlayManager &); - - /** \brief assignment operator */ - OverlayManager &operator=(const OverlayManager &); - }; - -} // namespace mitk - -#endif // OVERLAYMANAGER_H diff --git a/Modules/Core/src/Controllers/mitkRenderingManager.cpp b/Modules/Core/src/Controllers/mitkRenderingManager.cpp index b94c69a5e7..19239eadce 100644 --- a/Modules/Core/src/Controllers/mitkRenderingManager.cpp +++ b/Modules/Core/src/Controllers/mitkRenderingManager.cpp @@ -1,744 +1,744 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "mitkRenderingManager.h" #include "mitkBaseRenderer.h" #include "mitkCameraController.h" #include "mitkNodePredicateNot.h" #include "mitkNodePredicateProperty.h" #include "mitkProportionalTimeGeometry.h" #include "mitkRenderingManagerFactory.h" #include #include "mitkNumericTypes.h" #include #include #include #include #include namespace mitk { itkEventMacroDefinition(FocusChangedEvent, itk::AnyEvent) RenderingManager::Pointer RenderingManager::s_Instance = 0; RenderingManagerFactory *RenderingManager::s_RenderingManagerFactory = 0; RenderingManager::RenderingManager() : m_UpdatePending(false), m_MaxLOD(1), m_LODIncreaseBlocked(false), m_LODAbortMechanismEnabled(false), m_ClippingPlaneEnabled(false), m_TimeNavigationController(SliceNavigationController::New()), m_DataStorage(NULL), m_ConstrainedPanningZooming(true), m_FocusedRenderWindow(nullptr) { m_ShadingEnabled.assign(3, false); m_ShadingValues.assign(4, 0.0); InitializePropertyList(); } RenderingManager::~RenderingManager() { // Decrease reference counts of all registered vtkRenderWindows for // proper destruction RenderWindowVector::iterator it; for (it = m_AllRenderWindows.begin(); it != m_AllRenderWindows.end(); ++it) { (*it)->UnRegister(NULL); RenderWindowCallbacksList::iterator callbacks_it = this->m_RenderWindowCallbacksList.find(*it); if (callbacks_it != this->m_RenderWindowCallbacksList.end()) { (*it)->RemoveObserver(callbacks_it->second.commands[0u]); (*it)->RemoveObserver(callbacks_it->second.commands[1u]); (*it)->RemoveObserver(callbacks_it->second.commands[2u]); } } } void RenderingManager::SetFactory(RenderingManagerFactory *factory) { s_RenderingManagerFactory = factory; } const RenderingManagerFactory *RenderingManager::GetFactory() { return s_RenderingManagerFactory; } bool RenderingManager::HasFactory() { if (RenderingManager::s_RenderingManagerFactory) { return true; } else { return false; } } RenderingManager::Pointer RenderingManager::New() { const RenderingManagerFactory *factory = GetFactory(); if (factory == NULL) return NULL; return factory->CreateRenderingManager(); } RenderingManager *RenderingManager::GetInstance() { if (!RenderingManager::s_Instance) { if (s_RenderingManagerFactory) { s_Instance = s_RenderingManagerFactory->CreateRenderingManager(); } } return s_Instance; } bool RenderingManager::IsInstantiated() { if (RenderingManager::s_Instance) return true; else return false; } void RenderingManager::AddRenderWindow(vtkRenderWindow *renderWindow) { if (renderWindow && (m_RenderWindowList.find(renderWindow) == m_RenderWindowList.end())) { m_RenderWindowList[renderWindow] = RENDERING_INACTIVE; m_AllRenderWindows.push_back(renderWindow); if (m_DataStorage.IsNotNull()) mitk::BaseRenderer::GetInstance(renderWindow)->SetDataStorage(m_DataStorage.GetPointer()); // Register vtkRenderWindow instance - renderWindow->Register(NULL); + renderWindow->Register(nullptr); // Add callbacks for rendering abort mechanism // BaseRenderer *renderer = BaseRenderer::GetInstance( renderWindow ); vtkCallbackCommand *startCallbackCommand = vtkCallbackCommand::New(); startCallbackCommand->SetCallback(RenderingManager::RenderingStartCallback); renderWindow->AddObserver(vtkCommand::StartEvent, startCallbackCommand); vtkCallbackCommand *progressCallbackCommand = vtkCallbackCommand::New(); progressCallbackCommand->SetCallback(RenderingManager::RenderingProgressCallback); renderWindow->AddObserver(vtkCommand::AbortCheckEvent, progressCallbackCommand); vtkCallbackCommand *endCallbackCommand = vtkCallbackCommand::New(); endCallbackCommand->SetCallback(RenderingManager::RenderingEndCallback); renderWindow->AddObserver(vtkCommand::EndEvent, endCallbackCommand); RenderWindowCallbacks callbacks; callbacks.commands[0u] = startCallbackCommand; callbacks.commands[1u] = progressCallbackCommand; callbacks.commands[2u] = endCallbackCommand; this->m_RenderWindowCallbacksList[renderWindow] = callbacks; // Delete vtk variables correctly startCallbackCommand->Delete(); progressCallbackCommand->Delete(); endCallbackCommand->Delete(); } } void RenderingManager::RemoveRenderWindow(vtkRenderWindow *renderWindow) { if (m_RenderWindowList.erase(renderWindow)) { RenderWindowCallbacksList::iterator callbacks_it = this->m_RenderWindowCallbacksList.find(renderWindow); if (callbacks_it != this->m_RenderWindowCallbacksList.end()) { renderWindow->RemoveObserver(callbacks_it->second.commands[0u]); renderWindow->RemoveObserver(callbacks_it->second.commands[1u]); renderWindow->RemoveObserver(callbacks_it->second.commands[2u]); this->m_RenderWindowCallbacksList.erase(callbacks_it); } RenderWindowVector::iterator rw_it = std::find(m_AllRenderWindows.begin(), m_AllRenderWindows.end(), renderWindow); if (rw_it != m_AllRenderWindows.cend()) { // Decrease reference count for proper destruction (*rw_it)->UnRegister(NULL); m_AllRenderWindows.erase(rw_it); } } } const RenderingManager::RenderWindowVector &RenderingManager::GetAllRegisteredRenderWindows() { return m_AllRenderWindows; } void RenderingManager::RequestUpdate(vtkRenderWindow *renderWindow) { // If the renderWindow is not valid, we do not want to inadvertantly create // an entry in the m_RenderWindowList map. It is possible if the user is // regularly calling AddRenderer and RemoveRenderer for a rendering update // to come into this method with a renderWindow pointer that is valid in the // sense that the window does exist within the application, but that // renderWindow has been temporarily removed from this RenderingManager for // performance reasons. if (m_RenderWindowList.find(renderWindow) == m_RenderWindowList.cend()) { return; } m_RenderWindowList[renderWindow] = RENDERING_REQUESTED; if (!m_UpdatePending) { m_UpdatePending = true; this->GenerateRenderingRequestEvent(); } } void RenderingManager::ForceImmediateUpdate(vtkRenderWindow *renderWindow) { // If the renderWindow is not valid, we do not want to inadvertantly create // an entry in the m_RenderWindowList map. It is possible if the user is // regularly calling AddRenderer and RemoveRenderer for a rendering update // to come into this method with a renderWindow pointer that is valid in the // sense that the window does exist within the application, but that // renderWindow has been temporarily removed from this RenderingManager for // performance reasons. if (m_RenderWindowList.find(renderWindow) == m_RenderWindowList.cend()) { return; } // Erase potentially pending requests for this window m_RenderWindowList[renderWindow] = RENDERING_INACTIVE; m_UpdatePending = false; // Immediately repaint this window (implementation platform specific) // If the size is 0 it crashes int *size = renderWindow->GetSize(); if (0 != size[0] && 0 != size[1]) { // prepare the camera etc. before rendering // Note: this is a very important step which should be called before the VTK render! // If you modify the camera anywhere else or after the render call, the scene cannot be seen. mitk::VtkPropRenderer *vPR = dynamic_cast(mitk::BaseRenderer::GetInstance(renderWindow)); if (vPR) vPR->PrepareRender(); // Execute rendering renderWindow->Render(); } } void RenderingManager::RequestUpdateAll(RequestType type) { RenderWindowList::const_iterator it; for (it = m_RenderWindowList.cbegin(); it != m_RenderWindowList.cend(); ++it) { int id = BaseRenderer::GetInstance(it->first)->GetMapperID(); if ((type == REQUEST_UPDATE_ALL) || ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1)) || ((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2))) { this->RequestUpdate(it->first); } } } void RenderingManager::ForceImmediateUpdateAll(RequestType type) { RenderWindowList::const_iterator it; for (it = m_RenderWindowList.cbegin(); it != m_RenderWindowList.cend(); ++it) { int id = BaseRenderer::GetInstance(it->first)->GetMapperID(); if ((type == REQUEST_UPDATE_ALL) || ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1)) || ((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2))) { // Immediately repaint this window (implementation platform specific) // If the size is 0, it crashes this->ForceImmediateUpdate(it->first); } } } void RenderingManager::InitializeViewsByBoundingObjects(const DataStorage *ds) { if (!ds) return; // get all nodes that have not set "includeInBoundingBox" to false mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New( mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false))); mitk::DataStorage::SetOfObjects::ConstPointer rs = ds->GetSubset(pred); // calculate bounding geometry of these nodes mitk::TimeGeometry::Pointer bounds = ds->ComputeBoundingGeometry3D(rs, "visible"); // initialize the views to the bounding geometry this->InitializeViews(bounds); } // TODO_GOETZ // Remove old function, so only this one is working. bool RenderingManager::InitializeViews(const BaseGeometry *dataGeometry, RequestType type, bool preserveRoughOrientationInWorldSpace) { ProportionalTimeGeometry::Pointer propTimeGeometry = ProportionalTimeGeometry::New(); propTimeGeometry->Initialize(dynamic_cast(dataGeometry->Clone().GetPointer()), 1); return InitializeViews(propTimeGeometry, type, preserveRoughOrientationInWorldSpace); } bool RenderingManager::InitializeViews(const TimeGeometry *dataGeometry, RequestType type, bool /*preserveRoughOrientationInWorldSpace*/) { MITK_DEBUG << "initializing views"; bool boundingBoxInitialized = false; TimeGeometry::ConstPointer timeGeometry = dataGeometry; TimeGeometry::Pointer modifiedGeometry = NULL; if (dataGeometry != NULL) { modifiedGeometry = dataGeometry->Clone(); } int warningLevel = vtkObject::GetGlobalWarningDisplay(); vtkObject::GlobalWarningDisplayOff(); if ((timeGeometry.IsNotNull()) && (const_cast(timeGeometry->GetBoundingBoxInWorld())->GetDiagonalLength2() > mitk::eps)) { boundingBoxInitialized = true; } if (timeGeometry.IsNotNull()) { // make sure bounding box has an extent bigger than zero in any direction // clone the input geometry // Old Geometry3D::Pointer modifiedGeometry = dynamic_cast( dataGeometry->Clone().GetPointer() ); assert(modifiedGeometry.IsNotNull()); for (TimeStepType step = 0; step < modifiedGeometry->CountTimeSteps(); ++step) { BaseGeometry::BoundsArrayType newBounds = modifiedGeometry->GetGeometryForTimeStep(step)->GetBounds(); for (unsigned int dimension = 0; (2 * dimension) < newBounds.Size(); dimension++) { // check for equality but for an epsilon if (Equal(newBounds[2 * dimension], newBounds[2 * dimension + 1])) { newBounds[2 * dimension + 1] += 1; if (Equal( newBounds[2 * dimension], newBounds[2 * dimension + 1])) // newBounds will still be equal if values are beyond double precision { mitkThrow() << "One dimension of object data has zero length, please make sure you're not using numbers " "beyond double precision as coordinates."; } } } modifiedGeometry->GetGeometryForTimeStep(step)->SetBounds(newBounds); } } timeGeometry = modifiedGeometry; RenderWindowList::const_iterator it; for (it = m_RenderWindowList.cbegin(); it != m_RenderWindowList.cend(); ++it) { mitk::BaseRenderer *baseRenderer = mitk::BaseRenderer::GetInstance(it->first); baseRenderer->SetConstrainZoomingAndPanning(m_ConstrainedPanningZooming); int id = baseRenderer->GetMapperID(); if (((type == REQUEST_UPDATE_ALL) || ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1)) || ((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2)))) { this->InternalViewInitialization(baseRenderer, timeGeometry, boundingBoxInitialized, id); } } if (boundingBoxInitialized) { m_TimeNavigationController->SetInputWorldTimeGeometry(timeGeometry); } m_TimeNavigationController->Update(); this->RequestUpdateAll(type); vtkObject::SetGlobalWarningDisplay(warningLevel); // Inform listeners that views have been initialized this->InvokeEvent(mitk::RenderingManagerViewsInitializedEvent()); return boundingBoxInitialized; } bool RenderingManager::InitializeViews(RequestType type) { RenderWindowList::const_iterator it; for (it = m_RenderWindowList.cbegin(); it != m_RenderWindowList.cend(); ++it) { mitk::BaseRenderer *baseRenderer = mitk::BaseRenderer::GetInstance(it->first); int id = baseRenderer->GetMapperID(); if ((type == REQUEST_UPDATE_ALL) || ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1)) || ((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2))) { mitk::SliceNavigationController *nc = baseRenderer->GetSliceNavigationController(); // Re-initialize view direction nc->SetViewDirectionToDefault(); // Update the SNC nc->Update(); } } this->RequestUpdateAll(type); return true; } bool RenderingManager::InitializeView(vtkRenderWindow *renderWindow, const BaseGeometry *geometry, bool initializeGlobalTimeSNC) { ProportionalTimeGeometry::Pointer propTimeGeometry = ProportionalTimeGeometry::New(); propTimeGeometry->Initialize(dynamic_cast(geometry->Clone().GetPointer()), 1); return InitializeView(renderWindow, propTimeGeometry, initializeGlobalTimeSNC); } bool RenderingManager::InitializeView(vtkRenderWindow *renderWindow, const TimeGeometry *geometry, bool initializeGlobalTimeSNC) { bool boundingBoxInitialized = false; int warningLevel = vtkObject::GetGlobalWarningDisplay(); vtkObject::GlobalWarningDisplayOff(); if ((geometry != NULL) && (const_cast(geometry->GetBoundingBoxInWorld())->GetDiagonalLength2() > mitk::eps)) { boundingBoxInitialized = true; } mitk::BaseRenderer *baseRenderer = mitk::BaseRenderer::GetInstance(renderWindow); int id = baseRenderer->GetMapperID(); this->InternalViewInitialization(baseRenderer, geometry, boundingBoxInitialized, id); if (boundingBoxInitialized && initializeGlobalTimeSNC) { m_TimeNavigationController->SetInputWorldTimeGeometry(geometry); } m_TimeNavigationController->Update(); this->RequestUpdate(renderWindow); vtkObject::SetGlobalWarningDisplay(warningLevel); return boundingBoxInitialized; } bool RenderingManager::InitializeView(vtkRenderWindow *renderWindow) { mitk::BaseRenderer *baseRenderer = mitk::BaseRenderer::GetInstance(renderWindow); mitk::SliceNavigationController *nc = baseRenderer->GetSliceNavigationController(); // Re-initialize view direction nc->SetViewDirectionToDefault(); // Update the SNC nc->Update(); this->RequestUpdate(renderWindow); return true; } void RenderingManager::InternalViewInitialization(mitk::BaseRenderer *baseRenderer, const mitk::TimeGeometry *geometry, bool boundingBoxInitialized, int mapperID) { mitk::SliceNavigationController *nc = baseRenderer->GetSliceNavigationController(); // Re-initialize view direction nc->SetViewDirectionToDefault(); if (boundingBoxInitialized) { // Set geometry for NC nc->SetInputWorldTimeGeometry(geometry); nc->Update(); if (mapperID == BaseRenderer::Standard2D) { // For 2D SNCs, steppers are set so that the cross is centered // in the image nc->GetSlice()->SetPos(nc->GetSlice()->GetSteps() / 2); } baseRenderer->GetCameraController()->SetViewToAnterior(); baseRenderer->GetCameraController()->Fit(); } else { nc->Update(); } } const SliceNavigationController *RenderingManager::GetTimeNavigationController() const { return m_TimeNavigationController.GetPointer(); } SliceNavigationController *RenderingManager::GetTimeNavigationController() { return m_TimeNavigationController.GetPointer(); } void RenderingManager::ExecutePendingRequests() { m_UpdatePending = false; // Satisfy all pending update requests RenderWindowList::const_iterator it; int i = 0; for (it = m_RenderWindowList.cbegin(); it != m_RenderWindowList.cend(); ++it, ++i) { if (it->second == RENDERING_REQUESTED) { this->ForceImmediateUpdate(it->first); } } } void RenderingManager::RenderingStartCallback(vtkObject *caller, unsigned long, void *, void *) { vtkRenderWindow *renderWindow = dynamic_cast(caller); mitk::RenderingManager *renman = mitk::BaseRenderer::GetInstance(renderWindow)->GetRenderingManager(); RenderWindowList &renderWindowList = renman->m_RenderWindowList; if (renderWindow) { renderWindowList[renderWindow] = RENDERING_INPROGRESS; } renman->m_UpdatePending = false; } void RenderingManager::RenderingProgressCallback(vtkObject *caller, unsigned long, void *, void *) { vtkRenderWindow *renderWindow = dynamic_cast(caller); mitk::RenderingManager *renman = mitk::BaseRenderer::GetInstance(renderWindow)->GetRenderingManager(); if (renman->m_LODAbortMechanismEnabled) { vtkRenderWindow *renderWindow = dynamic_cast(caller); if (renderWindow) { BaseRenderer *renderer = BaseRenderer::GetInstance(renderWindow); if (renderer && (renderer->GetNumberOfVisibleLODEnabledMappers() > 0)) { renman->DoMonitorRendering(); } } } } void RenderingManager::RenderingEndCallback(vtkObject *caller, unsigned long, void *, void *) { vtkRenderWindow *renderWindow = dynamic_cast(caller); mitk::RenderingManager *renman = mitk::BaseRenderer::GetInstance(renderWindow)->GetRenderingManager(); RenderWindowList &renderWindowList = renman->m_RenderWindowList; RendererIntMap &nextLODMap = renman->m_NextLODMap; if (renderWindow) { BaseRenderer *renderer = BaseRenderer::GetInstance(renderWindow); if (renderer) { renderWindowList[renderer->GetRenderWindow()] = RENDERING_INACTIVE; // Level-of-Detail handling if (renderer->GetNumberOfVisibleLODEnabledMappers() > 0) { if (nextLODMap[renderer] == 0) renman->StartOrResetTimer(); else nextLODMap[renderer] = 0; } } } } bool RenderingManager::IsRendering() const { RenderWindowList::const_iterator it; for (it = m_RenderWindowList.cbegin(); it != m_RenderWindowList.cend(); ++it) { if (it->second == RENDERING_INPROGRESS) { return true; } } return false; } void RenderingManager::AbortRendering() { RenderWindowList::const_iterator it; for (it = m_RenderWindowList.cbegin(); it != m_RenderWindowList.cend(); ++it) { if (it->second == RENDERING_INPROGRESS) { it->first->SetAbortRender(true); m_RenderingAbortedMap[BaseRenderer::GetInstance(it->first)] = true; } } } int RenderingManager::GetNextLOD(BaseRenderer *renderer) { if (renderer != NULL) { return m_NextLODMap[renderer]; } else { return 0; } } void RenderingManager::ExecutePendingHighResRenderingRequest() { RenderWindowList::const_iterator it; for (it = m_RenderWindowList.cbegin(); it != m_RenderWindowList.cend(); ++it) { BaseRenderer *renderer = BaseRenderer::GetInstance(it->first); if (renderer->GetNumberOfVisibleLODEnabledMappers() > 0) { if (m_NextLODMap[renderer] == 0) { m_NextLODMap[renderer] = 1; RequestUpdate(it->first); } } } } void RenderingManager::SetMaximumLOD(unsigned int max) { m_MaxLOD = max; } // enable/disable shading void RenderingManager::SetShading(bool state, unsigned int lod) { if (lod > m_MaxLOD) { itkWarningMacro(<< "LOD out of range requested: " << lod << " maxLOD: " << m_MaxLOD); return; } m_ShadingEnabled[lod] = state; } bool RenderingManager::GetShading(unsigned int lod) { if (lod > m_MaxLOD) { itkWarningMacro(<< "LOD out of range requested: " << lod << " maxLOD: " << m_MaxLOD); return false; } return m_ShadingEnabled[lod]; } // enable/disable the clipping plane void RenderingManager::SetClippingPlaneStatus(bool status) { m_ClippingPlaneEnabled = status; } bool RenderingManager::GetClippingPlaneStatus() { return m_ClippingPlaneEnabled; } void RenderingManager::SetShadingValues(float ambient, float diffuse, float specular, float specpower) { m_ShadingValues[0] = ambient; m_ShadingValues[1] = diffuse; m_ShadingValues[2] = specular; m_ShadingValues[3] = specpower; } RenderingManager::FloatVector &RenderingManager::GetShadingValues() { return m_ShadingValues; } void RenderingManager::InitializePropertyList() { if (m_PropertyList.IsNull()) { m_PropertyList = PropertyList::New(); } this->SetProperty("coupled-zoom", BoolProperty::New(false)); this->SetProperty("coupled-plane-rotation", BoolProperty::New(false)); this->SetProperty("MIP-slice-rendering", BoolProperty::New(false)); } PropertyList::Pointer RenderingManager::GetPropertyList() const { return m_PropertyList; } BaseProperty *RenderingManager::GetProperty(const char *propertyKey) const { return m_PropertyList->GetProperty(propertyKey); } void RenderingManager::SetProperty(const char *propertyKey, BaseProperty *propertyValue) { m_PropertyList->SetProperty(propertyKey, propertyValue); } void RenderingManager::SetDataStorage(DataStorage *storage) { if (storage != NULL) { m_DataStorage = storage; RenderingManager::RenderWindowVector::const_iterator iter; for (iter = m_AllRenderWindows.cbegin(); iter < m_AllRenderWindows.cend(); ++iter) { mitk::BaseRenderer::GetInstance((*iter))->SetDataStorage(m_DataStorage.GetPointer()); } } } mitk::DataStorage *RenderingManager::GetDataStorage() { return m_DataStorage; } void RenderingManager::SetRenderWindowFocus(vtkRenderWindow *focusWindow) { if (focusWindow != m_FocusedRenderWindow) { if (!focusWindow || (m_RenderWindowList.find(focusWindow) != m_RenderWindowList.cend())) { m_FocusedRenderWindow = focusWindow; this->InvokeEvent(FocusChangedEvent()); return; } MITK_ERROR << "Tried to set a RenderWindow that does not exist."; } } // Create and register generic RenderingManagerFactory. TestingRenderingManagerFactory renderingManagerFactory; } // namespace diff --git a/Modules/Core/src/Rendering/mitkAbstractAnnotationRenderer.cpp b/Modules/Core/src/Rendering/mitkAbstractAnnotationRenderer.cpp new file mode 100644 index 0000000000..abc7b46d2d --- /dev/null +++ b/Modules/Core/src/Rendering/mitkAbstractAnnotationRenderer.cpp @@ -0,0 +1,111 @@ +/*=================================================================== + +The Medical Imaging Interaction Toolkit (MITK) + +Copyright (c) German Cancer Research Center, +Division of Medical and Biological Informatics. +All rights reserved. + +This software is distributed WITHOUT ANY WARRANTY; without +even the implied warranty of MERCHANTABILITY or FITNESS FOR +A PARTICULAR PURPOSE. + +See LICENSE.txt or http://www.mitk.org for details. + +===================================================================*/ + +#include "mitkAbstractAnnotationRenderer.h" +#include "mitkBaseRenderer.h" +#include "mitkRenderingManager.h" +#include "usGetModuleContext.h" +#include + +namespace mitk +{ + const std::string AbstractAnnotationRenderer::US_INTERFACE_NAME = "org.mitk.services.AbstractAnnotationRenderer"; + const std::string AbstractAnnotationRenderer::US_PROPKEY_ID = US_INTERFACE_NAME + ".id"; + const std::string AbstractAnnotationRenderer::US_PROPKEY_RENDERER_ID = US_INTERFACE_NAME + ".rendererId"; + + AbstractAnnotationRenderer::AbstractAnnotationRenderer(const std::string &rendererID, const std::string &arID) + : Superclass(us::GetModuleContext(), + us::LDAPFilter("(&(" + Annotation::US_PROPKEY_RENDERER_ID + "=" + rendererID + ")(" + + Annotation::US_PROPKEY_AR_ID + "=" + arID + "))")), + m_RendererID(rendererID), + m_ID(arID) + { + this->Open(); + } + + AbstractAnnotationRenderer::~AbstractAnnotationRenderer() {} + const std::string AbstractAnnotationRenderer::GetRendererID() const { return m_RendererID; } + void AbstractAnnotationRenderer::CurrentBaseRendererChanged() + { + BaseRenderer *renderer = GetCurrentBaseRenderer(); + if (renderer) + { + for (Annotation *o : this->GetServices()) + { + o->AddToBaseRenderer(renderer); + } + } + } + + void AbstractAnnotationRenderer::RemoveAllAnnotation() + { + BaseRenderer *renderer = GetCurrentBaseRenderer(); + if (renderer) + { + for (Annotation *o : this->GetServices()) + { + o->RemoveFromBaseRenderer(renderer); + } + } + } + + void AbstractAnnotationRenderer::Update() + { + BaseRenderer *renderer = GetCurrentBaseRenderer(); + if (renderer) + { + for (Annotation *o : this->GetServices()) + { + o->Update(renderer); + } + } + } + const std::string AbstractAnnotationRenderer::GetID() const { return m_ID; } + AbstractAnnotationRenderer::TrackedType AbstractAnnotationRenderer::AddingService( + const AbstractAnnotationRenderer::ServiceReferenceType &reference) + { + Annotation *Annotation = Superclass::AddingService(reference); + BaseRenderer *renderer = GetCurrentBaseRenderer(); + if (Annotation && renderer) + { + Annotation->AddToBaseRenderer(renderer); + } + // OnAnnotationRenderersChanged(); + return Annotation; + } + + void AbstractAnnotationRenderer::ModifiedService(const AbstractAnnotationRenderer::ServiceReferenceType &, + AbstractAnnotationRenderer::TrackedType tracked) + { + BaseRenderer *renderer = GetCurrentBaseRenderer(); + if (tracked && renderer) + { + tracked->Update(renderer); + } + OnAnnotationRenderersChanged(); + } + + void AbstractAnnotationRenderer::RemovedService(const AbstractAnnotationRenderer::ServiceReferenceType &, + AbstractAnnotationRenderer::TrackedType /*tracked*/) + { + OnAnnotationRenderersChanged(); + } + + BaseRenderer *AbstractAnnotationRenderer::GetCurrentBaseRenderer() + { + return BaseRenderer::GetByName(this->GetRendererID()); + } +} diff --git a/Modules/Core/src/Rendering/mitkAbstractOverlayLayouter.cpp b/Modules/Core/src/Rendering/mitkAbstractOverlayLayouter.cpp deleted file mode 100644 index 2f9073f4da..0000000000 --- a/Modules/Core/src/Rendering/mitkAbstractOverlayLayouter.cpp +++ /dev/null @@ -1,60 +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 "mitkAbstractOverlayLayouter.h" -#include "mitkBaseRenderer.h" - -mitk::AbstractOverlayLayouter::AbstractOverlayLayouter() -{ -} - -mitk::AbstractOverlayLayouter::~AbstractOverlayLayouter() -{ -} - -std::list mitk::AbstractOverlayLayouter::GetManagedOverlays() const -{ - return m_ManagedOverlays; -} - -void mitk::AbstractOverlayLayouter::SetBaseRenderer(BaseRenderer *renderer) -{ - m_BaseRenderer = renderer; -} - -mitk::BaseRenderer *mitk::AbstractOverlayLayouter::GetBaseRenderer() -{ - return m_BaseRenderer; -} - -void mitk::AbstractOverlayLayouter::AddOverlay(mitk::Overlay *Overlay) -{ - if (Overlay->m_LayoutedBy && Overlay->m_LayoutedBy != this) - Overlay->m_LayoutedBy->RemoveOverlay(Overlay); - Overlay->m_LayoutedBy = this; - m_ManagedOverlays.push_back(Overlay); - PrepareLayout(); -} - -void mitk::AbstractOverlayLayouter::RemoveOverlay(mitk::Overlay *Overlay) -{ - m_ManagedOverlays.remove(Overlay); -} - -std::string mitk::AbstractOverlayLayouter::GetIdentifier() const -{ - return m_Identifier; -} diff --git a/Modules/Core/src/Rendering/mitkAnnotation.cpp b/Modules/Core/src/Rendering/mitkAnnotation.cpp new file mode 100644 index 0000000000..11c25b95e0 --- /dev/null +++ b/Modules/Core/src/Rendering/mitkAnnotation.cpp @@ -0,0 +1,352 @@ +/*=================================================================== + +The Medical Imaging Interaction Toolkit (MITK) + +Copyright (c) German Cancer Research Center, +Division of Medical and Biological Informatics. +All rights reserved. + +This software is distributed WITHOUT ANY WARRANTY; without +even the implied warranty of MERCHANTABILITY or FITNESS FOR +A PARTICULAR PURPOSE. + +See LICENSE.txt or http://www.mitk.org for details. + +===================================================================*/ + +#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::Pointer _PropertyListModifiedCommand = + itk::MemberCommand::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 propertyKeys; + m_ServiceRegistration.GetReference().GetPropertyKeys(propertyKeys); + for (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) == NULL)) + { + 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 NULL; +} + +bool mitk::Annotation::GetBoolProperty(const std::string &propertyKey, bool &boolValue) const +{ + mitk::BoolProperty::Pointer boolprop = dynamic_cast(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(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(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(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(this->GetProperty("name")); + if (sp == NULL) + 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(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(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 != NULL) + m_ServiceRegistration.Unregister(); + us::ModuleContext *context = us::GetModuleContext(); + // Define ServiceProps + mitk::UIDGenerator uidGen = mitk::UIDGenerator("org.mitk.services.Annotation.id_", 16); + props[US_PROPKEY_ID] = uidGen.GetUID(); + m_ServiceRegistration = context->RegisterService(this, props); +} + +void mitk::Annotation::UnRegisterMicroservice() +{ + if (m_ServiceRegistration != NULL) + 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 new file mode 100644 index 0000000000..ef21056540 --- /dev/null +++ b/Modules/Core/src/Rendering/mitkAnnotationUtils.cpp @@ -0,0 +1,126 @@ +/*=================================================================== + +The Medical Imaging Interaction Toolkit (MITK) + +Copyright (c) German Cancer Research Center, +Division of Medical and Biological Informatics. +All rights reserved. + +This software is distributed WITHOUT ANY WARRANTY; without +even the implied warranty of MERCHANTABILITY or FITNESS FOR +A PARTICULAR PURPOSE. + +See LICENSE.txt or http://www.mitk.org for details. + +===================================================================*/ + +#include "mitkAnnotationUtils.h" +#include "mitkAnnotation.h" +#include "vtkCallbackCommand.h" +#include "vtkCommand.h" +#include + +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 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(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(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 *) + { + vtkRenderWindow *renderWindow = dynamic_cast(caller); + if (!renderWindow) + return; + BaseRenderer *renderer = BaseRenderer::GetInstance(renderWindow); + 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> annotations = + context->GetServiceReferences(ldapFilter); + Annotation *annotation = nullptr; + if (!annotations.empty()) + { + annotation = us::GetModuleContext()->GetService(annotations.front()); + } + return annotation; + } + + std::vector 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 serviceReferences = + context->GetServiceReferences(AbstractAnnotationRenderer::US_INTERFACE_NAME, filter); + std::vector arList; + for (us::ServiceReferenceU service : serviceReferences) + { + arList.push_back(context->GetService(service)); + } + return arList; + } +} diff --git a/Modules/Core/src/Rendering/mitkBaseRenderer.cpp b/Modules/Core/src/Rendering/mitkBaseRenderer.cpp index 8638a8278b..047df06e48 100644 --- a/Modules/Core/src/Rendering/mitkBaseRenderer.cpp +++ b/Modules/Core/src/Rendering/mitkBaseRenderer.cpp @@ -1,802 +1,758 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #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 "mitkOverlayManager.h" #include "mitkProperties.h" #include "mitkWeakPointerProperty.h" // VTK #include #include #include #include #include #include #include mitk::BaseRenderer::BaseRendererMapType mitk::BaseRenderer::baseRendererMap; mitk::BaseRenderer *mitk::BaseRenderer::GetInstance(vtkRenderWindow *renWin) { for (BaseRendererMapType::iterator 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) { BaseRendererMapType::iterator mapit = baseRendererMap.find(renWin); if (mapit != baseRendererMap.end()) baseRendererMap.erase(mapit); } mitk::BaseRenderer *mitk::BaseRenderer::GetByName(const std::string &name) { for (BaseRendererMapType::iterator 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 (BaseRendererMapType::iterator 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, mitk::RenderingManager *rm, RenderingMode::Type renderingMode) : m_RenderWindow(nullptr), m_VtkRenderer(nullptr), m_MapperID(defaultMapper), m_DataStorage(nullptr), m_RenderingManager(rm), 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(); if (renderingMode == RenderingMode::DepthPeeling) { m_VtkRenderer->SetUseDepthPeeling(1); m_VtkRenderer->SetMaximumNumberOfPeels(8); m_VtkRenderer->SetOcclusionRatio(0.0); } if (mitk::VtkLayerController::GetInstance(m_RenderWindow) == nullptr) { mitk::VtkLayerController::AddInstance(m_RenderWindow, m_VtkRenderer); } mitk::VtkLayerController::GetInstance(m_RenderWindow)->InsertSceneRenderer(m_VtkRenderer); } mitk::BaseRenderer::~BaseRenderer() { - if (m_OverlayManager.IsNotNull()) - { - m_OverlayManager->RemoveBaseRenderer(this); - } - 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::RemoveAllLocalStorages() { this->InvokeEvent(mitk::BaseRenderer::RendererResetEvent()); std::list::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(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::SetOverlayManager(itk::SmartPointer overlayManager) -{ - if (overlayManager.IsNull()) - return; - - if (this->m_OverlayManager.IsNotNull()) - { - if (this->m_OverlayManager.GetPointer() == overlayManager.GetPointer()) - { - return; - } - else - { - this->m_OverlayManager->RemoveBaseRenderer(this); - } - } - this->m_OverlayManager = overlayManager; - this->m_OverlayManager->AddBaseRenderer(this); // TODO -} - -itk::SmartPointer mitk::BaseRenderer::GetOverlayManager() -{ - if (this->m_OverlayManager.IsNull()) - { - m_OverlayManager = mitk::OverlayManager::New(); - m_OverlayManager->AddBaseRenderer(this); - } - return this->m_OverlayManager; -} - 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(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 { 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::NonpositiveMin()) return 0; else return timeInMS; } } void mitk::BaseRenderer::SetWorldTimeGeometry(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(mitk::BaseGeometry *geometry) { itkDebugMacro("setting WorldGeometry3D to " << geometry); if (geometry->GetBoundingBox()->GetDiagonalLength2() == 0) return; SlicedGeometry3D *slicedWorldGeometry; slicedWorldGeometry = dynamic_cast(geometry); PlaneGeometry::Pointer 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(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(mitk::PlaneGeometry *geometry2d) { if (m_CurrentWorldPlaneGeometry != geometry2d) { m_CurrentWorldPlaneGeometry = geometry2d; 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(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::UpdateOverlays() -{ - if (m_OverlayManager.IsNotNull()) - { - m_OverlayManager->UpdateOverlays(this); - } -} - void mitk::BaseRenderer::SetGeometry(const itk::EventObject &geometrySendEvent) { const SliceNavigationController::GeometrySendEvent *sendEvent = dynamic_cast(&geometrySendEvent); assert(sendEvent != nullptr); SetWorldTimeGeometry(sendEvent->GetTimeGeometry()); } void mitk::BaseRenderer::UpdateGeometry(const itk::EventObject &geometryUpdateEvent) { const SliceNavigationController::GeometryUpdateEvent *updateEvent = dynamic_cast(&geometryUpdateEvent); if (updateEvent == nullptr) return; if (m_CurrentWorldGeometry.IsNotNull()) { SlicedGeometry3D *slicedWorldGeometry = dynamic_cast(m_CurrentWorldGeometry.GetPointer()); if (slicedWorldGeometry) { PlaneGeometry *geometry2D = slicedWorldGeometry->GetPlaneGeometry(m_Slice); SetCurrentWorldPlaneGeometry(geometry2D); // calls Modified() } } } void mitk::BaseRenderer::SetGeometrySlice(const itk::EventObject &geometrySliceEvent) { const SliceNavigationController::GeometrySliceEvent *sliceEvent = dynamic_cast(&geometrySliceEvent); assert(sliceEvent != nullptr); SetSlice(sliceEvent->GetPos()); } void mitk::BaseRenderer::SetGeometryTime(const itk::EventObject &geometryTimeEvent) { const SliceNavigationController::GeometryTimeEvent *timeEvent = dynamic_cast(&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); m_RenderingManager->RequestUpdate(this->m_RenderWindow); } void mitk::BaseRenderer::ForceImmediateUpdate() { m_RenderingManager->ForceImmediateUpdate(this->m_RenderWindow); } unsigned int mitk::BaseRenderer::GetNumberOfVisibleLODEnabledMappers() const { return m_NumberOfVisibleLODEnabledMappers; } mitk::RenderingManager *mitk::BaseRenderer::GetRenderingManager() const { return m_RenderingManager.GetPointer(); } /*! 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::PlaneToDisplay(const Point2D &planePointInMM, Point2D &displayPoint) const { Point3D worldPoint; this->m_CurrentWorldPlaneGeometry->Map(planePointInMM, worldPoint); this->WorldToDisplay(worldPoint, displayPoint); 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/src/Rendering/mitkManufacturerLogo.cpp b/Modules/Core/src/Rendering/mitkManufacturerLogo.cpp deleted file mode 100644 index 92f9fb6273..0000000000 --- a/Modules/Core/src/Rendering/mitkManufacturerLogo.cpp +++ /dev/null @@ -1,375 +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 "mitkManufacturerLogo.h" - -#include "mitkVtkLayerController.h" - -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include - -#include - -mitk::ManufacturerLogo::ManufacturerLogo() : m_ImageData(nullptr) -{ - m_RenderWindow = nullptr; - m_Renderer = vtkRenderer::New(); - m_Actor = vtkImageActor::New(); - m_Mapper = vtkImageMapper::New(); - m_PngReader = vtkPNGReader::New(); - m_VtkImageImport = vtkImageImport::New(); - - m_LogoPosition = mitk::ManufacturerLogo::LowerRight; - - m_IsEnabled = false; - m_ForceShowMBIDepartmentLogo = false; - - m_ZoomFactor = 1.15; - m_Opacity = 0.5; - - m_FileName = ""; - m_PngReader->SetFileName(m_FileName.c_str()); -} - -mitk::ManufacturerLogo::~ManufacturerLogo() -{ - if (m_RenderWindow != nullptr) - if (this->IsEnabled()) - this->Disable(); - - if (m_Mapper != nullptr) - m_Mapper->Delete(); - - if (m_Actor != nullptr) - m_Actor->Delete(); - - if (m_Renderer != nullptr) - m_Renderer->Delete(); - - if (m_PngReader != nullptr) - m_PngReader->Delete(); - - if (m_VtkImageImport != nullptr) - m_VtkImageImport->Delete(); - - if (m_ImageData != nullptr) - delete[] m_ImageData; -} - -/** - * Sets the renderwindow, in which the logo - * will be shown. Make sure, you have called this function - * before calling Enable() - */ -void mitk::ManufacturerLogo::SetRenderWindow(vtkRenderWindow *renderWindow) -{ - m_RenderWindow = renderWindow; -} - -/** - * Returns the vtkRenderWindow, which is used - * for displaying the logo - */ -vtkRenderWindow *mitk::ManufacturerLogo::GetRenderWindow() -{ - return m_RenderWindow; -} - -/** - * Returns the renderer responsible for - * rendering the logo into the - * vtkRenderWindow - */ -vtkRenderer *mitk::ManufacturerLogo::GetVtkRenderer() -{ - return m_Renderer; -} - -/** - * Returns the actor associated with the logo - */ -vtkImageActor *mitk::ManufacturerLogo::GetActor() -{ - return m_Actor; -} - -/** - * Returns the mapper associated with the - * logo. - */ -vtkImageMapper *mitk::ManufacturerLogo::GetMapper() -{ - return m_Mapper; -} - -void mitk::ManufacturerLogo::SetLogoSource(const char *filename) -{ - std::string file = filename; - if (file.length() != 0) - { - m_FileName = filename; - m_PngReader->SetFileName(m_FileName.c_str()); - } -} - -/** - * Enables drawing of the logo. - * If you want to disable it, call the Disable() function. - */ -void mitk::ManufacturerLogo::Enable() -{ - if (m_IsEnabled) - return; - - if (m_RenderWindow != nullptr) - { - if (itksys::SystemTools::FileExists(m_FileName.c_str()) && !m_ForceShowMBIDepartmentLogo) - { - m_PngReader->Update(); - m_Actor->SetInputData(m_PngReader->GetOutput()); - } - else // either logo file not found or logo renderer is forced to show the MBI logo - { - m_VtkImageImport->SetDataScalarTypeToUnsignedChar(); - m_VtkImageImport->SetNumberOfScalarComponents(mbiLogo_NumberOfScalars); - m_VtkImageImport->SetWholeExtent(0, mbiLogo_Width - 1, 0, mbiLogo_Height - 1, 0, 1 - 1); - m_VtkImageImport->SetDataExtentToWholeExtent(); - - // flip mbi logo around y axis and change color order - m_ImageData = new char[mbiLogo_Height * mbiLogo_Width * mbiLogo_NumberOfScalars]; - - unsigned int column, row; - char *dest = m_ImageData; - char *source = (char *)&mbiLogo_Data[0]; - ; - char r, g, b, a; - for (column = 0; column < mbiLogo_Height; column++) - for (row = 0; row < mbiLogo_Width; row++) - { // change r with b - b = *source++; - g = *source++; - r = *source++; - a = *source++; - - *dest++ = r; - *dest++ = g; - *dest++ = b; - *dest++ = a; - } - - m_VtkImageImport->SetImportVoidPointer(m_ImageData); - m_VtkImageImport->Modified(); - m_VtkImageImport->Update(); - - m_Actor->SetInputData(m_VtkImageImport->GetOutput()); - } - - m_Actor->SetOpacity(m_Opacity); - - m_Renderer->AddActor(m_Actor); - m_Renderer->InteractiveOff(); - - SetupCamera(); - SetupPosition(); - - mitk::VtkLayerController::GetInstance(m_RenderWindow)->InsertForegroundRenderer(m_Renderer, false); - - m_IsEnabled = true; - } -} - -void mitk::ManufacturerLogo::SetupCamera() -{ - // set the vtk camera in way that stretches the logo all over the renderwindow - - vtkImageData *image = m_Actor->GetInput(); - m_Camera = m_Renderer->GetActiveCamera(); - m_Camera->SetClippingRange(1, 100000); - - if (!image) - return; - - double spacing[3]; - double origin[3]; - int dimensions[3]; - - image->GetSpacing(spacing); - image->GetOrigin(origin); - image->GetDimensions(dimensions); - - double focalPoint[3]; - double position[3]; - - for (unsigned int cc = 0; cc < 3; cc++) - { - focalPoint[cc] = origin[cc] + (spacing[cc] * dimensions[cc]) / 2.0; - position[cc] = focalPoint[cc]; - } - - m_Camera->SetViewUp(0, 1, 0); - int idx = 2; - const double distanceToFocalPoint = 1000; - position[idx] = distanceToFocalPoint; - - m_Camera->ParallelProjectionOn(); - m_Camera->SetPosition(position); - m_Camera->SetFocalPoint(focalPoint); - - int d1 = (idx + 1) % 3; - int d2 = (idx + 2) % 3; - - double max = std::max(dimensions[d1], dimensions[d2]); - - m_Camera->SetParallelScale(max / 2); -} - -void mitk::ManufacturerLogo::SetupPosition() -{ // Position and Scale of the logo - - double newPos[4]; - int dimensions[3]; - vtkImageData *image = m_Actor->GetInput(); - image->GetDimensions(dimensions); - // normalize image dimensions - double max = std::max(dimensions[0], dimensions[1]); - double normX = dimensions[0] / max; - double normY = dimensions[1] / max; - - double buffer = 0; // buffer to the boarder of the renderwindow - - switch (m_LogoPosition) - { - case mitk::ManufacturerLogo::LowerLeft: - { - newPos[0] = (0 + buffer); - newPos[1] = (0 + buffer); - newPos[2] = 0.2 * normX * m_ZoomFactor; - newPos[3] = 0.2 * normY * m_ZoomFactor; - break; - } - case mitk::ManufacturerLogo::LowerRight: - { - newPos[0] = (1 - buffer) - 0.2 * normX * m_ZoomFactor; - newPos[1] = 0.0; - newPos[2] = (1 - buffer); - newPos[3] = 0.2 * normY * m_ZoomFactor; - break; - } - case mitk::ManufacturerLogo::UpperLeft: - { - newPos[0] = (0 + buffer); - newPos[1] = (1 - buffer) - 0.2 * normY * m_ZoomFactor; - newPos[2] = 0.2 * normX * m_ZoomFactor; - newPos[3] = (1 - buffer); - break; - } - case mitk::ManufacturerLogo::UpperRight: - { - newPos[0] = (1 - buffer) - 0.2 * normX * m_ZoomFactor; - newPos[1] = (1 - buffer) - 0.2 * normY * m_ZoomFactor; - newPos[2] = (1 - buffer); - newPos[3] = (1 - buffer); - break; - } - case mitk::ManufacturerLogo::Middle: - default: - { - newPos[0] = 0.5 - 0.1 * normX * m_ZoomFactor; - newPos[1] = 0.5 - 0.1 * normY * m_ZoomFactor; - newPos[2] = 0.5 + 0.1 * normX * m_ZoomFactor; - newPos[3] = 0.5 + 0.1 * normY * m_ZoomFactor; - break; - } - } - - m_Renderer->SetViewport(newPos); -} - -void mitk::ManufacturerLogo::ForceMBILogoVisible(bool visible) -{ - m_ForceShowMBIDepartmentLogo = visible; -} - -void mitk::ManufacturerLogo::SetZoomFactor(double factor) -{ - m_ZoomFactor = factor; -} -void mitk::ManufacturerLogo::SetOpacity(double opacity) -{ - m_Opacity = opacity; -} - -/** - * Disables drawing of the logo. - * If you want to enable it, call the Enable() function. - */ -void mitk::ManufacturerLogo::Disable() -{ - if (this->IsEnabled() && !m_ForceShowMBIDepartmentLogo) - { - mitk::VtkLayerController::GetInstance(m_RenderWindow)->RemoveRenderer(m_Renderer); - m_IsEnabled = false; - } -} - -/** - * Checks, if the logo is currently - * enabled (visible) - */ -bool mitk::ManufacturerLogo::IsEnabled() -{ - return m_IsEnabled; -} - -void mitk::ManufacturerLogo::SetRequestedRegionToLargestPossibleRegion() -{ - // nothing to do -} - -bool mitk::ManufacturerLogo::RequestedRegionIsOutsideOfTheBufferedRegion() -{ - return false; -} - -bool mitk::ManufacturerLogo::VerifyRequestedRegion() -{ - return true; -} - -void mitk::ManufacturerLogo::SetRequestedRegion(const itk::DataObject *) -{ - // nothing to do -} diff --git a/Modules/Core/src/Rendering/mitkMapper.cpp b/Modules/Core/src/Rendering/mitkMapper.cpp index 33b0f2de59..407cb89bcf 100644 --- a/Modules/Core/src/Rendering/mitkMapper.cpp +++ b/Modules/Core/src/Rendering/mitkMapper.cpp @@ -1,163 +1,152 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "mitkMapper.h" #include "mitkBaseRenderer.h" #include "mitkDataNode.h" -#include "mitkOverlayManager.h" #include "mitkProperties.h" mitk::Mapper::Mapper() : m_DataNode(NULL), m_TimeStep(0) { } mitk::Mapper::~Mapper() { } mitk::BaseData *mitk::Mapper::GetData() const { return m_DataNode == NULL ? NULL : m_DataNode->GetData(); } mitk::DataNode *mitk::Mapper::GetDataNode() const { return this->m_DataNode; } bool mitk::Mapper::GetColor(float rgb[3], mitk::BaseRenderer *renderer, const char *name) const { const mitk::DataNode *node = GetDataNode(); if (node == NULL) return false; return node->GetColor(rgb, renderer, name); } bool mitk::Mapper::GetVisibility(bool &visible, mitk::BaseRenderer *renderer, const char *name) const { const mitk::DataNode *node = GetDataNode(); if (node == NULL) return false; return node->GetVisibility(visible, renderer, name); } bool mitk::Mapper::GetOpacity(float &opacity, mitk::BaseRenderer *renderer, const char *name) const { const mitk::DataNode *node = GetDataNode(); if (node == NULL) return false; return node->GetOpacity(opacity, renderer, name); } bool mitk::Mapper::GetLevelWindow(mitk::LevelWindow &levelWindow, mitk::BaseRenderer *renderer, const char *name) const { const mitk::DataNode *node = GetDataNode(); if (node == NULL) return false; return node->GetLevelWindow(levelWindow, renderer, name); } bool mitk::Mapper::IsVisible(mitk::BaseRenderer *renderer, const char *name) const { bool visible = true; GetDataNode()->GetVisibility(visible, renderer, name); return visible; } void mitk::Mapper::CalculateTimeStep(mitk::BaseRenderer *renderer) { if ((renderer != NULL) && (m_DataNode != NULL)) { m_TimeStep = renderer->GetTimeStep(m_DataNode->GetData()); } else { m_TimeStep = 0; } } void mitk::Mapper::Update(mitk::BaseRenderer *renderer) { - if (GetOverlayManager()) - GetOverlayManager()->AddBaseRenderer(renderer); - const DataNode *node = GetDataNode(); assert(node != NULL); mitk::BaseData *data = static_cast(node->GetData()); if (!data) return; // Calculate time step of the input data for the specified renderer (integer value) this->CalculateTimeStep(renderer); // Check if time step is valid const TimeGeometry *dataTimeGeometry = data->GetTimeGeometry(); if ((dataTimeGeometry == NULL) || (dataTimeGeometry->CountTimeSteps() == 0) || (!dataTimeGeometry->IsValidTimeStep(m_TimeStep))) { // TimeGeometry or time step is not valid for this data: // reset mapper so that nothing is displayed this->ResetMapper(renderer); return; } this->GenerateDataForRenderer(renderer); - if (GetOverlayManager()) - GetOverlayManager()->UpdateOverlays(renderer); } bool mitk::Mapper::BaseLocalStorage::IsGenerateDataRequired(mitk::BaseRenderer *renderer, mitk::Mapper *mapper, mitk::DataNode *dataNode) const { if (mapper && m_LastGenerateDataTime < mapper->GetMTime()) return true; if (dataNode) { if (m_LastGenerateDataTime < dataNode->GetDataReferenceChangedTime()) return true; mitk::BaseData *data = dataNode->GetData(); if (data && m_LastGenerateDataTime < data->GetMTime()) return true; } if (renderer && m_LastGenerateDataTime < renderer->GetTimeStepUpdateTime()) return true; return false; } void mitk::Mapper::SetDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer, bool overwrite) { node->AddProperty("visible", mitk::BoolProperty::New(true), renderer, overwrite); node->AddProperty("layer", mitk::IntProperty::New(0), renderer, overwrite); node->AddProperty("name", mitk::StringProperty::New("No Name!"), renderer, overwrite); } - -mitk::OverlayManager *mitk::Mapper::GetOverlayManager() const -{ - return NULL; -} diff --git a/Modules/Core/src/Rendering/mitkOverlay.cpp b/Modules/Core/src/Rendering/mitkOverlay.cpp deleted file mode 100644 index 439f03eca9..0000000000 --- a/Modules/Core/src/Rendering/mitkOverlay.cpp +++ /dev/null @@ -1,335 +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 "mitkOverlay.h" - -mitk::Overlay::Overlay() : m_LayoutedBy(NULL) -{ - m_PropertyList = mitk::PropertyList::New(); - this->SetName(this->GetNameOfClass()); - this->SetVisibility(true); - this->SetOpacity(1.0); -} - -mitk::Overlay::~Overlay() -{ -} - -void mitk::Overlay::SetProperty(const std::string &propertyKey, - const BaseProperty::Pointer &propertyValue, - const mitk::BaseRenderer *renderer) -{ - GetPropertyList(renderer)->SetProperty(propertyKey, propertyValue); - GetPropertyList(renderer)->Modified(); -} - -void mitk::Overlay::ReplaceProperty(const std::string &propertyKey, - const BaseProperty::Pointer &propertyValue, - const mitk::BaseRenderer *renderer) -{ - GetPropertyList(renderer)->ReplaceProperty(propertyKey, propertyValue); - GetPropertyList(renderer)->Modified(); -} - -void mitk::Overlay::AddProperty(const std::string &propertyKey, - const BaseProperty::Pointer &propertyValue, - const mitk::BaseRenderer *renderer, - bool overwrite) -{ - if ((overwrite) || (GetProperty(propertyKey, renderer) == NULL)) - { - SetProperty(propertyKey, propertyValue, renderer); - } -} - -void mitk::Overlay::ConcatenatePropertyList(PropertyList *pList, bool replace) -{ - m_PropertyList->ConcatenatePropertyList(pList, replace); -} - -mitk::BaseProperty *mitk::Overlay::GetProperty(const std::string &propertyKey, const mitk::BaseRenderer *renderer) const -{ - // renderer specified? - if (renderer) - { - std::map::const_iterator it; - // check for the renderer specific property - it = m_MapOfPropertyLists.find(renderer); - if (it != m_MapOfPropertyLists.cend()) // found - { - mitk::BaseProperty::Pointer property = it->second->GetProperty(propertyKey); - if (property.IsNotNull()) // found an enabled property in the render specific list - return property; - else // found a renderer specific list, but not the desired property - return m_PropertyList->GetProperty(propertyKey); // return renderer unspecific property - } - else // didn't find the property list of the given renderer - { - // return the renderer unspecific property if there is one - return m_PropertyList->GetProperty(propertyKey); - } - } - else // no specific renderer given; use the renderer independent one - { - mitk::BaseProperty::Pointer property = m_PropertyList->GetProperty(propertyKey); - if (property.IsNotNull()) - return property; - } - - // only to satisfy compiler! - return NULL; -} - -bool mitk::Overlay::GetBoolProperty(const std::string &propertyKey, bool &boolValue, mitk::BaseRenderer *renderer) const -{ - mitk::BoolProperty::Pointer boolprop = dynamic_cast(GetProperty(propertyKey, renderer)); - if (boolprop.IsNull()) - return false; - - boolValue = boolprop->GetValue(); - return true; -} - -bool mitk::Overlay::GetIntProperty(const std::string &propertyKey, int &intValue, mitk::BaseRenderer *renderer) const -{ - mitk::IntProperty::Pointer intprop = dynamic_cast(GetProperty(propertyKey, renderer)); - if (intprop.IsNull()) - return false; - - intValue = intprop->GetValue(); - return true; -} - -bool mitk::Overlay::GetFloatProperty(const std::string &propertyKey, - float &floatValue, - mitk::BaseRenderer *renderer) const -{ - mitk::FloatProperty::Pointer floatprop = dynamic_cast(GetProperty(propertyKey, renderer)); - if (floatprop.IsNull()) - return false; - - floatValue = floatprop->GetValue(); - return true; -} - -bool mitk::Overlay::GetStringProperty(const std::string &propertyKey, - std::string &string, - mitk::BaseRenderer *renderer) const -{ - mitk::StringProperty::Pointer stringProp = dynamic_cast(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; - } -} - -void mitk::Overlay::SetIntProperty(const std::string &propertyKey, int intValue, mitk::BaseRenderer *renderer) -{ - GetPropertyList(renderer)->SetProperty(propertyKey, mitk::IntProperty::New(intValue)); - Modified(); -} -void mitk::Overlay::SetBoolProperty(const std::string &propertyKey, - bool boolValue, - mitk::BaseRenderer *renderer /*=NULL*/) -{ - GetPropertyList(renderer)->SetProperty(propertyKey, mitk::BoolProperty::New(boolValue)); - Modified(); -} - -void mitk::Overlay::SetFloatProperty(const std::string &propertyKey, - float floatValue, - mitk::BaseRenderer *renderer /*=NULL*/) -{ - GetPropertyList(renderer)->SetProperty(propertyKey, mitk::FloatProperty::New(floatValue)); - Modified(); -} - -void mitk::Overlay::SetStringProperty(const std::string &propertyKey, - const std::string &stringValue, - mitk::BaseRenderer *renderer /*=NULL*/) -{ - GetPropertyList(renderer)->SetProperty(propertyKey, mitk::StringProperty::New(stringValue)); - Modified(); -} - -std::string mitk::Overlay::GetName() const -{ - mitk::StringProperty *sp = dynamic_cast(this->GetProperty("name")); - if (sp == NULL) - return ""; - return sp->GetValue(); -} - -void mitk::Overlay::SetName(const std::string &name) -{ - this->SetStringProperty("name", name); -} - -bool mitk::Overlay::GetName(std::string &nodeName, mitk::BaseRenderer *renderer, const std::string &propertyKey) const -{ - return GetStringProperty(propertyKey, nodeName, renderer); -} - -void mitk::Overlay::SetText(std::string text, mitk::BaseRenderer *renderer) -{ - SetStringProperty("Text", text.c_str(), renderer); -} - -std::string mitk::Overlay::GetText(mitk::BaseRenderer *renderer) const -{ - std::string text; - GetStringProperty("Text", text, renderer); - return text; -} - -void mitk::Overlay::SetFontSize(int fontSize, mitk::BaseRenderer *renderer) -{ - SetIntProperty("FontSize", fontSize, renderer); -} - -int mitk::Overlay::GetFontSize(mitk::BaseRenderer *renderer) const -{ - int fontSize = 1; - GetIntProperty("FontSize", fontSize, renderer); - return fontSize; -} - -bool mitk::Overlay::GetVisibility(bool &visible, mitk::BaseRenderer *renderer, const std::string &propertyKey) const -{ - return GetBoolProperty(propertyKey, visible, renderer); -} - -bool mitk::Overlay::IsVisible(mitk::BaseRenderer *renderer, const std::string &propertyKey, bool defaultIsOn) const -{ - return IsOn(propertyKey, renderer, defaultIsOn); -} - -bool mitk::Overlay::GetColor(float rgb[], mitk::BaseRenderer *renderer, const std::string &propertyKey) const -{ - mitk::ColorProperty::Pointer colorprop = dynamic_cast(GetProperty(propertyKey, renderer)); - if (colorprop.IsNull()) - return false; - - memcpy(rgb, colorprop->GetColor().GetDataPointer(), 3 * sizeof(float)); - return true; -} - -void mitk::Overlay::SetColor(const mitk::Color &color, mitk::BaseRenderer *renderer, const std::string &propertyKey) -{ - mitk::ColorProperty::Pointer prop; - prop = mitk::ColorProperty::New(color); - GetPropertyList(renderer)->SetProperty(propertyKey, prop); -} - -void mitk::Overlay::SetColor( - float red, float green, float blue, mitk::BaseRenderer *renderer, const std::string &propertyKey) -{ - float color[3]; - color[0] = red; - color[1] = green; - color[2] = blue; - SetColor(color, renderer, propertyKey); -} - -void mitk::Overlay::SetColor(const float rgb[], mitk::BaseRenderer *renderer, const std::string &propertyKey) -{ - mitk::ColorProperty::Pointer prop; - prop = mitk::ColorProperty::New(rgb); - GetPropertyList(renderer)->SetProperty(propertyKey, prop); -} - -bool mitk::Overlay::GetOpacity(float &opacity, mitk::BaseRenderer *renderer, const std::string &propertyKey) const -{ - mitk::FloatProperty::Pointer opacityprop = dynamic_cast(GetProperty(propertyKey, renderer)); - if (opacityprop.IsNull()) - return false; - - opacity = opacityprop->GetValue(); - return true; -} - -void mitk::Overlay::SetOpacity(float opacity, mitk::BaseRenderer *renderer, const std::string &propertyKey) -{ - mitk::FloatProperty::Pointer prop; - prop = mitk::FloatProperty::New(opacity); - GetPropertyList(renderer)->SetProperty(propertyKey, prop); -} - -void mitk::Overlay::SetVisibility(bool visible, mitk::BaseRenderer *renderer, const std::string &propertyKey) -{ - mitk::BoolProperty::Pointer prop; - prop = mitk::BoolProperty::New(visible); - GetPropertyList(renderer)->SetProperty(propertyKey, prop); -} - -mitk::PropertyList *mitk::Overlay::GetPropertyList(const mitk::BaseRenderer *renderer) const -{ - if (renderer == NULL) - return m_PropertyList; - - mitk::PropertyList::Pointer &propertyList = m_MapOfPropertyLists[renderer]; - - if (propertyList.IsNull()) - propertyList = mitk::PropertyList::New(); - - assert(m_MapOfPropertyLists[renderer].IsNotNull()); - - return propertyList; -} - -bool mitk::Overlay::BaseLocalStorage::IsGenerateDataRequired(mitk::BaseRenderer *renderer, mitk::Overlay *overlay) -{ - if (m_LastGenerateDataTime < overlay->GetMTime()) - return true; - - if (m_LastGenerateDataTime < overlay->GetPropertyList()->GetMTime()) - return true; - - if (m_LastGenerateDataTime < overlay->GetPropertyList(renderer)->GetMTime()) - return true; - - if (renderer && m_LastGenerateDataTime < renderer->GetTimeStepUpdateTime()) - return true; - - return false; -} - -mitk::Overlay::Bounds mitk::Overlay::GetBoundsOnDisplay(mitk::BaseRenderer *) const -{ - mitk::Overlay::Bounds bounds; - bounds.Position[0] = bounds.Position[1] = bounds.Size[0] = bounds.Size[1] = 0; - return bounds; -} - -void mitk::Overlay::SetBoundsOnDisplay(mitk::BaseRenderer *, const mitk::Overlay::Bounds &) -{ -} - -void mitk::Overlay::SetForceInForeground(bool forceForeground) -{ - m_ForceInForeground = forceForeground; -} - -bool mitk::Overlay::IsForceInForeground() const -{ - return m_ForceInForeground; -} diff --git a/Modules/Core/src/Rendering/mitkOverlayManager.cpp b/Modules/Core/src/Rendering/mitkOverlayManager.cpp deleted file mode 100644 index 7af52e6a72..0000000000 --- a/Modules/Core/src/Rendering/mitkOverlayManager.cpp +++ /dev/null @@ -1,228 +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 "mitkOverlayManager.h" -#include "mitkBaseRenderer.h" - -#include - -namespace mitk -{ - itkEventMacroDefinition(OverlayAddEvent, itk::AnyEvent) - - OverlayManager::OverlayManager() - { - } - - OverlayManager::~OverlayManager() - { - RemoveAllOverlays(); - RemoveAllBaseRenderers(); - } - - void OverlayManager::AddBaseRenderer(BaseRenderer *renderer) - { - if (!m_ForegroundRenderer[renderer]) - { - m_ForegroundRenderer[renderer] = vtkSmartPointer::New(); - vtkRenderer *rendererVtk = m_ForegroundRenderer[renderer]; - rendererVtk->SetActiveCamera(renderer->GetVtkRenderer()->GetActiveCamera()); - VtkLayerController::GetInstance(renderer->GetRenderWindow())->InsertForegroundRenderer(rendererVtk, false); - rendererVtk->SetInteractive(false); - } - std::pair inSet; - inSet = m_BaseRendererSet.insert(renderer); - if (inSet.second) - { - OverlaySet::const_iterator it; - for (it = m_OverlaySet.cbegin(); it != m_OverlaySet.cend(); ++it) - { - if ((*it)->IsForceInForeground()) - (*it)->AddToRenderer(renderer, m_ForegroundRenderer[renderer]); - else - (*it)->AddToBaseRenderer(renderer); - } - } - } - - void OverlayManager::RemoveBaseRenderer(BaseRenderer *renderer) - { - if (!renderer) - return; - - vtkRenderer *forgroundRenderer = m_ForegroundRenderer[renderer]; - OverlaySet::const_iterator it; - for (it = m_OverlaySet.cbegin(); it != m_OverlaySet.cend(); ++it) - { - (*it)->RemoveFromBaseRenderer(renderer); - if (forgroundRenderer) - (*it)->RemoveFromRenderer(renderer, forgroundRenderer); - } - - BaseRendererSet::const_iterator i = m_BaseRendererSet.find(renderer); - if (i == m_BaseRendererSet.cend()) - return; - - m_BaseRendererSet.erase(i); - - m_ForegroundRenderer[renderer] = NULL; - } - - void OverlayManager::RemoveAllBaseRenderers() - { - BaseRendererSet::const_iterator it; - for (it = m_BaseRendererSet.cbegin(); it != m_BaseRendererSet.cend(); ++it) - { - this->RemoveBaseRenderer(*it); - } - } - - const OverlayManager::OverlaySet &OverlayManager::GetAllOverlays() { return m_OverlaySet; } - OverlayManager *OverlayManager::GetInstance() - { - auto renderwindows = RenderingManager::GetInstance()->GetAllRegisteredRenderWindows(); - for (auto renderwindow : renderwindows) - { - BaseRenderer *renderer = BaseRenderer::GetInstance(renderwindow); - if (renderer && renderer->GetOverlayManager().IsNotNull()) - return renderer->GetOverlayManager(); - } - return nullptr; - } - - void OverlayManager::AddOverlay(const Overlay::Pointer &overlay, bool ForceInForeground) - { - std::pair inSet; - inSet = m_OverlaySet.insert(overlay); - if (inSet.second) - { - BaseRendererSet::const_iterator it; - for (it = m_BaseRendererSet.cbegin(); it != m_BaseRendererSet.cend(); ++it) - { - if (ForceInForeground) - { - vtkRenderer *forgroundRenderer = m_ForegroundRenderer[*it]; - overlay->AddToRenderer(*it, forgroundRenderer); - } - else - overlay->AddToBaseRenderer(*it); - this->InvokeEvent(OverlayAddEvent()); - } - } - } - - void OverlayManager::AddOverlay(const Overlay::Pointer &overlay, BaseRenderer *renderer, bool ForceInForeground) - { - std::pair inSet; - inSet = m_OverlaySet.insert(overlay); - if (inSet.second) - { - if (ForceInForeground) - { - vtkRenderer *forgroundRenderer = m_ForegroundRenderer[renderer]; - overlay->AddToRenderer(renderer, forgroundRenderer); - } - else - overlay->AddToBaseRenderer(renderer); - this->InvokeEvent(OverlayAddEvent()); - } - } - - void OverlayManager::RemoveOverlay(const Overlay::Pointer &overlay) - { - OverlaySet::const_iterator overlayIt = m_OverlaySet.find(overlay); - if (overlayIt == m_OverlaySet.cend()) - return; - - BaseRendererSet::const_iterator it; - for (it = m_BaseRendererSet.cbegin(); it != m_BaseRendererSet.cend(); ++it) - { - overlay->RemoveFromBaseRenderer(*it); - vtkRenderer *forgroundRenderer = m_ForegroundRenderer[*it]; - if (forgroundRenderer) - overlay->RemoveFromRenderer(*it, forgroundRenderer); - } - - m_OverlaySet.erase(overlayIt); - this->InvokeEvent(OverlayAddEvent()); - } - - void OverlayManager::RemoveAllOverlays() - { - while (!m_OverlaySet.empty()) - RemoveOverlay(*m_OverlaySet.cbegin()); - } - - void OverlayManager::UpdateOverlays(BaseRenderer *baseRenderer) - { - OverlaySet::const_iterator it; - for (it = m_OverlaySet.cbegin(); it != m_OverlaySet.cend(); ++it) - { - (*it)->Update(baseRenderer); - } - UpdateLayouts(baseRenderer); - } - - void OverlayManager::SetLayouter(Overlay *overlay, const std::string &identifier, BaseRenderer *renderer) - { - if (renderer) - { - AbstractOverlayLayouter::Pointer layouter = GetLayouter(renderer, identifier); - if (layouter.IsNull()) - { - MITK_WARN << "Layouter " << identifier << " cannot be found or created!"; - return; - } - else - { - layouter->AddOverlay(overlay); - } - } - } - - void OverlayManager::UpdateLayouts(BaseRenderer *renderer) - { - const LayouterMap layouters = m_LayouterMap[renderer]; - LayouterMap::const_iterator it; - for (it = layouters.cbegin(); it != layouters.cend(); ++it) - { - (it->second)->PrepareLayout(); - } - } - - AbstractOverlayLayouter::Pointer OverlayManager::GetLayouter(BaseRenderer *renderer, const std::string &identifier) - { - AbstractOverlayLayouter::Pointer layouter = m_LayouterMap[renderer][identifier]; - return layouter; - } - - void OverlayManager::AddLayouter(const AbstractOverlayLayouter::Pointer &layouter) - { - if (layouter.IsNotNull()) - { - AbstractOverlayLayouter::Pointer oldLayouter = - m_LayouterMap[layouter->GetBaseRenderer()][layouter->GetIdentifier()]; - if (oldLayouter.IsNotNull() && oldLayouter.GetPointer() != layouter.GetPointer()) - { - MITK_WARN << "Layouter " << layouter->GetIdentifier() << " does already exist!"; - } - else if (oldLayouter.IsNull()) - { - m_LayouterMap[layouter->GetBaseRenderer()][layouter->GetIdentifier()] = layouter; - } - } - } -} diff --git a/Modules/Core/src/Rendering/mitkRenderWindowBase.cpp b/Modules/Core/src/Rendering/mitkRenderWindowBase.cpp index 70b4216a35..2b7750ceb1 100644 --- a/Modules/Core/src/Rendering/mitkRenderWindowBase.cpp +++ b/Modules/Core/src/Rendering/mitkRenderWindowBase.cpp @@ -1,116 +1,121 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "mitkRenderWindowBase.h" #include "mitkRenderingManager.h" #include "mitkVtkLayerController.h" #include "vtkRenderer.h" +#include "mitkAnnotationUtils.h" + mitk::RenderWindowBase::RenderWindowBase() : m_RenderProp(NULL), m_InResize(false) { } /* * "Member functions, including virtual functions (10.3), can be called during construction or destruction (12.6.2). When a * virtual function is called directly or indirectly from a constructor (including from the mem-initializer for a data member) or from * a destructor, and the object to which the call applies is the object under construction or destruction, the function called is * the one defined in the constructor or destructor's own class or in one of its bases, but not a function overriding it in a class * derived from the constructor or destructor's class, or overriding it in one of the other base classes of the most derived object[..]" * or short: within constructors and destructors classes are not polymorph. */ void mitk::RenderWindowBase::Initialize(mitk::RenderingManager *renderingManager, const char *name, mitk::BaseRenderer::RenderingMode::Type renderingMode) { if (renderingManager == NULL) { renderingManager = mitk::RenderingManager::GetInstance(); } if (m_Renderer.IsNull()) { m_Renderer = mitk::VtkPropRenderer::New(name, GetVtkRenderWindow(), renderingManager, renderingMode); } m_Renderer->InitRenderer(this->GetVtkRenderWindow()); mitk::BaseRenderer::AddInstance(GetVtkRenderWindow(), m_Renderer); renderingManager->AddRenderWindow(GetVtkRenderWindow()); + // Add previously created overlays to new BaseRenderer + mitk::AnnotationUtils::BaseRendererChanged(m_Renderer); + m_RenderProp = vtkMitkRenderProp::New(); m_RenderProp->SetPropRenderer(m_Renderer); m_Renderer->GetVtkRenderer()->AddViewProp(m_RenderProp); if ((this->GetVtkRenderWindow()->GetSize()[0] > 10) && (this->GetVtkRenderWindow()->GetSize()[1] > 10)) m_Renderer->InitSize(this->GetVtkRenderWindow()->GetSize()[0], this->GetVtkRenderWindow()->GetSize()[1]); m_InResize = false; } bool mitk::RenderWindowBase::HandleEvent(InteractionEvent *interactionEvent) { return m_Renderer->GetDispatcher()->ProcessEvent(interactionEvent); } void mitk::RenderWindowBase::Destroy() { m_Renderer->GetRenderingManager()->RemoveRenderWindow(GetVtkRenderWindow()); mitk::BaseRenderer::RemoveInstance(GetVtkRenderWindow()); m_Renderer->GetVtkRenderer()->RemoveViewProp(m_RenderProp); m_RenderProp->Delete(); } mitk::RenderWindowBase::~RenderWindowBase() { } mitk::SliceNavigationController *mitk::RenderWindowBase::GetSliceNavigationController() { return mitk::BaseRenderer::GetInstance(this->GetVtkRenderWindow())->GetSliceNavigationController(); } mitk::CameraRotationController *mitk::RenderWindowBase::GetCameraRotationController() { return mitk::BaseRenderer::GetInstance(this->GetVtkRenderWindow())->GetCameraRotationController(); } mitk::BaseController *mitk::RenderWindowBase::GetController() { mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(GetVtkRenderWindow()); switch (renderer->GetMapperID()) { case mitk::BaseRenderer::Standard2D: return GetSliceNavigationController(); case mitk::BaseRenderer::Standard3D: return GetCameraRotationController(); default: return GetSliceNavigationController(); } } mitk::VtkPropRenderer *mitk::RenderWindowBase::GetRenderer() { return m_Renderer; } diff --git a/Modules/Core/src/Rendering/mitkVtkPropRenderer.cpp b/Modules/Core/src/Rendering/mitkVtkPropRenderer.cpp index 88d712cd32..6309fc8ca8 100644 --- a/Modules/Core/src/Rendering/mitkVtkPropRenderer.cpp +++ b/Modules/Core/src/Rendering/mitkVtkPropRenderer.cpp @@ -1,685 +1,680 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "mitkVtkPropRenderer.h" // MAPPERS #include "mitkCameraController.h" #include "mitkImageVtkMapper2D.h" #include "mitkMapper.h" #include "mitkPlaneGeometryDataVtkMapper3D.h" #include "mitkVtkMapper.h" #include #include #include #include #include #include #include #include #include #include // VTK #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include mitk::VtkPropRenderer::VtkPropRenderer(const char *name, vtkRenderWindow *renWin, mitk::RenderingManager *rm, mitk::BaseRenderer::RenderingMode::Type renderingMode) : BaseRenderer(name, renWin, rm, renderingMode), m_CameraInitializedForMapperID(0) { didCount = false; m_WorldPointPicker = vtkWorldPointPicker::New(); m_PointPicker = vtkPointPicker::New(); m_PointPicker->SetTolerance(0.0025); m_CellPicker = vtkCellPicker::New(); m_CellPicker->SetTolerance(0.0025); mitk::PlaneGeometryDataVtkMapper3D::Pointer geometryMapper = mitk::PlaneGeometryDataVtkMapper3D::New(); m_CurrentWorldPlaneGeometryMapper = geometryMapper; m_CurrentWorldPlaneGeometryNode->SetMapper(2, geometryMapper); m_LightKit = vtkLightKit::New(); m_LightKit->AddLightsToRenderer(m_VtkRenderer); m_PickingMode = WorldPointPicking; m_TextRenderer = vtkRenderer::New(); m_TextRenderer->SetRenderWindow(renWin); m_TextRenderer->SetInteractive(0); m_TextRenderer->SetErase(0); } /*! \brief Destructs the VtkPropRenderer. */ mitk::VtkPropRenderer::~VtkPropRenderer() { // Workaround for GLDisplayList Bug { m_MapperID = 0; checkState(); } - if (m_LightKit != NULL) + if (m_LightKit != nullptr) m_LightKit->Delete(); - if (m_VtkRenderer != NULL) + if (m_VtkRenderer != nullptr) { - m_CameraController = NULL; + m_CameraController = nullptr; m_VtkRenderer->Delete(); - m_VtkRenderer = NULL; + m_VtkRenderer = nullptr; } else - m_CameraController = NULL; + m_CameraController = nullptr; - if (m_WorldPointPicker != NULL) + if (m_WorldPointPicker != nullptr) m_WorldPointPicker->Delete(); - if (m_PointPicker != NULL) + if (m_PointPicker != nullptr) m_PointPicker->Delete(); - if (m_CellPicker != NULL) + if (m_CellPicker != nullptr) m_CellPicker->Delete(); - if (m_TextRenderer != NULL) + if (m_TextRenderer != nullptr) m_TextRenderer->Delete(); } void mitk::VtkPropRenderer::SetDataStorage(mitk::DataStorage *storage) { - if (storage == NULL || storage == m_DataStorage) + if (storage == nullptr || storage == m_DataStorage) return; BaseRenderer::SetDataStorage(storage); static_cast(m_CurrentWorldPlaneGeometryMapper.GetPointer()) ->SetDataStorageForTexture(m_DataStorage.GetPointer()); // Compute the geometry from the current data tree bounds and set it as world geometry this->SetWorldGeometryToDataStorageBounds(); } bool mitk::VtkPropRenderer::SetWorldGeometryToDataStorageBounds() { if (m_DataStorage.IsNull()) return false; // initialize world geometry - mitk::TimeGeometry::Pointer geometry = m_DataStorage->ComputeVisibleBoundingGeometry3D(NULL, "includeInBoundingBox"); + mitk::TimeGeometry::Pointer geometry = m_DataStorage->ComputeVisibleBoundingGeometry3D(nullptr, "includeInBoundingBox"); if (geometry.IsNull()) return false; this->SetWorldTimeGeometry(geometry); this->GetVtkRenderer()->ResetCamera(); this->GetCameraController()->Fit(); this->Modified(); return true; } /*! \brief Called by the vtkMitkRenderProp in order to start MITK rendering process. */ int mitk::VtkPropRenderer::Render(mitk::VtkPropRenderer::RenderType type) { - // Update all overlays in any case - this->UpdateOverlays(); // Do we have objects to render? if (this->GetEmptyWorldGeometry()) return 0; if (m_DataStorage.IsNull()) return 0; // Update mappers and prepare mapper queue if (type == VtkPropRenderer::Opaque) this->PrepareMapperQueue(); // go through the generated list and let the sorted mappers paint for (auto it = m_MappersMap.cbegin(); it != m_MappersMap.cend(); it++) { Mapper *mapper = (*it).second; mapper->MitkRender(this, type); } - // Update overlays in case a mapper has changed them - this->UpdateOverlays(); - // Render text if (type == VtkPropRenderer::Overlay) { if (m_TextCollection.size() > 0) { m_TextRenderer->SetViewport(this->GetVtkRenderer()->GetViewport()); for (TextMapType::iterator it = m_TextCollection.begin(); it != m_TextCollection.end(); ++it) m_TextRenderer->AddViewProp((*it).second); m_TextRenderer->Render(); } } return 1; } /*! \brief PrepareMapperQueue iterates the datatree PrepareMapperQueue iterates the datatree in order to find mappers which shall be rendered. Also, it sortes the mappers wrt to their layer. */ void mitk::VtkPropRenderer::PrepareMapperQueue() { // variable for counting LOD-enabled mappers m_NumberOfVisibleLODEnabledMappers = 0; // Do we have to update the mappers ? if (m_LastUpdateTime < GetMTime() || m_LastUpdateTime < this->GetCurrentWorldPlaneGeometry()->GetMTime()) { Update(); } else if (m_MapperID >= 1 && m_MapperID < 6) Update(); // remove all text properties before mappers will add new ones m_TextRenderer->RemoveAllViewProps(); for (unsigned int i = 0; i < m_TextCollection.size(); i++) { m_TextCollection[i]->Delete(); } m_TextCollection.clear(); // clear priority_queue m_MappersMap.clear(); int mapperNo = 0; // DataStorage if (m_DataStorage.IsNull()) return; DataStorage::SetOfObjects::ConstPointer allObjects = m_DataStorage->GetAll(); for (DataStorage::SetOfObjects::ConstIterator it = allObjects->Begin(); it != allObjects->End(); ++it) { const DataNode::Pointer node = it->Value(); if (node.IsNull()) continue; const mitk::Mapper::Pointer mapper = node->GetMapper(m_MapperID); if (mapper.IsNull()) continue; bool visible = true; node->GetVisibility(visible, this, "visible"); // The information about LOD-enabled mappers is required by RenderingManager if (mapper->IsLODEnabled(this) && visible) { ++m_NumberOfVisibleLODEnabledMappers; } // mapper without a layer property get layer number 1 int layer = 1; node->GetIntProperty("layer", layer, this); int nr = (layer << 16) + mapperNo; m_MappersMap.insert(std::pair(nr, mapper)); mapperNo++; } } void mitk::VtkPropRenderer::Update(mitk::DataNode *datatreenode) { - if (datatreenode != NULL) + if (datatreenode != nullptr) { mitk::Mapper::Pointer mapper = datatreenode->GetMapper(m_MapperID); if (mapper.IsNotNull()) { if (GetCurrentWorldPlaneGeometry()->IsValid()) { mapper->Update(this); { VtkMapper *vtkmapper = dynamic_cast(mapper.GetPointer()); - if (vtkmapper != NULL) + if (vtkmapper != nullptr) { vtkmapper->UpdateVtkTransform(this); } } } } } } void mitk::VtkPropRenderer::Update() { if (m_DataStorage.IsNull()) return; mitk::DataStorage::SetOfObjects::ConstPointer all = m_DataStorage->GetAll(); for (mitk::DataStorage::SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it) Update(it->Value()); Modified(); m_LastUpdateTime = GetMTime(); } /*! \brief This method is called from the two Constructors */ void mitk::VtkPropRenderer::InitRenderer(vtkRenderWindow *renderWindow) { BaseRenderer::InitRenderer(renderWindow); vtkCallbackCommand *renderCallbackCommand = vtkCallbackCommand::New(); renderCallbackCommand->SetCallback(VtkPropRenderer::RenderingCallback); renderWindow->GetInteractor()->AddObserver(vtkCommand::RenderEvent, renderCallbackCommand); renderCallbackCommand->Delete(); - if (renderWindow == NULL) + if (renderWindow == nullptr) { m_InitNeeded = false; m_ResizeNeeded = false; return; } m_InitNeeded = true; m_ResizeNeeded = true; m_LastUpdateTime = 0; } void mitk::VtkPropRenderer::RenderingCallback(vtkObject *caller, unsigned long, void *, void *) { vtkRenderWindowInteractor *renderWindowInteractor = dynamic_cast(caller); if (!renderWindowInteractor) return; mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(renderWindowInteractor->GetRenderWindow()); if (renderer) renderer->RequestUpdate(); } /*! \brief Resize the OpenGL Window */ void mitk::VtkPropRenderer::Resize(int w, int h) { BaseRenderer::Resize(w, h); m_RenderingManager->RequestUpdate(this->GetRenderWindow()); } void mitk::VtkPropRenderer::InitSize(int w, int h) { m_RenderWindow->SetSize(w, h); Superclass::InitSize(w, h); Modified(); Update(); - if (m_VtkRenderer != NULL) + if (m_VtkRenderer != nullptr) { int w = vtkObject::GetGlobalWarningDisplay(); vtkObject::GlobalWarningDisplayOff(); m_VtkRenderer->ResetCamera(); vtkObject::SetGlobalWarningDisplay(w); } this->GetCameraController()->Fit(); } int mitk::VtkPropRenderer::WriteSimpleText( std::string text, double posX, double posY, double color1, double color2, double color3, float opacity) { this->GetVtkRenderer()->ViewToDisplay(); if (!text.empty()) { Point2D p; vtkTextActor *textActor = vtkTextActor::New(); textActor->SetDisplayPosition(posX, posY); textActor->SetInput(text.c_str()); textActor->SetTextScaleModeToNone(); textActor->GetTextProperty()->SetColor(color1, color2, color3); // TODO: Read color from node property textActor->GetTextProperty()->SetOpacity(opacity); int text_id = m_TextCollection.size(); m_TextCollection.insert(TextMapType::value_type(text_id, textActor)); return text_id; } else { return -1; } } void mitk::VtkPropRenderer::SetMapperID(const MapperSlotId mapperId) { if (m_MapperID != mapperId) Superclass::SetMapperID(mapperId); // Workaround for GL Displaylist Bug checkState(); } /*! \brief Activates the current renderwindow. */ void mitk::VtkPropRenderer::MakeCurrent() { - if (m_RenderWindow != NULL) + if (m_RenderWindow != nullptr) m_RenderWindow->MakeCurrent(); } void mitk::VtkPropRenderer::PickWorldPoint(const mitk::Point2D &displayPoint, mitk::Point3D &worldPoint) const { if (this->GetRenderWindow()->GetNeverRendered() != 0) return; // somebody called picking before we ever rendered; cannot have enough information yet switch (m_PickingMode) { case (WorldPointPicking): { m_WorldPointPicker->Pick(displayPoint[0], displayPoint[1], 0, m_VtkRenderer); vtk2itk(m_WorldPointPicker->GetPickPosition(), worldPoint); break; } case (PointPicking): { m_PointPicker->Pick(displayPoint[0], displayPoint[1], 0, m_VtkRenderer); vtk2itk(m_PointPicker->GetPickPosition(), worldPoint); break; } case (CellPicking): { m_CellPicker->Pick(displayPoint[0], displayPoint[1], 0, m_VtkRenderer); vtk2itk(m_CellPicker->GetPickPosition(), worldPoint); break; } } // todo: is this picking in 2D renderwindows? // Superclass::PickWorldPoint(displayPoint, worldPoint); } mitk::DataNode *mitk::VtkPropRenderer::PickObject(const Point2D &displayPosition, Point3D &worldPosition) const { m_CellPicker->InitializePickList(); // Iterate over all DataStorage objects to determine all vtkProps intended // for picking DataStorage::SetOfObjects::ConstPointer allObjects = m_DataStorage->GetAll(); for (DataStorage::SetOfObjects::ConstIterator it = allObjects->Begin(); it != allObjects->End(); ++it) { const DataNode *node = it->Value(); - if (node == NULL) + if (node == nullptr) continue; bool pickable = false; node->GetBoolProperty("pickable", pickable); if (!pickable) continue; VtkMapper *mapper = dynamic_cast(node->GetMapper(m_MapperID)); - if (mapper == NULL) + if (mapper == nullptr) continue; vtkProp *prop = mapper->GetVtkProp((mitk::BaseRenderer *)this); - if (prop == NULL) + if (prop == nullptr) continue; m_CellPicker->AddPickList(prop); } // Do the picking and retrieve the picked vtkProp (if any) m_CellPicker->PickFromListOn(); m_CellPicker->Pick(displayPosition[0], displayPosition[1], 0.0, m_VtkRenderer); m_CellPicker->PickFromListOff(); vtk2itk(m_CellPicker->GetPickPosition(), worldPosition); vtkProp *prop = m_CellPicker->GetViewProp(); - if (prop == NULL) + if (prop == nullptr) { - return NULL; + return nullptr; } // Iterate over all DataStorage objects to determine if the retrieved // vtkProp is owned by any associated mapper. for (DataStorage::SetOfObjects::ConstIterator it = allObjects->Begin(); it != allObjects->End(); ++it) { DataNode::Pointer node = it->Value(); if (node.IsNull()) continue; mitk::Mapper *mapper = node->GetMapper(m_MapperID); - if (mapper == NULL) + if (mapper == nullptr) continue; mitk::VtkMapper *vtkmapper = dynamic_cast(mapper); if (vtkmapper) { // if vtk-based, then ... if (vtkmapper->HasVtkProp(prop, const_cast(this))) { return node; } } } - return NULL; + return nullptr; } // todo: is this 2D renderwindow picking? // return Superclass::PickObject( displayPosition, worldPosition ); vtkTextProperty *mitk::VtkPropRenderer::GetTextLabelProperty(int text_id) { return this->m_TextCollection[text_id]->GetTextProperty(); } void mitk::VtkPropRenderer::InitPathTraversal() { if (m_DataStorage.IsNotNull()) { this->UpdatePaths(); this->m_Paths->InitTraversal(); } } void mitk::VtkPropRenderer::UpdatePaths() { if (m_DataStorage.IsNull()) { return; } if (GetMTime() > m_PathTime || (m_Paths != nullptr && m_Paths->GetMTime() > m_PathTime)) { // Create the list to hold all the paths m_Paths = vtkSmartPointer::New(); DataStorage::SetOfObjects::ConstPointer objects = m_DataStorage->GetAll(); for (DataStorage::SetOfObjects::const_iterator iter = objects->begin(); iter != objects->end(); ++iter) { vtkSmartPointer onePath = vtkSmartPointer::New(); Mapper *mapper = (*iter)->GetMapper(BaseRenderer::Standard3D); if (mapper) { VtkMapper *vtkmapper = dynamic_cast(mapper); { vtkProp *prop = vtkmapper->GetVtkProp(this); if (prop && prop->GetVisibility()) { // add to assembly path onePath->AddNode(prop, prop->GetMatrix()); m_Paths->AddItem(onePath); } } } } m_PathTime.Modified(); } } int mitk::VtkPropRenderer::GetNumberOfPaths() { UpdatePaths(); return m_Paths->GetNumberOfItems(); } vtkAssemblyPath *mitk::VtkPropRenderer::GetNextPath() { return m_Paths ? m_Paths->GetNextItem() : 0; } void mitk::VtkPropRenderer::ReleaseGraphicsResources(vtkWindow * /*renWin*/) { if (m_DataStorage.IsNull()) return; DataStorage::SetOfObjects::ConstPointer allObjects = m_DataStorage->GetAll(); for (DataStorage::SetOfObjects::const_iterator iter = allObjects->begin(); iter != allObjects->end(); ++iter) { DataNode::Pointer node = *iter; if (node.IsNull()) continue; Mapper *mapper = node->GetMapper(m_MapperID); if (mapper) { VtkMapper *vtkmapper = dynamic_cast(mapper); if (vtkmapper) vtkmapper->ReleaseGraphicsResources(this); } } } const vtkWorldPointPicker *mitk::VtkPropRenderer::GetWorldPointPicker() const { return m_WorldPointPicker; } const vtkPointPicker *mitk::VtkPropRenderer::GetPointPicker() const { return m_PointPicker; } const vtkCellPicker *mitk::VtkPropRenderer::GetCellPicker() const { return m_CellPicker; } mitk::VtkPropRenderer::MappersMapType mitk::VtkPropRenderer::GetMappersMap() const { return m_MappersMap; } // Workaround for GL Displaylist bug static int glWorkAroundGlobalCount = 0; bool mitk::VtkPropRenderer::useImmediateModeRendering() { return glWorkAroundGlobalCount > 1; } void mitk::VtkPropRenderer::checkState() { if (m_MapperID == Standard3D) { if (!didCount) { didCount = true; glWorkAroundGlobalCount++; if (glWorkAroundGlobalCount == 2) { MITK_INFO << "Multiple 3D Renderwindows active...: turning Immediate Rendering ON for legacy mappers"; // vtkMapper::GlobalImmediateModeRenderingOn(); } } } else { if (didCount) { didCount = false; glWorkAroundGlobalCount--; if (glWorkAroundGlobalCount == 1) { MITK_INFO << "Single 3D Renderwindow active...: turning Immediate Rendering OFF for legacy mappers"; // vtkMapper::GlobalImmediateModeRenderingOff(); } } } } //### Contains all methods which are neceassry before each VTK Render() call void mitk::VtkPropRenderer::PrepareRender() { if (this->GetMapperID() != m_CameraInitializedForMapperID) { Initialize2DvtkCamera(); // Set parallel projection etc. } GetCameraController()->AdjustCameraToPlane(); } bool mitk::VtkPropRenderer::Initialize2DvtkCamera() { if (this->GetMapperID() == Standard3D) { // activate parallel projection for 2D this->GetVtkRenderer()->GetActiveCamera()->SetParallelProjection(false); vtkSmartPointer style = vtkSmartPointer::New(); this->GetRenderWindow()->GetInteractor()->SetInteractorStyle(style); this->GetRenderWindow()->GetInteractor()->EnableRenderOff(); m_CameraInitializedForMapperID = Standard3D; } else if (this->GetMapperID() == Standard2D) { // activate parallel projection for 2D this->GetVtkRenderer()->GetActiveCamera()->SetParallelProjection(true); // turn the light out in the scene in order to render correct grey values. // TODO Implement a property for light in the 2D render windows (in another method) this->GetVtkRenderer()->RemoveAllLights(); vtkSmartPointer style = vtkSmartPointer::New(); this->GetRenderWindow()->GetInteractor()->SetInteractorStyle(style); this->GetRenderWindow()->GetInteractor()->EnableRenderOff(); m_CameraInitializedForMapperID = Standard2D; } return true; } diff --git a/Modules/Core/test/mitkDataNodeTest.cpp b/Modules/Core/test/mitkDataNodeTest.cpp index 26855a05cd..44756390c8 100644 --- a/Modules/Core/test/mitkDataNodeTest.cpp +++ b/Modules/Core/test/mitkDataNodeTest.cpp @@ -1,322 +1,317 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "mitkDataNode.h" #include "mitkVtkPropRenderer.h" #include #include "mitkTestingMacros.h" #include // Basedata Test #include #include -#include #include #include #include // Mapper Test #include #include #include #include #include #include #include // Interactors #include // Property list Test #include /** * Simple example for a test for the (non-existent) class "DataNode". * * argc and argv are the command line parameters which were passed to * the ADD_TEST command in the CMakeLists.txt file. For the automatic * tests, argv is either empty for the simple tests or contains the filename * of a test image for the image tests (see CMakeLists.txt). */ class mitkDataNodeTestClass { public: static void TestDataSetting(mitk::DataNode::Pointer dataNode) { mitk::BaseData::Pointer baseData; // NULL pointer Test dataNode->SetData(baseData); MITK_TEST_CONDITION(baseData == dataNode->GetData(), "Testing if a NULL pointer was set correctly") baseData = mitk::GeometryData::New(); dataNode->SetData(baseData); MITK_TEST_CONDITION(baseData == dataNode->GetData(), "Testing if a GeometryData object was set correctly") baseData = mitk::PlaneGeometryData::New(); dataNode->SetData(baseData); MITK_TEST_CONDITION(baseData == dataNode->GetData(), "Testing if a PlaneGeometryData object was set correctly") - baseData = mitk::ManufacturerLogo::New(); - dataNode->SetData(baseData); - MITK_TEST_CONDITION(baseData == dataNode->GetData(), "Testing if a ManufacturerLogo object was set correctly") - baseData = mitk::PointSet::New(); dataNode->SetData(baseData); MITK_TEST_CONDITION(baseData == dataNode->GetData(), "Testing if a PointSet object was set correctly") baseData = mitk::Image::New(); dataNode->SetData(baseData); MITK_TEST_CONDITION(baseData == dataNode->GetData(), "Testing if a Image object was set correctly") baseData = mitk::Surface::New(); dataNode->SetData(baseData); MITK_TEST_CONDITION(baseData == dataNode->GetData(), "Testing if a Surface object was set correctly") dataNode->SetData(nullptr); MITK_TEST_CONDITION(nullptr == dataNode->GetData(), "Testing if base data (already set) was replaced by a NULL pointer") } static void TestMapperSetting(mitk::DataNode::Pointer dataNode) { // tests the SetMapper() method // in dataNode is a mapper vector which can be accessed by index // in this test method we use only slot 0 (filled with null) and slot 1 // so we also test the destructor of the mapper classes mitk::Mapper::Pointer mapper; dataNode->SetMapper(0, mapper); MITK_TEST_CONDITION(mapper == dataNode->GetMapper(0), "Testing if a NULL pointer was set correctly") mapper = mitk::PlaneGeometryDataMapper2D::New(); dataNode->SetMapper(1, mapper); MITK_TEST_CONDITION(mapper == dataNode->GetMapper(1), "Testing if a PlaneGeometryDataMapper2D was set correctly") MITK_TEST_CONDITION(dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode") mapper = mitk::ImageVtkMapper2D::New(); dataNode->SetMapper(1, mapper); MITK_TEST_CONDITION(mapper == dataNode->GetMapper(1), "Testing if a ImageVtkMapper2D was set correctly") MITK_TEST_CONDITION(dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode") mapper = mitk::PointSetVtkMapper2D::New(); dataNode->SetMapper(1, mapper); MITK_TEST_CONDITION(mapper == dataNode->GetMapper(1), "Testing if a PointSetVtkMapper2D was set correctly") MITK_TEST_CONDITION(dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode") mapper = mitk::SurfaceVtkMapper2D::New(); dataNode->SetMapper(1, mapper); MITK_TEST_CONDITION(mapper == dataNode->GetMapper(1), "Testing if a SurfaceGLMapper2D was set correctly") MITK_TEST_CONDITION(dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode") mapper = mitk::PlaneGeometryDataVtkMapper3D::New(); dataNode->SetMapper(1, mapper); MITK_TEST_CONDITION(mapper == dataNode->GetMapper(1), "Testing if a PlaneGeometryDataVtkMapper3D was set correctly") MITK_TEST_CONDITION(dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode") mapper = mitk::PointSetVtkMapper3D::New(); dataNode->SetMapper(1, mapper); MITK_TEST_CONDITION(mapper == dataNode->GetMapper(1), "Testing if a PointSetVtkMapper3D was set correctly") MITK_TEST_CONDITION(dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode") mapper = mitk::SurfaceVtkMapper3D::New(); dataNode->SetMapper(1, mapper); MITK_TEST_CONDITION(mapper == dataNode->GetMapper(1), "Testing if a SurfaceVtkMapper3D was set correctly") MITK_TEST_CONDITION(dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode") } static void TestInteractorSetting(mitk::DataNode::Pointer dataNode) { // this method tests the SetInteractor() and GetInteractor methods // the DataInteractor base class calls the DataNode->SetInteractor method mitk::DataInteractor::Pointer interactor; MITK_TEST_CONDITION(interactor == dataNode->GetDataInteractor(), "Testing if a NULL pointer was set correctly (DataInteractor)") interactor = mitk::PointSetDataInteractor::New(); interactor->SetEventConfig("PointSetConfig.xml"); interactor->SetDataNode(dataNode); MITK_TEST_CONDITION(interactor == dataNode->GetDataInteractor(), "Testing if a PointSetDataInteractor was set correctly") interactor = mitk::PointSetDataInteractor::New(); dataNode->SetDataInteractor(interactor); MITK_TEST_CONDITION(interactor == dataNode->GetDataInteractor(), "Testing if a PointSetDataInteractor was set correctly") } static void TestPropertyList(mitk::DataNode::Pointer dataNode) { mitk::PropertyList::Pointer propertyList = dataNode->GetPropertyList(); MITK_TEST_CONDITION(dataNode->GetPropertyList() != NULL, "Testing if the constructor set the propertylist") dataNode->SetIntProperty("int", -31337); int x; dataNode->GetIntProperty("int", x); MITK_TEST_CONDITION(x == -31337, "Testing Set/GetIntProperty"); dataNode->SetBoolProperty("bool", true); bool b; dataNode->GetBoolProperty("bool", b); MITK_TEST_CONDITION(b == true, "Testing Set/GetBoolProperty"); dataNode->SetFloatProperty("float", -31.337); float y; dataNode->GetFloatProperty("float", y); MITK_TEST_CONDITION(y - -31.337 < 0.01, "Testing Set/GetFloatProperty"); double yd = 0; dataNode->GetDoubleProperty("float", yd); MITK_TEST_CONDITION(mitk::Equal(yd, static_cast(y)), "Testing GetDoubleProperty"); double d = sqrt(2.0); dataNode->SetDoubleProperty("double", d); double read_d; MITK_TEST_CONDITION(dataNode->GetDoubleProperty("double", read_d), "Testing GetDoubleProperty"); MITK_TEST_CONDITION(d == read_d, "Testing Set/GetDoubleProperty"); // Equal does not the same thing dataNode->SetStringProperty("string", "MITK"); std::string s = "GANZVIELPLATZ"; dataNode->GetStringProperty("string", s); MITK_TEST_CONDITION(s == "MITK", "Testing Set/GetStringProperty"); std::string name = "MyTestName"; dataNode->SetName(name.c_str()); MITK_TEST_CONDITION(dataNode->GetName() == name, "Testing Set/GetName"); name = "MySecondTestName"; dataNode->SetName(name); MITK_TEST_CONDITION(dataNode->GetName() == name, "Testing Set/GetName(std::string)"); MITK_TEST_CONDITION(propertyList == dataNode->GetPropertyList(), "Testing if the propertylist has changed during the last tests") } static void TestSelected(mitk::DataNode::Pointer dataNode) { vtkRenderWindow *renderWindow = vtkRenderWindow::New(); mitk::VtkPropRenderer::Pointer base = mitk::VtkPropRenderer::New("the first renderer", renderWindow, mitk::RenderingManager::GetInstance()); // with BaseRenderer==Null MITK_TEST_CONDITION(!dataNode->IsSelected(), "Testing if this node is not set as selected") dataNode->SetSelected(true); MITK_TEST_CONDITION(dataNode->IsSelected(), "Testing if this node is set as selected") dataNode->SetSelected(false); dataNode->SetSelected(true, base); MITK_TEST_CONDITION(dataNode->IsSelected(base), "Testing if this node with right base renderer is set as selected") // Delete RenderWindow correctly renderWindow->Delete(); } static void TestGetMTime(mitk::DataNode::Pointer dataNode) { unsigned long time; time = dataNode->GetMTime(); mitk::PointSet::Pointer pointSet = mitk::PointSet::New(); dataNode->SetData(pointSet); MITK_TEST_CONDITION(time != dataNode->GetMTime(), "Testing if the node timestamp is updated after adding data to the node") mitk::Point3D point; point.Fill(3.0); pointSet->SetPoint(0, point); // less or equal because dataNode timestamp is little later then the basedata timestamp MITK_TEST_CONDITION(pointSet->GetMTime() <= dataNode->GetMTime(), "Testing if the node timestamp is updated after base data was modified") // testing if changing anything in the property list also sets the node in a modified state unsigned long lastModified = dataNode->GetMTime(); dataNode->SetIntProperty("testIntProp", 2344); MITK_TEST_CONDITION(lastModified <= dataNode->GetMTime(), "Testing if the node timestamp is updated after property list was modified") } static void TestSetDataUnderPropertyChange(void) { mitk::Image::Pointer image = mitk::Image::New(); mitk::Image::Pointer additionalImage = mitk::Image::New(); mitk::DataNode::Pointer dataNode = mitk::DataNode::New(); image = mitk::ImageGenerator::GenerateRandomImage(3u, 3u); dataNode->SetData(image); const float defaultOutlineWidth = 1.0; float outlineWidth = 0; dataNode->GetPropertyValue("outline width", outlineWidth); MITK_TEST_CONDITION(mitk::Equal(outlineWidth, defaultOutlineWidth), "Testing if the SetData set the default property list") dataNode->SetProperty("outline width", mitk::FloatProperty::New(42.0)); dataNode->SetData(image); dataNode->GetPropertyValue("outline width", outlineWidth); MITK_TEST_CONDITION(mitk::Equal(outlineWidth, 42.0), "Testing if the SetData does not set anything if image data is identical") dataNode->SetData(additionalImage); dataNode->GetPropertyValue("outline width", outlineWidth); MITK_TEST_CONDITION(mitk::Equal(outlineWidth, 42.0), "Testing if the SetData does not set the default property list if image data is already set") mitk::Surface::Pointer surface = mitk::Surface::New(); dataNode->SetData(surface); MITK_TEST_CONDITION(dataNode->GetPropertyValue("outline width", outlineWidth) == false, "Testing if SetData cleared previous property list and set the default property list if data " "of different type has been set") } }; // mitkDataNodeTestClass int mitkDataNodeTest(int /* argc */, char * /*argv*/ []) { // always start with this! MITK_TEST_BEGIN("DataNode") // let's create an object of our class mitk::DataNode::Pointer myDataNode = mitk::DataNode::New(); // first test: did this work? // using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since // it makes no sense to continue without an object. MITK_TEST_CONDITION_REQUIRED(myDataNode.IsNotNull(), "Testing instantiation") // test setData() Method mitkDataNodeTestClass::TestDataSetting(myDataNode); mitkDataNodeTestClass::TestMapperSetting(myDataNode); // // note, that no data is set to the dataNode mitkDataNodeTestClass::TestInteractorSetting(myDataNode); mitkDataNodeTestClass::TestPropertyList(myDataNode); mitkDataNodeTestClass::TestSelected(myDataNode); mitkDataNodeTestClass::TestGetMTime(myDataNode); mitkDataNodeTestClass::TestSetDataUnderPropertyChange(); // write your own tests here and use the macros from mitkTestingMacros.h !!! // do not write to std::cout and do not return from this function yourself! // always end with this! MITK_TEST_END() } diff --git a/Modules/DiffusionImaging/Connectomics/Rendering/mitkConnectomicsNetworkMapper3D.cpp b/Modules/DiffusionImaging/Connectomics/Rendering/mitkConnectomicsNetworkMapper3D.cpp index c1609595e9..4b1dba26ea 100644 --- a/Modules/DiffusionImaging/Connectomics/Rendering/mitkConnectomicsNetworkMapper3D.cpp +++ b/Modules/DiffusionImaging/Connectomics/Rendering/mitkConnectomicsNetworkMapper3D.cpp @@ -1,825 +1,835 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "mitkConnectomicsNetworkMapper3D.h" -#include +#include "vtkGlyph3D.h" +#include "vtkGlyphSource2D.h" #include "vtkGraphLayout.h" -#include #include "vtkGraphToPolyData.h" +#include #include -#include "vtkGlyph3D.h" -#include "vtkGlyphSource2D.h" +#include -#include "mitkConnectomicsRenderingProperties.h" -#include "mitkConnectomicsRenderingSchemeProperty.h" +#include "mitkConnectomicsRenderingEdgeColorParameterProperty.h" #include "mitkConnectomicsRenderingEdgeFilteringProperty.h" -#include "mitkConnectomicsRenderingNodeFilteringProperty.h" +#include "mitkConnectomicsRenderingEdgeRadiusParameterProperty.h" +#include "mitkConnectomicsRenderingEdgeThresholdParameterProperty.h" #include "mitkConnectomicsRenderingNodeColorParameterProperty.h" +#include "mitkConnectomicsRenderingNodeFilteringProperty.h" #include "mitkConnectomicsRenderingNodeRadiusParameterProperty.h" -#include "mitkConnectomicsRenderingEdgeColorParameterProperty.h" -#include "mitkConnectomicsRenderingEdgeRadiusParameterProperty.h" #include "mitkConnectomicsRenderingNodeThresholdParameterProperty.h" -#include "mitkConnectomicsRenderingEdgeThresholdParameterProperty.h" +#include "mitkConnectomicsRenderingProperties.h" +#include "mitkConnectomicsRenderingSchemeProperty.h" #include +#include #include #include #include mitk::ConnectomicsNetworkMapper3D::ConnectomicsNetworkMapper3D() { m_NetworkAssembly = vtkPropAssembly::New(); m_Translator = mitk::FreeSurferParcellationTranslator::New(); } -mitk::ConnectomicsNetworkMapper3D:: ~ConnectomicsNetworkMapper3D() +mitk::ConnectomicsNetworkMapper3D::~ConnectomicsNetworkMapper3D() { m_NetworkAssembly->Delete(); } -void mitk::ConnectomicsNetworkMapper3D::GenerateDataForRenderer(mitk::BaseRenderer* renderer) +void mitk::ConnectomicsNetworkMapper3D::GenerateDataForRenderer(mitk::BaseRenderer *renderer) { - if( this-> GetInput() == nullptr ) + if (this->GetInput() == nullptr) { - renderer-> GetOverlayManager()-> RemoveOverlay( m_TextOverlay3D.GetPointer() ); + m_TextOverlay3D->UnRegisterMicroservice(); return; } - bool propertiesHaveChanged = this-> PropertiesChanged(); + bool propertiesHaveChanged = this->PropertiesChanged(); - if( this-> GetInput()-> GetIsModified() || propertiesHaveChanged ) + if (this->GetInput()->GetIsModified() || propertiesHaveChanged) { - - m_NetworkAssembly-> Delete(); + m_NetworkAssembly->Delete(); m_NetworkAssembly = vtkPropAssembly::New(); // Here is the part where a graph is given and converted to points and connections between points... - std::vector< mitk::ConnectomicsNetwork::NetworkNode > vectorOfNodes = this->GetInput()->GetVectorOfAllNodes(); - std::vector< std::pair< - std::pair< mitk::ConnectomicsNetwork::NetworkNode, mitk::ConnectomicsNetwork::NetworkNode > - , mitk::ConnectomicsNetwork::NetworkEdge > > vectorOfEdges = this->GetInput()->GetVectorOfAllEdges(); + std::vector vectorOfNodes = this->GetInput()->GetVectorOfAllNodes(); + std::vector, + mitk::ConnectomicsNetwork::NetworkEdge>> + vectorOfEdges = this->GetInput()->GetVectorOfAllEdges(); // Decide on the style of rendering due to property - if( m_ChosenRenderingScheme == connectomicsRenderingMITKScheme ) + if (m_ChosenRenderingScheme == connectomicsRenderingMITKScheme) { mitk::Point3D tempWorldPoint, tempCNFGeometryPoint; ////// Prepare BalloonWidgets/Overlays: //////////////////// - if( ( m_ChosenNodeLabel == "" || m_ChosenNodeLabel == "-1" ) && m_TextOverlay3D ) + if ((m_ChosenNodeLabel == "" || m_ChosenNodeLabel == "-1") && m_TextOverlay3D) { - renderer-> GetOverlayManager()-> RemoveOverlay( m_TextOverlay3D.GetPointer() ); - GetDataNode()-> SetProperty( connectomicsRenderingBalloonTextName.c_str(), mitk::StringProperty::New(""), nullptr ); - GetDataNode()-> SetProperty( connectomicsRenderingBalloonNodeStatsName.c_str(), mitk::StringProperty::New(""), nullptr ); + m_TextOverlay3D->UnRegisterMicroservice(); + GetDataNode()->SetProperty( + connectomicsRenderingBalloonTextName.c_str(), mitk::StringProperty::New(""), nullptr); + GetDataNode()->SetProperty( + connectomicsRenderingBalloonNodeStatsName.c_str(), mitk::StringProperty::New(""), nullptr); } //////////////////////Prepare coloring and radius//////////// - std::vector< double > vectorOfNodeRadiusParameterValues; - vectorOfNodeRadiusParameterValues.resize( vectorOfNodes.size() ); - double maxNodeRadiusParameterValue( FillNodeParameterVector( &vectorOfNodeRadiusParameterValues, m_NodeRadiusParameter ) ); - - std::vector< double > vectorOfNodeColorParameterValues; - vectorOfNodeColorParameterValues.resize( vectorOfNodes.size() ); - double maxNodeColorParameterValue( FillNodeParameterVector( &vectorOfNodeColorParameterValues, m_NodeColorParameter ) ); - - std::vector< double > vectorOfEdgeRadiusParameterValues; - vectorOfEdgeRadiusParameterValues.resize( vectorOfEdges.size() ); - double maxEdgeRadiusParameterValue( FillEdgeParameterVector( &vectorOfEdgeRadiusParameterValues, m_EdgeRadiusParameter ) ); - - std::vector< double > vectorOfEdgeColorParameterValues; - vectorOfEdgeColorParameterValues.resize( vectorOfEdges.size() ); - double maxEdgeColorParameterValue( FillEdgeParameterVector( &vectorOfEdgeColorParameterValues, m_EdgeColorParameter ) ); + std::vector vectorOfNodeRadiusParameterValues; + vectorOfNodeRadiusParameterValues.resize(vectorOfNodes.size()); + double maxNodeRadiusParameterValue( + FillNodeParameterVector(&vectorOfNodeRadiusParameterValues, m_NodeRadiusParameter)); + + std::vector vectorOfNodeColorParameterValues; + vectorOfNodeColorParameterValues.resize(vectorOfNodes.size()); + double maxNodeColorParameterValue( + FillNodeParameterVector(&vectorOfNodeColorParameterValues, m_NodeColorParameter)); + + std::vector vectorOfEdgeRadiusParameterValues; + vectorOfEdgeRadiusParameterValues.resize(vectorOfEdges.size()); + double maxEdgeRadiusParameterValue( + FillEdgeParameterVector(&vectorOfEdgeRadiusParameterValues, m_EdgeRadiusParameter)); + + std::vector vectorOfEdgeColorParameterValues; + vectorOfEdgeColorParameterValues.resize(vectorOfEdges.size()); + double maxEdgeColorParameterValue( + FillEdgeParameterVector(&vectorOfEdgeColorParameterValues, m_EdgeColorParameter)); //////////////////////Prepare Filtering////////////////////// // true will be rendered - std::vector< bool > vectorOfNodeFilterBools( vectorOfNodes.size(), true ); - if( m_ChosenNodeFilter == connectomicsRenderingNodeThresholdingFilter ) + std::vector vectorOfNodeFilterBools(vectorOfNodes.size(), true); + if (m_ChosenNodeFilter == connectomicsRenderingNodeThresholdingFilter) { - FillNodeFilterBoolVector( &vectorOfNodeFilterBools, m_NodeThresholdParameter ); + FillNodeFilterBoolVector(&vectorOfNodeFilterBools, m_NodeThresholdParameter); } - std::vector< bool > vectorOfEdgeFilterBools( vectorOfEdges.size(), true ); - if( m_ChosenEdgeFilter == connectomicsRenderingEdgeThresholdFilter ) + std::vector vectorOfEdgeFilterBools(vectorOfEdges.size(), true); + if (m_ChosenEdgeFilter == connectomicsRenderingEdgeThresholdFilter) { - FillEdgeFilterBoolVector( &vectorOfEdgeFilterBools, m_EdgeThresholdParameter ); + FillEdgeFilterBoolVector(&vectorOfEdgeFilterBools, m_EdgeThresholdParameter); } - //////////////////////Create Spheres///////////////////////// - std::stringstream nodeLabelStream; //local stream variable to hold csv list of node label names and node label numbers. + std::stringstream + nodeLabelStream; // local stream variable to hold csv list of node label names and node label numbers. - for(unsigned int i = 0; i < vectorOfNodes.size(); i++) + for (unsigned int i = 0; i < vectorOfNodes.size(); i++) { - vtkSmartPointer sphereSource = - vtkSmartPointer::New(); + vtkSmartPointer sphereSource = vtkSmartPointer::New(); - for(unsigned int dimension = 0; dimension < 3; dimension++) + for (unsigned int dimension = 0; dimension < 3; dimension++) { - tempCNFGeometryPoint.SetElement( dimension , vectorOfNodes[i].coordinates[dimension] ); + tempCNFGeometryPoint.SetElement(dimension, vectorOfNodes[i].coordinates[dimension]); } - GetDataNode()->GetData()->GetGeometry()->IndexToWorld( tempCNFGeometryPoint, tempWorldPoint ); + GetDataNode()->GetData()->GetGeometry()->IndexToWorld(tempCNFGeometryPoint, tempWorldPoint); - sphereSource->SetCenter( tempWorldPoint[0] , tempWorldPoint[1], tempWorldPoint[2] ); + sphereSource->SetCenter(tempWorldPoint[0], tempWorldPoint[1], tempWorldPoint[2]); // determine radius double radiusFactor = vectorOfNodeRadiusParameterValues[i] / maxNodeRadiusParameterValue; - double radius = m_NodeRadiusStart + ( m_NodeRadiusEnd - m_NodeRadiusStart) * radiusFactor; - sphereSource->SetRadius( radius ); + double radius = m_NodeRadiusStart + (m_NodeRadiusEnd - m_NodeRadiusStart) * radiusFactor; + sphereSource->SetRadius(radius); - vtkSmartPointer mapper = - vtkSmartPointer::New(); + vtkSmartPointer mapper = vtkSmartPointer::New(); mapper->SetInputConnection(sphereSource->GetOutputPort()); - vtkSmartPointer actor = - vtkSmartPointer::New(); + vtkSmartPointer actor = vtkSmartPointer::New(); actor->SetMapper(mapper); // determine color double colorFactor = vectorOfNodeColorParameterValues[i] / maxNodeColorParameterValue; - double redStart = m_NodeColorStart.GetElement( 0 ); - double greenStart = m_NodeColorStart.GetElement( 1 ); - double blueStart = m_NodeColorStart.GetElement( 2 ); - double redEnd = m_NodeColorEnd.GetElement( 0 ); - double greenEnd = m_NodeColorEnd.GetElement( 1 ); - double blueEnd = m_NodeColorEnd.GetElement( 2 ); + double redStart = m_NodeColorStart.GetElement(0); + double greenStart = m_NodeColorStart.GetElement(1); + double blueStart = m_NodeColorStart.GetElement(2); + double redEnd = m_NodeColorEnd.GetElement(0); + double greenEnd = m_NodeColorEnd.GetElement(1); + double blueEnd = m_NodeColorEnd.GetElement(2); - double red = redStart + ( redEnd - redStart ) * colorFactor; - double green = greenStart + ( greenEnd - greenStart ) * colorFactor; - double blue = blueStart + ( blueEnd - blueStart ) * colorFactor; + double red = redStart + (redEnd - redStart) * colorFactor; + double green = greenStart + (greenEnd - greenStart) * colorFactor; + double blue = blueStart + (blueEnd - blueStart) * colorFactor; - actor->GetProperty()->SetColor( red, green, blue); + actor->GetProperty()->SetColor(red, green, blue); - //append to csv list of nodelabels. - nodeLabelStream << m_Translator-> GetName( std::stoi( vectorOfNodes[i].label ) ) - << ": " << vectorOfNodes[i].label << ","; + // append to csv list of nodelabels. + nodeLabelStream << m_Translator->GetName(std::stoi(vectorOfNodes[i].label)) << ": " << vectorOfNodes[i].label + << ","; - if( vectorOfNodeFilterBools[i] ) + if (vectorOfNodeFilterBools[i]) { - if( vectorOfNodes[i].label == m_ChosenNodeLabel ) + if (vectorOfNodes[i].label == m_ChosenNodeLabel) { // if chosen and enabled, show information in Balloon or TextOverlay: // What to show: std::stringstream balloonStringstream; - balloonStringstream << "Node id: " << vectorOfNodes[i].id - << "\nlabel: " << vectorOfNodes[i].label - << "\nname: " - << m_Translator-> GetName( std::stoi( vectorOfNodes[i].label ) ) - << std::endl; + balloonStringstream << "Node id: " << vectorOfNodes[i].id << "\nlabel: " << vectorOfNodes[i].label + << "\nname: " << m_Translator->GetName(std::stoi(vectorOfNodes[i].label)) << std::endl; m_BalloonText = balloonStringstream.str(); - GetDataNode()-> - SetProperty( connectomicsRenderingBalloonTextName.c_str(), - mitk::StringProperty::New( m_BalloonText.c_str()), nullptr ); + GetDataNode()->SetProperty( + connectomicsRenderingBalloonTextName.c_str(), mitk::StringProperty::New(m_BalloonText.c_str()), nullptr); std::stringstream balloonNodeStatsStream; - balloonNodeStatsStream - << "Coordinates: (" << vectorOfNodes[i].coordinates[0] - << " ; " << vectorOfNodes[i].coordinates[1] - << " ; " << vectorOfNodes[i].coordinates[2] << " )" - << "\nDegree: " - << ( this-> GetInput()-> GetDegreeOfNodes() ).at( vectorOfNodes[i].id ) - << "\nBetweenness centrality: " - << ( this->GetInput()->GetNodeBetweennessVector() ).at( vectorOfNodes[i].id ) - << "\nClustering coefficient: " - << ( this->GetInput()->GetLocalClusteringCoefficients()).at( vectorOfNodes[i].id ) - << std::endl; + balloonNodeStatsStream << "Coordinates: (" << vectorOfNodes[i].coordinates[0] << " ; " + << vectorOfNodes[i].coordinates[1] << " ; " << vectorOfNodes[i].coordinates[2] + << " )" + << "\nDegree: " << (this->GetInput()->GetDegreeOfNodes()).at(vectorOfNodes[i].id) + << "\nBetweenness centrality: " + << (this->GetInput()->GetNodeBetweennessVector()).at(vectorOfNodes[i].id) + << "\nClustering coefficient: " + << (this->GetInput()->GetLocalClusteringCoefficients()).at(vectorOfNodes[i].id) + << std::endl; m_BalloonNodeStats = balloonNodeStatsStream.str(); - GetDataNode()-> - SetProperty( connectomicsRenderingBalloonNodeStatsName.c_str(), - mitk::StringProperty::New( m_BalloonNodeStats.c_str()), nullptr ); + GetDataNode()->SetProperty(connectomicsRenderingBalloonNodeStatsName.c_str(), + mitk::StringProperty::New(m_BalloonNodeStats.c_str()), + nullptr); // Where to show: float r[3]; - r[0]= vectorOfNodes[i].coordinates[0]; - r[1]= vectorOfNodes[i].coordinates[1]; - r[2]= vectorOfNodes[i].coordinates[2]; - mitk::Point3D BalloonAnchor( r ); - mitk::Point3D BalloonAnchorWorldCoord( r ); - GetDataNode()-> GetData()-> GetGeometry()-> IndexToWorld( BalloonAnchor, BalloonAnchorWorldCoord ); + r[0] = vectorOfNodes[i].coordinates[0]; + r[1] = vectorOfNodes[i].coordinates[1]; + r[2] = vectorOfNodes[i].coordinates[2]; + mitk::Point3D BalloonAnchor(r); + mitk::Point3D BalloonAnchorWorldCoord(r); + GetDataNode()->GetData()->GetGeometry()->IndexToWorld(BalloonAnchor, BalloonAnchorWorldCoord); // How to show: - if( m_ChosenNodeLabel != "-1" ) + if (m_ChosenNodeLabel != "-1") { if (m_TextOverlay3D != nullptr) { - renderer-> GetOverlayManager()-> RemoveOverlay( m_TextOverlay3D.GetPointer() ); + m_TextOverlay3D->UnRegisterMicroservice(); } - m_TextOverlay3D = mitk::TextOverlay3D::New(); - renderer-> GetOverlayManager()-> AddOverlay( m_TextOverlay3D.GetPointer() ); - m_TextOverlay3D-> SetFontSize( 2 ); - m_TextOverlay3D-> SetColor( 0.96, 0.69, 0.01 ); - m_TextOverlay3D-> SetOpacity( 0.81 ); - m_TextOverlay3D-> SetPosition3D( BalloonAnchorWorldCoord ); - m_TextOverlay3D-> SetText( "...." + m_BalloonText ); - m_TextOverlay3D-> SetForceInForeground( true ); // TODO: does not work anymore. - m_TextOverlay3D-> SetVisibility( GetDataNode()-> IsVisible( renderer ) ); - renderer-> GetOverlayManager()-> UpdateOverlays( renderer ); + m_TextOverlay3D = mitk::TextAnnotation3D::New(); + + mitk::ManualPlacementAnnotationRenderer::AddAnnotation(m_TextOverlay3D.GetPointer(), renderer); + m_TextOverlay3D->SetFontSize(2); + m_TextOverlay3D->SetColor(0.96, 0.69, 0.01); + m_TextOverlay3D->SetOpacity(0.81); + m_TextOverlay3D->SetPosition3D(BalloonAnchorWorldCoord); + m_TextOverlay3D->SetText("...." + m_BalloonText); + m_TextOverlay3D->SetForceInForeground(true); // TODO: does not work anymore. + m_TextOverlay3D->SetVisibility(GetDataNode()->IsVisible(renderer)); // Colorize chosen node: - actor-> GetProperty()-> SetColor( 1.0, 0.69, 0.01); + actor->GetProperty()->SetColor(1.0, 0.69, 0.01); } } - m_NetworkAssembly-> AddPart( actor ); + m_NetworkAssembly->AddPart(actor); } } - m_AllNodeLabels = nodeLabelStream.str(); // Store all Node Names and Node Labels in 1 Property. - m_AllNodeLabels.erase( m_AllNodeLabels.rfind(","), 1 ); // remove trailing ,. - GetDataNode()-> - SetProperty( connectomicsRenderingBalloonAllNodeLabelsName.c_str(), - mitk::StringProperty::New( m_AllNodeLabels.c_str() ), nullptr ); - + m_AllNodeLabels = nodeLabelStream.str(); // Store all Node Names and Node Labels in 1 Property. + m_AllNodeLabels.erase(m_AllNodeLabels.rfind(","), 1); // remove trailing ,. + GetDataNode()->SetProperty(connectomicsRenderingBalloonAllNodeLabelsName.c_str(), + mitk::StringProperty::New(m_AllNodeLabels.c_str()), + nullptr); //////////////////////Create Tubes///////////////////////// - for(unsigned int i = 0; i < vectorOfEdges.size(); i++) - { - - vtkSmartPointer lineSource = - vtkSmartPointer::New(); + for (unsigned int i = 0; i < vectorOfEdges.size(); i++) + { + vtkSmartPointer lineSource = vtkSmartPointer::New(); - for(unsigned int dimension = 0; dimension < 3; dimension++) - { - tempCNFGeometryPoint[ dimension ] = vectorOfEdges[i].first.first.coordinates[dimension]; - } + for (unsigned int dimension = 0; dimension < 3; dimension++) + { + tempCNFGeometryPoint[dimension] = vectorOfEdges[i].first.first.coordinates[dimension]; + } - GetDataNode()->GetData()->GetGeometry()->IndexToWorld( tempCNFGeometryPoint, tempWorldPoint ); + GetDataNode()->GetData()->GetGeometry()->IndexToWorld(tempCNFGeometryPoint, tempWorldPoint); - lineSource->SetPoint1(tempWorldPoint[0], tempWorldPoint[1],tempWorldPoint[2] ); + lineSource->SetPoint1(tempWorldPoint[0], tempWorldPoint[1], tempWorldPoint[2]); - for(unsigned int dimension = 0; dimension < 3; dimension++) - { - tempCNFGeometryPoint[ dimension ] = vectorOfEdges[i].first.second.coordinates[dimension]; - } + for (unsigned int dimension = 0; dimension < 3; dimension++) + { + tempCNFGeometryPoint[dimension] = vectorOfEdges[i].first.second.coordinates[dimension]; + } - GetDataNode()->GetData()->GetGeometry()->IndexToWorld( tempCNFGeometryPoint, tempWorldPoint ); + GetDataNode()->GetData()->GetGeometry()->IndexToWorld(tempCNFGeometryPoint, tempWorldPoint); - lineSource->SetPoint2(tempWorldPoint[0], tempWorldPoint[1], tempWorldPoint[2] ); + lineSource->SetPoint2(tempWorldPoint[0], tempWorldPoint[1], tempWorldPoint[2]); vtkSmartPointer tubes = vtkSmartPointer::New(); - tubes->SetInputConnection( lineSource->GetOutputPort() ); - tubes->SetNumberOfSides( 12 ); + tubes->SetInputConnection(lineSource->GetOutputPort()); + tubes->SetNumberOfSides(12); // determine radius double radiusFactor = vectorOfEdgeRadiusParameterValues[i] / maxEdgeRadiusParameterValue; - double radius = m_EdgeRadiusStart + ( m_EdgeRadiusEnd - m_EdgeRadiusStart) * radiusFactor; - tubes->SetRadius( radius ); + double radius = m_EdgeRadiusStart + (m_EdgeRadiusEnd - m_EdgeRadiusStart) * radiusFactor; + tubes->SetRadius(radius); // originally we used a logarithmic scaling, // double radiusFactor = 1.0 + ((double) vectorOfEdges[i].second.weight) / 10.0 ; // tubes->SetRadius( std::log10( radiusFactor ) ); - vtkSmartPointer mapper2 = - vtkSmartPointer::New(); - mapper2->SetInputConnection( tubes->GetOutputPort() ); + vtkSmartPointer mapper2 = vtkSmartPointer::New(); + mapper2->SetInputConnection(tubes->GetOutputPort()); - vtkSmartPointer actor = - vtkSmartPointer::New(); + vtkSmartPointer actor = vtkSmartPointer::New(); actor->SetMapper(mapper2); // determine color double colorFactor = vectorOfEdgeColorParameterValues[i] / maxEdgeColorParameterValue; - double redStart = m_EdgeColorStart.GetElement( 0 ); - double greenStart = m_EdgeColorStart.GetElement( 1 ); - double blueStart = m_EdgeColorStart.GetElement( 2 ); - double redEnd = m_EdgeColorEnd.GetElement( 0 ); - double greenEnd = m_EdgeColorEnd.GetElement( 1 ); - double blueEnd = m_EdgeColorEnd.GetElement( 2 ); + double redStart = m_EdgeColorStart.GetElement(0); + double greenStart = m_EdgeColorStart.GetElement(1); + double blueStart = m_EdgeColorStart.GetElement(2); + double redEnd = m_EdgeColorEnd.GetElement(0); + double greenEnd = m_EdgeColorEnd.GetElement(1); + double blueEnd = m_EdgeColorEnd.GetElement(2); - double red = redStart + ( redEnd - redStart ) * colorFactor; - double green = greenStart + ( greenEnd - greenStart ) * colorFactor; - double blue = blueStart + ( blueEnd - blueStart ) * colorFactor; + double red = redStart + (redEnd - redStart) * colorFactor; + double green = greenStart + (greenEnd - greenStart) * colorFactor; + double blue = blueStart + (blueEnd - blueStart) * colorFactor; - actor->GetProperty()->SetColor( red, green, blue); + actor->GetProperty()->SetColor(red, green, blue); - if( vectorOfEdgeFilterBools[i] ) - { + if (vectorOfEdgeFilterBools[i]) + { m_NetworkAssembly->AddPart(actor); - } } } - else if( m_ChosenRenderingScheme == connectomicsRenderingVTKScheme ) - { - vtkSmartPointer graph = - vtkSmartPointer::New(); + } + else if (m_ChosenRenderingScheme == connectomicsRenderingVTKScheme) + { + vtkSmartPointer graph = vtkSmartPointer::New(); - std::vector< vtkIdType > networkToVTKvector; + std::vector networkToVTKvector; networkToVTKvector.resize(vectorOfNodes.size()); - for(unsigned int i = 0; i < vectorOfNodes.size(); i++) - { + for (unsigned int i = 0; i < vectorOfNodes.size(); i++) + { networkToVTKvector[vectorOfNodes[i].id] = graph->AddVertex(); - } + } - for(unsigned int i = 0; i < vectorOfEdges.size(); i++) - { + for (unsigned int i = 0; i < vectorOfEdges.size(); i++) + { graph->AddEdge(networkToVTKvector[vectorOfEdges[i].first.first.id], - networkToVTKvector[vectorOfEdges[i].first.second.id]); - } + networkToVTKvector[vectorOfEdges[i].first.second.id]); + } - vtkSmartPointer points = - vtkSmartPointer::New(); - for(unsigned int i = 0; i < vectorOfNodes.size(); i++) - { + vtkSmartPointer points = vtkSmartPointer::New(); + for (unsigned int i = 0; i < vectorOfNodes.size(); i++) + { double x = vectorOfNodes[i].coordinates[0]; double y = vectorOfNodes[i].coordinates[1]; double z = vectorOfNodes[i].coordinates[2]; - points->InsertNextPoint( x, y, z); - } + points->InsertNextPoint(x, y, z); + } graph->SetPoints(points); - vtkGraphLayout* layout = vtkGraphLayout::New(); + vtkGraphLayout *layout = vtkGraphLayout::New(); layout->SetInputData(graph); - vtkPassThroughLayoutStrategy* ptls = vtkPassThroughLayoutStrategy::New(); - layout->SetLayoutStrategy( ptls ); + vtkPassThroughLayoutStrategy *ptls = vtkPassThroughLayoutStrategy::New(); + layout->SetLayoutStrategy(ptls); - vtkGraphToPolyData* graphToPoly = vtkGraphToPolyData::New(); + vtkGraphToPolyData *graphToPoly = vtkGraphToPolyData::New(); graphToPoly->SetInputConnection(layout->GetOutputPort()); // Create the standard VTK polydata mapper and actor // for the connections (edges) in the tree. - vtkPolyDataMapper* edgeMapper = vtkPolyDataMapper::New(); + vtkPolyDataMapper *edgeMapper = vtkPolyDataMapper::New(); edgeMapper->SetInputConnection(graphToPoly->GetOutputPort()); - vtkActor* edgeActor = vtkActor::New(); + vtkActor *edgeActor = vtkActor::New(); edgeActor->SetMapper(edgeMapper); edgeActor->GetProperty()->SetColor(0.0, 0.5, 1.0); // Glyph the points of the tree polydata to create // VTK_VERTEX cells at each vertex in the tree. - vtkGlyph3D* vertGlyph = vtkGlyph3D::New(); + vtkGlyph3D *vertGlyph = vtkGlyph3D::New(); vertGlyph->SetInputConnection(0, graphToPoly->GetOutputPort()); - vtkGlyphSource2D* glyphSource = vtkGlyphSource2D::New(); + vtkGlyphSource2D *glyphSource = vtkGlyphSource2D::New(); glyphSource->SetGlyphTypeToVertex(); vertGlyph->SetInputConnection(1, glyphSource->GetOutputPort()); // Create a mapper for the vertices, and tell the mapper // to use the specified color array. - vtkPolyDataMapper* vertMapper = vtkPolyDataMapper::New(); + vtkPolyDataMapper *vertMapper = vtkPolyDataMapper::New(); vertMapper->SetInputConnection(vertGlyph->GetOutputPort()); /*if (colorArray) { vertMapper->SetScalarModeToUsePointFieldData(); vertMapper->SelectColorArray(colorArray); vertMapper->SetScalarRange(colorRange); }*/ // Create an actor for the vertices. Move the actor forward // in the z direction so it is drawn on top of the edge actor. - vtkActor* vertActor = vtkActor::New(); + vtkActor *vertActor = vtkActor::New(); vertActor->SetMapper(vertMapper); vertActor->GetProperty()->SetPointSize(5); vertActor->SetPosition(0, 0, 0.001); - //vtkProp3D.h: virtual void SetPosition(double,double,double): - //Set/Get/Add the position of the Prop3D in world coordinates. + // vtkProp3D.h: virtual void SetPosition(double,double,double): + // Set/Get/Add the position of the Prop3D in world coordinates. m_NetworkAssembly->AddPart(edgeActor); m_NetworkAssembly->AddPart(vertActor); - } - - (static_cast ( GetDataNode()->GetData() ) )-> SetIsModified( false ); } + + (static_cast(GetDataNode()->GetData()))->SetIsModified(false); + } } -const mitk::ConnectomicsNetwork* mitk::ConnectomicsNetworkMapper3D::GetInput() +const mitk::ConnectomicsNetwork *mitk::ConnectomicsNetworkMapper3D::GetInput() { - return static_cast ( GetDataNode()->GetData() ); + return static_cast(GetDataNode()->GetData()); } -void mitk::ConnectomicsNetworkMapper3D::SetDefaultProperties(DataNode* node, BaseRenderer* renderer , bool overwrite) +void mitk::ConnectomicsNetworkMapper3D::SetDefaultProperties(DataNode *node, BaseRenderer *renderer, bool overwrite) { // Initialize enumeration properties mitk::ConnectomicsRenderingSchemeProperty::Pointer connectomicsRenderingScheme = mitk::ConnectomicsRenderingSchemeProperty::New(); mitk::ConnectomicsRenderingEdgeFilteringProperty::Pointer connectomicsRenderingEdgeFiltering = mitk::ConnectomicsRenderingEdgeFilteringProperty::New(); mitk::ConnectomicsRenderingNodeFilteringProperty::Pointer connectomicsRenderingNodeFiltering = - mitk::ConnectomicsRenderingNodeFilteringProperty::New(); + mitk::ConnectomicsRenderingNodeFilteringProperty::New(); - mitk::ConnectomicsRenderingNodeColorParameterProperty::Pointer connectomicsRenderingNodeGradientColorParameter = + mitk::ConnectomicsRenderingNodeColorParameterProperty::Pointer connectomicsRenderingNodeGradientColorParameter = mitk::ConnectomicsRenderingNodeColorParameterProperty::New(); mitk::ConnectomicsRenderingNodeRadiusParameterProperty::Pointer connectomicsRenderingNodeRadiusParameter = mitk::ConnectomicsRenderingNodeRadiusParameterProperty::New(); mitk::ConnectomicsRenderingEdgeColorParameterProperty::Pointer connectomicsRenderingEdgeGradientColorParameter = mitk::ConnectomicsRenderingEdgeColorParameterProperty::New(); mitk::ConnectomicsRenderingEdgeRadiusParameterProperty::Pointer connectomicsRenderingEdgeRadiusParameter = mitk::ConnectomicsRenderingEdgeRadiusParameterProperty::New(); mitk::ConnectomicsRenderingNodeThresholdParameterProperty::Pointer connectomicsRenderingNodeThresholdParameter = mitk::ConnectomicsRenderingNodeThresholdParameterProperty::New(); mitk::ConnectomicsRenderingEdgeThresholdParameterProperty::Pointer connectomicsRenderingEdgeThresholdParameter = mitk::ConnectomicsRenderingEdgeThresholdParameterProperty::New(); mitk::StringProperty::Pointer balloonText = mitk::StringProperty::New(); // set the properties - node->AddProperty( connectomicsRenderingSchemePropertyName.c_str(), - connectomicsRenderingScheme, renderer, overwrite ); - - node->AddProperty( connectomicsRenderingEdgeFilteringPropertyName.c_str(), - connectomicsRenderingEdgeFiltering, renderer, overwrite ); - node->AddProperty( connectomicsRenderingEdgeThresholdFilterParameterName.c_str(), - connectomicsRenderingEdgeThresholdParameter, renderer, overwrite ); - node->AddProperty( connectomicsRenderingEdgeThresholdFilterThresholdName.c_str(), - connectomicsRenderingEdgeThresholdFilterThresholdDefault, renderer, overwrite ); - - node->AddProperty( connectomicsRenderingNodeFilteringPropertyName.c_str(), - connectomicsRenderingNodeFiltering, renderer, overwrite ); - node->AddProperty( connectomicsRenderingNodeThresholdFilterParameterName.c_str(), - connectomicsRenderingNodeThresholdParameter, renderer, overwrite ); - node->AddProperty( connectomicsRenderingNodeThresholdFilterThresholdName.c_str(), - connectomicsRenderingNodeThresholdFilterThresholdDefault, renderer, overwrite ); - - node->AddProperty( connectomicsRenderingNodeGradientStartColorName.c_str(), - connectomicsRenderingNodeGradientStartColorDefault, renderer, overwrite ); - node->AddProperty( connectomicsRenderingNodeGradientEndColorName.c_str(), - connectomicsRenderingNodeGradientEndColorDefault, renderer, overwrite ); - node->AddProperty( connectomicsRenderingNodeGradientColorParameterName.c_str(), - connectomicsRenderingNodeGradientColorParameter, renderer, overwrite ); - - node->AddProperty( connectomicsRenderingNodeRadiusStartName.c_str(), - connectomicsRenderingNodeRadiusStartDefault, renderer, overwrite ); - node->AddProperty( connectomicsRenderingNodeRadiusEndName.c_str(), - connectomicsRenderingNodeRadiusEndDefault, renderer, overwrite ); - node->AddProperty( connectomicsRenderingNodeRadiusParameterName.c_str(), - connectomicsRenderingNodeRadiusParameter, renderer, overwrite ); - - node->AddProperty( connectomicsRenderingNodeChosenNodeName.c_str(), - connectomicsRenderingNodeChosenNodeDefault, renderer, overwrite ); - - node->AddProperty( connectomicsRenderingEdgeGradientStartColorName.c_str(), - connectomicsRenderingEdgeGradientStartColorDefault, renderer, overwrite ); - node->AddProperty( connectomicsRenderingEdgeGradientEndColorName.c_str(), - connectomicsRenderingEdgeGradientEndColorDefault, renderer, overwrite ); - node->AddProperty( connectomicsRenderingEdgeGradientColorParameterName.c_str(), - connectomicsRenderingEdgeGradientColorParameter, renderer, overwrite ); - - node->AddProperty( connectomicsRenderingEdgeRadiusStartName.c_str(), - connectomicsRenderingEdgeRadiusStartDefault, renderer, overwrite ); - node->AddProperty( connectomicsRenderingEdgeRadiusEndName.c_str(), - connectomicsRenderingEdgeRadiusEndDefault, renderer, overwrite ); - node->AddProperty( connectomicsRenderingEdgeRadiusParameterName.c_str(), - connectomicsRenderingEdgeRadiusParameter, renderer, overwrite ); - - node-> AddProperty( connectomicsRenderingBalloonTextName.c_str(), balloonText, - nullptr, overwrite ); // renderer=nullptr: Property is renderer independent. + node->AddProperty(connectomicsRenderingSchemePropertyName.c_str(), connectomicsRenderingScheme, renderer, overwrite); + + node->AddProperty( + connectomicsRenderingEdgeFilteringPropertyName.c_str(), connectomicsRenderingEdgeFiltering, renderer, overwrite); + node->AddProperty(connectomicsRenderingEdgeThresholdFilterParameterName.c_str(), + connectomicsRenderingEdgeThresholdParameter, + renderer, + overwrite); + node->AddProperty(connectomicsRenderingEdgeThresholdFilterThresholdName.c_str(), + connectomicsRenderingEdgeThresholdFilterThresholdDefault, + renderer, + overwrite); + + node->AddProperty( + connectomicsRenderingNodeFilteringPropertyName.c_str(), connectomicsRenderingNodeFiltering, renderer, overwrite); + node->AddProperty(connectomicsRenderingNodeThresholdFilterParameterName.c_str(), + connectomicsRenderingNodeThresholdParameter, + renderer, + overwrite); + node->AddProperty(connectomicsRenderingNodeThresholdFilterThresholdName.c_str(), + connectomicsRenderingNodeThresholdFilterThresholdDefault, + renderer, + overwrite); + + node->AddProperty(connectomicsRenderingNodeGradientStartColorName.c_str(), + connectomicsRenderingNodeGradientStartColorDefault, + renderer, + overwrite); + node->AddProperty(connectomicsRenderingNodeGradientEndColorName.c_str(), + connectomicsRenderingNodeGradientEndColorDefault, + renderer, + overwrite); + node->AddProperty(connectomicsRenderingNodeGradientColorParameterName.c_str(), + connectomicsRenderingNodeGradientColorParameter, + renderer, + overwrite); + + node->AddProperty( + connectomicsRenderingNodeRadiusStartName.c_str(), connectomicsRenderingNodeRadiusStartDefault, renderer, overwrite); + node->AddProperty( + connectomicsRenderingNodeRadiusEndName.c_str(), connectomicsRenderingNodeRadiusEndDefault, renderer, overwrite); + node->AddProperty(connectomicsRenderingNodeRadiusParameterName.c_str(), + connectomicsRenderingNodeRadiusParameter, + renderer, + overwrite); + + node->AddProperty( + connectomicsRenderingNodeChosenNodeName.c_str(), connectomicsRenderingNodeChosenNodeDefault, renderer, overwrite); + + node->AddProperty(connectomicsRenderingEdgeGradientStartColorName.c_str(), + connectomicsRenderingEdgeGradientStartColorDefault, + renderer, + overwrite); + node->AddProperty(connectomicsRenderingEdgeGradientEndColorName.c_str(), + connectomicsRenderingEdgeGradientEndColorDefault, + renderer, + overwrite); + node->AddProperty(connectomicsRenderingEdgeGradientColorParameterName.c_str(), + connectomicsRenderingEdgeGradientColorParameter, + renderer, + overwrite); + + node->AddProperty( + connectomicsRenderingEdgeRadiusStartName.c_str(), connectomicsRenderingEdgeRadiusStartDefault, renderer, overwrite); + node->AddProperty( + connectomicsRenderingEdgeRadiusEndName.c_str(), connectomicsRenderingEdgeRadiusEndDefault, renderer, overwrite); + node->AddProperty(connectomicsRenderingEdgeRadiusParameterName.c_str(), + connectomicsRenderingEdgeRadiusParameter, + renderer, + overwrite); + + node->AddProperty(connectomicsRenderingBalloonTextName.c_str(), + balloonText, + nullptr, + overwrite); // renderer=nullptr: Property is renderer independent. Superclass::SetDefaultProperties(node, renderer, overwrite); } -void mitk::ConnectomicsNetworkMapper3D::SetVtkMapperImmediateModeRendering(vtkMapper* mapper) +void mitk::ConnectomicsNetworkMapper3D::SetVtkMapperImmediateModeRendering(vtkMapper *mapper) { - mapper-> ImmediateModeRenderingOn(); + mapper->ImmediateModeRenderingOn(); } void mitk::ConnectomicsNetworkMapper3D::UpdateVtkObjects() { - //TODO: implement + // TODO: implement } -vtkProp* mitk::ConnectomicsNetworkMapper3D::GetVtkProp(mitk::BaseRenderer* /*renderer*/) +vtkProp *mitk::ConnectomicsNetworkMapper3D::GetVtkProp(mitk::BaseRenderer * /*renderer*/) { return m_NetworkAssembly; } bool mitk::ConnectomicsNetworkMapper3D::PropertiesChanged() { - mitk::ConnectomicsRenderingSchemeProperty * renderingScheme = - static_cast< mitk::ConnectomicsRenderingSchemeProperty * > ( - this->GetDataNode()->GetProperty( connectomicsRenderingSchemePropertyName.c_str() ) ); - mitk::ConnectomicsRenderingEdgeFilteringProperty * edgeFilter = - static_cast< mitk::ConnectomicsRenderingEdgeFilteringProperty * > ( - this->GetDataNode()->GetProperty( connectomicsRenderingEdgeFilteringPropertyName.c_str() ) ); - mitk::FloatProperty * edgeThreshold = static_cast< mitk::FloatProperty * > ( - this->GetDataNode()->GetProperty( connectomicsRenderingEdgeThresholdFilterThresholdName.c_str() ) ); - mitk::ConnectomicsRenderingNodeFilteringProperty * nodeFilter = - static_cast< mitk::ConnectomicsRenderingNodeFilteringProperty * > ( - this->GetDataNode()->GetProperty( connectomicsRenderingNodeFilteringPropertyName.c_str() ) ); - - mitk::ConnectomicsRenderingNodeThresholdParameterProperty * nodeThresholdParameter = - static_cast< mitk::ConnectomicsRenderingNodeThresholdParameterProperty * > ( - this->GetDataNode()->GetProperty( connectomicsRenderingNodeThresholdFilterParameterName.c_str() ) ); - mitk::ConnectomicsRenderingEdgeThresholdParameterProperty * edgeThresholdParameter = - static_cast< mitk::ConnectomicsRenderingEdgeThresholdParameterProperty * > ( - this->GetDataNode()->GetProperty( connectomicsRenderingEdgeThresholdFilterParameterName.c_str() ) ); - - mitk::FloatProperty * nodeThreshold = static_cast< mitk::FloatProperty * > ( - this->GetDataNode()->GetProperty( connectomicsRenderingNodeThresholdFilterThresholdName.c_str() ) ); - mitk::ColorProperty * nodeColorStart = static_cast< mitk::ColorProperty * > ( - this->GetDataNode()->GetProperty( connectomicsRenderingNodeGradientStartColorName.c_str() ) ); - mitk::ColorProperty * nodeColorEnd = static_cast< mitk::ColorProperty * > ( - this->GetDataNode()->GetProperty( connectomicsRenderingNodeGradientEndColorName.c_str() ) ); - mitk::FloatProperty * nodeRadiusStart = static_cast< mitk::FloatProperty * > ( - this->GetDataNode()->GetProperty( connectomicsRenderingNodeRadiusStartName.c_str() ) ); - mitk::FloatProperty * nodeRadiusEnd = static_cast< mitk::FloatProperty * > ( - this->GetDataNode()->GetProperty( connectomicsRenderingNodeRadiusEndName.c_str() ) ); - mitk::StringProperty * chosenNode = static_cast< mitk::StringProperty * > ( - this->GetDataNode()->GetProperty( connectomicsRenderingNodeChosenNodeName.c_str() ) ); - mitk::ColorProperty * edgeColorStart = static_cast< mitk::ColorProperty * > ( - this->GetDataNode()->GetProperty( connectomicsRenderingEdgeGradientStartColorName.c_str() ) ); - mitk::ColorProperty * edgeColorEnd = static_cast< mitk::ColorProperty * > ( - this->GetDataNode()->GetProperty( connectomicsRenderingEdgeGradientEndColorName.c_str() ) ); - mitk::FloatProperty * edgeRadiusStart = static_cast< mitk::FloatProperty * > ( - this->GetDataNode()->GetProperty( connectomicsRenderingEdgeRadiusStartName.c_str() ) ); - mitk::FloatProperty * edgeRadiusEnd = static_cast< mitk::FloatProperty * > ( - this->GetDataNode()->GetProperty( connectomicsRenderingEdgeRadiusEndName.c_str() ) ); - mitk::ConnectomicsRenderingNodeColorParameterProperty * nodeColorParameter = - static_cast< mitk::ConnectomicsRenderingNodeColorParameterProperty * > ( - this->GetDataNode()->GetProperty( connectomicsRenderingNodeGradientColorParameterName.c_str() ) ); - mitk::ConnectomicsRenderingNodeRadiusParameterProperty * nodeRadiusParameter = - static_cast< mitk::ConnectomicsRenderingNodeRadiusParameterProperty * > ( - this->GetDataNode()->GetProperty( connectomicsRenderingNodeRadiusParameterName.c_str() ) ); - mitk::ConnectomicsRenderingEdgeColorParameterProperty * edgeColorParameter = - static_cast< mitk::ConnectomicsRenderingEdgeColorParameterProperty * > ( - this->GetDataNode()->GetProperty( connectomicsRenderingEdgeGradientColorParameterName.c_str() ) ); - mitk::ConnectomicsRenderingEdgeRadiusParameterProperty * edgeRadiusParameter = - static_cast< mitk::ConnectomicsRenderingEdgeRadiusParameterProperty * > ( - this->GetDataNode()->GetProperty( connectomicsRenderingEdgeRadiusParameterName.c_str() ) ); - - if( - m_ChosenRenderingScheme != renderingScheme->GetValueAsString() || - m_ChosenEdgeFilter != edgeFilter->GetValueAsString() || - m_EdgeThreshold != edgeThreshold->GetValue() || - m_EdgeThresholdParameter != edgeThresholdParameter->GetValueAsString() || - m_ChosenNodeFilter != nodeFilter->GetValueAsString() || - m_NodeThreshold != nodeThreshold->GetValue() || - m_NodeThresholdParameter != nodeThresholdParameter->GetValueAsString() || - m_NodeColorStart != nodeColorStart->GetValue() || - m_NodeColorEnd != nodeColorEnd->GetValue() || - m_NodeRadiusStart != nodeRadiusStart->GetValue() || - m_NodeRadiusEnd != nodeRadiusEnd->GetValue() || - m_ChosenNodeLabel != chosenNode->GetValueAsString() || - m_EdgeColorStart != edgeColorStart->GetValue() || - m_EdgeColorEnd != edgeColorEnd->GetValue() || - m_EdgeRadiusStart != edgeRadiusStart->GetValue() || - m_EdgeRadiusEnd != edgeRadiusEnd->GetValue() || - m_NodeColorParameter != nodeColorParameter->GetValueAsString() || - m_NodeRadiusParameter != nodeRadiusParameter->GetValueAsString() || - m_EdgeColorParameter != edgeColorParameter->GetValueAsString() || - m_EdgeRadiusParameter != edgeRadiusParameter->GetValueAsString() ) + mitk::ConnectomicsRenderingSchemeProperty *renderingScheme = static_cast( + this->GetDataNode()->GetProperty(connectomicsRenderingSchemePropertyName.c_str())); + mitk::ConnectomicsRenderingEdgeFilteringProperty *edgeFilter = + static_cast( + this->GetDataNode()->GetProperty(connectomicsRenderingEdgeFilteringPropertyName.c_str())); + mitk::FloatProperty *edgeThreshold = static_cast( + this->GetDataNode()->GetProperty(connectomicsRenderingEdgeThresholdFilterThresholdName.c_str())); + mitk::ConnectomicsRenderingNodeFilteringProperty *nodeFilter = + static_cast( + this->GetDataNode()->GetProperty(connectomicsRenderingNodeFilteringPropertyName.c_str())); + + mitk::ConnectomicsRenderingNodeThresholdParameterProperty *nodeThresholdParameter = + static_cast( + this->GetDataNode()->GetProperty(connectomicsRenderingNodeThresholdFilterParameterName.c_str())); + mitk::ConnectomicsRenderingEdgeThresholdParameterProperty *edgeThresholdParameter = + static_cast( + this->GetDataNode()->GetProperty(connectomicsRenderingEdgeThresholdFilterParameterName.c_str())); + + mitk::FloatProperty *nodeThreshold = static_cast( + this->GetDataNode()->GetProperty(connectomicsRenderingNodeThresholdFilterThresholdName.c_str())); + mitk::ColorProperty *nodeColorStart = static_cast( + this->GetDataNode()->GetProperty(connectomicsRenderingNodeGradientStartColorName.c_str())); + mitk::ColorProperty *nodeColorEnd = static_cast( + this->GetDataNode()->GetProperty(connectomicsRenderingNodeGradientEndColorName.c_str())); + mitk::FloatProperty *nodeRadiusStart = static_cast( + this->GetDataNode()->GetProperty(connectomicsRenderingNodeRadiusStartName.c_str())); + mitk::FloatProperty *nodeRadiusEnd = static_cast( + this->GetDataNode()->GetProperty(connectomicsRenderingNodeRadiusEndName.c_str())); + mitk::StringProperty *chosenNode = static_cast( + this->GetDataNode()->GetProperty(connectomicsRenderingNodeChosenNodeName.c_str())); + mitk::ColorProperty *edgeColorStart = static_cast( + this->GetDataNode()->GetProperty(connectomicsRenderingEdgeGradientStartColorName.c_str())); + mitk::ColorProperty *edgeColorEnd = static_cast( + this->GetDataNode()->GetProperty(connectomicsRenderingEdgeGradientEndColorName.c_str())); + mitk::FloatProperty *edgeRadiusStart = static_cast( + this->GetDataNode()->GetProperty(connectomicsRenderingEdgeRadiusStartName.c_str())); + mitk::FloatProperty *edgeRadiusEnd = static_cast( + this->GetDataNode()->GetProperty(connectomicsRenderingEdgeRadiusEndName.c_str())); + mitk::ConnectomicsRenderingNodeColorParameterProperty *nodeColorParameter = + static_cast( + this->GetDataNode()->GetProperty(connectomicsRenderingNodeGradientColorParameterName.c_str())); + mitk::ConnectomicsRenderingNodeRadiusParameterProperty *nodeRadiusParameter = + static_cast( + this->GetDataNode()->GetProperty(connectomicsRenderingNodeRadiusParameterName.c_str())); + mitk::ConnectomicsRenderingEdgeColorParameterProperty *edgeColorParameter = + static_cast( + this->GetDataNode()->GetProperty(connectomicsRenderingEdgeGradientColorParameterName.c_str())); + mitk::ConnectomicsRenderingEdgeRadiusParameterProperty *edgeRadiusParameter = + static_cast( + this->GetDataNode()->GetProperty(connectomicsRenderingEdgeRadiusParameterName.c_str())); + + if (m_ChosenRenderingScheme != renderingScheme->GetValueAsString() || + m_ChosenEdgeFilter != edgeFilter->GetValueAsString() || m_EdgeThreshold != edgeThreshold->GetValue() || + m_EdgeThresholdParameter != edgeThresholdParameter->GetValueAsString() || + m_ChosenNodeFilter != nodeFilter->GetValueAsString() || m_NodeThreshold != nodeThreshold->GetValue() || + m_NodeThresholdParameter != nodeThresholdParameter->GetValueAsString() || + m_NodeColorStart != nodeColorStart->GetValue() || m_NodeColorEnd != nodeColorEnd->GetValue() || + m_NodeRadiusStart != nodeRadiusStart->GetValue() || m_NodeRadiusEnd != nodeRadiusEnd->GetValue() || + m_ChosenNodeLabel != chosenNode->GetValueAsString() || m_EdgeColorStart != edgeColorStart->GetValue() || + m_EdgeColorEnd != edgeColorEnd->GetValue() || m_EdgeRadiusStart != edgeRadiusStart->GetValue() || + m_EdgeRadiusEnd != edgeRadiusEnd->GetValue() || m_NodeColorParameter != nodeColorParameter->GetValueAsString() || + m_NodeRadiusParameter != nodeRadiusParameter->GetValueAsString() || + m_EdgeColorParameter != edgeColorParameter->GetValueAsString() || + m_EdgeRadiusParameter != edgeRadiusParameter->GetValueAsString()) { m_ChosenRenderingScheme = renderingScheme->GetValueAsString(); m_ChosenEdgeFilter = edgeFilter->GetValueAsString(); m_EdgeThreshold = edgeThreshold->GetValue(); m_EdgeThresholdParameter = edgeThresholdParameter->GetValueAsString(); m_ChosenNodeFilter = nodeFilter->GetValueAsString(); m_NodeThreshold = nodeThreshold->GetValue(); m_NodeThresholdParameter = nodeThresholdParameter->GetValueAsString(); m_NodeColorStart = nodeColorStart->GetValue(); m_NodeColorEnd = nodeColorEnd->GetValue(); m_NodeRadiusStart = nodeRadiusStart->GetValue(); m_NodeRadiusEnd = nodeRadiusEnd->GetValue(); m_ChosenNodeLabel = chosenNode->GetValueAsString(); m_EdgeColorStart = edgeColorStart->GetValue(); m_EdgeColorEnd = edgeColorEnd->GetValue(); m_EdgeRadiusStart = edgeRadiusStart->GetValue(); m_EdgeRadiusEnd = edgeRadiusEnd->GetValue(); m_NodeColorParameter = nodeColorParameter->GetValueAsString(); m_NodeRadiusParameter = nodeRadiusParameter->GetValueAsString(); m_EdgeColorParameter = edgeColorParameter->GetValueAsString(); m_EdgeRadiusParameter = edgeRadiusParameter->GetValueAsString(); return true; } return false; } -double mitk::ConnectomicsNetworkMapper3D::FillNodeParameterVector( std::vector< double > * parameterVector, std::string parameterName ) +double mitk::ConnectomicsNetworkMapper3D::FillNodeParameterVector(std::vector *parameterVector, + std::string parameterName) { - int end( parameterVector->size() ); + int end(parameterVector->size()); // constant parameter - uniform style - if( parameterName == connectomicsRenderingNodeParameterConstant ) + if (parameterName == connectomicsRenderingNodeParameterConstant) { - for(int index(0); index < end; index++) + for (int index(0); index < end; index++) { - parameterVector->at( index ) = 1.0; + parameterVector->at(index) = 1.0; } return 1.0; } - double maximum( 0.0 ); + double maximum(0.0); // using the degree as parameter - if( parameterName == connectomicsRenderingNodeParameterDegree ) + if (parameterName == connectomicsRenderingNodeParameterDegree) { - std::vector< int > vectorOfDegree = this->GetInput()->GetDegreeOfNodes(); - for(int index(0); index < end; index++) + std::vector vectorOfDegree = this->GetInput()->GetDegreeOfNodes(); + for (int index(0); index < end; index++) { - parameterVector->at( index ) = vectorOfDegree[ index ]; + parameterVector->at(index) = vectorOfDegree[index]; } - maximum = *std::max_element( parameterVector->begin(), parameterVector->end() ); + maximum = *std::max_element(parameterVector->begin(), parameterVector->end()); } // using betweenness centrality as parameter - if( parameterName == connectomicsRenderingNodeParameterBetweenness ) + if (parameterName == connectomicsRenderingNodeParameterBetweenness) { - std::vector< double > vectorOfBetweenness = this->GetInput()->GetNodeBetweennessVector(); - for(int index(0); index < end; index++) + std::vector vectorOfBetweenness = this->GetInput()->GetNodeBetweennessVector(); + for (int index(0); index < end; index++) { - parameterVector->at( index ) = vectorOfBetweenness[index]; + parameterVector->at(index) = vectorOfBetweenness[index]; } - maximum = *std::max_element( parameterVector->begin(), parameterVector->end() ); + maximum = *std::max_element(parameterVector->begin(), parameterVector->end()); } // using clustering coefficient as parameter - if( parameterName == connectomicsRenderingNodeParameterClustering ) + if (parameterName == connectomicsRenderingNodeParameterClustering) { - const std::vector< double > vectorOfClustering = this->GetInput()->GetLocalClusteringCoefficients(); - for(int index(0); index < end; index++) + const std::vector vectorOfClustering = this->GetInput()->GetLocalClusteringCoefficients(); + for (int index(0); index < end; index++) { - parameterVector->at( index ) = vectorOfClustering[index]; + parameterVector->at(index) = vectorOfClustering[index]; } - maximum = *std::max_element( parameterVector->begin(), parameterVector->end() ); + maximum = *std::max_element(parameterVector->begin(), parameterVector->end()); } // using distance to a specific node as parameter - if( parameterName == connectomicsRenderingNodeParameterColoringShortestPath ) + if (parameterName == connectomicsRenderingNodeParameterColoringShortestPath) { - bool labelFound( this->GetInput()->CheckForLabel( m_ChosenNodeLabel ) ); + bool labelFound(this->GetInput()->CheckForLabel(m_ChosenNodeLabel)); // check whether the chosen node is valid - if( !labelFound ) + if (!labelFound) { MITK_WARN << "Node chosen for rendering is not valid."; - for(int index(0); index < end; index++) + for (int index(0); index < end; index++) { - parameterVector->at( index ) = 1.0; + parameterVector->at(index) = 1.0; } return 1.0; } else { - const std::vector< double > distanceVector = this->GetInput()->GetShortestDistanceVectorFromLabel( m_ChosenNodeLabel ); - for(int index(0); index < end; index++) + const std::vector distanceVector = + this->GetInput()->GetShortestDistanceVectorFromLabel(m_ChosenNodeLabel); + for (int index(0); index < end; index++) { - parameterVector->at( index ) = distanceVector[index]; + parameterVector->at(index) = distanceVector[index]; } - maximum = *std::max_element( parameterVector->begin(), parameterVector->end() ); + maximum = *std::max_element(parameterVector->begin(), parameterVector->end()); } } // if the maximum is nearly zero - if( std::abs( maximum ) < mitk::eps ) + if (std::abs(maximum) < mitk::eps) { maximum = 1.0; } return maximum; } -double mitk::ConnectomicsNetworkMapper3D::FillEdgeParameterVector( std::vector< double > * parameterVector, std::string parameterName ) +double mitk::ConnectomicsNetworkMapper3D::FillEdgeParameterVector(std::vector *parameterVector, + std::string parameterName) { - int end( parameterVector->size() ); + int end(parameterVector->size()); // constant parameter - uniform style - if( parameterName == connectomicsRenderingEdgeParameterConstant ) + if (parameterName == connectomicsRenderingEdgeParameterConstant) { - for(int index(0); index < end; index++) + for (int index(0); index < end; index++) { - parameterVector->at( index ) = 1.0; + parameterVector->at(index) = 1.0; } return 1.0; } - double maximum( 0.0 ); + double maximum(0.0); // using the weight as parameter - if( parameterName == connectomicsRenderingEdgeParameterWeight ) + if (parameterName == connectomicsRenderingEdgeParameterWeight) { - std::vector< std::pair< - std::pair< mitk::ConnectomicsNetwork::NetworkNode, mitk::ConnectomicsNetwork::NetworkNode > - , mitk::ConnectomicsNetwork::NetworkEdge > > vectorOfEdges = this->GetInput()->GetVectorOfAllEdges(); - for(int index(0); index < end; index++) + std::vector, + mitk::ConnectomicsNetwork::NetworkEdge>> + vectorOfEdges = this->GetInput()->GetVectorOfAllEdges(); + for (int index(0); index < end; index++) { - parameterVector->at( index ) = vectorOfEdges[ index ].second.weight; + parameterVector->at(index) = vectorOfEdges[index].second.weight; } - maximum = *std::max_element( parameterVector->begin(), parameterVector->end() ); + maximum = *std::max_element(parameterVector->begin(), parameterVector->end()); } // using the edge centrality as parameter - if( parameterName == connectomicsRenderingEdgeParameterCentrality ) + if (parameterName == connectomicsRenderingEdgeParameterCentrality) { - const std::vector< double > vectorOfCentrality = this->GetInput()->GetEdgeBetweennessVector(); - for(int index(0); index < end; index++) + const std::vector vectorOfCentrality = this->GetInput()->GetEdgeBetweennessVector(); + for (int index(0); index < end; index++) { - parameterVector->at( index ) = vectorOfCentrality[index]; + parameterVector->at(index) = vectorOfCentrality[index]; } - maximum = *std::max_element( parameterVector->begin(), parameterVector->end() ); + maximum = *std::max_element(parameterVector->begin(), parameterVector->end()); } // if the maximum is nearly zero - if( std::abs( maximum ) < mitk::eps ) + if (std::abs(maximum) < mitk::eps) { maximum = 1.0; } return maximum; } -void mitk::ConnectomicsNetworkMapper3D::FillNodeFilterBoolVector( std::vector< bool > * boolVector, std::string parameterName ) +void mitk::ConnectomicsNetworkMapper3D::FillNodeFilterBoolVector(std::vector *boolVector, + std::string parameterName) { - std::vector< double > parameterVector; - parameterVector.resize( boolVector->size() ); - int end( parameterVector.size() ); + std::vector parameterVector; + parameterVector.resize(boolVector->size()); + int end(parameterVector.size()); // using the degree as parameter - if( parameterName == connectomicsRenderingNodeParameterDegree ) + if (parameterName == connectomicsRenderingNodeParameterDegree) { - std::vector< int > vectorOfDegree = this->GetInput()->GetDegreeOfNodes(); - for(int index(0); index < end; index++) + std::vector vectorOfDegree = this->GetInput()->GetDegreeOfNodes(); + for (int index(0); index < end; index++) { - parameterVector.at( index ) = vectorOfDegree[ index ]; + parameterVector.at(index) = vectorOfDegree[index]; } } // using betweenness centrality as parameter - if( parameterName == connectomicsRenderingNodeParameterBetweenness ) + if (parameterName == connectomicsRenderingNodeParameterBetweenness) { - std::vector< double > vectorOfBetweenness = this->GetInput()->GetNodeBetweennessVector(); - for(int index(0); index < end; index++) + std::vector vectorOfBetweenness = this->GetInput()->GetNodeBetweennessVector(); + for (int index(0); index < end; index++) { - parameterVector.at( index ) = vectorOfBetweenness[index]; + parameterVector.at(index) = vectorOfBetweenness[index]; } } // using clustering coefficient as parameter - if( parameterName == connectomicsRenderingNodeParameterClustering ) + if (parameterName == connectomicsRenderingNodeParameterClustering) { - const std::vector< double > vectorOfClustering = this->GetInput()->GetLocalClusteringCoefficients(); - for(int index(0); index < end; index++) + const std::vector vectorOfClustering = this->GetInput()->GetLocalClusteringCoefficients(); + for (int index(0); index < end; index++) { - parameterVector.at( index ) = vectorOfClustering[index]; + parameterVector.at(index) = vectorOfClustering[index]; } } - for( int index( 0 ), end( boolVector->size() ); index < end; index++ ) + for (int index(0), end(boolVector->size()); index < end; index++) { - if( parameterVector.at( index ) >= m_NodeThreshold ) + if (parameterVector.at(index) >= m_NodeThreshold) { - boolVector->at( index ) = true; + boolVector->at(index) = true; } else { - boolVector->at( index ) = false; + boolVector->at(index) = false; } } return; } -void mitk::ConnectomicsNetworkMapper3D::FillEdgeFilterBoolVector( std::vector< bool > * boolVector, std::string parameterName ) +void mitk::ConnectomicsNetworkMapper3D::FillEdgeFilterBoolVector(std::vector *boolVector, + std::string parameterName) { - std::vector< double > parameterVector; - parameterVector.resize( boolVector->size() ); - int end( parameterVector.size() ); - + std::vector parameterVector; + parameterVector.resize(boolVector->size()); + int end(parameterVector.size()); // using the weight as parameter - if( parameterName == connectomicsRenderingEdgeParameterWeight ) + if (parameterName == connectomicsRenderingEdgeParameterWeight) { - std::vector< std::pair< - std::pair< mitk::ConnectomicsNetwork::NetworkNode, mitk::ConnectomicsNetwork::NetworkNode > - , mitk::ConnectomicsNetwork::NetworkEdge > > vectorOfEdges = this->GetInput()->GetVectorOfAllEdges(); + std::vector, + mitk::ConnectomicsNetwork::NetworkEdge>> + vectorOfEdges = this->GetInput()->GetVectorOfAllEdges(); - for(int index(0); index < end; index++) + for (int index(0); index < end; index++) { - parameterVector.at( index ) = vectorOfEdges[ index ].second.weight; + parameterVector.at(index) = vectorOfEdges[index].second.weight; } } // using the edge centrality as parameter - if( parameterName == connectomicsRenderingEdgeParameterCentrality ) + if (parameterName == connectomicsRenderingEdgeParameterCentrality) { - const std::vector< double > vectorOfCentrality = this->GetInput()->GetEdgeBetweennessVector(); - for(int index(0); index < end; index++) + const std::vector vectorOfCentrality = this->GetInput()->GetEdgeBetweennessVector(); + for (int index(0); index < end; index++) { - parameterVector.at( index ) = vectorOfCentrality[index]; + parameterVector.at(index) = vectorOfCentrality[index]; } } - for( int index( 0 ), end( boolVector->size() ); index < end; index++ ) + for (int index(0), end(boolVector->size()); index < end; index++) { - if( parameterVector.at( index ) >= m_EdgeThreshold ) + if (parameterVector.at(index) >= m_EdgeThreshold) { - boolVector->at( index ) = true; + boolVector->at(index) = true; } else { - boolVector->at( index ) = false; + boolVector->at(index) = false; } } return; } diff --git a/Modules/DiffusionImaging/Connectomics/Rendering/mitkConnectomicsNetworkMapper3D.h b/Modules/DiffusionImaging/Connectomics/Rendering/mitkConnectomicsNetworkMapper3D.h index 90a1bc755b..4ed32cbf7c 100644 --- a/Modules/DiffusionImaging/Connectomics/Rendering/mitkConnectomicsNetworkMapper3D.h +++ b/Modules/DiffusionImaging/Connectomics/Rendering/mitkConnectomicsNetworkMapper3D.h @@ -1,150 +1,147 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ - #ifndef ConnectomicsNetworkMapper3D_H_HEADER_INCLUDED #define ConnectomicsNetworkMapper3D_H_HEADER_INCLUDED // VTK includes -#include #include "vtkPropAssembly.h" +#include // MITK includes // base class #include "mitkVtkMapper.h" // data type #include "mitkConnectomicsNetwork.h" #include -#include -#include #include #include #include +#include #include +#include #include -#include #include +#include -#include #include +#include #include -#include #include +#include -#include #include +#include -#include -#include "mitkTextOverlay2D.h" -#include "mitkTextOverlay3D.h" -#include -#include -#include -#include #include "mitkFreeSurferParcellationTranslator.h" +#include "mitkTextAnnotation2D.h" +#include "mitkTextAnnotation3D.h" #include "mitkVtkInteractorStyle.h" +#include +#include +#include +#include +#include -#include #include #include +#include #include -namespace mitk { - +namespace mitk +{ /** * \brief Mapper for Networks * \ingroup Mapper */ class MITKCONNECTOMICS_EXPORT ConnectomicsNetworkMapper3D : public VtkMapper { public: - mitkClassMacro(ConnectomicsNetworkMapper3D, VtkMapper); - itkFactorylessNewMacro(Self) - itkCloneMacro(Self) + itkFactorylessNewMacro(Self) itkCloneMacro(Self) - virtual vtkProp *GetVtkProp(mitk::BaseRenderer *renderer) override; //looks like deprecated.. should be replaced bz GetViewProp() - static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = nullptr, bool overwrite = false ); + virtual vtkProp *GetVtkProp( + mitk::BaseRenderer *renderer) override; // looks like deprecated.. should be replaced bz GetViewProp() + static void SetDefaultProperties(DataNode *node, BaseRenderer *renderer = nullptr, bool overwrite = false); - static void SetVtkMapperImmediateModeRendering(vtkMapper* mapper); + static void SetVtkMapperImmediateModeRendering(vtkMapper *mapper); - virtual void GenerateDataForRenderer(mitk::BaseRenderer* renderer) override; + virtual void GenerateDataForRenderer(mitk::BaseRenderer *renderer) override; - virtual const mitk::ConnectomicsNetwork* GetInput(); + virtual const mitk::ConnectomicsNetwork *GetInput(); protected: - ConnectomicsNetworkMapper3D(); virtual ~ConnectomicsNetworkMapper3D(); void UpdateVtkObjects(); vtkPropAssembly *m_NetworkAssembly; /** * \brief Returns true if the properties have changed since the last data generation */ bool PropertiesChanged(); // Create vectors for customizing color and radius and return maximum - double FillNodeParameterVector( std::vector< double > * parameterVector, std::string parameterName ); - double FillEdgeParameterVector( std::vector< double > * parameterVector, std::string parameterName ); + double FillNodeParameterVector(std::vector *parameterVector, std::string parameterName); + double FillEdgeParameterVector(std::vector *parameterVector, std::string parameterName); - void FillNodeFilterBoolVector( std::vector< bool > * boolVector, std::string parameterName ); - void FillEdgeFilterBoolVector( std::vector< bool > * boolVector, std::string parameterName ); + void FillNodeFilterBoolVector(std::vector *boolVector, std::string parameterName); + void FillEdgeFilterBoolVector(std::vector *boolVector, std::string parameterName); // Property storing members std::string m_ChosenRenderingScheme; std::string m_ChosenEdgeFilter; std::string m_EdgeThresholdParameter; double m_EdgeThreshold; std::string m_ChosenNodeFilter; std::string m_NodeThresholdParameter; double m_NodeThreshold; mitk::Color m_NodeColorStart; mitk::Color m_NodeColorEnd; double m_NodeRadiusStart; double m_NodeRadiusEnd; std::string m_ChosenNodeLabel; mitk::Color m_EdgeColorStart; mitk::Color m_EdgeColorEnd; double m_EdgeRadiusStart; double m_EdgeRadiusEnd; std::string m_NodeRadiusParameter; std::string m_NodeColorParameter; std::string m_EdgeRadiusParameter; std::string m_EdgeColorParameter; // Balloons std::string m_BalloonText; std::string m_BalloonNodeStats; mitk::FreeSurferParcellationTranslator::Pointer m_Translator; std::string m_AllNodeLabels; - mitk::TextOverlay3D::Pointer m_TextOverlay3D; + mitk::TextAnnotation3D::Pointer m_TextOverlay3D; }; } // namespace mitk #endif /* ConnectomicsNetworkMapper3D_H_HEADER_INCLUDED */ diff --git a/Modules/DiffusionImaging/DiffusionCore/cmdapps/CMakeLists.txt b/Modules/DiffusionImaging/DiffusionCore/cmdapps/CMakeLists.txt index 11f0c2aa2b..7fbf48d40b 100644 --- a/Modules/DiffusionImaging/DiffusionCore/cmdapps/CMakeLists.txt +++ b/Modules/DiffusionImaging/DiffusionCore/cmdapps/CMakeLists.txt @@ -1,44 +1,44 @@ option(BUILD_DiffusionMiniApps "Build commandline tools for diffusion" OFF) if(BUILD_DiffusionMiniApps OR MITK_BUILD_ALL_APPS) # needed include directories include_directories( ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR} ) # list of diffusion miniapps # if an app requires additional dependencies # they are added after a "^^" and separated by "_" set( diffusionminiapps DwiDenoising^^ ImageResampler^^ ExportShImage^^ CopyGeometry^^ DiffusionIndices^^ QballReconstruction^^ Registration^^ TensorReconstruction^^ TensorDerivedMapsExtraction^^ DiffusionDICOMLoader^^ - DiffusionIVIMFit^^ + DiffusionKurtosisFit^^ ) foreach(diffusionminiapp ${diffusionminiapps}) # extract mini app name and dependencies string(REPLACE "^^" "\\;" miniapp_info ${diffusionminiapp}) set(miniapp_info_list ${miniapp_info}) list(GET miniapp_info_list 0 appname) list(GET miniapp_info_list 1 raw_dependencies) string(REPLACE "_" "\\;" dependencies "${raw_dependencies}") set(dependencies_list ${dependencies}) mitkFunctionCreateCommandLineApp( NAME ${appname} DEPENDS MitkCore MitkDiffusionCore ${dependencies_list} PACKAGE_DEPENDS ITK ) endforeach() endif() diff --git a/Modules/DiffusionImaging/DiffusionCore/cmdapps/DiffusionIVIMFit.cpp b/Modules/DiffusionImaging/DiffusionCore/cmdapps/DiffusionKurtosisFit.cpp similarity index 60% rename from Modules/DiffusionImaging/DiffusionCore/cmdapps/DiffusionIVIMFit.cpp rename to Modules/DiffusionImaging/DiffusionCore/cmdapps/DiffusionKurtosisFit.cpp index 6c49d7a7d0..d1886d0469 100644 --- a/Modules/DiffusionImaging/DiffusionCore/cmdapps/DiffusionIVIMFit.cpp +++ b/Modules/DiffusionImaging/DiffusionCore/cmdapps/DiffusionKurtosisFit.cpp @@ -1,207 +1,253 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "mitkCommandLineParser.h" #include #include #include #include +#include "mitkImage.h" +#include +#include +#include +#include "mitkIOUtil.h" + +#include +#include + + //vnl_includes #include "vnl/vnl_math.h" #include "vnl/vnl_cost_function.h" #include "vnl/vnl_least_squares_function.h" #include "vnl/algo/vnl_lbfgsb.h" #include "vnl/algo/vnl_lbfgs.h" #include "vnl/algo/vnl_levenberg_marquardt.h" typedef mitk::DiffusionPropertyHelper DPH; #include #include #include #include #include #include + + DPH::ImageType::Pointer GetBlurredVectorImage( DPH::ImageType::Pointer vectorImage, double sigma) { typedef itk::DiscreteGaussianImageFilter< itk::Image, itk::Image > GaussianFilterType; typedef itk::VectorIndexSelectionCastImageFilter< DPH::ImageType, itk::Image > IndexSelectionType; IndexSelectionType::Pointer indexSelectionFilter = IndexSelectionType::New(); indexSelectionFilter->SetInput( vectorImage ); typedef itk::ComposeImageFilter< itk::Image, DPH::ImageType > ComposeFilterType; ComposeFilterType::Pointer vec_composer = ComposeFilterType::New(); for( unsigned int i=0; iGetVectorLength(); ++i) { GaussianFilterType::Pointer gaussian_filter = GaussianFilterType::New(); indexSelectionFilter->SetIndex( i ); gaussian_filter->SetInput( indexSelectionFilter->GetOutput() ); gaussian_filter->SetVariance( sigma ); vec_composer->SetInput(i, gaussian_filter->GetOutput() ); gaussian_filter->Update(); } try { vec_composer->Update(); } catch(const itk::ExceptionObject &e) { mitkThrow() << "[VectorImage.GaussianSmoothing] !! Failed with ITK Exception: " << e.what(); } DPH::ImageType::Pointer smoothed_vector = vec_composer->GetOutput(); -/* + + /* itk::ImageFileWriter< DPH::ImageType >::Pointer writer = itk::ImageFileWriter< DPH::ImageType >::New(); writer->SetInput( smoothed_vector ); writer->SetFileName( "/tmp/itk_smoothed_vector.nrrd"); writer->Update();*/ return smoothed_vector; } -void KurtosisMapComputation( mitk::Image::Pointer input, std::string output_prefix ) +void KurtosisMapComputation( mitk::Image::Pointer input, + std::string output_prefix , + std::string output_type, + std::string maskPath, + bool omitBZero, + double lower, + double upper ) { DPH::ImageType::Pointer vectorImage = DPH::ImageType::New(); mitk::CastToItkImage( input, vectorImage ); - - typedef itk::DiffusionKurtosisReconstructionImageFilter< short, double > KurtosisFilterType; KurtosisFilterType::Pointer kurtosis_filter = KurtosisFilterType::New(); - kurtosis_filter->SetInput( GetBlurredVectorImage( vectorImage, 1.5 ) ); kurtosis_filter->SetReferenceBValue( DPH::GetReferenceBValue( input.GetPointer() ) ); kurtosis_filter->SetGradientDirections( DPH::GetGradientContainer( input.GetPointer() ) ); - kurtosis_filter->SetNumberOfThreads(1); +// kurtosis_filter->SetNumberOfThreads(1); + kurtosis_filter->SetOmitUnweightedValue(omitBZero); + kurtosis_filter->SetBoundariesForKurtosis(-lower,upper); +// kurtosis_filter->SetInitialSolution(const vnl_vector& x0 ); - KurtosisFilterType::OutputImageRegionType o_region; - KurtosisFilterType::OutputImageRegionType::SizeType o_size; - KurtosisFilterType::OutputImageRegionType::IndexType o_index; - o_index.Fill(0); o_size.Fill(0); - o_index[0] = 48; o_index[1] = 18; o_index[2] = 12; - o_size[0] = 16; o_size[1] = 24; o_size[2] = 1; - - o_region.SetSize( o_size ); - o_region.SetIndex( o_index ); - kurtosis_filter->SetMapOutputRegion( o_region ); + if(maskPath != "") + { + mitk::Image::Pointer segmentation; + segmentation = mitk::IOUtil::LoadImage(maskPath); + typedef itk::Image< short , 3> MaskImageType; + MaskImageType::Pointer vectorSeg = MaskImageType::New() ; + mitk::CastToItkImage( segmentation, vectorSeg ); + kurtosis_filter->SetImageMask(vectorSeg) ; + } try { kurtosis_filter->Update(); } catch( const itk::ExceptionObject& e) { mitkThrow() << "Kurtosis fit failed with an ITK Exception: " << e.what(); } mitk::Image::Pointer d_image = mitk::Image::New(); d_image->InitializeByItk( kurtosis_filter->GetOutput(0) ); d_image->SetVolume( kurtosis_filter->GetOutput(0)->GetBufferPointer() ); mitk::Image::Pointer k_image = mitk::Image::New(); k_image->InitializeByItk( kurtosis_filter->GetOutput(1) ); k_image->SetVolume( kurtosis_filter->GetOutput(1)->GetBufferPointer() ); - std::string outputD_FileName = output_prefix + "_ADC_map.nrrd"; - std::string outputK_FileName = output_prefix + "_AKC_map.nrrd"; + std::string outputD_FileName = output_prefix + "_ADC_map." + output_type; + std::string outputK_FileName = output_prefix + "_AKC_map." + output_type; try { - mitk::IOUtil::Save( d_image, outputD_FileName ); - mitk::IOUtil::Save( k_image, outputK_FileName ); + mitk::IOUtil::Save( d_image, outputD_FileName ); + mitk::IOUtil::Save( k_image, outputK_FileName ); } catch( const itk::ExceptionObject& e) { mitkThrow() << "Failed to save the KurtosisFit Results due to exception: " << e.what(); } } int main( int argc, char* argv[] ) { - mitkCommandLineParser parser; - parser.setTitle("Diffusion IVIM (Kurtosis) Fit"); + parser.setTitle("Diffusion Kurtosis Fit"); parser.setCategory("Signal Reconstruction"); parser.setContributor("MIC"); - parser.setDescription("Fitting of IVIM / Kurtosis"); - + parser.setDescription("Fitting Kurtosis"); parser.setArgumentPrefix("--","-"); + // mandatory arguments parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input: ", "input image (DWI)", us::Any(), false); parser.addArgument("output", "o", mitkCommandLineParser::String, "Output Preifx: ", "Prefix for the output images, will append _f, _K, _D accordingly ", us::Any(), false); - parser.addArgument("fit", "f", mitkCommandLineParser::String, "Input: ", "input image (DWI)", us::Any(), false); + parser.addArgument("output_type", "ot", mitkCommandLineParser::String, "Output Type: ", "choose data type of output image, e.g. '.nii' or '.nrrd' ", us::Any(), false); // optional arguments - parser.addArgument("mask", "m", mitkCommandLineParser::InputFile, "Masking Image: ", "ROI (segmentation)", us::Any(), true); + parser.addArgument("mask", "m", mitkCommandLineParser::InputFile, "Masking Image: ", "ROI (segmentation)", us::Any()); + parser.addArgument("help", "h", mitkCommandLineParser::Bool, "Help", "Show this help text"); + parser.addArgument("omitbzero", "om", mitkCommandLineParser::Bool, "Omit b0:", "Omit b0 value during fit (default = false)", us::Any()); + parser.addArgument("lowerkbound", "kl", mitkCommandLineParser::Float, "lower Kbound:", "Set (unsigned) lower boundary for Kurtosis parameter (default = -1000)", us::Any()); + parser.addArgument("upperkbound", "ku", mitkCommandLineParser::Float, "upper Kbound:", "Set upper boundary for Kurtosis parameter (default = 1000)", us::Any()); std::map parsedArgs = parser.parseArguments(argc, argv); - if (parsedArgs.size()==0) - return EXIT_FAILURE; + + if (parsedArgs.size()==0 || parsedArgs.count("help") || parsedArgs.count("h")){ + std::cout << parser.helpText(); + return EXIT_SUCCESS; + } // mandatory arguments std::string inFileName = us::any_cast(parsedArgs["input"]); std::string out_prefix = us::any_cast(parsedArgs["output"]); - std::string fit_name = us::any_cast(parsedArgs["fit"]); + std::string maskPath = ""; mitk::Image::Pointer inputImage = mitk::IOUtil::LoadImage(inFileName); - if( !DPH::IsDiffusionWeightedImage( inputImage ) ) + + bool omitBZero = false; + double lower = -1000; + double upper = 1000; + std::string out_type = "nrrd"; + + if (parsedArgs.count("mask") || parsedArgs.count("m")) { - MITK_ERROR("DiffusionIVIMFit.Input") << "No valid diffusion-weighted image provided, failed to load " << inFileName << " as DW Image. Aborting..."; - return EXIT_FAILURE; + maskPath = us::any_cast(parsedArgs["mask"]); } - if( fit_name == "Kurtosis" ) + if (parsedArgs.count("output_type") || parsedArgs.count("ot")) { - MITK_INFO("DiffusionIVIMFit.Main") << "-----[ Kurtosis Fit ]-----"; + out_type = us::any_cast(parsedArgs["output_type"]); + } - KurtosisMapComputation( inputImage, out_prefix ); + if (parsedArgs.count("omitbzero") || parsedArgs.count("om")) + { + omitBZero = us::any_cast(parsedArgs["omitbzero"]); + } + if (parsedArgs.count("lowerkbound") || parsedArgs.count("kl")) + { + lower = us::any_cast(parsedArgs["lowerkbound"]); } - else if (fit_name == "IVIM" ) + + if (parsedArgs.count("upperkbound") || parsedArgs.count("ku")) { - MITK_INFO("DiffusionIVIMFit.Main") << "IVIM Fit not fully implemented yet. Aborting..."; - return EXIT_FAILURE; + upper = us::any_cast(parsedArgs["upperkbound"]); } - else + + if( !DPH::IsDiffusionWeightedImage( inputImage ) ) { - MITK_ERROR("DiffusionIVIMFit.Main") << "Unrecognized option: " << fit_name << ". Valid values [\"IVIM\", \"Kurtosis\"] \n Aborting... \n"; + MITK_ERROR("DiffusionIVIMFit.Input") << "No valid diffusion-weighted image provided, failed to load " << inFileName << " as DW Image. Aborting..."; return EXIT_FAILURE; - } + + +KurtosisMapComputation( inputImage, + out_prefix , + out_type, + maskPath, + omitBZero, + lower, + upper); + } diff --git a/Modules/IGTBase/include/mitkNavigationDataSet.h b/Modules/IGTBase/include/mitkNavigationDataSet.h index be1ab96b09..d5eec8f00d 100644 --- a/Modules/IGTBase/include/mitkNavigationDataSet.h +++ b/Modules/IGTBase/include/mitkNavigationDataSet.h @@ -1,171 +1,174 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef MITKNAVIGATIONDATASET_H_HEADER_INCLUDED_ #define MITKNAVIGATIONDATASET_H_HEADER_INCLUDED_ #include #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 >::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 >::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 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 virtual void SetRequestedRegionToLargestPossibleRegion( ) override; virtual bool RequestedRegionIsOutsideOfTheBufferedRegion( ) override; virtual bool VerifyRequestedRegion( ) override; virtual void SetRequestedRegion( const itk::DataObject *data ) override; /** * \brief This overrid is probably a little hacky. See Bug 19086. */ virtual 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 ); virtual ~NavigationDataSet( ); /** * \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 > 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/IGTBase/src/mitkNavigationDataSet.cpp b/Modules/IGTBase/src/mitkNavigationDataSet.cpp index 4424ec9fc1..2c5558397f 100644 --- a/Modules/IGTBase/src/mitkNavigationDataSet.cpp +++ b/Modules/IGTBase/src/mitkNavigationDataSet.cpp @@ -1,167 +1,190 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "mitkNavigationDataSet.h" +#include "mitkPointSet.h" +#include "mitkBaseRenderer.h" mitk::NavigationDataSet::NavigationDataSet( unsigned int numberOfTools ) : m_NavigationDataVectors(std::vector >()), m_NumberOfTools(numberOfTools) { } mitk::NavigationDataSet::~NavigationDataSet( ) { } bool mitk::NavigationDataSet::AddNavigationDatas( std::vector navigationDatas ) { // test if tool with given index exist if ( navigationDatas.size() != m_NumberOfTools ) { MITK_WARN("NavigationDataSet") << "Tried to add too many or too few navigation Datas to NavigationDataSet. " << m_NumberOfTools << " required, tried to add " << navigationDatas.size() << "."; return false; } // test for consistent timestamp if ( m_NavigationDataVectors.size() > 0) { for (std::vector::size_type i = 0; i < navigationDatas.size(); i++) if (navigationDatas[i]->GetIGTTimeStamp() <= m_NavigationDataVectors.back()[i]->GetIGTTimeStamp()) { MITK_WARN("NavigationDataSet") << "IGTTimeStamp of new NavigationData should be newer than timestamp of last NavigationData."; return false; } } m_NavigationDataVectors.push_back(navigationDatas); return true; } mitk::NavigationData::Pointer mitk::NavigationDataSet::GetNavigationDataForIndex( unsigned int index, unsigned int toolIndex ) const { if ( index >= m_NavigationDataVectors.size() ) { MITK_WARN("NavigationDataSet") << "There is no NavigationData available at index " << index << "."; return nullptr; } if ( toolIndex >= m_NavigationDataVectors.at(index).size() ) { MITK_WARN("NavigationDataSet") << "There is NavigatitionData available at index " << index << " for tool " << toolIndex << "."; return nullptr; } return m_NavigationDataVectors.at(index).at(toolIndex); } // Method not yet supported, code below compiles but delivers wrong results //mitk::NavigationData::Pointer mitk::NavigationDataSet::GetNavigationDataBeforeTimestamp( // mitk::NavigationData::TimeStampType timestamp, unsigned int toolIndex) const //{ // if ( toolIndex >= m_NavigationDataVectors.size() ) // { // MITK_WARN("NavigationDataSet") << "There is no tool with index " << toolIndex << "."; // return NULL; // } // // std::vector::const_iterator it; // // // iterate through all NavigationData objects of the given tool index // // till the timestamp of the NavigationData is greater then the given timestamp // for (it = m_NavigationDataVectors.at(toolIndex).begin(); // it != m_NavigationDataVectors.at(toolIndex).end(); ++it) // { // if ( (*it)->GetIGTTimeStamp() > timestamp) { break; } // } // // // first element was greater than timestamp -> return null // if ( it == m_NavigationDataVectors.at(toolIndex).begin() ) // { // MITK_WARN("NavigationDataSet") << "No NavigationData was recorded before given timestamp."; // return NULL; // } // // // return last element smaller than the given timestamp // return *(it-1); //} std::vector< mitk::NavigationData::Pointer > mitk::NavigationDataSet::GetDataStreamForTool(unsigned int toolIndex) { if (toolIndex >= m_NumberOfTools ) { MITK_WARN("NavigationDataSet") << "Invalid toolIndex: " << m_NumberOfTools << " Tools known, requested index " << toolIndex << ""; return std::vector(); } std::vector< mitk::NavigationData::Pointer > result; for(std::vector >::size_type i = 0; i < m_NavigationDataVectors.size(); i++) result.push_back(m_NavigationDataVectors[i][toolIndex]); return result; } std::vector< mitk::NavigationData::Pointer > mitk::NavigationDataSet::GetTimeStep(unsigned int index) const { return m_NavigationDataVectors[index]; } unsigned int mitk::NavigationDataSet::GetNumberOfTools() const { return m_NumberOfTools; } unsigned int mitk::NavigationDataSet::Size() const { return m_NavigationDataVectors.size(); } // ---> methods necessary for BaseData void mitk::NavigationDataSet::SetRequestedRegionToLargestPossibleRegion() { } bool mitk::NavigationDataSet::RequestedRegionIsOutsideOfTheBufferedRegion() { return false; } bool mitk::NavigationDataSet::VerifyRequestedRegion() { return true; } void mitk::NavigationDataSet::SetRequestedRegion(const DataObject * ) { } bool mitk::NavigationDataSet::IsEmpty() const { return (Size() == 0); } +void mitk::NavigationDataSet::ConvertNavigationDataToPointSet() const +{ + //iterate over all tools + for (unsigned int toolIndex = 0; toolIndex < this->GetNumberOfTools(); ++ toolIndex) + { + mitk::PointSet::Pointer _tempPointSet = mitk::PointSet::New(); + //iterate over all time steps + for (unsigned int time = 0; time < m_NavigationDataVectors.size(); time++) + { + _tempPointSet->InsertPoint(time,m_NavigationDataVectors[time][toolIndex]->GetPosition()); + MITK_DEBUG << m_NavigationDataVectors[time][toolIndex]->GetPosition() << " --- " << _tempPointSet->GetPoint(time); + } + mitk::DataNode::Pointer dn = mitk::DataNode::New(); + std::stringstream str; + str << "NavigationData Tool " << toolIndex; + dn->SetProperty("name", mitk::StringProperty::New(str.str())); + dn->SetData(_tempPointSet); + mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4"))->GetDataStorage()->Add(dn); + } +} + // <--- methods necessary for BaseData // ---> methods for Iterators mitk::NavigationDataSet::NavigationDataSetConstIterator mitk::NavigationDataSet::Begin() const { return m_NavigationDataVectors.cbegin(); } mitk::NavigationDataSet::NavigationDataSetConstIterator mitk::NavigationDataSet::End() const { return m_NavigationDataVectors.cend(); } diff --git a/Modules/ModuleList.cmake b/Modules/ModuleList.cmake index fe7e334497..afa09b7371 100644 --- a/Modules/ModuleList.cmake +++ b/Modules/ModuleList.cmake @@ -1,81 +1,81 @@ # The entries in the mitk_modules list must be # ordered according to their dependencies. set(mitk_modules Core CommandLine AppUtil DCMTesting RDF LegacyIO DataTypesExt - Overlays + Annotation LegacyGL AlgorithmsExt MapperExt DICOMReader DICOMReaderServices DICOMTesting SceneSerializationBase PlanarFigure ImageDenoising ImageExtraction LegacyAdaptors SceneSerialization Gizmo GraphAlgorithms Multilabel ImageStatistics ContourModel SurfaceInterpolation Segmentation PlanarFigureSegmentation OpenViewCore QtWidgets QtWidgetsExt C3js QmlItems SegmentationUI DiffusionImaging GPGPU OpenIGTLink IGTBase IGT CameraCalibration RigidRegistration RigidRegistrationUI DeformableRegistration DeformableRegistrationUI OpenCL OpenCVVideoSupport QtOverlays ToFHardware ToFProcessing ToFUI US USUI DicomUI Simulation Remeshing Python QtPython Persistence OpenIGTLinkUI IGTUI VtkShaders DicomRT RTUI IOExt XNAT TubeGraph BiophotonicsHardware Classification TumorInvasionAnalysis MatchPointRegistration MatchPointRegistrationUI BoundingShape ) if(MITK_ENABLE_PIC_READER) list(APPEND mitk_modules IpPicSupportIO) endif() diff --git a/Modules/Overlays/CMakeLists.txt b/Modules/Overlays/CMakeLists.txt deleted file mode 100644 index 9e84619f32..0000000000 --- a/Modules/Overlays/CMakeLists.txt +++ /dev/null @@ -1,8 +0,0 @@ -MITK_CREATE_MODULE(DEPENDS MitkCore - WARNINGS_AS_ERRORS -) - -# build tests? -if(BUILD_TESTING) - add_subdirectory(Testing) -ENDIF() diff --git a/Modules/Overlays/Documentation/doxygen/OverlaysModule.dox b/Modules/Overlays/Documentation/doxygen/OverlaysModule.dox deleted file mode 100644 index 282f67eed5..0000000000 --- a/Modules/Overlays/Documentation/doxygen/OverlaysModule.dox +++ /dev/null @@ -1,82 +0,0 @@ -/** -\page OverlaysModulePage Overlays and Annotations Module - -\tableofcontents - -\section OverlaysModulePage_Introduction Overlays and Annotations - -The overlays in MITK are a simple way to display additional information on the render windows. A class, deriving from mitk::Overlay represents an arbitrary -2D or 3D object that can be rendered as an overlay. This can for example be used for the annotation of 3D points or to overlay despriptions in the window corners. -The mitk::OverlayManager is used to add the overlays to the renderwindows, updating them and manage the respective layout managers. -The following features are implemented in this framework. -
    -
  1. Definition of graphical elements that can be displayed in the render windows. -
  2. It is possible to manage multiple elements in each window. -
  3. A single Overlay can be rendered on any number of available render windows. -
  4. 2D and 3D textelements are already defined in the Overlay module and are using VTK to create custom annotations. -
  5. The mitk::BaseLayouter interface enables the implementation of layout managers, to handle the placement of the overlays. -
- -\section OverlaysModulePage_ArchitectureSection General Architecture -\section OverlaysModulePage_UsageSection Usage of Predefined Overlays - -\subsection OverlaysModulePage_TextWidget2DUsageSubsection mitkTextOverlay2D -This exemplary overlay can render UTF-8 encoded text as a 2D Overlay. The Overlay2DLayouter can be used to automatically place a group of overlays to a -specific corner. -\snippet OverlayExample.cpp TextOverlay2D -\snippet OverlayExample.cpp SetLayouterToOverlay - -\subsection OverlaysModulePage_TextWidget3DUsageSubsection mitkTextOverlay3D -This overlay displays labels in 3D coordinates. The labels always face the camera. - -\snippet OverlayExample.cpp TextOverlay3D - -\subsection OverlaysModulePage_NotManagedSubsection Manually Managed Overlays -In order to integrate an Overlay into an mitk::Mapper, it is advised not to use the OverlayManager but to manually manage the Overlay. -To do so, the update methods of the overlays have to be called manually before the start of each rendering procedure. It must only be called if the Properties have changed or if your custom overlay implements its own rendering mechanism. - -\section OverlaysModulePage_CustomOverlaySection Implement a Custom Overlay - -A new custom Overlay should derive from mitkOverlay or one of the later mentioned subclasses VtkOverlay2D oder VtkOverlay3D. There should always be an implementation for the methods -AddOverlay, RemoveOverlay and Update Overlay. -UpdateOverlay is the procedure that is called in each rendering step. If the Overlay is rendered by VTK, this method only applies the properties to the representation. -If the custom Overlay requires additional properties, they should be made accessible by getters and setters for a better usability: -\code -void mitk::VtkOverlay3D::SetPosition3D(Point3D position3D, mitk::BaseRenderer *renderer) -{ - mitk::Point3dProperty::Pointer position3dProperty = mitk::Point3dProperty::New(position3D); - SetProperty("Position3D", position3dProperty,renderer); -} - -mitk::Point3D mitk::VtkOverlay3D::GetPosition3D(mitk::BaseRenderer *renderer) -{ - mitk::Point3D position3D; - GetPropertyValue("Position3D", position3D, renderer); - return position3D; -} -\endcode - -\subsection OverlaysModulePage_CustomVTK2DOverlaySubsection VTK 2D Overlay - -VTK based overlays which are meant to be displayed in 2D over the render window should derive from the mitk::VtkOverlay2D. -The mitk::VtkOverlay2D is a subclass of Vtk::Overlay, that uses VTK to render the overlay. This class creates the Overlay representation as a vtkActor2D, and is very easy to implement -because only UpdateVtkOverlay2D and GetVtkActor2D have to be implemented. The add, update and remove methods are implemented in the superclasses. -UpdateVtkOverlay2D only needs to apply the specific properties and GetVtkActor2D simply returns the created vtkActor. - -\subsection OverlaysModulePage_CustomVTK3DOverlaySubsection VTK 3D Overlay - -The mitkVtkOverlay3D works just like mitkVtkOverlay2D, but it is designed for arbitrary 3D objects which derive from vtkProp, - -\section OverlaysModulePage_CustomLayouterSection Implement a Custom Layouter - -A Layouter is used for an automatic positioning of a group of Overlays and is derived from mitkBaseLayouter. Every Layouter that manages a group of Layouts should have a unique identifier -which is used to register the Layouter in the OverlayManager. A Layouter is always uniquely defined by the identifier and one BaseRenderer. Before a Layouter can be used by the -OverlayManager it has to be added, using the AddLayouter Method. An Overlay can then be added to a Layout as follows: - -\code -overlayManager->SetLayouter(textOverlay.GetPointer(),mitk::Overlay2DLayouter::STANDARD_2D_TOPLEFT,axialRenderer); -\endcode - -A new Layouter has to implement PrepareLayout which should parse the internal Overlay list and set their position as required. - -*/ diff --git a/Modules/Overlays/Testing/CMakeLists.txt b/Modules/Overlays/Testing/CMakeLists.txt deleted file mode 100644 index 142632d517..0000000000 --- a/Modules/Overlays/Testing/CMakeLists.txt +++ /dev/null @@ -1,40 +0,0 @@ -MITK_CREATE_MODULE_TESTS() -if(TARGET ${TESTDRIVER}) - mitk_use_modules(TARGET ${TESTDRIVER} PACKAGES VTK|vtkTestingRendering) - - if(MITK_ENABLE_RENDERING_TESTING) ### since the rendering test's do not run in ubuntu, yet, we build them only for other systems or if the user explicitly sets the variable MITK_ENABLE_RENDERING_TESTING - - mitkAddCustomModuleTest(mitkLabelOverlay3DRendering2DTest mitkLabelOverlay3DRendering2DTest #OverlayTest - -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/mitkLabelOverlay3DRendering2DTest.png #corresponding reference screenshot - ) - - #mitkAddCustomModuleTest(mitkLabelOverlay3DRendering3DTest mitkLabelOverlay3DRendering3DTest #OverlayTest - # -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/mitkLabelOverlay3DRendering3DTest.png #corresponding reference screenshot - #) - - mitkAddCustomModuleTest(mitkTextOverlay2DRenderingTest_ball mitkTextOverlay2DRenderingTest #OverlayTest - ${MITK_DATA_DIR}/ball.stl #input image to load in data storage - -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/mitkTextOverlay2DRenderingTest_ball.png #corresponding reference screenshot - ) - - #mitkAddCustomModuleTest(mitkTextOverlay2DLayouterRenderingTest_ball mitkTextOverlay2DLayouterRenderingTest #OverlayTest - # ${MITK_DATA_DIR}/ball.stl #input image to load in data storage - # -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/mitkTextOverlay2DLayouterRenderingTest_ball.png #corresponding reference screenshot - #) - - mitkAddCustomModuleTest(mitkTextOverlay3DRendering2DTest_ball mitkTextOverlay3DRendering2DTest #OverlayTest - ${MITK_DATA_DIR}/ball.stl #input image to load in data storage - -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/mitkTextOverlay3DRendering2DTest_ball.png #corresponding reference screenshot - ) - - mitkAddCustomModuleTest(mitkTextOverlay3DRendering3DTest_ball mitkTextOverlay3DRendering3DTest #OverlayTest - ${MITK_DATA_DIR}/ball.stl #input image to load in data storage - -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/mitkTextOverlay3DRendering3DTest_ball.png #corresponding reference screenshot - ) - - mitkAddCustomModuleTest(mitkTextOverlay3DColorRenderingTest_ball mitkTextOverlay3DColorRenderingTest #OverlayTest - ${MITK_DATA_DIR}/ball.stl #input image to load in data storage - -V ${MITK_DATA_DIR}/RenderingTestData/ReferenceScreenshots/mitkTextOverlay3DColorRenderingTest_ball.png #corresponding reference screenshot - ) - endif() -endif() # TARGET ${TESTDRIVER} diff --git a/Modules/Overlays/Testing/files.cmake b/Modules/Overlays/Testing/files.cmake deleted file mode 100644 index 1ed23e2999..0000000000 --- a/Modules/Overlays/Testing/files.cmake +++ /dev/null @@ -1,9 +0,0 @@ -set(MODULE_CUSTOM_TESTS - mitkLabelOverlay3DRendering2DTest.cpp - mitkLabelOverlay3DRendering3DTest.cpp - mitkTextOverlay2DRenderingTest.cpp - mitkTextOverlay2DLayouterRenderingTest.cpp - mitkTextOverlay3DRendering2DTest.cpp - mitkTextOverlay3DRendering3DTest.cpp - mitkTextOverlay3DColorRenderingTest.cpp -) diff --git a/Modules/Overlays/Testing/mitkLabelOverlay3DRendering2DTest.cpp b/Modules/Overlays/Testing/mitkLabelOverlay3DRendering2DTest.cpp deleted file mode 100644 index 86476a1907..0000000000 --- a/Modules/Overlays/Testing/mitkLabelOverlay3DRendering2DTest.cpp +++ /dev/null @@ -1,91 +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. - -===================================================================*/ - -// MITK -#include "mitkRenderingTestHelper.h" -#include "mitkTestingMacros.h" -#include -#include - -// VTK -#include "mitkLabelOverlay3D.h" -#include "mitkOverlay2DLayouter.h" -#include "mitkTextOverlay2D.h" -#include - -int mitkLabelOverlay3DRendering2DTest(int argc, char *argv[]) -{ - // load all arguments into a datastorage, take last argument as reference rendering - // setup a renderwindow of fixed size X*Y - // render the datastorage - // compare rendering to reference image - MITK_TEST_BEGIN("mitkLabelOverlay3DRendering2DTest") - - mitk::RenderingTestHelper renderingHelper(640, 480, argc, argv); - // renderingHelper.SetAutomaticallyCloseRenderWindow(false); - - // renderingHelper.SetAutomaticallyCloseRenderWindow(false); - mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(renderingHelper.GetVtkRenderWindow()); - mitk::OverlayManager::Pointer OverlayManager = mitk::OverlayManager::New(); - renderer->SetOverlayManager(OverlayManager); - - mitk::PointSet::Pointer pointset = mitk::PointSet::New(); - mitk::LabelOverlay3D::Pointer label3d = mitk::LabelOverlay3D::New(); - mitk::Point3D offset; - offset[0] = .5; - offset[1] = .5; - offset[2] = .5; - - std::vector labels; - int idx = 0; - for (int i = -10; i < 10; i += 4) - { - for (int j = -10; j < 10; j += 4) - { - mitk::Point3D point; - point[0] = i; - point[1] = j; - point[2] = (i * j) / 10; - pointset->InsertPoint(idx++, point); - labels.push_back("test"); - } - } - - label3d->SetLabelCoordinates(pointset); - label3d->SetLabelVector(labels); - label3d->SetOffsetVector(offset); - OverlayManager->AddOverlay(label3d.GetPointer()); - - mitk::DataNode::Pointer datanode = mitk::DataNode::New(); - datanode->SetData(pointset); - datanode->SetName("pointSet"); - renderingHelper.AddNodeToStorage(datanode); - renderingHelper.Render(); - - //### Usage of CompareRenderWindowAgainstReference: See docu of mitkRrenderingTestHelper - MITK_TEST_CONDITION(renderingHelper.CompareRenderWindowAgainstReference(argc, argv, 200.0) == true, - "CompareRenderWindowAgainstReference test result positive?"); - - // use this to generate a reference screenshot or save the file: - bool generateReferenceScreenshot = false; - if (generateReferenceScreenshot) - { - renderingHelper.SaveReferenceScreenShot( - "/home/christoph/Pictures/RenderingTestData/mitkLabelOverlay3DRendering2DTest.png"); - } - - MITK_TEST_END(); -} diff --git a/Modules/Overlays/Testing/mitkLabelOverlay3DRendering3DTest.cpp b/Modules/Overlays/Testing/mitkLabelOverlay3DRendering3DTest.cpp deleted file mode 100644 index 1c0658c7dc..0000000000 --- a/Modules/Overlays/Testing/mitkLabelOverlay3DRendering3DTest.cpp +++ /dev/null @@ -1,93 +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. - -===================================================================*/ - -// MITK -#include "mitkRenderingTestHelper.h" -#include "mitkTestingMacros.h" -#include -#include - -// VTK -#include "mitkLabelOverlay3D.h" -#include "mitkOverlay2DLayouter.h" -#include "mitkTextOverlay2D.h" -#include - -int mitkLabelOverlay3DRendering3DTest(int argc, char *argv[]) -{ - // load all arguments into a datastorage, take last argument as reference rendering - // setup a renderwindow of fixed size X*Y - // render the datastorage - // compare rendering to reference image - MITK_TEST_BEGIN("mitkLabelOverlay3DRendering3DTest") - - mitk::RenderingTestHelper renderingHelper(640, 480, argc, argv); - // renderingHelper.SetAutomaticallyCloseRenderWindow(false); - - renderingHelper.SetMapperIDToRender3D(); - // renderingHelper.SetAutomaticallyCloseRenderWindow(false); - - mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(renderingHelper.GetVtkRenderWindow()); - mitk::OverlayManager::Pointer OverlayManager = mitk::OverlayManager::New(); - renderer->SetOverlayManager(OverlayManager); - - mitk::PointSet::Pointer ps = mitk::PointSet::New(); - mitk::LabelOverlay3D::Pointer to3d = mitk::LabelOverlay3D::New(); - mitk::Point3D offset; - offset[0] = .5; - offset[1] = .5; - offset[2] = .5; - std::vector labels; - int idx = 0; - for (int i = -10; i < 10; i += 2) - { - for (int j = -10; j < 10; j += 2) - { - mitk::Point3D point; - point[0] = i; - point[1] = j; - point[2] = (i * j) / 10 - 30; - ps->InsertPoint(idx++, point); - labels.push_back("test"); - } - } - - to3d->SetLabelCoordinates(ps); - to3d->SetLabelVector(labels); - to3d->SetOffsetVector(offset); - OverlayManager->AddOverlay(to3d.GetPointer()); - - mitk::DataNode::Pointer dn = mitk::DataNode::New(); - dn->SetData(ps); - dn->SetName("pointSet"); - renderingHelper.AddNodeToStorage(dn); - - renderingHelper.Render(); - - //### Usage of CompareRenderWindowAgainstReference: See docu of mitkRrenderingTestHelper - MITK_TEST_CONDITION(renderingHelper.CompareRenderWindowAgainstReference(argc, argv) == true, - "CompareRenderWindowAgainstReference test result positive?"); - - // use this to generate a reference screenshot or save the file: - bool generateReferenceScreenshot = false; - if (generateReferenceScreenshot) - { - renderingHelper.SaveReferenceScreenShot( - "/home/christoph/Pictures/RenderingTestData/mitkLabelOverlay3DRendering3DTest.png"); - } - - MITK_TEST_END(); -} diff --git a/Modules/Overlays/Testing/mitkTextOverlay2DLayouterRenderingTest.cpp b/Modules/Overlays/Testing/mitkTextOverlay2DLayouterRenderingTest.cpp deleted file mode 100644 index cc3931a9a6..0000000000 --- a/Modules/Overlays/Testing/mitkTextOverlay2DLayouterRenderingTest.cpp +++ /dev/null @@ -1,137 +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. - -===================================================================*/ - -// MITK -#include "mitkRenderingTestHelper.h" -#include "mitkTestingMacros.h" -#include - -// VTK -#include "mitkOverlay2DLayouter.h" -#include "mitkTextOverlay2D.h" -#include - -void createTextOverlayWithLayouter(mitk::OverlayManager::Pointer OverlayManager, - const std::string &layouter, - mitk::BaseRenderer *renderer, - int fontsize, - float red, - float green, - float blue, - std::string text) -{ - // Create a textOverlay2D - mitk::TextOverlay2D::Pointer textOverlay = mitk::TextOverlay2D::New(); - - textOverlay->SetText(text); - textOverlay->SetFontSize(fontsize); - textOverlay->SetColor(red, green, blue); - textOverlay->SetOpacity(1); - - // Position is committed as a Point2D Property - mitk::Point2D pos; - pos[0] = 0, pos[1] = 0; - textOverlay->SetPosition2D(pos); - OverlayManager->AddOverlay(textOverlay.GetPointer()); - OverlayManager->SetLayouter(textOverlay.GetPointer(), layouter, renderer); -} - -int mitkTextOverlay2DLayouterRenderingTest(int argc, char *argv[]) -{ - // load all arguments into a datastorage, take last argument as reference rendering - // setup a renderwindow of fixed size X*Y - // render the datastorage - // compare rendering to reference image - MITK_TEST_BEGIN("mitkTextOverlay2DLayouterRenderingTest") - - mitk::RenderingTestHelper renderingHelper(640, 480, argc, argv); - // renderingHelper.SetAutomaticallyCloseRenderWindow(false); - - mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(renderingHelper.GetVtkRenderWindow()); - mitk::OverlayManager::Pointer OverlayManager = mitk::OverlayManager::New(); - renderer->SetOverlayManager(OverlayManager); - - OverlayManager->AddLayouter( - mitk::Overlay2DLayouter::CreateLayouter(mitk::Overlay2DLayouter::STANDARD_2D_TOP(), renderer).GetPointer()); - OverlayManager->AddLayouter( - mitk::Overlay2DLayouter::CreateLayouter(mitk::Overlay2DLayouter::STANDARD_2D_TOPLEFT(), renderer).GetPointer()); - OverlayManager->AddLayouter( - mitk::Overlay2DLayouter::CreateLayouter(mitk::Overlay2DLayouter::STANDARD_2D_TOPRIGHT(), renderer).GetPointer()); - OverlayManager->AddLayouter( - mitk::Overlay2DLayouter::CreateLayouter(mitk::Overlay2DLayouter::STANDARD_2D_BOTTOM(), renderer).GetPointer()); - OverlayManager->AddLayouter( - mitk::Overlay2DLayouter::CreateLayouter(mitk::Overlay2DLayouter::STANDARD_2D_BOTTOMLEFT(), renderer).GetPointer()); - OverlayManager->AddLayouter( - mitk::Overlay2DLayouter::CreateLayouter(mitk::Overlay2DLayouter::STANDARD_2D_BOTTOMRIGHT(), renderer).GetPointer()); - - createTextOverlayWithLayouter( - OverlayManager, mitk::Overlay2DLayouter::STANDARD_2D_TOP(), renderer, 15, 1, 1, 1, "TOP_1"); - createTextOverlayWithLayouter( - OverlayManager, mitk::Overlay2DLayouter::STANDARD_2D_TOP(), renderer, 15, 1, 1, 1, "TOP_2"); - createTextOverlayWithLayouter( - OverlayManager, mitk::Overlay2DLayouter::STANDARD_2D_TOP(), renderer, 20, 1, 1, 1, "TOP_3"); - - createTextOverlayWithLayouter( - OverlayManager, mitk::Overlay2DLayouter::STANDARD_2D_TOPLEFT(), renderer, 15, 1, 1, 1, "TOPLEFT_1"); - createTextOverlayWithLayouter( - OverlayManager, mitk::Overlay2DLayouter::STANDARD_2D_TOPLEFT(), renderer, 20, 1, 1, 1, "TOPLEFT_2"); - createTextOverlayWithLayouter( - OverlayManager, mitk::Overlay2DLayouter::STANDARD_2D_TOPLEFT(), renderer, 15, 1, 1, 1, "TOPLEFT_3"); - - createTextOverlayWithLayouter( - OverlayManager, mitk::Overlay2DLayouter::STANDARD_2D_TOPRIGHT(), renderer, 20, 1, 1, 1, "TOPRIGHT_1"); - createTextOverlayWithLayouter( - OverlayManager, mitk::Overlay2DLayouter::STANDARD_2D_TOPRIGHT(), renderer, 20, 1, 1, 1, "TOPRIGHT_2"); - createTextOverlayWithLayouter( - OverlayManager, mitk::Overlay2DLayouter::STANDARD_2D_TOPRIGHT(), renderer, 15, 1, 1, 1, "TOPRIGHT_3"); - - createTextOverlayWithLayouter( - OverlayManager, mitk::Overlay2DLayouter::STANDARD_2D_BOTTOM(), renderer, 15, 1, 1, 1, "BOTTOM_1"); - createTextOverlayWithLayouter( - OverlayManager, mitk::Overlay2DLayouter::STANDARD_2D_BOTTOM(), renderer, 15, 1, 1, 1, "BOTTOM_2"); - createTextOverlayWithLayouter( - OverlayManager, mitk::Overlay2DLayouter::STANDARD_2D_BOTTOM(), renderer, 20, 1, 1, 1, "BOTTOM_3"); - - createTextOverlayWithLayouter( - OverlayManager, mitk::Overlay2DLayouter::STANDARD_2D_BOTTOMLEFT(), renderer, 15, 1, 1, 1, "BOTTOMLEFT_1"); - createTextOverlayWithLayouter( - OverlayManager, mitk::Overlay2DLayouter::STANDARD_2D_BOTTOMLEFT(), renderer, 20, 1, 1, 1, "BOTTOMLEFT_2"); - createTextOverlayWithLayouter( - OverlayManager, mitk::Overlay2DLayouter::STANDARD_2D_BOTTOMLEFT(), renderer, 15, 1, 1, 1, "BOTTOMLEFT_3"); - - createTextOverlayWithLayouter( - OverlayManager, mitk::Overlay2DLayouter::STANDARD_2D_BOTTOMRIGHT(), renderer, 20, 1, 1, 1, "BOTTOMRIGHT_1"); - createTextOverlayWithLayouter( - OverlayManager, mitk::Overlay2DLayouter::STANDARD_2D_BOTTOMRIGHT(), renderer, 20, 1, 1, 1, "BOTTOMRIGHT_2"); - createTextOverlayWithLayouter( - OverlayManager, mitk::Overlay2DLayouter::STANDARD_2D_BOTTOMRIGHT(), renderer, 15, 1, 1, 1, "BOTTOMRIGHT_3"); - - renderingHelper.Render(); - - // use this to generate a reference screenshot or save the file: - bool generateReferenceScreenshot = false; - if (generateReferenceScreenshot) - { - renderingHelper.SaveReferenceScreenShot( - "/home/christoph/Pictures/RenderingTestData/mitkTextOverlay2DLayouterRenderingTest_ball.png"); - } - - //### Usage of CompareRenderWindowAgainstReference: See docu of mitkRrenderingTestHelper - MITK_TEST_CONDITION(renderingHelper.CompareRenderWindowAgainstReference(argc, argv) == true, - "CompareRenderWindowAgainstReference test result positive?"); - - MITK_TEST_END(); -} diff --git a/Modules/Overlays/Testing/mitkTextOverlay2DRenderingTest.cpp b/Modules/Overlays/Testing/mitkTextOverlay2DRenderingTest.cpp deleted file mode 100644 index 3c188cf51e..0000000000 --- a/Modules/Overlays/Testing/mitkTextOverlay2DRenderingTest.cpp +++ /dev/null @@ -1,81 +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. - -===================================================================*/ - -// MITK -#include "mitkRenderingTestHelper.h" -#include "mitkTestingMacros.h" -#include - -// VTK -#include "mitkOverlay2DLayouter.h" -#include "mitkTextOverlay2D.h" -#include - -mitk::TextOverlay2D::Pointer createTextOverlay( - int fontsize, float red, float green, float blue, int posX, int posY, std::string text) -{ - // Create a textOverlay2D - mitk::TextOverlay2D::Pointer textOverlay = mitk::TextOverlay2D::New(); - - textOverlay->SetText(text); - textOverlay->SetFontSize(fontsize); - textOverlay->SetColor(red, green, blue); - textOverlay->SetOpacity(1); - - // Position is committed as a Point2D Property - mitk::Point2D pos; - pos[0] = posX, pos[1] = posY; - textOverlay->SetPosition2D(pos); - return textOverlay; -} - -int mitkTextOverlay2DRenderingTest(int argc, char *argv[]) -{ - // load all arguments into a datastorage, take last argument as reference rendering - // setup a renderwindow of fixed size X*Y - // render the datastorage - // compare rendering to reference image - MITK_TEST_BEGIN("mitkTextOverlay2DRenderingTest") - - mitk::RenderingTestHelper renderingHelper(640, 480, argc, argv); - // renderingHelper.SetAutomaticallyCloseRenderWindow(false); - - mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(renderingHelper.GetVtkRenderWindow()); - mitk::OverlayManager::Pointer OverlayManager = mitk::OverlayManager::New(); - renderer->SetOverlayManager(OverlayManager); - - // Add the overlay to the overlayManager. It is added to all registered renderers automaticly - OverlayManager->AddOverlay(createTextOverlay(20, 1, 0, 0, 200, 400, "Test1").GetPointer()); - OverlayManager->AddOverlay(createTextOverlay(30, 0, 1, 0, 400, 400, "Test2").GetPointer()); - OverlayManager->AddOverlay(createTextOverlay(15, 0, 0, 1, 400, 200, "Test3").GetPointer()); - OverlayManager->AddOverlay(createTextOverlay(10, 1, 0, 0, 20, 200, "Test4").GetPointer()); - - renderingHelper.Render(); - - // use this to generate a reference screenshot or save the file: - bool generateReferenceScreenshot = false; - if (generateReferenceScreenshot) - { - renderingHelper.SaveReferenceScreenShot( - "/home/christoph/Pictures/RenderingTestData/mitkTextOverlay2DRenderingTest_ball.png"); - } - - //### Usage of CompareRenderWindowAgainstReference: See docu of mitkRrenderingTestHelper - MITK_TEST_CONDITION(renderingHelper.CompareRenderWindowAgainstReference(argc, argv) == true, - "CompareRenderWindowAgainstReference test result positive?"); - - MITK_TEST_END(); -} diff --git a/Modules/Overlays/Testing/mitkTextOverlay2DSymbolsRenderingTest.cpp b/Modules/Overlays/Testing/mitkTextOverlay2DSymbolsRenderingTest.cpp deleted file mode 100644 index 5b332e5956..0000000000 --- a/Modules/Overlays/Testing/mitkTextOverlay2DSymbolsRenderingTest.cpp +++ /dev/null @@ -1,80 +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. - -===================================================================*/ - -// MITK -#include "mitkRenderingTestHelper.h" -#include "mitkTestingMacros.h" -#include - -// VTK -#include "mitkOverlay2DLayouter.h" -#include "mitkTextOverlay2D.h" -#include - -mitk::TextOverlay2D::Pointer createTextOverlaySymbols( - int fontsize, float red, float green, float blue, int posX, int posY, std::string text) -{ - // Create a textOverlay2D - mitk::TextOverlay2D::Pointer textOverlay = mitk::TextOverlay2D::New(); - - textOverlay->SetText(text); - textOverlay->SetFontSize(fontsize); - textOverlay->SetColor(red, green, blue); - textOverlay->SetOpacity(1); - - // Position is committed as a Point2D Property - mitk::Point2D pos; - pos[0] = posX, pos[1] = posY; - textOverlay->SetPosition2D(pos); - return textOverlay; -} - -int mitkTextOverlay2DSymbolsRenderingTest(int argc, char *argv[]) -{ - // load all arguments into a datastorage, take last argument as reference rendering - // setup a renderwindow of fixed size X*Y - // render the datastorage - // compare rendering to reference image - MITK_TEST_BEGIN("mitkTextOverlay2DSymbolsRenderingTest") - - mitk::RenderingTestHelper renderingHelper(640, 480, argc, argv); - renderingHelper.SetAutomaticallyCloseRenderWindow(false); - - mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(renderingHelper.GetVtkRenderWindow()); - mitk::OverlayManager::Pointer OverlayManager = mitk::OverlayManager::New(); - renderer->SetOverlayManager(OverlayManager); - - // Add the overlay to the overlayManager. It is added to all registered renderers automaticly - OverlayManager->AddOverlay(createTextOverlaySymbols(30, 1, 0, 0, 100, 400, "ä ö ü ß Ö Ä Ü").GetPointer()); - OverlayManager->AddOverlay(createTextOverlaySymbols(30, 0, 1, 0, 400, 400, "Ç æ Œ Æ").GetPointer()); - OverlayManager->AddOverlay(createTextOverlaySymbols(30, 0, 0, 1, 400, 200, "¼ ₧ ø £ Ø").GetPointer()); - OverlayManager->AddOverlay(createTextOverlaySymbols(30, 1, 0, 0, 100, 200, "Δ ξ Ψ Ω").GetPointer()); - - renderingHelper.Render(); - - // use this to generate a reference screenshot or save the file: - bool generateReferenceScreenshot = false; - if (generateReferenceScreenshot) - { - renderingHelper.SaveReferenceScreenShot("/home/christoph/Pictures/RenderingTestData/output.png"); - } - - //### Usage of CompareRenderWindowAgainstReference: See docu of mitkRrenderingTestHelper - MITK_TEST_CONDITION(renderingHelper.CompareRenderWindowAgainstReference(argc, argv) == true, - "CompareRenderWindowAgainstReference test result positive?"); - - MITK_TEST_END(); -} diff --git a/Modules/Overlays/Testing/mitkTextOverlay3DColorRenderingTest.cpp b/Modules/Overlays/Testing/mitkTextOverlay3DColorRenderingTest.cpp deleted file mode 100644 index 43ca0ceb42..0000000000 --- a/Modules/Overlays/Testing/mitkTextOverlay3DColorRenderingTest.cpp +++ /dev/null @@ -1,96 +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. - -===================================================================*/ - -// MITK -#include "mitkRenderingTestHelper.h" -#include "mitkTestingMacros.h" -#include - -// VTK -#include "mitkTextOverlay3D.h" -#include -#include - -int mitkTextOverlay3DColorRenderingTest(int argc, char *argv[]) -{ - // load all arguments into a datastorage, take last argument as reference rendering - // setup a renderwindow of fixed size X*Y - // render the datastorage - // compare rendering to reference image - MITK_TEST_BEGIN("mitkTextOverlay3DColorRenderingTest") - - mitk::RenderingTestHelper renderingHelper(640, 480, argc, argv); - // renderingHelper.SetAutomaticallyCloseRenderWindow(false); - - renderingHelper.SetMapperIDToRender3D(); - - mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(renderingHelper.GetVtkRenderWindow()); - mitk::OverlayManager::Pointer overlayManager = mitk::OverlayManager::New(); - renderer->SetOverlayManager(overlayManager); - - mitk::PointSet::Pointer pointset = mitk::PointSet::New(); - - // This vector is used to define an offset for the annotations, in order to show them with a margin to the actual - // coordinate. - mitk::Point3D offset; - offset[0] = .5; - offset[1] = .5; - offset[2] = .5; - - // Just a loop to create some points - for (int i = 0; i < 5; i++) - { - // To each point, a TextOverlay3D is created - mitk::TextOverlay3D::Pointer textOverlay3D = mitk::TextOverlay3D::New(); - mitk::Point3D point; - point[0] = i * 2; - point[1] = i * 3; - point[2] = -i * 5; - pointset->InsertPoint(i, point); - textOverlay3D->SetText("A Point"); - textOverlay3D->SetColor(1, 0, 0); - textOverlay3D->SetFontSize(1); - - // The Position is set to the point coordinate to create an annotation to the point in the PointSet. - textOverlay3D->SetPosition3D(point); - - // move the annotation away from the actual point - textOverlay3D->SetOffsetVector(offset); - - overlayManager->AddOverlay(textOverlay3D.GetPointer()); - } - - // also show the created pointset - mitk::DataNode::Pointer datanode = mitk::DataNode::New(); - datanode->SetData(pointset); - datanode->SetName("pointSet"); - datanode->SetProperty("pointsize", mitk::FloatProperty::New(2.0)); - renderingHelper.AddNodeToStorage(datanode); - - // use this to generate a reference screenshot or save the file: - bool generateReferenceScreenshot = false; - if (generateReferenceScreenshot) - { - renderingHelper.SaveReferenceScreenShot( - "/home/christoph/Pictures/RenderingTestData/mitkTextOverlay3DColorRenderingTest_ball.png"); - } - - //### Usage of CompareRenderWindowAgainstReference: See docu of mitkRrenderingTestHelper - MITK_TEST_CONDITION(renderingHelper.CompareRenderWindowAgainstReference(argc, argv) == true, - "CompareRenderWindowAgainstReference test result positive?"); - - MITK_TEST_END(); -} diff --git a/Modules/Overlays/Testing/mitkTextOverlay3DRendering2DTest.cpp b/Modules/Overlays/Testing/mitkTextOverlay3DRendering2DTest.cpp deleted file mode 100644 index fb52464333..0000000000 --- a/Modules/Overlays/Testing/mitkTextOverlay3DRendering2DTest.cpp +++ /dev/null @@ -1,92 +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. - -===================================================================*/ - -// MITK -#include "mitkRenderingTestHelper.h" -#include "mitkTestingMacros.h" -#include - -// VTK -#include "mitkTextOverlay3D.h" -#include -#include - -int mitkTextOverlay3DRendering2DTest(int argc, char *argv[]) -{ - // load all arguments into a datastorage, take last argument as reference rendering - // setup a renderwindow of fixed size X*Y - // render the datastorage - // compare rendering to reference image - MITK_TEST_BEGIN("mitkTextOverlay3DRendering2DTest") - - mitk::RenderingTestHelper renderingHelper(640, 480, argc, argv); - // renderingHelper.SetAutomaticallyCloseRenderWindow(false); - - mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(renderingHelper.GetVtkRenderWindow()); - mitk::OverlayManager::Pointer overlayManager = mitk::OverlayManager::New(); - renderer->SetOverlayManager(overlayManager); - - mitk::PointSet::Pointer pointset = mitk::PointSet::New(); - - // This vector is used to define an offset for the annotations, in order to show them with a margin to the actual - // coordinate. - mitk::Point3D offset; - offset[0] = .5; - offset[1] = .5; - offset[2] = .5; - - // Just a loop to create some points - for (int i = 0; i < 5; i++) - { - // To each point, a TextOverlay3D is created - mitk::TextOverlay3D::Pointer textOverlay3D = mitk::TextOverlay3D::New(); - mitk::Point3D point; - point[0] = i * 2; - point[1] = i * 3; - point[2] = -i * 5; - pointset->InsertPoint(i, point); - textOverlay3D->SetText("A Point"); - textOverlay3D->SetFontSize(1); - - // The Position is set to the point coordinate to create an annotation to the point in the PointSet. - textOverlay3D->SetPosition3D(point); - - // move the annotation away from the actual point - textOverlay3D->SetOffsetVector(offset); - - overlayManager->AddOverlay(textOverlay3D.GetPointer()); - } - - // also show the created pointset - mitk::DataNode::Pointer datanode = mitk::DataNode::New(); - datanode->SetData(pointset); - datanode->SetName("pointSet"); - renderingHelper.AddNodeToStorage(datanode); - renderingHelper.Render(); - - // use this to generate a reference screenshot or save the file: - bool generateReferenceScreenshot = false; - if (generateReferenceScreenshot) - { - renderingHelper.SaveReferenceScreenShot("d:/tmp/mitkTextOverlay3DRendering2DTest_ball.png"); - } - - //### Usage of CompareRenderWindowAgainstReference: See docu of mitkRrenderingTestHelper - MITK_TEST_CONDITION(renderingHelper.CompareRenderWindowAgainstReference(argc, argv) == true, - "CompareRenderWindowAgainstReference test result positive?"); - - MITK_TEST_END(); -} diff --git a/Modules/Overlays/Testing/mitkTextOverlay3DRendering3DTest.cpp b/Modules/Overlays/Testing/mitkTextOverlay3DRendering3DTest.cpp deleted file mode 100644 index ce58c74964..0000000000 --- a/Modules/Overlays/Testing/mitkTextOverlay3DRendering3DTest.cpp +++ /dev/null @@ -1,95 +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. - -===================================================================*/ - -// MITK -#include "mitkRenderingTestHelper.h" -#include "mitkTestingMacros.h" -#include - -// VTK -#include "mitkTextOverlay3D.h" -#include -#include - -int mitkTextOverlay3DRendering3DTest(int argc, char *argv[]) -{ - // load all arguments into a datastorage, take last argument as reference rendering - // setup a renderwindow of fixed size X*Y - // render the datastorage - // compare rendering to reference image - MITK_TEST_BEGIN("mitkTextOverlay3DRendering3DTest") - - mitk::RenderingTestHelper renderingHelper(640, 480, argc, argv); - // renderingHelper.SetAutomaticallyCloseRenderWindow(false); - - renderingHelper.SetMapperIDToRender3D(); - - mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(renderingHelper.GetVtkRenderWindow()); - mitk::OverlayManager::Pointer overlayManager = mitk::OverlayManager::New(); - renderer->SetOverlayManager(overlayManager); - - mitk::PointSet::Pointer pointset = mitk::PointSet::New(); - - // This vector is used to define an offset for the annotations, in order to show them with a margin to the actual - // coordinate. - mitk::Point3D offset; - offset[0] = .5; - offset[1] = .5; - offset[2] = .5; - - // Just a loop to create some points - for (int i = 0; i < 5; i++) - { - // To each point, a TextOverlay3D is created - mitk::TextOverlay3D::Pointer textOverlay3D = mitk::TextOverlay3D::New(); - mitk::Point3D point; - point[0] = i * 2; - point[1] = i * 3; - point[2] = -i * 5; - pointset->InsertPoint(i, point); - textOverlay3D->SetText("A Point"); - textOverlay3D->SetFontSize(1); - - // The Position is set to the point coordinate to create an annotation to the point in the PointSet. - textOverlay3D->SetPosition3D(point); - - // move the annotation away from the actual point - textOverlay3D->SetOffsetVector(offset); - - overlayManager->AddOverlay(textOverlay3D.GetPointer()); - } - - // also show the created pointset - mitk::DataNode::Pointer datanode = mitk::DataNode::New(); - datanode->SetData(pointset); - datanode->SetName("pointSet"); - datanode->SetProperty("pointsize", mitk::FloatProperty::New(2.0)); - renderingHelper.AddNodeToStorage(datanode); - - // use this to generate a reference screenshot or save the file: - bool generateReferenceScreenshot = false; - if (generateReferenceScreenshot) - { - renderingHelper.SaveReferenceScreenShot( - "/home/christoph/Pictures/RenderingTestData/mitkTextOverlay3DRendering3DTest_ball.png"); - } - - //### Usage of CompareRenderWindowAgainstReference: See docu of mitkRrenderingTestHelper - MITK_TEST_CONDITION(renderingHelper.CompareRenderWindowAgainstReference(argc, argv) == true, - "CompareRenderWindowAgainstReference test result positive?"); - - MITK_TEST_END(); -} diff --git a/Modules/Overlays/files.cmake b/Modules/Overlays/files.cmake deleted file mode 100644 index f561d168c0..0000000000 --- a/Modules/Overlays/files.cmake +++ /dev/null @@ -1,14 +0,0 @@ -set(H_FILES -) - -set(CPP_FILES - mitkTextOverlay2D.cpp - mitkTextOverlay3D.cpp - mitkLabelOverlay3D.cpp - mitkColorBarOverlay.cpp - mitkOverlay2DLayouter.cpp - mitkScaleLegendOverlay.cpp - mitkLogoOverlay.cpp - mitkVtkLogoRepresentation.cxx -) - diff --git a/Modules/Overlays/mitkOverlay2DLayouter.cpp b/Modules/Overlays/mitkOverlay2DLayouter.cpp deleted file mode 100644 index daa7dd4365..0000000000 --- a/Modules/Overlays/mitkOverlay2DLayouter.cpp +++ /dev/null @@ -1,228 +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 "mitkOverlay2DLayouter.h" - -std::string mitk::Overlay2DLayouter::STANDARD_2D_TOPLEFT() -{ - static const std::string s = "STANDARD_2D_TOPLEFT"; - return s; -} -std::string mitk::Overlay2DLayouter::STANDARD_2D_TOP() -{ - static const std::string s = "STANDARD_2D_TOP"; - return s; -} -std::string mitk::Overlay2DLayouter::STANDARD_2D_TOPRIGHT() -{ - static const std::string s = "STANDARD_2D_TOPRIGHT"; - return s; -} -std::string mitk::Overlay2DLayouter::STANDARD_2D_BOTTOMLEFT() -{ - static const std::string s = "STANDARD_2D_BOTTOMLEFT"; - return s; -} -std::string mitk::Overlay2DLayouter::STANDARD_2D_BOTTOM() -{ - static const std::string s = "STANDARD_2D_BOTTOM"; - return s; -} -std::string mitk::Overlay2DLayouter::STANDARD_2D_BOTTOMRIGHT() -{ - static const std::string s = "STANDARD_2D_BOTTOMRIGHT"; - return s; -} - -mitk::Overlay2DLayouter::Overlay2DLayouter() -{ - m_Margin = 5; -} - -mitk::Overlay2DLayouter::~Overlay2DLayouter() -{ -} - -mitk::Overlay2DLayouter::Pointer mitk::Overlay2DLayouter::CreateLayouter(const std::string &identifier, - mitk::BaseRenderer *renderer) -{ - if (renderer == NULL) - return NULL; - Alignment alignment; - if (identifier.compare(0, 11, "STANDARD_2D") != 0) - return NULL; - if (identifier.compare(STANDARD_2D_TOPLEFT()) == 0) - alignment = TopLeft; - else if (identifier.compare(STANDARD_2D_TOP()) == 0) - alignment = Top; - else if (identifier.compare(STANDARD_2D_TOPRIGHT()) == 0) - alignment = TopRight; - else if (identifier.compare(STANDARD_2D_BOTTOMLEFT()) == 0) - alignment = BottomLeft; - else if (identifier.compare(STANDARD_2D_BOTTOM()) == 0) - alignment = Bottom; - else if (identifier.compare(STANDARD_2D_BOTTOMRIGHT()) == 0) - alignment = BottomRight; - else - return NULL; - - mitk::Overlay2DLayouter::Pointer layouter = mitk::Overlay2DLayouter::New(); - layouter->m_Alignment = alignment; - layouter->m_Identifier = identifier; - layouter->SetBaseRenderer(renderer); - return layouter; -} - -mitk::Overlay2DLayouter::Pointer mitk::Overlay2DLayouter::CreateLayouter(mitk::Overlay2DLayouter::Alignment alignment, - mitk::BaseRenderer *renderer) -{ - if (renderer == NULL) - return NULL; - std::string identifier; - switch (alignment) - { - case TopLeft: - identifier = STANDARD_2D_TOPLEFT(); - break; - case Top: - identifier = STANDARD_2D_TOP(); - break; - case TopRight: - identifier = STANDARD_2D_TOPRIGHT(); - break; - case BottomLeft: - identifier = STANDARD_2D_BOTTOMLEFT(); - break; - case Bottom: - identifier = STANDARD_2D_BOTTOM(); - break; - case BottomRight: - identifier = STANDARD_2D_BOTTOMRIGHT(); - break; - default: - return NULL; - } - - mitk::Overlay2DLayouter::Pointer layouter = mitk::Overlay2DLayouter::New(); - layouter->m_Alignment = alignment; - layouter->m_Identifier = identifier; - layouter->SetBaseRenderer(renderer); - return layouter; -} - -void mitk::Overlay2DLayouter::PrepareLayout() -{ - std::list managedOverlays = GetManagedOverlays(); - std::list::iterator it; - mitk::Overlay::Bounds bounds; - double posX, posY; - int *size = GetBaseRenderer()->GetVtkRenderer()->GetSize(); - - // The alignment enum defines the type of this layouter - switch (m_Alignment) - { - case TopLeft: - posX = m_Margin; - posY = size[1] - m_Margin; - for (it = managedOverlays.begin(); it != managedOverlays.end(); it++) - { - mitk::Overlay *overlay = *it; - bounds = overlay->GetBoundsOnDisplay(this->GetBaseRenderer()); - posY -= bounds.Size[1]; - bounds.Position[0] = posX; - bounds.Position[1] = posY; - overlay->SetBoundsOnDisplay(this->GetBaseRenderer(), bounds); - posY -= m_Margin; - } - break; - default: - break; - case Top: - posX = 0; - posY = size[1] - m_Margin; - for (it = managedOverlays.begin(); it != managedOverlays.end(); it++) - { - mitk::Overlay *overlay = *it; - bounds = overlay->GetBoundsOnDisplay(this->GetBaseRenderer()); - posX = size[0] / 2 - bounds.Size[0] / 2; - posY -= bounds.Size[1]; - bounds.Position[0] = posX; - bounds.Position[1] = posY; - overlay->SetBoundsOnDisplay(this->GetBaseRenderer(), bounds); - posY -= m_Margin; - } - break; - case TopRight: - posX = 0; - posY = size[1] - m_Margin; - for (it = managedOverlays.begin(); it != managedOverlays.end(); it++) - { - mitk::Overlay *overlay = *it; - bounds = overlay->GetBoundsOnDisplay(this->GetBaseRenderer()); - posX = size[0] - (bounds.Size[0] + m_Margin); - posY -= bounds.Size[1]; - bounds.Position[0] = posX; - bounds.Position[1] = posY; - overlay->SetBoundsOnDisplay(this->GetBaseRenderer(), bounds); - posY -= m_Margin; - } - break; - case BottomLeft: - posX = m_Margin; - posY = m_Margin; - for (it = managedOverlays.begin(); it != managedOverlays.end(); it++) - { - mitk::Overlay *overlay = *it; - bounds = overlay->GetBoundsOnDisplay(this->GetBaseRenderer()); - bounds.Position[0] = posX; - bounds.Position[1] = posY; - overlay->SetBoundsOnDisplay(this->GetBaseRenderer(), bounds); - posY += bounds.Size[1]; - posY += m_Margin; - } - break; - case Bottom: - posX = 0; - posY = m_Margin; - for (it = managedOverlays.begin(); it != managedOverlays.end(); it++) - { - mitk::Overlay *overlay = *it; - bounds = overlay->GetBoundsOnDisplay(this->GetBaseRenderer()); - posX = size[0] / 2 - bounds.Size[0] / 2; - bounds.Position[0] = posX; - bounds.Position[1] = posY; - overlay->SetBoundsOnDisplay(this->GetBaseRenderer(), bounds); - posY += bounds.Size[1]; - posY += m_Margin; - } - break; - case BottomRight: - posX = 0; - posY = m_Margin; - for (it = managedOverlays.begin(); it != managedOverlays.end(); it++) - { - mitk::Overlay *overlay = *it; - bounds = overlay->GetBoundsOnDisplay(this->GetBaseRenderer()); - posX = size[0] - (bounds.Size[0] + m_Margin); - bounds.Position[0] = posX; - bounds.Position[1] = posY; - overlay->SetBoundsOnDisplay(this->GetBaseRenderer(), bounds); - posY += bounds.Size[1]; - posY += m_Margin; - } - break; - } -} diff --git a/Modules/Overlays/mitkOverlay2DLayouter.h b/Modules/Overlays/mitkOverlay2DLayouter.h deleted file mode 100644 index 3de1f00300..0000000000 --- a/Modules/Overlays/mitkOverlay2DLayouter.h +++ /dev/null @@ -1,79 +0,0 @@ -/*=================================================================== - -The Medical Imaging Interaction Toolkit (MITK) - -Copyright (c) German Cancer Research Center, -Division of Medical and Biological Informatics. -All rights reserved. - -This software is distributed WITHOUT ANY WARRANTY; without -even the implied warranty of MERCHANTABILITY or FITNESS FOR -A PARTICULAR PURPOSE. - -See LICENSE.txt or http://www.mitk.org for details. - -===================================================================*/ - -#ifndef MITKOVERLAY2DLAYOUTER_H -#define MITKOVERLAY2DLAYOUTER_H - -#include -#include - -namespace mitk -{ - /** @brief A simple implementation of a layouter for 2D Overlays - */ - class MITKOVERLAYS_EXPORT Overlay2DLayouter : public mitk::AbstractOverlayLayouter - { - public: - enum Alignment - { - TopLeft, - Top, - TopRight, - BottomLeft, - Bottom, - BottomRight - }; - mitkClassMacro(Overlay2DLayouter, mitk::AbstractOverlayLayouter); - itkFactorylessNewMacro(Self) itkCloneMacro(Self) - - static std::string STANDARD_2D_TOPLEFT(); - static std::string STANDARD_2D_TOP(); - static std::string STANDARD_2D_TOPRIGHT(); - static std::string STANDARD_2D_BOTTOMLEFT(); - static std::string STANDARD_2D_BOTTOM(); - static std::string STANDARD_2D_BOTTOMRIGHT(); - - /** \brief Factory method for the different kinds of Layouters */ - /** Create a Layouter that, depending on the identifier sorts the Overlays in one corner of the Renderwindow*/ - static Overlay2DLayouter::Pointer CreateLayouter(Alignment alignment, BaseRenderer *renderer); - - /** \brief Factory method for the different kinds of Layouters */ - /** Create a Layouter that, depending on the identifier sorts the Overlays in one corner of the Renderwindow*/ - static Overlay2DLayouter::Pointer CreateLayouter(const std::string &identifier, BaseRenderer *renderer); - - void PrepareLayout() override; - - protected: - /** \brief explicit constructor which disallows implicit conversions */ - explicit Overlay2DLayouter(); - - /** \brief virtual destructor in order to derive from this class */ - virtual ~Overlay2DLayouter(); - - Alignment m_Alignment; - - double m_Margin; - - private: - /** \brief copy constructor */ - Overlay2DLayouter(const Overlay2DLayouter &); - - /** \brief assignment operator */ - Overlay2DLayouter &operator=(const Overlay2DLayouter &); - }; - -} // namespace mitk -#endif // MITKOVERLAY2DLAYOUTER_H diff --git a/Modules/Overlays/mitkScaleLegendOverlay.cpp b/Modules/Overlays/mitkScaleLegendOverlay.cpp deleted file mode 100644 index ef2e50342e..0000000000 --- a/Modules/Overlays/mitkScaleLegendOverlay.cpp +++ /dev/null @@ -1,154 +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 "mitkScaleLegendOverlay.h" -#include - -mitk::ScaleLegendOverlay::ScaleLegendOverlay() -{ - SetRightAxisVisibility(true); - - SetLeftAxisVisibility(false); - - SetTopAxisVisibility(false); - - SetBottomAxisVisibility(false); - - SetLegendVisibility(false); - - SetRightBorderOffset(30); - - SetCornerOffsetFactor(2.0); -} - -mitk::ScaleLegendOverlay::~ScaleLegendOverlay() -{ -} - -mitk::ScaleLegendOverlay::LocalStorage::~LocalStorage() -{ -} - -mitk::ScaleLegendOverlay::LocalStorage::LocalStorage() -{ - m_legendScaleActor = vtkSmartPointer::New(); -} - -void mitk::ScaleLegendOverlay::UpdateVtkOverlay(mitk::BaseRenderer *renderer) -{ - LocalStorage *ls = this->m_LSH.GetLocalStorage(renderer); - - if (ls->IsGenerateDataRequired(renderer, this)) - { - ls->m_legendScaleActor->SetRightAxisVisibility(this->GetRightAxisVisibility()); - ls->m_legendScaleActor->SetTopAxisVisibility(this->GetTopAxisVisibility()); - ls->m_legendScaleActor->SetLeftAxisVisibility(this->GetLeftAxisVisibility()); - ls->m_legendScaleActor->SetBottomAxisVisibility(this->GetBottomAxisVisibility()); - ls->m_legendScaleActor->SetLegendVisibility(this->GetLegendVisibility()); - ls->m_legendScaleActor->SetRightBorderOffset(this->GetRightBorderOffset()); - ls->m_legendScaleActor->SetCornerOffsetFactor(this->GetCornerOffsetFactor()); - } -} - -vtkProp *mitk::ScaleLegendOverlay::GetVtkProp(BaseRenderer *renderer) const -{ - LocalStorage *ls = this->m_LSH.GetLocalStorage(renderer); - return ls->m_legendScaleActor; -} - -void mitk::ScaleLegendOverlay::SetRightAxisVisibility(bool visibility) -{ - SetBoolProperty("ScaleLegendOverlay.RightAxisVisibility", visibility); -} - -bool mitk::ScaleLegendOverlay::GetRightAxisVisibility() const -{ - bool visibility; - GetPropertyList()->GetBoolProperty("ScaleLegendOverlay.RightAxisVisibility", visibility); - return visibility; -} - -void mitk::ScaleLegendOverlay::SetLeftAxisVisibility(bool visibility) -{ - SetBoolProperty("ScaleLegendOverlay.LeftAxisVisibility", visibility); -} - -bool mitk::ScaleLegendOverlay::GetLeftAxisVisibility() const -{ - bool visibility; - GetPropertyList()->GetBoolProperty("ScaleLegendOverlay.LeftAxisVisibility", visibility); - return visibility; -} - -void mitk::ScaleLegendOverlay::SetTopAxisVisibility(bool visibility) -{ - SetBoolProperty("ScaleLegendOverlay.TopAxisVisibility", visibility); -} - -bool mitk::ScaleLegendOverlay::GetTopAxisVisibility() const -{ - bool visibility; - GetPropertyList()->GetBoolProperty("ScaleLegendOverlay.TopAxisVisibility", visibility); - return visibility; -} - -void mitk::ScaleLegendOverlay::SetBottomAxisVisibility(bool visibility) -{ - SetBoolProperty("ScaleLegendOverlay.BottomAxisVisibility", visibility); -} - -bool mitk::ScaleLegendOverlay::GetBottomAxisVisibility() const -{ - bool visibility; - GetPropertyList()->GetBoolProperty("ScaleLegendOverlay.BottomAxisVisibility", visibility); - return visibility; -} - -void mitk::ScaleLegendOverlay::SetLegendVisibility(bool visibility) -{ - SetBoolProperty("ScaleLegendOverlay.SetLegendVisibility", visibility); -} - -bool mitk::ScaleLegendOverlay::GetLegendVisibility() const -{ - bool visibility; - GetPropertyList()->GetBoolProperty("ScaleLegendOverlay.SetLegendVisibility", visibility); - return visibility; -} - -void mitk::ScaleLegendOverlay::SetRightBorderOffset(int offset) -{ - SetIntProperty("ScaleLegendOverlay.RightBorderOffset", offset); -} - -int mitk::ScaleLegendOverlay::GetRightBorderOffset() const -{ - int offset; - GetPropertyList()->GetIntProperty("ScaleLegendOverlay.RightBorderOffset", offset); - return offset; -} - -void mitk::ScaleLegendOverlay::SetCornerOffsetFactor(float offsetFactor) -{ - SetFloatProperty("ScaleLegendOverlay.CornerOffsetFactor", offsetFactor); -} - -float mitk::ScaleLegendOverlay::GetCornerOffsetFactor() const -{ - float offsetFactor; - GetPropertyList()->GetFloatProperty("ScaleLegendOverlay.CornerOffsetFactor", offsetFactor); - return offsetFactor; -} diff --git a/Modules/PlanarFigure/CMakeLists.txt b/Modules/PlanarFigure/CMakeLists.txt index 2f2b359e3c..08415106bf 100644 --- a/Modules/PlanarFigure/CMakeLists.txt +++ b/Modules/PlanarFigure/CMakeLists.txt @@ -1,8 +1,8 @@ MITK_CREATE_MODULE( INCLUDE_DIRS PRIVATE src/Algorithms src/DataManagement src/Interactions src/IO src/Rendering - DEPENDS MitkSceneSerializationBase MitkLegacyGL MitkOverlays + DEPENDS MitkSceneSerializationBase MitkLegacyGL MitkAnnotation WARNINGS_AS_ERRORS ) add_subdirectory(test) diff --git a/Modules/PlanarFigure/include/mitkPlanarFigure.h b/Modules/PlanarFigure/include/mitkPlanarFigure.h index 98e83510a7..146fd106ee 100644 --- a/Modules/PlanarFigure/include/mitkPlanarFigure.h +++ b/Modules/PlanarFigure/include/mitkPlanarFigure.h @@ -1,382 +1,382 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef _MITK_PLANAR_FIGURE_H_ #define _MITK_PLANAR_FIGURE_H_ #include "mitkBaseData.h" #include "mitkCommon.h" #include #include namespace mitk { class PlaneGeometry; /** * \brief Base-class for geometric planar (2D) figures, such as * lines, circles, rectangles, polygons, etc. * * \warning Currently does not support time-resolved data handling * * Behavior and appearance of PlanarFigures are controlled by various properties; for a detailed * list of appearance properties see mitk::PlanarFigureMapper2D * * The following properties control general PlanarFigure behavior: * *
    *
  • "selected": true if the planar figure is selected *
  • "planarfigure.ishovering": true if the mouse "hovers" over the planar figure *
  • "planarfigure.iseditable": true if the planar figure can be edited (otherwise, * it can only be picked/selected, but its control points cannot be edited); default is true *
  • "planarfigure.isextendable": true if new control points can be inserted into the list of control points; * default is false *
* * * TODO: Implement local 2D transform (including center of rotation...) * */ class MITKPLANARFIGURE_EXPORT PlanarFigure : public BaseData { public: mitkClassMacro(PlanarFigure, BaseData) itkCloneMacro(Self) typedef Point2D PolyLineElement; typedef itk::VectorContainer BoolContainerType; typedef std::deque ControlPointListType; typedef std::vector PolyLineType; /** \brief Sets the 2D geometry on which this figure will be placed. * * In most cases, this is a Geometry already owned by another object, e.g. * describing the slice of the image on which measurements will be * performed. */ virtual void SetPlaneGeometry(mitk::PlaneGeometry *geometry); /** \brief Returns (previously set) 2D geometry of this figure. */ virtual const PlaneGeometry *GetPlaneGeometry() const; /** \brief True if the planar figure is closed. * * Default is false. The "closed" boolean property must be set in sub-classes. */ virtual bool IsClosed() const; /** \brief True if the planar figure has been placed (and can be * displayed/interacted with). */ virtual bool IsPlaced() const { return m_FigurePlaced; }; /** \brief Place figure at the given point (in 2D index coordinates) onto * the given 2D geometry. * * By default, the first two control points of the figure are set to the * passed point. Further points can be set via AddControlPoint(), if the * current number of control points is below the maximum number of control * points. * * Can be re-implemented in sub-classes as needed. */ virtual void PlaceFigure(const Point2D &point); /** * \brief Adds / inserts new control-points * * This method adds a new control-point with the coordinates defined by point at the given index. * If 'index' == -1 or index is greater than the number of control-points the new point is appended * to the back of the list of control points. * If a control-point already exists for 'index', an additional point is inserted at that position. * It is not possible to add more points if the maximum number of control-points (GetMaximumNumberOfControlPoints()) * has been reached. */ virtual bool AddControlPoint(const Point2D &point, int index = -1); virtual bool SetControlPoint(unsigned int index, const Point2D &point, bool createIfDoesNotExist = false); virtual bool SetCurrentControlPoint(const Point2D &point); /** \brief Returns the current number of 2D control points defining this figure. */ unsigned int GetNumberOfControlPoints() const; /** \brief Returns the minimum number of control points needed to represent * this figure. * * Must be implemented in sub-classes. */ virtual unsigned int GetMinimumNumberOfControlPoints() const = 0; /** \brief Returns the maximum number of control points allowed for * this figure (e.g. 3 for triangles). * * Must be implemented in sub-classes. */ virtual unsigned int GetMaximumNumberOfControlPoints() const = 0; /** \brief Selects currently active control points. */ virtual bool SelectControlPoint(unsigned int index); /** \brief Deselect control point; no control point active. */ virtual bool DeselectControlPoint(); /** \brief Return currently selected control point. */ virtual int GetSelectedControlPoint() const { return m_SelectedControlPoint; } /** \brief Returns specified control point in 2D world coordinates. */ Point2D GetControlPoint(unsigned int index) const; /** * \brief Returns the id of the control-point that corresponds to the given * polyline-point. */ virtual int GetControlPointForPolylinePoint(int indexOfPolylinePoint, int polyLineIndex) const; /** \brief Returns specified control point in world coordinates. */ Point3D GetWorldControlPoint(unsigned int index) const; /** \brief Returns the polyline representing the planar figure * (for rendering, measurements, etc.). */ const PolyLineType GetPolyLine(unsigned int index); /** \brief Returns the polyline representing the planar figure * (for rendering, measurments, etc.). */ const PolyLineType GetPolyLine(unsigned int index) const; /** \brief Returns the polyline that should be drawn the same size at every scale * (for text, angles, etc.). */ const PolyLineType GetHelperPolyLine(unsigned int index, double mmPerDisplayUnit, unsigned int displayHeight); /** \brief Sets the position of the PreviewControlPoint. Automatically sets it visible.*/ void SetPreviewControlPoint(const Point2D &point); /** \brief Marks the PreviewControlPoint as invisible.*/ void ResetPreviewContolPoint(); /** \brief Returns whether or not the PreviewControlPoint is visible.*/ bool IsPreviewControlPointVisible() const; /** \brief Returns the coordinates of the PreviewControlPoint. */ Point2D GetPreviewControlPoint() const; /** \brief Returns the number of features available for this PlanarFigure * (such as, radius, area, ...). */ virtual unsigned int GetNumberOfFeatures() const; /** \brief Returns the name (identifier) of the specified features. */ const char *GetFeatureName(unsigned int index) const; /** \brief Returns the physical unit of the specified features. */ const char *GetFeatureUnit(unsigned int index) const; /** Returns quantity of the specified feature (e.g., length, radius, * area, ... ) */ double GetQuantity(unsigned int index) const; /** \brief Returns true if the feature with the specified index exists and * is active (an inactive feature may e.g. be the area of a non-closed * polygon. */ bool IsFeatureActive(unsigned int index) const; /** \brief Returns true if the feature with the specified index exists and is set visible */ bool IsFeatureVisible(unsigned int index) const; /** \brief Defines if the feature with the specified index will be shown as an - * overlay in the RenderWindow */ + * Annotation in the RenderWindow */ void SetFeatureVisible(unsigned int index, bool visible); /** \brief Calculates quantities of all features of this planar figure. */ virtual void EvaluateFeatures(); /** \brief Intherited from parent */ virtual void UpdateOutputInformation() override; /** \brief Intherited from parent */ virtual void SetRequestedRegionToLargestPossibleRegion() override; /** \brief Intherited from parent */ virtual bool RequestedRegionIsOutsideOfTheBufferedRegion() override; /** \brief Intherited from parent */ virtual bool VerifyRequestedRegion() override; /** \brief Intherited from parent */ virtual void SetRequestedRegion(const itk::DataObject *data) override; /** \brief Returns the current number of polylines */ virtual unsigned short GetPolyLinesSize(); /** \brief Returns the current number of helperpolylines */ virtual unsigned short GetHelperPolyLinesSize() const; /** \brief Returns whether a helper polyline should be painted or not */ virtual bool IsHelperToBePainted(unsigned int index) const; /** \brief Returns true if the planar figure is reset to "add points" mode * when a point is selected. * * Default return value is false. Subclasses can overwrite this method and * execute any reset / initialization statements required. */ virtual bool ResetOnPointSelect(); virtual bool ResetOnPointSelectNeeded() const; /** \brief removes the point with the given index from the list of controlpoints. */ virtual void RemoveControlPoint(unsigned int index); /** \brief Removes last control point */ virtual void RemoveLastControlPoint(); /** \brief Allow sub-classes to apply constraints on control points. * * Sub-classes can define spatial constraints to certain control points by * overwriting this method and returning a constrained point. By default, * the points are constrained by the image bounds. */ virtual Point2D ApplyControlPointConstraints(unsigned int /*index*/, const Point2D &point); /** * \brief Compare two PlanarFigure objects * Note: all subclasses have to implement the method on their own. */ virtual bool Equals(const mitk::PlanarFigure &other) const; protected: PlanarFigure(); PlanarFigure(const Self &other); /** \brief Set the initial number of control points of the planar figure */ void ResetNumberOfControlPoints(int numberOfControlPoints); /** Adds feature (e.g., circumference, radius, angle, ...) to feature vector * of a planar figure object and returns integer ID for the feature element. * Should be called in sub-class constructors. */ virtual unsigned int AddFeature(const char *featureName, const char *unitName); /** Sets the name of the specified feature. INTERNAL METHOD. */ void SetFeatureName(unsigned int index, const char *featureName); /** Sets the physical unit of the specified feature. INTERNAL METHOD. */ void SetFeatureUnit(unsigned int index, const char *unitName); /** Sets quantity of the specified feature. INTERNAL METHOD. */ void SetQuantity(unsigned int index, double quantity); /** Sets the specified feature as active. INTERAL METHOD. */ void ActivateFeature(unsigned int index); /** Sets the specified feature as active. INTERAL METHOD. */ void DeactivateFeature(unsigned int index); /** \brief Generates the poly-line representation of the planar figure. * Must be implemented in sub-classes. */ virtual void GeneratePolyLine() = 0; /** \brief Generates the poly-lines that should be drawn the same size regardless of zoom. * Must be implemented in sub-classes. */ virtual void GenerateHelperPolyLine(double mmPerDisplayUnit, unsigned int displayHeight) = 0; /** \brief Calculates quantities of all features of this planar figure. * Must be implemented in sub-classes. */ virtual void EvaluateFeaturesInternal() = 0; /** \brief Initializes the TimeGeometry describing the (time-resolved) * geometry of this figure. Note that each time step holds one PlaneGeometry. */ virtual void InitializeTimeGeometry(unsigned int timeSteps = 1) override; /** \brief defines the number of PolyLines that will be available */ void SetNumberOfPolyLines(unsigned int numberOfPolyLines); /** \brief Append a point to the PolyLine # index */ void AppendPointToPolyLine(unsigned int index, PolyLineElement element); /** \brief clears the list of PolyLines. Call before re-calculating a new Polyline. */ void ClearPolyLines(); /** \brief defines the number of HelperPolyLines that will be available */ void SetNumberOfHelperPolyLines(unsigned int numberOfHelperPolyLines); /** \brief Append a point to the HelperPolyLine # index */ void AppendPointToHelperPolyLine(unsigned int index, PolyLineElement element); /** \brief clears the list of HelperPolyLines. Call before re-calculating a new HelperPolyline. */ void ClearHelperPolyLines(); virtual void PrintSelf(std::ostream &os, itk::Indent indent) const override; ControlPointListType m_ControlPoints; unsigned int m_NumberOfControlPoints; // Currently selected control point; -1 means no point selected int m_SelectedControlPoint; std::vector m_PolyLines; std::vector m_HelperPolyLines; BoolContainerType::Pointer m_HelperPolyLinesToBePainted; // this point is used to store the coordiantes an additional 'ControlPoint' that is rendered // when the mouse cursor is above the figure (and not a control-point) and when the // property 'planarfigure.isextendable' is set to true Point2D m_PreviewControlPoint; bool m_PreviewControlPointVisible; bool m_FigurePlaced; private: // not implemented to prevent PlanarFigure::New() calls which would create an itk::Object. static Pointer New(); struct Feature { Feature(const char *name, const char *unit) : Name(name), Unit(unit), Quantity(0.0), Active(true), Visible(true) { } std::string Name; std::string Unit; double Quantity; bool Active; bool Visible; }; virtual itk::LightObject::Pointer InternalClone() const override = 0; PlaneGeometry *m_PlaneGeometry; bool m_PolyLineUpToDate; bool m_HelperLinesUpToDate; bool m_FeaturesUpToDate; // Vector of features available for this geometric figure typedef std::vector FeatureVectorType; FeatureVectorType m_Features; unsigned long m_FeaturesMTime; // this pair is used to store the mmInDisplayUnits (m_DisplaySize.first) and the displayHeight // (m_DisplaySize.second) // that the helperPolyLines have been calculated for. // It's used to determine whether or not GetHelperPolyLine() needs to recalculate the HelperPolyLines. std::pair m_DisplaySize; }; MITKPLANARFIGURE_EXPORT bool Equal(const mitk::PlanarFigure &leftHandSide, const mitk::PlanarFigure &rightHandSide, ScalarType eps, bool verbose); } // namespace mitk #endif //_MITK_PLANAR_FIGURE_H_ diff --git a/Modules/PlanarFigure/include/mitkPlanarFigureMapper2D.h b/Modules/PlanarFigure/include/mitkPlanarFigureMapper2D.h index 8f0507a381..487a1bfbfc 100644 --- a/Modules/PlanarFigure/include/mitkPlanarFigureMapper2D.h +++ b/Modules/PlanarFigure/include/mitkPlanarFigureMapper2D.h @@ -1,307 +1,307 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef MITK_PLANAR_FIGURE_MAPPER_2D_H_ #define MITK_PLANAR_FIGURE_MAPPER_2D_H_ #include "mitkCommon.h" #include "mitkGLMapper.h" #include "mitkPlanarFigure.h" #include "mitkPlanarFigureControlPointStyleProperty.h" #include namespace mitk { class BaseRenderer; class Contour; - class TextOverlay2D; + class TextAnnotation2D; /** * \brief OpenGL-based mapper to render display sub-class instances of mitk::PlanarFigure * * The appearance of planar figures can be configured through properties. If no properties are specified, * default values will be used. There are four elements a planar figure consists of: * *
    *
  1. "line": the main line segments of the planar figure (note: text is drawn in the same style) *
  2. "helperline": additional line segments of planar figures, such as arrow tips, arches of angles, etc. *
  3. "outline": background which is drawn behind the lines and helperlines of the planar figure (optional) *
  4. "marker": the markers (control points) of a planar figure *
  5. "markerline": the lines by which markers (control points) are surrounded *
* * In the following, all appearance-related planar figure properties are listed: * *
    *
  1. General properties for the planar figure *
      *
    • "planarfigure.drawoutline": if true, the "outline" lines is drawn *
    • "planarfigure.drawquantities": if true, the quantities (text) associated with the planar figure is drawn *
    • "planarfigure.drawname": if true, the name specified by the dataNode is drawn *
    • "planarfigure.drawshadow": if true, a black shadow is drawn around the planar figure *
    • "planarfigure.controlpointshape": style of the control points (enum) *
    *
  2. Line widths of planar figure elements *
      *
    • "planarfigure.line.width": width of "line" segments (float value, in mm) *
    • "planarfigure.shadow.widthmodifier": the width of the shadow is defined by width of the "line" * this * modifier *
    • "planarfigure.outline.width": width of "outline" segments (float value, in mm) *
    • "planarfigure.helperline.width": width of "helperline" segments (float value, in mm) *
    *
  3. Color/opacity of planar figure elements in normal mode (unselected) *
      *
    • "planarfigure.default.line.color" *
    • "planarfigure.default.line.opacity" *
    • "planarfigure.default.outline.color" *
    • "planarfigure.default.outline.opacity" *
    • "planarfigure.default.helperline.color" *
    • "planarfigure.default.helperline.opacity" *
    • "planarfigure.default.markerline.color" *
    • "planarfigure.default.markerline.opacity" *
    • "planarfigure.default.marker.color" *
    • "planarfigure.default.marker.opacity" *
    *
  4. Color/opacity of planar figure elements in hover mode (mouse-over) *
      *
    • "planarfigure.hover.line.color" *
    • "planarfigure.hover.line.opacity" *
    • "planarfigure.hover.outline.color" *
    • "planarfigure.hover.outline.opacity" *
    • "planarfigure.hover.helperline.color" *
    • "planarfigure.hover.helperline.opacity" *
    • "planarfigure.hover.markerline.color" *
    • "planarfigure.hover.markerline.opacity" *
    • "planarfigure.hover.marker.color" *
    • "planarfigure.hover.marker.opacity" *
    *
  5. Color/opacity of planar figure elements in selected mode *
      *
    • "planarfigure.selected.line.color" *
    • "planarfigure.selected.line.opacity" *
    • "planarfigure.selected.outline.color" *
    • "planarfigure.selected.outline.opacity" *
    • "planarfigure.selected.helperline.color" *
    • "planarfigure.selected.helperline.opacity" *
    • "planarfigure.selected.markerline.color;" *
    • "planarfigure.selected.markerline.opacity" *
    • "planarfigure.selected.marker.color" *
    • "planarfigure.selected.marker.opacity" *
    *
* * @ingroup MitkPlanarFigureModule */ class MITKPLANARFIGURE_EXPORT PlanarFigureMapper2D : public GLMapper { public: mitkClassMacro(PlanarFigureMapper2D, GLMapper); itkFactorylessNewMacro(Self) itkCloneMacro(Self) /** * reimplemented from Baseclass */ virtual void Paint(BaseRenderer *renderer) override; static void SetDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer = NULL, bool overwrite = false); protected: enum PlanarFigureDisplayMode { PF_DEFAULT = 0, PF_HOVER = 1, PF_SELECTED = 2, PF_COUNT = 3 // helper variable }; PlanarFigureMapper2D(); virtual ~PlanarFigureMapper2D(); /** * \brief Renders all the lines defined by the PlanarFigure. * * This method renders all the lines that are defined by the PlanarFigure. * That includes the mainlines and helperlines as well as their shadows * and the outlines. * * This method already takes responsibility for the setting of the relevant * openGL attributes to reduce unnecessary setting of these attributes. * (e.g. no need to set color twice if it's the same) */ void RenderLines(const PlanarFigureDisplayMode lineDisplayMode, mitk::PlanarFigure *planarFigure, mitk::Point2D &anchorPoint, const mitk::PlaneGeometry *planarFigurePlaneGeometry, const mitk::PlaneGeometry *rendererPlaneGeometry, const mitk::BaseRenderer *renderer); /** * \brief Renders the quantities of the figure below the text annotations. */ void RenderQuantities(const mitk::PlanarFigure *planarFigure, mitk::BaseRenderer *renderer, const mitk::Point2D anchorPoint, double &annotationOffset, float globalOpacity, const PlanarFigureDisplayMode lineDisplayMode); /** * \brief Renders the text annotations. */ void RenderAnnotations(mitk::BaseRenderer *renderer, const std::string name, const mitk::Point2D anchorPoint, float globalOpacity, const PlanarFigureDisplayMode lineDisplayMode, double &annotationOffset); /** * \brief Renders the control-points. */ void RenderControlPoints(const mitk::PlanarFigure *planarFigure, const PlanarFigureDisplayMode lineDisplayMode, const mitk::PlaneGeometry *planarFigurePlaneGeometry, const mitk::PlaneGeometry *rendererPlaneGeometry, mitk::BaseRenderer *renderer); void TransformObjectToDisplay(const mitk::Point2D &point2D, mitk::Point2D &displayPoint, const mitk::PlaneGeometry *objectGeometry, const mitk::PlaneGeometry *, const mitk::BaseRenderer *renderer); void DrawMarker(const mitk::Point2D &point, float *lineColor, float lineOpacity, float *markerColor, float markerOpacity, float lineWidth, PlanarFigureControlPointStyleProperty::Shape shape, const mitk::PlaneGeometry *objectGeometry, const mitk::PlaneGeometry *rendererGeometry, const mitk::BaseRenderer *renderer); /** * \brief Actually paints the polyline defined by the figure. */ void PaintPolyLine(const mitk::PlanarFigure::PolyLineType vertices, bool closed, Point2D &anchorPoint, const PlaneGeometry *planarFigurePlaneGeometry, const PlaneGeometry *rendererPlaneGeometry, const mitk::BaseRenderer *renderer); /** * \brief Internally used by RenderLines() to draw the mainlines using * PaintPolyLine(). */ void DrawMainLines(mitk::PlanarFigure *figure, Point2D &anchorPoint, const PlaneGeometry *planarFigurePlaneGeometry, const PlaneGeometry *rendererPlaneGeometry, const mitk::BaseRenderer *renderer); /** * \brief Internally used by RenderLines() to draw the helperlines using * PaintPolyLine(). */ void DrawHelperLines(mitk::PlanarFigure *figure, Point2D &anchorPoint, const PlaneGeometry *planarFigurePlaneGeometry, const PlaneGeometry *rendererPlaneGeometry, const mitk::BaseRenderer *renderer); void InitializeDefaultPlanarFigureProperties(); void InitializePlanarFigurePropertiesFromDataNode(const mitk::DataNode *node); void SetColorProperty(float property[3][3], PlanarFigureDisplayMode mode, float red, float green, float blue) { property[mode][0] = red; property[mode][1] = green; property[mode][2] = blue; } void SetFloatProperty(float *property, PlanarFigureDisplayMode mode, float value) { property[mode] = value; } /** * \brief Callback that sets m_NodeModified to true. * * This method set the bool flag m_NodeModified to true. It's a callback * that is executed when a itk::ModifiedEvet is invoked on our * DataNode. */ void OnNodeModified(); private: bool m_IsSelected; bool m_IsHovering; bool m_DrawOutline; bool m_DrawQuantities; bool m_DrawShadow; bool m_DrawControlPoints; bool m_DrawName; bool m_DrawDashed; bool m_DrawHelperDashed; bool m_AnnotationsShadow; std::string m_AnnotationFontFamily; bool m_DrawAnnotationBold; bool m_DrawAnnotationItalic; int m_AnnotationSize; // the width of the shadow is defined as 'm_LineWidth * m_ShadowWidthFactor' float m_LineWidth; float m_ShadowWidthFactor; float m_OutlineWidth; float m_HelperlineWidth; // float m_PointWidth; float m_DevicePixelRatio; PlanarFigureControlPointStyleProperty::Shape m_ControlPointShape; float m_LineColor[3][3]; float m_LineOpacity[3]; float m_OutlineColor[3][3]; float m_OutlineOpacity[3]; float m_HelperlineColor[3][3]; float m_HelperlineOpacity[3]; float m_MarkerlineColor[3][3]; float m_MarkerlineOpacity[3]; float m_MarkerColor[3][3]; float m_MarkerOpacity[3]; float m_AnnotationColor[3][3]; // Bool flag that represents whether or not the DataNode has been modified. bool m_NodeModified; // Observer-tag for listening to itk::ModifiedEvents on the DataNode unsigned long m_NodeModifiedObserverTag; // Bool flag that indicates if a node modified observer was added bool m_NodeModifiedObserverAdded; - itk::SmartPointer m_AnnotationOverlay; - itk::SmartPointer m_QuantityOverlay; + itk::SmartPointer m_AnnotationAnnotation; + itk::SmartPointer m_QuantityAnnotation; }; } // namespace mitk #endif /* MITK_PLANAR_FIGURE_MAPPER_2D_H_ */ diff --git a/Modules/PlanarFigure/src/Rendering/mitkPlanarFigureMapper2D.cpp b/Modules/PlanarFigure/src/Rendering/mitkPlanarFigureMapper2D.cpp index 636391486e..906104db36 100644 --- a/Modules/PlanarFigure/src/Rendering/mitkPlanarFigureMapper2D.cpp +++ b/Modules/PlanarFigure/src/Rendering/mitkPlanarFigureMapper2D.cpp @@ -1,949 +1,949 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "mitkPlanarFigureMapper2D.h" #include "mitkBaseRenderer.h" #include "mitkColorProperty.h" #include "mitkGL.h" #include "mitkPlaneGeometry.h" #include "mitkProperties.h" -#include "mitkTextOverlay2D.h" +#include "mitkTextAnnotation2D.h" #define _USE_MATH_DEFINES #include // offset which moves the planarfigures on top of the other content // the crosshair is rendered into the z = 1 layer. static const float PLANAR_OFFSET = 0.5f; mitk::PlanarFigureMapper2D::PlanarFigureMapper2D() : m_NodeModified(true), m_NodeModifiedObserverTag(0), m_NodeModifiedObserverAdded(false) { - m_AnnotationOverlay = mitk::TextOverlay2D::New(); - m_QuantityOverlay = mitk::TextOverlay2D::New(); + m_AnnotationAnnotation = mitk::TextAnnotation2D::New(); + m_QuantityAnnotation = mitk::TextAnnotation2D::New(); this->InitializeDefaultPlanarFigureProperties(); } mitk::PlanarFigureMapper2D::~PlanarFigureMapper2D() { if (m_NodeModifiedObserverAdded && GetDataNode() != NULL) { GetDataNode()->RemoveObserver(m_NodeModifiedObserverTag); } } void mitk::PlanarFigureMapper2D::Paint(mitk::BaseRenderer *renderer) { bool visible = true; - m_AnnotationOverlay->SetVisibility(false, renderer); + m_AnnotationAnnotation->SetVisibility(false); - m_QuantityOverlay->SetVisibility(false, renderer); + m_QuantityAnnotation->SetVisibility(false); GetDataNode()->GetVisibility(visible, renderer, "visible"); if (!visible) return; // Get PlanarFigure from input mitk::PlanarFigure *planarFigure = const_cast(static_cast(GetDataNode()->GetData())); // Check if PlanarFigure has already been placed; otherwise, do nothing if (!planarFigure->IsPlaced()) { return; } // Get 2D geometry frame of PlanarFigure const mitk::PlaneGeometry *planarFigurePlaneGeometry = planarFigure->GetPlaneGeometry(); if (planarFigurePlaneGeometry == NULL) { MITK_ERROR << "PlanarFigure does not have valid PlaneGeometry!"; return; } // Get current world 2D geometry from renderer const mitk::PlaneGeometry *rendererPlaneGeometry = renderer->GetCurrentWorldPlaneGeometry(); // If the PlanarFigure geometry is a plane geometry, check if current // world plane is parallel to and within the planar figure geometry bounds // (otherwise, display nothing) if ((planarFigurePlaneGeometry != NULL) && (rendererPlaneGeometry != NULL)) { double planeThickness = planarFigurePlaneGeometry->GetExtentInMM(2); if (!planarFigurePlaneGeometry->IsParallel(rendererPlaneGeometry) || !(planarFigurePlaneGeometry->DistanceFromPlane(rendererPlaneGeometry) < planeThickness / 3.0)) { // Planes are not parallel or renderer plane is not within PlanarFigure // geometry bounds --> exit return; } } else { // Plane is not valid (curved reformations are not possible yet) return; } // Apply visual appearance properties from the PropertyList ApplyColorAndOpacityProperties(renderer); // Enable line antialiasing glEnable(GL_LINE_SMOOTH); glHint(GL_LINE_SMOOTH_HINT, GL_NICEST); glEnable(GL_DEPTH_TEST); // Get properties from node (if present) const mitk::DataNode *node = this->GetDataNode(); this->InitializePlanarFigurePropertiesFromDataNode(node); PlanarFigureDisplayMode lineDisplayMode = PF_DEFAULT; if (m_IsSelected) { lineDisplayMode = PF_SELECTED; } else if (m_IsHovering) { lineDisplayMode = PF_HOVER; } mitk::Point2D anchorPoint; anchorPoint[0] = 0; anchorPoint[1] = 1; // render the actual lines of the PlanarFigure RenderLines(lineDisplayMode, planarFigure, anchorPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer); // position-offset of the annotations, is set in RenderAnnotations() and // used in RenderQuantities() double annotationOffset = 0.0; // Get Global Opacity float globalOpacity = 1.0; node->GetFloatProperty("opacity", globalOpacity); if (m_DrawControlPoints) { // draw the control-points RenderControlPoints(planarFigure, lineDisplayMode, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer); } // draw name near the anchor point (point located on the right) const std::string name = node->GetName(); if (m_DrawName && !name.empty()) { RenderAnnotations(renderer, name, anchorPoint, globalOpacity, lineDisplayMode, annotationOffset); } // draw feature quantities (if requested) next to the anchor point, // but under the name (that is where 'annotationOffset' is used) if (m_DrawQuantities) { RenderQuantities(planarFigure, renderer, anchorPoint, annotationOffset, globalOpacity, lineDisplayMode); } glLineWidth(1.0f); } void mitk::PlanarFigureMapper2D::PaintPolyLine(const mitk::PlanarFigure::PolyLineType vertices, bool closed, Point2D &anchorPoint, const PlaneGeometry *planarFigurePlaneGeometry, const PlaneGeometry *rendererPlaneGeometry, const mitk::BaseRenderer *renderer) { mitk::Point2D rightMostPoint; rightMostPoint.Fill(itk::NumericTraits::min()); // transform all vertices into Point2Ds in display-Coordinates and store them in vector std::vector pointlist; for (auto iter = vertices.cbegin(); iter != vertices.cend(); ++iter) { // Draw this 2D point as OpenGL vertex mitk::Point2D displayPoint; this->TransformObjectToDisplay(*iter, displayPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer); pointlist.push_back(displayPoint); if (displayPoint[0] > rightMostPoint[0]) rightMostPoint = displayPoint; } // If the planarfigure is closed, we add the first control point again. // Thus we can always use 'GL_LINE_STRIP' and get rid of strange flickering // effect when using the MESA OpenGL library. if (closed) { mitk::Point2D displayPoint; this->TransformObjectToDisplay( vertices.cbegin()[0], displayPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer); pointlist.push_back(displayPoint); } // now paint all the points in one run glBegin(GL_LINE_STRIP); for (auto pointIter = pointlist.cbegin(); pointIter != pointlist.cend(); pointIter++) { glVertex3f((*pointIter)[0], (*pointIter)[1], PLANAR_OFFSET); } glEnd(); anchorPoint = rightMostPoint; } void mitk::PlanarFigureMapper2D::DrawMainLines(mitk::PlanarFigure *figure, Point2D &anchorPoint, const PlaneGeometry *planarFigurePlaneGeometry, const PlaneGeometry *rendererPlaneGeometry, const mitk::BaseRenderer *renderer) { const auto numberOfPolyLines = figure->GetPolyLinesSize(); for (auto loop = 0; loop < numberOfPolyLines; ++loop) { const auto polyline = figure->GetPolyLine(loop); this->PaintPolyLine( polyline, figure->IsClosed(), anchorPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer); } } void mitk::PlanarFigureMapper2D::DrawHelperLines(mitk::PlanarFigure *figure, Point2D &anchorPoint, const PlaneGeometry *planarFigurePlaneGeometry, const PlaneGeometry *rendererPlaneGeometry, const mitk::BaseRenderer *renderer) { const auto numberOfHelperPolyLines = figure->GetHelperPolyLinesSize(); // Draw helper objects for (unsigned int loop = 0; loop < numberOfHelperPolyLines; ++loop) { const auto helperPolyLine = figure->GetHelperPolyLine(loop, renderer->GetScaleFactorMMPerDisplayUnit(), renderer->GetViewportSize()[1]); // Check if the current helper objects is to be painted if (!figure->IsHelperToBePainted(loop)) { continue; } // ... and once normally above the shadow. this->PaintPolyLine(helperPolyLine, false, anchorPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer); } } void mitk::PlanarFigureMapper2D::TransformObjectToDisplay(const mitk::Point2D &point2D, mitk::Point2D &displayPoint, const mitk::PlaneGeometry *objectGeometry, const mitk::PlaneGeometry * /*rendererGeometry*/, const mitk::BaseRenderer *renderer) { mitk::Point3D point3D; // Map circle point from local 2D geometry into 3D world space objectGeometry->Map(point2D, point3D); // Project 3D world point onto display geometry renderer->WorldToDisplay(point3D, displayPoint); } void mitk::PlanarFigureMapper2D::DrawMarker(const mitk::Point2D &point, float *lineColor, float lineOpacity, float *markerColor, float markerOpacity, float lineWidth, PlanarFigureControlPointStyleProperty::Shape shape, const mitk::PlaneGeometry *objectGeometry, const mitk::PlaneGeometry *rendererGeometry, const mitk::BaseRenderer *renderer) { if (this->GetDataNode() != nullptr && this->GetDataNode()->GetDataInteractor().IsNull()) return; if (markerOpacity == 0 && lineOpacity == 0) return; mitk::Point2D displayPoint; this->TransformObjectToDisplay(point, displayPoint, objectGeometry, rendererGeometry, renderer); glColor4f(markerColor[0], markerColor[1], markerColor[2], markerOpacity); glLineWidth(lineWidth); switch (shape) { case PlanarFigureControlPointStyleProperty::Square: default: { // Paint filled square // Disable line antialiasing (does not look nice for squares) glDisable(GL_LINE_SMOOTH); if (markerOpacity > 0) { glRectf(displayPoint[0] - 4, displayPoint[1] - 4, displayPoint[0] + 4, displayPoint[1] + 4); } // Paint outline glColor4f(lineColor[0], lineColor[1], lineColor[2], lineOpacity); glBegin(GL_LINE_LOOP); glVertex3f(displayPoint[0] - 4, displayPoint[1] - 4, PLANAR_OFFSET); glVertex3f(displayPoint[0] - 4, displayPoint[1] + 4, PLANAR_OFFSET); glVertex3f(displayPoint[0] + 4, displayPoint[1] + 4, PLANAR_OFFSET); glVertex3f(displayPoint[0] + 4, displayPoint[1] - 4, PLANAR_OFFSET); glEnd(); break; } case PlanarFigureControlPointStyleProperty::Circle: { float radius = 4.0; if (markerOpacity > 0) { // Paint filled circle glBegin(GL_POLYGON); for (int angle = 0; angle < 8; ++angle) { float angleRad = angle * (float)3.14159 / 4.0; float x = displayPoint[0] + radius * (float)cos(angleRad); float y = displayPoint[1] + radius * (float)sin(angleRad); glVertex3f(x, y, PLANAR_OFFSET); } glEnd(); } // Paint outline glColor4f(lineColor[0], lineColor[1], lineColor[2], lineOpacity); glBegin(GL_LINE_LOOP); for (int angle = 0; angle < 8; ++angle) { float angleRad = angle * (float)3.14159 / 4.0; float x = displayPoint[0] + radius * (float)cos(angleRad); float y = displayPoint[1] + radius * (float)sin(angleRad); glVertex3f(x, y, PLANAR_OFFSET); } glEnd(); break; } } // end switch } void mitk::PlanarFigureMapper2D::InitializeDefaultPlanarFigureProperties() { m_IsSelected = false; m_IsHovering = false; m_DrawOutline = false; m_DrawQuantities = false; m_DrawShadow = false; m_DrawControlPoints = false; m_DrawName = true; m_DrawDashed = false; m_DrawHelperDashed = false; m_AnnotationsShadow = false; m_ShadowWidthFactor = 1.2; m_LineWidth = 1.0; m_OutlineWidth = 4.0; m_HelperlineWidth = 2.0; m_DevicePixelRatio = 1.0; m_ControlPointShape = PlanarFigureControlPointStyleProperty::Square; this->SetColorProperty(m_LineColor, PF_DEFAULT, 1.0, 1.0, 1.0); this->SetFloatProperty(m_LineOpacity, PF_DEFAULT, 1.0); this->SetColorProperty(m_OutlineColor, PF_DEFAULT, 0.0, 0.0, 1.0); this->SetFloatProperty(m_OutlineOpacity, PF_DEFAULT, 1.0); this->SetColorProperty(m_HelperlineColor, PF_DEFAULT, 0.4, 0.8, 0.2); this->SetFloatProperty(m_HelperlineOpacity, PF_DEFAULT, 0.4); this->SetColorProperty(m_MarkerlineColor, PF_DEFAULT, 1.0, 1.0, 1.0); this->SetFloatProperty(m_MarkerlineOpacity, PF_DEFAULT, 1.0); this->SetColorProperty(m_MarkerColor, PF_DEFAULT, 1.0, 1.0, 1.0); this->SetFloatProperty(m_MarkerOpacity, PF_DEFAULT, 0.0); this->SetColorProperty(m_AnnotationColor, PF_DEFAULT, 1.0, 1.0, 1.0); this->SetColorProperty(m_LineColor, PF_HOVER, 1.0, 0.7, 0.0); this->SetFloatProperty(m_LineOpacity, PF_HOVER, 1.0); this->SetColorProperty(m_OutlineColor, PF_HOVER, 0.0, 0.0, 1.0); this->SetFloatProperty(m_OutlineOpacity, PF_HOVER, 1.0); this->SetColorProperty(m_HelperlineColor, PF_HOVER, 0.4, 0.8, 0.2); this->SetFloatProperty(m_HelperlineOpacity, PF_HOVER, 0.4); this->SetColorProperty(m_MarkerlineColor, PF_HOVER, 1.0, 1.0, 1.0); this->SetFloatProperty(m_MarkerlineOpacity, PF_HOVER, 1.0); this->SetColorProperty(m_MarkerColor, PF_HOVER, 1.0, 0.6, 0.0); this->SetFloatProperty(m_MarkerOpacity, PF_HOVER, 0.2); this->SetColorProperty(m_AnnotationColor, PF_HOVER, 1.0, 0.7, 0.0); this->SetColorProperty(m_LineColor, PF_SELECTED, 1.0, 0.0, 0.0); this->SetFloatProperty(m_LineOpacity, PF_SELECTED, 1.0); this->SetColorProperty(m_OutlineColor, PF_SELECTED, 0.0, 0.0, 1.0); this->SetFloatProperty(m_OutlineOpacity, PF_SELECTED, 1.0); this->SetColorProperty(m_HelperlineColor, PF_SELECTED, 0.4, 0.8, 0.2); this->SetFloatProperty(m_HelperlineOpacity, PF_SELECTED, 0.4); this->SetColorProperty(m_MarkerlineColor, PF_SELECTED, 1.0, 1.0, 1.0); this->SetFloatProperty(m_MarkerlineOpacity, PF_SELECTED, 1.0); this->SetColorProperty(m_MarkerColor, PF_SELECTED, 1.0, 0.6, 0.0); this->SetFloatProperty(m_MarkerOpacity, PF_SELECTED, 1.0); this->SetColorProperty(m_AnnotationColor, PF_SELECTED, 1.0, 0.0, 0.0); } void mitk::PlanarFigureMapper2D::InitializePlanarFigurePropertiesFromDataNode(const mitk::DataNode *node) { if (node == NULL) { return; } // if we have not added an observer for ModifiedEvents on the DataNode, // we add one now. if (!m_NodeModifiedObserverAdded) { itk::SimpleMemberCommand::Pointer nodeModifiedCommand = itk::SimpleMemberCommand::New(); nodeModifiedCommand->SetCallbackFunction(this, &mitk::PlanarFigureMapper2D::OnNodeModified); m_NodeModifiedObserverTag = node->AddObserver(itk::ModifiedEvent(), nodeModifiedCommand); m_NodeModifiedObserverAdded = true; } // If the DataNode has not been modified since the last execution of // this method, we do not run it now. if (!m_NodeModified) return; // Mark the current properties as unmodified m_NodeModified = false; // Get Global Opacity float globalOpacity = 1.0; node->GetFloatProperty("opacity", globalOpacity); node->GetBoolProperty("selected", m_IsSelected); node->GetBoolProperty("planarfigure.ishovering", m_IsHovering); node->GetBoolProperty("planarfigure.drawoutline", m_DrawOutline); node->GetBoolProperty("planarfigure.drawshadow", m_DrawShadow); node->GetBoolProperty("planarfigure.drawquantities", m_DrawQuantities); node->GetBoolProperty("planarfigure.drawcontrolpoints", m_DrawControlPoints); node->GetBoolProperty("planarfigure.drawname", m_DrawName); node->GetBoolProperty("planarfigure.drawdashed", m_DrawDashed); node->GetBoolProperty("planarfigure.helperline.drawdashed", m_DrawHelperDashed); node->GetFloatProperty("planarfigure.line.width", m_LineWidth); node->GetFloatProperty("planarfigure.shadow.widthmodifier", m_ShadowWidthFactor); node->GetFloatProperty("planarfigure.outline.width", m_OutlineWidth); node->GetFloatProperty("planarfigure.helperline.width", m_HelperlineWidth); node->GetFloatProperty("planarfigure.devicepixelratio", m_DevicePixelRatio); node->GetStringProperty("planarfigure.annotations.font.family", m_AnnotationFontFamily); node->GetBoolProperty("planarfigure.annotations.font.bold", m_DrawAnnotationBold); node->GetBoolProperty("planarfigure.annotations.font.italic", m_DrawAnnotationItalic); node->GetIntProperty("planarfigure.annotations.font.size", m_AnnotationSize); if (!node->GetBoolProperty("planarfigure.annotations.shadow", m_AnnotationsShadow)) { node->GetBoolProperty("planarfigure.drawshadow", m_AnnotationsShadow); } PlanarFigureControlPointStyleProperty::Pointer styleProperty = dynamic_cast(node->GetProperty("planarfigure.controlpointshape")); if (styleProperty.IsNotNull()) { m_ControlPointShape = styleProperty->GetShape(); } // Set default color and opacity // If property "planarfigure.default.*.color" exists, then use that color. Otherwise global "color" property is used. if (!node->GetColor(m_LineColor[PF_DEFAULT], NULL, "planarfigure.default.line.color")) { node->GetColor(m_LineColor[PF_DEFAULT], NULL, "color"); } node->GetFloatProperty("planarfigure.default.line.opacity", m_LineOpacity[PF_DEFAULT]); if (!node->GetColor(m_OutlineColor[PF_DEFAULT], NULL, "planarfigure.default.outline.color")) { node->GetColor(m_OutlineColor[PF_DEFAULT], NULL, "color"); } node->GetFloatProperty("planarfigure.default.outline.opacity", m_OutlineOpacity[PF_DEFAULT]); if (!node->GetColor(m_HelperlineColor[PF_DEFAULT], NULL, "planarfigure.default.helperline.color")) { node->GetColor(m_HelperlineColor[PF_DEFAULT], NULL, "color"); } node->GetFloatProperty("planarfigure.default.helperline.opacity", m_HelperlineOpacity[PF_DEFAULT]); node->GetColor(m_MarkerlineColor[PF_DEFAULT], NULL, "planarfigure.default.markerline.color"); node->GetFloatProperty("planarfigure.default.markerline.opacity", m_MarkerlineOpacity[PF_DEFAULT]); node->GetColor(m_MarkerColor[PF_DEFAULT], NULL, "planarfigure.default.marker.color"); node->GetFloatProperty("planarfigure.default.marker.opacity", m_MarkerOpacity[PF_DEFAULT]); if (!node->GetColor(m_AnnotationColor[PF_DEFAULT], NULL, "planarfigure.default.annotation.color")) { if (!node->GetColor(m_AnnotationColor[PF_DEFAULT], NULL, "planarfigure.default.line.color")) { node->GetColor(m_AnnotationColor[PF_DEFAULT], NULL, "color"); } } // Set hover color and opacity node->GetColor(m_LineColor[PF_HOVER], NULL, "planarfigure.hover.line.color"); node->GetFloatProperty("planarfigure.hover.line.opacity", m_LineOpacity[PF_HOVER]); node->GetColor(m_OutlineColor[PF_HOVER], NULL, "planarfigure.hover.outline.color"); node->GetFloatProperty("planarfigure.hover.outline.opacity", m_OutlineOpacity[PF_HOVER]); node->GetColor(m_HelperlineColor[PF_HOVER], NULL, "planarfigure.hover.helperline.color"); node->GetFloatProperty("planarfigure.hover.helperline.opacity", m_HelperlineOpacity[PF_HOVER]); node->GetColor(m_MarkerlineColor[PF_HOVER], NULL, "planarfigure.hover.markerline.color"); node->GetFloatProperty("planarfigure.hover.markerline.opacity", m_MarkerlineOpacity[PF_HOVER]); node->GetColor(m_MarkerColor[PF_HOVER], NULL, "planarfigure.hover.marker.color"); node->GetFloatProperty("planarfigure.hover.marker.opacity", m_MarkerOpacity[PF_HOVER]); if (!node->GetColor(m_AnnotationColor[PF_HOVER], NULL, "planarfigure.hover.annotation.color")) { if (!node->GetColor(m_AnnotationColor[PF_HOVER], NULL, "planarfigure.hover.line.color")) { node->GetColor(m_AnnotationColor[PF_HOVER], NULL, "color"); } } // Set selected color and opacity node->GetColor(m_LineColor[PF_SELECTED], NULL, "planarfigure.selected.line.color"); node->GetFloatProperty("planarfigure.selected.line.opacity", m_LineOpacity[PF_SELECTED]); node->GetColor(m_OutlineColor[PF_SELECTED], NULL, "planarfigure.selected.outline.color"); node->GetFloatProperty("planarfigure.selected.outline.opacity", m_OutlineOpacity[PF_SELECTED]); node->GetColor(m_HelperlineColor[PF_SELECTED], NULL, "planarfigure.selected.helperline.color"); node->GetFloatProperty("planarfigure.selected.helperline.opacity", m_HelperlineOpacity[PF_SELECTED]); node->GetColor(m_MarkerlineColor[PF_SELECTED], NULL, "planarfigure.selected.markerline.color"); node->GetFloatProperty("planarfigure.selected.markerline.opacity", m_MarkerlineOpacity[PF_SELECTED]); node->GetColor(m_MarkerColor[PF_SELECTED], NULL, "planarfigure.selected.marker.color"); node->GetFloatProperty("planarfigure.selected.marker.opacity", m_MarkerOpacity[PF_SELECTED]); if (!node->GetColor(m_AnnotationColor[PF_SELECTED], NULL, "planarfigure.selected.annotation.color")) { if (!node->GetColor(m_AnnotationColor[PF_SELECTED], NULL, "planarfigure.selected.line.color")) { node->GetColor(m_AnnotationColor[PF_SELECTED], NULL, "color"); } } // adapt opacity values to global "opacity" property for (unsigned int i = 0; i < PF_COUNT; ++i) { m_LineOpacity[i] *= globalOpacity; m_OutlineOpacity[i] *= globalOpacity; m_HelperlineOpacity[i] *= globalOpacity; m_MarkerlineOpacity[i] *= globalOpacity; m_MarkerOpacity[i] *= globalOpacity; } } void mitk::PlanarFigureMapper2D::OnNodeModified() { m_NodeModified = true; } void mitk::PlanarFigureMapper2D::SetDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer, bool overwrite) { node->AddProperty("visible", mitk::BoolProperty::New(true), renderer, overwrite); // node->SetProperty("planarfigure.iseditable",mitk::BoolProperty::New(true)); node->AddProperty("planarfigure.isextendable", mitk::BoolProperty::New(false)); // node->AddProperty( "planarfigure.ishovering", mitk::BoolProperty::New(true) ); node->AddProperty("planarfigure.drawoutline", mitk::BoolProperty::New(false)); // node->AddProperty( "planarfigure.drawquantities", mitk::BoolProperty::New(true) ); node->AddProperty("planarfigure.drawshadow", mitk::BoolProperty::New(true)); node->AddProperty("planarfigure.drawcontrolpoints", mitk::BoolProperty::New(true)); node->AddProperty("planarfigure.drawname", mitk::BoolProperty::New(true)); node->AddProperty("planarfigure.drawdashed", mitk::BoolProperty::New(false)); node->AddProperty("planarfigure.helperline.drawdashed", mitk::BoolProperty::New(false)); node->AddProperty("planarfigure.annotations.font.family", mitk::StringProperty::New("Arial")); node->AddProperty("planarfigure.annotations.font.bold", mitk::BoolProperty::New(false)); node->AddProperty("planarfigure.annotations.font.italic", mitk::BoolProperty::New(false)); node->AddProperty("planarfigure.annotations.font.size", mitk::IntProperty::New(12)); node->AddProperty("planarfigure.line.width", mitk::FloatProperty::New(2.0)); node->AddProperty("planarfigure.shadow.widthmodifier", mitk::FloatProperty::New(2.0)); node->AddProperty("planarfigure.outline.width", mitk::FloatProperty::New(2.0)); node->AddProperty("planarfigure.helperline.width", mitk::FloatProperty::New(1.0)); node->AddProperty("planarfigure.default.line.opacity", mitk::FloatProperty::New(1.0)); node->AddProperty("planarfigure.default.outline.opacity", mitk::FloatProperty::New(1.0)); node->AddProperty("planarfigure.default.helperline.opacity", mitk::FloatProperty::New(1.0)); node->AddProperty("planarfigure.default.markerline.color", mitk::ColorProperty::New(1.0, 1.0, 1.0)); node->AddProperty("planarfigure.default.markerline.opacity", mitk::FloatProperty::New(1.0)); node->AddProperty("planarfigure.default.marker.color", mitk::ColorProperty::New(1.0, 1.0, 1.0)); node->AddProperty("planarfigure.default.marker.opacity", mitk::FloatProperty::New(1.0)); node->AddProperty("planarfigure.hover.line.color", mitk::ColorProperty::New(0.0, 1.0, 0.0)); node->AddProperty("planarfigure.hover.line.opacity", mitk::FloatProperty::New(1.0)); node->AddProperty("planarfigure.hover.outline.color", mitk::ColorProperty::New(0.0, 1.0, 0.0)); node->AddProperty("planarfigure.hover.outline.opacity", mitk::FloatProperty::New(1.0)); node->AddProperty("planarfigure.hover.helperline.color", mitk::ColorProperty::New(0.0, 1.0, 0.0)); node->AddProperty("planarfigure.hover.helperline.opacity", mitk::FloatProperty::New(1.0)); node->AddProperty("planarfigure.hover.markerline.color", mitk::ColorProperty::New(0.0, 1.0, 0.0)); node->AddProperty("planarfigure.hover.markerline.opacity", mitk::FloatProperty::New(1.0)); node->AddProperty("planarfigure.hover.marker.color", mitk::ColorProperty::New(0.0, 1.0, 0.0)); node->AddProperty("planarfigure.hover.marker.opacity", mitk::FloatProperty::New(1.0)); node->AddProperty("planarfigure.selected.line.color", mitk::ColorProperty::New(1.0, 0.0, 0.0)); node->AddProperty("planarfigure.selected.line.opacity", mitk::FloatProperty::New(1.0)); node->AddProperty("planarfigure.selected.outline.color", mitk::ColorProperty::New(1.0, 0.0, 0.0)); node->AddProperty("planarfigure.selected.outline.opacity", mitk::FloatProperty::New(1.0)); node->AddProperty("planarfigure.selected.helperline.color", mitk::ColorProperty::New(1.0, 0.0, 0.0)); node->AddProperty("planarfigure.selected.helperline.opacity", mitk::FloatProperty::New(1.0)); node->AddProperty("planarfigure.selected.markerline.color", mitk::ColorProperty::New(1.0, 0.0, 0.0)); node->AddProperty("planarfigure.selected.markerline.opacity", mitk::FloatProperty::New(1.0)); node->AddProperty("planarfigure.selected.marker.color", mitk::ColorProperty::New(1.0, 0.0, 0.0)); node->AddProperty("planarfigure.selected.marker.opacity", mitk::FloatProperty::New(1.0)); } void mitk::PlanarFigureMapper2D::RenderControlPoints(const mitk::PlanarFigure *planarFigure, const PlanarFigureDisplayMode lineDisplayMode, const mitk::PlaneGeometry *planarFigurePlaneGeometry, const mitk::PlaneGeometry *rendererPlaneGeometry, mitk::BaseRenderer *renderer) { bool isEditable = true; m_DataNode->GetBoolProperty("planarfigure.iseditable", isEditable); PlanarFigureDisplayMode pointDisplayMode = PF_DEFAULT; const unsigned int selectedControlPointsIdx = (unsigned int)planarFigure->GetSelectedControlPoint(); const unsigned int numberOfControlPoints = planarFigure->GetNumberOfControlPoints(); // Draw markers at control points (selected control point will be colored) for (unsigned int i = 0; i < numberOfControlPoints; ++i) { // Only if planar figure is marked as editable: display markers (control points) in a // different style if mouse is over them or they are selected if (isEditable) { if (i == selectedControlPointsIdx) { pointDisplayMode = PF_SELECTED; } else if (m_IsHovering && isEditable) { pointDisplayMode = PF_HOVER; } } if (m_MarkerOpacity[pointDisplayMode] == 0 && m_MarkerlineOpacity[pointDisplayMode] == 0) { continue; } if (m_DrawOutline) { // draw outlines for markers as well // linewidth for the contour is only half, as full width looks // much too thick! this->DrawMarker(planarFigure->GetControlPoint(i), m_OutlineColor[lineDisplayMode], m_MarkerlineOpacity[pointDisplayMode], m_OutlineColor[lineDisplayMode], m_MarkerOpacity[pointDisplayMode], m_OutlineWidth / 2, m_ControlPointShape, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer); } this->DrawMarker(planarFigure->GetControlPoint(i), m_MarkerlineColor[pointDisplayMode], m_MarkerlineOpacity[pointDisplayMode], m_MarkerColor[pointDisplayMode], m_MarkerOpacity[pointDisplayMode], m_LineWidth, m_ControlPointShape, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer); } if (planarFigure->IsPreviewControlPointVisible()) { this->DrawMarker(planarFigure->GetPreviewControlPoint(), m_MarkerlineColor[PF_HOVER], m_MarkerlineOpacity[PF_HOVER], m_MarkerColor[PF_HOVER], m_MarkerOpacity[PF_HOVER], m_LineWidth, m_ControlPointShape, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer); } } void mitk::PlanarFigureMapper2D::RenderAnnotations(mitk::BaseRenderer *renderer, const std::string name, const mitk::Point2D anchorPoint, float globalOpacity, const PlanarFigureDisplayMode lineDisplayMode, double &annotationOffset) { if (anchorPoint[0] < mitk::eps || anchorPoint[1] < mitk::eps) { return; } - m_AnnotationOverlay->SetText(name); - m_AnnotationOverlay->SetColor(m_AnnotationColor[lineDisplayMode][0], + m_AnnotationAnnotation->SetText(name); + m_AnnotationAnnotation->SetColor(m_AnnotationColor[lineDisplayMode][0], m_AnnotationColor[lineDisplayMode][1], m_AnnotationColor[lineDisplayMode][2]); - m_AnnotationOverlay->SetOpacity(globalOpacity); - m_AnnotationOverlay->SetFontSize(m_AnnotationSize * m_DevicePixelRatio); - m_AnnotationOverlay->SetBoolProperty("drawShadow", m_AnnotationsShadow); - m_AnnotationOverlay->SetVisibility(true, renderer); - m_AnnotationOverlay->SetStringProperty("font.family", m_AnnotationFontFamily); - m_AnnotationOverlay->SetBoolProperty("font.bold", m_DrawAnnotationBold); - m_AnnotationOverlay->SetBoolProperty("font.italic", m_DrawAnnotationItalic); + m_AnnotationAnnotation->SetOpacity(globalOpacity); + m_AnnotationAnnotation->SetFontSize(m_AnnotationSize * m_DevicePixelRatio); + m_AnnotationAnnotation->SetBoolProperty("drawShadow", m_AnnotationsShadow); + m_AnnotationAnnotation->SetVisibility(true); + m_AnnotationAnnotation->SetStringProperty("font.family", m_AnnotationFontFamily); + m_AnnotationAnnotation->SetBoolProperty("font.bold", m_DrawAnnotationBold); + m_AnnotationAnnotation->SetBoolProperty("font.italic", m_DrawAnnotationItalic); mitk::Point2D offset; offset.Fill(5); mitk::Point2D scaledAnchorPoint; scaledAnchorPoint[0] = anchorPoint[0] * m_DevicePixelRatio; scaledAnchorPoint[1] = anchorPoint[1] * m_DevicePixelRatio; offset[0] = offset[0] * m_DevicePixelRatio; offset[1] = offset[1] * m_DevicePixelRatio; - m_AnnotationOverlay->SetPosition2D(scaledAnchorPoint); - m_AnnotationOverlay->SetOffsetVector(offset); + m_AnnotationAnnotation->SetPosition2D(scaledAnchorPoint); + m_AnnotationAnnotation->SetOffsetVector(offset); - m_AnnotationOverlay->Update(renderer); - m_AnnotationOverlay->Paint(renderer); + m_AnnotationAnnotation->Update(renderer); + m_AnnotationAnnotation->Paint(renderer); annotationOffset -= 15.0; - // annotationOffset -= m_AnnotationOverlay->GetBoundsOnDisplay( renderer ).Size[1]; + // annotationOffset -= m_AnnotationAnnotation->GetBoundsOnDisplay( renderer ).Size[1]; } void mitk::PlanarFigureMapper2D::RenderQuantities(const mitk::PlanarFigure *planarFigure, mitk::BaseRenderer *renderer, const mitk::Point2D anchorPoint, double &annotationOffset, float globalOpacity, const PlanarFigureDisplayMode lineDisplayMode) { if (anchorPoint[0] < mitk::eps || anchorPoint[1] < mitk::eps) { return; } std::stringstream quantityString; quantityString.setf(ios::fixed, ios::floatfield); quantityString.precision(1); bool firstActiveFeature = true; for (unsigned int i = 0; i < planarFigure->GetNumberOfFeatures(); ++i) { if (planarFigure->IsFeatureActive(i) && planarFigure->IsFeatureVisible(i)) { if (!firstActiveFeature) { quantityString << " x "; } quantityString << planarFigure->GetQuantity(i) << " "; quantityString << planarFigure->GetFeatureUnit(i); firstActiveFeature = false; } } - m_QuantityOverlay->SetColor(m_AnnotationColor[lineDisplayMode][0], + m_QuantityAnnotation->SetColor(m_AnnotationColor[lineDisplayMode][0], m_AnnotationColor[lineDisplayMode][1], m_AnnotationColor[lineDisplayMode][2]); - m_QuantityOverlay->SetOpacity(globalOpacity); - m_QuantityOverlay->SetFontSize(m_AnnotationSize * m_DevicePixelRatio); - m_QuantityOverlay->SetBoolProperty("drawShadow", m_DrawShadow); - m_QuantityOverlay->SetVisibility(true, renderer); + m_QuantityAnnotation->SetOpacity(globalOpacity); + m_QuantityAnnotation->SetFontSize(m_AnnotationSize * m_DevicePixelRatio); + m_QuantityAnnotation->SetBoolProperty("drawShadow", m_DrawShadow); + m_QuantityAnnotation->SetVisibility(true); - m_AnnotationOverlay->SetStringProperty("font.family", m_AnnotationFontFamily); - m_AnnotationOverlay->SetBoolProperty("font.bold", m_DrawAnnotationBold); - m_AnnotationOverlay->SetBoolProperty("font.italic", m_DrawAnnotationItalic); + m_AnnotationAnnotation->SetStringProperty("font.family", m_AnnotationFontFamily); + m_AnnotationAnnotation->SetBoolProperty("font.bold", m_DrawAnnotationBold); + m_AnnotationAnnotation->SetBoolProperty("font.italic", m_DrawAnnotationItalic); - m_QuantityOverlay->SetText(quantityString.str().c_str()); + m_QuantityAnnotation->SetText(quantityString.str().c_str()); mitk::Point2D offset; offset.Fill(5); offset[1] += annotationOffset; mitk::Point2D scaledAnchorPoint; scaledAnchorPoint[0] = anchorPoint[0] * m_DevicePixelRatio; scaledAnchorPoint[1] = anchorPoint[1] * m_DevicePixelRatio; offset[0] = offset[0] * m_DevicePixelRatio; offset[1] = offset[1] * m_DevicePixelRatio; - m_QuantityOverlay->SetPosition2D(scaledAnchorPoint); - m_QuantityOverlay->SetOffsetVector(offset); + m_QuantityAnnotation->SetPosition2D(scaledAnchorPoint); + m_QuantityAnnotation->SetOffsetVector(offset); - m_QuantityOverlay->Update(renderer); - m_QuantityOverlay->Paint(renderer); - // annotationOffset -= m_QuantityOverlay->GetBoundsOnDisplay( renderer ).Size[1]; + m_QuantityAnnotation->Update(renderer); + m_QuantityAnnotation->Paint(renderer); + // annotationOffset -= m_QuantityAnnotation->GetBoundsOnDisplay( renderer ).Size[1]; annotationOffset -= 15.0; } void mitk::PlanarFigureMapper2D::RenderLines(const PlanarFigureDisplayMode lineDisplayMode, mitk::PlanarFigure *planarFigure, mitk::Point2D &anchorPoint, const mitk::PlaneGeometry *planarFigurePlaneGeometry, const mitk::PlaneGeometry *rendererPlaneGeometry, const mitk::BaseRenderer *renderer) { glLineStipple(1, 0x00FF); // If we want to draw an outline, we do it here if (m_DrawOutline) { const float *color = m_OutlineColor[lineDisplayMode]; const float opacity = m_OutlineOpacity[lineDisplayMode]; // convert to a float array that also contains opacity, faster GL float *colorVector = new float[4]; colorVector[0] = color[0]; colorVector[1] = color[1]; colorVector[2] = color[2]; colorVector[3] = opacity; // set the color and opacity here as it is common for all outlines glColor4fv(colorVector); glLineWidth(m_OutlineWidth); if (m_DrawDashed) glEnable(GL_LINE_STIPPLE); else glDisable(GL_LINE_STIPPLE); // Draw the outline for all polylines if requested this->DrawMainLines(planarFigure, anchorPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer); glLineWidth(m_HelperlineWidth); if (m_DrawHelperDashed) glEnable(GL_LINE_STIPPLE); else glDisable(GL_LINE_STIPPLE); // Draw the outline for all helper objects if requested this->DrawHelperLines(planarFigure, anchorPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer); // cleanup delete[] colorVector; } // If we want to draw a shadow, we do it here if (m_DrawShadow) { // determine the shadow opacity const float opacity = m_OutlineOpacity[lineDisplayMode]; float shadowOpacity = 0.0f; if (opacity > 0.2f) shadowOpacity = opacity - 0.2f; // convert to a float array that also contains opacity, faster GL float *shadow = new float[4]; shadow[0] = 0; shadow[1] = 0; shadow[2] = 0; shadow[3] = shadowOpacity; // set the color and opacity here as it is common for all shadows glColor4fv(shadow); glLineWidth(m_OutlineWidth * m_ShadowWidthFactor); if (m_DrawDashed) glEnable(GL_LINE_STIPPLE); else glDisable(GL_LINE_STIPPLE); // Draw the outline for all polylines if requested this->DrawMainLines(planarFigure, anchorPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer); glLineWidth(m_HelperlineWidth); if (m_DrawHelperDashed) glEnable(GL_LINE_STIPPLE); else glDisable(GL_LINE_STIPPLE); // Draw the outline for all helper objects if requested this->DrawHelperLines(planarFigure, anchorPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer); // cleanup delete[] shadow; } // set this in brackets to avoid duplicate variables in the same scope { const float *color = m_LineColor[lineDisplayMode]; const float opacity = m_LineOpacity[lineDisplayMode]; // convert to a float array that also contains opacity, faster GL float *colorVector = new float[4]; colorVector[0] = color[0]; colorVector[1] = color[1]; colorVector[2] = color[2]; colorVector[3] = opacity; // set the color and opacity here as it is common for all mainlines glColor4fv(colorVector); glLineWidth(m_LineWidth); if (m_DrawDashed) glEnable(GL_LINE_STIPPLE); else glDisable(GL_LINE_STIPPLE); // Draw the main line for all polylines this->DrawMainLines(planarFigure, anchorPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer); const float *helperColor = m_HelperlineColor[lineDisplayMode]; const float helperOpacity = m_HelperlineOpacity[lineDisplayMode]; // convert to a float array that also contains opacity, faster GL float *helperColorVector = new float[4]; helperColorVector[0] = helperColor[0]; helperColorVector[1] = helperColor[1]; helperColorVector[2] = helperColor[2]; helperColorVector[3] = helperOpacity; // we only set the color for the helperlines as the linewidth is unchanged glColor4fv(helperColorVector); glLineWidth(m_HelperlineWidth); if (m_DrawHelperDashed) glEnable(GL_LINE_STIPPLE); else glDisable(GL_LINE_STIPPLE); // Draw helper objects this->DrawHelperLines(planarFigure, anchorPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer); // cleanup delete[] colorVector; delete[] helperColorVector; } if (m_DrawDashed || m_DrawHelperDashed) glDisable(GL_LINE_STIPPLE); } diff --git a/Modules/QmlItems/include/QmlAxisOverlay.h b/Modules/QmlItems/include/QmlAxisOverlay.h index 751249060b..dfd3bac4a4 100644 --- a/Modules/QmlItems/include/QmlAxisOverlay.h +++ b/Modules/QmlItems/include/QmlAxisOverlay.h @@ -1,83 +1,80 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef __mitkAxisOverlay_h #define __mitkAxisOverlay_h -#include #include +#include #include #include #include #include -namespace mitk { - class AxisOverlay : public mitk::VtkOverlay { +namespace mitk +{ + class AxisOverlay : public mitk::VtkAnnotation + { public: - class LocalStorage : public mitk::VtkOverlay::BaseLocalStorage + class LocalStorage : public mitk::VtkAnnotation::BaseLocalStorage { public: /** \brief Actor of a 2D render window. */ bool m_initialized = false; vtkSmartPointer m_axesActor; vtkSmartPointer m_widget; vtkSmartPointer m_dummyActor; vtkSmartPointer m_dummyMapper; vtkSmartPointer m_dummySource; /** \brief Timestamp of last update of stored data. */ itk::TimeStamp m_LastUpdateTime; /** \brief Default constructor of the local storage. */ LocalStorage(); /** \brief Default deconstructor of the local storage. */ ~LocalStorage(); - }; - mitkClassMacro(AxisOverlay, mitk::VtkOverlay); - itkFactorylessNewMacro(Self) - itkCloneMacro(Self) + mitkClassMacro(AxisOverlay, mitk::VtkAnnotation); + itkFactorylessNewMacro(Self) itkCloneMacro(Self) - protected: + protected : - /** \brief The LocalStorageHandler holds all LocalStorages for the render windows. */ - mutable mitk::LocalStorageHandler m_LSH; + /** \brief The LocalStorageHandler holds all LocalStorages for the render windows. */ + mutable mitk::LocalStorageHandler m_LSH; - virtual vtkProp* GetVtkProp(BaseRenderer *renderer) const; - void UpdateVtkOverlay(mitk::BaseRenderer *renderer); + virtual vtkProp *GetVtkProp(BaseRenderer *renderer) const; + void UpdateVtkAnnotation(mitk::BaseRenderer *renderer); /** \brief explicit constructor which disallows implicit conversions */ explicit AxisOverlay(); /** \brief virtual destructor in order to derive from this class */ virtual ~AxisOverlay(); private: - /** \brief copy constructor */ AxisOverlay(const AxisOverlay &); /** \brief assignment operator */ AxisOverlay &operator=(const AxisOverlay &); - }; - } #endif diff --git a/Modules/QmlItems/src/QmlAxisOverlay.cpp b/Modules/QmlItems/src/QmlAxisOverlay.cpp index 011b6fb3e3..9a32ecd860 100644 --- a/Modules/QmlItems/src/QmlAxisOverlay.cpp +++ b/Modules/QmlItems/src/QmlAxisOverlay.cpp @@ -1,68 +1,67 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ - #include "QmlAxisOverlay.h" -#include #include #include +#include //#include "Util_Debug.h" #include "mitkPoint.h" mitk::AxisOverlay::AxisOverlay() { } mitk::AxisOverlay::~AxisOverlay() { } mitk::AxisOverlay::LocalStorage::~LocalStorage() { } mitk::AxisOverlay::LocalStorage::LocalStorage() { this->m_axesActor = vtkSmartPointer::New(); this->m_widget = vtkSmartPointer::New(); this->m_dummyActor = vtkSmartPointer::New(); this->m_dummyMapper = vtkSmartPointer::New(); this->m_dummySource = vtkSmartPointer::New(); this->m_dummyMapper->SetInputConnection(m_dummySource->GetOutputPort()); this->m_dummyActor->SetMapper(this->m_dummyMapper); this->m_dummyActor->SetVisibility(false); this->m_dummyActor->GetProperty()->SetOpacity(0.0); } -void mitk::AxisOverlay::UpdateVtkOverlay(mitk::BaseRenderer *renderer) +void mitk::AxisOverlay::UpdateVtkAnnotation(mitk::BaseRenderer *renderer) { - LocalStorage* ls = this->m_LSH.GetLocalStorage(renderer); + LocalStorage *ls = this->m_LSH.GetLocalStorage(renderer); if (ls->IsGenerateDataRequired(renderer, this)) { ls->m_widget->SetOrientationMarker(ls->m_axesActor); ls->m_widget->SetInteractor(renderer->GetRenderWindow()->GetInteractor()); ls->m_widget->SetEnabled(true); ls->m_widget->SetOutlineColor(0.3, 0, 0); ls->m_widget->SetInteractive(true); ls->m_initialized = true; } } -vtkProp* mitk::AxisOverlay::GetVtkProp(BaseRenderer *renderer) const +vtkProp *mitk::AxisOverlay::GetVtkProp(BaseRenderer *renderer) const { - LocalStorage* ls = this->m_LSH.GetLocalStorage(renderer); + LocalStorage *ls = this->m_LSH.GetLocalStorage(renderer); return ls->m_dummyActor; } diff --git a/Modules/QtWidgets/CMakeLists.txt b/Modules/QtWidgets/CMakeLists.txt index 39683dcb7d..65a44f75f5 100644 --- a/Modules/QtWidgets/CMakeLists.txt +++ b/Modules/QtWidgets/CMakeLists.txt @@ -1,9 +1,9 @@ MITK_CREATE_MODULE( INCLUDE_DIRS PRIVATE resource # for xpm includes - DEPENDS MitkPlanarFigure MitkOverlays + DEPENDS MitkPlanarFigure MitkAnnotation PACKAGE_DEPENDS PUBLIC ITK|ITKIOImageBase VTK|vtkGUISupportQt+vtkGUISupportQtOpenGL Qt5|Widgets+OpenGL+Core SUBPROJECTS MITK-CoreUI ) add_subdirectory(test) diff --git a/Modules/QtWidgets/include/QmitkStdMultiWidget.h b/Modules/QtWidgets/include/QmitkStdMultiWidget.h index b676e35f55..cb7b47fc42 100644 --- a/Modules/QtWidgets/include/QmitkStdMultiWidget.h +++ b/Modules/QtWidgets/include/QmitkStdMultiWidget.h @@ -1,429 +1,429 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef QmitkStdMultiWidget_h #define QmitkStdMultiWidget_h #include "MitkQtWidgetsExports.h" #include -#include +#include #include #include #include #include #include #include #include class QHBoxLayout; class QVBoxLayout; class QGridLayout; class QSpacerItem; class QmitkLevelWindowWidget; class QmitkRenderWindow; class vtkCornerAnnotation; class vtkMitkRectangleProp; namespace mitk { class RenderingManager; } /// \ingroup QmitkModule class MITKQTWIDGETS_EXPORT QmitkStdMultiWidget : public QWidget { Q_OBJECT public: QmitkStdMultiWidget( QWidget *parent = 0, Qt::WindowFlags f = 0, mitk::RenderingManager *renderingManager = 0, mitk::BaseRenderer::RenderingMode::Type renderingMode = mitk::BaseRenderer::RenderingMode::Standard, const QString &name = "stdmulti"); virtual ~QmitkStdMultiWidget(); mitk::SliceNavigationController *GetTimeNavigationController(); void RequestUpdate(); void ForceImmediateUpdate(); mitk::MouseModeSwitcher *GetMouseModeSwitcher(); QmitkRenderWindow *GetRenderWindow1() const; QmitkRenderWindow *GetRenderWindow2() const; QmitkRenderWindow *GetRenderWindow3() const; QmitkRenderWindow *GetRenderWindow4() const; const mitk::Point3D GetCrossPosition() const; void EnablePositionTracking(); void DisablePositionTracking(); int GetLayout() const; bool GetGradientBackgroundFlag() const; /*! \brief Access node of widget plane 1 \return DataNode holding widget plane 1 */ mitk::DataNode::Pointer GetWidgetPlane1(); /*! \brief Access node of widget plane 2 \return DataNode holding widget plane 2 */ mitk::DataNode::Pointer GetWidgetPlane2(); /*! \brief Access node of widget plane 3 \return DataNode holding widget plane 3 */ mitk::DataNode::Pointer GetWidgetPlane3(); /*! \brief Convenience method to access node of widget planes \param id number of widget plane to be returned \return DataNode holding widget plane 3 */ mitk::DataNode::Pointer GetWidgetPlane(int id); bool IsColoredRectanglesEnabled() const; bool IsDepartmentLogoEnabled() const; void InitializeWidget(); /// called when the StdMultiWidget is closed to remove the 3 widget planes and the helper node from the DataStorage void RemovePlanesFromDataStorage(); void AddPlanesToDataStorage(); void SetDataStorage(mitk::DataStorage *ds); /** \brief Listener to the CrosshairPositionEvent Ensures the CrosshairPositionEvent is handled only once and at the end of the Qt-Event loop */ void HandleCrosshairPositionEvent(); /// activate Menu Widget. true: activated, false: deactivated void ActivateMenuWidget(bool state); bool IsMenuWidgetEnabled() const; void SetCornerAnnotationVisibility(bool visibility); bool IsCornerAnnotationVisible(void) const; protected: void UpdateAllWidgets(); void HideAllWidgetToolbars(); mitk::DataNode::Pointer GetTopLayerNode(mitk::DataStorage::SetOfObjects::ConstPointer nodes); public slots: /// Receives the signal from HandleCrosshairPositionEvent, executes the StatusBar update void HandleCrosshairPositionEventDelayed(); void changeLayoutTo2DImagesUp(); void changeLayoutTo2DImagesLeft(); void changeLayoutToDefault(); void changeLayoutToBig3D(); void changeLayoutToWidget1(); void changeLayoutToWidget2(); void changeLayoutToWidget3(); void changeLayoutToRowWidget3And4(); void changeLayoutToColumnWidget3And4(); void changeLayoutToRowWidgetSmall3andBig4(); void changeLayoutToSmallUpperWidget2Big3and4(); void changeLayoutTo2x2Dand3DWidget(); void changeLayoutToLeft2Dand3DRight2D(); void changeLayoutTo2DUpAnd3DDown(); void Fit(); void InitPositionTracking(); void AddDisplayPlaneSubTree(); void EnableStandardLevelWindow(); void DisableStandardLevelWindow(); bool InitializeStandardViews(const mitk::Geometry3D *geometry); void wheelEvent(QWheelEvent *e) override; void mousePressEvent(QMouseEvent *e) override; void moveEvent(QMoveEvent *e) override; void EnsureDisplayContainsPoint(mitk::BaseRenderer *renderer, const mitk::Point3D &p); void MoveCrossToPosition(const mitk::Point3D &newPosition); // void EnableNavigationControllerEventListening(); // void DisableNavigationControllerEventListening(); void EnableGradientBackground(); void DisableGradientBackground(); void EnableDepartmentLogo(); void DisableDepartmentLogo(); void EnableColoredRectangles(); void DisableColoredRectangles(); void SetWidgetPlaneVisibility(const char *widgetName, bool visible, mitk::BaseRenderer *renderer = NULL); void SetWidgetPlanesVisibility(bool visible, mitk::BaseRenderer *renderer = NULL); void SetWidgetPlanesLocked(bool locked); void SetWidgetPlanesRotationLocked(bool locked); void SetWidgetPlanesRotationLinked(bool link); void SetWidgetPlaneMode(int mode); void SetGradientBackgroundColors(const mitk::Color &upper, const mitk::Color &lower); void SetDepartmentLogoPath(const char *path); void SetWidgetPlaneModeToSlicing(bool activate); void SetWidgetPlaneModeToRotation(bool activate); void SetWidgetPlaneModeToSwivel(bool activate); void OnLayoutDesignChanged(int layoutDesignIndex); void ResetCrosshair(); signals: void LeftMouseClicked(mitk::Point3D pointValue); void WheelMoved(QWheelEvent *); void WidgetPlanesRotationLinked(bool); void WidgetPlanesRotationEnabled(bool); void ViewsInitialized(); void WidgetPlaneModeSlicing(bool); void WidgetPlaneModeRotation(bool); void WidgetPlaneModeSwivel(bool); void WidgetPlaneModeChange(int); void WidgetNotifyNewCrossHairMode(int); void Moved(); public: /** Define RenderWindow (public)*/ QmitkRenderWindow *mitkWidget1; QmitkRenderWindow *mitkWidget2; QmitkRenderWindow *mitkWidget3; QmitkRenderWindow *mitkWidget4; QmitkLevelWindowWidget *levelWindowWidget; /********************************/ enum { PLANE_MODE_SLICING = 0, PLANE_MODE_ROTATION, PLANE_MODE_SWIVEL }; enum { LAYOUT_DEFAULT = 0, LAYOUT_2D_IMAGES_UP, LAYOUT_2D_IMAGES_LEFT, LAYOUT_BIG_3D, LAYOUT_WIDGET1, LAYOUT_WIDGET2, LAYOUT_WIDGET3, LAYOUT_2X_2D_AND_3D_WIDGET, LAYOUT_ROW_WIDGET_3_AND_4, LAYOUT_COLUMN_WIDGET_3_AND_4, LAYOUT_ROW_WIDGET_SMALL3_AND_BIG4, LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4, LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET, LAYOUT_2D_UP_AND_3D_DOWN }; enum { AXIAL, SAGITTAL, CORONAL, THREE_D }; /** * @brief SetCornerAnnotation Create a corner annotation for a widget. * @param text The text of the annotation. * @param color The color. * @param widgetNumber The widget (0-3). */ void SetDecorationProperties(std::string text, mitk::Color color, int widgetNumber); /** * @brief GetRenderWindow convinience method to get a widget. * @param number of the widget (0-3) * @return The renderwindow widget. */ QmitkRenderWindow *GetRenderWindow(unsigned int number); /** * @brief SetGradientBackgroundColorForRenderWindow background for a widget. * * If two different input colors are, a gradient background is generated. * * @param upper Upper color of the gradient background. * @param lower Lower color of the gradient background. * @param widgetNumber The widget (0-3). */ void SetGradientBackgroundColorForRenderWindow(const mitk::Color &upper, const mitk::Color &lower, unsigned int widgetNumber); /** * @brief GetDecorationColorForWidget Get the color for annotation, crosshair and rectangle. * @param widgetNumber Number of the renderwindow (0-3). * @return Color in mitk format. */ mitk::Color GetDecorationColor(unsigned int widgetNumber); /** * @brief SetDecorationColor Set the color of the decoration of the 4 widgets. * * This is used to color the frame of the renderwindow and the corner annatation. * For the first 3 widgets, this color is a property of the helper object nodes * which contain the respective plane geometry. For widget 4, this is a member, * since there is no data node for this widget. */ void SetDecorationColor(unsigned int widgetNumber, mitk::Color color); /** * @brief GetCornerAnnotationText Getter for corner annotation text. * @param widgetNumber the widget number (0-3). * @return The text in the corner annotation. */ std::string GetCornerAnnotationText(unsigned int widgetNumber); /** * @brief GetGradientColors Getter for gradientbackground colors. * @param widgetNumber the widget number (0-3). * @return A pair of colors. First: upper, second: lower. */ std::pair GetGradientColors(unsigned int widgetNumber); protected: QHBoxLayout *QmitkStdMultiWidgetLayout; int m_Layout; int m_PlaneMode; mitk::RenderingManager *m_RenderingManager; - mitk::LogoOverlay::Pointer m_LogoRendering; + mitk::LogoAnnotation::Pointer m_LogoRendering; bool m_GradientBackgroundFlag; mitk::MouseModeSwitcher::Pointer m_MouseModeSwitcher; mitk::SliceNavigationController *m_TimeNavigationController; mitk::DataStorage::Pointer m_DataStorage; /** * @brief m_PlaneNode1 the 3 helper objects which contain the plane geometry. */ mitk::DataNode::Pointer m_PlaneNode1; mitk::DataNode::Pointer m_PlaneNode2; mitk::DataNode::Pointer m_PlaneNode3; /** * @brief m_ParentNodeForGeometryPlanes This helper object is added to the datastorage * and contains the 3 planes for displaying the image geometry (crosshair and 3D planes). */ mitk::DataNode::Pointer m_ParentNodeForGeometryPlanes; /** * @brief m_DecorationColorWidget4 color for annotation and rectangle of widget 4. * * For other widgets1-3, the color is a property of the respective data node. * There is no node for widget 4, hence, we need an extra member. */ mitk::Color m_DecorationColorWidget4; /** * @brief m_GradientBackgroundColors Contains the colors of the gradient background. * */ std::pair m_GradientBackgroundColors[4]; QSplitter *m_MainSplit; QSplitter *m_LayoutSplit; QSplitter *m_SubSplit1; QSplitter *m_SubSplit2; QWidget *mitkWidget1Container; QWidget *mitkWidget2Container; QWidget *mitkWidget3Container; QWidget *mitkWidget4Container; vtkSmartPointer m_CornerAnnotations[4]; vtkSmartPointer m_RectangleProps[4]; bool m_PendingCrosshairPositionEvent; bool m_CrosshairNavigationEnabled; /** * @brief CreateCornerAnnotation helper method to create a corner annotation. * @param text of the annotation. * @param color of the annotation. * @return the complete CornerAnnotation. */ vtkSmartPointer CreateCornerAnnotation(std::string text, mitk::Color color); /** * @brief FillGradientBackgroundWithBlack Internal helper method to initialize the * gradient background colors with black. */ void FillGradientBackgroundWithBlack(); }; #endif /*QmitkStdMultiWidget_h*/ diff --git a/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp b/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp index d66b1d3031..500968e857 100644 --- a/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp +++ b/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp @@ -1,2027 +1,2021 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #define SMW_INFO MITK_INFO("widget.stdmulti") #include "QmitkStdMultiWidget.h" #include #include #include #include #include #include #include #include "mitkImagePixelReadAccessor.h" #include "mitkPixelTypeMultiplex.h" +#include #include #include #include #include #include #include #include #include #include -#include #include #include #include #include #include #include #include #include #include QmitkStdMultiWidget::QmitkStdMultiWidget(QWidget *parent, Qt::WindowFlags f, mitk::RenderingManager *renderingManager, mitk::BaseRenderer::RenderingMode::Type renderingMode, const QString &name) : QWidget(parent, f), mitkWidget1(NULL), mitkWidget2(NULL), mitkWidget3(NULL), mitkWidget4(NULL), levelWindowWidget(NULL), QmitkStdMultiWidgetLayout(NULL), m_Layout(LAYOUT_DEFAULT), m_PlaneMode(PLANE_MODE_SLICING), m_RenderingManager(renderingManager), m_GradientBackgroundFlag(true), m_TimeNavigationController(NULL), m_MainSplit(NULL), m_LayoutSplit(NULL), m_SubSplit1(NULL), m_SubSplit2(NULL), mitkWidget1Container(NULL), mitkWidget2Container(NULL), mitkWidget3Container(NULL), mitkWidget4Container(NULL), m_PendingCrosshairPositionEvent(false), m_CrosshairNavigationEnabled(false) { /****************************************************** * Use the global RenderingManager if none was specified * ****************************************************/ if (m_RenderingManager == NULL) { m_RenderingManager = mitk::RenderingManager::GetInstance(); } m_TimeNavigationController = m_RenderingManager->GetTimeNavigationController(); /*******************************/ // Create Widget manually /*******************************/ // create Layouts QmitkStdMultiWidgetLayout = new QHBoxLayout(this); QmitkStdMultiWidgetLayout->setContentsMargins(0, 0, 0, 0); // Set Layout to widget this->setLayout(QmitkStdMultiWidgetLayout); // create main splitter m_MainSplit = new QSplitter(this); QmitkStdMultiWidgetLayout->addWidget(m_MainSplit); // create m_LayoutSplit and add to the mainSplit m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit); m_MainSplit->addWidget(m_LayoutSplit); // create m_SubSplit1 and m_SubSplit2 m_SubSplit1 = new QSplitter(m_LayoutSplit); m_SubSplit2 = new QSplitter(m_LayoutSplit); // creae Widget Container mitkWidget1Container = new QWidget(m_SubSplit1); mitkWidget2Container = new QWidget(m_SubSplit1); mitkWidget3Container = new QWidget(m_SubSplit2); mitkWidget4Container = new QWidget(m_SubSplit2); mitkWidget1Container->setContentsMargins(0, 0, 0, 0); mitkWidget2Container->setContentsMargins(0, 0, 0, 0); mitkWidget3Container->setContentsMargins(0, 0, 0, 0); mitkWidget4Container->setContentsMargins(0, 0, 0, 0); // create Widget Layout QHBoxLayout *mitkWidgetLayout1 = new QHBoxLayout(mitkWidget1Container); QHBoxLayout *mitkWidgetLayout2 = new QHBoxLayout(mitkWidget2Container); QHBoxLayout *mitkWidgetLayout3 = new QHBoxLayout(mitkWidget3Container); QHBoxLayout *mitkWidgetLayout4 = new QHBoxLayout(mitkWidget4Container); m_CornerAnnotations[0] = vtkSmartPointer::New(); m_CornerAnnotations[1] = vtkSmartPointer::New(); m_CornerAnnotations[2] = vtkSmartPointer::New(); m_CornerAnnotations[3] = vtkSmartPointer::New(); m_RectangleProps[0] = vtkSmartPointer::New(); m_RectangleProps[1] = vtkSmartPointer::New(); m_RectangleProps[2] = vtkSmartPointer::New(); m_RectangleProps[3] = vtkSmartPointer::New(); mitkWidgetLayout1->setMargin(0); mitkWidgetLayout2->setMargin(0); mitkWidgetLayout3->setMargin(0); mitkWidgetLayout4->setMargin(0); // set Layout to Widget Container mitkWidget1Container->setLayout(mitkWidgetLayout1); mitkWidget2Container->setLayout(mitkWidgetLayout2); mitkWidget3Container->setLayout(mitkWidgetLayout3); mitkWidget4Container->setLayout(mitkWidgetLayout4); // set SizePolicy mitkWidget1Container->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding); mitkWidget2Container->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding); mitkWidget3Container->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding); mitkWidget4Container->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding); // insert Widget Container into the splitters m_SubSplit1->addWidget(mitkWidget1Container); m_SubSplit1->addWidget(mitkWidget2Container); m_SubSplit2->addWidget(mitkWidget3Container); m_SubSplit2->addWidget(mitkWidget4Container); // Create RenderWindows 1 mitkWidget1 = new QmitkRenderWindow(mitkWidget1Container, name + ".widget1", NULL, m_RenderingManager, renderingMode); mitkWidget1->SetLayoutIndex(AXIAL); mitkWidgetLayout1->addWidget(mitkWidget1); // Create RenderWindows 2 mitkWidget2 = new QmitkRenderWindow(mitkWidget2Container, name + ".widget2", NULL, m_RenderingManager, renderingMode); mitkWidget2->setEnabled(true); mitkWidget2->SetLayoutIndex(SAGITTAL); mitkWidgetLayout2->addWidget(mitkWidget2); // Create RenderWindows 3 mitkWidget3 = new QmitkRenderWindow(mitkWidget3Container, name + ".widget3", NULL, m_RenderingManager, renderingMode); mitkWidget3->SetLayoutIndex(CORONAL); mitkWidgetLayout3->addWidget(mitkWidget3); // Create RenderWindows 4 mitkWidget4 = new QmitkRenderWindow(mitkWidget4Container, name + ".widget4", NULL, m_RenderingManager, renderingMode); mitkWidget4->SetLayoutIndex(THREE_D); mitkWidgetLayout4->addWidget(mitkWidget4); // create SignalSlot Connection connect(mitkWidget1, SIGNAL(SignalLayoutDesignChanged(int)), this, SLOT(OnLayoutDesignChanged(int))); connect(mitkWidget1, SIGNAL(ResetView()), this, SLOT(ResetCrosshair())); connect(mitkWidget1, SIGNAL(ChangeCrosshairRotationMode(int)), this, SLOT(SetWidgetPlaneMode(int))); connect(this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget1, SLOT(OnWidgetPlaneModeChanged(int))); connect(mitkWidget2, SIGNAL(SignalLayoutDesignChanged(int)), this, SLOT(OnLayoutDesignChanged(int))); connect(mitkWidget2, SIGNAL(ResetView()), this, SLOT(ResetCrosshair())); connect(mitkWidget2, SIGNAL(ChangeCrosshairRotationMode(int)), this, SLOT(SetWidgetPlaneMode(int))); connect(this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget2, SLOT(OnWidgetPlaneModeChanged(int))); connect(mitkWidget3, SIGNAL(SignalLayoutDesignChanged(int)), this, SLOT(OnLayoutDesignChanged(int))); connect(mitkWidget3, SIGNAL(ResetView()), this, SLOT(ResetCrosshair())); connect(mitkWidget3, SIGNAL(ChangeCrosshairRotationMode(int)), this, SLOT(SetWidgetPlaneMode(int))); connect(this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget3, SLOT(OnWidgetPlaneModeChanged(int))); connect(mitkWidget4, SIGNAL(SignalLayoutDesignChanged(int)), this, SLOT(OnLayoutDesignChanged(int))); connect(mitkWidget4, SIGNAL(ResetView()), this, SLOT(ResetCrosshair())); connect(mitkWidget4, SIGNAL(ChangeCrosshairRotationMode(int)), this, SLOT(SetWidgetPlaneMode(int))); connect(this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget4, SLOT(OnWidgetPlaneModeChanged(int))); // Create Level Window Widget levelWindowWidget = new QmitkLevelWindowWidget(m_MainSplit); // this levelWindowWidget->setObjectName(QString::fromUtf8("levelWindowWidget")); QSizePolicy sizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred); sizePolicy.setHorizontalStretch(0); sizePolicy.setVerticalStretch(0); sizePolicy.setHeightForWidth(levelWindowWidget->sizePolicy().hasHeightForWidth()); levelWindowWidget->setSizePolicy(sizePolicy); levelWindowWidget->setMaximumWidth(50); // add LevelWindow Widget to mainSplitter m_MainSplit->addWidget(levelWindowWidget); // show mainSplitt and add to Layout m_MainSplit->show(); // resize Image. this->resize(QSize(364, 477).expandedTo(minimumSizeHint())); // Initialize the widgets. this->InitializeWidget(); // Activate Widget Menu this->ActivateMenuWidget(true); } void QmitkStdMultiWidget::InitializeWidget() { // Make all black and overwrite renderwindow 4 this->FillGradientBackgroundWithBlack(); // This is #191919 in hex float tmp1[3] = {0.098f, 0.098f, 0.098f}; // This is #7F7F7F in hex float tmp2[3] = {0.498f, 0.498f, 0.498f}; m_GradientBackgroundColors[3] = std::make_pair(mitk::Color(tmp1), mitk::Color(tmp2)); // Yellow is default color for widget4 m_DecorationColorWidget4[0] = 1.0f; m_DecorationColorWidget4[1] = 1.0f; m_DecorationColorWidget4[2] = 0.0f; // transfer colors in WorldGeometry-Nodes of the associated Renderer mitk::IntProperty::Pointer layer; // of widget 1 m_PlaneNode1 = mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetCurrentWorldPlaneGeometryNode(); m_PlaneNode1->SetColor(GetDecorationColor(0)); layer = mitk::IntProperty::New(1000); m_PlaneNode1->SetProperty("layer", layer); // ... of widget 2 m_PlaneNode2 = mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetCurrentWorldPlaneGeometryNode(); m_PlaneNode2->SetColor(GetDecorationColor(1)); layer = mitk::IntProperty::New(1000); m_PlaneNode2->SetProperty("layer", layer); // ... of widget 3 m_PlaneNode3 = mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetCurrentWorldPlaneGeometryNode(); m_PlaneNode3->SetColor(GetDecorationColor(2)); layer = mitk::IntProperty::New(1000); m_PlaneNode3->SetProperty("layer", layer); // The parent node m_ParentNodeForGeometryPlanes = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetCurrentWorldPlaneGeometryNode(); layer = mitk::IntProperty::New(1000); m_ParentNodeForGeometryPlanes->SetProperty("layer", layer); - mitk::OverlayManager::Pointer OverlayManager = mitk::OverlayManager::New(); - mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->SetOverlayManager(OverlayManager); - mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->SetOverlayManager(OverlayManager); - mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->SetOverlayManager(OverlayManager); - mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->SetOverlayManager(OverlayManager); - mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->SetMapperID(mitk::BaseRenderer::Standard3D); // Set plane mode (slicing/rotation behavior) to slicing (default) m_PlaneMode = PLANE_MODE_SLICING; // Set default view directions for SNCs mitkWidget1->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial); mitkWidget2->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal); mitkWidget3->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Frontal); mitkWidget4->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Original); SetDecorationProperties("Axial", GetDecorationColor(0), 0); SetDecorationProperties("Sagittal", GetDecorationColor(1), 1); SetDecorationProperties("Coronal", GetDecorationColor(2), 2); SetDecorationProperties("3D", GetDecorationColor(3), 3); // connect to the "time navigation controller": send time via sliceNavigationControllers m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget1->GetSliceNavigationController(), false); m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget2->GetSliceNavigationController(), false); m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget3->GetSliceNavigationController(), false); m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget4->GetSliceNavigationController(), false); mitkWidget1->GetSliceNavigationController()->ConnectGeometrySendEvent( mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())); // reverse connection between sliceNavigationControllers and m_TimeNavigationController mitkWidget1->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false); mitkWidget2->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false); mitkWidget3->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false); // mitkWidget4->GetSliceNavigationController() // ->ConnectGeometryTimeEvent(m_TimeNavigationController, false); m_MouseModeSwitcher = mitk::MouseModeSwitcher::New(); // setup the department logo rendering - m_LogoRendering = mitk::LogoOverlay::New(); + m_LogoRendering = mitk::LogoAnnotation::New(); mitk::BaseRenderer::Pointer renderer4 = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow()); m_LogoRendering->SetOpacity(0.5); mitk::Point2D offset; offset.Fill(0.03); m_LogoRendering->SetOffsetVector(offset); m_LogoRendering->SetRelativeSize(0.15); m_LogoRendering->SetCornerPosition(1); m_LogoRendering->SetLogoImagePath("DefaultLogo"); - renderer4->GetOverlayManager()->AddOverlay(m_LogoRendering.GetPointer(), renderer4); + mitk::ManualPlacementAnnotationRenderer::AddAnnotation(m_LogoRendering.GetPointer(), renderer4); } void QmitkStdMultiWidget::FillGradientBackgroundWithBlack() { // We have 4 widgets and ... for (unsigned int i = 0; i < 4; ++i) { float black[3] = {0.0f, 0.0f, 0.0f}; m_GradientBackgroundColors[i] = std::make_pair(mitk::Color(black), mitk::Color(black)); } } std::pair QmitkStdMultiWidget::GetGradientColors(unsigned int widgetNumber) { if (widgetNumber > 3) { MITK_ERROR << "Decoration color for unknown widget!"; float black[3] = {0.0f, 0.0f, 0.0f}; return std::make_pair(mitk::Color(black), mitk::Color(black)); } return m_GradientBackgroundColors[widgetNumber]; } mitk::Color QmitkStdMultiWidget::GetDecorationColor(unsigned int widgetNumber) { // The implementation looks a bit messy here, but it avoids // synchronization of the color of the geometry nodes and an // internal member here. // Default colors were chosen for decent visibitliy. // Feel free to change your preferences in the workbench. float tmp[3] = {0.0f, 0.0f, 0.0f}; switch (widgetNumber) { case 0: { if (m_PlaneNode1.IsNotNull()) { if (m_PlaneNode1->GetColor(tmp)) { return dynamic_cast(m_PlaneNode1->GetProperty("color"))->GetColor(); } } float red[3] = {0.753f, 0.0f, 0.0f}; // This is #C00000 in hex return mitk::Color(red); } case 1: { if (m_PlaneNode2.IsNotNull()) { if (m_PlaneNode2->GetColor(tmp)) { return dynamic_cast(m_PlaneNode2->GetProperty("color"))->GetColor(); } } float green[3] = {0.0f, 0.69f, 0.0f}; // This is #00B000 in hex return mitk::Color(green); } case 2: { if (m_PlaneNode3.IsNotNull()) { if (m_PlaneNode3->GetColor(tmp)) { return dynamic_cast(m_PlaneNode3->GetProperty("color"))->GetColor(); } } float blue[3] = {0.0, 0.502f, 1.0f}; // This is #0080FF in hex return mitk::Color(blue); } case 3: { return m_DecorationColorWidget4; } default: MITK_ERROR << "Decoration color for unknown widget!"; float black[3] = {0.0f, 0.0f, 0.0f}; return mitk::Color(black); } } std::string QmitkStdMultiWidget::GetCornerAnnotationText(unsigned int widgetNumber) { if (widgetNumber > 3) { MITK_ERROR << "Decoration color for unknown widget!"; return std::string(""); } return std::string(m_CornerAnnotations[widgetNumber]->GetText(0)); } QmitkStdMultiWidget::~QmitkStdMultiWidget() { DisablePositionTracking(); // DisableNavigationControllerEventListening(); m_TimeNavigationController->Disconnect(mitkWidget1->GetSliceNavigationController()); m_TimeNavigationController->Disconnect(mitkWidget2->GetSliceNavigationController()); m_TimeNavigationController->Disconnect(mitkWidget3->GetSliceNavigationController()); m_TimeNavigationController->Disconnect(mitkWidget4->GetSliceNavigationController()); } void QmitkStdMultiWidget::RemovePlanesFromDataStorage() { if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull() && m_PlaneNode3.IsNotNull() && m_ParentNodeForGeometryPlanes.IsNotNull()) { if (m_DataStorage.IsNotNull()) { m_DataStorage->Remove(m_PlaneNode1); m_DataStorage->Remove(m_PlaneNode2); m_DataStorage->Remove(m_PlaneNode3); m_DataStorage->Remove(m_ParentNodeForGeometryPlanes); } } } void QmitkStdMultiWidget::AddPlanesToDataStorage() { if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull() && m_PlaneNode3.IsNotNull() && m_ParentNodeForGeometryPlanes.IsNotNull()) { if (m_DataStorage.IsNotNull()) { m_DataStorage->Add(m_ParentNodeForGeometryPlanes); m_DataStorage->Add(m_PlaneNode1, m_ParentNodeForGeometryPlanes); m_DataStorage->Add(m_PlaneNode2, m_ParentNodeForGeometryPlanes); m_DataStorage->Add(m_PlaneNode3, m_ParentNodeForGeometryPlanes); } } } void QmitkStdMultiWidget::changeLayoutTo2DImagesUp() { SMW_INFO << "changing layout to 2D images up... " << std::endl; // Hide all Menu Widgets this->HideAllWidgetToolbars(); delete QmitkStdMultiWidgetLayout; // create Main Layout QmitkStdMultiWidgetLayout = new QHBoxLayout(this); // Set Layout to widget this->setLayout(QmitkStdMultiWidgetLayout); // create main splitter m_MainSplit = new QSplitter(this); QmitkStdMultiWidgetLayout->addWidget(m_MainSplit); // create m_LayoutSplit and add to the mainSplit m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit); m_MainSplit->addWidget(m_LayoutSplit); // add LevelWindow Widget to mainSplitter m_MainSplit->addWidget(levelWindowWidget); // create m_SubSplit1 and m_SubSplit2 m_SubSplit1 = new QSplitter(m_LayoutSplit); m_SubSplit2 = new QSplitter(m_LayoutSplit); // insert Widget Container into splitter top m_SubSplit1->addWidget(mitkWidget1Container); m_SubSplit1->addWidget(mitkWidget2Container); m_SubSplit1->addWidget(mitkWidget3Container); // set SplitterSize for splitter top QList splitterSize; splitterSize.push_back(1000); splitterSize.push_back(1000); splitterSize.push_back(1000); m_SubSplit1->setSizes(splitterSize); // insert Widget Container into splitter bottom m_SubSplit2->addWidget(mitkWidget4Container); // set SplitterSize for splitter m_LayoutSplit splitterSize.clear(); splitterSize.push_back(400); splitterSize.push_back(1000); m_LayoutSplit->setSizes(splitterSize); // show mainSplitt m_MainSplit->show(); // show Widget if hidden if (mitkWidget1->isHidden()) mitkWidget1->show(); if (mitkWidget2->isHidden()) mitkWidget2->show(); if (mitkWidget3->isHidden()) mitkWidget3->show(); if (mitkWidget4->isHidden()) mitkWidget4->show(); // Change Layout Name m_Layout = LAYOUT_2D_IMAGES_UP; // update Layout Design List mitkWidget1->LayoutDesignListChanged(LAYOUT_2D_IMAGES_UP); mitkWidget2->LayoutDesignListChanged(LAYOUT_2D_IMAGES_UP); mitkWidget3->LayoutDesignListChanged(LAYOUT_2D_IMAGES_UP); mitkWidget4->LayoutDesignListChanged(LAYOUT_2D_IMAGES_UP); // update Alle Widgets this->UpdateAllWidgets(); } void QmitkStdMultiWidget::changeLayoutTo2DImagesLeft() { SMW_INFO << "changing layout to 2D images left... " << std::endl; // Hide all Menu Widgets this->HideAllWidgetToolbars(); delete QmitkStdMultiWidgetLayout; // create Main Layout QmitkStdMultiWidgetLayout = new QHBoxLayout(this); // create main splitter m_MainSplit = new QSplitter(this); QmitkStdMultiWidgetLayout->addWidget(m_MainSplit); // create m_LayoutSplit and add to the mainSplit m_LayoutSplit = new QSplitter(m_MainSplit); m_MainSplit->addWidget(m_LayoutSplit); // add LevelWindow Widget to mainSplitter m_MainSplit->addWidget(levelWindowWidget); // create m_SubSplit1 and m_SubSplit2 m_SubSplit1 = new QSplitter(Qt::Vertical, m_LayoutSplit); m_SubSplit2 = new QSplitter(m_LayoutSplit); // insert Widget into the splitters m_SubSplit1->addWidget(mitkWidget1Container); m_SubSplit1->addWidget(mitkWidget2Container); m_SubSplit1->addWidget(mitkWidget3Container); // set splitterSize of SubSplit1 QList splitterSize; splitterSize.push_back(1000); splitterSize.push_back(1000); splitterSize.push_back(1000); m_SubSplit1->setSizes(splitterSize); m_SubSplit2->addWidget(mitkWidget4Container); // set splitterSize of Layout Split splitterSize.clear(); splitterSize.push_back(400); splitterSize.push_back(1000); m_LayoutSplit->setSizes(splitterSize); // show mainSplitt and add to Layout m_MainSplit->show(); // show Widget if hidden if (mitkWidget1->isHidden()) mitkWidget1->show(); if (mitkWidget2->isHidden()) mitkWidget2->show(); if (mitkWidget3->isHidden()) mitkWidget3->show(); if (mitkWidget4->isHidden()) mitkWidget4->show(); // update Layout Name m_Layout = LAYOUT_2D_IMAGES_LEFT; // update Layout Design List mitkWidget1->LayoutDesignListChanged(LAYOUT_2D_IMAGES_LEFT); mitkWidget2->LayoutDesignListChanged(LAYOUT_2D_IMAGES_LEFT); mitkWidget3->LayoutDesignListChanged(LAYOUT_2D_IMAGES_LEFT); mitkWidget4->LayoutDesignListChanged(LAYOUT_2D_IMAGES_LEFT); // update Alle Widgets this->UpdateAllWidgets(); } void QmitkStdMultiWidget::SetDecorationProperties(std::string text, mitk::Color color, int widgetNumber) { if (widgetNumber > 3) { MITK_ERROR << "Unknown render window for annotation."; return; } vtkRenderer *renderer = this->GetRenderWindow(widgetNumber)->GetRenderer()->GetVtkRenderer(); if (!renderer) return; vtkSmartPointer annotation = m_CornerAnnotations[widgetNumber]; annotation->SetText(0, text.c_str()); annotation->SetMaximumFontSize(12); annotation->GetTextProperty()->SetColor(color[0], color[1], color[2]); if (!renderer->HasViewProp(annotation)) { renderer->AddViewProp(annotation); } vtkSmartPointer frame = m_RectangleProps[widgetNumber]; frame->SetColor(color[0], color[1], color[2]); if (!renderer->HasViewProp(frame)) { renderer->AddViewProp(frame); } } void QmitkStdMultiWidget::SetCornerAnnotationVisibility(bool visibility) { for (int i = 0; i < 4; ++i) { m_CornerAnnotations[i]->SetVisibility(visibility); } } bool QmitkStdMultiWidget::IsCornerAnnotationVisible(void) const { return m_CornerAnnotations[0]->GetVisibility() > 0; } QmitkRenderWindow *QmitkStdMultiWidget::GetRenderWindow(unsigned int number) { switch (number) { case 0: return this->GetRenderWindow1(); case 1: return this->GetRenderWindow2(); case 2: return this->GetRenderWindow3(); case 3: return this->GetRenderWindow4(); default: MITK_ERROR << "Requested unknown render window"; break; } return NULL; } void QmitkStdMultiWidget::changeLayoutToDefault() { SMW_INFO << "changing layout to default... " << std::endl; // Hide all Menu Widgets this->HideAllWidgetToolbars(); delete QmitkStdMultiWidgetLayout; // create Main Layout QmitkStdMultiWidgetLayout = new QHBoxLayout(this); // create main splitter m_MainSplit = new QSplitter(this); QmitkStdMultiWidgetLayout->addWidget(m_MainSplit); // create m_LayoutSplit and add to the mainSplit m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit); m_MainSplit->addWidget(m_LayoutSplit); // add LevelWindow Widget to mainSplitter m_MainSplit->addWidget(levelWindowWidget); // create m_SubSplit1 and m_SubSplit2 m_SubSplit1 = new QSplitter(m_LayoutSplit); m_SubSplit2 = new QSplitter(m_LayoutSplit); // insert Widget container into the splitters m_SubSplit1->addWidget(mitkWidget1Container); m_SubSplit1->addWidget(mitkWidget2Container); m_SubSplit2->addWidget(mitkWidget3Container); m_SubSplit2->addWidget(mitkWidget4Container); // set splitter Size QList splitterSize; splitterSize.push_back(1000); splitterSize.push_back(1000); m_SubSplit1->setSizes(splitterSize); m_SubSplit2->setSizes(splitterSize); m_LayoutSplit->setSizes(splitterSize); // show mainSplitt and add to Layout m_MainSplit->show(); // show Widget if hidden if (mitkWidget1->isHidden()) mitkWidget1->show(); if (mitkWidget2->isHidden()) mitkWidget2->show(); if (mitkWidget3->isHidden()) mitkWidget3->show(); if (mitkWidget4->isHidden()) mitkWidget4->show(); m_Layout = LAYOUT_DEFAULT; // update Layout Design List mitkWidget1->LayoutDesignListChanged(LAYOUT_DEFAULT); mitkWidget2->LayoutDesignListChanged(LAYOUT_DEFAULT); mitkWidget3->LayoutDesignListChanged(LAYOUT_DEFAULT); mitkWidget4->LayoutDesignListChanged(LAYOUT_DEFAULT); // update Alle Widgets this->UpdateAllWidgets(); } void QmitkStdMultiWidget::changeLayoutToBig3D() { SMW_INFO << "changing layout to big 3D ..." << std::endl; // Hide all Menu Widgets this->HideAllWidgetToolbars(); delete QmitkStdMultiWidgetLayout; // create Main Layout QmitkStdMultiWidgetLayout = new QHBoxLayout(this); // create main splitter m_MainSplit = new QSplitter(this); QmitkStdMultiWidgetLayout->addWidget(m_MainSplit); // add widget Splitter to main Splitter m_MainSplit->addWidget(mitkWidget4Container); // add LevelWindow Widget to mainSplitter m_MainSplit->addWidget(levelWindowWidget); // show mainSplitt and add to Layout m_MainSplit->show(); // show/hide Widgets mitkWidget1->hide(); mitkWidget2->hide(); mitkWidget3->hide(); if (mitkWidget4->isHidden()) mitkWidget4->show(); m_Layout = LAYOUT_BIG_3D; // update Layout Design List mitkWidget1->LayoutDesignListChanged(LAYOUT_BIG_3D); mitkWidget2->LayoutDesignListChanged(LAYOUT_BIG_3D); mitkWidget3->LayoutDesignListChanged(LAYOUT_BIG_3D); mitkWidget4->LayoutDesignListChanged(LAYOUT_BIG_3D); // update Alle Widgets this->UpdateAllWidgets(); mitk::RenderingManager::GetInstance()->SetRenderWindowFocus(mitkWidget4->GetVtkRenderWindow()); } void QmitkStdMultiWidget::changeLayoutToWidget1() { SMW_INFO << "changing layout to big Widget1 ..." << std::endl; // Hide all Menu Widgets this->HideAllWidgetToolbars(); delete QmitkStdMultiWidgetLayout; // create Main Layout QmitkStdMultiWidgetLayout = new QHBoxLayout(this); // create main splitter m_MainSplit = new QSplitter(this); QmitkStdMultiWidgetLayout->addWidget(m_MainSplit); // add widget Splitter to main Splitter m_MainSplit->addWidget(mitkWidget1Container); // add LevelWindow Widget to mainSplitter m_MainSplit->addWidget(levelWindowWidget); // show mainSplitt and add to Layout m_MainSplit->show(); // show/hide Widgets if (mitkWidget1->isHidden()) mitkWidget1->show(); mitkWidget2->hide(); mitkWidget3->hide(); mitkWidget4->hide(); m_Layout = LAYOUT_WIDGET1; // update Layout Design List mitkWidget1->LayoutDesignListChanged(LAYOUT_WIDGET1); mitkWidget2->LayoutDesignListChanged(LAYOUT_WIDGET1); mitkWidget3->LayoutDesignListChanged(LAYOUT_WIDGET1); mitkWidget4->LayoutDesignListChanged(LAYOUT_WIDGET1); // update Alle Widgets this->UpdateAllWidgets(); mitk::RenderingManager::GetInstance()->SetRenderWindowFocus(mitkWidget1->GetVtkRenderWindow()); } void QmitkStdMultiWidget::changeLayoutToWidget2() { SMW_INFO << "changing layout to big Widget2 ..." << std::endl; // Hide all Menu Widgets this->HideAllWidgetToolbars(); delete QmitkStdMultiWidgetLayout; // create Main Layout QmitkStdMultiWidgetLayout = new QHBoxLayout(this); // create main splitter m_MainSplit = new QSplitter(this); QmitkStdMultiWidgetLayout->addWidget(m_MainSplit); // add widget Splitter to main Splitter m_MainSplit->addWidget(mitkWidget2Container); // add LevelWindow Widget to mainSplitter m_MainSplit->addWidget(levelWindowWidget); // show mainSplitt and add to Layout m_MainSplit->show(); // show/hide Widgets mitkWidget1->hide(); if (mitkWidget2->isHidden()) mitkWidget2->show(); mitkWidget3->hide(); mitkWidget4->hide(); m_Layout = LAYOUT_WIDGET2; // update Layout Design List mitkWidget1->LayoutDesignListChanged(LAYOUT_WIDGET2); mitkWidget2->LayoutDesignListChanged(LAYOUT_WIDGET2); mitkWidget3->LayoutDesignListChanged(LAYOUT_WIDGET2); mitkWidget4->LayoutDesignListChanged(LAYOUT_WIDGET2); // update Alle Widgets this->UpdateAllWidgets(); mitk::RenderingManager::GetInstance()->SetRenderWindowFocus(mitkWidget2->GetVtkRenderWindow()); } void QmitkStdMultiWidget::changeLayoutToWidget3() { SMW_INFO << "changing layout to big Widget3 ..." << std::endl; // Hide all Menu Widgets this->HideAllWidgetToolbars(); delete QmitkStdMultiWidgetLayout; // create Main Layout QmitkStdMultiWidgetLayout = new QHBoxLayout(this); // create main splitter m_MainSplit = new QSplitter(this); QmitkStdMultiWidgetLayout->addWidget(m_MainSplit); // add widget Splitter to main Splitter m_MainSplit->addWidget(mitkWidget3Container); // add LevelWindow Widget to mainSplitter m_MainSplit->addWidget(levelWindowWidget); // show mainSplitt and add to Layout m_MainSplit->show(); // show/hide Widgets mitkWidget1->hide(); mitkWidget2->hide(); if (mitkWidget3->isHidden()) mitkWidget3->show(); mitkWidget4->hide(); m_Layout = LAYOUT_WIDGET3; // update Layout Design List mitkWidget1->LayoutDesignListChanged(LAYOUT_WIDGET3); mitkWidget2->LayoutDesignListChanged(LAYOUT_WIDGET3); mitkWidget3->LayoutDesignListChanged(LAYOUT_WIDGET3); mitkWidget4->LayoutDesignListChanged(LAYOUT_WIDGET3); // update Alle Widgets this->UpdateAllWidgets(); mitk::RenderingManager::GetInstance()->SetRenderWindowFocus(mitkWidget3->GetVtkRenderWindow()); } void QmitkStdMultiWidget::changeLayoutToRowWidget3And4() { SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl; // Hide all Menu Widgets this->HideAllWidgetToolbars(); delete QmitkStdMultiWidgetLayout; // create Main Layout QmitkStdMultiWidgetLayout = new QHBoxLayout(this); // create main splitter m_MainSplit = new QSplitter(this); QmitkStdMultiWidgetLayout->addWidget(m_MainSplit); // create m_LayoutSplit and add to the mainSplit m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit); m_MainSplit->addWidget(m_LayoutSplit); // add LevelWindow Widget to mainSplitter m_MainSplit->addWidget(levelWindowWidget); // add Widgets to splitter m_LayoutSplit->addWidget(mitkWidget3Container); m_LayoutSplit->addWidget(mitkWidget4Container); // set Splitter Size QList splitterSize; splitterSize.push_back(1000); splitterSize.push_back(1000); m_LayoutSplit->setSizes(splitterSize); // show mainSplitt and add to Layout m_MainSplit->show(); // show/hide Widgets mitkWidget1->hide(); mitkWidget2->hide(); if (mitkWidget3->isHidden()) mitkWidget3->show(); if (mitkWidget4->isHidden()) mitkWidget4->show(); m_Layout = LAYOUT_ROW_WIDGET_3_AND_4; // update Layout Design List mitkWidget1->LayoutDesignListChanged(LAYOUT_ROW_WIDGET_3_AND_4); mitkWidget2->LayoutDesignListChanged(LAYOUT_ROW_WIDGET_3_AND_4); mitkWidget3->LayoutDesignListChanged(LAYOUT_ROW_WIDGET_3_AND_4); mitkWidget4->LayoutDesignListChanged(LAYOUT_ROW_WIDGET_3_AND_4); // update Alle Widgets this->UpdateAllWidgets(); } void QmitkStdMultiWidget::changeLayoutToColumnWidget3And4() { SMW_INFO << "changing layout to Widget3 and 4 in one Column..." << std::endl; // Hide all Menu Widgets this->HideAllWidgetToolbars(); delete QmitkStdMultiWidgetLayout; // create Main Layout QmitkStdMultiWidgetLayout = new QHBoxLayout(this); // create main splitter m_MainSplit = new QSplitter(this); QmitkStdMultiWidgetLayout->addWidget(m_MainSplit); // create m_LayoutSplit and add to the mainSplit m_LayoutSplit = new QSplitter(m_MainSplit); m_MainSplit->addWidget(m_LayoutSplit); // add LevelWindow Widget to mainSplitter m_MainSplit->addWidget(levelWindowWidget); // add Widgets to splitter m_LayoutSplit->addWidget(mitkWidget3Container); m_LayoutSplit->addWidget(mitkWidget4Container); // set SplitterSize QList splitterSize; splitterSize.push_back(1000); splitterSize.push_back(1000); m_LayoutSplit->setSizes(splitterSize); // show mainSplitt and add to Layout m_MainSplit->show(); // show/hide Widgets mitkWidget1->hide(); mitkWidget2->hide(); if (mitkWidget3->isHidden()) mitkWidget3->show(); if (mitkWidget4->isHidden()) mitkWidget4->show(); m_Layout = LAYOUT_COLUMN_WIDGET_3_AND_4; // update Layout Design List mitkWidget1->LayoutDesignListChanged(LAYOUT_COLUMN_WIDGET_3_AND_4); mitkWidget2->LayoutDesignListChanged(LAYOUT_COLUMN_WIDGET_3_AND_4); mitkWidget3->LayoutDesignListChanged(LAYOUT_COLUMN_WIDGET_3_AND_4); mitkWidget4->LayoutDesignListChanged(LAYOUT_COLUMN_WIDGET_3_AND_4); // update Alle Widgets this->UpdateAllWidgets(); } void QmitkStdMultiWidget::changeLayoutToRowWidgetSmall3andBig4() { SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl; this->changeLayoutToRowWidget3And4(); m_Layout = LAYOUT_ROW_WIDGET_SMALL3_AND_BIG4; } void QmitkStdMultiWidget::changeLayoutToSmallUpperWidget2Big3and4() { SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl; // Hide all Menu Widgets this->HideAllWidgetToolbars(); delete QmitkStdMultiWidgetLayout; // create Main Layout QmitkStdMultiWidgetLayout = new QHBoxLayout(this); // create main splitter m_MainSplit = new QSplitter(this); QmitkStdMultiWidgetLayout->addWidget(m_MainSplit); // create m_LayoutSplit and add to the mainSplit m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit); m_MainSplit->addWidget(m_LayoutSplit); // add LevelWindow Widget to mainSplitter m_MainSplit->addWidget(levelWindowWidget); // create m_SubSplit1 and m_SubSplit2 m_SubSplit1 = new QSplitter(Qt::Vertical, m_LayoutSplit); m_SubSplit2 = new QSplitter(m_LayoutSplit); // insert Widget into the splitters m_SubSplit1->addWidget(mitkWidget2Container); m_SubSplit2->addWidget(mitkWidget3Container); m_SubSplit2->addWidget(mitkWidget4Container); // set Splitter Size QList splitterSize; splitterSize.push_back(1000); splitterSize.push_back(1000); m_SubSplit2->setSizes(splitterSize); splitterSize.clear(); splitterSize.push_back(500); splitterSize.push_back(1000); m_LayoutSplit->setSizes(splitterSize); // show mainSplitt m_MainSplit->show(); // show Widget if hidden mitkWidget1->hide(); if (mitkWidget2->isHidden()) mitkWidget2->show(); if (mitkWidget3->isHidden()) mitkWidget3->show(); if (mitkWidget4->isHidden()) mitkWidget4->show(); m_Layout = LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4; // update Layout Design List mitkWidget1->LayoutDesignListChanged(LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4); mitkWidget2->LayoutDesignListChanged(LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4); mitkWidget3->LayoutDesignListChanged(LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4); mitkWidget4->LayoutDesignListChanged(LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4); // update Alle Widgets this->UpdateAllWidgets(); } void QmitkStdMultiWidget::changeLayoutTo2x2Dand3DWidget() { SMW_INFO << "changing layout to 2 x 2D and 3D Widget" << std::endl; // Hide all Menu Widgets this->HideAllWidgetToolbars(); delete QmitkStdMultiWidgetLayout; // create Main Layout QmitkStdMultiWidgetLayout = new QHBoxLayout(this); // create main splitter m_MainSplit = new QSplitter(this); QmitkStdMultiWidgetLayout->addWidget(m_MainSplit); // create m_LayoutSplit and add to the mainSplit m_LayoutSplit = new QSplitter(m_MainSplit); m_MainSplit->addWidget(m_LayoutSplit); // add LevelWindow Widget to mainSplitter m_MainSplit->addWidget(levelWindowWidget); // create m_SubSplit1 and m_SubSplit2 m_SubSplit1 = new QSplitter(Qt::Vertical, m_LayoutSplit); m_SubSplit2 = new QSplitter(m_LayoutSplit); // add Widgets to splitter m_SubSplit1->addWidget(mitkWidget1Container); m_SubSplit1->addWidget(mitkWidget2Container); m_SubSplit2->addWidget(mitkWidget4Container); // set Splitter Size QList splitterSize; splitterSize.push_back(1000); splitterSize.push_back(1000); m_SubSplit1->setSizes(splitterSize); m_LayoutSplit->setSizes(splitterSize); // show mainSplitt and add to Layout m_MainSplit->show(); // show/hide Widgets if (mitkWidget1->isHidden()) mitkWidget1->show(); if (mitkWidget2->isHidden()) mitkWidget2->show(); mitkWidget3->hide(); if (mitkWidget4->isHidden()) mitkWidget4->show(); m_Layout = LAYOUT_2X_2D_AND_3D_WIDGET; // update Layout Design List mitkWidget1->LayoutDesignListChanged(LAYOUT_2X_2D_AND_3D_WIDGET); mitkWidget2->LayoutDesignListChanged(LAYOUT_2X_2D_AND_3D_WIDGET); mitkWidget3->LayoutDesignListChanged(LAYOUT_2X_2D_AND_3D_WIDGET); mitkWidget4->LayoutDesignListChanged(LAYOUT_2X_2D_AND_3D_WIDGET); // update Alle Widgets this->UpdateAllWidgets(); } void QmitkStdMultiWidget::changeLayoutToLeft2Dand3DRight2D() { SMW_INFO << "changing layout to 2D and 3D left, 2D right Widget" << std::endl; // Hide all Menu Widgets this->HideAllWidgetToolbars(); delete QmitkStdMultiWidgetLayout; // create Main Layout QmitkStdMultiWidgetLayout = new QHBoxLayout(this); // create main splitter m_MainSplit = new QSplitter(this); QmitkStdMultiWidgetLayout->addWidget(m_MainSplit); // create m_LayoutSplit and add to the mainSplit m_LayoutSplit = new QSplitter(m_MainSplit); m_MainSplit->addWidget(m_LayoutSplit); // add LevelWindow Widget to mainSplitter m_MainSplit->addWidget(levelWindowWidget); // create m_SubSplit1 and m_SubSplit2 m_SubSplit1 = new QSplitter(Qt::Vertical, m_LayoutSplit); m_SubSplit2 = new QSplitter(m_LayoutSplit); // add Widgets to splitter m_SubSplit1->addWidget(mitkWidget1Container); m_SubSplit1->addWidget(mitkWidget4Container); m_SubSplit2->addWidget(mitkWidget2Container); // set Splitter Size QList splitterSize; splitterSize.push_back(1000); splitterSize.push_back(1000); m_SubSplit1->setSizes(splitterSize); m_LayoutSplit->setSizes(splitterSize); // show mainSplitt and add to Layout m_MainSplit->show(); // show/hide Widgets if (mitkWidget1->isHidden()) mitkWidget1->show(); if (mitkWidget2->isHidden()) mitkWidget2->show(); mitkWidget3->hide(); if (mitkWidget4->isHidden()) mitkWidget4->show(); m_Layout = LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET; // update Layout Design List mitkWidget1->LayoutDesignListChanged(LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET); mitkWidget2->LayoutDesignListChanged(LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET); mitkWidget3->LayoutDesignListChanged(LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET); mitkWidget4->LayoutDesignListChanged(LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET); // update Alle Widgets this->UpdateAllWidgets(); } void QmitkStdMultiWidget::changeLayoutTo2DUpAnd3DDown() { SMW_INFO << "changing layout to 2D up and 3D down" << std::endl; // Hide all Menu Widgets this->HideAllWidgetToolbars(); delete QmitkStdMultiWidgetLayout; // create Main Layout QmitkStdMultiWidgetLayout = new QHBoxLayout(this); // Set Layout to widget this->setLayout(QmitkStdMultiWidgetLayout); // create main splitter m_MainSplit = new QSplitter(this); QmitkStdMultiWidgetLayout->addWidget(m_MainSplit); // create m_LayoutSplit and add to the mainSplit m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit); m_MainSplit->addWidget(m_LayoutSplit); // add LevelWindow Widget to mainSplitter m_MainSplit->addWidget(levelWindowWidget); // create m_SubSplit1 and m_SubSplit2 m_SubSplit1 = new QSplitter(m_LayoutSplit); m_SubSplit2 = new QSplitter(m_LayoutSplit); // insert Widget Container into splitter top m_SubSplit1->addWidget(mitkWidget1Container); // set SplitterSize for splitter top QList splitterSize; // insert Widget Container into splitter bottom m_SubSplit2->addWidget(mitkWidget4Container); // set SplitterSize for splitter m_LayoutSplit splitterSize.clear(); splitterSize.push_back(700); splitterSize.push_back(700); m_LayoutSplit->setSizes(splitterSize); // show mainSplitt m_MainSplit->show(); // show/hide Widgets if (mitkWidget1->isHidden()) mitkWidget1->show(); mitkWidget2->hide(); mitkWidget3->hide(); if (mitkWidget4->isHidden()) mitkWidget4->show(); m_Layout = LAYOUT_2D_UP_AND_3D_DOWN; // update Layout Design List mitkWidget1->LayoutDesignListChanged(LAYOUT_2D_UP_AND_3D_DOWN); mitkWidget2->LayoutDesignListChanged(LAYOUT_2D_UP_AND_3D_DOWN); mitkWidget3->LayoutDesignListChanged(LAYOUT_2D_UP_AND_3D_DOWN); mitkWidget4->LayoutDesignListChanged(LAYOUT_2D_UP_AND_3D_DOWN); // update all Widgets this->UpdateAllWidgets(); } void QmitkStdMultiWidget::SetDataStorage(mitk::DataStorage *ds) { if (ds == m_DataStorage) { return; } mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->SetDataStorage(ds); mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->SetDataStorage(ds); mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->SetDataStorage(ds); mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->SetDataStorage(ds); m_DataStorage = ds; } void QmitkStdMultiWidget::Fit() { vtkSmartPointer vtkrenderer; vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetVtkRenderer(); if (vtkrenderer != NULL) vtkrenderer->ResetCamera(); vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetVtkRenderer(); if (vtkrenderer != NULL) vtkrenderer->ResetCamera(); vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetVtkRenderer(); if (vtkrenderer != NULL) vtkrenderer->ResetCamera(); vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetVtkRenderer(); if (vtkrenderer != NULL) vtkrenderer->ResetCamera(); mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetCameraController()->Fit(); mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetCameraController()->Fit(); mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetCameraController()->Fit(); mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetCameraController()->Fit(); int w = vtkObject::GetGlobalWarningDisplay(); vtkObject::GlobalWarningDisplayOff(); vtkObject::SetGlobalWarningDisplay(w); } void QmitkStdMultiWidget::InitPositionTracking() { // TODO POSITIONTRACKER } void QmitkStdMultiWidget::AddDisplayPlaneSubTree() { // add the displayed planes of the multiwidget to a node to which the subtree // @a planesSubTree points ... mitk::PlaneGeometryDataMapper2D::Pointer mapper; // ... of widget 1 mitk::BaseRenderer *renderer1 = mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow()); m_PlaneNode1 = renderer1->GetCurrentWorldPlaneGeometryNode(); m_PlaneNode1->SetProperty("visible", mitk::BoolProperty::New(true)); m_PlaneNode1->SetProperty("name", mitk::StringProperty::New(std::string(renderer1->GetName()) + ".plane")); m_PlaneNode1->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false)); m_PlaneNode1->SetProperty("helper object", mitk::BoolProperty::New(true)); mapper = mitk::PlaneGeometryDataMapper2D::New(); m_PlaneNode1->SetMapper(mitk::BaseRenderer::Standard2D, mapper); // ... of widget 2 mitk::BaseRenderer *renderer2 = mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow()); m_PlaneNode2 = renderer2->GetCurrentWorldPlaneGeometryNode(); m_PlaneNode2->SetProperty("visible", mitk::BoolProperty::New(true)); m_PlaneNode2->SetProperty("name", mitk::StringProperty::New(std::string(renderer2->GetName()) + ".plane")); m_PlaneNode2->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false)); m_PlaneNode2->SetProperty("helper object", mitk::BoolProperty::New(true)); mapper = mitk::PlaneGeometryDataMapper2D::New(); m_PlaneNode2->SetMapper(mitk::BaseRenderer::Standard2D, mapper); // ... of widget 3 mitk::BaseRenderer *renderer3 = mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow()); m_PlaneNode3 = renderer3->GetCurrentWorldPlaneGeometryNode(); m_PlaneNode3->SetProperty("visible", mitk::BoolProperty::New(true)); m_PlaneNode3->SetProperty("name", mitk::StringProperty::New(std::string(renderer3->GetName()) + ".plane")); m_PlaneNode3->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false)); m_PlaneNode3->SetProperty("helper object", mitk::BoolProperty::New(true)); mapper = mitk::PlaneGeometryDataMapper2D::New(); m_PlaneNode3->SetMapper(mitk::BaseRenderer::Standard2D, mapper); m_ParentNodeForGeometryPlanes = mitk::DataNode::New(); m_ParentNodeForGeometryPlanes->SetProperty("name", mitk::StringProperty::New("Widgets")); m_ParentNodeForGeometryPlanes->SetProperty("helper object", mitk::BoolProperty::New(true)); } mitk::SliceNavigationController *QmitkStdMultiWidget::GetTimeNavigationController() { return m_TimeNavigationController; } void QmitkStdMultiWidget::EnableStandardLevelWindow() { levelWindowWidget->disconnect(this); levelWindowWidget->SetDataStorage(mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetDataStorage()); levelWindowWidget->show(); } void QmitkStdMultiWidget::DisableStandardLevelWindow() { levelWindowWidget->disconnect(this); levelWindowWidget->hide(); } // CAUTION: Legacy code for enabling Qt-signal-controlled view initialization. // Use RenderingManager::InitializeViews() instead. bool QmitkStdMultiWidget::InitializeStandardViews(const mitk::Geometry3D *geometry) { return m_RenderingManager->InitializeViews(geometry); } void QmitkStdMultiWidget::RequestUpdate() { m_RenderingManager->RequestUpdate(mitkWidget1->GetRenderWindow()); m_RenderingManager->RequestUpdate(mitkWidget2->GetRenderWindow()); m_RenderingManager->RequestUpdate(mitkWidget3->GetRenderWindow()); m_RenderingManager->RequestUpdate(mitkWidget4->GetRenderWindow()); } void QmitkStdMultiWidget::ForceImmediateUpdate() { m_RenderingManager->ForceImmediateUpdate(mitkWidget1->GetRenderWindow()); m_RenderingManager->ForceImmediateUpdate(mitkWidget2->GetRenderWindow()); m_RenderingManager->ForceImmediateUpdate(mitkWidget3->GetRenderWindow()); m_RenderingManager->ForceImmediateUpdate(mitkWidget4->GetRenderWindow()); } void QmitkStdMultiWidget::wheelEvent(QWheelEvent *e) { emit WheelMoved(e); } void QmitkStdMultiWidget::mousePressEvent(QMouseEvent *e) { } void QmitkStdMultiWidget::moveEvent(QMoveEvent *e) { QWidget::moveEvent(e); - // it is necessary to readjust the position of the overlays as the StdMultiWidget has moved + // it is necessary to readjust the position of the Annotation as the StdMultiWidget has moved // unfortunately it's not done by QmitkRenderWindow::moveEvent -> must be done here emit Moved(); } QmitkRenderWindow *QmitkStdMultiWidget::GetRenderWindow1() const { return mitkWidget1; } QmitkRenderWindow *QmitkStdMultiWidget::GetRenderWindow2() const { return mitkWidget2; } QmitkRenderWindow *QmitkStdMultiWidget::GetRenderWindow3() const { return mitkWidget3; } QmitkRenderWindow *QmitkStdMultiWidget::GetRenderWindow4() const { return mitkWidget4; } const mitk::Point3D QmitkStdMultiWidget::GetCrossPosition() const { const mitk::PlaneGeometry *plane1 = mitkWidget1->GetSliceNavigationController()->GetCurrentPlaneGeometry(); const mitk::PlaneGeometry *plane2 = mitkWidget2->GetSliceNavigationController()->GetCurrentPlaneGeometry(); const mitk::PlaneGeometry *plane3 = mitkWidget3->GetSliceNavigationController()->GetCurrentPlaneGeometry(); mitk::Line3D line; if ((plane1 != NULL) && (plane2 != NULL) && (plane1->IntersectionLine(plane2, line))) { mitk::Point3D point; if ((plane3 != NULL) && (plane3->IntersectionPoint(line, point))) { return point; } } // TODO BUG POSITIONTRACKER; mitk::Point3D p; return p; // return m_LastLeftClickPositionSupplier->GetCurrentPoint(); } void QmitkStdMultiWidget::EnablePositionTracking() { } void QmitkStdMultiWidget::DisablePositionTracking() { } void QmitkStdMultiWidget::EnsureDisplayContainsPoint(mitk::BaseRenderer *renderer, const mitk::Point3D &p) { mitk::Point2D pointOnDisplay; renderer->WorldToDisplay(p, pointOnDisplay); if (pointOnDisplay[0] < renderer->GetVtkRenderer()->GetOrigin()[0] || pointOnDisplay[1] < renderer->GetVtkRenderer()->GetOrigin()[1] || pointOnDisplay[0] > renderer->GetVtkRenderer()->GetOrigin()[0] + renderer->GetViewportSize()[0] || pointOnDisplay[1] > renderer->GetVtkRenderer()->GetOrigin()[1] + renderer->GetViewportSize()[1]) { mitk::Point2D pointOnPlane; renderer->GetCurrentWorldPlaneGeometry()->Map(p, pointOnPlane); renderer->GetCameraController()->MoveCameraToPoint(pointOnPlane); } } void QmitkStdMultiWidget::MoveCrossToPosition(const mitk::Point3D &newPosition) { mitkWidget1->GetSliceNavigationController()->SelectSliceByPoint(newPosition); mitkWidget2->GetSliceNavigationController()->SelectSliceByPoint(newPosition); mitkWidget3->GetSliceNavigationController()->SelectSliceByPoint(newPosition); m_RenderingManager->RequestUpdateAll(); } void QmitkStdMultiWidget::HandleCrosshairPositionEvent() { if (!m_PendingCrosshairPositionEvent) { m_PendingCrosshairPositionEvent = true; QTimer::singleShot(0, this, SLOT(HandleCrosshairPositionEventDelayed())); } } mitk::DataNode::Pointer QmitkStdMultiWidget::GetTopLayerNode(mitk::DataStorage::SetOfObjects::ConstPointer nodes) { mitk::Point3D crosshairPos = this->GetCrossPosition(); mitk::DataNode::Pointer node; int maxlayer = -32768; if (nodes.IsNotNull()) { mitk::BaseRenderer *baseRenderer = this->mitkWidget1->GetSliceNavigationController()->GetRenderer(); // find node with largest layer, that is the node shown on top in the render window for (unsigned int x = 0; x < nodes->size(); x++) { if ((nodes->at(x)->GetData()->GetGeometry() != NULL) && nodes->at(x)->GetData()->GetGeometry()->IsInside(crosshairPos)) { int layer = 0; if (!(nodes->at(x)->GetIntProperty("layer", layer))) continue; if (layer > maxlayer) { if (static_cast(nodes->at(x))->IsVisible(baseRenderer)) { node = nodes->at(x); maxlayer = layer; } } } } } return node; } void QmitkStdMultiWidget::HandleCrosshairPositionEventDelayed() { m_PendingCrosshairPositionEvent = false; // find image with highest layer mitk::TNodePredicateDataType::Pointer isImageData = mitk::TNodePredicateDataType::New(); mitk::DataStorage::SetOfObjects::ConstPointer nodes = this->m_DataStorage->GetSubset(isImageData).GetPointer(); mitk::DataNode::Pointer node; mitk::DataNode::Pointer topSourceNode; mitk::Image::Pointer image; bool isBinary = false; node = this->GetTopLayerNode(nodes); int component = 0; if (node.IsNotNull()) { node->GetBoolProperty("binary", isBinary); if (isBinary) { mitk::DataStorage::SetOfObjects::ConstPointer sourcenodes = m_DataStorage->GetSources(node, NULL, true); if (!sourcenodes->empty()) { topSourceNode = this->GetTopLayerNode(sourcenodes); } if (topSourceNode.IsNotNull()) { image = dynamic_cast(topSourceNode->GetData()); topSourceNode->GetIntProperty("Image.Displayed Component", component); } else { image = dynamic_cast(node->GetData()); node->GetIntProperty("Image.Displayed Component", component); } } else { image = dynamic_cast(node->GetData()); node->GetIntProperty("Image.Displayed Component", component); } } mitk::Point3D crosshairPos = this->GetCrossPosition(); std::string statusText; std::stringstream stream; itk::Index<3> p; mitk::BaseRenderer *baseRenderer = this->mitkWidget1->GetSliceNavigationController()->GetRenderer(); unsigned int timestep = baseRenderer->GetTimeStep(); if (image.IsNotNull() && (image->GetTimeSteps() > timestep)) { image->GetGeometry()->WorldToIndex(crosshairPos, p); stream.precision(2); stream << "Position: <" << std::fixed << crosshairPos[0] << ", " << std::fixed << crosshairPos[1] << ", " << std::fixed << crosshairPos[2] << "> mm"; stream << "; Index: <" << p[0] << ", " << p[1] << ", " << p[2] << "> "; mitk::ScalarType pixelValue; mitkPixelTypeMultiplex5(mitk::FastSinglePixelAccess, image->GetChannelDescriptor().GetPixelType(), image, image->GetVolumeData(baseRenderer->GetTimeStep()), p, pixelValue, component); if (fabs(pixelValue) > 1000000 || fabs(pixelValue) < 0.01) { stream << "; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: " << std::scientific << pixelValue << " "; } else { stream << "; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: " << pixelValue << " "; } } else { stream << "No image information at this position!"; } statusText = stream.str(); mitk::StatusBar::GetInstance()->DisplayGreyValueText(statusText.c_str()); } int QmitkStdMultiWidget::GetLayout() const { return m_Layout; } bool QmitkStdMultiWidget::GetGradientBackgroundFlag() const { return m_GradientBackgroundFlag; } void QmitkStdMultiWidget::EnableGradientBackground() { // gradient background is by default only in widget 4, otherwise // interferences between 2D rendering and VTK rendering may occur. for (unsigned int i = 0; i < 4; ++i) { GetRenderWindow(i)->GetRenderer()->GetVtkRenderer()->GradientBackgroundOn(); } m_GradientBackgroundFlag = true; } void QmitkStdMultiWidget::DisableGradientBackground() { for (unsigned int i = 0; i < 4; ++i) { GetRenderWindow(i)->GetRenderer()->GetVtkRenderer()->GradientBackgroundOff(); } m_GradientBackgroundFlag = false; } void QmitkStdMultiWidget::EnableDepartmentLogo() { m_LogoRendering->SetVisibility(true); RequestUpdate(); } void QmitkStdMultiWidget::DisableDepartmentLogo() { m_LogoRendering->SetVisibility(false); RequestUpdate(); } bool QmitkStdMultiWidget::IsDepartmentLogoEnabled() const { - return m_LogoRendering->IsVisible(mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())); + return m_LogoRendering->IsVisible(); } void QmitkStdMultiWidget::SetWidgetPlaneVisibility(const char *widgetName, bool visible, mitk::BaseRenderer *renderer) { if (m_DataStorage.IsNotNull()) { mitk::DataNode *n = m_DataStorage->GetNamedNode(widgetName); if (n != NULL) n->SetVisibility(visible, renderer); } } void QmitkStdMultiWidget::SetWidgetPlanesVisibility(bool visible, mitk::BaseRenderer *renderer) { if (m_PlaneNode1.IsNotNull()) { m_PlaneNode1->SetVisibility(visible, renderer); } if (m_PlaneNode2.IsNotNull()) { m_PlaneNode2->SetVisibility(visible, renderer); } if (m_PlaneNode3.IsNotNull()) { m_PlaneNode3->SetVisibility(visible, renderer); } m_RenderingManager->RequestUpdateAll(); } void QmitkStdMultiWidget::SetWidgetPlanesLocked(bool locked) { // do your job and lock or unlock slices. GetRenderWindow1()->GetSliceNavigationController()->SetSliceLocked(locked); GetRenderWindow2()->GetSliceNavigationController()->SetSliceLocked(locked); GetRenderWindow3()->GetSliceNavigationController()->SetSliceLocked(locked); } void QmitkStdMultiWidget::SetWidgetPlanesRotationLocked(bool locked) { // do your job and lock or unlock slices. GetRenderWindow1()->GetSliceNavigationController()->SetSliceRotationLocked(locked); GetRenderWindow2()->GetSliceNavigationController()->SetSliceRotationLocked(locked); GetRenderWindow3()->GetSliceNavigationController()->SetSliceRotationLocked(locked); } void QmitkStdMultiWidget::SetWidgetPlanesRotationLinked(bool link) { emit WidgetPlanesRotationLinked(link); } void QmitkStdMultiWidget::SetWidgetPlaneMode(int userMode) { MITK_DEBUG << "Changing crosshair mode to " << userMode; emit WidgetNotifyNewCrossHairMode(userMode); // Convert user interface mode to actual mode { switch (userMode) { case 0: m_MouseModeSwitcher->SetInteractionScheme(mitk::MouseModeSwitcher::InteractionScheme::MITK); break; case 1: m_MouseModeSwitcher->SetInteractionScheme(mitk::MouseModeSwitcher::InteractionScheme::ROTATION); break; case 2: m_MouseModeSwitcher->SetInteractionScheme(mitk::MouseModeSwitcher::InteractionScheme::ROTATIONLINKED); break; case 3: m_MouseModeSwitcher->SetInteractionScheme(mitk::MouseModeSwitcher::InteractionScheme::SWIVEL); break; } } } void QmitkStdMultiWidget::SetGradientBackgroundColorForRenderWindow(const mitk::Color &upper, const mitk::Color &lower, unsigned int widgetNumber) { if (widgetNumber > 3) { MITK_ERROR << "Gradientbackground for unknown widget!"; return; } m_GradientBackgroundColors[widgetNumber].first = upper; m_GradientBackgroundColors[widgetNumber].second = lower; vtkRenderer *renderer = GetRenderWindow(widgetNumber)->GetRenderer()->GetVtkRenderer(); renderer->SetBackground2(upper[0], upper[1], upper[2]); renderer->SetBackground(lower[0], lower[1], lower[2]); m_GradientBackgroundFlag = true; } void QmitkStdMultiWidget::SetGradientBackgroundColors(const mitk::Color &upper, const mitk::Color &lower) { for (unsigned int i = 0; i < 4; ++i) { vtkRenderer *renderer = GetRenderWindow(i)->GetRenderer()->GetVtkRenderer(); renderer->SetBackground2(upper[0], upper[1], upper[2]); renderer->SetBackground(lower[0], lower[1], lower[2]); } m_GradientBackgroundFlag = true; } void QmitkStdMultiWidget::SetDepartmentLogoPath(const char *path) { m_LogoRendering->SetLogoImagePath(path); mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow()); m_LogoRendering->Update(renderer); RequestUpdate(); } void QmitkStdMultiWidget::SetWidgetPlaneModeToSlicing(bool activate) { if (activate) { this->SetWidgetPlaneMode(PLANE_MODE_SLICING); } } void QmitkStdMultiWidget::SetWidgetPlaneModeToRotation(bool activate) { if (activate) { this->SetWidgetPlaneMode(PLANE_MODE_ROTATION); } } void QmitkStdMultiWidget::SetWidgetPlaneModeToSwivel(bool activate) { if (activate) { this->SetWidgetPlaneMode(PLANE_MODE_SWIVEL); } } void QmitkStdMultiWidget::OnLayoutDesignChanged(int layoutDesignIndex) { switch (layoutDesignIndex) { case LAYOUT_DEFAULT: { this->changeLayoutToDefault(); break; } case LAYOUT_2D_IMAGES_UP: { this->changeLayoutTo2DImagesUp(); break; } case LAYOUT_2D_IMAGES_LEFT: { this->changeLayoutTo2DImagesLeft(); break; } case LAYOUT_BIG_3D: { this->changeLayoutToBig3D(); break; } case LAYOUT_WIDGET1: { this->changeLayoutToWidget1(); break; } case LAYOUT_WIDGET2: { this->changeLayoutToWidget2(); break; } case LAYOUT_WIDGET3: { this->changeLayoutToWidget3(); break; } case LAYOUT_2X_2D_AND_3D_WIDGET: { this->changeLayoutTo2x2Dand3DWidget(); break; } case LAYOUT_ROW_WIDGET_3_AND_4: { this->changeLayoutToRowWidget3And4(); break; } case LAYOUT_COLUMN_WIDGET_3_AND_4: { this->changeLayoutToColumnWidget3And4(); break; } case LAYOUT_ROW_WIDGET_SMALL3_AND_BIG4: { this->changeLayoutToRowWidgetSmall3andBig4(); break; } case LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4: { this->changeLayoutToSmallUpperWidget2Big3and4(); break; } case LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET: { this->changeLayoutToLeft2Dand3DRight2D(); break; } }; } void QmitkStdMultiWidget::UpdateAllWidgets() { mitkWidget1->resize(mitkWidget1Container->frameSize().width() - 1, mitkWidget1Container->frameSize().height()); mitkWidget1->resize(mitkWidget1Container->frameSize().width(), mitkWidget1Container->frameSize().height()); mitkWidget2->resize(mitkWidget2Container->frameSize().width() - 1, mitkWidget2Container->frameSize().height()); mitkWidget2->resize(mitkWidget2Container->frameSize().width(), mitkWidget2Container->frameSize().height()); mitkWidget3->resize(mitkWidget3Container->frameSize().width() - 1, mitkWidget3Container->frameSize().height()); mitkWidget3->resize(mitkWidget3Container->frameSize().width(), mitkWidget3Container->frameSize().height()); mitkWidget4->resize(mitkWidget4Container->frameSize().width() - 1, mitkWidget4Container->frameSize().height()); mitkWidget4->resize(mitkWidget4Container->frameSize().width(), mitkWidget4Container->frameSize().height()); } void QmitkStdMultiWidget::HideAllWidgetToolbars() { mitkWidget1->HideRenderWindowMenu(); mitkWidget2->HideRenderWindowMenu(); mitkWidget3->HideRenderWindowMenu(); mitkWidget4->HideRenderWindowMenu(); } void QmitkStdMultiWidget::ActivateMenuWidget(bool state) { mitkWidget1->ActivateMenuWidget(state, this); mitkWidget2->ActivateMenuWidget(state, this); mitkWidget3->ActivateMenuWidget(state, this); mitkWidget4->ActivateMenuWidget(state, this); } bool QmitkStdMultiWidget::IsMenuWidgetEnabled() const { return mitkWidget1->GetActivateMenuWidgetFlag(); } void QmitkStdMultiWidget::SetDecorationColor(unsigned int widgetNumber, mitk::Color color) { switch (widgetNumber) { case 0: if (m_PlaneNode1.IsNotNull()) { m_PlaneNode1->SetColor(color); } break; case 1: if (m_PlaneNode2.IsNotNull()) { m_PlaneNode2->SetColor(color); } break; case 2: if (m_PlaneNode3.IsNotNull()) { m_PlaneNode3->SetColor(color); } break; case 3: m_DecorationColorWidget4 = color; break; default: MITK_ERROR << "Decoration color for unknown widget!"; break; } } void QmitkStdMultiWidget::ResetCrosshair() { if (m_DataStorage.IsNotNull()) { m_RenderingManager->InitializeViewsByBoundingObjects(m_DataStorage); // m_RenderingManager->InitializeViews( m_DataStorage->ComputeVisibleBoundingGeometry3D() ); // reset interactor to normal slicing this->SetWidgetPlaneMode(PLANE_MODE_SLICING); } } void QmitkStdMultiWidget::EnableColoredRectangles() { m_RectangleProps[0]->SetVisibility(1); m_RectangleProps[1]->SetVisibility(1); m_RectangleProps[2]->SetVisibility(1); m_RectangleProps[3]->SetVisibility(1); } void QmitkStdMultiWidget::DisableColoredRectangles() { m_RectangleProps[0]->SetVisibility(0); m_RectangleProps[1]->SetVisibility(0); m_RectangleProps[2]->SetVisibility(0); m_RectangleProps[3]->SetVisibility(0); } bool QmitkStdMultiWidget::IsColoredRectanglesEnabled() const { return m_RectangleProps[0]->GetVisibility() > 0; } mitk::MouseModeSwitcher *QmitkStdMultiWidget::GetMouseModeSwitcher() { return m_MouseModeSwitcher; } mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane1() { return this->m_PlaneNode1; } mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane2() { return this->m_PlaneNode2; } mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane3() { return this->m_PlaneNode3; } mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane(int id) { switch (id) { case 1: return this->m_PlaneNode1; break; case 2: return this->m_PlaneNode2; break; case 3: return this->m_PlaneNode3; break; default: return NULL; } } diff --git a/Modules/SceneSerializationBase/test/mitkPropertySerializationTest.cpp b/Modules/SceneSerializationBase/test/mitkPropertySerializationTest.cpp index 083f676b5e..014c5f1ed0 100644 --- a/Modules/SceneSerializationBase/test/mitkPropertySerializationTest.cpp +++ b/Modules/SceneSerializationBase/test/mitkPropertySerializationTest.cpp @@ -1,282 +1,281 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "mitkTestingMacros.h" #include "mitkCoreObjectFactory.h" #include "mitkBaseProperty.h" #include "mitkProperties.h" #include #include #include #include /* #include #include #include */ #include //#include //#include #include #include #include #include #include #include #include #include #include #include #include #include #include "mitkBasePropertySerializer.h" #include "mitkPropertyList.h" #include "mitkPropertyListSerializer.h" #include #include #include #include /* #include #include #include #include #include #include #include #include #include #include */ void TestAllProperties(const mitk::PropertyList *propList); /**Documentation * \brief Test for all PropertySerializer classes. * */ int mitkPropertySerializationTest(int /* argc */, char * /*argv*/ []) { MITK_TEST_BEGIN("PropertySerializationTest"); mitk::PropertyListSerializer::Pointer serializer = mitk::PropertyListSerializer::New(); // make sure something from the lib is actually used (registration of // serializers) /* build list of properties that will be serialized and deserialized */ mitk::PropertyList::Pointer propList = mitk::PropertyList::New(); propList->SetProperty("booltrue", mitk::BoolProperty::New(true)); propList->SetProperty("boolfalse", mitk::BoolProperty::New(false)); propList->SetProperty("int", mitk::IntProperty::New(-32)); propList->SetProperty("float", mitk::FloatProperty::New(-31.337)); propList->SetProperty("double", mitk::DoubleProperty::New(-31.337)); propList->SetProperty("string", mitk::StringProperty::New("Hello MITK")); mitk::Point3D p3d; mitk::FillVector3D(p3d, 1.0, 2.2, -3.3); propList->SetProperty("p3d", mitk::Point3dProperty::New(p3d)); mitk::Point3I p3i; mitk::FillVector3D(p3i, 1, 2, -3); propList->SetProperty("p3i", mitk::Point3iProperty::New(p3i)); mitk::Point4D p4d; mitk::FillVector4D(p4d, 1.5, 2.6, -3.7, 4.44); propList->SetProperty("p4d", mitk::Point4dProperty::New(p4d)); mitk::Vector3D v3d; mitk::FillVector3D(v3d, 1.0, 2.2, -3.3); propList->SetProperty("v3d", mitk::Vector3DProperty::New(v3d)); propList->SetProperty("annotation", mitk::AnnotationProperty::New("My Annotation", p3d)); propList->SetProperty("clipping", mitk::ClippingProperty::New(p3d, v3d)); propList->SetProperty("color", mitk::ColorProperty::New(1.0, 0.2, 0.2)); // mitk::EnumerationProperty::Pointer en = mitk::EnumerationProperty::New(); // en->AddEnum("PC", 1); en->AddEnum("Playstation", 2); en->AddEnum("Wii", 111); en->AddEnum("XBox", 7); // en->SetValue("XBox"); // propList->SetProperty("enum", en); /* propList->SetProperty("gridrep", mitk::GridRepresentationProperty::New(2)); propList->SetProperty("gridvol", mitk::GridVolumeMapperProperty::New(0)); propList->SetProperty("OrganTypeProperty", mitk::OrganTypeProperty::New("Larynx")); */ propList->SetProperty("modality", mitk::ModalityProperty::New("Color Doppler")); // propList->SetProperty("OdfNormalizationMethodProperty", mitk::OdfNormalizationMethodProperty::New("Global // Maximum")); // propList->SetProperty("OdfScaleByProperty", mitk::OdfScaleByProperty::New("Principal Curvature")); propList->SetProperty("PlaneOrientationProperty", mitk::PlaneOrientationProperty::New("Arrows in positive direction")); propList->SetProperty("ShaderProperty", mitk::ShaderProperty::New("fixed")); propList->SetProperty("VtkInterpolationProperty", mitk::VtkInterpolationProperty::New("Gouraud")); propList->SetProperty("VtkRepresentationProperty", mitk::VtkRepresentationProperty::New("Surface")); propList->SetProperty("VtkResliceInterpolationProperty", mitk::VtkResliceInterpolationProperty::New("Cubic")); propList->SetProperty("VtkScalarModeProperty", mitk::VtkScalarModeProperty::New("PointFieldData")); propList->SetProperty("VtkVolumeRenderingProperty", mitk::VtkVolumeRenderingProperty::New("COMPOSITE")); mitk::BoolLookupTable blt; blt.SetTableValue(0, true); blt.SetTableValue(1, false); blt.SetTableValue(2, true); propList->SetProperty("BoolLookupTableProperty", mitk::BoolLookupTableProperty::New(blt)); mitk::FloatLookupTable flt; flt.SetTableValue(0, 3.1); flt.SetTableValue(1, 3.3); flt.SetTableValue(2, 7.0); propList->SetProperty("FloatLookupTableProperty", mitk::FloatLookupTableProperty::New(flt)); mitk::IntLookupTable ilt; ilt.SetTableValue(0, 3); ilt.SetTableValue(1, 2); ilt.SetTableValue(2, 11); propList->SetProperty("IntLookupTableProperty", mitk::IntLookupTableProperty::New(ilt)); mitk::StringLookupTable slt; slt.SetTableValue(0, "Hello"); slt.SetTableValue(1, "MITK"); slt.SetTableValue(2, "world"); propList->SetProperty("StringLookupTableProperty", mitk::StringLookupTableProperty::New(slt)); propList->SetProperty("GroupTagProperty", mitk::GroupTagProperty::New()); propList->SetProperty("LevelWindowProperty", mitk::LevelWindowProperty::New(mitk::LevelWindow(100.0, 50.0))); mitk::LookupTable::Pointer lt = mitk::LookupTable::New(); lt->ChangeOpacityForAll(0.25); lt->ChangeOpacity(17, 0.88); propList->SetProperty("LookupTableProperty", mitk::LookupTableProperty::New(lt)); propList->SetProperty("StringProperty", mitk::StringProperty::New("Oh why, gruel world")); // mitk::TransferFunction::Pointer tf = mitk::TransferFunction::New(); // tf->SetTransferFunctionMode(1); // propList->SetProperty("TransferFunctionProperty", mitk::TransferFunctionProperty::New(tf)); MITK_TEST_CONDITION_REQUIRED(propList->GetMap()->size() > 0, "Initialize PropertyList"); TestAllProperties(propList); /* test default property lists of basedata objects */ // activate the following tests after MaterialProperty is deleted mitk::DataNode::Pointer node = mitk::DataNode::New(); node->SetData(mitk::PointSet::New()); TestAllProperties(node->GetPropertyList()); node->SetData(mitk::Image::New()); TestAllProperties(node->GetPropertyList()); node->SetData(mitk::Surface::New()); TestAllProperties(node->GetPropertyList()); node->SetData(mitk::VtkWidgetRendering::New()); TestAllProperties(node->GetPropertyList()); /* node->SetData(mitk::Contour::New()); TestAllProperties(node->GetPropertyList()); node->SetData(mitk::ContourSet::New()); TestAllProperties(node->GetPropertyList()); node->SetData(mitk::Mesh::New()); TestAllProperties(node->GetPropertyList()); node->SetData(mitk::Cone::New()); TestAllProperties(node->GetPropertyList()); node->SetData(mitk::Cuboid::New()); TestAllProperties(node->GetPropertyList()); node->SetData(mitk::Cylinder::New()); TestAllProperties(node->GetPropertyList()); node->SetData(mitk::Ellipsoid::New()); TestAllProperties(node->GetPropertyList()); node->SetData(mitk::ExtrudedContour::New()); TestAllProperties(node->GetPropertyList()); node->SetData(mitk::Plane::New()); TestAllProperties(node->GetPropertyList()); //node->SetData(mitk::TrackingVolume::New()); // TrackingVolume is in IGT Module, it does not have special properties, therefore we skip it here //TestAllProperties(node->GetPropertyList()); node->SetData(mitk::UnstructuredGrid::New()); TestAllProperties(node->GetPropertyList()); */ /* untested base data types: BaseDataTestImplementation RenderWindowFrame GeometryData mitk::PlaneGeometryData GradientBackground ItkBaseDataAdapter - ManufacturerLogo SlicedData QBallImage SeedsImage TensorImage BoundingObject BoundingObjectGroup */ MITK_TEST_END(); } void TestAllProperties(const mitk::PropertyList *propList) { assert(propList); /* try to serialize each property in the list, then deserialize again and check for equality */ for (mitk::PropertyList::PropertyMap::const_iterator it = propList->GetMap()->begin(); it != propList->GetMap()->end(); ++it) { const mitk::BaseProperty *prop = it->second; // construct name of serializer class std::string serializername = std::string(prop->GetNameOfClass()) + "Serializer"; std::list allSerializers = itk::ObjectFactoryBase::CreateAllInstance(serializername.c_str()); MITK_TEST_CONDITION(allSerializers.size() > 0, std::string("Creating serializers for ") + serializername); if (allSerializers.size() == 0) { MITK_TEST_OUTPUT(<< "serialization not possible, skipping " << prop->GetNameOfClass()); continue; } if (allSerializers.size() > 1) { MITK_TEST_OUTPUT(<< "Warning: " << allSerializers.size() << " serializers found for " << prop->GetNameOfClass() << "testing only the first one."); } mitk::BasePropertySerializer *serializer = dynamic_cast(allSerializers.begin()->GetPointer()); MITK_TEST_CONDITION(serializer != NULL, serializername + std::string(" is valid")); if (serializer != NULL) { serializer->SetProperty(prop); TiXmlElement *valueelement = NULL; try { valueelement = serializer->Serialize(); } catch (...) { } MITK_TEST_CONDITION(valueelement != NULL, std::string("Serialize property with ") + serializername); if (valueelement == NULL) { MITK_TEST_OUTPUT(<< "serialization failed, skipping deserialization"); continue; } mitk::BaseProperty::Pointer deserializedProp = serializer->Deserialize(valueelement); MITK_TEST_CONDITION(deserializedProp.IsNotNull(), "serializer created valid property"); if (deserializedProp.IsNotNull()) { MITK_TEST_CONDITION(*(deserializedProp.GetPointer()) == *prop, "deserialized property equals initial property for type " << prop->GetNameOfClass()); } } else { MITK_TEST_OUTPUT(<< "created serializer object is of class " << allSerializers.begin()->GetPointer()->GetNameOfClass()) } } // for all properties } diff --git a/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp b/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp index 7c2e977513..c459e0c8e3 100644 --- a/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp +++ b/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp @@ -1,1135 +1,1136 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "QmitkDataManagerView.h" //# Own Includes //## mitk #include "mitkDataStorageEditorInput.h" #include "mitkIDataStorageReference.h" #include "mitkNodePredicateDataType.h" #include "mitkCoreObjectFactory.h" #include "mitkColorProperty.h" #include "mitkCommon.h" #include "mitkNodePredicateData.h" #include "mitkNodePredicateNot.h" #include "mitkNodePredicateOr.h" #include "mitkNodePredicateProperty.h" #include "mitkEnumerationProperty.h" #include "mitkLookupTableProperty.h" #include "mitkProperties.h" #include #include #include #include #include //## Qmitk #include #include #include #include #include #include #include #include "src/internal/QmitkNodeTableViewKeyFilter.h" #include "src/internal/QmitkInfoDialog.h" #include "src/internal/QmitkDataManagerItemDelegate.h" //## Berry #include #include #include #include #include #include //# Toolkit Includes #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "mitkDataNodeObject.h" #include "mitkIContextMenuAction.h" #include "berryIExtensionRegistry.h" #include "mitkRenderingModeProperty.h" const QString QmitkDataManagerView::VIEW_ID = "org.mitk.views.datamanager"; QmitkDataManagerView::QmitkDataManagerView() : m_GlobalReinitOnNodeDelete(true), m_ItemDelegate(NULL) { } QmitkDataManagerView::~QmitkDataManagerView() { //Remove all registered actions from each descriptor for (std::vector< std::pair< QmitkNodeDescriptor*, QAction* > >::iterator it = m_DescriptorActionList.begin();it != m_DescriptorActionList.end(); it++) { // first== the NodeDescriptor; second== the registered QAction (it->first)->RemoveAction(it->second); } } void QmitkDataManagerView::CreateQtPartControl(QWidget* parent) { m_CurrentRowCount = 0; m_Parent = parent; //# Preferences berry::IPreferencesService* prefService = berry::Platform::GetPreferencesService(); berry::IBerryPreferences::Pointer prefs = (prefService->GetSystemPreferences()->Node(VIEW_ID)) .Cast(); assert( prefs ); prefs->OnChanged.AddListener( berry::MessageDelegate1( this , &QmitkDataManagerView::OnPreferencesChanged ) ); //# GUI m_NodeTreeModel = new QmitkDataStorageTreeModel(this->GetDataStorage()); m_NodeTreeModel->setParent( parent ); m_NodeTreeModel->SetPlaceNewNodesOnTop( prefs->GetBool("Place new nodes on top", true) ); m_NodeTreeModel->SetAllowHierarchyChange( prefs->GetBool("Allow changing of parent node", false)); m_SurfaceDecimation = prefs->GetBool("Use surface decimation", false); // Prepare filters m_HelperObjectFilterPredicate = mitk::NodePredicateOr::New( mitk::NodePredicateProperty::New("helper object", mitk::BoolProperty::New(true)), mitk::NodePredicateProperty::New("hidden object", mitk::BoolProperty::New(true))); m_NodeWithNoDataFilterPredicate = mitk::NodePredicateData::New(0); m_FilterModel = new QmitkDataStorageFilterProxyModel(); m_FilterModel->setSourceModel(m_NodeTreeModel); m_FilterModel->AddFilterPredicate(m_HelperObjectFilterPredicate); m_FilterModel->AddFilterPredicate(m_NodeWithNoDataFilterPredicate); //# Tree View (experimental) m_NodeTreeView = new QTreeView; m_NodeTreeView->setHeaderHidden(true); m_NodeTreeView->setSelectionMode( QAbstractItemView::ExtendedSelection ); m_NodeTreeView->setSelectionBehavior( QAbstractItemView::SelectRows ); m_NodeTreeView->setAlternatingRowColors(true); m_NodeTreeView->setDragEnabled(true); m_NodeTreeView->setDropIndicatorShown(true); m_NodeTreeView->setAcceptDrops(true); m_NodeTreeView->setContextMenuPolicy(Qt::CustomContextMenu); m_NodeTreeView->setModel(m_FilterModel); m_NodeTreeView->setTextElideMode(Qt::ElideMiddle); m_NodeTreeView->installEventFilter(new QmitkNodeTableViewKeyFilter(this)); m_ItemDelegate = new QmitkDataManagerItemDelegate(m_NodeTreeView); m_NodeTreeView->setItemDelegate(m_ItemDelegate); QObject::connect( m_NodeTreeView, SIGNAL(customContextMenuRequested(const QPoint&)) , this, SLOT(NodeTableViewContextMenuRequested(const QPoint&)) ); QObject::connect( m_NodeTreeModel, SIGNAL(rowsInserted (const QModelIndex&, int, int)) , this, SLOT(NodeTreeViewRowsInserted ( const QModelIndex&, int, int )) ); QObject::connect( m_NodeTreeModel, SIGNAL(rowsRemoved (const QModelIndex&, int, int)) , this, SLOT(NodeTreeViewRowsRemoved( const QModelIndex&, int, int )) ); QObject::connect( m_NodeTreeView->selectionModel() , SIGNAL( selectionChanged ( const QItemSelection &, const QItemSelection & ) ) , this , SLOT( NodeSelectionChanged ( const QItemSelection &, const QItemSelection & ) ) ); //# m_NodeMenu m_NodeMenu = new QMenu(m_NodeTreeView); // # Actions berry::IEditorRegistry* editorRegistry = berry::PlatformUI::GetWorkbench()->GetEditorRegistry(); QList editors = editorRegistry->GetEditors("*.mitk"); if (editors.size() > 1) { m_ShowInMapper = new QSignalMapper(this); foreach(berry::IEditorDescriptor::Pointer descriptor, editors) { QAction* action = new QAction(descriptor->GetLabel(), this); m_ShowInActions << action; m_ShowInMapper->connect(action, SIGNAL(triggered()), m_ShowInMapper, SLOT(map())); m_ShowInMapper->setMapping(action, descriptor->GetId()); } connect(m_ShowInMapper, SIGNAL(mapped(QString)), this, SLOT(ShowIn(QString))); } auto unknownDataNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetUnknownDataNodeDescriptor(); auto imageDataNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("Image"); auto multiComponentImageDataNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("MultiComponentImage"); auto diffusionImageDataNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("DiffusionImage"); auto surfaceDataNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("Surface"); auto labelSetImageDataNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("LabelSetImage"); auto pointSetNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PointSet"); auto planarLineNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarLine"); auto planarCircleNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarCircle"); auto planarEllipseNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarEllipse"); auto planarAngleNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarAngle"); auto planarFourPointAngleNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarFourPointAngle"); auto planarRectangleNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarRectangle"); auto planarPolygonNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarPolygon"); auto planarPathNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarPath"); auto planarDoubleEllipseNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarDoubleEllipse"); auto planarBezierCurveNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarBezierCurve"); auto planarSubdivisionPolygonNodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarSubdivisionPolygon"); QAction* globalReinitAction = new QAction(QIcon(":/org.mitk.gui.qt.datamanager/Refresh_48.png"), tr("Global Reinit"), this); QObject::connect( globalReinitAction, SIGNAL( triggered(bool) ) , this, SLOT( GlobalReinit(bool) ) ); unknownDataNodeDescriptor->AddAction(globalReinitAction); m_DescriptorActionList.push_back(std::pair(unknownDataNodeDescriptor, globalReinitAction)); QAction* saveAction = new QmitkFileSaveAction(QIcon(":/org.mitk.gui.qt.datamanager/Save_48.png"), this->GetSite()->GetWorkbenchWindow()); unknownDataNodeDescriptor->AddAction(saveAction); m_DescriptorActionList.push_back(std::pair(unknownDataNodeDescriptor,saveAction)); QAction* removeAction = new QAction(QIcon(":/org.mitk.gui.qt.datamanager/Remove_48.png"), tr("Remove"), this); QObject::connect( removeAction, SIGNAL( triggered(bool) ) , this, SLOT( RemoveSelectedNodes(bool) ) ); unknownDataNodeDescriptor->AddAction(removeAction); m_DescriptorActionList.push_back(std::pair(unknownDataNodeDescriptor,removeAction)); QAction* reinitAction = new QAction(QIcon(":/org.mitk.gui.qt.datamanager/Refresh_48.png"), tr("Reinit"), this); QObject::connect( reinitAction, SIGNAL( triggered(bool) ) , this, SLOT( ReinitSelectedNodes(bool) ) ); unknownDataNodeDescriptor->AddAction(reinitAction); m_DescriptorActionList.push_back(std::pair(unknownDataNodeDescriptor,reinitAction)); // find contextMenuAction extension points and add them to the node descriptor berry::IExtensionRegistry* extensionPointService = berry::Platform::GetExtensionRegistry(); QList cmActions( extensionPointService->GetConfigurationElementsFor("org.mitk.gui.qt.datamanager.contextMenuActions") ); QList::iterator cmActionsIt; QmitkNodeDescriptor* tmpDescriptor; QAction* contextMenuAction; QVariant cmActionDataIt; m_ConfElements.clear(); int i=1; for (cmActionsIt = cmActions.begin() ; cmActionsIt != cmActions.end() ; ++cmActionsIt) { QString cmNodeDescriptorName = (*cmActionsIt)->GetAttribute("nodeDescriptorName"); QString cmLabel = (*cmActionsIt)->GetAttribute("label"); QString cmClass = (*cmActionsIt)->GetAttribute("class"); if(!cmNodeDescriptorName.isEmpty() && !cmLabel.isEmpty() && !cmClass.isEmpty()) { QString cmIcon = (*cmActionsIt)->GetAttribute("icon"); // create context menu entry here tmpDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor(cmNodeDescriptorName); if(!tmpDescriptor) { MITK_WARN << "cannot add action \"" << cmLabel << "\" because descriptor " << cmNodeDescriptorName << " does not exist"; continue; } // check if the user specified an icon attribute if ( !cmIcon.isEmpty() ) { contextMenuAction = new QAction( QIcon(cmIcon), cmLabel, parent); } else { contextMenuAction = new QAction( cmLabel, parent); } tmpDescriptor->AddAction(contextMenuAction); m_DescriptorActionList.push_back(std::pair(tmpDescriptor,contextMenuAction)); m_ConfElements[contextMenuAction] = *cmActionsIt; cmActionDataIt.setValue(i); contextMenuAction->setData( cmActionDataIt ); connect( contextMenuAction, SIGNAL( triggered(bool) ) , this, SLOT( ContextMenuActionTriggered(bool) ) ); ++i; } } m_OpacitySlider = new QSlider; m_OpacitySlider->setMinimum(0); m_OpacitySlider->setMaximum(100); m_OpacitySlider->setOrientation(Qt::Horizontal); QObject::connect( m_OpacitySlider, SIGNAL( valueChanged(int) ) , this, SLOT( OpacityChanged(int) ) ); QLabel* _OpacityLabel = new QLabel(tr("Opacity: ")); QHBoxLayout* _OpacityWidgetLayout = new QHBoxLayout; _OpacityWidgetLayout->setContentsMargins(4,4,4,4); _OpacityWidgetLayout->addWidget(_OpacityLabel); _OpacityWidgetLayout->addWidget(m_OpacitySlider); QWidget* _OpacityWidget = new QWidget; _OpacityWidget->setLayout(_OpacityWidgetLayout); QWidgetAction* opacityAction = new QWidgetAction(this); opacityAction ->setDefaultWidget(_OpacityWidget); QObject::connect( opacityAction , SIGNAL( changed() ) , this, SLOT( OpacityActionChanged() ) ); unknownDataNodeDescriptor->AddAction(opacityAction , false); m_DescriptorActionList.push_back(std::pair(unknownDataNodeDescriptor,opacityAction)); m_ColorButton = new QPushButton; m_ColorButton->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Minimum); //m_ColorButton->setText("Change color"); QObject::connect( m_ColorButton, SIGNAL( clicked() ) , this, SLOT( ColorChanged() ) ); QLabel* _ColorLabel = new QLabel(tr("Color: ")); _ColorLabel->setSizePolicy(QSizePolicy::Minimum,QSizePolicy::Minimum); QHBoxLayout* _ColorWidgetLayout = new QHBoxLayout; _ColorWidgetLayout->setContentsMargins(4,4,4,4); _ColorWidgetLayout->addWidget(_ColorLabel); _ColorWidgetLayout->addWidget(m_ColorButton); QWidget* _ColorWidget = new QWidget; _ColorWidget->setLayout(_ColorWidgetLayout); QWidgetAction* colorAction = new QWidgetAction(this); colorAction->setDefaultWidget(_ColorWidget); QObject::connect( colorAction, SIGNAL( changed() ) , this, SLOT( ColorActionChanged() ) ); { // only give the color context menu option where appropriate if (imageDataNodeDescriptor != NULL) { imageDataNodeDescriptor->AddAction(colorAction, false); m_DescriptorActionList.push_back( std::pair(imageDataNodeDescriptor, colorAction)); } if (multiComponentImageDataNodeDescriptor != NULL) { multiComponentImageDataNodeDescriptor->AddAction(colorAction, false); m_DescriptorActionList.push_back( std::pair(multiComponentImageDataNodeDescriptor, colorAction)); } if (diffusionImageDataNodeDescriptor != NULL) { diffusionImageDataNodeDescriptor->AddAction(colorAction, false); m_DescriptorActionList.push_back( std::pair(diffusionImageDataNodeDescriptor, colorAction)); } if (surfaceDataNodeDescriptor != NULL) { surfaceDataNodeDescriptor->AddAction(colorAction, false); m_DescriptorActionList.push_back( std::pair(surfaceDataNodeDescriptor, colorAction)); } if (pointSetNodeDescriptor != NULL) { pointSetNodeDescriptor->AddAction(colorAction, false); m_DescriptorActionList.push_back( std::pair(pointSetNodeDescriptor, colorAction)); } if (planarLineNodeDescriptor != NULL) { planarLineNodeDescriptor->AddAction(colorAction, false); m_DescriptorActionList.push_back( std::pair(planarLineNodeDescriptor, colorAction)); } if (planarCircleNodeDescriptor != NULL) { planarCircleNodeDescriptor->AddAction(colorAction, false); m_DescriptorActionList.push_back( std::pair(planarCircleNodeDescriptor, colorAction)); } if (planarEllipseNodeDescriptor != NULL) { planarEllipseNodeDescriptor->AddAction(colorAction, false); m_DescriptorActionList.push_back( std::pair(planarEllipseNodeDescriptor, colorAction)); } if (planarAngleNodeDescriptor != NULL) { planarAngleNodeDescriptor->AddAction(colorAction, false); m_DescriptorActionList.push_back( std::pair(planarAngleNodeDescriptor, colorAction)); } if (planarFourPointAngleNodeDescriptor != NULL) { planarFourPointAngleNodeDescriptor->AddAction(colorAction, false); m_DescriptorActionList.push_back( std::pair(planarFourPointAngleNodeDescriptor, colorAction)); } if (planarRectangleNodeDescriptor != NULL) { planarRectangleNodeDescriptor->AddAction(colorAction, false); m_DescriptorActionList.push_back( std::pair(planarRectangleNodeDescriptor, colorAction)); } if (planarPolygonNodeDescriptor != NULL) { planarPolygonNodeDescriptor->AddAction(colorAction, false); m_DescriptorActionList.push_back( std::pair(planarPolygonNodeDescriptor, colorAction)); } if (planarPathNodeDescriptor != NULL) { planarPathNodeDescriptor->AddAction(colorAction, false); m_DescriptorActionList.push_back( std::pair(planarPathNodeDescriptor, colorAction)); } if (planarDoubleEllipseNodeDescriptor != NULL) { planarDoubleEllipseNodeDescriptor->AddAction(colorAction, false); m_DescriptorActionList.push_back( std::pair(planarDoubleEllipseNodeDescriptor, colorAction)); } if (planarBezierCurveNodeDescriptor != NULL) { planarBezierCurveNodeDescriptor->AddAction(colorAction, false); m_DescriptorActionList.push_back( std::pair(planarBezierCurveNodeDescriptor, colorAction)); } if (planarSubdivisionPolygonNodeDescriptor != NULL) { planarSubdivisionPolygonNodeDescriptor->AddAction(colorAction, false); m_DescriptorActionList.push_back( std::pair(planarSubdivisionPolygonNodeDescriptor, colorAction)); } } m_ComponentSlider = new QmitkNumberPropertySlider; m_ComponentSlider->setOrientation(Qt::Horizontal); //QObject::connect( m_OpacitySlider, SIGNAL( valueChanged(int) ) // , this, SLOT( OpacityChanged(int) ) ); QLabel* _ComponentLabel = new QLabel(tr("Component: ")); QHBoxLayout* _ComponentWidgetLayout = new QHBoxLayout; _ComponentWidgetLayout->setContentsMargins(4,4,4,4); _ComponentWidgetLayout->addWidget(_ComponentLabel); _ComponentWidgetLayout->addWidget(m_ComponentSlider); QLabel* _ComponentValueLabel = new QLabel(); _ComponentWidgetLayout->addWidget(_ComponentValueLabel); connect(m_ComponentSlider, SIGNAL(valueChanged(int)), _ComponentValueLabel, SLOT(setNum(int))); QWidget* _ComponentWidget = new QWidget; _ComponentWidget->setLayout(_ComponentWidgetLayout); QWidgetAction* componentAction = new QWidgetAction(this); componentAction->setDefaultWidget(_ComponentWidget); QObject::connect( componentAction , SIGNAL( changed() ) , this, SLOT( ComponentActionChanged() ) ); multiComponentImageDataNodeDescriptor->AddAction(componentAction, false); m_DescriptorActionList.push_back(std::pair(multiComponentImageDataNodeDescriptor,componentAction)); if (diffusionImageDataNodeDescriptor!=NULL) { diffusionImageDataNodeDescriptor->AddAction(componentAction, false); m_DescriptorActionList.push_back(std::pair(diffusionImageDataNodeDescriptor,componentAction)); } m_TextureInterpolation = new QAction(tr("Texture Interpolation"), this); m_TextureInterpolation->setCheckable ( true ); QObject::connect( m_TextureInterpolation, SIGNAL( changed() ) , this, SLOT( TextureInterpolationChanged() ) ); QObject::connect( m_TextureInterpolation, SIGNAL( toggled(bool) ) , this, SLOT( TextureInterpolationToggled(bool) ) ); imageDataNodeDescriptor->AddAction(m_TextureInterpolation, false); m_DescriptorActionList.push_back(std::pair(imageDataNodeDescriptor,m_TextureInterpolation)); if (diffusionImageDataNodeDescriptor!=NULL) { diffusionImageDataNodeDescriptor->AddAction(m_TextureInterpolation, false); m_DescriptorActionList.push_back(std::pair(diffusionImageDataNodeDescriptor,m_TextureInterpolation)); } m_ColormapAction = new QAction(tr("Colormap"), this); m_ColormapAction->setMenu(new QMenu); QObject::connect( m_ColormapAction->menu(), SIGNAL( aboutToShow() ) , this, SLOT( ColormapMenuAboutToShow() ) ); imageDataNodeDescriptor->AddAction(m_ColormapAction, false); m_DescriptorActionList.push_back(std::pair(imageDataNodeDescriptor, m_ColormapAction)); if (diffusionImageDataNodeDescriptor!=NULL) { diffusionImageDataNodeDescriptor->AddAction(m_ColormapAction, false); m_DescriptorActionList.push_back(std::pair(diffusionImageDataNodeDescriptor, m_ColormapAction)); } m_SurfaceRepresentation = new QAction(tr("Surface Representation"), this); m_SurfaceRepresentation->setMenu(new QMenu(m_NodeTreeView)); QObject::connect( m_SurfaceRepresentation->menu(), SIGNAL( aboutToShow() ) , this, SLOT( SurfaceRepresentationMenuAboutToShow() ) ); surfaceDataNodeDescriptor->AddAction(m_SurfaceRepresentation, false); m_DescriptorActionList.push_back(std::pair(surfaceDataNodeDescriptor, m_SurfaceRepresentation)); QAction* showOnlySelectedNodes = new QAction(QIcon(":/org.mitk.gui.qt.datamanager/ShowSelectedNode_48.png") , tr("Show only selected nodes"), this); QObject::connect( showOnlySelectedNodes, SIGNAL( triggered(bool) ) , this, SLOT( ShowOnlySelectedNodes(bool) ) ); unknownDataNodeDescriptor->AddAction(showOnlySelectedNodes); m_DescriptorActionList.push_back(std::pair(unknownDataNodeDescriptor, showOnlySelectedNodes)); QAction* toggleSelectedVisibility = new QAction(QIcon(":/org.mitk.gui.qt.datamanager/InvertShowSelectedNode_48.png") , tr("Toggle visibility"), this); QObject::connect( toggleSelectedVisibility, SIGNAL( triggered(bool) ) , this, SLOT( ToggleVisibilityOfSelectedNodes(bool) ) ); unknownDataNodeDescriptor->AddAction(toggleSelectedVisibility); m_DescriptorActionList.push_back(std::pair(unknownDataNodeDescriptor,toggleSelectedVisibility)); QAction* actionShowInfoDialog = new QAction(QIcon(":/org.mitk.gui.qt.datamanager/ShowDataInfo_48.png") , tr("Details..."), this); QObject::connect( actionShowInfoDialog, SIGNAL( triggered(bool) ) , this, SLOT( ShowInfoDialogForSelectedNodes(bool) ) ); unknownDataNodeDescriptor->AddAction(actionShowInfoDialog); m_DescriptorActionList.push_back(std::pair(unknownDataNodeDescriptor,actionShowInfoDialog)); QGridLayout* _DndFrameWidgetLayout = new QGridLayout; _DndFrameWidgetLayout->addWidget(m_NodeTreeView, 0, 0); _DndFrameWidgetLayout->setContentsMargins(0,0,0,0); m_DndFrameWidget = new QmitkDnDFrameWidget(m_Parent); m_DndFrameWidget->setLayout(_DndFrameWidgetLayout); QVBoxLayout* layout = new QVBoxLayout(parent); layout->addWidget(m_DndFrameWidget); layout->setContentsMargins(0,0,0,0); m_Parent->setLayout(layout); } void QmitkDataManagerView::SetFocus() { } void QmitkDataManagerView::ContextMenuActionTriggered( bool ) { QAction* action = qobject_cast ( sender() ); std::map::iterator it = m_ConfElements.find( action ); if( it == m_ConfElements.end() ) { MITK_WARN << "associated conf element for action " << action->text().toStdString() << " not found"; return; } berry::IConfigurationElement::Pointer confElem = it->second; mitk::IContextMenuAction* contextMenuAction = confElem->CreateExecutableExtension("class"); QString className = confElem->GetAttribute("class"); QString smoothed = confElem->GetAttribute("smoothed"); contextMenuAction->SetDataStorage(this->GetDataStorage()); if(className == "QmitkCreatePolygonModelAction") { + if(smoothed == "false") { contextMenuAction->SetSmoothed(false); } else { contextMenuAction->SetSmoothed(true); } contextMenuAction->SetDecimated(m_SurfaceDecimation); } else if(className == "QmitkStatisticsAction") { contextMenuAction->SetFunctionality(this); } contextMenuAction->Run( this->GetCurrentSelection() ); // run the action } void QmitkDataManagerView::OnPreferencesChanged(const berry::IBerryPreferences* prefs) { if( m_NodeTreeModel->GetPlaceNewNodesOnTopFlag() != prefs->GetBool("Place new nodes on top", true) ) m_NodeTreeModel->SetPlaceNewNodesOnTop( !m_NodeTreeModel->GetPlaceNewNodesOnTopFlag() ); bool hideHelperObjects = !prefs->GetBool("Show helper objects", false); if (m_FilterModel->HasFilterPredicate(m_HelperObjectFilterPredicate) != hideHelperObjects) { if (hideHelperObjects) { m_FilterModel->AddFilterPredicate(m_HelperObjectFilterPredicate); } else { m_FilterModel->RemoveFilterPredicate(m_HelperObjectFilterPredicate); } } bool hideNodesWithNoData = !prefs->GetBool("Show nodes containing no data", false); if (m_FilterModel->HasFilterPredicate(m_NodeWithNoDataFilterPredicate) != hideNodesWithNoData) { if (hideNodesWithNoData) { m_FilterModel->AddFilterPredicate(m_NodeWithNoDataFilterPredicate); } else { m_FilterModel->RemoveFilterPredicate(m_NodeWithNoDataFilterPredicate); } } m_GlobalReinitOnNodeDelete = prefs->GetBool("Call global reinit if node is deleted", true); m_NodeTreeView->expandAll(); m_SurfaceDecimation = prefs->GetBool("Use surface decimation", false); m_NodeTreeModel->SetAllowHierarchyChange( prefs->GetBool("Allow changing of parent node", false)); this->GlobalReinit(); } void QmitkDataManagerView::NodeTableViewContextMenuRequested( const QPoint & pos ) { QModelIndex selectedProxy = m_NodeTreeView->indexAt ( pos ); QModelIndex selected = m_FilterModel->mapToSource(selectedProxy); mitk::DataNode::Pointer node = m_NodeTreeModel->GetNode(selected); QList selectedNodes = this->GetCurrentSelection(); if(!selectedNodes.isEmpty()) { m_NodeMenu->clear(); QList actions; if(selectedNodes.size() == 1 ) { actions = QmitkNodeDescriptorManager::GetInstance()->GetActions(node); for(QList::iterator it = actions.begin(); it != actions.end(); ++it) { (*it)->setData(QVariant::fromValue(node.GetPointer())); } } else actions = QmitkNodeDescriptorManager::GetInstance()->GetActions(selectedNodes); if (!m_ShowInActions.isEmpty()) { QMenu* showInMenu = m_NodeMenu->addMenu(tr("Show In")); showInMenu->addActions(m_ShowInActions); } m_NodeMenu->addActions(actions); m_NodeMenu->popup(QCursor::pos()); } } void QmitkDataManagerView::OpacityChanged(int value) { mitk::DataNode* node = m_NodeTreeModel->GetNode(m_FilterModel->mapToSource(m_NodeTreeView->selectionModel()->currentIndex())); if(node) { float opacity = static_cast(value)/100.0f; node->SetFloatProperty("opacity", opacity); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } } void QmitkDataManagerView::OpacityActionChanged() { mitk::DataNode* node = m_NodeTreeModel->GetNode(m_FilterModel->mapToSource(m_NodeTreeView->selectionModel()->currentIndex())); if(node) { float opacity = 0.0; if(node->GetFloatProperty("opacity", opacity)) { m_OpacitySlider->setValue(static_cast(opacity*100)); } } } void QmitkDataManagerView::ComponentActionChanged() { mitk::DataNode* node = m_NodeTreeModel->GetNode(m_FilterModel->mapToSource(m_NodeTreeView->selectionModel()->currentIndex())); mitk::IntProperty* componentProperty = NULL; int numComponents = 0; if(node) { componentProperty = dynamic_cast(node->GetProperty("Image.Displayed Component")); mitk::Image* img = dynamic_cast(node->GetData()); if (img != NULL) { numComponents = img->GetPixelType().GetNumberOfComponents(); } } if (componentProperty && numComponents > 1) { m_ComponentSlider->SetProperty(componentProperty); m_ComponentSlider->setMinValue(0); m_ComponentSlider->setMaxValue(numComponents-1); } else { m_ComponentSlider->SetProperty(static_cast(NULL)); } } void QmitkDataManagerView::ColorChanged() { mitk::DataNode* node = m_NodeTreeModel->GetNode(m_FilterModel->mapToSource(m_NodeTreeView->selectionModel()->currentIndex())); if(node) { mitk::Color color; mitk::ColorProperty::Pointer colorProp; node->GetProperty(colorProp,"color"); if(colorProp.IsNull()) return; color = colorProp->GetValue(); QColor initial(color.GetRed()*255,color.GetGreen()*255,color.GetBlue()*255); QColor qcolor = QColorDialog::getColor(initial,0,QString(tr("Change color"))); if (!qcolor.isValid()) return; m_ColorButton->setAutoFillBackground(true); node->SetProperty("color",mitk::ColorProperty::New(qcolor.red()/255.0,qcolor.green()/255.0,qcolor.blue()/255.0)); if (node->GetProperty("binaryimage.selectedcolor")) { node->SetProperty("binaryimage.selectedcolor",mitk::ColorProperty::New(qcolor.red()/255.0,qcolor.green()/255.0,qcolor.blue()/255.0)); } mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } } void QmitkDataManagerView::ColorActionChanged() { mitk::DataNode* node = m_NodeTreeModel->GetNode(m_FilterModel->mapToSource(m_NodeTreeView->selectionModel()->currentIndex())); if(node) { mitk::Color color; mitk::ColorProperty::Pointer colorProp; node->GetProperty(colorProp,"color"); if(colorProp.IsNull()) return; color = colorProp->GetValue(); QString styleSheet = "background-color:rgb("; styleSheet.append(QString::number(color[0]*255)); styleSheet.append(","); styleSheet.append(QString::number(color[1]*255)); styleSheet.append(","); styleSheet.append(QString::number(color[2]*255)); styleSheet.append(")"); m_ColorButton->setStyleSheet(styleSheet); } } void QmitkDataManagerView::TextureInterpolationChanged() { mitk::DataNode* node = m_NodeTreeModel->GetNode(m_FilterModel->mapToSource(m_NodeTreeView->selectionModel()->currentIndex())); if(node) { bool textureInterpolation = false; node->GetBoolProperty("texture interpolation", textureInterpolation); m_TextureInterpolation->setChecked(textureInterpolation); } } void QmitkDataManagerView::TextureInterpolationToggled( bool checked ) { mitk::DataNode* node = m_NodeTreeModel->GetNode(m_FilterModel->mapToSource(m_NodeTreeView->selectionModel()->currentIndex())); if(node) { node->SetBoolProperty("texture interpolation", checked); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } } void QmitkDataManagerView::ColormapActionToggled( bool /*checked*/ ) { mitk::DataNode* node = m_NodeTreeModel->GetNode(m_FilterModel->mapToSource(m_NodeTreeView->selectionModel()->currentIndex())); if(!node) return; mitk::LookupTableProperty::Pointer lookupTableProperty = dynamic_cast(node->GetProperty("LookupTable")); if (!lookupTableProperty) return; QAction* senderAction = qobject_cast(QObject::sender()); if(!senderAction) return; std::string activatedItem = senderAction->text().toStdString(); mitk::LookupTable::Pointer lookupTable = lookupTableProperty->GetValue(); if (!lookupTable) return; lookupTable->SetType(activatedItem); lookupTableProperty->SetValue(lookupTable); mitk::RenderingModeProperty::Pointer renderingMode = dynamic_cast(node->GetProperty("Image Rendering.Mode")); renderingMode->SetValue(mitk::RenderingModeProperty::LOOKUPTABLE_LEVELWINDOW_COLOR); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } void QmitkDataManagerView::ColormapMenuAboutToShow() { mitk::DataNode* node = m_NodeTreeModel->GetNode(m_FilterModel->mapToSource(m_NodeTreeView->selectionModel()->currentIndex())); if(!node) return; mitk::LookupTableProperty::Pointer lookupTableProperty = dynamic_cast(node->GetProperty("LookupTable")); if (!lookupTableProperty) { mitk::LookupTable::Pointer mitkLut = mitk::LookupTable::New(); lookupTableProperty = mitk::LookupTableProperty::New(); lookupTableProperty->SetLookupTable(mitkLut); node->SetProperty("LookupTable", lookupTableProperty); } mitk::LookupTable::Pointer lookupTable = lookupTableProperty->GetValue(); if (!lookupTable) return; m_ColormapAction->menu()->clear(); QAction* tmp; int i = 0; std::string lutType = lookupTable->typenameList[i]; while (lutType != "END_OF_ARRAY") { tmp = m_ColormapAction->menu()->addAction(QString::fromStdString(lutType)); tmp->setCheckable(true); if (lutType == lookupTable->GetActiveTypeAsString()) { tmp->setChecked(true); } QObject::connect(tmp, SIGNAL(triggered(bool)), this, SLOT(ColormapActionToggled(bool))); lutType = lookupTable->typenameList[++i]; } } void QmitkDataManagerView::SurfaceRepresentationMenuAboutToShow() { mitk::DataNode* node = m_NodeTreeModel->GetNode(m_FilterModel->mapToSource(m_NodeTreeView->selectionModel()->currentIndex())); if(!node) return; mitk::EnumerationProperty* representationProp = dynamic_cast (node->GetProperty("material.representation")); if(!representationProp) return; // clear menu m_SurfaceRepresentation->menu()->clear(); QAction* tmp; // create menu entries for(mitk::EnumerationProperty::EnumConstIterator it=representationProp->Begin(); it!=representationProp->End() ; it++) { tmp = m_SurfaceRepresentation->menu()->addAction(QString::fromStdString(it->second)); tmp->setCheckable(true); if(it->second == representationProp->GetValueAsString()) { tmp->setChecked(true); } QObject::connect( tmp, SIGNAL( triggered(bool) ) , this, SLOT( SurfaceRepresentationActionToggled(bool) ) ); } } void QmitkDataManagerView::SurfaceRepresentationActionToggled( bool /*checked*/ ) { mitk::DataNode* node = m_NodeTreeModel->GetNode(m_FilterModel->mapToSource(m_NodeTreeView->selectionModel()->currentIndex())); if(!node) return; mitk::EnumerationProperty* representationProp = dynamic_cast (node->GetProperty("material.representation")); if(!representationProp) return; QAction* senderAction = qobject_cast ( QObject::sender() ); if(!senderAction) return; std::string activatedItem = senderAction->text().toStdString(); if ( activatedItem != representationProp->GetValueAsString() ) { if ( representationProp->IsValidEnumerationValue( activatedItem ) ) { representationProp->SetValue( activatedItem ); representationProp->InvokeEvent( itk::ModifiedEvent() ); representationProp->Modified(); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } } } void QmitkDataManagerView::ReinitSelectedNodes( bool ) { mitk::IRenderWindowPart* renderWindow = this->GetRenderWindowPart(); if (renderWindow == NULL) renderWindow = this->OpenRenderWindowPart(false); QList selectedNodes = this->GetCurrentSelection(); foreach(mitk::DataNode::Pointer node, selectedNodes) { mitk::BaseData::Pointer basedata = node->GetData(); if ( basedata.IsNotNull() && basedata->GetTimeGeometry()->IsValid() ) { renderWindow->GetRenderingManager()->InitializeViews( basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true ); } } } void QmitkDataManagerView::RemoveSelectedNodes( bool ) { QModelIndexList indexesOfSelectedRowsFiltered = m_NodeTreeView->selectionModel()->selectedRows(); QModelIndexList indexesOfSelectedRows; for (int i = 0; i < indexesOfSelectedRowsFiltered.size(); ++i) { indexesOfSelectedRows.push_back(m_FilterModel->mapToSource(indexesOfSelectedRowsFiltered[i])); } if(indexesOfSelectedRows.size() < 1) { return; } std::vector selectedNodes; mitk::DataNode::Pointer node = 0; QString question = tr("Do you really want to remove "); for (QModelIndexList::iterator it = indexesOfSelectedRows.begin() ; it != indexesOfSelectedRows.end(); it++) { node = m_NodeTreeModel->GetNode(*it); // if node is not defined or if the node contains geometry data do not remove it if ( node.IsNotNull() /*& strcmp(node->GetData()->GetNameOfClass(), "PlaneGeometryData") != 0*/ ) { selectedNodes.push_back(node); question.append(QString::fromStdString(node->GetName())); question.append(", "); } } // remove the last two characters = ", " question = question.remove(question.size()-2, 2); question.append(tr(" from data storage?")); QMessageBox::StandardButton answerButton = QMessageBox::question( m_Parent , tr("DataManager") , question , QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes); if(answerButton == QMessageBox::Yes) { for (std::vector::iterator it = selectedNodes.begin() ; it != selectedNodes.end(); it++) { node = *it; this->GetDataStorage()->Remove(node); if (m_GlobalReinitOnNodeDelete) this->GlobalReinit(false); } } } void QmitkDataManagerView::MakeAllNodesInvisible( bool ) { QList nodes = m_NodeTreeModel->GetNodeSet(); foreach(mitk::DataNode::Pointer node, nodes) { node->SetVisibility(false); } mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } void QmitkDataManagerView::ShowOnlySelectedNodes( bool ) { QList selectedNodes = this->GetCurrentSelection(); QList allNodes = m_NodeTreeModel->GetNodeSet(); foreach(mitk::DataNode::Pointer node, allNodes) { node->SetVisibility(selectedNodes.contains(node)); } mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } void QmitkDataManagerView::ToggleVisibilityOfSelectedNodes( bool ) { QList selectedNodes = this->GetCurrentSelection(); bool isVisible = false; foreach(mitk::DataNode::Pointer node, selectedNodes) { isVisible = false; node->GetBoolProperty("visible", isVisible); node->SetVisibility(!isVisible); } mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } void QmitkDataManagerView::ShowInfoDialogForSelectedNodes( bool ) { QList selectedNodes = this->GetCurrentSelection(); QmitkInfoDialog _QmitkInfoDialog(selectedNodes, this->m_Parent); _QmitkInfoDialog.exec(); } void QmitkDataManagerView::NodeChanged(const mitk::DataNode* /*node*/) { // m_FilterModel->invalidate(); // fix as proposed by R. Khlebnikov in the mitk-users mail from 02.09.2014 QMetaObject::invokeMethod( m_FilterModel, "invalidate", Qt::QueuedConnection ); } QItemSelectionModel *QmitkDataManagerView::GetDataNodeSelectionModel() const { return m_NodeTreeView->selectionModel(); } void QmitkDataManagerView::GlobalReinit( bool ) { mitk::IRenderWindowPart* renderWindow = this->GetRenderWindowPart(); if (renderWindow == NULL) renderWindow = this->OpenRenderWindowPart(false); // no render window available if (renderWindow == NULL) return; mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(this->GetDataStorage()); } void QmitkDataManagerView::NodeTreeViewRowsRemoved ( const QModelIndex & /*parent*/, int /*start*/, int /*end*/ ) { m_CurrentRowCount = m_NodeTreeModel->rowCount(); } void QmitkDataManagerView::NodeTreeViewRowsInserted( const QModelIndex & parent, int, int ) { QModelIndex viewIndex = m_FilterModel->mapFromSource(parent); m_NodeTreeView->setExpanded(viewIndex, true); // a new row was inserted if( m_CurrentRowCount == 0 && m_NodeTreeModel->rowCount() == 1 ) { this->OpenRenderWindowPart(); m_CurrentRowCount = m_NodeTreeModel->rowCount(); } } void QmitkDataManagerView::NodeSelectionChanged( const QItemSelection & /*selected*/, const QItemSelection & /*deselected*/ ) { QList nodes = m_NodeTreeModel->GetNodeSet(); foreach(mitk::DataNode::Pointer node, nodes) { if ( node.IsNotNull() ) node->SetBoolProperty("selected", false); } nodes.clear(); nodes = this->GetCurrentSelection(); foreach(mitk::DataNode::Pointer node, nodes) { if ( node.IsNotNull() ) node->SetBoolProperty("selected", true); } //changing the selection does NOT require any rendering processes! //mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } void QmitkDataManagerView::ShowIn(const QString &editorId) { berry::IWorkbenchPage::Pointer page = this->GetSite()->GetPage(); berry::IEditorInput::Pointer input(new mitk::DataStorageEditorInput(this->GetDataStorageReference())); page->OpenEditor(input, editorId, false, berry::IWorkbenchPage::MATCH_ID); } mitk::IRenderWindowPart* QmitkDataManagerView::OpenRenderWindowPart(bool activatedEditor) { if (activatedEditor) { return this->GetRenderWindowPart(QmitkAbstractView::ACTIVATE | QmitkAbstractView::OPEN); } else { return this->GetRenderWindowPart(QmitkAbstractView::BRING_TO_FRONT | QmitkAbstractView::OPEN); } } diff --git a/Plugins/org.mitk.gui.qt.dicom/CMakeLists.txt b/Plugins/org.mitk.gui.qt.dicom/CMakeLists.txt index 415772a9a8..4184514dad 100644 --- a/Plugins/org.mitk.gui.qt.dicom/CMakeLists.txt +++ b/Plugins/org.mitk.gui.qt.dicom/CMakeLists.txt @@ -1,30 +1,30 @@ project(org_mitk_gui_qt_dicom) # Note: # If we use an installed version of DCMTK then DCMTK_DIR points to the subdirectory # of the installation directory (share/dcmtk) that contains DCMTKConfig.cmake. # Therefore we look for the the storescp command in the '../../bin' directory, too. find_program(DCMTK_STORESCP NAMES storescp storescp${DCMTK_CMAKE_DEBUG_POSTFIX} storescp${CMAKE_DEBUG_POSTFIX} - PATHS "${DCMTK_DIR}/bin" "${DCMTK_DIR}/../../bin" + PATHS "${DCMTK_DIR}/bin" "${DCMTK_DIR}/../bin" "${DCMTK_DIR}/../../bin" PATH_SUFFIXES Release Debug DOC "Dcmtk storage provider which is used to store dicom files which are transfered over network." NO_DEFAULT_PATH ) mark_as_advanced(DCMTK_STORESCP) if(NOT EXISTS ${DCMTK_STORESCP}) message(WARNING "Couldn't find program storescp without the program query retrieve of the dicom plugin won't work!") else(NOT EXISTS ${DCMTK_STORESCP}) configure_file( org_mitk_gui_qt_dicom_config.h.in org_mitk_gui_qt_dicom_config.h @ONLY) MITK_INSTALL_HELPER_APP( EXECUTABLES ${DCMTK_STORESCP}) mitk_create_plugin( EXPORT_DIRECTIVE DICOM_EXPORT EXPORTED_INCLUDE_SUFFIXES src MODULE_DEPENDS MitkQtWidgetsExt MitkDicomUI MitkDicomRT MitkRTUI MitkDICOMReader ) endif() diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.cpp b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.cpp index 55cf197d54..f00972ed30 100644 --- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.cpp +++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.cpp @@ -1,935 +1,1020 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "QmitkUSNavigationStepMarkerIntervention.h" #include "ui_QmitkUSNavigationStepMarkerIntervention.h" -#include +#include "mitkBaseRenderer.h" #include "mitkContourModel.h" #include "mitkNeedleProjectionFilter.h" #include "mitkNodeDisplacementFilter.h" #include "mitkSurface.h" -#include "mitkBaseRenderer.h" -#include "mitkOverlayManager.h" -#include "mitkTextOverlay2D.h" -#include "mitkOverlay2DLayouter.h" +#include "mitkTextAnnotation2D.h" +#include +#include -#include "../Filter/mitkUSNavigationTargetUpdateFilter.h" -#include "../Filter/mitkUSNavigationTargetOcclusionFilter.h" #include "../Filter/mitkUSNavigationTargetIntersectionFilter.h" +#include "../Filter/mitkUSNavigationTargetOcclusionFilter.h" +#include "../Filter/mitkUSNavigationTargetUpdateFilter.h" -#include "../Widgets/QmitkZoneProgressBar.h" #include "../USNavigationMarkerPlacement.h" +#include "../Widgets/QmitkZoneProgressBar.h" #include "../mitkUSTargetPlacementQualityCalculator.h" -#include "usModuleRegistry.h" #include "../Interactors/mitkUSPointMarkInteractor.h" +#include "usModuleRegistry.h" #include "mitkLookupTable.h" #include "mitkLookupTableProperty.h" #include "mitkSurface.h" // VTK -#include "vtkSmartPointer.h" #include "vtkCellLocator.h" -#include "vtkOBBTree.h" -#include "vtkIdList.h" -#include "vtkPolyData.h" #include "vtkDataSet.h" -#include "vtkTransformPolyDataFilter.h" +#include "vtkDoubleArray.h" +#include "vtkFloatArray.h" +#include "vtkIdList.h" #include "vtkLinearTransform.h" +#include "vtkLookupTable.h" #include "vtkMath.h" +#include "vtkOBBTree.h" #include "vtkPointData.h" -#include "vtkFloatArray.h" -#include "vtkLookupTable.h" #include "vtkPointData.h" -#include "vtkDoubleArray.h" -#include "vtkWarpScalar.h" -#include "vtkSphereSource.h" +#include "vtkPolyData.h" #include "vtkSelectEnclosedPoints.h" +#include "vtkSmartPointer.h" +#include "vtkSphereSource.h" +#include "vtkTransformPolyDataFilter.h" +#include "vtkWarpScalar.h" -QmitkUSNavigationStepMarkerIntervention::QmitkUSNavigationStepMarkerIntervention(QWidget *parent) : -QmitkUSAbstractNavigationStep(parent), -m_NumberOfTargets(0), -m_TargetProgressBar(0), -m_PlannedTargetProgressBar(0), -m_CurrentTargetIndex(0), -m_CurrentTargetReached(false), -m_ShowPlanningColors(false), -m_NeedleProjectionFilter(mitk::NeedleProjectionFilter::New()), -m_NodeDisplacementFilter(mitk::NodeDisplacementFilter::New()), -m_TargetUpdateFilter(mitk::USNavigationTargetUpdateFilter::New()), -m_TargetOcclusionFilter(mitk::USNavigationTargetOcclusionFilter::New()), -m_TargetIntersectionFilter(mitk::USNavigationTargetIntersectionFilter::New()), -m_PlacementQualityCalculator(mitk::USTargetPlacementQualityCalculator::New()), -m_ListenerTargetCoordinatesChanged(this, &QmitkUSNavigationStepMarkerIntervention::UpdateTargetCoordinates), -m_TargetStructureWarnOverlay(mitk::TextOverlay2D::New()), -m_ReferenceSensorIndex(1), m_NeedleSensorIndex(0), -ui(new Ui::QmitkUSNavigationStepMarkerIntervention) +QmitkUSNavigationStepMarkerIntervention::QmitkUSNavigationStepMarkerIntervention(QWidget *parent) + : QmitkUSAbstractNavigationStep(parent), + m_NumberOfTargets(0), + m_TargetProgressBar(0), + m_PlannedTargetProgressBar(0), + m_CurrentTargetIndex(0), + m_CurrentTargetReached(false), + m_ShowPlanningColors(false), + m_NeedleProjectionFilter(mitk::NeedleProjectionFilter::New()), + m_NodeDisplacementFilter(mitk::NodeDisplacementFilter::New()), + m_TargetUpdateFilter(mitk::USNavigationTargetUpdateFilter::New()), + m_TargetOcclusionFilter(mitk::USNavigationTargetOcclusionFilter::New()), + m_TargetIntersectionFilter(mitk::USNavigationTargetIntersectionFilter::New()), + m_PlacementQualityCalculator(mitk::USTargetPlacementQualityCalculator::New()), + m_ListenerTargetCoordinatesChanged(this, &QmitkUSNavigationStepMarkerIntervention::UpdateTargetCoordinates), + m_TargetStructureWarnOverlay(mitk::TextAnnotation2D::New()), + m_ReferenceSensorIndex(1), + m_NeedleSensorIndex(0), + ui(new Ui::QmitkUSNavigationStepMarkerIntervention) { - m_ActiveTargetColor[0] = 1; m_ActiveTargetColor[1] = 1; m_ActiveTargetColor[2] = 0; - m_InactiveTargetColor[0] = 1; m_InactiveTargetColor[1] = 1; m_InactiveTargetColor[2] = 0.5; - m_ReachedTargetColor[0] = 0.6; m_ReachedTargetColor[1] = 1; m_ReachedTargetColor[2] = 0.6; + m_ActiveTargetColor[0] = 1; + m_ActiveTargetColor[1] = 1; + m_ActiveTargetColor[2] = 0; + m_InactiveTargetColor[0] = 1; + m_InactiveTargetColor[1] = 1; + m_InactiveTargetColor[2] = 0.5; + m_ReachedTargetColor[0] = 0.6; + m_ReachedTargetColor[1] = 1; + m_ReachedTargetColor[2] = 0.6; ui->setupUi(this); connect(ui->freezeImageButton, SIGNAL(SignalFreezed(bool)), this, SLOT(OnFreeze(bool))); connect(ui->backToLastTargetButton, SIGNAL(clicked()), this, SLOT(OnBackToLastTargetClicked())); connect(ui->targetReachedButton, SIGNAL(clicked()), this, SLOT(OnTargetLeft())); connect(this, SIGNAL(TargetReached(int)), this, SLOT(OnTargetReached())); connect(this, SIGNAL(TargetLeft(int)), this, SLOT(OnTargetLeft())); - connect(ui->riskStructuresRangeWidget, SIGNAL(SignalZoneViolated(const mitk::DataNode*, mitk::Point3D)), - this, SLOT(OnRiskZoneViolated(const mitk::DataNode*, mitk::Point3D))); + connect(ui->riskStructuresRangeWidget, + SIGNAL(SignalZoneViolated(const mitk::DataNode *, mitk::Point3D)), + this, + SLOT(OnRiskZoneViolated(const mitk::DataNode *, mitk::Point3D))); m_PointMarkInteractor = mitk::USPointMarkInteractor::New(); m_PointMarkInteractor->CoordinatesChangedEvent.AddListener(m_ListenerTargetCoordinatesChanged); this->GenerateTargetColorLookupTable(); m_TargetProgressBar = new QmitkZoneProgressBar(QString::fromStdString("Target: %1 mm"), 200, 0, this); m_TargetProgressBar->SetTextFormatInvalid("Target is not on Needle Path"); ui->targetStructuresRangeLayout->addWidget(m_TargetProgressBar); m_TargetUpdateFilter->SetScalarArrayIdentifier("USNavigation::ReachedTargetScores"); } QmitkUSNavigationStepMarkerIntervention::~QmitkUSNavigationStepMarkerIntervention() { mitk::DataStorage::Pointer dataStorage = this->GetDataStorage(false); if (dataStorage.IsNotNull()) { // remove the node for the needle path - mitk::DataNode::Pointer node = this->GetNamedDerivedNode("Needle Path", QmitkUSAbstractNavigationStep::DATANAME_BASENODE); - if (node.IsNotNull()) { dataStorage->Remove(node); } + mitk::DataNode::Pointer node = + this->GetNamedDerivedNode("Needle Path", QmitkUSAbstractNavigationStep::DATANAME_BASENODE); + if (node.IsNotNull()) + { + dataStorage->Remove(node); + } } - if (m_SegmentationNode.IsNotNull()) { this->GetDataStorage()->Remove(m_SegmentationNode); } - if (m_ForegroundModelPointsNode.IsNotNull()) { this->GetDataStorage()->Remove(m_ForegroundModelPointsNode); } + if (m_SegmentationNode.IsNotNull()) + { + this->GetDataStorage()->Remove(m_SegmentationNode); + } + if (m_ForegroundModelPointsNode.IsNotNull()) + { + this->GetDataStorage()->Remove(m_ForegroundModelPointsNode); + } delete ui; m_PointMarkInteractor->CoordinatesChangedEvent.RemoveListener(m_ListenerTargetCoordinatesChanged); } bool QmitkUSNavigationStepMarkerIntervention::OnStartStep() { m_NeedleProjectionFilter->SelectInput(m_NeedleSensorIndex); // create node for Needle Projection - mitk::DataNode::Pointer node = this->GetNamedDerivedNodeAndCreate("Needle Path", QmitkUSAbstractNavigationStep::DATANAME_BASENODE); + mitk::DataNode::Pointer node = + this->GetNamedDerivedNodeAndCreate("Needle Path", QmitkUSAbstractNavigationStep::DATANAME_BASENODE); node->SetData(m_NeedleProjectionFilter->GetProjection()); node->SetBoolProperty("show contour", true); - // get overlay manager for the standard multi widget (for displaying alert - // message on the render windows) - mitk::BaseRenderer* renderer = mitk::BaseRenderer::GetByName("stdmulti.widget4"); - if (renderer) { m_OverlayManager = renderer->GetOverlayManager(); } - // initialize warning overlay (and do not display it, yet) m_TargetStructureWarnOverlay->SetText("Warning: Needle is Inside the Target Structure."); m_TargetStructureWarnOverlay->SetVisibility(false); // set position and font size for the text overlay mitk::Point2D overlayPosition; overlayPosition.SetElement(0, 10.0f); overlayPosition.SetElement(1, 10.0f); m_TargetStructureWarnOverlay->SetPosition2D(overlayPosition); m_TargetStructureWarnOverlay->SetFontSize(18); // overlay should be red mitk::Color color; - color[0] = 1; color[1] = 0; color[2] = 0; + color[0] = 1; + color[1] = 0; + color[2] = 0; m_TargetStructureWarnOverlay->SetColor(color); - m_OverlayManager->AddOverlay(m_TargetStructureWarnOverlay.GetPointer()); + mitk::ManualPlacementAnnotationRenderer::AddAnnotation(m_TargetStructureWarnOverlay.GetPointer(), "stdmulti.widget4"); return true; } bool QmitkUSNavigationStepMarkerIntervention::OnStopStep() { mitk::DataStorage::Pointer dataStorage = this->GetDataStorage(); // remove all reached nodes from the data storage - for (QVector >::iterator it = m_ReachedTargetsNodes.begin(); - it != m_ReachedTargetsNodes.end(); ++it) + for (QVector>::iterator it = m_ReachedTargetsNodes.begin(); + it != m_ReachedTargetsNodes.end(); + ++it) { dataStorage->Remove(*it); } m_ReachedTargetsNodes.clear(); m_CurrentTargetIndex = 0; // reset button states ui->freezeImageButton->setEnabled(false); ui->backToLastTargetButton->setEnabled(false); ui->targetReachedButton->setEnabled(true); // make sure that it is unfreezed after stopping the step ui->freezeImageButton->Unfreeze(); // remove base node for reached targets from the data storage mitk::DataNode::Pointer reachedTargetsNode = this->GetNamedDerivedNode( - QmitkUSAbstractNavigationStep::DATANAME_BASENODE, - USNavigationMarkerPlacement::DATANAME_REACHED_TARGETS); - if (reachedTargetsNode.IsNotNull()) { dataStorage->Remove(reachedTargetsNode); } + QmitkUSAbstractNavigationStep::DATANAME_BASENODE, USNavigationMarkerPlacement::DATANAME_REACHED_TARGETS); + if (reachedTargetsNode.IsNotNull()) + { + dataStorage->Remove(reachedTargetsNode); + } return true; } bool QmitkUSNavigationStepMarkerIntervention::OnFinishStep() { return true; } bool QmitkUSNavigationStepMarkerIntervention::OnActivateStep() { this->ClearZones(); // clear risk zones before adding new ones // get target node from data storage and make sure that it contains data m_TargetNode = this->GetNamedDerivedNode(USNavigationMarkerPlacement::DATANAME_TARGETSURFACE, - USNavigationMarkerPlacement::DATANAME_TUMOUR); + USNavigationMarkerPlacement::DATANAME_TUMOUR); if (m_TargetNode.IsNull() || m_TargetNode->GetData() == 0) { mitkThrow() << "Target node (" << USNavigationMarkerPlacement::DATANAME_TARGETSURFACE << ") must not be null."; } // get target data and make sure that it is a surface - m_TargetSurface = dynamic_cast(m_TargetNode->GetData()); + m_TargetSurface = dynamic_cast(m_TargetNode->GetData()); if (m_TargetSurface.IsNull()) { - mitkThrow() << "Target node (" << USNavigationMarkerPlacement::DATANAME_TARGETSURFACE << ") data must be of type mitk::Surface"; + mitkThrow() << "Target node (" << USNavigationMarkerPlacement::DATANAME_TARGETSURFACE + << ") data must be of type mitk::Surface"; } // delete progress bars for reinitializing them again afterwards if (m_PlannedTargetProgressBar) { ui->targetStructuresRangeLayout->removeWidget(m_PlannedTargetProgressBar); delete m_PlannedTargetProgressBar; m_PlannedTargetProgressBar = 0; } m_NodeDisplacementFilter->SelectInput(m_ReferenceSensorIndex); this->UpdateTargetProgressDisplay(); - mitk::DataNode::Pointer tumourNode = this->GetNamedDerivedNode( - USNavigationMarkerPlacement::DATANAME_TUMOUR, QmitkUSAbstractNavigationStep::DATANAME_BASENODE); + mitk::DataNode::Pointer tumourNode = this->GetNamedDerivedNode(USNavigationMarkerPlacement::DATANAME_TUMOUR, + QmitkUSAbstractNavigationStep::DATANAME_BASENODE); if (tumourNode.IsNotNull()) { // do not show tumour node during intervention (target surface is shown) tumourNode->SetBoolProperty("visible", false); // add tumour as a risk structure ui->riskStructuresRangeWidget->AddZone(tumourNode); } // set target structure for target update filter m_TargetUpdateFilter->SetTargetStructure(m_TargetNode); m_TargetOcclusionFilter->SetTargetStructure(m_TargetNode); // set lookup table of tumour node m_TargetNode->SetProperty("LookupTable", m_TargetColorLookupTableProperty); // - mitk::DataNode::Pointer targetsBaseNode = this->GetNamedDerivedNode( - USNavigationMarkerPlacement::DATANAME_TARGETS, QmitkUSAbstractNavigationStep::DATANAME_BASENODE); + mitk::DataNode::Pointer targetsBaseNode = this->GetNamedDerivedNode(USNavigationMarkerPlacement::DATANAME_TARGETS, + QmitkUSAbstractNavigationStep::DATANAME_BASENODE); mitk::DataStorage::SetOfObjects::ConstPointer plannedTargetNodes; - if (targetsBaseNode.IsNotNull()) { plannedTargetNodes = this->GetDataStorage()->GetDerivations(targetsBaseNode); } + if (targetsBaseNode.IsNotNull()) + { + plannedTargetNodes = this->GetDataStorage()->GetDerivations(targetsBaseNode); + } if (plannedTargetNodes.IsNotNull() && plannedTargetNodes->Size() > 0) { for (mitk::DataStorage::SetOfObjects::ConstIterator it = plannedTargetNodes->Begin(); - it != plannedTargetNodes->End(); ++it) + it != plannedTargetNodes->End(); + ++it) { m_PlannedTargetsNodes.push_back(it->Value()); } m_PlannedTargetProgressBar = new QmitkZoneProgressBar(QString::fromStdString("Planned Target"), 200, 0); ui->targetStructuresRangeLayout->addWidget(m_PlannedTargetProgressBar); } // add progress bars for risk zone nodes - mitk::DataNode::Pointer zonesBaseNode = this->GetNamedDerivedNode( - USNavigationMarkerPlacement::DATANAME_ZONES, QmitkUSAbstractNavigationStep::DATANAME_BASENODE); + mitk::DataNode::Pointer zonesBaseNode = this->GetNamedDerivedNode(USNavigationMarkerPlacement::DATANAME_ZONES, + QmitkUSAbstractNavigationStep::DATANAME_BASENODE); // only add progress bars if the base node for zones was created if (zonesBaseNode.IsNotNull()) { mitk::DataStorage::SetOfObjects::ConstPointer zoneNodes = this->GetDataStorage()->GetDerivations(zonesBaseNode); - for (mitk::DataStorage::SetOfObjects::ConstIterator it = zoneNodes->Begin(); - it != zoneNodes->End(); ++it) + for (mitk::DataStorage::SetOfObjects::ConstIterator it = zoneNodes->Begin(); it != zoneNodes->End(); ++it) { ui->riskStructuresRangeWidget->AddZone(it->Value()); } m_TargetOcclusionFilter->SelectStartPositionInput(m_NeedleSensorIndex); m_TargetOcclusionFilter->SetObstacleStructures(zoneNodes); } return true; } bool QmitkUSNavigationStepMarkerIntervention::OnDeactivateStep() { ui->freezeImageButton->Unfreeze(); return true; } void QmitkUSNavigationStepMarkerIntervention::OnUpdate() { // 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")("QmitkUSNavigationStepMarkerIntervention") - << "Navigation Data Source of Combined Modality must not be null."; + MITK_ERROR("QmitkUSAbstractNavigationStep") + ("QmitkUSNavigationStepMarkerIntervention") << "Navigation Data Source of Combined Modality must not be null."; mitkThrow() << "Navigation Data Source of Combined Modality must not be null."; } ui->riskStructuresRangeWidget->UpdateDistancesToNeedlePosition(navigationDataSource->GetOutput(m_NeedleSensorIndex)); this->UpdateBodyMarkerStatus(navigationDataSource->GetOutput(m_ReferenceSensorIndex)); this->UpdateTargetColors(); this->UpdateTargetScore(); this->UpdateTargetViolationStatus(); } void QmitkUSNavigationStepMarkerIntervention::OnSettingsChanged(const itk::SmartPointer settingsNode) { - if (settingsNode.IsNull()) { return; } + if (settingsNode.IsNull()) + { + return; + } int numberOfTargets; if (settingsNode->GetIntProperty("settings.number-of-targets", numberOfTargets)) { m_NumberOfTargets = numberOfTargets; m_TargetUpdateFilter->SetNumberOfTargets(numberOfTargets); m_PlacementQualityCalculator->SetOptimalAngle(m_TargetUpdateFilter->GetOptimalAngle()); } std::string referenceSensorName; if (settingsNode->GetStringProperty("settings.reference-name-selected", referenceSensorName)) { m_ReferenceSensorName = referenceSensorName; } std::string needleSensorName; if (settingsNode->GetStringProperty("settings.needle-name-selected", needleSensorName)) { m_NeedleSensorName = needleSensorName; } this->UpdateSensorsNames(); } QString QmitkUSNavigationStepMarkerIntervention::GetTitle() { return "Computer-assisted Intervention"; } bool QmitkUSNavigationStepMarkerIntervention::GetIsRestartable() { return true; } QmitkUSAbstractNavigationStep::FilterVector QmitkUSNavigationStepMarkerIntervention::GetFilter() { FilterVector filter; filter.push_back(m_NeedleProjectionFilter.GetPointer()); filter.push_back(m_NodeDisplacementFilter.GetPointer()); filter.push_back(m_TargetOcclusionFilter.GetPointer()); return filter; } void QmitkUSNavigationStepMarkerIntervention::OnSetCombinedModality() { mitk::USCombinedModality::Pointer combinedModality = this->GetCombinedModality(false); if (combinedModality.IsNotNull()) { mitk::AffineTransform3D::Pointer calibration = combinedModality->GetCalibration(); if (calibration.IsNotNull()) { m_NeedleProjectionFilter->SetTargetPlane(calibration); } } ui->freezeImageButton->SetCombinedModality(combinedModality, m_ReferenceSensorIndex); this->UpdateSensorsNames(); } void QmitkUSNavigationStepMarkerIntervention::OnTargetReached() { m_CurrentTargetReached = true; } void QmitkUSNavigationStepMarkerIntervention::OnTargetLeft() { m_CurrentTargetReached = false; m_CurrentTargetIndex++; - if (m_CurrentTargetIndex >= 0 - && static_cast(m_CurrentTargetIndex) >= m_NumberOfTargets) + if (m_CurrentTargetIndex >= 0 && static_cast(m_CurrentTargetIndex) >= m_NumberOfTargets) { ui->targetReachedButton->setDisabled(true); } ui->backToLastTargetButton->setEnabled(true); ui->freezeImageButton->setEnabled(true); this->UpdateTargetProgressDisplay(); if (m_ReachedTargetsNodes.size() < m_CurrentTargetIndex) { mitk::DataNode::Pointer node = mitk::DataNode::New(); - node->SetName((QString("Target ") + QString("%1").arg(m_CurrentTargetIndex, 2, 10, QLatin1Char('0'))).toStdString()); - this->GetDataStorage()->Add(node, this->GetNamedDerivedNodeAndCreate(USNavigationMarkerPlacement::DATANAME_REACHED_TARGETS, - QmitkUSAbstractNavigationStep::DATANAME_BASENODE)); + node->SetName( + (QString("Target ") + QString("%1").arg(m_CurrentTargetIndex, 2, 10, QLatin1Char('0'))).toStdString()); + this->GetDataStorage()->Add( + node, + this->GetNamedDerivedNodeAndCreate(USNavigationMarkerPlacement::DATANAME_REACHED_TARGETS, + QmitkUSAbstractNavigationStep::DATANAME_BASENODE)); m_ReachedTargetsNodes.push_back(node); } mitk::DataNode::Pointer node = m_ReachedTargetsNodes.at(m_CurrentTargetIndex - 1); mitk::Surface::Pointer zone = mitk::Surface::New(); // create a vtk sphere with given radius vtkSphereSource *vtkData = vtkSphereSource::New(); vtkData->SetRadius(5); vtkData->SetCenter(0, 0, 0); vtkData->Update(); zone->SetVtkPolyData(vtkData->GetOutput()); vtkData->Delete(); // set vtk sphere and origin to data node node->SetData(zone); - node->GetData()->GetGeometry()->SetOrigin(this->GetCombinedModality()->GetNavigationDataSource()->GetOutput(m_NeedleSensorIndex)->GetPosition()); + node->GetData()->GetGeometry()->SetOrigin( + this->GetCombinedModality()->GetNavigationDataSource()->GetOutput(m_NeedleSensorIndex)->GetPosition()); node->SetColor(0.2, 0.9, 0.2); this->UpdateTargetCoordinates(node); } void QmitkUSNavigationStepMarkerIntervention::OnBackToLastTargetClicked() { if (m_CurrentTargetIndex < 1) { MITK_WARN << "Cannot go back to last target as there is no last target."; return; } m_CurrentTargetIndex--; if (m_ReachedTargetsNodes.size() > m_CurrentTargetIndex) { this->GetDataStorage()->Remove(m_ReachedTargetsNodes.last()); - MITK_INFO("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepMarkerIntervention") << "Removed Target " << m_ReachedTargetsNodes.size(); + MITK_INFO("QmitkUSAbstractNavigationStep") + ("QmitkUSNavigationStepMarkerIntervention") << "Removed Target " << m_ReachedTargetsNodes.size(); m_ReachedTargetsNodes.pop_back(); } - if (m_CurrentTargetIndex == 0) { ui->backToLastTargetButton->setDisabled(true); } - if (m_CurrentTargetIndex >= 0 - && static_cast(m_CurrentTargetIndex) < m_NumberOfTargets) + if (m_CurrentTargetIndex == 0) + { + ui->backToLastTargetButton->setDisabled(true); + } + if (m_CurrentTargetIndex >= 0 && static_cast(m_CurrentTargetIndex) < m_NumberOfTargets) { ui->targetReachedButton->setEnabled(true); } ui->freezeImageButton->setEnabled(false); ui->freezeImageButton->Unfreeze(); this->UpdateTargetProgressDisplay(); m_TargetUpdateFilter->RemovePositionOfTarget(m_CurrentTargetIndex); } void QmitkUSNavigationStepMarkerIntervention::OnFreeze(bool freezed) { if (freezed) { this->GetCombinedModality()->SetIsFreezed(true); // load state machine and event config for data interactor m_PointMarkInteractor->LoadStateMachine("USPointMarkInteractions.xml", us::ModuleRegistry::GetModule("MitkUS")); m_PointMarkInteractor->SetEventConfig("globalConfig.xml"); if (m_CurrentTargetIndex < 1) { mitkThrow() << "Current target index has to be greater zero when freeze button is clicked."; } if (m_ReachedTargetsNodes.size() < m_CurrentTargetIndex) { mitk::DataNode::Pointer node = mitk::DataNode::New(); - node->SetName((QString("Target ") + QString("%1").arg(m_CurrentTargetIndex, 2, 10, QLatin1Char('0'))).toStdString()); - this->GetDataStorage()->Add(node, this->GetNamedDerivedNodeAndCreate(USNavigationMarkerPlacement::DATANAME_REACHED_TARGETS, - QmitkUSAbstractNavigationStep::DATANAME_BASENODE)); + node->SetName( + (QString("Target ") + QString("%1").arg(m_CurrentTargetIndex, 2, 10, QLatin1Char('0'))).toStdString()); + this->GetDataStorage()->Add( + node, + this->GetNamedDerivedNodeAndCreate(USNavigationMarkerPlacement::DATANAME_REACHED_TARGETS, + QmitkUSAbstractNavigationStep::DATANAME_BASENODE)); m_ReachedTargetsNodes.push_back(node); } m_PointMarkInteractor->SetDataNode(m_ReachedTargetsNodes.last()); } else { m_PointMarkInteractor->SetDataNode(0); this->GetCombinedModality()->SetIsFreezed(false); } } void QmitkUSNavigationStepMarkerIntervention::OnShowPlanningView(bool show) { m_ShowPlanningColors = show; } -void QmitkUSNavigationStepMarkerIntervention::OnRiskZoneViolated(const mitk::DataNode* node, mitk::Point3D position) +void QmitkUSNavigationStepMarkerIntervention::OnRiskZoneViolated(const mitk::DataNode *node, mitk::Point3D position) { MITK_INFO << "Risk zone (" << node->GetName() << ") violated at position " << position << "."; } void QmitkUSNavigationStepMarkerIntervention::ClearZones() { ui->riskStructuresRangeWidget->ClearZones(); // remove all reached target nodes from the data storage and clear the list mitk::DataStorage::Pointer dataStorage = this->GetDataStorage(); - for (QVector::iterator it = m_ReachedTargetsNodes.begin(); - it != m_ReachedTargetsNodes.end(); ++it) + for (QVector::iterator it = m_ReachedTargetsNodes.begin(); it != m_ReachedTargetsNodes.end(); + ++it) { - if (it->IsNotNull()) { dataStorage->Remove(*it); } + if (it->IsNotNull()) + { + dataStorage->Remove(*it); + } } m_ReachedTargetsNodes.clear(); } -void QmitkUSNavigationStepMarkerIntervention::UpdateTargetCoordinates(mitk::DataNode* dataNode) +void QmitkUSNavigationStepMarkerIntervention::UpdateTargetCoordinates(mitk::DataNode *dataNode) { m_NodeDisplacementFilter->ResetNodes(); - for (QVector >::iterator it = m_ReachedTargetsNodes.begin(); - it != m_ReachedTargetsNodes.end(); ++it) + for (QVector>::iterator it = m_ReachedTargetsNodes.begin(); + it != m_ReachedTargetsNodes.end(); + ++it) { if (it->IsNotNull() && (*it)->GetData() != 0) { m_NodeDisplacementFilter->AddNode(*it); } } - mitk::BaseData* baseData = dataNode->GetData(); + mitk::BaseData *baseData = dataNode->GetData(); if (!baseData) { mitkThrow() << "Data of the data node must not be null."; } mitk::BaseGeometry::Pointer geometry = baseData->GetGeometry(); if (geometry.IsNull()) { mitkThrow() << "Geometry of the data node must not be null."; } m_TargetUpdateFilter->SetControlNode(m_CurrentTargetIndex - 1, dataNode); if (m_PlannedTargetsNodes.size() > m_CurrentTargetIndex - 1) { m_PlannedTargetsNodes.at(m_CurrentTargetIndex - 1)->SetVisibility(false); } - MITK_INFO("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepMarkerIntervention") - << "Target " << m_CurrentTargetIndex << " reached at position " << geometry->GetOrigin(); + MITK_INFO("QmitkUSAbstractNavigationStep") + ("QmitkUSNavigationStepMarkerIntervention") << "Target " << m_CurrentTargetIndex << " reached at position " + << geometry->GetOrigin(); this->CalculateTargetPlacementQuality(); } void QmitkUSNavigationStepMarkerIntervention::UpdateBodyMarkerStatus(mitk::NavigationData::Pointer bodyMarker) { if (bodyMarker.IsNull()) { - MITK_ERROR("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepMarkerIntervention") + MITK_ERROR("QmitkUSAbstractNavigationStep") + ("QmitkUSNavigationStepMarkerIntervention") << "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) { ui->bodyMarkerTrackingStatusLabel->setStyleSheet( "background-color: #8bff8b; margin-right: 1em; margin-left: 1em; border: 1px solid grey"); ui->bodyMarkerTrackingStatusLabel->setText("Body marker is inside the tracking volume."); } else { ui->bodyMarkerTrackingStatusLabel->setStyleSheet( "background-color: #ff7878; margin-right: 1em; margin-left: 1em; border: 1px solid grey"); ui->bodyMarkerTrackingStatusLabel->setText("Body marker is not inside the tracking volume."); } ui->targetStructuresRangeGroupBox->setEnabled(valid); ui->riskStructuresRangeGroupBox->setEnabled(valid); } void QmitkUSNavigationStepMarkerIntervention::GenerateTargetColorLookupTable() { vtkSmartPointer lookupTable = vtkSmartPointer::New(); lookupTable->SetHueRange(0.0, 0.33); lookupTable->SetSaturationRange(1.0, 1.0); lookupTable->SetValueRange(1.0, 1.0); lookupTable->SetTableRange(0.0, 1.0); lookupTable->Build(); mitk::LookupTable::Pointer lut = mitk::LookupTable::New(); lut->SetVtkLookupTable(lookupTable); m_TargetColorLookupTableProperty = mitk::LookupTableProperty::New(lut); } void QmitkUSNavigationStepMarkerIntervention::UpdateTargetColors() { - if (m_TargetNode.IsNull()) { return; } + if (m_TargetNode.IsNull()) + { + return; + } m_TargetNode->SetColor(1, 1, 1); - mitk::BaseData* targetNodeData = m_TargetNode->GetData(); - if (targetNodeData == 0) { return; } + mitk::BaseData *targetNodeData = m_TargetNode->GetData(); + if (targetNodeData == 0) + { + return; + } - mitk::Surface::Pointer targetNodeSurface = dynamic_cast(targetNodeData); + mitk::Surface::Pointer targetNodeSurface = dynamic_cast(targetNodeData); vtkSmartPointer targetNodeSurfaceVtk = targetNodeSurface->GetVtkPolyData(); - vtkPointData* targetPointData = targetNodeSurface->GetVtkPolyData()->GetPointData(); + vtkPointData *targetPointData = targetNodeSurface->GetVtkPolyData()->GetPointData(); - vtkFloatArray* scalars = dynamic_cast(targetPointData->GetScalars("USNavigation::Occlusion")); - vtkFloatArray* targetScoreScalars; + vtkFloatArray *scalars = dynamic_cast(targetPointData->GetScalars("USNavigation::Occlusion")); + vtkFloatArray *targetScoreScalars; if (m_ShowPlanningColors) { - targetScoreScalars = dynamic_cast(targetPointData->GetScalars("USNavigation::PlanningScalars")); + targetScoreScalars = dynamic_cast(targetPointData->GetScalars("USNavigation::PlanningScalars")); } else { - targetScoreScalars = dynamic_cast(targetPointData->GetScalars("USNavigation::ReachedTargetScores")); + targetScoreScalars = + dynamic_cast(targetPointData->GetScalars("USNavigation::ReachedTargetScores")); } - if (!scalars || !targetScoreScalars) { return; } + if (!scalars || !targetScoreScalars) + { + return; + } unsigned int numberOfTupels = scalars->GetNumberOfTuples(); - vtkSmartPointer colors = - vtkSmartPointer::New(); + vtkSmartPointer colors = vtkSmartPointer::New(); colors->SetNumberOfComponents(1); colors->SetNumberOfTuples(numberOfTupels); colors->SetName("Colors"); double color, intersection, markerScore; for (unsigned int n = 0; n < numberOfTupels; n++) { scalars->GetTuple(n, &intersection); targetScoreScalars->GetTuple(n, &markerScore); if (intersection > 0) { color = 0; } else { color = markerScore; } colors->SetTuple(n, &color); } if (numberOfTupels > 0) { targetNodeSurfaceVtk->GetPointData()->SetScalars(colors); targetNodeSurfaceVtk->GetPointData()->Update(); } } void QmitkUSNavigationStepMarkerIntervention::UpdateTargetScore() { - if (m_NeedleProjectionFilter->GetProjection()->GetSize() != 2) { return; } + if (m_NeedleProjectionFilter->GetProjection()->GetSize() != 2) + { + return; + } vtkSmartPointer targetSurfaceVtk = m_TargetSurface->GetVtkPolyData(); m_TargetIntersectionFilter->SetTargetSurface(m_TargetSurface); m_TargetIntersectionFilter->SetLine(m_NeedleProjectionFilter->GetProjection()); m_TargetIntersectionFilter->CalculateIntersection(); if (m_TargetIntersectionFilter->GetIsIntersecting()) { - vtkFloatArray* scalars = dynamic_cast(targetSurfaceVtk->GetPointData()->GetScalars("USNavigation::ReachedTargetScores")); + vtkFloatArray *scalars = + dynamic_cast(targetSurfaceVtk->GetPointData()->GetScalars("USNavigation::ReachedTargetScores")); double score; scalars->GetTuple(m_TargetIntersectionFilter->GetIntersectionNearestSurfacePointId(), &score); double color[3]; m_TargetColorLookupTableProperty->GetLookupTable()->GetVtkLookupTable()->GetColor(score, color); float colorF[3]; - colorF[0] = color[0]; colorF[1] = color[1]; colorF[2] = color[2]; + colorF[0] = color[0]; + colorF[1] = color[1]; + colorF[2] = color[2]; m_TargetProgressBar->SetColor(colorF); m_TargetProgressBar->SetBorderColor(colorF); m_TargetProgressBar->setValue(m_TargetIntersectionFilter->GetDistanceToIntersection()); if (m_PlannedTargetProgressBar) { - vtkFloatArray* scalars = dynamic_cast(targetSurfaceVtk->GetPointData()->GetScalars("USNavigation::PlanningScalars")); + vtkFloatArray *scalars = + dynamic_cast(targetSurfaceVtk->GetPointData()->GetScalars("USNavigation::PlanningScalars")); if (scalars) { double score; scalars->GetTuple(m_TargetIntersectionFilter->GetIntersectionNearestSurfacePointId(), &score); double color[3]; m_TargetColorLookupTableProperty->GetLookupTable()->GetVtkLookupTable()->GetColor(score, color); float colorF[3]; - colorF[0] = color[0]; colorF[1] = color[1]; colorF[2] = color[2]; + colorF[0] = color[0]; + colorF[1] = color[1]; + colorF[2] = color[2]; m_PlannedTargetProgressBar->SetColor(colorF); m_PlannedTargetProgressBar->SetBorderColor(colorF); m_PlannedTargetProgressBar->SetTextFormatValid("Planned Target: %1 mm"); mitk::Point3D intersectionPoint = m_TargetIntersectionFilter->GetIntersectionPoint(); mitk::ScalarType minDistance = -1; - for (QVector >::iterator it = m_PlannedTargetsNodes.begin(); - it != m_PlannedTargetsNodes.end(); ++it) + for (QVector>::iterator it = m_PlannedTargetsNodes.begin(); + it != m_PlannedTargetsNodes.end(); + ++it) { - mitk::ScalarType distance = intersectionPoint.EuclideanDistanceTo((*it)->GetData()->GetGeometry()->GetOrigin()); - if (minDistance < 0 || distance < minDistance) { minDistance = distance; } + mitk::ScalarType distance = + intersectionPoint.EuclideanDistanceTo((*it)->GetData()->GetGeometry()->GetOrigin()); + if (minDistance < 0 || distance < minDistance) + { + minDistance = distance; + } } m_PlannedTargetProgressBar->setValue(minDistance); } } } else { m_TargetProgressBar->setValueInvalid(); } } void QmitkUSNavigationStepMarkerIntervention::UpdateTargetProgressDisplay() { QString description; if (m_CurrentTargetIndex >= m_NumberOfTargets) { description = "All Targets Reached"; - if (m_TargetProgressBar) { m_TargetProgressBar->hide(); } + if (m_TargetProgressBar) + { + m_TargetProgressBar->hide(); + } } else { - description = QString("Distance to Target ") + QString::number(m_CurrentTargetIndex + 1) - + QString(" of ") + QString::number(m_NumberOfTargets); - if (m_TargetProgressBar) { m_TargetProgressBar->show(); } + description = QString("Distance to Target ") + QString::number(m_CurrentTargetIndex + 1) + QString(" of ") + + QString::number(m_NumberOfTargets); + if (m_TargetProgressBar) + { + m_TargetProgressBar->show(); + } } ui->targetStructuresRangeGroupBox->setTitle(description); } void QmitkUSNavigationStepMarkerIntervention::UpdatePlannedTargetProgressDisplay() { // make sure that the needle projection consists of two points - if (m_NeedleProjectionFilter->GetProjection()->GetSize() != 2) { return; } + if (m_NeedleProjectionFilter->GetProjection()->GetSize() != 2) + { + return; + } vtkSmartPointer targetSurfaceVtk = m_TargetSurface->GetVtkPolyData(); m_TargetIntersectionFilter->SetTargetSurface(m_TargetSurface); m_TargetIntersectionFilter->SetLine(m_NeedleProjectionFilter->GetProjection()); m_TargetIntersectionFilter->CalculateIntersection(); // update target progress bar according to the color of the intersection // point on the target surface and the distance to the intersection if (m_TargetIntersectionFilter->GetIsIntersecting()) { - vtkFloatArray* scalars = dynamic_cast(targetSurfaceVtk->GetPointData()->GetScalars("Colors")); + vtkFloatArray *scalars = dynamic_cast(targetSurfaceVtk->GetPointData()->GetScalars("Colors")); double score; scalars->GetTuple(m_TargetIntersectionFilter->GetIntersectionNearestSurfacePointId(), &score); double color[3]; m_TargetColorLookupTableProperty->GetLookupTable()->GetVtkLookupTable()->GetColor(score, color); float colorF[3]; - colorF[0] = color[0]; colorF[1] = color[1]; colorF[2] = color[2]; + colorF[0] = color[0]; + colorF[1] = color[1]; + colorF[2] = color[2]; m_TargetProgressBar->SetColor(colorF); m_TargetProgressBar->SetBorderColor(colorF); m_TargetProgressBar->setValue(m_TargetIntersectionFilter->GetDistanceToIntersection()); } else { - float red[3] = { 0.6, 0, 0 }; + float red[3] = {0.6, 0, 0}; m_TargetProgressBar->SetBorderColor(red); m_TargetProgressBar->setValueInvalid(); } } void QmitkUSNavigationStepMarkerIntervention::UpdateTargetViolationStatus() { // transform vtk polydata according to mitk geometry - vtkSmartPointer transformFilter = - vtkSmartPointer::New(); + vtkSmartPointer transformFilter = vtkSmartPointer::New(); transformFilter->SetInputData(0, m_TargetSurface->GetVtkPolyData()); transformFilter->SetTransform(m_TargetSurface->GetGeometry()->GetVtkTransform()); transformFilter->Update(); vtkSmartPointer enclosedPoints = vtkSmartPointer::New(); enclosedPoints->Initialize(transformFilter->GetOutput()); mitk::Point3D needleTip = m_NeedleProjectionFilter->GetProjection()->GetPoint(0); // show warning if the needle tip is inside the target surface if (enclosedPoints->IsInsideSurface(needleTip[0], needleTip[1], needleTip[2])) { if (!m_TargetStructureWarnOverlay->IsVisible(NULL)) { m_TargetStructureWarnOverlay->SetVisibility(true); mitk::DataNode::Pointer targetViolationResult = mitk::DataNode::New(); targetViolationResult->SetName("TargetViolation"); targetViolationResult->SetProperty("USNavigation::TargetViolationPoint", mitk::Point3dProperty::New(needleTip)); emit SignalIntermediateResult(targetViolationResult); } - MITK_INFO("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepMarkerIntervention") - << "Target surface violated at " << needleTip << "."; + MITK_INFO("QmitkUSAbstractNavigationStep") + ("QmitkUSNavigationStepMarkerIntervention") << "Target surface violated at " << needleTip << "."; } else { m_TargetStructureWarnOverlay->SetVisibility(false); } } void QmitkUSNavigationStepMarkerIntervention::CalculateTargetPlacementQuality() { // clear quality display if there aren't all targets reached if (m_ReachedTargetsNodes.size() != m_NumberOfTargets) { ui->placementQualityGroupBox->setEnabled(false); ui->angleDifferenceValue->setText(""); ui->centersOfMassValue->setText(""); return; } ui->placementQualityGroupBox->setEnabled(true); - mitk::Surface::Pointer targetSurface = dynamic_cast(m_TargetNode->GetData()); + mitk::Surface::Pointer targetSurface = dynamic_cast(m_TargetNode->GetData()); if (targetSurface.IsNull()) { mitkThrow() << "Target surface must not be null."; } m_PlacementQualityCalculator->SetTargetSurface(targetSurface); mitk::PointSet::Pointer targetPointSet = mitk::PointSet::New(); // copy the origins of all reached target nodes into a point set // for the quality calculator mitk::PointSet::PointIdentifier n = 0; - for (QVector >::iterator it = m_ReachedTargetsNodes.begin(); - it != m_ReachedTargetsNodes.end(); ++it) + for (QVector>::iterator it = m_ReachedTargetsNodes.begin(); + it != m_ReachedTargetsNodes.end(); + ++it) { targetPointSet->InsertPoint(n++, (*it)->GetData()->GetGeometry()->GetOrigin()); } m_PlacementQualityCalculator->SetTargetPoints(targetPointSet); m_PlacementQualityCalculator->Update(); double centersOfMassDistance = m_PlacementQualityCalculator->GetCentersOfMassDistance(); - ui->centersOfMassValue->setText(QString::number( - centersOfMassDistance, 103, 2) + " mm"); + ui->centersOfMassValue->setText(QString::number(centersOfMassDistance, 103, 2) + " mm"); double meanAnglesDifference = m_PlacementQualityCalculator->GetMeanAngleDifference(); - ui->angleDifferenceValue->setText(QString::number( - meanAnglesDifference, 103, 2) + QString::fromLatin1(" °")); + ui->angleDifferenceValue->setText(QString::number(meanAnglesDifference, 103, 2) + QString::fromLatin1(" °")); // create an intermediate result of the placement quality mitk::DataNode::Pointer placementQualityResult = mitk::DataNode::New(); placementQualityResult->SetName("PlacementQuality"); placementQualityResult->SetFloatProperty("USNavigation::CentersOfMassDistance", centersOfMassDistance); placementQualityResult->SetFloatProperty("USNavigation::MeanAngleDifference", meanAnglesDifference); - placementQualityResult->SetProperty("USNavigation::AngleDifferences", + placementQualityResult->SetProperty( + "USNavigation::AngleDifferences", mitk::GenericProperty::New(m_PlacementQualityCalculator->GetAngleDifferences())); if (m_PlannedTargetsNodes.size() == m_NumberOfTargets) { mitk::VnlVector reachedPlannedDifferences; double reachedPlannedDifferencesSum = 0; double reachedPlannedDifferencesMax = 0; reachedPlannedDifferences.set_size(m_NumberOfTargets); // get sum and maximum of the planning / reality differences for (unsigned int n = 0; n < m_NumberOfTargets; ++n) { - mitk::ScalarType distance = m_PlannedTargetsNodes.at(n)->GetData()->GetGeometry()->GetOrigin() - .EuclideanDistanceTo(m_ReachedTargetsNodes.at(n)->GetData()->GetGeometry()->GetOrigin()); + mitk::ScalarType distance = + m_PlannedTargetsNodes.at(n)->GetData()->GetGeometry()->GetOrigin().EuclideanDistanceTo( + m_ReachedTargetsNodes.at(n)->GetData()->GetGeometry()->GetOrigin()); reachedPlannedDifferences.put(n, distance); reachedPlannedDifferencesSum += distance; - if (distance > reachedPlannedDifferencesMax) { reachedPlannedDifferencesMax = distance; } + if (distance > reachedPlannedDifferencesMax) + { + reachedPlannedDifferencesMax = distance; + } } // add distances between planning and reality to the quality intermediate result placementQualityResult->SetProperty("USNavigation::PlanningRealityDistances", - mitk::GenericProperty::New(reachedPlannedDifferences)); - placementQualityResult->SetProperty("USNavigation::MeanPlanningRealityDistance", + mitk::GenericProperty::New(reachedPlannedDifferences)); + placementQualityResult->SetProperty( + "USNavigation::MeanPlanningRealityDistance", mitk::DoubleProperty::New(reachedPlannedDifferencesSum / static_cast(m_NumberOfTargets))); placementQualityResult->SetProperty("USNavigation::MaximumPlanningRealityDistance", - mitk::DoubleProperty::New(reachedPlannedDifferencesMax)); + mitk::DoubleProperty::New(reachedPlannedDifferencesMax)); } emit SignalIntermediateResult(placementQualityResult); } void QmitkUSNavigationStepMarkerIntervention::UpdateSensorsNames() { mitk::USCombinedModality::Pointer combinedModality = this->GetCombinedModality(false); - if (combinedModality.IsNull()) { return; } + if (combinedModality.IsNull()) + { + return; + } mitk::NavigationDataSource::Pointer navigationDataSource = combinedModality->GetNavigationDataSource(); - if (navigationDataSource.IsNull()) { return; } + if (navigationDataSource.IsNull()) + { + return; + } if (!m_NeedleSensorName.empty()) { try { m_NeedleSensorIndex = navigationDataSource->GetOutputIndex(m_NeedleSensorName); } catch (const std::exception &e) { - MITK_WARN("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepPlacementPlanning") - << "Cannot get index for needle sensor name: " << e.what(); + MITK_WARN("QmitkUSAbstractNavigationStep") + ("QmitkUSNavigationStepPlacementPlanning") << "Cannot get index for needle sensor name: " << e.what(); } } if (this->GetNavigationStepState() >= QmitkUSAbstractNavigationStep::State_Active) { m_NeedleProjectionFilter->SelectInput(m_NeedleSensorIndex); } if (!m_ReferenceSensorName.empty()) { try { m_ReferenceSensorIndex = navigationDataSource->GetOutputIndex(m_ReferenceSensorName); } catch (const std::exception &e) { - MITK_WARN("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepPlacementPlanning") - << "Cannot get index for reference sensor name: " << e.what(); + MITK_WARN("QmitkUSAbstractNavigationStep") + ("QmitkUSNavigationStepPlacementPlanning") << "Cannot get index for reference sensor name: " << e.what(); } } if (this->GetNavigationStepState() >= QmitkUSAbstractNavigationStep::State_Active) { m_NodeDisplacementFilter->SelectInput(m_ReferenceSensorIndex); } ui->freezeImageButton->SetCombinedModality(combinedModality, m_ReferenceSensorIndex); } diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.h b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.h index ca10e2334e..2f54e50fc5 100644 --- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.h +++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.h @@ -1,172 +1,171 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef QMITKUSNAVIGATIONSTEPMARKERINTERVENTION_H #define QMITKUSNAVIGATIONSTEPMARKERINTERVENTION_H #include "QmitkUSAbstractNavigationStep.h" -namespace mitk { -class DataNode; -class NeedleProjectionFilter; -class NodeDisplacementFilter; -class USNavigationGrabCutSegmentationUpdateFilter; -class USNavigationTargetUpdateFilter; -class USNavigationTargetOcclusionFilter; -class USNavigationTargetIntersectionFilter; -class USPointMarkInteractor; -class LookupTableProperty; -class Surface; -class OverlayManager; -class TextOverlay2D; -class USTargetPlacementQualityCalculator; +namespace mitk +{ + class DataNode; + class NeedleProjectionFilter; + class NodeDisplacementFilter; + class USNavigationGrabCutSegmentationUpdateFilter; + class USNavigationTargetUpdateFilter; + class USNavigationTargetOcclusionFilter; + class USNavigationTargetIntersectionFilter; + class USPointMarkInteractor; + class LookupTableProperty; + class Surface; + class TextAnnotation2D; + class USTargetPlacementQualityCalculator; } -namespace Ui { -class QmitkUSNavigationStepMarkerIntervention; +namespace Ui +{ + class QmitkUSNavigationStepMarkerIntervention; } class QmitkZoneProgressBar; /** * \brief Navigation step for the actual marker placement. */ class QmitkUSNavigationStepMarkerIntervention : public QmitkUSAbstractNavigationStep { Q_OBJECT signals: void TargetReached(int); void TargetLeft(int); protected slots: void OnTargetReached(); void OnTargetLeft(); void OnBackToLastTargetClicked(); void OnFreeze(bool); void OnShowPlanningView(bool); - void OnRiskZoneViolated(const mitk::DataNode*, mitk::Point3D); + void OnRiskZoneViolated(const mitk::DataNode *, mitk::Point3D); public: explicit QmitkUSNavigationStepMarkerIntervention(QWidget *parent = 0); ~QmitkUSNavigationStepMarkerIntervention(); virtual bool OnStartStep(); virtual bool OnStopStep(); virtual bool OnFinishStep(); virtual bool OnActivateStep(); virtual bool OnDeactivateStep(); virtual void OnUpdate(); virtual void OnSettingsChanged(const itk::SmartPointer settingsNode); virtual QString GetTitle(); virtual bool GetIsRestartable(); virtual FilterVector GetFilter(); protected: virtual void OnSetCombinedModality(); void ClearZones(); - void UpdateTargetCoordinates(mitk::DataNode*); + void UpdateTargetCoordinates(mitk::DataNode *); void UpdateBodyMarkerStatus(mitk::NavigationData::Pointer bodyMarker); void GenerateTargetColorLookupTable(); void UpdateTargetColors(); /** * \brief */ void UpdateTargetScore(); /** * \brief Updates display showing the number of the currently active target. */ void UpdateTargetProgressDisplay(); /** * \brief Updates color and distance of the progress bar for the planned target. * The intersection between needle path and target surface is calculated and * the color is got from the intersection point. */ void UpdatePlannedTargetProgressDisplay(); /** * \brief Tests for target violation and updates the display accordingly. * This method tests if the needle tip is inside the target surface. */ void UpdateTargetViolationStatus(); /** * \brief Calculates and display quality metrics if all three markers are placed. */ void CalculateTargetPlacementQuality(); void UpdateSensorsNames(); - unsigned int m_NumberOfTargets; - - QVector > m_ZoneNodes; - QVector > m_PlannedTargetsNodes; - QVector > m_ReachedTargetsNodes; + unsigned int m_NumberOfTargets; - itk::SmartPointer m_SegmentationNode; - itk::SmartPointer m_ForegroundModelPointsNode; + QVector> m_ZoneNodes; + QVector> m_PlannedTargetsNodes; + QVector> m_ReachedTargetsNodes; - QmitkZoneProgressBar* m_TargetProgressBar; - QmitkZoneProgressBar* m_PlannedTargetProgressBar; + itk::SmartPointer m_SegmentationNode; + itk::SmartPointer m_ForegroundModelPointsNode; - int m_CurrentTargetIndex; - bool m_CurrentTargetReached; + QmitkZoneProgressBar *m_TargetProgressBar; + QmitkZoneProgressBar *m_PlannedTargetProgressBar; - mitk::ScalarType m_ActiveTargetColor[3]; - mitk::ScalarType m_InactiveTargetColor[3]; - mitk::ScalarType m_ReachedTargetColor[3]; + int m_CurrentTargetIndex; + bool m_CurrentTargetReached; - bool m_ShowPlanningColors; - itk::SmartPointer m_PointMarkInteractor; + mitk::ScalarType m_ActiveTargetColor[3]; + mitk::ScalarType m_InactiveTargetColor[3]; + mitk::ScalarType m_ReachedTargetColor[3]; - itk::SmartPointer m_TargetNode; - itk::SmartPointer m_TargetColorLookupTableProperty; + bool m_ShowPlanningColors; + itk::SmartPointer m_PointMarkInteractor; - itk::SmartPointer m_TargetSurface; + itk::SmartPointer m_TargetNode; + itk::SmartPointer m_TargetColorLookupTableProperty; + itk::SmartPointer m_TargetSurface; - itk::SmartPointer m_NeedleProjectionFilter; - itk::SmartPointer m_NodeDisplacementFilter; + itk::SmartPointer m_NeedleProjectionFilter; + itk::SmartPointer m_NodeDisplacementFilter; - itk::SmartPointer m_TargetUpdateFilter; - itk::SmartPointer m_TargetOcclusionFilter; - itk::SmartPointer m_TargetIntersectionFilter; - itk::SmartPointer m_PlacementQualityCalculator; + itk::SmartPointer m_TargetUpdateFilter; + itk::SmartPointer m_TargetOcclusionFilter; + itk::SmartPointer m_TargetIntersectionFilter; + itk::SmartPointer m_PlacementQualityCalculator; - itk::SmartPointer m_OverlayManager; - itk::SmartPointer m_TargetStructureWarnOverlay; + itk::SmartPointer m_TargetStructureWarnOverlay; - std::string m_ReferenceSensorName; - std::string m_NeedleSensorName; + std::string m_ReferenceSensorName; + std::string m_NeedleSensorName; - unsigned int m_ReferenceSensorIndex; - unsigned int m_NeedleSensorIndex; + unsigned int m_ReferenceSensorIndex; + unsigned int m_NeedleSensorIndex; private: - mitk::MessageDelegate1 m_ListenerTargetCoordinatesChanged; + mitk::MessageDelegate1 m_ListenerTargetCoordinatesChanged; Ui::QmitkUSNavigationStepMarkerIntervention *ui; }; #endif // QMITKUSNAVIGATIONSTEPMARKERINTERVENTION_H diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.cpp b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.cpp index 5a60858b51..ee9412bb47 100644 --- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.cpp +++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.cpp @@ -1,778 +1,817 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "QmitkUSNavigationStepPlacementPlanning.h" #include "ui_QmitkUSNavigationStepPlacementPlanning.h" -#include "usModuleRegistry.h" #include "../Interactors/mitkUSPointMarkInteractor.h" -#include "mitkNodeDisplacementFilter.h" -#include "mitkNeedleProjectionFilter.h" #include "../mitkUSTargetPlacementQualityCalculator.h" +#include "mitkNeedleProjectionFilter.h" +#include "mitkNodeDisplacementFilter.h" +#include "usModuleRegistry.h" -#include "../Filter/mitkUSNavigationTargetUpdateFilter.h" #include "../Filter/mitkUSNavigationTargetIntersectionFilter.h" +#include "../Filter/mitkUSNavigationTargetUpdateFilter.h" #include "../USNavigationMarkerPlacement.h" -#include -#include "mitkSurface.h" #include "mitkLookupTableProperty.h" +#include "mitkSurface.h" +#include -#include "mitkOverlayManager.h" -#include "mitkTextOverlay3D.h" +#include "mitkLayoutAnnotationRenderer.h" +#include "mitkTextAnnotation3D.h" -#include "vtkSmartPointer.h" -#include "vtkPolyData.h" #include "vtkFloatArray.h" -#include "vtkPointData.h" #include "vtkLookupTable.h" +#include "vtkPointData.h" +#include "vtkPolyData.h" +#include "vtkSmartPointer.h" -#include "vtkSphereSource.h" #include "vtkLineSource.h" +#include "vtkSphereSource.h" -#include "vtkTransformPolyDataFilter.h" -#include "vtkLinearTransform.h" #include "vtkCenterOfMass.h" +#include "vtkLinearTransform.h" #include "vtkPoints.h" +#include "vtkTransformPolyDataFilter.h" #include "vtkUnstructuredGrid.h" #include "vtkMath.h" -QmitkUSNavigationStepPlacementPlanning::QmitkUSNavigationStepPlacementPlanning(QWidget *parent) : - QmitkUSAbstractNavigationStep(parent), - m_NumberOfTargets(0), - m_CurrentTargetIndex(0), - m_BodyMarkerValid(false), - m_PointMarkInteractor(mitk::USPointMarkInteractor::New()), - m_TargetUpdateFilter(mitk::USNavigationTargetUpdateFilter::New()), - m_NodeDisplacementFilter(mitk::NodeDisplacementFilter::New()), - m_NeedleProjectionFilter(mitk::NeedleProjectionFilter::New()), - m_TargetIntersectionFilter(mitk::USNavigationTargetIntersectionFilter::New()), - m_PlacementQualityCalculator(mitk::USTargetPlacementQualityCalculator::New()), - m_ListenerTargetCoordinatesChanged(this, &QmitkUSNavigationStepPlacementPlanning::UpdateTargetCoordinates), - m_ReferenceSensorIndex(1), m_NeedleSensorIndex(0), - ui(new Ui::QmitkUSNavigationStepPlacementPlanning) +QmitkUSNavigationStepPlacementPlanning::QmitkUSNavigationStepPlacementPlanning(QWidget *parent) + : QmitkUSAbstractNavigationStep(parent), + m_NumberOfTargets(0), + m_CurrentTargetIndex(0), + m_BodyMarkerValid(false), + m_PointMarkInteractor(mitk::USPointMarkInteractor::New()), + m_TargetUpdateFilter(mitk::USNavigationTargetUpdateFilter::New()), + m_NodeDisplacementFilter(mitk::NodeDisplacementFilter::New()), + m_NeedleProjectionFilter(mitk::NeedleProjectionFilter::New()), + m_TargetIntersectionFilter(mitk::USNavigationTargetIntersectionFilter::New()), + m_PlacementQualityCalculator(mitk::USTargetPlacementQualityCalculator::New()), + m_ListenerTargetCoordinatesChanged(this, &QmitkUSNavigationStepPlacementPlanning::UpdateTargetCoordinates), + m_ReferenceSensorIndex(1), + m_NeedleSensorIndex(0), + ui(new Ui::QmitkUSNavigationStepPlacementPlanning) { ui->setupUi(this); - connect( ui->freezeImageButton, SIGNAL(SignalFreezed(bool)), this, SLOT(OnFreeze(bool)) ); + connect(ui->freezeImageButton, SIGNAL(SignalFreezed(bool)), this, SLOT(OnFreeze(bool))); m_TargetUpdateFilter->SetScalarArrayIdentifier("USNavigation::PlanningPlacement"); this->GenerateTargetColorLookupTable(); } QmitkUSNavigationStepPlacementPlanning::~QmitkUSNavigationStepPlacementPlanning() { delete ui; } bool QmitkUSNavigationStepPlacementPlanning::OnStartStep() { // create node for needle projection - mitk::DataNode::Pointer node = this->GetNamedDerivedNodeAndCreate("Needle Path", QmitkUSAbstractNavigationStep::DATANAME_BASENODE); + mitk::DataNode::Pointer node = + this->GetNamedDerivedNodeAndCreate("Needle Path", QmitkUSAbstractNavigationStep::DATANAME_BASENODE); node->SetData(m_NeedleProjectionFilter->GetProjection()); node->SetBoolProperty("show contour", true); // make sure that the targets node exist in the data storage this->GetNamedDerivedNodeAndCreate(USNavigationMarkerPlacement::DATANAME_TARGETS, - QmitkUSAbstractNavigationStep::DATANAME_BASENODE); + QmitkUSAbstractNavigationStep::DATANAME_BASENODE); this->GetNamedDerivedNodeAndCreate(USNavigationMarkerPlacement::DATANAME_TARGETS_PATHS, - QmitkUSAbstractNavigationStep::DATANAME_BASENODE); + QmitkUSAbstractNavigationStep::DATANAME_BASENODE); // listen to event of point mark interactor m_PointMarkInteractor->CoordinatesChangedEvent.AddListener(m_ListenerTargetCoordinatesChanged); return true; } bool QmitkUSNavigationStepPlacementPlanning::OnStopStep() { // remove listener to event of point mark interactor m_PointMarkInteractor->CoordinatesChangedEvent.RemoveListener(m_ListenerTargetCoordinatesChanged); m_CurrentTargetIndex = 0; m_TargetUpdateFilter->Reset(); m_NodeDisplacementFilter->ResetNodes(); // remove the planned target nodes from the data storage mitk::DataStorage::Pointer dataStorage = this->GetDataStorage(); - for ( QVector >::iterator it = m_PlannedTargetNodes.begin(); - it != m_PlannedTargetNodes.end(); ++it ) + for (QVector>::iterator it = m_PlannedTargetNodes.begin(); + it != m_PlannedTargetNodes.end(); + ++it) { dataStorage->Remove(*it); } m_PlannedTargetNodes.clear(); // remove the planned target path nodes from the data storage - for ( QVector >::iterator it = m_PlannedNeedlePaths.begin(); - it != m_PlannedNeedlePaths.end(); ++it ) + for (QVector>::iterator it = m_PlannedNeedlePaths.begin(); + it != m_PlannedNeedlePaths.end(); + ++it) { dataStorage->Remove(*it); } m_PlannedNeedlePaths.clear(); // remove the targets node from the data storage - mitk::DataNode::Pointer targetsNode = this->GetNamedDerivedNode( - USNavigationMarkerPlacement::DATANAME_TARGETS, - QmitkUSAbstractNavigationStep::DATANAME_BASENODE); - if ( targetsNode.IsNotNull() ) { dataStorage->Remove(targetsNode); } + mitk::DataNode::Pointer targetsNode = this->GetNamedDerivedNode(USNavigationMarkerPlacement::DATANAME_TARGETS, + QmitkUSAbstractNavigationStep::DATANAME_BASENODE); + if (targetsNode.IsNotNull()) + { + dataStorage->Remove(targetsNode); + } // remove the target paths node from the data storage mitk::DataNode::Pointer targetPathsNode = this->GetNamedDerivedNode( - USNavigationMarkerPlacement::DATANAME_TARGETS_PATHS, - QmitkUSAbstractNavigationStep::DATANAME_BASENODE); - if ( targetPathsNode.IsNotNull() ) { dataStorage->Remove(targetPathsNode); } + USNavigationMarkerPlacement::DATANAME_TARGETS_PATHS, QmitkUSAbstractNavigationStep::DATANAME_BASENODE); + if (targetPathsNode.IsNotNull()) + { + dataStorage->Remove(targetPathsNode); + } // make sure that the image is no longer freezed after stopping ui->freezeImageButton->Unfreeze(); return true; } bool QmitkUSNavigationStepPlacementPlanning::OnRestartStep() { this->OnStopStep(); this->OnStartStep(); return true; } bool QmitkUSNavigationStepPlacementPlanning::OnFinishStep() { // create scalars showing the planned positions on the target surface - if ( ! m_PlannedTargetNodes.isEmpty() ) + if (!m_PlannedTargetNodes.isEmpty()) { mitk::USNavigationTargetUpdateFilter::Pointer planningSurfaceFilter = mitk::USNavigationTargetUpdateFilter::New(); planningSurfaceFilter->SetOptimalAngle(0); planningSurfaceFilter->SetScalarArrayIdentifier("USNavigation::PlanningScalars"); planningSurfaceFilter->SetUseMaximumScore(true); planningSurfaceFilter->SetTargetStructure(m_TargetNode); unsigned int n = 0; - for ( QVector >::iterator it = m_PlannedTargetNodes.begin(); - it != m_PlannedTargetNodes.end(); ++it ) + for (QVector>::iterator it = m_PlannedTargetNodes.begin(); + it != m_PlannedTargetNodes.end(); + ++it) { bool isSurfaceEmpty; - if ( ((*it)->GetBoolProperty("surface_empty", isSurfaceEmpty)) && isSurfaceEmpty ) + if (((*it)->GetBoolProperty("surface_empty", isSurfaceEmpty)) && isSurfaceEmpty) { // remove node from data storage if it is not fully planned this->GetDataStorage()->Remove(*it); } else { // set origin to filter for coloring target surface (good // positions are positions near to the origin) planningSurfaceFilter->SetControlNode(n, *it); } n++; } } // make sure that the image is no longer freezed after finishing ui->freezeImageButton->Unfreeze(); return true; } bool QmitkUSNavigationStepPlacementPlanning::OnActivateStep() { emit SignalReadyForNextStep(); m_NodeDisplacementFilter->SelectInput(m_ReferenceSensorIndex); m_NeedleProjectionFilter->SelectInput(m_NeedleSensorIndex); - if ( m_PlannedTargetNodes.empty() ) { m_CurrentTargetIndex = 0; } - else { m_CurrentTargetIndex = m_PlannedTargetNodes.size() - 1; } + if (m_PlannedTargetNodes.empty()) + { + m_CurrentTargetIndex = 0; + } + else + { + m_CurrentTargetIndex = m_PlannedTargetNodes.size() - 1; + } m_TargetNode = this->GetNamedDerivedNode(USNavigationMarkerPlacement::DATANAME_TARGETSURFACE, - USNavigationMarkerPlacement::DATANAME_TUMOUR); + USNavigationMarkerPlacement::DATANAME_TUMOUR); m_TargetNode->SetBoolProperty("visible", true); // set lookup table of tumour node m_TargetNode->SetProperty("LookupTable", m_TargetColorLookupTableProperty); m_TargetUpdateFilter->SetTargetStructure(m_TargetNode); - for ( QVector >::iterator it = m_PlannedTargetNodes.begin(); - it != m_PlannedTargetNodes.end(); ++it ) + for (QVector>::iterator it = m_PlannedTargetNodes.begin(); + it != m_PlannedTargetNodes.end(); + ++it) { (*it)->SetBoolProperty("visible", true); } this->UpdateTargetDescriptions(); - //m_TargetUpdateFilter->UpdateTargetScores(); + // m_TargetUpdateFilter->UpdateTargetScores(); return true; } bool QmitkUSNavigationStepPlacementPlanning::OnDeactivateStep() { ui->freezeImageButton->Unfreeze(); return true; } void QmitkUSNavigationStepPlacementPlanning::OnUpdate() { this->UpdateTargetColors(); - // get navigation data source and make sure that it is not null + // get navigation data source and make sure that it is not null mitk::NavigationDataSource::Pointer navigationDataSource = this->GetCombinedModality()->GetNavigationDataSource(); - if ( navigationDataSource.IsNull() ) + if (navigationDataSource.IsNull()) { - MITK_ERROR("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepPunctuationIntervention") - << "Navigation Data Source of Combined Modality must not be null."; + 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."; } navigationDataSource->Update(); this->UpdateBodyMarkerStatus(navigationDataSource->GetOutput(m_ReferenceSensorIndex)); ui->freezeImageButton->setEnabled(m_BodyMarkerValid); mitk::PointSet::Pointer needleProjectionPointSet = m_NeedleProjectionFilter->GetProjection(); - if ( needleProjectionPointSet->GetSize() == 2 ) + if (needleProjectionPointSet->GetSize() == 2) { - m_TargetIntersectionFilter->SetTargetSurface(dynamic_cast(m_TargetNode->GetData())); + m_TargetIntersectionFilter->SetTargetSurface(dynamic_cast(m_TargetNode->GetData())); m_TargetIntersectionFilter->SetLine(needleProjectionPointSet); m_TargetIntersectionFilter->CalculateIntersection(); - if ( m_TargetIntersectionFilter->GetIsIntersecting() ) + if (m_TargetIntersectionFilter->GetIsIntersecting()) { // only enable button if body marker is in the tracking volume, too ui->placeTargetButton->setEnabled(m_BodyMarkerValid); ui->placeTargetButton->setToolTip(""); - if ( m_PlannedTargetNodes.size() == m_NumberOfTargets - 1 ) + if (m_PlannedTargetNodes.size() == m_NumberOfTargets - 1) { mitk::PointSet::Pointer targetPointSet = mitk::PointSet::New(); mitk::PointSet::PointIdentifier n = 0; - for ( QVector >::iterator it = m_PlannedTargetNodes.begin(); - it != m_PlannedTargetNodes.end(); ++it ) + for (QVector>::iterator it = m_PlannedTargetNodes.begin(); + it != m_PlannedTargetNodes.end(); + ++it) { targetPointSet->InsertPoint(n++, (*it)->GetData()->GetGeometry()->GetOrigin()); } targetPointSet->InsertPoint(n, m_TargetIntersectionFilter->GetIntersectionPoint()); - this->CalculatePlanningQuality(dynamic_cast(m_TargetNode->GetData()), targetPointSet); + this->CalculatePlanningQuality(dynamic_cast(m_TargetNode->GetData()), targetPointSet); } } else { ui->placeTargetButton->setEnabled(false); - ui->placeTargetButton->setToolTip("Target cannot be placed as the needle path is not intersecting the target surface."); + ui->placeTargetButton->setToolTip( + "Target cannot be placed as the needle path is not intersecting the target surface."); // no not show planning quality if not all nodes are planned for now // and there is no needle path intersection - if ( m_PlannedTargetNodes.size() < m_NumberOfTargets ) + if (m_PlannedTargetNodes.size() < m_NumberOfTargets) { ui->angleDifferenceValue->setText(""); ui->centersOfMassValue->setText(""); } } } } void QmitkUSNavigationStepPlacementPlanning::OnSettingsChanged(const itk::SmartPointer settingsNode) { int numberOfTargets; - if ( settingsNode->GetIntProperty("settings.number-of-targets", numberOfTargets) ) + if (settingsNode->GetIntProperty("settings.number-of-targets", numberOfTargets)) { m_NumberOfTargets = numberOfTargets; m_TargetUpdateFilter->SetNumberOfTargets(numberOfTargets); m_PlacementQualityCalculator->SetOptimalAngle(m_TargetUpdateFilter->GetOptimalAngle()); } std::string referenceSensorName; - if ( settingsNode->GetStringProperty("settings.reference-name-selected", referenceSensorName) ) + if (settingsNode->GetStringProperty("settings.reference-name-selected", referenceSensorName)) { m_ReferenceSensorName = referenceSensorName; } std::string needleSensorName; - if ( settingsNode->GetStringProperty("settings.needle-name-selected", needleSensorName) ) + if (settingsNode->GetStringProperty("settings.needle-name-selected", needleSensorName)) { m_NeedleSensorName = needleSensorName; } this->UpdateSensorsNames(); } QString QmitkUSNavigationStepPlacementPlanning::GetTitle() { return "Placement Planning"; } QmitkUSAbstractNavigationStep::FilterVector QmitkUSNavigationStepPlacementPlanning::GetFilter() { FilterVector filterVector; filterVector.push_back(m_NodeDisplacementFilter.GetPointer()); filterVector.push_back(m_NeedleProjectionFilter.GetPointer()); return filterVector; } void QmitkUSNavigationStepPlacementPlanning::OnSetCombinedModality() { mitk::USCombinedModality::Pointer combinedModality = this->GetCombinedModality(false); - if ( combinedModality.IsNotNull() ) + if (combinedModality.IsNotNull()) { mitk::AffineTransform3D::Pointer calibration = combinedModality->GetCalibration(); - if ( calibration.IsNotNull() ) + if (calibration.IsNotNull()) { m_NeedleProjectionFilter->SetTargetPlane(calibration); } } ui->freezeImageButton->SetCombinedModality(combinedModality, m_ReferenceSensorIndex); this->UpdateSensorsNames(); } void QmitkUSNavigationStepPlacementPlanning::OnFreeze(bool freeze) { - if (freeze) this->GetCombinedModality()->SetIsFreezed(true); - if ( freeze ) + if (freeze) + this->GetCombinedModality()->SetIsFreezed(true); + if (freeze) { // load state machine and event config for data interactor m_PointMarkInteractor->LoadStateMachine("USPointMarkInteractions.xml", us::ModuleRegistry::GetModule("MitkUS")); m_PointMarkInteractor->SetEventConfig("globalConfig.xml"); this->CreateTargetNodesIfNecessary(); m_PointMarkInteractor->SetDataNode(m_PlannedTargetNodes.at(m_CurrentTargetIndex)); } else { m_PointMarkInteractor->SetDataNode(0); } - if (!freeze) this->GetCombinedModality()->SetIsFreezed(false); + if (!freeze) + this->GetCombinedModality()->SetIsFreezed(false); } void QmitkUSNavigationStepPlacementPlanning::OnPlaceTargetButtonClicked() { this->CreateTargetNodesIfNecessary(); mitk::DataNode::Pointer currentNode = m_PlannedTargetNodes.at(m_CurrentTargetIndex); currentNode->SetData(this->CreateSphere(5)); currentNode->SetBoolProperty("surface_empty", false); mitk::PointSet::Pointer needleProjection = m_NeedleProjectionFilter->GetProjection(); - m_TargetIntersectionFilter->SetTargetSurface(dynamic_cast(m_TargetNode->GetData())); + m_TargetIntersectionFilter->SetTargetSurface(dynamic_cast(m_TargetNode->GetData())); m_TargetIntersectionFilter->SetLine(m_NeedleProjectionFilter->GetProjection()); m_TargetIntersectionFilter->CalculateIntersection(); mitk::Point3D intersectionPoint = m_TargetIntersectionFilter->GetIntersectionPoint(); currentNode->GetData()->GetGeometry()->SetOrigin(intersectionPoint); m_TargetUpdateFilter->SetControlNode(m_CurrentTargetIndex, currentNode); mitk::PointSet::Pointer plannedPath = mitk::PointSet::New(); m_PlannedNeedlePaths.at(m_CurrentTargetIndex)->SetData(plannedPath); plannedPath->SetPoint(0, needleProjection->GetPoint(0)); plannedPath->SetPoint(1, intersectionPoint); - if ( m_CurrentTargetIndex < m_NumberOfTargets - 1 ) + if (m_CurrentTargetIndex < m_NumberOfTargets - 1) { this->OnGoToNextTarget(); } else { this->UpdateTargetDescriptions(); } this->ReinitNodeDisplacementFilter(); - MITK_INFO("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepPlacementPlanning") - << "Target " << m_CurrentTargetIndex+1 << " planned at position " << intersectionPoint << "."; + MITK_INFO("QmitkUSAbstractNavigationStep") + ("QmitkUSNavigationStepPlacementPlanning") << "Target " << m_CurrentTargetIndex + 1 << " planned at position " + << intersectionPoint << "."; } void QmitkUSNavigationStepPlacementPlanning::OnGoToPreviousTarget() { - if ( m_CurrentTargetIndex < 1 ) + if (m_CurrentTargetIndex < 1) { mitkThrow() << "Cannot go to previous target as current target is first target."; } m_CurrentTargetIndex--; this->UpdateTargetDescriptions(); } void QmitkUSNavigationStepPlacementPlanning::OnGoToNextTarget() { m_CurrentTargetIndex++; this->UpdateTargetDescriptions(); } void QmitkUSNavigationStepPlacementPlanning::OnRemoveCurrentTargetClicked() { - if ( m_CurrentTargetIndex >= m_PlannedTargetNodes.size() ) + if (m_CurrentTargetIndex >= m_PlannedTargetNodes.size()) { MITK_WARN << "Cannot remove current target as there aren't as much planned target nodes."; return; } this->GetDataStorage()->Remove(m_PlannedTargetNodes.at(m_CurrentTargetIndex)); m_PlannedTargetNodes.remove(m_CurrentTargetIndex); this->GetDataStorage()->Remove(m_PlannedNeedlePaths.at(m_CurrentTargetIndex)); m_PlannedNeedlePaths.remove(m_CurrentTargetIndex); this->ReinitNodeDisplacementFilter(); - for ( unsigned int n = 0; n < m_PlannedTargetNodes.size(); ++n ) + for (unsigned int n = 0; n < m_PlannedTargetNodes.size(); ++n) { // set name of the target node according to its new index m_PlannedTargetNodes.at(n)->SetName( - QString("Target %1").arg(n+1, m_NumberOfTargets / 10 + 1, 10, QLatin1Char('0')).toStdString()); + QString("Target %1").arg(n + 1, m_NumberOfTargets / 10 + 1, 10, QLatin1Char('0')).toStdString()); m_PlannedNeedlePaths.at(n)->SetName( - QString("Target Path %1").arg(n+1, m_NumberOfTargets / 10 + 1, 10, QLatin1Char('0')).toStdString()); + QString("Target Path %1").arg(n + 1, m_NumberOfTargets / 10 + 1, 10, QLatin1Char('0')).toStdString()); } m_TargetUpdateFilter->RemovePositionOfTarget(m_CurrentTargetIndex); m_CurrentTargetIndex = m_PlannedTargetNodes.size(); this->UpdateTargetDescriptions(); - MITK_INFO("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepPlacementPlanning") - << "Planned target " << m_CurrentTargetIndex + 1 << " removed."; + MITK_INFO("QmitkUSAbstractNavigationStep") + ("QmitkUSNavigationStepPlacementPlanning") << "Planned target " << m_CurrentTargetIndex + 1 << " removed."; } void QmitkUSNavigationStepPlacementPlanning::CreateTargetNodesIfNecessary() { mitk::DataStorage::Pointer dataStorage = this->GetDataStorage(); - while ( m_PlannedTargetNodes.size() <= m_CurrentTargetIndex ) + while (m_PlannedTargetNodes.size() <= m_CurrentTargetIndex) { - QString targetNumber = QString("%1").arg(m_PlannedTargetNodes.size()+1, m_NumberOfTargets / 10 + 1, 10, QLatin1Char('0')); + QString targetNumber = + QString("%1").arg(m_PlannedTargetNodes.size() + 1, m_NumberOfTargets / 10 + 1, 10, QLatin1Char('0')); mitk::DataNode::Pointer targetNode = this->GetNamedDerivedNodeAndCreate( - (QString("Target ")+targetNumber).toStdString().c_str(), - USNavigationMarkerPlacement::DATANAME_TARGETS); + (QString("Target ") + targetNumber).toStdString().c_str(), USNavigationMarkerPlacement::DATANAME_TARGETS); targetNode->SetOpacity(0.5); targetNode->SetBoolProperty("surface_empty", true); targetNode->SetData(mitk::Surface::New()); m_PlannedTargetNodes.push_back(targetNode); - mitk::DataNode::Pointer targetPathNode = this->GetNamedDerivedNodeAndCreate( - (QString("Target Path ")+targetNumber).toStdString().c_str(), - USNavigationMarkerPlacement::DATANAME_TARGETS_PATHS); + mitk::DataNode::Pointer targetPathNode = + this->GetNamedDerivedNodeAndCreate((QString("Target Path ") + targetNumber).toStdString().c_str(), + USNavigationMarkerPlacement::DATANAME_TARGETS_PATHS); targetPathNode->SetOpacity(0.5); targetPathNode->SetColor(1, 1, 1); targetPathNode->SetColor(1, 1, 1, NULL, "contourcolor"); targetPathNode->SetBoolProperty("show contour", true); m_PlannedNeedlePaths.push_back(targetPathNode); mitk::Surface::Pointer pathSurface = mitk::Surface::New(); targetPathNode->SetData(pathSurface); } } -void QmitkUSNavigationStepPlacementPlanning::UpdateTargetCoordinates(mitk::DataNode* dataNode) +void QmitkUSNavigationStepPlacementPlanning::UpdateTargetCoordinates(mitk::DataNode *dataNode) { bool surfaceEmpty; - if ( dataNode->GetBoolProperty("surface_empty", surfaceEmpty) && surfaceEmpty ) + if (dataNode->GetBoolProperty("surface_empty", surfaceEmpty) && surfaceEmpty) { mitk::Point3D origin = dataNode->GetData()->GetGeometry()->GetOrigin(); dataNode->SetData(this->CreateSphere(5)); dataNode->SetBoolProperty("surface_empty", false); dataNode->GetData()->GetGeometry()->SetOrigin(origin); } this->ReinitNodeDisplacementFilter(); - mitk::BaseData* baseData = dataNode->GetData(); - if ( ! baseData ) + mitk::BaseData *baseData = dataNode->GetData(); + if (!baseData) { mitkThrow() << "Data of the data node must not be null."; } mitk::BaseGeometry::Pointer geometry = baseData->GetGeometry(); - if ( geometry.IsNull() ) + if (geometry.IsNull()) { mitkThrow() << "Geometry of the data node must not be null."; } m_TargetUpdateFilter->SetControlNode(m_CurrentTargetIndex, dataNode); - MITK_INFO("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepPlacementPlanning") - << "Target " << m_CurrentTargetIndex+1 << " planned at position " << geometry->GetOrigin() << "."; + MITK_INFO("QmitkUSAbstractNavigationStep") + ("QmitkUSNavigationStepPlacementPlanning") << "Target " << m_CurrentTargetIndex + 1 << " planned at position " + << geometry->GetOrigin() << "."; - if ( ui->freezeImageButton->isChecked() ) + if (ui->freezeImageButton->isChecked()) { ui->freezeImageButton->Unfreeze(); - if ( m_CurrentTargetIndex < m_NumberOfTargets - 1 ) + if (m_CurrentTargetIndex < m_NumberOfTargets - 1) { this->OnGoToNextTarget(); } } this->UpdateTargetDescriptions(); } void QmitkUSNavigationStepPlacementPlanning::UpdateTargetColors() { - if ( m_TargetNode.IsNull() ) { return; } + if (m_TargetNode.IsNull()) + { + return; + } - m_TargetNode->SetColor(1,1,1); + m_TargetNode->SetColor(1, 1, 1); - mitk::BaseData* targetNodeData = m_TargetNode->GetData(); - if ( targetNodeData == 0 ) { return; } + mitk::BaseData *targetNodeData = m_TargetNode->GetData(); + if (targetNodeData == 0) + { + return; + } - mitk::Surface::Pointer targetNodeSurface = dynamic_cast(targetNodeData); + mitk::Surface::Pointer targetNodeSurface = dynamic_cast(targetNodeData); vtkSmartPointer targetNodeSurfaceVtk = targetNodeSurface->GetVtkPolyData(); - vtkFloatArray* targetScoreScalars = dynamic_cast( + vtkFloatArray *targetScoreScalars = dynamic_cast( targetNodeSurface->GetVtkPolyData()->GetPointData()->GetScalars("USNavigation::PlanningPlacement")); - if ( ! targetScoreScalars ) { return; } + if (!targetScoreScalars) + { + return; + } unsigned int numberOfTupels = targetScoreScalars->GetNumberOfTuples(); - vtkSmartPointer colors = - vtkSmartPointer::New(); + vtkSmartPointer colors = vtkSmartPointer::New(); colors->SetNumberOfComponents(1); colors->SetNumberOfTuples(numberOfTupels); colors->SetName("Colors"); double markerScore; - for ( unsigned int n = 0; n < numberOfTupels; n++ ) + for (unsigned int n = 0; n < numberOfTupels; n++) { targetScoreScalars->GetTuple(n, &markerScore); colors->SetTuple(n, &markerScore); } - if ( numberOfTupels > 0 ) + if (numberOfTupels > 0) { targetNodeSurfaceVtk->GetPointData()->SetScalars(colors); targetNodeSurfaceVtk->GetPointData()->Update(); } } void QmitkUSNavigationStepPlacementPlanning::UpdateTargetDescriptions() { ui->previousButton->setEnabled(m_CurrentTargetIndex > 0); ui->nextButton->setEnabled(m_CurrentTargetIndex + 1 < m_PlannedTargetNodes.size()); ui->removeButton->setEnabled(m_PlannedTargetNodes.size() > 0); - ui->currentTargetLabel->setText(QString("Planning Target %1 of %2").arg(m_CurrentTargetIndex+1).arg(m_NumberOfTargets)); + ui->currentTargetLabel->setText( + QString("Planning Target %1 of %2").arg(m_CurrentTargetIndex + 1).arg(m_NumberOfTargets)); ui->removeButton->setEnabled(m_CurrentTargetIndex < m_PlannedTargetNodes.size()); this->CalculatePlanningQuality(); } void QmitkUSNavigationStepPlacementPlanning::GenerateTargetColorLookupTable() { vtkSmartPointer lookupTable = vtkSmartPointer::New(); lookupTable->SetHueRange(0.0, 0.27); lookupTable->SetSaturationRange(1.0, 1.0); lookupTable->SetValueRange(1.0, 1.0); lookupTable->SetTableRange(0.0, 1.0); lookupTable->Build(); mitk::LookupTable::Pointer lut = mitk::LookupTable::New(); lut->SetVtkLookupTable(lookupTable); m_TargetColorLookupTableProperty = mitk::LookupTableProperty::New(lut); } void QmitkUSNavigationStepPlacementPlanning::ReinitNodeDisplacementFilter() { m_NodeDisplacementFilter->ResetNodes(); - for (QVector >::iterator it = m_PlannedTargetNodes.begin(); - it != m_PlannedTargetNodes.end(); ++it) + for (QVector>::iterator it = m_PlannedTargetNodes.begin(); + it != m_PlannedTargetNodes.end(); + ++it) { if (it->IsNotNull() && (*it)->GetData() != 0) { m_NodeDisplacementFilter->AddNode(*it); } } - for (QVector >::iterator it = m_PlannedNeedlePaths.begin(); - it != m_PlannedNeedlePaths.end(); ++it) + for (QVector>::iterator it = m_PlannedNeedlePaths.begin(); + it != m_PlannedNeedlePaths.end(); + ++it) { if (it->IsNotNull() && (*it)->GetData() != 0) { m_NodeDisplacementFilter->AddNode(*it); } } } void QmitkUSNavigationStepPlacementPlanning::CalculatePlanningQuality() { - if ( m_PlannedTargetNodes.size() != m_NumberOfTargets ) + if (m_PlannedTargetNodes.size() != m_NumberOfTargets) { ui->angleDifferenceLabel->setEnabled(false); ui->centersOfMassLabel->setEnabled(false); ui->allTargetsPlannedLabel->setEnabled(false); ui->angleDifferenceValue->setText(""); ui->centersOfMassValue->setText(""); return; } ui->angleDifferenceLabel->setEnabled(true); ui->centersOfMassLabel->setEnabled(true); ui->allTargetsPlannedLabel->setEnabled(true); mitk::PointSet::Pointer targetPointSet = mitk::PointSet::New(); mitk::PointSet::PointIdentifier n = 0; - for ( QVector >::iterator it = m_PlannedTargetNodes.begin(); - it != m_PlannedTargetNodes.end(); ++it ) + for (QVector>::iterator it = m_PlannedTargetNodes.begin(); + it != m_PlannedTargetNodes.end(); + ++it) { targetPointSet->InsertPoint(n++, (*it)->GetData()->GetGeometry()->GetOrigin()); } mitk::DataNode::Pointer planningQualityResult = - this->CalculatePlanningQuality(dynamic_cast(m_TargetNode->GetData()), targetPointSet); + this->CalculatePlanningQuality(dynamic_cast(m_TargetNode->GetData()), targetPointSet); emit SignalIntermediateResult(planningQualityResult); } mitk::DataNode::Pointer QmitkUSNavigationStepPlacementPlanning::CalculatePlanningQuality( mitk::Surface::Pointer targetSurface, mitk::PointSet::Pointer targetPoints) { - if ( targetSurface.IsNull() ) + if (targetSurface.IsNull()) { mitkThrow() << "Target surface must not be null."; } m_PlacementQualityCalculator->SetTargetSurface(targetSurface); m_PlacementQualityCalculator->SetTargetPoints(targetPoints); m_PlacementQualityCalculator->Update(); mitk::DataNode::Pointer planningQualityResult = mitk::DataNode::New(); planningQualityResult->SetName("PlanningQuality"); - double centersOfMassDistance = m_PlacementQualityCalculator->GetCentersOfMassDistance(); - ui->centersOfMassValue->setText(QString::number( - centersOfMassDistance, 103, 2) + " mm"); + ui->centersOfMassValue->setText(QString::number(centersOfMassDistance, 103, 2) + " mm"); planningQualityResult->SetFloatProperty("USNavigation::CentersOfMassDistance", centersOfMassDistance); - if ( m_PlannedTargetNodes.size() > 1 ) + if (m_PlannedTargetNodes.size() > 1) { double meanAnglesDifference = m_PlacementQualityCalculator->GetMeanAngleDifference(); - ui->angleDifferenceValue->setText(QString::number( - meanAnglesDifference, 103, 2) + QString::fromLatin1(" °")); + ui->angleDifferenceValue->setText(QString::number(meanAnglesDifference, 103, 2) + QString::fromLatin1(" °")); planningQualityResult->SetFloatProperty("USNavigation::MeanAngleDifference", meanAnglesDifference); - planningQualityResult->SetProperty("USNavigation::AngleDifferences", + planningQualityResult->SetProperty( + "USNavigation::AngleDifferences", mitk::GenericProperty::New(m_PlacementQualityCalculator->GetAngleDifferences())); } else { ui->angleDifferenceValue->setText("not valid for one point"); } return planningQualityResult; } itk::SmartPointer QmitkUSNavigationStepPlacementPlanning::CreateSphere(float radius) { mitk::Surface::Pointer surface = mitk::Surface::New(); // create a vtk sphere with fixed radius vtkSphereSource *vtkData = vtkSphereSource::New(); - vtkData->SetRadius( 5 ); - vtkData->SetCenter(0,0,0); + vtkData->SetRadius(5); + vtkData->SetCenter(0, 0, 0); vtkData->Update(); surface->SetVtkPolyData(vtkData->GetOutput()); vtkData->Delete(); return surface; } void QmitkUSNavigationStepPlacementPlanning::UpdateBodyMarkerStatus(mitk::NavigationData::Pointer bodyMarker) { - if ( bodyMarker.IsNull() ) + if (bodyMarker.IsNull()) { - MITK_ERROR("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepPunctuationIntervention") + 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."; } m_BodyMarkerValid = bodyMarker->IsDataValid(); // update body marker status label if (m_BodyMarkerValid) { ui->bodyMarkerTrackingStatusLabel->setStyleSheet( "background-color: #8bff8b; margin-right: 1em; margin-left: 1em; border: 1px solid grey"); ui->bodyMarkerTrackingStatusLabel->setText("Body marker is inside the tracking volume."); } else { ui->bodyMarkerTrackingStatusLabel->setStyleSheet( - "background-color: #ff7878; margin-right: 1em; margin-left: 1em; border: 1px solid grey"); + "background-color: #ff7878; margin-right: 1em; margin-left: 1em; border: 1px solid grey"); ui->bodyMarkerTrackingStatusLabel->setText("Body marker is not inside the tracking volume."); } } void QmitkUSNavigationStepPlacementPlanning::UpdateSensorsNames() { mitk::USCombinedModality::Pointer combinedModality = this->GetCombinedModality(false); - if ( combinedModality.IsNull() ) { return; } + if (combinedModality.IsNull()) + { + return; + } mitk::NavigationDataSource::Pointer navigationDataSource = combinedModality->GetNavigationDataSource(); - if ( navigationDataSource.IsNull() ) { return; } + if (navigationDataSource.IsNull()) + { + return; + } - if ( ! m_NeedleSensorName.empty() ) + if (!m_NeedleSensorName.empty()) { try { m_NeedleSensorIndex = navigationDataSource->GetOutputIndex(m_NeedleSensorName); } - catch ( const std::exception &e ) + catch (const std::exception &e) { - MITK_WARN("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepPlacementPlanning") - << "Cannot get index for needle sensor name: " << e.what(); + MITK_WARN("QmitkUSAbstractNavigationStep") + ("QmitkUSNavigationStepPlacementPlanning") << "Cannot get index for needle sensor name: " << e.what(); } } - if ( this->GetNavigationStepState() >= QmitkUSAbstractNavigationStep::State_Active ) + if (this->GetNavigationStepState() >= QmitkUSAbstractNavigationStep::State_Active) { m_NeedleProjectionFilter->SelectInput(m_NeedleSensorIndex); } - if ( ! m_ReferenceSensorName.empty() ) + if (!m_ReferenceSensorName.empty()) { try { m_ReferenceSensorIndex = navigationDataSource->GetOutputIndex(m_ReferenceSensorName); } - catch ( const std::exception &e ) + catch (const std::exception &e) { - MITK_WARN("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepPlacementPlanning") - << "Cannot get index for reference sensor name: " << e.what(); + MITK_WARN("QmitkUSAbstractNavigationStep") + ("QmitkUSNavigationStepPlacementPlanning") << "Cannot get index for reference sensor name: " << e.what(); } } - if ( this->GetNavigationStepState() >= QmitkUSAbstractNavigationStep::State_Active ) + if (this->GetNavigationStepState() >= QmitkUSAbstractNavigationStep::State_Active) { m_NodeDisplacementFilter->SelectInput(m_ReferenceSensorIndex); } ui->freezeImageButton->SetCombinedModality(combinedModality, m_ReferenceSensorIndex); } diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.h b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.h index fd52c89e18..05b320bf36 100644 --- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.h +++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.h @@ -1,147 +1,148 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef QMITKUSNAVIGATIONSTEPPLACEMENTPLANNING_H #define QMITKUSNAVIGATIONSTEPPLACEMENTPLANNING_H #include "QmitkUSAbstractNavigationStep.h" -namespace Ui { -class QmitkUSNavigationStepPlacementPlanning; +namespace Ui +{ + class QmitkUSNavigationStepPlacementPlanning; } -namespace mitk { -class USNavigationTargetUpdateFilter; -class USNavigationTargetIntersectionFilter; -class USPointMarkInteractor; -class NodeDisplacementFilter; -class NeedleProjectionFilter; -class LookupTableProperty; -class OverlayManager; -class TextOverlay3D; -class Surface; -class PointSet; -class USTargetPlacementQualityCalculator; +namespace mitk +{ + class USNavigationTargetUpdateFilter; + class USNavigationTargetIntersectionFilter; + class USPointMarkInteractor; + class NodeDisplacementFilter; + class NeedleProjectionFilter; + class LookupTableProperty; + class TextAnnotation3D; + class Surface; + class PointSet; + class USTargetPlacementQualityCalculator; } /** * \brief Navigation step for planning the positions for implanting markers. * * The planned targets are stored in the data storage under DATANAME_BASENODE -> * DATANAME_TARGETS and the needle path to the planned targets are stored under * DATANAME_BASENODE -> DATANAME_TARGETS_PATHS. The target structure is expected * to be stored under DATANAME_BASENODE -> DATANAME_TUMOR -> * DATANAME_TARGETSURFACE. * */ class QmitkUSNavigationStepPlacementPlanning : public QmitkUSAbstractNavigationStep { Q_OBJECT protected slots: /** * \brief Freezes or unfreezes the combined modality. * In freeze state an interactor is activated in the render window, so the * position of the currently active target can be planned by clicking into the * render window. */ void OnFreeze(bool freezed); /** * \brief Plan target position at the intersection between needle path and target surface. */ void OnPlaceTargetButtonClicked(); /** * \brief Selects the previous target as active target. */ void OnGoToPreviousTarget(); /** * \brief Selects the next target as active target. */ void OnGoToNextTarget(); /** * \brief The currently active target is removed from the data storage. */ void OnRemoveCurrentTargetClicked(); public: explicit QmitkUSNavigationStepPlacementPlanning(QWidget *parent = 0); ~QmitkUSNavigationStepPlacementPlanning(); virtual QString GetTitle(); virtual FilterVector GetFilter(); protected: virtual bool OnStartStep(); virtual bool OnStopStep(); virtual bool OnRestartStep(); virtual bool OnFinishStep(); virtual bool OnActivateStep(); virtual bool OnDeactivateStep(); virtual void OnUpdate(); virtual void OnSettingsChanged(const itk::SmartPointer settingsNode); virtual void OnSetCombinedModality(); void CreateTargetNodesIfNecessary(); - void UpdateTargetCoordinates(mitk::DataNode*); + void UpdateTargetCoordinates(mitk::DataNode *); void UpdateTargetColors(); void UpdateTargetDescriptions(); void GenerateTargetColorLookupTable(); void ReinitNodeDisplacementFilter(); void CalculatePlanningQuality(); - itk::SmartPointer CalculatePlanningQuality(itk::SmartPointer targetSurface, itk::SmartPointer); + itk::SmartPointer CalculatePlanningQuality(itk::SmartPointer targetSurface, + itk::SmartPointer); itk::SmartPointer CreateSphere(float radius); void UpdateBodyMarkerStatus(mitk::NavigationData::Pointer bodyMarker); void UpdateSensorsNames(); - int m_NumberOfTargets; - int m_CurrentTargetIndex; - bool m_BodyMarkerValid; + int m_NumberOfTargets; + int m_CurrentTargetIndex; + bool m_BodyMarkerValid; - itk::SmartPointer m_PointMarkInteractor; - itk::SmartPointer m_TargetUpdateFilter; - itk::SmartPointer m_NodeDisplacementFilter; - itk::SmartPointer m_NeedleProjectionFilter; - itk::SmartPointer m_TargetIntersectionFilter; - itk::SmartPointer m_PlacementQualityCalculator; + itk::SmartPointer m_PointMarkInteractor; + itk::SmartPointer m_TargetUpdateFilter; + itk::SmartPointer m_NodeDisplacementFilter; + itk::SmartPointer m_NeedleProjectionFilter; + itk::SmartPointer m_TargetIntersectionFilter; + itk::SmartPointer m_PlacementQualityCalculator; - itk::SmartPointer m_TargetColorLookupTableProperty; + itk::SmartPointer m_TargetColorLookupTableProperty; - itk::SmartPointer m_TargetNode; - QVector > m_PlannedTargetNodes; - QVector > m_PlannedNeedlePaths; + itk::SmartPointer m_TargetNode; + QVector> m_PlannedTargetNodes; + QVector> m_PlannedNeedlePaths; - itk::SmartPointer m_OverlayManager; - itk::SmartPointer m_CurrentTargetNodeOverlay; + itk::SmartPointer m_CurrentTargetNodeOverlay; - std::string m_ReferenceSensorName; - std::string m_NeedleSensorName; + std::string m_ReferenceSensorName; + std::string m_NeedleSensorName; - unsigned int m_ReferenceSensorIndex; - unsigned int m_NeedleSensorIndex; + unsigned int m_ReferenceSensorIndex; + unsigned int m_NeedleSensorIndex; private: - mitk::MessageDelegate1 m_ListenerTargetCoordinatesChanged; + mitk::MessageDelegate1 m_ListenerTargetCoordinatesChanged; Ui::QmitkUSNavigationStepPlacementPlanning *ui; }; #endif // QMITKUSNAVIGATIONSTEPPLACEMENTPLANNING_H diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.cpp b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.cpp index 43e847db9c..98ccf1c6a4 100644 --- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.cpp +++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.cpp @@ -1,693 +1,713 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "USNavigationMarkerPlacement.h" #include "ui_USNavigationMarkerPlacement.h" #include "NavigationStepWidgets/QmitkUSNavigationStepCombinedModality.h" -#include "NavigationStepWidgets/QmitkUSNavigationStepTumourSelection.h" -#include "NavigationStepWidgets/QmitkUSNavigationStepZoneMarking.h" -#include "NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.h" #include "NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.h" +#include "NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.h" #include "NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.h" +#include "NavigationStepWidgets/QmitkUSNavigationStepTumourSelection.h" +#include "NavigationStepWidgets/QmitkUSNavigationStepZoneMarking.h" #include "SettingsWidgets/QmitkUSNavigationCombinedSettingsWidget.h" #include "mitkIRenderingManager.h" #include "mitkNodeDisplacementFilter.h" #include "mitkUSCombinedModality.h" -#include "mitkOverlay2DLayouter.h" #include -#include "IO/mitkUSNavigationStepTimer.h" #include "IO/mitkUSNavigationExperimentLogging.h" +#include "IO/mitkUSNavigationStepTimer.h" -#include -#include -#include +#include #include +#include #include -#include +#include +#include #include "QmitkRenderWindow.h" -#include "QmitkStdMultiWidgetEditor.h" #include "QmitkStdMultiWidget.h" +#include "QmitkStdMultiWidgetEditor.h" +#include "mitkLayoutAnnotationRenderer.h" // scene serialization -#include -#include +#include #include #include -#include +#include +#include const std::string USNavigationMarkerPlacement::VIEW_ID = "org.mitk.views.usmarkerplacement"; -const char* USNavigationMarkerPlacement::DATANAME_TUMOUR = "Tumour"; -const char* USNavigationMarkerPlacement::DATANAME_TARGETSURFACE = "Target Surface"; -const char* USNavigationMarkerPlacement::DATANAME_ZONES = "Zones"; -const char* USNavigationMarkerPlacement::DATANAME_TARGETS = "Targets"; -const char* USNavigationMarkerPlacement::DATANAME_TARGETS_PATHS = "Target Paths"; -const char* USNavigationMarkerPlacement::DATANAME_REACHED_TARGETS = "Reached Targets"; - -USNavigationMarkerPlacement::USNavigationMarkerPlacement() : -m_UpdateTimer(new QTimer(this)), -m_ImageAndNavigationDataLoggingTimer(new QTimer(this)), -m_StdMultiWidget(0), -m_ReinitAlreadyDone(false), -m_IsExperimentRunning(false), -m_NavigationStepTimer(mitk::USNavigationStepTimer::New()), -m_ExperimentLogging(mitk::USNavigationExperimentLogging::New()), -m_AblationZonesDisplacementFilter(mitk::NodeDisplacementFilter::New()), -m_IconRunning(QPixmap(":/USNavigation/record.png")), -m_IconNotRunning(QPixmap(":/USNavigation/record-gray.png")), -m_USImageLoggingFilter(mitk::USImageLoggingFilter::New()), -m_NavigationDataRecorder(mitk::NavigationDataRecorder::New()), -m_SceneNumber(1), -m_WarnOverlay(mitk::TextOverlay2D::New()), -m_ListenerDeviceChanged(this, &USNavigationMarkerPlacement::OnCombinedModalityPropertyChanged), -m_NeedleIndex(0), -m_MarkerIndex(1), -ui(new Ui::USNavigationMarkerPlacement) +const char *USNavigationMarkerPlacement::DATANAME_TUMOUR = "Tumour"; +const char *USNavigationMarkerPlacement::DATANAME_TARGETSURFACE = "Target Surface"; +const char *USNavigationMarkerPlacement::DATANAME_ZONES = "Zones"; +const char *USNavigationMarkerPlacement::DATANAME_TARGETS = "Targets"; +const char *USNavigationMarkerPlacement::DATANAME_TARGETS_PATHS = "Target Paths"; +const char *USNavigationMarkerPlacement::DATANAME_REACHED_TARGETS = "Reached Targets"; + +USNavigationMarkerPlacement::USNavigationMarkerPlacement() + : m_UpdateTimer(new QTimer(this)), + m_ImageAndNavigationDataLoggingTimer(new QTimer(this)), + m_StdMultiWidget(0), + m_ReinitAlreadyDone(false), + m_IsExperimentRunning(false), + m_NavigationStepTimer(mitk::USNavigationStepTimer::New()), + m_ExperimentLogging(mitk::USNavigationExperimentLogging::New()), + m_AblationZonesDisplacementFilter(mitk::NodeDisplacementFilter::New()), + m_IconRunning(QPixmap(":/USNavigation/record.png")), + m_IconNotRunning(QPixmap(":/USNavigation/record-gray.png")), + m_USImageLoggingFilter(mitk::USImageLoggingFilter::New()), + m_NavigationDataRecorder(mitk::NavigationDataRecorder::New()), + m_SceneNumber(1), + m_WarnOverlay(mitk::TextAnnotation2D::New()), + m_ListenerDeviceChanged(this, &USNavigationMarkerPlacement::OnCombinedModalityPropertyChanged), + m_NeedleIndex(0), + m_MarkerIndex(1), + ui(new Ui::USNavigationMarkerPlacement) { connect(m_UpdateTimer, SIGNAL(timeout()), this, SLOT(OnTimeout())); - connect(m_ImageAndNavigationDataLoggingTimer, SIGNAL(timeout()), this, SLOT(OnImageAndNavigationDataLoggingTimeout())); + connect( + m_ImageAndNavigationDataLoggingTimer, SIGNAL(timeout()), this, SLOT(OnImageAndNavigationDataLoggingTimeout())); // scale running (and not running) icon the specific height m_IconRunning = m_IconRunning.scaledToHeight(20, Qt::SmoothTransformation); m_IconNotRunning = m_IconNotRunning.scaledToHeight(20, Qt::SmoothTransformation); // set prefix for experiment logging (only keys with this prefix are taken // into consideration m_ExperimentLogging->SetKeyPrefix("USNavigation::"); - m_UpdateTimer->start(33); //every 33 Milliseconds = 30 Frames/Second + m_UpdateTimer->start(33); // every 33 Milliseconds = 30 Frames/Second } USNavigationMarkerPlacement::~USNavigationMarkerPlacement() { // make sure that the experiment got finished before destructing the object - if (m_IsExperimentRunning) { this->OnFinishExperiment(); } + if (m_IsExperimentRunning) + { + this->OnFinishExperiment(); + } // remove listener for ultrasound device changes if (m_CombinedModality.IsNotNull() && m_CombinedModality->GetUltrasoundDevice().IsNotNull()) { m_CombinedModality->GetUltrasoundDevice()->RemovePropertyChangedListener(m_ListenerDeviceChanged); } delete ui; } void USNavigationMarkerPlacement::OnChangeAblationZone(int id, int newSize) { - if ((m_AblationZonesVector.size() < id) || (id < 0)) { return; } + if ((m_AblationZonesVector.size() < id) || (id < 0)) + { + return; + } MITK_INFO << "Ablation Zone " << id << " changed, new size: " << newSize; // create a vtk sphere with given radius vtkSphereSource *vtkData = vtkSphereSource::New(); vtkData->SetRadius(newSize / 2); vtkData->SetCenter(0, 0, 0); vtkData->SetPhiResolution(20); vtkData->SetThetaResolution(20); vtkData->Update(); - mitk::Surface::Pointer zoneSurface = dynamic_cast(m_AblationZonesVector.at(id)->GetData()); + mitk::Surface::Pointer zoneSurface = dynamic_cast(m_AblationZonesVector.at(id)->GetData()); zoneSurface->SetVtkPolyData(vtkData->GetOutput()); vtkData->Delete(); } void USNavigationMarkerPlacement::OnAddAblationZone(int size) { - m_AblationZonesDisplacementFilter->SetInitialReferencePose(m_CombinedModality->GetNavigationDataSource()->GetOutput(m_MarkerIndex)); + m_AblationZonesDisplacementFilter->SetInitialReferencePose( + m_CombinedModality->GetNavigationDataSource()->GetOutput(m_MarkerIndex)); mitk::DataNode::Pointer NewAblationZone = mitk::DataNode::New(); mitk::Point3D origin = m_CombinedModality->GetNavigationDataSource()->GetOutput(m_NeedleIndex)->GetPosition(); MITK_INFO("USNavigationLogging") << "Ablation Zone Added, initial size: " << size << ", origin: " << origin; mitk::Surface::Pointer zone = mitk::Surface::New(); // create a vtk sphere with given radius vtkSphereSource *vtkData = vtkSphereSource::New(); vtkData->SetRadius(size / 2); vtkData->SetCenter(0, 0, 0); vtkData->SetPhiResolution(20); vtkData->SetThetaResolution(20); vtkData->Update(); zone->SetVtkPolyData(vtkData->GetOutput()); vtkData->Delete(); // set vtk sphere and origin to data node (origin must be set // again, because of the new sphere set as data) NewAblationZone->SetData(zone); NewAblationZone->GetData()->GetGeometry()->SetOrigin(origin); mitk::Color SphereColor = mitk::Color(); - //default color + // default color SphereColor[0] = 102; SphereColor[1] = 0; SphereColor[2] = 204; NewAblationZone->SetColor(SphereColor); NewAblationZone->SetOpacity(0.3); // set name of zone std::stringstream name; name << "Ablation Zone" << m_AblationZonesVector.size(); NewAblationZone->SetName(name.str()); // add zone to filter m_AblationZonesDisplacementFilter->AddNode(NewAblationZone); m_AblationZonesVector.push_back(NewAblationZone); this->GetDataStorage()->Add(NewAblationZone); } void USNavigationMarkerPlacement::CreateQtPartControl(QWidget *parent) { m_Parent = parent; ui->setupUi(parent); connect(ui->navigationProcessWidget, - SIGNAL(SignalCombinedModalityChanged(itk::SmartPointer)), - this, SLOT(OnCombinedModalityChanged(itk::SmartPointer))); + SIGNAL(SignalCombinedModalityChanged(itk::SmartPointer)), + this, + SLOT(OnCombinedModalityChanged(itk::SmartPointer))); connect(ui->navigationProcessWidget, - SIGNAL(SignalSettingsChanged(itk::SmartPointer)), - this, SLOT(OnSettingsChanged(itk::SmartPointer))); + SIGNAL(SignalSettingsChanged(itk::SmartPointer)), + this, + SLOT(OnSettingsChanged(itk::SmartPointer))); - connect(ui->navigationProcessWidget, SIGNAL(SignalActiveNavigationStepChanged(int)), - this, SLOT(OnActiveNavigationStepChanged(int))); + connect(ui->navigationProcessWidget, + SIGNAL(SignalActiveNavigationStepChanged(int)), + this, + SLOT(OnActiveNavigationStepChanged(int))); connect(ui->startExperimentButton, SIGNAL(clicked()), this, SLOT(OnStartExperiment())); connect(ui->finishExperimentButton, SIGNAL(clicked()), this, SLOT(OnFinishExperiment())); - connect(ui->navigationProcessWidget, SIGNAL(SignalIntermediateResult(const itk::SmartPointer)), - this, SLOT(OnIntermediateResultProduced(const itk::SmartPointer))); + connect(ui->navigationProcessWidget, + SIGNAL(SignalIntermediateResult(const itk::SmartPointer)), + this, + SLOT(OnIntermediateResultProduced(const itk::SmartPointer))); ui->navigationProcessWidget->SetDataStorage(this->GetDataStorage()); // indicate that no experiment is running at start ui->runningLabel->setPixmap(m_IconNotRunning); ui->navigationProcessWidget->SetSettingsWidget(new QmitkUSNavigationCombinedSettingsWidget(m_Parent)); } -void USNavigationMarkerPlacement::OnCombinedModalityPropertyChanged(const std::string& key, const std::string&) +void USNavigationMarkerPlacement::OnCombinedModalityPropertyChanged(const std::string &key, const std::string &) { if (key == mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DEPTH) { m_ReinitAlreadyDone = false; this->ReinitOnImage(); - // make sure that the overlay is not added twice - if (m_OverlayManager.IsNotNull()) { m_OverlayManager->RemoveOverlay(m_WarnOverlay.GetPointer()); } - if (m_CombinedModality.IsNotNull() && !m_CombinedModality->GetIsCalibratedForCurrentStatus()) { - if (m_OverlayManager.IsNotNull()) { m_OverlayManager->AddOverlay(m_WarnOverlay.GetPointer()); } + mitk::LayoutAnnotationRenderer::AddAnnotation( + m_WarnOverlay.GetPointer(), "stdmulti.widget1", mitk::LayoutAnnotationRenderer::TopLeft); MITK_WARN << "No calibration available for the selected ultrasound image depth."; } } } void USNavigationMarkerPlacement::SetFocus() { this->ReinitOnImage(); } void USNavigationMarkerPlacement::OnTimeout() { if (!m_StdMultiWidget) { // try to get the standard multi widget if it couldn't be got before - mitk::IRenderWindowPart* renderWindow = this->GetRenderWindowPart(); + mitk::IRenderWindowPart *renderWindow = this->GetRenderWindowPart(); - QmitkStdMultiWidgetEditor* multiWidgetEditor - = dynamic_cast(renderWindow); + QmitkStdMultiWidgetEditor *multiWidgetEditor = dynamic_cast(renderWindow); // if there is a standard multi widget now, disable the level window and // change the layout to 2D up and 3d down if (multiWidgetEditor) { m_StdMultiWidget = multiWidgetEditor->GetStdMultiWidget(); if (m_StdMultiWidget) { m_StdMultiWidget->DisableStandardLevelWindow(); m_StdMultiWidget->changeLayoutTo2DUpAnd3DDown(); } } - if (m_OverlayManager.IsNull()) { this->CreateOverlays(); } + this->CreateOverlays(); } - if (m_CombinedModality.IsNotNull() && !this->m_CombinedModality->GetIsFreezed()) //if the combined modality is freezed: do nothing + if (m_CombinedModality.IsNotNull() && + !this->m_CombinedModality->GetIsFreezed()) // if the combined modality is freezed: do nothing { ui->navigationProcessWidget->UpdateNavigationProgress(); m_AblationZonesDisplacementFilter->Update(); - //update the 3D window only every fourth time to speed up the rendering (at least in 2D) + // update the 3D window only every fourth time to speed up the rendering (at least in 2D) this->RequestRenderWindowUpdate(mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS); // make sure that a reinit was performed on the image this->ReinitOnImage(); } } void USNavigationMarkerPlacement::OnImageAndNavigationDataLoggingTimeout() { // update filter for logging navigation data and ultrasound images if (m_CombinedModality.IsNotNull()) { m_NavigationDataRecorder->Update(); - //get last messages for logging filer and store them + // get last messages for logging filer and store them std::vector messages = m_LoggingBackend.GetNavigationMessages(); std::string composedMessage = ""; - for (int i = 0; i < messages.size(); i++) { composedMessage += messages.at(i); } + for (int i = 0; i < messages.size(); i++) + { + composedMessage += messages.at(i); + } m_USImageLoggingFilter->AddMessageToCurrentImage(composedMessage); m_LoggingBackend.ClearNavigationMessages(); - //update logging filter + // update logging filter m_USImageLoggingFilter->Update(); } } void USNavigationMarkerPlacement::OnStartExperiment() { // get name for the experiment by a QInputDialog bool ok; if (m_ExperimentName.isEmpty()) - { //default: current date - m_ExperimentName = QString::number(QDateTime::currentDateTime().date().year()) + "_" - + QString::number(QDateTime::currentDateTime().date().month()) + "_" - + QString::number(QDateTime::currentDateTime().date().day()) + "_experiment_" - + QString::number(QDateTime::currentDateTime().time().hour()) + "." - + QString::number(QDateTime::currentDateTime().time().minute()); + { // default: current date + m_ExperimentName = QString::number(QDateTime::currentDateTime().date().year()) + "_" + + QString::number(QDateTime::currentDateTime().date().month()) + "_" + + QString::number(QDateTime::currentDateTime().date().day()) + "_experiment_" + + QString::number(QDateTime::currentDateTime().time().hour()) + "." + + QString::number(QDateTime::currentDateTime().time().minute()); } - m_ExperimentName = QInputDialog::getText(m_Parent, QString("Experiment Name"), QString("Name of the Experiment"), QLineEdit::Normal, m_ExperimentName, &ok); + m_ExperimentName = QInputDialog::getText( + m_Parent, QString("Experiment Name"), QString("Name of the Experiment"), QLineEdit::Normal, m_ExperimentName, &ok); MITK_INFO("USNavigationLogging") << "Experiment started: " << m_ExperimentName.toStdString(); if (ok && !m_ExperimentName.isEmpty()) { // display error message and call the function recursivly if a directory // with the given name already exists QDir experimentResultsDir(m_ResultsDirectory + QDir::separator() + m_ExperimentName); if (experimentResultsDir.exists()) { - QMessageBox::critical(m_Parent, "Results Directory Exists", "The result directory already exists.\nPlease choose an other name."); + QMessageBox::critical( + m_Parent, "Results Directory Exists", "The result directory already exists.\nPlease choose an other name."); this->OnStartExperiment(); } else { QDir(m_ResultsDirectory).mkdir(m_ExperimentName); m_ExperimentResultsSubDirectory = m_ResultsDirectory + QDir::separator() + m_ExperimentName; // experiment is running now ui->runningLabel->setPixmap(m_IconRunning); ui->navigationProcessWidget->EnableInteraction(true); // (re)start timer for navigation step durations m_NavigationStepTimer->Reset(); - m_NavigationStepTimer->SetOutputFileName(QString(m_ExperimentResultsSubDirectory + QDir::separator() - + QString("durations.cvs")).toStdString()); + m_NavigationStepTimer->SetOutputFileName( + QString(m_ExperimentResultsSubDirectory + QDir::separator() + QString("durations.cvs")).toStdString()); m_NavigationStepTimer->SetActiveIndex(0, m_NavigationSteps.at(0)->GetTitle().toStdString()); ui->finishExperimentButton->setEnabled(true); ui->startExperimentButton->setDisabled(true); // initialize and register logging backend QString loggingFilename = m_ExperimentResultsSubDirectory + QDir::separator() + "logging.txt"; m_LoggingBackend.SetOutputFileName(loggingFilename.toStdString()); mbilog::RegisterBackend(&m_LoggingBackend); // initialize and start navigation data recorder form xml recording m_NavigationDataRecorder->StartRecording(); m_IsExperimentRunning = true; m_ImageAndNavigationDataLoggingTimer->start(1000); // (re)start experiment logging and set output file name m_ExperimentLogging->Reset(); - m_ExperimentLogging->SetFileName(QString(m_ExperimentResultsSubDirectory + QDir::separator() + "experiment-logging.xml").toStdString()); + m_ExperimentLogging->SetFileName( + QString(m_ExperimentResultsSubDirectory + QDir::separator() + "experiment-logging.xml").toStdString()); } } } void USNavigationMarkerPlacement::OnFinishExperiment() { this->WaitCursorOn(); MITK_INFO("USNavigationLogging") << "Experiment finished!"; - MITK_INFO("USNavigationLogging") << "Position/Orientation of needle tip: " << (dynamic_cast(m_CombinedModality->GetTrackingDevice()->GetOutput(0)))->GetPosition(); - MITK_INFO("USNavigationLogging") << "Position of target: " << m_TargetNodeDisplacementFilter->GetRawDisplacementNavigationData(0)->GetPosition(); + MITK_INFO("USNavigationLogging") + << "Position/Orientation of needle tip: " + << (dynamic_cast(m_CombinedModality->GetTrackingDevice()->GetOutput(0)))->GetPosition(); + MITK_INFO("USNavigationLogging") + << "Position of target: " << m_TargetNodeDisplacementFilter->GetRawDisplacementNavigationData(0)->GetPosition(); MITK_INFO("USNavigationLogging") << "Total duration: " << m_NavigationStepTimer->GetTotalDuration(); ui->navigationProcessWidget->FinishCurrentNavigationStep(); m_ImageAndNavigationDataLoggingTimer->stop(); ui->runningLabel->setPixmap(m_IconNotRunning); ui->navigationProcessWidget->EnableInteraction(false); m_NavigationStepTimer->Stop(); // make sure that the navigation process will be start from beginning at the // next experiment ui->navigationProcessWidget->ResetNavigationProcess(); ui->finishExperimentButton->setDisabled(true); ui->startExperimentButton->setEnabled(true); MITK_INFO("USNavigationLogging") << "Writing logging data to " << m_ExperimentResultsSubDirectory.toStdString(); // save ultrasound images to the file system QDir(m_ExperimentResultsSubDirectory).mkdir("ImageStream"); m_USImageLoggingFilter->Update(); m_USImageLoggingFilter->SetImageFilesExtension(".jpg"); - m_USImageLoggingFilter->SaveImages(QString(m_ExperimentResultsSubDirectory + QDir::separator() + "ImageStream" + QDir::separator()).toStdString()); + m_USImageLoggingFilter->SaveImages( + QString(m_ExperimentResultsSubDirectory + QDir::separator() + "ImageStream" + QDir::separator()).toStdString()); m_USImageLoggingFilter = mitk::USImageLoggingFilter::New(); m_NavigationDataRecorder->StopRecording(); // Write data to csv and xml file - mitk::IOUtil::SaveBaseData(m_NavigationDataRecorder->GetNavigationDataSet(), (QString(m_ExperimentResultsSubDirectory + QDir::separator() + "navigation-data.xml").toStdString().c_str())); - mitk::IOUtil::SaveBaseData(m_NavigationDataRecorder->GetNavigationDataSet(), (QString(m_ExperimentResultsSubDirectory + QDir::separator() + "navigation-data.csv").toStdString().c_str())); - - //write logged navigation data messages to separate file + mitk::IOUtil::SaveBaseData( + m_NavigationDataRecorder->GetNavigationDataSet(), + (QString(m_ExperimentResultsSubDirectory + QDir::separator() + "navigation-data.xml").toStdString().c_str())); + mitk::IOUtil::SaveBaseData( + m_NavigationDataRecorder->GetNavigationDataSet(), + (QString(m_ExperimentResultsSubDirectory + QDir::separator() + "navigation-data.csv").toStdString().c_str())); + + // write logged navigation data messages to separate file std::stringstream csvNavigationMessagesFilename; - csvNavigationMessagesFilename << m_ExperimentResultsSubDirectory.toStdString() << QDir::separator().toLatin1() << "CSVNavigationMessagesLogFile.csv"; - MITK_INFO("USNavigationLogging") << "Writing logged navigation messages to separate csv file: " << csvNavigationMessagesFilename.str(); + csvNavigationMessagesFilename << m_ExperimentResultsSubDirectory.toStdString() << QDir::separator().toLatin1() + << "CSVNavigationMessagesLogFile.csv"; + MITK_INFO("USNavigationLogging") << "Writing logged navigation messages to separate csv file: " + << csvNavigationMessagesFilename.str(); m_LoggingBackend.WriteCSVFileWithNavigationMessages(csvNavigationMessagesFilename.str()); mbilog::UnregisterBackend(&m_LoggingBackend); m_IsExperimentRunning = false; m_ImageAndNavigationDataLoggingTimer->stop(); m_CombinedModality = 0; // reset scene number for next experiment m_SceneNumber = 1; this->WaitCursorOff(); MITK_INFO("USNavigationLogging") << "Finished!"; } -void USNavigationMarkerPlacement::OnCombinedModalityChanged(itk::SmartPointer combinedModality) +void USNavigationMarkerPlacement::OnCombinedModalityChanged( + itk::SmartPointer combinedModality) { // remove old listener for ultrasound device changes if (m_CombinedModality.IsNotNull() && m_CombinedModality->GetUltrasoundDevice().IsNotNull()) { m_CombinedModality->GetUltrasoundDevice()->RemovePropertyChangedListener(m_ListenerDeviceChanged); } m_CombinedModality = combinedModality; m_ReinitAlreadyDone = false; // add a listener for ultrasound device changes if (m_CombinedModality.IsNotNull() && m_CombinedModality->GetUltrasoundDevice().IsNotNull()) { m_CombinedModality->GetUltrasoundDevice()->AddPropertyChangedListener(m_ListenerDeviceChanged); } // update navigation data recorder for using the new combined modality mitk::NavigationDataSource::Pointer navigationDataSource = combinedModality->GetNavigationDataSource(); m_NavigationDataRecorder->ConnectTo(navigationDataSource); m_NavigationDataRecorder->ResetRecording(); // TODO check for correct connection // for (unsigned int n = 0; n < navigationDataSource->GetNumberOfIndexedOutputs(); ++n) // { // m_NavigationDataRecorder->AddNavigationData(navigationDataSource->GetOutput(n)); // } // update ultrasound image logging filter for using the new combined modality mitk::USDevice::Pointer ultrasoundImageSource = combinedModality->GetUltrasoundDevice(); for (unsigned int n = 0; n < ultrasoundImageSource->GetNumberOfIndexedOutputs(); ++n) { m_USImageLoggingFilter->SetInput(n, ultrasoundImageSource->GetOutput(n)); } // update ablation zone filter for using the new combined modality for (unsigned int n = 0; n < navigationDataSource->GetNumberOfIndexedOutputs(); ++n) { m_AblationZonesDisplacementFilter->SetInput(n, navigationDataSource->GetOutput(n)); } m_AblationZonesDisplacementFilter->SelectInput(m_MarkerIndex); // make sure that a reinit is done for the new images this->ReinitOnImage(); } void USNavigationMarkerPlacement::OnSettingsChanged(itk::SmartPointer settings) { std::string applicationName; if (!settings->GetStringProperty("settings.application", applicationName)) { // set default application if the string property is not available applicationName = "Marker Placement"; } // create navigation step widgets according to the selected application if (applicationName != m_CurrentApplicationName) { m_CurrentApplicationName = applicationName; QmitkUSNavigationProcessWidget::NavigationStepVector navigationSteps; if (applicationName == "Punction") { - QmitkUSNavigationStepCombinedModality* stepCombinedModality = - new QmitkUSNavigationStepCombinedModality(m_Parent); - QmitkUSNavigationStepTumourSelection* stepTumourSelection = - new QmitkUSNavigationStepTumourSelection(m_Parent); + QmitkUSNavigationStepCombinedModality *stepCombinedModality = new QmitkUSNavigationStepCombinedModality(m_Parent); + QmitkUSNavigationStepTumourSelection *stepTumourSelection = new QmitkUSNavigationStepTumourSelection(m_Parent); stepTumourSelection->SetTargetSelectionOptional(true); m_TargetNodeDisplacementFilter = stepTumourSelection->GetTumourNodeDisplacementFilter(); - QmitkUSNavigationStepZoneMarking* stepZoneMarking = - new QmitkUSNavigationStepZoneMarking(m_Parent); - QmitkUSNavigationStepPunctuationIntervention* stepIntervention = + QmitkUSNavigationStepZoneMarking *stepZoneMarking = new QmitkUSNavigationStepZoneMarking(m_Parent); + QmitkUSNavigationStepPunctuationIntervention *stepIntervention = new QmitkUSNavigationStepPunctuationIntervention(m_Parent); connect(stepIntervention, SIGNAL(AddAblationZoneClicked(int)), this, SLOT(OnAddAblationZone(int))); connect(stepIntervention, SIGNAL(AblationZoneChanged(int, int)), this, SLOT(OnChangeAblationZone(int, int))); m_NavigationStepNames = std::vector(); navigationSteps.push_back(stepCombinedModality); m_NavigationStepNames.push_back("Combined Modality Initialization"); navigationSteps.push_back(stepTumourSelection); m_NavigationStepNames.push_back("Target Selection"); navigationSteps.push_back(stepZoneMarking); m_NavigationStepNames.push_back("Critical Structure Marking"); navigationSteps.push_back(stepIntervention); m_NavigationStepNames.push_back("Intervention"); } else if (applicationName == "Marker Placement") { - QmitkUSNavigationStepCombinedModality* stepCombinedModality = - new QmitkUSNavigationStepCombinedModality(m_Parent); - QmitkUSNavigationStepTumourSelection* stepTumourSelection = - new QmitkUSNavigationStepTumourSelection(m_Parent); + QmitkUSNavigationStepCombinedModality *stepCombinedModality = new QmitkUSNavigationStepCombinedModality(m_Parent); + QmitkUSNavigationStepTumourSelection *stepTumourSelection = new QmitkUSNavigationStepTumourSelection(m_Parent); m_TargetNodeDisplacementFilter = stepTumourSelection->GetTumourNodeDisplacementFilter(); - QmitkUSNavigationStepZoneMarking* stepZoneMarking = - new QmitkUSNavigationStepZoneMarking(m_Parent); - QmitkUSNavigationStepPlacementPlanning* stepPlacementPlanning = + QmitkUSNavigationStepZoneMarking *stepZoneMarking = new QmitkUSNavigationStepZoneMarking(m_Parent); + QmitkUSNavigationStepPlacementPlanning *stepPlacementPlanning = new QmitkUSNavigationStepPlacementPlanning(m_Parent); - QmitkUSNavigationStepMarkerIntervention* stepMarkerIntervention = + QmitkUSNavigationStepMarkerIntervention *stepMarkerIntervention = new QmitkUSNavigationStepMarkerIntervention(m_Parent); m_NavigationStepNames = std::vector(); navigationSteps.push_back(stepCombinedModality); m_NavigationStepNames.push_back("Combined Modality Initialization"); navigationSteps.push_back(stepTumourSelection); m_NavigationStepNames.push_back("Target Selection"); navigationSteps.push_back(stepZoneMarking); m_NavigationStepNames.push_back("Critical Structure Marking"); navigationSteps.push_back(stepPlacementPlanning); m_NavigationStepNames.push_back("Placement Planning"); navigationSteps.push_back(stepMarkerIntervention); m_NavigationStepNames.push_back("Marker Intervention"); } // set navigation step widgets to the process widget ui->navigationProcessWidget->SetNavigationSteps(navigationSteps); for (QmitkUSNavigationProcessWidget::NavigationStepIterator it = m_NavigationSteps.begin(); - it != m_NavigationSteps.end(); ++it) + it != m_NavigationSteps.end(); + ++it) { delete *it; } m_NavigationSteps.clear(); m_NavigationSteps = navigationSteps; } // initialize gui according to the experiment mode setting bool experimentMode = false; settings->GetBoolProperty("settings.experiment-mode", experimentMode); ui->startExperimentButton->setVisible(experimentMode); ui->finishExperimentButton->setVisible(experimentMode); ui->runningLabel->setVisible(experimentMode); if (experimentMode && !m_IsExperimentRunning) { ui->navigationProcessWidget->ResetNavigationProcess(); ui->navigationProcessWidget->EnableInteraction(false); ui->runningLabel->setPixmap(m_IconNotRunning); } else if (!experimentMode) { - if (m_IsExperimentRunning) { this->OnFinishExperiment(); } + if (m_IsExperimentRunning) + { + this->OnFinishExperiment(); + } ui->navigationProcessWidget->EnableInteraction(true); } // get the results directory from the settings and use home directory if // there is no results directory configured std::string resultsDirectory; if (settings->GetStringProperty("settings.experiment-results-directory", resultsDirectory)) { m_ResultsDirectory = QString::fromStdString(resultsDirectory); } else { m_ResultsDirectory = QDir::homePath(); } // make sure that the results directory exists QDir resultsDirectoryQDir = QDir(m_ResultsDirectory); if (!resultsDirectoryQDir.exists()) { resultsDirectoryQDir.mkpath(m_ResultsDirectory); } MITK_INFO << "Results Directory: " << m_ResultsDirectory.toStdString(); } void USNavigationMarkerPlacement::OnActiveNavigationStepChanged(int index) { // update navigation step timer each time the active navigation step changes m_NavigationStepTimer->SetActiveIndex(index, m_NavigationSteps.at(index)->GetTitle().toStdString()); - if (m_NavigationStepNames.size() <= index) { MITK_INFO("USNavigationLogging") << "Someting went wrong: unknown navigation step!"; } - else { MITK_INFO("USNavigationLogging") << "Navigation step finished/changed, next step: " << this->m_NavigationStepNames.at(index).toStdString() << "; duration until now: " << m_NavigationStepTimer->GetTotalDuration(); } + if (m_NavigationStepNames.size() <= index) + { + MITK_INFO("USNavigationLogging") << "Someting went wrong: unknown navigation step!"; + } + else + { + MITK_INFO("USNavigationLogging") << "Navigation step finished/changed, next step: " + << this->m_NavigationStepNames.at(index).toStdString() + << "; duration until now: " << m_NavigationStepTimer->GetTotalDuration(); + } } void USNavigationMarkerPlacement::OnIntermediateResultProduced(const itk::SmartPointer resultsNode) { // intermediate results only matter during an experiment - if (!m_IsExperimentRunning) { return; } + if (!m_IsExperimentRunning) + { + return; + } this->WaitCursorOn(); // set results node to the experiment logging (for saving contents to the // file system) m_ExperimentLogging->SetResult(resultsNode); std::string resultsName; if (!resultsNode->GetName(resultsName)) { MITK_WARN << "Could not get name of current results node."; return; } // save the mitk scene - std::string scenefile = QString(m_ExperimentResultsSubDirectory + QDir::separator() - + QString("Scene %1 - ").arg(m_SceneNumber++, 2, 10, QChar('0')) - + QString::fromStdString(resultsName).replace(":", "_") + ".mitk").toStdString(); + std::string scenefile = QString(m_ExperimentResultsSubDirectory + QDir::separator() + + QString("Scene %1 - ").arg(m_SceneNumber++, 2, 10, QChar('0')) + + QString::fromStdString(resultsName).replace(":", "_") + ".mitk") + .toStdString(); MITK_INFO << "Saving Scene File: " << scenefile; mitk::SceneIO::Pointer sceneIO = mitk::SceneIO::New(); mitk::NodePredicateNot::Pointer isNotHelperObject = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object", mitk::BoolProperty::New(true))); mitk::DataStorage::SetOfObjects::ConstPointer nodesToBeSaved = this->GetDataStorage()->GetSubset(isNotHelperObject); this->Convert2DImagesTo3D(nodesToBeSaved); sceneIO->SaveScene(nodesToBeSaved, this->GetDataStorage(), scenefile); this->WaitCursorOff(); } void USNavigationMarkerPlacement::ReinitOnImage() { if (!m_ReinitAlreadyDone && m_CombinedModality.IsNotNull()) { // make sure that the output is already calibrated correctly // (if the zoom level was changed recently) m_CombinedModality->Modified(); m_CombinedModality->Update(); mitk::Image::Pointer image = m_CombinedModality->GetOutput(); if (image.IsNotNull() && image->IsInitialized()) { // make a reinit on the ultrasound image - mitk::IRenderWindowPart* renderWindow = this->GetRenderWindowPart(); + mitk::IRenderWindowPart *renderWindow = this->GetRenderWindowPart(); if (renderWindow != NULL && image->GetTimeGeometry()->IsValid()) { renderWindow->GetRenderingManager()->InitializeViews( image->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true); renderWindow->GetRenderingManager()->RequestUpdateAll(); } this->RequestRenderWindowUpdate(); m_ReinitAlreadyDone = true; } } } void USNavigationMarkerPlacement::Convert2DImagesTo3D(mitk::DataStorage::SetOfObjects::ConstPointer nodes) { - for (mitk::DataStorage::SetOfObjects::ConstIterator it = nodes->Begin(); - it != nodes->End(); ++it) + for (mitk::DataStorage::SetOfObjects::ConstIterator it = nodes->Begin(); it != nodes->End(); ++it) { if (it->Value()->GetData() && strcmp(it->Value()->GetData()->GetNameOfClass(), "Image") == 0) { // convert image to 3d image if it is 2d at the moment - mitk::Image::Pointer image = dynamic_cast(it->Value()->GetData()); - if (image.IsNotNull() && image->GetDimension() == 2 - && !image->GetGeometry()->Is2DConvertable()) + mitk::Image::Pointer image = dynamic_cast(it->Value()->GetData()); + if (image.IsNotNull() && image->GetDimension() == 2 && !image->GetGeometry()->Is2DConvertable()) { mitk::Convert2Dto3DImageFilter::Pointer convert2DTo3DImageFilter = mitk::Convert2Dto3DImageFilter::New(); convert2DTo3DImageFilter->SetInput(image); convert2DTo3DImageFilter->Update(); it->Value()->SetData(convert2DTo3DImageFilter->GetOutput()); } } } } void USNavigationMarkerPlacement::CreateOverlays() { // initialize warning overlay (and do not display it, yet) m_WarnOverlay->SetText("Warning: No calibration available for current depth."); // set position and font size for the text overlay // (nonesense postition as a layouter is used, but it ignored // the overlay without setting a position here) mitk::Point2D overlayPosition; overlayPosition.SetElement(0, -50.0f); overlayPosition.SetElement(1, -50.0f); m_WarnOverlay->SetPosition2D(overlayPosition); m_WarnOverlay->SetFontSize(22); m_WarnOverlay->SetColor(1, 0, 0); // overlay should be red - - mitk::BaseRenderer* renderer = mitk::BaseRenderer::GetByName("stdmulti.widget1"); - if (renderer) - { - m_OverlayManager = renderer->GetOverlayManager(); - - //add layouter if it doesn't exist yet - if (!m_OverlayManager->GetLayouter(renderer, mitk::Overlay2DLayouter::STANDARD_2D_TOP())) - { - m_OverlayManager->AddLayouter(mitk::Overlay2DLayouter::CreateLayouter(mitk::Overlay2DLayouter::STANDARD_2D_TOP(), renderer).GetPointer()); - } - - /* causes a crash when closing the view and opening it again, so deactivated at the moment TODO!! - //set layouter to warn overlay - m_OverlayManager->SetLayouter(m_WarnOverlay.GetPointer(), mitk::Overlay2DLayouter::STANDARD_2D_TOP(), renderer); - */ - } } diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.h b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.h index 3120d86164..f43ddf3e90 100644 --- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.h +++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.h @@ -1,187 +1,190 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef USNAVIGATIONMARKERPLACEMENT_H #define USNAVIGATIONMARKERPLACEMENT_H #include -#include -#include "Widgets/QmitkUSNavigationProcessWidget.h" #include "IO/mitkUSNavigationLoggingBackend.h" -#include "mitkUSImageLoggingFilter.h" +#include "Widgets/QmitkUSNavigationProcessWidget.h" #include "mitkNavigationDataRecorder.h" #include "mitkNodeDisplacementFilter.h" +#include "mitkUSImageLoggingFilter.h" #include -#include -#include +#include +#include -namespace itk { - template class SmartPointer; +namespace itk +{ + template + class SmartPointer; } -namespace mitk { +namespace mitk +{ class USNavigationStepTimer; class USNavigationExperimentLogging; } -namespace Ui { +namespace Ui +{ class USNavigationMarkerPlacement; } class QmitkUSAbstractNavigationStep; class QmitkStdMultiWidget; class QTimer; class QSignalMapper; /** * \brief View for navigated marker placement using the combined modality. * This view utilizes the QmitkUSNavigationProcessWidget to do the navigation * process. It can be switched between widgets for marker placement and widgets * for punctuation. * * An experiment mode allows for logging results, durations and the ultrasound * images. */ class USNavigationMarkerPlacement : public QmitkAbstractView { Q_OBJECT - protected slots: +protected slots: /** * \brief Called periodically to update the rendering. * The standard multi widget is changed to fit the navigation process once it * is available and a reinit on the ultrasound image is done for a new image * node. */ void OnTimeout(); /** * \brief Called periodically during an experiment for logging the ultrasound images. */ void OnImageAndNavigationDataLoggingTimeout(); /** * \brief Initializes anything neccessary for an experiment. * The user is asked for a directory for storing the results and the logging * is started. */ void OnStartExperiment(); /** * \brief Stops logging and saves everything to the file system. */ void OnFinishExperiment(); void OnCombinedModalityChanged(itk::SmartPointer); /** * \brief Switches the navigation step widgets if the navigation application was changed. */ void OnSettingsChanged(itk::SmartPointer); /** * \brief Updates the timer for the navigation steps durations every time the active navigation step changes. */ void OnActiveNavigationStepChanged(int); /** * \brief The data node is given to the experiment logging and scene is saved to the file system. */ void OnIntermediateResultProduced(const itk::SmartPointer); void OnAddAblationZone(int size); void OnChangeAblationZone(int id, int newSize); public: - static const char* DATANAME_TUMOUR; - static const char* DATANAME_TARGETSURFACE; - static const char* DATANAME_ZONES; - static const char* DATANAME_TARGETS; - static const char* DATANAME_TARGETS_PATHS; - static const char* DATANAME_REACHED_TARGETS; + static const char *DATANAME_TUMOUR; + static const char *DATANAME_TARGETSURFACE; + static const char *DATANAME_ZONES; + static const char *DATANAME_TARGETS; + static const char *DATANAME_TARGETS_PATHS; + static const char *DATANAME_REACHED_TARGETS; explicit USNavigationMarkerPlacement(); ~USNavigationMarkerPlacement(); virtual void CreateQtPartControl(QWidget *parent); static const std::string VIEW_ID; - void OnCombinedModalityPropertyChanged(const std::string&, const std::string&); + void OnCombinedModalityPropertyChanged(const std::string &, const std::string &); protected: /** * \brief A reinit on the ultrasound image is performed every time the view gets the focus. */ virtual void SetFocus(); /** * \brief Helper function which performs a reinit on the ultrasound image. */ void ReinitOnImage(); /** * \brief Helper function for being able to serialize the 2d ultrasound image. */ void Convert2DImagesTo3D(mitk::DataStorage::SetOfObjects::ConstPointer nodes); void CreateOverlays(); - QWidget* m_Parent; + QWidget *m_Parent; QmitkUSNavigationProcessWidget::NavigationStepVector m_NavigationSteps; - QTimer* m_UpdateTimer; - QTimer* m_ImageAndNavigationDataLoggingTimer; - QmitkStdMultiWidget* m_StdMultiWidget; - itk::SmartPointer m_CombinedModality; - bool m_ReinitAlreadyDone; - bool m_IsExperimentRunning; - std::string m_CurrentApplicationName; - - itk::SmartPointer m_NavigationStepTimer; + QTimer *m_UpdateTimer; + QTimer *m_ImageAndNavigationDataLoggingTimer; + QmitkStdMultiWidget *m_StdMultiWidget; + itk::SmartPointer m_CombinedModality; + bool m_ReinitAlreadyDone; + bool m_IsExperimentRunning; + std::string m_CurrentApplicationName; + + itk::SmartPointer m_NavigationStepTimer; itk::SmartPointer m_ExperimentLogging; - QPixmap m_IconRunning; - QPixmap m_IconNotRunning; + QPixmap m_IconRunning; + QPixmap m_IconNotRunning; - QString m_ResultsDirectory; - QString m_ExperimentName; - QString m_ExperimentResultsSubDirectory; - std::vector m_NavigationStepNames; //stores the names of the navigation steps which are currently used (for logging purposes) + QString m_ResultsDirectory; + QString m_ExperimentName; + QString m_ExperimentResultsSubDirectory; + std::vector + m_NavigationStepNames; // stores the names of the navigation steps which are currently used (for logging purposes) - mitk::USNavigationLoggingBackend m_LoggingBackend; - mitk::USImageLoggingFilter::Pointer m_USImageLoggingFilter; - mitk::NavigationDataRecorder::Pointer m_NavigationDataRecorder; //records navigation data files - mitk::NodeDisplacementFilter::Pointer m_TargetNodeDisplacementFilter; - mitk::NodeDisplacementFilter::Pointer m_AblationZonesDisplacementFilter; - std::vector m_AblationZonesVector; + mitk::USNavigationLoggingBackend m_LoggingBackend; + mitk::USImageLoggingFilter::Pointer m_USImageLoggingFilter; + mitk::NavigationDataRecorder::Pointer m_NavigationDataRecorder; // records navigation data files + mitk::NodeDisplacementFilter::Pointer m_TargetNodeDisplacementFilter; + mitk::NodeDisplacementFilter::Pointer m_AblationZonesDisplacementFilter; + std::vector m_AblationZonesVector; int m_NeedleIndex; int m_MarkerIndex; - int m_SceneNumber; + int m_SceneNumber; - itk::SmartPointer m_OverlayManager; - itk::SmartPointer m_WarnOverlay; + itk::SmartPointer m_WarnOverlay; private: - mitk::MessageDelegate2 m_ListenerDeviceChanged; + mitk::MessageDelegate2 m_ListenerDeviceChanged; Ui::USNavigationMarkerPlacement *ui; }; #endif // USNAVIGATIONMARKERPLACEMENT_H diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkNavigationDataPlayerView.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkNavigationDataPlayerView.cpp index 3767f5598c..eabc7aa9a4 100644 --- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkNavigationDataPlayerView.cpp +++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkNavigationDataPlayerView.cpp @@ -1,237 +1,240 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ // Qmitk #include "QmitkNavigationDataPlayerView.h" // QT #include #include //mitk #include #include #include #include #include #include // VTK #include const std::string QmitkNavigationDataPlayerView::VIEW_ID = "org.mitk.views.navigationdataplayer"; QmitkNavigationDataPlayerView::QmitkNavigationDataPlayerView() : m_Controls( 0 ) { } QmitkNavigationDataPlayerView::~QmitkNavigationDataPlayerView() { } void QmitkNavigationDataPlayerView::CreateQtPartControl( QWidget *parent ) { // build up qt view, unless already done if ( !m_Controls ) { // create GUI widgets from the Qt Designer's .ui file m_Controls = new Ui::QmitkNavigationDataPlayerViewControls; m_Controls->setupUi( parent ); this->CreateConnections(); // make deselected Player invisible m_Controls->m_TimedWidget->setVisible(false); } } void QmitkNavigationDataPlayerView::SetFocus() { if ( m_Controls ) { m_Controls->m_grpbxControls->setFocus(); } } void QmitkNavigationDataPlayerView::CreateConnections() { connect( m_Controls->m_RdbSequential, SIGNAL(released()), this, SLOT(OnSelectPlayer()) ); connect( m_Controls->m_RdbTimeBased, SIGNAL(released()), this, SLOT(OnSelectPlayer()) ); connect( m_Controls->m_BtnOpenFile, SIGNAL(released()), this, SLOT(OnOpenFile()) ); connect( m_Controls->m_ChkDisplay, SIGNAL(released()), this, SLOT(OnSetDisplay()) ); connect( m_Controls->m_chkRepeat, SIGNAL(stateChanged(int)), this, SLOT(OnSetRepeat(int)) ); connect( m_Controls->m_ChkMicroservice, SIGNAL(released()), this, SLOT(OnSetMicroservice()) ); connect( m_Controls->m_SequentialWidget, SIGNAL(SignalUpdate()), this, SLOT(OnUpdate()) ); connect( m_Controls->m_TimedWidget, SIGNAL(SignalUpdate()), this, SLOT(OnUpdate()) ); this->SetInteractionComponentsEnabledState(false); } void QmitkNavigationDataPlayerView::OnOpenFile() { mitk::NavigationDataReaderInterface::Pointer reader = NULL; QString filter = tr("NavigationData File (*.csv *.xml)"); QString fileName = QFileDialog::getOpenFileName(NULL, tr("Open NavigationData Set"), "", filter); if ( fileName.isNull() ) { return; } // user pressed cancel try { m_Data = dynamic_cast (mitk::IOUtil::LoadBaseData(fileName.toStdString()).GetPointer()); } catch ( const mitk::Exception &e ) { MITK_WARN("NavigationDataPlayerView") << "could not open file " << fileName.toStdString(); QMessageBox::critical(0, "Error Reading File", "The file '" + fileName +"' could not be read.\n" + e.GetDescription() ); return; } + if (m_Controls->m_ChkConvertToPointSet->isChecked()) + m_Data->ConvertNavigationDataToPointSet(); + // Update Labels m_Controls->m_LblFilePath->setText(fileName); m_Controls->m_LblFrames->setText(QString::number(m_Data->Size())); m_Controls->m_LblTools->setText(QString::number(m_Data->GetNumberOfTools())); // Initialize Widgets and create Player this->OnSelectPlayer(); this->SetInteractionComponentsEnabledState(true); } void QmitkNavigationDataPlayerView::OnSelectPlayer() { if (m_Controls->m_RdbSequential->isChecked()) { m_Controls->m_SequentialWidget->setVisible(true); m_Controls->m_TimedWidget->setVisible(false); mitk::NavigationDataSequentialPlayer::Pointer seqPlayer = mitk::NavigationDataSequentialPlayer::New(); seqPlayer->SetNavigationDataSet(m_Data); m_Controls->m_SequentialWidget->SetPlayer(seqPlayer); m_Player = seqPlayer; } else { m_Controls->m_SequentialWidget->setVisible(false); m_Controls->m_TimedWidget->setVisible(true); mitk::NavigationDataPlayer::Pointer timedPlayer = mitk::NavigationDataPlayer::New(); timedPlayer->SetNavigationDataSet(m_Data); m_Controls->m_TimedWidget->SetPlayer(timedPlayer); m_Player = timedPlayer; } this->ConfigurePlayer(); // SetupRenderingPipeline this->OnSetDisplay(); } void QmitkNavigationDataPlayerView::ConfigurePlayer() { // set repeat mode according to the checkbox m_Player->SetRepeat( m_Controls->m_chkRepeat->isChecked() ); } void QmitkNavigationDataPlayerView::OnSetRepeat(int checkState) { m_Player->SetRepeat(checkState != 0); } void QmitkNavigationDataPlayerView::OnSetMicroservice(){ if(m_Controls->m_ChkMicroservice->isChecked()) { m_ToolStorage = mitk::NavigationToolStorage::New(); for (itk::ProcessObject::DataObjectPointerArraySizeType i = 0; i < m_Player->GetNumberOfIndexedOutputs(); i++) { mitk::NavigationTool::Pointer currentDummyTool = mitk::NavigationTool::New(); mitk::VirtualTrackingTool::Pointer dummyTool = mitk::VirtualTrackingTool::New(); std::stringstream name; name << "Virtual Tool " << i; dummyTool->SetToolName(name.str()); currentDummyTool->SetTrackingTool(dummyTool.GetPointer()); currentDummyTool->SetDataNode(m_RenderingNodes.at(i)); currentDummyTool->SetIdentifier(name.str()); m_ToolStorage->AddTool(currentDummyTool); } m_Player->RegisterAsMicroservice(); m_ToolStorage->SetName("NavigationDataPlayer Tool Storage"); m_ToolStorage->RegisterAsMicroservice(m_Player->GetMicroserviceID()); } else { if (m_ToolStorage.IsNotNull()) m_ToolStorage->UnRegisterMicroservice(); m_ToolStorage = NULL; m_Player->UnRegisterMicroservice(); } } void QmitkNavigationDataPlayerView::OnUpdate(){ if (m_VisFilter.IsNotNull()) { m_VisFilter->Update(); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } } void QmitkNavigationDataPlayerView::OnSetDisplay(){ DestroyPipeline(); if ( (m_Controls->m_ChkDisplay->isChecked()) && ( m_Player.IsNotNull() )) { CreatePipeline(); } } void QmitkNavigationDataPlayerView::CreatePipeline(){ m_VisFilter = mitk::NavigationDataObjectVisualizationFilter::New(); m_VisFilter->ConnectTo(m_Player); for (unsigned int i = 0 ; i < m_Player->GetNumberOfIndexedOutputs(); i++ ) { mitk::DataNode::Pointer node = mitk::DataNode::New(); QString name = "Recorded Tool " + QString::number(i + 1); node->SetName(name.toStdString()); //create small sphere and use it as surface mitk::Surface::Pointer mySphere = mitk::Surface::New(); vtkSphereSource *vtkData = vtkSphereSource::New(); vtkData->SetRadius(5.0f); vtkData->SetCenter(0.0, 0.0, 0.0); vtkData->Update(); mySphere->SetVtkPolyData(vtkData->GetOutput()); vtkData->Delete(); node->SetData(mySphere); m_VisFilter->SetRepresentationObject(i, mySphere); // Add Node to DataStorageand to local list of Nodes GetDataStorage()->Add(node); m_RenderingNodes.push_back(node); } m_VisFilter->Update(); mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(GetDataStorage()); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } void QmitkNavigationDataPlayerView::DestroyPipeline(){ m_VisFilter = NULL; for (unsigned int i = 0; i < m_RenderingNodes.size(); i++){ this->GetDataStorage()->Remove(m_RenderingNodes[i]); } m_RenderingNodes.clear(); } void QmitkNavigationDataPlayerView::SetInteractionComponentsEnabledState(bool isActive){ m_Controls->m_grpbxSettings->setEnabled(isActive); m_Controls->m_grpbxControls->setEnabled(isActive); } \ No newline at end of file diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkNavigationDataPlayerViewControls.ui b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkNavigationDataPlayerViewControls.ui index 01b0369fbc..4e0f4e029a 100644 --- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkNavigationDataPlayerViewControls.ui +++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkNavigationDataPlayerViewControls.ui @@ -1,188 +1,195 @@ QmitkNavigationDataPlayerViewControls 0 0 415 762 0 0 QmitkTemplate File Management - + Open File - + No navigation data set loaded... - + Frames: - + + + + N/A + + + + Tools: - - + + N/A - + - N/A + Convert navigation data to point set true Settings Sequential Player true Time-based Player Repeat true Register as Microservice false Display true Player Controls Qt::Vertical 20 40 QmitkNavigationDataSequentialPlayerControlWidget QWidget
QmitkNavigationDataSequentialPlayerControlWidget.h
1 QmitkNavigationDataPlayerControlWidget QWidget
QmitkNavigationDataPlayerControlWidget.h
1 diff --git a/Plugins/org.mitk.gui.qt.overlaymanager/documentation/UserManual/QmitkOverlayManager.dox b/Plugins/org.mitk.gui.qt.overlaymanager/documentation/UserManual/QmitkOverlayManager.dox index ecb943f4e9..e34dbb5b5c 100644 --- a/Plugins/org.mitk.gui.qt.overlaymanager/documentation/UserManual/QmitkOverlayManager.dox +++ b/Plugins/org.mitk.gui.qt.overlaymanager/documentation/UserManual/QmitkOverlayManager.dox @@ -1,11 +1,11 @@ /** \page org_mitk_gui_qt_overlaymanager The OverlayManager Plugin \imageMacro{icon.png,"Icon of Overlaymanager",2.00} \tableofcontents \section org_mitk_gui_qt_overlaymanagerOverview Overview -The OverlayManager plugin allows to view all overlays currently managed by the mitk::OverlayManager. Properties of added overlays can be modified. Additionally it is possible to create some basic overlays and add them to the mitk::OverlayManager. +The OverlayManager plugin allows to view all annotations currently managed. Properties of added annotations can be modified. Additionally it is possible to create some basic overlays and register them. */ diff --git a/Plugins/org.mitk.gui.qt.overlaymanager/documentation/doxygen/modules.dox b/Plugins/org.mitk.gui.qt.overlaymanager/documentation/doxygen/modules.dox index 1858d3a08d..82586ab590 100644 --- a/Plugins/org.mitk.gui.qt.overlaymanager/documentation/doxygen/modules.dox +++ b/Plugins/org.mitk.gui.qt.overlaymanager/documentation/doxygen/modules.dox @@ -1,16 +1,16 @@ /** \defgroup org_mitk_gui_qt_overlaymanager org.mitk.gui.qt.overlaymanager \ingroup MITKPlugins - \brief This is the overlaymanager plugin. Overlays that have been addded to the OverlayManager can be viewed and modified. The plugin also allows to add new overlays. + \brief This is the overlaymanager plugin. Annotations that have been addded to the OverlayManager can be viewed and modified. The plugin also allows to add new annotations. */ /** \defgroup org_mitk_gui_qt_overlaymanager_internal Internal \ingroup org_mitk_gui_qt_overlaymanager \brief This subcategory includes the internal classes of the org.mitk.gui.qt.overlaymanager plugin. Other plugins must not rely on these classes. They contain implementation details and their interface may change at any time. We mean it. */ diff --git a/Plugins/org.mitk.gui.qt.overlaymanager/src/internal/QmitkAddNewPropertyDialog.cpp b/Plugins/org.mitk.gui.qt.overlaymanager/src/internal/QmitkAddNewPropertyDialog.cpp index a901cbfa7a..523daad284 100644 --- a/Plugins/org.mitk.gui.qt.overlaymanager/src/internal/QmitkAddNewPropertyDialog.cpp +++ b/Plugins/org.mitk.gui.qt.overlaymanager/src/internal/QmitkAddNewPropertyDialog.cpp @@ -1,179 +1,186 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "QmitkAddNewPropertyDialog.h" #include "mitkGetPropertyService.h" -#include -#include #include #include +#include +#include -QmitkAddNewPropertyDialog::QmitkAddNewPropertyDialog(mitk::Overlay::Pointer overlay, mitk::BaseRenderer::Pointer renderer, QWidget* parent) - : QDialog(parent), - m_Overlay(overlay), - m_Renderer(renderer) +QmitkAddNewPropertyDialog::QmitkAddNewPropertyDialog(mitk::Annotation::Pointer overlay, + mitk::BaseRenderer::Pointer renderer, + QWidget *parent) + : QDialog(parent), m_Overlay(overlay), m_Renderer(renderer) { this->Initialize(); } QmitkAddNewPropertyDialog::~QmitkAddNewPropertyDialog() { } void QmitkAddNewPropertyDialog::Initialize() { m_Controls.setupUi(this); QStringList types; - types << "bool" << "double" << "float" << "int" << "string"; + types << "bool" + << "double" + << "float" + << "int" + << "string"; m_Controls.typeComboBox->addItems(types); - connect(m_Controls.typeComboBox, SIGNAL(currentIndexChanged(const QString&)), this, SLOT(ShowAdequateValueWidget(const QString&))); + connect(m_Controls.typeComboBox, + SIGNAL(currentIndexChanged(const QString &)), + this, + SLOT(ShowAdequateValueWidget(const QString &))); connect(m_Controls.addButton, SIGNAL(clicked()), this, SLOT(AddNewProperty())); connect(m_Controls.cancelButton, SIGNAL(clicked()), this, SLOT(reject())); this->ShowAdequateValueWidget(types[0]); } void QmitkAddNewPropertyDialog::AddNewProperty() { if (m_Controls.nameLineEdit->text().isEmpty()) { QMessageBox::critical(this, "No name specified", "Enter a property name."); return; } if (!this->ValidateValue()) { QMessageBox::critical(this, "Invalid value", "Enter a valid " + m_Controls.typeComboBox->currentText() + " value."); return; } - m_Overlay->SetProperty(m_Controls.nameLineEdit->text().toStdString(), this->CreateProperty(), m_Renderer); + m_Overlay->SetProperty(m_Controls.nameLineEdit->text().toStdString(), this->CreateProperty()); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); this->accept(); } mitk::BaseProperty::Pointer QmitkAddNewPropertyDialog::CreateProperty() const { QString type = m_Controls.typeComboBox->currentText(); if (type == "bool") { return mitk::BoolProperty::New(m_Controls.valueCheckBox->isChecked()).GetPointer(); } else if (type == "double") { return mitk::DoubleProperty::New(m_Controls.valueLineEdit->text().toDouble()).GetPointer(); } else if (type == "float") { return mitk::FloatProperty::New(m_Controls.valueLineEdit->text().toFloat()).GetPointer(); } else if (type == "int") { return mitk::IntProperty::New(m_Controls.valueLineEdit->text().toInt()).GetPointer(); } else if (type == "string") { return mitk::StringProperty::New(m_Controls.valueLineEdit->text().toStdString()).GetPointer(); } else { assert(false && "Property creation for selected type not implemented!"); } return NULL; } bool QmitkAddNewPropertyDialog::ValidateValue() { QString type = m_Controls.typeComboBox->currentText(); if (type == "bool") { return true; } else if (type == "double") { bool ok = false; m_Controls.valueLineEdit->text().toDouble(&ok); return ok; } else if (type == "float") { bool ok = false; m_Controls.valueLineEdit->text().toFloat(&ok); return ok; } else if (type == "int") { bool ok = false; m_Controls.valueLineEdit->text().toInt(&ok); return ok; } else if (type == "string") { return true; } else { assert(false && "Value validation for selected type not implemented!"); } return false; } -void QmitkAddNewPropertyDialog::ShowAdequateValueWidget(const QString& type) +void QmitkAddNewPropertyDialog::ShowAdequateValueWidget(const QString &type) { m_Controls.valueLineEdit->clear(); m_Controls.valueLineEdit->hide(); m_Controls.valueCheckBox->setChecked(false); m_Controls.valueCheckBox->hide(); if (type == "bool") { m_Controls.valueCheckBox->show(); } else if (type == "double") { m_Controls.valueLineEdit->setText("0"); m_Controls.valueLineEdit->show(); } else if (type == "float") { m_Controls.valueLineEdit->setText("0"); m_Controls.valueLineEdit->show(); } else if (type == "int") { m_Controls.valueLineEdit->setText("0"); m_Controls.valueLineEdit->show(); } else if (type == "string") { m_Controls.valueLineEdit->show(); } else { assert(false && "No adequate value widget specified for selected type!"); } } diff --git a/Plugins/org.mitk.gui.qt.overlaymanager/src/internal/QmitkAddNewPropertyDialog.h b/Plugins/org.mitk.gui.qt.overlaymanager/src/internal/QmitkAddNewPropertyDialog.h index 9a1c0823e7..76cc57a121 100644 --- a/Plugins/org.mitk.gui.qt.overlaymanager/src/internal/QmitkAddNewPropertyDialog.h +++ b/Plugins/org.mitk.gui.qt.overlaymanager/src/internal/QmitkAddNewPropertyDialog.h @@ -1,48 +1,50 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef QmitkAddNewPropertyDialog_h #define QmitkAddNewPropertyDialog_h -#include -#include -#include #include +#include +#include +#include #include class QmitkAddNewPropertyDialog : public QDialog { Q_OBJECT public: - explicit QmitkAddNewPropertyDialog(mitk::Overlay::Pointer overlay, mitk::BaseRenderer::Pointer renderer = NULL, QWidget* parent = NULL); + explicit QmitkAddNewPropertyDialog(mitk::Annotation::Pointer overlay, + mitk::BaseRenderer::Pointer renderer = NULL, + QWidget *parent = NULL); ~QmitkAddNewPropertyDialog(); private slots: void AddNewProperty(); - void ShowAdequateValueWidget(const QString& type); + void ShowAdequateValueWidget(const QString &type); bool ValidateValue(); private: mitk::BaseProperty::Pointer CreateProperty() const; void Initialize(); Ui::QmitkAddNewPropertyDialog m_Controls; - mitk::Overlay::Pointer m_Overlay; + mitk::Annotation::Pointer m_Overlay; mitk::BaseRenderer::Pointer m_Renderer; }; #endif diff --git a/Plugins/org.mitk.gui.qt.overlaymanager/src/internal/QmitkOverlayManagerView.cpp b/Plugins/org.mitk.gui.qt.overlaymanager/src/internal/QmitkOverlayManagerView.cpp index 6225dcffcd..fa972b74b7 100644 --- a/Plugins/org.mitk.gui.qt.overlaymanager/src/internal/QmitkOverlayManagerView.cpp +++ b/Plugins/org.mitk.gui.qt.overlaymanager/src/internal/QmitkOverlayManagerView.cpp @@ -1,503 +1,536 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include // Blueberry +#include #include #include -#include // Qmitk -#include "QmitkOverlayManagerView.h" #include "QmitkAddNewPropertyDialog.h" +#include "QmitkOverlayManagerView.h" #include "QmitkPropertyItemDelegate.h" #include "QmitkPropertyItemModel.h" #include // Qt #include -#include #include +#include +#include "internal/org_mitk_gui_qt_overlaymanager_Activator.h" + +#include "mitkAnnotationUtils.h" +#include "mitkGetPropertyService.h" +#include "mitkLayoutAnnotationRenderer.h" +#include "mitkManualPlacementAnnotationRenderer.h" +#include "mitkRenderingManager.h" +#include #include #include -#include "mitkGetPropertyService.h" #include -#include "mitkOverlayManager.h" -#include "mitkRenderingManager.h" -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include const std::string QmitkOverlayManagerView::VIEW_ID = "org.mitk.views.overlaymanager"; QmitkOverlayManagerView::QmitkOverlayManagerView() : m_Parent(nullptr), m_PropertyNameChangedTag(0), m_OverlayManagerObserverTag(0), m_PropertyAliases(nullptr), m_PropertyDescriptions(nullptr), m_PropertyPersistence(nullptr), m_ProxyModel(nullptr), m_Model(nullptr), m_Delegate(nullptr), m_Renderer(nullptr), m_AddOverlayMenu(nullptr) { } QmitkOverlayManagerView::~QmitkOverlayManagerView() { } void QmitkOverlayManagerView::SetFocus() { } -void QmitkOverlayManagerView::CreateQtPartControl( QWidget *parent ) +void QmitkOverlayManagerView::CreateQtPartControl(QWidget *parent) { // create GUI widgets from the Qt Designer's .ui file - m_Controls.setupUi( parent ); - m_Controls.propertyListComboBox->addItem("common"); + m_Controls.setupUi(parent); m_Controls.m_OverlayList->clear(); - mitk::IRenderWindowPart* renderWindowPart = this->GetRenderWindowPart(); + mitk::IRenderWindowPart *renderWindowPart = this->GetRenderWindowPart(); if (renderWindowPart != NULL) { - QHash renderWindows = renderWindowPart->GetQmitkRenderWindows(); + QHash renderWindows = renderWindowPart->GetQmitkRenderWindows(); - Q_FOREACH(QString renderWindow, renderWindows.keys()) + Q_FOREACH (QString renderWindow, renderWindows.keys()) { - m_Controls.propertyListComboBox->addItem(renderWindow); + if (!m_Renderer) + m_Renderer = renderWindows[renderWindow]->GetRenderer(); + m_Controls.m_RendererCB->addItem(renderWindow); } } - InitializeAddAnimationMenu(); + InitializeAddOverlayMenu(); m_ProxyModel = new QSortFilterProxyModel(m_Controls.m_PropertyTree); m_Model = new QmitkPropertyItemModel(m_ProxyModel); m_ProxyModel->setSourceModel(m_Model); m_ProxyModel->setFilterCaseSensitivity(Qt::CaseInsensitive); m_ProxyModel->setSortCaseSensitivity(Qt::CaseInsensitive); m_ProxyModel->setDynamicSortFilter(true); m_Delegate = new QmitkPropertyItemDelegate(m_Controls.m_PropertyTree); m_Controls.m_PropertyTree->setItemDelegateForColumn(1, m_Delegate); m_Controls.m_PropertyTree->setModel(m_ProxyModel); m_Controls.m_PropertyTree->setColumnWidth(0, 160); m_Controls.m_PropertyTree->sortByColumn(0, Qt::AscendingOrder); m_Controls.m_PropertyTree->setSelectionBehavior(QAbstractItemView::SelectRows); m_Controls.m_PropertyTree->setSelectionMode(QAbstractItemView::SingleSelection); m_Controls.m_PropertyTree->setEditTriggers(QAbstractItemView::SelectedClicked | QAbstractItemView::DoubleClicked); - connect(m_Controls.propertyListComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnPropertyListChanged(int))); + connect(m_Controls.m_RendererCB, SIGNAL(currentIndexChanged(int)), this, SLOT(OnPropertyListChanged(int))); connect(m_Controls.newButton, SIGNAL(clicked()), this, SLOT(OnAddNewProperty())); - connect(m_Controls.m_PropertyTree->selectionModel(), SIGNAL(currentRowChanged(const QModelIndex&, const QModelIndex&)), this, SLOT(OnCurrentRowChanged(const QModelIndex&, const QModelIndex&))); - connect(m_Controls.m_OverlayList, SIGNAL(currentItemChanged(QListWidgetItem*,QListWidgetItem*)), this, SLOT(OnOverlaySelectionChanged(QListWidgetItem*,QListWidgetItem*)) ); + connect(m_Controls.m_PropertyTree->selectionModel(), + SIGNAL(currentRowChanged(const QModelIndex &, const QModelIndex &)), + this, + SLOT(OnCurrentRowChanged(const QModelIndex &, const QModelIndex &))); + connect(m_Controls.m_OverlayList, + SIGNAL(currentItemChanged(QListWidgetItem *, QListWidgetItem *)), + this, + SLOT(OnOverlaySelectionChanged(QListWidgetItem *, QListWidgetItem *))); connect(m_Controls.m_DeleteOverlay, SIGNAL(clicked()), this, SLOT(OnDelete())); connect(m_Controls.m_AddOverlay, SIGNAL(clicked()), this, SLOT(OnAddOverlay())); + + itk::MemberCommand::Pointer command = itk::MemberCommand::New(); + command->SetCallbackFunction(this, &QmitkOverlayManagerView::OnFocusChanged); + m_RenderWindowFocusObserverTag = + mitk::RenderingManager::GetInstance()->AddObserver(mitk::FocusChangedEvent(), command); } -QString QmitkOverlayManagerView::GetPropertyNameOrAlias(const QModelIndex& index) +void QmitkOverlayManagerView::OnFocusChanged(itk::Object * /*caller*/, const itk::EventObject &event) +{ + const mitk::FocusChangedEvent *focusEvent = dynamic_cast(&event); + if (focusEvent) + { + QHash renderWindows = this->GetRenderWindowPart()->GetQmitkRenderWindows(); + m_Controls.m_RendererCB->clear(); + Q_FOREACH (QString renderWindow, renderWindows.keys()) + { + m_Controls.m_RendererCB->addItem(renderWindow); + if (renderWindows[renderWindow]->GetVtkRenderWindow() == + mitk::RenderingManager::GetInstance()->GetFocusedRenderWindow()) + { + m_Controls.m_RendererCB->setCurrentText(renderWindow); + } + } + this->OnActivateOverlayList(); + } +} + +QString QmitkOverlayManagerView::GetPropertyNameOrAlias(const QModelIndex &index) { QString propertyName; if (index.isValid()) { QModelIndex current = index; while (current.isValid()) { QString name = m_ProxyModel->data(m_ProxyModel->index(current.row(), 0, current.parent())).toString(); - propertyName.prepend(propertyName.isEmpty() - ? name - : name.append('.')); + propertyName.prepend(propertyName.isEmpty() ? name : name.append('.')); current = current.parent(); } } return propertyName; } -void QmitkOverlayManagerView::OnCurrentRowChanged(const QModelIndex& current, const QModelIndex&) +void QmitkOverlayManagerView::OnCurrentRowChanged(const QModelIndex ¤t, const QModelIndex &) { if (m_PropertyDescriptions != nullptr && current.isValid()) { QString name = this->GetPropertyNameOrAlias(current); if (!name.isEmpty()) { QString alias; bool isTrueName = true; if (m_PropertyAliases != nullptr) { std::string trueName = m_PropertyAliases->GetPropertyName(name.toStdString()); if (trueName.empty() && !m_SelectionClassName.empty()) trueName = m_PropertyAliases->GetPropertyName(name.toStdString(), m_SelectionClassName); if (!trueName.empty()) { alias = name; name = QString::fromStdString(trueName); isTrueName = false; } } QString description = QString::fromStdString(m_PropertyDescriptions->GetDescription(name.toStdString())); std::vector aliases; if (!isTrueName && m_PropertyAliases != nullptr) { aliases = m_PropertyAliases->GetAliases(name.toStdString(), m_SelectionClassName); if (aliases.empty() && !m_SelectionClassName.empty()) aliases = m_PropertyAliases->GetAliases(name.toStdString()); } bool isPersistent = false; // QString persistenceKey; if (m_PropertyPersistence != nullptr) { isPersistent = m_PropertyPersistence->HasInfo(name.toStdString()); /*if (isPersistent) { persistenceKey = QString::fromStdString(m_PropertyPersistence->GetInfo(name.toStdString())->GetKey()); if (persistenceKey.isEmpty()) persistenceKey = name; }*/ } if (!description.isEmpty() || !aliases.empty() || isPersistent) { QString customizedDescription; if (!description.isEmpty()) customizedDescription += "

" + description + "

"; if (!aliases.empty() || isPersistent) { customizedDescription += "
"; if (!aliases.empty()) { - customizedDescription += aliases.size() > 1 - ? "" - : ""; + customizedDescription += aliases.size() > 1 ? + "" : + ""; } if (isPersistent) - customizedDescription += ""; + customizedDescription += + ""; customizedDescription += "
"; } return; } } } } -void QmitkOverlayManagerView::OnPropertyNameChanged(const itk::EventObject&) +void QmitkOverlayManagerView::OnPropertyNameChanged(const itk::EventObject &) { - mitk::PropertyList* propertyList = m_Model->GetPropertyList(); + mitk::PropertyList *propertyList = m_Model->GetPropertyList(); if (propertyList != NULL) { - mitk::BaseProperty* nameProperty = propertyList->GetProperty("name"); + mitk::BaseProperty *nameProperty = propertyList->GetProperty("name"); if (nameProperty != NULL) { QString partName = "Properties ("; partName.append(QString::fromStdString(nameProperty->GetValueAsString())).append(')'); this->SetPartName(partName); } } } -void QmitkOverlayManagerView::OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList& nodes) +void QmitkOverlayManagerView::OnSelectionChanged(berry::IWorkbenchPart::Pointer, + const QList &nodes) { - } -void QmitkOverlayManagerView::InitializeAddAnimationMenu() +void QmitkOverlayManagerView::InitializeAddOverlayMenu() { m_AddOverlayMenu = new QMenu(m_Controls.m_AddOverlay); - m_AddOverlayMenu->addAction("TextOverlay2D"); - m_AddOverlayMenu->addAction("TextOverlay3D"); - m_AddOverlayMenu->addAction("LabelOverlay"); - m_AddOverlayMenu->addAction("ColorBarOverlay"); - m_AddOverlayMenu->addAction("ScaleLegendOverlay"); - m_AddOverlayMenu->addAction("LogoOverlay"); -} - -void QmitkOverlayManagerView::OnOverlayAdded(itk::Object *,const itk::EventObject &event) -{ - const mitk::OverlayAddEvent* addEvent = dynamic_cast(&event); - if(addEvent) - { - OnActivateOverlayList(); - } + m_AddOverlayMenu->addAction("TextAnnotation2D"); + m_AddOverlayMenu->addAction("TextAnnotation3D"); + m_AddOverlayMenu->addAction("LabelAnnotation"); + m_AddOverlayMenu->addAction("ColorBarAnnotation"); + m_AddOverlayMenu->addAction("ScaleLegendAnnotation"); + m_AddOverlayMenu->addAction("LogoAnnotation"); } void QmitkOverlayManagerView::Activated() { - + // this->OnActivateOverlayList(); } void QmitkOverlayManagerView::Deactivated() { } void QmitkOverlayManagerView::Visible() { - mitk::OverlayManager* om = mitk::OverlayManager::GetInstance(); - if(om && m_OverlayManagerObserverTag == 0) - { - itk::MemberCommand::Pointer command - = itk::MemberCommand::New(); - command->SetCallbackFunction(this, &QmitkOverlayManagerView::OnOverlayAdded ); - m_OverlayManagerObserverTag = om->AddObserver(mitk::OverlayAddEvent(), command); - } this->OnActivateOverlayList(); } void QmitkOverlayManagerView::Hidden() { } void QmitkOverlayManagerView::OnPropertyListChanged(int index) { if (index == -1) return; - QString renderer = m_Controls.propertyListComboBox->itemText(index); + QString renderer = m_Controls.m_RendererCB->itemText(index); - QmitkRenderWindow* renwin = this->GetRenderWindowPart()->GetQmitkRenderWindow(renderer); - m_Renderer= renwin ? renwin->GetRenderer() : nullptr; + QmitkRenderWindow *renwin = this->GetRenderWindowPart()->GetQmitkRenderWindow(renderer); + m_Renderer = renwin ? renwin->GetRenderer() : nullptr; this->OnOverlaySelectionChanged(m_Controls.m_OverlayList->currentItem(), nullptr); + this->OnActivateOverlayList(); } void QmitkOverlayManagerView::OnAddNewProperty() { std::unique_ptr dialog( - new QmitkAddNewPropertyDialog(m_SelectedOverlay, m_Renderer, m_Parent)); + new QmitkAddNewPropertyDialog(m_SelectedOverlay, m_Renderer, m_Parent)); if (dialog->exec() == QDialog::Accepted) this->m_Model->Update(); } void QmitkOverlayManagerView::OnActivateOverlayList() { - typedef mitk::OverlayManager::OverlaySet OverlaySet; - mitk::OverlayManager* om = mitk::OverlayManager::GetInstance(); + if (!m_Renderer) + return; + std::vector arList = + mitk::AnnotationUtils::GetAnnotationRenderer(m_Renderer->GetName()); m_Controls.m_OverlayList->clear(); - if(om) + for (auto ar : arList) { - OverlaySet oset = om->GetAllOverlays(); - for (auto overlay : oset) + for (auto overlay : ar->GetServices()) { - QListWidgetItem* item = new QListWidgetItem(); - item->setData(Qt::UserRole,QVariant::fromValue(overlay.GetPointer())); + QListWidgetItem *item = new QListWidgetItem(); + item->setData(Qt::UserRole, QVariant(overlay->GetMicroserviceID().c_str())); QString text(overlay->GetName().c_str()); - if(text.length()>0) + if (text.length() > 0) { text.append(" : "); } text.append(overlay->GetNameOfClass()); item->setText(text); m_Controls.m_OverlayList->addItem(item); } } } void QmitkOverlayManagerView::OnOverlaySelectionChanged(QListWidgetItem *current, QListWidgetItem *) { - mitk::PropertyList* propertyList = m_Model->GetPropertyList(); + mitk::PropertyList *propertyList = m_Model->GetPropertyList(); if (propertyList != NULL) { - mitk::BaseProperty* nameProperty = propertyList->GetProperty("name"); + mitk::BaseProperty *nameProperty = propertyList->GetProperty("name"); if (nameProperty != NULL) nameProperty->RemoveObserver(m_PropertyNameChangedTag); m_PropertyNameChangedTag = 0; } - mitk::Overlay* overlay = nullptr; - if(current) - overlay = reinterpret_cast(current->data(Qt::UserRole).value()); + mitk::Annotation *overlay = nullptr; + QString oID; + if (current) + { + oID = current->data(Qt::UserRole).toString(); + OverlayMapType::iterator it = m_OverlayMap.find(oID.toStdString()); + if (it != m_OverlayMap.end()) + overlay = it->second; + else + { + overlay = mitk::AnnotationUtils::GetAnnotation(oID.toStdString()); + } + } + if (!overlay) { m_SelectedOverlay = NULL; this->SetPartName("Overlay Properties"); m_Model->SetPropertyList(NULL); m_Delegate->SetPropertyList(NULL); m_Controls.newButton->setEnabled(false); } else { m_SelectedOverlay = overlay; QString selectionClassName = m_SelectedOverlay->GetNameOfClass(); m_SelectionClassName = selectionClassName.toStdString(); - mitk::PropertyList::Pointer propertyList = overlay->GetPropertyList(m_Renderer); + mitk::PropertyList::Pointer propertyList = overlay->GetPropertyList(); m_Model->SetPropertyList(propertyList, selectionClassName); m_Delegate->SetPropertyList(propertyList); OnPropertyNameChanged(itk::ModifiedEvent()); - mitk::BaseProperty* nameProperty = m_SelectedOverlay->GetProperty("name"); + mitk::BaseProperty *nameProperty = m_SelectedOverlay->GetProperty("name"); if (nameProperty != NULL) { - itk::ReceptorMemberCommand::Pointer command = itk::ReceptorMemberCommand::New(); + itk::ReceptorMemberCommand::Pointer command = + itk::ReceptorMemberCommand::New(); command->SetCallbackFunction(this, &QmitkOverlayManagerView::OnPropertyNameChanged); m_PropertyNameChangedTag = nameProperty->AddObserver(itk::ModifiedEvent(), command); } m_Controls.newButton->setEnabled(true); } if (!m_ProxyModel->filterRegExp().isEmpty()) m_Controls.m_PropertyTree->expandAll(); } void QmitkOverlayManagerView::OnDelete() { - auto items = m_Controls.m_OverlayList->selectedItems(); - if(items.count() < 1) return; - mitk::Overlay* overlay = nullptr; - QListWidgetItem* item = items[0]; - if(item) - overlay = reinterpret_cast(item->data(Qt::UserRole).value()); - mitk::OverlayManager::GetInstance()->RemoveOverlay(overlay); + if (m_SelectedOverlay.IsNotNull()) + { + m_OverlayMap.erase(m_SelectedOverlay->GetMicroserviceID()); + m_SelectedOverlay = nullptr; + OnActivateOverlayList(); + } } void QmitkOverlayManagerView::OnAddOverlay() { - QAction* action = m_AddOverlayMenu->exec(QCursor::pos()); + QAction *action = m_AddOverlayMenu->exec(QCursor::pos()); + + mitk::Annotation::Pointer overlay; if (action != NULL) { const QString widgetKey = action->text(); - if (widgetKey == "TextOverlay2D") - OnAddTextOverlay2D(); + if (widgetKey == "TextAnnotation2D") + overlay = CreateTextOverlay2D(); - else if (widgetKey == "TextOverlay3D") - OnAddTextOverlay3D(); + else if (widgetKey == "TextAnnotation3D") + overlay = CreateTextOverlay3D(); - else if (widgetKey == "LabelOverlay") - OnAddLabelOverlay(); + else if (widgetKey == "LabelAnnotation") + overlay = CreateLabelOverlay(); - else if (widgetKey == "ColorBarOverlay") - OnAddColorBarOverlay(); + else if (widgetKey == "ColorBarAnnotation") + overlay = CreateColorBarOverlay(); - else if (widgetKey == "ScaleLegendOverlay") - OnAddScaleLegendOverlay(); + else if (widgetKey == "ScaleLegendAnnotation") + overlay = CreateScaleLegendOverlay(); - else if (widgetKey == "LogoOverlay") - OnAddLogoOverlay(); + else if (widgetKey == "LogoAnnotation") + overlay = CreateLogoOverlay(); + + mitk::BaseRenderer *renderer = + this->GetRenderWindowPart()->GetQmitkRenderWindow(m_Controls.m_RendererCB->currentText())->GetRenderer(); + mitk::LayoutAnnotationRenderer::AddAnnotation(overlay, renderer); + m_OverlayMap[overlay->GetMicroserviceID()] = overlay; } + OnActivateOverlayList(); } -void QmitkOverlayManagerView::OnAddTextOverlay2D() +mitk::Annotation::Pointer QmitkOverlayManagerView::CreateTextOverlay2D() { - mitk::OverlayManager* om = mitk::OverlayManager::GetInstance(); - mitk::TextOverlay2D::Pointer to = mitk::TextOverlay2D::New(); - om->AddOverlay(to.GetPointer()); + mitk::TextAnnotation2D::Pointer to = mitk::TextAnnotation2D::New(); + to->SetText("Test"); + return to.GetPointer(); } -void QmitkOverlayManagerView::OnAddTextOverlay3D() +mitk::Annotation::Pointer QmitkOverlayManagerView::CreateTextOverlay3D() { - mitk::OverlayManager* om = mitk::OverlayManager::GetInstance(); - mitk::TextOverlay3D::Pointer to = mitk::TextOverlay3D::New(); - om->AddOverlay(to.GetPointer()); + mitk::TextAnnotation3D::Pointer to = mitk::TextAnnotation3D::New(); + return to.GetPointer(); } -void QmitkOverlayManagerView::OnAddLabelOverlay() +mitk::Annotation::Pointer QmitkOverlayManagerView::CreateLabelOverlay() { - mitk::OverlayManager* om = mitk::OverlayManager::GetInstance(); - mitk::LabelOverlay3D::Pointer to = mitk::LabelOverlay3D::New(); - om->AddOverlay(to.GetPointer()); + mitk::LabelAnnotation3D::Pointer to = mitk::LabelAnnotation3D::New(); + return to.GetPointer(); } -void QmitkOverlayManagerView::OnAddColorBarOverlay() +mitk::Annotation::Pointer QmitkOverlayManagerView::CreateColorBarOverlay() { - mitk::OverlayManager* om = mitk::OverlayManager::GetInstance(); - mitk::ColorBarOverlay::Pointer to = mitk::ColorBarOverlay::New(); - om->AddOverlay(to.GetPointer()); + mitk::ColorBarAnnotation::Pointer to = mitk::ColorBarAnnotation::New(); + return to.GetPointer(); } -void QmitkOverlayManagerView::OnAddScaleLegendOverlay() +mitk::Annotation::Pointer QmitkOverlayManagerView::CreateScaleLegendOverlay() { - mitk::OverlayManager* om = mitk::OverlayManager::GetInstance(); - mitk::ScaleLegendOverlay::Pointer to = mitk::ScaleLegendOverlay::New(); - om->AddOverlay(to.GetPointer()); + mitk::ScaleLegendAnnotation::Pointer to = mitk::ScaleLegendAnnotation::New(); + return to.GetPointer(); } -void QmitkOverlayManagerView::OnAddLogoOverlay() +mitk::Annotation::Pointer QmitkOverlayManagerView::CreateLogoOverlay() { - mitk::OverlayManager* om = mitk::OverlayManager::GetInstance(); - mitk::LogoOverlay::Pointer to = mitk::LogoOverlay::New(); - om->AddOverlay(to.GetPointer()); + mitk::LogoAnnotation::Pointer to = mitk::LogoAnnotation::New(); + return to.GetPointer(); } -void QmitkOverlayManagerView::RenderWindowPartActivated(mitk::IRenderWindowPart* /*renderWindowPart*/) +void QmitkOverlayManagerView::RenderWindowPartActivated(mitk::IRenderWindowPart * /*renderWindowPart*/) { - if (m_Controls.propertyListComboBox->count() == 1) + if (m_Controls.m_RendererCB->count() == 0) { - QHash renderWindows = this->GetRenderWindowPart()->GetQmitkRenderWindows(); + QHash renderWindows = this->GetRenderWindowPart()->GetQmitkRenderWindows(); - Q_FOREACH(QString renderWindow, renderWindows.keys()) + Q_FOREACH (QString renderWindow, renderWindows.keys()) { - m_Controls.propertyListComboBox->insertItem(m_Controls.propertyListComboBox->count() - 1, renderWindow); + m_Controls.m_RendererCB->addItem(renderWindow); } } OnActivateOverlayList(); } -void QmitkOverlayManagerView::RenderWindowPartDeactivated(mitk::IRenderWindowPart*) +void QmitkOverlayManagerView::RenderWindowPartDeactivated(mitk::IRenderWindowPart *) { - if (m_Controls.propertyListComboBox->count() > 1) + if (m_Controls.m_RendererCB->count() > 0) { - m_Controls.propertyListComboBox->clear(); - m_Controls.propertyListComboBox->addItem("common"); + m_Controls.m_RendererCB->clear(); } m_Controls.m_OverlayList->clear(); } diff --git a/Plugins/org.mitk.gui.qt.overlaymanager/src/internal/QmitkOverlayManagerView.h b/Plugins/org.mitk.gui.qt.overlaymanager/src/internal/QmitkOverlayManagerView.h index 750c642845..46cc49b709 100644 --- a/Plugins/org.mitk.gui.qt.overlaymanager/src/internal/QmitkOverlayManagerView.h +++ b/Plugins/org.mitk.gui.qt.overlaymanager/src/internal/QmitkOverlayManagerView.h @@ -1,126 +1,125 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ - #ifndef QmitkOverlayManagerView_h #define QmitkOverlayManagerView_h #include +#include "mitkAnnotation.h" +#include "mitkILifecycleAwarePart.h" +#include "ui_QmitkOverlayManagerViewControls.h" #include #include -#include "ui_QmitkOverlayManagerViewControls.h" -#include "mitkOverlay.h" -#include "mitkILifecycleAwarePart.h" class QmitkPropertyItemDelegate; class QmitkPropertyItemModel; class QSortFilterProxyModel; namespace mitk { -class IPropertyAliases; -class IPropertyDescriptions; -class IPropertyPersistence; + class IPropertyAliases; + class IPropertyDescriptions; + class IPropertyPersistence; } /** - \brief QmitkOverlayManagerView allows to view all overlays added to the mitk::OverlayManager. Properties of these overlays + \brief QmitkOverlayManagerView allows to view all overlays added to the mitk::OverlayManager. Properties of these + overlays can be modified. \sa QmitkAbstractView \ingroup ${plugin_target}_internal */ -class QmitkOverlayManagerView : public QmitkAbstractView, public mitk::IRenderWindowPartListener, - public mitk::ILifecycleAwarePart +class QmitkOverlayManagerView : public QmitkAbstractView, + public mitk::IRenderWindowPartListener, + public mitk::ILifecycleAwarePart { // this is needed for all Qt objects that should have a Qt meta-object // (everything that derives from QObject and wants to have signal/slots) Q_OBJECT public: - + typedef std::map OverlayMapType; static const std::string VIEW_ID; QmitkOverlayManagerView(); ~QmitkOverlayManagerView(); protected: - virtual void CreateQtPartControl(QWidget *parent) override; virtual void SetFocus() override; - void RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart) override; - void RenderWindowPartDeactivated(mitk::IRenderWindowPart*) override; + void RenderWindowPartActivated(mitk::IRenderWindowPart *renderWindowPart) override; + void RenderWindowPartDeactivated(mitk::IRenderWindowPart *) override; Ui::QmitkOverlayManagerViewControls m_Controls; + void OnFocusChanged(itk::Object *, const itk::EventObject &event); private slots: - void OnCurrentRowChanged(const QModelIndex& current, const QModelIndex& previous); + void OnCurrentRowChanged(const QModelIndex ¤t, const QModelIndex &previous); void OnPropertyListChanged(int index); void OnAddNewProperty(); void OnActivateOverlayList(); - void OnOverlaySelectionChanged(QListWidgetItem* current,QListWidgetItem*); + void OnOverlaySelectionChanged(QListWidgetItem *current, QListWidgetItem *); void OnDelete(); void OnAddOverlay(); private: + mitk::Annotation::Pointer CreateTextOverlay2D(); + mitk::Annotation::Pointer CreateTextOverlay3D(); + mitk::Annotation::Pointer CreateLabelOverlay(); + mitk::Annotation::Pointer CreateColorBarOverlay(); + mitk::Annotation::Pointer CreateScaleLegendOverlay(); + mitk::Annotation::Pointer CreateLogoOverlay(); - void OnAddTextOverlay2D(); - void OnAddTextOverlay3D(); - void OnAddLabelOverlay(); - void OnAddColorBarOverlay(); - void OnAddScaleLegendOverlay(); - void OnAddLogoOverlay(); - - QString GetPropertyNameOrAlias(const QModelIndex& index); - void OnPropertyNameChanged(const itk::EventObject& event); - void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList& nodes) override; + QString GetPropertyNameOrAlias(const QModelIndex &index); + void OnPropertyNameChanged(const itk::EventObject &event); + void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList &nodes) override; - void InitializeAddAnimationMenu(); - - void OnOverlayAdded(itk::Object */*caller*/, const itk::EventObject &event); + void InitializeAddOverlayMenu(); /** \see berry::IPartListener::PartActivated */ virtual void Activated(); /** \see berry::IPartListener::PartDeactivated */ virtual void Deactivated(); /** \see berry::IPartListener::PartVisible */ virtual void Visible(); /** \see berry::IPartListener::PartHidden */ virtual void Hidden(); - QWidget* m_Parent; + QWidget *m_Parent; unsigned long m_PropertyNameChangedTag; unsigned long m_OverlayManagerObserverTag; std::string m_SelectionClassName; - mitk::IPropertyAliases* m_PropertyAliases; - mitk::IPropertyDescriptions* m_PropertyDescriptions; - mitk::IPropertyPersistence* m_PropertyPersistence; - QSortFilterProxyModel* m_ProxyModel; - QmitkPropertyItemModel* m_Model; - QmitkPropertyItemDelegate* m_Delegate; - mitk::Overlay::Pointer m_SelectedOverlay; - mitk::BaseRenderer* m_Renderer; - QMenu* m_AddOverlayMenu; - + mitk::IPropertyAliases *m_PropertyAliases; + mitk::IPropertyDescriptions *m_PropertyDescriptions; + mitk::IPropertyPersistence *m_PropertyPersistence; + QSortFilterProxyModel *m_ProxyModel; + QmitkPropertyItemModel *m_Model; + QmitkPropertyItemDelegate *m_Delegate; + mitk::Annotation::Pointer m_SelectedOverlay; + mitk::BaseRenderer *m_Renderer; + QMenu *m_AddOverlayMenu; + unsigned long m_RenderWindowFocusObserverTag; + OverlayMapType m_OverlayMap; }; #endif // QmitkOverlayManagerView_h diff --git a/Plugins/org.mitk.gui.qt.overlaymanager/src/internal/QmitkOverlayManagerViewControls.ui b/Plugins/org.mitk.gui.qt.overlaymanager/src/internal/QmitkOverlayManagerViewControls.ui index 5efda60d48..1eafdd314f 100644 --- a/Plugins/org.mitk.gui.qt.overlaymanager/src/internal/QmitkOverlayManagerViewControls.ui +++ b/Plugins/org.mitk.gui.qt.overlaymanager/src/internal/QmitkOverlayManagerViewControls.ui @@ -1,173 +1,136 @@ QmitkOverlayManagerViewControls 0 0 304 563 0 0 QmitkTemplate 0 Overlays - - - - 0 - 0 - - - - - 0 - 40 - - - - QAbstractItemView::AnyKeyPressed|QAbstractItemView::DoubleClicked|QAbstractItemView::EditKeyPressed - - - - - + 0 + + + ... :/org_mitk_icons/icons/tango/scalable/actions/list-add.svg:/org_mitk_icons/icons/tango/scalable/actions/list-add.svg ... :/org_mitk_icons/icons/tango/scalable/actions/list-remove.svg:/org_mitk_icons/icons/tango/scalable/actions/list-remove.svg - - - - Qt::Horizontal - - - - 40 - 20 - - - - - + + + + 0 + 0 + + + + + 0 + 40 + + + + QAbstractItemView::AnyKeyPressed|QAbstractItemView::DoubleClicked|QAbstractItemView::EditKeyPressed + + + + + 0 - - - - 0 - 0 - - + - Property List - - - - - - - - 0 - 0 - + New - - - Add new property - - - - - - - :/Properties/new.png:/Properties/new.png + + + Qt::Horizontal - + - 16 - 16 + 40 + 20 - - false - - + 0 0 -