vv/vvMainWindow.cxx

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