SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
+IF(MSVC)
+ SET( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj" )
+ SET( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /bigobj" )
+ENDIF(MSVC)
+
#=========================================================
INCLUDE(${CLITK_SOURCE_DIR}/cmake/common.cmake)
INCLUDE(${CLITK_SOURCE_DIR}/cmake/dependencies.cmake)
MESSAGE(STATUS "Looking for Root...")
-SET(ROOT_CONFIG_SEARCHPATH
- ${SIMPATH}/tools/root/bin
- $ENV{ROOTSYS}/bin
-)
-
SET(ROOT_DEFINITIONS "")
SET(ROOT_INSTALLED_VERSION_TOO_OLD FALSE)
SET(ROOT_CONFIG_EXECUTABLE ROOT_CONFIG_EXECUTABLE-NOTFOUND)
-FIND_PROGRAM(ROOT_CONFIG_EXECUTABLE NAMES root-config PATHS
- ${ROOT_CONFIG_SEARCHPATH}
- NO_SYSTEM_ENVIRONMENT_PATH)
+FIND_PROGRAM(ROOT_CONFIG_EXECUTABLE NAMES root-config PATHS)
IF (${ROOT_CONFIG_EXECUTABLE} MATCHES "ROOT_CONFIG_EXECUTABLE-NOTFOUND")
MESSAGE( FATAL_ERROR "ROOT not installed in the searchpath and ROOTSYS is not set. Please
set ROOTSYS or add the path to your ROOT installation in the Macro FindROOT.cmake in the
subdirectory cmake/modules.")
ELSE (${ROOT_CONFIG_EXECUTABLE} MATCHES "ROOT_CONFIG_EXECUTABLE-NOTFOUND")
+ MESSAGE(STATUS "root-config found")
STRING(REGEX REPLACE "(^.*)/bin/root-config" "\\1" test ${ROOT_CONFIG_EXECUTABLE})
SET( ENV{ROOTSYS} ${test})
set( ROOTSYS ${test})
ENDIF (ROOT_CONFIG_EXECUTABLE)
+#MESSAGE("root found = "${ROOT_FOUND})
IF (ROOT_FOUND)
ENDIF (ROOT_FOUND)
+#MESSAGE("icici")
###########################################
#
ARGS -f ${OUTFILE} -c -DHAVE_CONFIG_H ${INCLUDE_DIRS} ${INFILES} ${LINKDEF_FILE} DEPENDS ${INFILES})
ENDMACRO (ROOT_GENERATE_DICTIONARY)
+
+#MESSAGE("la")
+++ /dev/null
-# - Find ROOT instalation
-# This module tries to find the ROOT installation on your system.
-# It tries to find the root-config script which gives you all the needed information.
-# If the system variable ROOTSYS is set this is straight forward.
-# If not the module uses the pathes given in ROOT_CONFIG_SEARCHPATH.
-# If you need an other path you should add this path to this varaible.
-# The root-config script is then used to detect basically everything else.
-# This module defines a number of key variables and macros.
-
-
-MESSAGE("Looking for Root...")
-MESSAGE(STATUS "Looking for Root...")
-
-SET(ROOT_CONFIG_SEARCHPATH
- ${SIMPATH}/tools/root/bin
- $ENV{ROOTSYS}/bin
-)
-
-SET(ROOT_DEFINITIONS "")
-
-SET(ROOT_INSTALLED_VERSION_TOO_OLD FALSE)
-
-SET(ROOT_CONFIG_EXECUTABLE ROOT_CONFIG_EXECUTABLE-NOTFOUND)
-
-FIND_PROGRAM(ROOT_CONFIG_EXECUTABLE NAMES root-config PATHS
- ${ROOT_CONFIG_SEARCHPATH}
- NO_SYSTEM_ENVIRONMENT_PATH)
-
-IF (${ROOT_CONFIG_EXECUTABLE} MATCHES "ROOT_CONFIG_EXECUTABLE-NOTFOUND")
- MESSAGE( FATAL_ERROR "ROOT not installed in the searchpath and ROOTSYS is not set. Please
- set ROOTSYS or add the path to your ROOT installation in the Macro FindROOT.cmake in the
- subdirectory cmake/modules.")
-ELSE (${ROOT_CONFIG_EXECUTABLE} MATCHES "ROOT_CONFIG_EXECUTABLE-NOTFOUND")
- MESSAGE("root-config found")
- STRING(REGEX REPLACE "(^.*)/bin/root-config" "\\1" test ${ROOT_CONFIG_EXECUTABLE})
- SET( ENV{ROOTSYS} ${test})
- set( ROOTSYS ${test})
-ENDIF (${ROOT_CONFIG_EXECUTABLE} MATCHES "ROOT_CONFIG_EXECUTABLE-NOTFOUND")
-
-
-IF (ROOT_CONFIG_EXECUTABLE)
-
- SET(ROOT_FOUND FALSE)
-
- EXEC_PROGRAM(${ROOT_CONFIG_EXECUTABLE} ARGS "--version" OUTPUT_VARIABLE ROOTVERSION)
-
- MESSAGE(STATUS "Looking for Root... - found $ENV{ROOTSYS}/bin/root")
- MESSAGE(STATUS "Looking for Root... - version ${ROOTVERSION} ")
-
- MESSAGE( "Looking for Root... - found $ENV{ROOTSYS}/bin/root")
- MESSAGE( "Looking for Root... - version ${ROOTVERSION} ")
-
- # we need at least version 5.00/00
- IF (NOT ROOT_MIN_VERSION)
- SET(ROOT_MIN_VERSION "5.00/00")
- ENDIF (NOT ROOT_MIN_VERSION)
-
- # now parse the parts of the user given version string into variables
- STRING(REGEX REPLACE "^([0-9]+)\\.[0-9][0-9]+\\/[0-9][0-9]+" "\\1" req_root_major_vers "${ROOT_MIN_VERSION}")
- STRING(REGEX REPLACE "^[0-9]+\\.([0-9][0-9])+\\/[0-9][0-9]+.*" "\\1" req_root_minor_vers "${ROOT_MIN_VERSION}")
- STRING(REGEX REPLACE "^[0-9]+\\.[0-9][0-9]+\\/([0-9][0-9]+)" "\\1" req_root_patch_vers "${ROOT_MIN_VERSION}")
-
- # and now the version string given by qmake
- STRING(REGEX REPLACE "^([0-9]+)\\.[0-9][0-9]+\\/[0-9][0-9]+.*" "\\1" found_root_major_vers "${ROOTVERSION}")
- STRING(REGEX REPLACE "^[0-9]+\\.([0-9][0-9])+\\/[0-9][0-9]+.*" "\\1" found_root_minor_vers "${ROOTVERSION}")
- STRING(REGEX REPLACE "^[0-9]+\\.[0-9][0-9]+\\/([0-9][0-9]+).*" "\\1" found_root_patch_vers "${ROOTVERSION}")
-
- IF (found_root_major_vers LESS 5)
- MESSAGE( FATAL_ERROR "Invalid ROOT version \"${ROOTERSION}\", at least major version 4 is required, e.g. \"5.00/00\"")
- ENDIF (found_root_major_vers LESS 5)
-
- # compute an overall version number which can be compared at once
- MATH(EXPR req_vers "${req_root_major_vers}*10000 + ${req_root_minor_vers}*100 + ${req_root_patch_vers}")
- MATH(EXPR found_vers "${found_root_major_vers}*10000 + ${found_root_minor_vers}*100 + ${found_root_patch_vers}")
-
- IF (found_vers LESS req_vers)
- SET(ROOT_FOUND FALSE)
- SET(ROOT_INSTALLED_VERSION_TOO_OLD TRUE)
- ELSE (found_vers LESS req_vers)
- SET(ROOT_FOUND TRUE)
- ENDIF (found_vers LESS req_vers)
-
-ENDIF (ROOT_CONFIG_EXECUTABLE)
-
-#MESSAGE("root found = "${ROOT_FOUND})
-
-IF (ROOT_FOUND)
-
- # ask root-config for the library dir
- # Set ROOT_LIBRARY_DIR
-
- EXEC_PROGRAM( ${ROOT_CONFIG_EXECUTABLE}
- ARGS "--libdir"
- OUTPUT_VARIABLE ROOT_LIBRARY_DIR_TMP )
-
- IF(EXISTS "${ROOT_LIBRARY_DIR_TMP}")
- SET(ROOT_LIBRARY_DIR ${ROOT_LIBRARY_DIR_TMP} )
- ELSE(EXISTS "${ROOT_LIBRARY_DIR_TMP}")
- MESSAGE("Warning: ROOT_CONFIG_EXECUTABLE reported ${ROOT_LIBRARY_DIR_TMP} as library path,")
- MESSAGE("Warning: but ${ROOT_LIBRARY_DIR_TMP} does NOT exist, ROOT must NOT be installed correctly.")
- ENDIF(EXISTS "${ROOT_LIBRARY_DIR_TMP}")
-
- # ask root-config for the binary dir
- EXEC_PROGRAM(${ROOT_CONFIG_EXECUTABLE}
- ARGS "--bindir"
- OUTPUT_VARIABLE root_bins )
- SET(ROOT_BINARY_DIR ${root_bins})
-
- # ask root-config for the include dir
- EXEC_PROGRAM( ${ROOT_CONFIG_EXECUTABLE}
- ARGS "--incdir"
- OUTPUT_VARIABLE root_headers )
- SET(ROOT_INCLUDE_DIR ${root_headers})
- # CACHE INTERNAL "")
-
- # ask root-config for the library varaibles
- EXEC_PROGRAM( ${ROOT_CONFIG_EXECUTABLE}
-# ARGS "--noldflags --noauxlibs --libs"
- ARGS "--glibs"
- OUTPUT_VARIABLE root_flags )
-
-# STRING(REGEX MATCHALL "([^ ])+" root_libs_all ${root_flags})
-# STRING(REGEX MATCHALL "-L([^ ])+" root_library ${root_flags})
-# REMOVE_FROM_LIST(root_flags "${root_libs_all}" "${root_library}")
-
- SET(ROOT_LIBRARIES ${root_flags})
-
- # Make variables changeble to the advanced user
- MARK_AS_ADVANCED( ROOT_LIBRARY_DIR ROOT_INCLUDE_DIR ROOT_DEFINITIONS)
-
- # Set ROOT_INCLUDES
- SET( ROOT_INCLUDES ${ROOT_INCLUDE_DIR})
-
- SET(LD_LIBRARY_PATH ${LD_LIBRARY_PATH} ${ROOT_LIBRARY_DIR})
-
- #######################################
- #
- # Check the executables of ROOT
- # ( rootcint )
- #
- #######################################
-
- FIND_PROGRAM(ROOT_CINT_EXECUTABLE
- NAMES rootcint
- PATHS ${ROOT_BINARY_DIR}
- NO_DEFAULT_PATH
- )
-
-ENDIF (ROOT_FOUND)
-
-
-#MESSAGE("icici")
-
- ###########################################
- #
- # Macros for building ROOT dictionary
- #
- ###########################################
-
-MACRO (ROOT_GENERATE_DICTIONARY_OLD )
-
- set(INFILES "")
-
- foreach (_current_FILE ${ARGN})
-
- IF (${_current_FILE} MATCHES "^.*\\.h$")
- IF (${_current_FILE} MATCHES "^.*Link.*$")
- set(LINKDEF_FILE ${_current_FILE})
- ELSE (${_current_FILE} MATCHES "^.*Link.*$")
- set(INFILES ${INFILES} ${_current_FILE})
- ENDIF (${_current_FILE} MATCHES "^.*Link.*$")
- ELSE (${_current_FILE} MATCHES "^.*\\.h$")
- IF (${_current_FILE} MATCHES "^.*\\.cxx$")
- set(OUTFILE ${_current_FILE})
- ELSE (${_current_FILE} MATCHES "^.*\\.cxx$")
- set(INCLUDE_DIRS ${INCLUDE_DIRS} -I${_current_FILE})
- ENDIF (${_current_FILE} MATCHES "^.*\\.cxx$")
- ENDIF (${_current_FILE} MATCHES "^.*\\.h$")
-
- endforeach (_current_FILE ${ARGN})
-
-# MESSAGE("INFILES: ${INFILES}")
-# MESSAGE("OutFILE: ${OUTFILE}")
-# MESSAGE("LINKDEF_FILE: ${LINKDEF_FILE}")
-# MESSAGE("INCLUDE_DIRS: ${INCLUDE_DIRS}")
-
- STRING(REGEX REPLACE "(^.*).cxx" "\\1.h" bla "${OUTFILE}")
-# MESSAGE("BLA: ${bla}")
- SET (OUTFILES ${OUTFILE} ${bla})
-
- ADD_CUSTOM_COMMAND(OUTPUT ${OUTFILES}
- COMMAND ${ROOT_CINT_EXECUTABLE}
- ARGS -f ${OUTFILE} -c -DHAVE_CONFIG_H ${INCLUDE_DIRS} ${INFILES} ${LINKDEF_FILE} DEPENDS ${INFILES})
-
-# MESSAGE("ROOT_CINT_EXECUTABLE has created the dictionary ${OUTFILE}")
-
-ENDMACRO (ROOT_GENERATE_DICTIONARY_OLD)
-
- ###########################################
- #
- # Macros for building ROOT dictionary
- #
- ###########################################
-
-MACRO (ROOT_GENERATE_DICTIONARY INFILES LINKDEF_FILE OUTFILE INCLUDE_DIRS_IN)
-
- set(INCLUDE_DIRS)
-
- foreach (_current_FILE ${INCLUDE_DIRS_IN})
- set(INCLUDE_DIRS ${INCLUDE_DIRS} -I${_current_FILE})
- endforeach (_current_FILE ${INCLUDE_DIRS_IN})
-
-
-# MESSAGE("INFILES: ${INFILES}")
-# MESSAGE("OutFILE: ${OUTFILE}")
-# MESSAGE("LINKDEF_FILE: ${LINKDEF_FILE}")
-# MESSAGE("INCLUDE_DIRS: ${INCLUDE_DIRS}")
-
- STRING(REGEX REPLACE "^(.*)\\.(.*)$" "\\1.h" bla "${OUTFILE}")
-# MESSAGE("BLA: ${bla}")
- SET (OUTFILES ${OUTFILE} ${bla})
-
- ADD_CUSTOM_COMMAND(OUTPUT ${OUTFILES}
- COMMAND ${ROOT_CINT_EXECUTABLE}
- ARGS -f ${OUTFILE} -c -DHAVE_CONFIG_H ${INCLUDE_DIRS} ${INFILES} ${LINKDEF_FILE} DEPENDS ${INFILES})
-
-ENDMACRO (ROOT_GENERATE_DICTIONARY)
-
-#MESSAGE("la")
\ No newline at end of file
+++ /dev/null
-# - Find ROOT instalation # This module tries to find the ROOT installation on your system.
-# It tries to find the root-config script which gives you all the needed information.
-# If the system variable ROOTSYS is set this is straight forward.
-# If not the module uses the pathes given in ROOT_CONFIG_SEARCHPATH.
-# If you need an other path you should add this path to this varaible.
-# The root-config script is then used to detect basically everything else.
-# This module defines a number of key variables and macros.
-
-
-MESSAGE(STATUS "Looking for Root...")
-
-SET(ROOT_CONFIG_SEARCHPATH
- $ENV{ROOTSYS}/bin
- )
-
-SET(ROOT_DEFINITIONS "")
-
-SET(ROOT_INSTALLED_VERSION_TOO_OLD FALSE)
-
-SET(ROOT_CONFIG_EXECUTABLE ROOT_CONFIG_EXECUTABLE-NOTFOUND)
-
-FIND_PROGRAM(ROOT_CONFIG_EXECUTABLE NAMES root-config PATHS
- ${ROOT_CONFIG_SEARCHPATH}
- NO_SYSTEM_ENVIRONMENT_PATH)
-
-FIND_FILE( RVERSION_H NAMES RVersion.h PATHS $ENV{ROOTSYS}/include )
-
-IF ( RVERSION_H )
- FILE( READ ${RVERSION_H} RVERS_CONTENT )
- STRING( REGEX MATCH "#define ROOT_RELEASE \"[^\n]+\"\n" _line "${RVERS_CONTENT}" )
- STRING( REGEX REPLACE "#define ROOT_RELEASE \"([^\n]+)\"\n" "\\1" _match "${_line}")
- IF(_match)
- SET( ROOTVERSION ${_match})
- ENDIF(_match)
-ENDIF( RVERSION_H )
-
-
-IF (ROOTVERSION)
-
- SET(ROOT_FOUND FALSE)
-
- MESSAGE(STATUS "Looking for Root... - found $ENV{ROOTSYS}/bin/root")
- MESSAGE(STATUS "Looking for Root... - version ${ROOTVERSION} ")
-
- # we need at least version 5.00/00
- IF (NOT ROOT_MIN_VERSION)
- SET(ROOT_MIN_VERSION "5.00/00")
- ENDIF (NOT ROOT_MIN_VERSION)
-
- # now parse the parts of the user given version string into variables
- STRING(REGEX REPLACE "^([0-9]+)\\.[0-9][0-9]+\\/[0-9][0-9]+" "\\1" req_root_major_vers "${ROOT_MIN_VERSION}")
- STRING(REGEX REPLACE "^[0-9]+\\.([0-9][0-9])+\\/[0-9][0-9]+.*" "\\1" req_root_minor_vers "${ROOT_MIN_VERSION}")
- STRING(REGEX REPLACE "^[0-9]+\\.[0-9][0-9]+\\/([0-9][0-9]+)" "\\1" req_root_patch_vers "${ROOT_MIN_VERSION}")
-
- # and now the version string given by qmake
- STRING(REGEX REPLACE "^([0-9]+)\\.[0-9][0-9]+\\/[0-9][0-9]+.*" "\\1" found_root_major_vers "${ROOTVERSION}")
- STRING(REGEX REPLACE "^[0-9]+\\.([0-9][0-9])+\\/[0-9][0-9]+.*" "\\1" found_root_minor_vers "${ROOTVERSION}")
- STRING(REGEX REPLACE "^[0-9]+\\.[0-9][0-9]+\\/([0-9][0-9]+).*" "\\1" found_root_patch_vers "${ROOTVERSION}")
-
- IF (found_root_major_vers LESS 5)
- MESSAGE( FATAL_ERROR "Invalid ROOT version \"${ROOTERSION}\", at least major version 4 is required, e.g. \"5.00/00\"")
- ENDIF (found_root_major_vers LESS 5)
-
- # compute an overall version number which can be compared at once
- MATH(EXPR req_vers "${req_root_major_vers}*10000 + ${req_root_minor_vers}*100 + ${req_root_patch_vers}")
- MATH(EXPR found_vers "${found_root_major_vers}*10000 + ${found_root_minor_vers}*100 + ${found_root_patch_vers}")
-
- IF (found_vers LESS req_vers)
- SET(ROOT_FOUND FALSE)
- SET(ROOT_INSTALLED_VERSION_TOO_OLD TRUE)
- ELSE (found_vers LESS req_vers)
- SET(ROOT_FOUND TRUE)
- ENDIF (found_vers LESS req_vers)
-
-ENDIF (ROOTVERSION)
-
-
-IF (ROOT_FOUND)
-
- # ask root-config for the library dir
- # Set ROOT_LIBRARY_DIR
- IF( WIN32 )
- SET( ROOT_LIBRARY_DIR $ENV{ROOTSYS}/lib )
- SET( ROOT_INCLUDE_DIR $ENV{ROOTSYS}/include )
- SET( ROOT_BINARY_DIR $ENV{ROOTSYS}/bin )
-
- ELSE( WIN32 )
-
- EXEC_PROGRAM( ${ROOT_CONFIG_EXECUTABLE}
- ARGS "--libdir"
- OUTPUT_VARIABLE ROOT_LIBRARY_DIR_TMP )
-
- IF(EXISTS "${ROOT_LIBRARY_DIR_TMP}")
- SET(ROOT_LIBRARY_DIR ${ROOT_LIBRARY_DIR_TMP} )
- ELSE(EXISTS "${ROOT_LIBRARY_DIR_TMP}")
- MESSAGE("Warning: ROOT_CONFIG_EXECUTABLE reported ${ROOT_LIBRARY_DIR_TMP} as library path,")
- MESSAGE("Warning: but ${ROOT_LIBRARY_DIR_TMP} does NOT exist, ROOT must NOT be installed correctly.")
- ENDIF(EXISTS "${ROOT_LIBRARY_DIR_TMP}")
-
- # ask root-config for the binary dir
- EXEC_PROGRAM(${ROOT_CONFIG_EXECUTABLE}
- ARGS "--bindir"
- OUTPUT_VARIABLE root_bins )
- SET(ROOT_BINARY_DIR ${root_bins})
-
- # ask root-config for the include dir
- EXEC_PROGRAM( ${ROOT_CONFIG_EXECUTABLE}
- ARGS "--incdir"
- OUTPUT_VARIABLE root_headers )
- SET(ROOT_INCLUDE_DIR ${root_headers})
- # CACHE INTERNAL "")
-
- # ask root-config for the library varaibles
- EXEC_PROGRAM( ${ROOT_CONFIG_EXECUTABLE}
- ARGS "--noldflags --noauxlibs --libs"
- OUTPUT_VARIABLE root_flags )
-
- # STRING(REGEX MATCHALL "([^ ])+" root_libs_all ${root_flags})
- # STRING(REGEX MATCHALL "-L([^ ])+" root_library ${root_flags})
- # REMOVE_FROM_LIST(root_flags "${root_libs_all}" "${root_library}")
-
- SET(ROOT_LIBRARIES ${root_flags})
-
- ENDIF( WIN32 )
-
- # Make variables changeble to the advanced user
- MARK_AS_ADVANCED( ROOT_LIBRARY_DIR ROOT_INCLUDE_DIR ROOT_DEFINITIONS)
-
- # Set ROOT_INCLUDES
- SET( ROOT_INCLUDES ${ROOT_INCLUDE_DIR})
-
- SET(LD_LIBRARY_PATH ${LD_LIBRARY_PATH} ${ROOT_LIBRARY_DIR})
-
- #######################################
- #
- # Check the executables of ROOT
- # ( rootcint )
- #
- #######################################
-
- FIND_PROGRAM(ROOT_CINT_EXECUTABLE
- NAMES rootcint
- PATHS ${ROOT_BINARY_DIR}
- NO_DEFAULT_PATH
- )
-
-ENDIF (ROOT_FOUND)
-
-
-
-###########################################
-#
-# Macros for building ROOT dictionary
-#
-###########################################
-
-MACRO (ROOT_GENERATE_DICTIONARY_OLD )
-
- set(INFILES "")
-
- foreach (_current_FILE ${ARGN})
-
- IF (${_current_FILE} MATCHES "^.*\\.h$")
- IF (${_current_FILE} MATCHES "^.*Link.*$")
- set(LINKDEF_FILE ${_current_FILE})
- ELSE (${_current_FILE} MATCHES "^.*Link.*$")
- set(INFILES ${INFILES} ${_current_FILE})
- ENDIF (${_current_FILE} MATCHES "^.*Link.*$")
- ELSE (${_current_FILE} MATCHES "^.*\\.h$")
- IF (${_current_FILE} MATCHES "^.*\\.cxx$")
- set(OUTFILE ${_current_FILE})
- ELSE (${_current_FILE} MATCHES "^.*\\.cxx$")
- set(INCLUDE_DIRS ${INCLUDE_DIRS} -I${_current_FILE})
- ENDIF (${_current_FILE} MATCHES "^.*\\.cxx$")
- ENDIF (${_current_FILE} MATCHES "^.*\\.h$")
-
- endforeach (_current_FILE ${ARGN})
-
- # MESSAGE("INFILES: ${INFILES}")
- # MESSAGE("OutFILE: ${OUTFILE}")
- # MESSAGE("LINKDEF_FILE: ${LINKDEF_FILE}")
- # MESSAGE("INCLUDE_DIRS: ${INCLUDE_DIRS}")
-
- STRING(REGEX REPLACE "(^.*).cxx" "\\1.h" bla "${OUTFILE}")
- # MESSAGE("BLA: ${bla}")
- SET (OUTFILES ${OUTFILE} ${bla})
-
- ADD_CUSTOM_COMMAND(OUTPUT ${OUTFILES}
- COMMAND ${ROOT_CINT_EXECUTABLE}
- ARGS -f ${OUTFILE} -c -DHAVE_CONFIG_H ${INCLUDE_DIRS} ${INFILES} ${LINKDEF_FILE} DEPENDS ${INFILES})
-
- # MESSAGE("ROOT_CINT_EXECUTABLE has created the dictionary ${OUTFILE}")
-
-ENDMACRO (ROOT_GENERATE_DICTIONARY_OLD)
-
-###########################################
-#
-# Macros for building ROOT dictionary
-#
-###########################################
-
-MACRO (ROOT_GENERATE_DICTIONARY INFILES LINKDEF_FILE OUTFILE INCLUDE_DIRS_IN)
-
- set(INCLUDE_DIRS)
-
- foreach (_current_FILE ${INCLUDE_DIRS_IN})
- set(INCLUDE_DIRS ${INCLUDE_DIRS} -I${_current_FILE})
- endforeach (_current_FILE ${INCLUDE_DIRS_IN})
-
-
- # MESSAGE("INFILES: ${INFILES}")
- # MESSAGE("OutFILE: ${OUTFILE}")
- # MESSAGE("LINKDEF_FILE: ${LINKDEF_FILE}")
- # MESSAGE("INCLUDE_DIRS: ${INCLUDE_DIRS}")
-
- STRING(REGEX REPLACE "^(.*)\\.(.*)$" "\\1.h" bla "${OUTFILE}")
- # MESSAGE("BLA: ${bla}")
- SET (OUTFILES ${OUTFILE} ${bla})
-
- ADD_CUSTOM_COMMAND(OUTPUT ${OUTFILES}
- COMMAND ${ROOT_CINT_EXECUTABLE}
- ARGS -f ${OUTFILE} -c -DHAVE_CONFIG_H ${INCLUDE_DIRS} ${INFILES} ${LINKDEF_FILE} DEPENDS ${INFILES})
-
-ENDMACRO (ROOT_GENERATE_DICTIONARY)
-
# include <sys/resource.h>
#elif defined(_WIN32)
# include <windows.h>
+# include <stdint.h>
#endif
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
+//--------------------------------------------------------------------
+clitk::DicomRT_ROI* clitk::DicomRT_StructureSet::GetROIFromROIName(const std::string& name)
+{
+ std::map<int, std::string>::iterator it = mMapOfROIName.begin();
+ int number = -1;
+ while (it != mMapOfROIName.end() && number == -1) {
+ if (it->second == name)
+ number = it->first;
+ else
+ it++;
+ }
+
+ if (number == -1) {
+ std::cerr << "No ROI name " << name << std::endl;
+ return NULL;
+ }
+
+ return mROIs[number];
+}
+//--------------------------------------------------------------------
+/*
+// RP: 08/02/2013
+// RegEx version shall be available when C++x11 supports it propely
+//
+//--------------------------------------------------------------------
+clitk::DicomRT_ROI* clitk::DicomRT_StructureSet::GetROIFromROINameRegEx(const std::string& regEx)
+{
+ std::map<int, std::string>::iterator it = mMapOfROIName.begin();
+ int number = -1;
+
+ while (it != mMapOfROIName.end() && number == -1) {
+ if (std::tr1::regex_match (it->second, std::tr1::regex(regEx)))
+ number = it->first;
+ else
+ it++;
+ }
+
+ if (number == -1) {
+ std::cerr << "No ROI name " << number << std::endl;
+ return NULL;
+ }
+
+ return mROIs[number];
+}
+//--------------------------------------------------------------------
+*/
+//--------------------------------------------------------------------
+clitk::DicomRT_ROI* clitk::DicomRT_StructureSet::GetROIFromROINameSubstr(const std::string& s)
+{
+ std::map<int, std::string>::iterator it = mMapOfROIName.begin();
+ int number = -1;
+
+ while (it != mMapOfROIName.end() && number == -1) {
+ if (it->second.find(s) != std::string::npos)
+ number = it->first;
+ else
+ it++;
+ }
+
+ if (number == -1) {
+ std::cerr << "No ROI name " << s << std::endl;
+ return NULL;
+ }
+
+ return mROIs[number];
+}
+//--------------------------------------------------------------------
+
+//--------------------------------------------------------------------
+clitk::DicomRT_StructureSet::ROIMapContainer *
+clitk::DicomRT_StructureSet::GetROIsFromROINameSubstr(const std::string& s)
+{
+ static ROIMapContainer rois;
+ rois.clear();
+
+ ROIMapContainer::iterator it = mROIs.begin();
+ int number = -1;
+
+ while (it != mROIs.end()) {
+ if (it->second->GetName().find(s) != std::string::npos) {
+ number = it->first;
+ rois[number] = it->second;
+ }
+ it++;
+ }
+
+ if (number == -1) {
+ std::cerr << "No ROI name " << s << std::endl;
+ return NULL;
+ }
+
+ return &rois;
+
+}
+//--------------------------------------------------------------------
//--------------------------------------------------------------------
void clitk::DicomRT_StructureSet::Print(std::ostream & os) const
typedef itk::SmartPointer<Self> Pointer;
itkNewMacro(Self);
- typedef std::map<int, clitk::DicomRT_ROI::Pointer>::iterator ROIIteratorType;
- typedef std::map<int, clitk::DicomRT_ROI::Pointer>::const_iterator ROIConstIteratorType;
+ typedef std::map<int, clitk::DicomRT_ROI::Pointer> ROIMapContainer;
+ typedef ROIMapContainer::iterator ROIIteratorType;
+ typedef ROIMapContainer::const_iterator ROIConstIteratorType;
void Print(std::ostream & os = std::cout) const;
void Read(const std::string & filename);
void Write(const std::string & filename);
clitk::DicomRT_ROI * GetROIFromROINumber(int n);
- std::map<int, clitk::DicomRT_ROI::Pointer> & GetROIs() { return mROIs; }
+ clitk::DicomRT_ROI* GetROIFromROIName(const std::string& name);
+ //clitk::DicomRT_ROI* GetROIFromROINameRegEx(const std::string& regEx);
+ clitk::DicomRT_ROI* GetROIFromROINameSubstr(const std::string& s);
+ ROIMapContainer * GetROIsFromROINameSubstr(const std::string& s);
+ ROIMapContainer & GetROIs() { return mROIs; }
const std::string & GetStudyID() const;
const std::string & GetStudyTime() const;
const std::string & GetStudyDate() const;
size_t nelements = 0;
nelements += fread ( (void *) hnd.sFileType, sizeof(char), 32, fp);
- nelements += fread ( (void *) &hnd.FileLength, sizeof(uint32_t), 1, fp);
+ nelements += fread ( (void *) &hnd.FileLength, sizeof(itk::uint32_t), 1, fp);
nelements += fread ( (void *) hnd.sChecksumSpec, sizeof(char), 4, fp);
- nelements += fread ( (void *) &hnd.nCheckSum, sizeof(uint32_t), 1, fp);
+ nelements += fread ( (void *) &hnd.nCheckSum, sizeof(itk::uint32_t), 1, fp);
nelements += fread ( (void *) hnd.sCreationDate, sizeof(char), 8, fp);
nelements += fread ( (void *) hnd.sCreationTime, sizeof(char), 8, fp);
nelements += fread ( (void *) hnd.sPatientID, sizeof(char), 16, fp);
- nelements += fread ( (void *) &hnd.nPatientSer, sizeof(uint32_t), 1, fp);
+ nelements += fread ( (void *) &hnd.nPatientSer, sizeof(itk::uint32_t), 1, fp);
nelements += fread ( (void *) hnd.sSeriesID, sizeof(char), 16, fp);
- nelements += fread ( (void *) &hnd.nSeriesSer, sizeof(uint32_t), 1, fp);
+ nelements += fread ( (void *) &hnd.nSeriesSer, sizeof(itk::uint32_t), 1, fp);
nelements += fread ( (void *) hnd.sSliceID, sizeof(char), 16, fp);
- nelements += fread ( (void *) &hnd.nSliceSer, sizeof(uint32_t), 1, fp);
- nelements += fread ( (void *) &hnd.SizeX, sizeof(uint32_t), 1, fp);
- nelements += fread ( (void *) &hnd.SizeY, sizeof(uint32_t), 1, fp);
+ nelements += fread ( (void *) &hnd.nSliceSer, sizeof(itk::uint32_t), 1, fp);
+ nelements += fread ( (void *) &hnd.SizeX, sizeof(itk::uint32_t), 1, fp);
+ nelements += fread ( (void *) &hnd.SizeY, sizeof(itk::uint32_t), 1, fp);
nelements += fread ( (void *) &hnd.dSliceZPos, sizeof(double), 1, fp);
nelements += fread ( (void *) hnd.sModality, sizeof(char), 16, fp);
- nelements += fread ( (void *) &hnd.nWindow, sizeof(uint32_t), 1, fp);
- nelements += fread ( (void *) &hnd.nLevel, sizeof(uint32_t), 1, fp);
- nelements += fread ( (void *) &hnd.nPixelOffset, sizeof(uint32_t), 1, fp);
+ nelements += fread ( (void *) &hnd.nWindow, sizeof(itk::uint32_t), 1, fp);
+ nelements += fread ( (void *) &hnd.nLevel, sizeof(itk::uint32_t), 1, fp);
+ nelements += fread ( (void *) &hnd.nPixelOffset, sizeof(itk::uint32_t), 1, fp);
nelements += fread ( (void *) hnd.sImageType, sizeof(char), 4, fp);
nelements += fread ( (void *) &hnd.dGantryRtn, sizeof(double), 1, fp);
nelements += fread ( (void *) &hnd.dSAD, sizeof(double), 1, fp);
nelements += fread ( (void *) &hnd.dGating4DInfoZ, sizeof(double), 1, fp);
nelements += fread ( (void *) &hnd.dGating4DInfoTime, sizeof(double), 1, fp);
- if(nelements != /*char*/120 + /*uint32_t*/10 + /*double*/41)
+ if(nelements != /*char*/120 + /*itk::uint32_t*/10 + /*double*/41)
itkGenericExceptionMacro(<< "Could not read header data in " << m_FileName);
if(fclose (fp) != 0)
{
FILE *fp;
- uint32_t* buf = (uint32_t*)buffer;
+ itk::uint32_t* buf = (itk::uint32_t*)buffer;
unsigned char *pt_lut;
- uint32_t a;
+ itk::uint32_t a;
unsigned char v;
int lut_idx, lut_off;
size_t num_read;
char dc;
short ds;
long dl, diff=0;
- uint32_t i;
+ itk::uint32_t i;
fp = fopen (m_FileName.c_str(), "rb");
if (fp == NULL)
/* Read first row */
for (i = 0; i < GetDimensions(0); i++) {
- if(1 != fread (&a, sizeof(uint32_t), 1, fp))
+ if(1 != fread (&a, sizeof(itk::uint32_t), 1, fp))
itkGenericExceptionMacro(<< "Could not read first row in: " << m_FileName);
buf[i] = a;
}
/* Read first pixel of second row */
- if(1 != fread (&a, sizeof(uint32_t), 1, fp))
+ if(1 != fread (&a, sizeof(itk::uint32_t), 1, fp))
itkGenericExceptionMacro(<< "Could not read first pixel of second row");
buf[i++] = a;
lut_idx = 0;
lut_off = 0;
while (i < GetDimensions(0) * GetDimensions(1) ) {
- uint32_t r11, r12, r21;
+ itk::uint32_t r11, r12, r21;
r11 = buf[i-GetDimensions(0)-1];
r12 = buf[i-GetDimensions(0)];
diff = ds;
break;
case 2:
- num_read = fread (&dl, sizeof(uint32_t), 1, fp);
+ num_read = fread (&dl, sizeof(itk::uint32_t), 1, fp);
if (num_read != 1) goto read_error;
diff = dl;
break;
switch(mDim) {
case 2:
UpdateWithDim<2>(mInputPixelType);
- break;;
+ break;
case 3:
UpdateWithDim<3>(mInputPixelType);
- break;;
+ break;
case 4:
UpdateWithDim<4>(mInputPixelType);
- break;;
+ break;
default:
std::cerr << "dimension unknown in Update ! " << std::endl;
}
}
// TODO SR and BP: check on the list of transforms and not the first only
- mImage->GetTransform()[0]->PostMultiply();
+ mImage->GetTransform()[0]->PreMultiply();
mImage->GetTransform()[0]->Concatenate(matrix);
mImage->GetTransform()[0]->Update();
+
+ //for image sequences, apply the transform to each images of the sequence
+ if (mImage->IsTimeSequence())
+ {
+ for (unsigned i = 1 ; i<mImage->GetTransform().size() ; i++)
+ {
+ mImage->GetTransform()[i]->PreMultiply();
+ mImage->GetTransform()[i]->Concatenate(matrix);
+ mImage->GetTransform()[i]->Update();
+ }
+ }
+
}
}
//------------------------------------------------------------------------------
component_filter[i]->Update();
coefficient_images[i] = component_filter[i]->GetOutput();
}
+
#if ITK_VERSION_MAJOR >= 4
- m_ITKTransform->SetCoefficientImages(coefficient_images);
+ // RP: 16/01/2013
+ // ATTENTION: Apparently, there's a bug in the SetCoefficientImages function of ITK 4.x
+ // I needed to use SetParametersByValue instead.
+ //
+ typename ITKTransformType::ParametersType params(input->GetPixelContainer()->Size() * BLUTCoefficientImageType::ImageDimension);
+ for (unsigned int i=0; i < BLUTCoefficientImageType::ImageDimension; i++) {
+ for (unsigned int j=0; j < coefficient_images[i]->GetPixelContainer()->Size(); j++)
+ params[input->GetPixelContainer()->Size() * i + j] = coefficient_images[i]->GetPixelContainer()->GetBufferPointer()[j];
+ }
+
+ m_ITKTransform->SetGridOrigin(input->GetOrigin());
+ m_ITKTransform->SetGridDirection(input->GetDirection());
+ m_ITKTransform->SetGridRegion(input->GetLargestPossibleRegion());
+ m_ITKTransform->SetGridSpacing(input->GetSpacing());
+ m_ITKTransform->SetParametersByValue(params);
#else
m_ITKTransform->SetCoefficientImage(coefficient_images);
#endif
WRAP_GGO(clitkImageArithm_GGO_C clitkImageArithm.ggo)
ADD_LIBRARY(clitkImageArithmImageLib clitkImageArithmGenericFilter.cxx ${clitkImageArithm_GGO_C})
+WRAP_GGO(clitkVectorArithm_GGO_C clitkVectorArithm.ggo)
+ADD_LIBRARY(clitkVectorArithmLib clitkVectorArithmGenericFilter.cxx ${clitkVectorArithm_GGO_C})
+
WRAP_GGO(clitkResampleImage_GGO_C clitkResampleImage.ggo)
ADD_LIBRARY(clitkResampleImageLib clitkResampleImageGenericFilter.cxx ${clitkResampleImage_GGO_C})
TARGET_LINK_LIBRARIES(clitkVFResample clitkCommon ${ITK_LIBRARIES})
SET(TOOLS_INSTALL ${TOOLS_INSTALL} clitkVFResample)
+ WRAP_GGO(clitkVFInterpolate_GGO_C clitkVFInterpolate.ggo)
+ ADD_EXECUTABLE(clitkVFInterpolate clitkVFInterpolate.cxx clitkVFInterpolateGenericFilter.cxx ${clitkVFInterpolate_GGO_C})
+ TARGET_LINK_LIBRARIES(clitkVFInterpolate clitkCommon ${ITK_LIBRARIES})
+ SET(TOOLS_INSTALL ${TOOLS_INSTALL} clitkVFInterpolate)
+
WRAP_GGO(clitkImageCreate_GGO_C clitkImageCreate.ggo)
ADD_EXECUTABLE(clitkImageCreate clitkImageCreate.cxx ${clitkImageCreate_GGO_C})
TARGET_LINK_LIBRARIES(clitkImageCreate clitkCommon ${ITK_LIBRARIES})
TARGET_LINK_LIBRARIES(clitkImageArithm clitkImageArithmImageLib clitkCommon ${ITK_LIBRARIES} )
SET(TOOLS_INSTALL ${TOOLS_INSTALL} clitkImageArithm)
+ ADD_EXECUTABLE(clitkVectorArithm clitkVectorArithm.cxx)
+ TARGET_LINK_LIBRARIES(clitkVectorArithm clitkVectorArithmLib clitkCommon ${ITK_LIBRARIES} )
+ SET(TOOLS_INSTALL ${TOOLS_INSTALL} clitkVectorArithm)
+
WRAP_GGO(clitkUnsharpMask_GGO_C clitkUnsharpMask.ggo)
ADD_EXECUTABLE(clitkUnsharpMask clitkUnsharpMask.cxx ${clitkUnsharpMask_GGO_C})
TARGET_LINK_LIBRARIES(clitkUnsharpMask clitkCommon ${ITK_LIBRARIES} )
IF(CLITK_EXPERIMENTAL)
WRAP_GGO(clitkBinaryImageToMesh_GGO_C clitkBinaryImageToMesh.ggo)
ADD_EXECUTABLE(clitkBinaryImageToMesh clitkBinaryImageToMesh.cxx ${clitkBinaryImageToMesh_GGO_C})
- TARGET_LINK_LIBRARIES(clitkBinaryImageToMesh itksys ${VTK_LIBRARIES})
+ TARGET_LINK_LIBRARIES(clitkBinaryImageToMesh itksys ${ITK_LIBRARIES} ${VTK_LIBRARIES})
SET(TOOLS_INSTALL ${TOOLS_INSTALL} clitkBinaryImageToMesh)
WRAP_GGO(clitkMeshToBinaryImage_GGO_C clitkMeshToBinaryImage.ggo)
WRAP_GGO(clitkMeshViewer_GGO_C clitkMeshViewer.ggo)
ADD_EXECUTABLE(clitkMeshViewer clitkMeshViewer.cxx ${clitkMeshViewer_GGO_C})
- TARGET_LINK_LIBRARIES(clitkMeshViewer ${VTK_LIBRARIES})
+ TARGET_LINK_LIBRARIES(clitkMeshViewer ${ITK_LIBRARIES} ${VTK_LIBRARIES})
SET(TOOLS_INSTALL ${TOOLS_INSTALL} clitkMeshViewer)
ENDIF(CLITK_EXPERIMENTAL)
#include <gdcmReader.h>
#endif
+#include <set>
+
//====================================================================
int main(int argc, char * argv[])
{
//===========================================
/// Get slices locations ...
- std::vector<double> theorigin(3);
- std::vector<double> sliceLocations;
+ int series_number = -1;
+ std::set<int> series_numbers;
+ std::map< int, std::vector<double> > theorigin;
+ std::map< int, std::vector<double> > sliceLocations;
+ std::map< int, std::vector<std::string> > seriesFiles;
for(unsigned int i=0; i<args_info.inputs_num; i++) {
//std::cout << "Reading <" << input_files[i] << std::endl;
#if GDCM_MAJOR_VERSION == 2
gdcm::Reader hreader;
hreader.SetFileName(input_files[i].c_str());
hreader.Read();
- theorigin = gdcm::ImageHelper::GetOriginValue(hreader.GetFile());
- sliceLocations.push_back(theorigin[2]);
- gdcm::Attribute<0x28, 0x100> pixel_size;
gdcm::DataSet& ds = hreader.GetFile().GetDataSet();
+
+ if (args_info.extract_series_flag) {
+ gdcm::Attribute<0x20,0x11> series_number_att;
+ series_number_att.SetFromDataSet(hreader.GetFile().GetDataSet());
+ series_number = series_number_att.GetValue();
+ }
+
+ series_numbers.insert(series_number);
+ theorigin[series_number] = gdcm::ImageHelper::GetOriginValue(hreader.GetFile());
+ sliceLocations[series_number].push_back(theorigin[series_number][2]);
+ seriesFiles[series_number].push_back(input_files[i]);
+
+ gdcm::Attribute<0x28, 0x100> pixel_size;
pixel_size.SetFromDataSet(ds);
if (pixel_size.GetValue() != 16)
{
header->SetFileName(input_files[i]);
header->SetMaxSizeLoadEntry(16384); // required ?
header->Load();
- theorigin[0] = header->GetXOrigin();
- theorigin[1] = header->GetYOrigin();
- theorigin[2] = header->GetZOrigin();
- sliceLocations.push_back(theorigin[2]);
+
+ if (args_info.extract_series_flag) {
+ series_number = atoi(header->GetEntryValue(0x20,0x11).c_str());
+ }
+
+ series_numbers.insert(series_number);
+ theorigin[series_number].resize(3);
+ theorigin[series_number][0] = header->GetXOrigin();
+ theorigin[series_number][1] = header->GetYOrigin();
+ theorigin[series_number][2] = header->GetZOrigin();
+ sliceLocations[series_number].push_back(theorigin[series_number][2]);
+ seriesFiles[series_number].push_back(input_files[i]);
if (header->GetPixelSize() != 2) {
std::cerr << "Pixel type 2 bytes ! " << std::endl;
std::cerr << "In file " << input_files[i] << std::endl;
//===========================================
// Sort slices locations ...
- std::vector<int> sliceIndex;
- clitk::GetSortedIndex(sliceLocations, sliceIndex);
- if (args_info.verboseSliceLocation_flag) {
- std::cout << sliceLocations[sliceIndex[0]] << " -> "
- << sliceIndex[0] << " / " << 0 << " => "
- << "0 mm "
- << input_files[sliceIndex[0]]
- << std::endl;
- for(unsigned int i=1; i<sliceIndex.size(); i++) {
- std::cout << sliceLocations[sliceIndex[i]] << " -> "
- << sliceIndex[i] << " / " << i << " => "
- << sliceLocations[sliceIndex[i]] - sliceLocations[sliceIndex[i-1]]
- << "mm "
- << input_files[sliceIndex[i]]
+ std::set<int>::iterator sn = series_numbers.begin();
+ while ( sn != series_numbers.end() ) {
+ std::vector<double> locs = sliceLocations[*sn];
+ std::vector<double> origin = theorigin[*sn];
+ std::vector<std::string> files = seriesFiles[*sn];
+ std::vector<int> sliceIndex;
+ clitk::GetSortedIndex(locs, sliceIndex);
+ if (args_info.verboseSliceLocation_flag) {
+ std::cout << locs[sliceIndex[0]] << " -> "
+ << sliceIndex[0] << " / " << 0 << " => "
+ << "0 mm "
+ << files[sliceIndex[0]]
<< std::endl;
- }
- }
-
- //===========================================
- // Analyze slices locations ...
- double currentDist;
- double dist=0;
- double tolerance = args_info.tolerance_arg;
- double previous = sliceLocations[sliceIndex[0]];
- for(unsigned int i=1; i<sliceIndex.size(); i++) {
- currentDist = sliceLocations[sliceIndex[i]]-previous;
- if (i!=1) {
- if (fabs(dist-currentDist) > tolerance) {
- std::cout << "ERROR : " << std::endl
- << "Current slice pos is = " << sliceLocations[sliceIndex[i]] << std::endl
- << "Previous slice pos is = " << previous << std::endl
- << "Current file is = " << input_files[sliceIndex[i]] << std::endl
- << "Current index is = " << i << std::endl
- << "Current sortindex is = " << sliceIndex[i] << std::endl
- << "Current slice diff = " << dist << std::endl
- << "Current error = " << fabs(dist-currentDist) << std::endl;
- exit(1);
+ for(unsigned int i=1; i<sliceIndex.size(); i++) {
+ std::cout << locs[sliceIndex[i]] << " -> "
+ << sliceIndex[i] << " / " << i << " => "
+ << locs[sliceIndex[i]] - locs[sliceIndex[i-1]]
+ << "mm "
+ << files[sliceIndex[i]]
+ << std::endl;
}
- } else dist = currentDist;
- previous = sliceLocations[sliceIndex[i]];
- }
+ }
- //===========================================
- // Create ordered vector of filenames
- std::vector<std::string> sorted_files;
- sorted_files.resize(sliceIndex.size());
- for(unsigned int i=0; i<sliceIndex.size(); i++)
- sorted_files[i] = input_files[ sliceIndex[i] ];
+ //===========================================
+ // Analyze slices locations ...
+ double currentDist;
+ double dist=0;
+ double tolerance = args_info.tolerance_arg;
+ double previous = locs[sliceIndex[0]];
+ for(unsigned int i=1; i<sliceIndex.size(); i++) {
+ currentDist = locs[sliceIndex[i]]-previous;
+ if (i!=1) {
+ if (fabs(dist-currentDist) > tolerance) {
+ std::cout << "ERROR : " << std::endl
+ << "Current slice pos is = " << locs[sliceIndex[i]] << std::endl
+ << "Previous slice pos is = " << previous << std::endl
+ << "Current file is = " << files[sliceIndex[i]] << std::endl
+ << "Current index is = " << i << std::endl
+ << "Current sortindex is = " << sliceIndex[i] << std::endl
+ << "Current slice diff = " << dist << std::endl
+ << "Current error = " << fabs(dist-currentDist) << std::endl;
+ exit(1);
+ }
+ } else dist = currentDist;
+ previous = locs[sliceIndex[i]];
+ }
- //===========================================
- // Read write serie
- vvImageReader::Pointer reader = vvImageReader::New();
- reader->SetInputFilenames(sorted_files);
- reader->Update(vvImageReader::DICOM);
- if (reader->GetLastError().size() != 0) {
- std::cerr << reader->GetLastError() << std::endl;
- return 1;
- }
-
- vvImage::Pointer image = reader->GetOutput();
- vtkImageData* vtk_image = image->GetFirstVTKImageData();
- vtkImageChangeInformation* modifier = vtkImageChangeInformation::New();
- if (args_info.focal_origin_given) {
- std::vector<double> spacing = image->GetSpacing();
- std::vector<int> size = image->GetSize();
- theorigin[0] = -spacing[0]*size[0]/2.0;
- theorigin[1] = -spacing[1]*size[1]/2.0;
- modifier->SetInput(vtk_image);
- modifier->SetOutputOrigin(theorigin[0], theorigin[1], sliceLocations[sliceIndex[0]]);
- modifier->Update();
- vvImage::Pointer focal_image = vvImage::New();
- focal_image->AddVtkImage(modifier->GetOutput());
- image = focal_image;
- }
+ //===========================================
+ // Create ordered vector of filenames
+ std::vector<std::string> sorted_files;
+ sorted_files.resize(sliceIndex.size());
+ for(unsigned int i=0; i<sliceIndex.size(); i++)
+ sorted_files[i] = files[ sliceIndex[i] ];
- vvImageWriter::Pointer writer = vvImageWriter::New();
- writer->SetInput(image);
- writer->SetOutputFileName(args_info.output_arg);
- writer->Update();
+ //===========================================
+ // Read write serie
+ vvImageReader::Pointer reader = vvImageReader::New();
+ reader->SetInputFilenames(sorted_files);
+ reader->Update(vvImageReader::DICOM);
+ if (reader->GetLastError().size() != 0) {
+ std::cerr << reader->GetLastError() << std::endl;
+ return 1;
+ }
+
+ vvImage::Pointer image = reader->GetOutput();
+ vtkImageData* vtk_image = image->GetFirstVTKImageData();
+ vtkImageChangeInformation* modifier = vtkImageChangeInformation::New();
+ if (args_info.focal_origin_given) {
+ std::vector<double> spacing = image->GetSpacing();
+ std::vector<int> size = image->GetSize();
+ origin[0] = -spacing[0]*size[0]/2.0;
+ origin[1] = -spacing[1]*size[1]/2.0;
+ modifier->SetInput(vtk_image);
+ modifier->SetOutputOrigin(origin[0], origin[1], locs[sliceIndex[0]]);
+ modifier->Update();
+ vvImage::Pointer focal_image = vvImage::New();
+ focal_image->AddVtkImage(modifier->GetOutput());
+ image = focal_image;
+ }
- modifier->Delete();
+ std::string outfile;
+ if (series_numbers.size() == 1)
+ outfile = args_info.output_arg;
+ else {
+ std::ostringstream name;
+ name << *sn << "_" << args_info.output_arg;
+ outfile = name.str();
+ }
+ vvImageWriter::Pointer writer = vvImageWriter::New();
+ writer->SetInput(image);
+ writer->SetOutputFileName(outfile);
+ writer->Update();
+ modifier->Delete();
+
+ sn++;
+ }
+
return 0;
}
option "output" o "Output image filename" string yes
option "std_input" - "Take the like of input file from stdin, to support huge lists of filenames" flag off
option "focal_origin" - "Output files with FOCAL-like origin, instead of the origin present in the dicom files" flag off
+option "extract_series" s "Identify different series in the file list and create the MHDs accordinly" flag off
clitk::DicomRTStruct2ImageFilter filter;
filter.SetCropMaskEnabled(args_info.crop_flag);
filter.SetImageFilename(args_info.image_arg); // Used to get spacing + origin
- if (args_info.roi_arg != -1) {
+ if (args_info.roiName_given) {
+ filter.SetROI(s->GetROIFromROIName(args_info.roiName_arg));
+ filter.SetOutputImageFilename(args_info.output_arg);
+ filter.Update();
+ }
+ else if (args_info.roi_given && args_info.roi_arg != -1) {
filter.SetROI(s->GetROIFromROINumber(args_info.roi_arg));
filter.SetOutputImageFilename(args_info.output_arg);
filter.Update();
}
else {
+ clitk::DicomRT_StructureSet::ROIMapContainer* rois;
+ if (args_info.roiNameSubstr_given)
+ rois = s->GetROIsFromROINameSubstr(args_info.roiNameSubstr_arg);
+ else
+ rois = &s->GetROIs();
+
clitk::DicomRT_StructureSet::ROIConstIteratorType iter;
- for(iter = s->GetROIs().begin(); iter != s->GetROIs().end(); iter++) {
- clitk::DicomRT_ROI::Pointer roi = iter->second;
- // Create the filter
- clitk::DicomRTStruct2ImageFilter filter;
- filter.SetCropMaskEnabled(args_info.crop_flag);
- filter.SetImageFilename(args_info.image_arg); // Used to get spacing + origin
- std::string name = roi->GetName();
- int num = roi->GetROINumber();
- filter.SetROI(roi);
- name.erase(remove_if(name.begin(), name.end(), isspace), name.end());
- std::string n = std::string(args_info.output_arg).append
- (clitk::toString(num)).append
- ("_").append
- (name).append
- (".mhd");
- if (args_info.verbose_flag) {
- std::cout << num << " " << roi->GetName() << " num=" << num << " : " << n << std::endl;
+ if (rois) {
+ for(iter = rois->begin(); iter != rois->end(); iter++) {
+ clitk::DicomRT_ROI::Pointer roi = iter->second;
+ clitk::DicomRTStruct2ImageFilter filter;
+ std::string name = roi->GetName();
+ int num = roi->GetROINumber();
+ filter.SetROI(roi);
+ filter.SetCropMaskEnabled(args_info.crop_flag);
+ filter.SetImageFilename(args_info.image_arg); // Used to get spacing + origin
+ name.erase(remove_if(name.begin(), name.end(), isspace), name.end());
+ std::string n = std::string(args_info.output_arg).append
+ (clitk::toString(num)).append
+ ("_").append
+ (name).append
+ (".mhd");
+ if (args_info.verbose_flag) {
+ std::cout << num << " " << roi->GetName() << " num=" << num << " : " << n << std::endl;
+ }
+ filter.SetOutputImageFilename(n);
+ filter.Update();
}
- filter.SetOutputImageFilename(n);
- filter.Update();
}
+ }
+// else {
+// clitk::DicomRT_StructureSet::ROIConstIteratorType iter;
+// for(iter = s->GetROIs().begin(); iter != s->GetROIs().end(); iter++) {
+// clitk::DicomRT_ROI::Pointer roi = iter->second;
+// // Create the filter
+// clitk::DicomRTStruct2ImageFilter filter;
+// filter.SetCropMaskEnabled(args_info.crop_flag);
+// filter.SetImageFilename(args_info.image_arg); // Used to get spacing + origin
+// std::string name = roi->GetName();
+// int num = roi->GetROINumber();
+// filter.SetROI(roi);
+// name.erase(remove_if(name.begin(), name.end(), isspace), name.end());
+// std::string n = std::string(args_info.output_arg).append
+// (clitk::toString(num)).append
+// ("_").append
+// (name).append
+// (".mhd");
+// if (args_info.verbose_flag) {
+// std::cout << num << " " << roi->GetName() << " num=" << num << " : " << n << std::endl;
+// }
+// filter.SetOutputImageFilename(n);
+// filter.Update();
+// }
/*
for(unsigned int i=0; i<s->GetListOfROI().size(); i++) {
filter.SetOutputImageFilename(n);
filter.Update();
}*/
- }
+ //}
// This is the end my friend
return 0;
option "verboseFile" - "Verbose file content" flag off
option "input" i "Input Dicom file" string yes
option "image" j "Used to read image info (spacing, origin)" string yes
-option "roi" r "ROI to binarize (if -1 = all roi)" int no default="-1"
option "output" o "Output image filename" string yes
+defgroup "ROIoption" groupdesc="an option of this group is required"
+groupoption "roi" r "ROI to binarize (if -1 = all roi)" int no default="-1" group="ROIoption"
+groupoption "roiName" n "ROI name to binarize (be wary of spaces in ROI names; if blank, use given 'roi' value)" string no default="" group="ROIoption"
+groupoption "roiNameSubstr" s "Substring of ROI name to binarize (reuturns all matches; if blank, use given 'roiName' value)" string no default="" group="ROIoption"
+
option "crop" c "Crop binary mask" flag off
#option "roi" r "ROI to print (ID)" int no
// template<>
// class ImageArithmGenericFilter<args_info_clitkImageArithm>;
-////////////////////////////////////////////////////////////////////
- // specializations for itk::Vector<float, 3u>, 3u
- template<>
- template<>
- void ImageArithmGenericFilter<args_info_clitkImageArithm>::UpdateWithInputImageType< itk::Image< itk::Vector<float, 3u>, 3u > >()
- {
- typedef itk::Image< itk::Vector<float, 3u>, 3u > ImageType;
-
- // Read input1
- ImageType::Pointer input1 = this->GetInput<ImageType>(0);
-
- // Set input image iterator
- typedef itk::ImageRegionIterator<ImageType> IteratorType;
- IteratorType it(input1, input1->GetLargestPossibleRegion());
-
- // typedef input2
- ImageType::Pointer input2 = NULL;
- IteratorType it2;
-
- /*
- // Special case for normalisation
- if (mTypeOfOperation == 12) {
- typedef itk::MinimumMaximumImageCalculator<ImageType> MinMaxFilterType;
- typename MinMaxFilterType::Pointer ff = MinMaxFilterType::New();
- ff->SetImage(input1);
- ff->ComputeMaximum();
- mScalar = ff->GetMaximum();
- mTypeOfOperation = 11; // divide
- }
- */
-
- if (mIsOperationUseASecondImage) {
- // Read input2
- input2 = this->GetInput<ImageType>(1);
- // Set input image iterator
- it2 = IteratorType(input2, input2->GetLargestPossibleRegion());
- // Check dimension
- if (!clitk::HaveSameSize<ImageType, ImageType>(input1, input2)) {
- itkExceptionMacro(<< "The images (input and input2) must have the same size");
- }
- if(!clitk::HaveSameSpacing<ImageType, ImageType>(input1, input2)) {
- itkWarningMacro(<< "The images (input and input2) do not have the same spacing. "
- << "Using first input's information.");
- }
- }
-
- /*
- // Check if overwrite and outputisfloat and pixeltype is not float -> do not overwrite
- if (mOverwriteInputImage && mOutputIsFloat && (typeid(typename ImageType::PixelType) != typeid(float))) {
- // std::cerr << "Warning. Could not use both mOverwriteInputImage and mOutputIsFloat, because input is "
- // << typeid(PixelType).name()
- // << std::endl;
- mOverwriteInputImage = false;
- }
- */
-
- // ---------------- Overwrite input Image ---------------------
- if (mOverwriteInputImage) {
- // Set output iterator (to input1)
- IteratorType ito = IteratorType(input1, input1->GetLargestPossibleRegion());
- if (mIsOperationUseASecondImage) ComputeImage(it, it2, ito);
- else ComputeImage(it, ito);
- this->SetNextOutput<ImageType>(input1);
- }
- // ---------------- Create new output Image ---------------------
- else {
- /*if (mOutputIsFloat) {
- // Create output image
- typedef itk::Image<float,ImageType::ImageDimension> OutputImageType;
- typename OutputImageType::Pointer output = OutputImageType::New();
- output->SetRegions(input1->GetLargestPossibleRegion());
- output->SetOrigin(input1->GetOrigin());
- output->SetSpacing(input1->GetSpacing());
- output->Allocate();
- // Set output iterator
- typedef itk::ImageRegionIterator<OutputImageType> IteratorOutputType;
- IteratorOutputType ito = IteratorOutputType(output, output->GetLargestPossibleRegion());
- if (mIsOperationUseASecondImage) ComputeImage(it, it2, ito);
- else ComputeImage(it, ito);
- this->template SetNextOutput<OutputImageType>(output);
- } else*/ {
- // Create output image
- typedef ImageType OutputImageType;
- OutputImageType::Pointer output = OutputImageType::New();
- output->SetRegions(input1->GetLargestPossibleRegion());
- output->SetOrigin(input1->GetOrigin());
- output->SetSpacing(input1->GetSpacing());
- output->Allocate();
- // Set output iterator
- typedef itk::ImageRegionIterator<OutputImageType> IteratorOutputType;
- IteratorOutputType ito = IteratorOutputType(output, output->GetLargestPossibleRegion());
- if (mIsOperationUseASecondImage) ComputeImage(it, it2, ito);
- else ComputeImage(it, ito);
- this->SetNextOutput<OutputImageType>(output);
- }
- }
- }
-
- template<>
- template<>
- void ImageArithmGenericFilter<args_info_clitkImageArithm>::ComputeImage<
- itk::ImageRegionIterator< itk::Image< itk::Vector<float, 3u>, 3u > >,
- itk::ImageRegionIterator< itk::Image< itk::Vector<float, 3u>, 3u > > >
- (itk::ImageRegionIterator< itk::Image< itk::Vector<float, 3u>, 3u > > it,
- itk::ImageRegionIterator< itk::Image< itk::Vector<float, 3u>, 3u > > ito)
- {
- typedef itk::ImageRegionIterator< itk::Image< itk::Vector<float, 3u>, 3u > > Iter2;
-
- ito.GoToBegin();
- it.GoToBegin();
-
- typedef Iter2::PixelType PixelType;
-
- PixelType scalar_vector;
- scalar_vector.Fill(mScalar);
-
- // Perform operation
- switch (mTypeOfOperation) {
- case 0: // Addition
- while (!it.IsAtEnd()) {
- ito.Set(it.Get() + scalar_vector);
- ++it;
- ++ito;
- }
- break;
- case 1: // Multiply
- while (!it.IsAtEnd()) {
- ito.Set(it.Get() * mScalar);
- ++it;
- ++ito;
- }
- break;
- /*
- case 2: // Inverse
- while (!it.IsAtEnd()) {
- if (it.Get() != 0)
- ito.Set(mScalar / it.Get()));
- else ito.Set(mDefaultPixelValue);
- ++it;
- ++ito;
- }
- break;
- case 3: // Max
- while (!it.IsAtEnd()) {
- if (it.Get() < mScalar) ito.Set(PixelTypeDownCast<double, PixelType>(mScalar));
- else ito.Set(PixelTypeDownCast<double, PixelType>(it.Get()));
- ++it;
- ++ito;
- }
- break;
- case 4: // Min
- while (!it.IsAtEnd()) {
- if (it.Get() > mScalar) ito.Set(PixelTypeDownCast<double, PixelType>(mScalar));
- else ito.Set(PixelTypeDownCast<double, PixelType>(it.Get()));
- ++it;
- ++ito;
- }
- break;
- case 5: // Absolute value
- while (!it.IsAtEnd()) {
- if (it.Get() <= 0) ito.Set(PixelTypeDownCast<double, PixelType>(-it.Get()));
- // <= zero to avoid warning for unsigned types
- else ito.Set(PixelTypeDownCast<double, PixelType>(it.Get()));
- ++it;
- ++ito;
- }
- break;
- case 6: // Squared value
- while (!it.IsAtEnd()) {
- ito.Set(PixelTypeDownCast<double, PixelType>((double)it.Get()*(double)it.Get()));
- ++it;
- ++ito;
- }
- break;
- case 7: // Log
- while (!it.IsAtEnd()) {
- if (it.Get() > 0)
- ito.Set(PixelTypeDownCast<double, PixelType>(log((double)it.Get())));
- else ito.Set(mDefaultPixelValue);
- ++it;
- ++ito;
- }
- break;
- case 8: // exp
- while (!it.IsAtEnd()) {
- ito.Set(PixelTypeDownCast<double, PixelType>(exp((double)it.Get())));
- ++it;
- ++ito;
- }
- break;
- case 9: // sqrt
- while (!it.IsAtEnd()) {
- if (it.Get() > 0)
- ito.Set(PixelTypeDownCast<double, PixelType>(sqrt((double)it.Get())));
- else {
- if (it.Get() ==0) ito.Set(0);
- else ito.Set(mDefaultPixelValue);
- }
- ++it;
- ++ito;
- }
- break;
- case 10: // exp
- while (!it.IsAtEnd()) {
- ito.Set(PixelTypeDownCast<double, PixelType>((0x10000 - (double)it.Get())/mScalar));
- ++it;
- ++ito;
- }
- break;
- */
- case 11: // divide
- while (!it.IsAtEnd()) {
- ito.Set(it.Get() / mScalar);
- ++it;
- ++ito;
- }
- break;
- default: // error ?
- std::cerr << "ERROR : the operation number (" << mTypeOfOperation << ") is not known." << std::endl;
- exit(-1);
- }
-
- }
-
- template<>
- template<>
- void ImageArithmGenericFilter<args_info_clitkImageArithm>::ComputeImage<
- itk::ImageRegionIterator< itk::Image< itk::Vector<float, 3u>, 3u > >,
- itk::ImageRegionIterator< itk::Image< itk::Vector<float, 3u>, 3u > >,
- itk::ImageRegionIterator< itk::Image< itk::Vector<float, 3u>, 3u > >
- >
- (itk::ImageRegionIterator< itk::Image< itk::Vector<float, 3u>, 3u > > it1,
- itk::ImageRegionIterator< itk::Image< itk::Vector<float, 3u>, 3u > > it2,
- itk::ImageRegionIterator< itk::Image< itk::Vector<float, 3u>, 3u > > ito)
- {
- typedef itk::ImageRegionIterator< itk::Image< itk::Vector<float, 3u>, 3u > > Iter1;
- typedef itk::ImageRegionIterator< itk::Image< itk::Vector<float, 3u>, 3u > > Iter2;
- typedef itk::ImageRegionIterator< itk::Image< itk::Vector<float, 3u>, 3u > > Iter3;
-
- it1.GoToBegin();
- it2.GoToBegin();
- ito.GoToBegin();
- typedef Iter3::PixelType PixelType;
-
- switch (mTypeOfOperation) {
- case 0: // Addition
- while (!ito.IsAtEnd()) {
- ito.Set(it1.Get() + it2.Get());
- ++it1;
- ++it2;
- ++ito;
- }
- break;
- /*
- case 1: // Multiply
- while (!ito.IsAtEnd()) {
- ito.Set(it1.Get() * it2.Get()) );
- ++it1;
- ++it2;
- ++ito;
- }
- break;
- case 2: // Divide
- while (!ito.IsAtEnd()) {
- if (it1.Get() != 0)
- ito.Set(it1.Get() / it2.Get()));
- else ito.Set(mDefaultPixelValue);
- ++it1;
- ++it2;
- ++ito;
- }
- break;
- case 3: // Max
- while (!ito.IsAtEnd()) {
- if (it1.Get() < it2.Get()) ito.Set(it2.Get());
- ++it1;
- ++it2;
- ++ito;
- }
- break;
- case 4: // Min
- while (!ito.IsAtEnd()) {
- if (it1.Get() > it2.Get()) ito.Set(it2.Get());
- ++it1;
- ++it2;
- ++ito;
- }
- break;
- */
- case 5: // Absolute difference
- while (!ito.IsAtEnd()) {
- ito.Set(it2.Get()-it1.Get());
- ++it1;
- ++it2;
- ++ito;
- }
- break;
- /*
- case 6: // Squared differences
- while (!ito.IsAtEnd()) {
- ito.Set(pow(it1.Get()-it2.Get(),2)));
- ++it1;
- ++it2;
- ++ito;
- }
- break;
- */
- case 7: // Difference
- while (!ito.IsAtEnd()) {
- ito.Set(it1.Get()-it2.Get());
- ++it1;
- ++it2;
- ++ito;
- }
- break;
- /*
- case 8: // Relative Difference
- while (!ito.IsAtEnd()) {
- if (it1.Get() != 0) ito.Set(PixelTypeDownCast<double, PixelType>(((double)it1.Get()-(double)it2.Get()))/(double)it1.Get());
- else ito.Set(0.0);
- ++it1;
- ++it2;
- ++ito;
- }
- break;
- */
- default: // error ?
- std::cerr << "ERROR : the operation number (" << mTypeOfOperation << ") is not known." << std::endl;
- exit(-1);
- }
- }
-
-////////////////////////////////////////////////////////////////////
- // specializations for itk::Vector<double, 3u>, 3u
- template<>
- template<>
- void ImageArithmGenericFilter<args_info_clitkImageArithm>::UpdateWithInputImageType< itk::Image< itk::Vector<double, 3u>, 3u > >()
- {
- typedef itk::Image< itk::Vector<double, 3u>, 3u > ImageType;
-
- // Read input1
- ImageType::Pointer input1 = this->GetInput<ImageType>(0);
-
- // Set input image iterator
- typedef itk::ImageRegionIterator<ImageType> IteratorType;
- IteratorType it(input1, input1->GetLargestPossibleRegion());
-
- // typedef input2
- ImageType::Pointer input2 = NULL;
- IteratorType it2;
-
- /*
- // Special case for normalisation
- if (mTypeOfOperation == 12) {
- typedef itk::MinimumMaximumImageCalculator<ImageType> MinMaxFilterType;
- typename MinMaxFilterType::Pointer ff = MinMaxFilterType::New();
- ff->SetImage(input1);
- ff->ComputeMaximum();
- mScalar = ff->GetMaximum();
- mTypeOfOperation = 11; // divide
- }
- */
-
- if (mIsOperationUseASecondImage) {
- // Read input2
- input2 = this->GetInput<ImageType>(1);
- // Set input image iterator
- it2 = IteratorType(input2, input2->GetLargestPossibleRegion());
- // Check dimension
- if (!clitk::HaveSameSize<ImageType, ImageType>(input1, input2)) {
- itkExceptionMacro(<< "The images (input and input2) must have the same size");
- }
- if(!clitk::HaveSameSpacing<ImageType, ImageType>(input1, input2)) {
- itkWarningMacro(<< "The images (input and input2) do not have the same spacing. "
- << "Using first input's information.");
- }
- }
-
- /*
- // Check if overwrite and outputisfloat and pixeltype is not float -> do not overwrite
- if (mOverwriteInputImage && mOutputIsFloat && (typeid(typename ImageType::PixelType) != typeid(float))) {
- // std::cerr << "Warning. Could not use both mOverwriteInputImage and mOutputIsFloat, because input is "
- // << typeid(PixelType).name()
- // << std::endl;
- mOverwriteInputImage = false;
- }
- */
-
- // ---------------- Overwrite input Image ---------------------
- if (mOverwriteInputImage) {
- // Set output iterator (to input1)
- IteratorType ito = IteratorType(input1, input1->GetLargestPossibleRegion());
- if (mIsOperationUseASecondImage) ComputeImage(it, it2, ito);
- else ComputeImage(it, ito);
- this->SetNextOutput<ImageType>(input1);
- }
- // ---------------- Create new output Image ---------------------
- else {
- /*if (mOutputIsFloat) {
- // Create output image
- typedef itk::Image<float,ImageType::ImageDimension> OutputImageType;
- typename OutputImageType::Pointer output = OutputImageType::New();
- output->SetRegions(input1->GetLargestPossibleRegion());
- output->SetOrigin(input1->GetOrigin());
- output->SetSpacing(input1->GetSpacing());
- output->Allocate();
- // Set output iterator
- typedef itk::ImageRegionIterator<OutputImageType> IteratorOutputType;
- IteratorOutputType ito = IteratorOutputType(output, output->GetLargestPossibleRegion());
- if (mIsOperationUseASecondImage) ComputeImage(it, it2, ito);
- else ComputeImage(it, ito);
- this->template SetNextOutput<OutputImageType>(output);
- } else*/ {
- // Create output image
- typedef ImageType OutputImageType;
- OutputImageType::Pointer output = OutputImageType::New();
- output->SetRegions(input1->GetLargestPossibleRegion());
- output->SetOrigin(input1->GetOrigin());
- output->SetSpacing(input1->GetSpacing());
- output->Allocate();
- // Set output iterator
- typedef itk::ImageRegionIterator<OutputImageType> IteratorOutputType;
- IteratorOutputType ito = IteratorOutputType(output, output->GetLargestPossibleRegion());
- if (mIsOperationUseASecondImage) ComputeImage(it, it2, ito);
- else ComputeImage(it, ito);
- this->SetNextOutput<OutputImageType>(output);
- }
- }
- }
-
- template<>
- template<>
- void ImageArithmGenericFilter<args_info_clitkImageArithm>::ComputeImage<
- itk::ImageRegionIterator< itk::Image< itk::Vector<double, 3u>, 3u > >,
- itk::ImageRegionIterator< itk::Image< itk::Vector<double, 3u>, 3u > > >
- (itk::ImageRegionIterator< itk::Image< itk::Vector<double, 3u>, 3u > > it,
- itk::ImageRegionIterator< itk::Image< itk::Vector<double, 3u>, 3u > > ito)
- {
- typedef itk::ImageRegionIterator< itk::Image< itk::Vector<double, 3u>, 3u > > Iter2;
-
- ito.GoToBegin();
- it.GoToBegin();
-
- typedef Iter2::PixelType PixelType;
-
- PixelType scalar_vector;
- scalar_vector.Fill(mScalar);
-
- // Perform operation
- switch (mTypeOfOperation) {
- case 0: // Addition
- while (!it.IsAtEnd()) {
- ito.Set(it.Get() + scalar_vector);
- ++it;
- ++ito;
- }
- break;
- case 1: // Multiply
- while (!it.IsAtEnd()) {
- ito.Set(it.Get() * mScalar);
- ++it;
- ++ito;
- }
- break;
- /*
- case 2: // Inverse
- while (!it.IsAtEnd()) {
- if (it.Get() != 0)
- ito.Set(mScalar / it.Get()));
- else ito.Set(mDefaultPixelValue);
- ++it;
- ++ito;
- }
- break;
- case 3: // Max
- while (!it.IsAtEnd()) {
- if (it.Get() < mScalar) ito.Set(PixelTypeDownCast<double, PixelType>(mScalar));
- else ito.Set(PixelTypeDownCast<double, PixelType>(it.Get()));
- ++it;
- ++ito;
- }
- break;
- case 4: // Min
- while (!it.IsAtEnd()) {
- if (it.Get() > mScalar) ito.Set(PixelTypeDownCast<double, PixelType>(mScalar));
- else ito.Set(PixelTypeDownCast<double, PixelType>(it.Get()));
- ++it;
- ++ito;
- }
- break;
- case 5: // Absolute value
- while (!it.IsAtEnd()) {
- if (it.Get() <= 0) ito.Set(PixelTypeDownCast<double, PixelType>(-it.Get()));
- // <= zero to avoid warning for unsigned types
- else ito.Set(PixelTypeDownCast<double, PixelType>(it.Get()));
- ++it;
- ++ito;
- }
- break;
- case 6: // Squared value
- while (!it.IsAtEnd()) {
- ito.Set(PixelTypeDownCast<double, PixelType>((double)it.Get()*(double)it.Get()));
- ++it;
- ++ito;
- }
- break;
- case 7: // Log
- while (!it.IsAtEnd()) {
- if (it.Get() > 0)
- ito.Set(PixelTypeDownCast<double, PixelType>(log((double)it.Get())));
- else ito.Set(mDefaultPixelValue);
- ++it;
- ++ito;
- }
- break;
- case 8: // exp
- while (!it.IsAtEnd()) {
- ito.Set(PixelTypeDownCast<double, PixelType>(exp((double)it.Get())));
- ++it;
- ++ito;
- }
- break;
- case 9: // sqrt
- while (!it.IsAtEnd()) {
- if (it.Get() > 0)
- ito.Set(PixelTypeDownCast<double, PixelType>(sqrt((double)it.Get())));
- else {
- if (it.Get() ==0) ito.Set(0);
- else ito.Set(mDefaultPixelValue);
- }
- ++it;
- ++ito;
- }
- break;
- case 10: // exp
- while (!it.IsAtEnd()) {
- ito.Set(PixelTypeDownCast<double, PixelType>((0x10000 - (double)it.Get())/mScalar));
- ++it;
- ++ito;
- }
- break;
- */
- case 11: // divide
- while (!it.IsAtEnd()) {
- ito.Set(it.Get() / mScalar);
- ++it;
- ++ito;
- }
- break;
- default: // error ?
- std::cerr << "ERROR : the operation number (" << mTypeOfOperation << ") is not known." << std::endl;
- exit(-1);
- }
-
- }
-
- template<>
- template<>
- void ImageArithmGenericFilter<args_info_clitkImageArithm>::ComputeImage<
- itk::ImageRegionIterator< itk::Image< itk::Vector<double, 3u>, 3u > >,
- itk::ImageRegionIterator< itk::Image< itk::Vector<double, 3u>, 3u > >,
- itk::ImageRegionIterator< itk::Image< itk::Vector<double, 3u>, 3u > >
- >
- (itk::ImageRegionIterator< itk::Image< itk::Vector<double, 3u>, 3u > > it1,
- itk::ImageRegionIterator< itk::Image< itk::Vector<double, 3u>, 3u > > it2,
- itk::ImageRegionIterator< itk::Image< itk::Vector<double, 3u>, 3u > > ito)
- {
- typedef itk::ImageRegionIterator< itk::Image< itk::Vector<double, 3u>, 3u > > Iter1;
- typedef itk::ImageRegionIterator< itk::Image< itk::Vector<double, 3u>, 3u > > Iter2;
- typedef itk::ImageRegionIterator< itk::Image< itk::Vector<double, 3u>, 3u > > Iter3;
-
- it1.GoToBegin();
- it2.GoToBegin();
- ito.GoToBegin();
- typedef Iter3::PixelType PixelType;
-
- switch (mTypeOfOperation) {
- case 0: // Addition
- while (!ito.IsAtEnd()) {
- ito.Set(it1.Get() + it2.Get());
- ++it1;
- ++it2;
- ++ito;
- }
- break;
- /*
- case 1: // Multiply
- while (!ito.IsAtEnd()) {
- ito.Set(it1.Get() * it2.Get()) );
- ++it1;
- ++it2;
- ++ito;
- }
- break;
- case 2: // Divide
- while (!ito.IsAtEnd()) {
- if (it1.Get() != 0)
- ito.Set(it1.Get() / it2.Get()));
- else ito.Set(mDefaultPixelValue);
- ++it1;
- ++it2;
- ++ito;
- }
- break;
- case 3: // Max
- while (!ito.IsAtEnd()) {
- if (it1.Get() < it2.Get()) ito.Set(it2.Get());
- ++it1;
- ++it2;
- ++ito;
- }
- break;
- case 4: // Min
- while (!ito.IsAtEnd()) {
- if (it1.Get() > it2.Get()) ito.Set(it2.Get());
- ++it1;
- ++it2;
- ++ito;
- }
- break;
- */
- case 5: // Absolute difference
- while (!ito.IsAtEnd()) {
- ito.Set(it2.Get()-it1.Get());
- ++it1;
- ++it2;
- ++ito;
- }
- break;
- /*
- case 6: // Squared differences
- while (!ito.IsAtEnd()) {
- ito.Set(pow(it1.Get()-it2.Get(),2)));
- ++it1;
- ++it2;
- ++ito;
- }
- break;
- */
- case 7: // Difference
- while (!ito.IsAtEnd()) {
- ito.Set(it1.Get()-it2.Get());
- ++it1;
- ++it2;
- ++ito;
- }
- break;
- /*
- case 8: // Relative Difference
- while (!ito.IsAtEnd()) {
- if (it1.Get() != 0) ito.Set(PixelTypeDownCast<double, PixelType>(((double)it1.Get()-(double)it2.Get()))/(double)it1.Get());
- else ito.Set(0.0);
- ++it1;
- ++it2;
- ++ito;
- }
- break;
- */
- default: // error ?
- std::cerr << "ERROR : the operation number (" << mTypeOfOperation << ") is not known." << std::endl;
- exit(-1);
- }
- }
}
}; // end class ImageArithmGenericFilter
- // specializations for itk::Vector<float, 3u>, 3u
- template<> template<>
- void ImageArithmGenericFilter<args_info_clitkImageArithm>::UpdateWithInputImageType< itk::Image< itk::Vector<float, 3u>, 3u > >();
-
- template<> template<>
- void ImageArithmGenericFilter<args_info_clitkImageArithm>::ComputeImage<
- itk::ImageRegionIterator< itk::Image< itk::Vector<float, 3u>, 3u > >,
- itk::ImageRegionIterator< itk::Image< itk::Vector<float, 3u>, 3u > >
- >
- (itk::ImageRegionIterator< itk::Image< itk::Vector<float, 3u>, 3u > > it,
- itk::ImageRegionIterator< itk::Image< itk::Vector<float, 3u>, 3u > > ito);
-
- template<> template<>
- void ImageArithmGenericFilter<args_info_clitkImageArithm>::ComputeImage<
- itk::ImageRegionIterator< itk::Image< itk::Vector<float, 3u>, 3u > >,
- itk::ImageRegionIterator< itk::Image< itk::Vector<float, 3u>, 3u > >,
- itk::ImageRegionIterator< itk::Image< itk::Vector<float, 3u>, 3u > >
- >
- (itk::ImageRegionIterator< itk::Image< itk::Vector<float, 3u>, 3u > > it1,
- itk::ImageRegionIterator< itk::Image< itk::Vector<float, 3u>, 3u > > it2,
- itk::ImageRegionIterator< itk::Image< itk::Vector<float, 3u>, 3u > > ito);
-
- // specializations for itk::Vector<double, 3u>, 3u
- template<> template<>
- void ImageArithmGenericFilter<args_info_clitkImageArithm>::UpdateWithInputImageType< itk::Image< itk::Vector<double, 3u>, 3u > >();
-
- template<> template<>
- void ImageArithmGenericFilter<args_info_clitkImageArithm>::ComputeImage<
- itk::ImageRegionIterator< itk::Image< itk::Vector<double, 3u>, 3u > >,
- itk::ImageRegionIterator< itk::Image< itk::Vector<double, 3u>, 3u > >
- >
- (itk::ImageRegionIterator< itk::Image< itk::Vector<double, 3u>, 3u > > it,
- itk::ImageRegionIterator< itk::Image< itk::Vector<double, 3u>, 3u > > ito);
-
- template<> template<>
- void ImageArithmGenericFilter<args_info_clitkImageArithm>::ComputeImage<
- itk::ImageRegionIterator< itk::Image< itk::Vector<double, 3u>, 3u > >,
- itk::ImageRegionIterator< itk::Image< itk::Vector<double, 3u>, 3u > >,
- itk::ImageRegionIterator< itk::Image< itk::Vector<double, 3u>, 3u > >
- >
- (itk::ImageRegionIterator< itk::Image< itk::Vector<double, 3u>, 3u > > it1,
- itk::ImageRegionIterator< itk::Image< itk::Vector<double, 3u>, 3u > > it2,
- itk::ImageRegionIterator< itk::Image< itk::Vector<double, 3u>, 3u > > ito);
} // end namespace
//--------------------------------------------------------------------
void ImageArithmGenericFilter<args_info_type>::InitializeImageType()
{
ADD_DEFAULT_IMAGE_TYPES(Dim);
- ADD_VEC_IMAGE_TYPE(3u,3u,float);
- ADD_VEC_IMAGE_TYPE(3u,3u,double);
}
//--------------------------------------------------------------------
--- /dev/null
+/*=========================================================================
+ Program: vv http://www.creatis.insa-lyon.fr/rio/vv
+
+ Authors belong to:
+ - University of LYON http://www.universite-lyon.fr/
+ - Léon Bérard cancer center http://www.centreleonberard.fr
+ - CREATIS CNRS laboratory http://www.creatis.insa-lyon.fr
+
+ This software is distributed WITHOUT ANY WARRANTY; without even
+ the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ PURPOSE. See the copyright notices for more information.
+
+ It is distributed under dual licence
+
+ - BSD See included LICENSE.txt file
+ - CeCILL-B http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
+===========================================================================**/
+#ifndef CLITKVFRESAMPLE_CXX
+#define CLITKVFRESAMPLE_CXX
+
+// clitk
+#include "clitkVFInterpolate_ggo.h"
+#include "clitkIO.h"
+#include "clitkVFInterpolateGenericFilter.h"
+
+//--------------------------------------------------------------------
+int main(int argc, char * argv[])
+{
+
+ // Init command line
+ GGO(clitkVFInterpolate, args_info);
+ CLITK_INIT;
+
+ // Read input image header to check image dimension
+ itk::ImageIOBase::Pointer header = clitk::readImageHeader(args_info.input1_arg);
+ unsigned int dim = header->GetNumberOfDimensions();
+ std::string pixelTypeName = header->GetComponentTypeAsString(header->GetComponentType());
+
+ // Print image info if verbose
+ if (args_info.verbose_flag) {
+ std::cout << "Input image <" << args_info.input1_arg << "> is ";
+ clitk::printImageHeader(header, std::cout);
+ std::cout << std::endl;
+ }
+
+ // Get input size/spacing
+ std::vector<int> inputSize;
+ std::vector<double> inputSpacing;
+ inputSize.resize(dim);
+ inputSpacing.resize(dim);
+ for (unsigned int i=0; i<dim; i++) {
+ inputSpacing[i] = header->GetSpacing(i);
+ inputSize[i] = header->GetDimensions(i);
+ }
+
+ if (args_info.verbose_flag) {
+ std::cout << "Output image will be : " << std::endl;
+ }
+
+ // Create a filter
+ clitk::VFInterpolateGenericFilter::Pointer filter = clitk::VFInterpolateGenericFilter::New();
+ filter->SetInputFilename(args_info.input1_arg);
+ filter->SetInputFilename2(args_info.input2_arg);
+ filter->SetInterpolationName(args_info.interp_arg);
+ filter->SetDistance(args_info.distance_arg);
+// filter->SetBSplineOrder(args_info.order_arg);
+// filter->SetBLUTSampling(args_info.sampling_arg);
+ filter->SetOutputFilename(args_info.output_arg);
+
+ // Go !
+ filter->Update();
+
+ // this is the end my friend
+ return 0;
+}// end main
+//--------------------------------------------------------------------
+
+#endif /* end #define CLITKVFRESAMPLE_CXX */
--- /dev/null
+#File clitkImageInterpolate.ggo
+package "clitkImageInterpolate"
+version "1.0"
+purpose "Interpolate an image. You can specify the interpolation, you can apply a Gaussian filter before."
+
+option "config" - "Config file" string no
+option "input1" i "Input image filename" string yes
+option "input2" j "Input image filename" string yes
+option "output" o "Output image filename" string yes
+option "distance" d "Distance (d in [0,1])" float yes
+option "verbose" v "Verbose" flag off
+option "interp" - "Interpolation type: {nn, linear}" string no default="nn"
+#option "order" b "BSpline ordre (range 0-5)" int no default="3"
+#option "sampling" s "BLUT sampling value" int no default="30"
+
--- /dev/null
+/*=========================================================================
+ Program: vv http://www.creatis.insa-lyon.fr/rio/vv
+
+ Authors belong to:
+ - University of LYON http://www.universite-lyon.fr/
+ - Léon Bérard cancer center http://www.centreleonberard.fr
+ - CREATIS CNRS laboratory http://www.creatis.insa-lyon.fr
+
+ This software is distributed WITHOUT ANY WARRANTY; without even
+ the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ PURPOSE. See the copyright notices for more information.
+
+ It is distributed under dual licence
+
+ - BSD See included LICENSE.txt file
+ - CeCILL-B http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
+===========================================================================**/
+#ifndef CLITKVFRESAMPLEGENERICFILTER_CXX
+#define CLITKVFRESAMPLEGENERICFILTER_CXX
+
+#include "clitkVFInterpolateGenericFilter.h"
+#include "itkInterpolateImageFilter.h"
+#include "itkLinearInterpolateImageFunction.h"
+#include "itkNearestNeighborInterpolateImageFunction.h"
+#include "itkNthElementImageAdaptor.h"
+
+//--------------------------------------------------------------------
+clitk::VFInterpolateGenericFilter::VFInterpolateGenericFilter():
+ clitk::ImageToImageGenericFilter<Self>("VFInterpolate")
+{
+ //InitializeImageType<2>();
+ InitializeImageType<3>();
+ // InitializeImageType<4>();
+ mInterpolatorName = "nn";
+ mBSplineOrder=3;
+ mDistance=0;
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+template<unsigned int Dim>
+void clitk::VFInterpolateGenericFilter::InitializeImageType()
+{
+ //typedef itk::Vector<float,Dim> v3f;
+ //ADD_IMAGE_TYPE(Dim, v3f);
+// ADD_VEC_IMAGE_TYPE(Dim,2,double)
+ ADD_VEC_IMAGE_TYPE(Dim,3,float)
+ ADD_VEC_IMAGE_TYPE(Dim,3,double)
+
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+template<class ImageType>
+void clitk::VFInterpolateGenericFilter::UpdateWithInputImageType()
+{
+
+ if (m_NbOfComponents == 1) {
+ std::cerr << "Error, only one components ? Use clitkImageInterpolate instead." << std::endl;
+ exit(0);
+ }
+ typedef typename ImageType::PixelType PixelType;
+// if (m_NbOfComponents == 2) Update_WithDimAndPixelTypeAndComponent<ImageType::ImageDimension,PixelType,2>();
+ if (m_NbOfComponents == 3) Update_WithDimAndPixelTypeAndComponent<ImageType::ImageDimension,PixelType,3>();
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+template<unsigned int Dim, class PixelType, unsigned int DimCompo>
+void clitk::VFInterpolateGenericFilter::Update_WithDimAndPixelTypeAndComponent()
+{
+ // Reading input
+ // typedef itk::Vector<PixelType, DimCompo> DisplacementType;
+ typedef PixelType DisplacementType;
+ typedef itk::Image< DisplacementType, Dim > ImageType;
+
+ typename ImageType::Pointer input1 = clitk::readImage<ImageType>(m_InputFilenames[0], m_IOVerbose);
+ typename ImageType::Pointer input2 = clitk::readImage<ImageType>(mInputFilename2, m_IOVerbose);
+
+ // Main filter
+ typename ImageType::Pointer outputImage = ComputeImage<ImageType>(input1, input2);
+
+ // Write results
+ SetNextOutput<ImageType>(outputImage);
+}
+//--------------------------------------------------------------------
+
+//--------------------------------------------------------------------
+template<class ImageType>
+typename ImageType::Pointer
+clitk::VFInterpolateGenericFilter::ComputeImage(typename ImageType::Pointer inputImage1, typename ImageType::Pointer inputImage2)
+{
+
+ // Some typedefs
+ typedef itk::Image<typename ImageType::PixelType::ValueType, ImageType::ImageDimension> ScalarImageType;
+ typedef itk::Image<typename ImageType::PixelType::ValueType, ImageType::ImageDimension + 1> InterpolationImageType;
+ typedef itk::NthElementImageAdaptor<ImageType, typename ImageType::PixelType::ValueType> ImageAdaptorType;
+ typename ImageAdaptorType::Pointer adaptor1 = ImageAdaptorType::New();
+ typename ImageAdaptorType::Pointer adaptor2 = ImageAdaptorType::New();
+ adaptor1->SetImage(inputImage1);
+ adaptor2->SetImage(inputImage2);
+
+ // Create Image Filter
+ typedef itk::InterpolateImageFilter<ImageAdaptorType, ScalarImageType> FilterType;
+ typename FilterType::Pointer filter = FilterType::New();
+ filter->SetInput1(adaptor1);
+ filter->SetInput2(adaptor2);
+ filter->SetDistance(mDistance);
+
+ // Select interpolator
+ if (mInterpolatorName == "nn") {
+ typedef itk::NearestNeighborInterpolateImageFunction<InterpolationImageType> InterpolatorType;
+ typename InterpolatorType::Pointer interpolator = InterpolatorType::New();
+ filter->SetInterpolator(interpolator);
+ } else {
+ if (mInterpolatorName == "linear") {
+ typedef itk::LinearInterpolateImageFunction<InterpolationImageType> InterpolatorType;
+ typename InterpolatorType::Pointer interpolator = InterpolatorType::New();
+ filter->SetInterpolator(interpolator);
+ } else {
+ std::cerr << "Sorry, I do not know the interpolator (for vector field) '" << mInterpolatorName
+ << "'. Known interpolators are : nn, linear" << std::endl;
+ exit(0);
+ }
+ }
+
+ typename ImageType::Pointer output = ImageType::New();
+ typename ImageAdaptorType::Pointer adaptorOutput = ImageAdaptorType::New();
+ output->CopyInformation(inputImage1);
+ output->SetRegions(inputImage1->GetLargestPossibleRegion());
+ output->Allocate();
+
+ typedef itk::ImageRegionIterator<ScalarImageType> IteratorType1;
+ typedef itk::ImageRegionIterator<ImageAdaptorType> IteratorType2;
+
+ for (unsigned int i = 0; i < ImageType::PixelType::Dimension; i++) {
+ adaptor1->SelectNthElement(i);
+ adaptor2->SelectNthElement(i);
+
+ // Go !
+ try {
+ filter->Update();
+ } catch( itk::ExceptionObject & err ) {
+ std::cerr << "Error while filtering " << m_InputFilenames[0].c_str()
+ << " " << err << std::endl;
+ exit(0);
+ }
+
+ adaptorOutput->SelectNthElement(i);
+ adaptorOutput->SetImage(output);
+
+ IteratorType1 it1(filter->GetOutput(), filter->GetOutput()->GetLargestPossibleRegion());
+ IteratorType2 it2(adaptorOutput, adaptorOutput->GetLargestPossibleRegion());
+
+ it1.GoToBegin();
+ it2.GoToBegin();
+ while ( ! it1.IsAtEnd() ) {
+ it2.Set(it1.Get());
+ ++it1;
+ ++it2;
+ }
+ }
+
+ // Return result
+ return output;
+
+}
+//--------------------------------------------------------------------
+
+//--------------------------------------------------------------------
+void clitk::VFInterpolateGenericFilter::SetInterpolationName(const std::string & inter)
+{
+ mInterpolatorName = inter;
+}
+//--------------------------------------------------------------------
+
+#endif
+
--- /dev/null
+/*=========================================================================
+ Program: vv http://www.creatis.insa-lyon.fr/rio/vv
+
+ Authors belong to:
+ - University of LYON http://www.universite-lyon.fr/
+ - Léon Bérard cancer center http://www.centreleonberard.fr
+ - CREATIS CNRS laboratory http://www.creatis.insa-lyon.fr
+
+ This software is distributed WITHOUT ANY WARRANTY; without even
+ the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ PURPOSE. See the copyright notices for more information.
+
+ It is distributed under dual licence
+
+ - BSD See included LICENSE.txt file
+ - CeCILL-B http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
+===========================================================================**/
+#ifndef CLITKIMAGERESAMPLEGENERICFILTER_H
+#define CLITKIMAGERESAMPLEGENERICFILTER_H
+/**
+ -------------------------------------------------------------------
+ * @file clitkVFInterpolateGenericFilter.h
+ * @author David Sarrut <David.Sarrut@creatis.insa-lyon.fr>
+ * @date 23 Feb 2008 08:37:53
+
+ * @brief
+ -------------------------------------------------------------------*/
+
+// clitk include
+#include "clitkCommon.h"
+#include "clitkImageCommon.h"
+#include "clitkImageToImageGenericFilter.h"
+
+// itk include
+#include "itkImage.h"
+#include "itkVectorImage.h"
+#include "itkFixedArray.h"
+#include "itkImageFileReader.h"
+#include "itkImageSeriesReader.h"
+#include "itkImageFileWriter.h"
+#include "itkRecursiveGaussianImageFilter.h"
+#include "itkInterpolateImageFilter.h"
+#include "itkAffineTransform.h"
+#include "itkVectorNearestNeighborInterpolateImageFunction.h"
+#include "itkVectorLinearInterpolateImageFunction.h"
+#include "itkBSplineInterpolateImageFunction.h"
+#include "itkBSplineInterpolateImageFunctionWithLUT.h"
+#include "itkCommand.h"
+
+namespace clitk {
+
+ //--------------------------------------------------------------------
+ class VFInterpolateGenericFilter:
+ public clitk::ImageToImageGenericFilter<VFInterpolateGenericFilter> {
+
+ public:
+ // constructor
+ VFInterpolateGenericFilter();
+
+ // Types
+ typedef VFInterpolateGenericFilter Self;
+ typedef itk::SmartPointer<Self> Pointer;
+ typedef itk::SmartPointer<const Self> ConstPointer;
+
+ // New
+ itkNewMacro(Self);
+
+ void SetInputFilename1(const std::string& file) { mInputFilename1 = file; }
+ void SetInputFilename2(const std::string& file) { mInputFilename2 = file; }
+ void SetInterpolationName(const std::string & inter);
+ void SetDistance(double distance) { mDistance = distance; }
+ void SetBSplineOrder(int o) { mBSplineOrder = o; }
+ void SetBLUTSampling(int b) { mSamplingFactors.resize(1); mSamplingFactors[0] = b; }
+
+ //--------------------------------------------------------------------
+ // Main function called each time the filter is updated
+ template<class InputImageType>
+ void UpdateWithInputImageType();
+
+ protected:
+ template<unsigned int Dim> void InitializeImageType();
+ //--------------------------------------------------------------------
+ std::string mInputFilename1, mInputFilename2;
+ std::string mInterpolatorName;
+ int mBSplineOrder;
+ std::vector<int> mSamplingFactors;
+ double mDistance;
+
+ //--------------------------------------------------------------------
+ template<unsigned int Dim, class PixelType, unsigned int DimCompo>
+ void Update_WithDimAndPixelTypeAndComponent();
+ template<class ImageType>
+ typename ImageType::Pointer ComputeImage(typename ImageType::Pointer inputImage1, typename ImageType::Pointer inputImage2);
+
+ }; // end class VFInterpolateGenericFilter
+ //--------------------------------------------------------------------
+
+} // end namespace
+//--------------------------------------------------------------------
+
+#endif /* end #define CLITKIMAGERESAMPLEGENERICFILTER_H */
+
--- /dev/null
+/*=========================================================================
+ Program: vv http://www.creatis.insa-lyon.fr/rio/vv
+
+ Authors belong to:
+ - University of LYON http://www.universite-lyon.fr/
+ - Léon Bérard cancer center http://www.centreleonberard.fr
+ - CREATIS CNRS laboratory http://www.creatis.insa-lyon.fr
+
+ This software is distributed WITHOUT ANY WARRANTY; without even
+ the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ PURPOSE. See the copyright notices for more information.
+
+ It is distributed under dual licence
+
+ - BSD See included LICENSE.txt file
+ - CeCILL-B http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
+===========================================================================**/
+#ifndef CLITKVFRESAMPLEGENERICFILTER_TXX
+#define CLITKVFRESAMPLEGENERICFILTER_TXX
+/**
+ ------------------------------------------------=
+ * @file clitkVFInterpolateGenericFilter.txx
+ * @author David Sarrut <david.sarrut@creatis.insa-lyon.fr>
+ * @date 23 Feb 2008 08:40:11
+ *
+ * @brief
+ *
+ *
+ ------------------------------------------------=*/
+
+//--------------------------------------------------------------------
+
+#endif /* end #define CLITKVFRESAMPLEGENERICFILTER_TXX */
+
--- /dev/null
+/*=========================================================================
+ Program: vv http://www.creatis.insa-lyon.fr/rio/vv
+
+ Authors belong to:
+ - University of LYON http://www.universite-lyon.fr/
+ - Léon Bérard cancer center http://www.centreleonberard.fr
+ - CREATIS CNRS laboratory http://www.creatis.insa-lyon.fr
+
+ This software is distributed WITHOUT ANY WARRANTY; without even
+ the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ PURPOSE. See the copyright notices for more information.
+
+ It is distributed under dual licence
+
+ - BSD See included LICENSE.txt file
+ - CeCILL-B http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
+===========================================================================**/
+#ifndef CLITKVECTORARITHM_CXX
+#define CLITKVECTORARITHM_CXX
+/**
+ -------------------------------------------------
+ * @file clitkVectorArithm.cxx
+ * @author David Sarrut <David.Sarrut@creatis.insa-lyon.fr>
+ * @date 23 Feb 2008 08:37:53
+ -------------------------------------------------*/
+
+// clitk include
+#include "clitkVectorArithm_ggo.h"
+#include "clitkVectorArithmGenericFilter.h"
+#include "clitkIO.h"
+
+//--------------------------------------------------------------------
+int main(int argc, char * argv[])
+{
+
+ // Init command line
+ GGO(clitkVectorArithm, args_info);
+ CLITK_INIT;
+
+ // Creation of a generic filter
+ typedef clitk::VectorArithmGenericFilter<args_info_clitkVectorArithm> FilterType;
+ FilterType::Pointer filter = FilterType::New();
+
+ // Go !
+ filter->SetArgsInfo(args_info);
+ CLITK_TRY_CATCH_EXIT(filter->Update());
+
+ // this is the end my friend
+ return EXIT_SUCCESS;
+} // end main
+
+#endif //define CLITKVECTORARITHM_CXX
--- /dev/null
+#File clitkVectorArithm.ggo
+package "clitkVectorArithm"
+version "1.0"
+purpose "Perform an arithmetic operation (+-*/ ...) using two images or using an image and a scalar value."
+
+
+option "config" - "Config file" string no
+option "verbose" v "Verbose" flag off
+option "imagetypes" - "Display allowed image types" flag off
+
+option "input1" i "Input first image filename" string yes
+option "input2" j "Input second image filename" string no
+option "output" o "Output image filename" string yes
+
+option "scalar" s "Scalar value" double no
+option "operation" t "Type of operation : \n With another image : 0=add, 1=multiply (dotproduct), 7=difference, 9=crossproduct\n; For 'scalar' : 0=add, 1=multiply, 5=absval (magnitude), 6=squared magnitude, 11=divide, 12=normalize" int default="0" no
+option "pixelValue" - "Default value for NaN/Inf" double default="0.0" no
+
+option "setFloatOutput" f "Set output to float pixel type" flag off
+
+#option "binary" b "Mask for binary operation" string no
--- /dev/null
+/*=========================================================================
+ Program: vv http://www.creatis.insa-lyon.fr/rio/vv
+
+ Authors belong to:
+ - University of LYON http://www.universite-lyon.fr/
+ - Léon Bérard cancer center http://www.centreleonberard.fr
+ - CREATIS CNRS laboratory http://www.creatis.insa-lyon.fr
+
+ This software is distributed WITHOUT ANY WARRANTY; without even
+ the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ PURPOSE. See the copyright notices for more information.
+
+ It is distributed under dual licence
+
+ - BSD See included LICENSE.txt file
+ - CeCILL-B http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
+===========================================================================**/
+#ifndef CLITKVECTORARITHMGENERICFILTER_CXX
+#define CLITKVECTORARITHMGENERICFILTER_CXX
+
+#include "clitkVectorArithmGenericFilter.h"
+
+namespace clitk {
+ // Specialisation
+// template<>
+// class VectorArithmGenericFilter<args_info_clitkVECTORARITHM>;
+
+
+}
+
+#endif //define CLITKVECTORARITHMGENERICFILTER_CXX
--- /dev/null
+/*=========================================================================
+ Program: vv http://www.creatis.insa-lyon.fr/rio/vv
+
+ Authors belong to:
+ - University of LYON http://www.universite-lyon.fr/
+ - Léon Bérard cancer center http://www.centreleonberard.fr
+ - CREATIS CNRS laboratory http://www.creatis.insa-lyon.fr
+
+ This software is distributed WITHOUT ANY WARRANTY; without even
+ the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ PURPOSE. See the copyright notices for more information.
+
+ It is distributed under dual licence
+
+ - BSD See included LICENSE.txt file
+ - CeCILL-B http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
+===========================================================================**/
+#ifndef CLITKVectorArithmGENERICFILTER_H
+#define CLITKVectorArithmGENERICFILTER_H
+/**
+ -------------------------------------------------------------------
+ * @file clitkVectorArithmGenericFilter.h
+ * @author David Sarrut <David.Sarrut@creatis.insa-lyon.fr>
+ * @date 23 Feb 2008 08:37:53
+
+ * @brief
+ -------------------------------------------------------------------*/
+
+// clitk include
+#include "clitkCommon.h"
+#include "clitkImageToImageGenericFilter.h"
+#include "clitkVectorArithm_ggo.h"
+
+// itk include
+#include "itkImage.h"
+#include "itkImageIOBase.h"
+#include "itkImageRegionIterator.h"
+#include "itkImageRegionConstIterator.h"
+
+//--------------------------------------------------------------------
+namespace clitk {
+
+ template<class args_info_type>
+ class ITK_EXPORT VectorArithmGenericFilter:
+ public clitk::ImageToImageGenericFilter<VectorArithmGenericFilter<args_info_type> > {
+
+ public:
+
+ // Constructor
+ VectorArithmGenericFilter ();
+
+ // Types
+ typedef VectorArithmGenericFilter Self;
+ typedef ImageToImageGenericFilterBase Superclass;
+ typedef itk::SmartPointer<Self> Pointer;
+ typedef itk::SmartPointer<const Self> ConstPointer;
+
+ // New
+ itkNewMacro(Self);
+
+ //--------------------------------------------------------------------
+ void SetArgsInfo(const args_info_type & a);
+
+ // Set methods
+ void SetDefaultPixelValue (double value) { mDefaultPixelValue = value ;}
+ void SetTypeOfOperation (int value) { mTypeOfOperation = value ;}
+ void SetScalar (double value) { mScalar = value ;}
+ void EnableOverwriteInputImage(bool b);
+
+ // Get methods
+ double GetDefaultPixelValue () { return mDefaultPixelValue ;}
+ int GetTypeOfOperation () { return mTypeOfOperation ;}
+ double GetScalar () { return mScalar ;}
+
+ //--------------------------------------------------------------------
+ // Main function called each time the filter is updated
+ template<class InputImageType>
+ void UpdateWithInputImageType();
+
+ protected:
+ template<unsigned int Dim> void InitializeImageType();
+ bool mIsOperationUseASecondImage;
+ double mScalar;
+ double mDefaultPixelValue;
+ int mTypeOfOperation;
+ args_info_type mArgsInfo;
+ bool mOverwriteInputImage;
+ bool mOutputIsFloat;
+ bool mIsOutputScalar;
+
+ template<class Iter1, class Iter2>
+ void ComputeImage(Iter1 it, Iter2 ito);
+
+ template<class Iter1, class Iter2, class Iter3>
+ void ComputeImage(Iter1 it1, Iter2 it2, Iter3 ito);
+
+ template<class Iter1, class Iter2>
+ void ComputeScalarImage(Iter1 it, Iter2 ito);
+
+ template<class Iter1, class Iter2, class Iter3>
+ void ComputeScalarImage(Iter1 it1, Iter2 it2, Iter3 ito);
+
+ //--------------------------------------------------------------------
+
+ }; // end class VectorArithmGenericFilter
+
+ // specializations for itk::Vector<float, 3u>, 3u
+} // end namespace
+//--------------------------------------------------------------------
+
+
+#ifndef ITK_MANUAL_INSTANTIATION
+#include "clitkVectorArithmGenericFilter.txx"
+#endif
+
+#endif //#define CLITKVectorArithmGENERICFILTER_H
+
--- /dev/null
+/*=========================================================================
+ Program: vv http://www.creatis.insa-lyon.fr/rio/vv
+
+ Authors belong to:
+ - University of LYON http://www.universite-lyon.fr/
+ - Léon Bérard cancer center http://www.centreleonberard.fr
+ - CREATIS CNRS laboratory http://www.creatis.insa-lyon.fr
+
+ This software is distributed WITHOUT ANY WARRANTY; without even
+ the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ PURPOSE. See the copyright notices for more information.
+
+ It is distributed under dual licence
+
+ - BSD See included LICENSE.txt file
+ - CeCILL-B http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
+===========================================================================**/
+#ifndef CLITKVectorArithmGENERICFILTER_TXX
+#define CLITKVectorArithmGENERICFILTER_TXX
+
+#include "clitkImageCommon.h"
+
+#include "itkMinimumMaximumImageCalculator.h"
+
+namespace clitk
+{
+
+//--------------------------------------------------------------------
+template<class args_info_type>
+VectorArithmGenericFilter<args_info_type>::VectorArithmGenericFilter()
+ :ImageToImageGenericFilter<Self>("VectorArithmGenericFilter"),mTypeOfOperation(0)
+{
+ InitializeImageType<3>();
+ mIsOperationUseASecondImage = false;
+ mIsOutputScalar = false;
+ mOverwriteInputImage = true;
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+template<class args_info_type>
+template<unsigned int Dim>
+void VectorArithmGenericFilter<args_info_type>::InitializeImageType()
+{
+ ADD_VEC_IMAGE_TYPE(Dim,3u,float);
+ ADD_VEC_IMAGE_TYPE(Dim,3u,double);
+ ADD_VEC_IMAGE_TYPE(Dim,2u,float);
+ ADD_VEC_IMAGE_TYPE(Dim,2u,double);
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+template<class args_info_type>
+void VectorArithmGenericFilter<args_info_type>::EnableOverwriteInputImage(bool b)
+{
+ mOverwriteInputImage = b;
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+template<class args_info_type>
+void VectorArithmGenericFilter<args_info_type>::SetArgsInfo(const args_info_type & a)
+{
+ mArgsInfo=a;
+
+ // Set value
+ this->SetIOVerbose(mArgsInfo.verbose_flag);
+ mTypeOfOperation = mArgsInfo.operation_arg;
+ mDefaultPixelValue = mArgsInfo.pixelValue_arg;
+ mScalar = mArgsInfo.scalar_arg;
+ mOutputIsFloat = mArgsInfo.setFloatOutput_flag;
+
+ if (mArgsInfo.imagetypes_flag) this->PrintAvailableImageTypes();
+
+ if (mArgsInfo.input1_given) this->AddInputFilename(mArgsInfo.input1_arg);
+ if (mArgsInfo.input2_given) {
+ mIsOperationUseASecondImage = true;
+ this->AddInputFilename(mArgsInfo.input2_arg);
+ if (mArgsInfo.operation_arg == 1)
+ mIsOutputScalar = true;
+ }
+ else if (mArgsInfo.operation_arg == 5 || mArgsInfo.operation_arg == 6)
+ mIsOutputScalar = true;
+
+ if (mArgsInfo.output_given) this->SetOutputFilename(mArgsInfo.output_arg);
+
+ // Check type of operation (with scalar or with other image)
+ if ((mArgsInfo.input2_given) && (mArgsInfo.scalar_given)) {
+ std::cerr << "ERROR : you cannot provide both --scalar and --input2 option" << std::endl;
+ exit(-1);
+ }
+ if ((!mArgsInfo.input2_given) && (!mArgsInfo.scalar_given)) {
+ if (mArgsInfo.operation_arg < 5) {
+ std::cerr << "Such operation need the --scalar option." << std::endl;
+ exit(-1);
+ }
+ }
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+template<class args_info_type>
+template<class ImageType>
+void VectorArithmGenericFilter<args_info_type>::UpdateWithInputImageType()
+{
+ // Read input1
+ typename ImageType::Pointer input1 = this->template GetInput<ImageType>(0);
+
+ // Set input image iterator
+ typedef itk::ImageRegionIterator<ImageType> IteratorType;
+ IteratorType it(input1, input1->GetLargestPossibleRegion());
+
+ // typedef input2
+ typename ImageType::Pointer input2 = NULL;
+ IteratorType it2;
+
+ // Special case for normalisation
+ /*
+ if (mTypeOfOperation == 12) {
+ typedef itk::MinimumMaximumImageCalculator<ImageType> MinMaxFilterType;
+ typename MinMaxFilterType::Pointer ff = MinMaxFilterType::New();
+ ff->SetImage(input1);
+ ff->ComputeMaximum();
+ mScalar = ff->GetMaximum();
+ mTypeOfOperation = 11; // divide
+ }
+ */
+
+ if (mIsOperationUseASecondImage) {
+ // Read input2
+ input2 = this->template GetInput<ImageType>(1);
+ // Set input image iterator
+ it2 = IteratorType(input2, input2->GetLargestPossibleRegion());
+ // Check dimension
+ if (!clitk::HaveSameSize<ImageType, ImageType>(input1, input2)) {
+ itkExceptionMacro(<< "The images (input and input2) must have the same size");
+ }
+ if(!clitk::HaveSameSpacing<ImageType, ImageType>(input1, input2)) {
+ itkWarningMacro(<< "The images (input and input2) do not have the same spacing. "
+ << "Using first input's information.");
+ }
+ }
+
+ // Check if overwrite and outputisfloat and pixeltype is not float -> do not overwrite
+ if (mOverwriteInputImage && mOutputIsFloat && (typeid(typename ImageType::PixelType) != typeid(float))) {
+ // std::cerr << "Warning. Could not use both mOverwriteInputImage and mOutputIsFloat, because input is "
+ // << typeid(PixelType).name()
+ // << std::endl;
+ mOverwriteInputImage = false;
+ }
+
+ // ---------------- Overwrite input Image ---------------------
+ if (mOverwriteInputImage && !mIsOutputScalar) {
+ // Set output iterator (to input1)
+ IteratorType ito = IteratorType(input1, input1->GetLargestPossibleRegion());
+ if (mIsOperationUseASecondImage) ComputeImage(it, it2, ito);
+ else ComputeImage(it, ito);
+ this->template SetNextOutput<ImageType>(input1);
+ }
+
+ // ---------------- Create new output Image ---------------------
+ else {
+ // Create output image
+ if (!mIsOutputScalar) {
+ typedef ImageType OutputImageType;
+ typename OutputImageType::Pointer output = OutputImageType::New();
+ output->SetRegions(input1->GetLargestPossibleRegion());
+ output->SetOrigin(input1->GetOrigin());
+ output->SetSpacing(input1->GetSpacing());
+ output->Allocate();
+ // Set output iterator
+ typedef itk::ImageRegionIterator<OutputImageType> IteratorOutputType;
+ IteratorOutputType ito = IteratorOutputType(output, output->GetLargestPossibleRegion());
+ if (mIsOperationUseASecondImage) ComputeImage(it, it2, ito);
+ else ComputeImage(it, ito);
+ this->template SetNextOutput<OutputImageType>(output);
+ }
+ else {
+ // Create scalar output image
+ typedef itk::Image<typename ImageType::PixelType::ValueType, ImageType::ImageDimension> OutputImageType;
+ typename OutputImageType::Pointer output = OutputImageType::New();
+ output->SetRegions(input1->GetLargestPossibleRegion());
+ output->SetOrigin(input1->GetOrigin());
+ output->SetSpacing(input1->GetSpacing());
+ output->Allocate();
+ // Set output iterator
+ typedef itk::ImageRegionIterator<OutputImageType> IteratorOutputType;
+ IteratorOutputType ito = IteratorOutputType(output, output->GetLargestPossibleRegion());
+ if (mIsOperationUseASecondImage) ComputeScalarImage(it, it2, ito);
+ else ComputeScalarImage(it, ito);
+ this->template SetNextOutput<OutputImageType>(output);
+ }
+ }
+}
+//--------------------------------------------------------------------
+
+//--------------------------------------------------------------------
+template<class args_info_type>
+template<class Iter1, class Iter2, class Iter3>
+void VectorArithmGenericFilter<args_info_type>::ComputeImage(Iter1 it1, Iter2 it2, Iter3 ito)
+{
+ it1.GoToBegin();
+ it2.GoToBegin();
+ ito.GoToBegin();
+ typedef typename Iter3::PixelType PixelType;
+
+ switch (mTypeOfOperation) {
+ case 0: // Addition
+ while (!ito.IsAtEnd()) {
+ ito.Set(it1.Get() + it2.Get());
+ ++it1;
+ ++it2;
+ ++ito;
+ }
+ break;
+ /*
+ case 1: // Multiply
+ while (!ito.IsAtEnd()) {
+ ito.Set(it1.Get() * it2.Get()) );
+ ++it1;
+ ++it2;
+ ++ito;
+ }
+ break;
+ */
+ /*
+ case 2: // Divide
+ while (!ito.IsAtEnd()) {
+ if (it1.Get() != 0)
+ ito.Set(it1.Get() / it2.Get()));
+ else ito.Set(mDefaultPixelValue);
+ ++it1;
+ ++it2;
+ ++ito;
+ }
+ break;
+ case 3: // Max
+ while (!ito.IsAtEnd()) {
+ if (it1.Get() < it2.Get()) ito.Set(it2.Get());
+ ++it1;
+ ++it2;
+ ++ito;
+ }
+ break;
+ case 4: // Min
+ while (!ito.IsAtEnd()) {
+ if (it1.Get() > it2.Get()) ito.Set(it2.Get());
+ ++it1;
+ ++it2;
+ ++ito;
+ }
+ break;
+ */
+ /*
+ case 5: // Absolute difference
+ while (!ito.IsAtEnd()) {
+ ito.Set(it2.Get()-it1.Get());
+ ++it1;
+ ++it2;
+ ++ito;
+ }
+ break;
+ */
+ /*
+ case 6: // Squared differences
+ while (!ito.IsAtEnd()) {
+ ito.Set(pow(it1.Get()-it2.Get(),2)));
+ ++it1;
+ ++it2;
+ ++ito;
+ }
+ break;
+ */
+ case 7: // Difference
+ while (!ito.IsAtEnd()) {
+ ito.Set(it1.Get()-it2.Get());
+ ++it1;
+ ++it2;
+ ++ito;
+ }
+ break;
+ /*
+ case 8: // Relative Difference
+ while (!ito.IsAtEnd()) {
+ if (it1.Get() != 0) ito.Set(PixelTypeDownCast<double, PixelType>(((double)it1.Get()-(double)it2.Get()))/(double)it1.Get());
+ else ito.Set(0.0);
+ ++it1;
+ ++it2;
+ ++ito;
+ }
+ break;
+ */
+ /*
+ case 9: // CrossProduct
+ while (!ito.IsAtEnd()) {
+ ito.Set(it1.Get()^it2.Get());
+ ++it1;
+ ++it2;
+ ++ito;
+ }
+ break;
+ */
+ default: // error ?
+ std::cerr << "ERROR : the operation number (" << mTypeOfOperation << ") is not known." << std::endl;
+ exit(-1);
+ }
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+template<class args_info_type>
+template<class Iter1, class Iter2>
+void clitk::VectorArithmGenericFilter<args_info_type>::ComputeImage(Iter1 it, Iter2 ito)
+{
+ ito.GoToBegin();
+ it.GoToBegin();
+
+ typedef typename Iter1::PixelType PixelType;
+
+ PixelType scalar_vector;
+ scalar_vector.Fill(mScalar);
+
+ // Perform operation
+ switch (mTypeOfOperation) {
+ case 0: // Addition
+ while (!it.IsAtEnd()) {
+ ito.Set(it.Get() + scalar_vector);
+ ++it;
+ ++ito;
+ }
+ break;
+ case 1: // Multiply
+ while (!it.IsAtEnd()) {
+ ito.Set(it.Get() * mScalar);
+ ++it;
+ ++ito;
+ }
+ break;
+ /*
+ case 2: // Inverse
+ while (!it.IsAtEnd()) {
+ if (it.Get() != 0)
+ ito.Set(mScalar / it.Get()));
+ else ito.Set(mDefaultPixelValue);
+ ++it;
+ ++ito;
+ }
+ break;
+ case 3: // Max
+ while (!it.IsAtEnd()) {
+ if (it.Get() < mScalar) ito.Set(PixelTypeDownCast<double, PixelType>(mScalar));
+ else ito.Set(PixelTypeDownCast<double, PixelType>(it.Get()));
+ ++it;
+ ++ito;
+ }
+ break;
+ case 4: // Min
+ while (!it.IsAtEnd()) {
+ if (it.Get() > mScalar) ito.Set(PixelTypeDownCast<double, PixelType>(mScalar));
+ else ito.Set(PixelTypeDownCast<double, PixelType>(it.Get()));
+ ++it;
+ ++ito;
+ }
+ break;
+ */
+ /*
+ case 5: // Absolute value
+ while (!it.IsAtEnd()) {
+ ito.Set(PixelTypeDownCast<double, PixelType>(it.GetNorm()));
+ ++it;
+ ++ito;
+ }
+ break;
+ case 6: // Squared value
+ while (!it.IsAtEnd()) {
+ ito.Set(PixelTypeDownCast<double, PixelType>(it.GetSquaredNorm());
+ ++it;
+ ++ito;
+ }
+ break;
+ */
+ /*
+ case 7: // Log
+ while (!it.IsAtEnd()) {
+ if (it.Get() > 0)
+ ito.Set(PixelTypeDownCast<double, PixelType>(log((double)it.Get())));
+ else ito.Set(mDefaultPixelValue);
+ ++it;
+ ++ito;
+ }
+ break;
+ case 8: // exp
+ while (!it.IsAtEnd()) {
+ ito.Set(PixelTypeDownCast<double, PixelType>(exp((double)it.Get())));
+ ++it;
+ ++ito;
+ }
+ break;
+ case 9: // sqrt
+ while (!it.IsAtEnd()) {
+ if (it.Get() > 0)
+ ito.Set(PixelTypeDownCast<double, PixelType>(sqrt((double)it.Get())));
+ else {
+ if (it.Get() ==0) ito.Set(0);
+ else ito.Set(mDefaultPixelValue);
+ }
+ ++it;
+ ++ito;
+ }
+ break;
+ case 10: // exp
+ while (!it.IsAtEnd()) {
+ ito.Set(PixelTypeDownCast<double, PixelType>((0x10000 - (double)it.Get())/mScalar));
+ ++it;
+ ++ito;
+ }
+ break;
+ */
+ case 11: // divide
+ while (!it.IsAtEnd()) {
+ ito.Set(it.Get() / mScalar);
+ ++it;
+ ++ito;
+ }
+ break;
+ case 12: // normalize
+ while (!it.IsAtEnd()) {
+ PixelType n = it.Get();
+ if (n.GetNorm() != 0)
+ n.Normalize();
+
+ ito.Set(n);
+ ++it;
+ ++ito;
+ }
+ break;
+ default: // error ?
+ std::cerr << "ERROR : the operation number (" << mTypeOfOperation << ") is not known." << std::endl;
+ exit(-1);
+ }
+}
+//--------------------------------------------------------------------
+
+//--------------------------------------------------------------------
+template<class args_info_type>
+template<class Iter1, class Iter2, class Iter3>
+void VectorArithmGenericFilter<args_info_type>::ComputeScalarImage(Iter1 it1, Iter2 it2, Iter3 ito)
+{
+ it1.GoToBegin();
+ it2.GoToBegin();
+ ito.GoToBegin();
+ typedef typename Iter3::PixelType PixelType;
+
+ switch (mTypeOfOperation) {
+ case 1: // Multiply
+ while (!ito.IsAtEnd()) {
+ ito.Set(it1.Get() * it2.Get());
+ ++it1;
+ ++it2;
+ ++ito;
+ }
+ break;
+ default: // error ?
+ std::cerr << "ERROR : the operation number (" << mTypeOfOperation << ") is not known." << std::endl;
+ exit(-1);
+ }
+}
+//--------------------------------------------------------------------
+
+//--------------------------------------------------------------------
+template<class args_info_type>
+template<class Iter1, class Iter2>
+void clitk::VectorArithmGenericFilter<args_info_type>::ComputeScalarImage(Iter1 it, Iter2 ito)
+{
+ ito.GoToBegin();
+ it.GoToBegin();
+
+ typedef typename Iter2::PixelType PixelType;
+
+
+ // Perform operation
+ switch (mTypeOfOperation) {
+ case 5: // Absolute value
+ while (!it.IsAtEnd()) {
+ ito.Set(PixelTypeDownCast<double, PixelType>(it.Get().GetNorm()));
+ ++it;
+ ++ito;
+ }
+ break;
+ case 6: // Squared value
+ while (!it.IsAtEnd()) {
+ ito.Set(PixelTypeDownCast<double, PixelType>(it.Get().GetSquaredNorm()));
+ ++it;
+ ++ito;
+ }
+ break;
+ default: // error ?
+ std::cerr << "ERROR : the operation number (" << mTypeOfOperation << ") is not known." << std::endl;
+ exit(-1);
+ }
+}
+//--------------------------------------------------------------------
+
+
+} // end namespace
+
+#endif //#define CLITKVectorArithmGENERICFILTER_TXX
namesGenerator->SetInputDirectory( m_ArgsInfo.inputDir_arg );
namesGenerator->SetOutputDirectory( m_ArgsInfo.outputDir_arg );
typename ReaderType::FileNamesContainer filenames_in = namesGenerator->GetInputFileNames();
- typename ReaderType::FileNamesContainer filenames_out;
+ typename ReaderType::FileNamesContainer filenames_out = namesGenerator->GetOutputFileNames();
// Output the dicom files
unsigned int numberOfFilenames = filenames_in.size();
gdcmIO->SetKeepOriginalUID(true);
#endif
namesGenerator->SetOutputDirectory( m_ArgsInfo.outputDir_arg );
- filenames_out = namesGenerator->GetOutputFileNames();
}
filenames_out.resize(numberOfFilenames);
// file UIDs are recreated for new studies or series
if (!useInputFileUID)
{
+ if (m_ArgsInfo.verbose_flag)
+ std::cout << "Recreating file UIDs" << std::endl;
+
std::string fileUID;
#if GDCM_MAJOR_VERSION >= 2
gdcm::UIDGenerator fid;
// Write
try {
+ if (m_ArgsInfo.verbose_flag)
+ std::cout << seriesWriter << std::endl;
seriesWriter->Update();
} catch( itk::ExceptionObject & excp ) {
std::cerr << "Error: Exception thrown while writing the series!!" << std::endl;
IF(WIN32)
#INCLUDE(InstallRequiredSystemLibraries)
- INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/vv.exe DESTINATION .)
+ INSTALL(TARGETS vv DESTINATION bin)
#INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/icons/ducky.png DESTINATION .)
ENDIF(WIN32)
#=========================================================
<string>Bones</string>
</property>
</item>
+ <item>
+ <property name="text">
+ <string>Head/Brain</string>
+ </property>
+ </item>
<item>
<property name="text">
<string>[0,1] Scale</string>
</sizepolicy>
</property>
<property name="currentIndex">
- <number>0</number>
+ <number>1</number>
</property>
<widget class="QWidget" name="DataTab">
<attribute name="title">
<x>0</x>
<y>0</y>
<width>1008</width>
- <height>25</height>
+ <height>18</height>
</rect>
</property>
<property name="defaultUp">
<addaction name="actionAdd_VF_to_current_Image"/>
<addaction name="actionAdd_overlay_image_to_current_image"/>
<addaction name="actionAdd_fusion_image"/>
+ <addaction name="actionAdd_USSequence_toCT"/>
</widget>
<widget class="QMenu" name="menuScreenshots">
<property name="title">
<bool>true</bool>
</property>
</action>
+ <action name="actionAdd_USSequence_toCT">
+ <property name="icon">
+ <iconset resource="../vvIcons.qrc">
+ <normaloff>:/common/icons/rotateright.png</normaloff>:/common/icons/rotateright.png</iconset>
+ </property>
+ <property name="text">
+ <string>Test / Fusion of US & CT sequences</string>
+ </property>
+ <property name="iconVisibleInMenu">
+ <bool>true</bool>
+ </property>
+ </action>
</widget>
<customwidgets>
<customwidget>
<rect>
<x>0</x>
<y>0</y>
- <width>344</width>
- <height>480</height>
+ <width>444</width>
+ <height>612</height>
</rect>
</property>
<property name="sizePolicy">
</property>
</widget>
</item>
+ <item>
+ <widget class="QFrame" name="fCTUSFrame">
+ <property name="enabled">
+ <bool>true</bool>
+ </property>
+ <property name="sizePolicy">
+ <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+ <horstretch>0</horstretch>
+ <verstretch>0</verstretch>
+ </sizepolicy>
+ </property>
+ <property name="minimumSize">
+ <size>
+ <width>0</width>
+ <height>90</height>
+ </size>
+ </property>
+ <property name="frameShape">
+ <enum>QFrame::StyledPanel</enum>
+ </property>
+ <property name="frameShadow">
+ <enum>QFrame::Raised</enum>
+ </property>
+ <widget class="QCheckBox" name="fCTUSActivateTimeSyncCheckBox">
+ <property name="enabled">
+ <bool>false</bool>
+ </property>
+ <property name="geometry">
+ <rect>
+ <x>220</x>
+ <y>60</y>
+ <width>80</width>
+ <height>17</height>
+ </rect>
+ </property>
+ <property name="text">
+ <string>Temporal</string>
+ </property>
+ </widget>
+ <widget class="QCheckBox" name="fCTUSActivateSpaceSyncCheckBox">
+ <property name="geometry">
+ <rect>
+ <x>220</x>
+ <y>10</y>
+ <width>61</width>
+ <height>17</height>
+ </rect>
+ </property>
+ <property name="text">
+ <string>Spatial</string>
+ </property>
+ <property name="checkable">
+ <bool>true</bool>
+ </property>
+ <property name="checked">
+ <bool>false</bool>
+ </property>
+ </widget>
+ <widget class="QLabel" name="label_13">
+ <property name="geometry">
+ <rect>
+ <x>0</x>
+ <y>0</y>
+ <width>31</width>
+ <height>32</height>
+ </rect>
+ </property>
+ <property name="text">
+ <string/>
+ </property>
+ <property name="pixmap">
+ <pixmap resource="../vvIcons.qrc">:/common/icons/rotateright.png</pixmap>
+ </property>
+ </widget>
+ <widget class="QLabel" name="label_14">
+ <property name="geometry">
+ <rect>
+ <x>30</x>
+ <y>0</y>
+ <width>171</width>
+ <height>32</height>
+ </rect>
+ </property>
+ <property name="text">
+ <string>Synchronized fusion of sequences</string>
+ </property>
+ </widget>
+ <widget class="QLabel" name="label_15">
+ <property name="geometry">
+ <rect>
+ <x>0</x>
+ <y>30</y>
+ <width>121</width>
+ <height>29</height>
+ </rect>
+ </property>
+ <property name="text">
+ <string> Browse fused sequence </string>
+ </property>
+ </widget>
+ <widget class="QSlider" name="fCTUSSlider">
+ <property name="geometry">
+ <rect>
+ <x>130</x>
+ <y>36</y>
+ <width>151</width>
+ <height>20</height>
+ </rect>
+ </property>
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ </widget>
+ <widget class="QPushButton" name="fCTUSLoadSignalPushButton">
+ <property name="geometry">
+ <rect>
+ <x>20</x>
+ <y>60</y>
+ <width>131</width>
+ <height>23</height>
+ </rect>
+ </property>
+ <property name="text">
+ <string>Load Fused Seq. Signal</string>
+ </property>
+ </widget>
+ </widget>
+ </item>
<item>
<widget class="QFrame" name="vFFrame">
<property name="enabled">
</item>
<item>
<widget class="QDoubleSpinBox" name="mValueSpinBox">
+ <property name="minimum">
+ <double>-999999999.000000000000000</double>
+ </property>
<property name="maximum">
<double>999999999.000000000000000</double>
</property>
std::vector<std::string> &sequence_filenames,
int n_image_loaded)
{
- const std::string open_mode_names[] = {"base", "overlay", "fusion", "vf", "contour"};
+ const std::string open_mode_names[] = {"base", "overlay", "fusion", "vf", "contour", "fusionSequence"};
if(open_mode==O_BASE)
window.LoadImages(sequence_filenames, vvImageReader::MERGEDWITHTIME);
else if (open_mode==O_OVERLAY)
class vtkImageAppend;
-class VTK_IO_EXPORT vvAnimatedGIFWriter : public vtkGenericMovieWriter
+class vvAnimatedGIFWriter : public vtkGenericMovieWriter //test this if link error...
{
public:
static vvAnimatedGIFWriter *New();
/*=========================================================================
- Program: vv http://www.creatis.insa-lyon.fr/rio/vv
+Program: vv http://www.creatis.insa-lyon.fr/rio/vv
- Authors belong to:
- - University of LYON http://www.universite-lyon.fr/
- - Léon Bérard cancer center http://www.centreleonberard.fr
- - CREATIS CNRS laboratory http://www.creatis.insa-lyon.fr
+Authors belong to:
+- University of LYON http://www.universite-lyon.fr/
+- Léon Bérard cancer center http://www.centreleonberard.fr
+- CREATIS CNRS laboratory http://www.creatis.insa-lyon.fr
- This software is distributed WITHOUT ANY WARRANTY; without even
- the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- PURPOSE. See the copyright notices for more information.
+This software is distributed WITHOUT ANY WARRANTY; without even
+the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+PURPOSE. See the copyright notices for more information.
- It is distributed under dual licence
+It is distributed under dual licence
- - BSD See included LICENSE.txt file
- - CeCILL-B http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
+- BSD See included LICENSE.txt file
+- CeCILL-B http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
===========================================================================**/
#include <algorithm>
/*Data Tree values
- 0,Qt::UserRole full filename
- 1,Qt::CheckStateRole checkbutton UL View
- 1,Qt::UserRole overlay, fusion or vector
- 2,Qt::CheckStateRole checkbutton UR View
- 3,Qt::CheckStateRole checkbutton DL View
- 4,Qt::CheckStateRole checkbutton DR View
- 5,0 short filename
- 5,Qt::UserRole mSlicerManager id*/
+0,Qt::UserRole full filename
+1,Qt::CheckStateRole checkbutton UL View
+1,Qt::UserRole overlay, fusion or vector
+2,Qt::CheckStateRole checkbutton UR View
+3,Qt::CheckStateRole checkbutton DL View
+4,Qt::CheckStateRole checkbutton DR View
+5,0 short filename
+5,Qt::UserRole mSlicerManager id*/
//------------------------------------------------------------------------------
vvMainWindow::vvMainWindow():vvMainWindowBase()
this->setContextMenuPolicy(Qt::CustomContextMenu);
contextActions.resize(0);
QAction* actionOpen_new_image = contextMenu.addAction(QIcon(QString::fromUtf8(":/common/icons/fileopen.png")),
- tr("O&pen new Image"));
+ tr("O&pen new Image"));
actionOpen_new_image->setShortcut(QKeySequence(tr("Ctrl+O")));
connect(actionOpen_new_image,SIGNAL(triggered()),this,SLOT(OpenImages()));
contextActions.push_back(actionOpen_new_image);
contextMenu.addSeparator();
QAction* actionClose_Image = contextMenu.addAction(QIcon(QString::fromUtf8(":/common/icons/exit.png")),
- tr("Close Current Image"));
+ tr("Close Current Image"));
connect(actionClose_Image,SIGNAL(triggered()),this,SLOT(CloseImage()));
contextActions.push_back(actionClose_Image);
QAction* actionReload_image = contextMenu.addAction(QIcon(QString::fromUtf8(":/common/icons/rotateright.png")),
- tr("Reload Current Image"));
+ tr("Reload Current Image"));
connect(actionReload_image,SIGNAL(triggered()),this,SLOT(ReloadImage()));
contextActions.push_back(actionReload_image);
QAction* actionSave_image = contextMenu.addAction(QIcon(QString::fromUtf8(":/common/icons/filesave.png")),
- tr("Save Current Image"));
+ tr("Save Current Image"));
connect(actionSave_image,SIGNAL(triggered()),this,SLOT(SaveAs()));
contextActions.push_back(actionSave_image);
QAction* actionSave_state = contextMenu.addAction(QIcon(QString::fromUtf8(":/common/icons/filesave.png")),
- tr("Save Current State"));
+ tr("Save Current State"));
connect(actionSave_state,SIGNAL(triggered()),this,SLOT(SaveCurrentState()));
contextActions.push_back(actionSave_state);
QAction* actionRead_state = contextMenu.addAction(QIcon(QString::fromUtf8(":/common/icons/filesave.png")),
- tr("Read Saved State"));
+ tr("Read Saved State"));
connect(actionRead_state,SIGNAL(triggered()),this,SLOT(ReadSavedState()));
contextActions.push_back(actionRead_state);
contextMenu.addAction(actionAdd_fusion_image);
contextActions.push_back(actionAdd_fusion_image);
+#ifdef CLITK_EXPERIMENTAL
+ contextMenu.addAction(actionAdd_USSequence_toCT);
+ contextActions.push_back(actionAdd_USSequence_toCT);
+#endif
+
+
contextMenu.addSeparator();
QAction* actionResetMatrix = contextMenu.addAction(QIcon(QString::fromUtf8(":/common/icons/identity.png")),
- tr("Reset transformation to identity"));
+ tr("Reset transformation to identity"));
connect(actionResetMatrix, SIGNAL(triggered()), this,SLOT(ResetTransformationToIdentity()));
// TRIAL DS
// m->setObjectName(QString::fromUtf8("TOTOTO"));
contextMenu.addMenu(m);
QAction * a = m->addAction(QIcon(QString::fromUtf8(":/common/icons/GPSup.png")),
- tr("BIDON"));
+ tr("BIDON"));
QAction * b = m->addAction(QIcon(QString::fromUtf8(":/common/icons/GPSup.png")),
- tr("BIDON2"));
+ tr("BIDON2"));
m->addAction(a);
m->addAction(b);
connect(a,SIGNAL(triggered()),this,SLOT(AddFusionImage()));
actionSave_As->setEnabled(0);
actionAdd_VF_to_current_Image->setEnabled(0);
actionAdd_fusion_image->setEnabled(0);
+ actionAdd_USSequence_toCT->setEnabled(0);
//init the sliders
verticalSliders.push_back(NOVerticalSlider);
connect(actionExit,SIGNAL(triggered()),this,SLOT(close()));
connect(actionAdd_VF_to_current_Image,SIGNAL(triggered()),this,SLOT(OpenField()));
connect(actionAdd_fusion_image,SIGNAL(triggered()),this,SLOT(SelectFusionImage()));
- connect(actionAdd_overlay_image_to_current_image,SIGNAL(triggered()), this,SLOT(SelectOverlayImage())); connect(actionNavigation_Help,SIGNAL(triggered()),this,SLOT(ShowHelpDialog()));
+ connect(actionAdd_overlay_image_to_current_image,SIGNAL(triggered()), this,SLOT(SelectOverlayImage()));
+ connect(actionAdd_USSequence_toCT,SIGNAL(triggered()), this,SLOT(SelectFusionSequence()));
+ connect(actionNavigation_Help,SIGNAL(triggered()),this,SLOT(ShowHelpDialog()));
connect(actionDocumentation,SIGNAL(triggered()),this,SLOT(ShowDocumentation()));
connect(actionRegister_vv,SIGNAL(triggered()),this,SLOT(PopupRegisterForm()));
+ connect(overlayPanel, SIGNAL(FusionSequenceSignalButtonPressed()), this, SLOT(SelectFusionSequenceTemporalSignal()));
+
+
///////////////////////////////////////////////
connect(actionSegmentation,SIGNAL(triggered()),this,SLOT(SegmentationOnCurrentImage()));
connect(actionSurface_Viewer,SIGNAL(triggered()),this,SLOT(SurfaceViewerLaunch()));
connect(DataTree,SIGNAL(itemSelectionChanged()),this,SLOT(ImageInfoChanged()));
connect(DataTree,SIGNAL(itemClicked(QTreeWidgetItem*, int)),this,
- SLOT(DisplayChanged(QTreeWidgetItem*, int)));
+ SLOT(DisplayChanged(QTreeWidgetItem*, int)));
connect(viewButton,SIGNAL(clicked()),this, SLOT(ChangeViewMode()) );
connect(windowSpinBox,SIGNAL(editingFinished()),this,SLOT(WindowLevelEdited()));
connect(linkPanel,SIGNAL(removeLink(QString,QString)),this,SLOT(RemoveLink(QString,QString)));
connect(overlayPanel,SIGNAL(VFPropertyUpdated(int,int,int,int,double,double,double)),this,SLOT(SetVFProperty(int,int,int,int,double,double,double)));
connect(overlayPanel,SIGNAL(OverlayPropertyUpdated(int,int,double,double)),
- this,SLOT(SetOverlayProperty(int,int,double,double)));
+ this,SLOT(SetOverlayProperty(int,int,double,double)));
connect(overlayPanel,SIGNAL(FusionPropertyUpdated(int,int,int,double,double, bool)),
- this,SLOT(SetFusionProperty(int,int,int,double,double, bool)));
+ this,SLOT(SetFusionProperty(int,int,int,double,double, bool)));
connect(landmarksPanel,SIGNAL(UpdateRenderWindows()),this,SLOT(UpdateRenderWindows()));
connect(landmarksPanel,SIGNAL(SelectedPointChanged()),this,SLOT(GoToLandmark()));
+ connect(overlayPanel,SIGNAL(FusionSequencePropertyUpdated(int, bool, unsigned int, bool)),
+ this,SLOT(SetFusionSequenceProperty(int, bool,unsigned int, bool)));
+
+
playMode = 0;//pause
mFrameRate = 10;
playButton->setEnabled(0);
//timerMemory->setInterval(5);
connect(timerMemory, SIGNAL(timeout()), this, SLOT(UpdateMemoryUsage()));
timerMemory->start(2000);
+
}
//------------------------------------------------------------------------------
void vvMainWindow::show()
bool ok;
int index=GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
int ref = QInputDialog::getInteger(this,"Chose reference phase","Reference phase",0,0,\
- mSlicerManagers[index]->GetImage()->GetVTKImages().size()-1,1,&ok);
+ mSlicerManagers[index]->GetImage()->GetVTKImages().size()-1,1,&ok);
if (ok) {
vvMidPosition midp;
midp.slicer_manager = mSlicerManagers[index];
cButton->setToolTip(tr("close image"));
cButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/exit.png")));
connect(cButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
- this,SLOT(CloseImage(QTreeWidgetItem*, int)));
+ this,SLOT(CloseImage(QTreeWidgetItem*, int)));
QTreePushButton* rButton = new QTreePushButton;
rButton->setItem(item);
//------------------------------------------------------------------------------
void vvMainWindow::AddDCStructContour(int index, QString file)
{
- vvMeshReader reader;
- reader.SetFilename(file.toStdString());
- vvStructSelector selector;
- selector.SetStructures(reader.GetROINames());
- if (!mSlicerManagers[index]->GetVF().IsNull())
- selector.EnablePropagationCheckBox();
- if (selector.exec()) {
- QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
- reader.SetSelectedItems(selector.getSelectedItems());
- reader.SetImage(mSlicerManagers[index]->GetImage());
- if (selector.PropagationEnabled())
- reader.SetPropagationVF(mSlicerManagers[index]->GetVF());
- reader.Update();
- std::vector<vvMesh::Pointer> contours=reader.GetOutput();
- for (std::vector<vvMesh::Pointer>::iterator i=contours.begin();
- i!=contours.end(); i++)
- AddContour(index,*i,selector.PropagationEnabled());
- QApplication::restoreOverrideCursor();
- }
+ vvMeshReader reader;
+ reader.SetFilename(file.toStdString());
+ vvStructSelector selector;
+ selector.SetStructures(reader.GetROINames());
+ if (!mSlicerManagers[index]->GetVF().IsNull())
+ selector.EnablePropagationCheckBox();
+ if (selector.exec()) {
+ QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+ reader.SetSelectedItems(selector.getSelectedItems());
+ reader.SetImage(mSlicerManagers[index]->GetImage());
+ if (selector.PropagationEnabled())
+ reader.SetPropagationVF(mSlicerManagers[index]->GetVF());
+ reader.Update();
+ std::vector<vvMesh::Pointer> contours=reader.GetOutput();
+ for (std::vector<vvMesh::Pointer>::iterator i=contours.begin();
+ i!=contours.end(); i++)
+ AddContour(index,*i,selector.PropagationEnabled());
+ QApplication::restoreOverrideCursor();
+ }
}
//------------------------------------------------------------------------------
if (!mSlicerManagers[index]->GetVF().IsNull()) {
bool ok;
int ref = QInputDialog::getInteger(this,"Chose reference phase","Reference phase",0,0,\
- mSlicerManagers[index]->GetImage()->GetVTKImages().size()-1,1,&ok);
+ mSlicerManagers[index]->GetImage()->GetVTKImages().size()-1,1,&ok);
if (ok) {
WarpImage(mSlicerManagers[index],ref);
}
QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
QFileInfo info(selected_slicer->GetFileName().c_str());
vvImageWarp warp(selected_slicer->GetImage(),selected_slicer->GetVF(),
- reference_phase,this);
+ reference_phase,this);
if (warp.ComputeWarpedImage()) {
AddImage(warp.GetWarpedImage(),info.path().toStdString()+"/"+info.completeBaseName().toStdString()+"_warped.mhd");
AddImage(warp.GetDiffImage() ,info.path().toStdString()+"/"+info.completeBaseName().toStdString()+"_diff.mhd");
for (int i = 0; i < files.size(); i++) {
itk::ImageIOBase::Pointer reader = itk::ImageIOFactory::CreateImageIO(
- files[i].toStdString().c_str(), itk::ImageIOFactory::ReadMode);
+ files[i].toStdString().c_str(), itk::ImageIOFactory::ReadMode);
reader->SetFileName(files[i].toStdString().c_str());
reader->ReadImageInformation();
if (reader) {
currentSpacing[j] = reader->GetSpacing(j);
currentSize[j] = reader->GetDimensions(j);
} else if (currentDim != reader->GetNumberOfDimensions()
- || currentSpacing[j] != reader->GetSpacing(j)
- || currentSize[j] != (int)reader->GetDimensions(j)
- || currentOrigin[j] != reader->GetOrigin(j)) {
- QString error = "Cannot read file (too different from others ";
- error += files[i].toStdString().c_str();
- QMessageBox::information(this,tr("Reading problem"),error);
- IsOk = false;
- break;
+ || currentSpacing[j] != reader->GetSpacing(j)
+ || currentSize[j] != (int)reader->GetDimensions(j)
+ || currentOrigin[j] != reader->GetOrigin(j)) {
+ QString error = "Cannot read file (too different from others ";
+ error += files[i].toStdString().c_str();
+ QMessageBox::information(this,tr("Reading problem"),error);
+ IsOk = false;
+ break;
}
}
if (IsOk)
int numberofsuccesulreads=0;
//open images as 1 or multiples
for (int i = 0; i < fileSize; i++) {
-
progress.SetText("Opening " + files[i]);
progress.SetProgress(i,fileSize);
qApp->processEvents();
else {
SetImageSucceed = imageManager->SetImages(files,filetype, number);
}
+
if (!SetImageSucceed) {
QApplication::restoreOverrideCursor();
QString error = "Cannot open file \n";
cButton->setToolTip(tr("close image"));
cButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/exit.png")));
connect(cButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
- this,SLOT(CloseImage(QTreeWidgetItem*, int)));
+ this,SLOT(CloseImage(QTreeWidgetItem*, int)));
QTreePushButton* rButton = new QTreePushButton;
rButton->setItem(item);
rButton->setToolTip(tr("reload image"));
rButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/rotateright.png")));
connect(rButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
- this,SLOT(ReloadImage(QTreeWidgetItem*, int)));
+ this,SLOT(ReloadImage(QTreeWidgetItem*, int)));
DataTree->addTopLevelItem(item);
DataTree->setItemWidget(item, COLUMN_CLOSE_IMAGE, cButton);
linkPanel->addImage(imageManager->GetFileName(), id.toStdString());
connect(mSlicerManagers.back(), SIGNAL(currentImageChanged(std::string)),
- this,SLOT(CurrentImageChanged(std::string)));
+ this,SLOT(CurrentImageChanged(std::string)));
connect(mSlicerManagers.back(), SIGNAL(currentPickedImageChanged(std::string)),
- this, SLOT(CurrentPickedImageChanged(std::string)));
+ this, SLOT(CurrentPickedImageChanged(std::string)));
connect(mSlicerManagers.back(), SIGNAL(UpdatePosition(int, double, double, double, double, double, double, double)),
- this,SLOT(MousePositionChanged(int,double, double, double, double, double, double, double)));
+ this,SLOT(MousePositionChanged(int,double, double, double, double, double, double, double)));
connect(mSlicerManagers.back(), SIGNAL(UpdateVector(int, double, double, double, double)),
- this, SLOT(VectorChanged(int,double,double,double, double)));
+ this, SLOT(VectorChanged(int,double,double,double, double)));
connect(mSlicerManagers.back(), SIGNAL(UpdateOverlay(int, double, double)),
- this, SLOT(OverlayChanged(int,double,double)));
+ this, SLOT(OverlayChanged(int,double,double)));
connect(mSlicerManagers.back(), SIGNAL(UpdateFusion(int, double)),
- this, SLOT(FusionChanged(int,double)));
+ this, SLOT(FusionChanged(int,double)));
connect(mSlicerManagers.back(), SIGNAL(WindowLevelChanged()),
- this,SLOT(WindowLevelChanged()));
+ this,SLOT(WindowLevelChanged()));
connect(mSlicerManagers.back(), SIGNAL(UpdateSlice(int,int)),
- this,SLOT(UpdateSlice(int,int)));
- connect(mSlicerManagers.back(), SIGNAL(UpdateTSlice(int, int)),
- this,SLOT(UpdateTSlice(int, int)));
- connect(mSlicerManagers.back(), SIGNAL(UpdateTSlice(int, int)),
- this,SLOT(ImageInfoChanged()));
+ this,SLOT(UpdateSlice(int,int)));
+ connect(mSlicerManagers.back(), SIGNAL(UpdateTSlice(int, int, int)),
+ this,SLOT(UpdateTSlice(int, int, int)));
+ connect(mSlicerManagers.back(), SIGNAL(UpdateTSlice(int, int, int)),
+ this,SLOT(ImageInfoChanged()));
connect(mSlicerManagers.back(), SIGNAL(UpdateSliceRange(int,int,int,int,int)),
- this,SLOT(UpdateSliceRange(int,int,int,int,int)));
+ this,SLOT(UpdateSliceRange(int,int,int,int,int)));
connect(mSlicerManagers.back(), SIGNAL(UpdateLinkManager(std::string,int,double,double,double,int)),
- this,SLOT(UpdateLinkManager(std::string,int,double,double,double,int)));
+ this,SLOT(UpdateLinkManager(std::string,int,double,double,double,int)));
connect(mSlicerManagers.back(), SIGNAL(UpdateLinkedNavigation(std::string,vvSlicerManager*,vvSlicer*)),
- this,SLOT(UpdateLinkedNavigation(std::string,vvSlicerManager*,vvSlicer*)));
+ this,SLOT(UpdateLinkedNavigation(std::string,vvSlicerManager*,vvSlicer*)));
connect(mSlicerManagers.back(), SIGNAL(ChangeImageWithIndexOffset(vvSlicerManager*,int,int)),
- this,SLOT(ChangeImageWithIndexOffset(vvSlicerManager*,int,int)));
+ this,SLOT(ChangeImageWithIndexOffset(vvSlicerManager*,int,int)));
connect(mSlicerManagers.back(),SIGNAL(LandmarkAdded()),landmarksPanel,SLOT(AddPoint()));
+
InitSlicers();
numberofsuccesulreads++;
}
double range[2];
mSlicerManagers.back()->GetImage()->GetFirstVTKImageData()->GetScalarRange(range);
if ((range[0] == 0) && (range[1] == 1)) {
- presetComboBox->setCurrentIndex(5);// binary
+ presetComboBox->setCurrentIndex(WL_BINARY);// binary
} else {
// TODO
}
actionAdd_VF_to_current_Image->setEnabled(1);
actionAdd_fusion_image->setEnabled(1);
actionAdd_overlay_image_to_current_image->setEnabled(1);
+ actionAdd_USSequence_toCT->setEnabled(1);
actionNorth_East_Window->setEnabled(1);
actionNorth_West_Window->setEnabled(1);
actionSouth_East_Window->setEnabled(1);
colorMapComboBox->setEnabled(1);
for (int i = 0; i < DataTree->topLevelItem(index)->childCount(); i++) {
if (DataTree->topLevelItem(index)->child(i)->data(1,Qt::UserRole).toString() == "overlay" ||
- DataTree->topLevelItem(index)->child(i)->data(1,Qt::UserRole).toString() == "fusion") {
- colorMapComboBox->setEnabled(0);
- break;
+ DataTree->topLevelItem(index)->child(i)->data(1,Qt::UserRole).toString() == "fusion" ||
+ DataTree->topLevelItem(index)->child(i)->data(1,Qt::UserRole).toString() == "fusionSequence") {
+ colorMapComboBox->setEnabled(0);
+ break;
}
}
QString image = DataTree->selectedItems()[0]->data(COLUMN_IMAGE_NAME,Qt::DisplayRole).toString();
int nframes = mSlicerManagers[index]->GetSlicer(0)->GetTMax();
+
if (nframes > 1 || playMode == 1) {
playButton->setEnabled(1);
frameRateLabel->setEnabled(1);
imageSelected = mSlicerManagers[index]->GetSlicer(0)->GetFusion();
tSlice = mSlicerManagers[index]->GetSlicer(0)->GetFusionTSlice();
}
+ else if (DataTree->selectedItems()[0]->data(1,Qt::UserRole).toString() == "fusionSequence") {
+ imageSelected = mSlicerManagers[index]->GetSlicer(0)->GetFusion();
+ tSlice = mSlicerManagers[index]->GetSlicer(0)->GetFusionTSlice();
+ }
else if (DataTree->selectedItems()[0]->data(1,Qt::UserRole).toString() == "contour") {
imageSelected = mSlicerManagers[index]->GetSlicer(0)->GetImage();
tSlice = mSlicerManagers[index]->GetSlicer(0)->GetTSlice();
NPixel *= inputSize[i];
}
inputSizeInBytes = GetSizeInBytes(imageSelected->GetActualMemorySize()*1000);
-
+
QString dim = QString::number(dimension) + " (";
dim += pixelType + ")";
infoPanel->setOrigin(GetVectorDoubleAsString(origin));
infoPanel->setSpacing(GetVectorDoubleAsString(inputSpacing));
infoPanel->setNPixel(QString::number(NPixel)+" ("+inputSizeInBytes+")");
+
transformation = imageSelected->GetTransform()[tSlice]->GetMatrix();
infoPanel->setTransformation(Get4x4MatrixDoubleAsString(transformation));
// }
// }
WindowLevelChanged();
+
slicingPresetComboBox->setCurrentIndex(mSlicerManagers[index]->GetSlicingPreset());
if (mSlicerManagers[index]->GetSlicer(0)->GetVF()) {
overlayPanel->getVFName(mSlicerManagers[index]->GetVFName().c_str());
overlayPanel->getVFProperty(mSlicerManagers[index]->GetSlicer(0)->GetVFSubSampling(),
- mSlicerManagers[index]->GetSlicer(0)->GetVFScale(),
- mSlicerManagers[index]->GetSlicer(0)->GetVFLog());
+ mSlicerManagers[index]->GetSlicer(0)->GetVFScale(),
+ mSlicerManagers[index]->GetSlicer(0)->GetVFLog());
} else {
overlayPanel->getVFName(mSlicerManagers[index]->GetVFName().c_str());
overlayPanel->getVFProperty(-1,-1,-1);
} else {
overlayPanel->getOverlayName(mSlicerManagers[index]->GetOverlayName().c_str());
}
-
+
if (mSlicerManagers[index]->GetSlicer(0)->GetFusion()) {
overlayPanel->getFusionName(mSlicerManagers[index]->GetFusionName().c_str());
} else {
sizes[3].cols[0] = 1;
sizes[3].cols[1] = 2;
sizes[3].cols[2] = 3;
-
+
int slicer = mSlicerManagers[mCurrentPickedImageIndex]->GetSelectedSlicer();
if (viewMode == 1) {
if (slicer >= 0) {
** the associated Slicer to redraw crosses.
*/
for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
-// if (DataTree->topLevelItem(i)->data(COLUMN_UL_VIEW,Qt::CheckStateRole).toInt() > 1)
- mSlicerManagers[i]->GetSlicer(0)->Render();
- mSlicerManagers[i]->GetSlicer(1)->Render();
-// if (DataTree->topLevelItem(i)->data(COLUMN_DL_VIEW,Qt::CheckStateRole).toInt() > 1)
- mSlicerManagers[i]->GetSlicer(2)->Render();
- mSlicerManagers[i]->GetSlicer(3)->Render();
+ // if (DataTree->topLevelItem(i)->data(COLUMN_UL_VIEW,Qt::CheckStateRole).toInt() > 1)
+ mSlicerManagers[i]->GetSlicer(0)->Render();
+ mSlicerManagers[i]->GetSlicer(1)->Render();
+ // if (DataTree->topLevelItem(i)->data(COLUMN_DL_VIEW,Qt::CheckStateRole).toInt() > 1)
+ mSlicerManagers[i]->GetSlicer(2)->Render();
+ mSlicerManagers[i]->GetSlicer(3)->Render();
}
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
+//this actually returns the SlicerManager index!
int vvMainWindow::GetSlicerIndexFromItem(QTreeWidgetItem* item)
{
QString id = item->data(COLUMN_IMAGE_NAME,Qt::UserRole).toString();
QString warning = "Do you really want to close the overlay : ";
warning += item->data(COLUMN_IMAGE_NAME,Qt::DisplayRole).toString();
QMessageBox msgBox(QMessageBox::Warning, tr("Close Overlay"),
- warning, 0, this);
+ warning, 0, this);
msgBox.addButton(tr("Close"), QMessageBox::AcceptRole);
msgBox.addButton(tr("Cancel"), QMessageBox::RejectRole);
if (msgBox.exec() == QMessageBox::AcceptRole) {
int overlay_index=0;
for (int child = 0; child < DataTree->topLevelItem(index)->childCount(); child++) {
if (DataTree->topLevelItem(index)->\
- child(child)->data(1,Qt::UserRole).toString().toStdString() == overlay_type)
+ child(child)->data(1,Qt::UserRole).toString().toStdString() == overlay_type)
overlay_index++;
if (DataTree->topLevelItem(index)->child(child) == item) break;
}
+ if (overlay_type=="fusionSequence") {
+ //removing the overlay sequence in a fusion sequence visualization mode
+ //reset the transforms
+ overlayPanel->getFusionSequenceProperty(-1, false, 0, false);
+
+ //unlink and untie the slicer managers
+ RemoveLink(mSlicerManagers[index]->GetId().c_str(), mSlicerManagers[mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager()]->GetId().c_str());
+ mSlicerManagers[index]->SetFusionSequenceInvolvmentCode(-1);
+ mSlicerManagers[mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager()]->SetFusionSequenceInvolvmentCode(-1);
+ for (unsigned i=0 ; i<4 ; i++) {
+ mSlicerManagers[index]->GetSlicer(i)->SetFusionSequenceCode(-1);
+ mSlicerManagers[mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager()]->GetSlicer(i)->SetFusionSequenceCode(-1);
+ }
+
+ }
mSlicerManagers[index]->RemoveActor(overlay_type, overlay_index-1);
mSlicerManagers[index]->SetColorMap(0);
DataTree->topLevelItem(index)->takeChild(DataTree->topLevelItem(index)->indexOfChild(item));
warning += item->data(COLUMN_IMAGE_NAME,Qt::DisplayRole).toString();
warning += "\nThis is the last image, you're about to close vv !!!";
QMessageBox msgBox(QMessageBox::Warning, tr("Close Image"),
- warning, 0, this);
+ warning, 0, this);
msgBox.addButton(tr("Close vv"), QMessageBox::AcceptRole);
msgBox.addButton(tr("Cancel"), QMessageBox::RejectRole);
if (msgBox.exec() == QMessageBox::AcceptRole) {
QString warning = "Do you really want to close the image : ";
warning += item->data(COLUMN_IMAGE_NAME,Qt::DisplayRole).toString();
QMessageBox msgBox(QMessageBox::Warning, tr("Close Image"),
- warning, 0, this);
+ warning, 0, this);
msgBox.addButton(tr("Close"), QMessageBox::AcceptRole);
msgBox.addButton(tr("Cancel"), QMessageBox::RejectRole);
if (msgBox.exec() == QMessageBox::AcceptRole) {
for (int i = 0; i < index; i++) {
Manageriter++;
}
+ //if the slicer manager was involved in a fusion sequence visualization...
+ if ( mSlicerManagers[index]->IsInvolvedInFusionSequence() ) {
+ //reset the transforms
+ overlayPanel->getFusionSequenceProperty(-1, false, 0, false);
+
+ //unlink and untie the slicer managers
+ RemoveLink(mSlicerManagers[index]->GetId().c_str(), mSlicerManagers[mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager()]->GetId().c_str());
+ mSlicerManagers[index]->SetFusionSequenceInvolvmentCode(-1);
+ mSlicerManagers[mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager()]->SetFusionSequenceInvolvmentCode(-1);
+ for (unsigned i=0 ; i<4 ; i++) {
+ mSlicerManagers[index]->GetSlicer(i)->SetFusionSequenceCode(-1);
+ mSlicerManagers[mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager()]->GetSlicer(i)->SetFusionSequenceCode(-1);
+ }
+
+ //TODO: also remove the image overlaid with the main sequence, as it is becoming invalid...
+ }
+
linkPanel->removeImage(index);
mSlicerManagers[index]->RemoveActors();
+
+ //remove the slicer manager
delete mSlicerManagers[index];
mSlicerManagers.erase(Manageriter);
int index = GetSlicerIndexFromItem(item);
QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
QString role=item->data(1,Qt::UserRole).toString();
- if ( role == "vector"){
+ if ( role == "vector") {
mSlicerManagers[index]->ReloadVF();
}
- else if (role == "overlay"){
+ else if (role == "overlay") {
mSlicerManagers[index]->ReloadOverlay();
}
- else if (role == "fusion"){
+ else if (role == "fusion") {
mSlicerManagers[index]->ReloadFusion();
}
- else{
+ else if (role == "fusionSequence") {
+ //both versions of the secondary sequence must be updated.
+ mSlicerManagers[index]->ReloadFusionSequence();
+ mSlicerManagers[mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager()]->Reload();
+ }
+ else {
mSlicerManagers[index]->Reload();
+ //if we update the secondary sequence, then the overlay of the main sequence should also be updated
+ if (mSlicerManagers[index]->IsSecondarySequenceOfFusionSequence()) mSlicerManagers[mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager()]->ReloadFusionSequence();
}
// Update view and info
ImageInfoChanged();
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
+//called when AddOverlayImage, AddFusionSequence
+//or when UpdateWindowLevel() is called ; when slicerManager emits WindowLevelChanged
+//when ImageInfoChanged() is called
void vvMainWindow::WindowLevelChanged()
{
// Base image
// Overlay image
if (mSlicerManagers[index]->GetSlicer(0)->GetOverlay())
overlayPanel->getOverlayProperty(mSlicerManagers[index]->GetOverlayColor(),
- mSlicerManagers[index]->GetLinkOverlayWindowLevel(),
- mSlicerManagers[index]->GetOverlayColorWindow(),
- mSlicerManagers[index]->GetOverlayColorLevel());
+ mSlicerManagers[index]->GetLinkOverlayWindowLevel(),
+ mSlicerManagers[index]->GetOverlayColorWindow(),
+ mSlicerManagers[index]->GetOverlayColorLevel());
else
overlayPanel->getOverlayProperty(-1,0,0.,0.);
- // Fusion image
- if (mSlicerManagers[index]->GetSlicer(0)->GetFusion())
+ // Fusion & SequenceFusion image
+ if (mSlicerManagers[index]->GetSlicer(0)->GetFusion()) {
overlayPanel->getFusionProperty(mSlicerManagers[index]->GetFusionOpacity(),
- mSlicerManagers[index]->GetFusionThresholdOpacity(),
- mSlicerManagers[index]->GetFusionColorMap(),
- mSlicerManagers[index]->GetFusionWindow(),
- mSlicerManagers[index]->GetFusionLevel());
+ mSlicerManagers[index]->GetFusionThresholdOpacity(),
+ mSlicerManagers[index]->GetFusionColorMap(),
+ mSlicerManagers[index]->GetFusionWindow(),
+ mSlicerManagers[index]->GetFusionLevel());
+ if (mSlicerManagers[index]->IsMainSequenceOfFusionSequence()) {
+ overlayPanel->getFusionSequenceProperty(mSlicerManagers[index]->GetFusionSequenceFrameIndex(),
+ mSlicerManagers[index]->GetFusionSequenceSpatialSyncFlag(),
+ mSlicerManagers[index]->GetFusionSequenceNbFrames(),
+ mSlicerManagers[index]->GetFusionSequenceTemporalSyncFlag());
+ }
+ }
+ else if ( mSlicerManagers[index]->IsSecondarySequenceOfFusionSequence() ) {
+ //if the image is involved in a fusion sequence, preserve the overlay panel!
+ int ind = mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager();
+ overlayPanel->getFusionProperty(mSlicerManagers[ind]->GetFusionOpacity(),
+ mSlicerManagers[ind]->GetFusionThresholdOpacity(),
+ mSlicerManagers[ind]->GetFusionColorMap(),
+ mSlicerManagers[ind]->GetFusionWindow(),
+ mSlicerManagers[ind]->GetFusionLevel());
+ overlayPanel->getFusionSequenceProperty(mSlicerManagers[ind]->GetFusionSequenceFrameIndex(),
+ mSlicerManagers[ind]->GetFusionSequenceSpatialSyncFlag(),
+ mSlicerManagers[ind]->GetFusionSequenceNbFrames(),
+ mSlicerManagers[ind]->GetFusionSequenceTemporalSyncFlag());
+ }
else
+ {
overlayPanel->getFusionProperty(-1, -1, -1, -1, -1);
+ overlayPanel->getFusionSequenceProperty(-1, false, 0, false);
+ }
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::WindowLevelEdited()
{
- presetComboBox->setCurrentIndex(6);
+ presetComboBox->setCurrentIndex(WL_USER);
UpdateWindowLevel();
}
//------------------------------------------------------------------------------
{
windowSpinBox->setValue(w);
levelSpinBox->setValue(l);
- presetComboBox->setCurrentIndex(6);
+ presetComboBox->setCurrentIndex(WL_USER);
colorMapComboBox->setCurrentIndex(0);
UpdateWindowLevel();
}
void vvMainWindow::UpdateWindowLevel()
{
if (DataTree->selectedItems().size()) {
- if (presetComboBox->currentIndex() == 7) //For ventilation
+ if (presetComboBox->currentIndex() == WL_VENTILATION) //For ventilation
colorMapComboBox->setCurrentIndex(5);
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
mSlicerManagers[index]->SetColorWindow(windowSpinBox->value());
{
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
int window = mSlicerManagers[index]->GetColorWindow();
- presetComboBox->setCurrentIndex(6);
+ presetComboBox->setCurrentIndex(WL_USER);
windowSpinBox->setValue(-window);
UpdateWindowLevel();
}
continue;
mSlicerManagers[i]->SetColorWindow(window);
mSlicerManagers[i]->SetColorLevel(level);
- mSlicerManagers[i]->SetPreset(6);
+ mSlicerManagers[i]->SetPreset(WL_USER);
mSlicerManagers[i]->Render();
}
}
if (mSlicerManagers[i] == NULL)
continue;
mSlicerManagers[i]->SetColorWindow(window);
- mSlicerManagers[i]->SetPreset(6);
+ mSlicerManagers[i]->SetPreset(WL_USER);
mSlicerManagers[i]->Render();
}
}
if (mSlicerManagers[i] == NULL)
continue;
mSlicerManagers[i]->SetColorLevel(level);
- mSlicerManagers[i]->SetPreset(6);
+ mSlicerManagers[i]->SetPreset(WL_USER);
mSlicerManagers[i]->Render();
}
}
{
for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
if (mSlicerManagers[i]->GetId() == id) {
- //mSlicerManagers[i]->SetTSlice(temps);
mSlicerManagers[i]->GetSlicer(slicer)->SetCurrentPosition(x,y,z,temps);
mSlicerManagers[i]->UpdateViews(0,slicer);
break;
contextActions[1]->setEnabled(1);
contextActions[2]->setEnabled(
DataTree->itemWidget(DataTree->selectedItems()[0],
- COLUMN_RELOAD_IMAGE)->isEnabled());
+ COLUMN_RELOAD_IMAGE)->isEnabled());
contextActions[3]->setEnabled(1);
contextActions[5]->setEnabled(1);
contextActions[6]->setEnabled(1);
return;
}
- QString Extensions = EXTENSIONS;
- Extensions += ";;All Files (*)";
- QStringList files = QFileDialog::getOpenFileNames(this,tr("Load Overlay image"),mInputPathName,Extensions);
- if (files.isEmpty())
- return;
+ QString Extensions = EXTENSIONS;
+ Extensions += ";;All Files (*)";
+ QStringList files = QFileDialog::getOpenFileNames(this,tr("Load Overlay image"),mInputPathName,Extensions);
+ if (files.isEmpty())
+ return;
- std::vector<std::string> vecFileNames;
- for (int i = 0; i < files.size(); i++) {
- vecFileNames.push_back(files[i].toStdString());
- }
- AddOverlayImage(index,vecFileNames,vvImageReader::IMAGE);
+ std::vector<std::string> vecFileNames;
+ for (int i = 0; i < files.size(); i++) {
+ vecFileNames.push_back(files[i].toStdString());
+ }
+ AddOverlayImage(index,vecFileNames,vvImageReader::IMAGE);
}
//------------------------------------------------------------------------------
{
mInputPathName = itksys::SystemTools::GetFilenamePath(file.toStdString()).c_str();
itk::ImageIOBase::Pointer reader = itk::ImageIOFactory::CreateImageIO(
- file.toStdString().c_str(), itk::ImageIOFactory::ReadMode);
+ file.toStdString().c_str(), itk::ImageIOFactory::ReadMode);
reader->SetFileName(fileNames[0].c_str());
reader->ReadImageInformation();
std::string component = reader->GetComponentTypeAsString(reader->GetComponentType());
cButton->setToolTip(tr("close image"));
cButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/exit.png")));
connect(cButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
- this,SLOT(CloseImage(QTreeWidgetItem*, int)));
+ this,SLOT(CloseImage(QTreeWidgetItem*, int)));
QTreePushButton* rButton = new QTreePushButton;
rButton->setItem(item);
rButton->setToolTip(tr("reload image"));
rButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/rotateright.png")));
connect(rButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
- this,SLOT(ReloadImage(QTreeWidgetItem*, int)));
+ this,SLOT(ReloadImage(QTreeWidgetItem*, int)));
DataTree->topLevelItem(index)->setExpanded(1);
DataTree->topLevelItem(index)->addChild(item);
mReader->SetInputFilename(filename.toStdString());
mReader->Update(IMAGE);
if (mReader->GetLastError().size() != 0) {
- std::cerr << "Error while reading " << filename.toStdString() << std::endl;
- QString error = "Cannot open file \n";
- error += mReader->GetLastError().c_str();
- QMessageBox::information(this,tr("Reading problem"),error);
- delete mReader;
- return;
+ std::cerr << "Error while reading " << filename.toStdString() << std::endl;
+ QString error = "Cannot open file \n";
+ error += mReader->GetLastError().c_str();
+ QMessageBox::information(this,tr("Reading problem"),error);
+ delete mReader;
+ return;
}
vvImage::Pointer roi = mReader->GetOutput();
//check if one fusion image is added
for (int child = 0; child < DataTree->topLevelItem(index)->childCount(); child++)
- if (DataTree->topLevelItem(index)->child(child)->data(1,Qt::UserRole).toString() == "fusion") {
- QString error = "Cannot add more than one fusion image\n";
- error += "Please remove first ";
- error += DataTree->topLevelItem(index)->child(child)->data(COLUMN_IMAGE_NAME,Qt::DisplayRole).toString();
- QMessageBox::information(this,tr("Problem adding fusion image !"),error);
- return;
+ if ( (DataTree->topLevelItem(index)->child(child)->data(1,Qt::UserRole).toString() == "fusion") ||
+ (DataTree->topLevelItem(index)->child(child)->data(1,Qt::UserRole).toString() == "fusionSequence") ) {
+ QString error = "Cannot add more than one fusion image\n";
+ error += "Please remove first ";
+ error += DataTree->topLevelItem(index)->child(child)->data(COLUMN_IMAGE_NAME,Qt::DisplayRole).toString();
+ QMessageBox::information(this,tr("Problem adding fusion image !"),error);
+ return;
}
- QString Extensions = EXTENSIONS;
- Extensions += ";;All Files (*)";
- QString file = QFileDialog::getOpenFileName(this,tr("Load Fusion image"),mInputPathName,Extensions);
- if (!file.isEmpty())
- AddFusionImage(index,file);
+ QString Extensions = EXTENSIONS;
+ Extensions += ";;All Files (*)";
+ QString file = QFileDialog::getOpenFileName(this,tr("Load Fusion image"),mInputPathName,Extensions);
+ if (!file.isEmpty())
+ AddFusionImage(index,file);
}
//------------------------------------------------------------------------------
{
mInputPathName = itksys::SystemTools::GetFilenamePath(file.toStdString()).c_str();
itk::ImageIOBase::Pointer reader = itk::ImageIOFactory::CreateImageIO(
- file.toStdString().c_str(), itk::ImageIOFactory::ReadMode);
+ file.toStdString().c_str(), itk::ImageIOFactory::ReadMode);
reader->SetFileName(file.toStdString().c_str());
reader->ReadImageInformation();
std::string component = reader->GetComponentTypeAsString(reader->GetComponentType());
std::string filename = itksys::SystemTools::GetFilenameWithoutExtension(file.toStdString()).c_str();
if (mSlicerManagers[index]->SetFusion(file.toStdString(),
- reader->GetNumberOfDimensions(), component)) {
- //create an item in the tree with good settings
- QTreeWidgetItem *item = new QTreeWidgetItem();
- item->setData(0,Qt::UserRole,file.toStdString().c_str());
- item->setData(1,Qt::UserRole,tr("fusion"));
- QFileInfo fileinfo(filename.c_str()); //Do not show the path
- item->setData(COLUMN_IMAGE_NAME,Qt::DisplayRole,fileinfo.fileName());
- item->setToolTip(COLUMN_IMAGE_NAME, mSlicerManagers[index]->GetListOfAbsoluteFilePathInOneString("fusion").c_str());
- qApp->processEvents();
-
- for (int j = 1; j <= 4; j++) {
- item->setData(j,Qt::CheckStateRole,DataTree->topLevelItem(index)->data(j,Qt::CheckStateRole));
- }
+ reader->GetNumberOfDimensions(), component)) {
+ //create an item in the tree with good settings
+ QTreeWidgetItem *item = new QTreeWidgetItem();
+ item->setData(0,Qt::UserRole,file.toStdString().c_str());
+ item->setData(1,Qt::UserRole,tr("fusion"));
+ QFileInfo fileinfo(filename.c_str()); //Do not show the path
+ item->setData(COLUMN_IMAGE_NAME,Qt::DisplayRole,fileinfo.fileName());
+ item->setToolTip(COLUMN_IMAGE_NAME, mSlicerManagers[index]->GetListOfAbsoluteFilePathInOneString("fusion").c_str());
+ qApp->processEvents();
+
+ for (int j = 1; j <= 4; j++) {
+ item->setData(j,Qt::CheckStateRole,DataTree->topLevelItem(index)->data(j,Qt::CheckStateRole));
+ }
- //Create the buttons for reload and close
- qApp->processEvents();
- QTreePushButton* cButton = new QTreePushButton;
- cButton->setItem(item);
- cButton->setColumn(COLUMN_CLOSE_IMAGE);
- cButton->setToolTip(tr("close image"));
- cButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/exit.png")));
- connect(cButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
+ //Create the buttons for reload and close
+ qApp->processEvents();
+ QTreePushButton* cButton = new QTreePushButton;
+ cButton->setItem(item);
+ cButton->setColumn(COLUMN_CLOSE_IMAGE);
+ cButton->setToolTip(tr("close image"));
+ cButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/exit.png")));
+ connect(cButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
this,SLOT(CloseImage(QTreeWidgetItem*, int)));
- QTreePushButton* rButton = new QTreePushButton;
- rButton->setItem(item);
- rButton->setColumn(COLUMN_RELOAD_IMAGE);
- rButton->setToolTip(tr("reload image"));
- rButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/rotateright.png")));
- connect(rButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
+ QTreePushButton* rButton = new QTreePushButton;
+ rButton->setItem(item);
+ rButton->setColumn(COLUMN_RELOAD_IMAGE);
+ rButton->setToolTip(tr("reload image"));
+ rButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/rotateright.png")));
+ connect(rButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
this,SLOT(ReloadImage(QTreeWidgetItem*, int)));
- DataTree->topLevelItem(index)->setExpanded(1);
- DataTree->topLevelItem(index)->addChild(item);
- DataTree->setItemWidget(item, COLUMN_CLOSE_IMAGE, cButton);
- DataTree->setItemWidget(item, COLUMN_RELOAD_IMAGE, rButton);
-
- //set the id of the image
- QString id = DataTree->topLevelItem(index)->data(COLUMN_IMAGE_NAME,Qt::UserRole).toString();
- item->setData(COLUMN_IMAGE_NAME,Qt::UserRole,id.toStdString().c_str());
- UpdateTree();
- qApp->processEvents();
- ImageInfoChanged();
- QApplication::restoreOverrideCursor();
+ DataTree->topLevelItem(index)->setExpanded(1);
+ DataTree->topLevelItem(index)->addChild(item);
+ DataTree->setItemWidget(item, COLUMN_CLOSE_IMAGE, cButton);
+ DataTree->setItemWidget(item, COLUMN_RELOAD_IMAGE, rButton);
+
+ //set the id of the image
+ QString id = DataTree->topLevelItem(index)->data(COLUMN_IMAGE_NAME,Qt::UserRole).toString();
+ item->setData(COLUMN_IMAGE_NAME,Qt::UserRole,id.toStdString().c_str());
+ UpdateTree();
+ qApp->processEvents();
+ ImageInfoChanged();
+ QApplication::restoreOverrideCursor();
} else {
QApplication::restoreOverrideCursor();
QString error = "Cannot import the new image.\n";
return;
}
- QString Extensions = "Images ( *.mhd)";
- Extensions += ";;Images ( *.mha)";
- Extensions += ";;VF Images ( *.vf)";
- Extensions += ";;nii Images ( *.nii)";
- Extensions += ";;nrrd Images ( *.nrrd)";
- Extensions += ";;nhdr Images ( *.nhdr)";
- Extensions += ";;All Files (*)";
- QString file = QFileDialog::getOpenFileName(this,tr("Load deformation field"),mInputPathName,Extensions);
- if (!file.isEmpty())
- AddField(file,index);
+ QString Extensions = "Images ( *.mhd)";
+ Extensions += ";;Images ( *.mha)";
+ Extensions += ";;VF Images ( *.vf)";
+ Extensions += ";;nii Images ( *.nii)";
+ Extensions += ";;nrrd Images ( *.nrrd)";
+ Extensions += ";;nhdr Images ( *.nhdr)";
+ Extensions += ";;All Files (*)";
+ QString file = QFileDialog::getOpenFileName(this,tr("Load deformation field"),mInputPathName,Extensions);
+ if (!file.isEmpty())
+ AddField(file,index);
}
//------------------------------------------------------------------------------
cButton->setToolTip(tr("close vector field"));
cButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/exit.png")));
connect(cButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
- this,SLOT(CloseImage(QTreeWidgetItem*, int)));
+ this,SLOT(CloseImage(QTreeWidgetItem*, int)));
QTreePushButton* rButton = new QTreePushButton;
rButton->setItem(item);
rButton->setEnabled(from_disk);
rButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/rotateright.png")));
connect(rButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
- this,SLOT(ReloadImage(QTreeWidgetItem*, int)));
+ this,SLOT(ReloadImage(QTreeWidgetItem*, int)));
DataTree->topLevelItem(index)->setExpanded(1);
DataTree->topLevelItem(index)->addChild(item);
}
//------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+void vvMainWindow::SelectFusionSequence()
+{
+ //get the index of the slicer manager of the main sequence (CT)
+ int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
+ //check if one overlay image is already associated
+ for (int child = 0; child < DataTree->topLevelItem(index)->childCount(); child++)
+ if ( (DataTree->topLevelItem(index)->child(child)->data(1,Qt::UserRole).toString() == "fusion") ||
+ (DataTree->topLevelItem(index)->child(child)->data(1,Qt::UserRole).toString() == "fusionSequence") ) {
+ QString error = "Cannot add more than one compared image\n";
+ error += "Please remove first ";
+ error += DataTree->topLevelItem(index)->child(child)->data(COLUMN_IMAGE_NAME,Qt::DisplayRole).toString();
+ QMessageBox::information(this,tr("Problem adding compared image !"),error);
+ return;
+ }
+
+ QString Extensions = EXTENSIONS;
+ Extensions += ";;All Files (*)";
+ QStringList files = QFileDialog::getOpenFileNames(this,tr("Load Overlay image sequence"),mInputPathName,Extensions);
+ if (files.isEmpty())
+ return;
+
+ std::vector<std::string> vecFileNames;
+ for (int i = 0; i < files.size(); i++) {
+ vecFileNames.push_back(files[i].toStdString());
+ }
+
+ //associate the secondary sequence (US) to the main one
+ AddFusionSequence(index,vecFileNames,vvImageReader::MERGEDWITHTIME);
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+void vvMainWindow::SelectFusionSequenceTemporalSignal() {
+
+ //make sure the index is right?
+ //in the end, I should attach the temporal data to the right sequence!
+ int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
+ //in case the other sequence got selected, make sure we select the primary sequence
+ if ( (!mSlicerManagers[index]->GetSlicer(0)->GetFusion()) && mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager()>=0 ) {
+ index = mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager();
+ }
+
+ //open a dialog box to find a file
+ QString Extensions = EXTENSIONS;
+ Extensions += ";;All Files (*)";
+ QString fileName = QFileDialog::getOpenFileName(this,tr("Load respiratory signal for fused sequence"),mInputPathName,Extensions);
+ if (fileName.isNull())
+ return;
+
+ //read it as a vector of values
+ std::vector<double> signal;
+ //...TODO, look for itk functions that can do that... vnl in the worst case.
+ signal.push_back(1);signal.push_back(2);
+
+ //TODO: instead: if the loaded signal is longer, just crop it...
+ //this allows loading only the first few frames when testing.
+ //->maybe raise a message that this behavior may be unsafe...
+
+ //if compatible with the fused image sequence (number of images = number of entries), enable the temporalSync
+ if ( signal.size() >= mSlicerManagers[index]->GetFusionSequenceNbFrames()) {
+ //for convenience, associate this sequence to both the current slicer manager, and to the linked one
+ mSlicerManagers[index]->SetFusionSequenceTemporalSignal(signal);
+ mSlicerManagers[ mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager() ]->SetFusionSequenceTemporalSignal(signal);
+ overlayPanel->enableFusionSequenceTemporalSync();
+ QMessageBox::information(this,tr("Adding signal"),"would add the signal from file: "+ fileName);
+ }
+ else {//else, send a message to signal the failure...
+ QString error = "The provided signal doesn't have the same duration as the sequence\n";
+ error += "Ignoring file: " + fileName;
+ QMessageBox::information(this,tr("Problem adding signal!"),error);
+ return;
+ }
+
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+//when this function is called index is the slicer manager index corresponding to the main sequence (CT)
+//the files behind fileNames points to the data for the secondary sequence
+void vvMainWindow::AddFusionSequence(int index, std::vector<std::string> fileNames, vvImageReader::LoadedImageType type)
+{
+ QString file(fileNames[0].c_str());
+ if (QFile::exists(file))
+ {
+ mInputPathName = itksys::SystemTools::GetFilenamePath(file.toStdString()).c_str();
+ itk::ImageIOBase::Pointer reader = itk::ImageIOFactory::CreateImageIO(
+ file.toStdString().c_str(), itk::ImageIOFactory::ReadMode);
+ reader->SetFileName(fileNames[0].c_str());
+ reader->ReadImageInformation();
+ std::string component = reader->GetComponentTypeAsString(reader->GetComponentType());
+ int dimension = reader->GetNumberOfDimensions();
+ QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+ vvProgressDialog progress("Opening " + file.toStdString());
+ qApp->processEvents();
+
+ std::string filename = itksys::SystemTools::GetFilenameWithoutExtension(file.toStdString()).c_str();
+
+ if (mSlicerManagers[index]->SetFusionSequence(fileNames,dimension, component,type)) {
+ //create an item in the tree with good settings
+ QTreeWidgetItem *item = new QTreeWidgetItem();
+ item->setData(0,Qt::UserRole,file.toStdString().c_str());
+ item->setData(1,Qt::UserRole,tr("fusionSequence"));
+
+ QFileInfo fileinfo(file); //Do not show the path
+ item->setData(COLUMN_IMAGE_NAME,Qt::DisplayRole,fileinfo.fileName());
+ item->setToolTip(COLUMN_IMAGE_NAME, mSlicerManagers[index]->GetListOfAbsoluteFilePathInOneString("fusionSequence").c_str());
+ qApp->processEvents();
+ for (int j = 1; j <= 4; j++) {
+ item->setData(j,Qt::CheckStateRole,DataTree->topLevelItem(index)->data(j,Qt::CheckStateRole));
+ }
+
+ //Create the buttons for reload and close
+ qApp->processEvents();
+ QTreePushButton* cButton = new QTreePushButton;
+ cButton->setItem(item);
+ cButton->setColumn(COLUMN_CLOSE_IMAGE);
+ cButton->setToolTip(tr("close image"));
+ cButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/exit.png")));
+ connect(cButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
+ this,SLOT(CloseImage(QTreeWidgetItem*, int)));
+
+ QTreePushButton* rButton = new QTreePushButton;
+ rButton->setItem(item);
+ rButton->setColumn(COLUMN_RELOAD_IMAGE);
+ rButton->setToolTip(tr("reload image"));
+ rButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/rotateright.png")));
+ connect(rButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
+ this,SLOT(ReloadImage(QTreeWidgetItem*, int)));
+
+ DataTree->topLevelItem(index)->setExpanded(1);
+ DataTree->topLevelItem(index)->addChild(item);
+ DataTree->setItemWidget(item, COLUMN_CLOSE_IMAGE, cButton);
+ DataTree->setItemWidget(item, COLUMN_RELOAD_IMAGE, rButton);
+
+ //store the original transform matrix
+ int indexParent = GetSlicerIndexFromItem( DataTree->topLevelItem(index) );
+ mSlicerManagers[indexParent]->SetFusionSequenceMainTransformMatrix( mSlicerManagers[indexParent]->GetSlicer(0)->GetImage()->GetTransform()[0]->GetMatrix() );
+
+ //set the id of the image
+ QString id = DataTree->topLevelItem(index)->data(COLUMN_IMAGE_NAME,Qt::UserRole).toString();
+ item->setData(COLUMN_IMAGE_NAME,Qt::UserRole,id.toStdString().c_str());
+ UpdateTree();
+ qApp->processEvents();
+
+ //ImageInfoChanged();
+
+ QApplication::restoreOverrideCursor();
+ // Update the display to update, e.g., the sliders
+ for(int i=0; i<4; i++)
+ DisplaySliders(index, i);
+
+
+ //This loads the secondary sequence (US) as an independent sequence
+ LoadImages(fileNames, type);
+ //reset the transforms to identiy
+ for (unsigned i=0 ; i<mSlicerManagers.back()->GetImage()->GetTransform().size() ; i++) {
+ mSlicerManagers.back()->GetImage()->GetTransform()[i]->Identity();
+ mSlicerManagers.back()->GetImage()->GetTransform()[i]->Update();
+ }
+
+ //automatically link both images...
+ AddLink(mSlicerManagers[indexParent]->GetId().c_str(), mSlicerManagers.back()->GetId().c_str(), false);
+
+ //tie the main and secondary sequences by raising flags and informing each another of their respective SlicerManager indices
+ mSlicerManagers[indexParent]->SetFusionSequenceIndexOfLinkedManager(mSlicerManagers.size()-1);
+ mSlicerManagers[indexParent]->SetFusionSequenceInvolvmentCode(0); //main sequence
+ mSlicerManagers.back()->SetFusionSequenceIndexOfLinkedManager(indexParent);
+ mSlicerManagers.back()->SetFusionSequenceInvolvmentCode(1); //secondary sequence
+ for (unsigned i=0 ; i<4 ; i++) {
+ mSlicerManagers.back()->GetSlicer(i)->SetFusionSequenceCode(1); //flag the slicers of the secondary sequence
+ }
+
+ } else {
+ QApplication::restoreOverrideCursor();
+ QString error = "Cannot import the new image.\n";
+ error += mSlicerManagers[index]->GetLastError().c_str();
+ QMessageBox::information(this,tr("Problem reading image !"),error);
+ }
+ //WindowLevelChanged();
+ ImageInfoChanged(); //this internally calls WindowLevelChanged...
+ }
+ else {
+ QMessageBox::information(this,tr("Problem reading fusion sequence !"),"File doesn't exist!");
+ return;
+ }
+
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+//fusionSequenceFrameIndex and fusionSequenceNbFrames are relative to the secondary sequence (US)
+void vvMainWindow::SetFusionSequenceProperty(int fusionSequenceFrameIndex, bool spatialSyncFlag, unsigned int fusionSequenceNbFrames, bool temporalSyncFlag)
+{
+ int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
+
+ if (!mSlicerManagers[index]->IsInvolvedInFusionSequence()) return;
+
+ //check if the focus moved to the linked sequence, and in this case, select the master sequence instead
+ if (!mSlicerManagers[index]->IsMainSequenceOfFusionSequence()) {
+ index = mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager();
+ }
+ int secondaryIndex = mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager();
+ if (secondaryIndex==-1) return; //this should never happen
+ if ( (!mSlicerManagers[index]->IsMainSequenceOfFusionSequence()) ||
+ (!mSlicerManagers[secondaryIndex]->IsSecondarySequenceOfFusionSequence()) )
+ {return;} //this should never happen, raise an exception?
+
+ if (mSlicerManagers[index]->GetSlicer(0)->GetFusion()) {
+
+ //First, if the spatialSync button is unchecked, then reposition the parent sequence (CT) in its original coordinate frame
+ if ( (!spatialSyncFlag) && (mSlicerManagers[index]->GetFusionSequenceSpatialSyncFlag()) ) {
+ for ( unsigned i=0 ; i<mSlicerManagers[index]->GetSlicer(0)->GetImage()->GetTransform().size() ; i++ ) {
+ mSlicerManagers[index]->GetSlicer(0)->GetImage()->GetTransform()[i]->SetMatrix( mSlicerManagers[index]->GetFusionSequenceMainTransformMatrix() );
+ mSlicerManagers[index]->GetSlicer(0)->GetImage()->GetTransform()[i]->Update();
+ }
+
+ for (int i=0; i<mSlicerManagers[index]->GetNumberOfSlicers(); i++) {
+ mSlicerManagers[index]->GetSlicer(i)->ForceUpdateDisplayExtent();
+ mSlicerManagers[index]->GetSlicer(i)->Render();
+ }
+ }
+
+ //then, update the property values in the slicer manager
+ mSlicerManagers[index]->SetFusionSequenceLength(fusionSequenceNbFrames);
+ mSlicerManagers[index]->SetFusionSequenceSpatialSyncFlag(spatialSyncFlag);
+ mSlicerManagers[index]->SetFusionSequenceTemporalSyncFlag(temporalSyncFlag);
+ mSlicerManagers[index]->SetFusionSequenceFrameIndex(fusionSequenceFrameIndex);
+
+ //select the right frame of the US sequence
+ mSlicerManagers[index]->SetFusionSequenceTSlice(fusionSequenceFrameIndex); //here, I should only update the overlayed sequence
+ mSlicerManagers[secondaryIndex]->SetTSlice(fusionSequenceFrameIndex, false); //this should update the secondary sequence (individual version)
+
+ //update the horizontal sliders of the main window
+ overlayPanel->updateFusionSequenceSliderValueFromWindow(fusionSequenceFrameIndex, false);
+
+ if (spatialSyncFlag) { //reslice the CT
+
+ if (temporalSyncFlag) { //do the temporal synchronisation
+ //TODO: add the temporal synchronisation stuff
+ //if the button is checked, get the phase of the requested US frame from the available signal
+ //and select the corresponding one in the CT. (check the one just before, and the one just after, and select the closest)
+
+ //TODO: do it also the other way around, when modifying the time index related to CT, select a close frame
+ //this should not be done here directly, but the code should be inspired from the one here
+ //->find a good US frame such that when calling this function with this US frame, it produces the expected result
+
+
+ //TODO: select the right CT image to display
+ int mainSequenceFrameIndex=0;
+ //estimate the TSlice to set to the CT
+
+ //and set it!
+ mSlicerManagers[index]->SetTSlice(mainSequenceFrameIndex, false);
+ }
+
+
+ //Set the transform matrix of the parent sequence (typically CT / 4DCT)
+ vtkSmartPointer<vtkMatrix4x4> tmpMat = vtkSmartPointer<vtkMatrix4x4>::New();
+ vtkMatrix4x4::Invert( mSlicerManagers[index]->GetFusionSequenceInitialTransformMatrixAtFrame(fusionSequenceFrameIndex), tmpMat );
+ for ( unsigned i=0 ; i<mSlicerManagers[index]->GetSlicer(0)->GetImage()->GetTransform().size() ; i++ ) {
+ mSlicerManagers[index]->GetSlicer(0)->GetImage()->GetTransform()[i]->SetMatrix( mSlicerManagers[index]->GetFusionSequenceMainTransformMatrix() );
+ mSlicerManagers[index]->GetSlicer(0)->GetImage()->GetTransform()[i]->PreMultiply();
+ mSlicerManagers[index]->GetSlicer(0)->GetImage()->GetTransform()[i]->Concatenate( tmpMat );
+ mSlicerManagers[index]->GetSlicer(0)->GetImage()->GetTransform()[i]->Update();
+ }
+
+ for (int i=0; i<mSlicerManagers[index]->GetNumberOfSlicers(); i++) {
+ mSlicerManagers[index]->GetSlicer(i)->ForceUpdateDisplayExtent();
+ mSlicerManagers[index]->GetSlicer(i)->Render();
+ }
+
+ }
+
+ }
+}
+//------------------------------------------------------------------------------
+
+
//------------------------------------------------------------------------------
void vvMainWindow::SaveAs()
{
Extensions += ")";
}
QString fileName = QFileDialog::getSaveFileName(this,
- tr("Save As"),
- mSlicerManagers[index]->GetFileName().c_str(),
- Extensions);
+ tr("Save As"),
+ mSlicerManagers[index]->GetFileName().c_str(),
+ Extensions);
if (!fileName.isEmpty()) {
std::string fileformat = itksys::SystemTools::GetFilenameLastExtension(fileName.toStdString());
if (OutputListeFormat.contains(
- fileformat.c_str())) {
- QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
- std::string action = "Saving";
- vvProgressDialog progress("Saving "+fileName.toStdString());
- qApp->processEvents();
- vvImageWriter::Pointer writer = vvImageWriter::New();
- writer->SetOutputFileName(fileName.toStdString());
- writer->SetInput(mSlicerManagers[index]->GetImage());
-
- // Check on transform and prompt user
- writer->SetSaveTransform(false);
- bool bId = true;
- for(int i=0; i<4; i++)
- for(int j=0; j<4; j++) {
- // TODO SR and BP: check on the list of transforms and not the first only
- double elt = mSlicerManagers[index]->GetImage()->GetTransform()[0]->GetMatrix()->GetElement(i,j);
- if(i==j && elt!=1.)
- bId = false;
- if(i!=j && elt!=0.)
- bId = false;
- }
- if( !bId ) {
- QString warning = "The image has an associated linear transform. Do you want to save it along?";
- QMessageBox msgBox(QMessageBox::Warning, tr("Save transform"), warning, 0, this);
- msgBox.addButton(tr("Yes"), QMessageBox::AcceptRole);
- msgBox.addButton(tr("No"), QMessageBox::RejectRole);
- if (msgBox.exec() == QMessageBox::AcceptRole)
- writer->SetSaveTransform(true);
- }
+ fileformat.c_str())) {
+ QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+ std::string action = "Saving";
+ vvProgressDialog progress("Saving "+fileName.toStdString());
+ qApp->processEvents();
+ vvImageWriter::Pointer writer = vvImageWriter::New();
+ writer->SetOutputFileName(fileName.toStdString());
+ writer->SetInput(mSlicerManagers[index]->GetImage());
+
+ // Check on transform and prompt user
+ writer->SetSaveTransform(false);
+ bool bId = true;
+ for(int i=0; i<4; i++)
+ for(int j=0; j<4; j++) {
+ // TODO SR and BP: check on the list of transforms and not the first only
+ double elt = mSlicerManagers[index]->GetImage()->GetTransform()[0]->GetMatrix()->GetElement(i,j);
+ if(i==j && elt!=1.)
+ bId = false;
+ if(i!=j && elt!=0.)
+ bId = false;
+ }
+ if( !bId ) {
+ QString warning = "The image has an associated linear transform. Do you want to save it along?";
+ QMessageBox msgBox(QMessageBox::Warning, tr("Save transform"), warning, 0, this);
+ msgBox.addButton(tr("Yes"), QMessageBox::AcceptRole);
+ msgBox.addButton(tr("No"), QMessageBox::RejectRole);
+ if (msgBox.exec() == QMessageBox::AcceptRole)
+ writer->SetSaveTransform(true);
+ }
- writer->Update();
- QApplication::restoreOverrideCursor();
- if (writer->GetLastError().size()) {
- QString error = "Saving did not succeed\n";
- error += writer->GetLastError().c_str();
- QMessageBox::information(this,tr("Saving Problem"),error);
- SaveAs();
- }
+ writer->Update();
+ QApplication::restoreOverrideCursor();
+ if (writer->GetLastError().size()) {
+ QString error = "Saving did not succeed\n";
+ error += writer->GetLastError().c_str();
+ QMessageBox::information(this,tr("Saving Problem"),error);
+ SaveAs();
+ }
} else {
QString error = fileformat.c_str();
if (error.isEmpty())
{
QString Extensions = "XML Files(*.xml)";
QString fileName = QFileDialog::getSaveFileName(this,
- tr("Save Current Window State"),
- "",
- Extensions);
-
+ tr("Save Current Window State"),
+ "",
+ Extensions);
+
SaveCurrentStateAs(fileName.toStdString());
}
//------------------------------------------------------------------------------
{
QString Extensions = "XML Files(*.xml)";
QString fileName = QFileDialog::getOpenFileName(this,
- tr("Load Window State"),
- "",
- Extensions);
-
+ tr("Load Window State"),
+ "",
+ Extensions);
+
ReadSavedStateFile(fileName.toStdString());
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::LinkAllImages()
{
- linkPanel->linkAll();
+ linkPanel->linkAll();
}
//------------------------------------------------------------------------------
linkPanel->addLinkFromIds(image1, image2);
return;
}
-
+
unsigned int sm1 = 0;
unsigned int sm2 = 0;
DisplayChanged(item,slicer+1);
}
//------------------------------------------------------------------------------
-
void vvMainWindow::HorizontalSliderMoved(int value,int column, int slicer_index)
{
for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
if (DataTree->topLevelItem(i)->data(column,Qt::CheckStateRole).toInt() > 1) {
+ //i is the SlicerManager that is in charge of this slicer.
+ if (mSlicerManagers[i]->IsInvolvedInFusionSequence()) {
+ //if the slicerManager is involved in a fusionSequence as the secondary sequence, then update the slider position in the overlay panel and everything accordingly
+ if (mSlicerManagers[i]->IsSecondarySequenceOfFusionSequence()) {
+ overlayPanel->updateFusionSequenceSliderValueFromWindow(value, true);
+ }
+ else { //if this is the primary sequence that has been modified
+ if (mSlicerManagers[i]->GetFusionSequenceTemporalSyncFlag()) {
+ //WARNING: for some obscure reason, there are problems when accessing mSlicerManagers[mSlicerManagers[i]->GetFusionSequenceIndexOfLinkedManager()]->GetFusionSequenceFrameIndex();
+
+ //int estimatedValue=mSlicerManagers[mSlicerManagers[i]->GetFusionSequenceIndexOfLinkedManager()]->GetFusionSequenceFrameIndex();
+ int estimatedValue=0;
+ //TODO: if temporal sync is active
+ //estimate a corresponding time index for the secondary (US) sequence, and update it accordingly.
+ //estimatedValue = ...
+ overlayPanel->updateFusionSequenceSliderValueFromWindow(estimatedValue, true);
+ }
+ }
+ }
+
for (int j = 0; j < 4; j++) {
mSlicerManagers[i]->SetTSliceInSlicer(value,j);
- //if (mSlicerManagers[i]->GetSlicer(j)->GetImageActor()->GetVisibility())
- //UpdateTSlice(j,value);
}
mSlicerManagers[i]->GetSlicer(slicer_index)->Render();
break;
{
// if (mCurrentTime == NOHorizontalSlider->value()) return;
HorizontalSliderMoved(NOHorizontalSlider->value(),COLUMN_UL_VIEW,0);
-// mCurrentTime = NOHorizontalSlider->value();
+ // mCurrentTime = NOHorizontalSlider->value();
}
//------------------------------------------------------------------------------
{
// if (mCurrentTime == NEHorizontalSlider->value()) return;
HorizontalSliderMoved(NEHorizontalSlider->value(),COLUMN_UR_VIEW,1);
-// mCurrentTime = NEHorizontalSlider->value();
+ // mCurrentTime = NEHorizontalSlider->value();
}
//------------------------------------------------------------------------------
void vvMainWindow::UpdateSlice(int slicer, int slice)
{
// DD("vvMainWindow::UpdateSlice");
-// DD(slicer);
-// DD(slice);
+ // DD(slicer);
+ // DD(slice);
if (slicer == 0) {
// if (slice != NOVerticalSlider->value())
NOVerticalSlider->setValue(slice);
//------------------------------------------------------------------------------
-void vvMainWindow::UpdateTSlice(int slicer, int slice)
+void vvMainWindow::UpdateTSlice(int slicer, int slice, int code)
{
+ //FusionSequence: the slider value should be updated for slicers which show the same sequence as requested
+ bool doUpdate=false;
+ if (code==-1) doUpdate=true;
+ else {
+ for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
+ if (DataTree->topLevelItem(i)->data(slicer+1,Qt::CheckStateRole).toInt() > 1) {
+ //i is the active SlicerManager
+ if (mSlicerManagers[i]->GetFusionSequenceInvolvmentCode()==code) doUpdate=true;
+ break;
+ }
+ }
+ }
+ if (!doUpdate) return;
+
switch (slicer) {
case 0:
+ if (NOHorizontalSlider->value()==slice) return;
NOHorizontalSlider->setValue(slice);
break;
case 1:
+ if (NEHorizontalSlider->value()==slice) return;
NEHorizontalSlider->setValue(slice);
break;
case 2:
+ if (SOHorizontalSlider->value()==slice) return;
SOHorizontalSlider->setValue(slice);
break;
case 3:
+ if (SEHorizontalSlider->value()==slice) return;
SEHorizontalSlider->setValue(slice);
break;
}
// Select filename base
QString filename = QFileDialog::getSaveFileName(this,
- tr("Save As (filename will be completed by slice number)"),
- itksys::SystemTools::GetFilenamePath(mSlicerManagers[index]->GetFileName()).c_str(),
- "Images( *.png);;Images( *.jpg)");
+ tr("Save As (filename will be completed by slice number)"),
+ itksys::SystemTools::GetFilenamePath(mSlicerManagers[index]->GetFileName()).c_str(),
+ "Images( *.png);;Images( *.jpg)");
// Loop on slices
for(int i=0; i<nbSlices; i++) {
windowToImageFilter->SetMagnification(1);
windowToImageFilter->SetInputBufferTypeToRGBA(); //also record the alpha (transparency) channel
windowToImageFilter->Update();
-
+
vtkSmartPointer<vtkPNGWriter> writer = vtkSmartPointer<vtkPNGWriter>::New();
std::string fn = itksys::SystemTools::GetFilenameWithoutLastExtension(filename.toStdString());
std::string num = clitk::toString(i);
int smIndex=GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
QString fileName = QFileDialog::getSaveFileName(this,
- tr("Save As"),
- itksys::SystemTools::GetFilenamePath(mSlicerManagers[smIndex]->GetFileName()).c_str(),
- Extensions);
+ tr("Save As"),
+ itksys::SystemTools::GetFilenamePath(mSlicerManagers[smIndex]->GetFileName()).c_str(),
+ Extensions);
if (!fileName.isEmpty()) {
vtkSmartPointer<vtkWindowToImageFilter> w2i = vtkSmartPointer<vtkWindowToImageFilter>::New();
// FPS
bool ok;
int fps = QInputDialog::getInteger(this, tr("Number of frames per second"),
- tr("FPS:"), 5, 0, 1000, 1, &ok);
+ tr("FPS:"), 5, 0, 1000, 1, &ok);
if(ok)
gif->SetRate(fps);
// Loops
int loops = QInputDialog::getInteger(this, tr("Loops"),
- tr("Number of loops (0 means infinite):"), 0, 0, 1000000000, 1, &ok);
+ tr("Number of loops (0 means infinite):"), 0, 0, 1000000000, 1, &ok);
if(ok)
gif->SetLoops(loops);
mpg->SetQuality(2);
bool ok;
int fps = QInputDialog::getInteger(this, tr("Number of frames per second"),
- tr("FPS:"), 5, 0, 1024, 1, &ok);
+ tr("FPS:"), 5, 0, 1024, 1, &ok);
if(!ok)
fps = 5;
mpg->SetRate(fps);
mpg->SetQuality(2);
bool ok;
int fps = QInputDialog::getInteger(this, tr("Number of frames per second"),
- tr("FPS:"), 5, 0, 1024, 1, &ok);
+ tr("FPS:"), 5, 0, 1024, 1, &ok);
if(!ok)
fps = 5;
mpg->SetRate(fps);
has_temporal=true;
break;
}
- if (has_temporal) {
- playMode = 1;
- playButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/player_pause.png")));
- QTimer::singleShot(1000/mFrameRate, this, SLOT(PlayNext()));
- }
+ if (has_temporal) {
+ playMode = 1;
+ playButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/player_pause.png")));
+ QTimer::singleShot(1000/mFrameRate, this, SLOT(PlayNext()));
+ }
}
}
//------------------------------------------------------------------------------
for (int i=0; i<image_number; i++)
for (int j=0; j<4; j++)
if (mSlicerManagers[i]->GetSlicer(0)->GetTMax() > 0 &&
- DataTree->topLevelItem(i)->data(j+1,Qt::CheckStateRole).toInt() > 0) {
- mSlicerManagers[i]->SetNextTSlice(j);
- break;
+ DataTree->topLevelItem(i)->data(j+1,Qt::CheckStateRole).toInt() > 0) {
+ mSlicerManagers[i]->SetNextTSlice(j);
+ break;
}
- QTimer::singleShot(1000/mFrameRate, this, SLOT(PlayNext()));
+ QTimer::singleShot(1000/mFrameRate, this, SLOT(PlayNext()));
}
}
//------------------------------------------------------------------------------
for(unsigned int l=0; l<mSlicerManagers.size(); l++) {
vvSlicerManager * v = mSlicerManagers[l];
if (v->GetBaseFileName() ==
- vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename))) {
- number = std::max(number, v->GetBaseFileNameNumber()+1);
+ vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename))) {
+ number = std::max(number, v->GetBaseFileNameNumber()+1);
}
}
return number;
cButton->setColumn(COLUMN_CLOSE_IMAGE);
cButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/exit.png")));
connect(cButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
- this,SLOT(CloseImage(QTreeWidgetItem*, int)));
+ this,SLOT(CloseImage(QTreeWidgetItem*, int)));
QTreePushButton* rButton = new QTreePushButton;
rButton->setItem(item);
rButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/rotateright.png")));
rButton->setEnabled(0);
connect(rButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
- this,SLOT(ReloadImage(QTreeWidgetItem*, int)));
+ this,SLOT(ReloadImage(QTreeWidgetItem*, int)));
DataTree->addTopLevelItem(item);
DataTree->setItemWidget(item, COLUMN_CLOSE_IMAGE, cButton);
mSlicerManagers.back()->SetId(id.toStdString());
linkPanel->addImage(slicer_manager->GetFileName().c_str()// filename
- , id.toStdString());
+ , id.toStdString());
connect(mSlicerManagers.back(), SIGNAL(currentImageChanged(std::string)),
- this, SLOT(CurrentImageChanged(std::string)));
+ this, SLOT(CurrentImageChanged(std::string)));
connect(mSlicerManagers.back(), SIGNAL(currentPickedImageChanged(std::string)),
- this, SLOT(CurrentPickedImageChanged(std::string)));
+ this, SLOT(CurrentPickedImageChanged(std::string)));
connect(mSlicerManagers.back(), SIGNAL(UpdatePosition(int, double, double, double, double, double, double, double)),
- this, SLOT(MousePositionChanged(int,double, double, double, double, double, double, double)));
+ this, SLOT(MousePositionChanged(int,double, double, double, double, double, double, double)));
connect(mSlicerManagers.back(), SIGNAL(UpdateVector(int, double, double, double, double)),
- this, SLOT(VectorChanged(int,double,double,double, double)));
+ this, SLOT(VectorChanged(int,double,double,double, double)));
connect(mSlicerManagers.back(), SIGNAL(UpdateOverlay(int, double, double)),
- this, SLOT(OverlayChanged(int,double,double)));
+ this, SLOT(OverlayChanged(int,double,double)));
connect(mSlicerManagers.back(), SIGNAL(UpdateFusion(int, double)),
- this, SLOT(FusionChanged(int,double)));
+ this, SLOT(FusionChanged(int,double)));
+ //connect(mSlicerManagers.back(), SIGNAL(UpdateFusionSequence(int, bool, unsigned int)),
+ // this, SLOT(FusionSequenceChanged(int, bool, unsigned int)));
connect(mSlicerManagers.back(), SIGNAL(WindowLevelChanged()),
- this,SLOT(WindowLevelChanged()));
+ this,SLOT(WindowLevelChanged()));
connect(mSlicerManagers.back(), SIGNAL(UpdateSlice(int,int)),
- this,SLOT(UpdateSlice(int,int)));
- connect(mSlicerManagers.back(), SIGNAL(UpdateTSlice(int, int)),
- this,SLOT(UpdateTSlice(int, int)));
- connect(mSlicerManagers.back(), SIGNAL(UpdateTSlice(int, int)),
- this,SLOT(ImageInfoChanged()));
+ this,SLOT(UpdateSlice(int,int)));
+ connect(mSlicerManagers.back(), SIGNAL(UpdateTSlice(int, int, int)),
+ this,SLOT(UpdateTSlice(int, int, int)));
+ connect(mSlicerManagers.back(), SIGNAL(UpdateTSlice(int, int, int)),
+ this,SLOT(ImageInfoChanged()));
connect(mSlicerManagers.back(), SIGNAL(UpdateSliceRange(int,int,int,int,int)),
- this,SLOT(UpdateSliceRange(int,int,int,int,int)));
+ this,SLOT(UpdateSliceRange(int,int,int,int,int)));
connect(mSlicerManagers.back(), SIGNAL(UpdateLinkManager(std::string,int,double,double,double,int)),
- this,SLOT(UpdateLinkManager(std::string,int,double,double,double,int)));
+ this,SLOT(UpdateLinkManager(std::string,int,double,double,double,int)));
connect(mSlicerManagers.back(), SIGNAL(UpdateLinkedNavigation(std::string,vvSlicerManager*,vvSlicer*)),
- this,SLOT(UpdateLinkedNavigation(std::string,vvSlicerManager*,vvSlicer*)));
+ this,SLOT(UpdateLinkedNavigation(std::string,vvSlicerManager*,vvSlicer*)));
connect(mSlicerManagers.back(), SIGNAL(ChangeImageWithIndexOffset(vvSlicerManager*,int,int)),
- this,SLOT(ChangeImageWithIndexOffset(vvSlicerManager*,int,int)));
+ this,SLOT(ChangeImageWithIndexOffset(vvSlicerManager*,int,int)));
connect(mSlicerManagers.back(), SIGNAL(LandmarkAdded()),landmarksPanel,SLOT(AddPoint()));
+
+
UpdateTree();
qApp->processEvents();
InitSlicers();
void AddOverlayImage(int index, std::vector<std::string> fileNames, vvImageReader::LoadedImageType type);
void AddFusionImage(int index, QString filename);
void AddROI(int index, QString filename);
+
+ //Process the sequence for fusion:
+ void AddFusionSequence(int index, std::vector<std::string> fileNames, vvImageReader::LoadedImageType type);
+
void AddLandmarks(int index, std::vector<std::string>);
///Adds a mesh to a SlicerManager, with optional warping by vector field
void AddContour(int image_index, vvMesh::Pointer contour, bool propagation);
void VectorChanged(int visibility, double x, double y, double z, double value);
void OverlayChanged(int visibility, double valueOver, double valueRef);
void FusionChanged(int visibility, double value);
+ //void FusionSequenceChanged(int visibility, double value);
void SegmentationOnCurrentImage();
void SurfaceViewerLaunch();
void WindowLevelChanged();
void UpdateSlice(int slicer, int slice);
- void UpdateTSlice(int slicer, int slice);
+ void UpdateTSlice(int slicer, int slice, int code=-1);
void UpdateSliceRange(int slicer, int min, int max, int tmin, int tmax);
void WindowLevelEdited();
void SetWindowLevel(double w, double l);
void OpenField();
void SelectOverlayImage();
void SelectFusionImage();
+ //select the file(s) from the disk containing the image sequence to fuse
+ void SelectFusionSequence();
+ void SelectFusionSequenceTemporalSignal();
+
void ResetTransformationToIdentity();
void SetVFProperty(int subsampling,int scale,int lut, int width, double r, double g, double b);
void SetOverlayProperty(int color, int linked, double window, double level);
void SetFusionProperty(int opacity, int tresOpacity, int colormap,double window,double level, bool showLegend);
+ void SetFusionSequenceProperty(int fusionSequenceFrameIndex, bool spatialSyncFlag, unsigned int fusionSequenceNbFrames, bool temporalSyncFlag);
void GoToCursor();
void GoToLandmark();
QString GetSizeInBytes(unsigned long size);
QString GetVectorDoubleAsString(std::vector<double> vectorDouble);
QString GetVectorIntAsString(std::vector<int> vectorInt);
- int GetSlicerIndexFromItem(QTreeWidgetItem* item);
+ int GetSlicerIndexFromItem(QTreeWidgetItem* item); //this actually returns the SlicerManager index TODO: rename it to GetSlicerManagerIndexFromItem
QTreeWidgetItem* GetItemFromSlicerManager(vvSlicerManager* sm);
void SaveScreenshot(QVTKWidget *widget);
int GetImageDuplicateFilenameNumber(std::string filename);
//====================================================================
vvOverlayPanel::vvOverlayPanel(QWidget * parent):QWidget(parent)
{
+ disableFusionSignals = true;
+ disableFusionSequenceSignals = true;
+
setupUi(this);
vFFrame->hide();
compareFrame->hide();
fusionFrame->hide();
+ fCTUSFrame->hide();
subSamplingSpinBox->setEnabled(0);
scaleSpinBox->setEnabled(0);
lutCheckBox->hide();
lutCheckBox->setEnabled(0);
fusionShowLegendCheckBox->setChecked(false);
-
+
connect(subSamplingSpinBox,SIGNAL(editingFinished()),this,SLOT(setVFProperty()));
connect(scaleSpinBox,SIGNAL(editingFinished()),this,SLOT(setVFProperty()));
connect(lutCheckBox,SIGNAL(clicked()),this,SLOT(setVFProperty()));
connect(overlayLevelSpinBox,SIGNAL(valueChanged(double)),this,SLOT(setOverlayProperty()));
connect(overlayLinkCheckBox,SIGNAL(stateChanged(int)),this,SLOT(setOverlayProperty()));
- disableFusionSignals = false;
+ connect(fCTUSSlider,SIGNAL(valueChanged(int)),this,SLOT(setFusionSequenceProperty()));
+ connect(fCTUSActivateSpaceSyncCheckBox,SIGNAL(stateChanged(int)),this,SLOT(setFusionSequenceProperty()));
+ connect(fCTUSActivateTimeSyncCheckBox,SIGNAL(stateChanged(int)),this,SLOT(setFusionSequenceProperty()));
+ connect(fCTUSLoadSignalPushButton,SIGNAL(clicked()),this,SIGNAL(FusionSequenceSignalButtonPressed()));
}
void vvOverlayPanel::getCurrentImageName(QString name)
{
if (disableFusionSignals)
return;
-
+
fusionOpacitySpin->setValue(opacityHorizontalSlider->value());
fusionThresSpin->setValue(thresOpacityHorizontalSlider->value());
valueFusionnedLabel->setText(fusionValue);
}
+
+void vvOverlayPanel::getFusionSequenceProperty(int sequenceFrameIndex, bool spatialSync, unsigned int sequenceLenth, bool temporalSync)
+{
+ if (sequenceFrameIndex > -1) {
+ disableFusionSequenceSignals = true;
+ fCTUSFrame->show();
+ fCTUSFrame->setEnabled(1);
+ fCTUSSlider->setEnabled(1);
+ fCTUSSlider->setValue(sequenceFrameIndex);
+ fCTUSSlider->setMaximum(sequenceLenth);
+ if (spatialSync) fCTUSActivateSpaceSyncCheckBox->setCheckState(Qt::Checked);
+ else fCTUSActivateSpaceSyncCheckBox->setCheckState(Qt::Unchecked);
+ if (fCTUSActivateTimeSyncCheckBox->isEnabled()) {
+ if ( temporalSync ) fCTUSActivateTimeSyncCheckBox->setCheckState(Qt::Checked);
+ else fCTUSActivateTimeSyncCheckBox->setCheckState(Qt::Unchecked);
+ }
+ disableFusionSequenceSignals = false;
+ setFusionSequenceProperty();
+ } else {
+ disableFusionSequenceSignals = true;
+ fCTUSFrame->hide();
+ fCTUSFrame->setEnabled(0);
+ fCTUSSlider->setEnabled(0);
+ fCTUSSlider->setValue(0);
+ fCTUSSlider->setMaximum(0);
+ fCTUSActivateSpaceSyncCheckBox->setCheckState(Qt::Unchecked);
+ fCTUSActivateTimeSyncCheckBox->setCheckState(Qt::Unchecked);
+ disableFusionSequenceSignals = false;
+ setFusionSequenceProperty();
+ }
+}
+
+
+void vvOverlayPanel::setFusionSequenceProperty()
+{
+ if (disableFusionSequenceSignals)
+ return;
+ emit FusionSequencePropertyUpdated(fCTUSSlider->value(), fCTUSActivateSpaceSyncCheckBox->isChecked(), fCTUSSlider->maximum(), fCTUSActivateTimeSyncCheckBox->isChecked());
+}
+
+void vvOverlayPanel::enableFusionSequenceTemporalSync() {
+ bool backup = disableFusionSequenceSignals;
+ disableFusionSequenceSignals=true; //not sure this is necessary, but just in case...
+ fCTUSActivateTimeSyncCheckBox->setEnabled(1);
+ fCTUSActivateTimeSyncCheckBox->setChecked(true);
+ disableFusionSequenceSignals = backup; //
+
+ if (disableFusionSequenceSignals) return;
+ emit FusionSequencePropertyUpdated(fCTUSSlider->value(), fCTUSActivateSpaceSyncCheckBox->isChecked(), fCTUSSlider->maximum(), fCTUSActivateTimeSyncCheckBox->isChecked());
+}
+
+void vvOverlayPanel::updateFusionSequenceSliderValueFromWindow(int val, bool updateVisualization) {
+ if (fCTUSSlider->value()==val) return;
+
+ disableFusionSequenceSignals = true; //not sure this is necessary, but just in case...
+ fCTUSSlider->setValue(val);
+ disableFusionSequenceSignals = false;
+
+ if (disableFusionSequenceSignals) return;
+ if (updateVisualization) emit FusionSequencePropertyUpdated(fCTUSSlider->value(), fCTUSActivateSpaceSyncCheckBox->isChecked(), fCTUSSlider->maximum(), fCTUSActivateTimeSyncCheckBox->isChecked());
+}
+
void vvOverlayPanel::VFColorChangeRequest()
{
QColor color(vfColorButton->palette().color(QPalette::Background));
/*=========================================================================
- Program: vv http://www.creatis.insa-lyon.fr/rio/vv
+Program: vv http://www.creatis.insa-lyon.fr/rio/vv
- Authors belong to:
- - University of LYON http://www.universite-lyon.fr/
- - Léon Bérard cancer center http://www.centreleonberard.fr
- - CREATIS CNRS laboratory http://www.creatis.insa-lyon.fr
+Authors belong to:
+- University of LYON http://www.universite-lyon.fr/
+- Léon Bérard cancer center http://www.centreleonberard.fr
+- CREATIS CNRS laboratory http://www.creatis.insa-lyon.fr
- This software is distributed WITHOUT ANY WARRANTY; without even
- the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- PURPOSE. See the copyright notices for more information.
+This software is distributed WITHOUT ANY WARRANTY; without even
+the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+PURPOSE. See the copyright notices for more information.
- It is distributed under dual licence
+It is distributed under dual licence
- - BSD See included LICENSE.txt file
- - CeCILL-B http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
+- BSD See included LICENSE.txt file
+- CeCILL-B http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
===========================================================================**/
#ifndef _vvOverlayPanel_H
#define _vvOverlayPanel_H
class vvOverlayPanel : public QWidget, private Ui::vvOverlayPanel
{
- Q_OBJECT
+ Q_OBJECT
public:
- // constructor - destructor
- vvOverlayPanel(QWidget * parent=0);
- ~vvOverlayPanel() {}
+ // constructor - destructor
+ vvOverlayPanel(QWidget * parent=0);
+ ~vvOverlayPanel() {}
- void getCurrentImageName(QString name);
+ void getCurrentImageName(QString name);
- void getVFProperty(int subsampling, int scale, int log);
- void getVFName(QString name);
+ void getVFProperty(int subsampling, int scale, int log);
+ void getVFName(QString name);
- void getOverlayProperty(int color, int linked, double window, double level);
- void getOverlayName(QString name);
+ void getOverlayProperty(int color, int linked, double window, double level);
+ void getOverlayName(QString name);
- void getFusionProperty(int opacity, int thresOpacity, int colormap, double window, double level);
- void getFusionName(QString name);
+ void getFusionProperty(int opacity, int thresOpacity, int colormap, double window, double level);
+ void getFusionName(QString name);
- void getCurrentVectorInfo(int visibility, double x, double y, double z, double value);
- void getCurrentOverlayInfo(int visibility,double valueOver, double valueRef);
- void getCurrentFusionInfo(int visibility,double value);
-
- bool getShowLegend();
+ void getFusionSequenceProperty(int sequenceFrameIndex, bool spatialSync, unsigned int sequenceLength, bool temporalSync);
+
+ void getCurrentVectorInfo(int visibility, double x, double y, double z, double value);
+ void getCurrentOverlayInfo(int visibility,double valueOver, double valueRef);
+ void getCurrentFusionInfo(int visibility,double value);
+
+ bool getShowLegend();
+
+ void updateFusionSequenceSliderValueFromWindow(int val, bool updateVisualization);
public slots:
- void setVFProperty();
- void setOverlayProperty();
- void setFusionProperty();
- void setFusionSpinProperty();
- void VFColorChangeRequest();
+ void setVFProperty();
+ void setOverlayProperty();
+ void setFusionProperty();
+ void setFusionSpinProperty();
+ void VFColorChangeRequest();
+ void setFusionSequenceProperty();
+ void enableFusionSequenceTemporalSync();
signals:
- void VFPropertyUpdated(int subsampling, int scale, int log, int width, double r, double g, double b);
- void OverlayPropertyUpdated(int color, int linked, double window, double level);
- void FusionPropertyUpdated(int opacity, int thresOpacity, int colormap, double window, double level, bool showLegend);
+ void VFPropertyUpdated(int subsampling, int scale, int log, int width, double r, double g, double b);
+ void OverlayPropertyUpdated(int color, int linked, double window, double level);
+ void FusionPropertyUpdated(int opacity, int thresOpacity, int colormap, double window, double level, bool showLegend);
+ void FusionSequencePropertyUpdated(int sequenceFrameIndex, bool spatialSync, unsigned int sequenceLength, bool temporalSync);
+ void FusionSequenceSignalButtonPressed();
-
private:
- bool disableFusionSignals;
-
+ bool disableFusionSignals;
+ bool disableFusionSequenceSignals;
+
}; // end class vvOverlayPanel
//====================================================================
- CeCILL-B http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
===========================================================================**/
+#include <QMessageBox>
+#include <QString>
+
#include "vvSlicer.h"
#include "vvImage.h"
#include "vvSlicerManagerCommand.h"
#include <vtkImageReslice.h>
#if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10)
# include <vtkImageMapper3D.h>
+# include <vtkImageSliceMapper.h>
#endif
vtkCxxRevisionMacro(vvSlicer, "DummyRevision");
//------------------------------------------------------------------------------
vvSlicer::vvSlicer()
{
+ mFusionSequenceCode = -1;
this->UnInstallPipeline();
mImage = NULL;
mReducedExtent = new int[6];
this->InstallPipeline();
mLinkOverlayWindowLevel = true;
+ mImageVisibility = true;
#if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10)
this->GetImageActor()->GetMapper()->BorderOn();
mCurrentBeforeSlicingTransform[1]=y;
mCurrentBeforeSlicingTransform[2]=z;
mSlicingTransform->GetInverse()->TransformPoint(mCurrentBeforeSlicingTransform,mCurrent);
- SetTSlice(t);
+ if (t>=0) SetTSlice(t);
}
//------------------------------------------------------------------------------
{
if (overlay->GetVTKImages().size()) {
mOverlay = overlay;
+ mOverlayVisibility = true;
if (!mOverlayReslice) {
mOverlayReslice = vtkSmartPointer<vtkImageReslice>::New();
//------------------------------------------------------------------------------
-void vvSlicer::SetFusion(vvImage::Pointer fusion)
+void vvSlicer::SetFusion(vvImage::Pointer fusion, int fusionSequenceCode)
{
+ mFusionSequenceCode = fusionSequenceCode;
if (fusion->GetVTKImages().size()) {
mFusion = fusion;
+ mFusionVisibility = true;
if (!mFusionReslice) {
mFusionReslice = vtkSmartPointer<vtkImageReslice>::New();
bool vvSlicer::GetActorVisibility(const std::string& actor_type, int overlay_index)
{
bool vis = false;
- if (actor_type == "image") {
- vis = this->ImageActor->GetVisibility();
- }
- else if (actor_type == "vector") {
- vis = this->mVFActor->GetVisibility();
- }
- else if (actor_type == "overlay") {
- vis = this->mOverlayActor->GetVisibility();
- }
- else if (actor_type == "fusion") {
- vis = this->mFusionActor->GetVisibility();
- }
+ if (actor_type == "image")
+ vis = mImageVisibility;
+ else if (actor_type == "vector")
+ vis = mVFVisibility;
+ else if (actor_type == "overlay")
+ vis = mOverlayVisibility;
+ else if ( (actor_type == "fusion") || (actor_type == "fusionSequence") )
+ vis = mFusionVisibility;
else if (actor_type == "contour")
vis = this->mSurfaceCutActors[overlay_index]->GetActor()->GetVisibility();
-
return vis;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvSlicer::SetActorVisibility(const std::string& actor_type, int overlay_index ,bool vis)
{
- if (actor_type == "image") {
- this->ImageActor->SetVisibility(vis);
- }
- else if (actor_type == "vector") {
- this->mVFActor->SetVisibility(vis);
- }
- else if (actor_type == "overlay") {
- this->mOverlayActor->SetVisibility(vis);
- }
- else if (actor_type == "fusion") {
- this->mFusionActor->SetVisibility(vis);
- }
+ if (actor_type == "image")
+ mImageVisibility = vis;
+ else if (actor_type == "vector")
+ mVFVisibility = vis;
+ else if (actor_type == "overlay")
+ mOverlayVisibility = vis;
+ else if ( (actor_type == "fusion") || (actor_type == "fusionSequence") )
+ mFusionVisibility = vis;
else if (actor_type == "contour")
this->mSurfaceCutActors[overlay_index]->GetActor()->SetVisibility(vis);
UpdateDisplayExtent();
{
if (vf->GetVTKImages().size()) {
mVF = vf;
+ mVFVisibility = true;
if (!mAAFilter) {
mAAFilter= vtkSmartPointer<vtkAssignAttribute>::New();
mOverlayActor = NULL;
mOverlayMapper = NULL;
}
- if (actor_type == "fusion") {
+ if ( (actor_type == "fusion") || (actor_type == "fusionSequence") ) {
Renderer->RemoveActor(mFusionActor);
mFusion = NULL;
mFusionActor = NULL;
//------------------------------------------------------------------------------
-void vvSlicer::SetTSlice(int t)
+void vvSlicer::SetTSlice(int t, bool updateLinkedImages)
{
+ if (!updateLinkedImages) {
+ mCurrentTSlice = t;
+ mImageReslice->SetInput( mImage->GetVTKImages()[mCurrentTSlice] );
+ // Update transform
+ mConcatenatedTransform->Identity();
+ mConcatenatedTransform->Concatenate(mImage->GetTransform()[mCurrentTSlice]);
+ mConcatenatedTransform->Concatenate(mSlicingTransform);
+ UpdateDisplayExtent();
+ return;
+ }
+
if (t < 0)
mCurrentTSlice = 0;
else if ((unsigned int)t >= mImage->GetVTKImages().size())
if (mVF->GetVTKImages().size() > (unsigned int)mCurrentTSlice)
mVOIFilter->SetInput(mVF->GetVTKImages()[mCurrentTSlice]);
}
+ //update the overlay
if (mOverlay && mOverlayActor->GetVisibility()) {
if (mOverlay->GetVTKImages().size() > (unsigned int)t) {
mCurrentOverlayTSlice = t;
mConcatenatedOverlayTransform->Concatenate(mSlicingTransform);
}
}
- if (mFusion && mFusionActor->GetVisibility()) {
+ //update the fusion ; except in case this is a fusionSequence, in which case both 'times' should be independent.
+ if (mFusion && mFusionActor->GetVisibility() && (mFusionSequenceCode<0)) {
if (mFusion->GetVTKImages().size() > (unsigned int)t) {
mCurrentFusionTSlice = t;
mFusionReslice->SetInput( mFusion->GetVTKImages()[mCurrentFusionTSlice]);
//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+void vvSlicer::SetFusionSequenceTSlice(int t)
+{
+ if (mFusion && mFusionActor->GetVisibility() && (mFusionSequenceCode>=0)) {
+ if (mFusion->GetVTKImages().size() > (unsigned int)t) {
+ mCurrentFusionTSlice = t;
+ mFusionReslice->SetInput( mFusion->GetVTKImages()[mCurrentFusionTSlice] );
+ // Update fusion transform
+ mConcatenatedFusionTransform->Identity();
+ mConcatenatedFusionTransform->Concatenate(mFusion->GetTransform()[mCurrentFusionTSlice]); //not really useful...
+ mConcatenatedFusionTransform->Concatenate(mSlicingTransform);
+ }
+ }
+
+ UpdateDisplayExtent();
+}
+//------------------------------------------------------------------------------
+
+
//------------------------------------------------------------------------------
int vvSlicer::GetTSlice()
{
int t = mCurrentTSlice;
if(mOverlay)
t = std::max(t, mCurrentOverlayTSlice);
- if(mFusion)
+ if(mFusion&& (mFusionSequenceCode<0)) //ignore fusionSequence data: for these, the times are not to be related (this way)
t = std::max(t, mCurrentFusionTSlice);
return t;
}
// Step 1: from world coordinates to image coordinates
origin[this->SliceOrientation] -= mImageReslice->GetOutput()->GetOrigin()[this->SliceOrientation];
origin[this->SliceOrientation] /= mImageReslice->GetOutput()->GetSpacing()[this->SliceOrientation];
- // Step 2: round to superior grid positionInc
- origin[this->SliceOrientation] = itk::Math::Ceil<double>(origin[this->SliceOrientation]);
+
+ // Step 2: round to nearest grid positionInc. This has been validated as the only
+ // way to have something consistent with the thickness of a 2D slice visible on the
+ // other slices. The thickness is accounted for so if the 2D slice is to thin and
+ // between two slices, one will never be able to see this 2D slice (bug #1883).
+ origin[this->SliceOrientation] = itk::Math::Round<double>(origin[this->SliceOrientation]);
+
// Step 3: back to world coordinates
origin[this->SliceOrientation] *= mImageReslice->GetOutput()->GetSpacing()[this->SliceOrientation];
origin[this->SliceOrientation] += mImageReslice->GetOutput()->GetOrigin()[this->SliceOrientation];
w_ext[ this->SliceOrientation*2+1 ] = this->Slice;
// Image actor
+ this->ImageActor->SetVisibility(mImageVisibility);
this->ImageActor->SetDisplayExtent(w_ext);
-
+#if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10)
+ // Fix for bug #1882
+ dynamic_cast<vtkImageSliceMapper *>(this->ImageActor->GetMapper())->SetOrientation(this->GetOrientation());
+#endif
+
// Overlay image actor
- if (mOverlay && mOverlayActor->GetVisibility()) {
+ if (mOverlay && mOverlayVisibility) {
AdjustResliceToSliceOrientation(mOverlayReslice);
int overExtent[6];
this->ConvertImageToImageDisplayExtent(input, w_ext, mOverlayReslice->GetOutput(), overExtent);
- ClipDisplayedExtent(overExtent, mOverlayMapper->GetInput()->GetWholeExtent());
+ bool out = ClipDisplayedExtent(overExtent, mOverlayMapper->GetInput()->GetWholeExtent());
+ mOverlayActor->SetVisibility(!out);
mOverlayActor->SetDisplayExtent( overExtent );
+#if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10)
+ // Fix for bug #1882
+ dynamic_cast<vtkImageSliceMapper *>(mOverlayActor->GetMapper())->SetOrientation(this->GetOrientation());
+#endif
}
+ else if(mOverlay)
+ mOverlayActor->SetVisibility(false);
// Fusion image actor
- if (mFusion && mFusionActor->GetVisibility()) {
+ if (mFusion && mFusionVisibility) {
AdjustResliceToSliceOrientation(mFusionReslice);
int fusExtent[6];
this->ConvertImageToImageDisplayExtent(input, w_ext, mFusionReslice->GetOutput(), fusExtent);
- ClipDisplayedExtent(fusExtent, mFusionMapper->GetInput()->GetWholeExtent());
- mFusionActor->SetDisplayExtent(fusExtent);
+ bool out = ClipDisplayedExtent(fusExtent, mFusionMapper->GetInput()->GetWholeExtent());
+ mFusionActor->SetVisibility(!out);
+ mFusionActor->SetDisplayExtent( fusExtent );
+#if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10)
+ // Fix for bug #1882
+ dynamic_cast<vtkImageSliceMapper *>(mFusionActor->GetMapper())->SetOrientation(this->GetOrientation());
+#endif
}
+ else if(mFusion)
+ mFusionActor->SetVisibility(false);
// Vector field actor
double* camera = Renderer->GetActiveCamera()->GetPosition();
if (camera[this->SliceOrientation] < image_bounds[this->SliceOrientation*2])
offset = -1;
- if (mVF && mVFActor->GetVisibility()) {
+ if (mVF && mVFVisibility) {
int vfExtent[6];
mVF->GetVTKImages()[0]->UpdateInformation();
this->ConvertImageToImageDisplayExtent(input, w_ext, mVF->GetVTKImages()[0], vfExtent);
- ClipDisplayedExtent(vfExtent, mVOIFilter->GetInput()->GetWholeExtent());
+ bool out = ClipDisplayedExtent(vfExtent, mVOIFilter->GetInput()->GetWholeExtent());
+ mVFActor->SetVisibility(!out);
mVOIFilter->SetVOI(vfExtent);
int orientation[3] = {1,1,1};
orientation[this->SliceOrientation] = 0;
position[this->SliceOrientation] += offset;
mVFActor->SetPosition(position);
}
-
+ else if(mVF)
+ mVFActor->SetVisibility(false);
+
// Landmarks actor
if (mLandActor) {
if (mClipBox) {
}
}
}
-
}
//----------------------------------------------------------------------------
// From world coordinates to floating point target voxel coordinates
dExtents[i] = (dExtents[i]- targetImage->GetOrigin()[i/2]) / targetImage->GetSpacing()[i/2];
- // Round to nearest
- //targetExtent[i] = itk::Math::Round<double>(dExtents[i]);
- targetExtent[i] = itk::Math::Floor<double>(dExtents[i]);
+ // Round to current slice or larger extent
+ if(i/2==this->GetOrientation())
+ targetExtent[i] = itk::Math::Round<double>(dExtents[i]);
+ else if(i%2==1)
+ targetExtent[i] = itk::Math::Ceil<double>(dExtents[i]);
+ else
+ targetExtent[i] = itk::Math::Floor<double>(dExtents[i]);
}
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
-void vvSlicer::ClipDisplayedExtent(int extent[6], int refExtent[6])
+bool vvSlicer::ClipDisplayedExtent(int extent[6], int refExtent[6])
{
bool out = false;
int maxBound = 6;
- //2D overlay on 3D image specific case
- if (refExtent[4] == refExtent[5]) {
- maxBound = 4;
- extent[4] = refExtent[4];
- extent[5] = refExtent[5];
- }
-
for (int i = 0; i < maxBound; i = i+2) {
//if we are totally outside the image
if ( extent[i] > refExtent[i+1] || extent[i+1] < refExtent[i] ) {
break;
}
//crop to the limit of the image
- extent[i] = (extent[i] > refExtent[i]) ? extent[i] : refExtent[i];
- extent[i] = (extent[i] < refExtent[i+1]) ? extent[i] : refExtent[i+1];
- extent[i+1] = (extent[i+1] > refExtent[i]) ? extent[i+1] : refExtent[i];
- extent[i+1] = (extent[i+1] < refExtent[i+1]) ? extent[i+1] : refExtent[i+1];
+ extent[i] = std::max(extent[i], refExtent[i]);
+ extent[i] = std::min(extent[i], refExtent[i+1]);;
+ extent[i+1] = std::max(extent[i+1], refExtent[i]);
+ extent[i+1] = std::min(extent[i+1], refExtent[i+1]);;
}
if (out)
for (int i = 0; i < maxBound; i = i+2) {
extent[i] = refExtent[i];
extent[i+1] = refExtent[i];
}
+ return out;
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicer::SetDisplayMode(bool i)
{
- this->GetRenderer()->SetDraw(i);
- if (i)
- UpdateDisplayExtent();
+ this->GetRenderer()->SetDraw(i);
+ if (i) UpdateDisplayExtent();
}
//----------------------------------------------------------------------------
ix = lrint(X);
iy = lrint(Y);
iz = lrint(Z);
+
if (ix < image->GetWholeExtent()[0] ||
ix > image->GetWholeExtent()[1] ||
iy < image->GetWholeExtent()[2] ||
double yCursor = (y - this->GetInput()->GetOrigin()[1])/this->GetInput()->GetSpacing()[1];
double zCursor = (z - this->GetInput()->GetOrigin()[2])/this->GetInput()->GetSpacing()[2];
- if (xCursor >= this->GetImageActor()->GetDisplayExtent()[0] &&
- xCursor < this->GetImageActor()->GetDisplayExtent()[1]+1 &&
- yCursor >= this->GetImageActor()->GetDisplayExtent()[2] &&
- yCursor < this->GetImageActor()->GetDisplayExtent()[3]+1 &&
- zCursor >= this->GetImageActor()->GetDisplayExtent()[4] &&
- zCursor < this->GetImageActor()->GetDisplayExtent()[5]+1 ) {
+ if (xCursor >= this->GetImageActor()->GetDisplayExtent()[0]-0.5 &&
+ xCursor < this->GetImageActor()->GetDisplayExtent()[1]+0.5 &&
+ yCursor >= this->GetImageActor()->GetDisplayExtent()[2]-0.5 &&
+ yCursor < this->GetImageActor()->GetDisplayExtent()[3]+0.5 &&
+ zCursor >= this->GetImageActor()->GetDisplayExtent()[4]-0.5 &&
+ zCursor < this->GetImageActor()->GetDisplayExtent()[5]+0.5 ) {
vtkRenderer * renderer = this->Renderer;
renderer->WorldToView(x,y,z);
#include <iostream>
#include <vector>
+#include <QString> //TODO delete
+#include <QMessageBox>
+
#include "vvLandmarks.h"
#include "vvImage.h"
#include "vvMesh.h"
vtkActor* GetVFActor() ;
vtkCornerAnnotation* GetAnnotation();
- void SetFusion(vvImage::Pointer inputFusion);
+ void SetFusion(vvImage::Pointer inputFusion, int fusionSequenceCode = -1);
vvImage::Pointer GetFusion() {
return mFusion;
}
}
void SetLandmarks(vvLandmarks* landmarks);
- void SetTSlice(int t);
+ void SetTSlice(int t, bool updateLinkedImages = true);
+
+ void SetFusionSequenceTSlice(int t);
+
void SetSliceOrientation(int orientation);
void AdjustResliceToSliceOrientation(vtkImageReslice *reslice);
int GetTSlice();
void EnableReducedExtent(bool b);
void SetReducedExtent(int * ext);
- void ClipDisplayedExtent(int extent[6], int refExtent[6]);
+ bool ClipDisplayedExtent(int extent[6], int refExtent[6]);
int GetOrientation();
int * GetExtent();
}
void SetVFColor(double r, double g, double b);
+ //necessary to flag the secondary sequence
+ void SetFusionSequenceCode(int code) {mFusionSequenceCode=code;}
protected:
vvSlicer();
~vvSlicer();
vvLandmarks* mLandmarks;
+ int mFusionSequenceCode; //-1: not involved in a fusion sequence, 0: main sequence (CT), 1: secondary sequence (US)
+
// __________ Image coordinates accounting for spacing and origin
// Λ Λ
// | | vvImage.GetTransform()
///Sets the surfaces to be cut on the image slice: update the vtkCutter
void SetContourSlice();
-
+ // Visibility of the different elements that can be set from outside the object.
+ // Note that vvSlicer also check if the element is to be displayed according to
+ // the extent of the displayed object.
+ // These members have been introduced to fix Bug #1883.
+ bool mImageVisibility;
+ bool mOverlayVisibility;
+ bool mFusionVisibility;
+ bool mVFVisibility;
};
#endif
-/*=========================================================================
- Program: vv http://www.creatis.insa-lyon.fr/rio/vv
-
- Authors belong to:
- - University of LYON http://www.universite-lyon.fr/
- - Léon Bérard cancer center http://oncora1.lyon.fnclcc.fr
- - CREATIS CNRS laboratory http://www.creatis.insa-lyon.fr
-
- This software is distributed WITHOUT ANY WARRANTY; without even
- the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- PURPOSE. See the copyright notices for more information.
-
- It is distributed under dual licence
-
- - BSD See included LICENSE.txt file
- - CeCILL-B http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
- ======================================================================-====*/
-
-#include "vvSlicerManager.h"
-#include "vvSlicer.h"
-#include "vvImage.h"
-#include "vvSlicerManagerCommand.h"
-#include "vvInteractorStyleNavigator.h"
-#include "vvLandmarks.h"
-#include "vvMesh.h"
-#include "vvBlendImageActor.h"
-
-#include <vtkImageActor.h>
-#include <vtkImageData.h>
-#include <vtkRenderWindow.h>
-#include <vtkRendererCollection.h>
-#include <vtkRenderWindowInteractor.h>
-#include <vtkImageMapToWindowLevelColors.h>
-#include <vtkWindowLevelLookupTable.h>
-#include <vtkColorTransferFunction.h>
-#include <vtkImageClip.h>
-#include <vtkLODActor.h>
-#include <vtkPointData.h>
-#include <vtksys/SystemTools.hxx>
-#include <vtkCamera.h>
-
-#include <qfileinfo.h>
-
-//----------------------------------------------------------------------------
-vvSlicerManager::vvSlicerManager(int numberOfSlicers)
-{
- mFileName = "";
- mId = "";
- mVFName = "";
- mOverlayName = "";
- mFusionName = "";
- mVFId = "";
- mLastError = "";
- mType = vvImageReader::UNDEFINEDIMAGETYPE;
- mColorMap = 0;
- mPreset = 0;
- mOverlayColor = 130;
-
- mFusionOpacity = 30;
- mFusionThresOpacity = 1;
- mFusionColorMap = 3;
- mFusionWindow = 1000;
- mFusionLevel = 1000;
- mFusionShowLegend = true;
-
- mLandmarks = NULL;
- mLinkedId.resize(0);
-
- for ( int i = 0; i < numberOfSlicers; i++)
- mSlicers.push_back(vtkSmartPointer<vvSlicer>::New());
- mSelectedSlicer = -1;
-
- mPreviousSlice.resize(numberOfSlicers);
- mPreviousTSlice.resize(numberOfSlicers);
- mSlicingPreset = WORLD_SLICING;
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-vvSlicerManager::~vvSlicerManager()
-{
- if (mLandmarks)
- delete mLandmarks;
-}
-//----------------------------------------------------------------------------
-
-
-//------------------------------------------------------------------------------
-void vvSlicerManager::SetFilename(std::string filename, int number)
-{
- mFileName = filename;
- mFileName = vtksys::SystemTools::GetFilenameName(mFileName);
- mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));
- mBaseFileNameNumber = number;
-
- mFileName = mBaseFileName;
- if (number != 0) {
- mFileName.append("_"+clitk::toString(number));
- }
- mFileName.append(vtksys::SystemTools::GetFilenameLastExtension(filename));
-
- for(unsigned int i=0; i<mSlicers.size(); i++) {
- mSlicers[i]->SetFileName(mFileName);//vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));
- }
-
-}
-//------------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::AddContour(vvMesh::Pointer contour,bool propagate)
-{
- for ( unsigned int i = 0; i < mSlicers.size(); i++) {
- mSlicers[i]->AddContour(contour,propagate);
- }
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::ToggleContourSuperposition()
-{
- for ( unsigned int i = 0; i < mSlicers.size(); i++)
- mSlicers[i]->ToggleContourSuperposition();
-}
-//----------------------------------------------------------------------------
-
-//----------------------------------------------------------------------------
-std::string vvSlicerManager::GetListOfAbsoluteFilePathInOneString(const std::string &actorType)
-{
- vvImageReader *reader = NULL;
-
- if(actorType=="image")
- reader = mReader;
- else if(actorType=="overlay")
- reader = mOverlayReader;
- else if(actorType=="fusion")
- reader = mFusionReader;
- else if(actorType=="vector")
- reader = mVectorReader;
-
- if(!reader)
- return "";
-
- std::string list;
- for(unsigned int i=0; i<reader->GetInputFilenames().size(); i++){
- QFileInfo fileinfo(reader->GetInputFilenames()[i].c_str()); //Do not show the path
- if(i)
- list += '\n';
- list += fileinfo.absoluteFilePath().toStdString();
- }
- return list;
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-bool vvSlicerManager::SetImage(std::string filename, vvImageReader::LoadedImageType type, int n, unsigned int slice)
-{
- mType = type;
- if (mReader.IsNull())
- mReader = vvImageReader::New();
- std::vector<std::string> filenames;
- filenames.push_back(filename);
- mReader->SetInputFilenames(filenames);
- mReader->SetSlice(slice); // Only used for SLICED type
- mReader->Update(type);
-
- SetFilename(filename, n);
- // mFileName = vtksys::SystemTools::GetFilenameName(mFileName);
- //mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));
- //mBaseFileNameNumber = n;
-
- if (mReader->GetLastError().size() == 0) {
- mImage=mReader->GetOutput();
- for ( unsigned int i = 0; i < mSlicers.size(); i++) {
- mSlicers[i]->SetFileName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));
- mSlicers[i]->SetImage(mReader->GetOutput());
- }
- } else {
- mLastError = mReader->GetLastError();
- return false;
- }
- // if (n!=0) {
- // mFileName.append("_"+clitk::toString(n));
- // }
- return true;
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::SetImage(vvImage::Pointer image)
-{
- mImage=image;
- for (unsigned int i = 0; i < mSlicers.size(); i++) {
- mSlicers[i]->SetImage(image);
- }
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-bool vvSlicerManager::SetImages(std::vector<std::string> filenames, vvImageReader::LoadedImageType type, int n)
-{
- mType = type;
- std::string fileWithoutExtension = vtksys::SystemTools::GetFilenameWithoutExtension(filenames[0]);
- if (type == vvImageReader::DICOM)
- fileWithoutExtension += "_dicom";
- else if (type == vvImageReader::MERGED)
- fileWithoutExtension += "_merged";
- else if (type == vvImageReader::MERGEDWITHTIME)
- fileWithoutExtension += "_merged_wt";
-
- mFileName = vtksys::SystemTools::GetFilenameName(mFileName);
- mFileName = fileWithoutExtension + vtksys::SystemTools::GetFilenameExtension(filenames[0]);
- if (mReader.IsNull())
- mReader = vvImageReader::New();
- mReader->SetInputFilenames(filenames);
- mReader->Update(type);
-
- mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));
- mBaseFileNameNumber = n;
-
- if (mReader->GetLastError().size() == 0) {
- mImage=mReader->GetOutput();
- for ( unsigned int i = 0; i < mSlicers.size(); i++) {
- mSlicers[i]->SetFileName(fileWithoutExtension);
- mSlicers[i]->SetImage(mReader->GetOutput());
- }
- } else {
- mLastError = mReader->GetLastError();
- return false;
- }
- if (n!=0) {
- mFileName.append("_"+clitk::toString(n));
- }
- return true;
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-bool vvSlicerManager::SetOverlay(std::vector<std::string> filenames,int dim, std::string component, vvImageReader::LoadedImageType type)
-{
- mOverlayName = filenames[0];
- mOverlayComponent = component;
- if (dim > mImage->GetNumberOfDimensions()) {
- mLastError = " Overlay dimension cannot be greater than reference image!";
- return false;
- }
- if (mOverlayReader.IsNull())
- mOverlayReader = vvImageReader::New();
- mOverlayReader->SetInputFilenames(filenames);
- mOverlayReader->Update(type);
- if (mOverlayReader->GetLastError().size() == 0) {
- for ( unsigned int i = 0; i < mSlicers.size(); i++) {
- mSlicers[i]->SetOverlay(mOverlayReader->GetOutput());
- }
- } else {
- mLastError = mOverlayReader->GetLastError();
- return false;
- }
- return true;
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-bool vvSlicerManager::SetFusion(std::string filename,int dim, std::string component)
-{
- mFusionName = filename;
- mFusionComponent = component;
- if (dim > mImage->GetNumberOfDimensions()) {
- mLastError = " Overlay dimension cannot be greater then reference image!";
- return false;
- }
- if (mFusionReader.IsNull())
- mFusionReader = vvImageReader::New();
- std::vector<std::string> filenames;
- filenames.push_back(filename);
- mFusionReader->SetInputFilenames(filenames);
- mFusionReader->Update(mImage->GetNumberOfDimensions(),component.c_str(),mType);
- if (mFusionReader->GetLastError().size() == 0) {
- for ( unsigned int i = 0; i < mSlicers.size(); i++) {
- mSlicers[i]->SetFusion(mFusionReader->GetOutput());
- }
- } else {
- mLastError = mFusionReader->GetLastError();
- return false;
- }
- double *fusRange = mFusionReader->GetOutput()->GetVTKImages()[0]->GetScalarRange();
- mFusionLevel = (fusRange[0]+fusRange[1])/2;
- mFusionWindow = fusRange[1]-fusRange[0];
-
- return true;
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-bool vvSlicerManager::SetVF(std::string filename)
-{
- if (mVectorReader.IsNull())
- mVectorReader = vvImageReader::New();
- mVectorReader->SetInputFilename(filename);
-
- if (mType == vvImageReader::IMAGEWITHTIME)
- mVectorReader->Update(vvImageReader::VECTORFIELDWITHTIME);
- else
- mVectorReader->Update(vvImageReader::VECTORFIELD);
- if (mVectorReader->GetLastError().size() != 0) {
- mLastError = mVectorReader->GetLastError();
- return false;
- } else
- return SetVF(mVectorReader->GetOutput(),filename);
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-bool vvSlicerManager::SetVF(vvImage::Pointer vf,std::string filename)
-{
- if (vf->GetNumberOfDimensions() > mImage->GetNumberOfDimensions()) {
- mLastError = "Sorry, vector field dimension cannot be greater then reference image.";
- return false;
- }
- if (vf->GetNumberOfDimensions() == 4) {
- if (vf->GetSpacing()[3] != mImage->GetSpacing()[3]) {
- mLastError = "Sorry, vector field time spacing cannot be different from time spacing of the reference image.";
- return false;
- }
- if (vf->GetOrigin()[3] != mImage->GetOrigin()[3]) {
- mLastError = "Sorry, vector field time origin cannot be different from time origin of the reference image.";
- return false;
- }
- }
- mVF=vf;
- mVFName = filename;
- for ( unsigned int i = 0; i < mSlicers.size(); i++) {
- mSlicers[i]->SetVF(vf);
- }
- return true;
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-vvSlicer* vvSlicerManager::GetSlicer(int i)
-{
- return mSlicers[i];
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::UpdateSlicer(int num, bool state)
-{
- if (mSlicers[num]->GetImage())
- mSlicers[num]->SetDisplayMode(state);
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::SetSlicerWindow(int i, vtkRenderWindow* RW)
-{
- mSlicers[i]->SetRenderWindow(i,RW);
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::SetInteractorStyleNavigator(int i, vtkInteractorStyle* style)
-{
- vvSlicerManagerCommand *smc = vvSlicerManagerCommand::New();
- smc->SM = this;
- smc->SetSlicerNumber(i);
- mSlicers[i]->GetRenderWindow()->GetInteractor()->SetInteractorStyle(style);
-
- mSlicers[i]->GetRenderWindow()->GetInteractor()->
- GetInteractorStyle()->AddObserver(vtkCommand::KeyPressEvent, smc);
- mSlicers[i]->GetRenderWindow()->GetInteractor()->
- GetInteractorStyle()->AddObserver(vtkCommand::WindowLevelEvent, smc);
- mSlicers[i]->GetRenderWindow()->GetInteractor()->
- GetInteractorStyle()->AddObserver(vtkCommand::EndWindowLevelEvent, smc);
- mSlicers[i]->GetRenderWindow()->GetInteractor()->
- GetInteractorStyle()->AddObserver(vtkCommand::StartWindowLevelEvent, smc);
- mSlicers[i]->GetRenderWindow()->GetInteractor()->
- GetInteractorStyle()->AddObserver(vtkCommand::PickEvent, smc);
- mSlicers[i]->GetRenderWindow()->GetInteractor()->
- GetInteractorStyle()->AddObserver(vtkCommand::StartPickEvent, smc);
- mSlicers[i]->GetRenderWindow()->GetInteractor()->
- GetInteractorStyle()->AddObserver(vtkCommand::LeaveEvent, smc);
- mSlicers[i]->GetRenderWindow()->GetInteractor()->
- GetInteractorStyle()->AddObserver(vtkCommand::UserEvent, smc);
- mSlicers[i]->GetRenderWindow()->GetInteractor()->
- GetInteractorStyle()->AddObserver(vtkCommand::MouseWheelForwardEvent, smc);
- mSlicers[i]->GetRenderWindow()->GetInteractor()->
- GetInteractorStyle()->AddObserver(vtkCommand::MouseWheelBackwardEvent, smc);
- // mSlicers[i]->GetRenderWindow()->GetInteractor()->
- // GetInteractorStyle()->AddObserver(vtkCommand::LeftButtonReleaseEvent, smc);
- mSlicers[i]->GetRenderWindow()->GetInteractor()->
- GetInteractorStyle()->AddObserver(vtkCommand::EndPickEvent, smc);
- mSlicers[i]->GetRenderWindow()->GetInteractor()->
- GetInteractorStyle()->AddObserver(vtkCommand::EndInteractionEvent, smc);
- smc->Delete();
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::LeftButtonReleaseEvent(int slicer)
-{
- emit LeftButtonReleaseSignal(slicer);
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::EmitMousePositionUpdated(int slicer)
-{
- emit MousePositionUpdatedSignal(slicer);
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::EmitKeyPressed(std::string KeyPress)
-{
- emit KeyPressedSignal(KeyPress);
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::SetSliceOrientation(int slicer, int orientation)
-{
- mSlicers[slicer]->SetSliceOrientation(orientation);
- emit UpdateOrientation(slicer, orientation);
-}
-//----------------------------------------------------------------------------
-
-//----------------------------------------------------------------------------
-int vvSlicerManager::GetTSlice()
-{
- return mSlicers[0]->GetTSlice();
-}
-//----------------------------------------------------------------------------
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::SetTSlice(int slice)
-{
- if (slice < 0)
- slice = 0;
- else if (slice > mSlicers[0]->GetTMax())
- slice = mSlicers[0]->GetTMax();
- if (mLandmarks)
- mLandmarks->SetTime(slice);
- for ( unsigned int i = 0; i < mSlicers.size(); i++) {
- if (slice != mSlicers[i]->GetMaxCurrentTSlice()) {
- mSlicers[i]->SetTSlice(slice);
- UpdateTSlice(i);
- }
- }
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::SetNextTSlice(int originating_slicer)
-{
- int t = mSlicers[0]->GetMaxCurrentTSlice();
- t++;
- if (t > mSlicers[0]->GetTMax())
- t = 0;
- //std::cout << "vvSlicerManager::SetNextTSlice" << std::endl;
- emit UpdateTSlice(originating_slicer,t);
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::SetPreviousTSlice(int originating_slicer)
-{
- int t = mSlicers[0]->GetMaxCurrentTSlice();
- t--;
- if (t < 0)
- t = mSlicers[0]->GetTMax();
- //std::cout << "vvSlicerManager::SetPreviousTSlice" << std::endl;
- emit UpdateTSlice(originating_slicer,t);
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::ToggleInterpolation()
-{
- bool interpolate=!(mSlicers[0]->GetImageActor()->GetInterpolate());
- for ( unsigned int i = 0; i < mSlicers.size(); i++) {
- mSlicers[i]->GetImageActor()->SetInterpolate(interpolate);
- if (mSlicers[i]->GetOverlayActor())
- mSlicers[i]->GetOverlayActor()->SetInterpolate(interpolate);
- if (mSlicers[i]->GetFusionActor())
- mSlicers[i]->GetFusionActor()->SetInterpolate(interpolate);
- }
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::SetTSliceInSlicer(int tslice, int slicer)
-{
- if (tslice < 0)
- tslice = 0;
- else if (tslice > mSlicers[slicer]->GetTMax())
- tslice = mSlicers[slicer]->GetTMax();
- if (mLandmarks)
- mLandmarks->SetTime(tslice);
-
- if (mSlicers[slicer]->GetMaxCurrentTSlice() == tslice) return;
-
- mSlicers[slicer]->SetTSlice(tslice);
-
- if(mSlicingPreset==VOXELS_SLICING) {
- vtkMatrix4x4 *imageTransformInverse = vtkMatrix4x4::New();
- mImage->GetTransform()[mSlicers[slicer]->GetTSlice()]->GetInverse(imageTransformInverse);
- this->GetSlicer(slicer)->GetSlicingTransform()->SetMatrix(imageTransformInverse);
- imageTransformInverse->Delete();
- }
-
- UpdateTSlice(slicer);
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::SetColorWindow(double s)
-{
- for ( unsigned int i = 0; i < mSlicers.size(); i++) {
- mSlicers[i]->SetColorWindow(s);
- }
-}
-//----------------------------------------------------------------------------
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::SetColorLevel(double s)
-{
- for ( unsigned int i = 0; i < mSlicers.size(); i++) {
- mSlicers[i]->SetColorLevel(s);
- }
-}
-//----------------------------------------------------------------------------
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::SetOverlayColorWindow(double s)
-{
- for ( unsigned int i = 0; i < mSlicers.size(); i++) {
- mSlicers[i]->SetOverlayColorWindow(s);
- }
-}
-//----------------------------------------------------------------------------
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::SetOverlayColorLevel(double s)
-{
- for ( unsigned int i = 0; i < mSlicers.size(); i++) {
- mSlicers[i]->SetOverlayColorLevel(s);
- }
-}
-//----------------------------------------------------------------------------
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::SetLinkOverlayWindowLevel(bool b)
-{
- for ( unsigned int i = 0; i < mSlicers.size(); i++) {
- mSlicers[i]->SetLinkOverlayWindowLevel(b);
- }
-}
-//----------------------------------------------------------------------------
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::SetCursorAndCornerAnnotationVisibility(int s)
-{
- for ( unsigned int i = 0; i < mSlicers.size(); i++) {
- mSlicers[i]->SetCursorVisibility(s);
- mSlicers[i]->SetCornerAnnotationVisibility(s);
- }
-}
-//----------------------------------------------------------------------------
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::SetOpacity(int i, double factor)
-{
- mSlicers[i]->SetOpacity(1/factor);
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::UpdateViews(int current,int slicer)
-{
- double p[3], pt[3];
- p[0] = mSlicers[slicer]->GetCurrentPosition()[0];
- p[1] = mSlicers[slicer]->GetCurrentPosition()[1];
- p[2] = mSlicers[slicer]->GetCurrentPosition()[2];
- mSlicers[slicer]->GetSlicingTransform()->GetInverse()->TransformPoint(p, pt);
-
- double x = (pt[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0])
- /mSlicers[slicer]->GetInput()->GetSpacing()[0];
- double y = (pt[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1])
- /mSlicers[slicer]->GetInput()->GetSpacing()[1];
- double z = (pt[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2])
- /mSlicers[slicer]->GetInput()->GetSpacing()[2];
-
- if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0]-0.5 &&
- x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1]+0.5 &&
- y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2]-0.5 &&
- y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3]+0.5 &&
- z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4]-0.5 &&
- z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]+0.5) {
- mSlicers[slicer]->UpdateCursorPosition();
- mSlicers[slicer]->SetCursorColor(10,212,255);
- mSelectedSlicer = slicer;
-
- switch (mSlicers[slicer]->GetSliceOrientation()) {
- case vtkImageViewer2::SLICE_ORIENTATION_XY:
- if (mSlicers[slicer]->GetSlice() != (int)lrint(z))
- mSlicers[slicer]->SetSlice((int)lrint(z));
- break;
-
- case vtkImageViewer2::SLICE_ORIENTATION_XZ:
- if (mSlicers[slicer]->GetSlice() != (int)lrint(y))
- mSlicers[slicer]->SetSlice((int)lrint(y));
- break;
-
- case vtkImageViewer2::SLICE_ORIENTATION_YZ:
- if (mSlicers[slicer]->GetSlice() != (int)lrint(x))
- mSlicers[slicer]->SetSlice((int)lrint(x));
- break;
- }
- mSlicers[slicer]->Render();
-
- for ( unsigned int i = 0; i < mSlicers.size(); i++) {
- if (i != (unsigned int)slicer
- && mSlicers[i]->GetRenderer()->GetDraw()
- && mSlicers[i]->GetRenderWindow()->GetSize()[0] > 2
- && mSlicers[i]->GetRenderWindow()->GetSize()[1] > 2) {
- mSlicers[i]->SetCurrentPosition(p[0], p[1], p[2], mSlicers[slicer]->GetMaxCurrentTSlice());
- mSlicers[i]->UpdateCursorPosition();
- if (current) { //do not display corner annotation if image is the one picked
- mSlicers[i]->SetCurrentPosition(-VTK_DOUBLE_MAX,-VTK_DOUBLE_MAX,
- -VTK_DOUBLE_MAX, mSlicers[slicer]->GetMaxCurrentTSlice());
- mSlicers[i]->SetCursorColor(255,10,212);
- } else {
- mSlicers[i]->SetCursorColor(150,10,282);
- }
- switch (mSlicers[i]->GetSliceOrientation()) {
- case vtkImageViewer2::SLICE_ORIENTATION_XY:
- if (mSlicers[i]->GetSlice() != (int)lrint(z))
- mSlicers[i]->SetSlice((int)lrint(z));
- break;
-
- case vtkImageViewer2::SLICE_ORIENTATION_XZ:
- if (mSlicers[i]->GetSlice() != (int)lrint(y))
- mSlicers[i]->SetSlice((int)lrint(y));
- break;
-
- case vtkImageViewer2::SLICE_ORIENTATION_YZ:
- if (mSlicers[i]->GetSlice() != (int)lrint(x))
- mSlicers[i]->SetSlice((int)lrint(x));
- break;
- }
-
- mSlicers[i]->Render();
-
- UpdateSlice(i);
- UpdateTSlice(i);
- }
- }
- }
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::UpdateLinked(int slicer)
-{
- double p[3], pt[3];
- p[0] = mSlicers[slicer]->GetCurrentPosition()[0];
- p[1] = mSlicers[slicer]->GetCurrentPosition()[1];
- p[2] = mSlicers[slicer]->GetCurrentPosition()[2];
- mSlicers[slicer]->GetSlicingTransform()->GetInverse()->TransformPoint(p, pt);
- double x = (pt[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0]) / mSlicers[slicer]->GetInput()->GetSpacing()[0];
- double y = (pt[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1]) / mSlicers[slicer]->GetInput()->GetSpacing()[1];
- double z = (pt[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2]) / mSlicers[slicer]->GetInput()->GetSpacing()[2];
-
- if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0]-0.5 &&
- x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1]+0.5 &&
- y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2]-0.5 &&
- y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3]+0.5 &&
- z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4]-0.5 &&
- z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]+0.5) {
- for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++) {
- emit UpdateLinkManager(*i, slicer, p[0], p[1], p[2], mSlicers[slicer]->GetMaxCurrentTSlice());
- }
- }
-}
-//----------------------------------------------------------------------------
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::UpdateLinkedNavigation(vvSlicer *refSlicer, bool bPropagate)
-{
- vtkCamera *refCam = refSlicer->GetRenderer()->GetActiveCamera();
-
- double refPosition[3];
- refCam->GetPosition(refPosition);
- refPosition[refSlicer->GetSliceOrientation()] = refSlicer->GetSlice() *
- refSlicer->GetInput()->GetSpacing()[refSlicer->GetSliceOrientation()] +
- refSlicer->GetInput()->GetOrigin()[refSlicer->GetSliceOrientation()];
-
- refSlicer->GetSlicingTransform()->TransformPoint(refPosition, refPosition);
- mSlicers[0]->GetSlicingTransform()->GetInverse()->TransformPoint(refPosition, refPosition);
-
- for ( unsigned int i = 0; i < mSlicers.size(); i++) {
- vtkCamera *camera = mSlicers[i]->GetRenderer()->GetActiveCamera();
- camera->SetParallelScale(refCam->GetParallelScale());
-
- double position[3], focal[3];
- camera->GetPosition(position);
- camera->GetFocalPoint(focal);
-
- for(int j=0; j<3; j++) {
- if(j!=mSlicers[i]->GetSliceOrientation()) {
- position[j] = refPosition[j];
- focal[j] = refPosition[j];
- }
- }
-
- camera->SetFocalPoint(focal);
- camera->SetPosition(position);
-
- //Fix for bug #243
- mSlicers[i]->ForceUpdateDisplayExtent();
- }
-
- Render();
- if(bPropagate)
- for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++)
- emit UpdateLinkedNavigation(*i, this, refSlicer);
-}
-//----------------------------------------------------------------------------
-
-//----------------------------------------------------------------------------
-double vvSlicerManager::GetColorWindow() const
-{
- if (mSlicers.size())
- return mSlicers[0]->GetColorWindow();
- return -1;
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-double vvSlicerManager::GetColorLevel() const
-{
- if (mSlicers.size())
- return mSlicers[0]->GetColorLevel();
- return -1;
-}
-//----------------------------------------------------------------------------
-
-//----------------------------------------------------------------------------
-double vvSlicerManager::GetOverlayColorWindow() const
-{
- if (mSlicers.size())
- return mSlicers[0]->GetOverlayColorWindow();
- return -1;
-}
-//----------------------------------------------------------------------------
-
-//----------------------------------------------------------------------------
-double vvSlicerManager::GetOverlayColorLevel() const
-{
- if (mSlicers.size())
- return mSlicers[0]->GetOverlayColorLevel();
- return -1;
-}
-//----------------------------------------------------------------------------
-
-//----------------------------------------------------------------------------
-bool vvSlicerManager::GetLinkOverlayWindowLevel() const
-{
- if (mSlicers.size())
- return mSlicers[0]->GetLinkOverlayWindowLevel();
- return -1;
-}
-//----------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-void vvSlicerManager::ResetTransformationToIdentity(const std::string actorType)
-{
- if(actorType == "image")
- for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
- this->GetImage()->GetTransform()[i]->Identity();
- else if(actorType == "overlay")
- for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
- this->GetSlicer(0)->GetOverlay()->GetTransform()[i]->Identity();
- else if(actorType == "fusion")
- for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
- this->GetSlicer(0)->GetFusion()->GetTransform()[i]->Identity();
- else if(actorType == "vf")
- for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
- this->GetVF()->GetTransform()[i]->Identity();
- else
- return;
-
- for(int i=0; i< this->GetNumberOfSlicers(); i++){
- this->GetSlicer(i)->ForceUpdateDisplayExtent();
- this->GetSlicer(i)->ResetCamera();
- this->GetSlicer(i)->Render();
- }
-}
-//------------------------------------------------------------------------------
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::Render()
-{
- for ( unsigned int i = 0; i < mSlicers.size(); i++) {
- mSlicers[i]->Render();
- }
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::GenerateDefaultLookupTable()
-{
- SetPreset(mPreset);
- SetColorMap(mColorMap);
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::Reload()
-{
- mReader->Update(mType);
- mImage=mReader->GetOutput();
- for ( unsigned int i = 0; i < mSlicers.size(); i++) {
- mSlicers[i]->SetImage(mImage);
- }
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::ReloadFusion()
-{
- mFusionReader->Update(mImage->GetNumberOfDimensions(),mFusionComponent.c_str(),mType);
-
- for ( unsigned int i = 0; i < mSlicers.size(); i++) {
- mSlicers[i]->SetFusion(mFusionReader->GetOutput());
- mSlicers[i]->Render();
- }
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::ReloadOverlay()
-{
- mOverlayReader->Update(mImage->GetNumberOfDimensions(),mOverlayComponent.c_str(),mType);
- for ( unsigned int i = 0; i < mSlicers.size(); i++) {
- mSlicers[i]->SetOverlay(mOverlayReader->GetOutput());
- mSlicers[i]->Render();
- }
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::ReloadVF()
-{
- mVectorReader->Update(vvImageReader::VECTORFIELD); //deletes the old images through the VF::Init() function
- mVF=mVectorReader->GetOutput();
- for ( unsigned int i = 0; i < mSlicers.size(); i++) {
- mSlicers[i]->SetVF(mVF);
- mSlicers[i]->Render();
- }
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::RemoveActor(const std::string& actor_type, int overlay_index)
-{
- if (actor_type =="overlay")
- mOverlayReader = NULL;
-
- if (actor_type =="fusion")
- mFusionReader = NULL;
-
- for (unsigned int i = 0; i < mSlicers.size(); i++)
- mSlicers[i]->RemoveActor(actor_type,overlay_index);
-
- if (actor_type=="vector") {
- mVF=NULL;
- mVectorReader=NULL;
- }
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::RemoveActors()
-{
- ///This method leaks a few objects. See RemoveActor for what a
- ///correct implementation would look like
- //DS -> probably due to the reader (now released in the
- //RemoveActor() function. (I hope)
- for ( unsigned int i = 0; i < mSlicers.size(); i++) {
- mSlicers[i]->SetDisplayMode(0);
- mSlicers[i]->GetRenderer()->RemoveActor(mSlicers[i]->GetImageActor());
- }
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::UpdateInfoOnCursorPosition(int slicer)
-{
- // int view = mSlicers[slicer]->GetSliceOrientation();
- // int slice = mSlicers[slicer]->GetSlice();
- double x = mSlicers[slicer]->GetCursorPosition()[0];
- double y = mSlicers[slicer]->GetCursorPosition()[1];
- double z = mSlicers[slicer]->GetCursorPosition()[2];
- double X = (x - mSlicers[slicer]->GetInput()->GetOrigin()[0])/
- mSlicers[slicer]->GetInput()->GetSpacing()[0];
- double Y = (y - mSlicers[slicer]->GetInput()->GetOrigin()[1])/
- mSlicers[slicer]->GetInput()->GetSpacing()[1];
- double Z = (z - mSlicers[slicer]->GetInput()->GetOrigin()[2])/
- mSlicers[slicer]->GetInput()->GetSpacing()[2];
- double value = -VTK_DOUBLE_MAX;
- int displayVec = 0;
- double xVec=0, yVec=0, zVec=0, valueVec=0;
- int displayOver = 0;
- int displayFus = 0;
- double valueOver=0, valueFus=0;
- if (X >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] &&
- X <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] &&
- Y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&
- Y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&
- Z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&
- Z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]) {
- value = this->GetScalarComponentAsDouble(mSlicers[slicer]->GetInput(), X, Y, Z);
-
- if (mSlicers[slicer]->GetVFActor() ) {
- displayVec = 1;
- unsigned int currentTime = mSlicers[slicer]->GetMaxCurrentTSlice();
- vtkImageData *vf = NULL;
-
- if (mSlicers[slicer]->GetVF()->GetVTKImages().size() > currentTime)
- vf = mSlicers[slicer]->GetVF()->GetVTKImages()[currentTime];
- else
- vf = mSlicers[slicer]->GetVF()->GetVTKImages()[0];
-
- if (vf) {
- double Xvf = (x - vf->GetOrigin()[0])/ vf->GetSpacing()[0];
- double Yvf = (y - vf->GetOrigin()[1])/ vf->GetSpacing()[1];
- double Zvf = (z - vf->GetOrigin()[2])/ vf->GetSpacing()[2];
- xVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 0);
- yVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 1);
- zVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 2);
- valueVec = sqrt(xVec*xVec + yVec*yVec + zVec*zVec);
- }
- }
- if (mSlicers[slicer]->GetOverlayActor() ) {
- displayOver = 1;
- vtkImageData *overlay = dynamic_cast<vtkImageData*>(mSlicers[slicer]->GetOverlayMapper()->GetInput());
- double Xover = (x - overlay->GetOrigin()[0]) / overlay->GetSpacing()[0];
- double Yover = (y - overlay->GetOrigin()[1]) / overlay->GetSpacing()[1];
- double Zover = (z - overlay->GetOrigin()[2]) / overlay->GetSpacing()[2];
- valueOver = this->GetScalarComponentAsDouble(overlay, Xover, Yover, Zover);
- }
- if (mSlicers[slicer]->GetFusionActor() ) {
- displayFus = 1;
- vtkImageData *fusion = dynamic_cast<vtkImageData*>(mSlicers[slicer]->GetFusionMapper()->GetInput());
- double Xover = (x - fusion->GetOrigin()[0]) / fusion->GetSpacing()[0];
- double Yover = (y - fusion->GetOrigin()[1]) / fusion->GetSpacing()[1];
- double Zover = (z - fusion->GetOrigin()[2]) / fusion->GetSpacing()[2];
- valueFus = this->GetScalarComponentAsDouble(fusion, Xover, Yover, Zover);
- }
- emit UpdatePosition(mSlicers[slicer]->GetCursorVisibility(),
- x,y,z,X,Y,Z,value);
- emit UpdateVector(displayVec,xVec, yVec, zVec, valueVec);
- emit UpdateOverlay(displayOver,valueOver,value);
- emit UpdateFusion(displayFus,valueFus);
- }
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::Activated()
-{
- emit currentImageChanged(mId);
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::Picked()
-{
- emit currentPickedImageChanged(mId);
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::UpdateWindowLevel()
-{
- emit WindowLevelChanged();
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::UpdateSlice(int slicer)
-{
- if (mPreviousSlice[slicer] == mSlicers[slicer]->GetSlice()) {
- //DD("============= NOTHING");
- return;
- }
- //std::cout << "vvSlicerManager::UpdateSlice " << slicer << " " << mSlicers[slicer]->GetSlice() << std::endl;
- emit UpdateSlice(slicer, mSlicers[slicer]->GetSlice());
- mSlicers[slicer]->Render(); // DS <-- I add this, this could/must be the only Render ...
- mPreviousSlice[slicer] = mSlicers[slicer]->GetSlice();
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::UpdateTSlice(int slicer)
-{
- int slice = mSlicers[slicer]->GetSlice();
- int tslice = mSlicers[slicer]->GetMaxCurrentTSlice();
- if (mPreviousSlice[slicer] == slice) {
- if (mPreviousTSlice[slicer] == tslice) {
- // DD("************** NOTHING ***********");
- return;
- }
- }
- mPreviousSlice[slicer] = slice;
- mPreviousTSlice[slicer] = tslice;
- //std::cout << "vvSlicerManager::UpdateTSlice " << slicer << " " << tslice << std::endl;
- emit UpdateTSlice(slicer, tslice);
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::UpdateSliceRange(int slicer)
-{
- emit UpdateSliceRange(slicer,
- mSlicers[slicer]->GetSliceRange()[0], mSlicers[slicer]->GetSliceRange()[1],
- 0,mSlicers[slicer]->GetTMax());
-}
-//----------------------------------------------------------------------------
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::SetSlicingPreset(SlicingPresetType preset)
-{
- if(mSlicingPreset==preset)
- return;
-
- vtkMatrix4x4 *imageTransformInverse = vtkMatrix4x4::New();
- mImage->GetTransform()[this->GetTSlice()]->GetInverse(imageTransformInverse);
-
- for(int i=0; i< this->GetNumberOfSlicers(); i++){
- vvSlicer *s = this->GetSlicer(i);
- switch(preset)
- {
- case WORLD_SLICING:
- s->GetSlicingTransform()->Identity();
- break;
- case VOXELS_SLICING:
- s->GetSlicingTransform()->SetMatrix(imageTransformInverse);
- break;
- default:
- imageTransformInverse->Delete();
- return;
- }
- s->ForceUpdateDisplayExtent();
- s->SetSlice((s->GetInput()->GetWholeExtent()[s->GetSliceOrientation()*2+1]
- +s->GetInput()->GetWholeExtent()[s->GetSliceOrientation()*2])/2.0);
- s->ResetCamera();
- s->Render();
- }
-
- imageTransformInverse->Delete();
- mSlicingPreset = preset;
-}
-
-//----------------------------------------------------------------------------
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::SetPreset(int preset)
-{
- //vtkLookupTable* LUT = static_cast<vtkLookupTable*>(mSlicers[0]->GetWindowLevel()->GetLookupTable());
- double window = mSlicers[0]->GetColorWindow();
- double level = mSlicers[0]->GetColorLevel();
-
- std::string component_type=mImage->GetScalarTypeAsITKString();
- switch (preset) {
- case 0:
- double range[2];
- mImage->GetScalarRange(range);
- window = range[1] - range[0];
- level = (range[1] + range[0])* 0.5;
- break;
- case 1:
- window = 2000;
- level = 0;
- break;
- case 2:
- window = 400;
- level = 20;
- break;
- case 3: // lungs (same as FOCAL)
- window = 1700;
- level = -300;
- break;
- case 4:
- window = 1000;
- level = 500;
- break;
- case 5:
- window = 1;
- level = 0.5;
- break;
- case 6:
- break;
- case 7:
- window=1.;
- level=0.;
- break;
- }
- mPreset = preset;
- this->SetColorWindow(window);
- this->SetColorLevel(level);
-
- //if (LUT)
- //{
- // SetColorMap(-1);
- //}
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::SetLocalColorWindowing(const int slicer, const bool bCtrlKey)
-{
- double min, max;
- if(bCtrlKey && this->mSlicers[slicer]->GetFusion()) {
- int t = mSlicers[slicer]->GetFusionTSlice();
- this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max,
- this->mSlicers[slicer]->GetFusion()->GetVTKImages()[t],
- this->mSlicers[slicer]->GetConcatenatedFusionTransform());
- this->SetFusionWindow(max-min);
- this->SetFusionLevel(0.5*(min+max));
- this->SetColorMap(mColorMap);
- }
- else if(bCtrlKey && this->mSlicers[slicer]->GetOverlay()) {
- int t = mSlicers[slicer]->GetOverlayTSlice();
- this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max,
- this->mSlicers[slicer]->GetOverlay()->GetVTKImages()[t],
- this->mSlicers[slicer]->GetConcatenatedOverlayTransform());
- if(this->mSlicers[slicer]->GetLinkOverlayWindowLevel()){
- this->SetColorWindow(max-min);
- this->SetColorLevel(0.5*(min+max));
- } else {
- this->SetOverlayColorWindow(max-min);
- this->SetOverlayColorLevel(0.5*(min+max));
- }
- }
- else {
- int t = this->GetTSlice();
- this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max,
- this->mSlicers[slicer]->GetImage()->GetVTKImages()[t],
- this->mSlicers[slicer]->GetConcatenatedTransform());
- this->SetColorWindow(max-min);
- this->SetColorLevel(0.5*(min+max));
- this->SetPreset(6);
- }
- this->Render();
- this->UpdateWindowLevel();
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::SetColorMap(int colormap)
-{
- double range[2];
- range[0] = mSlicers[0]->GetInput()->GetScalarRange()[0];
- range[1] = mSlicers[0]->GetInput()->GetScalarRange()[1];
-
- double window = mSlicers[0]->GetWindowLevel()->GetWindow();
- double level = mSlicers[0]->GetWindowLevel()->GetLevel();
-
- vtkLookupTable* LUT = static_cast<vtkLookupTable*>(mSlicers[0]->GetWindowLevel()->GetLookupTable());
- switch (colormap) {
- case -1:
- break;
- case 0:
- LUT = NULL;
- break;
- case 1:
- if (LUT == NULL)
- LUT = vtkLookupTable::New();
- LUT->SetValueRange(0,1);
- LUT->SetSaturationRange(1,1);
- LUT->SetHueRange(0,0.18);
- break;
- case 2:
- if (LUT == NULL)
- LUT = vtkLookupTable::New();
- LUT->SetValueRange(0,1);
- LUT->SetSaturationRange(1,1);
- LUT->SetHueRange(0.4,0.80);
- break;
- case 3:
- if (LUT == NULL)
- LUT = vtkLookupTable::New();
- LUT->SetValueRange(0.5,1);
- LUT->SetSaturationRange(1,1);
- LUT->SetHueRange(0.666,0);
- break;
- case 4:
- if (LUT == NULL)
- LUT = vtkLookupTable::New();
- LUT->SetValueRange(1,1);
- LUT->SetSaturationRange(1,1);
- LUT->SetHueRange(0,1);
- LUT->SetAlphaRange(1, 1);
- break;
- case 5:
- if (LUT == NULL)
- LUT = vtkLookupTable::New();
- LUT->SetValueRange(1,1);
- LUT->SetSaturationRange(1,1);
- LUT->SetHueRange(1,0.1);
- //LUT->SetRampToLinear();
- break;
- }
- if (LUT) {
- LUT->SetTableRange(level-fabs(window)/2,level+fabs(window)/2);
- LUT->Build();
- }
- vtkWindowLevelLookupTable* fusLUT = NULL;
- if (mSlicers[0]->GetFusion()) { // && mFusionColorMap >= 0) {
- fusLUT = vtkWindowLevelLookupTable::New();
- double fusRange [2];
- fusRange[0] = mFusionLevel - mFusionWindow/2;
- fusRange[1] = mFusionLevel + mFusionWindow/2;
- double* frange = mFusionReader->GetOutput()->GetVTKImages()[0]->GetScalarRange();
- fusLUT->SetTableRange(frange);
- fusLUT->SetValueRange(1,1);
- fusLUT->SetSaturationRange(1,1);
- fusLUT->SetAlphaRange(1, 1);
- fusLUT->SetWindow(mFusionWindow);
- fusLUT->SetLevel(mFusionLevel);
- if (mFusionColorMap == 1)
- fusLUT->SetHueRange(0,0.18);
- else if (mFusionColorMap == 2)
- fusLUT->SetHueRange(0.4,0.80);
- else if (mFusionColorMap == 3)
- {
- fusLUT->SetHueRange(0.666, 0);
- fusLUT->SetValueRange(0.5, 1);
- }
- else if (mFusionColorMap == 4)
- fusLUT->SetHueRange(0,1);
- else if (mFusionColorMap <= 0)
- {
- fusLUT->SetValueRange(0,1);
- fusLUT->SetSaturationRange(0,0);
- }
-
- fusLUT->ForceBuild();
- double v[4];
-
- // set color table transparency
- //double alpha_range=(double)mFusionThresOpacity/10;
- double range_end = fusRange[0] + (double)mFusionThresOpacity*(fusRange[1] - fusRange[0])/100;
- double curr_value = fusRange[0];
- int nvalues = fusLUT->GetNumberOfTableValues();
- for (double i = 0; curr_value < range_end; i++) {
- fusLUT->GetTableValue(i, v);
- v[3] = 0;
- //if (curr_value >= -alpha_range && curr_value <= alpha_range) v[3] = pow(fabs(curr_value/alpha_range),2);
- //else v[3] = 1;
- fusLUT->SetTableValue(i, v);
- curr_value += (fusRange[1] - fusRange[0])/nvalues;
- }
- }
- for ( unsigned int i = 0; i < mSlicers.size(); i++) {
-
- if (mSlicers[i]->GetOverlay()) {
- vtkLookupTable* supLUT = vtkLookupTable::New();
- supLUT->SetTableRange(range[0],range[1]);
- supLUT->SetValueRange(1,1);
- supLUT->SetSaturationRange(1,1);
- supLUT->SetHueRange(double(mOverlayColor)/360,double(mOverlayColor)/360);
- supLUT->Build();
- vtkLookupTable* invLUT = vtkLookupTable::New();
- invLUT->SetTableRange(range[0],range[1]);
- invLUT->SetValueRange(1,1);
- invLUT->SetSaturationRange(1,1);
- invLUT->SetHueRange(double((mOverlayColor+180)%360)/360,double((mOverlayColor+180)%360)/360);
- invLUT->Build();
- mSlicers[i]->GetWindowLevel()->SetLookupTable(supLUT);
- mSlicers[i]->GetOverlayMapper()->SetLookupTable(invLUT);
- invLUT->Delete();
- supLUT->Delete();
- } else if (mSlicers[i]->GetOverlay()) {
- mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT);
- } else {
- mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT);
- }
-
- if (mSlicers[i]->GetFusion()) {
- mSlicers[i]->ShowFusionLegend(mFusionShowLegend);
- mSlicers[i]->GetFusionMapper()->SetLookupTable(fusLUT);
- mSlicers[i]->GetFusionActor()->SetOpacity(double(mFusionOpacity)/100);
- }
- }
- if (fusLUT)
- fusLUT->Delete();
- if (colormap >= 0)
- mColorMap = colormap;
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-vvLandmarks* vvSlicerManager::GetLandmarks()
-{
- if (mLandmarks == NULL) {
- mLandmarks = new vvLandmarks(mSlicers[0]->GetTMax()+1);
- for (unsigned int i = 0; i < mSlicers.size(); i++)
- mSlicers[i]->SetLandmarks(mLandmarks);
- }
- return mLandmarks;
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::AddLandmark(float x,float y,float z,float t)
-{
- double x_index = (x - mSlicers[0]->GetInput()->GetOrigin()[0])/mSlicers[0]->GetInput()->GetSpacing()[0];
- double y_index = (y - mSlicers[0]->GetInput()->GetOrigin()[1])/mSlicers[0]->GetInput()->GetSpacing()[1];
- double z_index = (z - mSlicers[0]->GetInput()->GetOrigin()[2])/mSlicers[0]->GetInput()->GetSpacing()[2];
- if (x_index >= mSlicers[0]->GetInput()->GetWholeExtent()[0]-0.5 &&
- x_index <= mSlicers[0]->GetInput()->GetWholeExtent()[1]+0.5 &&
- y_index >= mSlicers[0]->GetInput()->GetWholeExtent()[2]-0.5 &&
- y_index <= mSlicers[0]->GetInput()->GetWholeExtent()[3]+0.5 &&
- z_index >= mSlicers[0]->GetInput()->GetWholeExtent()[4]-0.5 &&
- z_index <= mSlicers[0]->GetInput()->GetWholeExtent()[5]+0.5) {
- double value = this->GetScalarComponentAsDouble(mSlicers[0]->GetInput(), x_index, y_index, z_index);
- this->GetLandmarks()->AddLandmark(x,y,z,t,value);
- emit LandmarkAdded();
- }
-}
-//----------------------------------------------------------------------------
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::PrevImage(int slicer)
-{
- emit ChangeImageWithIndexOffset(this, slicer, -1);
-}
-//----------------------------------------------------------------------------
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::NextImage(int slicer)
-{
- emit ChangeImageWithIndexOffset(this, slicer, 1);
-}
-//----------------------------------------------------------------------------
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::VerticalSliderHasChanged(int slicer, int slice)
-{
- emit AVerticalSliderHasChanged(slicer, slice);
-}
-
-//----------------------------------------------------------------------------
-
-//----------------------------------------------------------------------------
-double vvSlicerManager::GetScalarComponentAsDouble(vtkImageData *image, double X, double Y, double Z, int component)
-{
- int ix, iy, iz;
- return mSlicers[0]->GetScalarComponentAsDouble(image, X, Y, Z, ix, iy, iz, component);
-}
-//----------------------------------------------------------------------------
+/*=========================================================================\r
+ Program: vv http://www.creatis.insa-lyon.fr/rio/vv\r
+\r
+ Authors belong to:\r
+ - University of LYON http://www.universite-lyon.fr/\r
+ - Léon Bérard cancer center http://oncora1.lyon.fnclcc.fr\r
+ - CREATIS CNRS laboratory http://www.creatis.insa-lyon.fr\r
+\r
+ This software is distributed WITHOUT ANY WARRANTY; without even\r
+ the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\r
+ PURPOSE. See the copyright notices for more information.\r
+\r
+ It is distributed under dual licence\r
+\r
+ - BSD See included LICENSE.txt file\r
+ - CeCILL-B http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html\r
+ ======================================================================-====*/\r
+\r
+#include "vvSlicerManager.h"\r
+#include "vvSlicer.h"\r
+#include "vvImage.h"\r
+#include "vvSlicerManagerCommand.h"\r
+#include "vvInteractorStyleNavigator.h"\r
+#include "vvLandmarks.h"\r
+#include "vvMesh.h"\r
+#include "vvBlendImageActor.h"\r
+\r
+#include <vtkImageActor.h>\r
+#include <vtkImageData.h>\r
+#include <vtkRenderWindow.h>\r
+#include <vtkRendererCollection.h>\r
+#include <vtkRenderWindowInteractor.h>\r
+#include <vtkImageMapToWindowLevelColors.h>\r
+#include <vtkWindowLevelLookupTable.h>\r
+#include <vtkColorTransferFunction.h>\r
+#include <vtkImageClip.h>\r
+#include <vtkLODActor.h>\r
+#include <vtkPointData.h>\r
+#include <vtksys/SystemTools.hxx>\r
+#include <vtkCamera.h>\r
+\r
+#include <qfileinfo.h>\r
+#include <QMessageBox>\r
+//----------------------------------------------------------------------------\r
+vvSlicerManager::vvSlicerManager(int numberOfSlicers)\r
+{\r
+ mFileName = "";\r
+ mId = "";\r
+ mVFName = "";\r
+ mOverlayName = "";\r
+ mFusionName = "";\r
+ mVFId = "";\r
+ mLastError = "";\r
+ mType = vvImageReader::UNDEFINEDIMAGETYPE;\r
+ mColorMap = 0;\r
+ mPreset = 0;\r
+ mOverlayColor = 130;\r
+\r
+ mFusionOpacity = 30;\r
+ mFusionThresOpacity = 1;\r
+ mFusionColorMap = 3;\r
+ mFusionWindow = 1000;\r
+ mFusionLevel = 1000;\r
+ mFusionShowLegend = true;\r
+ \r
+ mFusionSequenceInvolvementCode = -1;\r
+ mFusionSequenceIndexLinkedManager = -1;\r
+ mFusionSequenceFrameIndex = -1;\r
+ mFusionSequenceNbFrames = 0;\r
+ mFusionSequenceSpatialSyncFlag = false;\r
+ mFusionSequenceTemporalSyncFlag = false;\r
+\r
+ mLandmarks = NULL;\r
+ mLinkedId.resize(0);\r
+\r
+ for ( int i = 0; i < numberOfSlicers; i++)\r
+ mSlicers.push_back(vtkSmartPointer<vvSlicer>::New());\r
+ mSelectedSlicer = -1;\r
+ \r
+ mPreviousSlice.resize(numberOfSlicers, 0);\r
+ mPreviousTSlice.resize(numberOfSlicers, 0);\r
+ mSlicingPreset = WORLD_SLICING;\r
+\r
+ \r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+vvSlicerManager::~vvSlicerManager()\r
+{\r
+ if (mLandmarks)\r
+ delete mLandmarks;\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//------------------------------------------------------------------------------\r
+void vvSlicerManager::SetFilename(std::string filename, int number)\r
+{\r
+ mFileName = filename;\r
+ mFileName = vtksys::SystemTools::GetFilenameName(mFileName);\r
+ mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));\r
+ mBaseFileNameNumber = number;\r
+\r
+ mFileName = mBaseFileName;\r
+ if (number != 0) {\r
+ mFileName.append("_"+clitk::toString(number));\r
+ }\r
+ mFileName.append(vtksys::SystemTools::GetFilenameLastExtension(filename));\r
+\r
+ for(unsigned int i=0; i<mSlicers.size(); i++) {\r
+ mSlicers[i]->SetFileName(mFileName);//vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));\r
+ }\r
+ \r
+}\r
+//------------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::AddContour(vvMesh::Pointer contour,bool propagate)\r
+{\r
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
+ mSlicers[i]->AddContour(contour,propagate);\r
+ }\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::ToggleContourSuperposition()\r
+{\r
+ for ( unsigned int i = 0; i < mSlicers.size(); i++)\r
+ mSlicers[i]->ToggleContourSuperposition();\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+//----------------------------------------------------------------------------\r
+std::string vvSlicerManager::GetListOfAbsoluteFilePathInOneString(const std::string &actorType)\r
+{\r
+ vvImageReader *reader = NULL;\r
+\r
+ if(actorType=="image")\r
+ reader = mReader;\r
+ else if(actorType=="overlay")\r
+ reader = mOverlayReader;\r
+ else if(actorType=="fusion")\r
+ reader = mFusionReader;\r
+ else if(actorType=="vector")\r
+ reader = mVectorReader;\r
+ else if(actorType=="fusionSequence")\r
+ reader = mFusionSequenceReader;\r
+\r
+ if(!reader)\r
+ return "";\r
+\r
+ std::string list;\r
+ for(unsigned int i=0; i<reader->GetInputFilenames().size(); i++){\r
+ QFileInfo fileinfo(reader->GetInputFilenames()[i].c_str()); //Do not show the path\r
+ if(i)\r
+ list += '\n';\r
+ list += fileinfo.absoluteFilePath().toStdString();\r
+ }\r
+ return list;\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+bool vvSlicerManager::SetImage(std::string filename, vvImageReader::LoadedImageType type, int n, unsigned int slice)\r
+{\r
+ mType = type;\r
+ if (mReader.IsNull())\r
+ mReader = vvImageReader::New();\r
+ std::vector<std::string> filenames;\r
+ filenames.push_back(filename);\r
+ mReader->SetInputFilenames(filenames);\r
+ mReader->SetSlice(slice); // Only used for SLICED type\r
+ mReader->Update(type);\r
+\r
+ SetFilename(filename, n);\r
+ // mFileName = vtksys::SystemTools::GetFilenameName(mFileName);\r
+ //mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));\r
+ //mBaseFileNameNumber = n;\r
+\r
+ if (mReader->GetLastError().size() == 0) {\r
+ mImage=mReader->GetOutput();\r
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
+ mSlicers[i]->SetFileName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));\r
+ mSlicers[i]->SetImage(mReader->GetOutput());\r
+ }\r
+ } else {\r
+ mLastError = mReader->GetLastError();\r
+ return false;\r
+ }\r
+ // if (n!=0) {\r
+ // mFileName.append("_"+clitk::toString(n));\r
+ // }\r
+ return true;\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::SetImage(vvImage::Pointer image)\r
+{\r
+ mImage=image;\r
+ for (unsigned int i = 0; i < mSlicers.size(); i++) {\r
+ mSlicers[i]->SetImage(image);\r
+ }\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+bool vvSlicerManager::SetImages(std::vector<std::string> filenames, vvImageReader::LoadedImageType type, int n)\r
+{\r
+ mType = type;\r
+ std::string fileWithoutExtension = vtksys::SystemTools::GetFilenameWithoutExtension(filenames[0]);\r
+ if (type == vvImageReader::DICOM)\r
+ fileWithoutExtension += "_dicom";\r
+ else if (type == vvImageReader::MERGED)\r
+ fileWithoutExtension += "_merged";\r
+ else if (type == vvImageReader::MERGEDWITHTIME)\r
+ fileWithoutExtension += "_merged_wt";\r
+\r
+ mFileName = vtksys::SystemTools::GetFilenameName(mFileName);\r
+ mFileName = fileWithoutExtension + vtksys::SystemTools::GetFilenameExtension(filenames[0]);\r
+ if (mReader.IsNull())\r
+ mReader = vvImageReader::New();\r
+ mReader->SetInputFilenames(filenames);\r
+ mReader->Update(type);\r
+\r
+ mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));\r
+ mBaseFileNameNumber = n;\r
+\r
+ if (mReader->GetLastError().size() == 0) {\r
+ mImage=mReader->GetOutput();\r
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
+ mSlicers[i]->SetFileName(fileWithoutExtension);\r
+ mSlicers[i]->SetImage(mReader->GetOutput());\r
+ }\r
+ } else {\r
+ mLastError = mReader->GetLastError();\r
+ return false;\r
+ }\r
+ if (n!=0) {\r
+ mFileName.append("_"+clitk::toString(n));\r
+ }\r
+ return true;\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+bool vvSlicerManager::SetOverlay(std::vector<std::string> filenames,int dim, std::string component, vvImageReader::LoadedImageType type)\r
+{\r
+ mOverlayName = filenames[0];\r
+ mOverlayComponent = component;\r
+ if (dim > mImage->GetNumberOfDimensions()) {\r
+ mLastError = " Overlay dimension cannot be greater than reference image!";\r
+ return false;\r
+ }\r
+ if (mOverlayReader.IsNull())\r
+ mOverlayReader = vvImageReader::New();\r
+ mOverlayReader->SetInputFilenames(filenames);\r
+ mOverlayReader->Update(type);\r
+ if (mOverlayReader->GetLastError().size() == 0) {\r
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
+ mSlicers[i]->SetOverlay(mOverlayReader->GetOutput());\r
+ }\r
+ } else {\r
+ mLastError = mOverlayReader->GetLastError();\r
+ return false;\r
+ }\r
+ return true;\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+bool vvSlicerManager::SetFusion(std::string filename,int dim, std::string component)\r
+{\r
+ mFusionName = filename;\r
+ mFusionComponent = component;\r
+ if (dim > mImage->GetNumberOfDimensions()) {\r
+ mLastError = " Overlay dimension cannot be greater then reference image!";\r
+ return false;\r
+ }\r
+ if (mFusionReader.IsNull())\r
+ mFusionReader = vvImageReader::New();\r
+ std::vector<std::string> filenames;\r
+ filenames.push_back(filename);\r
+ mFusionReader->SetInputFilenames(filenames);\r
+ mFusionReader->Update(mImage->GetNumberOfDimensions(),component.c_str(),mType);\r
+ if (mFusionReader->GetLastError().size() == 0) {\r
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
+ mSlicers[i]->SetFusion(mFusionReader->GetOutput());\r
+ }\r
+ } else {\r
+ mLastError = mFusionReader->GetLastError();\r
+ return false;\r
+ }\r
+ double *fusRange = mFusionReader->GetOutput()->GetVTKImages()[0]->GetScalarRange();\r
+ mFusionLevel = (fusRange[0]+fusRange[1])/2;\r
+ mFusionWindow = fusRange[1]-fusRange[0];\r
+\r
+ return true;\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+//----------------------------------------------------------------------------\r
+//this function is called by vvMainWindow::AddFusionSequence for the primary sequence (CT), while the given files constitute the secondary sequence.\r
+bool vvSlicerManager::SetFusionSequence(std::vector<std::string> filenames, int dim, std::string component, vvImageReader::LoadedImageType type)\r
+{\r
+ mFusionSequenceInvolvementCode = 0;\r
+\r
+ mFusionName = filenames[0];\r
+ mFusionComponent = component;\r
+\r
+ if (dim > mImage->GetNumberOfDimensions()) {\r
+ mLastError = " Fusion Sequence dimension cannot be greater than reference image!";\r
+ return false;\r
+ }\r
+\r
+ if (mFusionSequenceReader.IsNull())\r
+ mFusionSequenceReader = vvImageReader::New();\r
+\r
+ mFusionSequenceReader->SetInputFilenames(filenames);\r
+ mFusionSequenceReader->Update(type);\r
+\r
+\r
+ if (mFusionSequenceReader->GetLastError().size() == 0) {\r
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
+ mSlicers[i]->SetFusion(mFusionSequenceReader->GetOutput(), mFusionSequenceInvolvementCode);\r
+ }\r
+ } else {\r
+ mLastError = mFusionSequenceReader->GetLastError();\r
+ return false;\r
+ }\r
+ double *fusRange = mFusionSequenceReader->GetOutput()->GetVTKImages()[0]->GetScalarRange();\r
+ mFusionLevel = (fusRange[0]+fusRange[1])/2;\r
+ mFusionWindow = fusRange[1]-fusRange[0];\r
+\r
+ //store the initial transform matrices of each frame, and reset them to identity\r
+ mFusionSequenceListInitialTransformMatrices.clear();\r
+ for (unsigned i=0 ; i<mFusionSequenceReader->GetOutput()->GetTransform().size() ; i++) {\r
+ AddFusionSequenceInitialTransformMatrices( mFusionSequenceReader->GetOutput()->GetTransform()[i]->GetMatrix() );\r
+ mFusionSequenceReader->GetOutput()->GetTransform()[i]->Identity();\r
+ mFusionSequenceReader->GetOutput()->GetTransform()[i]->Update();\r
+ }\r
+\r
+ //adjust the time slider in the overlay panel\r
+ mFusionSequenceNbFrames = mFusionSequenceReader->GetOutput()->GetTransform().size()-1; //actually, this is the maximum index...\r
+ mFusionSequenceFrameIndex = std::max<int>( 0, std::min<int>(mFusionSequenceFrameIndex, mFusionSequenceNbFrames));\r
+\r
+ return true;\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+bool vvSlicerManager::SetVF(std::string filename)\r
+{\r
+ if (mVectorReader.IsNull())\r
+ mVectorReader = vvImageReader::New();\r
+ mVectorReader->SetInputFilename(filename);\r
+ \r
+ if (mType == vvImageReader::IMAGEWITHTIME)\r
+ mVectorReader->Update(vvImageReader::VECTORFIELDWITHTIME);\r
+ else\r
+ mVectorReader->Update(vvImageReader::VECTORFIELD);\r
+ if (mVectorReader->GetLastError().size() != 0) {\r
+ mLastError = mVectorReader->GetLastError();\r
+ return false;\r
+ } else\r
+ return SetVF(mVectorReader->GetOutput(),filename);\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+bool vvSlicerManager::SetVF(vvImage::Pointer vf,std::string filename)\r
+{\r
+ if (vf->GetNumberOfDimensions() > mImage->GetNumberOfDimensions()) {\r
+ mLastError = "Sorry, vector field dimension cannot be greater then reference image.";\r
+ return false;\r
+ }\r
+ if (vf->GetNumberOfDimensions() == 4) {\r
+ if (vf->GetSpacing()[3] != mImage->GetSpacing()[3]) {\r
+ mLastError = "Sorry, vector field time spacing cannot be different from time spacing of the reference image.";\r
+ return false;\r
+ }\r
+ if (vf->GetOrigin()[3] != mImage->GetOrigin()[3]) {\r
+ mLastError = "Sorry, vector field time origin cannot be different from time origin of the reference image.";\r
+ return false;\r
+ }\r
+ }\r
+ mVF=vf;\r
+ mVFName = filename;\r
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
+ mSlicers[i]->SetVF(vf);\r
+ }\r
+ return true;\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+vvSlicer* vvSlicerManager::GetSlicer(int i)\r
+{\r
+ return mSlicers[i];\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::UpdateSlicer(int num, bool state)\r
+{\r
+ if (mSlicers[num]->GetImage()) {\r
+ mSlicers[num]->SetDisplayMode(state);\r
+ }\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::SetSlicerWindow(int i, vtkRenderWindow* RW)\r
+{\r
+ mSlicers[i]->SetRenderWindow(i,RW);\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::SetInteractorStyleNavigator(int i, vtkInteractorStyle* style)\r
+{\r
+ vvSlicerManagerCommand *smc = vvSlicerManagerCommand::New();\r
+ smc->SM = this;\r
+ smc->SetSlicerNumber(i);\r
+ mSlicers[i]->GetRenderWindow()->GetInteractor()->SetInteractorStyle(style);\r
+\r
+ mSlicers[i]->GetRenderWindow()->GetInteractor()->\r
+ GetInteractorStyle()->AddObserver(vtkCommand::KeyPressEvent, smc);\r
+ mSlicers[i]->GetRenderWindow()->GetInteractor()->\r
+ GetInteractorStyle()->AddObserver(vtkCommand::WindowLevelEvent, smc);\r
+ mSlicers[i]->GetRenderWindow()->GetInteractor()->\r
+ GetInteractorStyle()->AddObserver(vtkCommand::EndWindowLevelEvent, smc);\r
+ mSlicers[i]->GetRenderWindow()->GetInteractor()->\r
+ GetInteractorStyle()->AddObserver(vtkCommand::StartWindowLevelEvent, smc);\r
+ mSlicers[i]->GetRenderWindow()->GetInteractor()->\r
+ GetInteractorStyle()->AddObserver(vtkCommand::PickEvent, smc);\r
+ mSlicers[i]->GetRenderWindow()->GetInteractor()->\r
+ GetInteractorStyle()->AddObserver(vtkCommand::StartPickEvent, smc);\r
+ mSlicers[i]->GetRenderWindow()->GetInteractor()->\r
+ GetInteractorStyle()->AddObserver(vtkCommand::LeaveEvent, smc);\r
+ mSlicers[i]->GetRenderWindow()->GetInteractor()->\r
+ GetInteractorStyle()->AddObserver(vtkCommand::UserEvent, smc);\r
+ mSlicers[i]->GetRenderWindow()->GetInteractor()->\r
+ GetInteractorStyle()->AddObserver(vtkCommand::MouseWheelForwardEvent, smc);\r
+ mSlicers[i]->GetRenderWindow()->GetInteractor()->\r
+ GetInteractorStyle()->AddObserver(vtkCommand::MouseWheelBackwardEvent, smc);\r
+ // mSlicers[i]->GetRenderWindow()->GetInteractor()->\r
+ // GetInteractorStyle()->AddObserver(vtkCommand::LeftButtonReleaseEvent, smc);\r
+ mSlicers[i]->GetRenderWindow()->GetInteractor()->\r
+ GetInteractorStyle()->AddObserver(vtkCommand::EndPickEvent, smc);\r
+ mSlicers[i]->GetRenderWindow()->GetInteractor()->\r
+ GetInteractorStyle()->AddObserver(vtkCommand::EndInteractionEvent, smc);\r
+ smc->Delete();\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::LeftButtonReleaseEvent(int slicer)\r
+{\r
+ emit LeftButtonReleaseSignal(slicer);\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::EmitMousePositionUpdated(int slicer)\r
+{\r
+ emit MousePositionUpdatedSignal(slicer);\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::EmitKeyPressed(std::string KeyPress)\r
+{\r
+ emit KeyPressedSignal(KeyPress);\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::SetSliceOrientation(int slicer, int orientation)\r
+{\r
+ mSlicers[slicer]->SetSliceOrientation(orientation);\r
+ emit UpdateOrientation(slicer, orientation);\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+//----------------------------------------------------------------------------\r
+int vvSlicerManager::GetTSlice()\r
+{\r
+ return mSlicers[0]->GetTSlice();\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::SetTSlice(int slice, bool updateLinkedImages)\r
+{\r
+ if (!updateLinkedImages) { //for fusionSequence, TMax / MaxCurrentTSlice are irrelevant.\r
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
+ mSlicers[i]->SetTSlice(slice, updateLinkedImages);\r
+ UpdateTSlice(i);\r
+ }\r
+ return;\r
+ }\r
+\r
+ if (slice < 0)\r
+ slice = 0;\r
+ else if (slice > mSlicers[0]->GetTMax())\r
+ slice = mSlicers[0]->GetTMax();\r
+ if (mLandmarks)\r
+ mLandmarks->SetTime(slice);\r
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
+ if (slice != mSlicers[i]->GetMaxCurrentTSlice()) {\r
+ mSlicers[i]->SetTSlice(slice, updateLinkedImages);\r
+ UpdateTSlice(i);\r
+ }\r
+ }\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::SetFusionSequenceTSlice(int slice)\r
+{\r
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
+ mSlicers[i]->SetFusionSequenceTSlice(slice);\r
+ UpdateTSlice(i);\r
+ }\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::SetNextTSlice(int originating_slicer)\r
+{\r
+ int t = mSlicers[0]->GetMaxCurrentTSlice();\r
+ t++;\r
+ if (t > mSlicers[0]->GetTMax())\r
+ t = 0;\r
+ //std::cout << "vvSlicerManager::SetNextTSlice" << std::endl;\r
+ emit UpdateTSlice(originating_slicer,t, mFusionSequenceInvolvementCode);\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::SetPreviousTSlice(int originating_slicer)\r
+{\r
+ int t = mSlicers[0]->GetMaxCurrentTSlice();\r
+ t--;\r
+ if (t < 0)\r
+ t = mSlicers[0]->GetTMax();\r
+ //std::cout << "vvSlicerManager::SetPreviousTSlice" << std::endl;\r
+ emit UpdateTSlice(originating_slicer,t, mFusionSequenceInvolvementCode);\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::ToggleInterpolation()\r
+{\r
+ bool interpolate=!(mSlicers[0]->GetImageActor()->GetInterpolate());\r
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
+ mSlicers[i]->GetImageActor()->SetInterpolate(interpolate);\r
+ if (mSlicers[i]->GetOverlayActor())\r
+ mSlicers[i]->GetOverlayActor()->SetInterpolate(interpolate);\r
+ if (mSlicers[i]->GetFusionActor())\r
+ mSlicers[i]->GetFusionActor()->SetInterpolate(interpolate);\r
+ }\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::SetTSliceInSlicer(int tslice, int slicer)\r
+{\r
+ if (tslice < 0)\r
+ tslice = 0;\r
+ else if (tslice > mSlicers[slicer]->GetTMax())\r
+ tslice = mSlicers[slicer]->GetTMax();\r
+ if (mLandmarks)\r
+ mLandmarks->SetTime(tslice);\r
+\r
+ if (mSlicers[slicer]->GetMaxCurrentTSlice() == tslice) return;\r
+\r
+ mSlicers[slicer]->SetTSlice(tslice);\r
+\r
+ if(mSlicingPreset==VOXELS_SLICING) {\r
+ vtkMatrix4x4 *imageTransformInverse = vtkMatrix4x4::New();\r
+ mImage->GetTransform()[mSlicers[slicer]->GetTSlice()]->GetInverse(imageTransformInverse);\r
+ this->GetSlicer(slicer)->GetSlicingTransform()->SetMatrix(imageTransformInverse);\r
+ imageTransformInverse->Delete();\r
+ }\r
+\r
+ UpdateTSlice(slicer);\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::SetColorWindow(double s)\r
+{\r
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
+ mSlicers[i]->SetColorWindow(s);\r
+ }\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::SetColorLevel(double s)\r
+{\r
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
+ mSlicers[i]->SetColorLevel(s);\r
+ }\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::SetOverlayColorWindow(double s)\r
+{\r
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
+ mSlicers[i]->SetOverlayColorWindow(s);\r
+ }\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::SetOverlayColorLevel(double s)\r
+{\r
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
+ mSlicers[i]->SetOverlayColorLevel(s);\r
+ }\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::SetLinkOverlayWindowLevel(bool b)\r
+{\r
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
+ mSlicers[i]->SetLinkOverlayWindowLevel(b);\r
+ }\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::SetCursorAndCornerAnnotationVisibility(int s)\r
+{\r
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
+ mSlicers[i]->SetCursorVisibility(s);\r
+ mSlicers[i]->SetCornerAnnotationVisibility(s);\r
+ }\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::SetOpacity(int i, double factor)\r
+{\r
+ mSlicers[i]->SetOpacity(1/factor);\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::UpdateViews(int current,int slicer)\r
+{\r
+ double p[3], pt[3];\r
+ p[0] = mSlicers[slicer]->GetCurrentPosition()[0];\r
+ p[1] = mSlicers[slicer]->GetCurrentPosition()[1];\r
+ p[2] = mSlicers[slicer]->GetCurrentPosition()[2];\r
+ mSlicers[slicer]->GetSlicingTransform()->GetInverse()->TransformPoint(p, pt);\r
+\r
+ double x = (pt[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0])\r
+ /mSlicers[slicer]->GetInput()->GetSpacing()[0];\r
+ double y = (pt[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1])\r
+ /mSlicers[slicer]->GetInput()->GetSpacing()[1];\r
+ double z = (pt[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2])\r
+ /mSlicers[slicer]->GetInput()->GetSpacing()[2];\r
+\r
+ if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0]-0.5 &&\r
+ x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1]+0.5 &&\r
+ y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2]-0.5 &&\r
+ y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3]+0.5 &&\r
+ z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4]-0.5 &&\r
+ z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]+0.5) {\r
+ mSlicers[slicer]->UpdateCursorPosition();\r
+ mSlicers[slicer]->SetCursorColor(10,212,255);\r
+ mSelectedSlicer = slicer;\r
+\r
+ switch (mSlicers[slicer]->GetSliceOrientation()) {\r
+ case vtkImageViewer2::SLICE_ORIENTATION_XY:\r
+ if (mSlicers[slicer]->GetSlice() != (int)lrint(z))\r
+ mSlicers[slicer]->SetSlice((int)lrint(z));\r
+ break;\r
+\r
+ case vtkImageViewer2::SLICE_ORIENTATION_XZ:\r
+ if (mSlicers[slicer]->GetSlice() != (int)lrint(y))\r
+ mSlicers[slicer]->SetSlice((int)lrint(y));\r
+ break;\r
+\r
+ case vtkImageViewer2::SLICE_ORIENTATION_YZ:\r
+ if (mSlicers[slicer]->GetSlice() != (int)lrint(x))\r
+ mSlicers[slicer]->SetSlice((int)lrint(x));\r
+ break;\r
+ }\r
+ mSlicers[slicer]->Render();\r
+\r
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
+ if (i != (unsigned int)slicer\r
+ && mSlicers[i]->GetRenderer()->GetDraw()\r
+ && mSlicers[i]->GetRenderWindow()->GetSize()[0] > 2\r
+ && mSlicers[i]->GetRenderWindow()->GetSize()[1] > 2) {\r
+ mSlicers[i]->SetCurrentPosition(p[0], p[1], p[2], mSlicers[slicer]->GetMaxCurrentTSlice());\r
+ mSlicers[i]->UpdateCursorPosition();\r
+ if (current) { //do not display corner annotation if image is the one picked\r
+ mSlicers[i]->SetCurrentPosition(-VTK_DOUBLE_MAX,-VTK_DOUBLE_MAX,\r
+ -VTK_DOUBLE_MAX, mSlicers[slicer]->GetMaxCurrentTSlice());\r
+ mSlicers[i]->SetCursorColor(255,10,212);\r
+ } else {\r
+ mSlicers[i]->SetCursorColor(150,10,282);\r
+ }\r
+ switch (mSlicers[i]->GetSliceOrientation()) {\r
+ case vtkImageViewer2::SLICE_ORIENTATION_XY:\r
+ if (mSlicers[i]->GetSlice() != (int)lrint(z))\r
+ mSlicers[i]->SetSlice((int)lrint(z));\r
+ break;\r
+\r
+ case vtkImageViewer2::SLICE_ORIENTATION_XZ:\r
+ if (mSlicers[i]->GetSlice() != (int)lrint(y))\r
+ mSlicers[i]->SetSlice((int)lrint(y));\r
+ break;\r
+\r
+ case vtkImageViewer2::SLICE_ORIENTATION_YZ:\r
+ if (mSlicers[i]->GetSlice() != (int)lrint(x))\r
+ mSlicers[i]->SetSlice((int)lrint(x));\r
+ break;\r
+ }\r
+ \r
+ mSlicers[i]->Render();\r
+ \r
+ UpdateSlice(i);\r
+ UpdateTSlice(i);\r
+ }\r
+ }\r
+ }\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::UpdateLinked(int slicer)\r
+{\r
+ double p[3], pt[3];\r
+ p[0] = mSlicers[slicer]->GetCurrentPosition()[0];\r
+ p[1] = mSlicers[slicer]->GetCurrentPosition()[1];\r
+ p[2] = mSlicers[slicer]->GetCurrentPosition()[2];\r
+ mSlicers[slicer]->GetSlicingTransform()->GetInverse()->TransformPoint(p, pt);\r
+ double x = (pt[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0]) / mSlicers[slicer]->GetInput()->GetSpacing()[0];\r
+ double y = (pt[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1]) / mSlicers[slicer]->GetInput()->GetSpacing()[1];\r
+ double z = (pt[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2]) / mSlicers[slicer]->GetInput()->GetSpacing()[2];\r
+\r
+ if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0]-0.5 &&\r
+ x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1]+0.5 &&\r
+ y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2]-0.5 &&\r
+ y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3]+0.5 &&\r
+ z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4]-0.5 &&\r
+ z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]+0.5) {\r
+ for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++) {\r
+ if (this->IsInvolvedInFusionSequence()) {\r
+ //this SlicerManager is involved in fusionSequence => do not synchronize the times\r
+ emit UpdateLinkManager(*i, slicer, p[0], p[1], p[2], -1);\r
+ }\r
+ else {\r
+ emit UpdateLinkManager(*i, slicer, p[0], p[1], p[2], mSlicers[slicer]->GetMaxCurrentTSlice());\r
+ }\r
+ }\r
+ }\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::UpdateLinkedNavigation(vvSlicer *refSlicer, bool bPropagate)\r
+{\r
+ vtkCamera *refCam = refSlicer->GetRenderer()->GetActiveCamera();\r
+\r
+ double refPosition[3];\r
+ refCam->GetPosition(refPosition);\r
+ refPosition[refSlicer->GetSliceOrientation()] = refSlicer->GetSlice() *\r
+ refSlicer->GetInput()->GetSpacing()[refSlicer->GetSliceOrientation()] +\r
+ refSlicer->GetInput()->GetOrigin()[refSlicer->GetSliceOrientation()];\r
+\r
+ refSlicer->GetSlicingTransform()->TransformPoint(refPosition, refPosition);\r
+ mSlicers[0]->GetSlicingTransform()->GetInverse()->TransformPoint(refPosition, refPosition);\r
+\r
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
+ vtkCamera *camera = mSlicers[i]->GetRenderer()->GetActiveCamera();\r
+ camera->SetParallelScale(refCam->GetParallelScale());\r
+\r
+ double position[3], focal[3];\r
+ camera->GetPosition(position);\r
+ camera->GetFocalPoint(focal);\r
+\r
+ for(int j=0; j<3; j++) {\r
+ if(j!=mSlicers[i]->GetSliceOrientation()) {\r
+ position[j] = refPosition[j];\r
+ focal[j] = refPosition[j];\r
+ }\r
+ }\r
+\r
+ camera->SetFocalPoint(focal);\r
+ camera->SetPosition(position);\r
+\r
+ //Fix for bug #243\r
+ mSlicers[i]->ForceUpdateDisplayExtent();\r
+ }\r
+ \r
+ Render();\r
+ if(bPropagate)\r
+ for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++)\r
+ emit UpdateLinkedNavigation(*i, this, refSlicer);\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+//----------------------------------------------------------------------------\r
+double vvSlicerManager::GetColorWindow() const\r
+{\r
+ if (mSlicers.size())\r
+ return mSlicers[0]->GetColorWindow();\r
+ return -1;\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+double vvSlicerManager::GetColorLevel() const\r
+{\r
+ if (mSlicers.size())\r
+ return mSlicers[0]->GetColorLevel();\r
+ return -1;\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+//----------------------------------------------------------------------------\r
+double vvSlicerManager::GetOverlayColorWindow() const\r
+{\r
+ if (mSlicers.size())\r
+ return mSlicers[0]->GetOverlayColorWindow();\r
+ return -1;\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+//----------------------------------------------------------------------------\r
+double vvSlicerManager::GetOverlayColorLevel() const\r
+{\r
+ if (mSlicers.size())\r
+ return mSlicers[0]->GetOverlayColorLevel();\r
+ return -1;\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+//----------------------------------------------------------------------------\r
+bool vvSlicerManager::GetLinkOverlayWindowLevel() const\r
+{\r
+ if (mSlicers.size())\r
+ return mSlicers[0]->GetLinkOverlayWindowLevel();\r
+ return -1;\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+//------------------------------------------------------------------------------\r
+void vvSlicerManager::ResetTransformationToIdentity(const std::string actorType)\r
+{\r
+ if(actorType == "image")\r
+ for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)\r
+ this->GetImage()->GetTransform()[i]->Identity();\r
+ else if(actorType == "overlay")\r
+ for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)\r
+ this->GetSlicer(0)->GetOverlay()->GetTransform()[i]->Identity();\r
+ else if(actorType == "fusion")\r
+ for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)\r
+ this->GetSlicer(0)->GetFusion()->GetTransform()[i]->Identity();\r
+ else if(actorType == "fusionSequence") //TODO: Check what should really be done here\r
+ for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)\r
+ this->GetSlicer(0)->GetFusion()->GetTransform()[i]->Identity();\r
+ else if(actorType == "vf")\r
+ for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)\r
+ this->GetVF()->GetTransform()[i]->Identity();\r
+ else\r
+ return;\r
+\r
+ for(int i=0; i< this->GetNumberOfSlicers(); i++){\r
+ this->GetSlicer(i)->ForceUpdateDisplayExtent();\r
+ this->GetSlicer(i)->ResetCamera();\r
+ this->GetSlicer(i)->Render();\r
+ }\r
+}\r
+//------------------------------------------------------------------------------\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::Render()\r
+{\r
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
+ mSlicers[i]->Render();\r
+ }\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::GenerateDefaultLookupTable()\r
+{\r
+ SetPreset(mPreset);\r
+ SetColorMap(mColorMap);\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::Reload()\r
+{\r
+ mReader->Update(mType);\r
+ mImage=mReader->GetOutput();\r
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
+ mSlicers[i]->SetImage(mImage);\r
+ }\r
+ \r
+ //if this image is the primary sequence of a fusion sequence, then the main transform matrix should be updated.\r
+ if (this->IsMainSequenceOfFusionSequence()) {\r
+ SetFusionSequenceMainTransformMatrix( mImage->GetTransform()[0]->GetMatrix() );\r
+ }\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::ReloadFusion()\r
+{\r
+ mFusionReader->Update(mImage->GetNumberOfDimensions(),mFusionComponent.c_str(),mType);\r
+\r
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
+ mSlicers[i]->SetFusion(mFusionReader->GetOutput());\r
+ mSlicers[i]->Render();\r
+ }\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+//----------------------------------------------------------------------------\r
+//the secondary sequence is being reloaded.\r
+void vvSlicerManager::ReloadFusionSequence()\r
+{\r
+ mFusionSequenceReader->Update(mImage->GetNumberOfDimensions(),mFusionComponent.c_str(),vvImageReader::MERGEDWITHTIME);\r
+\r
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
+ mSlicers[i]->SetFusion(mFusionSequenceReader->GetOutput(), 1);\r
+ mSlicers[i]->Render();\r
+ }\r
+\r
+ //Update the slider\r
+ mFusionSequenceNbFrames = mFusionSequenceReader->GetOutput()->GetTransform().size();\r
+ if (mFusionSequenceFrameIndex>=mFusionSequenceNbFrames) {\r
+ mFusionSequenceFrameIndex=0;\r
+ }\r
+\r
+ //Update the list of initial transforms\r
+ mFusionSequenceListInitialTransformMatrices.clear();\r
+ for (unsigned i=0 ; i<mFusionSequenceNbFrames ; i++) {\r
+ this->AddFusionSequenceInitialTransformMatrices( mFusionSequenceReader->GetOutput()->GetTransform()[i]->GetMatrix() );\r
+ }\r
+\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::ReloadOverlay()\r
+{\r
+ mOverlayReader->Update(mImage->GetNumberOfDimensions(),mOverlayComponent.c_str(),mType);\r
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
+ mSlicers[i]->SetOverlay(mOverlayReader->GetOutput());\r
+ mSlicers[i]->Render();\r
+ }\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::ReloadVF()\r
+{\r
+ mVectorReader->Update(vvImageReader::VECTORFIELD); //deletes the old images through the VF::Init() function\r
+ mVF=mVectorReader->GetOutput();\r
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
+ mSlicers[i]->SetVF(mVF);\r
+ mSlicers[i]->Render();\r
+ }\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::RemoveActor(const std::string& actor_type, int overlay_index)\r
+{\r
+ if (actor_type =="overlay")\r
+ mOverlayReader = NULL;\r
+\r
+ if (actor_type =="fusion")\r
+ mFusionReader = NULL;\r
+\r
+ if (actor_type =="fusionSequence") {\r
+ mFusionSequenceReader = NULL;\r
+ }\r
+\r
+ for (unsigned int i = 0; i < mSlicers.size(); i++)\r
+ mSlicers[i]->RemoveActor(actor_type,overlay_index);\r
+\r
+ if (actor_type=="vector") {\r
+ mVF=NULL;\r
+ mVectorReader=NULL;\r
+ }\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::RemoveActors()\r
+{\r
+ ///This method leaks a few objects. See RemoveActor for what a\r
+ ///correct implementation would look like\r
+ //DS -> probably due to the reader (now released in the\r
+ //RemoveActor() function. (I hope)\r
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
+ mSlicers[i]->SetDisplayMode(0);\r
+ mSlicers[i]->GetRenderer()->RemoveActor(mSlicers[i]->GetImageActor());\r
+ }\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::UpdateInfoOnCursorPosition(int slicer)\r
+{\r
+ // int view = mSlicers[slicer]->GetSliceOrientation();\r
+ // int slice = mSlicers[slicer]->GetSlice();\r
+ double x = mSlicers[slicer]->GetCursorPosition()[0];\r
+ double y = mSlicers[slicer]->GetCursorPosition()[1];\r
+ double z = mSlicers[slicer]->GetCursorPosition()[2];\r
+ double X = (x - mSlicers[slicer]->GetInput()->GetOrigin()[0])/\r
+ mSlicers[slicer]->GetInput()->GetSpacing()[0];\r
+ double Y = (y - mSlicers[slicer]->GetInput()->GetOrigin()[1])/\r
+ mSlicers[slicer]->GetInput()->GetSpacing()[1];\r
+ double Z = (z - mSlicers[slicer]->GetInput()->GetOrigin()[2])/\r
+ mSlicers[slicer]->GetInput()->GetSpacing()[2];\r
+ double value = -VTK_DOUBLE_MAX;\r
+ int displayVec = 0;\r
+ double xVec=0, yVec=0, zVec=0, valueVec=0;\r
+ int displayOver = 0;\r
+ int displayFus = 0;\r
+ double valueOver=0, valueFus=0;\r
+ if (X >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] &&\r
+ X <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] &&\r
+ Y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&\r
+ Y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&\r
+ Z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&\r
+ Z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]) {\r
+\r
+ value = this->GetScalarComponentAsDouble(mSlicers[slicer]->GetInput(), X, Y, Z);\r
+\r
+ if (mSlicers[slicer]->GetVFActor() ) {\r
+ displayVec = 1;\r
+ unsigned int currentTime = mSlicers[slicer]->GetMaxCurrentTSlice();\r
+ vtkImageData *vf = NULL;\r
+\r
+ if (mSlicers[slicer]->GetVF()->GetVTKImages().size() > currentTime)\r
+ vf = mSlicers[slicer]->GetVF()->GetVTKImages()[currentTime];\r
+ else\r
+ vf = mSlicers[slicer]->GetVF()->GetVTKImages()[0];\r
+\r
+ if (vf) {\r
+ double Xvf = (x - vf->GetOrigin()[0])/ vf->GetSpacing()[0];\r
+ double Yvf = (y - vf->GetOrigin()[1])/ vf->GetSpacing()[1];\r
+ double Zvf = (z - vf->GetOrigin()[2])/ vf->GetSpacing()[2];\r
+ xVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 0);\r
+ yVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 1);\r
+ zVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 2);\r
+ valueVec = sqrt(xVec*xVec + yVec*yVec + zVec*zVec);\r
+ }\r
+ }\r
+ if (mSlicers[slicer]->GetOverlayActor() ) {\r
+ displayOver = 1;\r
+ vtkImageData *overlay = dynamic_cast<vtkImageData*>(mSlicers[slicer]->GetOverlayMapper()->GetInput());\r
+ double Xover = (x - overlay->GetOrigin()[0]) / overlay->GetSpacing()[0];\r
+ double Yover = (y - overlay->GetOrigin()[1]) / overlay->GetSpacing()[1];\r
+ double Zover = (z - overlay->GetOrigin()[2]) / overlay->GetSpacing()[2];\r
+ valueOver = this->GetScalarComponentAsDouble(overlay, Xover, Yover, Zover);\r
+ }\r
+\r
+ if ( mSlicers[slicer]->GetFusionActor() ) {\r
+ displayFus = 1;\r
+ vtkImageData *fusion = dynamic_cast<vtkImageData*>(mSlicers[slicer]->GetFusionMapper()->GetInput());\r
+ double Xover = (x - fusion->GetOrigin()[0]) / fusion->GetSpacing()[0];\r
+ double Yover = (y - fusion->GetOrigin()[1]) / fusion->GetSpacing()[1];\r
+ double Zover = (z - fusion->GetOrigin()[2]) / fusion->GetSpacing()[2];\r
+ valueFus = this->GetScalarComponentAsDouble(fusion, Xover, Yover, Zover);\r
+ }\r
+ else if (this->IsInvolvedInFusionSequence()) { \r
+ //if the cursor moves over the 'independent' version of the secondary sequence\r
+ //do not update the panel, just keep it as it is.\r
+ displayFus = 1;\r
+ valueFus = std::numeric_limits<double>::quiet_NaN();\r
+ }\r
+\r
+ emit UpdatePosition(mSlicers[slicer]->GetCursorVisibility(),\r
+ x,y,z,X,Y,Z,value);\r
+ emit UpdateVector(displayVec,xVec, yVec, zVec, valueVec);\r
+ emit UpdateOverlay(displayOver,valueOver,value);\r
+ emit UpdateFusion(displayFus,valueFus);\r
+ }\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::Activated()\r
+{\r
+ emit currentImageChanged(mId);\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::Picked()\r
+{\r
+ emit currentPickedImageChanged(mId);\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::UpdateWindowLevel()\r
+{\r
+ emit WindowLevelChanged();\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::UpdateSlice(int slicer)\r
+{\r
+ if (mPreviousSlice[slicer] == mSlicers[slicer]->GetSlice()) {\r
+ //DD("============= NOTHING");\r
+ return;\r
+ }\r
+ //std::cout << "vvSlicerManager::UpdateSlice " << slicer << " " << mSlicers[slicer]->GetSlice() << std::endl;\r
+ emit UpdateSlice(slicer, mSlicers[slicer]->GetSlice());\r
+ mSlicers[slicer]->Render(); // DS <-- I add this, this could/must be the only Render ...\r
+ mPreviousSlice[slicer] = mSlicers[slicer]->GetSlice();\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::UpdateTSlice(int slicer)\r
+{\r
+ int slice = mSlicers[slicer]->GetSlice();\r
+\r
+ int tslice = mSlicers[slicer]->GetMaxCurrentTSlice();\r
+ //if (this->IsInvolvedInFusionSequence()) tslice = mSlicers[slicer]->GetTSlice(); //actually, this is handled by the Slicer\r
+\r
+ if (mPreviousSlice[slicer] == slice) {\r
+ if (mPreviousTSlice[slicer] == tslice) {\r
+ // DD("************** NOTHING ***********");\r
+ return;\r
+ }\r
+ }\r
+ mPreviousSlice[slicer] = slice;\r
+ mPreviousTSlice[slicer] = tslice;\r
+\r
+ emit UpdateTSlice(slicer, tslice, mFusionSequenceInvolvementCode);\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::UpdateSliceRange(int slicer)\r
+{\r
+ emit UpdateSliceRange(slicer,\r
+ mSlicers[slicer]->GetSliceRange()[0], mSlicers[slicer]->GetSliceRange()[1],\r
+ 0,mSlicers[slicer]->GetTMax());\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::SetSlicingPreset(SlicingPresetType preset)\r
+{\r
+ if(mSlicingPreset==preset)\r
+ return;\r
+\r
+ vtkMatrix4x4 *imageTransformInverse = vtkMatrix4x4::New();\r
+ mImage->GetTransform()[this->GetTSlice()]->GetInverse(imageTransformInverse);\r
+\r
+ for(int i=0; i< this->GetNumberOfSlicers(); i++){\r
+ vvSlicer *s = this->GetSlicer(i);\r
+ switch(preset)\r
+ {\r
+ case WORLD_SLICING:\r
+ s->GetSlicingTransform()->Identity();\r
+ break;\r
+ case VOXELS_SLICING:\r
+ s->GetSlicingTransform()->SetMatrix(imageTransformInverse);\r
+ break;\r
+ default:\r
+ imageTransformInverse->Delete();\r
+ return;\r
+ }\r
+ s->ForceUpdateDisplayExtent();\r
+ s->SetSlice((s->GetInput()->GetWholeExtent()[s->GetSliceOrientation()*2+1]\r
+ +s->GetInput()->GetWholeExtent()[s->GetSliceOrientation()*2])/2.0);\r
+ s->ResetCamera();\r
+ s->Render();\r
+ }\r
+\r
+ imageTransformInverse->Delete();\r
+ mSlicingPreset = preset;\r
+}\r
+\r
+//----------------------------------------------------------------------------\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::SetPreset(int preset)\r
+{\r
+\r
+ //vtkLookupTable* LUT = static_cast<vtkLookupTable*>(mSlicers[0]->GetWindowLevel()->GetLookupTable());\r
+ double window = mSlicers[0]->GetColorWindow();\r
+ double level = mSlicers[0]->GetColorLevel();\r
+\r
+ std::string component_type=mImage->GetScalarTypeAsITKString();\r
+ switch (preset) {\r
+ case WL_AUTO:\r
+ double range[2];\r
+ mImage->GetScalarRange(range);\r
+ window = range[1] - range[0];\r
+ level = (range[1] + range[0])* 0.5;\r
+ break;\r
+ case WL_HOUNSFIELD:\r
+ window = 2000;\r
+ level = 0;\r
+ break;\r
+ case WL_SOFTTISSUE:\r
+ window = 400;\r
+ level = 20;\r
+ break;\r
+ case WL_LUNGS: // lungs (same as FOCAL)\r
+ window = 1700;\r
+ level = -300;\r
+ break;\r
+ case WL_BONES:\r
+ window = 1000;\r
+ level = 500;\r
+ break;\r
+ case WL_HEAD:\r
+ window = 200;\r
+ level = 70;\r
+ break;\r
+ case WL_BINARY:\r
+ window = 1;\r
+ level = 0.5;\r
+ break;\r
+ case WL_USER:\r
+ break;\r
+ case WL_VENTILATION:\r
+ window=1.;\r
+ level=0.;\r
+ break;\r
+ }\r
+ mPreset = preset;\r
+ this->SetColorWindow(window);\r
+ this->SetColorLevel(level);\r
+\r
+ //if (LUT)\r
+ //{\r
+ // SetColorMap(-1);\r
+ //}\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::SetLocalColorWindowing(const int slicer, const bool bCtrlKey)\r
+{\r
+ double min, max;\r
+ if(bCtrlKey && this->mSlicers[slicer]->GetFusion()) {\r
+ int t = mSlicers[slicer]->GetFusionTSlice();\r
+ this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max,\r
+ this->mSlicers[slicer]->GetFusion()->GetVTKImages()[t],\r
+ this->mSlicers[slicer]->GetConcatenatedFusionTransform());\r
+ this->SetFusionWindow(max-min);\r
+ this->SetFusionLevel(0.5*(min+max));\r
+ this->SetColorMap(mColorMap);\r
+ }\r
+ else if(bCtrlKey && this->mSlicers[slicer]->GetOverlay()) {\r
+ int t = mSlicers[slicer]->GetOverlayTSlice();\r
+ this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max,\r
+ this->mSlicers[slicer]->GetOverlay()->GetVTKImages()[t],\r
+ this->mSlicers[slicer]->GetConcatenatedOverlayTransform());\r
+ if(this->mSlicers[slicer]->GetLinkOverlayWindowLevel()){\r
+ this->SetColorWindow(max-min);\r
+ this->SetColorLevel(0.5*(min+max));\r
+ } else {\r
+ this->SetOverlayColorWindow(max-min);\r
+ this->SetOverlayColorLevel(0.5*(min+max));\r
+ }\r
+ }\r
+ else {\r
+ int t = this->GetTSlice();\r
+ this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max,\r
+ this->mSlicers[slicer]->GetImage()->GetVTKImages()[t],\r
+ this->mSlicers[slicer]->GetConcatenatedTransform());\r
+ this->SetColorWindow(max-min);\r
+ this->SetColorLevel(0.5*(min+max));\r
+ this->SetPreset(WL_USER);\r
+ }\r
+ this->Render();\r
+ this->UpdateWindowLevel();\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::SetColorMap(int colormap)\r
+{\r
+ double range[2];\r
+\r
+ range[0] = mSlicers[0]->GetInput()->GetScalarRange()[0];\r
+ range[1] = mSlicers[0]->GetInput()->GetScalarRange()[1];\r
+\r
+ double window = mSlicers[0]->GetWindowLevel()->GetWindow();\r
+ double level = mSlicers[0]->GetWindowLevel()->GetLevel();\r
+\r
+ vtkLookupTable* LUT = static_cast<vtkLookupTable*>(mSlicers[0]->GetWindowLevel()->GetLookupTable());\r
+ switch (colormap) {\r
+ case -1:\r
+ break;\r
+ case 0:\r
+ LUT = NULL;\r
+ break;\r
+ case 1:\r
+ if (LUT == NULL)\r
+ LUT = vtkLookupTable::New();\r
+ LUT->SetValueRange(0,1);\r
+ LUT->SetSaturationRange(1,1);\r
+ LUT->SetHueRange(0,0.18);\r
+ break;\r
+ case 2:\r
+ if (LUT == NULL)\r
+ LUT = vtkLookupTable::New();\r
+ LUT->SetValueRange(0,1);\r
+ LUT->SetSaturationRange(1,1);\r
+ LUT->SetHueRange(0.4,0.80);\r
+ break;\r
+ case 3:\r
+ if (LUT == NULL)\r
+ LUT = vtkLookupTable::New();\r
+ LUT->SetValueRange(0.5,1);\r
+ LUT->SetSaturationRange(1,1);\r
+ LUT->SetHueRange(0.666,0);\r
+ break;\r
+ case 4:\r
+ if (LUT == NULL)\r
+ LUT = vtkLookupTable::New();\r
+ LUT->SetValueRange(1,1);\r
+ LUT->SetSaturationRange(1,1);\r
+ LUT->SetHueRange(0,1);\r
+ LUT->SetAlphaRange(1, 1);\r
+ break;\r
+ case 5:\r
+ if (LUT == NULL)\r
+ LUT = vtkLookupTable::New();\r
+ LUT->SetValueRange(1,1);\r
+ LUT->SetSaturationRange(1,1);\r
+ LUT->SetHueRange(1,0.1);\r
+ //LUT->SetRampToLinear();\r
+ break;\r
+ }\r
+ if (LUT) {\r
+ LUT->SetTableRange(level-fabs(window)/2,level+fabs(window)/2);\r
+ LUT->Build();\r
+ }\r
+ vtkWindowLevelLookupTable* fusLUT = NULL;\r
+\r
+ //FUSION / FUSION SEQUENCE\r
+ if (mSlicers[0]->GetFusion()) { // && mFusionColorMap >= 0) {\r
+ fusLUT = vtkWindowLevelLookupTable::New();\r
+ double fusRange [2];\r
+ fusRange[0] = mFusionLevel - mFusionWindow/2;\r
+ fusRange[1] = mFusionLevel + mFusionWindow/2;\r
+\r
+ //check whether it is actually a fusionSequence or a fusion, before invoking mFusionReader...\r
+ double* frange;\r
+ if (this->IsInvolvedInFusionSequence()) \r
+ frange = mFusionSequenceReader->GetOutput()->GetVTKImages()[0]->GetScalarRange();\r
+ else\r
+ frange = mFusionReader->GetOutput()->GetVTKImages()[0]->GetScalarRange();\r
+\r
+ fusLUT->SetTableRange(frange);\r
+ fusLUT->SetValueRange(1,1);\r
+ fusLUT->SetSaturationRange(1,1);\r
+ fusLUT->SetAlphaRange(1, 1);\r
+ fusLUT->SetWindow(mFusionWindow);\r
+ fusLUT->SetLevel(mFusionLevel);\r
+ if (mFusionColorMap == 1)\r
+ fusLUT->SetHueRange(0,0.18);\r
+ else if (mFusionColorMap == 2)\r
+ fusLUT->SetHueRange(0.4,0.80);\r
+ else if (mFusionColorMap == 3)\r
+ {\r
+ fusLUT->SetHueRange(0.666, 0);\r
+ fusLUT->SetValueRange(0.5, 1);\r
+ }\r
+ else if (mFusionColorMap == 4)\r
+ fusLUT->SetHueRange(0,1);\r
+ else if (mFusionColorMap <= 0)\r
+ {\r
+ fusLUT->SetValueRange(0,1);\r
+ fusLUT->SetSaturationRange(0,0);\r
+ }\r
+\r
+ fusLUT->ForceBuild();\r
+ double v[4];\r
+\r
+ // set color table transparency\r
+ //double alpha_range=(double)mFusionThresOpacity/10;\r
+ double range_end = fusRange[0] + (double)mFusionThresOpacity*(fusRange[1] - fusRange[0])/100;\r
+ double curr_value = fusRange[0];\r
+ int nvalues = fusLUT->GetNumberOfTableValues();\r
+ for (double i = 0; curr_value < range_end; i++) { \r
+ fusLUT->GetTableValue(i, v);\r
+ v[3] = 0;\r
+ //if (curr_value >= -alpha_range && curr_value <= alpha_range) v[3] = pow(fabs(curr_value/alpha_range),2);\r
+ //else v[3] = 1;\r
+ fusLUT->SetTableValue(i, v);\r
+ curr_value += (fusRange[1] - fusRange[0])/nvalues;\r
+ }\r
+ }\r
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
+\r
+ if (mSlicers[i]->GetOverlay()) {\r
+ vtkLookupTable* supLUT = vtkLookupTable::New();\r
+ supLUT->SetTableRange(range[0],range[1]);\r
+ supLUT->SetValueRange(1,1);\r
+ supLUT->SetSaturationRange(1,1);\r
+ supLUT->SetHueRange(double(mOverlayColor)/360,double(mOverlayColor)/360);\r
+ supLUT->Build();\r
+ vtkLookupTable* invLUT = vtkLookupTable::New();\r
+ invLUT->SetTableRange(range[0],range[1]);\r
+ invLUT->SetValueRange(1,1);\r
+ invLUT->SetSaturationRange(1,1);\r
+ invLUT->SetHueRange(double((mOverlayColor+180)%360)/360,double((mOverlayColor+180)%360)/360);\r
+ invLUT->Build();\r
+ mSlicers[i]->GetWindowLevel()->SetLookupTable(supLUT);\r
+ mSlicers[i]->GetOverlayMapper()->SetLookupTable(invLUT);\r
+ invLUT->Delete();\r
+ supLUT->Delete();\r
+ } else if (mSlicers[i]->GetOverlay()) {\r
+ mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT);\r
+ } else {\r
+ mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT);\r
+ }\r
+\r
+ if (mSlicers[i]->GetFusion()) {\r
+ mSlicers[i]->ShowFusionLegend(mFusionShowLegend);\r
+ mSlicers[i]->GetFusionMapper()->SetLookupTable(fusLUT);\r
+ mSlicers[i]->GetFusionActor()->SetOpacity(double(mFusionOpacity)/100);\r
+ }\r
+ }\r
+ if (fusLUT)\r
+ fusLUT->Delete();\r
+ if (colormap >= 0)\r
+ mColorMap = colormap;\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+vvLandmarks* vvSlicerManager::GetLandmarks()\r
+{\r
+ if (mLandmarks == NULL) {\r
+ mLandmarks = new vvLandmarks(mSlicers[0]->GetTMax()+1);\r
+ for (unsigned int i = 0; i < mSlicers.size(); i++)\r
+ mSlicers[i]->SetLandmarks(mLandmarks);\r
+ }\r
+ return mLandmarks;\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::AddLandmark(float x,float y,float z,float t)\r
+{\r
+ double x_index = (x - mSlicers[0]->GetInput()->GetOrigin()[0])/mSlicers[0]->GetInput()->GetSpacing()[0];\r
+ double y_index = (y - mSlicers[0]->GetInput()->GetOrigin()[1])/mSlicers[0]->GetInput()->GetSpacing()[1];\r
+ double z_index = (z - mSlicers[0]->GetInput()->GetOrigin()[2])/mSlicers[0]->GetInput()->GetSpacing()[2];\r
+ if (x_index >= mSlicers[0]->GetInput()->GetWholeExtent()[0]-0.5 &&\r
+ x_index <= mSlicers[0]->GetInput()->GetWholeExtent()[1]+0.5 &&\r
+ y_index >= mSlicers[0]->GetInput()->GetWholeExtent()[2]-0.5 &&\r
+ y_index <= mSlicers[0]->GetInput()->GetWholeExtent()[3]+0.5 &&\r
+ z_index >= mSlicers[0]->GetInput()->GetWholeExtent()[4]-0.5 &&\r
+ z_index <= mSlicers[0]->GetInput()->GetWholeExtent()[5]+0.5) {\r
+ double value = this->GetScalarComponentAsDouble(mSlicers[0]->GetInput(), x_index, y_index, z_index);\r
+ this->GetLandmarks()->AddLandmark(x,y,z,t,value);\r
+ emit LandmarkAdded();\r
+ }\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::PrevImage(int slicer)\r
+{\r
+ emit ChangeImageWithIndexOffset(this, slicer, -1);\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::NextImage(int slicer)\r
+{\r
+ emit ChangeImageWithIndexOffset(this, slicer, 1);\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::VerticalSliderHasChanged(int slicer, int slice)\r
+{\r
+ emit AVerticalSliderHasChanged(slicer, slice);\r
+}\r
+\r
+//----------------------------------------------------------------------------\r
+\r
+//----------------------------------------------------------------------------\r
+double vvSlicerManager::GetScalarComponentAsDouble(vtkImageData *image, double X, double Y, double Z, int component)\r
+{\r
+ int ix, iy, iz;\r
+ return mSlicers[0]->GetScalarComponentAsDouble(image, X, Y, Z, ix, iy, iz, component);\r
+}\r
+//----------------------------------------------------------------------------\r
class vvImageReader;
class vvLandmarks;
+enum WindowLevelPreset {
+ WL_AUTO,
+ WL_HOUNSFIELD,
+ WL_SOFTTISSUE,
+ WL_LUNGS,
+ WL_BONES,
+ WL_HEAD,
+ WL_BINARY,
+ WL_USER,
+ WL_VENTILATION
+};
+
//------------------------------------------------------------------------------
class vvSlicerManager : public QObject {
Q_OBJECT
bool SetOverlay(std::vector<std::string> filenames, int dim, std::string component, vvImageReader::LoadedImageType type);
bool SetFusion(std::string filename, int dim, std::string component);
+ bool SetFusionSequence(std::vector<std::string> filenames, int dim, std::string component, vvImageReader::LoadedImageType type);
///Set a VF by loading it from the disk
bool SetVF(std::string filename);
///Set a VF from memory
void SetSliceOrientation(int slicer, int orientation);
int GetTSlice();
- void SetTSlice(int slice);
+ void SetTSlice(int slice, bool updateLinkedImages = true);
void SetNextTSlice(int originating_slicer);
void SetPreviousTSlice(int originating_slicer);
void SetTSliceInSlicer(int tslice, int slicer);
+ void SetFusionSequenceTSlice(int slice);
+
void GenerateDefaultLookupTable();
void SetColorWindow(double s);
void SetColorLevel(double s);
mFusionShowLegend = show;
}
+
+ //set/get fusionSequence related data
+ void SetFusionSequenceFrameIndex(int sequenceFrameIndex) { mFusionSequenceFrameIndex = sequenceFrameIndex; }
+ void SetFusionSequenceSpatialSyncFlag(bool spatialSync) { mFusionSequenceSpatialSyncFlag = spatialSync; }
+ void SetFusionSequenceTemporalSyncFlag(bool temporalSync) { mFusionSequenceTemporalSyncFlag = temporalSync; }
+ void SetFusionSequenceLength(unsigned int fusionSequenceNbFrames) { mFusionSequenceNbFrames = fusionSequenceNbFrames; }
+ void SetFusionSequenceMainTransformMatrix(vtkSmartPointer<vtkMatrix4x4> mat) {
+ mFusionSequenceMainTransform = vtkSmartPointer<vtkMatrix4x4>::New();
+ mFusionSequenceMainTransform->DeepCopy(mat);
+ }
+ void AddFusionSequenceInitialTransformMatrices(vtkSmartPointer<vtkMatrix4x4> mat) {
+ vtkSmartPointer<vtkMatrix4x4> tmpMat = vtkSmartPointer<vtkMatrix4x4>::New();
+ tmpMat->DeepCopy(mat);
+ mFusionSequenceListInitialTransformMatrices.push_back( tmpMat );
+ }
+ void SetFusionSequenceIndexOfLinkedManager(int index) { mFusionSequenceIndexLinkedManager = index; }
+ void SetFusionSequenceTemporalSignal(std::vector<double> s) { mFusionSequenceTemporalSignal = s; }
+
+ void SetFusionSequenceInvolvmentCode(int code) { mFusionSequenceInvolvementCode=code; }
+ int GetFusionSequenceInvolvmentCode() { return mFusionSequenceInvolvementCode;}
+ bool IsInvolvedInFusionSequence() {return (!(mFusionSequenceInvolvementCode==-1));}
+ bool IsMainSequenceOfFusionSequence() {return (mFusionSequenceInvolvementCode==0);}
+ bool IsSecondarySequenceOfFusionSequence() {return (mFusionSequenceInvolvementCode==1);}
+
+ int GetFusionSequenceIndexOfLinkedManager() { return mFusionSequenceIndexLinkedManager; }
+ int GetFusionSequenceFrameIndex() { return mFusionSequenceFrameIndex; }
+ bool GetFusionSequenceSpatialSyncFlag() { return mFusionSequenceSpatialSyncFlag; }
+ bool GetFusionSequenceTemporalSyncFlag() { return mFusionSequenceTemporalSyncFlag; }
+ unsigned int GetFusionSequenceNbFrames() { return mFusionSequenceNbFrames; }
+ const vtkSmartPointer<vtkMatrix4x4>& GetFusionSequenceMainTransformMatrix() {return mFusionSequenceMainTransform;}
+ const std::vector< vtkSmartPointer<vtkMatrix4x4> >& GetFusionSequenceInitialTransformMatrices() {return mFusionSequenceListInitialTransformMatrices;}
+ const vtkSmartPointer<vtkMatrix4x4>& GetFusionSequenceInitialTransformMatrixAtFrame(unsigned i) {
+ return mFusionSequenceListInitialTransformMatrices[i];
+ }
+ const std::vector<double>& GetFusionSequenceTemporalSignal() {return mFusionSequenceTemporalSignal;}
+
double GetColorWindow() const;
double GetColorLevel() const;
double GetOverlayColorWindow() const;
return mFusionLevel;
}
+
void SetCursorAndCornerAnnotationVisibility(int s);
void UpdateViews(int current, int slicer);
void UpdateLinked(int slicer);
void Reload();
void ReloadOverlay();
void ReloadFusion();
+ void ReloadFusionSequence();
void ReloadVF();
void Activated();
void UpdateVector(int display, double x, double y, double z, double value);
void UpdateOverlay(int display, double valueOver, double valueRef);
void UpdateFusion(int display, double valueFus);
+ void UpdateFusionSequence(int fusionSequenceFrameIndex, bool fusionSequenceSpatialSyncFlag, unsigned int fusionSequenceNbFrames);
void MousePositionUpdatedSignal(int slicer);
void KeyPressedSignal(std::string KeyPressed);
void UpdateOrientation(int slicer, int orientation);
void UpdateSlice(int slicer, int slice);
- void UpdateTSlice(int slicer, int slice);
+ void UpdateTSlice(int slicer, int slice, int code);
void UpdateSliceRange(int slice, int min, int max, int tmin, int tmax);
void WindowLevelChanged();
void UpdateLinkManager(std::string, int slicer, double x, double y, double z, int temps);
vvImageReader::Pointer mReader;
vvImageReader::Pointer mOverlayReader;
vvImageReader::Pointer mFusionReader;
+ vvImageReader::Pointer mFusionSequenceReader;
vvImageReader::Pointer mVectorReader;
vvImage::Pointer mImage;
vvImage::Pointer mVF;
double mFusionLevel;
bool mFusionShowLegend;
+ //Fusion of sequences related data
+ int mFusionSequenceInvolvementCode; //-1: not involved, 0: main sequence(CT), 1: secondary sequence (US)
+ int mFusionSequenceIndexLinkedManager; //index of the other sequence involved in the visualization
+ int mFusionSequenceFrameIndex; //temporal index of the current image in the sequence (<->TSlice)
+ unsigned int mFusionSequenceNbFrames; //number of frames in the temporal sequence
+ bool mFusionSequenceSpatialSyncFlag, mFusionSequenceTemporalSyncFlag; //flags indicating whether the spatial/temporal synchronization are actives
+ vtkSmartPointer<vtkMatrix4x4> mFusionSequenceMainTransform;
+ std::vector< vtkSmartPointer<vtkMatrix4x4> > mFusionSequenceListInitialTransformMatrices;
+ std::vector<double> mFusionSequenceTemporalSignal;
+
int mPreset;
SlicingPresetType mSlicingPreset;
vvImageReader::LoadedImageType mType;
return;
}
if (KeyPress == "0") {
- this->SM->SetPreset(0);
+ this->SM->SetPreset(WL_AUTO);
this->SM->UpdateWindowLevel();
return;
}
if (KeyPress == "1") {
- this->SM->SetPreset(1);
+ this->SM->SetPreset(WL_HOUNSFIELD);
this->SM->UpdateWindowLevel();
return;
}
if (KeyPress == "2") {
- this->SM->SetPreset(2);
+ this->SM->SetPreset(WL_SOFTTISSUE);
this->SM->UpdateWindowLevel();
return;
}
if (KeyPress == "3") {
- this->SM->SetPreset(3);
+ this->SM->SetPreset(WL_LUNGS);
this->SM->UpdateWindowLevel();
return;
}
if (KeyPress == "4") {
- this->SM->SetPreset(4);
+ this->SM->SetPreset(WL_BONES);
this->SM->UpdateWindowLevel();
return;
}
if (KeyPress == "5") {
- this->SM->SetPreset(5);
+ this->SM->SetPreset(WL_HEAD);
this->SM->UpdateWindowLevel();
return;
}
return;
}
if (KeyPress == "equal") { //keycodes are in vtkWin32RenderWindowInteractor
- this->SM->SetPreset(7);
+ this->SM->SetPreset(WL_VENTILATION);
//this->SM->SetColorMap(1);
this->SM->UpdateWindowLevel();
return;
this->SM->SetColorWindow(window*dx);
this->SM->SetColorLevel(level-dy);
- this->SM->SetPreset(6);
+ this->SM->SetPreset(WL_USER);
this->SM->Render();
this->SM->UpdateWindowLevel();
return;
#ifndef VVTOOLBASEBASE_H
#define VVTOOLBASEBASE_H
+#include <algorithm>
#include "vvMainWindowBase.h"
#include "vvToolCreatorBase.h"
class QXmlStreamWriter;
git://git.creatis.insa-lyon.fr / clitk.git / commitdiff