Authors belong to:
- University of LYON http://www.universite-lyon.fr/
- - Léon Bérard cancer center http://oncora1.lyon.fnclcc.fr
+ - Léon Bérard cancer center http://www.centreleonberard.fr
- CREATIS CNRS laboratory http://www.creatis.insa-lyon.fr
This software is distributed WITHOUT ANY WARRANTY; without even
- BSD See included LICENSE.txt file
- CeCILL-B http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
-======================================================================-====*/
+===========================================================================**/
#include <algorithm>
#include <QMessageBox>
#include <QInputDialog>
#include <QTimer>
#include "QTreePushButton.h"
+#include <QUrl>
+#include <QSettings>
// VV include
#include "vvMainWindow.h"
#include "vvHelpDialog.h"
+#include "vvRegisterForm.h"
#include "vvDocumentation.h"
#include "vvProgressDialog.h"
#include "vvQDicomSeriesSelector.h"
#include "vvDeformationDialog.h"
#include "vvImageWarp.h"
#include "vvUtils.h"
-#include "vvMaximumIntensityProjection.h"
#include "vvMidPosition.h"
#include "vvMesh.h"
#include "vvStructSelector.h"
#include "vvMeshReader.h"
-#include "vvConstants.h"
#include "clitkConfiguration.h"
// ITK include
-#include "itkImage.h"
-#include "itkImageFileReader.h"
-#include "itkByteSwapper.h"
-#include "itkCommand.h"
-#include "itkNumericSeriesFileNames.h"
+#include <itkImage.h>
+#include <itkImageFileReader.h>
+#include <itkByteSwapper.h>
+#include <itkCommand.h>
+#include <itkNumericSeriesFileNames.h>
// VTK include
-#include "vtkImageData.h"
-#include "vtkImageActor.h"
-#include "vtkCornerAnnotation.h"
-#include "vtkRenderWindow.h"
-#include "vtkRenderWindowInteractor.h"
-#include "vtkRenderer.h"
-#include "vtkRendererCollection.h"
-#include "vtkWindowToImageFilter.h"
-#include "vtkBMPWriter.h"
-#include "vtkTIFFWriter.h"
-#include "vtkPNMWriter.h"
-#include "vtkPNGWriter.h"
-#include "vtkJPEGWriter.h"
-#include "vtkMatrix4x4.h"
-#include "vtkTransform.h"
+#include <vtkImageData.h>
+#include <vtkImageActor.h>
+#include <vtkCornerAnnotation.h>
+#include <vtkRenderWindow.h>
+#include <vtkRenderWindowInteractor.h>
+#include <vtkRenderer.h>
+#include <vtkRendererCollection.h>
+#include <vtkWindowToImageFilter.h>
+#include <vtkBMPWriter.h>
+#include <vtkTIFFWriter.h>
+#include <vtkPNMWriter.h>
+#include <vtkPNGWriter.h>
+#include <vtkJPEGWriter.h>
+#ifdef VTK_USE_FFMPEG_ENCODER
+# include <vtkFFMPEGWriter.h>
+#endif
+#ifdef VTK_USE_MPEG2_ENCODER
+# include <vtkMPEG2Writer.h>
+#endif
+#include <vtkMatrix4x4.h>
+#include <vtkTransform.h>
// Standard includes
#include <iostream>
#define COLUMN_RELOAD_IMAGE 6
#define COLUMN_IMAGE_NAME 7
-#define EXTENSIONS "Images ( *.bmp *.png *.jpeg *.jpg *.tif *.mhd *.hdr *.vox *.his *.xdr *.SCAN )"
+#define EXTENSIONS "Images ( *.bmp *.png *.jpeg *.jpg *.tif *.mhd *.mha *.hdr *.vox *.his *.xdr *.SCAN )"
/*Data Tree values
0,Qt::UserRole full filename
mMainWidget = this;
mCurrentTime = -1;
mCurrentSelectedImageId = "";
+ mCurrentPickedImageId = "";
+ mCurrentPickedImageIndex = 0;
//Init the contextMenu
this->setContextMenuPolicy(Qt::CustomContextMenu);
connect(SEHorizontalSlider,SIGNAL(valueChanged(int)),this,SLOT(SEHorizontalSliderMoved()));
//connect everything
- connect(actionMaximum_Intensity_Projection,SIGNAL(triggered()),this,SLOT(ComputeMIP()));
connect(actionCompute_mid_position_image,SIGNAL(triggered()),this,SLOT(ComputeMidPosition()));
connect(actionDeformable_Registration,SIGNAL(triggered()),this,SLOT(ComputeDeformableRegistration()));
connect(actionWarp_image_with_vector_field,SIGNAL(triggered()),this,SLOT(WarpImage()));
connect(actionAdd_VF_to_current_Image,SIGNAL(triggered()),this,SLOT(OpenField()));
connect(actionNavigation_Help,SIGNAL(triggered()),this,SLOT(ShowHelpDialog()));
connect(actionDocumentation,SIGNAL(triggered()),this,SLOT(ShowDocumentation()));
+ connect(actionRegister_vv,SIGNAL(triggered()),this,SLOT(PopupRegisterForm()));
///////////////////////////////////////////////
connect(actionSegmentation,SIGNAL(triggered()),this,SLOT(SegmentationOnCurrentImage()));
//Recently opened files
std::list<std::string> recent_files = GetRecentlyOpenedImages();
+ recentlyOpenedFilesMenu=NULL;
if ( !recent_files.empty() ) {
- QMenu * rmenu = new QMenu("Recently opened files...");
- rmenu->setIcon(QIcon(QString::fromUtf8(":/common/icons/open.png")));
- menuFile->insertMenu(actionOpen_Image_With_Time,rmenu);
- menuFile->insertSeparator(actionOpen_Image_With_Time);
- for (std::list<std::string>::iterator i = recent_files.begin(); i!=recent_files.end(); i++) {
- QAction* current=new QAction(QIcon(QString::fromUtf8(":/common/icons/open.png")),
- (*i).c_str(),this);
- rmenu->addAction(current);
- connect(current,SIGNAL(triggered()),this,SLOT(OpenRecentImage()));
- }
+ createRecentlyOpenedFilesMenu();
+ updateRecentlyOpenedFilesMenu(recent_files);
}
// Adding all new tools (insertion in the menu)
vvToolManager::GetInstance()->InsertToolsInMenu(this);
+ vvToolManager::GetInstance()->EnableToolsInMenu(this, false);
if (!CLITK_EXPERIMENTAL)
menuExperimental->menuAction()->setVisible(false);
timerMemory->start(2000);
}
//------------------------------------------------------------------------------
-
-
+void vvMainWindow::show()
+{
+ vvMainWindowBase::show();
+ PopupRegisterForm(true);
+}
//------------------------------------------------------------------------------
void vvMainWindow::UpdateMemoryUsage()
{
//------------------------------------------------------------------------------
-void vvMainWindow::ComputeMIP()
+void vvMainWindow::createRecentlyOpenedFilesMenu()
+{
+ recentlyOpenedFilesMenu = new QMenu("Recently opened files...");
+ recentlyOpenedFilesMenu->setIcon(QIcon(QString::fromUtf8(":/common/icons/open.png")));
+ menuFile->insertMenu(actionOpen_Image_With_Time,recentlyOpenedFilesMenu);
+ menuFile->insertSeparator(actionOpen_Image_With_Time);
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+
+void vvMainWindow::updateRecentlyOpenedFilesMenu(const std::list<std::string> &recent_files)
{
- vvMaximumIntensityProjection mip;
- vvSlicerManager* selected_slicer = mSlicerManagers[GetSlicerIndexFromItem(DataTree->selectedItems()[0])];
- QFileInfo info(selected_slicer->GetFileName().c_str());
- mip.Compute(selected_slicer);
- if (!mip.error)
- AddImage(mip.GetOutput(),info.path().toStdString()+"/"+info.completeBaseName().toStdString()+"_mip.mhd");
+ if(recentlyOpenedFilesMenu==NULL) {
+ createRecentlyOpenedFilesMenu();
+ } else {
+ recentlyOpenedFilesMenu->clear();
+ }
+ for (std::list<std::string>::const_iterator i = recent_files.begin(); i!=recent_files.end(); i++) {
+ QAction* current=new QAction(QIcon(QString::fromUtf8(":/common/icons/open.png")), i->c_str(),this);
+ recentlyOpenedFilesMenu->addAction(current);
+ connect(current,SIGNAL(triggered()),this,SLOT(OpenRecentImage()));
+ }
}
//------------------------------------------------------------------------------
}
}
if (vector.size() > 0)
- LoadImages(vector, MERGED);
+ LoadImages(vector, vvImageReader::MERGED);
}
//------------------------------------------------------------------------------
std::vector<std::string> vector;
for (int i = 0; i < files.size(); i++)
vector.push_back(files[i].toStdString());
- LoadImages(vector, SLICED);
+ LoadImages(vector, vvImageReader::SLICED);
}
//------------------------------------------------------------------------------
}
sort(vector.begin(),vector.end());
if (vector.size() > 1)
- LoadImages(vector, MERGEDWITHTIME);
+ LoadImages(vector, vvImageReader::MERGEDWITHTIME);
else
QMessageBox::warning(this,tr("Reading problem"),"You need to select at least two images to merge images with time.\nIf you only want to open one image, please use the \"Open Image\" function.");
}
std::cout << "dicomSeriesSelector " << std::endl;
if (dicomSeriesSelector->exec() == QDialog::Accepted) {
files = *(dicomSeriesSelector->GetFilenames());
- LoadImages(files,DICOM);
+ LoadImages(files, vvImageReader::DICOM);
}
}
//------------------------------------------------------------------------------
std::vector<std::string> vector;
for (int i = 0; i < files.size(); i++)
vector.push_back(files[i].toStdString());
- LoadImages(vector, IMAGE);
+ LoadImages(vector, vvImageReader::IMAGE);
}
//------------------------------------------------------------------------------
void vvMainWindow::OpenRecentImage()
std::vector<std::string> images;
images.push_back(caller->text().toStdString());
mInputPathName = itksys::SystemTools::GetFilenamePath(images[0]).c_str();
- LoadImages(images,IMAGE);
+ LoadImages(images, vvImageReader::IMAGE);
}
//------------------------------------------------------------------------------
for (int i = 0; i < files.size(); i++) {
vector.push_back(files[i].toStdString());
}
- LoadImages(vector, IMAGEWITHTIME);
+ LoadImages(vector, vvImageReader::IMAGEWITHTIME);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-void vvMainWindow::LoadImages(std::vector<std::string> files, LoadedImageType filetype)
+void vvMainWindow::LoadImages(std::vector<std::string> files, vvImageReader::LoadedImageType filetype)
{
//Separate the way to open images and dicoms
int fileSize;
- if (filetype == IMAGE || filetype == IMAGEWITHTIME)
+ if (filetype == vvImageReader::IMAGE || filetype == vvImageReader::IMAGEWITHTIME)
fileSize = files.size();
else
fileSize = 1;
std::vector<unsigned int> nSlices;
nSlices.resize(files.size());
std::fill(nSlices.begin(), nSlices.end(), 1);
- if (filetype == SLICED) {
+ if (filetype == vvImageReader::SLICED) {
for (int i = 0; i < fileSize; i++) {
itk::ImageIOBase::Pointer header = clitk::readImageHeader(files[i]);
QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
nSlices[i] = header->GetDimensions( header->GetNumberOfDimensions()-1 );
}
}
-
+
//Only add to the list of recently opened files when a single file is opened,
//to avoid polluting the list of recently opened files
if (files.size() == 1) {
QFileInfo finfo=tr(files[0].c_str());
AddToRecentlyOpenedImages(finfo.absoluteFilePath().toStdString());
+ updateRecentlyOpenedFilesMenu(GetRecentlyOpenedImages());
}
//init the progress events
QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
// Change filename if an image with the same already exist
int number = GetImageDuplicateFilenameNumber(files[i] + std::string("_slice"));
- if (filetype == IMAGE || filetype == IMAGEWITHTIME || filetype == SLICED)
+ if (filetype == vvImageReader::IMAGE || filetype == vvImageReader::IMAGEWITHTIME || filetype == vvImageReader::SLICED)
SetImageSucceed = imageManager->SetImage(files[i],filetype, number, j);
else {
SetImageSucceed = imageManager->SetImages(files,filetype, number);
}
- if (SetImageSucceed == false) {
+ if (!SetImageSucceed) {
QApplication::restoreOverrideCursor();
QString error = "Cannot open file \n";
error += imageManager->GetLastError().c_str();
item->setData(0,Qt::UserRole,files[i].c_str());
QFileInfo fileinfo(imageManager->GetFileName().c_str()); //Do not show the path
item->setData(COLUMN_IMAGE_NAME,Qt::DisplayRole,fileinfo.fileName());
- item->setToolTip(COLUMN_IMAGE_NAME,fileinfo.absoluteFilePath());
+ item->setData(1,Qt::UserRole,tr("image"));
+ item->setToolTip(COLUMN_IMAGE_NAME, imageManager->GetListOfAbsoluteFilePathInOneString("image").c_str());
qApp->processEvents();
//Create the buttons for reload and close
connect(mSlicerManagers.back(), SIGNAL(currentImageChanged(std::string)),
this,SLOT(CurrentImageChanged(std::string)));
+ connect(mSlicerManagers.back(), SIGNAL(currentPickedImageChanged(std::string)),
+ this, SLOT(CurrentPickedImageChanged(std::string)));
connect(mSlicerManagers.back(), SIGNAL(UpdatePosition(int, double, double, double, double, double, double, double)),
this,SLOT(MousePositionChanged(int,double, double, double, double, double, double, double)));
connect(mSlicerManagers.back(), SIGNAL(UpdateVector(int, double, double, double, double)),
this, SLOT(OverlayChanged(int,double,double)));
connect(mSlicerManagers.back(), SIGNAL(UpdateFusion(int, double)),
this, SLOT(FusionChanged(int,double)));
- connect(mSlicerManagers.back(), SIGNAL(UpdateWindows(int, int, int)),
- this,SLOT(WindowsChanged(int, int, int)));
connect(mSlicerManagers.back(), SIGNAL(WindowLevelChanged(double, double,int, int)),
this,SLOT(WindowLevelChanged(double, double, int, int)));
connect(mSlicerManagers.back(), SIGNAL(UpdateSlice(int,int)),
this,SLOT(UpdateSliceRange(int,int,int,int,int)));
connect(mSlicerManagers.back(), SIGNAL(UpdateLinkManager(std::string,int,double,double,double,int)),
this,SLOT(UpdateLinkManager(std::string,int,double,double,double,int)));
- connect(mSlicerManagers.back(), SIGNAL(UpdateLinkedNavigation(std::string,vvSlicerManager*)),
- this,SLOT(UpdateLinkedNavigation(std::string,vvSlicerManager*)));
+ connect(mSlicerManagers.back(), SIGNAL(UpdateLinkedNavigation(std::string,vvSlicerManager*,vvSlicer*)),
+ this,SLOT(UpdateLinkedNavigation(std::string,vvSlicerManager*,vvSlicer*)));
connect(mSlicerManagers.back(), SIGNAL(ChangeImageWithIndexOffset(vvSlicerManager*,int,int)),
this,SLOT(ChangeImageWithIndexOffset(vvSlicerManager*,int,int)));
connect(mSlicerManagers.back(),SIGNAL(LandmarkAdded()),landmarksPanel,SLOT(AddPoint()));
InitSlicers();
+ numberofsuccesulreads++;
}
- numberofsuccesulreads++;
}
}
if (numberofsuccesulreads) {
}
//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+void vvMainWindow::CurrentPickedImageChanged(std::string id)
+{
+ if (id == mCurrentPickedImageId) return; // Do nothing
+ int selected = 0;
+ for (int i = 0; i < DataTree->topLevelItemCount(); i++) {
+ if (DataTree->topLevelItem(i)->data(COLUMN_IMAGE_NAME,Qt::UserRole).toString().toStdString() == id) {
+ selected = i;
+ } else {
+ DataTree->topLevelItem(i)->setSelected(0);
+ }
+ for (int child = 0; child < DataTree->topLevelItem(i)->childCount(); child++)
+ DataTree->topLevelItem(i)->child(child)->setSelected(0);
+
+ }
+ DataTree->topLevelItem(selected)->setSelected(1);
+ mCurrentPickedImageId = id;
+ mCurrentPickedImageIndex = selected;
+}
+//------------------------------------------------------------------------------
+
//------------------------------------------------------------------------------
void vvMainWindow::ImageInfoChanged()
{
actionNorth_West_Window->setEnabled(1);
actionSouth_East_Window->setEnabled(1);
actionSouth_West_Window->setEnabled(1);
+ vvToolManager::GetInstance()->EnableToolsInMenu(this, true);
inverseButton->setEnabled(1);
goToCursorPushButton->setEnabled(1);
//read image header
int NPixel = 1;
+ vvImage::Pointer imageSelected;
if (DataTree->topLevelItem(index) == DataTree->selectedItems()[0]) {
- vvImage::Pointer imageSelected = mSlicerManagers[index]->GetSlicer(0)->GetImage();
- dimension = imageSelected->GetNumberOfDimensions();
- origin.resize(dimension);
- inputSpacing.resize(dimension);
- inputSize.resize(dimension);
- sizeMM.resize(dimension);
- pixelType = mSlicerManagers[index]->GetImage()->GetScalarTypeAsITKString().c_str();
- for (int i = 0; i < dimension; i++) {
- origin[i] = imageSelected->GetOrigin()[i];
- inputSpacing[i] = imageSelected->GetSpacing()[i];
- inputSize[i] = imageSelected->GetSize()[i];
- sizeMM[i] = inputSize[i]*inputSpacing[i];
- NPixel *= inputSize[i];
- }
- transformation = imageSelected->GetTransform()->GetMatrix();
- inputSizeInBytes = GetSizeInBytes(imageSelected->GetActualMemorySize()*1000);
+ imageSelected = mSlicerManagers[index]->GetSlicer(0)->GetImage();
} else if (DataTree->selectedItems()[0]->data(1,Qt::UserRole).toString() == "vector") {
- vvImage::Pointer imageSelected = mSlicerManagers[index]->GetSlicer(0)->GetVF();
- dimension = imageSelected->GetNumberOfDimensions();
- origin.resize(dimension);
- inputSpacing.resize(dimension);
- inputSize.resize(dimension);
- sizeMM.resize(dimension);
- pixelType = mSlicerManagers[index]->GetVF()->GetScalarTypeAsITKString().c_str();
- for (int i = 0; i < dimension; i++) {
- origin[i] = imageSelected->GetOrigin()[i];
- inputSpacing[i] = imageSelected->GetSpacing()[i];
- inputSize[i] = imageSelected->GetSize()[i];
- sizeMM[i] = inputSize[i]*inputSpacing[i];
- NPixel *= inputSize[i];
- }
- inputSizeInBytes = GetSizeInBytes(imageSelected->GetActualMemorySize()*1000);
+ imageSelected = mSlicerManagers[index]->GetSlicer(0)->GetVF();
} else if (DataTree->selectedItems()[0]->data(1,Qt::UserRole).toString() == "overlay") {
- vvImage::Pointer imageSelected = mSlicerManagers[index]->GetSlicer(0)->GetOverlay();
- dimension = imageSelected->GetNumberOfDimensions();
- origin.resize(dimension);
- inputSpacing.resize(dimension);
- inputSize.resize(dimension);
- sizeMM.resize(dimension);
- pixelType = mSlicerManagers[index]->GetImage()->GetScalarTypeAsITKString().c_str();
- for (int i = 0; i < dimension; i++) {
- origin[i] = imageSelected->GetOrigin()[i];
- inputSpacing[i] = imageSelected->GetSpacing()[i];
- inputSize[i] = imageSelected->GetSize()[i];
- sizeMM[i] = inputSize[i]*inputSpacing[i];
- NPixel *= inputSize[i];
- }
- inputSizeInBytes = GetSizeInBytes(imageSelected->GetActualMemorySize()*1000);
+ imageSelected = mSlicerManagers[index]->GetSlicer(0)->GetOverlay();
} else if (DataTree->selectedItems()[0]->data(1,Qt::UserRole).toString() == "fusion") {
- vvImage::Pointer imageSelected = mSlicerManagers[index]->GetSlicer(0)->GetFusion();
- dimension = imageSelected->GetNumberOfDimensions();
- origin.resize(dimension);
- inputSpacing.resize(dimension);
- inputSize.resize(dimension);
- sizeMM.resize(dimension);
- pixelType = mSlicerManagers[index]->GetImage()->GetScalarTypeAsITKString().c_str();
- for (int i = 0; i < dimension; i++) {
- origin[i] = imageSelected->GetOrigin()[i];
- inputSpacing[i] = imageSelected->GetSpacing()[i];
- inputSize[i] = imageSelected->GetSize()[i];
- sizeMM[i] = inputSize[i]*inputSpacing[i];
- NPixel *= inputSize[i];
- }
- inputSizeInBytes = GetSizeInBytes(imageSelected->GetActualMemorySize()*1000);
+ imageSelected = mSlicerManagers[index]->GetSlicer(0)->GetFusion();
+ }
+ else if (DataTree->selectedItems()[0]->data(1,Qt::UserRole).toString() == "contour") {
+ imageSelected = mSlicerManagers[index]->GetSlicer(0)->GetImage();
+ }
+ else {
+ imageSelected = mSlicerManagers[index]->GetSlicer(0)->GetImage();
}
+ dimension = imageSelected->GetNumberOfDimensions();
+ origin.resize(dimension);
+ inputSpacing.resize(dimension);
+ inputSize.resize(dimension);
+ sizeMM.resize(dimension);
+ pixelType = mSlicerManagers[index]->GetImage()->GetScalarTypeAsITKString().c_str();
+ for (int i = 0; i < dimension; i++) {
+ origin[i] = imageSelected->GetOrigin()[i];
+ inputSpacing[i] = imageSelected->GetSpacing()[i];
+ inputSize[i] = imageSelected->GetSize()[i];
+ sizeMM[i] = inputSize[i]*inputSpacing[i];
+ NPixel *= inputSize[i];
+ }
+ inputSizeInBytes = GetSizeInBytes(imageSelected->GetActualMemorySize()*1000);
+
QString dim = QString::number(dimension) + " (";
dim += pixelType + ")";
infoPanel->setOrigin(GetVectorDoubleAsString(origin));
infoPanel->setSpacing(GetVectorDoubleAsString(inputSpacing));
infoPanel->setNPixel(QString::number(NPixel)+" ("+inputSizeInBytes+")");
+ transformation = imageSelected->GetTransform()->GetMatrix();
infoPanel->setTransformation(Get4x4MatrixDoubleAsString(transformation));
landmarksPanel->SetCurrentLandmarks(mSlicerManagers[index]->GetLandmarks(),
{
documentation->show();
}
+//------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+void vvMainWindow::PopupRegisterForm(bool checkCanPush)
+{
+ vvRegisterForm* registerForm = new vvRegisterForm(QUrl("http://www.creatis.insa-lyon.fr/~dsarrut/vvregister/write.php"), getVVSettingsPath(), getSettingsOptionFormat());
+ if(!checkCanPush) {
+ registerForm->show();
+ } else {
+ if(registerForm->canPush()) {
+ registerForm->show();
+ registerForm->acquitPushed();//too bad if there is not internet connection anymore.
+ }
+ }
+}
+//------------------------------------------------------------------------------
+
//------------------------------------------------------------------------------
void vvMainWindow::ShowHelpDialog()
{
//------------------------------------------------------------------------------
void vvMainWindow::ChangeViewMode()
{
- QListIterator<int> it0(splitter_3->sizes());
- QListIterator<int> it1(splitter_3->sizes());
- int max0 = 0;
- int max1 = 1;
- while (it0.hasNext()) {
- max0 += it0.next();
- }
- while (it1.hasNext()) {
- max1 += it1.next();
- }
- QList<int> size0;
- QList<int> size1;
+ QList<int> size;
if (viewMode == 1) {
viewMode = 0;
- size0.push_back(max0);
- size0.push_back(0);
- size1.push_back(max1);
- size1.push_back(0);
- splitter_3->setSizes(size0);
- OSplitter->setSizes(size1);
+ 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);
} else {
viewMode = 1;
- size0.push_back(int(max0/2));
- size0.push_back(int(max0/2));
- size1.push_back(int(max1/2));
- size1.push_back(int(max1/2));
- splitter_3->setSizes(size0);
- OSplitter->setSizes(size1);
+ 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);
}
+ UpdateRenderWindows();
+ /*
+ ** I don't know why but for both resized QVTKWidget we also need to render
+ ** the associated Slicer to redraw crosses.
+ */
+ for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
+ if (DataTree->topLevelItem(i)->data(COLUMN_UL_VIEW,Qt::CheckStateRole).toInt() > 1)
+ mSlicerManagers[i]->GetSlicer(0)->Render();
+ if (DataTree->topLevelItem(i)->data(COLUMN_DL_VIEW,Qt::CheckStateRole).toInt() > 1)
+ mSlicerManagers[i]->GetSlicer(2)->Render();
+ }
}
//------------------------------------------------------------------------------
QString vvMainWindow::Get4x4MatrixDoubleAsString(vtkSmartPointer<vtkMatrix4x4> matrix)
{
std::ostringstream strmatrix;
-
+
for (unsigned int i = 0; i < 4; i++) {
for (unsigned int j = 0; j < 4; j++) {
strmatrix.flags(ios::showpos);
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-void vvMainWindow::DisplayChanged(QTreeWidgetItem *clicked_item, int column)
+void vvMainWindow::DisplayChanged(QTreeWidgetItem *clickedItem, int column)
{
- int index = GetSlicerIndexFromItem(clicked_item);
if ( column >= COLUMN_CLOSE_IMAGE || column <= 0)
return;
+
+ // Get parent information (might be the same item)
+ int slicerManagerIndex = GetSlicerIndexFromItem(clickedItem);
+ QTreeWidgetItem* clickedParentItem = DataTree->topLevelItem(slicerManagerIndex);
+ vvSlicer* clickedSlicer = mSlicerManagers[slicerManagerIndex]->GetSlicer(column-1);
+
+ // Go over the complete item tree (only 2 levels, parents and children)
for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
- //Trick to avoid redoing twice the job for a key (sr)
- mSlicerManagers[i]->GetSlicer(column-1)->GetRenderWindow()-> GetInteractor()->SetKeySym("Crap");
-
- QTreeWidgetItem* current_row=DataTree->topLevelItem(i);
- if (DataTree->topLevelItem(index) == current_row) {
- vvSlicer* clicked_slicer=mSlicerManagers[i]->GetSlicer(column-1);
- if (current_row == clicked_item) {
- //If we just activated a slicer
- if (current_row->data(column,Qt::CheckStateRole).toInt() > 0) {
- mSlicerManagers[i]->UpdateSlicer(column-1,clicked_item->data(column,Qt::CheckStateRole).toInt());
- mSlicerManagers[i]->UpdateInfoOnCursorPosition(column-1);
- DisplaySliders(i,column-1);
- std::map<std::string,int> overlay_counts;
- for (int child = 0; child < current_row->childCount(); child++) {
- std::string overlay_type =
- current_row->child(child)->data(1,Qt::UserRole).toString().toStdString();
- overlay_counts[overlay_type]++;
- current_row->child(child)->setData(column,Qt::CheckStateRole,
- current_row->data(column,Qt::CheckStateRole));
- clicked_slicer->SetActorVisibility(overlay_type,overlay_counts[overlay_type]-1,true);
- }
- } else { //We don't allow simply desactivating a slicer
- clicked_item->setData(column,Qt::CheckStateRole,2);
- return;
- }
+ // Trick to avoid redoing twice the job for a key (sr)
+ mSlicerManagers[i]->GetSlicer(column-1)->GetRenderWindow()->GetInteractor()->SetKeySym("Crap");
+
+ QTreeWidgetItem* currentParentItem = DataTree->topLevelItem(i);
+ if(currentParentItem != clickedParentItem) {
+ // Not the branch of the clicked item, uncheck all
+
+ // Parent
+ currentParentItem->setData(column,Qt::CheckStateRole, 0);
+ mSlicerManagers[i]->UpdateSlicer(column-1, false);
+
+ // Children
+ for (int iChild = 0; iChild < currentParentItem->childCount(); iChild++) {
+ currentParentItem->child(iChild)->setData(column,Qt::CheckStateRole, 0);
}
- //if we clicked on the vector(or overlay) and not the image
- else {
- if (clicked_item->data(column,Qt::CheckStateRole).toInt()) {
- current_row->setData(column,Qt::CheckStateRole,2);
- mSlicerManagers[i]->UpdateSlicer(column-1,2);
- mSlicerManagers[i]->UpdateInfoOnCursorPosition(column-1);
- DisplaySliders(i,column-1);
- }
- int vis = clicked_item->data(column,Qt::CheckStateRole).toInt();
- std::string overlay_type = clicked_item->data(1,Qt::UserRole).toString().toStdString();
- int overlay_index=0;
- for (int child = 0; child < current_row->childCount(); child++) {
- if (current_row->child(child)->data(1,Qt::UserRole).toString().toStdString() == overlay_type)
- overlay_index++;
- if (current_row->child(child) == clicked_item) break;
- }
- clicked_slicer->SetActorVisibility(
- clicked_item->data(1,Qt::UserRole).toString().toStdString(), overlay_index-1,vis);
+ }
+ else {
+ // Branch of the clicked one: get check status from actor visibility in slicer
+ // and toggle the clicked one
+
+ // Parent
+ bool vis = clickedSlicer->GetActorVisibility("image", 0);
+ bool draw = clickedSlicer->GetRenderer()->GetDraw();
+
+ // Update slicer (after getting visibility)
+ mSlicerManagers[slicerManagerIndex]->UpdateSlicer(column-1, true);
+ mSlicerManagers[slicerManagerIndex]->UpdateInfoOnCursorPosition(column-1);
+ DisplaySliders(slicerManagerIndex, column-1);
+ if(clickedParentItem == clickedItem) {
+ // Toggle
+ vis = !draw || !vis;
}
- } else if (current_row->data(column,Qt::CheckStateRole).toInt() > 0) {
- current_row->setData(column,Qt::CheckStateRole,0);
- mSlicerManagers[i]->UpdateSlicer(column-1,0);
- std::map<std::string,int> overlay_counts;
- for (int child = 0; child < current_row->childCount(); child++) {
- std::string overlay_type =
- current_row->child(child)->data(1,Qt::UserRole).toString().toStdString();
- overlay_counts[overlay_type]++;
- current_row->child(child)->setData(column,Qt::CheckStateRole,0);
- vvSlicer * current_slicer=mSlicerManagers[i]->GetSlicer(column-1);
- current_slicer->SetActorVisibility(overlay_type,overlay_counts[overlay_type]-1,false);
+ clickedSlicer->SetActorVisibility("image", 0, vis);
+ clickedParentItem->setData(column, Qt::CheckStateRole, vis?2:0);
+
+ // Children
+ std::map<std::string, int> actorTypeCounts;
+ for (int iChild = 0; iChild < clickedParentItem->childCount(); iChild++) {
+ QTreeWidgetItem* currentChildItem = clickedParentItem->child(iChild);
+ std::string actorType = currentChildItem->data(1,Qt::UserRole).toString().toStdString();
+ vis = clickedSlicer->GetActorVisibility(actorType, actorTypeCounts[actorType]);
+ if(currentChildItem == clickedItem) {
+ // Toggle or force visibility if it was not on this branch so far
+ vis = !draw || !vis;
+ clickedSlicer->SetActorVisibility(actorType, actorTypeCounts[actorType], vis);
+ }
+ currentChildItem->setData(column, Qt::CheckStateRole, vis?2:0);
+ actorTypeCounts[actorType]++;
}
}
- //mSlicerManagers[i]->SetColorMap(-1);
- mSlicerManagers[i]->SetColorMap();
}
- mSlicerManagers[index]->GetSlicer(column-1)->Render();
+
+ clickedSlicer->Render();
}
//------------------------------------------------------------------------------
bool showVertical = false;
if (mSlicerManagers[slicer]->GetSlicer(window)->GetImage()->GetNumberOfDimensions() > 3
|| (mSlicerManagers[slicer]->GetSlicer(window)->GetImage()->GetNumberOfDimensions() > 2
- && mSlicerManagers[slicer]->GetType() != IMAGEWITHTIME
- && mSlicerManagers[slicer]->GetType() != MERGEDWITHTIME))
+ && mSlicerManagers[slicer]->GetType() != vvImageReader::IMAGEWITHTIME
+ && mSlicerManagers[slicer]->GetType() != vvImageReader::MERGEDWITHTIME))
showVertical = true;
if (mSlicerManagers[slicer]->GetSlicer(window)->GetImage()->GetNumberOfDimensions() > 3
- || mSlicerManagers[slicer]->GetType() == IMAGEWITHTIME
- || mSlicerManagers[slicer]->GetType() == MERGEDWITHTIME)
+ || mSlicerManagers[slicer]->GetType() == vvImageReader::IMAGEWITHTIME
+ || mSlicerManagers[slicer]->GetType() == vvImageReader::MERGEDWITHTIME)
showHorizontal = true;
if (showVertical)
int index = GetSlicerIndexFromItem(item);
QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
QString role=item->data(1,Qt::UserRole).toString();
- if ( role == "vector")
+ if ( role == "vector"){
mSlicerManagers[index]->ReloadVF();
- else if (role == "overlay")
+ }
+ else if (role == "overlay"){
mSlicerManagers[index]->ReloadOverlay();
- else if (role == "fusion")
+ }
+ else if (role == "fusion"){
mSlicerManagers[index]->ReloadFusion();
- else
+ }
+ else{
mSlicerManagers[index]->Reload();
-
+ }
// Update view and info
ImageInfoChanged();
mSlicerManagers[index]->Render();
}
//------------------------------------------------------------------------------
-//------------------------------------------------------------------------------
-void vvMainWindow::WindowsChanged(int window, int view, int slice)
-{
- infoPanel->setViews(window, view, slice);
-}
-//------------------------------------------------------------------------------
-
//------------------------------------------------------------------------------
void vvMainWindow::WindowLevelChanged(double window, double level,int preset,int colormap)
{
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-void vvMainWindow::UpdateLinkedNavigation(std::string id, vvSlicerManager * sm)
+void vvMainWindow::UpdateLinkedNavigation(std::string id, vvSlicerManager * sm, vvSlicer* refSlicer)
{
for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
if (id == mSlicerManagers[i]->GetId()) {
- mSlicerManagers[i]->UpdateLinkedNavigation(sm->GetSlicer(0));
+ mSlicerManagers[i]->UpdateLinkedNavigation(refSlicer);
}
}
}
item->setData(1,Qt::UserRole,tr("overlay"));
QFileInfo fileinfo(file); //Do not show the path
item->setData(COLUMN_IMAGE_NAME,Qt::DisplayRole,fileinfo.fileName());
- item->setToolTip(COLUMN_IMAGE_NAME,fileinfo.absoluteFilePath());
+ item->setToolTip(COLUMN_IMAGE_NAME, mSlicerManagers[index]->GetListOfAbsoluteFilePathInOneString("overlay").c_str());
qApp->processEvents();
for (int j = 1; j <= 4; j++) {
item->setData(j,Qt::CheckStateRole,DataTree->topLevelItem(index)->data(j,Qt::CheckStateRole));
- mSlicerManagers[index]->GetSlicer(j-1)->SetActorVisibility("overlay",0,
- DataTree->topLevelItem(index)->data(j,Qt::CheckStateRole).toInt());
}
//Create the buttons for reload and close
// Create roi in new tool
vvToolStructureSetManager::AddImage(mCurrentSlicerManager, roi);
-*/
+ */
}
//------------------------------------------------------------------------------
item->setData(1,Qt::UserRole,tr("fusion"));
QFileInfo fileinfo(filename.c_str()); //Do not show the path
item->setData(COLUMN_IMAGE_NAME,Qt::DisplayRole,fileinfo.fileName());
- item->setToolTip(COLUMN_IMAGE_NAME,fileinfo.absoluteFilePath());
+ item->setToolTip(COLUMN_IMAGE_NAME, mSlicerManagers[index]->GetListOfAbsoluteFilePathInOneString("fusion").c_str());
qApp->processEvents();
for (int j = 1; j <= 4; j++) {
item->setData(j,Qt::CheckStateRole,DataTree->topLevelItem(index)->data(j,Qt::CheckStateRole));
- mSlicerManagers[index]->GetSlicer(j-1)->SetActorVisibility("fusion",0,
- DataTree->topLevelItem(index)->data(j,Qt::CheckStateRole).toInt());
}
//Create the buttons for reload and close
item->setData(1,Qt::UserRole,tr("vector"));
QFileInfo fileinfo(filename); //Do not show the path
item->setData(COLUMN_IMAGE_NAME,Qt::DisplayRole,fileinfo.fileName());
- item->setToolTip(COLUMN_IMAGE_NAME,fileinfo.absoluteFilePath());
+ item->setToolTip(COLUMN_IMAGE_NAME, mSlicerManagers[index]->GetListOfAbsoluteFilePathInOneString("vector").c_str());
qApp->processEvents();
for (int j = 1; j <= 4; j++) {
item->setData(j,Qt::CheckStateRole,DataTree->topLevelItem(index)->data(j,Qt::CheckStateRole));
- mSlicerManagers[index]->GetSlicer(j-1)->SetActorVisibility("vector",0,
- DataTree->topLevelItem(index)->data(j,Qt::CheckStateRole).toInt());
}
//Create the buttons for reload and close
std::string action = "Saving";
vvProgressDialog progress("Saving "+fileName.toStdString());
qApp->processEvents();
- vvImageWriter *writer = new vvImageWriter;
+ vvImageWriter::Pointer writer = vvImageWriter::New();
writer->SetOutputFileName(fileName.toStdString());
writer->SetInput(mSlicerManagers[index]->GetImage());
writer->Update();
//------------------------------------------------------------------------------
void vvMainWindow::AddLink(QString image1,QString image2)
{
+ unsigned int sm1 = 0;
+ unsigned int sm2 = 0;
+
for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
if (image1.toStdString() == mSlicerManagers[i]->GetId()) {
mSlicerManagers[i]->AddLink(image2.toStdString());
+ sm1 = i;
}
if (image2.toStdString() == mSlicerManagers[i]->GetId()) {
mSlicerManagers[i]->AddLink(image1.toStdString());
+ sm2 = i;
}
}
+
+ if (linkPanel->isLinkAll()) {
+ emit UpdateLinkedNavigation(mSlicerManagers[sm1]->GetId(), mSlicerManagers[mCurrentPickedImageIndex], mSlicerManagers[mCurrentPickedImageIndex]->GetSlicer(0));
+ emit UpdateLinkedNavigation(mSlicerManagers[sm2]->GetId(), mSlicerManagers[mCurrentPickedImageIndex], mSlicerManagers[mCurrentPickedImageIndex]->GetSlicer(0));
+ } else {
+ emit UpdateLinkedNavigation(mSlicerManagers[sm2]->GetId(), mSlicerManagers[sm1], mSlicerManagers[sm1]->GetSlicer(0));
+ }
}
+
//------------------------------------------------------------------------------
index = (index+offset) % mSlicerManagers.size();
QTreeWidgetItem* item = GetItemFromSlicerManager(mSlicerManagers[index]);
- //CurrentImageChanged(mSlicerManagers[index]->GetId()); //select new image
item->setData(slicer+1,Qt::CheckStateRole,2); //change checkbox
+ CurrentImageChanged(mSlicerManagers[index]->GetId()); //select new image
DisplayChanged(item,slicer+1);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::SaveNOScreenshot()
{
- vtkWindowToImageFilter *w2i = vtkWindowToImageFilter::New();
- w2i->SetInput(NOViewWidget->GetRenderWindow());
- w2i->Update();
- SaveScreenshot(w2i->GetOutput());
- w2i->Delete();
+ SaveScreenshot(NOViewWidget);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::SaveNEScreenshot()
{
- vtkWindowToImageFilter *w2i = vtkWindowToImageFilter::New();
- w2i->SetInput(NEViewWidget->GetRenderWindow());
- w2i->Update();
- SaveScreenshot(w2i->GetOutput());
- w2i->Delete();
+ SaveScreenshot(NEViewWidget);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::SaveSOScreenshot()
{
- vtkWindowToImageFilter *w2i = vtkWindowToImageFilter::New();
- w2i->SetInput(SOViewWidget->GetRenderWindow());
- w2i->Update();
- SaveScreenshot(w2i->GetOutput());
- w2i->Delete();
+ SaveScreenshot(SOViewWidget);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::SaveSEScreenshot()
{
- vtkWindowToImageFilter *w2i = vtkWindowToImageFilter::New();
- w2i->SetInput(SEViewWidget->GetRenderWindow());
- w2i->Update();
- SaveScreenshot(w2i->GetOutput());
- w2i->Delete();
+ SaveScreenshot(SEViewWidget);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-void vvMainWindow::SaveScreenshot(vtkImageData* image)
+void vvMainWindow::SaveScreenshot(QVTKWidget *widget)
{
QString Extensions = "Images( *.png);;";
Extensions += "Images( *.jpg);;";
Extensions += "Images( *.bmp);;";
Extensions += "Images( *.tif);;";
Extensions += "Images( *.ppm)";
+#ifdef VTK_USE_FFMPEG_ENCODER
+ Extensions += "Images( *.avi)";
+#endif
+#ifdef VTK_USE_MPEG2_ENCODER
+ Extensions += "Images( *.mpg)";
+#endif
+
+ int smIndex=GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
QString fileName = QFileDialog::getSaveFileName(this,
tr("Save As"),
- itksys::SystemTools::GetFilenamePath(
- mSlicerManagers[0]->GetFileName()).c_str(),
+ itksys::SystemTools::GetFilenamePath(mSlicerManagers[smIndex]->GetFileName()).c_str(),
Extensions);
+
if (!fileName.isEmpty()) {
+ vtkSmartPointer<vtkWindowToImageFilter> w2i = vtkSmartPointer<vtkWindowToImageFilter>::New();
+ w2i->SetInput(widget->GetRenderWindow());
+ w2i->Update();
+ vtkImageData *image = w2i->GetOutput();
+
const char *ext = fileName.toStdString().c_str() + strlen(fileName.toStdString().c_str()) - 4;
if (!strcmp(ext, ".bmp")) {
vtkBMPWriter *bmp = vtkBMPWriter::New();
jpg->SetFileName(fileName.toStdString().c_str());
jpg->Write();
jpg->Delete();
+#ifdef VTK_USE_FFMPEG_ENCODER
+ } else if (!strcmp(ext, ".avi")) {
+ vtkFFMPEGWriter *mpg = vtkFFMPEGWriter::New();
+ mpg->SetInput(image);
+ mpg->SetFileName(fileName.toStdString().c_str());
+ mpg->SetQuality(2);
+ mpg->SetRate(5);
+ mpg->Start();
+
+ vvImage * vvImg = mSlicerManagers[smIndex]->GetImage();
+ int nSlice = vvImg->GetVTKImages().size();
+ for(int i=0; i<nSlice; i++) {
+ mSlicerManagers[smIndex]->SetNextTSlice(0);
+ vtkSmartPointer<vtkWindowToImageFilter> w2i = vtkSmartPointer<vtkWindowToImageFilter>::New();
+ w2i->SetInput(widget->GetRenderWindow());
+ w2i->Update();
+ mpg->SetInput(w2i->GetOutput());
+ mpg->Write();
+ }
+ mpg->End();
+ mpg->Delete();
+#endif
+#ifdef VTK_USE_MPEG2_ENCODER
+ } else if (!strcmp(ext, ".mpg")) {
+ vtkMPEG2Writer *mpg = vtkMPEG2Writer::New();
+ mpg->SetInput(image);
+ mpg->SetFileName(fileName.toStdString().c_str());
+ mpg->Start();
+
+ vvImage * vvImg = mSlicerManagers[smIndex]->GetImage();
+ int nSlice = vvImg->GetVTKImages().size();
+ for(int i=0; i<nSlice; i++) {
+ mSlicerManagers[smIndex]->SetNextTSlice(0);
+ vtkSmartPointer<vtkWindowToImageFilter> w2i = vtkSmartPointer<vtkWindowToImageFilter>::New();
+ w2i->SetInput(widget->GetRenderWindow());
+ w2i->Update();
+ mpg->SetInput(w2i->GetOutput());
+ mpg->Write();
+ }
+ mpg->End();
+ mpg->Delete();
+#endif
} else {
QMessageBox::information(this,tr("Problem saving screenshot !"),tr("Cannot save image.\nPlease set a file extension !!!"));
}
}
-
}
//------------------------------------------------------------------------------
for(unsigned int l=0; l<mSlicerManagers.size(); l++) {
vvSlicerManager * v = mSlicerManagers[l];
if (v->GetBaseFileName() ==
- vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename))) {
+ vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename))) {
number = std::max(number, v->GetBaseFileNameNumber()+1);
}
}
//create an item in the tree with good settings
QTreeWidgetItem *item = new QTreeWidgetItem();
item->setData(0,Qt::UserRole,slicer_manager->GetFileName().c_str());//files[i].c_str());
- item->setData(COLUMN_IMAGE_NAME,Qt::DisplayRole,filename.c_str());
+ item->setData(1,Qt::UserRole,tr("image"));
+ item->setData(COLUMN_IMAGE_NAME,Qt::DisplayRole,slicer_manager->GetFileName().c_str());//filename.c_str());
qApp->processEvents();
for (int j = 1; j <= 4; j++) item->setData(j,Qt::CheckStateRole,1);
item->setData(COLUMN_IMAGE_NAME,Qt::UserRole,id.toStdString().c_str());
mSlicerManagers.back()->SetId(id.toStdString());
- linkPanel->addImage(filename, id.toStdString());
+ linkPanel->addImage(slicer_manager->GetFileName().c_str()// filename
+ , id.toStdString());
connect(mSlicerManagers.back(), SIGNAL(currentImageChanged(std::string)),
this, SLOT(CurrentImageChanged(std::string)));
+ connect(mSlicerManagers.back(), SIGNAL(currentPickedImageChanged(std::string)),
+ this, SLOT(CurrentPickedImageChanged(std::string)));
connect(mSlicerManagers.back(), SIGNAL(UpdatePosition(int, double, double, double, double, double, double, double)),
this, SLOT(MousePositionChanged(int,double, double, double, double, double, double, double)));
connect(mSlicerManagers.back(), SIGNAL(UpdateVector(int, double, double, double, double)),
this, SLOT(OverlayChanged(int,double,double)));
connect(mSlicerManagers.back(), SIGNAL(UpdateFusion(int, double)),
this, SLOT(FusionChanged(int,double)));
- connect(mSlicerManagers.back(), SIGNAL(UpdateWindows(int, int, int)),
- this,SLOT(WindowsChanged(int, int, int)));
connect(mSlicerManagers.back(), SIGNAL(WindowLevelChanged(double, double,int, int)),
this,SLOT(WindowLevelChanged(double, double, int, int)));
connect(mSlicerManagers.back(), SIGNAL(UpdateSlice(int,int)),
this,SLOT(UpdateSliceRange(int,int,int,int,int)));
connect(mSlicerManagers.back(), SIGNAL(UpdateLinkManager(std::string,int,double,double,double,int)),
this,SLOT(UpdateLinkManager(std::string,int,double,double,double,int)));
- connect(mSlicerManagers.back(), SIGNAL(UpdateLinkedNavigation(std::string,vvSlicerManager*)),
- this,SLOT(UpdateLinkedNavigation(std::string,vvSlicerManager*)));
+ connect(mSlicerManagers.back(), SIGNAL(UpdateLinkedNavigation(std::string,vvSlicerManager*,vvSlicer*)),
+ this,SLOT(UpdateLinkedNavigation(std::string,vvSlicerManager*,vvSlicer*)));
connect(mSlicerManagers.back(), SIGNAL(ChangeImageWithIndexOffset(vvSlicerManager*,int,int)),
this,SLOT(ChangeImageWithIndexOffset(vvSlicerManager*,int,int)));
connect(mSlicerManagers.back(), SIGNAL(LandmarkAdded()),landmarksPanel,SLOT(AddPoint()));
ShowLastImage();
InitDisplay();
qApp->processEvents();
-
+
// End
ImageInfoChanged();
return slicer_manager;