vv/vvMainWindow.cxx

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