vv/vvSlicerManager.cxx

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