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