vv/vvSlicerManager.cxx

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