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