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 #if VTK_MAJOR_VERSION > 5
2040       for ( unsigned int i = 0; i < mSlicerManagers[index]->GetNumberOfSlicers(); i++)
2041         mSlicerManagers[index]->GetSlicer(i)->ForceUpdateDisplayExtent();
2042 #endif
2043
2044       for (int j = 1; j <= 4; j++) {
2045         item->setData(j,Qt::CheckStateRole,DataTree->topLevelItem(index)->data(j,Qt::CheckStateRole));
2046       }
2047
2048       //Create the buttons for reload and close
2049       qApp->processEvents();
2050       QTreePushButton* cButton = new QTreePushButton;
2051       cButton->setItem(item);
2052       cButton->setColumn(COLUMN_CLOSE_IMAGE);
2053       cButton->setToolTip(tr("close image"));
2054       cButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/exit.png")));
2055       connect(cButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
2056         this,SLOT(CloseImage(QTreeWidgetItem*, int)));
2057
2058       QTreePushButton* rButton = new QTreePushButton;
2059       rButton->setItem(item);
2060       rButton->setColumn(COLUMN_RELOAD_IMAGE);
2061       rButton->setToolTip(tr("reload image"));
2062       rButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/rotateright.png")));
2063       connect(rButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
2064         this,SLOT(ReloadImage(QTreeWidgetItem*, int)));
2065
2066       DataTree->topLevelItem(index)->setExpanded(1);
2067       DataTree->topLevelItem(index)->addChild(item);
2068       DataTree->setItemWidget(item, COLUMN_CLOSE_IMAGE, cButton);
2069       DataTree->setItemWidget(item, COLUMN_RELOAD_IMAGE, rButton);
2070
2071       //set the id of the image
2072       QString id = DataTree->topLevelItem(index)->data(COLUMN_IMAGE_NAME,Qt::UserRole).toString();
2073       item->setData(COLUMN_IMAGE_NAME,Qt::UserRole,id.toStdString().c_str());
2074       UpdateTree();
2075       qApp->processEvents();
2076       ImageInfoChanged();
2077       QApplication::restoreOverrideCursor();
2078
2079       // Update the display to update, e.g., the sliders
2080       for(int i=0; i<4; i++)
2081         DisplaySliders(index, i);
2082     } else {
2083       QApplication::restoreOverrideCursor();
2084       QString error = "Cannot import the new image.\n";
2085       error += mSlicerManagers[index]->GetLastError().c_str();
2086       QMessageBox::information(this,tr("Problem reading image !"),error);
2087     }
2088     WindowLevelChanged();
2089   }
2090   else
2091     QMessageBox::information(this,tr("Problem reading Overlay !"),"File doesn't exist!");
2092 }
2093 //------------------------------------------------------------------------------
2094
2095
2096 //------------------------------------------------------------------------------
2097 void vvMainWindow::AddROI(int index, QString file)
2098 {
2099   /*
2100   // Get slice manager
2101
2102   // Load image
2103
2104   vvImageReader * mReader = new vvImageReader;
2105   mReader->SetInputFilename(filename.toStdString());
2106   mReader->Update(IMAGE);
2107   if (mReader->GetLastError().size() != 0) {
2108   std::cerr << "Error while reading " << filename.toStdString() << std::endl;
2109   QString error = "Cannot open file \n";
2110   error += mReader->GetLastError().c_str();
2111   QMessageBox::information(this,tr("Reading problem"),error);
2112   delete mReader;
2113   return;
2114   }
2115   vvImage::Pointer roi = mReader->GetOutput();
2116
2117   // Create roi in new tool
2118   vvToolStructureSetManager::AddImage(mCurrentSlicerManager, roi);
2119   */
2120 }
2121 //------------------------------------------------------------------------------
2122
2123 //------------------------------------------------------------------------------
2124 void vvMainWindow::SelectFusionImage()
2125 {
2126   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
2127
2128   //check if one fusion image is added
2129   for (int child = 0; child < DataTree->topLevelItem(index)->childCount(); child++)
2130     if ( (DataTree->topLevelItem(index)->child(child)->data(1,Qt::UserRole).toString() == "fusion") ||
2131       (DataTree->topLevelItem(index)->child(child)->data(1,Qt::UserRole).toString() == "fusionSequence") ) {
2132         QString error = "Cannot add more than one fusion image\n";
2133         error += "Please remove first ";
2134         error += DataTree->topLevelItem(index)->child(child)->data(COLUMN_IMAGE_NAME,Qt::DisplayRole).toString();
2135         QMessageBox::information(this,tr("Problem adding fusion image !"),error);
2136         return;
2137     }
2138
2139     QString Extensions = EXTENSIONS;
2140     Extensions += ";;All Files (*)";
2141     QStringList files = QFileDialog::getOpenFileNames(this,tr("Load Fusion image"),mInputPathName,Extensions);
2142     if (files.isEmpty())
2143       return;
2144
2145     std::vector<std::string> vecFileNames;
2146     for (int i = 0; i < files.size(); i++) {
2147       vecFileNames.push_back(files[i].toStdString());
2148     }
2149     AddFusionImage(index,vecFileNames,vvImageReader::IMAGE);
2150 }
2151 //------------------------------------------------------------------------------
2152
2153 //------------------------------------------------------------------------------
2154 void vvMainWindow::ResetTransformationToIdentity()
2155 {
2156   std::string actorType = DataTree->selectedItems()[0]->data(1,Qt::UserRole).toString().toStdString();
2157   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
2158   mSlicerManagers[index]->ResetTransformationToIdentity(actorType);
2159   ImageInfoChanged();
2160 }
2161 //------------------------------------------------------------------------------
2162
2163 //------------------------------------------------------------------------------
2164 void vvMainWindow::AddFusionImage(int index, std::vector<std::string> fileNames, vvImageReader::LoadedImageType type)
2165 {
2166   QString file(fileNames[0].c_str());
2167   if (QFile::exists(file))
2168   {
2169     mInputPathName = itksys::SystemTools::GetFilenamePath(file.toStdString()).c_str();
2170     itk::ImageIOBase::Pointer reader = itk::ImageIOFactory::CreateImageIO(
2171       file.toStdString().c_str(), itk::ImageIOFactory::ReadMode);
2172     reader->SetFileName(fileNames[0].c_str());
2173     reader->ReadImageInformation();
2174     std::string component = reader->GetComponentTypeAsString(reader->GetComponentType());
2175     int dimension = reader->GetNumberOfDimensions();
2176     QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
2177     vvProgressDialog progress("Opening fusion");
2178     qApp->processEvents();
2179
2180     std::string filename = itksys::SystemTools::GetFilenameWithoutExtension(file.toStdString()).c_str();
2181     if (mSlicerManagers[index]->SetFusion(fileNames,dimension, component,type)) {
2182       //create an item in the tree with good settings
2183       QTreeWidgetItem *item = new QTreeWidgetItem();
2184       item->setData(0,Qt::UserRole,file.toStdString().c_str());
2185       item->setData(1,Qt::UserRole,tr("fusion"));
2186       QFileInfo fileinfo(file); //Do not show the path
2187           item->setData(COLUMN_IMAGE_NAME,Qt::DisplayRole,fileinfo.fileName());
2188           item->setToolTip(COLUMN_IMAGE_NAME, mSlicerManagers[index]->GetListOfAbsoluteFilePathInOneString("fusion").c_str());
2189           qApp->processEvents();
2190 #if VTK_MAJOR_VERSION > 5
2191       for ( unsigned int i = 0; i < mSlicerManagers[index]->GetNumberOfSlicers(); i++)
2192         mSlicerManagers[index]->GetSlicer(i)->ForceUpdateDisplayExtent();
2193 #endif
2194       for (int j = 1; j <= 4; j++) {
2195         item->setData(j,Qt::CheckStateRole,DataTree->topLevelItem(index)->data(j,Qt::CheckStateRole));
2196       }
2197
2198       //Create the buttons for reload and close
2199       qApp->processEvents();
2200       QTreePushButton* cButton = new QTreePushButton;
2201       cButton->setItem(item);
2202       cButton->setColumn(COLUMN_CLOSE_IMAGE);
2203       cButton->setToolTip(tr("close image"));
2204       cButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/exit.png")));
2205       connect(cButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
2206         this,SLOT(CloseImage(QTreeWidgetItem*, int)));
2207
2208       QTreePushButton* rButton = new QTreePushButton;
2209       rButton->setItem(item);
2210       rButton->setColumn(COLUMN_RELOAD_IMAGE);
2211       rButton->setToolTip(tr("reload image"));
2212       rButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/rotateright.png")));
2213       connect(rButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
2214         this,SLOT(ReloadImage(QTreeWidgetItem*, int)));
2215
2216       DataTree->topLevelItem(index)->setExpanded(1);
2217       DataTree->topLevelItem(index)->addChild(item);
2218       DataTree->setItemWidget(item, COLUMN_CLOSE_IMAGE, cButton);
2219       DataTree->setItemWidget(item, COLUMN_RELOAD_IMAGE, rButton);
2220
2221       //set the id of the image
2222       QString id = DataTree->topLevelItem(index)->data(COLUMN_IMAGE_NAME,Qt::UserRole).toString();
2223       item->setData(COLUMN_IMAGE_NAME,Qt::UserRole,id.toStdString().c_str());
2224       UpdateTree();
2225       qApp->processEvents();
2226       ImageInfoChanged();
2227       QApplication::restoreOverrideCursor();
2228
2229       // Update the display to update, e.g., the sliders
2230       for(int i=0; i<4; i++)
2231         DisplaySliders(index, i);
2232     } else {
2233       QApplication::restoreOverrideCursor();
2234       QString error = "Cannot import the new image.\n";
2235       error += mSlicerManagers[index]->GetLastError().c_str();
2236       QMessageBox::information(this,tr("Problem reading image !"),error);
2237     }
2238     WindowLevelChanged();
2239   }
2240   else
2241     QMessageBox::information(this,tr("Problem reading Fusion !"),"File doesn't exist!");
2242 }
2243 //------------------------------------------------------------------------------
2244 //------------------------------------------------------------------------------
2245 void vvMainWindow::AddLandmarks(int index, std::vector<std::string> files)
2246 {
2247     if (!landmarksPanel->LoadFromFile(files))
2248       QMessageBox::information(this,tr("Problem reading Landmarks !"),"File doesn't exist!");
2249
2250     landmarksPanel->SetCurrentPath(mInputPathName.toStdString());
2251     landmarksPanel->SetCurrentImage(mSlicerManagers[index]->GetFileName().c_str());
2252 }
2253
2254 //------------------------------------------------------------------------------
2255 void vvMainWindow::OpenField()
2256 {
2257   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
2258   //check if a vector field has already been added
2259   for (int child = 0; child < DataTree->topLevelItem(index)->childCount(); child++)
2260     if (DataTree->topLevelItem(index)->child(child)->data(1,Qt::UserRole).toString() == "vector") {
2261       QString error = "Cannot add more than one vector field\n";
2262       error += "Please remove first ";
2263       error += DataTree->topLevelItem(index)->child(child)->data(COLUMN_IMAGE_NAME,Qt::DisplayRole).toString();
2264       QMessageBox::information(this,tr("Problem adding vector field!"),error);
2265       return;
2266     }
2267
2268     QString Extensions = "Images ( *.mhd *.mha *.vf *.nii *.nrrd *.nhdr)";
2269     // Extensions += ";;Images ( *.mha)";
2270     // Extensions += ";;VF Images ( *.vf)";
2271     // Extensions += ";;nii Images ( *.nii)";
2272     // Extensions += ";;nrrd Images ( *.nrrd)";
2273     // Extensions += ";;nhdr Images ( *.nhdr)";
2274     Extensions += ";;All Files (*)";
2275     QString file = QFileDialog::getOpenFileName(this,tr("Load deformation field"),mInputPathName,Extensions);
2276     if (!file.isEmpty())
2277       AddField(file,index);
2278 }
2279 //------------------------------------------------------------------------------
2280
2281
2282 //------------------------------------------------------------------------------
2283 void vvMainWindow::AddFieldEntry(QString filename,int index,bool from_disk)
2284 {
2285   //create an item in the tree with good settings
2286   QTreeWidgetItem *item = new QTreeWidgetItem();
2287   item->setData(0,Qt::UserRole,filename.toStdString().c_str());
2288   item->setData(1,Qt::UserRole,tr("vector"));
2289   QFileInfo fileinfo(filename); //Do not show the path
2290   item->setData(COLUMN_IMAGE_NAME,Qt::DisplayRole,fileinfo.fileName());
2291   item->setToolTip(COLUMN_IMAGE_NAME, mSlicerManagers[index]->GetListOfAbsoluteFilePathInOneString("vector").c_str());
2292   qApp->processEvents();
2293
2294   for (int j = 1; j <= 4; j++) {
2295     item->setData(j,Qt::CheckStateRole,DataTree->topLevelItem(index)->data(j,Qt::CheckStateRole));
2296   }
2297
2298   //Create the buttons for reload and close
2299   qApp->processEvents();
2300   QTreePushButton* cButton = new QTreePushButton;
2301   cButton->setItem(item);
2302   cButton->setColumn(COLUMN_CLOSE_IMAGE);
2303   cButton->setToolTip(tr("close vector field"));
2304   cButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/exit.png")));
2305   connect(cButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
2306     this,SLOT(CloseImage(QTreeWidgetItem*, int)));
2307
2308   QTreePushButton* rButton = new QTreePushButton;
2309   rButton->setItem(item);
2310   rButton->setColumn(COLUMN_RELOAD_IMAGE);
2311   rButton->setToolTip(tr("reload vector field"));
2312   rButton->setEnabled(from_disk);
2313   rButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/rotateright.png")));
2314   connect(rButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
2315     this,SLOT(ReloadImage(QTreeWidgetItem*, int)));
2316
2317   DataTree->topLevelItem(index)->setExpanded(1);
2318   DataTree->topLevelItem(index)->addChild(item);
2319   DataTree->setItemWidget(item, COLUMN_RELOAD_IMAGE, rButton);
2320   DataTree->setItemWidget(item, COLUMN_CLOSE_IMAGE, cButton);
2321
2322   //set the id of the image
2323   QString id = DataTree->topLevelItem(index)->data(COLUMN_IMAGE_NAME,Qt::UserRole).toString();
2324   item->setData(COLUMN_IMAGE_NAME,Qt::UserRole,id.toStdString().c_str());
2325   UpdateTree();
2326   qApp->processEvents();
2327   ImageInfoChanged();
2328   QApplication::restoreOverrideCursor();
2329 }
2330 //------------------------------------------------------------------------------
2331
2332
2333 //------------------------------------------------------------------------------
2334 void vvMainWindow::AddField(vvImage::Pointer vf,QString file,int index)
2335 {
2336   QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
2337   vvSlicerManager* imageManager = mSlicerManagers[index];
2338   if (imageManager->SetVF(vf,file.toStdString())) {
2339     AddFieldEntry(file,index,false);
2340 #if VTK_MAJOR_VERSION > 5
2341       for ( unsigned int i = 0; i < mSlicerManagers[index]->GetNumberOfSlicers(); i++)
2342         mSlicerManagers[index]->GetSlicer(i)->ForceUpdateDisplayExtent();
2343 #endif
2344   } else {
2345     QString error = "Cannot import the vector field for this image.\n";
2346     error += imageManager->GetLastError().c_str();
2347     QMessageBox::information(this,tr("Problem reading VF !"),error);
2348   }
2349   QApplication::restoreOverrideCursor();
2350 }
2351 //------------------------------------------------------------------------------
2352
2353
2354 //------------------------------------------------------------------------------
2355 void vvMainWindow::AddField(QString file,int index)
2356 {
2357   if (QFile::exists(file)) {
2358     mInputPathName = itksys::SystemTools::GetFilenamePath(file.toStdString()).c_str();
2359
2360     //init the progress events
2361     QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
2362     vvProgressDialog progress("Opening " + file.toStdString());
2363     qApp->processEvents();
2364
2365     //read the vector and put it in the current mSlicerManager
2366     vvSlicerManager* imageManager = mSlicerManagers[index];
2367     qApp->processEvents();
2368
2369     std::string filename = itksys::SystemTools::GetFilenameWithoutExtension(file.toStdString()).c_str();
2370     if (imageManager->SetVF(file.toStdString())) {
2371       imageManager->Render();
2372       AddFieldEntry(file,index,true);
2373     } else {
2374       QApplication::restoreOverrideCursor();
2375       QString error = "Cannot import the vector field for this image.\n";
2376       error += imageManager->GetLastError().c_str();
2377       QMessageBox::information(this,tr("Problem reading VF !"),error);
2378     }
2379   } else
2380     QMessageBox::information(this,tr("Problem reading VF !"),"File doesn't exist!");
2381
2382 }
2383 //------------------------------------------------------------------------------
2384
2385
2386 //------------------------------------------------------------------------------
2387 void vvMainWindow::SetVFProperty(int subsampling, int scale, int log, int width, double r, double g, double b)
2388 {
2389   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
2390   if (mSlicerManagers[index]->GetSlicer(0)->GetVF()) {
2391     for (int i = 0; i < 4; i++) {
2392       mSlicerManagers[index]->GetSlicer(i)->SetVFSubSampling(subsampling);
2393       mSlicerManagers[index]->GetSlicer(i)->SetVFScale(scale);
2394       mSlicerManagers[index]->GetSlicer(i)->SetVFWidth(width);
2395       mSlicerManagers[index]->GetSlicer(i)->SetVFColor(r,g,b);
2396       if (log > 0)
2397         mSlicerManagers[index]->GetSlicer(i)->SetVFLog(1);
2398       else
2399         mSlicerManagers[index]->GetSlicer(i)->SetVFLog(0);
2400     }
2401   }
2402 }
2403 //------------------------------------------------------------------------------
2404
2405
2406 //------------------------------------------------------------------------------
2407 void vvMainWindow::SetOverlayProperty(int color, int linked, double window, double level)
2408 {
2409   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
2410   if (mSlicerManagers[index]->GetSlicer(0)->GetOverlay()) {
2411     mSlicerManagers[index]->SetOverlayColor(color);
2412     mSlicerManagers[index]->SetColorMap(0);
2413     mSlicerManagers[index]->SetLinkOverlayWindowLevel(linked);
2414     mSlicerManagers[index]->SetOverlayColorWindow(window);
2415     mSlicerManagers[index]->SetOverlayColorLevel(level);
2416     mSlicerManagers[index]->Render();
2417   }
2418 }
2419 //------------------------------------------------------------------------------
2420
2421 //------------------------------------------------------------------------------
2422 void vvMainWindow::SetFusionProperty(int opacity, int thresOpacity, int colormap,double window, double level, bool showLegend)
2423 {
2424   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
2425   if (mSlicerManagers[index]->GetSlicer(0)->GetFusion()) {
2426     mSlicerManagers[index]->SetFusionColorMap(colormap);
2427     mSlicerManagers[index]->SetFusionOpacity(opacity);
2428     mSlicerManagers[index]->SetFusionThresholdOpacity(thresOpacity);
2429     mSlicerManagers[index]->SetFusionWindow(window);
2430     mSlicerManagers[index]->SetFusionLevel(level);
2431     mSlicerManagers[index]->SetFusionShowLegend(showLegend);
2432     mSlicerManagers[index]->SetColorMap(0);
2433     mSlicerManagers[index]->Render();
2434   }
2435 }
2436 //------------------------------------------------------------------------------
2437
2438
2439 //------------------------------------------------------------------------------
2440 void vvMainWindow::SelectFusionSequence()
2441 {
2442   //get the index of the slicer manager of the main sequence (CT)
2443   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
2444   //check if one overlay image is already associated
2445   for (int child = 0; child < DataTree->topLevelItem(index)->childCount(); child++)
2446     if ( (DataTree->topLevelItem(index)->child(child)->data(1,Qt::UserRole).toString() == "fusion") ||
2447       (DataTree->topLevelItem(index)->child(child)->data(1,Qt::UserRole).toString() == "fusionSequence") ) {
2448         QString error = "Cannot add more than one compared image\n";
2449         error += "Please remove first ";
2450         error += DataTree->topLevelItem(index)->child(child)->data(COLUMN_IMAGE_NAME,Qt::DisplayRole).toString();
2451         QMessageBox::information(this,tr("Problem adding compared image !"),error);
2452         return;
2453     }
2454
2455     QString Extensions = EXTENSIONS;
2456     Extensions += ";;All Files (*)";
2457     QStringList files = QFileDialog::getOpenFileNames(this,tr("Load Overlay image sequence"),mInputPathName,Extensions);
2458     if (files.isEmpty())
2459       return;
2460
2461     std::vector<std::string> vecFileNames;
2462     for (int i = 0; i < files.size(); i++) {
2463       vecFileNames.push_back(files[i].toStdString());
2464     }
2465
2466     //associate the secondary sequence (US) to the main one
2467     AddFusionSequence(index,vecFileNames,vvImageReader::MERGEDWITHTIME);
2468 }
2469 //------------------------------------------------------------------------------
2470
2471
2472 //------------------------------------------------------------------------------
2473 void vvMainWindow::SelectFusionSequenceCorrespondances()
2474 {
2475   //make sure the index is right?
2476   //in the end, I should attach the temporal data to the right sequence!
2477   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
2478   //in case the other sequence got selected, make sure we select the primary sequence
2479   if ( (!mSlicerManagers[index]->GetSlicer(0)->GetFusion()) && mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager()>=0 ) {
2480     index = mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager();
2481   }
2482
2483   //open a dialog box to find a file
2484   //QString Extensions = EXTENSIONS;
2485   QString Extensions = ";;All Files (*)";
2486   QString fileName = QFileDialog::getOpenFileName(this,tr("Load respiratory signal for fused sequence"),mInputPathName,Extensions);
2487   if (fileName.isNull())
2488     return;
2489
2490   //read it as a vector of values
2491   vnl_vector<double> tmpVect;
2492
2493   std::ifstream file;
2494   file.open(fileName.toStdString().c_str());
2495   tmpVect.read_ascii(file);
2496   file.close();
2497
2498   //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
2499   bool signalOK = true;
2500   unsigned nbFrameMain = mSlicerManagers[index]->GetImage()->GetTransform().size();
2501   unsigned nbFrameSecondary = mSlicerManagers[index]->GetFusionSequenceNbFrames();
2502   std::cout<<"nbFrameMain = "<<nbFrameMain<<", nbFrameSecondary= "<<nbFrameSecondary<<", signal size: "<<tmpVect.size()<<std::endl;
2503   std::vector<unsigned> temporalCorrespondances;
2504   if ( tmpVect.size() == nbFrameMain + nbFrameSecondary ) {
2505     for (unsigned i=0 ; i<tmpVect.size() ; i++) {
2506       if (i<nbFrameMain) { //first part of the file: i -> index in secondary seq.
2507         if ( tmpVect(i)<nbFrameSecondary ) temporalCorrespondances.push_back(tmpVect(i));
2508         else { signalOK=false; break; } //pointing outside the secondary sequence...
2509       }
2510       else { //first part of the file -> index in secondary seq.
2511         if ( tmpVect(i)<nbFrameMain ) temporalCorrespondances.push_back(tmpVect(i));
2512         else { signalOK=false; break; } //pointing outside the secondary sequence...
2513       }
2514     }
2515   }
2516   else {signalOK=false;}
2517   if (!signalOK) {//else, send a message to signal the failure...
2518     QString error = "The provided temporal correspondances is invalid - check tooltip.\n";
2519     error += "Ignoring file: " + fileName;
2520     QMessageBox::information(this,tr("Problem adding temporal correspondances!"),error);
2521     return;
2522   }
2523   else {
2524     //for convenience, associate this sequence to both the current slicer manager, and to the linked one
2525     mSlicerManagers[index]->SetFusionSequenceCorrespondances(temporalCorrespondances);
2526     mSlicerManagers[ mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager() ]->SetFusionSequenceCorrespondances(temporalCorrespondances);
2527     overlayPanel->enableFusionSequenceTemporalSync();
2528   }
2529
2530 }
2531 //------------------------------------------------------------------------------
2532
2533
2534 //------------------------------------------------------------------------------
2535 //when this function is called index is the slicer manager index corresponding to the main sequence (CT)
2536 //the files behind fileNames points to the data for the secondary sequence
2537 void vvMainWindow::AddFusionSequence(int index, std::vector<std::string> fileNames, vvImageReader::LoadedImageType type)
2538 {
2539   QString file(fileNames[0].c_str());
2540   if (QFile::exists(file))
2541   {
2542     mInputPathName = itksys::SystemTools::GetFilenamePath(file.toStdString()).c_str();
2543     itk::ImageIOBase::Pointer reader = itk::ImageIOFactory::CreateImageIO(
2544       file.toStdString().c_str(), itk::ImageIOFactory::ReadMode);
2545     std::sort (fileNames.begin(), fileNames.end());//make sure the files are sorted.
2546     reader->SetFileName(fileNames[0].c_str());
2547     reader->ReadImageInformation();
2548     std::string component = reader->GetComponentTypeAsString(reader->GetComponentType());
2549     int dimension = reader->GetNumberOfDimensions();
2550     QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
2551     vvProgressDialog progress("Opening " + file.toStdString());
2552     qApp->processEvents();
2553
2554     std::string filename = itksys::SystemTools::GetFilenameWithoutExtension(file.toStdString()).c_str();
2555
2556     if (mSlicerManagers[index]->SetFusionSequence(fileNames,dimension, component,type)) {
2557       //create an item in the tree with good settings
2558       QTreeWidgetItem *item = new QTreeWidgetItem();
2559       item->setData(0,Qt::UserRole,file.toStdString().c_str());
2560       item->setData(1,Qt::UserRole,tr("fusionSequence"));
2561
2562       QFileInfo fileinfo(file); //Do not show the path
2563       item->setData(COLUMN_IMAGE_NAME,Qt::DisplayRole,fileinfo.fileName());
2564       item->setToolTip(COLUMN_IMAGE_NAME, mSlicerManagers[index]->GetListOfAbsoluteFilePathInOneString("fusionSequence").c_str());
2565       qApp->processEvents();
2566 #if VTK_MAJOR_VERSION > 5
2567       for ( unsigned int i = 0; i < mSlicerManagers[index]->GetNumberOfSlicers(); i++)
2568         mSlicerManagers[index]->GetSlicer(i)->ForceUpdateDisplayExtent();
2569 #endif
2570       for (int j = 1; j <= 4; j++) {
2571         item->setData(j,Qt::CheckStateRole,DataTree->topLevelItem(index)->data(j,Qt::CheckStateRole));
2572       }
2573
2574       //Create the buttons for reload and close
2575       qApp->processEvents();
2576       QTreePushButton* cButton = new QTreePushButton;
2577       cButton->setItem(item);
2578       cButton->setColumn(COLUMN_CLOSE_IMAGE);
2579       cButton->setToolTip(tr("close image"));
2580       cButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/exit.png")));
2581       connect(cButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
2582         this,SLOT(CloseImage(QTreeWidgetItem*, int)));
2583
2584       QTreePushButton* rButton = new QTreePushButton;
2585       rButton->setItem(item);
2586       rButton->setColumn(COLUMN_RELOAD_IMAGE);
2587       rButton->setToolTip(tr("reload image"));
2588       rButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/rotateright.png")));
2589       connect(rButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
2590         this,SLOT(ReloadImage(QTreeWidgetItem*, int)));
2591
2592       DataTree->topLevelItem(index)->setExpanded(1);
2593       DataTree->topLevelItem(index)->addChild(item);
2594       DataTree->setItemWidget(item, COLUMN_CLOSE_IMAGE, cButton);
2595       DataTree->setItemWidget(item, COLUMN_RELOAD_IMAGE, rButton);
2596
2597       //store the original transform matrix
2598       int indexParent = GetSlicerIndexFromItem( DataTree->topLevelItem(index) );
2599       mSlicerManagers[indexParent]->SetFusionSequenceMainTransformMatrix( mSlicerManagers[indexParent]->GetSlicer(0)->GetImage()->GetTransform()[0]->GetMatrix() );
2600
2601       //set the id of the image
2602       QString id = DataTree->topLevelItem(index)->data(COLUMN_IMAGE_NAME,Qt::UserRole).toString();
2603       item->setData(COLUMN_IMAGE_NAME,Qt::UserRole,id.toStdString().c_str());
2604       UpdateTree();
2605       qApp->processEvents();
2606
2607       //ImageInfoChanged();
2608
2609       QApplication::restoreOverrideCursor();
2610       // Update the display to update, e.g., the sliders
2611       for(int i=0; i<4; i++)
2612         DisplaySliders(index, i);
2613
2614
2615       //This loads the secondary sequence (US) as an independent sequence
2616       LoadImages(fileNames, type);
2617       //reset the transforms to identity
2618       //FIX -- and set the thickness of the US slices to a large value (necessary for visualization purposes...)
2619       double sp_x, sp_y, sp_z;
2620       mSlicerManagers[indexParent]->GetImage()->GetVTKImages()[0]->GetSpacing(sp_x, sp_y, sp_z);
2621       sp_z = std::max(sp_x, std::max(sp_y, sp_z)) + 0.5; //
2622       for (unsigned i=0 ; i<mSlicerManagers.back()->GetImage()->GetTransform().size() ; i++) {
2623         sp_x = mSlicerManagers.back()->GetImage()->GetVTKImages()[i]->GetSpacing()[0];
2624         sp_y = mSlicerManagers.back()->GetImage()->GetVTKImages()[i]->GetSpacing()[1];
2625         mSlicerManagers.back()->GetImage()->GetVTKImages()[i]->SetSpacing( sp_x, sp_y, sp_z);
2626         mSlicerManagers.back()->GetImage()->GetTransform()[i]->Identity();
2627         mSlicerManagers.back()->GetImage()->GetTransform()[i]->Update();
2628       }
2629
2630       //automatically link both images...
2631       AddLink(mSlicerManagers[indexParent]->GetId().c_str(), mSlicerManagers.back()->GetId().c_str(), false);
2632
2633       //tie the main and secondary sequences by raising flags and informing each another of their respective SlicerManager indices
2634       mSlicerManagers[indexParent]->SetFusionSequenceIndexOfLinkedManager(mSlicerManagers.size()-1);
2635       mSlicerManagers[indexParent]->SetFusionSequenceInvolvmentCode(0); //main sequence
2636       mSlicerManagers.back()->SetFusionSequenceIndexOfLinkedManager(indexParent);
2637       mSlicerManagers.back()->SetFusionSequenceInvolvmentCode(1); //secondary sequence
2638       for (unsigned i=0 ; i<4 ; i++) {
2639         mSlicerManagers.back()->GetSlicer(i)->SetFusionSequenceCode(1); //flag the slicers of the secondary sequence
2640       }
2641
2642     } else {
2643       QApplication::restoreOverrideCursor();
2644       QString error = "Cannot import the new image.\n";
2645       error += mSlicerManagers[index]->GetLastError().c_str();
2646       QMessageBox::information(this,tr("Problem reading image !"),error);
2647     }
2648     WindowLevelChanged();
2649     ImageInfoChanged(); //this internally calls WindowLevelChanged...
2650   }
2651   else {
2652     QMessageBox::information(this,tr("Problem reading fusion sequence !"),"File doesn't exist!");
2653     return;
2654   }
2655
2656 }
2657 //------------------------------------------------------------------------------
2658
2659
2660 //------------------------------------------------------------------------------
2661 //fusionSequenceFrameIndex and fusionSequenceNbFrames are relative to the secondary sequence (US)
2662 void vvMainWindow::SetFusionSequenceProperty(int fusionSequenceFrameIndex, bool spatialSyncFlag, unsigned int fusionSequenceNbFrames, bool temporalSyncFlag)
2663 {
2664   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
2665
2666   if (!mSlicerManagers[index]->IsInvolvedInFusionSequence()) return;
2667
2668   //check if the focus moved to the linked sequence, and in this case, select the master sequence instead
2669   if (!mSlicerManagers[index]->IsMainSequenceOfFusionSequence()) {
2670     index = mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager();
2671   }
2672   int secondaryIndex = mSlicerManagers[index]->GetFusionSequenceIndexOfLinkedManager();
2673   if (secondaryIndex==-1) return; //this should never happen
2674   if ( (!mSlicerManagers[index]->IsMainSequenceOfFusionSequence()) ||
2675     (!mSlicerManagers[secondaryIndex]->IsSecondarySequenceOfFusionSequence()) )
2676   {return;} //this should never happen, raise an exception?
2677
2678   if (mSlicerManagers[index]->GetSlicer(0)->GetFusion()) {
2679
2680     //First, if the spatialSync button is unchecked, then reposition the parent sequence (CT) in its original coordinate frame
2681     if ( (!spatialSyncFlag) && (mSlicerManagers[index]->GetFusionSequenceSpatialSyncFlag()) ) {
2682       for ( unsigned i=0 ; i<mSlicerManagers[index]->GetSlicer(0)->GetImage()->GetTransform().size() ; i++ ) {
2683         mSlicerManagers[index]->GetSlicer(0)->GetImage()->GetTransform()[i]->SetMatrix( mSlicerManagers[index]->GetFusionSequenceMainTransformMatrix() );
2684         mSlicerManagers[index]->GetSlicer(0)->GetImage()->GetTransform()[i]->Update();
2685       }
2686
2687       for (int i=0; i<mSlicerManagers[index]->GetNumberOfSlicers(); i++) {
2688         mSlicerManagers[index]->GetSlicer(i)->ForceUpdateDisplayExtent();
2689         mSlicerManagers[index]->GetSlicer(i)->Render();
2690       }
2691     }
2692
2693     //then, update the property values in the slicer manager
2694     mSlicerManagers[index]->SetFusionSequenceLength(fusionSequenceNbFrames);
2695     mSlicerManagers[index]->SetFusionSequenceSpatialSyncFlag(spatialSyncFlag);
2696     mSlicerManagers[index]->SetFusionSequenceTemporalSyncFlag(temporalSyncFlag);
2697     mSlicerManagers[index]->SetFusionSequenceFrameIndex(fusionSequenceFrameIndex);
2698
2699     //select the right frame of the US sequence
2700     mSlicerManagers[index]->SetFusionSequenceTSlice(fusionSequenceFrameIndex); //here, I should only update the overlayed sequence
2701     mSlicerManagers[secondaryIndex]->SetTSlice(fusionSequenceFrameIndex, false); //this should update the secondary sequence (individual version)
2702
2703     //update the horizontal sliders of the main window
2704     overlayPanel->updateFusionSequenceSliderValueFromWindow(fusionSequenceFrameIndex, false);
2705
2706     if (spatialSyncFlag) { //reslice the CT
2707
2708       if (temporalSyncFlag) { //do the temporal synchronisation
2709         int mainSequenceFrameIndex=0;
2710         //estimate the TSlice to set to the CT
2711         unsigned nbFramesMain = mSlicerManagers[index]->GetImage()->GetTransform().size();
2712         mainSequenceFrameIndex = mSlicerManagers[index]->GetFusionSequenceCorrespondances()[ nbFramesMain + fusionSequenceFrameIndex];
2713         //and set it!
2714         mSlicerManagers[index]->SetTSlice(mainSequenceFrameIndex, false);
2715         //warning, there is a loopback, and modification of the TSlice in main sequence forces an update of the TSlice in secondary, etc...
2716       }
2717
2718
2719       //Set the transform matrix of the parent sequence (typically CT / 4DCT)
2720       vtkSmartPointer<vtkMatrix4x4> tmpMat = vtkSmartPointer<vtkMatrix4x4>::New();
2721       vtkMatrix4x4::Invert( mSlicerManagers[index]->GetFusionSequenceInitialTransformMatrixAtFrame(fusionSequenceFrameIndex), tmpMat );
2722       for ( unsigned i=0 ; i<mSlicerManagers[index]->GetSlicer(0)->GetImage()->GetTransform().size() ; i++ ) {
2723         mSlicerManagers[index]->GetSlicer(0)->GetImage()->GetTransform()[i]->SetMatrix( mSlicerManagers[index]->GetFusionSequenceMainTransformMatrix() );
2724         mSlicerManagers[index]->GetSlicer(0)->GetImage()->GetTransform()[i]->PreMultiply();
2725         mSlicerManagers[index]->GetSlicer(0)->GetImage()->GetTransform()[i]->Concatenate( tmpMat );
2726         mSlicerManagers[index]->GetSlicer(0)->GetImage()->GetTransform()[i]->Update();
2727       }
2728
2729       for (int i=0; i<mSlicerManagers[index]->GetNumberOfSlicers(); i++) {
2730         mSlicerManagers[index]->GetSlicer(i)->ForceUpdateDisplayExtent();
2731         mSlicerManagers[index]->GetSlicer(i)->Render();
2732       }
2733
2734     }
2735
2736   }
2737 }
2738 //------------------------------------------------------------------------------
2739
2740
2741 //------------------------------------------------------------------------------
2742 void vvMainWindow::SaveAs()
2743 {
2744   if (DataTree->selectedItems()[0]->data(1,Qt::UserRole).toString() == "vector") {
2745     QMessageBox::warning(this,tr("Unsupported type"),tr("Sorry, saving a vector field is unsupported for the moment"));
2746     return;
2747   }
2748
2749   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
2750   int dimension = mSlicerManagers[index]->GetDimension();
2751   QStringList OutputListeFormat;
2752   OutputListeFormat.clear();
2753   if (dimension == 1) {
2754     OutputListeFormat.push_back(".mhd");
2755     OutputListeFormat.push_back(".mha");
2756   }
2757   if (dimension == 2) {
2758     OutputListeFormat.push_back(".bmp");
2759     OutputListeFormat.push_back(".png");
2760     OutputListeFormat.push_back(".jpeg");
2761     OutputListeFormat.push_back(".tif");
2762     OutputListeFormat.push_back(".mhd");
2763     OutputListeFormat.push_back(".mha");
2764     OutputListeFormat.push_back(".hdr");
2765     OutputListeFormat.push_back(".vox");
2766   } else if (dimension == 3) {
2767     OutputListeFormat.push_back(".mhd");
2768     OutputListeFormat.push_back(".mha");
2769     OutputListeFormat.push_back(".nii");
2770     OutputListeFormat.push_back(".nrrd");
2771     OutputListeFormat.push_back(".nhdr");
2772     OutputListeFormat.push_back(".hdr");
2773     OutputListeFormat.push_back(".vox");
2774   } else if (dimension == 4) {
2775     OutputListeFormat.push_back(".mhd");
2776     OutputListeFormat.push_back(".mha");
2777     OutputListeFormat.push_back(".nii");
2778     OutputListeFormat.push_back(".nrrd");
2779     OutputListeFormat.push_back(".nhdr");
2780   }
2781   QString Extensions = "AllFiles(*.*)";
2782   for (int i = 0; i < OutputListeFormat.count(); i++) {
2783     Extensions += ";;Images ( *";
2784     Extensions += OutputListeFormat[i];
2785     Extensions += ")";
2786   }
2787   QString fileName = QFileDialog::getSaveFileName(this,
2788     tr("Save As"),
2789     mSlicerManagers[index]->GetFileName().c_str(),
2790     Extensions);
2791   if (!fileName.isEmpty()) {
2792     std::string fileformat = itksys::SystemTools::GetFilenameLastExtension(fileName.toStdString());
2793     if (OutputListeFormat.contains(
2794       fileformat.c_str())) {
2795         QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
2796         std::string action = "Saving";
2797         vvProgressDialog progress("Saving "+fileName.toStdString());
2798         qApp->processEvents();
2799         vvImageWriter::Pointer writer = vvImageWriter::New();
2800         writer->SetOutputFileName(fileName.toStdString());
2801         writer->SetInput(mSlicerManagers[index]->GetImage());
2802
2803         // Check on transform and prompt user
2804         writer->SetSaveTransform(false);
2805         bool bId = true;
2806         for(int i=0; i<4; i++)
2807           for(int j=0; j<4; j++) {
2808             // TODO SR and BP: check on the list of transforms and not the first only
2809             double elt = mSlicerManagers[index]->GetImage()->GetTransform()[0]->GetMatrix()->GetElement(i,j);
2810             if(i==j && elt!=1.)
2811               bId = false;
2812             if(i!=j && elt!=0.)
2813               bId = false;
2814           }
2815           if( !bId ) {
2816             QString warning = "The image has an associated linear transform. Do you want to save it along?";
2817             QMessageBox msgBox(QMessageBox::Warning, tr("Save transform"), warning, 0, this);
2818             msgBox.addButton(tr("Yes"), QMessageBox::AcceptRole);
2819             msgBox.addButton(tr("No"), QMessageBox::RejectRole);
2820             if (msgBox.exec() == QMessageBox::AcceptRole)
2821               writer->SetSaveTransform(true);
2822           }
2823
2824           writer->Update();
2825           QApplication::restoreOverrideCursor();
2826           if (writer->GetLastError().size()) {
2827             QString error = "Saving did not succeed\n";
2828             error += writer->GetLastError().c_str();
2829             QMessageBox::information(this,tr("Saving Problem"),error);
2830             SaveAs();
2831           }
2832     } else {
2833       QString error = fileformat.c_str();
2834       if (error.isEmpty())
2835         error += "no file format specified !";
2836       else
2837         error += " format unknown !!!\n";
2838       QMessageBox::information(this,tr("Saving Problem"),error);
2839       SaveAs();
2840     }
2841   }
2842 }
2843 //------------------------------------------------------------------------------
2844
2845 //------------------------------------------------------------------------------
2846 void vvMainWindow::SaveCurrentState()
2847 {
2848   QString Extensions = "XML Files(*.xml)";
2849   QString fileName = QFileDialog::getSaveFileName(this,
2850     tr("Save Current Window State"),
2851     "",
2852     Extensions);
2853
2854   SaveCurrentStateAs(fileName.toStdString());
2855 }
2856 //------------------------------------------------------------------------------
2857
2858 //------------------------------------------------------------------------------
2859 void vvMainWindow::SaveCurrentStateAs(const std::string& stateFile)
2860 {
2861   vvSaveState save_state;
2862   save_state.Run(this, stateFile);
2863 }
2864
2865 //------------------------------------------------------------------------------
2866 void vvMainWindow::ReadSavedState()
2867 {
2868   QString Extensions = "XML Files(*.xml)";
2869   QString fileName = QFileDialog::getOpenFileName(this,
2870     tr("Load Window State"),
2871     "",
2872     Extensions);
2873
2874   ReadSavedStateFile(fileName.toStdString());
2875 }
2876 //------------------------------------------------------------------------------
2877
2878 //------------------------------------------------------------------------------
2879 void vvMainWindow::ReadSavedStateFile(const std::string& stateFile)
2880 {
2881   vvReadState read_state;
2882   read_state.Run(this, stateFile);
2883 }
2884 //------------------------------------------------------------------------------
2885
2886 //------------------------------------------------------------------------------
2887 void vvMainWindow::LinkAllImages()
2888 {
2889   linkPanel->linkAll();
2890 }
2891
2892 //------------------------------------------------------------------------------
2893 void vvMainWindow::AddLink(QString image1,QString image2,bool fromPanel)
2894 {
2895   if (!fromPanel) {
2896     // delegate to linkPanel if call came from elsewhere...
2897     linkPanel->addLinkFromIds(image1, image2);
2898     return;
2899   }
2900
2901   unsigned int sm1 = 0;
2902   unsigned int sm2 = 0;
2903
2904   for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
2905     if (image1.toStdString() == mSlicerManagers[i]->GetId()) {
2906       mSlicerManagers[i]->AddLink(image2.toStdString());
2907       sm1 = i;
2908     }
2909     if (image2.toStdString() == mSlicerManagers[i]->GetId()) {
2910       mSlicerManagers[i]->AddLink(image1.toStdString());
2911       sm2 = i;
2912     }
2913   }
2914
2915   if (linkPanel->isLinkAll())   {
2916     emit UpdateLinkedNavigation(mSlicerManagers[sm1]->GetId(), mSlicerManagers[mCurrentPickedImageIndex], mSlicerManagers[mCurrentPickedImageIndex]->GetSlicer(0));
2917     emit UpdateLinkedNavigation(mSlicerManagers[sm2]->GetId(), mSlicerManagers[mCurrentPickedImageIndex], mSlicerManagers[mCurrentPickedImageIndex]->GetSlicer(0));
2918   } else {
2919     emit UpdateLinkedNavigation(mSlicerManagers[sm2]->GetId(), mSlicerManagers[sm1], mSlicerManagers[sm1]->GetSlicer(0));
2920   }
2921 }
2922
2923 //------------------------------------------------------------------------------
2924
2925
2926 //------------------------------------------------------------------------------
2927 void vvMainWindow::RemoveLink(QString image1,QString image2)
2928 {
2929   for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
2930     if (image1.toStdString() == mSlicerManagers[i]->GetId()) {
2931       mSlicerManagers[i]->RemoveLink(image2.toStdString());
2932     }
2933     if (image2.toStdString() == mSlicerManagers[i]->GetId()) {
2934       mSlicerManagers[i]->RemoveLink(image1.toStdString());
2935     }
2936   }
2937 }
2938 //------------------------------------------------------------------------------
2939
2940 //------------------------------------------------------------------------------
2941 void vvMainWindow::ChangeImageWithIndexOffset(vvSlicerManager *sm, int slicer, int offset)
2942 {
2943   if(mSlicerManagers.size()==1)
2944     return;
2945
2946   int index = 0;
2947   while(sm != mSlicerManagers[index])
2948     index++;
2949   index = (index+offset+mSlicerManagers.size()) % mSlicerManagers.size();
2950
2951   QTreeWidgetItem* item = GetItemFromSlicerManager(mSlicerManagers[index]);
2952   item->setData(slicer+1,Qt::CheckStateRole,2);         //change checkbox
2953   CurrentImageChanged(mSlicerManagers[index]->GetId()); //select new image
2954   DisplayChanged(item,slicer+1);
2955 }
2956 //------------------------------------------------------------------------------
2957 void vvMainWindow::HorizontalSliderMoved(int value,int column, int slicer_index)
2958 {
2959   for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
2960     if (DataTree->topLevelItem(i)->data(column,Qt::CheckStateRole).toInt() > 1) {
2961       //i is the SlicerManager that is in charge of this slicer.
2962       if (mSlicerManagers[i]->IsInvolvedInFusionSequence()) {
2963         //if the slicerManager is involved in a fusionSequence as the secondary sequence, then update the slider position in the overlay panel and everything accordingly
2964         if (mSlicerManagers[i]->IsSecondarySequenceOfFusionSequence()) {
2965           overlayPanel->updateFusionSequenceSliderValueFromWindow(value, true);
2966         }
2967         else { //if this is the primary sequence that has been modified
2968           if (mSlicerManagers[i]->GetFusionSequenceTemporalSyncFlag()) {
2969             //WARNING: for some obscure reason, there are problems when accessing mSlicerManagers[mSlicerManagers[i]->GetFusionSequenceIndexOfLinkedManager()]->GetFusionSequenceFrameIndex();
2970
2971             int estimatedValue=0;
2972             //estimate a corresponding time index for the secondary (US) sequence, and update it accordingly.
2973             estimatedValue = mSlicerManagers[i]->GetFusionSequenceCorrespondances()[ value ];
2974             //TODO: at the moment, there is a loop in TSlice modifications
2975             //modifying sequence 1 causes seq 2 to update, which in turns update seq1...
2976             //I disable control on seq1 at the moment.
2977             //overlayPanel->updateFusionSequenceSliderValueFromWindow(estimatedValue, true);
2978           }
2979         }
2980       }
2981
2982       for (int j = 0; j < 4; j++) {
2983         mSlicerManagers[i]->SetTSliceInSlicer(value,j);
2984       }
2985       mSlicerManagers[i]->GetSlicer(slicer_index)->Render();
2986       break;
2987     }
2988   }
2989 }
2990 //------------------------------------------------------------------------------
2991
2992
2993 //------------------------------------------------------------------------------
2994 void vvMainWindow::NOHorizontalSliderMoved()
2995 {
2996   // if (mCurrentTime == NOHorizontalSlider->value()) return;
2997   HorizontalSliderMoved(NOHorizontalSlider->value(),COLUMN_UL_VIEW,0);
2998   //  mCurrentTime = NOHorizontalSlider->value();
2999 }
3000 //------------------------------------------------------------------------------
3001
3002
3003 //------------------------------------------------------------------------------
3004 void vvMainWindow::NEHorizontalSliderMoved()
3005 {
3006   // if (mCurrentTime == NEHorizontalSlider->value()) return;
3007   HorizontalSliderMoved(NEHorizontalSlider->value(),COLUMN_UR_VIEW,1);
3008   //  mCurrentTime = NEHorizontalSlider->value();
3009 }
3010 //------------------------------------------------------------------------------
3011
3012
3013 //------------------------------------------------------------------------------
3014 void vvMainWindow::SOHorizontalSliderMoved()
3015 {
3016   // if (mCurrentTime == SOHorizontalSlider->value()) return;
3017   HorizontalSliderMoved(SOHorizontalSlider->value(),COLUMN_DL_VIEW,2);
3018   // mCurrentTime = SOHorizontalSlider->value();
3019 }
3020 //------------------------------------------------------------------------------
3021
3022
3023 //------------------------------------------------------------------------------
3024 void vvMainWindow::SEHorizontalSliderMoved()
3025 {
3026   // if (mCurrentTime == SEHorizontalSlider->value()) return;
3027   HorizontalSliderMoved(SEHorizontalSlider->value(),COLUMN_DR_VIEW,3);
3028   // mCurrentTime = SEHorizontalSlider->value();
3029 }
3030 //------------------------------------------------------------------------------
3031
3032 //------------------------------------------------------------------------------
3033 void vvMainWindow::NOVerticalSliderChanged()
3034 {
3035   static int value=-1;
3036   if (value == NOVerticalSlider->value()) return;
3037   else value = NOVerticalSlider->value();
3038   //  int value = NOVerticalSlider->value();
3039   for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
3040     if (DataTree->topLevelItem(i)->data(COLUMN_UL_VIEW,Qt::CheckStateRole).toInt() > 1) {
3041       if (mSlicerManagers[i]->GetSlicer(0)->GetSlice() != value) {
3042         mSlicerManagers[i]->GetSlicer(0)->SetSlice(value);
3043         mSlicerManagers[i]->VerticalSliderHasChanged(0, value);
3044
3045         // If nor Update/Render -> slider not work
3046         // only render = ok navigation, but for contour Update needed but slower ?
3047
3048         mSlicerManagers[i]->UpdateSlice(0);  // <-- DS add this. Not too much update ? YES. but needed for ImageContour ...
3049         //mSlicerManagers[i]->GetSlicer(0)->Render(); // <-- DS add this, needed for contour, seems ok ? not too slow ?
3050       }
3051       break;
3052     }
3053   }
3054 }
3055 //------------------------------------------------------------------------------
3056
3057
3058 //------------------------------------------------------------------------------
3059 void vvMainWindow::NEVerticalSliderChanged()
3060 {
3061   static int value=-1;
3062   if (value == NEVerticalSlider->value()) return;
3063   else value = NEVerticalSlider->value();
3064   //  int value = NEVerticalSlider->value();
3065   for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
3066     if (DataTree->topLevelItem(i)->data(COLUMN_UR_VIEW,Qt::CheckStateRole).toInt() > 1) {
3067       if (mSlicerManagers[i]->GetSlicer(1)->GetSlice() != value) {
3068         mSlicerManagers[i]->GetSlicer(1)->SetSlice(value);
3069         mSlicerManagers[i]->VerticalSliderHasChanged(1, value);
3070         mSlicerManagers[i]->UpdateSlice(1);
3071         //mSlicerManagers[i]->GetSlicer(1)->Render(); // <-- DS add this, needed for contour, seems ok ? not too slow ?
3072       }
3073       break;
3074     }
3075   }
3076 }
3077 //------------------------------------------------------------------------------
3078
3079
3080 //------------------------------------------------------------------------------
3081 void vvMainWindow::SOVerticalSliderChanged()
3082 {
3083   static int value=-1;
3084   if (value == SOVerticalSlider->value()) return;
3085   else value = SOVerticalSlider->value();
3086   //int value = SOVerticalSlider->value();
3087   for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
3088     if (DataTree->topLevelItem(i)->data(COLUMN_DL_VIEW,Qt::CheckStateRole).toInt() > 1) {
3089       if (mSlicerManagers[i]->GetSlicer(2)->GetSlice() != value) {
3090         mSlicerManagers[i]->GetSlicer(2)->SetSlice(value);
3091         mSlicerManagers[i]->VerticalSliderHasChanged(2, value);
3092         mSlicerManagers[i]->UpdateSlice(2);
3093         //mSlicerManagers[i]->GetSlicer(2)->Render(); // <-- DS add this, needed for contour, seems ok ? not too slow ?
3094       }
3095       // else { DD("avoid SOVerticalSlider slicer update"); }
3096       break;
3097     }
3098   }
3099 }
3100 //------------------------------------------------------------------------------
3101
3102
3103 //------------------------------------------------------------------------------
3104 void vvMainWindow::SEVerticalSliderChanged()
3105 {
3106   static int value=-1;
3107   if (value == SEVerticalSlider->value()) return;
3108   else value = SEVerticalSlider->value();
3109   // int value = SEVerticalSlider->value();
3110   for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
3111     if (DataTree->topLevelItem(i)->data(COLUMN_DR_VIEW,Qt::CheckStateRole).toInt() > 1) {
3112       if (mSlicerManagers[i]->GetSlicer(3)->GetSlice() != value) {
3113         mSlicerManagers[i]->GetSlicer(3)->SetSlice(value);
3114         mSlicerManagers[i]->VerticalSliderHasChanged(3, value);
3115         mSlicerManagers[i]->UpdateSlice(3);
3116         //mSlicerManagers[i]->GetSlicer(3)->Render(); // <-- DS add this, needed for contour, seems ok ? not too slow ?
3117       }
3118       break;
3119     }
3120   }
3121 }
3122 //------------------------------------------------------------------------------
3123
3124
3125 //------------------------------------------------------------------------------
3126 void vvMainWindow::UpdateSlice(int slicer, int slice)
3127 {
3128   // DD("vvMainWindow::UpdateSlice");
3129   //   DD(slicer);
3130   //   DD(slice);
3131   if (slicer == 0) {
3132     //    if (slice != NOVerticalSlider->value())
3133     NOVerticalSlider->setValue(slice);
3134   } else {
3135     if (slicer == 1)
3136       NEVerticalSlider->setValue(slice);
3137     else {
3138       if (slicer == 2)
3139         SOVerticalSlider->setValue(slice);
3140       else {
3141         if (slicer == 3)
3142           SEVerticalSlider->setValue(slice);
3143       }
3144     }
3145   }
3146   // DD("vvMainWindow:UpdateSlice END");
3147 }
3148 //------------------------------------------------------------------------------
3149
3150
3151 //------------------------------------------------------------------------------
3152 void vvMainWindow::UpdateTSlice(int slicer, int slice, int code)
3153 {
3154   //FusionSequence: the slider value should be updated for slicers which show the same sequence as requested
3155   bool doUpdate=false;
3156   if (code==-1) doUpdate=true;
3157   else {
3158     for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
3159       if (DataTree->topLevelItem(i)->data(slicer+1,Qt::CheckStateRole).toInt() > 1) {
3160         //i is the active SlicerManager
3161         if (mSlicerManagers[i]->GetFusionSequenceInvolvmentCode()==code) doUpdate=true;
3162         break;
3163       }
3164     }
3165   }
3166   if (!doUpdate) return;
3167
3168   switch (slicer) {
3169   case 0:
3170     if (NOHorizontalSlider->value()==slice) return;
3171     NOHorizontalSlider->setValue(slice);
3172     break;
3173   case 1:
3174     if (NEHorizontalSlider->value()==slice) return;
3175     NEHorizontalSlider->setValue(slice);
3176     break;
3177   case 2:
3178     if (SOHorizontalSlider->value()==slice) return;
3179     SOHorizontalSlider->setValue(slice);
3180     break;
3181   case 3:
3182     if (SEHorizontalSlider->value()==slice) return;
3183     SEHorizontalSlider->setValue(slice);
3184     break;
3185   }
3186 }
3187 //------------------------------------------------------------------------------
3188
3189
3190 //------------------------------------------------------------------------------
3191 void vvMainWindow::UpdateSliceRange(int slicer, int min, int max, int tmin, int tmax)
3192 {
3193   //int position = int((min+max)/2);
3194   int position = mSlicerManagers[mCurrentPickedImageIndex]->GetSlicer(slicer)->GetSlice();
3195   if (slicer == 0) {
3196     NOVerticalSlider->setRange(min,max);
3197     NOHorizontalSlider->setRange(tmin,tmax);
3198     NOVerticalSlider->setValue(position);
3199   } else if (slicer == 1) {
3200     NEVerticalSlider->setRange(min,max);
3201     NEHorizontalSlider->setRange(tmin,tmax);
3202     NEVerticalSlider->setValue(position);
3203   } else if (slicer == 2) {
3204     SOVerticalSlider->setRange(min,max);
3205     SOHorizontalSlider->setRange(tmin,tmax);
3206     SOVerticalSlider->setValue(position);
3207   } else if (slicer == 3) {
3208     SEVerticalSlider->setRange(min,max);
3209     SEHorizontalSlider->setRange(tmin,tmax);
3210     SEVerticalSlider->setValue(position);
3211   }
3212 }
3213 //------------------------------------------------------------------------------
3214
3215
3216 //------------------------------------------------------------------------------
3217 void vvMainWindow::SaveNOScreenshot()
3218 {
3219   SaveScreenshot(NOViewWidget);
3220 }
3221 //------------------------------------------------------------------------------
3222
3223
3224 //------------------------------------------------------------------------------
3225 void vvMainWindow::SaveNEScreenshot()
3226 {
3227   SaveScreenshot(NEViewWidget);
3228 }
3229 //------------------------------------------------------------------------------
3230
3231
3232 //------------------------------------------------------------------------------
3233 void vvMainWindow::SaveSOScreenshot()
3234 {
3235   SaveScreenshot(SOViewWidget);
3236 }
3237 //------------------------------------------------------------------------------
3238
3239
3240 //------------------------------------------------------------------------------
3241 void vvMainWindow::SaveSEScreenshot()
3242 {
3243   SaveScreenshot(SEViewWidget);
3244 }
3245 //------------------------------------------------------------------------------
3246
3247
3248 //------------------------------------------------------------------------------
3249 void vvMainWindow::SaveScreenshotAllSlices()
3250 {
3251   QVTKWidget *widget = NOViewWidget;
3252
3253   int index = 0;// GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
3254   vvSlicerManager * SM = mSlicerManagers[index];
3255   vvImage * image = SM->GetImage();
3256   vvSlicer * slicer = SM->GetSlicer(0);
3257   int orientation = slicer->GetOrientation();
3258   int nbSlices = image->GetSize()[orientation];
3259   vtkSmartPointer<vtkRenderWindow>  renderWindow = widget->GetRenderWindow();
3260
3261   // Select filename base
3262   QString filename = QFileDialog::getSaveFileName(this,
3263     tr("Save As (filename will be completed by slice number)"),
3264     itksys::SystemTools::GetFilenamePath(mSlicerManagers[index]->GetFileName()).c_str(),
3265     "Images( *.png);;Images( *.jpg)");
3266
3267   // Loop on slices
3268   for(int i=0; i<nbSlices; i++) {
3269     // Change the slice
3270     slicer->SetSlice(i); // -> change the slice of the current slicer
3271     SM->UpdateSlice(0); // --> this one emit UpdateSlice
3272     QCoreApplication::flush(); // -> needed to force display of contours
3273
3274     // Screenshot
3275     vtkSmartPointer<vtkWindowToImageFilter> windowToImageFilter = vtkSmartPointer<vtkWindowToImageFilter>::New();
3276     windowToImageFilter->SetInput(renderWindow);
3277     windowToImageFilter->SetMagnification(1);
3278     windowToImageFilter->SetInputBufferTypeToRGBA(); //also record the alpha (transparency) channel
3279     windowToImageFilter->Update();
3280
3281     vtkSmartPointer<vtkPNGWriter> writer = vtkSmartPointer<vtkPNGWriter>::New();
3282     std::string fn = itksys::SystemTools::GetFilenameWithoutLastExtension(filename.toStdString());
3283     std::string num = clitk::toString(i);
3284     if (i<10) num = "0"+num;
3285     if (i<100) num = "0"+num;
3286     if (i<1000) num = "0"+num;
3287
3288     fn = itksys::SystemTools::GetFilenamePath(filename.toStdString()) + "/"+ fn
3289       + "_" + num + itksys::SystemTools::GetFilenameLastExtension(filename.toStdString());
3290     writer->SetFileName(fn.c_str());
3291 #if VTK_MAJOR_VERSION <= 5
3292     writer->SetInput(windowToImageFilter->GetOutput());
3293 #else
3294     writer->SetInputConnection(windowToImageFilter->GetOutputPort());
3295 #endif
3296     writer->Write();
3297   }
3298 }
3299 //------------------------------------------------------------------------------
3300
3301
3302 //------------------------------------------------------------------------------
3303 void vvMainWindow::SaveScreenshot(QVTKWidget *widget)
3304 {
3305   QString Extensions = "Images( *.png);;";
3306   Extensions += "Images( *.jpg);;";
3307   Extensions += "Images( *.bmp);;";
3308   Extensions += "Images( *.tif);;";
3309   Extensions += "Images( *.ppm)";
3310 #if defined(VTK_USE_FFMPEG_ENCODER) || defined(VTK_USE_VIDEO_FOR_WINDOWS)
3311   Extensions += ";;Video( *.avi)";
3312 #endif
3313 #ifdef VTK_USE_MPEG2_ENCODER
3314   Extensions += ";;Video( *.mpg)";
3315 #endif
3316 #ifdef CLITK_EXPERIMENTAL
3317   Extensions += ";;Video( *.gif)";
3318 #endif
3319
3320   int smIndex=GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
3321   QString fileName = QFileDialog::getSaveFileName(this,
3322     tr("Save As"),
3323     itksys::SystemTools::GetFilenamePath(mSlicerManagers[smIndex]->GetFileName()).c_str(),
3324     Extensions);
3325
3326   if (!fileName.isEmpty()) {
3327     vtkSmartPointer<vtkWindowToImageFilter> w2i = vtkSmartPointer<vtkWindowToImageFilter>::New();
3328     w2i->SetInput(widget->GetRenderWindow());
3329     w2i->Update();
3330     vtkImageData *image = w2i->GetOutput();
3331
3332     std::string ext(itksys::SystemTools::GetFilenameLastExtension(fileName.toStdString()));
3333
3334     // Image
3335     vtkImageWriter *imgwriter = NULL;
3336     if (ext==".bmp")
3337       imgwriter = vtkBMPWriter::New();
3338     else if (ext==".tif")
3339       imgwriter = vtkTIFFWriter::New();
3340     else if (ext==".ppm")
3341       imgwriter = vtkPNMWriter::New();
3342     else if (ext==".png")
3343       imgwriter = vtkPNGWriter::New();
3344     else if (ext==".jpg")
3345       imgwriter = vtkJPEGWriter::New();
3346
3347     // Snapshot image if not null
3348     if(imgwriter!=NULL) {
3349 #if VTK_MAJOR_VERSION <= 5
3350       imgwriter->SetInput(image);
3351 #else
3352       imgwriter->SetInputConnection(w2i->GetOutputPort());
3353 #endif
3354       imgwriter->SetFileName(fileName.toStdString().c_str());
3355       imgwriter->Write();
3356       return;
3357     }
3358
3359     // Video
3360     vtkGenericMovieWriter *vidwriter = NULL;
3361 #if CLITK_EXPERIMENTAL == 1
3362     if (ext==".gif") {
3363       vvAnimatedGIFWriter *gif = vvAnimatedGIFWriter::New();
3364       vidwriter = gif;
3365
3366       // FPS
3367       bool ok;
3368       int fps = QInputDialog::getInt(this, tr("Number of frames per second"),
3369         tr("FPS:"), 5, 0, 1000, 1, &ok);
3370       if(ok)
3371         gif->SetRate(fps);
3372
3373       // Loops
3374       int loops = QInputDialog::getInt(this, tr("Loops"),
3375         tr("Number of loops (0 means infinite):"), 0, 0, 1000000000, 1, &ok);
3376       if(ok)
3377         gif->SetLoops(loops);
3378
3379       // Dithering
3380       QString msg = "Would you like to activate dithering?";
3381       QMessageBox msgBox(QMessageBox::Question, tr("Dithering"),msg, 0, this);
3382       msgBox.addButton(tr("Yes"), QMessageBox::AcceptRole);
3383       msgBox.addButton(tr("No"), QMessageBox::RejectRole);
3384       gif->SetDither(msgBox.exec() == QMessageBox::AcceptRole);
3385     }
3386 #endif
3387 #ifdef VTK_USE_VIDEO_FOR_WINDOWS
3388     if (ext==".avi") {
3389       vtkAVIWriter *mpg = vtkAVIWriter::New();
3390       vidwriter = mpg;
3391       mpg->SetQuality(2);
3392       bool ok;
3393       int fps = QInputDialog::getInteger(this, tr("Number of frames per second"),
3394         tr("FPS:"), 5, 0, 1024, 1, &ok);
3395       if(!ok)
3396         fps = 5;
3397       mpg->SetRate(fps);
3398     }
3399 #endif
3400 #ifdef VTK_USE_FFMPEG_ENCODER
3401     if (ext==".avi") {
3402       vtkFFMPEGWriter *mpg = vtkFFMPEGWriter::New();
3403       vidwriter = mpg;
3404       mpg->SetQuality(2);
3405       bool ok;
3406       int fps = QInputDialog::getInteger(this, tr("Number of frames per second"),
3407         tr("FPS:"), 5, 0, 1024, 1, &ok);
3408       if(!ok)
3409         fps = 5;
3410       mpg->SetRate(fps);
3411       mpg->SetBitRateTolerance(int(ceil(12.0*1024*1024/fps)));
3412     }
3413 #endif
3414 #ifdef VTK_USE_MPEG2_ENCODER
3415     if (ext==".mpg") {
3416       vtkMPEG2Writer *mpg = vtkMPEG2Writer::New();
3417       vidwriter = mpg;
3418     }
3419 #endif
3420
3421     // Take video if not null
3422     if(vidwriter!=NULL){
3423 #if VTK_MAJOR_VERSION <= 5
3424       vidwriter->SetInput(image);
3425 #else
3426       vidwriter->SetInputConnection(w2i->GetOutputPort());
3427 #endif
3428       vidwriter->SetFileName(fileName.toStdString().c_str());
3429       vidwriter->Start();
3430       int nSlice = mSlicerManagers[smIndex]->GetSlicer(0)->GetTMax();
3431       for(int i=0; i<=nSlice; i++) {
3432         mSlicerManagers[smIndex]->SetNextTSlice(0);
3433         vtkSmartPointer<vtkWindowToImageFilter> w2i = vtkSmartPointer<vtkWindowToImageFilter>::New();
3434         w2i->SetInput(widget->GetRenderWindow());
3435         w2i->Update();
3436 #if VTK_MAJOR_VERSION <= 5
3437         vidwriter->SetInput(w2i->GetOutput());
3438 #else
3439         vidwriter->SetInputConnection(w2i->GetOutputPort());
3440 #endif
3441         vidwriter->Write();
3442       }
3443       vidwriter->End();
3444       vidwriter->Delete();
3445       return;
3446     }
3447
3448     QMessageBox::information(this,tr("Problem saving screenshot !"),tr("Cannot save image.\nPlease set a file extension !!!"));
3449   }
3450 }
3451 //------------------------------------------------------------------------------
3452
3453
3454 //------------------------------------------------------------------------------
3455 void vvMainWindow::GoToCursor()
3456 {
3457   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
3458   for (int column = 1; column < 5; column++) {
3459     if (DataTree->selectedItems()[0]->data(column,Qt::CheckStateRole).toInt() > 1) {
3460       double* cursorPos = mSlicerManagers[index]->GetSlicer(column-1)->GetCursorPosition();
3461       mSlicerManagers[index]->GetSlicer(column-1)->SetCurrentPosition(
3462         cursorPos[0],cursorPos[1],cursorPos[2],cursorPos[3]);
3463       mSlicerManagers[index]->UpdateViews(1,column-1);
3464       mSlicerManagers[index]->UpdateLinked(column-1);
3465       break;
3466     }
3467   }
3468 }
3469 //------------------------------------------------------------------------------
3470
3471 //------------------------------------------------------------------------------
3472 void vvMainWindow::GoToLandmark()
3473 {
3474   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
3475   for (int column = 1; column < 5; column++) {
3476     if (DataTree->selectedItems()[0]->data(column,Qt::CheckStateRole).toInt() > 1) {
3477       double* cursorPos = landmarksPanel->GetSelectedPoint();
3478       mSlicerManagers[index]->GetSlicer(column-1)->SetCurrentPosition(
3479         cursorPos[0],cursorPos[1],cursorPos[2],cursorPos[3]);
3480       mSlicerManagers[index]->UpdateViews(1,column-1);
3481       mSlicerManagers[index]->UpdateLinked(column-1);
3482       break;
3483     }
3484   }
3485 }
3486 //------------------------------------------------------------------------------
3487
3488 //------------------------------------------------------------------------------
3489 void vvMainWindow::PlayPause()
3490 {
3491   if (playMode) {
3492     playMode = 0;
3493     playButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/player_play.png")));
3494     ImageInfoChanged();
3495     return;
3496   } else {
3497     int image_number=DataTree->topLevelItemCount();
3498     bool has_temporal;
3499     for (int i=0; i<image_number; i++)
3500       if (mSlicerManagers[i]->GetSlicer(0)->GetTMax() > 0) {
3501         has_temporal=true;
3502         break;
3503       }
3504       if (has_temporal) {
3505         playMode = 1;
3506         playButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/player_pause.png")));
3507         QTimer::singleShot(1000/mFrameRate, this, SLOT(PlayNext()));
3508       }
3509   }
3510 }
3511 //------------------------------------------------------------------------------
3512
3513 //------------------------------------------------------------------------------
3514 void vvMainWindow::PlayNext()
3515 {
3516   if (playMode && !this->isHidden()) {
3517     int image_number=DataTree->topLevelItemCount();
3518     ///Only play one slicer per SM, and only if the SM is being displayed
3519     for (int i=0; i<image_number; i++)
3520       for (int j=0; j<4; j++)
3521         if (mSlicerManagers[i]->GetSlicer(0)->GetTMax() > 0 &&
3522           DataTree->topLevelItem(i)->data(j+1,Qt::CheckStateRole).toInt() > 0) {
3523             mSlicerManagers[i]->SetNextTSlice(j);
3524             break;
3525         }
3526         QTimer::singleShot(1000/mFrameRate, this, SLOT(PlayNext()));
3527   }
3528 }
3529 //------------------------------------------------------------------------------
3530
3531 void vvMainWindow::ShowLastImage()
3532 {
3533   if (mSlicerManagers.size() > 1) {
3534     QTreeWidgetItem * item=DataTree->topLevelItem(DataTree->topLevelItemCount()-1);
3535     CurrentImageChanged(mSlicerManagers.back()->GetId()); //select new image
3536     item->setData(1,Qt::CheckStateRole,2); //show the new image in the first panel
3537     //mSlicerManagers[GetSlicerIndexFromItem(item)]->GetSlicer(0)->SetActorVisibility("image", 0, 1); //Set the Last Image visibles
3538     DisplayChanged(item,1);
3539   }
3540 }
3541
3542 //------------------------------------------------------------------------------
3543 void vvMainWindow::UpdateRenderWindows()
3544 {
3545   for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
3546     mSlicerManagers[i]->GetSlicer(0)->UpdateLandmarks();
3547     mSlicerManagers[i]->GetSlicer(1)->UpdateLandmarks();
3548     mSlicerManagers[i]->GetSlicer(2)->UpdateLandmarks();
3549     mSlicerManagers[i]->GetSlicer(3)->UpdateLandmarks();
3550   }
3551   if (NOViewWidget->GetRenderWindow()) NOViewWidget->GetRenderWindow()->Render();
3552   if (NEViewWidget->GetRenderWindow()) NEViewWidget->GetRenderWindow()->Render();
3553   if (SOViewWidget->GetRenderWindow()) SOViewWidget->GetRenderWindow()->Render();
3554   if (SEViewWidget->GetRenderWindow()) SEViewWidget->GetRenderWindow()->Render();
3555 }
3556 //------------------------------------------------------------------------------
3557
3558 //------------------------------------------------------------------------------
3559 void vvMainWindow::SegmentationOnCurrentImage()
3560 {
3561   int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
3562
3563   vvSegmentationDialog segmentation;
3564   segmentation.SetImage(mSlicerManagers[index]->GetSlicer(0)->GetImage());
3565   segmentation.exec();
3566 }
3567 //------------------------------------------------------------------------------
3568
3569 void vvMainWindow::SurfaceViewerLaunch()
3570 {
3571   vvSurfaceViewerDialog surfaceViewer;
3572   surfaceViewer.exec();
3573 }
3574 //------------------------------------------------------------------------------
3575
3576
3577 //------------------------------------------------------------------------------
3578 int vvMainWindow::GetImageDuplicateFilenameNumber(std::string filename)
3579 {
3580   int number=0;
3581   for(unsigned int l=0; l<mSlicerManagers.size(); l++) {
3582     vvSlicerManager * v = mSlicerManagers[l];
3583     if (v->GetBaseFileName() ==
3584       vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename))) {
3585         number = std::max(number, v->GetBaseFileNameNumber()+1);
3586     }
3587   }
3588   return number;
3589 }
3590 //------------------------------------------------------------------------------
3591
3592
3593 //------------------------------------------------------------------------------
3594 vvSlicerManager* vvMainWindow::AddImage(vvImage::Pointer image,std::string filename)
3595 {
3596   // Change filename if another image exist with the same name
3597   int number = GetImageDuplicateFilenameNumber(filename);
3598
3599   // Create new SliceManager
3600   vvSlicerManager* slicer_manager = new vvSlicerManager(4);
3601   slicer_manager->SetImage(image);//, IMAGE, number);
3602   //  filename = filename+"_"+clitk::toString(number);
3603   slicer_manager->SetFilename(filename, number);
3604   mSlicerManagers.push_back(slicer_manager);
3605
3606   //create an item in the tree with good settings
3607   QTreeWidgetItem *item = new QTreeWidgetItem();
3608   item->setData(0,Qt::UserRole,slicer_manager->GetFileName().c_str());//files[i].c_str());
3609   item->setData(1,Qt::UserRole,tr("image"));
3610   item->setData(COLUMN_IMAGE_NAME,Qt::DisplayRole,slicer_manager->GetFileName().c_str());//filename.c_str());
3611   qApp->processEvents();
3612
3613   for (int j = 1; j <= 4; j++) item->setData(j,Qt::CheckStateRole,1);
3614
3615   //Create the buttons for reload and close
3616   qApp->processEvents();
3617   QTreePushButton* cButton = new QTreePushButton;
3618   cButton->setItem(item);
3619   cButton->setColumn(COLUMN_CLOSE_IMAGE);
3620   cButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/exit.png")));
3621   connect(cButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
3622     this,SLOT(CloseImage(QTreeWidgetItem*, int)));
3623
3624   QTreePushButton* rButton = new QTreePushButton;
3625   rButton->setItem(item);
3626   rButton->setColumn(COLUMN_RELOAD_IMAGE);
3627   rButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/rotateright.png")));
3628   rButton->setEnabled(0);
3629   connect(rButton,SIGNAL(clickedInto(QTreeWidgetItem*, int)),
3630     this,SLOT(ReloadImage(QTreeWidgetItem*, int)));
3631
3632   DataTree->addTopLevelItem(item);
3633   DataTree->setItemWidget(item, COLUMN_CLOSE_IMAGE, cButton);
3634   DataTree->setItemWidget(item, COLUMN_RELOAD_IMAGE, rButton);
3635
3636   //set the id of the image
3637   QString id = QDir::current().absoluteFilePath(slicer_manager->GetFileName().c_str()) + QString::number(mSlicerManagers.size()-1);
3638   item->setData(COLUMN_IMAGE_NAME,Qt::UserRole,id.toStdString().c_str());
3639   mSlicerManagers.back()->SetId(id.toStdString());
3640
3641   linkPanel->addImage(slicer_manager->GetFileName().c_str()// filename
3642     , id.toStdString());
3643
3644   connect(mSlicerManagers.back(), SIGNAL(currentImageChanged(std::string)),
3645     this, SLOT(CurrentImageChanged(std::string)));
3646   connect(mSlicerManagers.back(), SIGNAL(currentPickedImageChanged(std::string)),
3647     this, SLOT(CurrentPickedImageChanged(std::string)));
3648   connect(mSlicerManagers.back(), SIGNAL(UpdatePosition(int, double, double, double, double, double, double, double)),
3649     this, SLOT(MousePositionChanged(int,double, double, double, double, double, double, double)));
3650   connect(mSlicerManagers.back(), SIGNAL(UpdateVector(int, double, double, double, double)),
3651     this, SLOT(VectorChanged(int,double,double,double, double)));
3652   connect(mSlicerManagers.back(), SIGNAL(UpdateOverlay(int, double, double)),
3653     this, SLOT(OverlayChanged(int,double,double)));
3654   connect(mSlicerManagers.back(), SIGNAL(UpdateFusion(int, double)),
3655     this, SLOT(FusionChanged(int,double)));
3656   //connect(mSlicerManagers.back(), SIGNAL(UpdateFusionSequence(int, bool, unsigned int)),
3657   //  this, SLOT(FusionSequenceChanged(int, bool, unsigned int)));
3658   connect(mSlicerManagers.back(), SIGNAL(WindowLevelChanged()),
3659     this,SLOT(WindowLevelChanged()));
3660   connect(mSlicerManagers.back(), SIGNAL(UpdateSlice(int,int)),
3661     this,SLOT(UpdateSlice(int,int)));
3662   connect(mSlicerManagers.back(), SIGNAL(UpdateTSlice(int, int, int)),
3663     this,SLOT(UpdateTSlice(int, int, int)));
3664   connect(mSlicerManagers.back(), SIGNAL(UpdateTSlice(int, int, int)),
3665     this,SLOT(ImageInfoChanged()));
3666   connect(mSlicerManagers.back(), SIGNAL(UpdateSliceRange(int,int,int,int,int)),
3667     this,SLOT(UpdateSliceRange(int,int,int,int,int)));
3668   connect(mSlicerManagers.back(), SIGNAL(UpdateLinkManager(std::string,int,double,double,double,int)),
3669     this,SLOT(UpdateLinkManager(std::string,int,double,double,double,int)));
3670   connect(mSlicerManagers.back(), SIGNAL(UpdateLinkedNavigation(std::string,vvSlicerManager*,vvSlicer*)),
3671     this,SLOT(UpdateLinkedNavigation(std::string,vvSlicerManager*,vvSlicer*)));
3672   connect(mSlicerManagers.back(), SIGNAL(ChangeImageWithIndexOffset(vvSlicerManager*,int,int)),
3673     this,SLOT(ChangeImageWithIndexOffset(vvSlicerManager*,int,int)));
3674   connect(mSlicerManagers.back(), SIGNAL(LandmarkAdded()),landmarksPanel,SLOT(AddPoint()));
3675
3676
3677
3678   InitSlicers();
3679   UpdateTree();
3680   qApp->processEvents();
3681   InitDisplay();
3682   ShowLastImage();
3683   qApp->processEvents();
3684   // End
3685   ImageInfoChanged();
3686   return slicer_manager;
3687 }
3688 //------------------------------------------------------------------------------
3689
3690
3691 //------------------------------------------------------------------------------
3692 void vvMainWindow::UpdateCurrentSlicer()
3693 {
3694   int index = -1;
3695   if (DataTree->selectedItems().size() > 0) {
3696     index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
3697   }
3698   mSlicerManagerCurrentIndex = index;
3699 }
3700 //------------------------------------------------------------------------------