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