vv/vvSlicerManager.cxx

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