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