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