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