vv/vvSlicerManager.cxx

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