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 //----------------------------------------------------------------------------
 386 void vvSlicerManager::SetTSlice(int slice)
 387 {
 388   if (slice < 0)
 389     slice = 0;
 390   else if (slice > mSlicers[0]->GetTMax())
 391     slice = mSlicers[0]->GetTMax();
 392   if (mLandmarks)
 393     mLandmarks->SetTime(slice);
 394   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 395     if (slice != mSlicers[i]->GetTSlice()) {
 396       mSlicers[i]->SetTSlice(slice);
 397       if (mSlicers[i]->GetImageActor()->GetVisibility())
 398         UpdateTSlice(i);
 399     }
 400   }
 401 }
 402 //----------------------------------------------------------------------------
 403
 404
 405 //----------------------------------------------------------------------------
 406 void vvSlicerManager::SetNextTSlice(int originating_slicer)
 407 {
 408   int t = mSlicers[0]->GetTSlice();
 409   t++;
 410   if (t > mSlicers[0]->GetTMax())
 411     t = 0;
 412   emit UpdateTSlice(originating_slicer,t);
 413 }
 414 //----------------------------------------------------------------------------
 415
 416
 417 //----------------------------------------------------------------------------
 418 void vvSlicerManager::SetPreviousTSlice(int originating_slicer)
 419 {
 420   int t = mSlicers[0]->GetTSlice();
 421   t--;
 422   if (t < 0)
 423     t = mSlicers[0]->GetTMax();
 424   emit UpdateTSlice(originating_slicer,t);
 425 }
 426 //----------------------------------------------------------------------------
 427
 428
 429 //----------------------------------------------------------------------------
 430 void vvSlicerManager::ToggleInterpolation()
 431 {
 432   bool interpolate=!(mSlicers[0]->GetImageActor()->GetInterpolate());
 433   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 434     mSlicers[i]->GetImageActor()->SetInterpolate(interpolate);
 435     if (mSlicers[i]->GetOverlayActor())
 436       mSlicers[i]->GetOverlayActor()->SetInterpolate(interpolate);
 437     if (mSlicers[i]->GetFusionActor())
 438       mSlicers[i]->GetFusionActor()->SetInterpolate(interpolate);
 439   }
 440 }
 441 //----------------------------------------------------------------------------
 442
 443
 444 //----------------------------------------------------------------------------
 445 void vvSlicerManager::SetTSliceInSlicer(int tslice, int slicer)
 446 {
 447   if (tslice < 0)
 448     tslice = 0;
 449   else if (tslice > mSlicers[slicer]->GetTMax())
 450     tslice = mSlicers[slicer]->GetTMax();
 451   if (mLandmarks)
 452     mLandmarks->SetTime(tslice);
 453
 454   if (mSlicers[slicer]->GetTSlice() == tslice) return;
 455
 456   mSlicers[slicer]->SetTSlice(tslice);
 457   if (mSlicers[slicer]->GetImageActor()->GetVisibility())
 458     UpdateTSlice(slicer);
 459 }
 460 //----------------------------------------------------------------------------
 461
 462
 463 //----------------------------------------------------------------------------
 464 void vvSlicerManager::SetColorWindow(double s)
 465 {
 466   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 467     mSlicers[i]->SetColorWindow(s);
 468   }
 469 }
 470 //----------------------------------------------------------------------------
 471
 472
 473 //----------------------------------------------------------------------------
 474 void vvSlicerManager::SetColorLevel(double s)
 475 {
 476   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 477     mSlicers[i]->SetColorLevel(s);
 478   }
 479 }
 480 //----------------------------------------------------------------------------
 481
 482 //----------------------------------------------------------------------------
 483 void vvSlicerManager::SetCursorAndCornerAnnotationVisibility(int s)
 484 {
 485   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 486     mSlicers[i]->SetCursorVisibility(s);
 487     mSlicers[i]->SetCornerAnnotationVisibility(s);
 488   }
 489 }
 490 //----------------------------------------------------------------------------
 491
 492 //----------------------------------------------------------------------------
 493 void vvSlicerManager::SetOpacity(int i, double factor)
 494 {
 495   mSlicers[i]->SetOpacity(1/factor);
 496 }
 497 //----------------------------------------------------------------------------
 498
 499
 500 //----------------------------------------------------------------------------
 501 void vvSlicerManager::UpdateViews(int current,int slicer)
 502 {
 503   double x = (mSlicers[slicer]->GetCurrentPosition()[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0])
 504     /mSlicers[slicer]->GetInput()->GetSpacing()[0];
 505   double y = (mSlicers[slicer]->GetCurrentPosition()[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1])
 506     /mSlicers[slicer]->GetInput()->GetSpacing()[1];
 507   double z = (mSlicers[slicer]->GetCurrentPosition()[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2])
 508     /mSlicers[slicer]->GetInput()->GetSpacing()[2];
 509
 510   if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] &&
 511       x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] &&
 512       y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&
 513       y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&
 514       z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&
 515       z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]) {
 516     mSlicers[slicer]->UpdateCursorPosition();
 517     mSlicers[slicer]->SetCursorColor(10,212,255);
 518
 519     switch (mSlicers[slicer]->GetSliceOrientation()) {
 520     case vtkImageViewer2::SLICE_ORIENTATION_XY:
 521       if (mSlicers[slicer]->GetSlice() != (int)floor(z))
 522         mSlicers[slicer]->SetSlice((int)floor(z));
 523       break;
 524
 525     case vtkImageViewer2::SLICE_ORIENTATION_XZ:
 526       if (mSlicers[slicer]->GetSlice() != (int)floor(y))
 527         mSlicers[slicer]->SetSlice((int)floor(y));
 528       break;
 529
 530     case vtkImageViewer2::SLICE_ORIENTATION_YZ:
 531       if (mSlicers[slicer]->GetSlice() != (int)floor(x))
 532         mSlicers[slicer]->SetSlice((int)floor(x));
 533       break;
 534     }
 535     mSlicers[slicer]->Render();
 536
 537     for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 538       if (i != (unsigned int)slicer && mSlicers[i]->GetImageActor()->GetVisibility()
 539           && mSlicers[i]->GetRenderWindow()->GetSize()[0] > 2
 540           && mSlicers[i]->GetRenderWindow()->GetSize()[1] > 2) {
 541         mSlicers[i]->SetCurrentPosition(mSlicers[slicer]->GetCurrentPosition()[0],
 542                                         mSlicers[slicer]->GetCurrentPosition()[1],
 543                                         mSlicers[slicer]->GetCurrentPosition()[2],
 544                                         mSlicers[slicer]->GetTSlice());
 545         mSlicers[i]->UpdateCursorPosition();
 546         if (current) { //do not display corner annotation if image is the one picked
 547           mSlicers[i]->SetCurrentPosition(-VTK_DOUBLE_MAX,-VTK_DOUBLE_MAX,
 548                                           -VTK_DOUBLE_MAX, mSlicers[slicer]->GetTSlice());
 549           mSlicers[i]->SetCursorColor(255,10,212);
 550         } else {
 551           mSlicers[i]->SetCursorColor(150,10,282);
 552         }
 553         switch (mSlicers[i]->GetSliceOrientation()) {
 554         case vtkImageViewer2::SLICE_ORIENTATION_XY:
 555           if (mSlicers[i]->GetSlice() != (int)floor(z))
 556             mSlicers[i]->SetSlice((int)floor(z));
 557           break;
 558
 559         case vtkImageViewer2::SLICE_ORIENTATION_XZ:
 560           if (mSlicers[i]->GetSlice() != (int)floor(y))
 561             mSlicers[i]->SetSlice((int)floor(y));
 562           break;
 563
 564         case vtkImageViewer2::SLICE_ORIENTATION_YZ:
 565           if (mSlicers[i]->GetSlice() != (int)floor(x))
 566             mSlicers[i]->SetSlice((int)floor(x));
 567           break;
 568         }
 569
 570         mSlicers[i]->Render();
 571
 572         UpdateSlice(i);
 573         UpdateTSlice(i);
 574       }
 575     }
 576   }
 577 }
 578 //----------------------------------------------------------------------------
 579
 580
 581 //----------------------------------------------------------------------------
 582 void vvSlicerManager::UpdateLinked(int slicer)
 583 {
 584   double x = (mSlicers[slicer]->GetCurrentPosition()[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0])
 585     /mSlicers[slicer]->GetInput()->GetSpacing()[0];
 586   double y = (mSlicers[slicer]->GetCurrentPosition()[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1])
 587     /mSlicers[slicer]->GetInput()->GetSpacing()[1];
 588   double z = (mSlicers[slicer]->GetCurrentPosition()[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2])
 589     /mSlicers[slicer]->GetInput()->GetSpacing()[2];
 590
 591   if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] &&
 592       x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] &&
 593       y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&
 594       y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&
 595       z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&
 596       z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]) {
 597     for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++) {
 598       emit UpdateLinkManager(*i, slicer,mSlicers[slicer]->GetCurrentPosition()[0],
 599                              mSlicers[slicer]->GetCurrentPosition()[1],
 600                              mSlicers[slicer]->GetCurrentPosition()[2],mSlicers[slicer]->GetTSlice());
 601     }
 602   }
 603 }
 604 //----------------------------------------------------------------------------
 605
 606 //----------------------------------------------------------------------------
 607 void vvSlicerManager::UpdateLinkedNavigation(vvSlicer *refSlicer, bool bPropagate)
 608 {
 609   vtkCamera *refCam = refSlicer->GetRenderer()->GetActiveCamera();
 610   double refPosition[3], refFocal[3];
 611   refCam->GetPosition(refPosition);
 612   refCam->GetFocalPoint(refFocal);
 613
 614   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 615     vtkCamera *camera = mSlicers[i]->GetRenderer()->GetActiveCamera();
 616     camera->SetParallelScale(refCam->GetParallelScale());
 617
 618     double position[3], focal[3];
 619     camera->GetPosition(position);
 620     camera->GetFocalPoint(focal);
 621
 622     if(refSlicer->GetSliceOrientation()==mSlicers[i]->GetSliceOrientation()) {
 623       for(int i=0; i<3; i++) {
 624         position[i] = refPosition[i];
 625         focal[i]    = refFocal[i];
 626       }
 627     }
 628
 629     if(refSlicer->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XY) {
 630       if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XZ) {
 631         position[0] = refPosition[0];
 632         focal[0]    = refFocal[0];
 633       }
 634       if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_YZ) {
 635         position[1] = refPosition[1];
 636         focal[1]    = refFocal[1];
 637       }
 638     }
 639
 640     if(refSlicer->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XZ) {
 641       if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_YZ) {
 642         position[2] = refPosition[2];
 643         focal[2]    = refFocal[2];
 644       }
 645       if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XY) {
 646         position[0] = refPosition[0];
 647         focal[0]    = refFocal[0];
 648       }
 649     }
 650
 651     if(refSlicer->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_YZ) {
 652       if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XY) {
 653         position[1] = refPosition[1];
 654         focal[1]    = refFocal[1];
 655       }
 656       if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XZ) {
 657         position[2] = refPosition[2];
 658         focal[2]    = refFocal[2];
 659       }
 660     }
 661
 662     camera->SetFocalPoint(focal);
 663     camera->SetPosition(position);
 664
 665     //Fix for bug #243
 666     mSlicers[i]->ForceUpdateDisplayExtent();
 667   }
 668
 669   Render();
 670   if(bPropagate)
 671     for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++)
 672       emit UpdateLinkedNavigation(*i, this, refSlicer);
 673 }
 674 //----------------------------------------------------------------------------
 675
 676 //----------------------------------------------------------------------------
 677 double vvSlicerManager::GetColorWindow()
 678 {
 679   if (mSlicers.size())
 680     return mSlicers[0]->GetColorWindow();
 681   return -1;
 682 }
 683 //----------------------------------------------------------------------------
 684
 685
 686 //----------------------------------------------------------------------------
 687 double vvSlicerManager::GetColorLevel()
 688 {
 689   if (mSlicers.size())
 690     return mSlicers[0]->GetColorLevel();
 691   return -1;
 692 }
 693 //----------------------------------------------------------------------------
 694
 695
 696 //----------------------------------------------------------------------------
 697 void vvSlicerManager::Render()
 698 {
 699   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 700     mSlicers[i]->Render();
 701   }
 702 }
 703 //----------------------------------------------------------------------------
 704
 705
 706 //----------------------------------------------------------------------------
 707 void vvSlicerManager::GenerateDefaultLookupTable()
 708 {
 709   SetPreset(mPreset);
 710   SetColorMap(mColorMap);
 711 }
 712 //----------------------------------------------------------------------------
 713
 714
 715 //----------------------------------------------------------------------------
 716 void vvSlicerManager::Reload()
 717 {
 718   mReader->Update(mType);
 719   mImage=mReader->GetOutput();
 720   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 721     mSlicers[i]->SetImage(mImage);
 722   }
 723 }
 724 //----------------------------------------------------------------------------
 725
 726
 727 //----------------------------------------------------------------------------
 728 void vvSlicerManager::ReloadFusion()
 729 {
 730   mFusionReader->Update();
 731   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 732     mSlicers[i]->SetFusion(mFusionReader->GetOutput());
 733     mSlicers[i]->Render();
 734   }
 735 }
 736 //----------------------------------------------------------------------------
 737
 738
 739 //----------------------------------------------------------------------------
 740 void vvSlicerManager::ReloadOverlay()
 741 {
 742   mOverlayReader->Update();
 743   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 744     mSlicers[i]->SetOverlay(mOverlayReader->GetOutput());
 745     mSlicers[i]->Render();
 746   }
 747 }
 748 //----------------------------------------------------------------------------
 749
 750
 751 //----------------------------------------------------------------------------
 752 void vvSlicerManager::ReloadVF()
 753 {
 754   mVectorReader->Update(vvImageReader::VECTORFIELD); //deletes the old images through the VF::Init() function
 755   mVF=mVectorReader->GetOutput();
 756   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 757     mSlicers[i]->SetVF(mVF);
 758     mSlicers[i]->Render();
 759   }
 760 }
 761 //----------------------------------------------------------------------------
 762
 763
 764 //----------------------------------------------------------------------------
 765 void vvSlicerManager::RemoveActor(const std::string& actor_type, int overlay_index)
 766 {
 767   if (actor_type =="overlay")
 768     mOverlayReader = NULL;
 769
 770   if (actor_type =="fusion")
 771     mFusionReader = NULL;
 772
 773   for (unsigned int i = 0; i < mSlicers.size(); i++)
 774     mSlicers[i]->RemoveActor(actor_type,overlay_index);
 775
 776   if (actor_type=="vector") {
 777     mVF=NULL;
 778     mVectorReader=NULL;
 779   }
 780 }
 781 //----------------------------------------------------------------------------
 782
 783
 784 //----------------------------------------------------------------------------
 785 void vvSlicerManager::RemoveActors()
 786 {
 787   ///This method leaks a few objects. See RemoveActor for what a
 788   ///correct implementation would look like
 789   //DS -> probably due to the reader (now released in the
 790   //RemoveActor() function. (I hope)
 791   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 792     mSlicers[i]->SetDisplayMode(0);
 793     mSlicers[i]->GetRenderer()->RemoveActor(mSlicers[i]->GetImageActor());
 794   }
 795 }
 796 //----------------------------------------------------------------------------
 797
 798
 799 //----------------------------------------------------------------------------
 800 void vvSlicerManager::UpdateInfoOnCursorPosition(int slicer)
 801 {
 802   //  int view = mSlicers[slicer]->GetSliceOrientation();
 803   //  int slice = mSlicers[slicer]->GetSlice();
 804   double x = mSlicers[slicer]->GetCursorPosition()[0];
 805   double y = mSlicers[slicer]->GetCursorPosition()[1];
 806   double z = mSlicers[slicer]->GetCursorPosition()[2];
 807   double X = (x - mSlicers[slicer]->GetInput()->GetOrigin()[0])/
 808     mSlicers[slicer]->GetInput()->GetSpacing()[0];
 809   double Y = (y - mSlicers[slicer]->GetInput()->GetOrigin()[1])/
 810     mSlicers[slicer]->GetInput()->GetSpacing()[1];
 811   double Z = (z - mSlicers[slicer]->GetInput()->GetOrigin()[2])/
 812     mSlicers[slicer]->GetInput()->GetSpacing()[2];
 813   double value = -VTK_DOUBLE_MAX;
 814   int displayVec = 0;
 815   double xVec=0, yVec=0, zVec=0, valueVec=0;
 816   int displayOver = 0;
 817   int displayFus = 0;
 818   double valueOver=0, valueFus=0;
 819   if (X >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] &&
 820       X <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] &&
 821       Y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&
 822       Y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&
 823       Z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&
 824       Z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]) {
 825     value = this->GetScalarComponentAsDouble(mSlicers[slicer]->GetInput(), X, Y, Z);
 826
 827     if (mSlicers[slicer]->GetVFActor() && mSlicers[slicer]->GetVFActor()->GetVisibility()) {
 828       displayVec = 1;
 829       unsigned int currentTime = mSlicers[slicer]->GetTSlice();
 830       vtkImageData *vf = NULL;
 831
 832       if (mSlicers[slicer]->GetVF()->GetVTKImages().size() > currentTime)
 833         vf = mSlicers[slicer]->GetVF()->GetVTKImages()[currentTime];
 834       else
 835         vf = mSlicers[slicer]->GetVF()->GetVTKImages()[0];
 836
 837       if (vf) {
 838         double Xvf = (x - vf->GetOrigin()[0])/ vf->GetSpacing()[0];
 839         double Yvf = (y - vf->GetOrigin()[1])/ vf->GetSpacing()[1];
 840         double Zvf = (z - vf->GetOrigin()[2])/ vf->GetSpacing()[2];
 841         xVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 0);
 842         yVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 1);
 843         zVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 2);
 844         valueVec = sqrt(xVec*xVec + yVec*yVec + zVec*zVec);
 845       }
 846     }
 847     if (mSlicers[slicer]->GetOverlayActor() && mSlicers[slicer]->GetOverlayActor()->GetVisibility()) {
 848       displayOver = 1;
 849       double Xover = (x - mSlicers[slicer]->GetOverlay()->GetOrigin()[0])
 850         /mSlicers[slicer]->GetOverlay()->GetSpacing()[0];
 851       double Yover = (y - mSlicers[slicer]->GetOverlay()->GetOrigin()[1])
 852         /mSlicers[slicer]->GetOverlay()->GetSpacing()[1];
 853       double Zover = (z - mSlicers[slicer]->GetOverlay()->GetOrigin()[2])
 854         /mSlicers[slicer]->GetOverlay()->GetSpacing()[2];
 855       valueOver = this->GetScalarComponentAsDouble(static_cast<vtkImageData*>(mSlicers[slicer]->GetOverlayMapper()->GetInput()), Xover, Yover, Zover);
 856     }
 857     if (mSlicers[slicer]->GetFusionActor() && mSlicers[slicer]->GetFusionActor()->GetVisibility()) {
 858       displayFus = 1;
 859       double Xfus = (x - mSlicers[slicer]->GetFusion()->GetOrigin()[0])
 860         /mSlicers[slicer]->GetFusion()->GetSpacing()[0];
 861       double Yfus = (y - mSlicers[slicer]->GetFusion()->GetOrigin()[1])
 862         /mSlicers[slicer]->GetFusion()->GetSpacing()[1];
 863       double Zfus = (z - mSlicers[slicer]->GetFusion()->GetOrigin()[2])
 864         /mSlicers[slicer]->GetFusion()->GetSpacing()[2];
 865       valueFus = this->GetScalarComponentAsDouble(static_cast<vtkImageData*>(mSlicers[slicer]->GetFusionMapper()->GetInput()), Xfus, Yfus, Zfus);
 866     }
 867     emit UpdatePosition(mSlicers[slicer]->GetCursorVisibility(),
 868                         x,y,z,X,Y,Z,value);
 869     emit UpdateVector(displayVec,xVec, yVec, zVec, valueVec);
 870     emit UpdateOverlay(displayOver,valueOver,value);
 871     emit UpdateFusion(displayFus,valueFus);
 872     for (unsigned int i = 0; i < mSlicers.size(); i++) {
 873       if (mSlicers[i]->GetImageActor()->GetVisibility() == 1)
 874         emit UpdateWindows(i,mSlicers[i]->GetSliceOrientation(),mSlicers[i]->GetSlice());
 875       else
 876         emit UpdateWindows(i,-1,-1);
 877     }
 878   }
 879 }
 880 //----------------------------------------------------------------------------
 881
 882
 883 //----------------------------------------------------------------------------
 884 void vvSlicerManager::Activated()
 885 {
 886   emit currentImageChanged(mId);
 887 }
 888 //----------------------------------------------------------------------------
 889
 890
 891 //----------------------------------------------------------------------------
 892 void vvSlicerManager::Picked()
 893 {
 894   emit currentPickedImageChanged(mId);
 895 }
 896 //----------------------------------------------------------------------------
 897
 898 //----------------------------------------------------------------------------
 899 void vvSlicerManager::UpdateWindowLevel()
 900 {
 901   emit WindowLevelChanged(mSlicers[0]->GetColorWindow(),mSlicers[0]->GetColorLevel(),mPreset,mColorMap);
 902 }
 903 //----------------------------------------------------------------------------
 904
 905
 906 //----------------------------------------------------------------------------
 907 void vvSlicerManager::UpdateSlice(int slicer)
 908 {
 909   if (mPreviousSlice[slicer] == mSlicers[slicer]->GetSlice()) {
 910     //DD("============= NOTHING");
 911     return;
 912   }
 913   emit UpdateSlice(slicer, mSlicers[slicer]->GetSlice());
 914   mSlicers[slicer]->Render(); // DS <-- I add this, this could/must be the only Render ...
 915   mPreviousSlice[slicer] = mSlicers[slicer]->GetSlice();
 916 }
 917 //----------------------------------------------------------------------------
 918
 919
 920 //----------------------------------------------------------------------------
 921 void vvSlicerManager::UpdateTSlice(int slicer)
 922 {
 923   if (mPreviousSlice[slicer] == mSlicers[slicer]->GetSlice()) {
 924     if (mPreviousTSlice[slicer] == mSlicers[slicer]->GetTSlice()) {
 925       //      DD("************** NOTHING ***********");
 926       return;
 927     }
 928   }
 929   mPreviousSlice[slicer] = mSlicers[slicer]->GetSlice();
 930   mPreviousTSlice[slicer] = mSlicers[slicer]->GetTSlice();
 931   emit UpdateTSlice(slicer,mSlicers[slicer]->GetTSlice());
 932 }
 933 //----------------------------------------------------------------------------
 934
 935
 936 //----------------------------------------------------------------------------
 937 void vvSlicerManager::UpdateSliceRange(int slicer)
 938 {
 939   emit UpdateSliceRange(slicer,
 940                         mSlicers[slicer]->GetSliceRange()[0], mSlicers[slicer]->GetSliceRange()[1],
 941                         0,mSlicers[slicer]->GetTMax());
 942 }
 943 //----------------------------------------------------------------------------
 944
 945
 946 //----------------------------------------------------------------------------
 947 void vvSlicerManager::SetPreset(int preset)
 948 {
 949   //vtkLookupTable* LUT = static_cast<vtkLookupTable*>(mSlicers[0]->GetWindowLevel()->GetLookupTable());
 950   double window = mSlicers[0]->GetColorWindow();
 951   double level = mSlicers[0]->GetColorLevel();
 952
 953   std::string component_type=mImage->GetScalarTypeAsITKString();
 954   switch (preset) {
 955   case 0:
 956     double range[2];
 957     mImage->GetScalarRange(range);
 958     window = range[1] - range[0];
 959     level = (range[1] + range[0])* 0.5;
 960     break;
 961   case 1:
 962     window = 2000;
 963     level = 0;
 964     break;
 965   case 2:
 966     window = 400;
 967     level = 20;
 968     break;
 969   case 3:
 970     window = 1500;
 971     level = -500;
 972     break;
 973   case 4:
 974     window = 1000;
 975     level = 500;
 976     break;
 977   case 5:
 978     window = 1;
 979     level = 0.5;
 980     break;
 981   case 6:
 982     break;
 983   case 7:
 984     window=1.;
 985     level=0.;
 986     break;
 987   }
 988   mPreset = preset;
 989   this->SetColorWindow(window);
 990   this->SetColorLevel(level);
 991
 992   //if (LUT)
 993   //{
 994   //    SetColorMap(-1);
 995   //}
 996 }
 997 //----------------------------------------------------------------------------
 998
 999
