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