vv/vvMainWindow.cxx

   1 /*=========================================================================
   2 Program:   vv                     http://www.creatis.insa-lyon.fr/rio/vv
   3
   4 Authors belong to:
   5 - University of LYON              http://www.universite-lyon.fr/
   6 - Léon Bérard cancer center       http://www.centreleonberard.fr
   7 - CREATIS CNRS laboratory         http://www.creatis.insa-lyon.fr
   8
   9 This software is distributed WITHOUT ANY WARRANTY; without even
  10 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  11 PURPOSE.  See the copyright notices for more information.
  12
  13 It is distributed under dual licence
  14
  15 - BSD        See included LICENSE.txt file
  16 - CeCILL-B   http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
  17 ===========================================================================**/
  18
  19 #include <algorithm>
  20 #include <QMessageBox>
  21 #include <QInputDialog>
  22 #include <QTimer>
  23 #include "QTreePushButton.h"
  24 #include <QUrl>
  25 #include <QSettings>
  26
  27 // VV include
  28 #include "vvMainWindow.h"
  29 #include "vvHelpDialog.h"
  30 #include "vvRegisterForm.h"
  31 #include "vvDocumentation.h"
  32 #include "vvProgressDialog.h"
  33 #include "vvQDicomSeriesSelector.h"
  34 #include "vvSlicerManager.h"
  35 #include "clitkImageCommon.h"
  36 #include "vvSlicer.h"
  37 #include "vvInteractorStyleNavigator.h"
  38 #include "vvImageWriter.h"
  39 #include "vvSegmentationDialog.h"
  40 #include "vvSurfaceViewerDialog.h"
  41 #include "vvDeformationDialog.h"
  42 #include "vvImageWarp.h"
  43 #include "vvUtils.h"
  44 #include "vvMidPosition.h"
  45 #include "vvMesh.h"
  46 #include "vvStructSelector.h"
  47 #include "vvMeshReader.h"
  48 #include "vvSaveState.h"
  49 #include "vvReadState.h"
  50 #include "clitkConfiguration.h"
  51 #include "clitkMatrix.h"
  52
  53 // ITK include
  54 #include <itkImage.h>
  55 #include <itkImageFileReader.h>
  56 #include <itkByteSwapper.h>
  57 #include <itkCommand.h>
  58 #include <itkNumericSeriesFileNames.h>
  59
  60 // VTK include
  61 #include <vtkImageMapper3D.h>
  62 #include <vtkInformation.h>
  63 #include <vtkVersion.h>
  64 #include <vtkImageData.h>
  65 #include <vtkImageActor.h>
  66 #include <vtkCornerAnnotation.h>
  67 #include <vtkRenderWindow.h>
  68 #include <vtkRenderWindowInteractor.h>
  69 #include <vtkRenderer.h>
  70 #include <vtkRendererCollection.h>
  71 #include <vtkWindowToImageFilter.h>
  72 #include <vtkBMPWriter.h>
  73 #include <vtkTIFFWriter.h>
  74 #include <vtkPNMWriter.h>
  75 #include <vtkPNGWriter.h>
  76 #include <vtkJPEGWriter.h>
  77 #include <vtkGenericMovieWriter.h>
  78 #ifdef CLITK_EXPERIMENTAL
  79 #  include <vvAnimatedGIFWriter.h>
  80 #endif
  81 #ifdef VTK_USE_VIDEO_FOR_WINDOWS
  82 #  include <vtkAVIWriter.h>
  83 #endif
  84 #ifdef VTK_USE_FFMPEG_ENCODER
  85 #  include <vtkFFMPEGWriter.h>
  86 #endif
  87 #ifdef VTK_USE_MPEG2_ENCODER
  88 #  include <vtkMPEG2Writer.h>
  89 #endif
  90 #include <vtkMatrix4x4.h>
  91 #include <vtkTransform.h>
  92
  93 // Standard includes
  94 #include <iostream>
  95 #include <fstream>
  96 #include <sstream>
  97 #include <iomanip>
  98
  99 #define COLUMN_TREE 0
 100 #define COLUMN_UL_VIEW 1
 101 #define COLUMN_UR_VIEW 2
 102 #define COLUMN_DL_VIEW 3
 103 #define COLUMN_DR_VIEW 4
 104 #define COLUMN_CLOSE_IMAGE 5
 105 #define COLUMN_RELOAD_IMAGE 6
 106 #define COLUMN_IMAGE_NAME 7
 107
 108 #ifdef CLITK_PRIVATE_FEATURES
 109 #define EXTENSIONS "Images ( *.bmp *.dcm *.png *.jpeg *.jpg *.tif *.mhd *.mha *.hdr *.vox *.his *.xdr *.SCAN *.nii *.nrrd *.nhdr *.refscan *.nii.gz *.usf *.svl)"
 110 #else
 111 #define EXTENSIONS "Images ( *.bmp *.dcm *.png *.jpeg *.jpg *.tif *.mhd *.mha *.hdr *.vox *.his *.xdr *.SCAN *.nii *.nrrd *.nhdr *.refscan *.nii.gz)"
 112 #endif
 113
 114
 115 /*Data Tree values
 116 0,Qt::UserRole full filename
 117 1,Qt::CheckStateRole checkbutton UL View
 118 1,Qt::UserRole overlay, fusion or vector
 119 2,Qt::CheckStateRole checkbutton UR View
 120 3,Qt::CheckStateRole checkbutton DL View
 121 4,Qt::CheckStateRole checkbutton DR View
 122 5,0  short filename
 123 5,Qt::UserRole mSlicerManager id*/
 124
 125 //------------------------------------------------------------------------------
 126 vvMainWindow::vvMainWindow():vvMainWindowBase()
 127 {
 128   setupUi(this); // this sets up the GUI
 129
 130   mInputPathName = "";
 131   mMenuTools = menuTools;
 132   //  mMenuSegmentation = menuSegmentation;
 133   mContextMenu = &contextMenu;
 134   mMenuExperimentalTools = menuExperimental;
 135   mMainWidget = this;
 136   mCurrentTime = -1;
 137   mCurrentSelectedImageId = "";
 138   mCurrentPickedImageId = "";
 139   mCurrentPickedImageIndex = 0;
 140
 141   //Init the contextMenu
 142   this->setContextMenuPolicy(Qt::CustomContextMenu);
 143   contextActions.resize(0);
 144   QAction* actionOpen_new_image = contextMenu.addAction(QIcon(QString::fromUtf8(":/common/icons/fileopen.png")),
 145     tr("O&pen new Image"));
 146   actionOpen_new_image->setShortcut(QKeySequence(tr("Ctrl+O")));
 147   connect(actionOpen_new_image,SIGNAL(triggered()),this,SLOT(OpenImages()));
 148   contextActions.push_back(actionOpen_new_image);
 149   contextMenu.addSeparator();
 150
 151   QAction* actionClose_Image = contextMenu.addAction(QIcon(QString::fromUtf8(":/common/icons/exit.png")),
 152     tr("Close Current Image"));
 153   connect(actionClose_Image,SIGNAL(triggered()),this,SLOT(CloseImage()));
 154   contextActions.push_back(actionClose_Image);
 155
 156   QAction* actionReload_image = contextMenu.addAction(QIcon(QString::fromUtf8(":/common/icons/rotateright.png")),
 157     tr("Reload Current Image"));
 158   connect(actionReload_image,SIGNAL(triggered()),this,SLOT(ReloadImage()));
 159   contextActions.push_back(actionReload_image);
 160
 161   QAction* actionSave_image = contextMenu.addAction(QIcon(QString::fromUtf8(":/common/icons/filesave.png")),
 162     tr("Save Current Image"));
 163   connect(actionSave_image,SIGNAL(triggered()),this,SLOT(SaveAs()));
 164   contextActions.push_back(actionSave_image);
 165
 166   QAction* actionSave_state = contextMenu.addAction(QIcon(QString::fromUtf8(":/common/icons/filesave.png")),
 167     tr("Save Current State"));
 168   connect(actionSave_state,SIGNAL(triggered()),this,SLOT(SaveCurrentState()));
 169   contextActions.push_back(actionSave_state);
 170
 171   QAction* actionRead_state = contextMenu.addAction(QIcon(QString::fromUtf8(":/common/icons/filesave.png")),
 172     tr("Read Saved State"));
 173   connect(actionRead_state,SIGNAL(triggered()),this,SLOT(ReadSavedState()));
 174   contextActions.push_back(actionRead_state);
 175
 176   contextMenu.addSeparator();
 177
 178   contextMenu.addAction(actionAdd_VF_to_current_Image);
 179   contextActions.push_back(actionAdd_VF_to_current_Image);
 180
 181   //QAction* actionAdd_Overlay_to_current_Image = menuOverlay->addAction(QIcon(QString::fromUtf8(":/common/icons/GPSup.png")),
 182   //    tr("Add overlay image to current image"));
 183   contextMenu.addAction(actionAdd_overlay_image_to_current_image);
 184   contextActions.push_back(actionAdd_overlay_image_to_current_image);
 185
 186   contextMenu.addAction(actionAdd_fusion_image);
 187   contextActions.push_back(actionAdd_fusion_image);
 188
 189 #ifdef CLITK_EXPERIMENTAL
 190   contextMenu.addAction(actionAdd_USSequence_toCT);
 191   contextActions.push_back(actionAdd_USSequence_toCT);
 192 #endif
 193
 194
 195   contextMenu.addSeparator();
 196   QAction* actionResetMatrix = contextMenu.addAction(QIcon(QString::fromUtf8(":/common/icons/identity.png")),
 197     tr("Reset transformation to identity"));
 198   connect(actionResetMatrix, SIGNAL(triggered()), this,SLOT(ResetTransformationToIdentity()));
 199
 200   // TRIAL DS
 201   /*
 202   QMenu * m = new QMenu(menubar);
 203   m->setTitle("TOTO");
 204   //  m->setObjectName(QString::fromUtf8("TOTOTO"));
 205   contextMenu.addMenu(m);
 206   QAction * a = m->addAction(QIcon(QString::fromUtf8(":/common/icons/GPSup.png")),
 207   tr("BIDON"));
 208   QAction * b = m->addAction(QIcon(QString::fromUtf8(":/common/icons/GPSup.png")),
 209   tr("BIDON2"));
 210   m->addAction(a);
 211   m->addAction(b);
 212   connect(a,SIGNAL(triggered()),this,SLOT(AddFusionImage()));
 213   */
 214
 215   //init the DataTree
 216   mSlicerManagers.resize(0);
 217
 218   QStringList header;
 219   header.append("");
 220   header.append("TL");
 221   header.append("TR");
 222   header.append("BL");
 223   header.append("BR");
 224   header.append("");
 225   header.append("");
 226   header.append("Name");
 227
 228   DataTree->setHeaderLabels(header);
 229   DataTree->resizeColumnToContents(COLUMN_TREE);
 230   DataTree->resizeColumnToContents(COLUMN_UL_VIEW);
 231   DataTree->resizeColumnToContents(COLUMN_UR_VIEW);
 232   DataTree->resizeColumnToContents(COLUMN_DL_VIEW);
 233   DataTree->resizeColumnToContents(COLUMN_DR_VIEW);
 234   DataTree->resizeColumnToContents(COLUMN_CLOSE_IMAGE);
 235   DataTree->resizeColumnToContents(COLUMN_RELOAD_IMAGE);
 236   DataTree->resizeColumnToContents(COLUMN_IMAGE_NAME);
 237
 238   viewMode = 1;
 239   documentation = new vvDocumentation();
 240   help_dialog = new vvHelpDialog();
 241   dicomSeriesSelector = new vvDicomSeriesSelector();
 242
 243   inverseButton->setEnabled(0);
 244   actionAdd_overlay_image_to_current_image->setEnabled(0);
 245   actionSave_As->setEnabled(0);
 246   actionAdd_VF_to_current_Image->setEnabled(0);
 247   actionAdd_fusion_image->setEnabled(0);
 248   actionAdd_USSequence_toCT->setEnabled(0);
 249
 250   //init the sliders
 251   verticalSliders.push_back(NOVerticalSlider);
 252   verticalSliders.push_back(NEVerticalSlider);
 253   verticalSliders.push_back(SOVerticalSlider);
 254   verticalSliders.push_back(SEVerticalSlider);
 255
 256   for (int i =0; i < 4; i++)
 257     verticalSliders[i]->hide();
 258
 259   horizontalSliders.push_back(NOHorizontalSlider);
 260   horizontalSliders.push_back(NEHorizontalSlider);
 261   horizontalSliders.push_back(SOHorizontalSlider);
 262   horizontalSliders.push_back(SEHorizontalSlider);
 263
 264   for (int i =0; i < 4; i++)
 265     horizontalSliders[i]->hide();
 266
 267
 268   connect(NOVerticalSlider,SIGNAL(valueChanged(int)),this,SLOT(NOVerticalSliderChanged()));
 269   connect(NEVerticalSlider,SIGNAL(valueChanged(int)),this,SLOT(NEVerticalSliderChanged()));
 270   connect(SOVerticalSlider,SIGNAL(valueChanged(int)),this,SLOT(SOVerticalSliderChanged()));
 271   connect(SEVerticalSlider,SIGNAL(valueChanged(int)),this,SLOT(SEVerticalSliderChanged()));
 272
 273   connect(NOHorizontalSlider,SIGNAL(valueChanged(int)),this,SLOT(NOHorizontalSliderMoved()));
 274   connect(NEHorizontalSlider,SIGNAL(valueChanged(int)),this,SLOT(NEHorizontalSliderMoved()));
 275   connect(SOHorizontalSlider,SIGNAL(valueChanged(int)),this,SLOT(SOHorizontalSliderMoved()));
 276   connect(SEHorizontalSlider,SIGNAL(valueChanged(int)),this,SLOT(SEHorizontalSliderMoved()));
 277
 278   //connect everything
 279   connect(actionCompute_mid_position_image,SIGNAL(triggered()),this,SLOT(ComputeMidPosition()));
 280   connect(actionDeformable_Registration,SIGNAL(triggered()),this,SLOT(ComputeDeformableRegistration()));
 281   connect(actionWarp_image_with_vector_field,SIGNAL(triggered()),this,SLOT(WarpImage()));
 282   connect(actionLoad_images,SIGNAL(triggered()),this,SLOT(OpenImages()));
 283   connect(actionOpen_Dicom,SIGNAL(triggered()),this,SLOT(OpenDicom()));
 284   //  connect(actionOpen_Dicom_Struct,SIGNAL(triggered()),this,SLOT(OpenDCStructContour()));
 285   connect(actionOpen_VTK_contour,SIGNAL(triggered()),this,SLOT(OpenVTKContour()));
 286   connect(actionOpen_Multiple_Images_As_One,SIGNAL(triggered()),this,SLOT(MergeImages()));
 287   connect(actionSlice_Image_As_Multiple_Images,SIGNAL(triggered()),this,SLOT(SliceImages()));
 288   connect(actionOpen_Image_With_Time,SIGNAL(triggered()),this,SLOT(OpenImageWithTime()));
 289   connect(actionMerge_images_as_n_dim_t, SIGNAL(triggered()), this, SLOT(MergeImagesWithTime()));
 290   connect(actionSave_As,SIGNAL(triggered()),this,SLOT(SaveAs()));
 291   connect(actionSave_current_state,SIGNAL(triggered()),this,SLOT(SaveCurrentState()));
 292   connect(actionRead_saved_state,SIGNAL(triggered()),this,SLOT(ReadSavedState()));
 293   connect(actionExit,SIGNAL(triggered()),this,SLOT(close()));
 294   connect(actionAdd_VF_to_current_Image,SIGNAL(triggered()),this,SLOT(OpenField()));
 295   connect(actionAdd_fusion_image,SIGNAL(triggered()),this,SLOT(SelectFusionImage()));
 296   connect(actionAdd_overlay_image_to_current_image,SIGNAL(triggered()), this,SLOT(SelectOverlayImage()));
 297   connect(actionAdd_USSequence_toCT,SIGNAL(triggered()), this,SLOT(SelectFusionSequence()));
 298   connect(actionNavigation_Help,SIGNAL(triggered()),this,SLOT(ShowHelpDialog()));
 299   connect(actionDocumentation,SIGNAL(triggered()),this,SLOT(ShowDocumentation()));
 300   connect(actionRegister_vv,SIGNAL(triggered()),this,SLOT(PopupRegisterForm()));
 301
 302   connect(overlayPanel, SIGNAL(FusionSequenceCorrespondancesButtonPressed()), this, SLOT(SelectFusionSequenceCorrespondances()));
 303
 304
 305   ///////////////////////////////////////////////
 306   connect(actionSegmentation,SIGNAL(triggered()),this,SLOT(SegmentationOnCurrentImage()));
 307   connect(actionSurface_Viewer,SIGNAL(triggered()),this,SLOT(SurfaceViewerLaunch()));
 308   ///////////////////////////////////////////////
 309
 310   actionNorth_East_Window->setEnabled(0);
 311   actionNorth_West_Window->setEnabled(0);
 312   actionSouth_East_Window->setEnabled(0);
 313   actionSouth_West_Window->setEnabled(0);
 314
 315   connect(actionNorth_East_Window,SIGNAL(triggered()),this,SLOT(SaveNEScreenshot()));
 316   connect(actionNorth_West_Window,SIGNAL(triggered()),this,SLOT(SaveNOScreenshot()));
 317   connect(actionSouth_East_Window,SIGNAL(triggered()),this,SLOT(SaveSEScreenshot()));
 318   connect(actionSouth_West_Window,SIGNAL(triggered()),this,SLOT(SaveSOScreenshot()));
 319   connect(actionSave_all_slices,SIGNAL(triggered()),this,SLOT(SaveScreenshotAllSlices()));
 320
 321   connect(DataTree,SIGNAL(itemSelectionChanged()),this,SLOT(ImageInfoChanged()));
 322   connect(DataTree,SIGNAL(itemClicked(QTreeWidgetItem*, int)),this,
 323     SLOT(DisplayChanged(QTreeWidgetItem*, int)));
 324
 325   connect(viewButton,SIGNAL(clicked()),this, SLOT(ChangeViewMode()) );
 326   connect(windowSpinBox,SIGNAL(editingFinished()),this,SLOT(WindowLevelEdited()));
 327   connect(levelSpinBox,SIGNAL(editingFinished()),this,SLOT(WindowLevelEdited()));
 328   connect(colorMapComboBox,SIGNAL(currentIndexChanged(int)),this,SLOT(UpdateColorMap()));
 329   connect(presetComboBox,SIGNAL(currentIndexChanged(int)),this,SLOT(UpdateWindowLevel()));
 330   connect(slicingPresetComboBox, SIGNAL(currentIndexChanged(int)),this,SLOT(UpdateSlicingPreset()));
 331   connect(inverseButton,SIGNAL(clicked()),this,SLOT(SwitchWindowLevel()));
 332   connect(applyWindowLevelToAllButton,SIGNAL(clicked()),this,SLOT(ApplyWindowLevelToAllImages()));
 333
 334   connect(this,SIGNAL(customContextMenuRequested(QPoint)),this,SLOT(ShowContextMenu(QPoint)));
 335
 336   connect(linkPanel,SIGNAL(addLink(QString,QString,bool)),this,SLOT(AddLink(QString,QString,bool)));
 337   connect(linkPanel,SIGNAL(removeLink(QString,QString)),this,SLOT(RemoveLink(QString,QString)));
 338   connect(overlayPanel,SIGNAL(VFPropertyUpdated(int,int,int,int,double,double,double)),this,SLOT(SetVFProperty(int,int,int,int,double,double,double)));
 339   connect(overlayPanel,SIGNAL(OverlayPropertyUpdated(int,int,double,double)),
 340     this,SLOT(SetOverlayProperty(int,int,double,double)));
 341   connect(overlayPanel,SIGNAL(FusionPropertyUpdated(int,int,int,double,double, bool)),
 342     this,SLOT(SetFusionProperty(int,int,int,double,double, bool)));
 343   connect(landmarksPanel,SIGNAL(UpdateRenderWindows()),this,SLOT(UpdateRenderWindows()));
 344   connect(landmarksPanel,SIGNAL(SelectedPointChanged()),this,SLOT(GoToLandmark()));
 345
 346   connect(overlayPanel,SIGNAL(FusionSequencePropertyUpdated(int, bool, unsigned int, bool)),
 347     this,SLOT(SetFusionSequenceProperty(int, bool,unsigned int, bool)));
 348
 349
 350   playMode = 0;//pause
 351   mFrameRate = 10;
 352   playButton->setEnabled(0);
 353   frameRateLabel->setEnabled(0);
 354   frameRateSpinBox->setEnabled(0);
 355   connect(playButton, SIGNAL(clicked()),this,SLOT(PlayPause()));
 356   connect(frameRateSpinBox, SIGNAL(valueChanged(int)),this,SLOT(ChangeFrameRate(int)));
 357
 358   goToCursorPushButton->setEnabled(0);
 359   connect(goToCursorPushButton, SIGNAL(clicked()),this,SLOT(GoToCursor()));
 360
 361   NOViewWidget->hide();
 362   NEViewWidget->hide();
 363   SOViewWidget->hide();
 364   SEViewWidget->hide();
 365
 366   //Recently opened files
 367   std::list<std::string> recent_files = GetRecentlyOpenedImages();
 368   recentlyOpenedFilesMenu=NULL;
 369   if ( !recent_files.empty() ) {
 370     createRecentlyOpenedFilesMenu();
 371     updateRecentlyOpenedFilesMenu(recent_files);
 372   }
 373
 374   // Adding all new tools (insertion in the menu)
 375   vvToolManager::GetInstance()->InsertToolsInMenu(this);
 376   vvToolManager::GetInstance()->EnableToolsInMenu(this, false);
 377
 378   if (!CLITK_EXPERIMENTAL)
 379     menuExperimental->menuAction()->setVisible(false);
 380
 381
 382   QTimer * timerMemory = new QTimer(this);
 383   //timerMemory->setInterval(5);
 384   connect(timerMemory, SIGNAL(timeout()), this, SLOT(UpdateMemoryUsage()));
 385   timerMemory->start(2000);
 386
 387 }
 388 //------------------------------------------------------------------------------
 389 void vvMainWindow::show()
 390 {
 391   vvMainWindowBase::show();
 392   PopupRegisterForm(true);
 393 }
 394 //------------------------------------------------------------------------------
 395 void vvMainWindow::UpdateMemoryUsage()
 396 {
 397   //  clitk::PrintMemory(true);
 398   if (clitk::GetMemoryUsageInMb() == 0) infoPanel->setMemoryInMb("NA");
 399   else infoPanel->setMemoryInMb(QString::number(clitk::GetMemoryUsageInMb())+" MiB");
 400 }
 401 //------------------------------------------------------------------------------
 402
 403
 404 //------------------------------------------------------------------------------
 405 void vvMainWindow::createRecentlyOpenedFilesMenu()
 406 {
 407   recentlyOpenedFilesMenu = new QMenu("Recently opened files...");
 408   recentlyOpenedFilesMenu->setIcon(QIcon(QString::fromUtf8(":/common/icons/open.png")));
 409   menuFile->insertMenu(actionOpen_Image_With_Time,recentlyOpenedFilesMenu);
 410   menuFile->insertSeparator(actionOpen_Image_With_Time);
 411 }
 412 //------------------------------------------------------------------------------
 413
 414
 415 //------------------------------------------------------------------------------
 416
 417 void vvMainWindow::updateRecentlyOpenedFilesMenu(const std::list<std::string> &recent_files)
 418 {
 419   if(recentlyOpenedFilesMenu==NULL) {
 420     createRecentlyOpenedFilesMenu();
 421   } else {
 422     recentlyOpenedFilesMenu->clear();
 423   }
 424   for (std::list<std::string>::const_iterator i = recent_files.begin(); i!=recent_files.end(); i++) {
 425     QAction* current=new QAction(QIcon(QString::fromUtf8(":/common/icons/open.png")), i->c_str(),this);
 426     recentlyOpenedFilesMenu->addAction(current);
 427     connect(current,SIGNAL(triggered()),this,SLOT(OpenRecentImage()));
 428   }
 429 }
 430 //------------------------------------------------------------------------------
 431
 432
 433 //------------------------------------------------------------------------------
 434 void vvMainWindow::ComputeMidPosition()
 435 {
 436   bool ok;
 437   int index=GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
 438   int ref = QInputDialog::getInt(this,"Chose reference phase","Reference phase",0,0,\
 439 mSlicerManagers[index]->GetImage()->GetVTKImages().size()-1,1,&ok);
 440   if (ok) {
 441     vvMidPosition midp;
 442     midp.slicer_manager = mSlicerManagers[index];
 443     midp.reference_image_index = ref;
 444     QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 445     midp.Update();
 446     if (midp.error)
 447       QMessageBox::warning(this, "Error computing midposition image",midp.error_message.c_str());
 448     else {
 449       QFileInfo info(midp.slicer_manager->GetFileName().c_str());
 450       AddImage(midp.output,info.path().toStdString()+"/"+info.completeBaseName().toStdString()+"_midposition.mhd");
 451     }
 452     QApplication::restoreOverrideCursor();
 453   }
 454 }
 455 //------------------------------------------------------------------------------
 456
 457
 458 //------------------------------------------------------------------------------
 459 void vvMainWindow::AddContour(int image_index, vvMesh::Pointer contour, bool propagation)
 460 {
 461   QTreeWidgetItem *item = new QTreeWidgetItem();
 462   item->setData(0,Qt::UserRole,"filename.vtk");
 463   item->setData(1,Qt::UserRole,tr("contour"));
 464   QBrush brush;
 465   brush.setColor(QColor(contour->r*255,contour->g*255,contour->b*255));
 466   brush.setStyle(Qt::SolidPattern);
 467   item->setData(COLUMN_IMAGE_NAME,Qt::BackgroundRole,brush);
 468   //  item->setData(COLUMN_IMAGE_NAME,Qt::DisplayRole,contour->structure_name.c_str());
 469
 470   for (int j = 1; j <= 4; j++)
 471     item->setData(j,Qt::CheckStateRole,DataTree->topLevelItem(image_index)->data(j,Qt::CheckStateRole));
 472
 473   QTreePushButton* cButton = new QTreePushButton;
 474   cButton->setItem(item);
 475   cButton->setColumn(COLUMN_CLOSE_IMAGE);
 476   cButton->setToolTip(tr("close image"));
 477   cButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/exit.png")));
 478   connect(cButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
 479     this,SLOT(CloseImage(QTreeWidgetItem*, int)));
 480
 481   QTreePushButton* rButton = new QTreePushButton;
 482   rButton->setItem(item);
 483   rButton->setColumn(COLUMN_RELOAD_IMAGE);
 484   rButton->setToolTip(tr("reload image"));
 485   rButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/rotateright.png")));
 486   rButton->setEnabled(false);
 487   //Not implemented
 488   //connect(rButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
 489   //this,SLOT(ReloadImage(QTreeWidgetItem*, int)));
 490
 491   DataTree->topLevelItem(image_index)->setExpanded(1);
 492   DataTree->topLevelItem(image_index)->addChild(item);
 493   DataTree->setItemWidget(item, COLUMN_CLOSE_IMAGE, cButton);
 494   DataTree->setItemWidget(item, COLUMN_RELOAD_IMAGE, rButton);
 495   QString id = DataTree->topLevelItem(image_index)->data(COLUMN_IMAGE_NAME,Qt::UserRole).toString();
 496   item->setData(COLUMN_IMAGE_NAME,Qt::UserRole,id.toStdString().c_str());
 497
 498   UpdateTree();
 499   mSlicerManagers[image_index]->AddContour(contour,propagation);
 500   mSlicerManagers[image_index]->Render();
 501 }
 502 //------------------------------------------------------------------------------
 503
 504
 505 //------------------------------------------------------------------------------
 506 void vvMainWindow::OpenVTKContour()
 507 {
 508   if (mSlicerManagers.size() > 0) {
 509     QString Extensions = "Images ( *.vtk *.obj)";
 510     Extensions += ";;All Files (*)";
 511     QString file = QFileDialog::getOpenFileName(this,tr("Open vtkPolyData"),mInputPathName,Extensions);
 512     if (file.isNull())
 513       return;
 514     QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 515     int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
 516     vvMeshReader reader;
 517     reader.SetImage(mSlicerManagers[index]->GetImage());
 518     reader.SetModeToVTK();
 519     reader.SetFilename(file.toStdString());
 520     reader.Update();
 521     AddContour(index,reader.GetOutput()[0],false);
 522     QApplication::restoreOverrideCursor();
 523   }
 524 }
 525 //------------------------------------------------------------------------------
 526
 527
 528 //------------------------------------------------------------------------------
 529 void vvMainWindow::AddDCStructContour(int index, QString file)
 530 {
 531   vvMeshReader reader;
 532   reader.SetFilename(file.toStdString());
 533   vvStructSelector selector;
 534   selector.SetStructures(reader.GetROINames());
 535   if (!mSlicerManagers[index]->GetVF().IsNull())
 536     selector.EnablePropagationCheckBox();
 537   if (selector.exec()) {
 538     QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 539     reader.SetSelectedItems(selector.getSelectedItems());
 540     reader.SetImage(mSlicerManagers[index]->GetImage());
 541     if (selector.PropagationEnabled())
 542       reader.SetPropagationVF(mSlicerManagers[index]->GetVF());
 543     reader.Update();
 544     std::vector<vvMesh::Pointer> contours=reader.GetOutput();
 545     for (std::vector<vvMesh::Pointer>::iterator i=contours.begin();
 546       i!=contours.end(); i++)
 547       AddContour(index,*i,selector.PropagationEnabled());
 548     QApplication::restoreOverrideCursor();
 549   }
 550 }
 551
 552 //------------------------------------------------------------------------------
 553 void vvMainWindow::OpenDCStructContour()
 554 {
 555   if (mSlicerManagers.size() > 0) {
 556     QString Extensions = "Dicom Files ( *.dcm RS*)";
 557     Extensions += ";;All Files (*)";
 558     QString file = QFileDialog::getOpenFileName(this,tr("Merge Images"),mInputPathName,Extensions);
 559     if (file.isNull())
 560       return;
 561     int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
 562     AddDCStructContour(index, file);
 563   }
 564 }
 565 //------------------------------------------------------------------------------
 566
 567
 568 //------------------------------------------------------------------------------
 569 void vvMainWindow::ComputeDeformableRegistration()
 570 {
 571   if (mSlicerManagers.size() > 0) {
 572     int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
 573     vvDeformationDialog dialog(index,mSlicerManagers);
 574     if (dialog.exec()) {
 575       std::string base_name=itksys::SystemTools::GetFilenameWithoutExtension(mSlicerManagers[dialog.GetInputFileIndex()]->GetFileName());
 576       AddField(dialog.GetOutput(),dialog.getFieldFile(),dialog.GetInputFileIndex());
 577       WarpImage(dialog.GetSelectedSlicer(),dialog.GetReferenceFrameIndex());
 578     } else
 579       std::cout << "Error or user cancellation while computing deformation field..." << std::endl;
 580   } else QMessageBox::information(this, "Need to open image","You must open an image first.");
 581 }
 582 //------------------------------------------------------------------------------
 583
 584
 585 //------------------------------------------------------------------------------
 586 void vvMainWindow::WarpImage()
 587 {
 588   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
 589   if (!mSlicerManagers[index]->GetVF().IsNull()) {
 590     bool ok;
 591     int ref = QInputDialog::getInt(this,"Chose reference phase","Reference phase",0,0,\
 592       mSlicerManagers[index]->GetImage()->GetVTKImages().size()-1,1,&ok);
 593     if (ok) {
 594       WarpImage(mSlicerManagers[index],ref);
 595     }
 596   } else
 597     QMessageBox::warning(this,tr("No vector field"),tr("Sorry, can't warp without a vector field"));
 598 }
 599 //------------------------------------------------------------------------------
 600
 601
 602 //------------------------------------------------------------------------------
 603 void vvMainWindow::WarpImage(vvSlicerManager* selected_slicer,int reference_phase)
 604 {
 605   if (!selected_slicer->GetVF().IsNull()) {
 606     QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 607     QFileInfo info(selected_slicer->GetFileName().c_str());
 608     vvImageWarp warp(selected_slicer->GetImage(),selected_slicer->GetVF(),
 609       reference_phase,this);
 610     if (warp.ComputeWarpedImage()) {
 611       AddImage(warp.GetWarpedImage(),info.path().toStdString()+"/"+info.completeBaseName().toStdString()+"_warped.mhd");
 612       AddImage(warp.GetDiffImage()  ,info.path().toStdString()+"/"+info.completeBaseName().toStdString()+"_diff.mhd");
 613       AddImage(warp.GetJacobianImage()  ,info.path().toStdString()+"/"+info.completeBaseName().toStdString()+"_jacobian.mhd");
 614       QApplication::restoreOverrideCursor();
 615     } else {
 616       QApplication::restoreOverrideCursor();
 617       QMessageBox::warning(this,tr("Different spacings"),tr("The vector field and image spacings must be the same in order to warp."));
 618     }
 619   } else
 620     QMessageBox::warning(this,tr("No vector field"),tr("Sorry, can't warp without a vector field."));
 621 }
 622 //------------------------------------------------------------------------------
 623
 624
 625 //------------------------------------------------------------------------------
 626 vvMainWindow::~vvMainWindow()
 627 {
 628   for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
 629     if (mSlicerManagers[i] != NULL)
 630       delete mSlicerManagers[i];
 631   }
 632   delete documentation;
 633   delete help_dialog;
 634   delete dicomSeriesSelector;
 635 }
 636 //------------------------------------------------------------------------------
 637
 638 //------------------------------------------------------------------------------
 639 QTabWidget * vvMainWindow::GetTab()
 640 {
 641   return tabWidget;
 642 }
 643 //------------------------------------------------------------------------------
 644
 645
 646 //------------------------------------------------------------------------------
 647 void vvMainWindow::MergeImages()
 648 {
 649   QString Extensions = EXTENSIONS;
 650   Extensions += ";;All Files (*)";
 651   QStringList files = QFileDialog::getOpenFileNames(this,tr("Merge Images"),mInputPathName,Extensions);
 652   if (files.isEmpty())
 653     return;
 654   mInputPathName = itksys::SystemTools::GetFilenamePath(files[0].toStdString()).c_str();
 655   std::vector<std::string> vector;
 656
 657   unsigned int currentDim = 0;
 658   std::vector<double> currentSpacing;
 659   std::vector<int> currentSize;
 660   std::vector<double> currentOrigin;
 661
 662   for (int i = 0; i < files.size(); i++) {
 663     itk::ImageIOBase::Pointer reader = itk::ImageIOFactory::CreateImageIO(
 664       files[i].toStdString().c_str(), itk::ImageIOFactory::ReadMode);
 665     reader->SetFileName(files[i].toStdString().c_str());
 666     reader->ReadImageInformation();
 667     if (reader)        {
 668       //NOViewWidget->hide();
 669       //NEViewWidget->hide();
 670       //SOViewWidget->hide();
 671       //SEViewWidget->hide();
 672       if (i == 0)
 673         currentDim = reader->GetNumberOfDimensions();
 674       bool IsOk = true;
 675       for (unsigned int j = 0; j < currentDim; j++) {
 676         if (i == 0) {
 677           if (j == 0) {
 678             currentSpacing.resize(currentDim);
 679             currentSize.resize(currentDim);
 680             currentOrigin.resize(currentDim);
 681           }
 682           currentOrigin[j] = reader->GetOrigin(j);
 683           currentSpacing[j] = reader->GetSpacing(j);
 684           currentSize[j] = reader->GetDimensions(j);
 685         } else if (currentDim != reader->GetNumberOfDimensions()
 686           || currentSpacing[j] != reader->GetSpacing(j)
 687           || currentSize[j] != (int)reader->GetDimensions(j)
 688           || currentOrigin[j] != reader->GetOrigin(j)) {
 689             QString error = "Cannot read file (too different from others ";
 690             error += files[i].toStdString().c_str();
 691             QMessageBox::information(this,tr("Reading problem"),error);
 692             IsOk = false;
 693             break;
 694         }
 695       }
 696       if (IsOk)
 697         vector.push_back(files[i].toStdString());
 698     }
 699   }
 700   if (vector.size() > 0)
 701     LoadImages(vector, vvImageReader::MERGED);
 702 }
 703 //------------------------------------------------------------------------------
 704
 705 //------------------------------------------------------------------------------
 706 void vvMainWindow::SliceImages()
 707 {
 708   QString Extensions = EXTENSIONS;
 709   Extensions += ";;All Files (*)";
 710
 711   QStringList files = QFileDialog::getOpenFileNames(this,tr("Slice Images"),mInputPathName,Extensions);
 712   if (files.isEmpty())
 713     return;
 714   mInputPathName = itksys::SystemTools::GetFilenamePath(files[0].toStdString()).c_str();
 715   std::vector<std::string> vector;
 716   for (int i = 0; i < files.size(); i++)
 717     vector.push_back(files[i].toStdString());
 718   LoadImages(vector, vvImageReader::SLICED);
 719 }
 720 //------------------------------------------------------------------------------
 721
 722 //------------------------------------------------------------------------------
 723 void vvMainWindow::MergeImagesWithTime()
 724 {
 725   QString Extensions = EXTENSIONS;
 726   Extensions += ";;All Files (*)";
 727   QStringList files = QFileDialog::getOpenFileNames(this,tr("Merge Images With Time"),mInputPathName,Extensions);
 728   if (files.isEmpty())
 729     return;
 730   mInputPathName = itksys::SystemTools::GetFilenamePath(files[0].toStdString()).c_str();
 731   std::vector<std::string> vector;
 732
 733   for (int i = 0; i < files.size(); i++)
 734     vector.push_back(files[i].toStdString());
 735   sort(vector.begin(),vector.end());
 736   if (vector.size() > 1)
 737     LoadImages(vector, vvImageReader::MERGEDWITHTIME);
 738   else
 739     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.");
 740 }
 741 //------------------------------------------------------------------------------
 742
 743
 744 //------------------------------------------------------------------------------
 745 void vvMainWindow::OpenDicom()
 746 {
 747   std::vector<std::string> files;
 748
 749   //std::cout << "dicomSeriesSelector " << std::endl;
 750   if (dicomSeriesSelector->exec() == QDialog::Accepted) {
 751     files = *(dicomSeriesSelector->GetFilenames());
 752     LoadImages(files, vvImageReader::DICOM);
 753   }
 754 }
 755 //------------------------------------------------------------------------------
 756
 757 //------------------------------------------------------------------------------
 758 void vvMainWindow::OpenImages()
 759 {
 760   QString Extensions = EXTENSIONS;
 761   Extensions += ";;All Files (*)";
 762
 763   QStringList files = QFileDialog::getOpenFileNames(this,tr("Load Images"),mInputPathName,Extensions);
 764   if (files.isEmpty())
 765     return;
 766   mInputPathName = itksys::SystemTools::GetFilenamePath(files[0].toStdString()).c_str();
 767   std::vector<std::string> vector;
 768   for (int i = 0; i < files.size(); i++)
 769     vector.push_back(files[i].toStdString());
 770   LoadImages(vector, vvImageReader::IMAGE);
 771 }
 772 //------------------------------------------------------------------------------
 773 void vvMainWindow::OpenRecentImage()
 774 {
 775   QAction * caller = qobject_cast<QAction*>(sender());
 776   std::vector<std::string> images;
 777   images.push_back(caller->text().toStdString());
 778   mInputPathName = itksys::SystemTools::GetFilenamePath(images[0]).c_str();
 779   LoadImages(images, vvImageReader::IMAGE);
 780 }
 781 //------------------------------------------------------------------------------
 782
 783
 784 //------------------------------------------------------------------------------
 785 void vvMainWindow::OpenImageWithTime()
 786 {
 787   QString Extensions = EXTENSIONS;
 788   Extensions += ";;All Files (*)";
 789
 790   QStringList files = QFileDialog::getOpenFileNames(this,tr("Load Images With Time"),mInputPathName,Extensions);
 791   if (files.isEmpty())
 792     return;
 793   mInputPathName = itksys::SystemTools::GetFilenamePath(files[0].toStdString()).c_str();
 794   std::vector<std::string> vector;
 795   for (int i = 0; i < files.size(); i++) {
 796     vector.push_back(files[i].toStdString());
 797   }
 798   LoadImages(vector, vvImageReader::IMAGEWITHTIME);
 799 }
 800 //------------------------------------------------------------------------------
 801
 802
 803 //------------------------------------------------------------------------------
 804 void vvMainWindow::LoadImages(std::vector<std::string> files, vvImageReader::LoadedImageType filetype)
 805 {
 806   //Separate the way to open images and dicoms
 807   int fileSize;
 808   if (filetype == vvImageReader::IMAGE || filetype == vvImageReader::IMAGEWITHTIME)
 809     fileSize = files.size();
 810   else
 811     fileSize = 1;
 812
 813   // For SLICED, we need the number of slices (ndim and #slices)
 814   std::vector<unsigned int> nSlices;
 815   nSlices.resize(files.size());
 816   std::fill(nSlices.begin(), nSlices.end(), 1);
 817   if (filetype == vvImageReader::SLICED) {
 818     for (int i = 0; i < fileSize; i++) {
 819       itk::ImageIOBase::Pointer header = clitk::readImageHeader(files[i]);
 820       QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 821       if (!header) {
 822         nSlices[i] = 0;
 823         QString error = "Cannot open file \n";
 824         error += files[i].c_str();
 825         QMessageBox::information(this,tr("Reading problem"),error);
 826         return;
 827       }
 828       if (header->GetNumberOfDimensions() < 3) {
 829         nSlices[i] = 0;
 830         QString error = "Dimension problem. Cannot slice \n";
 831         error += files[i].c_str();
 832         QMessageBox::information(this,tr("Reading problem"),error);
 833         return;
 834       }
 835       nSlices[i] = header->GetDimensions( header->GetNumberOfDimensions()-1 );
 836     }
 837   }
 838
 839   //Only add to the list of recently opened files when a single file is opened,
 840   //to avoid polluting the list of recently opened files
 841   if (files.size() == 1) {
 842     QFileInfo finfo=tr(files[0].c_str());
 843     AddToRecentlyOpenedImages(finfo.absoluteFilePath().toStdString());
 844     updateRecentlyOpenedFilesMenu(GetRecentlyOpenedImages());
 845   }
 846   //init the progress events
 847   QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 848   vvProgressDialog progress("Opening " + files[0],fileSize>1);
 849   qApp->processEvents();
 850
 851   int numberofsuccesulreads=0;
 852   //open images as 1 or multiples
 853   for (int i = 0; i < fileSize; i++) {
 854     progress.SetText("Opening " + files[i]);
 855     progress.SetProgress(i,fileSize);
 856     qApp->processEvents();
 857
 858     for (unsigned int j = 0; j < nSlices[i]; j++) {
 859       //read the image and put it in mSlicerManagers
 860       vvSlicerManager* imageManager = new vvSlicerManager(4);
 861       qApp->processEvents();
 862
 863       bool SetImageSucceed=false;
 864
 865       // Change filename if an image with the same already exist
 866       int number = GetImageDuplicateFilenameNumber(files[i] + std::string("_slice"));
 867
 868       if (filetype == vvImageReader::IMAGE || filetype == vvImageReader::IMAGEWITHTIME || filetype == vvImageReader::SLICED) {
 869         SetImageSucceed = imageManager->SetImage(files[i],filetype, number, j);
 870       } else {
 871         SetImageSucceed = imageManager->SetImages(files,filetype, number);
 872       }
 873       if (!SetImageSucceed) {
 874         QApplication::restoreOverrideCursor();
 875         QString error = "Cannot open file \n";
 876         error += imageManager->GetLastError().c_str();
 877         QMessageBox::information(this,tr("Reading problem"),error);
 878         delete imageManager;
 879       } else {
 880
 881         mSlicerManagers.push_back(imageManager);
 882
 883         //create an item in the tree with good settings
 884         QTreeWidgetItem *item = new QTreeWidgetItem();
 885         item->setData(0,Qt::UserRole,files[i].c_str());
 886         QFileInfo fileinfo(imageManager->GetFileName().c_str()); //Do not show the path
 887         item->setData(COLUMN_IMAGE_NAME,Qt::DisplayRole,fileinfo.fileName());
 888         item->setData(1,Qt::UserRole,tr("image"));
 889         item->setToolTip(COLUMN_IMAGE_NAME, imageManager->GetListOfAbsoluteFilePathInOneString("image").c_str());
 890         qApp->processEvents();
 891
 892         //Create the buttons for reload and close
 893         qApp->processEvents();
 894         QTreePushButton* cButton = new QTreePushButton;
 895         cButton->setItem(item);
 896         cButton->setColumn(COLUMN_CLOSE_IMAGE);
 897         cButton->setToolTip(tr("close image"));
 898         cButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/exit.png")));
 899         connect(cButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
 900           this,SLOT(CloseImage(QTreeWidgetItem*, int)));
 901
 902         QTreePushButton* rButton = new QTreePushButton;
 903         rButton->setItem(item);
 904         rButton->setColumn(COLUMN_RELOAD_IMAGE);
 905         rButton->setToolTip(tr("reload image"));
 906         rButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/rotateright.png")));
 907         connect(rButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
 908           this,SLOT(ReloadImage(QTreeWidgetItem*, int)));
 909
 910         DataTree->addTopLevelItem(item);
 911         DataTree->setItemWidget(item, COLUMN_CLOSE_IMAGE, cButton);
 912         DataTree->setItemWidget(item, COLUMN_RELOAD_IMAGE, rButton);
 913
 914         //set the id of the image
 915         QString id = QDir::current().absoluteFilePath(files[i].c_str()) + QString::number(mSlicerManagers.size()-1);
 916         item->setData(COLUMN_IMAGE_NAME,Qt::UserRole,id.toStdString().c_str());
 917         mSlicerManagers.back()->SetId(id.toStdString());
 918
 919         linkPanel->addImage(imageManager->GetFileName(), id.toStdString());
 920
 921         connect(mSlicerManagers.back(), SIGNAL(currentImageChanged(std::string)),
 922           this,SLOT(CurrentImageChanged(std::string)));
 923         connect(mSlicerManagers.back(), SIGNAL(currentPickedImageChanged(std::string)),
 924           this, SLOT(CurrentPickedImageChanged(std::string)));
 925         connect(mSlicerManagers.back(), SIGNAL(UpdatePosition(int, double, double, double, double, double, double, double)),
 926           this,SLOT(MousePositionChanged(int,double, double, double, double, double, double, double)));
 927         connect(mSlicerManagers.back(), SIGNAL(UpdateVector(int, double, double, double, double)),
 928           this, SLOT(VectorChanged(int,double,double,double, double)));
 929         connect(mSlicerManagers.back(), SIGNAL(UpdateOverlay(int, double, double)),
 930           this, SLOT(OverlayChanged(int,double,double)));
 931         connect(mSlicerManagers.back(), SIGNAL(UpdateFusion(int, double)),
 932           this, SLOT(FusionChanged(int,double)));
 933         connect(mSlicerManagers.back(), SIGNAL(WindowLevelChanged()),
 934           this,SLOT(WindowLevelChanged()));
 935         connect(mSlicerManagers.back(), SIGNAL(UpdateSlice(int,int)),
 936           this,SLOT(UpdateSlice(int,int)));
 937         connect(mSlicerManagers.back(), SIGNAL(UpdateTSlice(int, int, int)),
 938           this,SLOT(UpdateTSlice(int, int, int)));
 939         connect(mSlicerManagers.back(), SIGNAL(UpdateTSlice(int, int, int)),
 940           this,SLOT(ImageInfoChanged()));
 941         connect(mSlicerManagers.back(), SIGNAL(UpdateSliceRange(int,int,int,int,int)),
 942           this,SLOT(UpdateSliceRange(int,int,int,int,int)));
 943         connect(mSlicerManagers.back(), SIGNAL(UpdateLinkManager(std::string,int,double,double,double,int)),
 944           this,SLOT(UpdateLinkManager(std::string,int,double,double,double,int)));
 945         connect(mSlicerManagers.back(), SIGNAL(UpdateLinkedNavigation(std::string,vvSlicerManager*,vvSlicer*)),
 946           this,SLOT(UpdateLinkedNavigation(std::string,vvSlicerManager*,vvSlicer*)));
 947         connect(mSlicerManagers.back(), SIGNAL(ChangeImageWithIndexOffset(vvSlicerManager*,int,int)),
 948           this,SLOT(ChangeImageWithIndexOffset(vvSlicerManager*,int,int)));
 949         connect(mSlicerManagers.back(),SIGNAL(LandmarkAdded()),landmarksPanel,SLOT(AddPoint()));
 950         InitSlicers();
 951         numberofsuccesulreads++;
 952       }
 953     }
 954   }
 955
 956   if (numberofsuccesulreads) {
 957     NOViewWidget->show();
 958     NEViewWidget->show();
 959     SOViewWidget->show();
 960     SEViewWidget->show();
 961     UpdateTree();
 962     InitDisplay();
 963     ShowLastImage();
 964
 965     // Try to guess default WindowLevel
 966     double range[2];
 967     mSlicerManagers.back()->GetImage()->GetFirstVTKImageData()->GetScalarRange(range);
 968     if ((range[0] == 0) && (range[1] == 1)) {
 969       presetComboBox->setCurrentIndex(WL_BINARY);// binary
 970     } else {
 971       // TODO
 972     }
 973   }
 974   QApplication::restoreOverrideCursor();
 975 }
 976 //------------------------------------------------------------------------------
 977
 978 //------------------------------------------------------------------------------
 979 void vvMainWindow::UpdateTree()
 980 {
 981   DataTree->resizeColumnToContents(COLUMN_TREE);
 982   DataTree->resizeColumnToContents(COLUMN_UL_VIEW);
 983   DataTree->resizeColumnToContents(COLUMN_UR_VIEW);
 984   DataTree->resizeColumnToContents(COLUMN_DL_VIEW);
 985   DataTree->resizeColumnToContents(COLUMN_DR_VIEW);
 986   DataTree->resizeColumnToContents(COLUMN_IMAGE_NAME);
 987   DataTree->resizeColumnToContents(COLUMN_CLOSE_IMAGE);
 988   DataTree->resizeColumnToContents(COLUMN_RELOAD_IMAGE);
 989 }
 990 //------------------------------------------------------------------------------
 991
 992 //------------------------------------------------------------------------------
 993 void vvMainWindow::CurrentImageChanged(std::string id)
 994 {
 995   if (id == mCurrentSelectedImageId) return; // Do nothing
 996   int selected = 0;
 997   for (int i = 0; i < DataTree->topLevelItemCount(); i++) {
 998     if (DataTree->topLevelItem(i)->data(COLUMN_IMAGE_NAME,Qt::UserRole).toString().toStdString() == id) {
 999       selected = i;
1000     } else {
1001       DataTree->topLevelItem(i)->setSelected(0);
1002     }
1003     for (int child = 0; child < DataTree->topLevelItem(i)->childCount(); child++)
1004       DataTree->topLevelItem(i)->child(child)->setSelected(0);
1005
1006   }
1007   DataTree->topLevelItem(selected)->setSelected(1);
1008   mCurrentSelectedImageId = id;
1009
1010   landmarksPanel->SetCurrentLandmarks(mSlicerManagers[selected]->GetLandmarks(),
1011                                       mSlicerManagers[selected]->GetTSlice());
1012   landmarksPanel->SetCurrentPath(mInputPathName.toStdString());
1013   landmarksPanel->SetCurrentImage(mSlicerManagers[selected]->GetFileName().c_str());
1014
1015   emit SelectedImageHasChanged(mSlicerManagers[selected]);
1016 }
1017 //------------------------------------------------------------------------------
1018
1019 //------------------------------------------------------------------------------
1020 void vvMainWindow::CurrentPickedImageChanged(std::string id)
1021 {
1022   if (id == mCurrentPickedImageId) return; // Do nothing
1023   int selected = 0;
1024   for (int i = 0; i < DataTree->topLevelItemCount(); i++) {
1025     if (DataTree->topLevelItem(i)->data(COLUMN_IMAGE_NAME,Qt::UserRole).toString().toStdString() == id) {
1026       selected = i;
1027     } else {
1028       DataTree->topLevelItem(i)->setSelected(0);
1029     }
1030     for (int child = 0; child < DataTree->topLevelItem(i)->childCount(); child++)
1031       DataTree->topLevelItem(i)->child(child)->setSelected(0);
1032
1033   }
1034   DataTree->topLevelItem(selected)->setSelected(1);
1035   mCurrentPickedImageId = id;
1036   mCurrentPickedImageIndex = selected;
1037 }
1038 //------------------------------------------------------------------------------
1039
1040 //------------------------------------------------------------------------------
1041 void vvMainWindow::ImageInfoChanged()
1042 {
1043   contextActions[6]->setEnabled(1);
1044   contextActions[5]->setEnabled(1);
1045   actionSave_As->setEnabled(1);
1046   actionAdd_VF_to_current_Image->setEnabled(1);
1047   actionAdd_fusion_image->setEnabled(1);
1048   actionAdd_overlay_image_to_current_image->setEnabled(1);
1049   actionAdd_USSequence_toCT->setEnabled(1);
1050   actionNorth_East_Window->setEnabled(1);
1051   actionNorth_West_Window->setEnabled(1);
1052   actionSouth_East_Window->setEnabled(1);
1053   actionSouth_West_Window->setEnabled(1);
1054   vvToolManager::GetInstance()->EnableToolsInMenu(this, true);
1055   inverseButton->setEnabled(1);
1056
1057   goToCursorPushButton->setEnabled(1);
1058
1059   if (DataTree->selectedItems().size()) {
1060     int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
1061
1062     colorMapComboBox->setEnabled(1);
1063     for (int i = 0; i < DataTree->topLevelItem(index)->childCount(); i++) {
1064       if (DataTree->topLevelItem(index)->child(i)->data(1,Qt::UserRole).toString() == "overlay" ||
1065         DataTree->topLevelItem(index)->child(i)->data(1,Qt::UserRole).toString() == "fusion" ||
1066         DataTree->topLevelItem(index)->child(i)->data(1,Qt::UserRole).toString() == "fusionSequence") {
1067           colorMapComboBox->setEnabled(0);
1068           break;
1069       }
1070     }
1071
1072     std::vector<double> origin;
1073     std::vector<double> inputSpacing;
1074     std::vector<int> inputSize;
1075     std::vector<double> sizeMM;
1076     vtkSmartPointer<vtkMatrix4x4> transformation;
1077     int dimension=0;
1078     QString pixelType;
1079     QString inputSizeInBytes;
1080     QString image = DataTree->selectedItems()[0]->data(COLUMN_IMAGE_NAME,Qt::DisplayRole).toString();
1081
1082     int nframes = mSlicerManagers[index]->GetSlicer(0)->GetTMax();
1083
1084     if (nframes > 1 || playMode == 1) {
1085       playButton->setEnabled(1);
1086       frameRateLabel->setEnabled(1);
1087       frameRateSpinBox->setEnabled(1);
1088     } else {
1089       playButton->setEnabled(0);
1090       frameRateLabel->setEnabled(0);
1091       frameRateSpinBox->setEnabled(0);
1092     }
1093
1094     //read image header
1095     int NPixel = 1;
1096
1097     int tSlice = 0;
1098     vvImage::Pointer imageSelected;
1099     if (DataTree->topLevelItem(index) == DataTree->selectedItems()[0]) {
1100       imageSelected = mSlicerManagers[index]->GetSlicer(0)->GetImage();
1101       tSlice = mSlicerManagers[index]->GetSlicer(0)->GetTSlice();
1102     } else if (DataTree->selectedItems()[0]->data(1,Qt::UserRole).toString() == "vector") {
1103       imageSelected = mSlicerManagers[index]->GetSlicer(0)->GetVF();
1104       tSlice = mSlicerManagers[index]->GetSlicer(0)->GetOverlayTSlice();
1105     } else if (DataTree->selectedItems()[0]->data(1,Qt::UserRole).toString() == "overlay") {
1106       imageSelected = mSlicerManagers[index]->GetSlicer(0)->GetOverlay();
1107       tSlice = mSlicerManagers[index]->GetSlicer(0)->GetOverlayTSlice();
1108     } else if (DataTree->selectedItems()[0]->data(1,Qt::UserRole).toString() == "fusion") {
1109       imageSelected = mSlicerManagers[index]->GetSlicer(0)->GetFusion();
1110       tSlice = mSlicerManagers[index]->GetSlicer(0)->GetFusionTSlice();
1111     }
1112     else if (DataTree->selectedItems()[0]->data(1,Qt::UserRole).toString() == "fusionSequence") {
1113       imageSelected = mSlicerManagers[index]->GetSlicer(0)->GetFusion();
1114       tSlice = mSlicerManagers[index]->GetSlicer(0)->GetFusionTSlice();
1115     }
1116     else if (DataTree->selectedItems()[0]->data(1,Qt::UserRole).toString() == "contour") {
1117       imageSelected = mSlicerManagers[index]->GetSlicer(0)->GetImage();
1118       tSlice = mSlicerManagers[index]->GetSlicer(0)->GetTSlice();
1119     }
1120     else {
1121       imageSelected = mSlicerManagers[index]->GetSlicer(0)->GetImage();
1122       tSlice = mSlicerManagers[index]->GetSlicer(0)->GetTSlice();
1123     }
1124
1125     dimension = imageSelected->GetNumberOfDimensions();
1126     origin.resize(dimension);
1127     inputSpacing.resize(dimension);
1128     inputSize.resize(dimension);
1129     sizeMM.resize(dimension);
1130     pixelType = mSlicerManagers[index]->GetImage()->GetScalarTypeAsITKString().c_str();
1131     for (int i = 0; i < dimension; i++) {
1132       origin[i] = imageSelected->GetOrigin()[i];
1133       inputSpacing[i] = imageSelected->GetSpacing()[i];
1134       inputSize[i] = imageSelected->GetSize()[i];
1135       sizeMM[i] = inputSize[i]*inputSpacing[i];
1136       NPixel *= inputSize[i];
1137     }
1138     inputSizeInBytes = GetSizeInBytes(imageSelected->GetActualMemorySize()*1000);
1139
1140     QString dim = QString::number(dimension) + " (";
1141     dim += pixelType + ")";
1142
1143     infoPanel->setFileName(image);
1144     std::string creationImageTimeValue("No creation time");
1145     itk::ExposeMetaData< std::string > (*imageSelected->GetFirstMetaDataDictionary(), "creationImageTime", creationImageTimeValue);
1146     infoPanel->setImageCreationTime(QString(creationImageTimeValue.c_str()));
1147     infoPanel->setDimension(dim);
1148     infoPanel->setSizePixel(GetVectorIntAsString(inputSize));
1149     infoPanel->setSizeMM(GetVectorDoubleAsString(sizeMM));
1150     infoPanel->setOrigin(GetVectorDoubleAsString(origin));
1151     infoPanel->setSpacing(GetVectorDoubleAsString(inputSpacing));
1152     infoPanel->setNPixel(QString::number(NPixel)+" ("+inputSizeInBytes+")");
1153
1154     transformation = imageSelected->GetTransform()[tSlice]->GetMatrix();
1155     infoPanel->setTransformation(clitk::Get4x4MatrixDoubleAsString(transformation).c_str());
1156
1157     landmarksPanel->SetCurrentLandmarks(mSlicerManagers[index]->GetLandmarks(),
1158                                         mSlicerManagers[index]->GetTSlice());
1159     landmarksPanel->SetCurrentPath(mInputPathName.toStdString());
1160     landmarksPanel->SetCurrentImage(mSlicerManagers[index]->GetFileName().c_str());
1161
1162     overlayPanel->getCurrentImageName(mSlicerManagers[index]->GetFileName().c_str());
1163     for (int i = 0; i < 4; i++) {
1164       if (DataTree->selectedItems()[0]->data(i+1,Qt::CheckStateRole).toInt() > 0 || i == 3) {
1165         mSlicerManagers[index]->UpdateInfoOnCursorPosition(i);
1166         break;
1167       }
1168     }
1169
1170 //     infoPanel->setFileName(image);
1171 //     infoPanel->setDimension(dim);
1172 //     infoPanel->setSizePixel(GetVectorIntAsString(inputSize));
1173 //     infoPanel->setSizeMM(GetVectorDoubleAsString(sizeMM));
1174 //     infoPanel->setOrigin(GetVectorDoubleAsString(origin));
1175 //     infoPanel->setSpacing(GetVectorDoubleAsString(inputSpacing));
1176 //     infoPanel->setNPixel(QString::number(NPixel)+" ("+inputSizeInBytes+")");
1177 //
1178 //     landmarksPanel->SetCurrentLandmarks(mSlicerManagers[index]->GetLandmarks(),
1179 //                                         mSlicerManagers[index]->GetTSlice());
1180 //     landmarksPanel->SetCurrentPath(mInputPathName.toStdString());
1181 //     landmarksPanel->SetCurrentImage(mSlicerManagers[index]->GetFileName().c_str());
1182 //
1183 //     overlayPanel->getCurrentImageName(mSlicerManagers[index]->GetFileName().c_str());
1184 //     for (int i = 0; i < 4; i++) {
1185 //       if (DataTree->selectedItems()[0]->data(i+1,Qt::CheckStateRole).toInt() > 0 || i == 3) {
1186 //         mSlicerManagers[index]->UpdateInfoOnCursorPosition(i);
1187 //         break;
1188 //       }
1189 //     }
1190     WindowLevelChanged();
1191
1192     slicingPresetComboBox->setCurrentIndex(mSlicerManagers[index]->GetSlicingPreset());
1193
1194     if (mSlicerManagers[index]->GetSlicer(0)->GetVF()) {
1195       overlayPanel->getVFName(mSlicerManagers[index]->GetVFName().c_str());
1196       overlayPanel->getVFProperty(mSlicerManagers[index]->GetSlicer(0)->GetVFSubSampling(),
1197         mSlicerManagers[index]->GetSlicer(0)->GetVFScale(),
1198         mSlicerManagers[index]->GetSlicer(0)->GetVFLog());
1199     } else {
1200       overlayPanel->getVFName(mSlicerManagers[index]->GetVFName().c_str());
1201       overlayPanel->getVFProperty(-1,-1,-1);
1202     }
1203     if (mSlicerManagers[index]->GetSlicer(0)->GetOverlay()) {
1204       overlayPanel->getOverlayName(mSlicerManagers[index]->GetOverlayName().c_str());
1205     } else {
1206       overlayPanel->getOverlayName(mSlicerManagers[index]->GetOverlayName().c_str());
1207     }
1208
1209     if (mSlicerManagers[index]->GetSlicer(0)->GetFusion()) {
1210       overlayPanel->getFusionName(mSlicerManagers[index]->GetFusionName().c_str());
1211     } else {
1212       overlayPanel->getFusionName(mSlicerManagers[index]->GetFusionName().c_str());
1213     }
1214   }
1215 }
1216 //------------------------------------------------------------------------------
1217
1218 //------------------------------------------------------------------------------
1219 void vvMainWindow::ShowDocumentation()
1220 {
1221   documentation->show();
1222 }
1223 //------------------------------------------------------------------------------
1224
1225 //------------------------------------------------------------------------------
1226 void vvMainWindow::PopupRegisterForm(bool checkCanPush)
1227 {
1228   vvRegisterForm* registerForm = new vvRegisterForm(QUrl("http://www.creatis.insa-lyon.fr/~dsarrut/vvregister/write.php"), getVVSettingsPath(), getSettingsOptionFormat());
1229   if(!checkCanPush) {
1230     registerForm->show();
1231   } else {
1232     if(registerForm->canPush()) {
1233       registerForm->show();
1234       registerForm->acquitPushed();//too bad if there is not internet connection anymore.
1235     }
1236   }
1237 }
1238 //------------------------------------------------------------------------------
1239
1240 //------------------------------------------------------------------------------
1241 void vvMainWindow::ShowHelpDialog()
1242 {
1243   help_dialog->show();
1244 }
1245 //------------------------------------------------------------------------------
1246
1247 //------------------------------------------------------------------------------
1248 void vvMainWindow::ChangeViewMode()
1249 {
1250   typedef struct _SIZE{
1251     QSplitter* splitter;
1252     QList<int> size1, size2;
1253     int cols[3];
1254   }SplitterSize;
1255   SplitterSize sizes[4];
1256   sizes[0].splitter = OSplitter;
1257   sizes[0].size1.push_back(1);
1258   sizes[0].size1.push_back(0);
1259   sizes[0].size2.push_back(1);
1260   sizes[0].size2.push_back(0);
1261   sizes[0].cols[0] = 2;
1262   sizes[0].cols[1] = 3;
1263   sizes[0].cols[2] = 4;
1264
1265   sizes[1].splitter = ESplitter;
1266   sizes[1].size1.push_back(0);
1267   sizes[1].size1.push_back(1);
1268   sizes[1].size2.push_back(1);
1269   sizes[1].size2.push_back(0);
1270   sizes[1].cols[0] = 1;
1271   sizes[1].cols[1] = 3;
1272   sizes[1].cols[2] = 4;
1273
1274   sizes[2].splitter = OSplitter;
1275   sizes[2].size1.push_back(1);
1276   sizes[2].size1.push_back(0);
1277   sizes[2].size2.push_back(0);
1278   sizes[2].size2.push_back(1);
1279   sizes[2].cols[0] = 1;
1280   sizes[2].cols[1] = 2;
1281   sizes[2].cols[2] = 4;
1282
1283   sizes[3].splitter = ESplitter;
1284   sizes[3].size1.push_back(0);
1285   sizes[3].size1.push_back(1);
1286   sizes[3].size2.push_back(0);
1287   sizes[3].size2.push_back(1);
1288   sizes[3].cols[0] = 1;
1289   sizes[3].cols[1] = 2;
1290   sizes[3].cols[2] = 3;
1291
1292   int slicer = mSlicerManagers[mCurrentPickedImageIndex]->GetSelectedSlicer();
1293   if (viewMode == 1) {
1294     if (slicer >= 0) {
1295       viewMode = 0;
1296       splitter_3->setSizes(sizes[slicer].size1);
1297       sizes[slicer].splitter->setSizes(sizes[slicer].size2);
1298       DataTree->setColumnHidden(sizes[slicer].cols[0],1);
1299       DataTree->setColumnHidden(sizes[slicer].cols[1],1);
1300       DataTree->setColumnHidden(sizes[slicer].cols[2],1);
1301     }
1302   } else {
1303     QList<int> size;
1304     if (slicer >= 0) {
1305       viewMode = 1;
1306       size.push_back(1);
1307       size.push_back(1);
1308       splitter_3->setSizes(size);
1309       sizes[slicer].splitter->setSizes(size);
1310       DataTree->setColumnHidden(sizes[slicer].cols[0],0);
1311       DataTree->setColumnHidden(sizes[slicer].cols[1],0);
1312       DataTree->setColumnHidden(sizes[slicer].cols[2],0);
1313     }
1314   }
1315   UpdateRenderWindows();
1316   /*
1317   ** I don't know why but for both resized QVTKWidget we also need to render
1318   ** the associated Slicer to redraw crosses.
1319   */
1320   for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
1321     //     if (DataTree->topLevelItem(i)->data(COLUMN_UL_VIEW,Qt::CheckStateRole).toInt() > 1)
1322     mSlicerManagers[i]->GetSlicer(0)->Render();
1323     mSlicerManagers[i]->GetSlicer(1)->Render();
1324     //     if (DataTree->topLevelItem(i)->data(COLUMN_DL_VIEW,Qt::CheckStateRole).toInt() > 1)
1325     mSlicerManagers[i]->GetSlicer(2)->Render();
1326     mSlicerManagers[i]->GetSlicer(3)->Render();
1327   }
1328 }
1329 //------------------------------------------------------------------------------
1330
1331 //------------------------------------------------------------------------------
1332 QString vvMainWindow::GetSizeInBytes(unsigned long size)
1333 {
1334   QString result = "";// QString::number(size);
1335   //result += " bytes (";
1336   if (size > 1000000000) {
1337     size /= 1000000000;
1338     result += QString::number(size);
1339     result += "Gb";//)";
1340   } else if (size > 1000000) {
1341     size /= 1000000;
1342     result += QString::number(size);
1343     result += "Mb";//)";
1344   } else if (size > 1000) {
1345     size /= 1000;
1346     result += QString::number(size);
1347     result += "kb";//)";
1348   }
1349   return result;
1350 }
1351 //------------------------------------------------------------------------------
1352
1353 //------------------------------------------------------------------------------
1354 QString vvMainWindow::GetVectorDoubleAsString(std::vector<double> vectorDouble)
1355 {
1356   QString result;
1357   for (unsigned int i= 0; i < vectorDouble.size(); i++) {
1358     if (i != 0)
1359       result += " ";
1360     result += QString::number(vectorDouble[i]);
1361   }
1362   return result;
1363 }
1364 //------------------------------------------------------------------------------
1365
1366 //------------------------------------------------------------------------------
1367 QString vvMainWindow::GetVectorIntAsString(std::vector<int> vectorInt)
1368 {
1369   QString result;
1370   for (unsigned int i= 0; i < vectorInt.size(); i++) {
1371     if (i != 0)
1372       result += " ";
1373     result += QString::number(vectorInt[i]);
1374   }
1375   return result;
1376 }
1377 //------------------------------------------------------------------------------
1378
1379 //------------------------------------------------------------------------------
1380 //this actually returns the SlicerManager index!
1381 int vvMainWindow::GetSlicerIndexFromItem(QTreeWidgetItem* item)
1382 {
1383   QString id = item->data(COLUMN_IMAGE_NAME,Qt::UserRole).toString();
1384   for (int i = 0; i < DataTree->topLevelItemCount(); i++) {
1385     if (DataTree->topLevelItem(i)->data(COLUMN_IMAGE_NAME,Qt::UserRole).toString() == id)
1386       return i;
1387   }
1388   return -1;
1389 }
1390 //------------------------------------------------------------------------------
1391
1392 //------------------------------------------------------------------------------
1393 QTreeWidgetItem* vvMainWindow::GetItemFromSlicerManager(vvSlicerManager* sm)
1394 {
1395   QString id = sm->GetId().c_str();
1396   for (int i = 0; i < DataTree->topLevelItemCount(); i++) {
1397     if (DataTree->topLevelItem(i)->data(COLUMN_IMAGE_NAME,Qt::UserRole).toString() == id)
1398       return DataTree->topLevelItem(i);
1399   }
1400   return NULL;
1401 }
1402 //------------------------------------------------------------------------------
1403
1404 //------------------------------------------------------------------------------
1405 void vvMainWindow::DisplayChanged(QTreeWidgetItem *clickedItem, int column)
1406 {
1407   if ( column >= COLUMN_CLOSE_IMAGE || column <= 0)
1408     return;
1409
1410   // Get parent information (might be the same item)
1411   int slicerManagerIndex = GetSlicerIndexFromItem(clickedItem);
1412   QTreeWidgetItem* clickedParentItem = DataTree->topLevelItem(slicerManagerIndex);
1413   vvSlicer* clickedSlicer = mSlicerManagers[slicerManagerIndex]->GetSlicer(column-1);
1414
1415   // Go over the complete item tree (only 2 levels, parents and children)
1416   for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
1417     // Trick to avoid redoing twice the job for a key (sr)
1418     mSlicerManagers[i]->GetSlicer(column-1)->GetRenderWindow()->GetInteractor()->SetKeySym("Crap");
1419
1420     QTreeWidgetItem* currentParentItem = DataTree->topLevelItem(i);
1421     if(currentParentItem != clickedParentItem) {
1422       // Not the branch of the clicked item, uncheck all
1423
1424       // Parent
1425       currentParentItem->setData(column,Qt::CheckStateRole, 0);
1426       mSlicerManagers[i]->UpdateSlicer(column-1, false);
1427
1428       // Children
1429       for (int iChild = 0; iChild < currentParentItem->childCount(); iChild++) {
1430         currentParentItem->child(iChild)->setData(column,Qt::CheckStateRole, 0);
1431       }
1432     }
1433     else {
1434       // Branch of the clicked one: get check status from actor visibility in slicer
1435       // and toggle the clicked one
1436
1437       // Parent
1438       bool vis = clickedSlicer->GetActorVisibility("image", 0);
1439       bool draw = clickedSlicer->GetRenderer()->GetDraw();
1440
1441       // Update slicer (after getting visibility)
1442       mSlicerManagers[slicerManagerIndex]->UpdateSlicer(column-1, true);
1443       mSlicerManagers[slicerManagerIndex]->UpdateInfoOnCursorPosition(column-1);
1444       DisplaySliders(slicerManagerIndex, column-1);
1445       if(clickedParentItem == clickedItem) {
1446         // Toggle
1447         vis = !draw || !vis;
1448       }
1449       clickedSlicer->SetActorVisibility("image", 0, vis);
1450       clickedParentItem->setData(column, Qt::CheckStateRole, vis?2:0);
1451
1452       // Children
1453       std::map<std::string, int> actorTypeCounts;
1454       for (int iChild = 0; iChild < clickedParentItem->childCount(); iChild++) {
1455         QTreeWidgetItem* currentChildItem = clickedParentItem->child(iChild);
1456         std::string actorType = currentChildItem->data(1,Qt::UserRole).toString().toStdString();
1457         vis = clickedSlicer->GetActorVisibility(actorType, actorTypeCounts[actorType]);
1458         if(currentChildItem == clickedItem) {
1459           // Toggle or force visibility if it was not on this branch so far
1460           vis = !draw || !vis;
1461           clickedSlicer->SetActorVisibility(actorType, actorTypeCounts[actorType], vis);
1462         }
1463         currentChildItem->setData(column, Qt::CheckStateRole, vis?2:0);
1464         actorTypeCounts[actorType]++;
1465       }
1466     }
1467   }
1468
1469   clickedSlicer->Render();
1470 }
1471 //------------------------------------------------------------------------------
1472
1473 void vvMainWindow::InitSlicers()
1474 {
1475   if (mSlicerManagers.size()) {
1476     mSlicerManagers.back()->GenerateDefaultLookupTable();
1477     mSlicerManagers.back()->SetSlicerWindow(0,NOViewWidget->GetRenderWindow());
1478     mSlicerManagers.back()->SetSlicerWindow(1,NEViewWidget->GetRenderWindow());
1479     mSlicerManagers.back()->SetSlicerWindow(2,SOViewWidget->GetRenderWindow());
1480     mSlicerManagers.back()->SetSlicerWindow(3,SEViewWidget->GetRenderWindow());
1481 #if VTK_MAJOR_VERSION <= 5
1482     mSlicerManagers.back()->Render(); // SR: displayed #slice is wrong without this / TB: With VTK6 and multiple images, all slicers are updated, not only the first
1483 #endif
1484   }
1485 }
1486
1487 //------------------------------------------------------------------------------
1488 void vvMainWindow::InitDisplay()
1489 {
1490   if (mSlicerManagers.size()) {
1491     //BE CAREFUL : this is absolutely necessary to set the interactor style
1492     //in order to have the same style instanciation for all SlicerManagers in
1493     // a same window
1494     for (int j = 0; j < 4; j++) {
1495       vvInteractorStyleNavigator* style = vvInteractorStyleNavigator::New();
1496       style->SetAutoAdjustCameraClippingRange(1);
1497       bool AlreadySelected = false;
1498       for (int i = 0; i < DataTree->topLevelItemCount(); i++) {
1499         mSlicerManagers[i]->SetInteractorStyleNavigator(j,style);
1500         //select the image only if previous are not selected
1501         if (DataTree->topLevelItem(i)->data(j+1,Qt::CheckStateRole).toInt() > 1) {
1502           mSlicerManagers[i]->UpdateSlicer(j,1);
1503           AlreadySelected = true;
1504         } else if (i == DataTree->topLevelItemCount()-1 && !AlreadySelected) {
1505           if (DataTree->selectedItems().size() == 0) {
1506             DataTree->topLevelItem(i)->setSelected(1);
1507           }
1508           DataTree->topLevelItem(i)->setData(j+1,Qt::CheckStateRole,2);
1509           mSlicerManagers[i]->UpdateSlicer(j,1);
1510           DisplaySliders(i,j);
1511         } else {
1512           DataTree->topLevelItem(i)->setData(j+1,Qt::CheckStateRole,0);
1513           mSlicerManagers[i]->UpdateSlicer(j,0);
1514         }
1515       }
1516       style->Delete();
1517     }
1518   }
1519 }
1520 //------------------------------------------------------------------------------
1521
1522 //------------------------------------------------------------------------------
1523 void vvMainWindow::DisplaySliders(int slicer, int window)
1524 {
1525   if(!mSlicerManagers[slicer]->GetSlicer(window)->GetRenderer()->GetDraw())
1526     return;
1527
1528   int range[2];
1529   mSlicerManagers[slicer]->GetSlicer(window)->GetSliceRange(range);
1530   int position = mSlicerManagers[slicer]->GetSlicer(window)->GetSlice();
1531   if (range[1]>0)
1532     verticalSliders[window]->show();
1533   else
1534     verticalSliders[window]->hide();
1535   verticalSliders[window]->setRange(range[0],range[1]);
1536   verticalSliders[window]->setValue(position);
1537
1538   int tRange[2];
1539   tRange[0] = 0;
1540   tRange[1] = mSlicerManagers[slicer]->GetSlicer(window)->GetTMax();
1541   if (tRange[1]>0)
1542     horizontalSliders[window]->show();
1543   else
1544     horizontalSliders[window]->hide();
1545   horizontalSliders[window]->setRange(tRange[0],tRange[1]);
1546   int tPosition = mSlicerManagers[slicer]->GetSlicer(window)->GetMaxCurrentTSlice();
1547   horizontalSliders[window]->setValue(tPosition);
1548 }
1549 //------------------------------------------------------------------------------
1550
1551 //------------------------------------------------------------------------------
1552 void vvMainWindow::CloseImage(QTreeWidgetItem* item, int column)
1553 {
1554   int index = GetSlicerIndexFromItem(item);
1555
1556   if (DataTree->topLevelItem(index) != item) {
1557     QString warning = "Do you really want to close the overlay : ";
1558     warning += item->data(COLUMN_IMAGE_NAME,Qt::DisplayRole).toString();
1559     QMessageBox msgBox(QMessageBox::Warning, tr("Close Overlay"),
1560       warning, 0, this);
1561     msgBox.addButton(tr("Close"), QMessageBox::AcceptRole);
1562     msgBox.addButton(tr("Cancel"), QMessageBox::RejectRole);
1563     if (msgBox.exec() == QMessageBox::AcceptRole) {
1564       std::string overlay_type=item->data(1,Qt::UserRole).toString().toStdString();
1565       int overlay_index=0;
1566       for (int child = 0; child < DataTree->topLevelItem(index)->childCount(); child++) {
1567         if (DataTree->topLevelItem(index)->\
1568           child(child)->data(1,Qt::UserRole).toString().toStdString() == overlay_type)
1569           overlay_index++;
1570         if (DataTree->topLevelItem(index)->child(child) == item) break;
1571       }
1572       if (overlay_type=="fusionSequence") {
1573         //removing the overlay sequence in a fusion sequence visualization mode
1574         //reset the transforms
1575         overlayPanel->getFusionSequenceProperty(-1, false, 0, false);
1576
1577         //unlink and untie the slicer managers
1578         RemoveLink(mSlicerManagers[index]->GetId().c_str(), mSlicerManagers[mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager()]->GetId().c_str());
1579         mSlicerManagers[index]->SetFusionSequenceInvolvmentCode(-1);
1580         mSlicerManagers[mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager()]->SetFusionSequenceInvolvmentCode(-1);
1581         for (unsigned i=0 ; i<4 ; i++) {
1582             mSlicerManagers[index]->GetSlicer(i)->SetFusionSequenceCode(-1);
1583             mSlicerManagers[mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager()]->GetSlicer(i)->SetFusionSequenceCode(-1);
1584         }
1585
1586       }
1587       mSlicerManagers[index]->RemoveActor(overlay_type, overlay_index-1);
1588       mSlicerManagers[index]->SetColorMap(0);
1589       DataTree->topLevelItem(index)->takeChild(DataTree->topLevelItem(index)->indexOfChild(item));
1590       mSlicerManagers[index]->Render();
1591     }
1592   } else if (DataTree->topLevelItemCount() <= 1) {
1593     QString warning = "Do you really want to close the image : ";
1594     warning += item->data(COLUMN_IMAGE_NAME,Qt::DisplayRole).toString();
1595     warning += "\nThis is the last image, you're about to close vv !!!";
1596     QMessageBox msgBox(QMessageBox::Warning, tr("Close Image"),
1597       warning, 0, this);
1598     msgBox.addButton(tr("Close vv"), QMessageBox::AcceptRole);
1599     msgBox.addButton(tr("Cancel"), QMessageBox::RejectRole);
1600     if (msgBox.exec() == QMessageBox::AcceptRole) {
1601       this->close();
1602     }
1603   } else {
1604     QString warning = "Do you really want to close the image : ";
1605     warning += item->data(COLUMN_IMAGE_NAME,Qt::DisplayRole).toString();
1606     QMessageBox msgBox(QMessageBox::Warning, tr("Close Image"),
1607       warning, 0, this);
1608     msgBox.addButton(tr("Close"), QMessageBox::AcceptRole);
1609     msgBox.addButton(tr("Cancel"), QMessageBox::RejectRole);
1610     if (msgBox.exec() == QMessageBox::AcceptRole) {
1611
1612       // Tell tools that we close an image
1613       emit AnImageIsBeingClosed(mSlicerManagers[index]);
1614
1615       std::vector<vvSlicerManager*>::iterator Manageriter = mSlicerManagers.begin();
1616       DataTree->takeTopLevelItem(index);
1617       for (int i = 0; i < index; i++) {
1618         Manageriter++;
1619       }
1620       //if the slicer manager was involved in a fusion sequence visualization...
1621       if ( mSlicerManagers[index]->IsInvolvedInFusionSequence() ) {
1622         //in both cases, close the overlay: find it... and close it
1623         //ideally, I should duplicate the code, and avoid calling CloseImage, since this pops up another interactive box
1624         QTreeWidgetItem* overlayItem;
1625         if (mSlicerManagers[index]->IsMainSequenceOfFusionSequence()) {
1626           for (unsigned i=0 ; i<item->childCount() ; i++) {
1627             overlayItem = item->child(i);
1628             this->CloseImage( overlayItem, 0 );
1629           }
1630         }
1631         else {
1632           QTreeWidgetItem* linkedItem = this->GetItemFromSlicerManager( mSlicerManagers[mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager()] );
1633           for (unsigned i=0 ; i<linkedItem->childCount() ; i++) {
1634             overlayItem = linkedItem->child(i);
1635             this->CloseImage( overlayItem, 0 );
1636           }
1637         }
1638
1639         /* -- this is normally already done when closing the overlay.
1640         //reset the transforms
1641         overlayPanel->getFusionSequenceProperty(-1, false, 0, false);
1642
1643         //unlink and untie the slicer managers
1644         RemoveLink(mSlicerManagers[index]->GetId().c_str(), mSlicerManagers[mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager()]->GetId().c_str());
1645         mSlicerManagers[index]->SetFusionSequenceInvolvmentCode(-1);
1646         mSlicerManagers[mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager()]->SetFusionSequenceInvolvmentCode(-1);
1647         for (unsigned i=0 ; i<4 ; i++) {
1648             mSlicerManagers[index]->GetSlicer(i)->SetFusionSequenceCode(-1);
1649             mSlicerManagers[mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager()]->GetSlicer(i)->SetFusionSequenceCode(-1);
1650         }
1651         */
1652       }
1653
1654       linkPanel->removeImage(index);
1655       mSlicerManagers[index]->RemoveActors();
1656
1657       //remove the slicer manager
1658       delete mSlicerManagers[index];
1659       mSlicerManagers.erase(Manageriter);
1660
1661       //
1662       InitDisplay();
1663     }
1664   }
1665   ImageInfoChanged();
1666 }
1667 //------------------------------------------------------------------------------
1668
1669 //------------------------------------------------------------------------------
1670 void vvMainWindow::ReloadImage(QTreeWidgetItem* item, int column)
1671 {
1672   // int index = GetSlicerIndexFromItem(item);
1673   //   QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
1674   //   if (item->data(1,Qt::UserRole).toString() == "vector")
1675   //     mSlicerManagers[index]->ReloadVF();
1676   //   else
1677   //     mSlicerManagers[index]->Reload();
1678
1679   //   QApplication::restoreOverrideCursor();
1680   int index = GetSlicerIndexFromItem(item);
1681   QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
1682   QString role=item->data(1,Qt::UserRole).toString();
1683   if ( role == "vector") {
1684     mSlicerManagers[index]->ReloadVF();
1685   }
1686   else if (role == "overlay") {
1687     mSlicerManagers[index]->ReloadOverlay();
1688   }
1689   else if (role == "fusion") {
1690     mSlicerManagers[index]->ReloadFusion();
1691   }
1692   else if (role == "fusionSequence") {
1693     //both versions of the secondary sequence must be updated.
1694     mSlicerManagers[index]->ReloadFusionSequence();
1695     mSlicerManagers[mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager()]->Reload();
1696   }
1697   else {
1698     mSlicerManagers[index]->Reload();
1699     //if we update the secondary sequence, then the overlay of the main sequence should also be updated
1700     if (mSlicerManagers[index]->IsSecondarySequenceOfFusionSequence()) mSlicerManagers[mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager()]->ReloadFusionSequence();
1701   }
1702   // Update view and info
1703   ImageInfoChanged();
1704   mSlicerManagers[index]->Render();
1705   QApplication::restoreOverrideCursor();
1706 }
1707 //------------------------------------------------------------------------------
1708
1709 //------------------------------------------------------------------------------
1710 void vvMainWindow::MousePositionChanged(int visibility,double x, double y, double z, double X, double Y, double Z , double value)
1711 {
1712   infoPanel->setCurrentInfo(visibility,x,y,z,X,Y,Z,value);
1713 }
1714 //------------------------------------------------------------------------------
1715
1716 //------------------------------------------------------------------------------
1717 void vvMainWindow::VectorChanged(int visibility,double x, double y, double z, double value)
1718 {
1719   overlayPanel->getCurrentVectorInfo(visibility,x,y,z,value);
1720 }
1721 //------------------------------------------------------------------------------
1722
1723 //------------------------------------------------------------------------------
1724 void vvMainWindow::OverlayChanged(int visibility, double valueOver, double valueRef)
1725 {
1726   overlayPanel->getCurrentOverlayInfo(visibility,valueOver, valueRef);
1727 }
1728 //------------------------------------------------------------------------------
1729
1730 //------------------------------------------------------------------------------
1731 void vvMainWindow::FusionChanged(int visibility, double value)
1732 {
1733   overlayPanel->getCurrentFusionInfo(visibility,value);
1734 }
1735 //------------------------------------------------------------------------------
1736
1737 //------------------------------------------------------------------------------
1738 //called when AddOverlayImage, AddFusionSequence
1739 //or when UpdateWindowLevel() is called ; when slicerManager emits WindowLevelChanged
1740 //when ImageInfoChanged() is called
1741 void vvMainWindow::WindowLevelChanged()
1742 {
1743   // Base image
1744   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
1745   if(index==-1) return;
1746   windowSpinBox->setValue(mSlicerManagers[index]->GetColorWindow());
1747   levelSpinBox->setValue(mSlicerManagers[index]->GetColorLevel());
1748   colorMapComboBox->setCurrentIndex(mSlicerManagers[index]->GetColorMap());
1749   presetComboBox->setCurrentIndex(mSlicerManagers[index]->GetPreset());
1750
1751   // Overlay image
1752   if (mSlicerManagers[index]->GetSlicer(0)->GetOverlay())
1753     overlayPanel->getOverlayProperty(mSlicerManagers[index]->GetOverlayColor(),
1754     mSlicerManagers[index]->GetLinkOverlayWindowLevel(),
1755     mSlicerManagers[index]->GetOverlayColorWindow(),
1756     mSlicerManagers[index]->GetOverlayColorLevel());
1757   else
1758     overlayPanel->getOverlayProperty(-1,0,0.,0.);
1759
1760   // Fusion & SequenceFusion image
1761   if (mSlicerManagers[index]->GetSlicer(0)->GetFusion()) {
1762     overlayPanel->getFusionProperty(mSlicerManagers[index]->GetFusionOpacity(),
1763       mSlicerManagers[index]->GetFusionThresholdOpacity(),
1764       mSlicerManagers[index]->GetFusionColorMap(),
1765       mSlicerManagers[index]->GetFusionWindow(),
1766       mSlicerManagers[index]->GetFusionLevel());
1767     if (mSlicerManagers[index]->IsMainSequenceOfFusionSequence()) {
1768       overlayPanel->getFusionSequenceProperty(mSlicerManagers[index]->GetFusionSequenceFrameIndex(),
1769         mSlicerManagers[index]->GetFusionSequenceSpatialSyncFlag(),
1770         mSlicerManagers[index]->GetFusionSequenceNbFrames(),
1771         mSlicerManagers[index]->GetFusionSequenceTemporalSyncFlag());
1772     }
1773   }
1774   else if ( mSlicerManagers[index]->IsSecondarySequenceOfFusionSequence() ) {
1775     //if the image is involved in a fusion sequence, preserve the overlay panel!
1776     int ind = mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager();
1777     overlayPanel->getFusionProperty(mSlicerManagers[ind]->GetFusionOpacity(),
1778       mSlicerManagers[ind]->GetFusionThresholdOpacity(),
1779       mSlicerManagers[ind]->GetFusionColorMap(),
1780       mSlicerManagers[ind]->GetFusionWindow(),
1781       mSlicerManagers[ind]->GetFusionLevel());
1782     overlayPanel->getFusionSequenceProperty(mSlicerManagers[ind]->GetFusionSequenceFrameIndex(),
1783       mSlicerManagers[ind]->GetFusionSequenceSpatialSyncFlag(),
1784       mSlicerManagers[ind]->GetFusionSequenceNbFrames(),
1785       mSlicerManagers[ind]->GetFusionSequenceTemporalSyncFlag());
1786   }
1787   else
1788   {
1789     overlayPanel->getFusionProperty(-1, -1, -1, -1, -1);
1790     overlayPanel->getFusionSequenceProperty(-1, false, 0, false);
1791   }
1792 }
1793 //------------------------------------------------------------------------------
1794
1795 //------------------------------------------------------------------------------
1796 void vvMainWindow::WindowLevelEdited()
1797 {
1798   presetComboBox->setCurrentIndex(WL_USER);
1799   UpdateWindowLevel();
1800 }
1801 //------------------------------------------------------------------------------
1802
1803 //------------------------------------------------------------------------------
1804 void vvMainWindow::SetWindowLevel(double w, double l)
1805 {
1806   windowSpinBox->setValue(w);
1807   levelSpinBox->setValue(l);
1808   presetComboBox->setCurrentIndex(WL_USER);
1809   colorMapComboBox->setCurrentIndex(0);
1810   UpdateWindowLevel();
1811 }
1812 //------------------------------------------------------------------------------
1813
1814 //------------------------------------------------------------------------------
1815 void vvMainWindow::UpdateWindowLevel()
1816 {
1817   if (DataTree->selectedItems().size()) {
1818     if (presetComboBox->currentIndex() == WL_VENTILATION) //For ventilation
1819       colorMapComboBox->setCurrentIndex(5);
1820     int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
1821     mSlicerManagers[index]->SetColorWindow(windowSpinBox->value());
1822     mSlicerManagers[index]->SetColorLevel(levelSpinBox->value());
1823     mSlicerManagers[index]->SetPreset(presetComboBox->currentIndex());
1824     mSlicerManagers[index]->Render();
1825     WindowLevelChanged();
1826   }
1827 }
1828 //------------------------------------------------------------------------------
1829
1830 //------------------------------------------------------------------------------
1831 void vvMainWindow::UpdateSlicingPreset()
1832 {
1833   if (DataTree->selectedItems().size()) {
1834     int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
1835     mSlicerManagers[index]->SetSlicingPreset(vvSlicerManager::SlicingPresetType(slicingPresetComboBox->currentIndex()));
1836   }
1837 }
1838 //------------------------------------------------------------------------------
1839
1840 //------------------------------------------------------------------------------
1841 void vvMainWindow::UpdateColorMap()
1842 {
1843   if (DataTree->selectedItems().size()) {
1844     int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
1845     mSlicerManagers[index]->SetColorMap(colorMapComboBox->currentIndex());
1846     mSlicerManagers[index]->Render();
1847   }
1848 }
1849 //------------------------------------------------------------------------------
1850 void vvMainWindow::SwitchWindowLevel()
1851 {
1852   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
1853   int window = mSlicerManagers[index]->GetColorWindow();
1854   presetComboBox->setCurrentIndex(WL_USER);
1855   windowSpinBox->setValue(-window);
1856   UpdateWindowLevel();
1857 }
1858 //------------------------------------------------------------------------------
1859
1860 //------------------------------------------------------------------------------
1861 void vvMainWindow::ApplyWindowLevelToAllImages()
1862 {
1863   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
1864   if(index==-1) return;
1865   double window = mSlicerManagers[index]->GetColorWindow();
1866   double level = mSlicerManagers[index]->GetColorLevel();
1867
1868   double fusWindow = mSlicerManagers[index]->GetFusionWindow();
1869   double fusLevel = mSlicerManagers[index]->GetFusionLevel();
1870
1871   double overWindow = mSlicerManagers[index]->GetOverlayColorWindow();
1872   double overLevel = mSlicerManagers[index]->GetOverlayColorLevel();
1873
1874   for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
1875     if (mSlicerManagers[i] == NULL)
1876       continue;
1877     mSlicerManagers[i]->SetColorWindow(window);
1878     mSlicerManagers[i]->SetColorLevel(level);
1879     mSlicerManagers[i]->SetPreset(WL_USER);
1880     mSlicerManagers[i]->SetFusionWindow(fusWindow);
1881     mSlicerManagers[i]->SetFusionLevel(fusLevel);
1882     mSlicerManagers[i]->SetOverlayColorWindow(overWindow);
1883     mSlicerManagers[i]->SetOverlayColorLevel(overLevel);
1884     mSlicerManagers[i]->Render();
1885   }
1886 }
1887 //------------------------------------------------------------------------------
1888
1889 //------------------------------------------------------------------------------
1890 void vvMainWindow::ApplyWindowToSetOfImages(double window, unsigned int indexMin, unsigned int indexMax)
1891 {
1892   for (unsigned int i = indexMin; i <= indexMax && i < mSlicerManagers.size(); i++) {
1893     if (mSlicerManagers[i] == NULL)
1894       continue;
1895     mSlicerManagers[i]->SetColorWindow(window);
1896     mSlicerManagers[i]->SetPreset(WL_USER);
1897     mSlicerManagers[i]->Render();
1898   }
1899 }
1900 //------------------------------------------------------------------------------
1901
1902 //------------------------------------------------------------------------------
1903 void vvMainWindow::ApplyLevelToSetOfImages(double level, unsigned int indexMin, unsigned int indexMax)
1904 {
1905   for (unsigned int i = indexMin; i <= indexMax && i < mSlicerManagers.size(); i++) {
1906     if (mSlicerManagers[i] == NULL)
1907       continue;
1908     mSlicerManagers[i]->SetColorLevel(level);
1909     mSlicerManagers[i]->SetPreset(WL_USER);
1910     mSlicerManagers[i]->Render();
1911   }
1912 }
1913 //------------------------------------------------------------------------------
1914
1915 //------------------------------------------------------------------------------
1916 void vvMainWindow::UpdateLinkManager(std::string id, int slicer, double x, double y, double z, int temps)
1917 {
1918   for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
1919     if (mSlicerManagers[i]->GetId() == id) {
1920       mSlicerManagers[i]->GetSlicer(slicer)->SetCurrentPosition(x,y,z,temps);
1921       mSlicerManagers[i]->UpdateViews(0,slicer);
1922       break;
1923     }
1924   }
1925 }
1926 //------------------------------------------------------------------------------
1927
1928 //------------------------------------------------------------------------------
1929 void vvMainWindow::UpdateLinkedNavigation(std::string id, vvSlicerManager * sm, vvSlicer* refSlicer)
1930 {
1931   for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
1932     if (id == mSlicerManagers[i]->GetId()) {
1933       mSlicerManagers[i]->UpdateLinkedNavigation(refSlicer);
1934     }
1935   }
1936 }
1937 //------------------------------------------------------------------------------
1938
1939 //------------------------------------------------------------------------------
1940 void vvMainWindow::ShowContextMenu(QPoint point)
1941 {
1942   if (!DataTree->selectedItems().size()) {
1943     contextActions[1]->setEnabled(0);
1944     contextActions[2]->setEnabled(0);
1945     contextActions[3]->setEnabled(0);
1946     contextActions[4]->setEnabled(0);
1947     contextActions[5]->setEnabled(0);
1948     contextActions[6]->setEnabled(0);
1949   } else {
1950     int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
1951     contextActions[1]->setEnabled(1);
1952     contextActions[2]->setEnabled(
1953       DataTree->itemWidget(DataTree->selectedItems()[0],
1954       COLUMN_RELOAD_IMAGE)->isEnabled());
1955     contextActions[3]->setEnabled(1);
1956     contextActions[5]->setEnabled(1);
1957     contextActions[6]->setEnabled(1);
1958
1959     if (mSlicerManagers[index]->GetDimension() < 3)
1960       contextActions[4]->setEnabled(0);
1961     else
1962       contextActions[4]->setEnabled(1);
1963   }
1964   contextMenu.exec(QCursor::pos());
1965 }
1966 //------------------------------------------------------------------------------
1967
1968 //------------------------------------------------------------------------------
1969 void vvMainWindow::CloseImage()
1970 {
1971   CloseImage(DataTree->selectedItems()[0],0);
1972 }
1973 //------------------------------------------------------------------------------
1974
1975 //------------------------------------------------------------------------------
1976 void vvMainWindow::ReloadImage()
1977 {
1978   ReloadImage(DataTree->selectedItems()[0],0);
1979 }
1980 //------------------------------------------------------------------------------
1981
1982 //------------------------------------------------------------------------------
1983 void vvMainWindow::SelectOverlayImage()
1984 {
1985   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
1986
1987   //check if one overlay image is added
1988   for (int child = 0; child < DataTree->topLevelItem(index)->childCount(); child++)
1989     if (DataTree->topLevelItem(index)->child(child)->data(1,Qt::UserRole).toString() == "overlay") {
1990       QString error = "Cannot add more than one compared image\n";
1991       error += "Please remove first ";
1992       error += DataTree->topLevelItem(index)->child(child)->data(COLUMN_IMAGE_NAME,Qt::DisplayRole).toString();
1993       QMessageBox::information(this,tr("Problem adding compared image !"),error);
1994       return;
1995     }
1996
1997     QString Extensions = EXTENSIONS;
1998     Extensions += ";;All Files (*)";
1999     QStringList files = QFileDialog::getOpenFileNames(this,tr("Load Overlay image"),mInputPathName,Extensions);
2000     if (files.isEmpty())
2001       return;
2002
2003     std::vector<std::string> vecFileNames;
2004     for (int i = 0; i < files.size(); i++) {
2005       vecFileNames.push_back(files[i].toStdString());
2006     }
2007
2008     AddOverlayImage(index,vecFileNames,vvImageReader::IMAGE);
2009 }
2010 //------------------------------------------------------------------------------
2011
2012 //------------------------------------------------------------------------------
2013 void vvMainWindow::AddOverlayImage(int index, std::vector<std::string> fileNames, vvImageReader::LoadedImageType type)
2014 {
2015   QString file(fileNames[0].c_str());
2016   if (QFile::exists(file))
2017   {
2018     mInputPathName = itksys::SystemTools::GetFilenamePath(file.toStdString()).c_str();
2019     itk::ImageIOBase::Pointer reader = itk::ImageIOFactory::CreateImageIO(
2020       file.toStdString().c_str(), itk::ImageIOFactory::ReadMode);
2021     reader->SetFileName(fileNames[0].c_str());
2022     reader->ReadImageInformation();
2023     std::string component = reader->GetComponentTypeAsString(reader->GetComponentType());
2024     int dimension = reader->GetNumberOfDimensions();
2025     QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
2026     vvProgressDialog progress("Opening " + file.toStdString());
2027     qApp->processEvents();
2028
2029     std::string filename = itksys::SystemTools::GetFilenameWithoutExtension(file.toStdString()).c_str();
2030     if (mSlicerManagers[index]->SetOverlay(fileNames,dimension, component,type)) {
2031       //create an item in the tree with good settings
2032       QTreeWidgetItem *item = new QTreeWidgetItem();
2033       item->setData(0,Qt::UserRole,file.toStdString().c_str());
2034       item->setData(1,Qt::UserRole,tr("overlay"));
2035       QFileInfo fileinfo(file); //Do not show the path
2036       item->setData(COLUMN_IMAGE_NAME,Qt::DisplayRole,fileinfo.fileName());
2037       item->setToolTip(COLUMN_IMAGE_NAME, mSlicerManagers[index]->GetListOfAbsoluteFilePathInOneString("overlay").c_str());
2038       qApp->processEvents();
2039
2040       for (int j = 1; j <= 4; j++) {
2041         item->setData(j,Qt::CheckStateRole,DataTree->topLevelItem(index)->data(j,Qt::CheckStateRole));
2042       }
2043
2044       //Create the buttons for reload and close
2045       qApp->processEvents();
2046       QTreePushButton* cButton = new QTreePushButton;
2047       cButton->setItem(item);
2048       cButton->setColumn(COLUMN_CLOSE_IMAGE);
2049       cButton->setToolTip(tr("close image"));
2050       cButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/exit.png")));
2051       connect(cButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
2052         this,SLOT(CloseImage(QTreeWidgetItem*, int)));
2053
2054       QTreePushButton* rButton = new QTreePushButton;
2055       rButton->setItem(item);
2056       rButton->setColumn(COLUMN_RELOAD_IMAGE);
2057       rButton->setToolTip(tr("reload image"));
2058       rButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/rotateright.png")));
2059       connect(rButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
2060         this,SLOT(ReloadImage(QTreeWidgetItem*, int)));
2061
2062       DataTree->topLevelItem(index)->setExpanded(1);
2063       DataTree->topLevelItem(index)->addChild(item);
2064       DataTree->setItemWidget(item, COLUMN_CLOSE_IMAGE, cButton);
2065       DataTree->setItemWidget(item, COLUMN_RELOAD_IMAGE, rButton);
2066
2067       //set the id of the image
2068       QString id = DataTree->topLevelItem(index)->data(COLUMN_IMAGE_NAME,Qt::UserRole).toString();
2069       item->setData(COLUMN_IMAGE_NAME,Qt::UserRole,id.toStdString().c_str());
2070       UpdateTree();
2071       qApp->processEvents();
2072       ImageInfoChanged();
2073       QApplication::restoreOverrideCursor();
2074
2075       // Update the display to update, e.g., the sliders
2076       for(int i=0; i<4; i++)
2077         DisplaySliders(index, i);
2078     } else {
2079       QApplication::restoreOverrideCursor();
2080       QString error = "Cannot import the new image.\n";
2081       error += mSlicerManagers[index]->GetLastError().c_str();
2082       QMessageBox::information(this,tr("Problem reading image !"),error);
2083     }
2084     WindowLevelChanged();
2085   }
2086   else
2087     QMessageBox::information(this,tr("Problem reading Overlay !"),"File doesn't exist!");
2088 }
2089 //------------------------------------------------------------------------------
2090
2091
2092 //------------------------------------------------------------------------------
2093 void vvMainWindow::AddROI(int index, QString file)
2094 {
2095   /*
2096   // Get slice manager
2097
2098   // Load image
2099
2100   vvImageReader * mReader = new vvImageReader;
2101   mReader->SetInputFilename(filename.toStdString());
2102   mReader->Update(IMAGE);
2103   if (mReader->GetLastError().size() != 0) {
2104   std::cerr << "Error while reading " << filename.toStdString() << std::endl;
2105   QString error = "Cannot open file \n";
2106   error += mReader->GetLastError().c_str();
2107   QMessageBox::information(this,tr("Reading problem"),error);
2108   delete mReader;
2109   return;
2110   }
2111   vvImage::Pointer roi = mReader->GetOutput();
2112
2113   // Create roi in new tool
2114   vvToolStructureSetManager::AddImage(mCurrentSlicerManager, roi);
2115   */
2116 }
2117 //------------------------------------------------------------------------------
2118
2119 //------------------------------------------------------------------------------
2120 void vvMainWindow::SelectFusionImage()
2121 {
2122   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
2123
2124   //check if one fusion image is added
2125   for (int child = 0; child < DataTree->topLevelItem(index)->childCount(); child++)
2126     if ( (DataTree->topLevelItem(index)->child(child)->data(1,Qt::UserRole).toString() == "fusion") ||
2127       (DataTree->topLevelItem(index)->child(child)->data(1,Qt::UserRole).toString() == "fusionSequence") ) {
2128         QString error = "Cannot add more than one fusion image\n";
2129         error += "Please remove first ";
2130         error += DataTree->topLevelItem(index)->child(child)->data(COLUMN_IMAGE_NAME,Qt::DisplayRole).toString();
2131         QMessageBox::information(this,tr("Problem adding fusion image !"),error);
2132         return;
2133     }
2134
2135     QString Extensions = EXTENSIONS;
2136     Extensions += ";;All Files (*)";
2137     QStringList files = QFileDialog::getOpenFileNames(this,tr("Load Fusion image"),mInputPathName,Extensions);
2138     if (files.isEmpty())
2139       return;
2140
2141     std::vector<std::string> vecFileNames;
2142     for (int i = 0; i < files.size(); i++) {
2143       vecFileNames.push_back(files[i].toStdString());
2144     }
2145     AddFusionImage(index,vecFileNames,vvImageReader::IMAGE);
2146 }
2147 //------------------------------------------------------------------------------
2148
2149 //------------------------------------------------------------------------------
2150 void vvMainWindow::ResetTransformationToIdentity()
2151 {
2152   std::string actorType = DataTree->selectedItems()[0]->data(1,Qt::UserRole).toString().toStdString();
2153   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
2154   mSlicerManagers[index]->ResetTransformationToIdentity(actorType);
2155   ImageInfoChanged();
2156 }
2157 //------------------------------------------------------------------------------
2158
2159 //------------------------------------------------------------------------------
2160 void vvMainWindow::AddFusionImage(int index, std::vector<std::string> fileNames, vvImageReader::LoadedImageType type)
2161 {
2162   QString file(fileNames[0].c_str());
2163   if (QFile::exists(file))
2164   {
2165     mInputPathName = itksys::SystemTools::GetFilenamePath(file.toStdString()).c_str();
2166     itk::ImageIOBase::Pointer reader = itk::ImageIOFactory::CreateImageIO(
2167       file.toStdString().c_str(), itk::ImageIOFactory::ReadMode);
2168     reader->SetFileName(fileNames[0].c_str());
2169     reader->ReadImageInformation();
2170     std::string component = reader->GetComponentTypeAsString(reader->GetComponentType());
2171     int dimension = reader->GetNumberOfDimensions();
2172     QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
2173     vvProgressDialog progress("Opening fusion");
2174     qApp->processEvents();
2175
2176     std::string filename = itksys::SystemTools::GetFilenameWithoutExtension(file.toStdString()).c_str();
2177     if (mSlicerManagers[index]->SetFusion(fileNames,dimension, component,type)) {
2178       //create an item in the tree with good settings
2179       QTreeWidgetItem *item = new QTreeWidgetItem();
2180       item->setData(0,Qt::UserRole,file.toStdString().c_str());
2181       item->setData(1,Qt::UserRole,tr("fusion"));
2182       QFileInfo fileinfo(file); //Do not show the path
2183           item->setData(COLUMN_IMAGE_NAME,Qt::DisplayRole,fileinfo.fileName());
2184           item->setToolTip(COLUMN_IMAGE_NAME, mSlicerManagers[index]->GetListOfAbsoluteFilePathInOneString("fusion").c_str());
2185           qApp->processEvents();
2186
2187       for (int j = 1; j <= 4; j++) {
2188         item->setData(j,Qt::CheckStateRole,DataTree->topLevelItem(index)->data(j,Qt::CheckStateRole));
2189       }
2190
2191       //Create the buttons for reload and close
2192       qApp->processEvents();
2193       QTreePushButton* cButton = new QTreePushButton;
2194       cButton->setItem(item);
2195       cButton->setColumn(COLUMN_CLOSE_IMAGE);
2196       cButton->setToolTip(tr("close image"));
2197       cButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/exit.png")));
2198       connect(cButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
2199         this,SLOT(CloseImage(QTreeWidgetItem*, int)));
2200
2201       QTreePushButton* rButton = new QTreePushButton;
2202       rButton->setItem(item);
2203       rButton->setColumn(COLUMN_RELOAD_IMAGE);
2204       rButton->setToolTip(tr("reload image"));
2205       rButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/rotateright.png")));
2206       connect(rButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
2207         this,SLOT(ReloadImage(QTreeWidgetItem*, int)));
2208
2209       DataTree->topLevelItem(index)->setExpanded(1);
2210       DataTree->topLevelItem(index)->addChild(item);
2211       DataTree->setItemWidget(item, COLUMN_CLOSE_IMAGE, cButton);
2212       DataTree->setItemWidget(item, COLUMN_RELOAD_IMAGE, rButton);
2213
2214       //set the id of the image
2215       QString id = DataTree->topLevelItem(index)->data(COLUMN_IMAGE_NAME,Qt::UserRole).toString();
2216       item->setData(COLUMN_IMAGE_NAME,Qt::UserRole,id.toStdString().c_str());
2217       UpdateTree();
2218       qApp->processEvents();
2219       ImageInfoChanged();
2220       QApplication::restoreOverrideCursor();
2221
2222       // Update the display to update, e.g., the sliders
2223       for(int i=0; i<4; i++)
2224         DisplaySliders(index, i);
2225     } else {
2226       QApplication::restoreOverrideCursor();
2227       QString error = "Cannot import the new image.\n";
2228       error += mSlicerManagers[index]->GetLastError().c_str();
2229       QMessageBox::information(this,tr("Problem reading image !"),error);
2230     }
2231     WindowLevelChanged();
2232   }
2233   else
2234     QMessageBox::information(this,tr("Problem reading Fusion !"),"File doesn't exist!");
2235 }
2236 //------------------------------------------------------------------------------
2237 //------------------------------------------------------------------------------
2238 void vvMainWindow::AddLandmarks(int index, std::vector<std::string> files)
2239 {
2240     if (!landmarksPanel->LoadFromFile(files))
2241       QMessageBox::information(this,tr("Problem reading Landmarks !"),"File doesn't exist!");
2242
2243     landmarksPanel->SetCurrentPath(mInputPathName.toStdString());
2244     landmarksPanel->SetCurrentImage(mSlicerManagers[index]->GetFileName().c_str());
2245 }
2246
2247 //------------------------------------------------------------------------------
2248 void vvMainWindow::OpenField()
2249 {
2250   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
2251   //check if a vector field has already been added
2252   for (int child = 0; child < DataTree->topLevelItem(index)->childCount(); child++)
2253     if (DataTree->topLevelItem(index)->child(child)->data(1,Qt::UserRole).toString() == "vector") {
2254       QString error = "Cannot add more than one vector field\n";
2255       error += "Please remove first ";
2256       error += DataTree->topLevelItem(index)->child(child)->data(COLUMN_IMAGE_NAME,Qt::DisplayRole).toString();
2257       QMessageBox::information(this,tr("Problem adding vector field!"),error);
2258       return;
2259     }
2260
2261     QString Extensions = "Images ( *.mhd *.mha *.vf *.nii *.nrrd *.nhdr)";
2262     // Extensions += ";;Images ( *.mha)";
2263     // Extensions += ";;VF Images ( *.vf)";
2264     // Extensions += ";;nii Images ( *.nii)";
2265     // Extensions += ";;nrrd Images ( *.nrrd)";
2266     // Extensions += ";;nhdr Images ( *.nhdr)";
2267     Extensions += ";;All Files (*)";
2268     QString file = QFileDialog::getOpenFileName(this,tr("Load deformation field"),mInputPathName,Extensions);
2269     if (!file.isEmpty())
2270       AddField(file,index);
2271 }
2272 //------------------------------------------------------------------------------
2273
2274
2275 //------------------------------------------------------------------------------
2276 void vvMainWindow::AddFieldEntry(QString filename,int index,bool from_disk)
2277 {
2278   //create an item in the tree with good settings
2279   QTreeWidgetItem *item = new QTreeWidgetItem();
2280   item->setData(0,Qt::UserRole,filename.toStdString().c_str());
2281   item->setData(1,Qt::UserRole,tr("vector"));
2282   QFileInfo fileinfo(filename); //Do not show the path
2283   item->setData(COLUMN_IMAGE_NAME,Qt::DisplayRole,fileinfo.fileName());
2284   item->setToolTip(COLUMN_IMAGE_NAME, mSlicerManagers[index]->GetListOfAbsoluteFilePathInOneString("vector").c_str());
2285   qApp->processEvents();
2286
2287   for (int j = 1; j <= 4; j++) {
2288     item->setData(j,Qt::CheckStateRole,DataTree->topLevelItem(index)->data(j,Qt::CheckStateRole));
2289   }
2290
2291   //Create the buttons for reload and close
2292   qApp->processEvents();
2293   QTreePushButton* cButton = new QTreePushButton;
2294   cButton->setItem(item);
2295   cButton->setColumn(COLUMN_CLOSE_IMAGE);
2296   cButton->setToolTip(tr("close vector field"));
2297   cButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/exit.png")));
2298   connect(cButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
2299     this,SLOT(CloseImage(QTreeWidgetItem*, int)));
2300
2301   QTreePushButton* rButton = new QTreePushButton;
2302   rButton->setItem(item);
2303   rButton->setColumn(COLUMN_RELOAD_IMAGE);
2304   rButton->setToolTip(tr("reload vector field"));
2305   rButton->setEnabled(from_disk);
2306   rButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/rotateright.png")));
2307   connect(rButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
2308     this,SLOT(ReloadImage(QTreeWidgetItem*, int)));
2309
2310   DataTree->topLevelItem(index)->setExpanded(1);
2311   DataTree->topLevelItem(index)->addChild(item);
2312   DataTree->setItemWidget(item, COLUMN_RELOAD_IMAGE, rButton);
2313   DataTree->setItemWidget(item, COLUMN_CLOSE_IMAGE, cButton);
2314
2315   //set the id of the image
2316   QString id = DataTree->topLevelItem(index)->data(COLUMN_IMAGE_NAME,Qt::UserRole).toString();
2317   item->setData(COLUMN_IMAGE_NAME,Qt::UserRole,id.toStdString().c_str());
2318   UpdateTree();
2319   qApp->processEvents();
2320   ImageInfoChanged();
2321   QApplication::restoreOverrideCursor();
2322 }
2323 //------------------------------------------------------------------------------
2324
2325
2326 //------------------------------------------------------------------------------
2327 void vvMainWindow::AddField(vvImage::Pointer vf,QString file,int index)
2328 {
2329   QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
2330   vvSlicerManager* imageManager = mSlicerManagers[index];
2331   if (imageManager->SetVF(vf,file.toStdString())) {
2332     AddFieldEntry(file,index,false);
2333   } else {
2334     QString error = "Cannot import the vector field for this image.\n";
2335     error += imageManager->GetLastError().c_str();
2336     QMessageBox::information(this,tr("Problem reading VF !"),error);
2337   }
2338   QApplication::restoreOverrideCursor();
2339 }
2340 //------------------------------------------------------------------------------
2341
2342
2343 //------------------------------------------------------------------------------
2344 void vvMainWindow::AddField(QString file,int index)
2345 {
2346   if (QFile::exists(file)) {
2347     mInputPathName = itksys::SystemTools::GetFilenamePath(file.toStdString()).c_str();
2348
2349     //init the progress events
2350     QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
2351     vvProgressDialog progress("Opening " + file.toStdString());
2352     qApp->processEvents();
2353
2354     //read the vector and put it in the current mSlicerManager
2355     vvSlicerManager* imageManager = mSlicerManagers[index];
2356     qApp->processEvents();
2357
2358     std::string filename = itksys::SystemTools::GetFilenameWithoutExtension(file.toStdString()).c_str();
2359     if (imageManager->SetVF(file.toStdString())) {
2360       imageManager->Render();
2361       AddFieldEntry(file,index,true);
2362     } else {
2363       QApplication::restoreOverrideCursor();
2364       QString error = "Cannot import the vector field for this image.\n";
2365       error += imageManager->GetLastError().c_str();
2366       QMessageBox::information(this,tr("Problem reading VF !"),error);
2367     }
2368   } else
2369     QMessageBox::information(this,tr("Problem reading VF !"),"File doesn't exist!");
2370
2371 }
2372 //------------------------------------------------------------------------------
2373
2374
2375 //------------------------------------------------------------------------------
2376 void vvMainWindow::SetVFProperty(int subsampling, int scale, int log, int width, double r, double g, double b)
2377 {
2378   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
2379   if (mSlicerManagers[index]->GetSlicer(0)->GetVF()) {
2380     for (int i = 0; i < 4; i++) {
2381       mSlicerManagers[index]->GetSlicer(i)->SetVFSubSampling(subsampling);
2382       mSlicerManagers[index]->GetSlicer(i)->SetVFScale(scale);
2383       mSlicerManagers[index]->GetSlicer(i)->SetVFWidth(width);
2384       mSlicerManagers[index]->GetSlicer(i)->SetVFColor(r,g,b);
2385       if (log > 0)
2386         mSlicerManagers[index]->GetSlicer(i)->SetVFLog(1);
2387       else
2388         mSlicerManagers[index]->GetSlicer(i)->SetVFLog(0);
2389     }
2390   }
2391 }
2392 //------------------------------------------------------------------------------
2393
2394
2395 //------------------------------------------------------------------------------
2396 void vvMainWindow::SetOverlayProperty(int color, int linked, double window, double level)
2397 {
2398   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
2399   if (mSlicerManagers[index]->GetSlicer(0)->GetOverlay()) {
2400     mSlicerManagers[index]->SetOverlayColor(color);
2401     mSlicerManagers[index]->SetColorMap(0);
2402     mSlicerManagers[index]->SetLinkOverlayWindowLevel(linked);
2403     mSlicerManagers[index]->SetOverlayColorWindow(window);
2404     mSlicerManagers[index]->SetOverlayColorLevel(level);
2405     mSlicerManagers[index]->Render();
2406   }
2407 }
2408 //------------------------------------------------------------------------------
2409
2410 //------------------------------------------------------------------------------
2411 void vvMainWindow::SetFusionProperty(int opacity, int thresOpacity, int colormap,double window, double level, bool showLegend)
2412 {
2413   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
2414   if (mSlicerManagers[index]->GetSlicer(0)->GetFusion()) {
2415     mSlicerManagers[index]->SetFusionColorMap(colormap);
2416     mSlicerManagers[index]->SetFusionOpacity(opacity);
2417     mSlicerManagers[index]->SetFusionThresholdOpacity(thresOpacity);
2418     mSlicerManagers[index]->SetFusionWindow(window);
2419     mSlicerManagers[index]->SetFusionLevel(level);
2420     mSlicerManagers[index]->SetFusionShowLegend(showLegend);
2421     mSlicerManagers[index]->SetColorMap(0);
2422     mSlicerManagers[index]->Render();
2423   }
2424 }
2425 //------------------------------------------------------------------------------
2426
2427
2428 //------------------------------------------------------------------------------
2429 void vvMainWindow::SelectFusionSequence()
2430 {
2431   //get the index of the slicer manager of the main sequence (CT)
2432   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
2433   //check if one overlay image is already associated
2434   for (int child = 0; child < DataTree->topLevelItem(index)->childCount(); child++)
2435     if ( (DataTree->topLevelItem(index)->child(child)->data(1,Qt::UserRole).toString() == "fusion") ||
2436       (DataTree->topLevelItem(index)->child(child)->data(1,Qt::UserRole).toString() == "fusionSequence") ) {
2437         QString error = "Cannot add more than one compared image\n";
2438         error += "Please remove first ";
2439         error += DataTree->topLevelItem(index)->child(child)->data(COLUMN_IMAGE_NAME,Qt::DisplayRole).toString();
2440         QMessageBox::information(this,tr("Problem adding compared image !"),error);
2441         return;
2442     }
2443
2444     QString Extensions = EXTENSIONS;
2445     Extensions += ";;All Files (*)";
2446     QStringList files = QFileDialog::getOpenFileNames(this,tr("Load Overlay image sequence"),mInputPathName,Extensions);
2447     if (files.isEmpty())
2448       return;
2449
2450     std::vector<std::string> vecFileNames;
2451     for (int i = 0; i < files.size(); i++) {
2452       vecFileNames.push_back(files[i].toStdString());
2453     }
2454
2455     //associate the secondary sequence (US) to the main one
2456     AddFusionSequence(index,vecFileNames,vvImageReader::MERGEDWITHTIME);
2457 }
2458 //------------------------------------------------------------------------------
2459
2460
2461 //------------------------------------------------------------------------------
2462 void vvMainWindow::SelectFusionSequenceCorrespondances()
2463 {
2464   //make sure the index is right?
2465   //in the end, I should attach the temporal data to the right sequence!
2466   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
2467   //in case the other sequence got selected, make sure we select the primary sequence
2468   if ( (!mSlicerManagers[index]->GetSlicer(0)->GetFusion()) && mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager()>=0 ) {
2469     index = mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager();
2470   }
2471
2472   //open a dialog box to find a file
2473   //QString Extensions = EXTENSIONS;
2474   QString Extensions = ";;All Files (*)";
2475   QString fileName = QFileDialog::getOpenFileName(this,tr("Load respiratory signal for fused sequence"),mInputPathName,Extensions);
2476   if (fileName.isNull())
2477     return;
2478
2479   //read it as a vector of values
2480   vnl_vector<double> tmpVect;
2481
2482   std::ifstream file;
2483   file.open(fileName.toStdString().c_str());
2484   tmpVect.read_ascii(file);
2485   file.close();
2486
2487   //if compatible with the fused image sequence (number of entries = nb of entries in main sequence + nb of entries in joint sequence), enable the temporalSync
2488   bool signalOK = true;
2489   unsigned nbFrameMain = mSlicerManagers[index]->GetImage()->GetTransform().size();
2490   unsigned nbFrameSecondary = mSlicerManagers[index]->GetFusionSequenceNbFrames();
2491   std::cout<<"nbFrameMain = "<<nbFrameMain<<", nbFrameSecondary= "<<nbFrameSecondary<<", signal size: "<<tmpVect.size()<<std::endl;
2492   std::vector<unsigned> temporalCorrespondances;
2493   if ( tmpVect.size() == nbFrameMain + nbFrameSecondary ) {
2494     for (unsigned i=0 ; i<tmpVect.size() ; i++) {
2495       if (i<nbFrameMain) { //first part of the file: i -> index in secondary seq.
2496         if ( tmpVect(i)<nbFrameSecondary ) temporalCorrespondances.push_back(tmpVect(i));
2497         else { signalOK=false; break; } //pointing outside the secondary sequence...
2498       }
2499       else { //first part of the file -> index in secondary seq.
2500         if ( tmpVect(i)<nbFrameMain ) temporalCorrespondances.push_back(tmpVect(i));
2501         else { signalOK=false; break; } //pointing outside the secondary sequence...
2502       }
2503     }
2504   }
2505   else {signalOK=false;}
2506   if (!signalOK) {//else, send a message to signal the failure...
2507     QString error = "The provided temporal correspondances is invalid - check tooltip.\n";
2508     error += "Ignoring file: " + fileName;
2509     QMessageBox::information(this,tr("Problem adding temporal correspondances!"),error);
2510     return;
2511   }
2512   else {
2513     //for convenience, associate this sequence to both the current slicer manager, and to the linked one
2514     mSlicerManagers[index]->SetFusionSequenceCorrespondances(temporalCorrespondances);
2515     mSlicerManagers[ mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager() ]->SetFusionSequenceCorrespondances(temporalCorrespondances);
2516     overlayPanel->enableFusionSequenceTemporalSync();
2517   }
2518
2519 }
2520 //------------------------------------------------------------------------------
2521
2522
2523 //------------------------------------------------------------------------------
2524 //when this function is called index is the slicer manager index corresponding to the main sequence (CT)
2525 //the files behind fileNames points to the data for the secondary sequence
2526 void vvMainWindow::AddFusionSequence(int index, std::vector<std::string> fileNames, vvImageReader::LoadedImageType type)
2527 {
2528   QString file(fileNames[0].c_str());
2529   if (QFile::exists(file))
2530   {
2531     mInputPathName = itksys::SystemTools::GetFilenamePath(file.toStdString()).c_str();
2532     itk::ImageIOBase::Pointer reader = itk::ImageIOFactory::CreateImageIO(
2533       file.toStdString().c_str(), itk::ImageIOFactory::ReadMode);
2534     std::sort (fileNames.begin(), fileNames.end());//make sure the files are sorted.
2535     reader->SetFileName(fileNames[0].c_str());
2536     reader->ReadImageInformation();
2537     std::string component = reader->GetComponentTypeAsString(reader->GetComponentType());
2538     int dimension = reader->GetNumberOfDimensions();
2539     QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
2540     vvProgressDialog progress("Opening " + file.toStdString());
2541     qApp->processEvents();
2542
2543     std::string filename = itksys::SystemTools::GetFilenameWithoutExtension(file.toStdString()).c_str();
2544
2545     if (mSlicerManagers[index]->SetFusionSequence(fileNames,dimension, component,type)) {
2546       //create an item in the tree with good settings
2547       QTreeWidgetItem *item = new QTreeWidgetItem();
2548       item->setData(0,Qt::UserRole,file.toStdString().c_str());
2549       item->setData(1,Qt::UserRole,tr("fusionSequence"));
2550
2551       QFileInfo fileinfo(file); //Do not show the path
2552       item->setData(COLUMN_IMAGE_NAME,Qt::DisplayRole,fileinfo.fileName());
2553       item->setToolTip(COLUMN_IMAGE_NAME, mSlicerManagers[index]->GetListOfAbsoluteFilePathInOneString("fusionSequence").c_str());
2554       qApp->processEvents();
2555       for (int j = 1; j <= 4; j++) {
2556         item->setData(j,Qt::CheckStateRole,DataTree->topLevelItem(index)->data(j,Qt::CheckStateRole));
2557       }
2558
2559       //Create the buttons for reload and close
2560       qApp->processEvents();
2561       QTreePushButton* cButton = new QTreePushButton;
2562       cButton->setItem(item);
2563       cButton->setColumn(COLUMN_CLOSE_IMAGE);
2564       cButton->setToolTip(tr("close image"));
2565       cButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/exit.png")));
2566       connect(cButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
2567         this,SLOT(CloseImage(QTreeWidgetItem*, int)));
2568
2569       QTreePushButton* rButton = new QTreePushButton;
2570       rButton->setItem(item);
2571       rButton->setColumn(COLUMN_RELOAD_IMAGE);
2572       rButton->setToolTip(tr("reload image"));
2573       rButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/rotateright.png")));
2574       connect(rButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
2575         this,SLOT(ReloadImage(QTreeWidgetItem*, int)));
2576
2577       DataTree->topLevelItem(index)->setExpanded(1);
2578       DataTree->topLevelItem(index)->addChild(item);
2579       DataTree->setItemWidget(item, COLUMN_CLOSE_IMAGE, cButton);
2580       DataTree->setItemWidget(item, COLUMN_RELOAD_IMAGE, rButton);
2581
2582       //store the original transform matrix
2583       int indexParent = GetSlicerIndexFromItem( DataTree->topLevelItem(index) );
2584       mSlicerManagers[indexParent]->SetFusionSequenceMainTransformMatrix( mSlicerManagers[indexParent]->GetSlicer(0)->GetImage()->GetTransform()[0]->GetMatrix() );
2585
2586       //set the id of the image
2587       QString id = DataTree->topLevelItem(index)->data(COLUMN_IMAGE_NAME,Qt::UserRole).toString();
2588       item->setData(COLUMN_IMAGE_NAME,Qt::UserRole,id.toStdString().c_str());
2589       UpdateTree();
2590       qApp->processEvents();
2591
2592       //ImageInfoChanged();
2593
2594       QApplication::restoreOverrideCursor();
2595       // Update the display to update, e.g., the sliders
2596       for(int i=0; i<4; i++)
2597         DisplaySliders(index, i);
2598
2599
2600       //This loads the secondary sequence (US) as an independent sequence
2601       LoadImages(fileNames, type);
2602       //reset the transforms to identity
2603       //FIX -- and set the thickness of the US slices to a large value (necessary for visualization purposes...)
2604       double sp_x, sp_y, sp_z;
2605       mSlicerManagers[indexParent]->GetImage()->GetVTKImages()[0]->GetSpacing(sp_x, sp_y, sp_z);
2606       sp_z = std::max(sp_x, std::max(sp_y, sp_z)) + 0.5; //
2607       for (unsigned i=0 ; i<mSlicerManagers.back()->GetImage()->GetTransform().size() ; i++) {
2608         sp_x = mSlicerManagers.back()->GetImage()->GetVTKImages()[i]->GetSpacing()[0];
2609         sp_y = mSlicerManagers.back()->GetImage()->GetVTKImages()[i]->GetSpacing()[1];
2610         mSlicerManagers.back()->GetImage()->GetVTKImages()[i]->SetSpacing( sp_x, sp_y, sp_z);
2611         mSlicerManagers.back()->GetImage()->GetTransform()[i]->Identity();
2612         mSlicerManagers.back()->GetImage()->GetTransform()[i]->Update();
2613       }
2614
2615       //automatically link both images...
2616       AddLink(mSlicerManagers[indexParent]->GetId().c_str(), mSlicerManagers.back()->GetId().c_str(), false);
2617
2618       //tie the main and secondary sequences by raising flags and informing each another of their respective SlicerManager indices
2619       mSlicerManagers[indexParent]->SetFusionSequenceIndexOfLinkedManager(mSlicerManagers.size()-1);
2620       mSlicerManagers[indexParent]->SetFusionSequenceInvolvmentCode(0); //main sequence
2621       mSlicerManagers.back()->SetFusionSequenceIndexOfLinkedManager(indexParent);
2622       mSlicerManagers.back()->SetFusionSequenceInvolvmentCode(1); //secondary sequence
2623       for (unsigned i=0 ; i<4 ; i++) {
2624         mSlicerManagers.back()->GetSlicer(i)->SetFusionSequenceCode(1); //flag the slicers of the secondary sequence
2625       }
2626
2627     } else {
2628       QApplication::restoreOverrideCursor();
2629       QString error = "Cannot import the new image.\n";
2630       error += mSlicerManagers[index]->GetLastError().c_str();
2631       QMessageBox::information(this,tr("Problem reading image !"),error);
2632     }
2633     WindowLevelChanged();
2634     ImageInfoChanged(); //this internally calls WindowLevelChanged...
2635   }
2636   else {
2637     QMessageBox::information(this,tr("Problem reading fusion sequence !"),"File doesn't exist!");
2638     return;
2639   }
2640
2641 }
2642 //------------------------------------------------------------------------------
2643
2644
2645 //------------------------------------------------------------------------------
2646 //fusionSequenceFrameIndex and fusionSequenceNbFrames are relative to the secondary sequence (US)
2647 void vvMainWindow::SetFusionSequenceProperty(int fusionSequenceFrameIndex, bool spatialSyncFlag, unsigned int fusionSequenceNbFrames, bool temporalSyncFlag)
2648 {
2649   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
2650
2651   if (!mSlicerManagers[index]->IsInvolvedInFusionSequence()) return;
2652
2653   //check if the focus moved to the linked sequence, and in this case, select the master sequence instead
2654   if (!mSlicerManagers[index]->IsMainSequenceOfFusionSequence()) {
2655     index = mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager();
2656   }
2657   int secondaryIndex = mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager();
2658   if (secondaryIndex==-1) return; //this should never happen
2659   if ( (!mSlicerManagers[index]->IsMainSequenceOfFusionSequence()) ||
2660     (!mSlicerManagers[secondaryIndex]->IsSecondarySequenceOfFusionSequence()) )
2661   {return;} //this should never happen, raise an exception?
2662
2663   if (mSlicerManagers[index]->GetSlicer(0)->GetFusion()) {
2664
2665     //First, if the spatialSync button is unchecked, then reposition the parent sequence (CT) in its original coordinate frame
2666     if ( (!spatialSyncFlag) && (mSlicerManagers[index]->GetFusionSequenceSpatialSyncFlag()) ) {
2667       for ( unsigned i=0 ; i<mSlicerManagers[index]->GetSlicer(0)->GetImage()->GetTransform().size() ; i++ ) {
2668         mSlicerManagers[index]->GetSlicer(0)->GetImage()->GetTransform()[i]->SetMatrix( mSlicerManagers[index]->GetFusionSequenceMainTransformMatrix() );
2669         mSlicerManagers[index]->GetSlicer(0)->GetImage()->GetTransform()[i]->Update();
2670       }
2671
2672       for (int i=0; i<mSlicerManagers[index]->GetNumberOfSlicers(); i++) {
2673         mSlicerManagers[index]->GetSlicer(i)->ForceUpdateDisplayExtent();
2674         mSlicerManagers[index]->GetSlicer(i)->Render();
2675       }
2676     }
2677
2678     //then, update the property values in the slicer manager
2679     mSlicerManagers[index]->SetFusionSequenceLength(fusionSequenceNbFrames);
2680     mSlicerManagers[index]->SetFusionSequenceSpatialSyncFlag(spatialSyncFlag);
2681     mSlicerManagers[index]->SetFusionSequenceTemporalSyncFlag(temporalSyncFlag);
2682     mSlicerManagers[index]->SetFusionSequenceFrameIndex(fusionSequenceFrameIndex);
2683
2684     //select the right frame of the US sequence
2685     mSlicerManagers[index]->SetFusionSequenceTSlice(fusionSequenceFrameIndex); //here, I should only update the overlayed sequence
2686     mSlicerManagers[secondaryIndex]->SetTSlice(fusionSequenceFrameIndex, false); //this should update the secondary sequence (individual version)
2687
2688     //update the horizontal sliders of the main window
2689     overlayPanel->updateFusionSequenceSliderValueFromWindow(fusionSequenceFrameIndex, false);
2690
2691     if (spatialSyncFlag) { //reslice the CT
2692
2693       if (temporalSyncFlag) { //do the temporal synchronisation
2694         int mainSequenceFrameIndex=0;
2695         //estimate the TSlice to set to the CT
2696         unsigned nbFramesMain = mSlicerManagers[index]->GetImage()->GetTransform().size();
2697         mainSequenceFrameIndex = mSlicerManagers[index]->GetFusionSequenceCorrespondances()[ nbFramesMain + fusionSequenceFrameIndex];
2698         //and set it!
2699         mSlicerManagers[index]->SetTSlice(mainSequenceFrameIndex, false);
2700         //warning, there is a loopback, and modification of the TSlice in main sequence forces an update of the TSlice in secondary, etc...
2701       }
2702
2703
2704       //Set the transform matrix of the parent sequence (typically CT / 4DCT)
2705       vtkSmartPointer<vtkMatrix4x4> tmpMat = vtkSmartPointer<vtkMatrix4x4>::New();
2706       vtkMatrix4x4::Invert( mSlicerManagers[index]->GetFusionSequenceInitialTransformMatrixAtFrame(fusionSequenceFrameIndex), tmpMat );
2707       for ( unsigned i=0 ; i<mSlicerManagers[index]->GetSlicer(0)->GetImage()->GetTransform().size() ; i++ ) {
2708         mSlicerManagers[index]->GetSlicer(0)->GetImage()->GetTransform()[i]->SetMatrix( mSlicerManagers[index]->GetFusionSequenceMainTransformMatrix() );
2709         mSlicerManagers[index]->GetSlicer(0)->GetImage()->GetTransform()[i]->PreMultiply();
2710         mSlicerManagers[index]->GetSlicer(0)->GetImage()->GetTransform()[i]->Concatenate( tmpMat );
2711         mSlicerManagers[index]->GetSlicer(0)->GetImage()->GetTransform()[i]->Update();
2712       }
2713
2714       for (int i=0; i<mSlicerManagers[index]->GetNumberOfSlicers(); i++) {
2715         mSlicerManagers[index]->GetSlicer(i)->ForceUpdateDisplayExtent();
2716         mSlicerManagers[index]->GetSlicer(i)->Render();
2717       }
2718
2719     }
2720
2721   }
2722 }
2723 //------------------------------------------------------------------------------
2724
2725
2726 //------------------------------------------------------------------------------
2727 void vvMainWindow::SaveAs()
2728 {
2729   if (DataTree->selectedItems()[0]->data(1,Qt::UserRole).toString() == "vector") {
2730     QMessageBox::warning(this,tr("Unsupported type"),tr("Sorry, saving a vector field is unsupported for the moment"));
2731     return;
2732   }
2733
2734   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
2735   int dimension = mSlicerManagers[index]->GetDimension();
2736   QStringList OutputListeFormat;
2737   OutputListeFormat.clear();
2738   if (dimension == 1) {
2739     OutputListeFormat.push_back(".mhd");
2740     OutputListeFormat.push_back(".mha");
2741   }
2742   if (dimension == 2) {
2743     OutputListeFormat.push_back(".bmp");
2744     OutputListeFormat.push_back(".png");
2745     OutputListeFormat.push_back(".jpeg");
2746     OutputListeFormat.push_back(".tif");
2747     OutputListeFormat.push_back(".mhd");
2748     OutputListeFormat.push_back(".mha");
2749     OutputListeFormat.push_back(".hdr");
2750     OutputListeFormat.push_back(".vox");
2751   } else if (dimension == 3) {
2752     OutputListeFormat.push_back(".mhd");
2753     OutputListeFormat.push_back(".mha");
2754     OutputListeFormat.push_back(".nii");
2755     OutputListeFormat.push_back(".nrrd");
2756     OutputListeFormat.push_back(".nhdr");
2757     OutputListeFormat.push_back(".hdr");
2758     OutputListeFormat.push_back(".vox");
2759   } else if (dimension == 4) {
2760     OutputListeFormat.push_back(".mhd");
2761     OutputListeFormat.push_back(".mha");
2762     OutputListeFormat.push_back(".nii");
2763     OutputListeFormat.push_back(".nrrd");
2764     OutputListeFormat.push_back(".nhdr");
2765   }
2766   QString Extensions = "AllFiles(*.*)";
2767   for (int i = 0; i < OutputListeFormat.count(); i++) {
2768     Extensions += ";;Images ( *";
2769     Extensions += OutputListeFormat[i];
2770     Extensions += ")";
2771   }
2772   QString fileName = QFileDialog::getSaveFileName(this,
2773     tr("Save As"),
2774     mSlicerManagers[index]->GetFileName().c_str(),
2775     Extensions);
2776   if (!fileName.isEmpty()) {
2777     std::string fileformat = itksys::SystemTools::GetFilenameLastExtension(fileName.toStdString());
2778     if (OutputListeFormat.contains(
2779       fileformat.c_str())) {
2780         QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
2781         std::string action = "Saving";
2782         vvProgressDialog progress("Saving "+fileName.toStdString());
2783         qApp->processEvents();
2784         vvImageWriter::Pointer writer = vvImageWriter::New();
2785         writer->SetOutputFileName(fileName.toStdString());
2786         writer->SetInput(mSlicerManagers[index]->GetImage());
2787
2788         // Check on transform and prompt user
2789         writer->SetSaveTransform(false);
2790         bool bId = true;
2791         for(int i=0; i<4; i++)
2792           for(int j=0; j<4; j++) {
2793             // TODO SR and BP: check on the list of transforms and not the first only
2794             double elt = mSlicerManagers[index]->GetImage()->GetTransform()[0]->GetMatrix()->GetElement(i,j);
2795             if(i==j && elt!=1.)
2796               bId = false;
2797             if(i!=j && elt!=0.)
2798               bId = false;
2799           }
2800           if( !bId ) {
2801             QString warning = "The image has an associated linear transform. Do you want to save it along?";
2802             QMessageBox msgBox(QMessageBox::Warning, tr("Save transform"), warning, 0, this);
2803             msgBox.addButton(tr("Yes"), QMessageBox::AcceptRole);
2804             msgBox.addButton(tr("No"), QMessageBox::RejectRole);
2805             if (msgBox.exec() == QMessageBox::AcceptRole)
2806               writer->SetSaveTransform(true);
2807           }
2808
2809           writer->Update();
2810           QApplication::restoreOverrideCursor();
2811           if (writer->GetLastError().size()) {
2812             QString error = "Saving did not succeed\n";
2813             error += writer->GetLastError().c_str();
2814             QMessageBox::information(this,tr("Saving Problem"),error);
2815             SaveAs();
2816           }
2817     } else {
2818       QString error = fileformat.c_str();
2819       if (error.isEmpty())
2820         error += "no file format specified !";
2821       else
2822         error += " format unknown !!!\n";
2823       QMessageBox::information(this,tr("Saving Problem"),error);
2824       SaveAs();
2825     }
2826   }
2827 }
2828 //------------------------------------------------------------------------------
2829
2830 //------------------------------------------------------------------------------
2831 void vvMainWindow::SaveCurrentState()
2832 {
2833   QString Extensions = "XML Files(*.xml)";
2834   QString fileName = QFileDialog::getSaveFileName(this,
2835     tr("Save Current Window State"),
2836     "",
2837     Extensions);
2838
2839   SaveCurrentStateAs(fileName.toStdString());
2840 }
2841 //------------------------------------------------------------------------------
2842
2843 //------------------------------------------------------------------------------
2844 void vvMainWindow::SaveCurrentStateAs(const std::string& stateFile)
2845 {
2846   vvSaveState save_state;
2847   save_state.Run(this, stateFile);
2848 }
2849
2850 //------------------------------------------------------------------------------
2851 void vvMainWindow::ReadSavedState()
2852 {
2853   QString Extensions = "XML Files(*.xml)";
2854   QString fileName = QFileDialog::getOpenFileName(this,
2855     tr("Load Window State"),
2856     "",
2857     Extensions);
2858
2859   ReadSavedStateFile(fileName.toStdString());
2860 }
2861 //------------------------------------------------------------------------------
2862
2863 //------------------------------------------------------------------------------
2864 void vvMainWindow::ReadSavedStateFile(const std::string& stateFile)
2865 {
2866   vvReadState read_state;
2867   read_state.Run(this, stateFile);
2868 }
2869 //------------------------------------------------------------------------------
2870
2871 //------------------------------------------------------------------------------
2872 void vvMainWindow::LinkAllImages()
2873 {
2874   linkPanel->linkAll();
2875 }
2876
2877 //------------------------------------------------------------------------------
2878 void vvMainWindow::AddLink(QString image1,QString image2,bool fromPanel)
2879 {
2880   if (!fromPanel) {
2881     // delegate to linkPanel if call came from elsewhere...
2882     linkPanel->addLinkFromIds(image1, image2);
2883     return;
2884   }
2885
2886   unsigned int sm1 = 0;
2887   unsigned int sm2 = 0;
2888
2889   for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
2890     if (image1.toStdString() == mSlicerManagers[i]->GetId()) {
2891       mSlicerManagers[i]->AddLink(image2.toStdString());
2892       sm1 = i;
2893     }
2894     if (image2.toStdString() == mSlicerManagers[i]->GetId()) {
2895       mSlicerManagers[i]->AddLink(image1.toStdString());
2896       sm2 = i;
2897     }
2898   }
2899
2900   if (linkPanel->isLinkAll())   {
2901     emit UpdateLinkedNavigation(mSlicerManagers[sm1]->GetId(), mSlicerManagers[mCurrentPickedImageIndex], mSlicerManagers[mCurrentPickedImageIndex]->GetSlicer(0));
2902     emit UpdateLinkedNavigation(mSlicerManagers[sm2]->GetId(), mSlicerManagers[mCurrentPickedImageIndex], mSlicerManagers[mCurrentPickedImageIndex]->GetSlicer(0));
2903   } else {
2904     emit UpdateLinkedNavigation(mSlicerManagers[sm2]->GetId(), mSlicerManagers[sm1], mSlicerManagers[sm1]->GetSlicer(0));
2905   }
2906 }
2907
2908 //------------------------------------------------------------------------------
2909
2910
2911 //------------------------------------------------------------------------------
2912 void vvMainWindow::RemoveLink(QString image1,QString image2)
2913 {
2914   for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
2915     if (image1.toStdString() == mSlicerManagers[i]->GetId()) {
2916       mSlicerManagers[i]->RemoveLink(image2.toStdString());
2917     }
2918     if (image2.toStdString() == mSlicerManagers[i]->GetId()) {
2919       mSlicerManagers[i]->RemoveLink(image1.toStdString());
2920     }
2921   }
2922 }
2923 //------------------------------------------------------------------------------
2924
2925 //------------------------------------------------------------------------------
2926 void vvMainWindow::ChangeImageWithIndexOffset(vvSlicerManager *sm, int slicer, int offset)
2927 {
2928   if(mSlicerManagers.size()==1)
2929     return;
2930
2931   int index = 0;
2932   while(sm != mSlicerManagers[index])
2933     index++;
2934   index = (index+offset+mSlicerManagers.size()) % mSlicerManagers.size();
2935
2936   QTreeWidgetItem* item = GetItemFromSlicerManager(mSlicerManagers[index]);
2937   item->setData(slicer+1,Qt::CheckStateRole,2);         //change checkbox
2938   CurrentImageChanged(mSlicerManagers[index]->GetId()); //select new image
2939   DisplayChanged(item,slicer+1);
2940 }
2941 //------------------------------------------------------------------------------
2942 void vvMainWindow::HorizontalSliderMoved(int value,int column, int slicer_index)
2943 {
2944   for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
2945     if (DataTree->topLevelItem(i)->data(column,Qt::CheckStateRole).toInt() > 1) {
2946       //i is the SlicerManager that is in charge of this slicer.
2947       if (mSlicerManagers[i]->IsInvolvedInFusionSequence()) {
2948         //if the slicerManager is involved in a fusionSequence as the secondary sequence, then update the slider position in the overlay panel and everything accordingly
2949         if (mSlicerManagers[i]->IsSecondarySequenceOfFusionSequence()) {
2950           overlayPanel->updateFusionSequenceSliderValueFromWindow(value, true);
2951         }
2952         else { //if this is the primary sequence that has been modified
2953           if (mSlicerManagers[i]->GetFusionSequenceTemporalSyncFlag()) {
2954             //WARNING: for some obscure reason, there are problems when accessing mSlicerManagers[mSlicerManagers[i]->GetFusionSequenceIndexOfLinkedManager()]->GetFusionSequenceFrameIndex();
2955
2956             int estimatedValue=0;
2957             //estimate a corresponding time index for the secondary (US) sequence, and update it accordingly.
2958             estimatedValue = mSlicerManagers[i]->GetFusionSequenceCorrespondances()[ value ];
2959             //TODO: at the moment, there is a loop in TSlice modifications
2960             //modifying sequence 1 causes seq 2 to update, which in turns update seq1...
2961             //I disable control on seq1 at the moment.
2962             //overlayPanel->updateFusionSequenceSliderValueFromWindow(estimatedValue, true);
2963           }
2964         }
2965       }
2966
2967       for (int j = 0; j < 4; j++) {
2968         mSlicerManagers[i]->SetTSliceInSlicer(value,j);
2969       }
2970       mSlicerManagers[i]->GetSlicer(slicer_index)->Render();
2971       break;
2972     }
2973   }
2974 }
2975 //------------------------------------------------------------------------------
2976
2977
2978 //------------------------------------------------------------------------------
2979 void vvMainWindow::NOHorizontalSliderMoved()
2980 {
2981   // if (mCurrentTime == NOHorizontalSlider->value()) return;
2982   HorizontalSliderMoved(NOHorizontalSlider->value(),COLUMN_UL_VIEW,0);
2983   //  mCurrentTime = NOHorizontalSlider->value();
2984 }
2985 //------------------------------------------------------------------------------
2986
2987
2988 //------------------------------------------------------------------------------
2989 void vvMainWindow::NEHorizontalSliderMoved()
2990 {
2991   // if (mCurrentTime == NEHorizontalSlider->value()) return;
2992   HorizontalSliderMoved(NEHorizontalSlider->value(),COLUMN_UR_VIEW,1);
2993   //  mCurrentTime = NEHorizontalSlider->value();
2994 }
2995 //------------------------------------------------------------------------------
2996
2997
2998 //------------------------------------------------------------------------------
2999 void vvMainWindow::SOHorizontalSliderMoved()
3000 {
3001   // if (mCurrentTime == SOHorizontalSlider->value()) return;
3002   HorizontalSliderMoved(SOHorizontalSlider->value(),COLUMN_DL_VIEW,2);
3003   // mCurrentTime = SOHorizontalSlider->value();
3004 }
3005 //------------------------------------------------------------------------------
3006
3007
3008 //------------------------------------------------------------------------------
3009 void vvMainWindow::SEHorizontalSliderMoved()
3010 {
3011   // if (mCurrentTime == SEHorizontalSlider->value()) return;
3012   HorizontalSliderMoved(SEHorizontalSlider->value(),COLUMN_DR_VIEW,3);
3013   // mCurrentTime = SEHorizontalSlider->value();
3014 }
3015 //------------------------------------------------------------------------------
3016
3017 //------------------------------------------------------------------------------
3018 void vvMainWindow::NOVerticalSliderChanged()
3019 {
3020   static int value=-1;
3021   if (value == NOVerticalSlider->value()) return;
3022   else value = NOVerticalSlider->value();
3023   //  int value = NOVerticalSlider->value();
3024   for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
3025     if (DataTree->topLevelItem(i)->data(COLUMN_UL_VIEW,Qt::CheckStateRole).toInt() > 1) {
3026       if (mSlicerManagers[i]->GetSlicer(0)->GetSlice() != value) {
3027         mSlicerManagers[i]->GetSlicer(0)->SetSlice(value);
3028         mSlicerManagers[i]->VerticalSliderHasChanged(0, value);
3029
3030         // If nor Update/Render -> slider not work
3031         // only render = ok navigation, but for contour Update needed but slower ?
3032
3033         mSlicerManagers[i]->UpdateSlice(0);  // <-- DS add this. Not too much update ? YES. but needed for ImageContour ...
3034         //mSlicerManagers[i]->GetSlicer(0)->Render(); // <-- DS add this, needed for contour, seems ok ? not too slow ?
3035       }
3036       break;
3037     }
3038   }
3039 }
3040 //------------------------------------------------------------------------------
3041
3042
3043 //------------------------------------------------------------------------------
3044 void vvMainWindow::NEVerticalSliderChanged()
3045 {
3046   static int value=-1;
3047   if (value == NEVerticalSlider->value()) return;
3048   else value = NEVerticalSlider->value();
3049   //  int value = NEVerticalSlider->value();
3050   for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
3051     if (DataTree->topLevelItem(i)->data(COLUMN_UR_VIEW,Qt::CheckStateRole).toInt() > 1) {
3052       if (mSlicerManagers[i]->GetSlicer(1)->GetSlice() != value) {
3053         mSlicerManagers[i]->GetSlicer(1)->SetSlice(value);
3054         mSlicerManagers[i]->VerticalSliderHasChanged(1, value);
3055         mSlicerManagers[i]->UpdateSlice(1);
3056         //mSlicerManagers[i]->GetSlicer(1)->Render(); // <-- DS add this, needed for contour, seems ok ? not too slow ?
3057       }
3058       break;
3059     }
3060   }
3061 }
3062 //------------------------------------------------------------------------------
3063
3064
3065 //------------------------------------------------------------------------------
3066 void vvMainWindow::SOVerticalSliderChanged()
3067 {
3068   static int value=-1;
3069   if (value == SOVerticalSlider->value()) return;
3070   else value = SOVerticalSlider->value();
3071   //int value = SOVerticalSlider->value();
3072   for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
3073     if (DataTree->topLevelItem(i)->data(COLUMN_DL_VIEW,Qt::CheckStateRole).toInt() > 1) {
3074       if (mSlicerManagers[i]->GetSlicer(2)->GetSlice() != value) {
3075         mSlicerManagers[i]->GetSlicer(2)->SetSlice(value);
3076         mSlicerManagers[i]->VerticalSliderHasChanged(2, value);
3077         mSlicerManagers[i]->UpdateSlice(2);
3078         //mSlicerManagers[i]->GetSlicer(2)->Render(); // <-- DS add this, needed for contour, seems ok ? not too slow ?
3079       }
3080       // else { DD("avoid SOVerticalSlider slicer update"); }
3081       break;
3082     }
3083   }
3084 }
3085 //------------------------------------------------------------------------------
3086
3087
3088 //------------------------------------------------------------------------------
3089 void vvMainWindow::SEVerticalSliderChanged()
3090 {
3091   static int value=-1;
3092   if (value == SEVerticalSlider->value()) return;
3093   else value = SEVerticalSlider->value();
3094   // int value = SEVerticalSlider->value();
3095   for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
3096     if (DataTree->topLevelItem(i)->data(COLUMN_DR_VIEW,Qt::CheckStateRole).toInt() > 1) {
3097       if (mSlicerManagers[i]->GetSlicer(3)->GetSlice() != value) {
3098         mSlicerManagers[i]->GetSlicer(3)->SetSlice(value);
3099         mSlicerManagers[i]->VerticalSliderHasChanged(3, value);
3100         mSlicerManagers[i]->UpdateSlice(3);
3101         //mSlicerManagers[i]->GetSlicer(3)->Render(); // <-- DS add this, needed for contour, seems ok ? not too slow ?
3102       }
3103       break;
3104     }
3105   }
3106 }
3107 //------------------------------------------------------------------------------
3108
3109
3110 //------------------------------------------------------------------------------
3111 void vvMainWindow::UpdateSlice(int slicer, int slice)
3112 {
3113   // DD("vvMainWindow::UpdateSlice");
3114   //   DD(slicer);
3115   //   DD(slice);
3116   if (slicer == 0) {
3117     //    if (slice != NOVerticalSlider->value())
3118     NOVerticalSlider->setValue(slice);
3119   } else {
3120     if (slicer == 1)
3121       NEVerticalSlider->setValue(slice);
3122     else {
3123       if (slicer == 2)
3124         SOVerticalSlider->setValue(slice);
3125       else {
3126         if (slicer == 3)
3127           SEVerticalSlider->setValue(slice);
3128       }
3129     }
3130   }
3131   // DD("vvMainWindow:UpdateSlice END");
3132 }
3133 //------------------------------------------------------------------------------
3134
3135
3136 //------------------------------------------------------------------------------
3137 void vvMainWindow::UpdateTSlice(int slicer, int slice, int code)
3138 {
3139   //FusionSequence: the slider value should be updated for slicers which show the same sequence as requested
3140   bool doUpdate=false;
3141   if (code==-1) doUpdate=true;
3142   else {
3143     for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
3144       if (DataTree->topLevelItem(i)->data(slicer+1,Qt::CheckStateRole).toInt() > 1) {
3145         //i is the active SlicerManager
3146         if (mSlicerManagers[i]->GetFusionSequenceInvolvmentCode()==code) doUpdate=true;
3147         break;
3148       }
3149     }
3150   }
3151   if (!doUpdate) return;
3152
3153   switch (slicer) {
3154   case 0:
3155     if (NOHorizontalSlider->value()==slice) return;
3156     NOHorizontalSlider->setValue(slice);
3157     break;
3158   case 1:
3159     if (NEHorizontalSlider->value()==slice) return;
3160     NEHorizontalSlider->setValue(slice);
3161     break;
3162   case 2:
3163     if (SOHorizontalSlider->value()==slice) return;
3164     SOHorizontalSlider->setValue(slice);
3165     break;
3166   case 3:
3167     if (SEHorizontalSlider->value()==slice) return;
3168     SEHorizontalSlider->setValue(slice);
3169     break;
3170   }
3171 }
3172 //------------------------------------------------------------------------------
3173
3174
3175 //------------------------------------------------------------------------------
3176 void vvMainWindow::UpdateSliceRange(int slicer, int min, int max, int tmin, int tmax)
3177 {
3178   //int position = int((min+max)/2);
3179   int position = mSlicerManagers[mCurrentPickedImageIndex]->GetSlicer(slicer)->GetSlice();
3180   if (slicer == 0) {
3181     NOVerticalSlider->setRange(min,max);
3182     NOHorizontalSlider->setRange(tmin,tmax);
3183     NOVerticalSlider->setValue(position);
3184   } else if (slicer == 1) {
3185     NEVerticalSlider->setRange(min,max);
3186     NEHorizontalSlider->setRange(tmin,tmax);
3187     NEVerticalSlider->setValue(position);
3188   } else if (slicer == 2) {
3189     SOVerticalSlider->setRange(min,max);
3190     SOHorizontalSlider->setRange(tmin,tmax);
3191     SOVerticalSlider->setValue(position);
3192   } else if (slicer == 3) {
3193     SEVerticalSlider->setRange(min,max);
3194     SEHorizontalSlider->setRange(tmin,tmax);
3195     SEVerticalSlider->setValue(position);
3196   }
3197 }
3198 //------------------------------------------------------------------------------
3199
3200
3201 //------------------------------------------------------------------------------
3202 void vvMainWindow::SaveNOScreenshot()
3203 {
3204   SaveScreenshot(NOViewWidget);
3205 }
3206 //------------------------------------------------------------------------------
3207
3208
3209 //------------------------------------------------------------------------------
3210 void vvMainWindow::SaveNEScreenshot()
3211 {
3212   SaveScreenshot(NEViewWidget);
3213 }
3214 //------------------------------------------------------------------------------
3215
3216
3217 //------------------------------------------------------------------------------
3218 void vvMainWindow::SaveSOScreenshot()
3219 {
3220   SaveScreenshot(SOViewWidget);
3221 }
3222 //------------------------------------------------------------------------------
3223
3224
3225 //------------------------------------------------------------------------------
3226 void vvMainWindow::SaveSEScreenshot()
3227 {
3228   SaveScreenshot(SEViewWidget);
3229 }
3230 //------------------------------------------------------------------------------
3231
3232
3233 //------------------------------------------------------------------------------
3234 void vvMainWindow::SaveScreenshotAllSlices()
3235 {
3236   QVTKWidget *widget = NOViewWidget;
3237
3238   int index = 0;// GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
3239   vvSlicerManager * SM = mSlicerManagers[index];
3240   vvImage * image = SM->GetImage();
3241   vvSlicer * slicer = SM->GetSlicer(0);
3242   int orientation = slicer->GetOrientation();
3243   int nbSlices = image->GetSize()[orientation];
3244   vtkSmartPointer<vtkRenderWindow>  renderWindow = widget->GetRenderWindow();
3245
3246   // Select filename base
3247   QString filename = QFileDialog::getSaveFileName(this,
3248     tr("Save As (filename will be completed by slice number)"),
3249     itksys::SystemTools::GetFilenamePath(mSlicerManagers[index]->GetFileName()).c_str(),
3250     "Images( *.png);;Images( *.jpg)");
3251
3252   // Loop on slices
3253   for(int i=0; i<nbSlices; i++) {
3254     // Change the slice
3255     slicer->SetSlice(i); // -> change the slice of the current slicer
3256     SM->UpdateSlice(0); // --> this one emit UpdateSlice
3257     QCoreApplication::flush(); // -> needed to force display of contours
3258
3259     // Screenshot
3260     vtkSmartPointer<vtkWindowToImageFilter> windowToImageFilter = vtkSmartPointer<vtkWindowToImageFilter>::New();
3261     windowToImageFilter->SetInput(renderWindow);
3262     windowToImageFilter->SetMagnification(1);
3263     windowToImageFilter->SetInputBufferTypeToRGBA(); //also record the alpha (transparency) channel
3264     windowToImageFilter->Update();
3265
3266     vtkSmartPointer<vtkPNGWriter> writer = vtkSmartPointer<vtkPNGWriter>::New();
3267     std::string fn = itksys::SystemTools::GetFilenameWithoutLastExtension(filename.toStdString());
3268     std::string num = clitk::toString(i);
3269     if (i<10) num = "0"+num;
3270     if (i<100) num = "0"+num;
3271     if (i<1000) num = "0"+num;
3272
3273     fn = itksys::SystemTools::GetFilenamePath(filename.toStdString()) + "/"+ fn
3274       + "_" + num + itksys::SystemTools::GetFilenameLastExtension(filename.toStdString());
3275     writer->SetFileName(fn.c_str());
3276 #if VTK_MAJOR_VERSION <= 5
3277     writer->SetInput(windowToImageFilter->GetOutput());
3278 #else
3279     writer->SetInputConnection(windowToImageFilter->GetOutputPort());
3280 #endif
3281     writer->Write();
3282   }
3283 }
3284 //------------------------------------------------------------------------------
3285
3286
3287 //------------------------------------------------------------------------------
3288 void vvMainWindow::SaveScreenshot(QVTKWidget *widget)
3289 {
3290   QString Extensions = "Images( *.png);;";
3291   Extensions += "Images( *.jpg);;";
3292   Extensions += "Images( *.bmp);;";
3293   Extensions += "Images( *.tif);;";
3294   Extensions += "Images( *.ppm)";
3295 #if defined(VTK_USE_FFMPEG_ENCODER) || defined(VTK_USE_VIDEO_FOR_WINDOWS)
3296   Extensions += ";;Video( *.avi)";
3297 #endif
3298 #ifdef VTK_USE_MPEG2_ENCODER
3299   Extensions += ";;Video( *.mpg)";
3300 #endif
3301 #ifdef CLITK_EXPERIMENTAL
3302   Extensions += ";;Video( *.gif)";
3303 #endif
3304
3305   int smIndex=GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
3306   QString fileName = QFileDialog::getSaveFileName(this,
3307     tr("Save As"),
3308     itksys::SystemTools::GetFilenamePath(mSlicerManagers[smIndex]->GetFileName()).c_str(),
3309     Extensions);
3310
3311   if (!fileName.isEmpty()) {
3312     vtkSmartPointer<vtkWindowToImageFilter> w2i = vtkSmartPointer<vtkWindowToImageFilter>::New();
3313     w2i->SetInput(widget->GetRenderWindow());
3314     w2i->Update();
3315     vtkImageData *image = w2i->GetOutput();
3316
3317     std::string ext(itksys::SystemTools::GetFilenameLastExtension(fileName.toStdString()));
3318
3319     // Image
3320     vtkImageWriter *imgwriter = NULL;
3321     if (ext==".bmp")
3322       imgwriter = vtkBMPWriter::New();
3323     else if (ext==".tif")
3324       imgwriter = vtkTIFFWriter::New();
3325     else if (ext==".ppm")
3326       imgwriter = vtkPNMWriter::New();
3327     else if (ext==".png")
3328       imgwriter = vtkPNGWriter::New();
3329     else if (ext==".jpg")
3330       imgwriter = vtkJPEGWriter::New();
3331
3332     // Snapshot image if not null
3333     if(imgwriter!=NULL) {
3334 #if VTK_MAJOR_VERSION <= 5
3335       imgwriter->SetInput(image);
3336 #else
3337       imgwriter->SetInputConnection(w2i->GetOutputPort());
3338 #endif
3339       imgwriter->SetFileName(fileName.toStdString().c_str());
3340       imgwriter->Write();
3341       return;
3342     }
3343
3344     // Video
3345     vtkGenericMovieWriter *vidwriter = NULL;
3346 #if CLITK_EXPERIMENTAL == 1
3347     if (ext==".gif") {
3348       vvAnimatedGIFWriter *gif = vvAnimatedGIFWriter::New();
3349       vidwriter = gif;
3350
3351       // FPS
3352       bool ok;
3353       int fps = QInputDialog::getInt(this, tr("Number of frames per second"),
3354         tr("FPS:"), 5, 0, 1000, 1, &ok);
3355       if(ok)
3356         gif->SetRate(fps);
3357
3358       // Loops
3359       int loops = QInputDialog::getInt(this, tr("Loops"),
3360         tr("Number of loops (0 means infinite):"), 0, 0, 1000000000, 1, &ok);
3361       if(ok)
3362         gif->SetLoops(loops);
3363
3364       // Dithering
3365       QString msg = "Would you like to activate dithering?";
3366       QMessageBox msgBox(QMessageBox::Question, tr("Dithering"),msg, 0, this);
3367       msgBox.addButton(tr("Yes"), QMessageBox::AcceptRole);
3368       msgBox.addButton(tr("No"), QMessageBox::RejectRole);
3369       gif->SetDither(msgBox.exec() == QMessageBox::AcceptRole);
3370     }
3371 #endif
3372 #ifdef VTK_USE_VIDEO_FOR_WINDOWS
3373     if (ext==".avi") {
3374       vtkAVIWriter *mpg = vtkAVIWriter::New();
3375       vidwriter = mpg;
3376       mpg->SetQuality(2);
3377       bool ok;
3378       int fps = QInputDialog::getInteger(this, tr("Number of frames per second"),
3379         tr("FPS:"), 5, 0, 1024, 1, &ok);
3380       if(!ok)
3381         fps = 5;
3382       mpg->SetRate(fps);
3383     }
3384 #endif
3385 #ifdef VTK_USE_FFMPEG_ENCODER
3386     if (ext==".avi") {
3387       vtkFFMPEGWriter *mpg = vtkFFMPEGWriter::New();
3388       vidwriter = mpg;
3389       mpg->SetQuality(2);
3390       bool ok;
3391       int fps = QInputDialog::getInteger(this, tr("Number of frames per second"),
3392         tr("FPS:"), 5, 0, 1024, 1, &ok);
3393       if(!ok)
3394         fps = 5;
3395       mpg->SetRate(fps);
3396       mpg->SetBitRateTolerance(int(ceil(12.0*1024*1024/fps)));
3397     }
3398 #endif
3399 #ifdef VTK_USE_MPEG2_ENCODER
3400     if (ext==".mpg") {
3401       vtkMPEG2Writer *mpg = vtkMPEG2Writer::New();
3402       vidwriter = mpg;
3403     }
3404 #endif
3405
3406     // Take video if not null
3407     if(vidwriter!=NULL){
3408 #if VTK_MAJOR_VERSION <= 5
3409       vidwriter->SetInput(image);
3410 #else
3411       vidwriter->SetInputConnection(w2i->GetOutputPort());
3412 #endif
3413       vidwriter->SetFileName(fileName.toStdString().c_str());
3414       vidwriter->Start();
3415       int nSlice = mSlicerManagers[smIndex]->GetSlicer(0)->GetTMax();
3416       for(int i=0; i<=nSlice; i++) {
3417         mSlicerManagers[smIndex]->SetNextTSlice(0);
3418         vtkSmartPointer<vtkWindowToImageFilter> w2i = vtkSmartPointer<vtkWindowToImageFilter>::New();
3419         w2i->SetInput(widget->GetRenderWindow());
3420         w2i->Update();
3421 #if VTK_MAJOR_VERSION <= 5
3422         vidwriter->SetInput(w2i->GetOutput());
3423 #else
3424         vidwriter->SetInputConnection(w2i->GetOutputPort());
3425 #endif
3426         vidwriter->Write();
3427       }
3428       vidwriter->End();
3429       vidwriter->Delete();
3430       return;
3431     }
3432
3433     QMessageBox::information(this,tr("Problem saving screenshot !"),tr("Cannot save image.\nPlease set a file extension !!!"));
3434   }
3435 }
3436 //------------------------------------------------------------------------------
3437
3438
3439 //------------------------------------------------------------------------------
3440 void vvMainWindow::GoToCursor()
3441 {
3442   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
3443   for (int column = 1; column < 5; column++) {
3444     if (DataTree->selectedItems()[0]->data(column,Qt::CheckStateRole).toInt() > 1) {
3445       double* cursorPos = mSlicerManagers[index]->GetSlicer(column-1)->GetCursorPosition();
3446       mSlicerManagers[index]->GetSlicer(column-1)->SetCurrentPosition(
3447         cursorPos[0],cursorPos[1],cursorPos[2],cursorPos[3]);
3448       mSlicerManagers[index]->UpdateViews(1,column-1);
3449       mSlicerManagers[index]->UpdateLinked(column-1);
3450       break;
3451     }
3452   }
3453 }
3454 //------------------------------------------------------------------------------
3455
3456 //------------------------------------------------------------------------------
3457 void vvMainWindow::GoToLandmark()
3458 {
3459   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
3460   for (int column = 1; column < 5; column++) {
3461     if (DataTree->selectedItems()[0]->data(column,Qt::CheckStateRole).toInt() > 1) {
3462       double* cursorPos = landmarksPanel->GetSelectedPoint();
3463       mSlicerManagers[index]->GetSlicer(column-1)->SetCurrentPosition(
3464         cursorPos[0],cursorPos[1],cursorPos[2],cursorPos[3]);
3465       mSlicerManagers[index]->UpdateViews(1,column-1);
3466       mSlicerManagers[index]->UpdateLinked(column-1);
3467       break;
3468     }
3469   }
3470 }
3471 //------------------------------------------------------------------------------
3472
3473 //------------------------------------------------------------------------------
3474 void vvMainWindow::PlayPause()
3475 {
3476   if (playMode) {
3477     playMode = 0;
3478     playButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/player_play.png")));
3479     ImageInfoChanged();
3480     return;
3481   } else {
3482     int image_number=DataTree->topLevelItemCount();
3483     bool has_temporal;
3484     for (int i=0; i<image_number; i++)
3485       if (mSlicerManagers[i]->GetSlicer(0)->GetTMax() > 0) {
3486         has_temporal=true;
3487         break;
3488       }
3489       if (has_temporal) {
3490         playMode = 1;
3491         playButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/player_pause.png")));
3492         QTimer::singleShot(1000/mFrameRate, this, SLOT(PlayNext()));
3493       }
3494   }
3495 }
3496 //------------------------------------------------------------------------------
3497
3498 //------------------------------------------------------------------------------
3499 void vvMainWindow::PlayNext()
3500 {
3501   if (playMode && !this->isHidden()) {
3502     int image_number=DataTree->topLevelItemCount();
3503     ///Only play one slicer per SM, and only if the SM is being displayed
3504     for (int i=0; i<image_number; i++)
3505       for (int j=0; j<4; j++)
3506         if (mSlicerManagers[i]->GetSlicer(0)->GetTMax() > 0 &&
3507           DataTree->topLevelItem(i)->data(j+1,Qt::CheckStateRole).toInt() > 0) {
3508             mSlicerManagers[i]->SetNextTSlice(j);
3509             break;
3510         }
3511         QTimer::singleShot(1000/mFrameRate, this, SLOT(PlayNext()));
3512   }
3513 }
3514 //------------------------------------------------------------------------------
3515
3516 void vvMainWindow::ShowLastImage()
3517 {
3518   if (mSlicerManagers.size() > 1) {
3519     QTreeWidgetItem * item=DataTree->topLevelItem(DataTree->topLevelItemCount()-1);
3520     CurrentImageChanged(mSlicerManagers.back()->GetId()); //select new image
3521     item->setData(1,Qt::CheckStateRole,2); //show the new image in the first panel
3522     //mSlicerManagers[GetSlicerIndexFromItem(item)]->GetSlicer(0)->SetActorVisibility("image", 0, 1); //Set the Last Image visibles
3523     DisplayChanged(item,1);
3524   }
3525 }
3526
3527 //------------------------------------------------------------------------------
3528 void vvMainWindow::UpdateRenderWindows()
3529 {
3530   for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
3531     mSlicerManagers[i]->GetSlicer(0)->UpdateLandmarks();
3532     mSlicerManagers[i]->GetSlicer(1)->UpdateLandmarks();
3533     mSlicerManagers[i]->GetSlicer(2)->UpdateLandmarks();
3534     mSlicerManagers[i]->GetSlicer(3)->UpdateLandmarks();
3535   }
3536   if (NOViewWidget->GetRenderWindow()) NOViewWidget->GetRenderWindow()->Render();
3537   if (NEViewWidget->GetRenderWindow()) NEViewWidget->GetRenderWindow()->Render();
3538   if (SOViewWidget->GetRenderWindow()) SOViewWidget->GetRenderWindow()->Render();
3539   if (SEViewWidget->GetRenderWindow()) SEViewWidget->GetRenderWindow()->Render();
3540 }
3541 //------------------------------------------------------------------------------
3542
3543 //------------------------------------------------------------------------------
3544 void vvMainWindow::SegmentationOnCurrentImage()
3545 {
3546   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
3547
3548   vvSegmentationDialog segmentation;
3549   segmentation.SetImage(mSlicerManagers[index]->GetSlicer(0)->GetImage());
3550   segmentation.exec();
3551 }
3552 //------------------------------------------------------------------------------
3553
3554 void vvMainWindow::SurfaceViewerLaunch()
3555 {
3556   vvSurfaceViewerDialog surfaceViewer;
3557   surfaceViewer.exec();
3558 }
3559 //------------------------------------------------------------------------------
3560
3561
3562 //------------------------------------------------------------------------------
3563 int vvMainWindow::GetImageDuplicateFilenameNumber(std::string filename)
3564 {
3565   int number=0;
3566   for(unsigned int l=0; l<mSlicerManagers.size(); l++) {
3567     vvSlicerManager * v = mSlicerManagers[l];
3568     if (v->GetBaseFileName() ==
3569       vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename))) {
3570         number = std::max(number, v->GetBaseFileNameNumber()+1);
3571     }
3572   }
3573   return number;
3574 }
3575 //------------------------------------------------------------------------------
3576
3577
3578 //------------------------------------------------------------------------------
3579 vvSlicerManager* vvMainWindow::AddImage(vvImage::Pointer image,std::string filename)
3580 {
3581   // Change filename if another image exist with the same name
3582   int number = GetImageDuplicateFilenameNumber(filename);
3583
3584   // Create new SliceManager
3585   vvSlicerManager* slicer_manager = new vvSlicerManager(4);
3586   slicer_manager->SetImage(image);//, IMAGE, number);
3587   //  filename = filename+"_"+clitk::toString(number);
3588   slicer_manager->SetFilename(filename, number);
3589   mSlicerManagers.push_back(slicer_manager);
3590
3591   //create an item in the tree with good settings
3592   QTreeWidgetItem *item = new QTreeWidgetItem();
3593   item->setData(0,Qt::UserRole,slicer_manager->GetFileName().c_str());//files[i].c_str());
3594   item->setData(1,Qt::UserRole,tr("image"));
3595   item->setData(COLUMN_IMAGE_NAME,Qt::DisplayRole,slicer_manager->GetFileName().c_str());//filename.c_str());
3596   qApp->processEvents();
3597
3598   for (int j = 1; j <= 4; j++) item->setData(j,Qt::CheckStateRole,1);
3599
3600   //Create the buttons for reload and close
3601   qApp->processEvents();
3602   QTreePushButton* cButton = new QTreePushButton;
3603   cButton->setItem(item);
3604   cButton->setColumn(COLUMN_CLOSE_IMAGE);
3605   cButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/exit.png")));
3606   connect(cButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
3607     this,SLOT(CloseImage(QTreeWidgetItem*, int)));
3608
3609   QTreePushButton* rButton = new QTreePushButton;
3610   rButton->setItem(item);
3611   rButton->setColumn(COLUMN_RELOAD_IMAGE);
3612   rButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/rotateright.png")));
3613   rButton->setEnabled(0);
3614   connect(rButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
3615     this,SLOT(ReloadImage(QTreeWidgetItem*, int)));
3616
3617   DataTree->addTopLevelItem(item);
3618   DataTree->setItemWidget(item, COLUMN_CLOSE_IMAGE, cButton);
3619   DataTree->setItemWidget(item, COLUMN_RELOAD_IMAGE, rButton);
3620
3621   //set the id of the image
3622   QString id = QDir::current().absoluteFilePath(slicer_manager->GetFileName().c_str()) + QString::number(mSlicerManagers.size()-1);
3623   item->setData(COLUMN_IMAGE_NAME,Qt::UserRole,id.toStdString().c_str());
3624   mSlicerManagers.back()->SetId(id.toStdString());
3625
3626   linkPanel->addImage(slicer_manager->GetFileName().c_str()// filename
3627     , id.toStdString());
3628
3629   connect(mSlicerManagers.back(), SIGNAL(currentImageChanged(std::string)),
3630     this, SLOT(CurrentImageChanged(std::string)));
3631   connect(mSlicerManagers.back(), SIGNAL(currentPickedImageChanged(std::string)),
3632     this, SLOT(CurrentPickedImageChanged(std::string)));
3633   connect(mSlicerManagers.back(), SIGNAL(UpdatePosition(int, double, double, double, double, double, double, double)),
3634     this, SLOT(MousePositionChanged(int,double, double, double, double, double, double, double)));
3635   connect(mSlicerManagers.back(), SIGNAL(UpdateVector(int, double, double, double, double)),
3636     this, SLOT(VectorChanged(int,double,double,double, double)));
3637   connect(mSlicerManagers.back(), SIGNAL(UpdateOverlay(int, double, double)),
3638     this, SLOT(OverlayChanged(int,double,double)));
3639   connect(mSlicerManagers.back(), SIGNAL(UpdateFusion(int, double)),
3640     this, SLOT(FusionChanged(int,double)));
3641   //connect(mSlicerManagers.back(), SIGNAL(UpdateFusionSequence(int, bool, unsigned int)),
3642   //  this, SLOT(FusionSequenceChanged(int, bool, unsigned int)));
3643   connect(mSlicerManagers.back(), SIGNAL(WindowLevelChanged()),
3644     this,SLOT(WindowLevelChanged()));
3645   connect(mSlicerManagers.back(), SIGNAL(UpdateSlice(int,int)),
3646     this,SLOT(UpdateSlice(int,int)));
3647   connect(mSlicerManagers.back(), SIGNAL(UpdateTSlice(int, int, int)),
3648     this,SLOT(UpdateTSlice(int, int, int)));
3649   connect(mSlicerManagers.back(), SIGNAL(UpdateTSlice(int, int, int)),
3650     this,SLOT(ImageInfoChanged()));
3651   connect(mSlicerManagers.back(), SIGNAL(UpdateSliceRange(int,int,int,int,int)),
3652     this,SLOT(UpdateSliceRange(int,int,int,int,int)));
3653   connect(mSlicerManagers.back(), SIGNAL(UpdateLinkManager(std::string,int,double,double,double,int)),
3654     this,SLOT(UpdateLinkManager(std::string,int,double,double,double,int)));
3655   connect(mSlicerManagers.back(), SIGNAL(UpdateLinkedNavigation(std::string,vvSlicerManager*,vvSlicer*)),
3656     this,SLOT(UpdateLinkedNavigation(std::string,vvSlicerManager*,vvSlicer*)));
3657   connect(mSlicerManagers.back(), SIGNAL(ChangeImageWithIndexOffset(vvSlicerManager*,int,int)),
3658     this,SLOT(ChangeImageWithIndexOffset(vvSlicerManager*,int,int)));
3659   connect(mSlicerManagers.back(), SIGNAL(LandmarkAdded()),landmarksPanel,SLOT(AddPoint()));
3660
3661
3662
3663   InitSlicers();
3664   UpdateTree();
3665   qApp->processEvents();
3666   InitDisplay();
3667   ShowLastImage();
3668   qApp->processEvents();
3669   // End
3670   ImageInfoChanged();
3671   return slicer_manager;
3672 }
3673 //------------------------------------------------------------------------------
3674
3675
3676 //------------------------------------------------------------------------------
3677 void vvMainWindow::UpdateCurrentSlicer()
3678 {
3679   int index = -1;
3680   if (DataTree->selectedItems().size() > 0) {
3681     index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
3682   }
3683   mSlicerManagerCurrentIndex = index;
3684 }
3685 //------------------------------------------------------------------------------