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]->SetInterpolationImageReslice(interpolate);
 587     mSlicers[i]->GetImageActor()->SetInterpolate(interpolate);
 588     if (mSlicers[i]->GetOverlayActor())
 589       mSlicers[i]->GetOverlayActor()->SetInterpolate(interpolate);
 590     if (mSlicers[i]->GetFusionActor())
 591       mSlicers[i]->GetFusionActor()->SetInterpolate(interpolate);
 592   }
 593 }
 594 //----------------------------------------------------------------------------
 595
 596
 597 //----------------------------------------------------------------------------
 598 void vvSlicerManager::SetTSliceInSlicer(int tslice, int slicer)
 599 {
 600   if (tslice < 0)
 601     tslice = 0;
 602   else if (tslice > mSlicers[slicer]->GetTMax())
 603     tslice = mSlicers[slicer]->GetTMax();
 604   if (mLandmarks)
 605     mLandmarks->SetTime(tslice);
 606
 607   if (mSlicers[slicer]->GetMaxCurrentTSlice() == tslice) return;
 608
 609   mSlicers[slicer]->SetTSlice(tslice);
 610
 611   if(mSlicingPreset==VOXELS_SLICING) {
 612     vtkMatrix4x4 *imageTransformInverse = vtkMatrix4x4::New();
 613     mImage->GetTransform()[mSlicers[slicer]->GetTSlice()]->GetInverse(imageTransformInverse);
 614     this->GetSlicer(slicer)->GetSlicingTransform()->SetMatrix(imageTransformInverse);
 615     imageTransformInverse->Delete();
 616   }
 617
 618   UpdateTSlice(slicer);
 619 }
 620 //----------------------------------------------------------------------------
 621
 622
 623 //----------------------------------------------------------------------------
 624 void vvSlicerManager::SetColorWindow(double s)
 625 {
 626   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 627     mSlicers[i]->SetColorWindow(s);
 628   }
 629 }
 630 //----------------------------------------------------------------------------
 631
 632 //----------------------------------------------------------------------------
 633 void vvSlicerManager::SetColorLevel(double s)
 634 {
 635   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 636     mSlicers[i]->SetColorLevel(s);
 637   }
 638 }
 639 //----------------------------------------------------------------------------
 640
 641 //----------------------------------------------------------------------------
 642 void vvSlicerManager::SetOverlayColorWindow(double s)
 643 {
 644   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 645     mSlicers[i]->SetOverlayColorWindow(s);
 646   }
 647 }
 648 //----------------------------------------------------------------------------
 649
 650 //----------------------------------------------------------------------------
 651 void vvSlicerManager::SetOverlayColorLevel(double s)
 652 {
 653   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 654     mSlicers[i]->SetOverlayColorLevel(s);
 655   }
 656 }
 657 //----------------------------------------------------------------------------
 658
 659 //----------------------------------------------------------------------------
 660 void vvSlicerManager::SetLinkOverlayWindowLevel(bool b)
 661 {
 662   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 663     mSlicers[i]->SetLinkOverlayWindowLevel(b);
 664   }
 665 }
 666 //----------------------------------------------------------------------------
 667
 668 //----------------------------------------------------------------------------
 669 void vvSlicerManager::SetCursorAndCornerAnnotationVisibility(int s)
 670 {
 671   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 672     mSlicers[i]->SetCursorVisibility(s);
 673     mSlicers[i]->SetCornerAnnotationVisibility(s);
 674   }
 675 }
 676 //----------------------------------------------------------------------------
 677
 678 //----------------------------------------------------------------------------
 679 void vvSlicerManager::SetOpacity(int i, double factor)
 680 {
 681   mSlicers[i]->SetOpacity(1/factor);
 682 }
 683 //----------------------------------------------------------------------------
 684
 685
 686 //----------------------------------------------------------------------------
 687 void vvSlicerManager::UpdateViews(int current,int slicer)
 688 {
 689   double p[3], pt[3];
 690   p[0] = mSlicers[slicer]->GetCurrentPosition()[0];
 691   p[1] = mSlicers[slicer]->GetCurrentPosition()[1];
 692   p[2] = mSlicers[slicer]->GetCurrentPosition()[2];
 693   mSlicers[slicer]->GetSlicingTransform()->GetInverse()->TransformPoint(p, pt);
 694
 695   double x = (pt[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0])
 696     /mSlicers[slicer]->GetInput()->GetSpacing()[0];
 697   double y = (pt[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1])
 698     /mSlicers[slicer]->GetInput()->GetSpacing()[1];
 699   double z = (pt[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2])
 700     /mSlicers[slicer]->GetInput()->GetSpacing()[2];
 701 #if VTK_MAJOR_VERSION <= 5
 702   if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0]-0.5 &&
 703       x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1]+0.5 &&
 704       y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2]-0.5 &&
 705       y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3]+0.5 &&
 706       z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4]-0.5 &&
 707       z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]+0.5)
 708 #else
 709 int extentImageReslice[6];
 710 mSlicers[slicer]->GetRegisterExtent(extentImageReslice);
 711   if (x >= extentImageReslice[0]-0.5 &&
 712       x <= extentImageReslice[1]+0.5 &&
 713       y >= extentImageReslice[2]-0.5 &&
 714       y <= extentImageReslice[3]+0.5 &&
 715       z >= extentImageReslice[4]-0.5 &&
 716       z <= extentImageReslice[5]+0.5)
 717 #endif
 718   {
 719     mSlicers[slicer]->UpdateCursorPosition();
 720     mSlicers[slicer]->SetCursorColor(10,212,255);
 721     mSelectedSlicer = slicer;
 722
 723     switch (mSlicers[slicer]->GetSliceOrientation()) {
 724     case vtkImageViewer2::SLICE_ORIENTATION_XY:
 725       if (mSlicers[slicer]->GetSlice() != (int)lrint(z))
 726         mSlicers[slicer]->SetSlice((int)lrint(z));
 727       break;
 728
 729     case vtkImageViewer2::SLICE_ORIENTATION_XZ:
 730       if (mSlicers[slicer]->GetSlice() != (int)lrint(y))
 731         mSlicers[slicer]->SetSlice((int)lrint(y));
 732       break;
 733
 734     case vtkImageViewer2::SLICE_ORIENTATION_YZ:
 735       if (mSlicers[slicer]->GetSlice() != (int)lrint(x))
 736         mSlicers[slicer]->SetSlice((int)lrint(x));
 737       break;
 738     }
 739     mSlicers[slicer]->Render();
 740
 741     for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 742       if (i != (unsigned int)slicer
 743           && mSlicers[i]->GetRenderer()->GetDraw()
 744           && mSlicers[i]->GetRenderWindow()->GetSize()[0] > 2
 745           && mSlicers[i]->GetRenderWindow()->GetSize()[1] > 2) {
 746         mSlicers[i]->SetCurrentPosition(p[0], p[1], p[2], mSlicers[slicer]->GetMaxCurrentTSlice());
 747         mSlicers[i]->UpdateCursorPosition();
 748         if (current) { //do not display corner annotation if image is the one picked
 749           mSlicers[i]->SetCurrentPosition(-VTK_DOUBLE_MAX,-VTK_DOUBLE_MAX,
 750                                           -VTK_DOUBLE_MAX, mSlicers[slicer]->GetMaxCurrentTSlice());
 751           mSlicers[i]->SetCursorColor(255,10,212);
 752         } else {
 753           mSlicers[i]->SetCursorColor(150,10,282);
 754         }
 755         switch (mSlicers[i]->GetSliceOrientation()) {
 756         case vtkImageViewer2::SLICE_ORIENTATION_XY:
 757           if (mSlicers[i]->GetSlice() != (int)lrint(z))
 758             mSlicers[i]->SetSlice((int)lrint(z));
 759           break;
 760
 761         case vtkImageViewer2::SLICE_ORIENTATION_XZ:
 762           if (mSlicers[i]->GetSlice() != (int)lrint(y))
 763             mSlicers[i]->SetSlice((int)lrint(y));
 764           break;
 765
 766         case vtkImageViewer2::SLICE_ORIENTATION_YZ:
 767           if (mSlicers[i]->GetSlice() != (int)lrint(x))
 768             mSlicers[i]->SetSlice((int)lrint(x));
 769           break;
 770         }
 771
 772         mSlicers[i]->Render();
 773
 774         UpdateSlice(i);
 775         UpdateTSlice(i);
 776       }
 777     }
 778   }
 779 }
 780 //----------------------------------------------------------------------------
 781
 782
 783 //----------------------------------------------------------------------------
 784 void vvSlicerManager::UpdateLinked(int slicer)
 785 {
 786   double p[3], pt[3];
 787   p[0] = mSlicers[slicer]->GetCurrentPosition()[0];
 788   p[1] = mSlicers[slicer]->GetCurrentPosition()[1];
 789   p[2] = mSlicers[slicer]->GetCurrentPosition()[2];
 790   mSlicers[slicer]->GetSlicingTransform()->GetInverse()->TransformPoint(p, pt);
 791   double x = (pt[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0]) / mSlicers[slicer]->GetInput()->GetSpacing()[0];
 792   double y = (pt[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1]) / mSlicers[slicer]->GetInput()->GetSpacing()[1];
 793   double z = (pt[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2]) / mSlicers[slicer]->GetInput()->GetSpacing()[2];
 794 #if VTK_MAJOR_VERSION <= 5
 795   if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0]-0.5 &&
 796       x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1]+0.5 &&
 797       y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2]-0.5 &&
 798       y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3]+0.5 &&
 799       z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4]-0.5 &&
 800       z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]+0.5)
 801 #else
 802 int extentImageReslice[6];
 803 mSlicers[slicer]->GetRegisterExtent(extentImageReslice);
 804   if (x >= extentImageReslice[0]-0.5 &&
 805       x <= extentImageReslice[1]+0.5 &&
 806       y >= extentImageReslice[2]-0.5 &&
 807       y <= extentImageReslice[3]+0.5 &&
 808       z >= extentImageReslice[4]-0.5 &&
 809       z <= extentImageReslice[5]+0.5)
 810 #endif
 811   {
 812     for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++) {
 813                 if (this->IsInvolvedInFusionSequence()) {
 814                         //this SlicerManager is involved in fusionSequence => do not synchronize the times
 815                         emit UpdateLinkManager(*i, slicer, p[0], p[1], p[2], -1);
 816                 }
 817                 else {
 818                         emit UpdateLinkManager(*i, slicer, p[0], p[1], p[2], mSlicers[slicer]->GetMaxCurrentTSlice());
 819                 }
 820     }
 821   }
 822 }
 823 //----------------------------------------------------------------------------
 824
 825 //----------------------------------------------------------------------------
 826 void vvSlicerManager::UpdateLinkedNavigation(vvSlicer *refSlicer, bool bPropagate)
 827 {
 828   vtkCamera *refCam = refSlicer->GetRenderer()->GetActiveCamera();
 829
 830   double refPosition[3];
 831   refCam->GetPosition(refPosition);
 832   refPosition[refSlicer->GetSliceOrientation()] = refSlicer->GetSlice() *
 833       refSlicer->GetInput()->GetSpacing()[refSlicer->GetSliceOrientation()] +
 834       refSlicer->GetInput()->GetOrigin()[refSlicer->GetSliceOrientation()];
 835
 836   refSlicer->GetSlicingTransform()->TransformPoint(refPosition, refPosition);
 837   mSlicers[0]->GetSlicingTransform()->GetInverse()->TransformPoint(refPosition, refPosition);
 838
 839   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 840     vtkCamera *camera = mSlicers[i]->GetRenderer()->GetActiveCamera();
 841     camera->SetParallelScale(refCam->GetParallelScale());
 842
 843     double position[3], focal[3];
 844     camera->GetPosition(position);
 845     camera->GetFocalPoint(focal);
 846
 847     for(int j=0; j<3; j++) {
 848       if(j!=mSlicers[i]->GetSliceOrientation()) {
 849         position[j] = refPosition[j];
 850         focal[j]    = refPosition[j];
 851       }
 852     }
 853
 854     camera->SetFocalPoint(focal);
 855     camera->SetPosition(position);
 856
 857     //Fix for bug #243
 858     mSlicers[i]->ForceUpdateDisplayExtent();
 859   }
 860
 861   Render();
 862   if(bPropagate)
 863     for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++)
 864       emit UpdateLinkedNavigation(*i, this, refSlicer);
 865 }
 866 //----------------------------------------------------------------------------
 867
 868 //----------------------------------------------------------------------------
 869 double vvSlicerManager::GetColorWindow() const
 870 {
 871   if (mSlicers.size())
 872     return mSlicers[0]->GetColorWindow();
 873   return -1;
 874 }
 875 //----------------------------------------------------------------------------
 876
 877
 878 //----------------------------------------------------------------------------
 879 double vvSlicerManager::GetColorLevel() const
 880 {
 881   if (mSlicers.size())
 882     return mSlicers[0]->GetColorLevel();
 883   return -1;
 884 }
 885 //----------------------------------------------------------------------------
 886
 887 //----------------------------------------------------------------------------
 888 double vvSlicerManager::GetOverlayColorWindow() const
 889 {
 890   if (mSlicers.size())
 891     return mSlicers[0]->GetOverlayColorWindow();
 892   return -1;
 893 }
 894 //----------------------------------------------------------------------------
 895
 896 //----------------------------------------------------------------------------
 897 double vvSlicerManager::GetOverlayColorLevel() const
 898 {
 899   if (mSlicers.size())
 900     return mSlicers[0]->GetOverlayColorLevel();
 901   return -1;
 902 }
 903 //----------------------------------------------------------------------------
 904
 905 //----------------------------------------------------------------------------
 906 bool vvSlicerManager::GetLinkOverlayWindowLevel() const
 907 {
 908   if (mSlicers.size())
 909     return mSlicers[0]->GetLinkOverlayWindowLevel();
 910   return -1;
 911 }
 912 //----------------------------------------------------------------------------
 913
 914 //------------------------------------------------------------------------------
 915 void vvSlicerManager::ResetTransformationToIdentity(const std::string actorType)
 916 {
 917   if(actorType == "image")
 918     for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
 919       this->GetImage()->GetTransform()[i]->Identity();
 920   else if(actorType == "overlay")
 921     for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
 922       this->GetSlicer(0)->GetOverlay()->GetTransform()[i]->Identity();
 923   else if(actorType == "fusion")
 924     for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
 925       this->GetSlicer(0)->GetFusion()->GetTransform()[i]->Identity();
 926   else if(actorType == "fusionSequence") //TODO: Check what should really be done here
 927     for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
 928       this->GetSlicer(0)->GetFusion()->GetTransform()[i]->Identity();
 929   else if(actorType == "vf")
 930     for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
 931       this->GetVF()->GetTransform()[i]->Identity();
 932   else
 933     return;
 934
 935   for(int i=0; i< this->GetNumberOfSlicers(); i++){
 936     this->GetSlicer(i)->ForceUpdateDisplayExtent();
 937     this->GetSlicer(i)->ResetCamera();
 938     this->GetSlicer(i)->Render();
 939   }
 940 }
 941 //------------------------------------------------------------------------------
 942
 943 //----------------------------------------------------------------------------
 944 void vvSlicerManager::Render()
 945 {
 946   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 947     mSlicers[i]->Render();
 948   }
 949 }
 950 //----------------------------------------------------------------------------
 951
 952
 953 //----------------------------------------------------------------------------
 954 void vvSlicerManager::GenerateDefaultLookupTable()
 955 {
 956   SetPreset(mPreset);
 957   SetColorMap(mColorMap);
 958 }
 959 //----------------------------------------------------------------------------
 960
 961
 962 //----------------------------------------------------------------------------
 963 void vvSlicerManager::Reload()
 964 {
 965   mReader->Update(mType);
 966   mImage=mReader->GetOutput();
 967   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 968     mSlicers[i]->SetImage(mImage);
 969   }
 970
 971   //if this image is the primary sequence of a fusion sequence, then the main transform matrix should be updated.
 972   if (this->IsMainSequenceOfFusionSequence()) {
 973           SetFusionSequenceMainTransformMatrix( mImage->GetTransform()[0]->GetMatrix() );
 974   }
 975 }
 976 //----------------------------------------------------------------------------
 977
 978
 979 //----------------------------------------------------------------------------
 980 void vvSlicerManager::ReloadFusion()
 981 {
 982   mFusionReader->Update(mImage->GetNumberOfDimensions(),mFusionComponent.c_str(),mType);
 983
 984   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 985     mSlicers[i]->SetFusion(mFusionReader->GetOutput());
 986     mSlicers[i]->Render();
 987   }
 988 }
 989 //----------------------------------------------------------------------------
 990
 991 //----------------------------------------------------------------------------
 992 //the secondary sequence is being reloaded.
 993 void vvSlicerManager::ReloadFusionSequence()
 994 {
 995   //  this is to keep the slice thickness, which needs to be artificially increased for visualization
 996   double sp_x, sp_y, sp_z;
 997   this->GetImage()->GetVTKImages()[0]->GetSpacing(sp_x, sp_y, sp_z);
 998
 999   mFusionSequenceReader->Update(mImage->GetNumberOfDimensions(),mFusionComponent.c_str(),vvImageReader::MERGEDWITHTIME);
1000
1001   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
1002     mSlicers[i]->SetFusion(mFusionSequenceReader->GetOutput(), 1);
1003     mSlicers[i]->Render();
1004   }
1005
1006   //Update the slider
1007   mFusionSequenceNbFrames = mFusionSequenceReader->GetOutput()->GetTransform().size();
1008   if (mFusionSequenceFrameIndex>=mFusionSequenceNbFrames) {
1009           mFusionSequenceFrameIndex=0;
1010   }
1011
1012   //Update the list of initial transforms
1013   mFusionSequenceListInitialTransformMatrices.clear();
1014   for (unsigned i=0 ; i<mFusionSequenceNbFrames ; i++) {
1015           this->AddFusionSequenceInitialTransformMatrices( mFusionSequenceReader->GetOutput()->GetTransform()[i]->GetMatrix() );
1016   }
1017
1018   //  also update the slice thickness
1019   for (unsigned i=0 ; i<this->GetImage()->GetTransform().size() ; i++) {
1020     sp_x = this->GetImage()->GetVTKImages()[i]->GetSpacing()[0];
1021     sp_y = this->GetImage()->GetVTKImages()[i]->GetSpacing()[1];
1022     this->GetImage()->GetVTKImages()[i]->SetSpacing( sp_x, sp_y, sp_z);
1023   }
1024
1025 }
1026 //----------------------------------------------------------------------------
1027
1028
1029 //----------------------------------------------------------------------------
1030 void vvSlicerManager::ReloadOverlay()
1031 {
1032   mOverlayReader->Update(mImage->GetNumberOfDimensions(),mOverlayComponent.c_str(),mType);
1033   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
1034     mSlicers[i]->SetOverlay(mOverlayReader->GetOutput());
1035     mSlicers[i]->Render();
1036   }
1037 }
1038 //----------------------------------------------------------------------------
1039
1040
1041 //----------------------------------------------------------------------------
1042 void vvSlicerManager::ReloadVF()
1043 {
1044   mVectorReader->Update(vvImageReader::VECTORFIELD); //deletes the old images through the VF::Init() function
1045   mVF=mVectorReader->GetOutput();
1046   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
1047     mSlicers[i]->SetVF(mVF);
1048     mSlicers[i]->Render();
1049   }
1050 }
1051 //----------------------------------------------------------------------------
1052
1053
1054 //----------------------------------------------------------------------------
1055 void vvSlicerManager::RemoveActor(const std::string& actor_type, int overlay_index)
1056 {
1057   if (actor_type =="overlay")
1058     mOverlayReader = NULL;
1059
1060   if (actor_type =="fusion")
1061     mFusionReader = NULL;
1062
1063   if (actor_type =="fusionSequence") {
1064     mFusionSequenceReader = NULL;
1065   }
1066
1067   for (unsigned int i = 0; i < mSlicers.size(); i++)
1068     mSlicers[i]->RemoveActor(actor_type,overlay_index);
1069
1070   if (actor_type=="vector") {
1071     mVF=NULL;
1072     mVectorReader=NULL;
1073   }
1074 }
1075 //----------------------------------------------------------------------------
1076
1077
1078 //----------------------------------------------------------------------------
1079 void vvSlicerManager::RemoveActors()
1080 {
1081   ///This method leaks a few objects. See RemoveActor for what a
1082   ///correct implementation would look like
1083   //DS -> probably due to the reader (now released in the
1084   //RemoveActor() function. (I hope)
1085   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
1086     mSlicers[i]->SetDisplayMode(0);
1087     mSlicers[i]->GetRenderer()->RemoveActor(mSlicers[i]->GetImageActor());
1088   }
1089 }
1090 //----------------------------------------------------------------------------
1091
1092
1093 //----------------------------------------------------------------------------
1094 void vvSlicerManager::UpdateInfoOnCursorPosition(int slicer)
1095 {
1096   //  int view = mSlicers[slicer]->GetSliceOrientation();
1097   //  int slice = mSlicers[slicer]->GetSlice();
1098   double x = mSlicers[slicer]->GetCurrentPosition()[0];
1099   double y = mSlicers[slicer]->GetCurrentPosition()[1];
1100   double z = mSlicers[slicer]->GetCurrentPosition()[2];
1101   double xyz[3], xyzTransform[3];
1102   xyz[0] = x;
1103   xyz[1] = y;
1104   xyz[2] = z;
1105   mSlicers[slicer]->GetSlicingTransform()->GetInverse()->TransformPoint(xyz, xyzTransform);
1106   double X = (xyzTransform[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0])/mSlicers[slicer]->GetInput()->GetSpacing()[0];
1107   double Y = (xyzTransform[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1])/mSlicers[slicer]->GetInput()->GetSpacing()[1];
1108   double Z = (xyzTransform[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2])/mSlicers[slicer]->GetInput()->GetSpacing()[2];
1109   double value = -VTK_DOUBLE_MAX;
1110   int displayVec = 0;
1111   double xVec=0, yVec=0, zVec=0, valueVec=0;
1112   int displayOver = 0;
1113   int displayFus = 0;
1114   double valueOver=0, valueFus=0;
1115 #if VTK_MAJOR_VERSION <= 5
1116     if (X >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] -0.5 &&
1117       X <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] +0.5 &&
1118       Y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] -0.5 &&
1119       Y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] +0.5 &&
1120       Z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] -0.5 &&
1121       Z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5] +0.5)
1122 #else
1123 int extentImageReslice[6];
1124 mSlicers[slicer]->GetRegisterExtent(extentImageReslice);
1125     if (X >= extentImageReslice[0] -0.5 &&
1126       X <= extentImageReslice[1] +0.5 &&
1127       Y >= extentImageReslice[2] -0.5 &&
1128       Y <= extentImageReslice[3] +0.5 &&
1129       Z >= extentImageReslice[4] -0.5 &&
1130       Z <= extentImageReslice[5] +0.5)
1131 #endif
1132     {
1133     value = this->GetScalarComponentAsDouble(mSlicers[slicer]->GetInput(), X, Y, Z);
1134
1135     if (mSlicers[slicer]->GetVFActor() ) {
1136       displayVec = 1;
1137       unsigned int currentTime = mSlicers[slicer]->GetMaxCurrentTSlice();
1138       vtkImageData *vf = NULL;
1139
1140       if (mSlicers[slicer]->GetVF()->GetVTKImages().size() > currentTime)
1141         vf = mSlicers[slicer]->GetVF()->GetVTKImages()[currentTime];
1142       else
1143         vf = mSlicers[slicer]->GetVF()->GetVTKImages()[0];
1144
1145       if (vf) {
1146         double Xvf = (x - vf->GetOrigin()[0])/ vf->GetSpacing()[0];
1147         double Yvf = (y - vf->GetOrigin()[1])/ vf->GetSpacing()[1];
1148         double Zvf = (z - vf->GetOrigin()[2])/ vf->GetSpacing()[2];
1149         xVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 0);
1150         yVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 1);
1151         zVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 2);
1152         valueVec = sqrt(xVec*xVec + yVec*yVec + zVec*zVec);
1153       }
1154     }
1155     if (mSlicers[slicer]->GetOverlayActor() ) {
1156       displayOver = 1;
1157       vtkImageData *overlay = dynamic_cast<vtkImageData*>(mSlicers[slicer]->GetOverlayMapper()->GetInput());
1158       double Xover = (x - overlay->GetOrigin()[0]) / overlay->GetSpacing()[0];
1159       double Yover = (y - overlay->GetOrigin()[1]) / overlay->GetSpacing()[1];
1160       double Zover = (z - overlay->GetOrigin()[2]) / overlay->GetSpacing()[2];
1161       valueOver = this->GetScalarComponentAsDouble(overlay, Xover, Yover, Zover);
1162     }
1163
1164         if ( mSlicers[slicer]->GetFusionActor() ) {
1165                 displayFus = 1;
1166                 vtkImageData *fusion = dynamic_cast<vtkImageData*>(mSlicers[slicer]->GetFusionMapper()->GetInput());
1167                 double Xover = (x - fusion->GetOrigin()[0]) / fusion->GetSpacing()[0];
1168                 double Yover = (y - fusion->GetOrigin()[1]) / fusion->GetSpacing()[1];
1169                 double Zover = (z - fusion->GetOrigin()[2]) / fusion->GetSpacing()[2];
1170                 valueFus = this->GetScalarComponentAsDouble(fusion, Xover, Yover, Zover);
1171         }
1172         else if (this->IsInvolvedInFusionSequence()) {
1173     //if the cursor moves over the 'independent' version of the secondary sequence
1174     //do not update the panel, just keep it as it is.
1175                 displayFus = 1;
1176                 valueFus = std::numeric_limits<double>::quiet_NaN();
1177         }
1178
1179     emit UpdatePosition(mSlicers[slicer]->GetCursorVisibility(),
1180                         x,y,z,X,Y,Z,value);
1181     emit UpdateVector(displayVec,xVec, yVec, zVec, valueVec);
1182     emit UpdateOverlay(displayOver,valueOver,value);
1183     emit UpdateFusion(displayFus,valueFus);
1184   }
1185 }
1186 //----------------------------------------------------------------------------
1187
1188
1189 //----------------------------------------------------------------------------
1190 void vvSlicerManager::Activated()
1191 {
1192   emit currentImageChanged(mId);
1193 }
1194 //----------------------------------------------------------------------------
1195
1196
1197 //----------------------------------------------------------------------------
1198 void vvSlicerManager::Picked()
1199 {
1200   emit currentPickedImageChanged(mId);
1201 }
1202 //----------------------------------------------------------------------------
1203
1204
1205 //----------------------------------------------------------------------------
1206 void vvSlicerManager::UpdateWindowLevel()
1207 {
1208   emit WindowLevelChanged();
1209 }
1210 //----------------------------------------------------------------------------
1211
1212
1213 //----------------------------------------------------------------------------
1214 void vvSlicerManager::UpdateSlice(int slicer)
1215 {
1216   if (mPreviousSlice[slicer] == mSlicers[slicer]->GetSlice()) {
1217     //DD("============= NOTHING");
1218     return;
1219   }
1220   emit UpdateSlice(slicer, mSlicers[slicer]->GetSlice());
1221   mSlicers[slicer]->Render(); // DS <-- I add this, this could/must be the only Render ...
1222   mPreviousSlice[slicer] = mSlicers[slicer]->GetSlice();
1223 }
1224 //----------------------------------------------------------------------------
1225
1226
1227 //----------------------------------------------------------------------------
1228 void vvSlicerManager::UpdateTSlice(int slicer)
1229 {
1230   int slice = mSlicers[slicer]->GetSlice();
1231
1232   int tslice = mSlicers[slicer]->GetMaxCurrentTSlice();
1233   //if (this->IsInvolvedInFusionSequence()) tslice = mSlicers[slicer]->GetTSlice(); //actually, this is handled by the Slicer
1234
1235   if (mPreviousSlice[slicer] == slice) {
1236     if (mPreviousTSlice[slicer] == tslice) {
1237       //      DD("************** NOTHING ***********");
1238       return;
1239     }
1240   }
1241   mPreviousSlice[slicer] = slice;
1242   mPreviousTSlice[slicer] = tslice;
1243
1244   emit UpdateTSlice(slicer, tslice, mFusionSequenceInvolvementCode);
1245 }
1246 //----------------------------------------------------------------------------
1247
1248
1249 //----------------------------------------------------------------------------
1250 void vvSlicerManager::UpdateSliceRange(int slicer)
1251 {
1252   emit UpdateSliceRange(slicer,
1253                         mSlicers[slicer]->GetSliceRange()[0], mSlicers[slicer]->GetSliceRange()[1],
1254                         0,mSlicers[slicer]->GetTMax());
1255 }
1256 //----------------------------------------------------------------------------
1257
1258 //----------------------------------------------------------------------------
1259 void vvSlicerManager::SetSlicingPreset(SlicingPresetType preset)
1260 {
1261   if(mSlicingPreset==preset)
1262     return;
1263
1264   vtkMatrix4x4 *imageTransformInverse = vtkMatrix4x4::New();
1265   mImage->GetTransform()[this->GetTSlice()]->GetInverse(imageTransformInverse);
1266
1267   for(int i=0; i< this->GetNumberOfSlicers(); i++){
1268     vvSlicer *s = this->GetSlicer(i);
1269     switch(preset)
1270     {
1271     case WORLD_SLICING:
1272       s->GetSlicingTransform()->Identity();
1273       break;
1274     case VOXELS_SLICING:
1275       s->GetSlicingTransform()->SetMatrix(imageTransformInverse);
1276       break;
1277     default:
1278       imageTransformInverse->Delete();
1279       return;
1280     }
1281     s->ForceUpdateDisplayExtent();
1282 #if VTK_MAJOR_VERSION <= 5
1283     s->SetSlice((s->GetInput()->GetWholeExtent()[s->GetSliceOrientation()*2+1]
1284                 +s->GetInput()->GetWholeExtent()[s->GetSliceOrientation()*2])/2.0);
1285 #else
1286     int extentImageReslice[6];
1287     s->GetRegisterExtent(extentImageReslice);
1288     s->SetSlice((extentImageReslice[s->GetSliceOrientation()*2+1]
1289                 +extentImageReslice[s->GetSliceOrientation()*2])/2.0);
1290 #endif
1291     s->ResetCamera();
1292     s->Render();
1293   }
1294
1295   imageTransformInverse->Delete();
1296   mSlicingPreset = preset;
1297 }
1298
1299 //----------------------------------------------------------------------------
1300
1301 //----------------------------------------------------------------------------
1302 void vvSlicerManager::SetPreset(int preset)
1303 {
1304
1305   //vtkLookupTable* LUT = static_cast<vtkLookupTable*>(mSlicers[0]->GetWindowLevel()->GetLookupTable());
1306   double window = mSlicers[0]->GetColorWindow();
1307   double level = mSlicers[0]->GetColorLevel();
1308
1309   std::string component_type=mImage->GetScalarTypeAsITKString();
1310   switch (preset) {
1311   case WL_AUTO:
1312     double range[2];
1313     mImage->GetScalarRange(range);
1314     window = range[1] - range[0];
1315     level = (range[1] + range[0])* 0.5;
1316     break;
1317   case WL_HOUNSFIELD:
1318     window = 2000;
1319     level = 0;
1320     break;
1321   case WL_SOFTTISSUE:
1322     window = 400;
1323     level = 20;
1324     break;
1325   case WL_LUNGS: // lungs (same as FOCAL)
1326     window = 1700;
1327     level = -300;
1328     break;
1329   case WL_BONES:
1330     window = 1000;
1331     level = 500;
1332     break;
1333   case WL_HEAD:
1334     window = 200;
1335     level = 70;
1336     break;
1337   case WL_BINARY:
1338     window = 1;
1339     level = 0.5;
1340     break;
1341   case WL_USER:
1342     break;
1343   case WL_VENTILATION:
1344     window=1.;
1345     level=0.;
1346     break;
1347   }
1348   mPreset = preset;
1349   this->SetColorWindow(window);
1350   this->SetColorLevel(level);
1351
1352   //if (LUT)
1353   //{
1354   //    SetColorMap(-1);
1355   //}
1356 }
1357 //----------------------------------------------------------------------------
1358
1359
1360 //----------------------------------------------------------------------------
1361 void vvSlicerManager::SetLocalColorWindowing(const int slicer, const bool bCtrlKey)
1362 {
1363   double min, max;
1364   if(bCtrlKey && this->mSlicers[slicer]->GetFusion()) {
1365     int t = mSlicers[slicer]->GetFusionTSlice();
1366     this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max,
1367                                                           this->mSlicers[slicer]->GetFusion()->GetVTKImages()[t],
1368                                                           this->mSlicers[slicer]->GetConcatenatedFusionTransform());
1369     this->SetFusionWindow(max-min);
1370     this->SetFusionLevel(0.5*(min+max));
1371     this->SetColorMap(mColorMap);
1372   }
1373   else if(bCtrlKey && this->mSlicers[slicer]->GetOverlay()) {
1374     int t = mSlicers[slicer]->GetOverlayTSlice();
1375     this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max,
1376                                                           this->mSlicers[slicer]->GetOverlay()->GetVTKImages()[t],
1377                                                           this->mSlicers[slicer]->GetConcatenatedOverlayTransform());
1378     if(this->mSlicers[slicer]->GetLinkOverlayWindowLevel()){
1379       this->SetColorWindow(max-min);
1380       this->SetColorLevel(0.5*(min+max));
1381     } else {
1382       this->SetOverlayColorWindow(max-min);
1383       this->SetOverlayColorLevel(0.5*(min+max));
1384     }
1385   }
1386   else {
1387     int t = this->GetTSlice();
1388     this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max,
1389                                                           this->mSlicers[slicer]->GetImage()->GetVTKImages()[t],
1390                                                           this->mSlicers[slicer]->GetConcatenatedTransform());
1391     this->SetColorWindow(max-min);
1392     this->SetColorLevel(0.5*(min+max));
1393     this->SetPreset(WL_USER);
1394   }
1395   this->Render();
1396   this->UpdateWindowLevel();
1397 }
1398 //----------------------------------------------------------------------------
1399
1400
1401 //----------------------------------------------------------------------------
1402 void vvSlicerManager::SetColorMap(int colormap)
1403 {
1404   double range[2];
1405
1406   range[0] = mSlicers[0]->GetInput()->GetScalarRange()[0];
1407   range[1] = mSlicers[0]->GetInput()->GetScalarRange()[1];
1408
1409   double window = mSlicers[0]->GetWindowLevel()->GetWindow();
1410   double level = mSlicers[0]->GetWindowLevel()->GetLevel();
1411
1412   vtkLookupTable* LUT = static_cast<vtkLookupTable*>(mSlicers[0]->GetWindowLevel()->GetLookupTable());
1413   switch (colormap) {
1414   case -1:
1415     break;
1416   case 0:
1417     LUT = NULL;
1418     break;
1419   case 1:
1420     if (LUT == NULL)
1421       LUT = vtkLookupTable::New();
1422     LUT->SetValueRange(0,1);
1423     LUT->SetSaturationRange(1,1);
1424     LUT->SetHueRange(0,0.18);
1425     break;
1426   case 2:
1427     if (LUT == NULL)
1428       LUT = vtkLookupTable::New();
1429     LUT->SetValueRange(0,1);
1430     LUT->SetSaturationRange(1,1);
1431     LUT->SetHueRange(0.4,0.80);
1432     break;
1433   case 3:
1434     if (LUT == NULL)
1435       LUT = vtkLookupTable::New();
1436     LUT->SetValueRange(0.5,1);
1437     LUT->SetSaturationRange(1,1);
1438     LUT->SetHueRange(0.666,0);
1439     break;
1440   case 4:
1441     if (LUT == NULL)
1442       LUT = vtkLookupTable::New();
1443     LUT->SetValueRange(1,1);
1444     LUT->SetSaturationRange(1,1);
1445     LUT->SetHueRange(0,1);
1446     LUT->SetAlphaRange(1, 1);
1447     break;
1448   case 5:
1449     if (LUT == NULL)
1450       LUT = vtkLookupTable::New();
1451     LUT->SetValueRange(1,1);
1452     LUT->SetSaturationRange(1,1);
1453     LUT->SetHueRange(1,0.1);
1454     //LUT->SetRampToLinear();
1455     break;
1456   }
1457   if (LUT) {
1458     LUT->SetTableRange(level-fabs(window)/2,level+fabs(window)/2);
1459     LUT->Build();
1460   }
1461   vtkWindowLevelLookupTable* fusLUT = NULL;
1462
1463   //FUSION / FUSION SEQUENCE
1464   if (mSlicers[0]->GetFusion()) { // && mFusionColorMap >= 0) {
1465     fusLUT = vtkWindowLevelLookupTable::New();
1466     double fusRange [2];
1467     fusRange[0] = mFusionLevel - mFusionWindow/2;
1468     fusRange[1] = mFusionLevel + mFusionWindow/2;
1469
1470     //check whether it is actually a fusionSequence or a fusion, before invoking mFusionReader...
1471     double* frange;
1472     if (this->IsInvolvedInFusionSequence())
1473       frange = mFusionSequenceReader->GetOutput()->GetVTKImages()[0]->GetScalarRange();
1474     else
1475       frange = mFusionReader->GetOutput()->GetVTKImages()[0]->GetScalarRange();
1476
1477     fusLUT->SetTableRange(frange);
1478     fusLUT->SetValueRange(1,1);
1479     fusLUT->SetSaturationRange(1,1);
1480     fusLUT->SetAlphaRange(1, 1);
1481     fusLUT->SetWindow(mFusionWindow);
1482     fusLUT->SetLevel(mFusionLevel);
1483     if (mFusionColorMap == 1)
1484       fusLUT->SetHueRange(0,0.18);
1485     else if (mFusionColorMap == 2)
1486       fusLUT->SetHueRange(0.4,0.80);
1487     else if (mFusionColorMap == 3)
1488     {
1489       fusLUT->SetHueRange(0.666, 0);
1490       fusLUT->SetValueRange(0.5, 1);
1491     }
1492     else if (mFusionColorMap == 4)
1493       fusLUT->SetHueRange(0,1);
1494     else if (mFusionColorMap <= 0)
1495     {
1496       fusLUT->SetValueRange(0,1);
1497       fusLUT->SetSaturationRange(0,0);
1498     }
1499
1500     fusLUT->ForceBuild();
1501     double v[4];
1502     // set color table transparency
1503     //double alpha_range=(double)mFusionThresOpacity/10;
1504     double range_end = fusRange[0] + (double)mFusionThresOpacity*(fusRange[1] - fusRange[0])/100;
1505     double curr_value = fusRange[0];
1506     int nvalues = fusLUT->GetNumberOfTableValues();
1507     for (double i = 0; curr_value < range_end; i++) {
1508       fusLUT->GetTableValue(i, v);
1509       v[3] = 0;
1510       //if (curr_value >= -alpha_range && curr_value <= alpha_range) v[3] = pow(fabs(curr_value/alpha_range),2);
1511       //else v[3] = 1;
1512       fusLUT->SetTableValue(i, v);
1513       curr_value += (fusRange[1] - fusRange[0])/nvalues;
1514     }
1515   }
1516   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
1517
1518     if (mSlicers[i]->GetOverlay()) {
1519       vtkLookupTable* supLUT = vtkLookupTable::New();
1520       supLUT->SetTableRange(range[0],range[1]);
1521       supLUT->SetValueRange(1,1);
1522       supLUT->SetSaturationRange(1,1);
1523       supLUT->SetHueRange(double(mOverlayColor)/360,double(mOverlayColor)/360);
1524       supLUT->Build();
1525       vtkLookupTable* invLUT = vtkLookupTable::New();
1526       invLUT->SetTableRange(range[0],range[1]);
1527       invLUT->SetValueRange(1,1);
1528       invLUT->SetSaturationRange(1,1);
1529       invLUT->SetHueRange(double((mOverlayColor+180)%360)/360,double((mOverlayColor+180)%360)/360);
1530       invLUT->Build();
1531       mSlicers[i]->GetWindowLevel()->SetLookupTable(supLUT);
1532       mSlicers[i]->GetOverlayMapper()->SetLookupTable(invLUT);
1533       invLUT->Delete();
1534       supLUT->Delete();
1535     } else if (mSlicers[i]->GetOverlay()) {
1536       mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT);
1537     } else {
1538       mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT);
1539     }
1540
1541     if (mSlicers[i]->GetFusion()) {
1542       mSlicers[i]->ShowFusionLegend(mFusionShowLegend);
1543       mSlicers[i]->GetFusionMapper()->SetLookupTable(fusLUT);
1544       mSlicers[i]->GetFusionActor()->SetOpacity(double(mFusionOpacity)/100);
1545     }
1546   }
1547   if (fusLUT)
1548     fusLUT->Delete();
1549   if (colormap >= 0)
1550     mColorMap = colormap;
1551 }
1552 //----------------------------------------------------------------------------
1553
1554
1555 //----------------------------------------------------------------------------
1556 vvLandmarks* vvSlicerManager::GetLandmarks()
1557 {
1558   if (mLandmarks == NULL) {
1559     mLandmarks = new vvLandmarks(mSlicers[0]->GetTMax()+1);
1560     for (unsigned int i = 0; i < mSlicers.size(); i++)
1561       mSlicers[i]->SetLandmarks(mLandmarks);
1562   }
1563   return mLandmarks;
1564 }
1565 //----------------------------------------------------------------------------
1566 void vvSlicerManager::AddNewLandmark(float x,float y,float z,float t)
1567 {
1568     emit callAddLandmark(x,y,z,t);
1569 }
1570
1571 //----------------------------------------------------------------------------
1572 void vvSlicerManager::AddLandmark(float x,float y,float z,float t)
1573 {
1574   double x_index = (x - mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetOrigin()[0])/mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetSpacing()[0];
1575   double y_index = (y - mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetOrigin()[1])/mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetSpacing()[1];
1576   double z_index = (z - mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetOrigin()[2])/mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetSpacing()[2];
1577 #if VTK_MAJOR_VERSION <= 5
1578     if (x_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[0]-0.5 &&
1579         x_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[1]+0.5 &&
1580         y_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[2]-0.5 &&
1581         y_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[3]+0.5 &&
1582         z_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[4]-0.5 &&
1583         z_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[5]+0.5)
1584 #else
1585     if (x_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[0]-0.5 &&
1586         x_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[1]+0.5 &&
1587         y_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[2]-0.5 &&
1588         y_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[3]+0.5 &&
1589         z_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[4]-0.5 &&
1590         z_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[5]+0.5)
1591 #endif
1592   {
1593     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
1594     this->GetLandmarks()->AddLandmark(x,y,z,t,value);
1595     emit LandmarkAdded();
1596   }
1597 }
1598 //----------------------------------------------------------------------------
1599
1600 //----------------------------------------------------------------------------
1601 void vvSlicerManager::AddLandmarkProfile(float x,float y,float z,float t)
1602 {
1603   double x_index = (x - mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetOrigin()[0])/mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetSpacing()[0];
1604   double y_index = (y - mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetOrigin()[1])/mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetSpacing()[1];
1605   double z_index = (z - mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetOrigin()[2])/mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetSpacing()[2];
1606 #if VTK_MAJOR_VERSION <= 5
1607     if (x_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[0]-0.5 &&
1608         x_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[1]+0.5 &&
1609         y_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[2]-0.5 &&
1610         y_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[3]+0.5 &&
1611         z_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[4]-0.5 &&
1612         z_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[5]+0.5)
1613 #else
1614     if (x_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[0]-0.5 &&
1615         x_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[1]+0.5 &&
1616         y_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[2]-0.5 &&
1617         y_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[3]+0.5 &&
1618         z_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[4]-0.5 &&
1619         z_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[5]+0.5)
1620 #endif
1621   {
1622     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
1623     this->GetLandmarks()->AddLandmark(x,y,z,t,value);
1624   }
1625 }
1626 //----------------------------------------------------------------------------
1627
1628 //----------------------------------------------------------------------------
1629 void vvSlicerManager::UpdateLandmark()
1630 {
1631     this->GetLandmarks()->TransformUpdate(mSlicers[mSelectedSlicer]->GetConcatenatedTransform()->GetInverse());
1632 }
1633 //----------------------------------------------------------------------------
1634
1635 //----------------------------------------------------------------------------
1636 void vvSlicerManager::PrevImage(int slicer)
1637 {
1638   emit ChangeImageWithIndexOffset(this, slicer, -1);
1639 }
1640 //----------------------------------------------------------------------------
1641
1642 //----------------------------------------------------------------------------
1643 void vvSlicerManager::NextImage(int slicer)
1644 {
1645   emit ChangeImageWithIndexOffset(this, slicer,  1);
1646 }
1647 //----------------------------------------------------------------------------
1648
1649 //----------------------------------------------------------------------------
1650 void vvSlicerManager::VerticalSliderHasChanged(int slicer, int slice)
1651 {
1652   emit AVerticalSliderHasChanged(slicer, slice);
1653 }
1654
1655 //----------------------------------------------------------------------------
1656
1657 //----------------------------------------------------------------------------
1658 double vvSlicerManager::GetScalarComponentAsDouble(vtkImageData *image, double X, double Y, double Z, int component)
1659 {
1660   int ix, iy, iz;
1661   return mSlicers[0]->GetScalarComponentAsDouble(image, X, Y, Z, ix, iy, iz, component);
1662 }
1663 //----------------------------------------------------------------------------