vv/vvMainWindow.cxx

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