From: Simon Rit Date: Wed, 10 Oct 2012 08:26:39 +0000 (+0200) Subject: Merge branch 'master' of git.creatis.insa-lyon.fr:clitk X-Git-Tag: v1.4.0~239^2~19^2 X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=commitdiff_plain;h=bc4b7eaef671605cb3e8077ce8a70eb7386890e5;hp=1cc917fa6b46248867ad53e8de0ef85224525d12;p=clitk.git Merge branch 'master' of git.creatis.insa-lyon.fr:clitk Conflicts: vv/vv.cxx --- diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt index 4dcf325..91f53e5 100644 --- a/common/CMakeLists.txt +++ b/common/CMakeLists.txt @@ -37,6 +37,8 @@ IF(CLITK_PRIVATE_FEATURES) SET(clitkCommon_SRC ${clitkCommon_SRC} ${PROJECT_SOURCE_DIR}/private_features/clitkUsfImageIO.cxx ${PROJECT_SOURCE_DIR}/private_features/clitkUsfImageIOFactory.cxx + ${PROJECT_SOURCE_DIR}/private_features/clitkUSVoxImageIO.cxx + ${PROJECT_SOURCE_DIR}/private_features/clitkUSVoxImageIOFactory.cxx ) ENDIF(CLITK_PRIVATE_FEATURES) diff --git a/common/clitkIO.cxx b/common/clitkIO.cxx index 011147d..cfa8e86 100644 --- a/common/clitkIO.cxx +++ b/common/clitkIO.cxx @@ -36,6 +36,7 @@ #include "clitkConfiguration.h" #if CLITK_PRIVATE_FEATURES #include "clitkUsfImageIOFactory.h" + #include "clitkUSVoxImageIOFactory.h" #endif //-------------------------------------------------------------------- @@ -44,6 +45,7 @@ void clitk::RegisterClitkFactories() { #if CLITK_PRIVATE_FEATURES clitk::UsfImageIOFactory::RegisterOneFactory(); + clitk::USVoxImageIOFactory::RegisterOneFactory(); #endif clitk::GateAsciiImageIOFactory::RegisterOneFactory(); clitk::DicomRTDoseIOFactory::RegisterOneFactory(); diff --git a/common/vvImage.cxx b/common/vvImage.cxx index 0bddb26..31c6ef0 100644 --- a/common/vvImage.cxx +++ b/common/vvImage.cxx @@ -32,7 +32,7 @@ #include //-------------------------------------------------------------------- -vvImage::vvImage():mTransform(vtkSmartPointer::New()) +vvImage::vvImage() { Init(); } @@ -251,7 +251,7 @@ bool vvImage::IsScalarTypeInteger(int t) //-------------------------------------------------------------------- //-------------------------------------------------------------------- -vtkSmartPointer vvImage::GetTransform() +const std::vector< vtkSmartPointer >& vvImage::GetTransform() { return this->mTransform; } diff --git a/common/vvImage.h b/common/vvImage.h index ec01a1f..a120457 100644 --- a/common/vvImage.h +++ b/common/vvImage.h @@ -56,7 +56,7 @@ public : bool IsTimeSequence() const; bool IsScalarTypeInteger(); bool IsScalarTypeInteger(int t); - vtkSmartPointer GetTransform(); + const std::vector< vtkSmartPointer >& GetTransform(); void SetTimeSpacing(double s) { mTimeSpacing = s; } void SetTimeOrigin(double o) { mTimeOrigin = o; } bool HaveSameSizeAndSpacingThan(vvImage * other); @@ -66,8 +66,8 @@ private: ~vvImage(); std::vector< ConverterPointer > mItkToVtkConverters; - std::vector mVtkImages; - vtkSmartPointer mTransform; + std::vector< vtkImageData* > mVtkImages; + std::vector< vtkSmartPointer > mTransform; double mTimeOrigin; double mTimeSpacing; diff --git a/common/vvImage.txx b/common/vvImage.txx index 14da10a..55b785f 100644 --- a/common/vvImage.txx +++ b/common/vvImage.txx @@ -50,7 +50,8 @@ void vvImage::AddItkImage(TItkImageType *input) // GetDirection provides the forward transform, vtkImageReslice wants the inverse matrix->Invert(); - mTransform->SetMatrix(matrix); + mTransform.push_back(vtkSmartPointer::New()); + mTransform.back()->SetMatrix(matrix); } //-------------------------------------------------------------------- diff --git a/common/vvImageReader.cxx b/common/vvImageReader.cxx index 0205355..c795cd9 100644 --- a/common/vvImageReader.cxx +++ b/common/vvImageReader.cxx @@ -110,37 +110,37 @@ void vvImageReader::SetInputFilenames(const std::vector & filenames //------------------------------------------------------------------------------ //Read transformation in NKI format (Xdr, transposed, cm) -void vvImageReader::ReadNkiImageTransform() -{ - bool bRead=false; - std::string filename = mInputFilenames[0]+".MACHINEORIENTATION"; - if(itksys::SystemTools::FileExists(filename.c_str())){ - typedef itk::ImageFileReader< itk::Image< double, 2 > > MatrixReaderType; - MatrixReaderType::Pointer readerTransfo = MatrixReaderType::New(); - readerTransfo->SetFileName(filename); - try { - bRead = true; - readerTransfo->Update(); - } catch( itk::ExceptionObject & err ) { - bRead=false; - std::cerr << "Cannot read " << filename << std::endl - << "The error is: " << err << std::endl; - } - - if (bRead) { - //Transpose matrix (NKI format) - for(int j=0; j<4; j++) - for(int i=0; i<4; i++) - mImage->GetTransform()->GetMatrix()->SetElement(j,i,readerTransfo->GetOutput()->GetBufferPointer()[4*i+j]); - - //From cm to mm - for(int i=0; i<3; i++) - mImage->GetTransform()->GetMatrix()->SetElement(i,3,10*mImage->GetTransform()->GetMatrix()->GetElement(i,3)); - - mImage->GetTransform()->Inverse(); - } - } -} +//void vvImageReader::ReadNkiImageTransform() +//{ +// bool bRead=false; +// std::string filename = mInputFilenames[0]+".MACHINEORIENTATION"; +// if(itksys::SystemTools::FileExists(filename.c_str())){ +// typedef itk::ImageFileReader< itk::Image< double, 2 > > MatrixReaderType; +// MatrixReaderType::Pointer readerTransfo = MatrixReaderType::New(); +// readerTransfo->SetFileName(filename); +// try { +// bRead = true; +// readerTransfo->Update(); +// } catch( itk::ExceptionObject & err ) { +// bRead=false; +// std::cerr << "Cannot read " << filename << std::endl +// << "The error is: " << err << std::endl; +// } + +// if (bRead) { +// //Transpose matrix (NKI format) +// for(int j=0; j<4; j++) +// for(int i=0; i<4; i++) +// mImage->GetTransform()->GetMatrix()->SetElement(j,i,readerTransfo->GetOutput()->GetBufferPointer()[4*i+j]); + +// //From cm to mm +// for(int i=0; i<3; i++) +// mImage->GetTransform()->GetMatrix()->SetElement(i,3,10*mImage->GetTransform()->GetMatrix()->GetElement(i,3)); + +// mImage->GetTransform()->Inverse(); +// } +// } +//} //------------------------------------------------------------------------------ @@ -192,9 +192,10 @@ void vvImageReader::ReadMatImageTransform() vtkGenericWarningMacro("Matrix in " << filename.c_str() << " cannot be inverted (determinant = 0)"); } - mImage->GetTransform()->PostMultiply(); - mImage->GetTransform()->Concatenate(matrix); - mImage->GetTransform()->Update(); + // TODO SR and BP: check on the list of transforms and not the first only + mImage->GetTransform()[0]->PostMultiply(); + mImage->GetTransform()[0]->Concatenate(matrix); + mImage->GetTransform()[0]->Update(); } } //------------------------------------------------------------------------------ diff --git a/common/vvImageReader.h b/common/vvImageReader.h index dae05e4..4348e0f 100644 --- a/common/vvImageReader.h +++ b/common/vvImageReader.h @@ -92,7 +92,7 @@ protected: std::string mInputPixelType; //==================================================================== - void ReadNkiImageTransform(); +// void ReadNkiImageTransform(); void ReadMatImageTransform(); private: vvImageReader(); diff --git a/common/vvImageReader.txx b/common/vvImageReader.txx index 6a4333f..9b0e21a 100644 --- a/common/vvImageReader.txx +++ b/common/vvImageReader.txx @@ -187,12 +187,13 @@ void vvImageReader::UpdateWithDimAndInputPixelType() 0.,0.,1.,0., 0.,-1.,0.,0., 0.,0.,0.,1.}; + // TODO SR and BP: check on the list of transforms and not the first only int i; - for(i=0; i<16 && m[i]==mImage->GetTransform()->GetMatrix()->GetElement(i%4, i/4); i++); + for(i=0; i<16 && m[i]==mImage->GetTransform()[0]->GetMatrix()->GetElement(i%4, i/4); i++); if(i==16) { itkWarningMacro(<< "Analyze image file format detected with unknown orientation. " << "Forcing identity orientation, use other file format if not ok."); - mImage->GetTransform()->Identity(); + mImage->GetTransform()[0]->Identity(); } } } @@ -259,13 +260,13 @@ void vvImageReader::UpdateWithDimAndInputVectorPixelType() 0.,-1.,0.,0., 0.,0.,0.,1.}; int i; - for (i = 0; i < 16 && m[i] == mImage->GetTransform()->GetMatrix()->GetElement(i % 4, i / 4); i++) + for (i = 0; i < 16 && m[i] == mImage->GetTransform()[0]->GetMatrix()->GetElement(i % 4, i / 4); i++) ; if (i == 16) { itkWarningMacro(<< "Analyze image file format detected with unknown orientation. " << "Forcing identity orientation, use other file format if not ok."); - mImage->GetTransform()->Identity(); + mImage->GetTransform()[0]->Identity(); } } } diff --git a/common/vvImageWriter.txx b/common/vvImageWriter.txx index 0640f0c..0705197 100644 --- a/common/vvImageWriter.txx +++ b/common/vvImageWriter.txx @@ -73,7 +73,8 @@ void vvImageWriter::UpdateWithDimAndOutputPixelType() itk::Matrix trans; for(int i=0; i<4; i++) for(int j=0; j<4; j++) - trans[i][j] = mImage->GetTransform()->GetMatrix()->GetElement(i,j); + // TODO SR and BP: check on the list of transforms and not the first only + trans[i][j] = mImage->GetTransform()[0]->GetMatrix()->GetElement(i,j); trans = trans.GetInverse(); // Direction diff --git a/vv/qt_ui/vvMainWindow.ui b/vv/qt_ui/vvMainWindow.ui index 789e59f..8d3d8ff 100644 --- a/vv/qt_ui/vvMainWindow.ui +++ b/vv/qt_ui/vvMainWindow.ui @@ -67,19 +67,6 @@ 2 - - - - Qt::Horizontal - - - - 40 - 20 - - - - @@ -330,7 +317,7 @@ - + @@ -356,13 +343,6 @@ - - - - Qt::Vertical - - - @@ -402,6 +382,40 @@ + + + + + World + + + + + Voxels + + + + + + + + Slice to + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + @@ -791,7 +805,7 @@ 0 0 1008 - 22 + 25 diff --git a/vv/vv.cxx b/vv/vv.cxx index f5029b1..b4beaa8 100644 --- a/vv/vv.cxx +++ b/vv/vv.cxx @@ -45,6 +45,9 @@ #include #include +typedef enum {O_BASE,O_OVERLAY,O_FUSION,O_VF,O_CONTOUR} OpenModeType; +typedef enum {P_NORMAL,P_SEQUENCE,P_WINDOW,P_LEVEL} ParseModeType; + void load_image_first_error() { std::cerr << "You need to load an image before adding an overlay!" << std::endl; @@ -65,6 +68,28 @@ std::string create_timed_string() return st; } +void open_sequence(vvMainWindow &window, + OpenModeType &open_mode, + ParseModeType &parse_mode, + std::vector &sequence_filenames, + int n_image_loaded) +{ + const std::string open_mode_names[] = {"base", "overlay", "fusion", "vf", "contour"}; + if(open_mode==O_BASE) + window.LoadImages(sequence_filenames, vvImageReader::MERGEDWITHTIME); + else if (open_mode==O_OVERLAY) + window.AddOverlayImage(n_image_loaded-1,sequence_filenames,vvImageReader::MERGEDWITHTIME); + else { + std::cerr << "Sequences are not managed for opening " << open_mode_names[open_mode] << std::endl; + exit(1); + } + + // Reset + sequence_filenames.clear(); + parse_mode=P_NORMAL; + open_mode=O_BASE; +} + //------------------------------------------------------------------------------ #ifdef _WIN32 int CALLBACK WinMain(HINSTANCE hInstance, HINSTANCE prevInstance, LPSTR lpCmdLine, int nShowCmd) @@ -110,8 +135,8 @@ int main( int argc, char** argv ) window.show(); std::vector sequence_filenames; - enum {P_NORMAL,P_SEQUENCE,P_WINDOW,P_LEVEL}; - int parse_mode=P_NORMAL; + ParseModeType parse_mode = P_NORMAL; + OpenModeType open_mode = O_BASE; int n_image_loaded=0; std::string win(""), lev(""); @@ -121,9 +146,7 @@ int main( int argc, char** argv ) std::string current = argv[i]; if (!current.compare(0,1,"-")) { // && !current.compare(0,2,"--")) { //We are parsing an option if (parse_mode == P_SEQUENCE) {//First finish the current sequence - window.LoadImages(sequence_filenames, vvImageReader::MERGEDWITHTIME); - sequence_filenames.clear(); - parse_mode=P_NORMAL; + open_sequence(window, open_mode, parse_mode, sequence_filenames, n_image_loaded); } else if (parse_mode == P_WINDOW) { // handle negative window values win=current; @@ -156,26 +179,18 @@ int main( int argc, char** argv ) exit(0); } else if (current=="--vf") { if (!n_image_loaded) load_image_first_error(); - window.AddField(argv[i+1],n_image_loaded-1); - i++; //skip vf name + open_mode = O_VF; } else if (current=="--overlay") { if (!n_image_loaded) load_image_first_error(); - window.AddOverlayImage(n_image_loaded-1,argv[i+1]); - i++; //skip overlay name - } /*else if (current=="--roi") { + open_mode = O_OVERLAY; + } else if (current=="--contour") { if (!n_image_loaded) load_image_first_error(); - window.AddROI(n_image_loaded-1,argv[i+1]); - i++; //skip roi name - }*/ else if (current=="--contour") { - if (!n_image_loaded) load_image_first_error(); - window.AddDCStructContour(n_image_loaded-1,argv[i+1]); - i++; //skip roi name + open_mode = O_CONTOUR; } else if (current=="--fusion") { if (!n_image_loaded) load_image_first_error(); - window.AddFusionImage(n_image_loaded-1,argv[i+1]); - i++; //skip fusion name + open_mode = O_FUSION; } else if (current == "--sequence") { - n_image_loaded++; //count only one for the sequence + if(open_mode==O_BASE) n_image_loaded++; //count only one for the whole sequence parse_mode=P_SEQUENCE; } else if (current == "--window") { parse_mode=P_WINDOW; @@ -228,14 +243,23 @@ int main( int argc, char** argv ) } else { std::vector image; image.push_back(current); - window.LoadImages(image, vvImageReader::IMAGE); - n_image_loaded++; + if(open_mode==O_BASE) { + window.LoadImages(image, vvImageReader::IMAGE); + n_image_loaded++; + } + else if (open_mode==O_VF) + window.AddField(current.c_str(), n_image_loaded-1); + else if (open_mode==O_OVERLAY) + window.AddOverlayImage(n_image_loaded-1,image,vvImageReader::IMAGE); + else if (open_mode==O_CONTOUR) + window.AddDCStructContour(n_image_loaded-1,current.c_str()); + else if (open_mode==O_FUSION) + window.AddFusionImage(n_image_loaded-1,current.c_str()); + open_mode = O_BASE; } } if (parse_mode == P_SEQUENCE) { //Finish any current sequence - window.LoadImages(sequence_filenames, vvImageReader::MERGEDWITHTIME); - sequence_filenames.clear(); - parse_mode=P_NORMAL; + open_sequence(window, open_mode, parse_mode, sequence_filenames, n_image_loaded); } } diff --git a/vv/vvMainWindow.cxx b/vv/vvMainWindow.cxx index 9fc078c..8f94ff6 100644 --- a/vv/vvMainWindow.cxx +++ b/vv/vvMainWindow.cxx @@ -309,10 +309,10 @@ vvMainWindow::vvMainWindow():vvMainWindowBase() connect(levelSpinBox,SIGNAL(editingFinished()),this,SLOT(WindowLevelEdited())); connect(colorMapComboBox,SIGNAL(currentIndexChanged(int)),this,SLOT(UpdateColorMap())); connect(presetComboBox,SIGNAL(currentIndexChanged(int)),this,SLOT(UpdateWindowLevel())); + connect(slicingPresetComboBox, SIGNAL(currentIndexChanged(int)),this,SLOT(UpdateSlicingPreset())); connect(inverseButton,SIGNAL(clicked()),this,SLOT(SwitchWindowLevel())); connect(applyWindowLevelToAllButton,SIGNAL(clicked()),this,SLOT(ApplyWindowLevelToAllImages())); - connect(this,SIGNAL(customContextMenuRequested(QPoint)),this,SLOT(ShowContextMenu(QPoint))); connect(linkPanel,SIGNAL(addLink(QString,QString)),this,SLOT(AddLink(QString,QString))); @@ -952,6 +952,8 @@ void vvMainWindow::LoadImages(std::vector files, vvImageReader::Loa 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())); connect(mSlicerManagers.back(), SIGNAL(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)), @@ -1084,7 +1086,8 @@ void vvMainWindow::ImageInfoChanged() QString inputSizeInBytes; QString image = DataTree->selectedItems()[0]->data(COLUMN_IMAGE_NAME,Qt::DisplayRole).toString(); - if (mSlicerManagers[index]->GetSlicer(0)->GetImage()->GetVTKImages().size() > 1 || playMode == 1) { + int nframes = mSlicerManagers[index]->GetSlicer(0)->GetTMax(); + if (nframes > 1 || playMode == 1) { playButton->setEnabled(1); frameRateLabel->setEnabled(1); frameRateSpinBox->setEnabled(1); @@ -1139,7 +1142,7 @@ void vvMainWindow::ImageInfoChanged() infoPanel->setOrigin(GetVectorDoubleAsString(origin)); infoPanel->setSpacing(GetVectorDoubleAsString(inputSpacing)); infoPanel->setNPixel(QString::number(NPixel)+" ("+inputSizeInBytes+")"); - transformation = imageSelected->GetTransform()->GetMatrix(); + transformation = imageSelected->GetTransform()[mSlicerManagers[index]->GetTSlice()]->GetMatrix(); infoPanel->setTransformation(Get4x4MatrixDoubleAsString(transformation)); landmarksPanel->SetCurrentLandmarks(mSlicerManagers[index]->GetLandmarks(), @@ -1176,6 +1179,7 @@ void vvMainWindow::ImageInfoChanged() } } WindowLevelChanged(); + slicingPresetComboBox->setCurrentIndex(mSlicerManagers[index]->GetSlicingPreset()); if (mSlicerManagers[index]->GetSlicer(0)->GetVF()) { overlayPanel->getVFName(mSlicerManagers[index]->GetVFName().c_str()); @@ -1497,17 +1501,12 @@ void vvMainWindow::DisplaySliders(int slicer, int window) int tRange[2]; tRange[0] = 0; tRange[1] = mSlicerManagers[slicer]->GetSlicer(window)->GetTMax(); - int tPosition = mSlicerManagers[slicer]->GetSlicer(window)->GetTSlice(); + int tPosition = mSlicerManagers[slicer]->GetSlicer(window)->GetMaxCurrentTSlice(); bool showHorizontal = false; bool showVertical = false; - if (mSlicerManagers[slicer]->GetSlicer(window)->GetImage()->GetNumberOfDimensions() > 3 - || (mSlicerManagers[slicer]->GetSlicer(window)->GetImage()->GetNumberOfDimensions() > 2 - && mSlicerManagers[slicer]->GetType() != vvImageReader::IMAGEWITHTIME - && mSlicerManagers[slicer]->GetType() != vvImageReader::MERGEDWITHTIME)) + if (range[1]>0) showVertical = true; - if (mSlicerManagers[slicer]->GetSlicer(window)->GetImage()->GetNumberOfDimensions() > 3 - || mSlicerManagers[slicer]->GetType() == vvImageReader::IMAGEWITHTIME - || mSlicerManagers[slicer]->GetType() == vvImageReader::MERGEDWITHTIME) + if (tRange[1]>0) showHorizontal = true; if (showVertical) @@ -1721,6 +1720,16 @@ void vvMainWindow::UpdateWindowLevel() } //------------------------------------------------------------------------------ +//------------------------------------------------------------------------------ +void vvMainWindow::UpdateSlicingPreset() +{ + if (DataTree->selectedItems().size()) { + int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]); + mSlicerManagers[index]->SetSlicingPreset(vvSlicerManager::SlicingPresetType(slicingPresetComboBox->currentIndex())); + } +} +//------------------------------------------------------------------------------ + //------------------------------------------------------------------------------ void vvMainWindow::UpdateColorMap() { @@ -1845,21 +1854,28 @@ void vvMainWindow::SelectOverlayImage() QString Extensions = EXTENSIONS; Extensions += ";;All Files (*)"; - QString file = QFileDialog::getOpenFileName(this,tr("Load Overlay image"),mInputPathName,Extensions); - if (!file.isEmpty()) - AddOverlayImage(index,file); + QStringList files = QFileDialog::getOpenFileNames(this,tr("Load Overlay image"),mInputPathName,Extensions); + if (files.isEmpty()) + return; + + std::vector vecFileNames; + for (int i = 0; i < files.size(); i++) { + vecFileNames.push_back(files[i].toStdString()); + } + AddOverlayImage(index,vecFileNames,vvImageReader::IMAGE); } //------------------------------------------------------------------------------ //------------------------------------------------------------------------------ -void vvMainWindow::AddOverlayImage(int index, QString file) +void vvMainWindow::AddOverlayImage(int index, std::vector 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(file.toStdString().c_str()); + reader->SetFileName(fileNames[0].c_str()); reader->ReadImageInformation(); std::string component = reader->GetComponentTypeAsString(reader->GetComponentType()); int dimension = reader->GetNumberOfDimensions(); @@ -1868,7 +1884,7 @@ void vvMainWindow::AddOverlayImage(int index, QString file) qApp->processEvents(); std::string filename = itksys::SystemTools::GetFilenameWithoutExtension(file.toStdString()).c_str(); - if (mSlicerManagers[index]->SetOverlay(file.toStdString(),dimension, component)) { + if (mSlicerManagers[index]->SetOverlay(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()); @@ -1912,6 +1928,10 @@ void vvMainWindow::AddOverlayImage(int index, QString file) qApp->processEvents(); ImageInfoChanged(); QApplication::restoreOverrideCursor(); + + // Update the display to update, e.g., the sliders + for(int i=0; i<4; i++) + DisplaySliders(index, i); } else { QApplication::restoreOverrideCursor(); QString error = "Cannot import the new image.\n"; @@ -2308,7 +2328,8 @@ void vvMainWindow::SaveAs() bool bId = true; for(int i=0; i<4; i++) for(int j=0; j<4; j++) { - double elt = mSlicerManagers[index]->GetImage()->GetTransform()->GetMatrix()->GetElement(i,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.) @@ -2874,9 +2895,8 @@ void vvMainWindow::SaveScreenshot(QVTKWidget *widget) vidwriter->SetInput(image); vidwriter->SetFileName(fileName.toStdString().c_str()); vidwriter->Start(); - vvImage * vvImg = mSlicerManagers[smIndex]->GetImage(); - int nSlice = vvImg->GetVTKImages().size(); - for(int i=0; iGetSlicer(0)->GetTMax(); + for(int i=0; i<=nSlice; i++) { mSlicerManagers[smIndex]->SetNextTSlice(0); vtkSmartPointer w2i = vtkSmartPointer::New(); w2i->SetInput(widget->GetRenderWindow()); @@ -2924,7 +2944,7 @@ void vvMainWindow::PlayPause() int image_number=DataTree->topLevelItemCount(); bool has_temporal; for (int i=0; iGetImage()->GetVTKImages().size() > 1) { + if (mSlicerManagers[i]->GetSlicer(0)->GetTMax() > 0) { has_temporal=true; break; } @@ -2945,7 +2965,7 @@ void vvMainWindow::PlayNext() ///Only play one slicer per SM, and only if the SM is being displayed for (int i=0; iGetImage()->GetVTKImages().size() > 1 && + if (mSlicerManagers[i]->GetSlicer(0)->GetTMax() > 0 && DataTree->topLevelItem(i)->data(j+1,Qt::CheckStateRole).toInt() > 0) { mSlicerManagers[i]->SetNextTSlice(j); break; @@ -3079,6 +3099,8 @@ vvSlicerManager* vvMainWindow::AddImage(vvImage::Pointer image,std::string filen 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())); connect(mSlicerManagers.back(), SIGNAL(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)), diff --git a/vv/vvMainWindow.h b/vv/vvMainWindow.h index bbdfe26..015a468 100644 --- a/vv/vvMainWindow.h +++ b/vv/vvMainWindow.h @@ -54,7 +54,7 @@ class vvMainWindow: public vvMainWindowBase, void LoadImages(std::vector filenames, vvImageReader::LoadedImageType type); vvSlicerManager * AddImage(vvImage::Pointer image,std::string filename); void AddField(QString file,int index); - void AddOverlayImage(int index, QString filename); + void AddOverlayImage(int index, std::vector fileNames, vvImageReader::LoadedImageType type); void AddFusionImage(int index, QString filename); void AddROI(int index, QString filename); ///Adds a mesh to a SlicerManager, with optional warping by vector field @@ -118,6 +118,7 @@ public slots: void SetWindowLevel(double w, double l); void UpdateColorMap(); void UpdateWindowLevel(); + void UpdateSlicingPreset(); void SwitchWindowLevel(); void ApplyWindowLevelToAllImages(); void UpdateLinkManager(std::string id, int slicer, double x, double y, double z, int temps); diff --git a/vv/vvReadState.cxx b/vv/vvReadState.cxx index 7383ecd..6d61ca5 100644 --- a/vv/vvReadState.cxx +++ b/vv/vvReadState.cxx @@ -191,8 +191,12 @@ std::string vvReadState::ReadOverlay(int index) if (m_XmlReader->isStartElement()) { if (value == "FileName") { file = m_XmlReader->readElementText().toStdString(); - if (!m_XmlReader->hasError()) - m_Window->AddOverlayImage(index, file.c_str()); + if (!m_XmlReader->hasError()) { + // TODO: manage sequence of images + std::vector vec; + vec.push_back(file.c_str()); + m_Window->AddOverlayImage(index, vec, vvImageReader::IMAGE); + } } if (value == "OverlayColorWindow") { vald = m_XmlReader->readElementText().toDouble(); diff --git a/vv/vvSlicer.cxx b/vv/vvSlicer.cxx index 1e133d6..17aa41b 100644 --- a/vv/vvSlicer.cxx +++ b/vv/vvSlicer.cxx @@ -82,6 +82,8 @@ vvSlicer::vvSlicer() mImage = NULL; mReducedExtent = new int[6]; mCurrentTSlice = 0; + mCurrentFusionTSlice = 0; + mCurrentOverlayTSlice = 0; mUseReducedExtent = false; mCurrent[0] = -VTK_DOUBLE_MAX; @@ -145,6 +147,11 @@ vvSlicer::vvSlicer() #if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10) this->GetImageActor()->GetMapper()->BorderOn(); #endif + + mSlicingTransform = vtkSmartPointer::New(); + mConcatenatedTransform = vtkSmartPointer::New(); + mConcatenatedFusionTransform = vtkSmartPointer::New(); + mConcatenatedOverlayTransform = vtkSmartPointer::New(); } //------------------------------------------------------------------------------ @@ -290,14 +297,21 @@ vvSlicer::~vvSlicer() } //------------------------------------------------------------------------------ +//------------------------------------------------------------------------------ +double* vvSlicer::GetCurrentPosition() +{ + return mCurrentBeforeSlicingTransform; +} +//------------------------------------------------------------------------------ //------------------------------------------------------------------------------ void vvSlicer::SetCurrentPosition(double x, double y, double z, int t) { - mCurrent[0] = x; - mCurrent[1] = y; - mCurrent[2] = z; - mCurrentTSlice = t; + mCurrentBeforeSlicingTransform[0]=x; + mCurrentBeforeSlicingTransform[1]=y; + mCurrentBeforeSlicingTransform[2]=z; + mSlicingTransform->GetInverse()->TransformPoint(mCurrentBeforeSlicingTransform,mCurrent); + SetTSlice(t); } //------------------------------------------------------------------------------ @@ -314,7 +328,11 @@ void vvSlicer::SetImage(vvImage::Pointer image) mImageReslice->AutoCropOutputOn(); mImageReslice->SetBackgroundColor(-1000,-1000,-1000,1); } - mImageReslice->SetResliceTransform(mImage->GetTransform()); + + mConcatenatedTransform->Identity(); + mConcatenatedTransform->Concatenate(mImage->GetTransform()[0]); + mConcatenatedTransform->Concatenate(mSlicingTransform); + mImageReslice->SetResliceTransform(mConcatenatedTransform); mImageReslice->SetInput(0, mImage->GetFirstVTKImageData()); mImageReslice->UpdateInformation(); @@ -355,8 +373,13 @@ void vvSlicer::SetOverlay(vvImage::Pointer overlay) mOverlayReslice->AutoCropOutputOn(); mOverlayReslice->SetBackgroundColor(-1000,-1000,-1000,1); } - mOverlayReslice->SetResliceTransform(mOverlay->GetTransform()); + + mConcatenatedOverlayTransform->Identity(); + mConcatenatedOverlayTransform->Concatenate(mOverlay->GetTransform()[0]); + mConcatenatedOverlayTransform->Concatenate(mSlicingTransform); + mOverlayReslice->SetResliceTransform(mConcatenatedOverlayTransform); mOverlayReslice->SetInput(0, mOverlay->GetFirstVTKImageData()); + mImageReslice->UpdateInformation(); if (!mOverlayMapper) mOverlayMapper = vtkSmartPointer::New(); @@ -402,8 +425,13 @@ void vvSlicer::SetFusion(vvImage::Pointer fusion) mFusionReslice->AutoCropOutputOn(); mFusionReslice->SetBackgroundColor(-1000,-1000,-1000,1); } - mFusionReslice->SetResliceTransform(mFusion->GetTransform()); + + mConcatenatedFusionTransform->Identity(); + mConcatenatedFusionTransform->Concatenate(mFusion->GetTransform()[0]); + mConcatenatedFusionTransform->Concatenate(mSlicingTransform); + mFusionReslice->SetResliceTransform(mConcatenatedFusionTransform); mFusionReslice->SetInput(0, mFusion->GetFirstVTKImageData()); + mFusionReslice->UpdateInformation(); if (!mFusionMapper) mFusionMapper = vtkSmartPointer::New(); @@ -680,23 +708,44 @@ void vvSlicer::SetVFLog(int log) void vvSlicer::SetTSlice(int t) { if (t < 0) - t = 0; + mCurrentTSlice = 0; else if ((unsigned int)t >= mImage->GetVTKImages().size()) - t = mImage->GetVTKImages().size() -1; + mCurrentTSlice = mImage->GetVTKImages().size() -1; + else + mCurrentTSlice = t; + + // Update transform + mConcatenatedTransform->Identity(); + mConcatenatedTransform->Concatenate(mImage->GetTransform()[mCurrentTSlice]); + mConcatenatedTransform->Concatenate(mSlicingTransform); - mCurrentTSlice = t; + // Update image data mImageReslice->SetInput( mImage->GetVTKImages()[mCurrentTSlice] ); if (mVF && mVFActor->GetVisibility()) { if (mVF->GetVTKImages().size() > (unsigned int)mCurrentTSlice) mVOIFilter->SetInput(mVF->GetVTKImages()[mCurrentTSlice]); } if (mOverlay && mOverlayActor->GetVisibility()) { - if (mOverlay->GetVTKImages().size() > (unsigned int)mCurrentTSlice) - mOverlayReslice->SetInput( mOverlay->GetVTKImages()[mCurrentTSlice] ); + if (mOverlay->GetVTKImages().size() > (unsigned int)t) { + mCurrentOverlayTSlice = t; + mOverlayReslice->SetInput( mOverlay->GetVTKImages()[mCurrentOverlayTSlice] ); + + // Update overlay transform + mConcatenatedOverlayTransform->Identity(); + mConcatenatedOverlayTransform->Concatenate(mOverlay->GetTransform()[mCurrentOverlayTSlice]); + mConcatenatedOverlayTransform->Concatenate(mSlicingTransform); + } } if (mFusion && mFusionActor->GetVisibility()) { - if (mFusion->GetVTKImages().size() > (unsigned int)mCurrentTSlice) - mFusionReslice->SetInput( mFusion->GetVTKImages()[mCurrentTSlice]); + if (mFusion->GetVTKImages().size() > (unsigned int)t) { + mCurrentFusionTSlice = t; + mFusionReslice->SetInput( mFusion->GetVTKImages()[mCurrentFusionTSlice]); + + // Update fusion transform + mConcatenatedFusionTransform->Identity(); + mConcatenatedFusionTransform->Concatenate(mFusion->GetTransform()[mCurrentFusionTSlice]); + mConcatenatedFusionTransform->Concatenate(mSlicingTransform); + } } if (mSurfaceCutActors.size() > 0) for (std::vector::iterator i=mSurfaceCutActors.begin(); @@ -714,6 +763,32 @@ int vvSlicer::GetTSlice() } //------------------------------------------------------------------------------ +//------------------------------------------------------------------------------ +int vvSlicer::GetMaxCurrentTSlice() +{ + int t = mCurrentTSlice; + if(mOverlay) + t = std::max(t, mCurrentOverlayTSlice); + if(mFusion) + t = std::max(t, mCurrentFusionTSlice); + return t; +} +//------------------------------------------------------------------------------ + +//------------------------------------------------------------------------------ +int vvSlicer::GetFusionTSlice() +{ + return mCurrentFusionTSlice; +} +//------------------------------------------------------------------------------ + +//------------------------------------------------------------------------------ +int vvSlicer::GetOverlayTSlice() +{ + return mCurrentOverlayTSlice; +} +//------------------------------------------------------------------------------ + //------------------------------------------------------------------------------ void vvSlicer::SetSliceOrientation(int orientation) { @@ -920,9 +995,8 @@ void vvSlicer::UpdateDisplayExtent() double cpos = (double)cam->GetPosition()[this->SliceOrientation]; double range = fabs(spos - cpos); double *spacing = input->GetSpacing(); - double avg_spacing = - ((double)spacing[0] + (double)spacing[1] + (double)spacing[2]) / 3.0; - cam->SetClippingRange(range - avg_spacing * 3.0, range + avg_spacing * 3.0); + double sumSpacing = spacing[0] + spacing[1] + spacing[2]; + cam->SetClippingRange(range - sumSpacing, range + sumSpacing); } } } @@ -1178,7 +1252,7 @@ void vvSlicer::SetOverlayColorLevel(double level) //---------------------------------------------------------------------------- //---------------------------------------------------------------------------- -// Returns the min an the max value in a 41x41 region around the mouse pointer +// Returns the min an the max value in a 20%x20% region around the mouse pointer void vvSlicer::GetExtremasAroundMousePointer(double & min, double & max, vtkImageData *image, vtkTransform *transform) { //Get mouse pointer position in view coordinates @@ -1272,34 +1346,29 @@ void vvSlicer::Render() if (ca->GetVisibility()) { std::stringstream worldPos; - double X = (mCurrent[0] - this->GetInput()->GetOrigin()[0])/this->GetInput()->GetSpacing()[0]; - double Y = (mCurrent[1] - this->GetInput()->GetOrigin()[1])/this->GetInput()->GetSpacing()[1]; - double Z = (mCurrent[2] - this->GetInput()->GetOrigin()[2])/this->GetInput()->GetSpacing()[2]; - -// if (X < this->GetInput()->GetWholeExtent()[0]) X = this->GetInput()->GetWholeExtent()[0]; -// else if (X > this->GetInput()->GetWholeExtent()[1]) X = this->GetInput()->GetWholeExtent()[1]; -// if (Y < this->GetInput()->GetWholeExtent()[2]) Y = this->GetInput()->GetWholeExtent()[2]; -// else if (Y > this->GetInput()->GetWholeExtent()[3]) Y = this->GetInput()->GetWholeExtent()[3]; -// if (Z < this->GetInput()->GetWholeExtent()[4]) Z = this->GetInput()->GetWholeExtent()[4]; -// else if (Z > this->GetInput()->GetWholeExtent()[5]) Z = this->GetInput()->GetWholeExtent()[5]; - - if (X >= this->GetInput()->GetWholeExtent()[0] && - X <= this->GetInput()->GetWholeExtent()[1] && - Y >= this->GetInput()->GetWholeExtent()[2] && - Y <= this->GetInput()->GetWholeExtent()[3] && - Z >= this->GetInput()->GetWholeExtent()[4] && - Z <= this->GetInput()->GetWholeExtent()[5]) { + double pt[3]; + mConcatenatedTransform->TransformPoint(mCurrent, pt); + double X = (pt[0] - mImage->GetVTKImages()[mCurrentTSlice]->GetOrigin()[0])/mImage->GetVTKImages()[mCurrentTSlice]->GetSpacing()[0]; + double Y = (pt[1] - mImage->GetVTKImages()[mCurrentTSlice]->GetOrigin()[1])/mImage->GetVTKImages()[mCurrentTSlice]->GetSpacing()[1]; + double Z = (pt[2] - mImage->GetVTKImages()[mCurrentTSlice]->GetOrigin()[2])/mImage->GetVTKImages()[mCurrentTSlice]->GetSpacing()[2]; + + if (X >= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[0]-0.5 && + X <= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[1]+0.5 && + Y >= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[2]-0.5 && + Y <= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[3]+0.5 && + Z >= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[4]-0.5 && + Z <= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[5]+0.5) { int ix, iy, iz; - double value = this->GetScalarComponentAsDouble(this->GetInput(), X, Y, Z, ix, iy, iz); + double value = this->GetScalarComponentAsDouble(mImage->GetVTKImages()[mCurrentTSlice], X, Y, Z, ix, iy, iz); if(ImageActor->GetVisibility()) worldPos << "data value : " << value << std::endl; - worldPos << "mm : " << lrint(mCurrent[0]) << ' ' - << lrint(mCurrent[1]) << ' ' - << lrint(mCurrent[2]) << ' ' + worldPos << "mm : " << lrint(mCurrentBeforeSlicingTransform[0]) << ' ' + << lrint(mCurrentBeforeSlicingTransform[1]) << ' ' + << lrint(mCurrentBeforeSlicingTransform[2]) << ' ' << mCurrentTSlice << std::endl; worldPos << "pixel : " << ix << ' ' @@ -1411,6 +1480,14 @@ void vvSlicer::SetSlice(int slice) } //---------------------------------------------------------------------------- +//---------------------------------------------------------------------------- +int vvSlicer::GetTMax() { + int tmax = (int)mImage->GetVTKImages().size() - 1; + if(mOverlay) + tmax = std::max(tmax, (int)mOverlay->GetVTKImages().size()-1); + return tmax; +} +//---------------------------------------------------------------------------- //---------------------------------------------------------------------------- void vvSlicer::SetContourSlice() diff --git a/vv/vvSlicer.h b/vv/vvSlicer.h index c09001d..9a750e1 100644 --- a/vv/vvSlicer.h +++ b/vv/vvSlicer.h @@ -99,11 +99,12 @@ public: void SetSliceOrientation(int orientation); void AdjustResliceToSliceOrientation(vtkImageReslice *reslice); int GetTSlice(); + int GetFusionTSlice(); + int GetOverlayTSlice(); + int GetMaxCurrentTSlice(); ///Reimplemented from vtkImageViewer2 to add polydata support void SetSlice(int s); - int GetTMax() { - return (unsigned int)mImage->GetVTKImages().size() - 1; - } + int GetTMax(); void SetOpacity(double s); void SetRenderWindow(int orientation, vtkRenderWindow * rw); @@ -140,10 +141,13 @@ public: return mCursor; } + vtkTransform * GetSlicingTransform() { return mSlicingTransform; } + vtkTransform * GetConcatenatedTransform() { return mConcatenatedTransform; } + vtkTransform * GetConcatenatedFusionTransform() { return mConcatenatedFusionTransform; } + vtkTransform * GetConcatenatedOverlayTransform() { return mConcatenatedOverlayTransform; } + void SetCurrentPosition(double x, double y, double z, int t); - double* GetCurrentPosition() { - return mCurrent; - } + double* GetCurrentPosition(); void UpdateCursorPosition(); void SetCursorVisibility(bool s); @@ -206,11 +210,25 @@ protected: vvLandmarks* mLandmarks; + // __________ Image coordinates accounting for spacing and origin + // Λ Λ + // | | vvImage.GetTransform() + // | | + // GetConcatenatedTransform() | _|___ VV world coordinates (mm) (displayed in VV) mCurrentBeforeSlicingTransform + // | Λ + // | | GetSlicingTransform() + // | | + // ___|__|___ VTK world coordinates (mm) (never displayed) mCurrent + + vtkSmartPointer mSlicingTransform; vtkSmartPointer mImageReslice; + vtkSmartPointer mConcatenatedTransform; vtkSmartPointer mOverlayReslice; + vtkSmartPointer mConcatenatedOverlayTransform; vtkSmartPointer mOverlayMapper; vtkSmartPointer mOverlayActor; vtkSmartPointer mFusionReslice; + vtkSmartPointer mConcatenatedFusionTransform; vtkSmartPointer mFusionMapper; vtkSmartPointer mFusionActor; vtkSmartPointer ca; @@ -234,7 +252,10 @@ protected: std::vector mSurfaceCutActors; int mCurrentTSlice; + int mCurrentFusionTSlice; + int mCurrentOverlayTSlice; double mCurrent[3]; + double mCurrentBeforeSlicingTransform[3]; double mCursor[4]; int mSubSampling; int mScale; diff --git a/vv/vvSlicerManager.cxx b/vv/vvSlicerManager.cxx index dc75f8f..eb8977d 100644 --- a/vv/vvSlicerManager.cxx +++ b/vv/vvSlicerManager.cxx @@ -72,6 +72,7 @@ vvSlicerManager::vvSlicerManager(int numberOfSlicers) mPreviousSlice.resize(numberOfSlicers); mPreviousTSlice.resize(numberOfSlicers); + mSlicingPreset = WORLD_SLICING; } //---------------------------------------------------------------------------- @@ -241,20 +242,18 @@ bool vvSlicerManager::SetImages(std::vector filenames, vvImageReade //---------------------------------------------------------------------------- -bool vvSlicerManager::SetOverlay(std::string filename,int dim, std::string component) +bool vvSlicerManager::SetOverlay(std::vector filenames,int dim, std::string component, vvImageReader::LoadedImageType type) { - mOverlayName = filename; + mOverlayName = filenames[0]; mOverlayComponent = component; if (dim > mImage->GetNumberOfDimensions()) { - mLastError = " Overlay dimension cannot be greater then reference image!"; + mLastError = " Overlay dimension cannot be greater than reference image!"; return false; } if (mOverlayReader.IsNull()) mOverlayReader = vvImageReader::New(); - std::vector filenames; - filenames.push_back(filename); mOverlayReader->SetInputFilenames(filenames); - mOverlayReader->Update(mImage->GetNumberOfDimensions(),component.c_str(),mType); + mOverlayReader->Update(type); if (mOverlayReader->GetLastError().size() == 0) { for ( unsigned int i = 0; i < mSlicers.size(); i++) { mSlicers[i]->SetOverlay(mOverlayReader->GetOutput()); @@ -426,6 +425,13 @@ void vvSlicerManager::SetSliceOrientation(int slicer, int orientation) } //---------------------------------------------------------------------------- +//---------------------------------------------------------------------------- +int vvSlicerManager::GetTSlice() +{ + return mSlicers[0]->GetTSlice(); +} +//---------------------------------------------------------------------------- + //---------------------------------------------------------------------------- void vvSlicerManager::SetTSlice(int slice) { @@ -436,9 +442,9 @@ void vvSlicerManager::SetTSlice(int slice) if (mLandmarks) mLandmarks->SetTime(slice); for ( unsigned int i = 0; i < mSlicers.size(); i++) { - if (slice != mSlicers[i]->GetTSlice()) { + if (slice != mSlicers[i]->GetMaxCurrentTSlice()) { mSlicers[i]->SetTSlice(slice); - UpdateTSlice(i); + UpdateTSlice(i); } } } @@ -448,7 +454,7 @@ void vvSlicerManager::SetTSlice(int slice) //---------------------------------------------------------------------------- void vvSlicerManager::SetNextTSlice(int originating_slicer) { - int t = mSlicers[0]->GetTSlice(); + int t = mSlicers[0]->GetMaxCurrentTSlice(); t++; if (t > mSlicers[0]->GetTMax()) t = 0; @@ -461,7 +467,7 @@ void vvSlicerManager::SetNextTSlice(int originating_slicer) //---------------------------------------------------------------------------- void vvSlicerManager::SetPreviousTSlice(int originating_slicer) { - int t = mSlicers[0]->GetTSlice(); + int t = mSlicers[0]->GetMaxCurrentTSlice(); t--; if (t < 0) t = mSlicers[0]->GetTMax(); @@ -496,9 +502,17 @@ void vvSlicerManager::SetTSliceInSlicer(int tslice, int slicer) if (mLandmarks) mLandmarks->SetTime(tslice); - if (mSlicers[slicer]->GetTSlice() == tslice) return; + 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); } //---------------------------------------------------------------------------- @@ -570,36 +584,42 @@ void vvSlicerManager::SetOpacity(int i, double factor) //---------------------------------------------------------------------------- void vvSlicerManager::UpdateViews(int current,int slicer) { - double x = (mSlicers[slicer]->GetCurrentPosition()[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0]) + 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 = (mSlicers[slicer]->GetCurrentPosition()[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1]) + double y = (pt[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1]) /mSlicers[slicer]->GetInput()->GetSpacing()[1]; - double z = (mSlicers[slicer]->GetCurrentPosition()[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2]) + double z = (pt[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2]) /mSlicers[slicer]->GetInput()->GetSpacing()[2]; - 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]) { + 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); switch (mSlicers[slicer]->GetSliceOrientation()) { case vtkImageViewer2::SLICE_ORIENTATION_XY: - if (mSlicers[slicer]->GetSlice() != (int)floor(z)) - mSlicers[slicer]->SetSlice((int)floor(z)); + if (mSlicers[slicer]->GetSlice() != (int)lrint(z)) + mSlicers[slicer]->SetSlice((int)lrint(z)); break; case vtkImageViewer2::SLICE_ORIENTATION_XZ: - if (mSlicers[slicer]->GetSlice() != (int)floor(y)) - mSlicers[slicer]->SetSlice((int)floor(y)); + if (mSlicers[slicer]->GetSlice() != (int)lrint(y)) + mSlicers[slicer]->SetSlice((int)lrint(y)); break; case vtkImageViewer2::SLICE_ORIENTATION_YZ: - if (mSlicers[slicer]->GetSlice() != (int)floor(x)) - mSlicers[slicer]->SetSlice((int)floor(x)); + if (mSlicers[slicer]->GetSlice() != (int)lrint(x)) + mSlicers[slicer]->SetSlice((int)lrint(x)); break; } mSlicers[slicer]->Render(); @@ -609,14 +629,11 @@ void vvSlicerManager::UpdateViews(int current,int slicer) && mSlicers[i]->GetRenderer()->GetDraw() && mSlicers[i]->GetRenderWindow()->GetSize()[0] > 2 && mSlicers[i]->GetRenderWindow()->GetSize()[1] > 2) { - mSlicers[i]->SetCurrentPosition(mSlicers[slicer]->GetCurrentPosition()[0], - mSlicers[slicer]->GetCurrentPosition()[1], - mSlicers[slicer]->GetCurrentPosition()[2], - mSlicers[slicer]->GetTSlice()); + 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]->GetTSlice()); + -VTK_DOUBLE_MAX, mSlicers[slicer]->GetMaxCurrentTSlice()); mSlicers[i]->SetCursorColor(255,10,212); } else { mSlicers[i]->SetCursorColor(150,10,282); @@ -652,23 +669,23 @@ void vvSlicerManager::UpdateViews(int current,int slicer) //---------------------------------------------------------------------------- void vvSlicerManager::UpdateLinked(int slicer) { - double x = (mSlicers[slicer]->GetCurrentPosition()[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0]) - /mSlicers[slicer]->GetInput()->GetSpacing()[0]; - double y = (mSlicers[slicer]->GetCurrentPosition()[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1]) - /mSlicers[slicer]->GetInput()->GetSpacing()[1]; - double z = (mSlicers[slicer]->GetCurrentPosition()[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2]) - /mSlicers[slicer]->GetInput()->GetSpacing()[2]; - - 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]) { + 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::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++) { - emit UpdateLinkManager(*i, slicer,mSlicers[slicer]->GetCurrentPosition()[0], - mSlicers[slicer]->GetCurrentPosition()[1], - mSlicers[slicer]->GetCurrentPosition()[2],mSlicers[slicer]->GetTSlice()); + emit UpdateLinkManager(*i, slicer, p[0], p[1], p[2], mSlicers[slicer]->GetMaxCurrentTSlice()); } } } @@ -678,10 +695,16 @@ void vvSlicerManager::UpdateLinked(int slicer) void vvSlicerManager::UpdateLinkedNavigation(vvSlicer *refSlicer, bool bPropagate) { vtkCamera *refCam = refSlicer->GetRenderer()->GetActiveCamera(); - double refPosition[3], refFocal[3]; + + double refPosition[3]; refCam->GetPosition(refPosition); - refCam->GetFocalPoint(refFocal); - + 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()); @@ -690,49 +713,16 @@ void vvSlicerManager::UpdateLinkedNavigation(vvSlicer *refSlicer, bool bPropagat camera->GetPosition(position); camera->GetFocalPoint(focal); - if(refSlicer->GetSliceOrientation()==mSlicers[i]->GetSliceOrientation()) { - for(int i=0; i<3; i++) { - position[i] = refPosition[i]; - focal[i] = refFocal[i]; - } - } - - if(refSlicer->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XY) { - if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XZ) { - position[0] = refPosition[0]; - focal[0] = refFocal[0]; - } - if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_YZ) { - position[1] = refPosition[1]; - focal[1] = refFocal[1]; - } - } - - if(refSlicer->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XZ) { - if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_YZ) { - position[2] = refPosition[2]; - focal[2] = refFocal[2]; - } - if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XY) { - position[0] = refPosition[0]; - focal[0] = refFocal[0]; - } - } - - if(refSlicer->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_YZ) { - if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XY) { - position[1] = refPosition[1]; - focal[1] = refFocal[1]; - } - if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XZ) { - position[2] = refPosition[2]; - focal[2] = refFocal[2]; + 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(); } @@ -794,13 +784,17 @@ bool vvSlicerManager::GetLinkOverlayWindowLevel() const void vvSlicerManager::ResetTransformationToIdentity(const std::string actorType) { if(actorType == "image") - this->GetImage()->GetTransform()->Identity(); + for(unsigned int i=0; iGetImage()->GetTransform().size(); i++) + this->GetImage()->GetTransform()[i]->Identity(); else if(actorType == "overlay") - this->GetSlicer(0)->GetOverlay()->GetTransform()->Identity(); + for(unsigned int i=0; iGetImage()->GetTransform().size(); i++) + this->GetSlicer(0)->GetOverlay()->GetTransform()[i]->Identity(); else if(actorType == "fusion") - this->GetSlicer(0)->GetFusion()->GetTransform()->Identity(); + for(unsigned int i=0; iGetImage()->GetTransform().size(); i++) + this->GetSlicer(0)->GetFusion()->GetTransform()[i]->Identity(); else if(actorType == "vf") - this->GetVF()->GetTransform()->Identity(); + for(unsigned int i=0; iGetImage()->GetTransform().size(); i++) + this->GetVF()->GetTransform()[i]->Identity(); else return; @@ -946,7 +940,7 @@ void vvSlicerManager::UpdateInfoOnCursorPosition(int slicer) if (mSlicers[slicer]->GetVFActor() ) { displayVec = 1; - unsigned int currentTime = mSlicers[slicer]->GetTSlice(); + unsigned int currentTime = mSlicers[slicer]->GetMaxCurrentTSlice(); vtkImageData *vf = NULL; if (mSlicers[slicer]->GetVF()->GetVTKImages().size() > currentTime) @@ -1033,7 +1027,7 @@ void vvSlicerManager::UpdateSlice(int slicer) void vvSlicerManager::UpdateTSlice(int slicer) { int slice = mSlicers[slicer]->GetSlice(); - int tslice = mSlicers[slicer]->GetTSlice(); + int tslice = mSlicers[slicer]->GetMaxCurrentTSlice(); if (mPreviousSlice[slicer] == slice) { if (mPreviousTSlice[slicer] == tslice) { // DD("************** NOTHING ***********"); @@ -1057,6 +1051,41 @@ void vvSlicerManager::UpdateSliceRange(int slicer) } //---------------------------------------------------------------------------- +//---------------------------------------------------------------------------- +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) @@ -1116,19 +1145,20 @@ void vvSlicerManager::SetPreset(int preset) void vvSlicerManager::SetLocalColorWindowing(const int slicer, const bool bCtrlKey) { double min, max; - int t = this->mSlicers[slicer]->GetTSlice(); 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]->GetFusion()->GetTransform()); + 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]->GetOverlay()->GetTransform()); + this->mSlicers[slicer]->GetConcatenatedOverlayTransform()); if(this->mSlicers[slicer]->GetLinkOverlayWindowLevel()){ this->SetColorWindow(max-min); this->SetColorLevel(0.5*(min+max)); @@ -1138,9 +1168,10 @@ void vvSlicerManager::SetLocalColorWindowing(const int slicer, const bool bCtrlK } } else { + int t = this->GetTSlice(); this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max, this->mSlicers[slicer]->GetImage()->GetVTKImages()[t], - this->mSlicers[slicer]->GetImage()->GetTransform()); + this->mSlicers[slicer]->GetConcatenatedTransform()); this->SetColorWindow(max-min); this->SetColorLevel(0.5*(min+max)); this->SetPreset(6); @@ -1319,12 +1350,12 @@ 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] && - x_index <= mSlicers[0]->GetInput()->GetWholeExtent()[1] && - y_index >= mSlicers[0]->GetInput()->GetWholeExtent()[2] && - y_index <= mSlicers[0]->GetInput()->GetWholeExtent()[3] && - z_index >= mSlicers[0]->GetInput()->GetWholeExtent()[4] && - z_index <= mSlicers[0]->GetInput()->GetWholeExtent()[5]) { + 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(); diff --git a/vv/vvSlicerManager.h b/vv/vvSlicerManager.h index 9858d69..088df61 100644 --- a/vv/vvSlicerManager.h +++ b/vv/vvSlicerManager.h @@ -52,6 +52,7 @@ class vvSlicerManager : public QObject { Q_OBJECT public: + typedef enum {WORLD_SLICING, VOXELS_SLICING} SlicingPresetType; vvSlicerManager(int numberOfSlicers); ~vvSlicerManager(); @@ -63,7 +64,7 @@ class vvSlicerManager : public QObject { void SetImage(vvImage::Pointer image); bool SetImages(std::vector filenames, vvImageReader::LoadedImageType type, int n=0); - bool SetOverlay(std::string filename, int dim, std::string component); + bool SetOverlay(std::vector filenames, int dim, std::string component, vvImageReader::LoadedImageType type); bool SetFusion(std::string filename, int dim, std::string component); ///Set a VF by loading it from the disk bool SetVF(std::string filename); @@ -103,6 +104,7 @@ class vvSlicerManager : public QObject { void SetFilename(std::string f, int number=0); void SetSliceOrientation(int slicer, int orientation); + int GetTSlice(); void SetTSlice(int slice); void SetNextTSlice(int originating_slicer); void SetPreviousTSlice(int originating_slicer); @@ -151,6 +153,9 @@ class vvSlicerManager : public QObject { int GetPreset() { return mPreset; } + SlicingPresetType GetSlicingPreset() { + return mSlicingPreset; + } int GetOverlayColor() const { return mOverlayColor; } @@ -203,6 +208,7 @@ class vvSlicerManager : public QObject { void UpdateSlice(int slicer); void UpdateTSlice(int slicer); void UpdateSliceRange(int slicer); + void SetSlicingPreset(SlicingPresetType preset); vvLandmarks *GetLandmarks(); void AddLandmark(float x,float y,float z,float t); @@ -251,6 +257,7 @@ protected: bool mFusionShowLegend; int mPreset; + SlicingPresetType mSlicingPreset; vvImageReader::LoadedImageType mType; std::string mVFComponent; std::string mOverlayComponent; diff --git a/vv/vvSlicerManagerCommand.cxx b/vv/vvSlicerManagerCommand.cxx index 1b71033..73a0ab5 100644 --- a/vv/vvSlicerManagerCommand.cxx +++ b/vv/vvSlicerManagerCommand.cxx @@ -271,7 +271,7 @@ void vvSlicerManagerCommand::Execute(vtkObject *caller, //All type of mouse events if (event == vtkCommand::LeaveEvent) { this->SM->GetSlicer(VisibleInWindow)->SetCurrentPosition(-VTK_DOUBLE_MAX,-VTK_DOUBLE_MAX, - -VTK_DOUBLE_MAX,this->SM->GetSlicer(VisibleInWindow)->GetTSlice()); + -VTK_DOUBLE_MAX,this->SM->GetSlicer(VisibleInWindow)->GetMaxCurrentTSlice()); this->SM->GetSlicer(VisibleInWindow)->Render(); return; } @@ -362,8 +362,13 @@ void vvSlicerManagerCommand::Execute(vtkObject *caller, zWorld = z; break; } - this->SM->GetSlicer(VisibleInWindow)->SetCurrentPosition(xWorld,yWorld,zWorld, - this->SM->GetSlicer(VisibleInWindow)->GetTSlice()); + + double p[3]; p[0] = xWorld; p[1] = yWorld; p[2] = zWorld; + double pt[3]; + this->SM->GetSlicer(VisibleInWindow)->GetSlicingTransform()->TransformPoint(p, pt); + + this->SM->GetSlicer(VisibleInWindow)->SetCurrentPosition(pt[0],pt[1],pt[2], + this->SM->GetSlicer(VisibleInWindow)->GetMaxCurrentTSlice()); if (newLandmark) { this->SM->AddLandmark(xWorld,yWorld,zWorld, this->SM->GetSlicer(VisibleInWindow)->GetTSlice()); diff --git a/vv/vvToolRigidReg.cxx b/vv/vvToolRigidReg.cxx index 28591ba..508551d 100644 --- a/vv/vvToolRigidReg.cxx +++ b/vv/vvToolRigidReg.cxx @@ -118,7 +118,8 @@ void vvToolRigidReg::InputIsSelected(vvSlicerManager *input) //backup original matrix for(int j=0; j<4; j++) for(int i=0; i<4; i++) - mInitialMatrix->SetElement(i,j, mCurrentSlicerManager->GetImage()->GetTransform()->GetMatrix()->GetElement(i,j)); + // TODO SR and BP: check on the list of transforms and not the first only + mInitialMatrix->SetElement(i,j, mCurrentSlicerManager->GetImage()->GetTransform()[0]->GetMatrix()->GetElement(i,j)); QString origTransformString = dynamic_cast(mMainWindow)->Get4x4MatrixDoubleAsString(mInitialMatrix); transformationLabel->setText(origTransformString); SetTransform(mInitialMatrix); @@ -242,7 +243,8 @@ void vvToolRigidReg::SpinBoxChange(double newVal) } // Compute transform and set - vtkSmartPointer transform_final=mInput->GetImage()->GetTransform(); + // TODO SR and BP: check on the list of transforms and not the first only + vtkSmartPointer transform_final=mInput->GetImage()->GetTransform()[0]; transform_final->Identity(); transform_final->PostMultiply(); @@ -294,7 +296,8 @@ void vvToolRigidReg::SaveFile() QFile file(filename); if (file.open(QFile::WriteOnly | QFile::Truncate)) { - vtkMatrix4x4* matrix = mCurrentSlicerManager->GetImage()->GetTransform()->GetMatrix(); + // TODO SR and BP: check on the list of transforms and not the first only + vtkMatrix4x4* matrix = mCurrentSlicerManager->GetImage()->GetTransform()[0]->GetMatrix(); QString matrixStr = dynamic_cast(mMainWindow)->Get4x4MatrixDoubleAsString(matrix,16); QTextStream out(&file); out << matrixStr; @@ -332,7 +335,8 @@ void vvToolRigidReg::LoadFile() //------------------------------------------------------------------------------ void vvToolRigidReg::ChangeOfRotationCenter() { - SetTransform(mCurrentSlicerManager->GetImage()->GetTransform()->GetMatrix()); + // TODO SR and BP: check on the list of transforms and not the first only + SetTransform(mCurrentSlicerManager->GetImage()->GetTransform()[0]->GetMatrix()); } //------------------------------------------------------------------------------ @@ -347,7 +351,8 @@ void vvToolRigidReg::ResetTransform() void vvToolRigidReg::SetTransform(vtkMatrix4x4 *matrix) { vtkSmartPointer transform=vtkSmartPointer::New(); - mCurrentSlicerManager->GetImage()->GetTransform()->SetMatrix(matrix); + // TODO SR and BP: check on the list of transforms and not the first only + mCurrentSlicerManager->GetImage()->GetTransform()[0]->SetMatrix(matrix); transform->Update(); Render(); dynamic_cast(mMainWindow)->ImageInfoChanged();