1000 //----------------------------------------------------------------------------
1001 void vvSlicerManager::SetLocalColorWindowing(const int slicer)
1002 {
1003   double min, max;
1004   this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max);
1005   this->SetColorWindow(max-min);
1006   this->SetColorLevel(0.5*(min+max));
1007   this->UpdateWindowLevel();
1008   this->Render();
1009 }
1010 //----------------------------------------------------------------------------
1011
1012
1013 //----------------------------------------------------------------------------
1014 void vvSlicerManager::SetColorMap()
1015 {
1016   SetColorMap(mColorMap);
1017 }
1018 //----------------------------------------------------------------------------
1019
1020
1021 //----------------------------------------------------------------------------
1022 void vvSlicerManager::SetColorMap(int colormap)
1023 {
1024   double range[2];
1025   range[0] = mSlicers[0]->GetInput()->GetScalarRange()[0];
1026   range[1] = mSlicers[0]->GetInput()->GetScalarRange()[1];
1027
1028   double window = mSlicers[0]->GetWindowLevel()->GetWindow();
1029   double level = mSlicers[0]->GetWindowLevel()->GetLevel();
1030
1031   vtkLookupTable* LUT = static_cast<vtkLookupTable*>(mSlicers[0]->GetWindowLevel()->GetLookupTable());
1032   switch (colormap) {
1033   case -1:
1034     break;
1035   case 0:
1036     LUT = NULL;
1037     break;
1038   case 1:
1039     if (LUT == NULL)
1040       LUT = vtkLookupTable::New();
1041     LUT->SetValueRange(0,1);
1042     LUT->SetSaturationRange(1,1);
1043     LUT->SetHueRange(0,0.18);
1044     break;
1045   case 2:
1046     if (LUT == NULL)
1047       LUT = vtkLookupTable::New();
1048     LUT->SetValueRange(0,1);
1049     LUT->SetSaturationRange(1,1);
1050     LUT->SetHueRange(0.4,0.80);
1051     break;
1052   case 3:
1053     if (LUT == NULL)
1054       LUT = vtkLookupTable::New();
1055     LUT->SetValueRange(0,1);
1056     LUT->SetSaturationRange(1,1);
1057     LUT->SetHueRange(0,1);
1058     break;
1059   case 5:
1060     if (LUT == NULL)
1061       LUT = vtkLookupTable::New();
1062     LUT->SetValueRange(0.,1);
1063     LUT->SetSaturationRange(1,1);
1064     LUT->SetHueRange(1,0.1);
1065     //LUT->SetRampToLinear();
1066     break;
1067   }
1068   if (LUT) {
1069     LUT->SetTableRange(level-fabs(window)/4,level+fabs(window)/4);
1070     LUT->Build();
1071   }
1072   vtkLookupTable* fusLUT = NULL;
1073   if (mSlicers[0]->GetFusion()) {
1074     fusLUT = vtkLookupTable::New();
1075     double fusRange [2];
1076     fusRange[0] = mFusionLevel - mFusionWindow/2;
1077     fusRange[1] = mFusionLevel + mFusionWindow/2;
1078     fusLUT->SetTableRange(fusRange[0],fusRange[1]);
1079     fusLUT->SetValueRange(1,1);
1080     fusLUT->SetSaturationRange(1,1);
1081     if (mFusionColorMap == 1)
1082       fusLUT->SetHueRange(0,0.18);
1083     else if (mFusionColorMap == 2)
1084       fusLUT->SetHueRange(0.4,0.80);
1085     else if (mFusionColorMap == 3)
1086       fusLUT->SetHueRange(0,1);
1087     fusLUT->Build();
1088     if (mFusionColorMap == 0)
1089       fusLUT = NULL;
1090   }
1091   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
1092     if (mSlicers[i]->GetOverlay() && mSlicers[i]->GetOverlayActor()->GetVisibility()) {
1093       vtkLookupTable* supLUT = vtkLookupTable::New();
1094       supLUT->SetTableRange(range[0],range[1]);
1095       supLUT->SetValueRange(1,1);
1096       supLUT->SetSaturationRange(1,1);
1097       supLUT->SetHueRange(double(mOverlayColor)/360,double(mOverlayColor)/360);
1098       supLUT->Build();
1099       vtkLookupTable* invLUT = vtkLookupTable::New();
1100       invLUT->SetTableRange(range[0],range[1]);
1101       invLUT->SetValueRange(1,1);
1102       invLUT->SetSaturationRange(1,1);
1103       invLUT->SetHueRange(double((mOverlayColor+180)%360)/360,double((mOverlayColor+180)%360)/360);
1104       invLUT->Build();
1105       dynamic_cast<vvImageMapToWLColors*>(mSlicers[i]->GetWindowLevel())
1106         ->SetWindowLevelMode(true);
1107       mSlicers[i]->GetWindowLevel()->SetLookupTable(supLUT);
1108       mSlicers[i]->GetOverlayMapper()->SetLookupTable(invLUT);
1109       invLUT->Delete();
1110       supLUT->Delete();
1111     } else if (mSlicers[i]->GetOverlay()) {
1112       //dynamic_cast<vvImageMapToWLColors*>(mSlicers[i]->GetWindowLevel())
1113       //->SetWindowLevelMode(false);
1114       mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT);
1115     } else {
1116       mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT);
1117     }
1118     if (mSlicers[i]->GetFusion() && mSlicers[i]->GetFusionActor()->GetVisibility()) {
1119       mSlicers[i]->GetFusionActor()->SetOpacity(double(mFusionOpacity)/100);
1120       mSlicers[i]->GetFusionMapper()->SetLookupTable(fusLUT);
1121       mSlicers[i]->GetFusionMapper()->SetWindow(mFusionWindow);
1122       mSlicers[i]->GetFusionMapper()->SetLevel(mFusionLevel);
1123     }
1124   }
1125   if (fusLUT)
1126     fusLUT->Delete();
1127   if (colormap >= 0)
1128     mColorMap = colormap;
1129 }
1130 //----------------------------------------------------------------------------
1131
1132
1133 //----------------------------------------------------------------------------
1134 vvLandmarks* vvSlicerManager::GetLandmarks()
1135 {
1136   if (mLandmarks == NULL) {
1137     mLandmarks = new vvLandmarks(mSlicers[0]->GetTMax()+1);
1138     for (unsigned int i = 0; i < mSlicers.size(); i++)
1139       mSlicers[i]->SetLandmarks(mLandmarks);
1140   }
1141   return mLandmarks;
1142 }
1143 //----------------------------------------------------------------------------
1144
1145
1146 //----------------------------------------------------------------------------
1147 void vvSlicerManager::AddLandmark(float x,float y,float z,float t)
1148 {
1149   double x_index = (x - mSlicers[0]->GetInput()->GetOrigin()[0])/mSlicers[0]->GetInput()->GetSpacing()[0];
1150   double y_index = (y - mSlicers[0]->GetInput()->GetOrigin()[1])/mSlicers[0]->GetInput()->GetSpacing()[1];
1151   double z_index = (z - mSlicers[0]->GetInput()->GetOrigin()[2])/mSlicers[0]->GetInput()->GetSpacing()[2];
1152   if (x_index >= mSlicers[0]->GetInput()->GetWholeExtent()[0] &&
1153       x_index <= mSlicers[0]->GetInput()->GetWholeExtent()[1] &&
1154       y_index >= mSlicers[0]->GetInput()->GetWholeExtent()[2] &&
1155       y_index <= mSlicers[0]->GetInput()->GetWholeExtent()[3] &&
1156       z_index >= mSlicers[0]->GetInput()->GetWholeExtent()[4] &&
1157       z_index <= mSlicers[0]->GetInput()->GetWholeExtent()[5]) {
1158     double value = this->GetScalarComponentAsDouble(mSlicers[0]->GetInput(), x_index, y_index, z_index);
1159     this->GetLandmarks()->AddLandmark(x,y,z,t,value);
1160     emit LandmarkAdded();
1161   }
1162 }
1163 //----------------------------------------------------------------------------
1164
1165 //----------------------------------------------------------------------------
1166 void vvSlicerManager::PrevImage(int slicer)
1167 {
1168   emit ChangeImageWithIndexOffset(this, slicer, -1);
1169 }
1170 //----------------------------------------------------------------------------
1171
1172 //----------------------------------------------------------------------------
1173 void vvSlicerManager::NextImage(int slicer)
1174 {
1175   emit ChangeImageWithIndexOffset(this, slicer,  1);
1176 }
1177 //----------------------------------------------------------------------------
1178
1179 //----------------------------------------------------------------------------
1180 void vvSlicerManager::VerticalSliderHasChanged(int slicer, int slice)
1181 {
1182   emit AVerticalSliderHasChanged(slicer, slice);
1183 }
1184
1185 //----------------------------------------------------------------------------
1186
1187 //----------------------------------------------------------------------------
1188 double vvSlicerManager::GetScalarComponentAsDouble(vtkImageData *image, double X, double Y, double Z, int component)
1189 {
1190   int ix, iy, iz;
1191   return mSlicers[0]->GetScalarComponentAsDouble(image, X, Y, Z, ix, iy, iz, component);
1192 }
1193 //----------------------------------------------------------------------------