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