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 "vvMesh.h"
  26 #include "vvBlendImageActor.h"
  27
  28 #include <vtkVersion.h>
  29 #include <vtkStreamingDemandDrivenPipeline.h>
  30 #include <vtkInformation.h>
  31 #include <vtkImageActor.h>
  32 #include <vtkImageData.h>
  33 #include <vtkRenderWindow.h>
  34 #include <vtkRendererCollection.h>
  35 #include <vtkRenderWindowInteractor.h>
  36 #include <vtkImageMapToWindowLevelColors.h>
  37 #include <vtkWindowLevelLookupTable.h>
  38 #include <vtkColorTransferFunction.h>
  39 #include <vtkImageClip.h>
  40 #include <vtkLODActor.h>
  41 #include <vtkPointData.h>
  42 #include <vtksys/SystemTools.hxx>
  43 #include <vtkCamera.h>
  44
  45 #include <qfileinfo.h>
  46 #include <QMessageBox>
  47 //----------------------------------------------------------------------------
  48 vvSlicerManager::vvSlicerManager(int numberOfSlicers)
  49 {
  50
  51   connect(this, SIGNAL(callAddLandmark(float,float,float,float)), this, SLOT(AddLandmark(float,float,float,float)));
  52
  53   mFileName = "";
  54   mId = "";
  55   mVFName = "";
  56   mOverlayName = "";
  57   mFusionName = "";
  58   mVFId = "";
  59   mLastError = "";
  60   mType = vvImageReader::UNDEFINEDIMAGETYPE;
  61   mColorMap = 0;
  62   mPreset = 0;
  63   mOverlayColor = 130;
  64
  65   mFusionOpacity = 30;
  66   mFusionThresOpacity = 1;
  67   mFusionColorMap = 3;
  68   mFusionWindow = 1000;
  69   mFusionLevel = 1000;
  70   mFusionShowLegend = true;
  71
  72   mFusionSequenceInvolvementCode = -1;
  73   mFusionSequenceIndexLinkedManager = -1;
  74   mFusionSequenceFrameIndex = -1;
  75   mFusionSequenceNbFrames = 0;
  76   mFusionSequenceSpatialSyncFlag = false;
  77   mFusionSequenceTemporalSyncFlag = false;
  78
  79   mLandmarks = NULL;
  80   mLinkedId.resize(0);
  81
  82   for ( int i = 0; i < numberOfSlicers; i++) {
  83     mSlicers.push_back(vtkSmartPointer<vvSlicer>::New());
  84     mSlicers[i]->SetSlicerNumber(i);
  85   }
  86   mSelectedSlicer = -1;
  87
  88   mPreviousSlice.resize(numberOfSlicers, 0);
  89   mPreviousTSlice.resize(numberOfSlicers, 0);
  90   mSlicingPreset = WORLD_SLICING;
  91
  92
  93 }
  94 //----------------------------------------------------------------------------
  95
  96
  97 //----------------------------------------------------------------------------
  98 vvSlicerManager::~vvSlicerManager()
  99 {
 100   if (mLandmarks)
 101     delete mLandmarks;
 102 }
 103 //----------------------------------------------------------------------------
 104
 105
 106 //------------------------------------------------------------------------------
 107 void vvSlicerManager::SetFilename(std::string filename, int number)
 108 {
 109   mFileName = filename;
 110   mFileName = vtksys::SystemTools::GetFilenameName(mFileName);
 111   mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));
 112   mBaseFileNameNumber = number;
 113
 114   mFileName = mBaseFileName;
 115   if (number != 0) {
 116     mFileName.append("_"+clitk::toString(number));
 117   }
 118   mFileName.append(vtksys::SystemTools::GetFilenameLastExtension(filename));
 119
 120   for(unsigned int i=0; i<mSlicers.size(); i++) {
 121     mSlicers[i]->SetFileName(mFileName);//vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));
 122   }
 123
 124 }
 125 //------------------------------------------------------------------------------
 126
 127
 128 //----------------------------------------------------------------------------
 129 void vvSlicerManager::AddContour(vvMesh::Pointer contour,bool propagate)
 130 {
 131   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 132     mSlicers[i]->AddContour(contour,propagate);
 133   }
 134 }
 135 //----------------------------------------------------------------------------
 136
 137
 138 //----------------------------------------------------------------------------
 139 void vvSlicerManager::ToggleContourSuperposition()
 140 {
 141   for ( unsigned int i = 0; i < mSlicers.size(); i++)
 142     mSlicers[i]->ToggleContourSuperposition();
 143 }
 144 //----------------------------------------------------------------------------
 145
 146 //----------------------------------------------------------------------------
 147 std::string vvSlicerManager::GetListOfAbsoluteFilePathInOneString(const std::string &actorType)
 148 {
 149   vvImageReader *reader = NULL;
 150
 151   if(actorType=="image")
 152     reader = mReader;
 153   else if(actorType=="overlay")
 154     reader = mOverlayReader;
 155   else if(actorType=="fusion")
 156     reader = mFusionReader;
 157   else if(actorType=="vector")
 158     reader = mVectorReader;
 159   else if(actorType=="fusionSequence")
 160         reader = mFusionSequenceReader;
 161
 162   if(!reader)
 163     return "";
 164
 165   std::string list;
 166   for(unsigned int i=0; i<reader->GetInputFilenames().size(); i++){
 167     QFileInfo fileinfo(reader->GetInputFilenames()[i].c_str()); //Do not show the path
 168     if(i)
 169       list += '\n';
 170     list += fileinfo.absoluteFilePath().toStdString();
 171   }
 172   return list;
 173 }
 174 //----------------------------------------------------------------------------
 175
 176
 177 //----------------------------------------------------------------------------
 178 bool vvSlicerManager::SetImage(std::string filename, vvImageReader::LoadedImageType type, int n, unsigned int slice)
 179 {
 180   mType = type;
 181   if (mReader.IsNull())
 182     mReader = vvImageReader::New();
 183   std::vector<std::string> filenames;
 184   filenames.push_back(filename);
 185   mReader->SetInputFilenames(filenames);
 186   mReader->SetSlice(slice); // Only used for SLICED type
 187   mReader->Update(type);
 188
 189   SetFilename(filename, n);
 190   //  mFileName = vtksys::SystemTools::GetFilenameName(mFileName);
 191   //mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));
 192   //mBaseFileNameNumber = n;
 193
 194   if (mReader->GetLastError().size() == 0) {
 195     mImage=mReader->GetOutput();
 196     for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 197       mSlicers[i]->SetFileName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));
 198       mSlicers[i]->SetImage(mReader->GetOutput());
 199     }
 200   } else {
 201     mLastError = mReader->GetLastError();
 202     return false;
 203   }
 204   // if (n!=0) {
 205   //   mFileName.append("_"+clitk::toString(n));
 206   // }
 207   return true;
 208 }
 209 //----------------------------------------------------------------------------
 210
 211
 212 //----------------------------------------------------------------------------
 213 void vvSlicerManager::SetImage(vvImage::Pointer image)
 214 {
 215   mImage=image;
 216   for (unsigned int i = 0; i < mSlicers.size(); i++) {
 217     mSlicers[i]->SetImage(image);
 218   }
 219 }
 220 //----------------------------------------------------------------------------
 221
 222
 223 //----------------------------------------------------------------------------
 224 bool vvSlicerManager::SetImages(std::vector<std::string> filenames, vvImageReader::LoadedImageType type, int n)
 225 {
 226   mType = type;
 227   std::string fileWithoutExtension = vtksys::SystemTools::GetFilenameWithoutExtension(filenames[0]);
 228   if (type == vvImageReader::DICOM)
 229     fileWithoutExtension += "_dicom";
 230   else if (type == vvImageReader::MERGED)
 231     fileWithoutExtension += "_merged";
 232   else if (type == vvImageReader::MERGEDWITHTIME)
 233     fileWithoutExtension += "_merged_wt";
 234
 235   mFileName = vtksys::SystemTools::GetFilenameName(mFileName);
 236   mFileName = fileWithoutExtension + vtksys::SystemTools::GetFilenameExtension(filenames[0]);
 237   if (mReader.IsNull())
 238     mReader = vvImageReader::New();
 239   mReader->SetInputFilenames(filenames);
 240   mReader->Update(type);
 241
 242   mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));
 243   mBaseFileNameNumber = n;
 244
 245   if (mReader->GetLastError().size() == 0) {
 246     mImage=mReader->GetOutput();
 247     for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 248       mSlicers[i]->SetFileName(fileWithoutExtension);
 249       mSlicers[i]->SetImage(mReader->GetOutput());
 250     }
 251   } else {
 252     mLastError = mReader->GetLastError();
 253     return false;
 254   }
 255   if (n!=0) {
 256     mFileName.append("_"+clitk::toString(n));
 257   }
 258   return true;
 259 }
 260 //----------------------------------------------------------------------------
 261
 262
 263 //----------------------------------------------------------------------------
 264 bool vvSlicerManager::SetOverlay(std::vector<std::string> filenames,int dim, std::string component, vvImageReader::LoadedImageType type)
 265 {
 266   mOverlayName = filenames[0];
 267   mOverlayComponent = component;
 268   if (dim > mImage->GetNumberOfDimensions()) {
 269     mLastError = " Overlay dimension cannot be greater than reference image!";
 270     return false;
 271   }
 272   if (mOverlayReader.IsNull())
 273     mOverlayReader = vvImageReader::New();
 274   mOverlayReader->SetInputFilenames(filenames);
 275   mOverlayReader->Update(type);
 276   if (mOverlayReader->GetLastError().size() == 0) {
 277     for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 278       mSlicers[i]->SetOverlay(mOverlayReader->GetOutput());
 279     }
 280   } else {
 281     mLastError = mOverlayReader->GetLastError();
 282     return false;
 283   }
 284   return true;
 285 }
 286 //----------------------------------------------------------------------------
 287
 288
 289 //----------------------------------------------------------------------------
 290 bool vvSlicerManager::SetFusion(std::vector<std::string> filenames,int dim, std::string component, vvImageReader::LoadedImageType type)
 291 {
 292   mFusionName = filenames[0];
 293   mFusionComponent = component;
 294   if (dim > mImage->GetNumberOfDimensions()) {
 295     mLastError = " Fusion dimension cannot be greater than reference image!";
 296     return false;
 297   }
 298   if (mFusionReader.IsNull())
 299     mFusionReader = vvImageReader::New();
 300   mFusionReader->SetInputFilenames(filenames);
 301   mFusionReader->Update(type);
 302   if (mFusionReader->GetLastError().size() == 0) {
 303     for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 304       mSlicers[i]->SetFusion(mFusionReader->GetOutput());
 305     }
 306   } else {
 307     mLastError = mFusionReader->GetLastError();
 308     return false;
 309   }
 310   double *fusRange = mFusionReader->GetOutput()->GetVTKImages()[0]->GetScalarRange();
 311   mFusionLevel = (fusRange[0]+fusRange[1])/2;
 312   mFusionWindow = fusRange[1]-fusRange[0];
 313
 314   return true;
 315 }
 316 //----------------------------------------------------------------------------
 317
 318 //----------------------------------------------------------------------------
 319 //this function is called by vvMainWindow::AddFusionSequence for the primary sequence (CT), while the given files constitute the secondary sequence.
 320 bool vvSlicerManager::SetFusionSequence(std::vector<std::string> filenames, int dim, std::string component, vvImageReader::LoadedImageType type)
 321 {
 322         mFusionSequenceInvolvementCode = 0;
 323
 324         mFusionName = filenames[0];
 325         mFusionComponent = component;
 326
 327         if (dim > mImage->GetNumberOfDimensions()) {
 328                 mLastError = " Fusion Sequence dimension cannot be greater than reference image!";
 329                 return false;
 330         }
 331
 332         if (mFusionSequenceReader.IsNull())
 333                 mFusionSequenceReader = vvImageReader::New();
 334
 335         mFusionSequenceReader->SetInputFilenames(filenames);
 336         mFusionSequenceReader->Update(type);
 337
 338
 339         if (mFusionSequenceReader->GetLastError().size() == 0) {
 340                 for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 341                         mSlicers[i]->SetFusion(mFusionSequenceReader->GetOutput(), mFusionSequenceInvolvementCode);
 342                 }
 343         } else {
 344                 mLastError = mFusionSequenceReader->GetLastError();
 345                 return false;
 346         }
 347         double *fusRange = mFusionSequenceReader->GetOutput()->GetVTKImages()[0]->GetScalarRange();
 348         mFusionLevel = (fusRange[0]+fusRange[1])/2;
 349         mFusionWindow = fusRange[1]-fusRange[0];
 350
 351         //store the initial transform matrices of each frame, and reset them to identity
 352         mFusionSequenceListInitialTransformMatrices.clear();
 353         for (unsigned i=0 ; i<mFusionSequenceReader->GetOutput()->GetTransform().size() ; i++) {
 354                 AddFusionSequenceInitialTransformMatrices( mFusionSequenceReader->GetOutput()->GetTransform()[i]->GetMatrix() );
 355                 mFusionSequenceReader->GetOutput()->GetTransform()[i]->Identity();
 356                 mFusionSequenceReader->GetOutput()->GetTransform()[i]->Update();
 357         }
 358
 359         //adjust the time slider in the overlay panel
 360         mFusionSequenceNbFrames = mFusionSequenceReader->GetOutput()->GetTransform().size();
 361         mFusionSequenceFrameIndex = std::max<int>( 0, std::min<int>(mFusionSequenceFrameIndex, mFusionSequenceNbFrames));
 362
 363         return true;
 364 }
 365 //----------------------------------------------------------------------------
 366
 367
 368 //----------------------------------------------------------------------------
 369 bool vvSlicerManager::SetVF(std::string filename)
 370 {
 371   if (mVectorReader.IsNull())
 372     mVectorReader = vvImageReader::New();
 373   mVectorReader->SetInputFilename(filename);
 374
 375   if (mType == vvImageReader::IMAGEWITHTIME)
 376     mVectorReader->Update(vvImageReader::VECTORFIELDWITHTIME);
 377   else
 378     mVectorReader->Update(vvImageReader::VECTORFIELD);
 379   if (mVectorReader->GetLastError().size() != 0) {
 380     mLastError = mVectorReader->GetLastError();
 381     return false;
 382   } else
 383     return SetVF(mVectorReader->GetOutput(),filename);
 384 }
 385 //----------------------------------------------------------------------------
 386
 387
 388 //----------------------------------------------------------------------------
 389 bool vvSlicerManager::SetVF(vvImage::Pointer vf,std::string filename)
 390 {
 391   if (vf->GetNumberOfDimensions() > mImage->GetNumberOfDimensions()) {
 392     mLastError = "Sorry, vector field dimension cannot be greater then reference image.";
 393     return false;
 394   }
 395   if (vf->GetNumberOfDimensions() == 4) {
 396     if (vf->GetSpacing()[3] != mImage->GetSpacing()[3]) {
 397       mLastError = "Sorry, vector field time spacing cannot be different from time spacing of the reference image.";
 398       return false;
 399     }
 400     if (vf->GetOrigin()[3] != mImage->GetOrigin()[3]) {
 401       mLastError = "Sorry, vector field time origin cannot be different from time origin of the reference image.";
 402       return false;
 403     }
 404   }
 405   mVF=vf;
 406   mVFName = filename;
 407   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 408     mSlicers[i]->SetVF(vf);
 409   }
 410   return true;
 411 }
 412 //----------------------------------------------------------------------------
 413
 414
 415 //----------------------------------------------------------------------------
 416 vvSlicer* vvSlicerManager::GetSlicer(int i)
 417 {
 418   return mSlicers[i];
 419 }
 420 //----------------------------------------------------------------------------
 421
 422
 423 //----------------------------------------------------------------------------
 424 void vvSlicerManager::UpdateSlicer(int num, bool state)
 425 {
 426   if (mSlicers[num]->GetImage()) {
 427     mSlicers[num]->SetDisplayMode(state);
 428   }
 429 }
 430 //----------------------------------------------------------------------------
 431
 432
 433 //----------------------------------------------------------------------------
 434 void vvSlicerManager::SetSlicerWindow(int i, vtkRenderWindow* RW)
 435 {
 436   mSlicers[i]->SetRenderWindow(i,RW);
 437 }
 438 //----------------------------------------------------------------------------
 439
 440
 441 //----------------------------------------------------------------------------
 442 void vvSlicerManager::SetInteractorStyleNavigator(int i, vtkInteractorStyle* style)
 443 {
 444   vvSlicerManagerCommand *smc = vvSlicerManagerCommand::New();
 445   smc->SM = this;
 446   smc->SetSlicerNumber(i);
 447   mSlicers[i]->GetRenderWindow()->GetInteractor()->SetInteractorStyle(style);
 448
 449   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 450     GetInteractorStyle()->AddObserver(vtkCommand::KeyPressEvent, smc);
 451   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 452     GetInteractorStyle()->AddObserver(vtkCommand::WindowLevelEvent, smc);
 453   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 454     GetInteractorStyle()->AddObserver(vtkCommand::EndWindowLevelEvent, smc);
 455   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 456     GetInteractorStyle()->AddObserver(vtkCommand::StartWindowLevelEvent, smc);
 457   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 458     GetInteractorStyle()->AddObserver(vtkCommand::PickEvent, smc);
 459   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 460     GetInteractorStyle()->AddObserver(vtkCommand::StartPickEvent, smc);
 461   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 462     GetInteractorStyle()->AddObserver(vtkCommand::LeaveEvent, smc);
 463   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 464     GetInteractorStyle()->AddObserver(vtkCommand::UserEvent, smc);
 465   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 466     GetInteractorStyle()->AddObserver(vtkCommand::MouseWheelForwardEvent, smc);
 467   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 468     GetInteractorStyle()->AddObserver(vtkCommand::MouseWheelBackwardEvent, smc);
 469   // mSlicers[i]->GetRenderWindow()->GetInteractor()->
 470   //   GetInteractorStyle()->AddObserver(vtkCommand::LeftButtonReleaseEvent, smc);
 471   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 472     GetInteractorStyle()->AddObserver(vtkCommand::EndPickEvent, smc);
 473   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 474     GetInteractorStyle()->AddObserver(vtkCommand::EndInteractionEvent, smc);
 475   smc->Delete();
 476 }
 477 //----------------------------------------------------------------------------
 478
 479
 480 //----------------------------------------------------------------------------
 481 void vvSlicerManager::LeftButtonReleaseEvent(int slicer)
 482 {
 483   emit LeftButtonReleaseSignal(slicer);
 484 }
 485 //----------------------------------------------------------------------------
 486
 487
 488 //----------------------------------------------------------------------------
 489 void vvSlicerManager::EmitMousePositionUpdated(int slicer)
 490 {
 491   emit MousePositionUpdatedSignal(slicer);
 492 }
 493 //----------------------------------------------------------------------------
 494
 495
 496 //----------------------------------------------------------------------------
 497 void vvSlicerManager::EmitKeyPressed(std::string KeyPress)
 498 {
 499   emit KeyPressedSignal(KeyPress);
 500 }
 501 //----------------------------------------------------------------------------
 502
 503
 504 //----------------------------------------------------------------------------
 505 void vvSlicerManager::SetSliceOrientation(int slicer, int orientation)
 506 {
 507   mSlicers[slicer]->SetSliceOrientation(orientation);
 508   emit UpdateOrientation(slicer, orientation);
 509 }
 510 //----------------------------------------------------------------------------
 511
 512 //----------------------------------------------------------------------------
 513 int vvSlicerManager::GetTSlice()
 514 {
 515   return mSlicers[0]->GetTSlice();
 516 }
 517 //----------------------------------------------------------------------------
 518
 519 //----------------------------------------------------------------------------
 520 void vvSlicerManager::SetTSlice(int slice, bool updateLinkedImages)
 521 {
 522         if (!updateLinkedImages) { //for fusionSequence, TMax / MaxCurrentTSlice are irrelevant.
 523                 for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 524                         mSlicers[i]->SetTSlice(slice, updateLinkedImages);
 525                         UpdateTSlice(i);
 526                 }
 527                 return;
 528         }
 529
 530   if (slice < 0)
 531     slice = 0;
 532   else if (slice > mSlicers[0]->GetTMax())
 533     slice = mSlicers[0]->GetTMax();
 534   if (mLandmarks)
 535     mLandmarks->SetTime(slice);
 536   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 537     if (slice != mSlicers[i]->GetMaxCurrentTSlice()) {
 538       mSlicers[i]->SetTSlice(slice, updateLinkedImages);
 539       UpdateTSlice(i);
 540     }
 541   }
 542 }
 543 //----------------------------------------------------------------------------
 544
 545
 546 //----------------------------------------------------------------------------
 547 void vvSlicerManager::SetFusionSequenceTSlice(int slice)
 548 {
 549         for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 550                 mSlicers[i]->SetFusionSequenceTSlice(slice);
 551                 UpdateTSlice(i);
 552         }
 553 }
 554 //----------------------------------------------------------------------------
 555
 556
 557 //----------------------------------------------------------------------------
 558 void vvSlicerManager::SetNextTSlice(int originating_slicer)
 559 {
 560   int t = mSlicers[0]->GetMaxCurrentTSlice();
 561   t++;
 562   if (t > mSlicers[0]->GetTMax())
 563     t = 0;
 564   emit UpdateTSlice(originating_slicer,t, mFusionSequenceInvolvementCode);
 565 }
 566 //----------------------------------------------------------------------------
 567
 568
 569 //----------------------------------------------------------------------------
 570 void vvSlicerManager::SetPreviousTSlice(int originating_slicer)
 571 {
 572   int t = mSlicers[0]->GetMaxCurrentTSlice();
 573   t--;
 574   if (t < 0)
 575     t = mSlicers[0]->GetTMax();
 576   emit UpdateTSlice(originating_slicer,t, mFusionSequenceInvolvementCode);
 577 }
 578 //----------------------------------------------------------------------------
 579
 580
 581 //----------------------------------------------------------------------------
 582 void vvSlicerManager::ToggleInterpolation()
 583 {
 584   bool interpolate=!(mSlicers[0]->GetImageActor()->GetInterpolate());
 585   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 586     mSlicers[i]->GetImageActor()->SetInterpolate(interpolate);
 587     if (mSlicers[i]->GetOverlayActor())
 588       mSlicers[i]->GetOverlayActor()->SetInterpolate(interpolate);
 589     if (mSlicers[i]->GetFusionActor())
 590       mSlicers[i]->GetFusionActor()->SetInterpolate(interpolate);
 591   }
 592 }
 593 //----------------------------------------------------------------------------
 594
 595
 596 //----------------------------------------------------------------------------
 597 void vvSlicerManager::SetTSliceInSlicer(int tslice, int slicer)
 598 {
 599   if (tslice < 0)
 600     tslice = 0;
 601   else if (tslice > mSlicers[slicer]->GetTMax())
 602     tslice = mSlicers[slicer]->GetTMax();
 603   if (mLandmarks)
 604     mLandmarks->SetTime(tslice);
 605
 606   if (mSlicers[slicer]->GetMaxCurrentTSlice() == tslice) return;
 607
 608   mSlicers[slicer]->SetTSlice(tslice);
 609
 610   if(mSlicingPreset==VOXELS_SLICING) {
 611     vtkMatrix4x4 *imageTransformInverse = vtkMatrix4x4::New();
 612     mImage->GetTransform()[mSlicers[slicer]->GetTSlice()]->GetInverse(imageTransformInverse);
 613     this->GetSlicer(slicer)->GetSlicingTransform()->SetMatrix(imageTransformInverse);
 614     imageTransformInverse->Delete();
 615   }
 616
 617   UpdateTSlice(slicer);
 618 }
 619 //----------------------------------------------------------------------------
 620
 621
 622 //----------------------------------------------------------------------------
 623 void vvSlicerManager::SetColorWindow(double s)
 624 {
 625   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 626     mSlicers[i]->SetColorWindow(s);
 627   }
 628 }
 629 //----------------------------------------------------------------------------
 630
 631 //----------------------------------------------------------------------------
 632 void vvSlicerManager::SetColorLevel(double s)
 633 {
 634   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 635     mSlicers[i]->SetColorLevel(s);
 636   }
 637 }
 638 //----------------------------------------------------------------------------
 639
 640 //----------------------------------------------------------------------------
 641 void vvSlicerManager::SetOverlayColorWindow(double s)
 642 {
 643   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 644     mSlicers[i]->SetOverlayColorWindow(s);
 645   }
 646 }
 647 //----------------------------------------------------------------------------
 648
 649 //----------------------------------------------------------------------------
 650 void vvSlicerManager::SetOverlayColorLevel(double s)
 651 {
 652   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 653     mSlicers[i]->SetOverlayColorLevel(s);
 654   }
 655 }
 656 //----------------------------------------------------------------------------
 657
 658 //----------------------------------------------------------------------------
 659 void vvSlicerManager::SetLinkOverlayWindowLevel(bool b)
 660 {
 661   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 662     mSlicers[i]->SetLinkOverlayWindowLevel(b);
 663   }
 664 }
 665 //----------------------------------------------------------------------------
 666
 667 //----------------------------------------------------------------------------
 668 void vvSlicerManager::SetCursorAndCornerAnnotationVisibility(int s)
 669 {
 670   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 671     mSlicers[i]->SetCursorVisibility(s);
 672     mSlicers[i]->SetCornerAnnotationVisibility(s);
 673   }
 674 }
 675 //----------------------------------------------------------------------------
 676
 677 //----------------------------------------------------------------------------
 678 void vvSlicerManager::SetOpacity(int i, double factor)
 679 {
 680   mSlicers[i]->SetOpacity(1/factor);
 681 }
 682 //----------------------------------------------------------------------------
 683
 684
 685 //----------------------------------------------------------------------------
 686 void vvSlicerManager::UpdateViews(int current,int slicer)
 687 {
 688   double p[3], pt[3];
 689   p[0] = mSlicers[slicer]->GetCurrentPosition()[0];
 690   p[1] = mSlicers[slicer]->GetCurrentPosition()[1];
 691   p[2] = mSlicers[slicer]->GetCurrentPosition()[2];
 692   mSlicers[slicer]->GetSlicingTransform()->GetInverse()->TransformPoint(p, pt);
 693
 694   double x = (pt[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0])
 695     /mSlicers[slicer]->GetInput()->GetSpacing()[0];
 696   double y = (pt[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1])
 697     /mSlicers[slicer]->GetInput()->GetSpacing()[1];
 698   double z = (pt[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2])
 699     /mSlicers[slicer]->GetInput()->GetSpacing()[2];
 700 #if VTK_MAJOR_VERSION <= 5
 701   if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0]-0.5 &&
 702       x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1]+0.5 &&
 703       y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2]-0.5 &&
 704       y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3]+0.5 &&
 705       z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4]-0.5 &&
 706       z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]+0.5)
 707 #else
 708 int extentImageReslice[6];
 709 mSlicers[slicer]->GetRegisterExtent(extentImageReslice);
 710   if (x >= extentImageReslice[0]-0.5 &&
 711       x <= extentImageReslice[1]+0.5 &&
 712       y >= extentImageReslice[2]-0.5 &&
 713       y <= extentImageReslice[3]+0.5 &&
 714       z >= extentImageReslice[4]-0.5 &&
 715       z <= extentImageReslice[5]+0.5)
 716 #endif
 717   {
 718     mSlicers[slicer]->UpdateCursorPosition();
 719     mSlicers[slicer]->SetCursorColor(10,212,255);
 720     mSelectedSlicer = slicer;
 721
 722     switch (mSlicers[slicer]->GetSliceOrientation()) {
 723     case vtkImageViewer2::SLICE_ORIENTATION_XY:
 724       if (mSlicers[slicer]->GetSlice() != (int)lrint(z))
 725         mSlicers[slicer]->SetSlice((int)lrint(z));
 726       break;
 727
 728     case vtkImageViewer2::SLICE_ORIENTATION_XZ:
 729       if (mSlicers[slicer]->GetSlice() != (int)lrint(y))
 730         mSlicers[slicer]->SetSlice((int)lrint(y));
 731       break;
 732
 733     case vtkImageViewer2::SLICE_ORIENTATION_YZ:
 734       if (mSlicers[slicer]->GetSlice() != (int)lrint(x))
 735         mSlicers[slicer]->SetSlice((int)lrint(x));
 736       break;
 737     }
 738     mSlicers[slicer]->Render();
 739
 740     for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 741       if (i != (unsigned int)slicer
 742           && mSlicers[i]->GetRenderer()->GetDraw()
 743           && mSlicers[i]->GetRenderWindow()->GetSize()[0] > 2
 744           && mSlicers[i]->GetRenderWindow()->GetSize()[1] > 2) {
 745         mSlicers[i]->SetCurrentPosition(p[0], p[1], p[2], mSlicers[slicer]->GetMaxCurrentTSlice());
 746         mSlicers[i]->UpdateCursorPosition();
 747         if (current) { //do not display corner annotation if image is the one picked
 748           mSlicers[i]->SetCurrentPosition(-VTK_DOUBLE_MAX,-VTK_DOUBLE_MAX,
 749                                           -VTK_DOUBLE_MAX, mSlicers[slicer]->GetMaxCurrentTSlice());
 750           mSlicers[i]->SetCursorColor(255,10,212);
 751         } else {
 752           mSlicers[i]->SetCursorColor(150,10,282);
 753         }
 754         switch (mSlicers[i]->GetSliceOrientation()) {
 755         case vtkImageViewer2::SLICE_ORIENTATION_XY:
 756           if (mSlicers[i]->GetSlice() != (int)lrint(z))
 757             mSlicers[i]->SetSlice((int)lrint(z));
 758           break;
 759
 760         case vtkImageViewer2::SLICE_ORIENTATION_XZ:
 761           if (mSlicers[i]->GetSlice() != (int)lrint(y))
 762             mSlicers[i]->SetSlice((int)lrint(y));
 763           break;
 764
 765         case vtkImageViewer2::SLICE_ORIENTATION_YZ:
 766           if (mSlicers[i]->GetSlice() != (int)lrint(x))
 767             mSlicers[i]->SetSlice((int)lrint(x));
 768           break;
 769         }
 770
 771         mSlicers[i]->Render();
 772
 773         UpdateSlice(i);
 774         UpdateTSlice(i);
 775       }
 776     }
 777   }
 778 }
 779 //----------------------------------------------------------------------------
 780
 781
 782 //----------------------------------------------------------------------------
 783 void vvSlicerManager::UpdateLinked(int slicer)
 784 {
 785   double p[3], pt[3];
 786   p[0] = mSlicers[slicer]->GetCurrentPosition()[0];
 787   p[1] = mSlicers[slicer]->GetCurrentPosition()[1];
 788   p[2] = mSlicers[slicer]->GetCurrentPosition()[2];
 789   mSlicers[slicer]->GetSlicingTransform()->GetInverse()->TransformPoint(p, pt);
 790   double x = (pt[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0]) / mSlicers[slicer]->GetInput()->GetSpacing()[0];
 791   double y = (pt[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1]) / mSlicers[slicer]->GetInput()->GetSpacing()[1];
 792   double z = (pt[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2]) / mSlicers[slicer]->GetInput()->GetSpacing()[2];
 793 #if VTK_MAJOR_VERSION <= 5
 794   if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0]-0.5 &&
 795       x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1]+0.5 &&
 796       y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2]-0.5 &&
 797       y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3]+0.5 &&
 798       z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4]-0.5 &&
 799       z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]+0.5)
 800 #else
 801 int extentImageReslice[6];
 802 mSlicers[slicer]->GetRegisterExtent(extentImageReslice);
 803   if (x >= extentImageReslice[0]-0.5 &&
 804       x <= extentImageReslice[1]+0.5 &&
 805       y >= extentImageReslice[2]-0.5 &&
 806       y <= extentImageReslice[3]+0.5 &&
 807       z >= extentImageReslice[4]-0.5 &&
 808       z <= extentImageReslice[5]+0.5)
 809 #endif
 810   {
 811     for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++) {
 812                 if (this->IsInvolvedInFusionSequence()) {
 813                         //this SlicerManager is involved in fusionSequence => do not synchronize the times
 814                         emit UpdateLinkManager(*i, slicer, p[0], p[1], p[2], -1);
 815                 }
 816                 else {
 817                         emit UpdateLinkManager(*i, slicer, p[0], p[1], p[2], mSlicers[slicer]->GetMaxCurrentTSlice());
 818                 }
 819     }
 820   }
 821 }
 822 //----------------------------------------------------------------------------
 823
 824 //----------------------------------------------------------------------------
 825 void vvSlicerManager::UpdateLinkedNavigation(vvSlicer *refSlicer, bool bPropagate)
 826 {
 827   vtkCamera *refCam = refSlicer->GetRenderer()->GetActiveCamera();
 828
 829   double refPosition[3];
 830   refCam->GetPosition(refPosition);
 831   refPosition[refSlicer->GetSliceOrientation()] = refSlicer->GetSlice() *
 832       refSlicer->GetInput()->GetSpacing()[refSlicer->GetSliceOrientation()] +
 833       refSlicer->GetInput()->GetOrigin()[refSlicer->GetSliceOrientation()];
 834
 835   refSlicer->GetSlicingTransform()->TransformPoint(refPosition, refPosition);
 836   mSlicers[0]->GetSlicingTransform()->GetInverse()->TransformPoint(refPosition, refPosition);
 837
 838   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 839     vtkCamera *camera = mSlicers[i]->GetRenderer()->GetActiveCamera();
 840     camera->SetParallelScale(refCam->GetParallelScale());
 841
 842     double position[3], focal[3];
 843     camera->GetPosition(position);
 844     camera->GetFocalPoint(focal);
 845
 846     for(int j=0; j<3; j++) {
 847       if(j!=mSlicers[i]->GetSliceOrientation()) {
 848         position[j] = refPosition[j];
 849         focal[j]    = refPosition[j];
 850       }
 851     }
 852
 853     camera->SetFocalPoint(focal);
 854     camera->SetPosition(position);
 855
 856     //Fix for bug #243
 857     mSlicers[i]->ForceUpdateDisplayExtent();
 858   }
 859
 860   Render();
 861   if(bPropagate)
 862     for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++)
 863       emit UpdateLinkedNavigation(*i, this, refSlicer);
 864 }
 865 //----------------------------------------------------------------------------
 866
 867 //----------------------------------------------------------------------------
 868 double vvSlicerManager::GetColorWindow() const
 869 {
 870   if (mSlicers.size())
 871     return mSlicers[0]->GetColorWindow();
 872   return -1;
 873 }
 874 //----------------------------------------------------------------------------
 875
 876
 877 //----------------------------------------------------------------------------
 878 double vvSlicerManager::GetColorLevel() const
 879 {
 880   if (mSlicers.size())
 881     return mSlicers[0]->GetColorLevel();
 882   return -1;
 883 }
 884 //----------------------------------------------------------------------------
 885
 886 //----------------------------------------------------------------------------
 887 double vvSlicerManager::GetOverlayColorWindow() const
 888 {
 889   if (mSlicers.size())
 890     return mSlicers[0]->GetOverlayColorWindow();
 891   return -1;
 892 }
 893 //----------------------------------------------------------------------------
 894
 895 //----------------------------------------------------------------------------
 896 double vvSlicerManager::GetOverlayColorLevel() const
 897 {
 898   if (mSlicers.size())
 899     return mSlicers[0]->GetOverlayColorLevel();
 900   return -1;
 901 }
 902 //----------------------------------------------------------------------------
 903
 904 //----------------------------------------------------------------------------
 905 bool vvSlicerManager::GetLinkOverlayWindowLevel() const
 906 {
 907   if (mSlicers.size())
 908     return mSlicers[0]->GetLinkOverlayWindowLevel();
 909   return -1;
 910 }
 911 //----------------------------------------------------------------------------
 912
 913 //------------------------------------------------------------------------------
 914 void vvSlicerManager::ResetTransformationToIdentity(const std::string actorType)
 915 {
 916   if(actorType == "image")
 917     for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
 918       this->GetImage()->GetTransform()[i]->Identity();
 919   else if(actorType == "overlay")
 920     for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
 921       this->GetSlicer(0)->GetOverlay()->GetTransform()[i]->Identity();
 922   else if(actorType == "fusion")
 923     for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
 924       this->GetSlicer(0)->GetFusion()->GetTransform()[i]->Identity();
 925   else if(actorType == "fusionSequence") //TODO: Check what should really be done here
 926     for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
 927       this->GetSlicer(0)->GetFusion()->GetTransform()[i]->Identity();
 928   else if(actorType == "vf")
 929     for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
 930       this->GetVF()->GetTransform()[i]->Identity();
 931   else
 932     return;
 933
 934   for(int i=0; i< this->GetNumberOfSlicers(); i++){
 935     this->GetSlicer(i)->ForceUpdateDisplayExtent();
 936     this->GetSlicer(i)->ResetCamera();
 937     this->GetSlicer(i)->Render();
 938   }
 939 }
 940 //------------------------------------------------------------------------------
 941
 942 //----------------------------------------------------------------------------
 943 void vvSlicerManager::Render()
 944 {
 945   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 946     mSlicers[i]->Render();
 947   }
 948 }
 949 //----------------------------------------------------------------------------
 950
 951
 952 //----------------------------------------------------------------------------
 953 void vvSlicerManager::GenerateDefaultLookupTable()
 954 {
 955   SetPreset(mPreset);
 956   SetColorMap(mColorMap);
 957 }
 958 //----------------------------------------------------------------------------
 959
 960
 961 //----------------------------------------------------------------------------
 962 void vvSlicerManager::Reload()
 963 {
 964   mReader->Update(mType);
 965   mImage=mReader->GetOutput();
 966   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 967     mSlicers[i]->SetImage(mImage);
 968   }
 969
 970   //if this image is the primary sequence of a fusion sequence, then the main transform matrix should be updated.
 971   if (this->IsMainSequenceOfFusionSequence()) {
 972           SetFusionSequenceMainTransformMatrix( mImage->GetTransform()[0]->GetMatrix() );
 973   }
 974 }
 975 //----------------------------------------------------------------------------
 976
 977
 978 //----------------------------------------------------------------------------
 979 void vvSlicerManager::ReloadFusion()
 980 {
 981   mFusionReader->Update(mImage->GetNumberOfDimensions(),mFusionComponent.c_str(),mType);
 982
 983   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 984     mSlicers[i]->SetFusion(mFusionReader->GetOutput());
 985     mSlicers[i]->Render();
 986   }
 987 }
 988 //----------------------------------------------------------------------------
 989
 990 //----------------------------------------------------------------------------
 991 //the secondary sequence is being reloaded.
 992 void vvSlicerManager::ReloadFusionSequence()
 993 {
 994   //  this is to keep the slice thickness, which needs to be artificially increased for visualization
 995   double sp_x, sp_y, sp_z;
 996   this->GetImage()->GetVTKImages()[0]->GetSpacing(sp_x, sp_y, sp_z);
 997
 998   mFusionSequenceReader->Update(mImage->GetNumberOfDimensions(),mFusionComponent.c_str(),vvImageReader::MERGEDWITHTIME);
 999
1000   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
1001     mSlicers[i]->SetFusion(mFusionSequenceReader->GetOutput(), 1);
1002     mSlicers[i]->Render();
1003   }
1004
1005   //Update the slider
1006   mFusionSequenceNbFrames = mFusionSequenceReader->GetOutput()->GetTransform().size();
1007   if (mFusionSequenceFrameIndex>=mFusionSequenceNbFrames) {
1008           mFusionSequenceFrameIndex=0;
1009   }
1010
1011   //Update the list of initial transforms
1012   mFusionSequenceListInitialTransformMatrices.clear();
1013   for (unsigned i=0 ; i<mFusionSequenceNbFrames ; i++) {
1014           this->AddFusionSequenceInitialTransformMatrices( mFusionSequenceReader->GetOutput()->GetTransform()[i]->GetMatrix() );
1015   }
1016
1017   //  also update the slice thickness
1018   for (unsigned i=0 ; i<this->GetImage()->GetTransform().size() ; i++) {
1019     sp_x = this->GetImage()->GetVTKImages()[i]->GetSpacing()[0];
1020     sp_y = this->GetImage()->GetVTKImages()[i]->GetSpacing()[1];
1021     this->GetImage()->GetVTKImages()[i]->SetSpacing( sp_x, sp_y, sp_z);
1022   }
1023
1024 }
1025 //----------------------------------------------------------------------------
1026
1027
1028 //----------------------------------------------------------------------------
1029 void vvSlicerManager::ReloadOverlay()
1030 {
1031   mOverlayReader->Update(mImage->GetNumberOfDimensions(),mOverlayComponent.c_str(),mType);
1032   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
1033     mSlicers[i]->SetOverlay(mOverlayReader->GetOutput());
1034     mSlicers[i]->Render();
1035   }
1036 }
1037 //----------------------------------------------------------------------------
1038
1039
1040 //----------------------------------------------------------------------------
1041 void vvSlicerManager::ReloadVF()
1042 {
1043   mVectorReader->Update(vvImageReader::VECTORFIELD); //deletes the old images through the VF::Init() function
1044   mVF=mVectorReader->GetOutput();
1045   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
1046     mSlicers[i]->SetVF(mVF);
1047     mSlicers[i]->Render();
1048   }
1049 }
1050 //----------------------------------------------------------------------------
1051
1052
1053 //----------------------------------------------------------------------------
1054 void vvSlicerManager::RemoveActor(const std::string& actor_type, int overlay_index)
1055 {
1056   if (actor_type =="overlay")
1057     mOverlayReader = NULL;
1058
1059   if (actor_type =="fusion")
1060     mFusionReader = NULL;
1061
1062   if (actor_type =="fusionSequence") {
1063     mFusionSequenceReader = NULL;
1064   }
1065
1066   for (unsigned int i = 0; i < mSlicers.size(); i++)
1067     mSlicers[i]->RemoveActor(actor_type,overlay_index);
1068
1069   if (actor_type=="vector") {
1070     mVF=NULL;
1071     mVectorReader=NULL;
1072   }
1073 }
1074 //----------------------------------------------------------------------------
1075
1076
1077 //----------------------------------------------------------------------------
1078 void vvSlicerManager::RemoveActors()
1079 {
1080   ///This method leaks a few objects. See RemoveActor for what a
1081   ///correct implementation would look like
1082   //DS -> probably due to the reader (now released in the
1083   //RemoveActor() function. (I hope)
1084   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
1085     mSlicers[i]->SetDisplayMode(0);
1086     mSlicers[i]->GetRenderer()->RemoveActor(mSlicers[i]->GetImageActor());
1087   }
1088 }
1089 //----------------------------------------------------------------------------
1090
1091
1092 //----------------------------------------------------------------------------
1093 void vvSlicerManager::UpdateInfoOnCursorPosition(int slicer)
1094 {
1095   //  int view = mSlicers[slicer]->GetSliceOrientation();
1096   //  int slice = mSlicers[slicer]->GetSlice();
1097   double x = mSlicers[slicer]->GetCurrentPosition()[0];
1098   double y = mSlicers[slicer]->GetCurrentPosition()[1];
1099   double z = mSlicers[slicer]->GetCurrentPosition()[2];
1100   double xyz[3], xyzTransform[3];
1101   xyz[0] = x;
1102   xyz[1] = y;
1103   xyz[2] = z;
1104   mSlicers[slicer]->GetSlicingTransform()->GetInverse()->TransformPoint(xyz, xyzTransform);
1105   double X = (xyzTransform[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0])/mSlicers[slicer]->GetInput()->GetSpacing()[0];
1106   double Y = (xyzTransform[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1])/mSlicers[slicer]->GetInput()->GetSpacing()[1];
1107   double Z = (xyzTransform[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2])/mSlicers[slicer]->GetInput()->GetSpacing()[2];
1108   double value = -VTK_DOUBLE_MAX;
1109   int displayVec = 0;
1110   double xVec=0, yVec=0, zVec=0, valueVec=0;
1111   int displayOver = 0;
1112   int displayFus = 0;
1113   double valueOver=0, valueFus=0;
1114 #if VTK_MAJOR_VERSION <= 5
1115     if (X >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] -0.5 &&
1116       X <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] +0.5 &&
1117       Y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] -0.5 &&
1118       Y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] +0.5 &&
1119       Z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] -0.5 &&
1120       Z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5] +0.5)
1121 #else
1122 int extentImageReslice[6];
1123 mSlicers[slicer]->GetRegisterExtent(extentImageReslice);
1124     if (X >= extentImageReslice[0] -0.5 &&
1125       X <= extentImageReslice[1] +0.5 &&
1126       Y >= extentImageReslice[2] -0.5 &&
1127       Y <= extentImageReslice[3] +0.5 &&
1128       Z >= extentImageReslice[4] -0.5 &&
1129       Z <= extentImageReslice[5] +0.5)
1130 #endif
1131     {
1132     value = this->GetScalarComponentAsDouble(mSlicers[slicer]->GetInput(), X, Y, Z);
1133
1134     if (mSlicers[slicer]->GetVFActor() ) {
1135       displayVec = 1;
1136       unsigned int currentTime = mSlicers[slicer]->GetMaxCurrentTSlice();
1137       vtkImageData *vf = NULL;
1138
1139       if (mSlicers[slicer]->GetVF()->GetVTKImages().size() > currentTime)
1140         vf = mSlicers[slicer]->GetVF()->GetVTKImages()[currentTime];
1141       else
1142         vf = mSlicers[slicer]->GetVF()->GetVTKImages()[0];
1143
1144       if (vf) {
1145         double Xvf = (x - vf->GetOrigin()[0])/ vf->GetSpacing()[0];
1146         double Yvf = (y - vf->GetOrigin()[1])/ vf->GetSpacing()[1];
1147         double Zvf = (z - vf->GetOrigin()[2])/ vf->GetSpacing()[2];
1148         xVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 0);
1149         yVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 1);
1150         zVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 2);
1151         valueVec = sqrt(xVec*xVec + yVec*yVec + zVec*zVec);
1152       }
1153     }
1154     if (mSlicers[slicer]->GetOverlayActor() ) {
1155       displayOver = 1;
1156       vtkImageData *overlay = dynamic_cast<vtkImageData*>(mSlicers[slicer]->GetOverlayMapper()->GetInput());
1157       double Xover = (x - overlay->GetOrigin()[0]) / overlay->GetSpacing()[0];
1158       double Yover = (y - overlay->GetOrigin()[1]) / overlay->GetSpacing()[1];
1159       double Zover = (z - overlay->GetOrigin()[2]) / overlay->GetSpacing()[2];
1160       valueOver = this->GetScalarComponentAsDouble(overlay, Xover, Yover, Zover);
1161     }
1162
1163         if ( mSlicers[slicer]->GetFusionActor() ) {
1164                 displayFus = 1;
1165                 vtkImageData *fusion = dynamic_cast<vtkImageData*>(mSlicers[slicer]->GetFusionMapper()->GetInput());
1166                 double Xover = (x - fusion->GetOrigin()[0]) / fusion->GetSpacing()[0];
1167                 double Yover = (y - fusion->GetOrigin()[1]) / fusion->GetSpacing()[1];
1168                 double Zover = (z - fusion->GetOrigin()[2]) / fusion->GetSpacing()[2];
1169                 valueFus = this->GetScalarComponentAsDouble(fusion, Xover, Yover, Zover);
1170         }
1171         else if (this->IsInvolvedInFusionSequence()) {
1172     //if the cursor moves over the 'independent' version of the secondary sequence
1173     //do not update the panel, just keep it as it is.
1174                 displayFus = 1;
1175                 valueFus = std::numeric_limits<double>::quiet_NaN();
1176         }
1177
1178     emit UpdatePosition(mSlicers[slicer]->GetCursorVisibility(),
1179                         x,y,z,X,Y,Z,value);
1180     emit UpdateVector(displayVec,xVec, yVec, zVec, valueVec);
1181     emit UpdateOverlay(displayOver,valueOver,value);
1182     emit UpdateFusion(displayFus,valueFus);
1183   }
1184 }
1185 //----------------------------------------------------------------------------
1186
1187
1188 //----------------------------------------------------------------------------
1189 void vvSlicerManager::Activated()
1190 {
1191   emit currentImageChanged(mId);
1192 }
1193 //----------------------------------------------------------------------------
1194
1195
1196 //----------------------------------------------------------------------------
1197 void vvSlicerManager::Picked()
1198 {
1199   emit currentPickedImageChanged(mId);
1200 }
1201 //----------------------------------------------------------------------------
1202
1203
1204 //----------------------------------------------------------------------------
1205 void vvSlicerManager::UpdateWindowLevel()
1206 {
1207   emit WindowLevelChanged();
1208 }
1209 //----------------------------------------------------------------------------
1210
1211
1212 //----------------------------------------------------------------------------
1213 void vvSlicerManager::UpdateSlice(int slicer)
1214 {
1215   if (mPreviousSlice[slicer] == mSlicers[slicer]->GetSlice()) {
1216     //DD("============= NOTHING");
1217     return;
1218   }
1219   emit UpdateSlice(slicer, mSlicers[slicer]->GetSlice());
1220   mSlicers[slicer]->Render(); // DS <-- I add this, this could/must be the only Render ...
1221   mPreviousSlice[slicer] = mSlicers[slicer]->GetSlice();
1222 }
1223 //----------------------------------------------------------------------------
1224
1225
1226 //----------------------------------------------------------------------------
1227 void vvSlicerManager::UpdateTSlice(int slicer)
1228 {
1229   int slice = mSlicers[slicer]->GetSlice();
1230
1231   int tslice = mSlicers[slicer]->GetMaxCurrentTSlice();
1232   //if (this->IsInvolvedInFusionSequence()) tslice = mSlicers[slicer]->GetTSlice(); //actually, this is handled by the Slicer
1233
1234   if (mPreviousSlice[slicer] == slice) {
1235     if (mPreviousTSlice[slicer] == tslice) {
1236       //      DD("************** NOTHING ***********");
1237       return;
1238     }
1239   }
1240   mPreviousSlice[slicer] = slice;
1241   mPreviousTSlice[slicer] = tslice;
1242
1243   emit UpdateTSlice(slicer, tslice, mFusionSequenceInvolvementCode);
1244 }
1245 //----------------------------------------------------------------------------
1246
1247
1248 //----------------------------------------------------------------------------
1249 void vvSlicerManager::UpdateSliceRange(int slicer)
1250 {
1251   emit UpdateSliceRange(slicer,
1252                         mSlicers[slicer]->GetSliceRange()[0], mSlicers[slicer]->GetSliceRange()[1],
1253                         0,mSlicers[slicer]->GetTMax());
1254 }
1255 //----------------------------------------------------------------------------
1256
1257 //----------------------------------------------------------------------------
1258 void vvSlicerManager::SetSlicingPreset(SlicingPresetType preset)
1259 {
1260   if(mSlicingPreset==preset)
1261     return;
1262
1263   vtkMatrix4x4 *imageTransformInverse = vtkMatrix4x4::New();
1264   mImage->GetTransform()[this->GetTSlice()]->GetInverse(imageTransformInverse);
1265
1266   for(int i=0; i< this->GetNumberOfSlicers(); i++){
1267     vvSlicer *s = this->GetSlicer(i);
1268     switch(preset)
1269     {
1270     case WORLD_SLICING:
1271       s->GetSlicingTransform()->Identity();
1272       break;
1273     case VOXELS_SLICING:
1274       s->GetSlicingTransform()->SetMatrix(imageTransformInverse);
1275       break;
1276     default:
1277       imageTransformInverse->Delete();
1278       return;
1279     }
1280     s->ForceUpdateDisplayExtent();
1281 #if VTK_MAJOR_VERSION <= 5
1282     s->SetSlice((s->GetInput()->GetWholeExtent()[s->GetSliceOrientation()*2+1]
1283                 +s->GetInput()->GetWholeExtent()[s->GetSliceOrientation()*2])/2.0);
1284 #else
1285     int extentImageReslice[6];
1286     s->GetRegisterExtent(extentImageReslice);
1287     s->SetSlice((extentImageReslice[s->GetSliceOrientation()*2+1]
1288                 +extentImageReslice[s->GetSliceOrientation()*2])/2.0);
1289 #endif
1290     s->ResetCamera();
1291     s->Render();
1292   }
1293
1294   imageTransformInverse->Delete();
1295   mSlicingPreset = preset;
1296 }
1297
1298 //----------------------------------------------------------------------------
1299
1300 //----------------------------------------------------------------------------
1301 void vvSlicerManager::SetPreset(int preset)
1302 {
1303
1304   //vtkLookupTable* LUT = static_cast<vtkLookupTable*>(mSlicers[0]->GetWindowLevel()->GetLookupTable());
1305   double window = mSlicers[0]->GetColorWindow();
1306   double level = mSlicers[0]->GetColorLevel();
1307
1308   std::string component_type=mImage->GetScalarTypeAsITKString();
1309   switch (preset) {
1310   case WL_AUTO:
1311     double range[2];
1312     mImage->GetScalarRange(range);
1313     window = range[1] - range[0];
1314     level = (range[1] + range[0])* 0.5;
1315     break;
1316   case WL_HOUNSFIELD:
1317     window = 2000;
1318     level = 0;
1319     break;
1320   case WL_SOFTTISSUE:
1321     window = 400;
1322     level = 20;
1323     break;
1324   case WL_LUNGS: // lungs (same as FOCAL)
1325     window = 1700;
1326     level = -300;
1327     break;
1328   case WL_BONES:
1329     window = 1000;
1330     level = 500;
1331     break;
1332   case WL_HEAD:
1333     window = 200;
1334     level = 70;
1335     break;
1336   case WL_BINARY:
1337     window = 1;
1338     level = 0.5;
1339     break;
1340   case WL_USER:
1341     break;
1342   case WL_VENTILATION:
1343     window=1.;
1344     level=0.;
1345     break;
1346   }
1347   mPreset = preset;
1348   this->SetColorWindow(window);
1349   this->SetColorLevel(level);
1350
1351   //if (LUT)
1352   //{
1353   //    SetColorMap(-1);
1354   //}
1355 }
1356 //----------------------------------------------------------------------------
1357
1358
1359 //----------------------------------------------------------------------------
1360 void vvSlicerManager::SetLocalColorWindowing(const int slicer, const bool bCtrlKey)
1361 {
1362   double min, max;
1363   if(bCtrlKey && this->mSlicers[slicer]->GetFusion()) {
1364     int t = mSlicers[slicer]->GetFusionTSlice();
1365     this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max,
1366                                                           this->mSlicers[slicer]->GetFusion()->GetVTKImages()[t],
1367                                                           this->mSlicers[slicer]->GetConcatenatedFusionTransform());
1368     this->SetFusionWindow(max-min);
1369     this->SetFusionLevel(0.5*(min+max));
1370     this->SetColorMap(mColorMap);
1371   }
1372   else if(bCtrlKey && this->mSlicers[slicer]->GetOverlay()) {
1373     int t = mSlicers[slicer]->GetOverlayTSlice();
1374     this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max,
1375                                                           this->mSlicers[slicer]->GetOverlay()->GetVTKImages()[t],
1376                                                           this->mSlicers[slicer]->GetConcatenatedOverlayTransform());
1377     if(this->mSlicers[slicer]->GetLinkOverlayWindowLevel()){
1378       this->SetColorWindow(max-min);
1379       this->SetColorLevel(0.5*(min+max));
1380     } else {
1381       this->SetOverlayColorWindow(max-min);
1382       this->SetOverlayColorLevel(0.5*(min+max));
1383     }
1384   }
1385   else {
1386     int t = this->GetTSlice();
1387     this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max,
1388                                                           this->mSlicers[slicer]->GetImage()->GetVTKImages()[t],
1389                                                           this->mSlicers[slicer]->GetConcatenatedTransform());
1390     this->SetColorWindow(max-min);
1391     this->SetColorLevel(0.5*(min+max));
1392     this->SetPreset(WL_USER);
1393   }
1394   this->Render();
1395   this->UpdateWindowLevel();
1396 }
1397 //----------------------------------------------------------------------------
1398
1399
1400 //----------------------------------------------------------------------------
1401 void vvSlicerManager::SetColorMap(int colormap)
1402 {
1403   double range[2];
1404
1405   range[0] = mSlicers[0]->GetInput()->GetScalarRange()[0];
1406   range[1] = mSlicers[0]->GetInput()->GetScalarRange()[1];
1407
1408   double window = mSlicers[0]->GetWindowLevel()->GetWindow();
1409   double level = mSlicers[0]->GetWindowLevel()->GetLevel();
1410
1411   vtkLookupTable* LUT = static_cast<vtkLookupTable*>(mSlicers[0]->GetWindowLevel()->GetLookupTable());
1412   switch (colormap) {
1413   case -1:
1414     break;
1415   case 0:
1416     LUT = NULL;
1417     break;
1418   case 1:
1419     if (LUT == NULL)
1420       LUT = vtkLookupTable::New();
1421     LUT->SetValueRange(0,1);
1422     LUT->SetSaturationRange(1,1);
1423     LUT->SetHueRange(0,0.18);
1424     break;
1425   case 2:
1426     if (LUT == NULL)
1427       LUT = vtkLookupTable::New();
1428     LUT->SetValueRange(0,1);
1429     LUT->SetSaturationRange(1,1);
1430     LUT->SetHueRange(0.4,0.80);
1431     break;
1432   case 3:
1433     if (LUT == NULL)
1434       LUT = vtkLookupTable::New();
1435     LUT->SetValueRange(0.5,1);
1436     LUT->SetSaturationRange(1,1);
1437     LUT->SetHueRange(0.666,0);
1438     break;
1439   case 4:
1440     if (LUT == NULL)
1441       LUT = vtkLookupTable::New();
1442     LUT->SetValueRange(1,1);
1443     LUT->SetSaturationRange(1,1);
1444     LUT->SetHueRange(0,1);
1445     LUT->SetAlphaRange(1, 1);
1446     break;
1447   case 5:
1448     if (LUT == NULL)
1449       LUT = vtkLookupTable::New();
1450     LUT->SetValueRange(1,1);
1451     LUT->SetSaturationRange(1,1);
1452     LUT->SetHueRange(1,0.1);
1453     //LUT->SetRampToLinear();
1454     break;
1455   }
1456   if (LUT) {
1457     LUT->SetTableRange(level-fabs(window)/2,level+fabs(window)/2);
1458     LUT->Build();
1459   }
1460   vtkWindowLevelLookupTable* fusLUT = NULL;
1461
1462   //FUSION / FUSION SEQUENCE
1463   if (mSlicers[0]->GetFusion()) { // && mFusionColorMap >= 0) {
1464     fusLUT = vtkWindowLevelLookupTable::New();
1465     double fusRange [2];
1466     fusRange[0] = mFusionLevel - mFusionWindow/2;
1467     fusRange[1] = mFusionLevel + mFusionWindow/2;
1468
1469     //check whether it is actually a fusionSequence or a fusion, before invoking mFusionReader...
1470     double* frange;
1471     if (this->IsInvolvedInFusionSequence())
1472       frange = mFusionSequenceReader->GetOutput()->GetVTKImages()[0]->GetScalarRange();
1473     else
1474       frange = mFusionReader->GetOutput()->GetVTKImages()[0]->GetScalarRange();
1475
1476     fusLUT->SetTableRange(frange);
1477     fusLUT->SetValueRange(1,1);
1478     fusLUT->SetSaturationRange(1,1);
1479     fusLUT->SetAlphaRange(1, 1);
1480     fusLUT->SetWindow(mFusionWindow);
1481     fusLUT->SetLevel(mFusionLevel);
1482     if (mFusionColorMap == 1)
1483       fusLUT->SetHueRange(0,0.18);
1484     else if (mFusionColorMap == 2)
1485       fusLUT->SetHueRange(0.4,0.80);
1486     else if (mFusionColorMap == 3)
1487     {
1488       fusLUT->SetHueRange(0.666, 0);
1489       fusLUT->SetValueRange(0.5, 1);
1490     }
1491     else if (mFusionColorMap == 4)
1492       fusLUT->SetHueRange(0,1);
1493     else if (mFusionColorMap <= 0)
1494     {
1495       fusLUT->SetValueRange(0,1);
1496       fusLUT->SetSaturationRange(0,0);
1497     }
1498
1499     fusLUT->ForceBuild();
1500     double v[4];
1501     // set color table transparency
1502     //double alpha_range=(double)mFusionThresOpacity/10;
1503     double range_end = fusRange[0] + (double)mFusionThresOpacity*(fusRange[1] - fusRange[0])/100;
1504     double curr_value = fusRange[0];
1505     int nvalues = fusLUT->GetNumberOfTableValues();
1506     for (double i = 0; curr_value < range_end; i++) {
1507       fusLUT->GetTableValue(i, v);
1508       v[3] = 0;
1509       //if (curr_value >= -alpha_range && curr_value <= alpha_range) v[3] = pow(fabs(curr_value/alpha_range),2);
1510       //else v[3] = 1;
1511       fusLUT->SetTableValue(i, v);
1512       curr_value += (fusRange[1] - fusRange[0])/nvalues;
1513     }
1514   }
1515   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
1516
1517     if (mSlicers[i]->GetOverlay()) {
1518       vtkLookupTable* supLUT = vtkLookupTable::New();
1519       supLUT->SetTableRange(range[0],range[1]);
1520       supLUT->SetValueRange(1,1);
1521       supLUT->SetSaturationRange(1,1);
1522       supLUT->SetHueRange(double(mOverlayColor)/360,double(mOverlayColor)/360);
1523       supLUT->Build();
1524       vtkLookupTable* invLUT = vtkLookupTable::New();
1525       invLUT->SetTableRange(range[0],range[1]);
1526       invLUT->SetValueRange(1,1);
1527       invLUT->SetSaturationRange(1,1);
1528       invLUT->SetHueRange(double((mOverlayColor+180)%360)/360,double((mOverlayColor+180)%360)/360);
1529       invLUT->Build();
1530       mSlicers[i]->GetWindowLevel()->SetLookupTable(supLUT);
1531       mSlicers[i]->GetOverlayMapper()->SetLookupTable(invLUT);
1532       invLUT->Delete();
1533       supLUT->Delete();
1534     } else if (mSlicers[i]->GetOverlay()) {
1535       mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT);
1536     } else {
1537       mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT);
1538     }
1539
1540     if (mSlicers[i]->GetFusion()) {
1541       mSlicers[i]->ShowFusionLegend(mFusionShowLegend);
1542       mSlicers[i]->GetFusionMapper()->SetLookupTable(fusLUT);
1543       mSlicers[i]->GetFusionActor()->SetOpacity(double(mFusionOpacity)/100);
1544     }
1545   }
1546   if (fusLUT)
1547     fusLUT->Delete();
1548   if (colormap >= 0)
1549     mColorMap = colormap;
1550 }
1551 //----------------------------------------------------------------------------
1552
1553
1554 //----------------------------------------------------------------------------
1555 vvLandmarks* vvSlicerManager::GetLandmarks()
1556 {
1557   if (mLandmarks == NULL) {
1558     mLandmarks = new vvLandmarks(mSlicers[0]->GetTMax()+1);
1559     for (unsigned int i = 0; i < mSlicers.size(); i++)
1560       mSlicers[i]->SetLandmarks(mLandmarks);
1561   }
1562   return mLandmarks;
1563 }
1564 //----------------------------------------------------------------------------
1565 void vvSlicerManager::AddNewLandmark(float x,float y,float z,float t)
1566 {
1567     emit callAddLandmark(x,y,z,t);
1568 }
1569
1570 //----------------------------------------------------------------------------
1571 void vvSlicerManager::AddLandmark(float x,float y,float z,float t)
1572 {
1573   double x_index = (x - mSlicers[0]->GetInput()->GetOrigin()[0])/mSlicers[0]->GetInput()->GetSpacing()[0];
1574   double y_index = (y - mSlicers[0]->GetInput()->GetOrigin()[1])/mSlicers[0]->GetInput()->GetSpacing()[1];
1575   double z_index = (z - mSlicers[0]->GetInput()->GetOrigin()[2])/mSlicers[0]->GetInput()->GetSpacing()[2];
1576 #if VTK_MAJOR_VERSION <= 5
1577   if (x_index >= mSlicers[0]->GetInput()->GetWholeExtent()[0]-0.5 &&
1578       x_index <= mSlicers[0]->GetInput()->GetWholeExtent()[1]+0.5 &&
1579       y_index >= mSlicers[0]->GetInput()->GetWholeExtent()[2]-0.5 &&
1580       y_index <= mSlicers[0]->GetInput()->GetWholeExtent()[3]+0.5 &&
1581       z_index >= mSlicers[0]->GetInput()->GetWholeExtent()[4]-0.5 &&
1582       z_index <= mSlicers[0]->GetInput()->GetWholeExtent()[5]+0.5)
1583 #else
1584   int extentImageReslice[6];
1585   mSlicers[0]->GetRegisterExtent(extentImageReslice);
1586   if (x_index >= extentImageReslice[0]-0.5 &&
1587       x_index <= extentImageReslice[1]+0.5 &&
1588       y_index >= extentImageReslice[2]-0.5 &&
1589       y_index <= extentImageReslice[3]+0.5 &&
1590       z_index >= extentImageReslice[4]-0.5 &&
1591       z_index <= extentImageReslice[5]+0.5)
1592 #endif
1593   {
1594     double value = this->GetScalarComponentAsDouble(mSlicers[mSelectedSlicer]->GetInput(), x_index, y_index, z_index); //Value in selected Slicer (not 0): bug #2848
1595     this->GetLandmarks()->AddLandmark(x,y,z,t,value);
1596     emit LandmarkAdded();
1597   }
1598 }
1599 //----------------------------------------------------------------------------
1600
1601 //----------------------------------------------------------------------------
1602 void vvSlicerManager::AddLandmarkProfile(float x,float y,float z,float t)
1603 {
1604   double x_index = (x - mSlicers[0]->GetInput()->GetOrigin()[0])/mSlicers[0]->GetInput()->GetSpacing()[0];
1605   double y_index = (y - mSlicers[0]->GetInput()->GetOrigin()[1])/mSlicers[0]->GetInput()->GetSpacing()[1];
1606   double z_index = (z - mSlicers[0]->GetInput()->GetOrigin()[2])/mSlicers[0]->GetInput()->GetSpacing()[2];
1607 #if VTK_MAJOR_VERSION <= 5
1608   if (x_index >= mSlicers[0]->GetInput()->GetWholeExtent()[0]-0.5 &&
1609       x_index <= mSlicers[0]->GetInput()->GetWholeExtent()[1]+0.5 &&
1610       y_index >= mSlicers[0]->GetInput()->GetWholeExtent()[2]-0.5 &&
1611       y_index <= mSlicers[0]->GetInput()->GetWholeExtent()[3]+0.5 &&
1612       z_index >= mSlicers[0]->GetInput()->GetWholeExtent()[4]-0.5 &&
1613       z_index <= mSlicers[0]->GetInput()->GetWholeExtent()[5]+0.5)
1614 #else
1615   int extentImageReslice[6];
1616   mSlicers[0]->GetRegisterExtent(extentImageReslice);
1617   if (x_index >= extentImageReslice[0]-0.5 &&
1618       x_index <= extentImageReslice[1]+0.5 &&
1619       y_index >= extentImageReslice[2]-0.5 &&
1620       y_index <= extentImageReslice[3]+0.5 &&
1621       z_index >= extentImageReslice[4]-0.5 &&
1622       z_index <= extentImageReslice[5]+0.5)
1623 #endif
1624   {
1625     double value = this->GetScalarComponentAsDouble(mSlicers[mSelectedSlicer]->GetInput(), x_index, y_index, z_index); //Value in selected Slicer (not 0): bug #2848
1626     this->GetLandmarks()->AddLandmark(x,y,z,t,value);
1627   }
1628 }
1629 //----------------------------------------------------------------------------
1630
1631 //----------------------------------------------------------------------------
1632 void vvSlicerManager::PrevImage(int slicer)
1633 {
1634   emit ChangeImageWithIndexOffset(this, slicer, -1);
1635 }
1636 //----------------------------------------------------------------------------
1637
1638 //----------------------------------------------------------------------------
1639 void vvSlicerManager::NextImage(int slicer)
1640 {
1641   emit ChangeImageWithIndexOffset(this, slicer,  1);
1642 }
1643 //----------------------------------------------------------------------------
1644
1645 //----------------------------------------------------------------------------
1646 void vvSlicerManager::VerticalSliderHasChanged(int slicer, int slice)
1647 {
1648   emit AVerticalSliderHasChanged(slicer, slice);
1649 }
1650
1651 //----------------------------------------------------------------------------
1652
1653 //----------------------------------------------------------------------------
1654 double vvSlicerManager::GetScalarComponentAsDouble(vtkImageData *image, double X, double Y, double Z, int component)
1655 {
1656   int ix, iy, iz;
1657   return mSlicers[0]->GetScalarComponentAsDouble(image, X, Y, Z, ix, iy, iz, component);
1658 }
1659 //----------------------------------------------------------------------------