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