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