vv/vvSlicerManager.cxx

   1 /*=========================================================================
   2   Program:   vv                     http://www.creatis.insa-lyon.fr/rio/vv
   3
   4   Authors belong to:
   5   - University of LYON              http://www.universite-lyon.fr/
   6   - Léon Bérard cancer center       http://oncora1.lyon.fnclcc.fr
   7   - CREATIS CNRS laboratory         http://www.creatis.insa-lyon.fr
   8
   9   This software is distributed WITHOUT ANY WARRANTY; without even
  10   the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  11   PURPOSE.  See the copyright notices for more information.
  12
  13   It is distributed under dual licence
  14
  15   - BSD        See included LICENSE.txt file
  16   - CeCILL-B   http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
  17   ======================================================================-====*/
  18
  19 #include "vvSlicerManager.h"
  20 #include "vvSlicer.h"
  21 #include "vvImage.h"
  22 #include "vvSlicerManagerCommand.h"
  23 #include "vvInteractorStyleNavigator.h"
  24 #include "vvLandmarks.h"
  25 #include "vvImageReader.h"
  26 #include "vvImageReader.h"
  27 #include "vvMesh.h"
  28 #include "vvImageMapToWLColors.h"
  29
  30 #include "vtkImageActor.h"
  31 #include "vtkImageData.h"
  32 #include "vtkRenderWindow.h"
  33 #include "vtkRendererCollection.h"
  34 #include "vtkRenderWindowInteractor.h"
  35 #include "vtkImageMapToWindowLevelColors.h"
  36 #include "vtkWindowLevelLookupTable.h"
  37 #include "vtkColorTransferFunction.h"
  38 #include "vtkImageClip.h"
  39 #include <vtkLODActor.h>
  40 #include <vtkPointData.h>
  41 #include <vtksys/SystemTools.hxx>
  42
  43 //----------------------------------------------------------------------------
  44 vvSlicerManager::vvSlicerManager(int numberOfSlicers)
  45 {
  46   mFileName = "";
  47   mId = "";
  48   mVFName = "";
  49   mOverlayName = "";
  50   mFusionName = "";
  51   mVFId = "";
  52   mLastError = "";
  53   mType = UNDEFINEDIMAGETYPE;
  54   mColorMap = 0;
  55   mPreset = 0;
  56   mOverlayColor = 130;
  57
  58   mFusionOpacity = 70;
  59   mFusionColorMap = 3;
  60   mFusionWindow = 1000;
  61   mFusionLevel = 1000;
  62
  63   mReader = NULL;
  64   mImage = NULL;
  65   mVF=NULL;
  66   mVectorReader = NULL;
  67   mOverlayReader = NULL;
  68   mFusionReader = NULL;
  69   mLandmarks = NULL;
  70   mLinkedId.resize(0);
  71
  72   for ( int i = 0; i < numberOfSlicers; i++)
  73     {
  74       vvSlicer *slicer = vvSlicer::New();
  75       mSlicers.push_back(slicer);
  76     }
  77 }
  78 //----------------------------------------------------------------------------
  79
  80
  81 //----------------------------------------------------------------------------
  82 vvSlicerManager::~vvSlicerManager()
  83 {
  84   for ( unsigned int i = 0; i < mSlicers.size(); i++)
  85     {
  86       if (mSlicers[i] != NULL)
  87         mSlicers[i]->Delete();
  88     }
  89   if (mReader)
  90     {
  91       delete mReader;
  92     }
  93   if (mVectorReader)
  94     {
  95       delete mVectorReader;
  96     }
  97   if (mOverlayReader)
  98     {
  99       delete mOverlayReader;
 100     }
 101   if (mFusionReader)
 102     {
 103       delete mFusionReader;
 104     }
 105   if (mLandmarks)
 106     delete mLandmarks;
 107 }
 108 //----------------------------------------------------------------------------
 109
 110
 111 //------------------------------------------------------------------------------
 112 void vvSlicerManager::SetFilename(std::string f) {
 113   mFileName = f;
 114   for(unsigned int i=0; i<mSlicers.size(); i++) {
 115     mSlicers[i]->SetFileName(f);
 116   }
 117 }
 118 //------------------------------------------------------------------------------
 119
 120
 121 //----------------------------------------------------------------------------
 122 void vvSlicerManager::AddContour(vvMesh::Pointer contour,bool propagate)
 123 {
 124   for ( unsigned int i = 0; i < mSlicers.size(); i++)
 125     {
 126       mSlicers[i]->AddContour(contour,propagate);
 127     }
 128 }
 129 //----------------------------------------------------------------------------
 130
 131
 132 //----------------------------------------------------------------------------
 133 void vvSlicerManager::ToggleContourSuperposition()
 134 {
 135   for ( unsigned int i = 0; i < mSlicers.size(); i++)
 136     mSlicers[i]->ToggleContourSuperposition();
 137 }
 138 //----------------------------------------------------------------------------
 139
 140
 141 //----------------------------------------------------------------------------
 142 bool vvSlicerManager::SetImage(std::string filename, LoadedImageType type, int n)
 143 {
 144   mFileName = filename;
 145   mType = type;
 146   if (mReader == NULL)
 147     mReader = new vvImageReader;
 148   std::vector<std::string> filenames;
 149   filenames.push_back(filename);
 150   mReader->SetInputFilenames(filenames);
 151   mReader->Update(type);
 152
 153   mFileName = vtksys::SystemTools::GetFilenameName(mFileName);
 154   mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));
 155   //  DD(mBaseFileName);
 156   mBaseFileNameNumber = n;
 157
 158   if (mReader->GetLastError().size() == 0)
 159     {
 160       mImage=mReader->GetOutput();
 161       for ( unsigned int i = 0; i < mSlicers.size(); i++)
 162         {
 163           mSlicers[i]->SetFileName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));
 164           mSlicers[i]->SetImage(mReader->GetOutput());
 165           //          DD(mSlicers[i]->GetFileName());
 166         }
 167     }
 168   else
 169     {
 170       mLastError = mReader->GetLastError();
 171       return false;
 172     }
 173   if (n!=0) {
 174     //    DD(mFileName);
 175     mFileName.append("_"+clitk::toString(n));
 176   }
 177   return true;
 178 }
 179 //----------------------------------------------------------------------------
 180
 181
 182 //----------------------------------------------------------------------------
 183 void vvSlicerManager::SetImage(vvImage::Pointer image)
 184 {
 185   mImage=image;
 186   for (unsigned int i = 0; i < mSlicers.size();i++)
 187     {
 188       mSlicers[i]->SetImage(image);
 189     }
 190 }
 191 //----------------------------------------------------------------------------
 192
 193
 194 //----------------------------------------------------------------------------
 195 bool vvSlicerManager::SetImages(std::vector<std::string> filenames,LoadedImageType type, int n)
 196 {
 197   mType = type;
 198   std::string fileWithoutExtension = vtksys::SystemTools::GetFilenameWithoutExtension(filenames[0]);
 199   if (type == DICOM)
 200     fileWithoutExtension += "_dicom";
 201   else if (type == MERGED)
 202     fileWithoutExtension += "_merged";
 203   else if (type == MERGEDWITHTIME)
 204     fileWithoutExtension += "_merged_wt";
 205
 206   mFileName = vtksys::SystemTools::GetFilenameName(mFileName);
 207   mFileName = fileWithoutExtension + vtksys::SystemTools::GetFilenameExtension(filenames[0]);
 208   if (mReader == NULL)
 209     mReader = new vvImageReader;
 210   mReader->SetInputFilenames(filenames);
 211   mReader->Update(type);
 212
 213   mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));
 214   //  DD(mBaseFileName);
 215   mBaseFileNameNumber = n;
 216
 217   if (mReader->GetLastError().size() == 0)
 218     {
 219       mImage=mReader->GetOutput();
 220       for ( unsigned int i = 0; i < mSlicers.size(); i++)
 221         {
 222           mSlicers[i]->SetFileName(fileWithoutExtension);
 223           mSlicers[i]->SetImage(mReader->GetOutput());
 224         }
 225     }
 226   else
 227     {
 228       mLastError = mReader->GetLastError();
 229       return false;
 230     }
 231   if (n!=0) {
 232     //    DD(mFileName);
 233     mFileName.append("_"+clitk::toString(n));
 234     //    DD(mFileName);
 235   }
 236  return true;
 237 }
 238 //----------------------------------------------------------------------------
 239
 240
 241 //----------------------------------------------------------------------------
 242 bool vvSlicerManager::SetOverlay(std::string filename,int dim, std::string component)
 243 {
 244   mOverlayName = filename;
 245   mOverlayComponent = component;
 246   if (dim > mImage->GetNumberOfDimensions())
 247     {
 248       mLastError = " Overlay dimension cannot be greater then reference image!";
 249       return false;
 250     }
 251   if (mOverlayReader == NULL)
 252     mOverlayReader = new vvImageReader;
 253   std::vector<std::string> filenames;
 254   filenames.push_back(filename);
 255   mOverlayReader->SetInputFilenames(filenames);
 256   mOverlayReader->Update(mImage->GetNumberOfDimensions(),component.c_str(),mType);
 257   if (mOverlayReader->GetLastError().size() == 0)
 258     {
 259       for ( unsigned int i = 0; i < mSlicers.size(); i++)
 260         {
 261           mSlicers[i]->SetOverlay(mOverlayReader->GetOutput());
 262         }
 263     }
 264   else
 265     {
 266       mLastError = mOverlayReader->GetLastError();
 267       return false;
 268     }
 269   return true;
 270 }
 271 //----------------------------------------------------------------------------
 272
 273
 274 //----------------------------------------------------------------------------
 275 bool vvSlicerManager::SetFusion(std::string filename,int dim, std::string component)
 276 {
 277   mFusionName = filename;
 278   mFusionComponent = component;
 279   if (dim > mImage->GetNumberOfDimensions())
 280     {
 281       mLastError = " Overlay dimension cannot be greater then reference image!";
 282       return false;
 283     }
 284   if (mFusionReader == NULL)
 285     mFusionReader = new vvImageReader;
 286   std::vector<std::string> filenames;
 287   filenames.push_back(filename);
 288   mFusionReader->SetInputFilenames(filenames);
 289   mFusionReader->Update(mImage->GetNumberOfDimensions(),component.c_str(),mType);
 290   if (mFusionReader->GetLastError().size() == 0)
 291     {
 292       for ( unsigned int i = 0; i < mSlicers.size(); i++)
 293         {
 294           mSlicers[i]->SetFusion(mFusionReader->GetOutput());
 295         }
 296     }
 297   else
 298     {
 299       mLastError = mFusionReader->GetLastError();
 300       return false;
 301     }
 302   double *fusRange = mFusionReader->GetOutput()->GetVTKImages()[0]->GetScalarRange();
 303   mFusionLevel = (fusRange[0]+fusRange[1])/2;
 304   mFusionWindow = fusRange[1]-fusRange[0];
 305   return true;
 306 }
 307 //----------------------------------------------------------------------------
 308
 309
 310 //----------------------------------------------------------------------------
 311 bool vvSlicerManager::SetVF(std::string filename)
 312 {
 313   if (mVectorReader == NULL)
 314     mVectorReader = new vvImageReader;
 315   mVectorReader->SetInputFilename(filename);
 316   mVectorReader->Update(VECTORFIELD);
 317   if (mVectorReader->GetLastError().size() != 0)
 318     {
 319       mLastError = mVectorReader->GetLastError();
 320       return false;
 321     }
 322   else
 323     return SetVF(mVectorReader->GetOutput(),filename);
 324 }
 325 //----------------------------------------------------------------------------
 326
 327
 328 //----------------------------------------------------------------------------
 329 bool vvSlicerManager::SetVF(vvImage::Pointer vf,std::string filename)
 330 {
 331   if (vf->GetNumberOfDimensions() > mImage->GetNumberOfDimensions())
 332     {
 333       mLastError = " Vector field dimension cannot be greater then reference image!";
 334       return false;
 335     }
 336   mVF=vf;
 337   mVFName = filename;
 338   for ( unsigned int i = 0; i < mSlicers.size(); i++)
 339     {
 340       mSlicers[i]->SetVF(vf);
 341     }
 342   return true;
 343 }
 344 //----------------------------------------------------------------------------
 345
 346
 347 //----------------------------------------------------------------------------
 348 void vvSlicerManager::SetExtractedImage(std::string filename,vvImage::Pointer image, int slice)
 349 {
 350   mFileName = filename;
 351   mImage = vvImage::New();
 352   if (image->GetNumberOfDimensions() == 4)
 353     {
 354       mImage->AddImage(image->GetVTKImages()[slice]);
 355       for ( unsigned int i = 0; i < mSlicers.size(); i++)
 356         {
 357           mSlicers[i]->SetFileName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));
 358           mSlicers[i]->SetImage(mImage);
 359         }
 360     }
 361   else
 362     {
 363       vtkImageClip* clipper = vtkImageClip::New();
 364       int extent[6];
 365       image->GetVTKImages()[0]->GetWholeExtent(extent);
 366       clipper->SetInput(image->GetVTKImages()[0]);
 367       clipper->SetOutputWholeExtent(extent[0],extent[1],extent[2],extent[3],slice,slice);
 368       clipper->Update();
 369       mImage->AddImage(clipper->GetOutput());
 370       for ( unsigned int i = 0; i < mSlicers.size(); i++)
 371         {
 372           mSlicers[i]->SetFileName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));
 373           mSlicers[i]->SetImage(mImage);
 374         }
 375       clipper->Delete();
 376     }
 377 }
 378 //----------------------------------------------------------------------------
 379
 380
 381 //----------------------------------------------------------------------------
 382 vvSlicer* vvSlicerManager::GetSlicer(int i)
 383 {
 384   return mSlicers[i];
 385 }
 386 //----------------------------------------------------------------------------
 387
 388
 389 //----------------------------------------------------------------------------
 390 void vvSlicerManager::UpdateSlicer(int num, bool state)
 391 {
 392   if (mSlicers[num]->GetImage())
 393     mSlicers[num]->SetDisplayMode(state);
 394 }
 395 //----------------------------------------------------------------------------
 396
 397
 398 //----------------------------------------------------------------------------
 399 void vvSlicerManager::SetSlicerWindow(int i, vtkRenderWindow* RW)
 400 {
 401   mSlicers[i]->SetRenderWindow(i,RW);
 402 }
 403 //----------------------------------------------------------------------------
 404
 405
 406 //----------------------------------------------------------------------------
 407 void vvSlicerManager::SetInteractorStyleNavigator(int i, vtkInteractorStyle* style)
 408 {
 409   vvSlicerManagerCommand *smc = vvSlicerManagerCommand::New();
 410   smc->SM = this;
 411   smc->SetSlicerNumber(i);
 412   mSlicers[i]->GetRenderWindow()->GetInteractor()->SetInteractorStyle(style);
 413
 414   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 415     GetInteractorStyle()->AddObserver(vtkCommand::KeyPressEvent, smc);
 416   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 417     GetInteractorStyle()->AddObserver(vtkCommand::WindowLevelEvent, smc);
 418   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 419     GetInteractorStyle()->AddObserver(vtkCommand::EndWindowLevelEvent, smc);
 420   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 421     GetInteractorStyle()->AddObserver(vtkCommand::StartWindowLevelEvent, smc);
 422   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 423     GetInteractorStyle()->AddObserver(vtkCommand::PickEvent, smc);
 424   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 425     GetInteractorStyle()->AddObserver(vtkCommand::StartPickEvent, smc);
 426   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 427     GetInteractorStyle()->AddObserver(vtkCommand::LeaveEvent, smc);
 428   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 429     GetInteractorStyle()->AddObserver(vtkCommand::UserEvent, smc);
 430   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 431     GetInteractorStyle()->AddObserver(vtkCommand::MouseWheelForwardEvent, smc);
 432   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 433     GetInteractorStyle()->AddObserver(vtkCommand::MouseWheelBackwardEvent, smc);
 434   smc->Delete();
 435 }
 436 //----------------------------------------------------------------------------
 437
 438
 439 //----------------------------------------------------------------------------
 440 void vvSlicerManager::SetTSlice(int slice)
 441 {
 442   if (slice < 0)
 443     slice = 0;
 444   else if (slice > mSlicers[0]->GetTMax())
 445     slice = mSlicers[0]->GetTMax();
 446   if (mLandmarks)
 447     mLandmarks->SetTime(slice);
 448   for ( unsigned int i = 0; i < mSlicers.size(); i++)
 449     {
 450       mSlicers[i]->SetTSlice(slice);
 451       if (mSlicers[i]->GetImageActor()->GetVisibility())
 452         UpdateTSlice(i);
 453     }
 454 }
 455 //----------------------------------------------------------------------------
 456
 457
 458 //----------------------------------------------------------------------------
 459 void vvSlicerManager::SetNextTSlice(int originating_slicer)
 460 {
 461   int t = mSlicers[0]->GetTSlice();
 462   t++;
 463   if (t > mSlicers[0]->GetTMax())
 464     t = 0;
 465   emit UpdateTSlice(originating_slicer,t);
 466 }
 467 //----------------------------------------------------------------------------
 468
 469
 470 //----------------------------------------------------------------------------
 471 void vvSlicerManager::SetPreviousTSlice(int originating_slicer)
 472 {
 473   int t = mSlicers[0]->GetTSlice();
 474   t--;
 475   if (t < 0)
 476     t = mSlicers[0]->GetTMax();
 477   emit UpdateTSlice(originating_slicer,t);
 478 }
 479 //----------------------------------------------------------------------------
 480
 481
 482 //----------------------------------------------------------------------------
 483 void vvSlicerManager::ToggleInterpolation()
 484 {
 485   bool interpolate=!(mSlicers[0]->GetImageActor()->GetInterpolate());
 486   for ( unsigned int i = 0; i < mSlicers.size(); i++)
 487     {
 488       mSlicers[i]->GetImageActor()->SetInterpolate(interpolate);
 489     }
 490 }
 491 //----------------------------------------------------------------------------
 492
 493
 494 //----------------------------------------------------------------------------
 495 void vvSlicerManager::SetTSliceInSlicer(int tslice, int slicer)
 496 {
 497   if (tslice < 0)
 498     tslice = 0;
 499   else if (tslice > mSlicers[slicer]->GetTMax())
 500     tslice = mSlicers[slicer]->GetTMax();
 501   if (mLandmarks)
 502     mLandmarks->SetTime(tslice);
 503   mSlicers[slicer]->SetTSlice(tslice);
 504   if (mSlicers[slicer]->GetImageActor()->GetVisibility())
 505     UpdateTSlice(slicer);
 506 }
 507 //----------------------------------------------------------------------------
 508
 509
 510 //----------------------------------------------------------------------------
 511 void vvSlicerManager::SetColorWindow(double s)
 512 {
 513   for ( unsigned int i = 0; i < mSlicers.size(); i++)
 514     {
 515       mSlicers[i]->SetColorWindow(s);
 516     }
 517 }
 518 //----------------------------------------------------------------------------
 519
 520
 521 //----------------------------------------------------------------------------
 522 void vvSlicerManager::SetColorLevel(double s)
 523 {
 524   for ( unsigned int i = 0; i < mSlicers.size(); i++)
 525     {
 526       mSlicers[i]->SetColorLevel(s);
 527     }
 528 }
 529 //----------------------------------------------------------------------------
 530
 531 //----------------------------------------------------------------------------
 532 void vvSlicerManager::SetCursorVisibility(int s)
 533 {
 534   for ( unsigned int i = 0; i < mSlicers.size(); i++)
 535     {
 536       mSlicers[i]->SetCursorVisibility(s);
 537     }
 538 }
 539 //----------------------------------------------------------------------------
 540
 541
 542 //----------------------------------------------------------------------------
 543 void vvSlicerManager::SetOpacity(int i, double factor)
 544 {
 545   mSlicers[i]->SetOpacity(1/factor);
 546 }
 547 //----------------------------------------------------------------------------
 548
 549
 550 //----------------------------------------------------------------------------
 551 void vvSlicerManager::UpdateViews(int current,int slicer)
 552 {
 553   double x = (mSlicers[slicer]->GetCurrentPosition()[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0])
 554     /mSlicers[slicer]->GetInput()->GetSpacing()[0];
 555   double y = (mSlicers[slicer]->GetCurrentPosition()[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1])
 556     /mSlicers[slicer]->GetInput()->GetSpacing()[1];
 557   double z = (mSlicers[slicer]->GetCurrentPosition()[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2])
 558     /mSlicers[slicer]->GetInput()->GetSpacing()[2];
 559
 560   if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] &&
 561       x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] &&
 562       y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&
 563       y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&
 564       z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&
 565       z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5])
 566     {
 567       mSlicers[slicer]->UpdateCursorPosition();
 568       mSlicers[slicer]->SetCursorColor(10,212,255);
 569
 570       switch (mSlicers[slicer]->GetSliceOrientation())
 571         {
 572         case vtkImageViewer2::SLICE_ORIENTATION_XY:
 573           if (mSlicers[slicer]->GetSlice() == (int)floor(z))
 574             mSlicers[slicer]->Render();
 575           else
 576             mSlicers[slicer]->SetSlice((int)floor(z));
 577           break;
 578
 579         case vtkImageViewer2::SLICE_ORIENTATION_XZ:
 580           if (mSlicers[slicer]->GetSlice() == (int)floor(y))
 581             mSlicers[slicer]->Render();
 582           else
 583             mSlicers[slicer]->SetSlice((int)floor(y));
 584           break;
 585
 586         case vtkImageViewer2::SLICE_ORIENTATION_YZ:
 587           if (mSlicers[slicer]->GetSlice() == (int)floor(x))
 588             mSlicers[slicer]->Render();
 589           else
 590             mSlicers[slicer]->SetSlice((int)floor(x));
 591           break;
 592         }
 593
 594       for ( unsigned int i = 0; i < mSlicers.size(); i++)
 595         {
 596           if (i != (unsigned int)slicer && mSlicers[i]->GetImageActor()->GetVisibility()
 597               && mSlicers[i]->GetRenderWindow()->GetSize()[0] > 2
 598               && mSlicers[i]->GetRenderWindow()->GetSize()[1] > 2)
 599             {
 600               mSlicers[i]->SetCurrentPosition(mSlicers[slicer]->GetCurrentPosition()[0],
 601                                               mSlicers[slicer]->GetCurrentPosition()[1],
 602                                               mSlicers[slicer]->GetCurrentPosition()[2],
 603                                               mSlicers[slicer]->GetTSlice());
 604               mSlicers[i]->UpdateCursorPosition();
 605               if (current) //do not display corner annotation if image is the one picked
 606                 {
 607                   mSlicers[i]->SetCurrentPosition(-VTK_DOUBLE_MAX,-VTK_DOUBLE_MAX,
 608                                                   -VTK_DOUBLE_MAX, mSlicers[slicer]->GetTSlice());
 609                   mSlicers[i]->SetCursorColor(255,10,212);
 610                 }
 611               else
 612                 {
 613                   mSlicers[i]->SetCursorColor(150,10,282);
 614                 }
 615               switch (mSlicers[i]->GetSliceOrientation())
 616                 {
 617                 case vtkImageViewer2::SLICE_ORIENTATION_XY:
 618                   if (mSlicers[i]->GetSlice() == (int)floor(z))
 619                     mSlicers[i]->Render();
 620                   else
 621                     mSlicers[i]->SetSlice((int)floor(z));
 622                   break;
 623
 624                 case vtkImageViewer2::SLICE_ORIENTATION_XZ:
 625                   if (mSlicers[i]->GetSlice() == (int)floor(y))
 626                     mSlicers[i]->Render();
 627                   else
 628                     mSlicers[i]->SetSlice((int)floor(y));
 629                   break;
 630
 631                 case vtkImageViewer2::SLICE_ORIENTATION_YZ:
 632                   if (mSlicers[i]->GetSlice() == (int)floor(x))
 633                     mSlicers[i]->Render();
 634                   else
 635                     mSlicers[i]->SetSlice((int)floor(x));
 636                   break;
 637                 }
 638               UpdateSlice(i);
 639               UpdateTSlice(i);
 640             }
 641         }
 642     }
 643 }
 644 //----------------------------------------------------------------------------
 645
 646
 647 //----------------------------------------------------------------------------
 648 void vvSlicerManager::UpdateLinked(int slicer)
 649 {
 650   double x = (mSlicers[slicer]->GetCurrentPosition()[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0])
 651     /mSlicers[slicer]->GetInput()->GetSpacing()[0];
 652   double y = (mSlicers[slicer]->GetCurrentPosition()[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1])
 653     /mSlicers[slicer]->GetInput()->GetSpacing()[1];
 654   double z = (mSlicers[slicer]->GetCurrentPosition()[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2])
 655     /mSlicers[slicer]->GetInput()->GetSpacing()[2];
 656
 657   if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] &&
 658       x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] &&
 659       y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&
 660       y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&
 661       z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&
 662       z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5])
 663     {
 664       for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++)
 665         {
 666           emit UpdateLinkManager(*i, slicer,mSlicers[slicer]->GetCurrentPosition()[0],
 667                                  mSlicers[slicer]->GetCurrentPosition()[1],
 668                                  mSlicers[slicer]->GetCurrentPosition()[2],mSlicers[slicer]->GetTSlice());
 669         }
 670     }
 671 }
 672 //----------------------------------------------------------------------------
 673
 674
 675 //----------------------------------------------------------------------------
 676 double vvSlicerManager::GetColorWindow()
 677 {
 678   if (mSlicers.size())
 679     return mSlicers[0]->GetColorWindow();
 680   return -1;
 681 }
 682 //----------------------------------------------------------------------------
 683
 684
 685 //----------------------------------------------------------------------------
 686 double vvSlicerManager::GetColorLevel()
 687 {
 688   if (mSlicers.size())
 689     return mSlicers[0]->GetColorLevel();
 690   return -1;
 691 }
 692 //----------------------------------------------------------------------------
 693
 694
 695 //----------------------------------------------------------------------------
 696 void vvSlicerManager::Render()
 697 {
 698   for ( unsigned int i = 0; i < mSlicers.size(); i++)
 699     {
 700       mSlicers[i]->Render();
 701     }
 702 }
 703 //----------------------------------------------------------------------------
 704
 705
 706 //----------------------------------------------------------------------------
 707 void vvSlicerManager::GenerateDefaultLookupTable()
 708 {
 709   SetPreset(mPreset);
 710   SetColorMap(mColorMap);
 711 }
 712 //----------------------------------------------------------------------------
 713
 714
 715 //----------------------------------------------------------------------------
 716 void vvSlicerManager::Reload()
 717 {
 718   mReader->Update(mType);
 719   mImage=mReader->GetOutput();
 720   for ( unsigned int i = 0; i < mSlicers.size(); i++)
 721     {
 722       mSlicers[i]->SetImage(mImage);
 723     }
 724 }
 725 //----------------------------------------------------------------------------
 726
 727
 728 //----------------------------------------------------------------------------
 729 void vvSlicerManager::ReloadFusion()
 730 {
 731   mFusionReader->Update();
 732   for ( unsigned int i = 0; i < mSlicers.size(); i++)
 733     {
 734       mSlicers[i]->SetFusion(mFusionReader->GetOutput());
 735       mSlicers[i]->Render();
 736     }
 737 }
 738 //----------------------------------------------------------------------------
 739
 740
 741 //----------------------------------------------------------------------------
 742 void vvSlicerManager::ReloadOverlay()
 743 {
 744   mOverlayReader->Update();
 745   for ( unsigned int i = 0; i < mSlicers.size(); i++)
 746     {
 747       mSlicers[i]->SetOverlay(mOverlayReader->GetOutput());
 748       mSlicers[i]->Render();
 749     }
 750 }
 751 //----------------------------------------------------------------------------
 752
 753
 754 //----------------------------------------------------------------------------
 755 void vvSlicerManager::ReloadVF()
 756 {
 757   mVectorReader->Update(VECTORFIELD); //deletes the old images through the VF::Init() function
 758   mVF=mVectorReader->GetOutput();
 759   for ( unsigned int i = 0; i < mSlicers.size(); i++)
 760     {
 761       mSlicers[i]->SetVF(mVF);
 762       mSlicers[i]->Render();
 763     }
 764 }
 765 //----------------------------------------------------------------------------
 766
 767
 768 //----------------------------------------------------------------------------
 769 void vvSlicerManager::RemoveActor(const std::string& actor_type, int overlay_index)
 770 {
 771   for (unsigned int i = 0; i < mSlicers.size();i++)
 772     {
 773       mSlicers[i]->RemoveActor(actor_type,overlay_index);
 774     }
 775   if (actor_type=="vector")
 776     {
 777       mVF=NULL;
 778       if (mVectorReader) {
 779         delete mVectorReader;
 780         mVectorReader=NULL;
 781       }
 782     }
 783 }
 784 //----------------------------------------------------------------------------
 785
 786
 787 //----------------------------------------------------------------------------
 788 void vvSlicerManager::RemoveActors()
 789 {
 790   ///This method leaks a few objects. See RemoveActor for what a correct implementation would look like
 791   for ( unsigned int i = 0; i < mSlicers.size(); i++)
 792     {
 793       mSlicers[i]->SetDisplayMode(0);
 794       mSlicers[i]->GetRenderer()->RemoveActor(mSlicers[i]->GetImageActor());
 795     }
 796 }
 797 //----------------------------------------------------------------------------
 798
 799
 800 //----------------------------------------------------------------------------
 801 void vvSlicerManager::UpdateInfoOnCursorPosition(int slicer)
 802 {
 803   //  int view = mSlicers[slicer]->GetSliceOrientation();
 804   //  int slice = mSlicers[slicer]->GetSlice();
 805   double x = mSlicers[slicer]->GetCursorPosition()[0];
 806   double y = mSlicers[slicer]->GetCursorPosition()[1];
 807   double z = mSlicers[slicer]->GetCursorPosition()[2];
 808   double X = (x - mSlicers[slicer]->GetInput()->GetOrigin()[0])/
 809     mSlicers[slicer]->GetInput()->GetSpacing()[0];
 810   double Y = (y - mSlicers[slicer]->GetInput()->GetOrigin()[1])/
 811     mSlicers[slicer]->GetInput()->GetSpacing()[1];
 812   double Z = (z - mSlicers[slicer]->GetInput()->GetOrigin()[2])/
 813     mSlicers[slicer]->GetInput()->GetSpacing()[2];
 814   double value = -VTK_DOUBLE_MAX;
 815   int displayVec = 0;
 816   double xVec=0, yVec=0, zVec=0, valueVec=0;
 817   int displayOver = 0;
 818   int displayFus = 0;
 819   double valueOver=0, valueFus=0;
 820   if (X >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] &&
 821       X <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] &&
 822       Y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&
 823       Y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&
 824       Z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&
 825       Z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5])
 826     {
 827       value = mSlicers[slicer]->GetInput()->GetScalarComponentAsDouble(
 828                                                                        (int)floor(X),
 829                                                                        (int)floor(Y),
 830                                                                        (int)floor(Z),0);
 831       if (mSlicers[slicer]->GetVFActor() && mSlicers[slicer]->GetVFActor()->GetVisibility())
 832         {
 833           displayVec = 1;
 834           unsigned int currentTime = mSlicers[slicer]->GetTSlice();
 835           vtkImageData *vf = NULL;
 836
 837           if (mSlicers[slicer]->GetVF()->GetVTKImages().size() > currentTime)
 838             vf = mSlicers[slicer]->GetVF()->GetVTKImages()[currentTime];
 839           else
 840             vf = mSlicers[slicer]->GetVF()->GetVTKImages()[0];
 841
 842           if (vf)
 843             {
 844               double Xvf = (x - vf->GetOrigin()[0])/ vf->GetSpacing()[0];
 845               double Yvf = (y - vf->GetOrigin()[1])/ vf->GetSpacing()[1];
 846               double Zvf = (z - vf->GetOrigin()[2])/ vf->GetSpacing()[2];
 847               xVec = vf->GetScalarComponentAsDouble( (int)floor(Xvf), (int)floor(Yvf), (int)floor(Zvf),0);
 848               yVec = vf->GetScalarComponentAsDouble( (int)floor(Xvf), (int)floor(Yvf), (int)floor(Zvf),1);
 849               zVec = vf->GetScalarComponentAsDouble( (int)floor(Xvf), (int)floor(Yvf), (int)floor(Zvf),2);
 850               valueVec = sqrt(xVec*xVec + yVec*yVec + zVec*zVec);
 851             }
 852         }
 853       if (mSlicers[slicer]->GetOverlayActor() && mSlicers[slicer]->GetOverlayActor()->GetVisibility())
 854         {
 855           displayOver = 1;
 856           double Xover = (x - mSlicers[slicer]->GetOverlay()->GetOrigin()[0])
 857             /mSlicers[slicer]->GetOverlay()->GetSpacing()[0];
 858           double Yover = (y - mSlicers[slicer]->GetOverlay()->GetOrigin()[1])
 859             /mSlicers[slicer]->GetOverlay()->GetSpacing()[1];
 860           double Zover = (z - mSlicers[slicer]->GetOverlay()->GetOrigin()[2])
 861             /mSlicers[slicer]->GetOverlay()->GetSpacing()[2];
 862           if (Xover >= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[0] &&
 863               Xover <= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[1] &&
 864               Yover >= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[2] &&
 865               Yover <= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[3] &&
 866               Zover >= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[4] &&
 867               Zover <= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[5])
 868             {
 869               valueOver = static_cast<vtkImageData*>(mSlicers[slicer]->GetOverlayMapper()->GetInput())->
 870                 GetScalarComponentAsDouble(
 871                                            (int)floor(Xover),
 872                                            (int)floor(Yover),
 873                                            (int)floor(Zover),0);
 874             }
 875         }
 876       if (mSlicers[slicer]->GetFusionActor() && mSlicers[slicer]->GetFusionActor()->GetVisibility())
 877         {
 878           displayFus = 1;
 879           double Xfus = (x - mSlicers[slicer]->GetFusion()->GetOrigin()[0])
 880             /mSlicers[slicer]->GetFusion()->GetSpacing()[0];
 881           double Yfus = (y - mSlicers[slicer]->GetFusion()->GetOrigin()[1])
 882             /mSlicers[slicer]->GetFusion()->GetSpacing()[1];
 883           double Zfus = (z - mSlicers[slicer]->GetFusion()->GetOrigin()[2])
 884             /mSlicers[slicer]->GetFusion()->GetSpacing()[2];
 885           if (Xfus >= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[0] &&
 886               Xfus <= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[1] &&
 887               Yfus >= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[2] &&
 888               Yfus <= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[3] &&
 889               Zfus >= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[4] &&
 890               Zfus <= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[5])
 891             {
 892               valueFus = static_cast<vtkImageData*>(mSlicers[slicer]->GetFusionMapper()->GetInput())->
 893                 GetScalarComponentAsDouble(
 894                                            (int)floor(Xfus),
 895                                            (int)floor(Yfus),
 896                                            (int)floor(Zfus),0);
 897             }
 898         }
 899       emit UpdatePosition(mSlicers[slicer]->GetCursorVisibility(),
 900                           x,y,z,X,Y,Z,value);
 901       emit UpdateVector(displayVec,xVec, yVec, zVec, valueVec);
 902       emit UpdateOverlay(displayOver,valueOver,value);
 903       emit UpdateFusion(displayFus,valueFus);
 904       for (unsigned int i = 0; i < mSlicers.size(); i++)
 905         {
 906           if (mSlicers[i]->GetImageActor()->GetVisibility() == 1)
 907             emit UpdateWindows(i,mSlicers[i]->GetSliceOrientation(),mSlicers[i]->GetSlice());
 908           else
 909             emit UpdateWindows(i,-1,-1);
 910         }
 911     }
 912 }
 913 //----------------------------------------------------------------------------
 914
 915
 916 //----------------------------------------------------------------------------
 917 void vvSlicerManager::Activated()
 918 {
 919   emit currentImageChanged(mId);
 920 }
 921 //----------------------------------------------------------------------------
 922
 923
 924 //----------------------------------------------------------------------------
 925 void vvSlicerManager::UpdateWindowLevel()
 926 {
 927   emit WindowLevelChanged(mSlicers[0]->GetColorWindow(),mSlicers[0]->GetColorLevel(),mPreset,mColorMap);
 928 }
 929 //----------------------------------------------------------------------------
 930
 931
 932 //----------------------------------------------------------------------------
 933 void vvSlicerManager::UpdateSlice(int slicer)
 934 {
 935   emit UpdateSlice(slicer, mSlicers[slicer]->GetSlice());
 936 }
 937 //----------------------------------------------------------------------------
 938
 939
 940 //----------------------------------------------------------------------------
 941 void vvSlicerManager::UpdateTSlice(int slicer)
 942 {
 943   emit UpdateTSlice(slicer,mSlicers[0]->GetTSlice());
 944 }
 945 //----------------------------------------------------------------------------
 946
 947
 948 //----------------------------------------------------------------------------
 949 void vvSlicerManager::UpdateSliceRange(int slicer)
 950 {
 951   emit UpdateSliceRange(slicer,
 952                         mSlicers[slicer]->GetSliceRange()[0], mSlicers[slicer]->GetSliceRange()[1],
 953                         0,mSlicers[slicer]->GetTMax());
 954 }
 955 //----------------------------------------------------------------------------
 956
 957
 958 //----------------------------------------------------------------------------
 959 void vvSlicerManager::SetPreset(int preset)
 960 {
 961   //vtkLookupTable* LUT = static_cast<vtkLookupTable*>(mSlicers[0]->GetWindowLevel()->GetLookupTable());
 962   double window = mSlicers[0]->GetColorWindow();
 963   double level = mSlicers[0]->GetColorLevel();
 964
 965   std::string component_type=mImage->GetScalarTypeAsString();
 966   switch (preset)
 967     {
 968     case 0:
 969       if (component_type == "unsigned_char")
 970         {
 971           window = 255;
 972           level = 127;
 973         }
 974       else if (component_type == "short")
 975         {
 976           window = 2000;
 977           level = 0;
 978         }
 979       else
 980         {
 981           double range[2];
 982           mImage->GetScalarRange(range);
 983           window = range[1] - range[0];
 984           level = (range[1] + range[0])* 0.5;
 985         }
 986       break;
 987     case 1:
 988       window = 2000;
 989       level = 0;
 990       break;
 991     case 2:
 992       window = 350;
 993       level = 60;
 994       break;
 995     case 3:
 996       window = 1500;
 997       level = -500;
 998       break;
 999     case 4:
1000       window = 1000;
1001       level = 500;
1002       break;
1003     case 5:
1004       window = 1;
1005       level = 0.5;
1006       break;
1007     case 6:
1008       break;
1009     case 7:
1010       window=1.;
1011       level=0.;
1012       break;
1013     }
1014   mPreset = preset;
1015   this->SetColorWindow(window);
1016   this->SetColorLevel(level);
1017
1018   //if (LUT)
1019   //{
1020   //    SetColorMap(-1);
1021   //}
1022 }
1023 //----------------------------------------------------------------------------
1024
1025
1026 //----------------------------------------------------------------------------
1027 void vvSlicerManager::SetLocalColorWindowing(const int slicer)
1028 {
1029   double min, max;
1030   this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max);
1031   this->SetColorWindow(max-min);
1032   this->SetColorLevel(0.5*(min+max));
1033   this->Render();
1034 }
1035 //----------------------------------------------------------------------------
1036
1037
1038 //----------------------------------------------------------------------------
1039 void vvSlicerManager::SetColorMap()
1040 {
1041   SetColorMap(mColorMap);
1042 }
1043 //----------------------------------------------------------------------------
1044
1045
1046 //----------------------------------------------------------------------------
1047 void vvSlicerManager::SetColorMap(int colormap)
1048 {
1049   double range[2];
1050   range[0] = mSlicers[0]->GetInput()->GetScalarRange()[0];
1051   range[1] = mSlicers[0]->GetInput()->GetScalarRange()[1];
1052
1053   double window = mSlicers[0]->GetWindowLevel()->GetWindow();
1054   double level = mSlicers[0]->GetWindowLevel()->GetLevel();
1055
1056   vtkLookupTable* LUT = static_cast<vtkLookupTable*>(mSlicers[0]->GetWindowLevel()->GetLookupTable());
1057   switch (colormap)
1058     {
1059     case -1:
1060       break;
1061     case 0:
1062       LUT = NULL;
1063       break;
1064     case 1:
1065       if (LUT == NULL)
1066         LUT = vtkLookupTable::New();
1067       LUT->SetValueRange(0,1);
1068       LUT->SetSaturationRange(1,1);
1069       LUT->SetHueRange(0,0.18);
1070       break;
1071     case 2:
1072       if (LUT == NULL)
1073         LUT = vtkLookupTable::New();
1074       LUT->SetValueRange(0,1);
1075       LUT->SetSaturationRange(1,1);
1076       LUT->SetHueRange(0.4,0.80);
1077       break;
1078     case 3:
1079       if (LUT == NULL)
1080         LUT = vtkLookupTable::New();
1081       LUT->SetValueRange(0,1);
1082       LUT->SetSaturationRange(1,1);
1083       LUT->SetHueRange(0,1);
1084       break;
1085     case 5:
1086       if (LUT == NULL)
1087         LUT = vtkLookupTable::New();
1088       LUT->SetValueRange(0.,1);
1089       LUT->SetSaturationRange(1,1);
1090       LUT->SetHueRange(1,0.1);
1091       //LUT->SetRampToLinear();
1092       break;
1093     }
1094   if (LUT)
1095     {
1096       LUT->SetTableRange(level-fabs(window)/4,level+fabs(window)/4);
1097       LUT->Build();
1098     }
1099   vtkLookupTable* fusLUT = NULL;
1100   if (mSlicers[0]->GetFusion())
1101     {
1102       fusLUT = vtkLookupTable::New();
1103       double fusRange [2];
1104       fusRange[0] = mFusionLevel - mFusionWindow/2;
1105       fusRange[1] = mFusionLevel + mFusionWindow/2;
1106       fusLUT->SetTableRange(fusRange[0],fusRange[1]);
1107       fusLUT->SetValueRange(1,1);
1108       fusLUT->SetSaturationRange(1,1);
1109       if (mFusionColorMap == 1)
1110         fusLUT->SetHueRange(0,0.18);
1111       else if (mFusionColorMap == 2)
1112         fusLUT->SetHueRange(0.4,0.80);
1113       else if (mFusionColorMap == 3)
1114         fusLUT->SetHueRange(0,1);
1115       fusLUT->Build();
1116       if (mFusionColorMap == 0)
1117         fusLUT = NULL;
1118     }
1119   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
1120     if (mSlicers[i]->GetOverlay() && mSlicers[i]->GetOverlayActor()->GetVisibility()) {
1121       vtkLookupTable* supLUT = vtkLookupTable::New();
1122       supLUT->SetTableRange(range[0],range[1]);
1123       supLUT->SetValueRange(1,1);
1124       supLUT->SetSaturationRange(1,1);
1125       supLUT->SetHueRange(double(mOverlayColor)/360,double(mOverlayColor)/360);
1126       supLUT->Build();
1127       vtkLookupTable* invLUT = vtkLookupTable::New();
1128       invLUT->SetTableRange(range[0],range[1]);
1129       invLUT->SetValueRange(1,1);
1130       invLUT->SetSaturationRange(1,1);
1131       invLUT->SetHueRange(double((mOverlayColor+180)%360)/360,double((mOverlayColor+180)%360)/360);
1132       invLUT->Build();
1133       dynamic_cast<vvImageMapToWLColors*>(mSlicers[i]->GetWindowLevel())
1134         ->SetWindowLevelMode(true);
1135       mSlicers[i]->GetWindowLevel()->SetLookupTable(supLUT);
1136       mSlicers[i]->GetOverlayMapper()->SetLookupTable(invLUT);
1137       invLUT->Delete();
1138       supLUT->Delete();
1139     }
1140     else if (mSlicers[i]->GetOverlay())
1141       {
1142         //dynamic_cast<vvImageMapToWLColors*>(mSlicers[i]->GetWindowLevel())
1143         //->SetWindowLevelMode(false);
1144         mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT);
1145       }
1146     else
1147       {
1148         mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT);
1149       }
1150     if (mSlicers[i]->GetFusion() && mSlicers[i]->GetFusionActor()->GetVisibility())
1151       {
1152         mSlicers[i]->GetFusionActor()->SetOpacity(double(mFusionOpacity)/100);
1153         mSlicers[i]->GetFusionMapper()->SetLookupTable(fusLUT);
1154       }
1155   }
1156   if (fusLUT)
1157     fusLUT->Delete();
1158   if (colormap >= 0)
1159     mColorMap = colormap;
1160 }
1161 //----------------------------------------------------------------------------
1162
1163
1164 //----------------------------------------------------------------------------
1165 vvLandmarks* vvSlicerManager::GetLandmarks()
1166 {
1167   if (mLandmarks == NULL)
1168     {
1169       mLandmarks = new vvLandmarks(mSlicers[0]->GetTMax()+1);
1170       for (unsigned int i = 0; i < mSlicers.size(); i++)
1171         mSlicers[i]->SetLandmarks(mLandmarks);
1172     }
1173   return mLandmarks;
1174 }
1175 //----------------------------------------------------------------------------
1176
1177
1178 //----------------------------------------------------------------------------
1179 void vvSlicerManager::AddLandmark(float x,float y,float z,float t)
1180 {
1181   double x_index = (x - mSlicers[0]->GetInput()->GetOrigin()[0])/mSlicers[0]->GetInput()->GetSpacing()[0];
1182   double y_index = (y - mSlicers[0]->GetInput()->GetOrigin()[1])/mSlicers[0]->GetInput()->GetSpacing()[1];
1183   double z_index = (z - mSlicers[0]->GetInput()->GetOrigin()[2])/mSlicers[0]->GetInput()->GetSpacing()[2];
1184   double value = mSlicers[0]->GetInput()->GetScalarComponentAsDouble(
1185                                                                      (int)x_index,
1186                                                                      (int)y_index,
1187                                                                      (int)z_index,0);
1188   this->GetLandmarks()->AddLandmark(x,y,z,t,value);
1189   emit LandmarkAdded();
1190 }
1191 //----------------------------------------------------------------------------