vv/vvMainWindow.cxx

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