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