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