FIND_PROGRAM(GENGETOPT gengetopt)
IF (GENGETOPT STREQUAL "GENGETOPT-NOTFOUND")
GET_FILENAME_COMPONENT(CLITK_CMAKE_DIR ${CMAKE_CURRENT_LIST_FILE} PATH)
- ADD_SUBDIRECTORY(${CLITK_CMAKE_DIR}/gengetopt ${CMAKE_CURRENT_BINARY_DIR}/gengetopt)
+ ADD_SUBDIRECTORY(${CLITK_CMAKE_DIR}/../utilities/gengetopt ${CMAKE_CURRENT_BINARY_DIR}/gengetopt)
ELSE(GENGETOPT STREQUAL "GENGETOPT-NOTFOUND")
ADD_EXECUTABLE(gengetopt IMPORTED)
SET_PROPERTY(TARGET gengetopt PROPERTY IMPORTED_LOCATION ${GENGETOPT})
INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
ENDFOREACH(GGO_FILE)
SET_SOURCE_FILES_PROPERTIES(${${GGO_SRCS}} PROPERTIES GENERATED TRUE)
+ IF(CMAKE_COMPILER_IS_GNUCXX)
+ FIND_PROGRAM(DEFAULT_GCC gcc)
+ EXEC_PROGRAM(${DEFAULT_GCC} ARGS "-dumpversion" OUTPUT_VARIABLE GCCVER)
+ IF("${GCCVER}" VERSION_GREATER "4.5.2")
+ SET_SOURCE_FILES_PROPERTIES(${${GGO_SRCS}} PROPERTIES COMPILE_FLAGS "-Wno-unused-but-set-variable")
+ ENDIF("${GCCVER}" VERSION_GREATER "4.5.2")
+ ENDIF(CMAKE_COMPILER_IS_GNUCXX)
ENDMACRO (WRAP_GGO)
f->SetUpper(GetUpperThresholdForTrachea());
f->SetMinimumLowerThreshold(-2000);
// f->SetMaximumUpperThreshold(0); // MAYBE TO CHANGE ???
- f->SetMaximumUpperThreshold(-700); // MAYBE TO CHANGE ???
+ f->SetMaximumUpperThreshold(-300); // MAYBE TO CHANGE ???
f->SetAdaptLowerBorder(false);
f->SetAdaptUpperBorder(true);
f->SetMinimumSize(5000);
--- /dev/null
+cmake_minimum_required(VERSION 2.8)
+cmake_policy(VERSION 2.8)
+
+# set a default build type if it is undefined, then make sure it goes in the cache
+if(NOT CMAKE_BUILD_TYPE)
+ set(CMAKE_BUILD_TYPE Release)
+endif()
+set(CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE} CACHE STRING "Build configuration type" FORCE)
+set(build_type ${CMAKE_BUILD_TYPE})
+
+#=========================================================
+MACRO (DD in)
+ MESSAGE(${in}=${${in}})
+ENDMACRO(DD)
+#=========================================================
+
+project(SuperBuild_VV)
+
+if(MSVC)
+ set(CMAKE_C_FLAGS_DEBUG "/D_DEBUG /MTd /Zi /Ob0 /Od /RTC1" CACHE STRING "" FORCE)
+ set(CMAKE_C_FLAGS_MINSIZEREL "/MT /O1 /Ob1 /D NDEBUG" CACHE STRING "" FORCE)
+ set(CMAKE_C_FLAGS_RELEASE "/MT /O2 /Ob2 /D NDEBUG" CACHE STRING "" FORCE)
+ set(CMAKE_C_FLAGS_RELWITHDEBINFO "/MT /Zi /O2 /Ob1 /D NDEBUG" CACHE STRING "" FORCE)
+
+ set(CMAKE_CXX_FLAGS_DEBUG "/D_DEBUG /MTd /Zi /Ob0 /Od /RTC1" CACHE STRING "" FORCE)
+ set(CMAKE_CXX_FLAGS_MINSIZEREL "/MT /O1 /Ob1 /D NDEBUG" CACHE STRING "" FORCE)
+ set(CMAKE_CXX_FLAGS_RELEASE "/MT /O2 /Ob2 /D NDEBUG" CACHE STRING "" FORCE)
+ set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "/MT /Zi /O2 /Ob1 /D NDEBUG" CACHE STRING "" FORCE)
+endif(MSVC)
+
+include(ExternalProject)
+
+set(base "${CMAKE_BINARY_DIR}")
+set_property(DIRECTORY PROPERTY EP_BASE ${base})
+set(source_prefix ${base}/Source)
+set(build_prefix ${base}/Build)
+set(install_prefix ${base}/Install)
+
+find_package(Git REQUIRED)
+
+#=========================================================
+# QT
+SET(QtWinSpecFiles "${source_prefix}/qt/mkspecs/win32-msvc2003/qmake.conf";
+ "${source_prefix}/qt/mkspecs/win32-msvc2005/qmake.conf";
+ "${source_prefix}/qt/mkspecs/win32-msvc2008/qmake.conf";
+ "${source_prefix}/qt/mkspecs/win32-msvc2010/qmake.conf")
+ExternalProject_Add(
+ QT
+ SOURCE_DIR ${source_prefix}/qt
+ GIT_REPOSITORY git://gitorious.org/qt/qt.git
+ GIT_TAG v4.8.3
+ PATCH_COMMAND sed -i "s/\\-MD/-MT/g" ${QtWinSpecFiles}
+ CONFIGURE_COMMAND ${source_prefix}/qt/configure -confirm-license
+ -static
+ -fast
+ -opensource
+ -release
+ -prefix ${build_prefix}/QT
+ -nomake examples
+ -nomake demos
+ -qt-libpng
+ -no-libtiff
+ -no-libjpeg
+ -no-libmng
+ INSTALL_COMMAND ""
+)
+SET(qmake_executable "${build_prefix}/QT/bin/qmake")
+#=========================================================
+
+#=========================================================
+# VTK
+SET(VTK_CMAKE_CXX_STANDARD_LIBRARIES "${CMAKE_CXX_STANDARD_LIBRARIES}")
+IF(MSVC)
+ SET(VTK_CMAKE_CXX_STANDARD_LIBRARIES "${VTK_CMAKE_CXX_STANDARD_LIBRARIES} Imm32.lib Winmm.lib Ws2_32.lib")
+ENDIF(MSVC)
+ExternalProject_Add(
+ VTK
+ DEPENDS QT
+ SOURCE_DIR ${source_prefix}/vtk
+ GIT_REPOSITORY git://vtk.org/VTK.git
+ GIT_TAG v5.10.0
+ INSTALL_COMMAND ""
+ CMAKE_ARGS
+ -DQT_QMAKE_EXECUTABLE:FILEPATH=${qmake_executable}
+ -DCMAKE_C_FLAGS_DEBUG:STRING=${CMAKE_C_FLAGS_DEBUG}
+ -DCMAKE_C_FLAGS_MINSIZEREL:STRING=${CMAKE_C_FLAGS_MINSIZEREL}
+ -DCMAKE_C_FLAGS_RELEASE:STRING=${CMAKE_C_FLAGS_RELEASE}
+ -DCMAKE_C_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_C_FLAGS_RELWITHDEBINFO}
+ -DCMAKE_CXX_FLAGS_DEBUG:STRING=${CMAKE_CXX_FLAGS_DEBUG}
+ -DCMAKE_CXX_FLAGS_MINSIZEREL:STRING=${CMAKE_CXX_FLAGS_MINSIZEREL}
+ -DCMAKE_CXX_FLAGS_RELEASE:STRING=${CMAKE_CXX_FLAGS_RELEASE}
+ -DCMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_CXX_FLAGS_RELWITHDEBINFO}
+ -DCMAKE_INSTALL_PREFIX:PATH=${install_prefix}/${proj}
+ -DCMAKE_BUILD_TYPE:STRING=${build_type}
+ -DBUILD_SHARED_LIBS:BOOL=OFF
+ -DBUILD_EXAMPLES:BOOL=OFF
+ -DBUILD_TESTING:BOOL=OFF
+ -DVTK_USE_QT:BOOL=ON
+ -DVTK_USE_QVTK_QTOPENGL:BOOL=ON
+ -DCMAKE_CXX_STANDARD_LIBRARIES:STRING=${VTK_CMAKE_CXX_STANDARD_LIBRARIES}
+)
+SET(VTK_DIR ${build_prefix}/VTK)
+#=========================================================
+
+#=========================================================
+# ITK
+ExternalProject_Add(
+ ITK
+ SOURCE_DIR ${source_prefix}/itk
+ GIT_REPOSITORY git://itk.org/ITK.git
+ GIT_TAG v4.2.0
+ INSTALL_COMMAND ""
+ CMAKE_ARGS
+ -DCMAKE_C_FLAGS_DEBUG:STRING=${CMAKE_C_FLAGS_DEBUG}
+ -DCMAKE_C_FLAGS_MINSIZEREL:STRING=${CMAKE_C_FLAGS_MINSIZEREL}
+ -DCMAKE_C_FLAGS_RELEASE:STRING=${CMAKE_C_FLAGS_RELEASE}
+ -DCMAKE_C_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_C_FLAGS_RELWITHDEBINFO}
+ -DCMAKE_CXX_FLAGS_DEBUG:STRING=${CMAKE_CXX_FLAGS_DEBUG}
+ -DCMAKE_CXX_FLAGS_MINSIZEREL:STRING=${CMAKE_CXX_FLAGS_MINSIZEREL}
+ -DCMAKE_CXX_FLAGS_RELEASE:STRING=${CMAKE_CXX_FLAGS_RELEASE}
+ -DCMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_CXX_FLAGS_RELWITHDEBINFO}
+ -DCMAKE_INSTALL_PREFIX:PATH=${install_prefix}/${proj}
+ -DCMAKE_BUILD_TYPE:STRING=${build_type}
+ -DBUILD_SHARED_LIBS:BOOL=OFF
+ -DBUILD_EXAMPLES:BOOL=OFF
+ -DBUILD_TESTING:BOOL=OFF
+)
+SET(ITK_DIR ${build_prefix}/ITK)
+#=========================================================
+
+#=========================================================
+# VV
+SET(VV_CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+if(MSVC)
+ SET(VV_CMAKE_CXX_FLAGS "${VV_CMAKE_CXX_FLAGS} /bigobj")
+endif(MSVC)
+
+SET(VV_CMAKE_EXE_LINKER_FLAGS ${CMAKE_EXE_LINKER_FLAGS})
+if(CMAKE_COMPILER_IS_GNUCXX)
+ SET(VV_CMAKE_EXE_LINKER_FLAGS "-static-libgcc -static-libstdc++")
+endif(CMAKE_COMPILER_IS_GNUCXX)
+
+SET(MAKE_COMMAND "make")
+if(MSVC)
+ SET(MAKE_COMMAND "nmake")
+endif(MSVC)
+
+ExternalProject_Add(
+ VV
+ DEPENDS QT VTK ITK
+ SOURCE_DIR ${source_prefix}/vv
+ GIT_REPOSITORY git://git.creatis.insa-lyon.fr/clitk
+ GIT_TAG v1.3.0
+ INSTALL_COMMAND ${MAKE_COMMAND} package
+ CMAKE_ARGS
+ -DQT_QMAKE_EXECUTABLE:FILEPATH=${qmake_executable}
+ -DITK_DIR:PATH=${ITK_DIR}
+ -DVTK_DIR:PATH=${VTK_DIR}
+ -DCMAKE_C_FLAGS_DEBUG:STRING=${CMAKE_C_FLAGS_DEBUG}
+ -DCMAKE_C_FLAGS_MINSIZEREL:STRING=${CMAKE_C_FLAGS_MINSIZEREL}
+ -DCMAKE_C_FLAGS_RELEASE:STRING=${CMAKE_C_FLAGS_RELEASE}
+ -DCMAKE_C_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_C_FLAGS_RELWITHDEBINFO}
+ -DCMAKE_CXX_FLAGS_DEBUG:STRING=${CMAKE_CXX_FLAGS_DEBUG}
+ -DCMAKE_CXX_FLAGS_MINSIZEREL:STRING=${CMAKE_CXX_FLAGS_MINSIZEREL}
+ -DCMAKE_CXX_FLAGS_RELEASE:STRING=${CMAKE_CXX_FLAGS_RELEASE}
+ -DCMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_CXX_FLAGS_RELWITHDEBINFO}
+ -DCMAKE_CXX_FLAGS:STRING=${VV_CMAKE_CXX_FLAGS}
+ -DCMAKE_EXE_LINKER_FLAGS:STRING=${VV_CMAKE_EXE_LINKER_FLAGS}
+ -DCMAKE_INSTALL_PREFIX:PATH=${install_prefix}/${proj}
+ -DCMAKE_BUILD_TYPE:STRING=${build_type}
+ -DBUILD_SHARED_LIBS:BOOL=OFF
+ -DBUILD_TESTING:BOOL=OFF
+)
+#=========================================================
+
option "outputDir" o "Output dicom directory" string yes
option "key" k "Keys of tags to modify" string no multiple default="0008|103e"
option "tag" t "Tags values" string no multiple default="MIDPOSITION"
-option "useSizeAsReference" s "Use the size of the dicom image as reference for an occasional resampling" flag off
\ No newline at end of file
+option "newSeriesUID" e "Write the series with a new series UID (ignored if given in key/tag option)" flag off
+option "newStudyUID" u "Write the series with a new study UID (ignored if given in key/tag option; forces newSeriesUID = true)" flag off
+option "useSizeAsReference" s "Use the size of the dicom image as reference for an occasional resampling" flag off
// clitk
#include "clitkResampleImageWithOptionsFilter.h"
+#if GDCM_MAJOR_VERSION >= 2
+#include "gdcmUIDGenerator.h"
+#else
+#include "gdcmFile.h"
+#include "gdcmUtil.h"
+#endif
namespace clitk
namesGenerator->SetInputDirectory( m_ArgsInfo.inputDir_arg );
namesGenerator->SetOutputDirectory( m_ArgsInfo.outputDir_arg );
typename ReaderType::FileNamesContainer filenames_in = namesGenerator->GetInputFileNames();
- typename ReaderType::FileNamesContainer filenames_out = namesGenerator->GetOutputFileNames();
+ typename ReaderType::FileNamesContainer filenames_out;
// Output the dicom files
unsigned int numberOfFilenames = filenames_in.size();
// Get keys
unsigned int numberOfKeysGiven=m_ArgsInfo.key_given;
+ if (m_ArgsInfo.verbose_flag)
+ DD(numberOfKeysGiven);
+ std::string seriesUID;
+ std::string frameOfReferenceUID;
+ std::string studyUID;
+
+ // one pass through the keys given on the cmd-line, to check what will be recreated
+ std::string seriesUIDkey = "0020|000e";
+ std::string seriesNumberKey = "0020|0011";
+ std::string seriesDescriptionKey = "0008|103e";
+ std::string frameOfReferenceUIDKey = "0020|0052";
+ std::string studyUIDKey = "0020|000d";
+ std::string studyIDKey = "0020|0010";
+ std::string studyDescriptionKey = "0008|1030";
+ bool seriesUIDGiven = false;
+ bool seriesNumberGiven = false;
+ bool seriesDescriptionGiven = false;
+ bool studyUIDGiven = false;
+ bool studyIDGiven = false;
+ bool studyDescriptionGiven = false;
for (unsigned int i = 0; i < numberOfKeysGiven; i++) {
- std::string entryId(m_ArgsInfo.key_arg[i] );
- std::string value( m_ArgsInfo.tag_arg[i] );
- std::cout << entryId << " " << value << std::endl;
- for(unsigned int fni = 0; fni<numberOfFilenames; fni++)
- itk::EncapsulateMetaData<std::string>( *((*dictionary)[fni]), entryId, value );
+ std::string entryId( m_ArgsInfo.key_arg[i] );
+ if (m_ArgsInfo.verbose_flag)
+ DD(entryId);
+
+ seriesUIDGiven |= (entryId == seriesUIDkey || entryId == frameOfReferenceUIDKey);
+ seriesNumberGiven |= (entryId == seriesNumberKey);
+ seriesDescriptionGiven |= (entryId == seriesDescriptionKey);
+ studyUIDGiven |= (entryId == studyUIDKey);
+ studyIDGiven |= (entryId == studyIDKey);
+ studyDescriptionGiven |= (entryId == studyDescriptionKey);
+ }
+
+ // force the creation of a new series if a new study was specified
+ if (!studyUIDGiven && m_ArgsInfo.newStudyUID_flag) {
+ m_ArgsInfo.newSeriesUID_flag = true;
+#if GDCM_MAJOR_VERSION >= 2
+ gdcm::UIDGenerator suid;
+ studyUID = suid.Generate();
+#else
+ studyUID = gdcm::Util::CreateUniqueUID( gdcmIO->GetUIDPrefix());
+#endif
+ }
+
+ if (!seriesUIDGiven && m_ArgsInfo.newSeriesUID_flag) {
+#if GDCM_MAJOR_VERSION >= 2
+ gdcm::UIDGenerator suid;
+ seriesUID = suid.Generate();
+ gdcm::UIDGenerator fuid;
+ frameOfReferenceUID = fuid.Generate();
+#else
+ seriesUID = gdcm::Util::CreateUniqueUID( gdcmIO->GetUIDPrefix());
+ frameOfReferenceUID = gdcm::Util::CreateUniqueUID( gdcmIO->GetUIDPrefix());
+#endif
+ }
+
+ if (m_ArgsInfo.verbose_flag) {
+ DD(seriesUID);
+ DD(frameOfReferenceUID);
+ DD(studyUID);
+ }
+
+ // check if file UIDs will be be preserved
+ bool useInputFileUID = true;
+ if (m_ArgsInfo.newSeriesUID_flag || m_ArgsInfo.newStudyUID_flag || seriesUIDGiven || studyUIDGiven) {
+ useInputFileUID = false;
+ }
+ else {
+#if GDCM_MAJOR_VERSION < 2
+ gdcmIO->SetKeepOriginalUID(true);
+#endif
+ namesGenerator->SetOutputDirectory( m_ArgsInfo.outputDir_arg );
+ filenames_out = namesGenerator->GetOutputFileNames();
}
+ filenames_out.resize(numberOfFilenames);
+
+ time_t t;
+ t = time(&t);
+ struct tm* instanceDateTimeTm = localtime(&t);
+ char datetime[16];
+ strftime(datetime, 16, "%Y%m%d", instanceDateTimeTm);
+ std::ostringstream instanceDate;
+ instanceDate << datetime;
+ std::ostringstream instanceTime;
+ strftime(datetime, 16, "%H%M%S", instanceDateTimeTm);
+ instanceTime << datetime;
+
+ // update output dicom keys/tags
+ for(unsigned int fni = 0; fni<numberOfFilenames; fni++) {
+ for (unsigned int i = 0; i < numberOfKeysGiven; i++) {
+ std::string entryId(m_ArgsInfo.key_arg[i] );
+ std::string value( m_ArgsInfo.tag_arg[i] );
+
+ itk::EncapsulateMetaData<std::string>( *((*dictionary)[fni]), entryId, value );
+ }
+ // series UID
+ if (!seriesUIDGiven) {
+ if (m_ArgsInfo.newSeriesUID_flag) {
+ itk::EncapsulateMetaData<std::string>( *((*dictionary)[fni]), seriesUIDkey, seriesUID );
+ itk::EncapsulateMetaData<std::string>( *((*dictionary)[fni]), frameOfReferenceUIDKey, frameOfReferenceUID );
+ }
+ }
+
+ // study UID
+ if (!studyUIDGiven) {
+ if (m_ArgsInfo.newStudyUID_flag)
+ itk::EncapsulateMetaData<std::string>( *((*dictionary)[fni]), studyUIDKey, studyUID );
+ }
+
+ // study description
+ if (studyUIDGiven || m_ArgsInfo.newStudyUID_flag) {
+ if (!studyIDGiven)
+ itk::EncapsulateMetaData<std::string>( *((*dictionary)[fni]), studyIDKey,itksys::SystemTools::GetFilenameName( m_ArgsInfo.outputDir_arg ));
+ if (!studyDescriptionGiven)
+ itk::EncapsulateMetaData<std::string>( *((*dictionary)[fni]), studyDescriptionKey,itksys::SystemTools::GetFilenameName( m_ArgsInfo.outputDir_arg ));
+
+ itk::EncapsulateMetaData<std::string>( *((*dictionary)[fni]), "0008|0020", instanceDate.str() );
+ itk::EncapsulateMetaData<std::string>( *((*dictionary)[fni]), "0008|0030", instanceTime.str() );
+ }
+
+ // series description/number
+ if (seriesUIDGiven || m_ArgsInfo.newSeriesUID_flag) {
+ if (!seriesDescriptionGiven)
+ itk::EncapsulateMetaData<std::string>( *((*dictionary)[fni]), seriesDescriptionKey, itksys::SystemTools::GetFilenameName(m_ArgsInfo.outputDir_arg) );
+ if (!seriesNumberGiven)
+ itk::EncapsulateMetaData<std::string>( *((*dictionary)[fni]), seriesNumberKey, itksys::SystemTools::GetFilenameName(m_ArgsInfo.outputDir_arg) );
+
+ itk::EncapsulateMetaData<std::string>( *((*dictionary)[fni]), "0008|0012", instanceDate.str() );
+ itk::EncapsulateMetaData<std::string>( *((*dictionary)[fni]), "0008|0013", instanceTime.str() );
+ }
+
+ // file UIDs are recreated for new studies or series
+ if (!useInputFileUID)
+ {
+ std::string fileUID;
+#if GDCM_MAJOR_VERSION >= 2
+ gdcm::UIDGenerator fid;
+ fileUID = fid.Generate();
+#else
+ fileUID = gdcm::Util::CreateUniqueUID( gdcmIO->GetUIDPrefix());
+#endif
+ itk::EncapsulateMetaData<std::string>( *((*dictionary)[fni]), "0008|0018", fileUID );
+ itk::EncapsulateMetaData<std::string>( *((*dictionary)[fni]), "0002|0003", fileUID );
+
+ filenames_out[fni] = itksys::SystemTools::CollapseFullPath(fileUID.c_str(), m_ArgsInfo.outputDir_arg) + std::string(".dcm");
+ }
+ }
+
// Output directory and filenames
itksys::SystemTools::MakeDirectory( m_ArgsInfo.outputDir_arg ); // create if it doesn't exist
typedef itk::ImageSeriesWriter<InputImageType, OutputImageType > SeriesWriterType;
IF(WIN32)
#INCLUDE(InstallRequiredSystemLibraries)
- INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_BUILD_TYPE}/vv.exe DESTINATION .)
+ INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/vv.exe DESTINATION .)
#INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/icons/ducky.png DESTINATION .)
ENDIF(WIN32)
#=========================================================
SET(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/ReadMe.txt")
SET(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/License.txt")
SET(CPACK_PACKAGE_VERSION_MAJOR "1")
-SET(CPACK_PACKAGE_VERSION_MINOR "2")
-SET(CPACK_PACKAGE_VERSION_PATCH "2")
+SET(CPACK_PACKAGE_VERSION_MINOR "3")
+SET(CPACK_PACKAGE_VERSION_PATCH "0")
SET(CPACK_PACKAGE_INSTALL_DIRECTORY "vv")
SET(CPACK_STRIP_FILES TRUE)
# There is a bug in NSI that does not handle full unix paths properly. Make
# sure there is at least one set of four (4) backlasshes.
SET(CPACK_NSIS_MUI_ICON "${CMAKE_CURRENT_SOURCE_DIR}\\\\icons\\\\ducky.ico")
- SET(CPACK_NSIS_INSTALLED_ICON_NAME "${CMAKE_BUILD_TYPE}\\\\vv.exe")
+ SET(CPACK_NSIS_INSTALLED_ICON_NAME "vv.exe")
SET(CPACK_NSIS_DISPLAY_NAME "vv - The 4D slicer")
SET(CPACK_NSIS_HELP_LINK "http://www.creatis.insa-lyon.fr/rio/vv")
SET(CPACK_NSIS_URL_INFO_ABOUT "http://www.creatis.insa-lyon.fr/rio")
int n_image_loaded=0;
std::string win(""), lev("");
+ int first_of_wl_set = -1;
+ bool new_wl_set = false;
bool link_images = false;
if (argc >1) {
for (int i = 1; i < argc; i++) {
std::string current = argv[i];
- if (!current.compare(0,2,"--")) { //We are parsing an option
+ if (!current.compare(0,1,"-")) { // && !current.compare(0,2,"--")) { //We are parsing an option
if (parse_mode == P_SEQUENCE) {//First finish the current sequence
open_sequence(window, open_mode, parse_mode, sequence_filenames, n_image_loaded);
+ }
+ else if (parse_mode == P_WINDOW) { // handle negative window values
+ win=current;
+ window.ApplyWindowToSetOfImages(atof(win.c_str()), first_of_wl_set, n_image_loaded-1);
+ parse_mode=P_NORMAL;
+ new_wl_set = false;
+ continue;
+ } else if (parse_mode == P_LEVEL) { // handle negative level values
+ lev=current;
+ window.ApplyLevelToSetOfImages(atof(lev.c_str()), first_of_wl_set, n_image_loaded-1);
+ parse_mode=P_NORMAL;
+ new_wl_set = false;
+ continue;
}
if ((current=="--help") || (current=="-h")) {
std::cout << "vv " << VV_VERSION << ", the 2D, 2D+t, 3D and 3D+t (or 4D) image viewer" << std::endl << std::endl
<< "Open file(s) for visualization." << std::endl << std::endl
<< "OPTIONS may be:" << std::endl
<< "--help \t Print command line help and exit." << std::endl
- << "--window number\t Gray scale window width for all images." << std::endl
- << "--level number \t Gray scale window level for all images." << std::endl
+ << "--window number\t Gray scale window width for set of images appearing before in the cmd line (may appear more than once)." << std::endl
+ << "--level number \t Gray scale window level for set of images appearing before in the cmd line (may appear more than once)." << std::endl
<< "--linkall \t Link pan, zoom and spatial position of crosshair in images." << std::endl
<< "--log \t Log output messages in vv-log directory." << std::endl
<< "--state file \t Read display parameters from file." << std::endl
//<< "--roi file \t Overlay binary mask images. Option may be repeated on a single base image." << std::endl
<< "--contour file \t Overlay DICOM RT-STRUCT contours." << std::endl;
exit(0);
- }
- if (current=="--vf") {
+ } else if (current=="--vf") {
if (!n_image_loaded) load_image_first_error();
open_mode = O_VF;
} else if (current=="--overlay") {
} else if (current == "--sequence") {
if(open_mode==O_BASE) n_image_loaded++; //count only one for the whole sequence
parse_mode=P_SEQUENCE;
+ if (!new_wl_set) {
+ new_wl_set = true;
+ first_of_wl_set = n_image_loaded-1;
+ }
} else if (current == "--window") {
parse_mode=P_WINDOW;
} else if (current == "--level") {
parse_mode=P_LEVEL;
} else if (current == "--linkall") {
- link_images = true;
- }
- else if (current == "--log") {
+ link_images = true;
+ }
+ else if (current == "--log") {
std::string log_dir = QDir::tempPath().toStdString() + std::string("/vv-log");
if(itksys::SystemTools::FileExists(log_dir.c_str()) &&
sequence_filenames.push_back(current);
} else if (parse_mode == P_WINDOW) {
win=current;
+ window.ApplyWindowToSetOfImages(atof(win.c_str()), first_of_wl_set, n_image_loaded-1);
parse_mode=P_NORMAL;
+ new_wl_set = false;
} else if (parse_mode == P_LEVEL) {
lev=current;
+ window.ApplyLevelToSetOfImages(atof(lev.c_str()), first_of_wl_set, n_image_loaded-1);
parse_mode=P_NORMAL;
+ new_wl_set = false;
} else {
std::vector<std::string> image;
image.push_back(current);
if(open_mode==O_BASE) {
window.LoadImages(image, vvImageReader::IMAGE);
n_image_loaded++;
+ if (!new_wl_set) {
+ new_wl_set = true;
+ first_of_wl_set = n_image_loaded-1;
+ }
}
else if (open_mode==O_VF)
window.AddField(current.c_str(), n_image_loaded-1);
}
}
- if(win!="" && lev!="") {
- window.SetWindowLevel(atof(win.c_str()), atof(lev.c_str()));
- window.ApplyWindowLevelToAllImages();
- }
+// if(win!="" && lev!="") {
+// window.SetWindowLevel(atof(win.c_str()), atof(lev.c_str()));
+// window.ApplyWindowLevelToAllImages();
+// }
if (link_images)
window.LinkAllImages();
// Redefine this button to handle pick
this->GrabFocus(this->EventCallbackCommand);
- if (!this->Interactor->GetShiftKey() && !this->Interactor->GetControlKey()) {
+ if (this->Interactor->GetShiftKey()) {
+ this->OnMiddleButtonDown();
+ }
+ else if (!this->Interactor->GetControlKey()) {
this->StartPick();
}
this->ReleaseFocus();
}
break;
+ case VTKIS_PAN:
+ this->OnMiddleButtonUp();
+ break;
}
// Call parent to handle all other states and perform additional work
}
//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+void vvLinkPanel::addLinkFromIds(QString id1, QString id2)
+{
+ int index1 = -1, index2 = -1;
+ size_t s1 = image1Ids.size();
+ size_t s2 = image2Ids.size();
+ for (size_t i = 0; i < s1 && index1 == -1; i++)
+ if (image1Ids[i] == id1.toStdString())
+ index1 = i;
+
+ if (index1 >= 0)
+ image1ComboBox->setCurrentIndex(index1);
+
+ for (size_t i = 0; i < s2 && index2 == -1; i++)
+ if (image2Ids[i] == id2.toStdString())
+ index2 = i;
+
+ if (index1 >= 0 && index2 >= 0) {
+ image2ComboBox->setCurrentIndex(index2);
+ addLink();
+ }
+}
+//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvLinkPanel::addLink()
linkTableWidget->setRowHeight(row,17);
emit addLink(image1Ids[image1ComboBox->currentIndex()].c_str(),
- image2Ids[image2ComboBox->currentIndex()].c_str());
+ image2Ids[image2ComboBox->currentIndex()].c_str(),
+ true
+ );
UpdateComboBox2(image1ComboBox->currentIndex());
}
~vvLinkPanel() {}
void addImage(std::string name, std::string id);
+ void addLinkFromIds(QString id1, QString id2);
void removeImage(int i);
bool isLinkAll();
void linkAll();
signals:
- void addLink(QString image1,QString image2);
+ void addLink(QString image1,QString image2,bool);
void removeLink(QString image1,QString image2);
private:
connect(this,SIGNAL(customContextMenuRequested(QPoint)),this,SLOT(ShowContextMenu(QPoint)));
- connect(linkPanel,SIGNAL(addLink(QString,QString)),this,SLOT(AddLink(QString,QString)));
+ connect(linkPanel,SIGNAL(addLink(QString,QString,bool)),this,SLOT(AddLink(QString,QString,bool)));
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)),
DataTree->setItemWidget(item, COLUMN_RELOAD_IMAGE, rButton);
//set the id of the image
- QString id = files[i].c_str() + QString::number(mSlicerManagers.size()-1);
+ QString id = QDir::current().absoluteFilePath(files[i].c_str()) + QString::number(mSlicerManagers.size()-1);
item->setData(COLUMN_IMAGE_NAME,Qt::UserRole,id.toStdString().c_str());
mSlicerManagers.back()->SetId(id.toStdString());
//read image header
int NPixel = 1;
+ int tSlice = 0;
vvImage::Pointer imageSelected;
if (DataTree->topLevelItem(index) == DataTree->selectedItems()[0]) {
imageSelected = mSlicerManagers[index]->GetSlicer(0)->GetImage();
+ tSlice = mSlicerManagers[index]->GetSlicer(0)->GetTSlice();
} else if (DataTree->selectedItems()[0]->data(1,Qt::UserRole).toString() == "vector") {
imageSelected = mSlicerManagers[index]->GetSlicer(0)->GetVF();
+ tSlice = mSlicerManagers[index]->GetSlicer(0)->GetOverlayTSlice();
} else if (DataTree->selectedItems()[0]->data(1,Qt::UserRole).toString() == "overlay") {
imageSelected = mSlicerManagers[index]->GetSlicer(0)->GetOverlay();
+ tSlice = mSlicerManagers[index]->GetSlicer(0)->GetOverlayTSlice();
} else if (DataTree->selectedItems()[0]->data(1,Qt::UserRole).toString() == "fusion") {
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();
}
else {
imageSelected = mSlicerManagers[index]->GetSlicer(0)->GetImage();
+ tSlice = mSlicerManagers[index]->GetSlicer(0)->GetTSlice();
}
dimension = imageSelected->GetNumberOfDimensions();
infoPanel->setOrigin(GetVectorDoubleAsString(origin));
infoPanel->setSpacing(GetVectorDoubleAsString(inputSpacing));
infoPanel->setNPixel(QString::number(NPixel)+" ("+inputSizeInBytes+")");
- transformation = imageSelected->GetTransform()[mSlicerManagers[index]->GetTSlice()]->GetMatrix();
+ transformation = imageSelected->GetTransform()[tSlice]->GetMatrix();
infoPanel->setTransformation(Get4x4MatrixDoubleAsString(transformation));
landmarksPanel->SetCurrentLandmarks(mSlicerManagers[index]->GetLandmarks(),
//------------------------------------------------------------------------------
void vvMainWindow::ChangeViewMode()
{
- QList<int> size;
+ typedef struct _SIZE{
+ QSplitter* splitter;
+ QList<int> size1, size2;
+ int cols[3];
+ }SplitterSize;
+ SplitterSize sizes[4];
+ sizes[0].splitter = OSplitter;
+ sizes[0].size1.push_back(1);
+ sizes[0].size1.push_back(0);
+ sizes[0].size2.push_back(1);
+ sizes[0].size2.push_back(0);
+ sizes[0].cols[0] = 2;
+ sizes[0].cols[1] = 3;
+ sizes[0].cols[2] = 4;
+
+ sizes[1].splitter = ESplitter;
+ sizes[1].size1.push_back(0);
+ sizes[1].size1.push_back(1);
+ sizes[1].size2.push_back(1);
+ sizes[1].size2.push_back(0);
+ sizes[1].cols[0] = 1;
+ sizes[1].cols[1] = 3;
+ sizes[1].cols[2] = 4;
+
+ sizes[2].splitter = OSplitter;
+ sizes[2].size1.push_back(1);
+ sizes[2].size1.push_back(0);
+ sizes[2].size2.push_back(0);
+ sizes[2].size2.push_back(1);
+ sizes[2].cols[0] = 1;
+ sizes[2].cols[1] = 2;
+ sizes[2].cols[2] = 4;
+
+ sizes[3].splitter = ESplitter;
+ sizes[3].size1.push_back(0);
+ sizes[3].size1.push_back(1);
+ sizes[3].size2.push_back(0);
+ sizes[3].size2.push_back(1);
+ sizes[3].cols[0] = 1;
+ sizes[3].cols[1] = 2;
+ sizes[3].cols[2] = 3;
+
+ int slicer = mSlicerManagers[mCurrentPickedImageIndex]->GetSelectedSlicer();
if (viewMode == 1) {
- viewMode = 0;
- size.push_back(1);
- size.push_back(0);
- splitter_3->setSizes(size);
- OSplitter->setSizes(size);
- DataTree->setColumnHidden(2,1);
- DataTree->setColumnHidden(3,1);
- DataTree->setColumnHidden(4,1);
+ if (slicer >= 0) {
+ viewMode = 0;
+ splitter_3->setSizes(sizes[slicer].size1);
+ sizes[slicer].splitter->setSizes(sizes[slicer].size2);
+ DataTree->setColumnHidden(sizes[slicer].cols[0],1);
+ DataTree->setColumnHidden(sizes[slicer].cols[1],1);
+ DataTree->setColumnHidden(sizes[slicer].cols[2],1);
+ }
} else {
- viewMode = 1;
- size.push_back(1);
- size.push_back(1);
- splitter_3->setSizes(size);
- OSplitter->setSizes(size);
- DataTree->setColumnHidden(2,0);
- DataTree->setColumnHidden(3,0);
- DataTree->setColumnHidden(4,0);
+ QList<int> size;
+ if (slicer >= 0) {
+ viewMode = 1;
+ size.push_back(1);
+ size.push_back(1);
+ splitter_3->setSizes(size);
+ sizes[slicer].splitter->setSizes(size);
+ DataTree->setColumnHidden(sizes[slicer].cols[0],0);
+ DataTree->setColumnHidden(sizes[slicer].cols[1],0);
+ DataTree->setColumnHidden(sizes[slicer].cols[2],0);
+ }
}
UpdateRenderWindows();
/*
** 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)
+// if (DataTree->topLevelItem(i)->data(COLUMN_UL_VIEW,Qt::CheckStateRole).toInt() > 1)
mSlicerManagers[i]->GetSlicer(0)->Render();
- if (DataTree->topLevelItem(i)->data(COLUMN_DL_VIEW,Qt::CheckStateRole).toInt() > 1)
+ 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();
}
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::DisplaySliders(int slicer, int window)
{
+ if(!mSlicerManagers[slicer]->GetSlicer(window)->GetRenderer()->GetDraw())
+ return;
+
int range[2];
mSlicerManagers[slicer]->GetSlicer(window)->GetSliceRange(range);
int position = mSlicerManagers[slicer]->GetSlicer(window)->GetSlice();
-
- int tRange[2];
- tRange[0] = 0;
- tRange[1] = mSlicerManagers[slicer]->GetSlicer(window)->GetTMax();
- int tPosition = mSlicerManagers[slicer]->GetSlicer(window)->GetMaxCurrentTSlice();
- bool showHorizontal = false;
- bool showVertical = false;
if (range[1]>0)
- showVertical = true;
- if (tRange[1]>0)
- showHorizontal = true;
-
- if (showVertical)
verticalSliders[window]->show();
else
verticalSliders[window]->hide();
verticalSliders[window]->setRange(range[0],range[1]);
verticalSliders[window]->setValue(position);
- if (showHorizontal)
+ int tRange[2];
+ tRange[0] = 0;
+ tRange[1] = mSlicerManagers[slicer]->GetSlicer(window)->GetTMax();
+ if (tRange[1]>0)
horizontalSliders[window]->show();
else
horizontalSliders[window]->hide();
horizontalSliders[window]->setRange(tRange[0],tRange[1]);
+ int tPosition = mSlicerManagers[slicer]->GetSlicer(window)->GetMaxCurrentTSlice();
horizontalSliders[window]->setValue(tPosition);
}
//------------------------------------------------------------------------------
}
//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+void vvMainWindow::ApplyWindowToSetOfImages(double window, unsigned int indexMin, unsigned int indexMax)
+{
+ for (unsigned int i = indexMin; i <= indexMax && i < mSlicerManagers.size(); i++) {
+ if (mSlicerManagers[i] == NULL)
+ continue;
+ mSlicerManagers[i]->SetColorWindow(window);
+ mSlicerManagers[i]->SetPreset(6);
+ mSlicerManagers[i]->Render();
+ }
+}
+//------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+void vvMainWindow::ApplyLevelToSetOfImages(double level, unsigned int indexMin, unsigned int indexMax)
+{
+ for (unsigned int i = indexMin; i <= indexMax && i < mSlicerManagers.size(); i++) {
+ if (mSlicerManagers[i] == NULL)
+ continue;
+ mSlicerManagers[i]->SetColorLevel(level);
+ mSlicerManagers[i]->SetPreset(6);
+ mSlicerManagers[i]->Render();
+ }
+}
+//------------------------------------------------------------------------------
+
//------------------------------------------------------------------------------
void vvMainWindow::UpdateLinkManager(std::string id, int slicer, double x, double y, double z, int temps)
{
}
//------------------------------------------------------------------------------
-void vvMainWindow::AddLink(QString image1,QString image2)
+void vvMainWindow::AddLink(QString image1,QString image2,bool fromPanel)
{
+ if (!fromPanel) {
+ // delegate to linkPanel if call came from elsewhere...
+ linkPanel->addLinkFromIds(image1, image2);
+ return;
+ }
+
unsigned int sm1 = 0;
unsigned int sm2 = 0;
//------------------------------------------------------------------------------
void vvMainWindow::UpdateSliceRange(int slicer, int min, int max, int tmin, int tmax)
{
- int position = int((min+max)/2);
+ //int position = int((min+max)/2);
+ int position = mSlicerManagers[mCurrentPickedImageIndex]->GetSlicer(slicer)->GetSlice();
if (slicer == 0) {
- NOVerticalSlider->setValue(position);
NOVerticalSlider->setRange(min,max);
NOHorizontalSlider->setRange(tmin,tmax);
+ NOVerticalSlider->setValue(position);
} else if (slicer == 1) {
- NEVerticalSlider->setValue(position);
NEVerticalSlider->setRange(min,max);
NEHorizontalSlider->setRange(tmin,tmax);
+ NEVerticalSlider->setValue(position);
} else if (slicer == 2) {
- SOVerticalSlider->setValue(position);
SOVerticalSlider->setRange(min,max);
SOHorizontalSlider->setRange(tmin,tmax);
+ SOVerticalSlider->setValue(position);
} else if (slicer == 3) {
- SEVerticalSlider->setValue(position);
SEVerticalSlider->setRange(min,max);
SEHorizontalSlider->setRange(tmin,tmax);
+ SEVerticalSlider->setValue(position);
}
}
//------------------------------------------------------------------------------
DataTree->setItemWidget(item, COLUMN_RELOAD_IMAGE, rButton);
//set the id of the image
- QString id = slicer_manager->GetFileName().c_str() + QString::number(mSlicerManagers.size()-1);
+ QString id = QDir::current().absoluteFilePath(slicer_manager->GetFileName().c_str()) + QString::number(mSlicerManagers.size()-1);
item->setData(COLUMN_IMAGE_NAME,Qt::UserRole,id.toStdString().c_str());
mSlicerManagers.back()->SetId(id.toStdString());
void UpdateSlicingPreset();
void SwitchWindowLevel();
void ApplyWindowLevelToAllImages();
+ void ApplyWindowToSetOfImages(double window, unsigned int indexMin, unsigned int indexMax);
+ void ApplyLevelToSetOfImages(double level, unsigned int indexMin, unsigned int indexMax);
void UpdateLinkManager(std::string id, int slicer, double x, double y, double z, int temps);
void UpdateLinkedNavigation(std::string id, vvSlicerManager *sm, vvSlicer* refSlicer);
- void AddLink(QString image1,QString image2);
+ void AddLink(QString image1,QString image2,bool fromPanel = true);
void RemoveLink(QString image1,QString image2);
void ChangeImageWithIndexOffset(vvSlicerManager *sm, int slicer, int offset);
{
std::string value;
+ // read images
while (!m_XmlReader->isEndElement() || value != "Images") {
m_XmlReader->readNext();
value = m_XmlReader->qualifiedName().toString().toStdString();
}
}
+ // read links
+ while (!m_XmlReader->isEndElement() || value != "Links") {
+ m_XmlReader->readNext();
+ value = m_XmlReader->qualifiedName().toString().toStdString();
+ if (m_XmlReader->isStartElement()) {
+ if (value == "LinkedFrom") value = ReadLink();
+ }
+ }
+
if (m_XmlReader->hasError())
std::cout << "Error " << m_XmlReader->error() << " XML " << std::endl;
}
}
}
else if (current_index >= 0) {
- if (value == "Fusion")
+ vvSlicerManager* slicerManager = m_Window->GetSlicerManagers()[current_index];
+ if (value == "Preset") {
+ double vali = m_XmlReader->readElementText().toInt();
+ if (!m_XmlReader->hasError())
+ slicerManager->SetPreset(vali);
+ }
+ else if (value == "Window") {
+ double vald = m_XmlReader->readElementText().toDouble();
+ if (!m_XmlReader->hasError())
+ slicerManager->SetColorWindow(vald);
+ }
+ else if (value == "Level") {
+ double vald = m_XmlReader->readElementText().toDouble();
+ if (!m_XmlReader->hasError())
+ slicerManager->SetColorLevel(vald);
+ }
+ else if (value == "Fusion")
value = ReadFusion(current_index);
else if (value == "Overlay")
value = ReadOverlay(current_index);
//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+std::string vvReadState::ReadLink()
+{
+ std::string id_from, id_to, value;
+
+ QXmlStreamAttributes attributes = m_XmlReader->attributes();
+ if (!m_XmlReader->hasError()) {
+ id_from = attributes.value("Id").toString().toStdString();
+ }
+
+ while (!m_XmlReader->isEndElement() || value != "LinkedFrom") {
+ m_XmlReader->readNext();
+ value = m_XmlReader->qualifiedName().toString().toStdString();
+ if (m_XmlReader->isStartElement()) {
+ if (value == "LinkedTo") {
+ id_to = m_XmlReader->readElementText().toStdString();
+ if (!m_XmlReader->hasError()) {
+ m_Window->AddLink(id_from.c_str(), id_to.c_str(), false);
+ }
+ }
+ }
+ }
+
+ return value;
+}
+//------------------------------------------------------------------------------
+
//------------------------------------------------------------------------------
void vvReadState::ReadGUI()
{
std::string ReadFusion(int index);
std::string ReadOverlay(int index);
std::string ReadVector(int index);
+ std::string ReadLink();
std::auto_ptr<QXmlStreamReader> m_XmlReader;
std::auto_ptr<QFile> m_File;
SaveImage(item, i);
}
m_XmlWriter->writeEndElement();
+
+ m_XmlWriter->writeStartElement("Links");
+ for (int i = 0; i < tree->topLevelItemCount(); i++) {
+ const vvSlicerManager * slicerManager = m_Window->GetSlicerManagers()[i];
+ SaveLink(slicerManager);
+ }
+ m_XmlWriter->writeEndElement();
}
//------------------------------------------------------------------------------
const vvSlicerManager * slicerManager = m_Window->GetSlicerManagers()[index];
m_XmlWriter->writeStartElement("Image");
- std::ostringstream indexStr;
- indexStr.str("");
- indexStr << index;
- m_XmlWriter->writeAttribute("Index", indexStr.str().c_str());
+ std::ostringstream valueStr;
+ valueStr.str("");
+ valueStr << index;
+ m_XmlWriter->writeAttribute("Index", valueStr.str().c_str());
std::string filename = item->data(0, Qt::UserRole).toString().toStdString();
m_XmlWriter->writeTextElement("FileName", QDir::current().absoluteFilePath(filename.c_str()));
-
+ int preset = slicerManager->GetPreset();
+ m_XmlWriter->writeTextElement("Preset", QString::number(preset));
+ if (preset == 6) {
+ m_XmlWriter->writeTextElement("Window", QString::number(slicerManager->GetColorWindow()));
+ m_XmlWriter->writeTextElement("Level", QString::number(slicerManager->GetColorLevel()));
+ }
+
QTreeWidgetItem* item_child;
std::string role;
for (int i = 0; i < item->childCount(); i++) {
}
//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+void vvSaveState::SaveLink(const vvSlicerManager* vvManager)
+{
+ typedef std::list<std::string> LinkListType;
+ LinkListType links = vvManager->GetLinks();
+ if (!links.empty()) {
+ std::string my_id = vvManager->GetId();
+ m_XmlWriter->writeStartElement("LinkedFrom");
+ m_XmlWriter->writeAttribute("Id", my_id.c_str());
+ typename LinkListType::iterator i;
+ for (i = links.begin(); i != links.end(); i++) {
+ std::string link_id = *i;
+ m_XmlWriter->writeTextElement("LinkedTo", link_id.c_str());
+ }
+ m_XmlWriter->writeEndElement();
+ }
+}
+//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvSaveState::SaveGUI()
void SaveFusion(const QTreeWidgetItem* item, const vvSlicerManager* slicerManager);
void SaveOverlay(const QTreeWidgetItem* item, const vvSlicerManager* slicerManager);
void SaveVector(const QTreeWidgetItem* item);
+ void SaveLink(const vvSlicerManager* slicerManager);
std::auto_ptr<QXmlStreamWriter> m_XmlWriter;
std::auto_ptr<QFile> m_File;
mCurrent[1] = -VTK_DOUBLE_MAX;
mCurrent[2] = -VTK_DOUBLE_MAX;
- mCursor[0] = -VTK_DOUBLE_MAX;
- mCursor[1] = -VTK_DOUBLE_MAX;
- mCursor[2] = -VTK_DOUBLE_MAX;
- mCursor[3] = -VTK_DOUBLE_MAX;
+ mCursor[0] = 0;//-VTK_DOUBLE_MAX;
+ mCursor[1] = 0;//-VTK_DOUBLE_MAX;
+ mCursor[2] = 0;//-VTK_DOUBLE_MAX;
+ mCursor[3] = 0;//-VTK_DOUBLE_MAX;
mSubSampling = 5;
mScale = 1;
AdjustResliceToSliceOrientation(mOverlayReslice);
// Update the viewer
- int *range = this->GetSliceRange();
- if (range)
- this->Slice = static_cast<int>((range[0] + range[1]) * 0.5);
-
+
// Go to current cursor position
// double* cursorPos = GetCursorPosition();
// DDV(cursorPos, 3);
// SetCurrentPosition(cursorPos[0],cursorPos[1],cursorPos[2],cursorPos[3]);
+ if (this->Renderer && this->GetInput()) {
+ double s = mCursor[orientation];
+ double sCursor = (s - this->GetInput()->GetOrigin()[orientation])/this->GetInput()->GetSpacing()[orientation];
+ this->Slice = static_cast<int>(sCursor);
+ }
+
+// int *range = this->GetSliceRange();
+// if (range)
+// this->Slice = static_cast<int>((range[0] + range[1]) * 0.5);
+
this->UpdateOrientation();
this->UpdateDisplayExtent();
for ( int i = 0; i < numberOfSlicers; i++)
mSlicers.push_back(vtkSmartPointer<vvSlicer>::New());
-
+ mSelectedSlicer = -1;
+
mPreviousSlice.resize(numberOfSlicers);
mPreviousTSlice.resize(numberOfSlicers);
mSlicingPreset = WORLD_SLICING;
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:
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
-double vvSlicerManager::GetColorWindow()
+double vvSlicerManager::GetColorWindow() const
{
if (mSlicers.size())
return mSlicers[0]->GetColorWindow();
//----------------------------------------------------------------------------
-double vvSlicerManager::GetColorLevel()
+double vvSlicerManager::GetColorLevel() const
{
if (mSlicers.size())
return mSlicers[0]->GetColorLevel();
window = 400;
level = 20;
break;
- case 3:
- window = 1500;
- level = -500;
+ case 3: // lungs (same as FOCAL)
+ window = 1700;
+ level = -300;
break;
case 4:
window = 1000;
///Switch between nearest neighbor and linear interpolation
void ToggleInterpolation();
vvSlicer* GetSlicer(int i);
+ int GetSelectedSlicer() {
+ return mSelectedSlicer;
+ }
+
void UpdateSlicer(int num, bool state);
void SetSlicerWindow(int i, vtkRenderWindow* RW);
void SetInteractorStyleNavigator(int i,vtkInteractorStyle* style);
vvImage::Pointer GetVF() { return mVF; }
int GetType() { return mType; }
void SetId(std::string id) { mId = id; }
- std::string GetId() { return mId; }
+ std::string GetId() const { return mId; }
int GetDimension() {
if (mImage) return mImage->GetNumberOfDimensions();
else return -1;
mFusionShowLegend = show;
}
- double GetColorWindow();
- double GetColorLevel();
+ double GetColorWindow() const;
+ double GetColorLevel() const;
double GetOverlayColorWindow() const;
double GetOverlayColorLevel() const;
bool GetLinkOverlayWindowLevel() const;
int GetColorMap() {
return mColorMap;
}
- int GetPreset() {
+ int GetPreset() const {
return mPreset;
}
SlicingPresetType GetSlicingPreset() {
mLinkedId.remove(oldId);
}
+ std::list<std::string> GetLinks() const {
+ return mLinkedId;
+ }
+
bool IsLinked() {
return mLinkedId.size() > 0;
}
protected:
std::vector< vtkSmartPointer<vvSlicer> > mSlicers;
+ int mSelectedSlicer;
vvImageReader::Pointer mReader;
vvImageReader::Pointer mOverlayReader;
vvImageReader::Pointer mFusionReader;