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