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