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