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