vv/vvMainWindow.cxx

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