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 "vvMesh.h"
  26 #include "vvBlendImageActor.h"
  27
  28 #include <vtkImageActor.h>
  29 #include <vtkImageData.h>
  30 #include <vtkRenderWindow.h>
  31 #include <vtkRendererCollection.h>
  32 #include <vtkRenderWindowInteractor.h>
  33 #include <vtkImageMapToWindowLevelColors.h>
  34 #include <vtkWindowLevelLookupTable.h>
  35 #include <vtkColorTransferFunction.h>
  36 #include <vtkImageClip.h>
  37 #include <vtkLODActor.h>
  38 #include <vtkPointData.h>
  39 #include <vtksys/SystemTools.hxx>
  40 #include <vtkCamera.h>
  41
  42 #include <qfileinfo.h>
  43 //----------------------------------------------------------------------------
  44 vvSlicerManager::vvSlicerManager(int numberOfSlicers)
  45 {
  46   mFileName = "";
  47   mId = "";
  48   mVFName = "";
  49   mOverlayName = "";
  50   mFusionName = "";
  51   mVFId = "";
  52   mLastError = "";
  53   mType = vvImageReader::UNDEFINEDIMAGETYPE;
  54   mColorMap = 0;
  55   mPreset = 0;
  56   mOverlayColor = 130;
  57
  58   mFusionOpacity = 30;
  59   mFusionThresOpacity = 1;
  60   mFusionColorMap = 3;
  61   mFusionWindow = 1000;
  62   mFusionLevel = 1000;
  63   mFusionShowLegend = true;
  64
  65   mFusionSequenceFrameIndex = -1;
  66   mFusionSequenceSpatialSyncFlag = false;
  67   mFusionSequenceNbFrames = 0;
  68
  69   mLandmarks = NULL;
  70   mLinkedId.resize(0);
  71
  72   for ( int i = 0; i < numberOfSlicers; i++)
  73     mSlicers.push_back(vtkSmartPointer<vvSlicer>::New());
  74   mSelectedSlicer = -1;
  75
  76   mPreviousSlice.resize(numberOfSlicers);
  77   mPreviousTSlice.resize(numberOfSlicers);
  78   mSlicingPreset = WORLD_SLICING;
  79
  80
  81 }
  82 //----------------------------------------------------------------------------
  83
  84
  85 //----------------------------------------------------------------------------
  86 vvSlicerManager::~vvSlicerManager()
  87 {
  88   if (mLandmarks)
  89     delete mLandmarks;
  90 }
  91 //----------------------------------------------------------------------------
  92
  93
  94 //------------------------------------------------------------------------------
  95 void vvSlicerManager::SetFilename(std::string filename, int number)
  96 {
  97   mFileName = filename;
  98   mFileName = vtksys::SystemTools::GetFilenameName(mFileName);
  99   mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));
 100   mBaseFileNameNumber = number;
 101
 102   mFileName = mBaseFileName;
 103   if (number != 0) {
 104     mFileName.append("_"+clitk::toString(number));
 105   }
 106   mFileName.append(vtksys::SystemTools::GetFilenameLastExtension(filename));
 107
 108   for(unsigned int i=0; i<mSlicers.size(); i++) {
 109     mSlicers[i]->SetFileName(mFileName);//vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));
 110   }
 111
 112 }
 113 //------------------------------------------------------------------------------
 114
 115
 116 //----------------------------------------------------------------------------
 117 void vvSlicerManager::AddContour(vvMesh::Pointer contour,bool propagate)
 118 {
 119   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 120     mSlicers[i]->AddContour(contour,propagate);
 121   }
 122 }
 123 //----------------------------------------------------------------------------
 124
 125
 126 //----------------------------------------------------------------------------
 127 void vvSlicerManager::ToggleContourSuperposition()
 128 {
 129   for ( unsigned int i = 0; i < mSlicers.size(); i++)
 130     mSlicers[i]->ToggleContourSuperposition();
 131 }
 132 //----------------------------------------------------------------------------
 133
 134 //----------------------------------------------------------------------------
 135 std::string vvSlicerManager::GetListOfAbsoluteFilePathInOneString(const std::string &actorType)
 136 {
 137   vvImageReader *reader = NULL;
 138
 139   if(actorType=="image")
 140     reader = mReader;
 141   else if(actorType=="overlay")
 142     reader = mOverlayReader;
 143   else if(actorType=="fusion")
 144     reader = mFusionReader;
 145   else if(actorType=="vector")
 146     reader = mVectorReader;
 147   else if(actorType=="fusionSequence")
 148         reader = mFusionSequenceReader;
 149
 150   if(!reader)
 151     return "";
 152
 153   std::string list;
 154   for(unsigned int i=0; i<reader->GetInputFilenames().size(); i++){
 155     QFileInfo fileinfo(reader->GetInputFilenames()[i].c_str()); //Do not show the path
 156     if(i)
 157       list += '\n';
 158     list += fileinfo.absoluteFilePath().toStdString();
 159   }
 160   return list;
 161 }
 162 //----------------------------------------------------------------------------
 163
 164
 165 //----------------------------------------------------------------------------
 166 bool vvSlicerManager::SetImage(std::string filename, vvImageReader::LoadedImageType type, int n, unsigned int slice)
 167 {
 168   mType = type;
 169   if (mReader.IsNull())
 170     mReader = vvImageReader::New();
 171   std::vector<std::string> filenames;
 172   filenames.push_back(filename);
 173   mReader->SetInputFilenames(filenames);
 174   mReader->SetSlice(slice); // Only used for SLICED type
 175   mReader->Update(type);
 176
 177   SetFilename(filename, n);
 178   //  mFileName = vtksys::SystemTools::GetFilenameName(mFileName);
 179   //mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));
 180   //mBaseFileNameNumber = n;
 181
 182   if (mReader->GetLastError().size() == 0) {
 183     mImage=mReader->GetOutput();
 184     for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 185       mSlicers[i]->SetFileName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));
 186       mSlicers[i]->SetImage(mReader->GetOutput());
 187     }
 188   } else {
 189     mLastError = mReader->GetLastError();
 190     return false;
 191   }
 192   // if (n!=0) {
 193   //   mFileName.append("_"+clitk::toString(n));
 194   // }
 195   return true;
 196 }
 197 //----------------------------------------------------------------------------
 198
 199
 200 //----------------------------------------------------------------------------
 201 void vvSlicerManager::SetImage(vvImage::Pointer image)
 202 {
 203   mImage=image;
 204   for (unsigned int i = 0; i < mSlicers.size(); i++) {
 205     mSlicers[i]->SetImage(image);
 206   }
 207 }
 208 //----------------------------------------------------------------------------
 209
 210
 211 //----------------------------------------------------------------------------
 212 bool vvSlicerManager::SetImages(std::vector<std::string> filenames, vvImageReader::LoadedImageType type, int n)
 213 {
 214   mType = type;
 215   std::string fileWithoutExtension = vtksys::SystemTools::GetFilenameWithoutExtension(filenames[0]);
 216   if (type == vvImageReader::DICOM)
 217     fileWithoutExtension += "_dicom";
 218   else if (type == vvImageReader::MERGED)
 219     fileWithoutExtension += "_merged";
 220   else if (type == vvImageReader::MERGEDWITHTIME)
 221     fileWithoutExtension += "_merged_wt";
 222
 223   mFileName = vtksys::SystemTools::GetFilenameName(mFileName);
 224   mFileName = fileWithoutExtension + vtksys::SystemTools::GetFilenameExtension(filenames[0]);
 225   if (mReader.IsNull())
 226     mReader = vvImageReader::New();
 227   mReader->SetInputFilenames(filenames);
 228   mReader->Update(type);
 229
 230   mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));
 231   mBaseFileNameNumber = n;
 232
 233   if (mReader->GetLastError().size() == 0) {
 234     mImage=mReader->GetOutput();
 235     for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 236       mSlicers[i]->SetFileName(fileWithoutExtension);
 237       mSlicers[i]->SetImage(mReader->GetOutput());
 238     }
 239   } else {
 240     mLastError = mReader->GetLastError();
 241     return false;
 242   }
 243   if (n!=0) {
 244     mFileName.append("_"+clitk::toString(n));
 245   }
 246   return true;
 247 }
 248 //----------------------------------------------------------------------------
 249
 250
 251 //----------------------------------------------------------------------------
 252 bool vvSlicerManager::SetOverlay(std::vector<std::string> filenames,int dim, std::string component, vvImageReader::LoadedImageType type)
 253 {
 254   mOverlayName = filenames[0];
 255   mOverlayComponent = component;
 256   if (dim > mImage->GetNumberOfDimensions()) {
 257     mLastError = " Overlay dimension cannot be greater than reference image!";
 258     return false;
 259   }
 260   if (mOverlayReader.IsNull())
 261     mOverlayReader = vvImageReader::New();
 262   mOverlayReader->SetInputFilenames(filenames);
 263   mOverlayReader->Update(type);
 264   if (mOverlayReader->GetLastError().size() == 0) {
 265     for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 266       mSlicers[i]->SetOverlay(mOverlayReader->GetOutput());
 267     }
 268   } else {
 269     mLastError = mOverlayReader->GetLastError();
 270     return false;
 271   }
 272   return true;
 273 }
 274 //----------------------------------------------------------------------------
 275
 276
 277 //----------------------------------------------------------------------------
 278 bool vvSlicerManager::SetFusion(std::string filename,int dim, std::string component)
 279 {
 280   mFusionName = filename;
 281   mFusionComponent = component;
 282   if (dim > mImage->GetNumberOfDimensions()) {
 283     mLastError = " Overlay dimension cannot be greater then reference image!";
 284     return false;
 285   }
 286   if (mFusionReader.IsNull())
 287     mFusionReader = vvImageReader::New();
 288   std::vector<std::string> filenames;
 289   filenames.push_back(filename);
 290   mFusionReader->SetInputFilenames(filenames);
 291   mFusionReader->Update(mImage->GetNumberOfDimensions(),component.c_str(),mType);
 292   if (mFusionReader->GetLastError().size() == 0) {
 293     for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 294       mSlicers[i]->SetFusion(mFusionReader->GetOutput());
 295     }
 296   } else {
 297     mLastError = mFusionReader->GetLastError();
 298     return false;
 299   }
 300   double *fusRange = mFusionReader->GetOutput()->GetVTKImages()[0]->GetScalarRange();
 301   mFusionLevel = (fusRange[0]+fusRange[1])/2;
 302   mFusionWindow = fusRange[1]-fusRange[0];
 303
 304   return true;
 305 }
 306 //----------------------------------------------------------------------------
 307
 308 //----------------------------------------------------------------------------
 309 bool vvSlicerManager::SetFusionSequence(std::vector<std::string> filenames,int dim, std::string component, vvImageReader::LoadedImageType type)
 310 {
 311   mFusionName = filenames[0];
 312   mFusionComponent = component;
 313
 314   if (dim > mImage->GetNumberOfDimensions()) {
 315     mLastError = " Fusion Sequence dimension cannot be greater than reference image!";
 316     return false;
 317   }
 318
 319   if (mFusionSequenceReader.IsNull())
 320     mFusionSequenceReader = vvImageReader::New();
 321
 322   mFusionSequenceReader->SetInputFilenames(filenames);
 323   mFusionSequenceReader->Update(type);
 324
 325   //store the initial transform matrices of each frame, and reset them to identity
 326   mFusionSequenceListInitialTransformMatrices.clear();
 327   for (unsigned i=0 ; i<mFusionSequenceReader->GetOutput()->GetTransform().size() ; i++) {
 328           AddFusionSequenceInitialTransformMatrices( mFusionSequenceReader->GetOutput()->GetTransform()[i]->GetMatrix() );
 329           mFusionSequenceReader->GetOutput()->GetTransform()[i]->Identity();
 330           mFusionSequenceReader->GetOutput()->GetTransform()[i]->Update();
 331   }
 332
 333   //adjust the time slider in the overlay panel
 334   mFusionSequenceNbFrames = mFusionSequenceReader->GetOutput()->GetTransform().size()-1; //actually, this is the maximum index...
 335   if (mFusionSequenceFrameIndex>=mFusionSequenceNbFrames) {
 336           mFusionSequenceFrameIndex=0;
 337   }
 338
 339
 340   if (mFusionSequenceReader->GetLastError().size() == 0) {
 341     for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 342       mSlicers[i]->SetFusion(mFusionSequenceReader->GetOutput());
 343     }
 344   } else {
 345     mLastError = mFusionSequenceReader->GetLastError();
 346     return false;
 347   }
 348   double *fusRange = mFusionSequenceReader->GetOutput()->GetVTKImages()[0]->GetScalarRange();
 349   mFusionLevel = (fusRange[0]+fusRange[1])/2;
 350   mFusionWindow = fusRange[1]-fusRange[0];
 351
 352   return true;
 353 }
 354 //----------------------------------------------------------------------------
 355
 356
 357 //----------------------------------------------------------------------------
 358 bool vvSlicerManager::SetVF(std::string filename)
 359 {
 360   if (mVectorReader.IsNull())
 361     mVectorReader = vvImageReader::New();
 362   mVectorReader->SetInputFilename(filename);
 363
 364   if (mType == vvImageReader::IMAGEWITHTIME)
 365     mVectorReader->Update(vvImageReader::VECTORFIELDWITHTIME);
 366   else
 367     mVectorReader->Update(vvImageReader::VECTORFIELD);
 368   if (mVectorReader->GetLastError().size() != 0) {
 369     mLastError = mVectorReader->GetLastError();
 370     return false;
 371   } else
 372     return SetVF(mVectorReader->GetOutput(),filename);
 373 }
 374 //----------------------------------------------------------------------------
 375
 376
 377 //----------------------------------------------------------------------------
 378 bool vvSlicerManager::SetVF(vvImage::Pointer vf,std::string filename)
 379 {
 380   if (vf->GetNumberOfDimensions() > mImage->GetNumberOfDimensions()) {
 381     mLastError = "Sorry, vector field dimension cannot be greater then reference image.";
 382     return false;
 383   }
 384   if (vf->GetNumberOfDimensions() == 4) {
 385     if (vf->GetSpacing()[3] != mImage->GetSpacing()[3]) {
 386       mLastError = "Sorry, vector field time spacing cannot be different from time spacing of the reference image.";
 387       return false;
 388     }
 389     if (vf->GetOrigin()[3] != mImage->GetOrigin()[3]) {
 390       mLastError = "Sorry, vector field time origin cannot be different from time origin of the reference image.";
 391       return false;
 392     }
 393   }
 394   mVF=vf;
 395   mVFName = filename;
 396   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 397     mSlicers[i]->SetVF(vf);
 398   }
 399   return true;
 400 }
 401 //----------------------------------------------------------------------------
 402
 403
 404 //----------------------------------------------------------------------------
 405 vvSlicer* vvSlicerManager::GetSlicer(int i)
 406 {
 407   return mSlicers[i];
 408 }
 409 //----------------------------------------------------------------------------
 410
 411
 412 //----------------------------------------------------------------------------
 413 void vvSlicerManager::UpdateSlicer(int num, bool state)
 414 {
 415   if (mSlicers[num]->GetImage())
 416     mSlicers[num]->SetDisplayMode(state);
 417 }
 418 //----------------------------------------------------------------------------
 419
 420
 421 //----------------------------------------------------------------------------
 422 void vvSlicerManager::SetSlicerWindow(int i, vtkRenderWindow* RW)
 423 {
 424   mSlicers[i]->SetRenderWindow(i,RW);
 425 }
 426 //----------------------------------------------------------------------------
 427
 428
 429 //----------------------------------------------------------------------------
 430 void vvSlicerManager::SetInteractorStyleNavigator(int i, vtkInteractorStyle* style)
 431 {
 432   vvSlicerManagerCommand *smc = vvSlicerManagerCommand::New();
 433   smc->SM = this;
 434   smc->SetSlicerNumber(i);
 435   mSlicers[i]->GetRenderWindow()->GetInteractor()->SetInteractorStyle(style);
 436
 437   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 438     GetInteractorStyle()->AddObserver(vtkCommand::KeyPressEvent, smc);
 439   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 440     GetInteractorStyle()->AddObserver(vtkCommand::WindowLevelEvent, smc);
 441   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 442     GetInteractorStyle()->AddObserver(vtkCommand::EndWindowLevelEvent, smc);
 443   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 444     GetInteractorStyle()->AddObserver(vtkCommand::StartWindowLevelEvent, smc);
 445   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 446     GetInteractorStyle()->AddObserver(vtkCommand::PickEvent, smc);
 447   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 448     GetInteractorStyle()->AddObserver(vtkCommand::StartPickEvent, smc);
 449   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 450     GetInteractorStyle()->AddObserver(vtkCommand::LeaveEvent, smc);
 451   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 452     GetInteractorStyle()->AddObserver(vtkCommand::UserEvent, smc);
 453   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 454     GetInteractorStyle()->AddObserver(vtkCommand::MouseWheelForwardEvent, smc);
 455   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 456     GetInteractorStyle()->AddObserver(vtkCommand::MouseWheelBackwardEvent, smc);
 457   // mSlicers[i]->GetRenderWindow()->GetInteractor()->
 458   //   GetInteractorStyle()->AddObserver(vtkCommand::LeftButtonReleaseEvent, smc);
 459   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 460     GetInteractorStyle()->AddObserver(vtkCommand::EndPickEvent, smc);
 461   mSlicers[i]->GetRenderWindow()->GetInteractor()->
 462     GetInteractorStyle()->AddObserver(vtkCommand::EndInteractionEvent, smc);
 463   smc->Delete();
 464 }
 465 //----------------------------------------------------------------------------
 466
 467
 468 //----------------------------------------------------------------------------
 469 void vvSlicerManager::LeftButtonReleaseEvent(int slicer)
 470 {
 471   emit LeftButtonReleaseSignal(slicer);
 472 }
 473 //----------------------------------------------------------------------------
 474
 475
 476 //----------------------------------------------------------------------------
 477 void vvSlicerManager::EmitMousePositionUpdated(int slicer)
 478 {
 479   emit MousePositionUpdatedSignal(slicer);
 480 }
 481 //----------------------------------------------------------------------------
 482
 483
 484 //----------------------------------------------------------------------------
 485 void vvSlicerManager::EmitKeyPressed(std::string KeyPress)
 486 {
 487   emit KeyPressedSignal(KeyPress);
 488 }
 489 //----------------------------------------------------------------------------
 490
 491
 492 //----------------------------------------------------------------------------
 493 void vvSlicerManager::SetSliceOrientation(int slicer, int orientation)
 494 {
 495   mSlicers[slicer]->SetSliceOrientation(orientation);
 496   emit UpdateOrientation(slicer, orientation);
 497 }
 498 //----------------------------------------------------------------------------
 499
 500 //----------------------------------------------------------------------------
 501 int vvSlicerManager::GetTSlice()
 502 {
 503   return mSlicers[0]->GetTSlice();
 504 }
 505 //----------------------------------------------------------------------------
 506
 507 //----------------------------------------------------------------------------
 508 void vvSlicerManager::SetTSlice(int slice)
 509 {
 510   if (slice < 0)
 511     slice = 0;
 512   else if (slice > mSlicers[0]->GetTMax())
 513     slice = mSlicers[0]->GetTMax();
 514   if (mLandmarks)
 515     mLandmarks->SetTime(slice);
 516   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 517     if (slice != mSlicers[i]->GetMaxCurrentTSlice()) {
 518       mSlicers[i]->SetTSlice(slice);
 519       UpdateTSlice(i);
 520     }
 521   }
 522 }
 523 //----------------------------------------------------------------------------
 524
 525
 526 //----------------------------------------------------------------------------
 527 void vvSlicerManager::SetFusionSequenceTSlice(int slice)
 528 {
 529         for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 530                 mSlicers[i]->SetFusionSequenceTSlice(slice);
 531                 UpdateTSlice(i);
 532         }
 533 }
 534 //----------------------------------------------------------------------------
 535
 536
 537 //----------------------------------------------------------------------------
 538 void vvSlicerManager::SetNextTSlice(int originating_slicer)
 539 {
 540   int t = mSlicers[0]->GetMaxCurrentTSlice();
 541   t++;
 542   if (t > mSlicers[0]->GetTMax())
 543     t = 0;
 544   //std::cout << "vvSlicerManager::SetNextTSlice" << std::endl;
 545   emit UpdateTSlice(originating_slicer,t);
 546 }
 547 //----------------------------------------------------------------------------
 548
 549
 550 //----------------------------------------------------------------------------
 551 void vvSlicerManager::SetPreviousTSlice(int originating_slicer)
 552 {
 553   int t = mSlicers[0]->GetMaxCurrentTSlice();
 554   t--;
 555   if (t < 0)
 556     t = mSlicers[0]->GetTMax();
 557   //std::cout << "vvSlicerManager::SetPreviousTSlice" << std::endl;
 558   emit UpdateTSlice(originating_slicer,t);
 559 }
 560 //----------------------------------------------------------------------------
 561
 562
 563 //----------------------------------------------------------------------------
 564 void vvSlicerManager::ToggleInterpolation()
 565 {
 566   bool interpolate=!(mSlicers[0]->GetImageActor()->GetInterpolate());
 567   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 568     mSlicers[i]->GetImageActor()->SetInterpolate(interpolate);
 569     if (mSlicers[i]->GetOverlayActor())
 570       mSlicers[i]->GetOverlayActor()->SetInterpolate(interpolate);
 571     if (mSlicers[i]->GetFusionActor())
 572       mSlicers[i]->GetFusionActor()->SetInterpolate(interpolate);
 573   }
 574 }
 575 //----------------------------------------------------------------------------
 576
 577
 578 //----------------------------------------------------------------------------
 579 void vvSlicerManager::SetTSliceInSlicer(int tslice, int slicer)
 580 {
 581   if (tslice < 0)
 582     tslice = 0;
 583   else if (tslice > mSlicers[slicer]->GetTMax())
 584     tslice = mSlicers[slicer]->GetTMax();
 585   if (mLandmarks)
 586     mLandmarks->SetTime(tslice);
 587
 588   if (mSlicers[slicer]->GetMaxCurrentTSlice() == tslice) return;
 589
 590   mSlicers[slicer]->SetTSlice(tslice);
 591
 592   if(mSlicingPreset==VOXELS_SLICING) {
 593     vtkMatrix4x4 *imageTransformInverse = vtkMatrix4x4::New();
 594     mImage->GetTransform()[mSlicers[slicer]->GetTSlice()]->GetInverse(imageTransformInverse);
 595     this->GetSlicer(slicer)->GetSlicingTransform()->SetMatrix(imageTransformInverse);
 596     imageTransformInverse->Delete();
 597   }
 598
 599   UpdateTSlice(slicer);
 600 }
 601 //----------------------------------------------------------------------------
 602
 603
 604 //----------------------------------------------------------------------------
 605 void vvSlicerManager::SetColorWindow(double s)
 606 {
 607   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 608     mSlicers[i]->SetColorWindow(s);
 609   }
 610 }
 611 //----------------------------------------------------------------------------
 612
 613 //----------------------------------------------------------------------------
 614 void vvSlicerManager::SetColorLevel(double s)
 615 {
 616   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 617     mSlicers[i]->SetColorLevel(s);
 618   }
 619 }
 620 //----------------------------------------------------------------------------
 621
 622 //----------------------------------------------------------------------------
 623 void vvSlicerManager::SetOverlayColorWindow(double s)
 624 {
 625   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 626     mSlicers[i]->SetOverlayColorWindow(s);
 627   }
 628 }
 629 //----------------------------------------------------------------------------
 630
 631 //----------------------------------------------------------------------------
 632 void vvSlicerManager::SetOverlayColorLevel(double s)
 633 {
 634   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 635     mSlicers[i]->SetOverlayColorLevel(s);
 636   }
 637 }
 638 //----------------------------------------------------------------------------
 639
 640 //----------------------------------------------------------------------------
 641 void vvSlicerManager::SetLinkOverlayWindowLevel(bool b)
 642 {
 643   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 644     mSlicers[i]->SetLinkOverlayWindowLevel(b);
 645   }
 646 }
 647 //----------------------------------------------------------------------------
 648
 649 //----------------------------------------------------------------------------
 650 void vvSlicerManager::SetCursorAndCornerAnnotationVisibility(int s)
 651 {
 652   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 653     mSlicers[i]->SetCursorVisibility(s);
 654     mSlicers[i]->SetCornerAnnotationVisibility(s);
 655   }
 656 }
 657 //----------------------------------------------------------------------------
 658
 659 //----------------------------------------------------------------------------
 660 void vvSlicerManager::SetOpacity(int i, double factor)
 661 {
 662   mSlicers[i]->SetOpacity(1/factor);
 663 }
 664 //----------------------------------------------------------------------------
 665
 666
 667 //----------------------------------------------------------------------------
 668 void vvSlicerManager::UpdateViews(int current,int slicer)
 669 {
 670   double p[3], pt[3];
 671   p[0] = mSlicers[slicer]->GetCurrentPosition()[0];
 672   p[1] = mSlicers[slicer]->GetCurrentPosition()[1];
 673   p[2] = mSlicers[slicer]->GetCurrentPosition()[2];
 674   mSlicers[slicer]->GetSlicingTransform()->GetInverse()->TransformPoint(p, pt);
 675
 676   double x = (pt[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0])
 677     /mSlicers[slicer]->GetInput()->GetSpacing()[0];
 678   double y = (pt[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1])
 679     /mSlicers[slicer]->GetInput()->GetSpacing()[1];
 680   double z = (pt[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2])
 681     /mSlicers[slicer]->GetInput()->GetSpacing()[2];
 682
 683   if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0]-0.5 &&
 684       x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1]+0.5 &&
 685       y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2]-0.5 &&
 686       y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3]+0.5 &&
 687       z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4]-0.5 &&
 688       z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]+0.5) {
 689     mSlicers[slicer]->UpdateCursorPosition();
 690     mSlicers[slicer]->SetCursorColor(10,212,255);
 691     mSelectedSlicer = slicer;
 692
 693     switch (mSlicers[slicer]->GetSliceOrientation()) {
 694     case vtkImageViewer2::SLICE_ORIENTATION_XY:
 695       if (mSlicers[slicer]->GetSlice() != (int)lrint(z))
 696         mSlicers[slicer]->SetSlice((int)lrint(z));
 697       break;
 698
 699     case vtkImageViewer2::SLICE_ORIENTATION_XZ:
 700       if (mSlicers[slicer]->GetSlice() != (int)lrint(y))
 701         mSlicers[slicer]->SetSlice((int)lrint(y));
 702       break;
 703
 704     case vtkImageViewer2::SLICE_ORIENTATION_YZ:
 705       if (mSlicers[slicer]->GetSlice() != (int)lrint(x))
 706         mSlicers[slicer]->SetSlice((int)lrint(x));
 707       break;
 708     }
 709     mSlicers[slicer]->Render();
 710
 711     for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 712       if (i != (unsigned int)slicer
 713           && mSlicers[i]->GetRenderer()->GetDraw()
 714           && mSlicers[i]->GetRenderWindow()->GetSize()[0] > 2
 715           && mSlicers[i]->GetRenderWindow()->GetSize()[1] > 2) {
 716         mSlicers[i]->SetCurrentPosition(p[0], p[1], p[2], mSlicers[slicer]->GetMaxCurrentTSlice());
 717         mSlicers[i]->UpdateCursorPosition();
 718         if (current) { //do not display corner annotation if image is the one picked
 719           mSlicers[i]->SetCurrentPosition(-VTK_DOUBLE_MAX,-VTK_DOUBLE_MAX,
 720                                           -VTK_DOUBLE_MAX, mSlicers[slicer]->GetMaxCurrentTSlice());
 721           mSlicers[i]->SetCursorColor(255,10,212);
 722         } else {
 723           mSlicers[i]->SetCursorColor(150,10,282);
 724         }
 725         switch (mSlicers[i]->GetSliceOrientation()) {
 726         case vtkImageViewer2::SLICE_ORIENTATION_XY:
 727           if (mSlicers[i]->GetSlice() != (int)lrint(z))
 728             mSlicers[i]->SetSlice((int)lrint(z));
 729           break;
 730
 731         case vtkImageViewer2::SLICE_ORIENTATION_XZ:
 732           if (mSlicers[i]->GetSlice() != (int)lrint(y))
 733             mSlicers[i]->SetSlice((int)lrint(y));
 734           break;
 735
 736         case vtkImageViewer2::SLICE_ORIENTATION_YZ:
 737           if (mSlicers[i]->GetSlice() != (int)lrint(x))
 738             mSlicers[i]->SetSlice((int)lrint(x));
 739           break;
 740         }
 741
 742         mSlicers[i]->Render();
 743
 744         UpdateSlice(i);
 745         UpdateTSlice(i);
 746       }
 747     }
 748   }
 749 }
 750 //----------------------------------------------------------------------------
 751
 752
 753 //----------------------------------------------------------------------------
 754 void vvSlicerManager::UpdateLinked(int slicer)
 755 {
 756   double p[3], pt[3];
 757   p[0] = mSlicers[slicer]->GetCurrentPosition()[0];
 758   p[1] = mSlicers[slicer]->GetCurrentPosition()[1];
 759   p[2] = mSlicers[slicer]->GetCurrentPosition()[2];
 760   mSlicers[slicer]->GetSlicingTransform()->GetInverse()->TransformPoint(p, pt);
 761   double x = (pt[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0]) / mSlicers[slicer]->GetInput()->GetSpacing()[0];
 762   double y = (pt[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1]) / mSlicers[slicer]->GetInput()->GetSpacing()[1];
 763   double z = (pt[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2]) / mSlicers[slicer]->GetInput()->GetSpacing()[2];
 764
 765   if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0]-0.5 &&
 766       x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1]+0.5 &&
 767       y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2]-0.5 &&
 768       y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3]+0.5 &&
 769       z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4]-0.5 &&
 770       z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]+0.5) {
 771     for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++) {
 772       emit UpdateLinkManager(*i, slicer, p[0], p[1], p[2], mSlicers[slicer]->GetMaxCurrentTSlice());
 773     }
 774   }
 775 }
 776 //----------------------------------------------------------------------------
 777
 778 //----------------------------------------------------------------------------
 779 void vvSlicerManager::UpdateLinkedNavigation(vvSlicer *refSlicer, bool bPropagate)
 780 {
 781   vtkCamera *refCam = refSlicer->GetRenderer()->GetActiveCamera();
 782
 783   double refPosition[3];
 784   refCam->GetPosition(refPosition);
 785   refPosition[refSlicer->GetSliceOrientation()] = refSlicer->GetSlice() *
 786       refSlicer->GetInput()->GetSpacing()[refSlicer->GetSliceOrientation()] +
 787       refSlicer->GetInput()->GetOrigin()[refSlicer->GetSliceOrientation()];
 788
 789   refSlicer->GetSlicingTransform()->TransformPoint(refPosition, refPosition);
 790   mSlicers[0]->GetSlicingTransform()->GetInverse()->TransformPoint(refPosition, refPosition);
 791
 792   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 793     vtkCamera *camera = mSlicers[i]->GetRenderer()->GetActiveCamera();
 794     camera->SetParallelScale(refCam->GetParallelScale());
 795
 796     double position[3], focal[3];
 797     camera->GetPosition(position);
 798     camera->GetFocalPoint(focal);
 799
 800     for(int j=0; j<3; j++) {
 801       if(j!=mSlicers[i]->GetSliceOrientation()) {
 802         position[j] = refPosition[j];
 803         focal[j]    = refPosition[j];
 804       }
 805     }
 806
 807     camera->SetFocalPoint(focal);
 808     camera->SetPosition(position);
 809
 810     //Fix for bug #243
 811     mSlicers[i]->ForceUpdateDisplayExtent();
 812   }
 813
 814   Render();
 815   if(bPropagate)
 816     for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++)
 817       emit UpdateLinkedNavigation(*i, this, refSlicer);
 818 }
 819 //----------------------------------------------------------------------------
 820
 821 //----------------------------------------------------------------------------
 822 double vvSlicerManager::GetColorWindow() const
 823 {
 824   if (mSlicers.size())
 825     return mSlicers[0]->GetColorWindow();
 826   return -1;
 827 }
 828 //----------------------------------------------------------------------------
 829
 830
 831 //----------------------------------------------------------------------------
 832 double vvSlicerManager::GetColorLevel() const
 833 {
 834   if (mSlicers.size())
 835     return mSlicers[0]->GetColorLevel();
 836   return -1;
 837 }
 838 //----------------------------------------------------------------------------
 839
 840 //----------------------------------------------------------------------------
 841 double vvSlicerManager::GetOverlayColorWindow() const
 842 {
 843   if (mSlicers.size())
 844     return mSlicers[0]->GetOverlayColorWindow();
 845   return -1;
 846 }
 847 //----------------------------------------------------------------------------
 848
 849 //----------------------------------------------------------------------------
 850 double vvSlicerManager::GetOverlayColorLevel() const
 851 {
 852   if (mSlicers.size())
 853     return mSlicers[0]->GetOverlayColorLevel();
 854   return -1;
 855 }
 856 //----------------------------------------------------------------------------
 857
 858 //----------------------------------------------------------------------------
 859 bool vvSlicerManager::GetLinkOverlayWindowLevel() const
 860 {
 861   if (mSlicers.size())
 862     return mSlicers[0]->GetLinkOverlayWindowLevel();
 863   return -1;
 864 }
 865 //----------------------------------------------------------------------------
 866
 867 //------------------------------------------------------------------------------
 868 void vvSlicerManager::ResetTransformationToIdentity(const std::string actorType)
 869 {
 870   if(actorType == "image")
 871     for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
 872       this->GetImage()->GetTransform()[i]->Identity();
 873   else if(actorType == "overlay")
 874     for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
 875       this->GetSlicer(0)->GetOverlay()->GetTransform()[i]->Identity();
 876   else if(actorType == "fusion")
 877     for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
 878       this->GetSlicer(0)->GetFusion()->GetTransform()[i]->Identity();
 879   else if(actorType == "fusionSequence") //TODO: Check what should really be done here
 880     for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
 881       this->GetSlicer(0)->GetFusion()->GetTransform()[i]->Identity();
 882   else if(actorType == "vf")
 883     for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
 884       this->GetVF()->GetTransform()[i]->Identity();
 885   else
 886     return;
 887
 888   for(int i=0; i< this->GetNumberOfSlicers(); i++){
 889     this->GetSlicer(i)->ForceUpdateDisplayExtent();
 890     this->GetSlicer(i)->ResetCamera();
 891     this->GetSlicer(i)->Render();
 892   }
 893 }
 894 //------------------------------------------------------------------------------
 895
 896 //----------------------------------------------------------------------------
 897 void vvSlicerManager::Render()
 898 {
 899   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 900     mSlicers[i]->Render();
 901   }
 902 }
 903 //----------------------------------------------------------------------------
 904
 905
 906 //----------------------------------------------------------------------------
 907 void vvSlicerManager::GenerateDefaultLookupTable()
 908 {
 909   SetPreset(mPreset);
 910   SetColorMap(mColorMap);
 911 }
 912 //----------------------------------------------------------------------------
 913
 914
 915 //----------------------------------------------------------------------------
 916 void vvSlicerManager::Reload()
 917 {
 918   mReader->Update(mType);
 919   mImage=mReader->GetOutput();
 920   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 921     mSlicers[i]->SetImage(mImage);
 922   }
 923   //TODO: check if this image is involved in a fusion sequence, then the main transform matrix should be updated.
 924 }
 925 //----------------------------------------------------------------------------
 926
 927
 928 //----------------------------------------------------------------------------
 929 void vvSlicerManager::ReloadFusion()
 930 {
 931   mFusionReader->Update(mImage->GetNumberOfDimensions(),mFusionComponent.c_str(),mType);
 932
 933   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 934     mSlicers[i]->SetFusion(mFusionReader->GetOutput());
 935     mSlicers[i]->Render();
 936   }
 937 }
 938 //----------------------------------------------------------------------------
 939
 940 //----------------------------------------------------------------------------
 941 void vvSlicerManager::ReloadFusionSequence()
 942 {
 943   mFusionSequenceReader->Update(mImage->GetNumberOfDimensions(),mFusionComponent.c_str(),vvImageReader::MERGEDWITHTIME);
 944
 945   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 946     mSlicers[i]->SetFusion(mFusionSequenceReader->GetOutput());
 947     mSlicers[i]->Render();
 948   }
 949
 950   //Update the slider
 951   mFusionSequenceNbFrames = mFusionSequenceReader->GetOutput()->GetTransform().size();
 952   if (mFusionSequenceFrameIndex>=mFusionSequenceNbFrames) {
 953           mFusionSequenceFrameIndex=0;
 954   }
 955
 956   //Update the list of initial transforms
 957   //Warning, the main transform will not be updated on reload.........
 958   mFusionSequenceListInitialTransformMatrices.clear();
 959   for (unsigned i=0 ; i<mFusionSequenceNbFrames ; i++) {
 960           this->AddFusionSequenceInitialTransformMatrices( mFusionSequenceReader->GetOutput()->GetTransform()[i]->GetMatrix() );
 961   }
 962
 963   //emit UpdateFusionSequence(mFusionSequenceFrameIndex, mFusionSequenceSpatialSyncFlag, mFusionSequenceNbFrames);
 964 }
 965 //----------------------------------------------------------------------------
 966
 967
 968 //----------------------------------------------------------------------------
 969 void vvSlicerManager::ReloadOverlay()
 970 {
 971   mOverlayReader->Update(mImage->GetNumberOfDimensions(),mOverlayComponent.c_str(),mType);
 972   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 973     mSlicers[i]->SetOverlay(mOverlayReader->GetOutput());
 974     mSlicers[i]->Render();
 975   }
 976 }
 977 //----------------------------------------------------------------------------
 978
 979
 980 //----------------------------------------------------------------------------
 981 void vvSlicerManager::ReloadVF()
 982 {
 983   mVectorReader->Update(vvImageReader::VECTORFIELD); //deletes the old images through the VF::Init() function
 984   mVF=mVectorReader->GetOutput();
 985   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 986     mSlicers[i]->SetVF(mVF);
 987     mSlicers[i]->Render();
 988   }
 989 }
 990 //----------------------------------------------------------------------------
 991
 992
 993 //----------------------------------------------------------------------------
 994 void vvSlicerManager::RemoveActor(const std::string& actor_type, int overlay_index)
 995 {
 996   if (actor_type =="overlay")
 997     mOverlayReader = NULL;
 998
 999   if (actor_type =="fusion")
1000     mFusionReader = NULL;
1001
1002   if (actor_type =="fusionSequence") {
1003     mFusionSequenceReader = NULL;
1004   }
1005
1006   for (unsigned int i = 0; i < mSlicers.size(); i++)
1007     mSlicers[i]->RemoveActor(actor_type,overlay_index);
1008
1009   if (actor_type=="vector") {
1010     mVF=NULL;
1011     mVectorReader=NULL;
1012   }
1013 }
1014 //----------------------------------------------------------------------------
1015
1016
1017 //----------------------------------------------------------------------------
1018 void vvSlicerManager::RemoveActors()
1019 {
1020   ///This method leaks a few objects. See RemoveActor for what a
1021   ///correct implementation would look like
1022   //DS -> probably due to the reader (now released in the
1023   //RemoveActor() function. (I hope)
1024   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
1025     mSlicers[i]->SetDisplayMode(0);
1026     mSlicers[i]->GetRenderer()->RemoveActor(mSlicers[i]->GetImageActor());
1027   }
1028 }
1029 //----------------------------------------------------------------------------
1030
1031
1032 //----------------------------------------------------------------------------
1033 void vvSlicerManager::UpdateInfoOnCursorPosition(int slicer)
1034 {
1035   //  int view = mSlicers[slicer]->GetSliceOrientation();
1036   //  int slice = mSlicers[slicer]->GetSlice();
1037   double x = mSlicers[slicer]->GetCursorPosition()[0];
1038   double y = mSlicers[slicer]->GetCursorPosition()[1];
1039   double z = mSlicers[slicer]->GetCursorPosition()[2];
1040   double X = (x - mSlicers[slicer]->GetInput()->GetOrigin()[0])/
1041     mSlicers[slicer]->GetInput()->GetSpacing()[0];
1042   double Y = (y - mSlicers[slicer]->GetInput()->GetOrigin()[1])/
1043     mSlicers[slicer]->GetInput()->GetSpacing()[1];
1044   double Z = (z - mSlicers[slicer]->GetInput()->GetOrigin()[2])/
1045     mSlicers[slicer]->GetInput()->GetSpacing()[2];
1046   double value = -VTK_DOUBLE_MAX;
1047   int displayVec = 0;
1048   double xVec=0, yVec=0, zVec=0, valueVec=0;
1049   int displayOver = 0;
1050   int displayFus = 0;
1051   double valueOver=0, valueFus=0;
1052   if (X >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] &&
1053       X <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] &&
1054       Y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&
1055       Y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&
1056       Z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&
1057       Z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]) {
1058     value = this->GetScalarComponentAsDouble(mSlicers[slicer]->GetInput(), X, Y, Z);
1059
1060     if (mSlicers[slicer]->GetVFActor() ) {
1061       displayVec = 1;
1062       unsigned int currentTime = mSlicers[slicer]->GetMaxCurrentTSlice();
1063       vtkImageData *vf = NULL;
1064
1065       if (mSlicers[slicer]->GetVF()->GetVTKImages().size() > currentTime)
1066         vf = mSlicers[slicer]->GetVF()->GetVTKImages()[currentTime];
1067       else
1068         vf = mSlicers[slicer]->GetVF()->GetVTKImages()[0];
1069
1070       if (vf) {
1071         double Xvf = (x - vf->GetOrigin()[0])/ vf->GetSpacing()[0];
1072         double Yvf = (y - vf->GetOrigin()[1])/ vf->GetSpacing()[1];
1073         double Zvf = (z - vf->GetOrigin()[2])/ vf->GetSpacing()[2];
1074         xVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 0);
1075         yVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 1);
1076         zVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 2);
1077         valueVec = sqrt(xVec*xVec + yVec*yVec + zVec*zVec);
1078       }
1079     }
1080     if (mSlicers[slicer]->GetOverlayActor() ) {
1081       displayOver = 1;
1082       vtkImageData *overlay = dynamic_cast<vtkImageData*>(mSlicers[slicer]->GetOverlayMapper()->GetInput());
1083       double Xover = (x - overlay->GetOrigin()[0]) / overlay->GetSpacing()[0];
1084       double Yover = (y - overlay->GetOrigin()[1]) / overlay->GetSpacing()[1];
1085       double Zover = (z - overlay->GetOrigin()[2]) / overlay->GetSpacing()[2];
1086       valueOver = this->GetScalarComponentAsDouble(overlay, Xover, Yover, Zover);
1087     }
1088 \r
1089         if (mSlicers[slicer]->GetFusionActor() ) {\r
1090                 displayFus = 1;\r
1091                 vtkImageData *fusion = dynamic_cast<vtkImageData*>(mSlicers[slicer]->GetFusionMapper()->GetInput());\r
1092                 double Xover = (x - fusion->GetOrigin()[0]) / fusion->GetSpacing()[0];\r
1093                 double Yover = (y - fusion->GetOrigin()[1]) / fusion->GetSpacing()[1];\r
1094                 double Zover = (z - fusion->GetOrigin()[2]) / fusion->GetSpacing()[2];\r
1095                 valueFus = this->GetScalarComponentAsDouble(fusion, Xover, Yover, Zover);\r
1096         }\r
1097
1098
1099     emit UpdatePosition(mSlicers[slicer]->GetCursorVisibility(),
1100                         x,y,z,X,Y,Z,value);
1101     emit UpdateVector(displayVec,xVec, yVec, zVec, valueVec);
1102     emit UpdateOverlay(displayOver,valueOver,value);
1103     emit UpdateFusion(displayFus,valueFus);
1104   }
1105 }
1106 //----------------------------------------------------------------------------
1107
1108
1109 //----------------------------------------------------------------------------
1110 void vvSlicerManager::Activated()
1111 {
1112   emit currentImageChanged(mId);
1113 }
1114 //----------------------------------------------------------------------------
1115
1116
1117 //----------------------------------------------------------------------------
1118 void vvSlicerManager::Picked()
1119 {
1120   emit currentPickedImageChanged(mId);
1121 }
1122 //----------------------------------------------------------------------------
1123
1124
1125 //----------------------------------------------------------------------------
1126 void vvSlicerManager::UpdateWindowLevel()
1127 {
1128   emit WindowLevelChanged();
1129 }
1130 //----------------------------------------------------------------------------
1131
1132
1133 //----------------------------------------------------------------------------
1134 void vvSlicerManager::UpdateSlice(int slicer)
1135 {
1136   if (mPreviousSlice[slicer] == mSlicers[slicer]->GetSlice()) {
1137     //DD("============= NOTHING");
1138     return;
1139   }
1140   //std::cout << "vvSlicerManager::UpdateSlice " << slicer << " " << mSlicers[slicer]->GetSlice() << std::endl;
1141   emit UpdateSlice(slicer, mSlicers[slicer]->GetSlice());
1142   mSlicers[slicer]->Render(); // DS <-- I add this, this could/must be the only Render ...
1143   mPreviousSlice[slicer] = mSlicers[slicer]->GetSlice();
1144 }
1145 //----------------------------------------------------------------------------
1146
1147
1148 //----------------------------------------------------------------------------
1149 void vvSlicerManager::UpdateTSlice(int slicer)
1150 {
1151   int slice = mSlicers[slicer]->GetSlice();
1152   int tslice = mSlicers[slicer]->GetMaxCurrentTSlice();
1153   if (mPreviousSlice[slicer] == slice) {
1154     if (mPreviousTSlice[slicer] == tslice) {
1155       //      DD("************** NOTHING ***********");
1156       return;
1157     }
1158   }
1159   mPreviousSlice[slicer] = slice;
1160   mPreviousTSlice[slicer] = tslice;
1161   //std::cout << "vvSlicerManager::UpdateTSlice " << slicer << " " << tslice << std::endl;
1162   emit UpdateTSlice(slicer, tslice);
1163 }
1164 //----------------------------------------------------------------------------
1165
1166
1167 //----------------------------------------------------------------------------
1168 void vvSlicerManager::UpdateSliceRange(int slicer)
1169 {
1170   emit UpdateSliceRange(slicer,
1171                         mSlicers[slicer]->GetSliceRange()[0], mSlicers[slicer]->GetSliceRange()[1],
1172                         0,mSlicers[slicer]->GetTMax());
1173 }
1174 //----------------------------------------------------------------------------
1175
1176 //----------------------------------------------------------------------------
1177 void vvSlicerManager::SetSlicingPreset(SlicingPresetType preset)
1178 {
1179   if(mSlicingPreset==preset)
1180     return;
1181
1182   vtkMatrix4x4 *imageTransformInverse = vtkMatrix4x4::New();
1183   mImage->GetTransform()[this->GetTSlice()]->GetInverse(imageTransformInverse);
1184
1185   for(int i=0; i< this->GetNumberOfSlicers(); i++){
1186     vvSlicer *s = this->GetSlicer(i);
1187     switch(preset)
1188     {
1189     case WORLD_SLICING:
1190       s->GetSlicingTransform()->Identity();
1191       break;
1192     case VOXELS_SLICING:
1193       s->GetSlicingTransform()->SetMatrix(imageTransformInverse);
1194       break;
1195     default:
1196       imageTransformInverse->Delete();
1197       return;
1198     }
1199     s->ForceUpdateDisplayExtent();
1200     s->SetSlice((s->GetInput()->GetWholeExtent()[s->GetSliceOrientation()*2+1]
1201                 +s->GetInput()->GetWholeExtent()[s->GetSliceOrientation()*2])/2.0);
1202     s->ResetCamera();
1203     s->Render();
1204   }
1205
1206   imageTransformInverse->Delete();
1207   mSlicingPreset = preset;
1208 }
1209
1210 //----------------------------------------------------------------------------
1211
1212 //----------------------------------------------------------------------------
1213 void vvSlicerManager::SetPreset(int preset)
1214 {
1215   //vtkLookupTable* LUT = static_cast<vtkLookupTable*>(mSlicers[0]->GetWindowLevel()->GetLookupTable());
1216   double window = mSlicers[0]->GetColorWindow();
1217   double level = mSlicers[0]->GetColorLevel();
1218
1219   std::string component_type=mImage->GetScalarTypeAsITKString();
1220   switch (preset) {
1221   case 0:
1222     double range[2];
1223     mImage->GetScalarRange(range);
1224     window = range[1] - range[0];
1225     level = (range[1] + range[0])* 0.5;
1226     break;
1227   case 1:
1228     window = 2000;
1229     level = 0;
1230     break;
1231   case 2:
1232     window = 400;
1233     level = 20;
1234     break;
1235   case 3: // lungs (same as FOCAL)
1236     window = 1700;
1237     level = -300;
1238     break;
1239   case 4:
1240     window = 1000;
1241     level = 500;
1242     break;
1243   case 5:
1244     window = 1;
1245     level = 0.5;
1246     break;
1247   case 6:
1248     break;
1249   case 7:
1250     window=1.;
1251     level=0.;
1252     break;
1253   }
1254   mPreset = preset;
1255   this->SetColorWindow(window);
1256   this->SetColorLevel(level);
1257
1258   //if (LUT)
1259   //{
1260   //    SetColorMap(-1);
1261   //}
1262 }
1263 //----------------------------------------------------------------------------
1264
1265
1266 //----------------------------------------------------------------------------
1267 void vvSlicerManager::SetLocalColorWindowing(const int slicer, const bool bCtrlKey)
1268 {
1269   double min, max;
1270   if(bCtrlKey && this->mSlicers[slicer]->GetFusion()) {
1271     int t = mSlicers[slicer]->GetFusionTSlice();
1272     this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max,
1273                                                           this->mSlicers[slicer]->GetFusion()->GetVTKImages()[t],
1274                                                           this->mSlicers[slicer]->GetConcatenatedFusionTransform());
1275     this->SetFusionWindow(max-min);
1276     this->SetFusionLevel(0.5*(min+max));
1277     this->SetColorMap(mColorMap);
1278   }
1279   else if(bCtrlKey && this->mSlicers[slicer]->GetOverlay()) {
1280     int t = mSlicers[slicer]->GetOverlayTSlice();
1281     this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max,
1282                                                           this->mSlicers[slicer]->GetOverlay()->GetVTKImages()[t],
1283                                                           this->mSlicers[slicer]->GetConcatenatedOverlayTransform());
1284     if(this->mSlicers[slicer]->GetLinkOverlayWindowLevel()){
1285       this->SetColorWindow(max-min);
1286       this->SetColorLevel(0.5*(min+max));
1287     } else {
1288       this->SetOverlayColorWindow(max-min);
1289       this->SetOverlayColorLevel(0.5*(min+max));
1290     }
1291   }
1292   else {
1293     int t = this->GetTSlice();
1294     this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max,
1295                                                           this->mSlicers[slicer]->GetImage()->GetVTKImages()[t],
1296                                                           this->mSlicers[slicer]->GetConcatenatedTransform());
1297     this->SetColorWindow(max-min);
1298     this->SetColorLevel(0.5*(min+max));
1299     this->SetPreset(6);
1300   }
1301   this->Render();
1302   this->UpdateWindowLevel();
1303 }
1304 //----------------------------------------------------------------------------
1305
1306
1307 //----------------------------------------------------------------------------
1308 void vvSlicerManager::SetColorMap(int colormap)
1309 {
1310   double range[2];
1311
1312   range[0] = mSlicers[0]->GetInput()->GetScalarRange()[0];
1313   range[1] = mSlicers[0]->GetInput()->GetScalarRange()[1];
1314
1315   double window = mSlicers[0]->GetWindowLevel()->GetWindow();
1316   double level = mSlicers[0]->GetWindowLevel()->GetLevel();
1317
1318   vtkLookupTable* LUT = static_cast<vtkLookupTable*>(mSlicers[0]->GetWindowLevel()->GetLookupTable());
1319   switch (colormap) {
1320   case -1:
1321     break;
1322   case 0:
1323     LUT = NULL;
1324     break;
1325   case 1:
1326     if (LUT == NULL)
1327       LUT = vtkLookupTable::New();
1328     LUT->SetValueRange(0,1);
1329     LUT->SetSaturationRange(1,1);
1330     LUT->SetHueRange(0,0.18);
1331     break;
1332   case 2:
1333     if (LUT == NULL)
1334       LUT = vtkLookupTable::New();
1335     LUT->SetValueRange(0,1);
1336     LUT->SetSaturationRange(1,1);
1337     LUT->SetHueRange(0.4,0.80);
1338     break;
1339   case 3:
1340     if (LUT == NULL)
1341       LUT = vtkLookupTable::New();
1342     LUT->SetValueRange(0.5,1);
1343     LUT->SetSaturationRange(1,1);
1344     LUT->SetHueRange(0.666,0);
1345     break;
1346   case 4:
1347     if (LUT == NULL)
1348       LUT = vtkLookupTable::New();
1349     LUT->SetValueRange(1,1);
1350     LUT->SetSaturationRange(1,1);
1351     LUT->SetHueRange(0,1);
1352     LUT->SetAlphaRange(1, 1);
1353     break;
1354   case 5:
1355     if (LUT == NULL)
1356       LUT = vtkLookupTable::New();
1357     LUT->SetValueRange(1,1);
1358     LUT->SetSaturationRange(1,1);
1359     LUT->SetHueRange(1,0.1);
1360     //LUT->SetRampToLinear();
1361     break;
1362   }
1363   if (LUT) {
1364     LUT->SetTableRange(level-fabs(window)/2,level+fabs(window)/2);
1365     LUT->Build();
1366   }
1367   vtkWindowLevelLookupTable* fusLUT = NULL;
1368   if (mSlicers[0]->GetFusion()) { // && mFusionColorMap >= 0) {
1369         fusLUT = vtkWindowLevelLookupTable::New();
1370     double fusRange [2];
1371     fusRange[0] = mFusionLevel - mFusionWindow/2;
1372     fusRange[1] = mFusionLevel + mFusionWindow/2;
1373
1374         //check whether it is actually a fusionSequence or a fusion, before invoking mFusionReader...
1375         double* frange;
1376         if (mFusionReader.IsNull()) frange = mFusionSequenceReader->GetOutput()->GetVTKImages()[0]->GetScalarRange();
1377     else                        frange = mFusionReader->GetOutput()->GetVTKImages()[0]->GetScalarRange();
1378
1379         fusLUT->SetTableRange(frange);
1380     fusLUT->SetValueRange(1,1);
1381     fusLUT->SetSaturationRange(1,1);
1382     fusLUT->SetAlphaRange(1, 1);
1383     fusLUT->SetWindow(mFusionWindow);
1384     fusLUT->SetLevel(mFusionLevel);
1385     if (mFusionColorMap == 1)
1386       fusLUT->SetHueRange(0,0.18);
1387     else if (mFusionColorMap == 2)
1388       fusLUT->SetHueRange(0.4,0.80);
1389     else if (mFusionColorMap == 3)
1390     {
1391       fusLUT->SetHueRange(0.666, 0);
1392       fusLUT->SetValueRange(0.5, 1);
1393     }
1394     else if (mFusionColorMap == 4)
1395       fusLUT->SetHueRange(0,1);
1396     else if (mFusionColorMap <= 0)
1397     {
1398       fusLUT->SetValueRange(0,1);
1399       fusLUT->SetSaturationRange(0,0);
1400     }
1401
1402     fusLUT->ForceBuild();
1403     double v[4];
1404
1405     // set color table transparency
1406     //double alpha_range=(double)mFusionThresOpacity/10;
1407     double range_end = fusRange[0] + (double)mFusionThresOpacity*(fusRange[1] - fusRange[0])/100;
1408     double curr_value = fusRange[0];
1409     int nvalues = fusLUT->GetNumberOfTableValues();
1410     for (double i = 0; curr_value < range_end; i++) {
1411       fusLUT->GetTableValue(i, v);
1412       v[3] = 0;
1413       //if (curr_value >= -alpha_range && curr_value <= alpha_range) v[3] = pow(fabs(curr_value/alpha_range),2);
1414       //else v[3] = 1;
1415       fusLUT->SetTableValue(i, v);
1416       curr_value += (fusRange[1] - fusRange[0])/nvalues;
1417     }
1418   }
1419   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
1420
1421     if (mSlicers[i]->GetOverlay()) {
1422       vtkLookupTable* supLUT = vtkLookupTable::New();
1423       supLUT->SetTableRange(range[0],range[1]);
1424       supLUT->SetValueRange(1,1);
1425       supLUT->SetSaturationRange(1,1);
1426       supLUT->SetHueRange(double(mOverlayColor)/360,double(mOverlayColor)/360);
1427       supLUT->Build();
1428       vtkLookupTable* invLUT = vtkLookupTable::New();
1429       invLUT->SetTableRange(range[0],range[1]);
1430       invLUT->SetValueRange(1,1);
1431       invLUT->SetSaturationRange(1,1);
1432       invLUT->SetHueRange(double((mOverlayColor+180)%360)/360,double((mOverlayColor+180)%360)/360);
1433       invLUT->Build();
1434       mSlicers[i]->GetWindowLevel()->SetLookupTable(supLUT);
1435       mSlicers[i]->GetOverlayMapper()->SetLookupTable(invLUT);
1436       invLUT->Delete();
1437       supLUT->Delete();
1438     } else if (mSlicers[i]->GetOverlay()) {
1439       mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT);
1440     } else {
1441       mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT);
1442     }
1443
1444     if (mSlicers[i]->GetFusion()) {
1445       mSlicers[i]->ShowFusionLegend(mFusionShowLegend);
1446       mSlicers[i]->GetFusionMapper()->SetLookupTable(fusLUT);
1447       mSlicers[i]->GetFusionActor()->SetOpacity(double(mFusionOpacity)/100);
1448     }
1449   }
1450   if (fusLUT)
1451     fusLUT->Delete();
1452   if (colormap >= 0)
1453     mColorMap = colormap;
1454 }
1455 //----------------------------------------------------------------------------
1456
1457
1458 //----------------------------------------------------------------------------
1459 vvLandmarks* vvSlicerManager::GetLandmarks()
1460 {
1461   if (mLandmarks == NULL) {
1462     mLandmarks = new vvLandmarks(mSlicers[0]->GetTMax()+1);
1463     for (unsigned int i = 0; i < mSlicers.size(); i++)
1464       mSlicers[i]->SetLandmarks(mLandmarks);
1465   }
1466   return mLandmarks;
1467 }
1468 //----------------------------------------------------------------------------
1469
1470
1471 //----------------------------------------------------------------------------
1472 void vvSlicerManager::AddLandmark(float x,float y,float z,float t)
1473 {
1474   double x_index = (x - mSlicers[0]->GetInput()->GetOrigin()[0])/mSlicers[0]->GetInput()->GetSpacing()[0];
1475   double y_index = (y - mSlicers[0]->GetInput()->GetOrigin()[1])/mSlicers[0]->GetInput()->GetSpacing()[1];
1476   double z_index = (z - mSlicers[0]->GetInput()->GetOrigin()[2])/mSlicers[0]->GetInput()->GetSpacing()[2];
1477   if (x_index >= mSlicers[0]->GetInput()->GetWholeExtent()[0]-0.5 &&
1478       x_index <= mSlicers[0]->GetInput()->GetWholeExtent()[1]+0.5 &&
1479       y_index >= mSlicers[0]->GetInput()->GetWholeExtent()[2]-0.5 &&
1480       y_index <= mSlicers[0]->GetInput()->GetWholeExtent()[3]+0.5 &&
1481       z_index >= mSlicers[0]->GetInput()->GetWholeExtent()[4]-0.5 &&
1482       z_index <= mSlicers[0]->GetInput()->GetWholeExtent()[5]+0.5) {
1483     double value = this->GetScalarComponentAsDouble(mSlicers[0]->GetInput(), x_index, y_index, z_index);
1484     this->GetLandmarks()->AddLandmark(x,y,z,t,value);
1485     emit LandmarkAdded();
1486   }
1487 }
1488 //----------------------------------------------------------------------------
1489
1490 //----------------------------------------------------------------------------
1491 void vvSlicerManager::PrevImage(int slicer)
1492 {
1493   emit ChangeImageWithIndexOffset(this, slicer, -1);
1494 }
1495 //----------------------------------------------------------------------------
1496
1497 //----------------------------------------------------------------------------
1498 void vvSlicerManager::NextImage(int slicer)
1499 {
1500   emit ChangeImageWithIndexOffset(this, slicer,  1);
1501 }
1502 //----------------------------------------------------------------------------
1503
1504 //----------------------------------------------------------------------------
1505 void vvSlicerManager::VerticalSliderHasChanged(int slicer, int slice)
1506 {
1507   emit AVerticalSliderHasChanged(slicer, slice);
1508 }
1509
1510 //----------------------------------------------------------------------------
1511
1512 //----------------------------------------------------------------------------
1513 double vvSlicerManager::GetScalarComponentAsDouble(vtkImageData *image, double X, double Y, double Z, int component)
1514 {
1515   int ix, iy, iz;
1516   return mSlicers[0]->GetScalarComponentAsDouble(image, X, Y, Z, ix, iy, iz, component);
1517 }
1518 //----------------------------------------------------------------------------