vv/vvSlicerManager.cxx

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