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               // DD("UpdateViews::");
 639               // DD(i);
 640               UpdateSlice(i);
 641               UpdateTSlice(i);
 642             }
 643         }
 644     }
 645 }
 646 //----------------------------------------------------------------------------
 647
 648
 649 //----------------------------------------------------------------------------
 650 void vvSlicerManager::UpdateLinked(int slicer)
 651 {
 652   double x = (mSlicers[slicer]->GetCurrentPosition()[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0])
 653     /mSlicers[slicer]->GetInput()->GetSpacing()[0];
 654   double y = (mSlicers[slicer]->GetCurrentPosition()[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1])
 655     /mSlicers[slicer]->GetInput()->GetSpacing()[1];
 656   double z = (mSlicers[slicer]->GetCurrentPosition()[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2])
 657     /mSlicers[slicer]->GetInput()->GetSpacing()[2];
 658
 659   if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] &&
 660       x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] &&
 661       y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&
 662       y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&
 663       z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&
 664       z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5])
 665     {
 666       for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++)
 667         {
 668           emit UpdateLinkManager(*i, slicer,mSlicers[slicer]->GetCurrentPosition()[0],
 669                                  mSlicers[slicer]->GetCurrentPosition()[1],
 670                                  mSlicers[slicer]->GetCurrentPosition()[2],mSlicers[slicer]->GetTSlice());
 671         }
 672     }
 673 }
 674 //----------------------------------------------------------------------------
 675
 676
 677 //----------------------------------------------------------------------------
 678 double vvSlicerManager::GetColorWindow()
 679 {
 680   if (mSlicers.size())
 681     return mSlicers[0]->GetColorWindow();
 682   return -1;
 683 }
 684 //----------------------------------------------------------------------------
 685
 686
 687 //----------------------------------------------------------------------------
 688 double vvSlicerManager::GetColorLevel()
 689 {
 690   if (mSlicers.size())
 691     return mSlicers[0]->GetColorLevel();
 692   return -1;
 693 }
 694 //----------------------------------------------------------------------------
 695
 696
 697 //----------------------------------------------------------------------------
 698 void vvSlicerManager::Render()
 699 {
 700   for ( unsigned int i = 0; i < mSlicers.size(); i++)
 701     {
 702       mSlicers[i]->Render();
 703     }
 704 }
 705 //----------------------------------------------------------------------------
 706
 707
 708 //----------------------------------------------------------------------------
 709 void vvSlicerManager::GenerateDefaultLookupTable()
 710 {
 711   SetPreset(mPreset);
 712   SetColorMap(mColorMap);
 713 }
 714 //----------------------------------------------------------------------------
 715
 716
 717 //----------------------------------------------------------------------------
 718 void vvSlicerManager::Reload()
 719 {
 720   mReader->Update(mType);
 721   mImage=mReader->GetOutput();
 722   for ( unsigned int i = 0; i < mSlicers.size(); i++)
 723     {
 724       mSlicers[i]->SetImage(mImage);
 725     }
 726 }
 727 //----------------------------------------------------------------------------
 728
 729
 730 //----------------------------------------------------------------------------
 731 void vvSlicerManager::ReloadFusion()
 732 {
 733   mFusionReader->Update();
 734   for ( unsigned int i = 0; i < mSlicers.size(); i++)
 735     {
 736       mSlicers[i]->SetFusion(mFusionReader->GetOutput());
 737       mSlicers[i]->Render();
 738     }
 739 }
 740 //----------------------------------------------------------------------------
 741
 742
 743 //----------------------------------------------------------------------------
 744 void vvSlicerManager::ReloadOverlay()
 745 {
 746   mOverlayReader->Update();
 747   for ( unsigned int i = 0; i < mSlicers.size(); i++)
 748     {
 749       mSlicers[i]->SetOverlay(mOverlayReader->GetOutput());
 750       mSlicers[i]->Render();
 751     }
 752 }
 753 //----------------------------------------------------------------------------
 754
 755
 756 //----------------------------------------------------------------------------
 757 void vvSlicerManager::ReloadVF()
 758 {
 759   mVectorReader->Update(VECTORFIELD); //deletes the old images through the VF::Init() function
 760   mVF=mVectorReader->GetOutput();
 761   for ( unsigned int i = 0; i < mSlicers.size(); i++)
 762     {
 763       mSlicers[i]->SetVF(mVF);
 764       mSlicers[i]->Render();
 765     }
 766 }
 767 //----------------------------------------------------------------------------
 768
 769
 770 //----------------------------------------------------------------------------
 771 void vvSlicerManager::RemoveActor(const std::string& actor_type, int overlay_index)
 772 {
 773   for (unsigned int i = 0; i < mSlicers.size();i++)
 774     {
 775       mSlicers[i]->RemoveActor(actor_type,overlay_index);
 776     }
 777   if (actor_type=="vector")
 778     {
 779       mVF=NULL;
 780       if (mVectorReader) {
 781         delete mVectorReader;
 782         mVectorReader=NULL;
 783       }
 784     }
 785 }
 786 //----------------------------------------------------------------------------
 787
 788
 789 //----------------------------------------------------------------------------
 790 void vvSlicerManager::RemoveActors()
 791 {
 792   ///This method leaks a few objects. See RemoveActor for what a correct implementation would look like
 793   for ( unsigned int i = 0; i < mSlicers.size(); i++)
 794     {
 795       mSlicers[i]->SetDisplayMode(0);
 796       mSlicers[i]->GetRenderer()->RemoveActor(mSlicers[i]->GetImageActor());
 797     }
 798 }
 799 //----------------------------------------------------------------------------
 800
 801
 802 //----------------------------------------------------------------------------
 803 void vvSlicerManager::UpdateInfoOnCursorPosition(int slicer)
 804 {
 805   //  int view = mSlicers[slicer]->GetSliceOrientation();
 806   //  int slice = mSlicers[slicer]->GetSlice();
 807   double x = mSlicers[slicer]->GetCursorPosition()[0];
 808   double y = mSlicers[slicer]->GetCursorPosition()[1];
 809   double z = mSlicers[slicer]->GetCursorPosition()[2];
 810   double X = (x - mSlicers[slicer]->GetInput()->GetOrigin()[0])/
 811     mSlicers[slicer]->GetInput()->GetSpacing()[0];
 812   double Y = (y - mSlicers[slicer]->GetInput()->GetOrigin()[1])/
 813     mSlicers[slicer]->GetInput()->GetSpacing()[1];
 814   double Z = (z - mSlicers[slicer]->GetInput()->GetOrigin()[2])/
 815     mSlicers[slicer]->GetInput()->GetSpacing()[2];
 816   double value = -VTK_DOUBLE_MAX;
 817   int displayVec = 0;
 818   double xVec=0, yVec=0, zVec=0, valueVec=0;
 819   int displayOver = 0;
 820   int displayFus = 0;
 821   double valueOver=0, valueFus=0;
 822   if (X >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] &&
 823       X <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] &&
 824       Y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&
 825       Y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&
 826       Z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&
 827       Z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5])
 828     {
 829       value = mSlicers[slicer]->GetInput()->GetScalarComponentAsDouble(
 830                                                                        (int)floor(X),
 831                                                                        (int)floor(Y),
 832                                                                        (int)floor(Z),0);
 833       if (mSlicers[slicer]->GetVFActor() && mSlicers[slicer]->GetVFActor()->GetVisibility())
 834         {
 835           displayVec = 1;
 836           unsigned int currentTime = mSlicers[slicer]->GetTSlice();
 837           vtkImageData *vf = NULL;
 838
 839           if (mSlicers[slicer]->GetVF()->GetVTKImages().size() > currentTime)
 840             vf = mSlicers[slicer]->GetVF()->GetVTKImages()[currentTime];
 841           else
 842             vf = mSlicers[slicer]->GetVF()->GetVTKImages()[0];
 843
 844           if (vf)
 845             {
 846               double Xvf = (x - vf->GetOrigin()[0])/ vf->GetSpacing()[0];
 847               double Yvf = (y - vf->GetOrigin()[1])/ vf->GetSpacing()[1];
 848               double Zvf = (z - vf->GetOrigin()[2])/ vf->GetSpacing()[2];
 849               xVec = vf->GetScalarComponentAsDouble( (int)floor(Xvf), (int)floor(Yvf), (int)floor(Zvf),0);
 850               yVec = vf->GetScalarComponentAsDouble( (int)floor(Xvf), (int)floor(Yvf), (int)floor(Zvf),1);
 851               zVec = vf->GetScalarComponentAsDouble( (int)floor(Xvf), (int)floor(Yvf), (int)floor(Zvf),2);
 852               valueVec = sqrt(xVec*xVec + yVec*yVec + zVec*zVec);
 853             }
 854         }
 855       if (mSlicers[slicer]->GetOverlayActor() && mSlicers[slicer]->GetOverlayActor()->GetVisibility())
 856         {
 857           displayOver = 1;
 858           double Xover = (x - mSlicers[slicer]->GetOverlay()->GetOrigin()[0])
 859             /mSlicers[slicer]->GetOverlay()->GetSpacing()[0];
 860           double Yover = (y - mSlicers[slicer]->GetOverlay()->GetOrigin()[1])
 861             /mSlicers[slicer]->GetOverlay()->GetSpacing()[1];
 862           double Zover = (z - mSlicers[slicer]->GetOverlay()->GetOrigin()[2])
 863             /mSlicers[slicer]->GetOverlay()->GetSpacing()[2];
 864           if (Xover >= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[0] &&
 865               Xover <= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[1] &&
 866               Yover >= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[2] &&
 867               Yover <= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[3] &&
 868               Zover >= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[4] &&
 869               Zover <= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[5])
 870             {
 871               valueOver = static_cast<vtkImageData*>(mSlicers[slicer]->GetOverlayMapper()->GetInput())->
 872                 GetScalarComponentAsDouble(
 873                                            (int)floor(Xover),
 874                                            (int)floor(Yover),
 875                                            (int)floor(Zover),0);
 876             }
 877         }
 878       if (mSlicers[slicer]->GetFusionActor() && mSlicers[slicer]->GetFusionActor()->GetVisibility())
 879         {
 880           displayFus = 1;
 881           double Xfus = (x - mSlicers[slicer]->GetFusion()->GetOrigin()[0])
 882             /mSlicers[slicer]->GetFusion()->GetSpacing()[0];
 883           double Yfus = (y - mSlicers[slicer]->GetFusion()->GetOrigin()[1])
 884             /mSlicers[slicer]->GetFusion()->GetSpacing()[1];
 885           double Zfus = (z - mSlicers[slicer]->GetFusion()->GetOrigin()[2])
 886             /mSlicers[slicer]->GetFusion()->GetSpacing()[2];
 887           if (Xfus >= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[0] &&
 888               Xfus <= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[1] &&
 889               Yfus >= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[2] &&
 890               Yfus <= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[3] &&
 891               Zfus >= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[4] &&
 892               Zfus <= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[5])
 893             {
 894               valueFus = static_cast<vtkImageData*>(mSlicers[slicer]->GetFusionMapper()->GetInput())->
 895                 GetScalarComponentAsDouble(
 896                                            (int)floor(Xfus),
 897                                            (int)floor(Yfus),
 898                                            (int)floor(Zfus),0);
 899             }
 900         }
 901       emit UpdatePosition(mSlicers[slicer]->GetCursorVisibility(),
 902                           x,y,z,X,Y,Z,value);
 903       emit UpdateVector(displayVec,xVec, yVec, zVec, valueVec);
 904       emit UpdateOverlay(displayOver,valueOver,value);
 905       emit UpdateFusion(displayFus,valueFus);
 906       for (unsigned int i = 0; i < mSlicers.size(); i++)
 907         {
 908           if (mSlicers[i]->GetImageActor()->GetVisibility() == 1)
 909             emit UpdateWindows(i,mSlicers[i]->GetSliceOrientation(),mSlicers[i]->GetSlice());
 910           else
 911             emit UpdateWindows(i,-1,-1);
 912         }
 913     }
 914 }
 915 //----------------------------------------------------------------------------
 916
 917
 918 //----------------------------------------------------------------------------
 919 void vvSlicerManager::Activated()
 920 {
 921   emit currentImageChanged(mId);
 922 }
 923 //----------------------------------------------------------------------------
 924
 925
 926 //----------------------------------------------------------------------------
 927 void vvSlicerManager::UpdateWindowLevel()
 928 {
 929   emit WindowLevelChanged(mSlicers[0]->GetColorWindow(),mSlicers[0]->GetColorLevel(),mPreset,mColorMap);
 930 }
 931 //----------------------------------------------------------------------------
 932
 933
 934 //----------------------------------------------------------------------------
 935 void vvSlicerManager::UpdateSlice(int slicer)
 936 {
 937   // DD("vvSlicerManager::UpdateSlice emit UpdateSlice");
 938   // DD(slicer);
 939   // DD(mSlicers[slicer]->GetSlice());
 940   emit UpdateSlice(slicer, mSlicers[slicer]->GetSlice());
 941 }
 942 //----------------------------------------------------------------------------
 943
 944
 945 //----------------------------------------------------------------------------
 946 void vvSlicerManager::UpdateTSlice(int slicer)
 947 {
 948   emit UpdateTSlice(slicer,mSlicers[0]->GetTSlice());
 949 }
 950 //----------------------------------------------------------------------------
 951
 952
 953 //----------------------------------------------------------------------------
 954 void vvSlicerManager::UpdateSliceRange(int slicer)
 955 {
 956   emit UpdateSliceRange(slicer,
 957                         mSlicers[slicer]->GetSliceRange()[0], mSlicers[slicer]->GetSliceRange()[1],
 958                         0,mSlicers[slicer]->GetTMax());
 959 }
 960 //----------------------------------------------------------------------------
 961
 962
 963 //----------------------------------------------------------------------------
 964 void vvSlicerManager::SetPreset(int preset)
 965 {
 966   //vtkLookupTable* LUT = static_cast<vtkLookupTable*>(mSlicers[0]->GetWindowLevel()->GetLookupTable());
 967   double window = mSlicers[0]->GetColorWindow();
 968   double level = mSlicers[0]->GetColorLevel();
 969
 970   std::string component_type=mImage->GetScalarTypeAsString();
 971   switch (preset)
 972     {
 973     case 0:
 974       if (component_type == "unsigned_char")
 975         {
 976           window = 255;
 977           level = 127;
 978         }
 979       else if (component_type == "short")
 980         {
 981           window = 2000;
 982           level = 0;
 983         }
 984       else
 985         {
 986           double range[2];
 987           mImage->GetScalarRange(range);
 988           window = range[1] - range[0];
 989           level = (range[1] + range[0])* 0.5;
 990         }
 991       break;
 992     case 1:
 993       window = 2000;
 994       level = 0;
 995       break;
 996     case 2:
 997       window = 350;
 998       level = 60;
 999       break;
1000     case 3:
1001       window = 1500;
1002       level = -500;
1003       break;
1004     case 4:
1005       window = 1000;
1006       level = 500;
1007       break;
1008     case 5:
1009       window = 1;
1010       level = 0.5;
1011       break;
1012     case 6:
1013       break;
1014     case 7:
1015       window=1.;
1016       level=0.;
1017       break;
1018     }
1019   mPreset = preset;
1020   this->SetColorWindow(window);
1021   this->SetColorLevel(level);
1022
1023   //if (LUT)
1024   //{
1025   //    SetColorMap(-1);
1026   //}
1027 }
1028 //----------------------------------------------------------------------------
1029
1030
1031 //----------------------------------------------------------------------------
1032 void vvSlicerManager::SetLocalColorWindowing(const int slicer)
1033 {
1034   double min, max;
1035   this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max);
1036   this->SetColorWindow(max-min);
1037   this->SetColorLevel(0.5*(min+max));
1038   this->Render();
1039 }
1040 //----------------------------------------------------------------------------
1041
1042
1043 //----------------------------------------------------------------------------
1044 void vvSlicerManager::SetColorMap()
1045 {
1046   SetColorMap(mColorMap);
1047 }
1048 //----------------------------------------------------------------------------
1049
1050
1051 //----------------------------------------------------------------------------
1052 void vvSlicerManager::SetColorMap(int colormap)
1053 {
1054   double range[2];
1055   range[0] = mSlicers[0]->GetInput()->GetScalarRange()[0];
1056   range[1] = mSlicers[0]->GetInput()->GetScalarRange()[1];
1057
1058   double window = mSlicers[0]->GetWindowLevel()->GetWindow();
1059   double level = mSlicers[0]->GetWindowLevel()->GetLevel();
1060
1061   vtkLookupTable* LUT = static_cast<vtkLookupTable*>(mSlicers[0]->GetWindowLevel()->GetLookupTable());
1062   switch (colormap)
1063     {
1064     case -1:
1065       break;
1066     case 0:
1067       LUT = NULL;
1068       break;
1069     case 1:
1070       if (LUT == NULL)
1071         LUT = vtkLookupTable::New();
1072       LUT->SetValueRange(0,1);
1073       LUT->SetSaturationRange(1,1);
1074       LUT->SetHueRange(0,0.18);
1075       break;
1076     case 2:
1077       if (LUT == NULL)
1078         LUT = vtkLookupTable::New();
1079       LUT->SetValueRange(0,1);
1080       LUT->SetSaturationRange(1,1);
1081       LUT->SetHueRange(0.4,0.80);
1082       break;
1083     case 3:
1084       if (LUT == NULL)
1085         LUT = vtkLookupTable::New();
1086       LUT->SetValueRange(0,1);
1087       LUT->SetSaturationRange(1,1);
1088       LUT->SetHueRange(0,1);
1089       break;
1090     case 5:
1091       if (LUT == NULL)
1092         LUT = vtkLookupTable::New();
1093       LUT->SetValueRange(0.,1);
1094       LUT->SetSaturationRange(1,1);
1095       LUT->SetHueRange(1,0.1);
1096       //LUT->SetRampToLinear();
1097       break;
1098     }
1099   if (LUT)
1100     {
1101       LUT->SetTableRange(level-fabs(window)/4,level+fabs(window)/4);
1102       LUT->Build();
1103     }
1104   vtkLookupTable* fusLUT = NULL;
1105   if (mSlicers[0]->GetFusion())
1106     {
1107       fusLUT = vtkLookupTable::New();
1108       double fusRange [2];
1109       fusRange[0] = mFusionLevel - mFusionWindow/2;
1110       fusRange[1] = mFusionLevel + mFusionWindow/2;
1111       fusLUT->SetTableRange(fusRange[0],fusRange[1]);
1112       fusLUT->SetValueRange(1,1);
1113       fusLUT->SetSaturationRange(1,1);
1114       if (mFusionColorMap == 1)
1115         fusLUT->SetHueRange(0,0.18);
1116       else if (mFusionColorMap == 2)
1117         fusLUT->SetHueRange(0.4,0.80);
1118       else if (mFusionColorMap == 3)
1119         fusLUT->SetHueRange(0,1);
1120       fusLUT->Build();
1121       if (mFusionColorMap == 0)
1122         fusLUT = NULL;
1123     }
1124   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
1125     if (mSlicers[i]->GetOverlay() && mSlicers[i]->GetOverlayActor()->GetVisibility()) {
1126       vtkLookupTable* supLUT = vtkLookupTable::New();
1127       supLUT->SetTableRange(range[0],range[1]);
1128       supLUT->SetValueRange(1,1);
1129       supLUT->SetSaturationRange(1,1);
1130       supLUT->SetHueRange(double(mOverlayColor)/360,double(mOverlayColor)/360);
1131       supLUT->Build();
1132       vtkLookupTable* invLUT = vtkLookupTable::New();
1133       invLUT->SetTableRange(range[0],range[1]);
1134       invLUT->SetValueRange(1,1);
1135       invLUT->SetSaturationRange(1,1);
1136       invLUT->SetHueRange(double((mOverlayColor+180)%360)/360,double((mOverlayColor+180)%360)/360);
1137       invLUT->Build();
1138       dynamic_cast<vvImageMapToWLColors*>(mSlicers[i]->GetWindowLevel())
1139         ->SetWindowLevelMode(true);
1140       mSlicers[i]->GetWindowLevel()->SetLookupTable(supLUT);
1141       mSlicers[i]->GetOverlayMapper()->SetLookupTable(invLUT);
1142       invLUT->Delete();
1143       supLUT->Delete();
1144     }
1145     else if (mSlicers[i]->GetOverlay())
1146       {
1147         //dynamic_cast<vvImageMapToWLColors*>(mSlicers[i]->GetWindowLevel())
1148         //->SetWindowLevelMode(false);
1149         mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT);
1150       }
1151     else
1152       {
1153         mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT);
1154       }
1155     if (mSlicers[i]->GetFusion() && mSlicers[i]->GetFusionActor()->GetVisibility())
1156       {
1157         mSlicers[i]->GetFusionActor()->SetOpacity(double(mFusionOpacity)/100);
1158         mSlicers[i]->GetFusionMapper()->SetLookupTable(fusLUT);
1159       }
1160   }
1161   if (fusLUT)
1162     fusLUT->Delete();
1163   if (colormap >= 0)
1164     mColorMap = colormap;
1165 }
1166 //----------------------------------------------------------------------------
1167
1168
1169 //----------------------------------------------------------------------------
1170 vvLandmarks* vvSlicerManager::GetLandmarks()
1171 {
1172   if (mLandmarks == NULL)
1173     {
1174       mLandmarks = new vvLandmarks(mSlicers[0]->GetTMax()+1);
1175       for (unsigned int i = 0; i < mSlicers.size(); i++)
1176         mSlicers[i]->SetLandmarks(mLandmarks);
1177     }
1178   return mLandmarks;
1179 }
1180 //----------------------------------------------------------------------------
1181
1182
1183 //----------------------------------------------------------------------------
1184 void vvSlicerManager::AddLandmark(float x,float y,float z,float t)
1185 {
1186   double x_index = (x - mSlicers[0]->GetInput()->GetOrigin()[0])/mSlicers[0]->GetInput()->GetSpacing()[0];
1187   double y_index = (y - mSlicers[0]->GetInput()->GetOrigin()[1])/mSlicers[0]->GetInput()->GetSpacing()[1];
1188   double z_index = (z - mSlicers[0]->GetInput()->GetOrigin()[2])/mSlicers[0]->GetInput()->GetSpacing()[2];
1189   double value = mSlicers[0]->GetInput()->GetScalarComponentAsDouble(
1190                                                                      (int)x_index,
1191                                                                      (int)y_index,
1192                                                                      (int)z_index,0);
1193   this->GetLandmarks()->AddLandmark(x,y,z,t,value);
1194   emit LandmarkAdded();
1195 }
1196 //----------------------------------------------------------------------------