vv/vvSlicer.cxx

   1 /*=========================================================================
   2   Program:   vv                     http://www.creatis.insa-lyon.fr/rio/vv
   3
   4   Authors belong to:
   5   - University of LYON              http://www.universite-lyon.fr/
   6   - Léon Bérard cancer center       http://oncora1.lyon.fnclcc.fr
   7   - CREATIS CNRS laboratory         http://www.creatis.insa-lyon.fr
   8
   9   This software is distributed WITHOUT ANY WARRANTY; without even
  10   the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  11   PURPOSE.  See the copyright notices for more information.
  12
  13   It is distributed under dual licence
  14
  15   - BSD        See included LICENSE.txt file
  16   - CeCILL-B   http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
  17   ======================================================================-====*/
  18
  19 #include "vvSlicer.h"
  20 #include "vvImage.h"
  21 #include "vvSlicerManagerCommand.h"
  22 #include "vvGlyphSource.h"
  23 #include "vvGlyph2D.h"
  24 #include "vvImageMapToWLColors.h"
  25
  26 #include <vtkTextProperty.h>
  27 #include <vtkTextActor.h>
  28 #include <vtkTextSource.h>
  29 #include <vtkActor2D.h>
  30 #include <vtkCursor2D.h>
  31 #include <vtkPolyDataMapper2D.h>
  32 #include <vtkProperty2D.h>
  33 #include <vtkCornerAnnotation.h>
  34 #include <vtkImageMapToWindowLevelColors.h>
  35 #include <vtkImageData.h>
  36 #include <vtkImageActor.h>
  37 #include <vvBlendImageActor.h>
  38 #include <vtkToolkits.h>
  39 #include <vtkObjectFactory.h>
  40 #include <vtkPointData.h>
  41 #include <vtkDataArray.h>
  42 #include <vtkFloatArray.h>
  43 #include <vtkClipPolyData.h>
  44 #include <vtkGlyph3D.h>
  45 #include <vtkMath.h>
  46 #include <vtkCursor3D.h>
  47 #include <vtkProperty.h>
  48 #include <vtkLight.h>
  49 #include <vtkLightCollection.h>
  50 #include <vtkScalarBarActor.h>
  51 #include <vtkLookupTable.h>
  52
  53 #include <vtkRenderer.h>
  54 #include <vtkRendererCollection.h>
  55 #include <vtkRenderWindow.h>
  56 #include <vtkRenderWindowInteractor.h>
  57 #include <vtkCamera.h>
  58 #include <vtkCallbackCommand.h>
  59 #include <vtkCommand.h>
  60 #include <vtkPolyDataMapper.h>
  61 #include <vtkBox.h>
  62
  63 #include <vtkExtractVOI.h>
  64 #include <vtkSphereSource.h>
  65 #include <vtkCutter.h>
  66 #include <vtkAssignAttribute.h>
  67 #include <vtkImageAccumulate.h>
  68 #include <vtkImageReslice.h>
  69
  70 vtkCxxRevisionMacro(vvSlicer, "DummyRevision");
  71 vtkStandardNewMacro(vvSlicer);
  72
  73 //------------------------------------------------------------------------------
  74 vvSlicer::vvSlicer()
  75 {
  76   this->UnInstallPipeline();
  77   mImage = NULL;
  78   mCurrentTSlice = 0;
  79   mUseReducedExtent = false;
  80
  81   mCurrent[0] = -VTK_DOUBLE_MAX;
  82   mCurrent[1] = -VTK_DOUBLE_MAX;
  83   mCurrent[2] = -VTK_DOUBLE_MAX;
  84
  85   mCursor[0] = -VTK_DOUBLE_MAX;
  86   mCursor[1] = -VTK_DOUBLE_MAX;
  87   mCursor[2] = -VTK_DOUBLE_MAX;
  88   mCursor[3] = -VTK_DOUBLE_MAX;
  89
  90   mSubSampling = 5;
  91   mScale = 1;
  92   mVFLog = 0;
  93   mVFWidth = 1;
  94
  95   std::string text = "F1 = sagital; F2 = coronal; F3 = axial\n";
  96   text += "F5 = horizontal flip; F6 = vertical flip\n\n";
  97   text += "0,1,2,3,4,5 : preset windowing\n";
  98   text += "6,7,8,9 : preset colormap\n";
  99   text += "z : local windowing\n";
 100   text += "r : reset view\n";
 101   text += "l : reload image\n";
 102   text += "f : fly to mouse position\n";
 103   text += "g : go to cross hair position\n\n";
 104   text += "Up,down : change slice\n";
 105   text += "Left,right : change tenporal slice\n\n";
 106   text += "Scrollbar (or w/x) : zoom in/out\n";
 107   text += "left button : synchronize all views\n";
 108   text += "middle button : grab image\n";
 109   text += "right button : change windowing\n";
 110
 111   crossCursor = vtkSmartPointer<vtkCursor2D>::New();
 112   crossCursor->AllOff();
 113   crossCursor->AxesOn();
 114   crossCursor->SetTranslationMode(1);
 115   crossCursor->SetRadius(2);
 116
 117   pdm = vtkSmartPointer<vtkPolyDataMapper2D>::New();
 118   pdm->SetInput(crossCursor->GetOutput());
 119
 120   pdmA = vtkSmartPointer<vtkActor2D>::New();
 121   pdmA->SetMapper(pdm);
 122   pdmA->GetProperty()->SetColor(255,10,212);
 123   pdmA->SetVisibility(0);
 124   pdmA->SetPickable(0);
 125
 126   ca = vtkSmartPointer<vtkCornerAnnotation>::New();
 127   ca->GetTextProperty()->SetColor(255,10,212);
 128   ca->SetVisibility(1);
 129   mFileName = "";
 130
 131   mVF = NULL;
 132   mOverlay = NULL;
 133   mFusion = NULL;
 134   mLandmarks = NULL;
 135
 136   legend = vtkSmartPointer<vtkScalarBarActor>::New();
 137   //legend->SetTitle("test!");
 138   legend->SetPosition(0.82,0.18);
 139   legend->SetWidth(0.1);
 140   legend->SetVisibility(0);
 141   legend->SetLabelFormat("%.1f");
 142   this->GetRenderer()->AddActor(legend);
 143
 144   this->WindowLevel->Delete();
 145   this->WindowLevel = vvImageMapToWLColors::New();
 146
 147   this->InstallPipeline();
 148 }
 149 //------------------------------------------------------------------------------
 150
 151
 152 //------------------------------------------------------------------------------
 153 vtkImageMapToWindowLevelColors* vvSlicer::GetOverlayMapper()
 154 {
 155   return mOverlayMapper.GetPointer();
 156 }
 157 //------------------------------------------------------------------------------
 158
 159
 160 //------------------------------------------------------------------------------
 161 vvBlendImageActor* vvSlicer::GetOverlayActor()
 162 {
 163   return mOverlayActor.GetPointer();
 164 }
 165 //------------------------------------------------------------------------------
 166
 167
 168 //------------------------------------------------------------------------------
 169 vtkImageMapToWindowLevelColors* vvSlicer::GetFusionMapper()
 170 {
 171   return mFusionMapper.GetPointer();
 172 }
 173 //------------------------------------------------------------------------------
 174
 175
 176 //------------------------------------------------------------------------------
 177 vtkImageActor* vvSlicer::GetFusionActor()
 178 {
 179   return mFusionActor.GetPointer();
 180 }
 181 //------------------------------------------------------------------------------
 182
 183
 184 //------------------------------------------------------------------------------
 185 vtkActor* vvSlicer::GetVFActor()
 186 {
 187   return mVFActor.GetPointer();
 188 }
 189 //------------------------------------------------------------------------------
 190
 191
 192 //------------------------------------------------------------------------------
 193 vtkCornerAnnotation* vvSlicer::GetAnnotation()
 194 {
 195   return ca.GetPointer();
 196 }
 197 //------------------------------------------------------------------------------
 198
 199
 200 //------------------------------------------------------------------------------
 201 void vvSlicer::EnableReducedExtent(bool b)
 202 {
 203   mUseReducedExtent = b;
 204 }
 205 //------------------------------------------------------------------------------
 206
 207
 208 //------------------------------------------------------------------------------
 209 void vvSlicer::SetReducedExtent(int * ext)
 210 {
 211   mReducedExtent = ext;
 212 }
 213 //------------------------------------------------------------------------------
 214
 215
 216 //------------------------------------------------------------------------------
 217 void vvSlicer::AddContour(vvMesh::Pointer contour,bool propagate)
 218 {
 219
 220   mSurfaceCutActors.push_back(new vvMeshActor());
 221   if (propagate)
 222     mSurfaceCutActors.back()->Init(contour,mCurrentTSlice,mVF);
 223   else
 224     mSurfaceCutActors.back()->Init(contour,mCurrentTSlice);
 225   mSurfaceCutActors.back()->SetSlicingOrientation(SliceOrientation);
 226   this->GetRenderer()->AddActor(mSurfaceCutActors.back()->GetActor());
 227
 228   SetContourSlice();
 229 }
 230 //------------------------------------------------------------------------------
 231
 232
 233 //------------------------------------------------------------------------------
 234 void vvSlicer::ToggleContourSuperposition()
 235 {
 236   for (std::vector<vvMeshActor*>::iterator i=mSurfaceCutActors.begin();
 237        i!=mSurfaceCutActors.end(); i++)
 238     (*i)->ToggleSuperposition();
 239 }
 240 //------------------------------------------------------------------------------
 241
 242
 243 //------------------------------------------------------------------------------
 244 void vvSlicer::SetCursorColor(int r,int g, int b)
 245 {
 246   pdmA->GetProperty()->SetColor(r,g,b);
 247 }
 248 //------------------------------------------------------------------------------
 249
 250
 251 //------------------------------------------------------------------------------
 252 void vvSlicer::SetCursorVisibility(bool s)
 253 {
 254   pdmA->SetVisibility(s);
 255 }
 256 //------------------------------------------------------------------------------
 257
 258
 259 //------------------------------------------------------------------------------
 260 bool vvSlicer::GetCursorVisibility()
 261 {
 262   return pdmA->GetVisibility();
 263 }
 264 //------------------------------------------------------------------------------
 265
 266
 267 //------------------------------------------------------------------------------
 268 vvSlicer::~vvSlicer()
 269 {
 270   for (std::vector<vvMeshActor*>::iterator i=mSurfaceCutActors.begin();
 271        i!=mSurfaceCutActors.end(); i++)
 272     delete (*i);
 273 }
 274 //------------------------------------------------------------------------------
 275
 276
 277 //------------------------------------------------------------------------------
 278 void vvSlicer::SetCurrentPosition(double x, double y, double z, int t)
 279 {
 280   mCurrent[0] = x;
 281   mCurrent[1] = y;
 282   mCurrent[2] = z;
 283   mCurrentTSlice = t;
 284 }
 285 //------------------------------------------------------------------------------
 286
 287
 288 //------------------------------------------------------------------------------
 289 void vvSlicer::SetImage(vvImage::Pointer image)
 290 {
 291   if (image->GetVTKImages().size()) {
 292     mImage = image;
 293     this->Superclass::SetInput(image->GetVTKImages()[0]);
 294
 295     // Prevent crash when reload -> change slice if outside extent
 296     int extent[6];
 297     this->GetInput()->GetWholeExtent(extent);
 298     if (SliceOrientation == 0) {
 299       if (Slice >= extent[1]) {
 300         Slice = (extent[1]-extent[0])/2.0;
 301       }
 302     }
 303     if (SliceOrientation == 1) {
 304       if (Slice >= extent[3]) {
 305         Slice = (extent[3]-extent[2])/2.0;
 306       }
 307     }
 308     if (SliceOrientation == 2) {
 309       if (Slice >= extent[5]) {
 310         Slice = (extent[5]-extent[4])/2.0;
 311       }
 312     }
 313
 314     this->UpdateDisplayExtent();
 315     mCurrentTSlice = 0;
 316     ca->SetText(0,mFileName.c_str());
 317   }
 318 }
 319 //------------------------------------------------------------------------------
 320
 321
 322 //------------------------------------------------------------------------------
 323 void vvSlicer::SetOverlay(vvImage::Pointer overlay)
 324 {
 325   if (overlay->GetVTKImages().size()) {
 326     mOverlay = overlay;
 327
 328     if (!mOverlayMapper)
 329       mOverlayMapper = vtkSmartPointer<vtkImageMapToWindowLevelColors>::New();
 330     mOverlayMapper->SetInput(overlay->GetVTKImages()[0]);
 331
 332     if (!mOverlayActor) {
 333       mOverlayActor = vtkSmartPointer<vvBlendImageActor>::New();
 334       mOverlayActor->SetInput(mOverlayMapper->GetOutput());
 335       mOverlayActor->SetPickable(0);
 336       mOverlayActor->SetVisibility(false);
 337       mOverlayActor->SetOpacity(0.5);
 338       this->UpdateDisplayExtent();
 339     }
 340
 341     //stupid but necessary : the Overlay need to be rendered before fusion
 342     if (mFusionActor) {
 343       this->GetRenderer()->RemoveActor(mFusionActor);
 344       this->GetRenderer()->AddActor(mOverlayActor);
 345       this->GetRenderer()->AddActor(mFusionActor);
 346     } else
 347       this->GetRenderer()->AddActor(mOverlayActor);
 348
 349     //Synchronize slice
 350     SetTSlice(mCurrentTSlice);
 351   }
 352 }
 353 //------------------------------------------------------------------------------
 354
 355
 356 //------------------------------------------------------------------------------
 357 void vvSlicer::SetFusion(vvImage::Pointer fusion)
 358 {
 359   if (fusion->GetVTKImages().size()) {
 360     mFusion = fusion;
 361
 362     if (!mFusionMapper)
 363       mFusionMapper = vtkSmartPointer<vtkImageMapToWindowLevelColors>::New();
 364     mFusionMapper->SetInput(fusion->GetVTKImages()[0]);
 365
 366     if (!mFusionActor) {
 367       mFusionActor = vtkSmartPointer<vtkImageActor>::New();
 368       mFusionActor->SetInput(mFusionMapper->GetOutput());
 369       mFusionActor->SetPickable(0);
 370       mFusionActor->SetVisibility(false);
 371       mFusionActor->SetOpacity(0.7);
 372       this->UpdateDisplayExtent();
 373       this->GetRenderer()->AddActor(mFusionActor);
 374     }
 375
 376     //Synchronize slice
 377     SetTSlice(mCurrentTSlice);
 378   }
 379 }
 380 //------------------------------------------------------------------------------
 381
 382
 383 //------------------------------------------------------------------------------
 384 void vvSlicer::SetActorVisibility(const std::string& actor_type, int overlay_index ,bool vis)
 385 {
 386   if (actor_type == "vector") {
 387     this->mVFActor->SetVisibility(vis);
 388   }
 389   if (actor_type == "overlay") {
 390     this->mOverlayActor->SetVisibility(vis);
 391   }
 392   if (actor_type == "fusion") {
 393     this->mFusionActor->SetVisibility(vis);
 394   }
 395   if (actor_type == "contour")
 396     this->mSurfaceCutActors[overlay_index]->GetActor()->SetVisibility(vis);
 397   UpdateDisplayExtent();
 398 }
 399 //------------------------------------------------------------------------------
 400
 401
 402 //------------------------------------------------------------------------------
 403 void vvSlicer::SetVF(vvImage::Pointer vf)
 404 {
 405   if (vf->GetVTKImages().size()) {
 406     mVF = vf;
 407
 408     if (!mAAFilter) {
 409       mAAFilter= vtkSmartPointer<vtkAssignAttribute>::New();
 410       mVOIFilter = vtkSmartPointer<vtkExtractVOI>::New();
 411       mVOIFilter->SetSampleRate(mSubSampling,mSubSampling,mSubSampling);
 412     }
 413     mVOIFilter->SetInput(vf->GetVTKImages()[0]);
 414     mAAFilter->SetInput(mVOIFilter->GetOutput());
 415     ///This tells VTK to use the scalar (pixel) data of the image to draw the little arrows
 416     mAAFilter->Assign(vtkDataSetAttributes::SCALARS, vtkDataSetAttributes::VECTORS, vtkAssignAttribute::POINT_DATA);
 417
 418     if (!mArrow)
 419       mArrow = vtkSmartPointer<vvGlyphSource>::New();
 420     mArrow->SetGlyphTypeToSpecificArrow();
 421     mArrow->SetScale(mScale);
 422     mArrow->FilledOff();
 423
 424     // Glyph the gradient vector (with arrows)
 425     if (!mGlyphFilter)
 426       mGlyphFilter = vtkSmartPointer<vvGlyph2D>::New();
 427     mGlyphFilter->SetInput(mAAFilter->GetOutput());
 428     mGlyphFilter->SetSource(mArrow->GetOutput());
 429     mGlyphFilter->ScalingOn();
 430     mGlyphFilter->SetScaleModeToScaleByVector();
 431     mGlyphFilter->OrientOn();
 432     mGlyphFilter->SetVectorModeToUseVector();
 433     mGlyphFilter->SetColorModeToColorByVector();
 434
 435     if (!mVFMapper)
 436       mVFMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
 437     //mVFMapper->SetInputConnection(mGlyphFilter->GetOutputPort());
 438     mVFMapper->SetInput(mGlyphFilter->GetOutput());
 439     mVFMapper->ImmediateModeRenderingOn();
 440
 441     if (!mVFActor)
 442       mVFActor = vtkSmartPointer<vtkActor>::New();
 443     mVFActor->SetMapper(mVFMapper);
 444     mVFActor->SetPickable(0);
 445     mVFActor->GetProperty()->SetLineWidth(mVFWidth);
 446     this->UpdateDisplayExtent();
 447     this->GetRenderer()->AddActor(mVFActor);
 448
 449     //Synchronize slice
 450     SetTSlice(mCurrentTSlice);
 451   }
 452 }
 453 //------------------------------------------------------------------------------
 454
 455
 456 //------------------------------------------------------------------------------
 457 void vvSlicer::SetLandmarks(vvLandmarks* landmarks)
 458 {
 459   mLandmarks = landmarks;
 460   if (landmarks) {
 461
 462     if (!mCross)
 463       mCross = vtkSmartPointer<vtkCursor3D>::New();
 464     mCross->SetFocalPoint(0.0,0.0,0.0);
 465     mCross->SetModelBounds(-10,10,-10,10,-10,10);
 466     mCross->AllOff();
 467     mCross->AxesOn();
 468
 469     if (!mLandGlyph)
 470       mLandGlyph = vtkSmartPointer<vtkGlyph3D>::New();
 471     mLandGlyph->SetSource(mCross->GetOutput());
 472     mLandGlyph->SetInput(landmarks->GetOutput());
 473     //mLandGlyph->SetIndexModeToScalar();
 474     mLandGlyph->SetRange(0,1);
 475     mLandGlyph->ScalingOff();
 476
 477     mLandGlyph->SetColorModeToColorByScalar();
 478
 479     if (!mClipBox)
 480       mClipBox = vtkSmartPointer<vtkBox>::New();
 481     if (!mLandClipper)
 482       mLandClipper = vtkSmartPointer<vtkClipPolyData>::New();
 483     mLandClipper->InsideOutOn();
 484     mLandClipper->SetInput(mLandGlyph->GetOutput());
 485     mLandClipper->SetClipFunction(mClipBox);
 486
 487     if (!mLandMapper)
 488       mLandMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
 489     mLandMapper->SetInputConnection(mLandClipper->GetOutputPort());
 490     //mLandMapper->ScalarVisibilityOff();
 491
 492     if (!mLandActor)
 493       mLandActor = vtkSmartPointer<vtkActor>::New();
 494     mLandActor->SetMapper(mLandMapper);
 495     mLandActor->GetProperty()->SetColor(255,10,212);
 496     mLandActor->SetPickable(0);
 497     mLandActor->SetVisibility(true);
 498     this->UpdateDisplayExtent();
 499     this->GetRenderer()->AddActor(mLandActor);
 500   }
 501 }
 502 //------------------------------------------------------------------------------
 503
 504 //------------------------------------------------------------------------------
 505 //FIXME: this function leaks memory, we should fix it someday :)
 506 void vvSlicer::RemoveActor(const std::string& actor_type, int overlay_index)
 507 {
 508   if (actor_type == "vector") {
 509     Renderer->RemoveActor(mVFActor);
 510     mGlyphFilter=NULL;
 511     mVF = NULL;
 512     mArrow = NULL;
 513     mAAFilter=NULL;
 514     mVOIFilter = NULL;
 515     mVFMapper = NULL;
 516     mVFActor = NULL;
 517   }
 518   if (actor_type == "overlay") {
 519     Renderer->RemoveActor(mOverlayActor);
 520     mOverlay = NULL;
 521     mOverlayActor = NULL;
 522     mOverlayMapper = NULL;
 523   }
 524   if (actor_type == "fusion") {
 525     Renderer->RemoveActor(mFusionActor);
 526     mFusion = NULL;
 527     mFusionActor = NULL;
 528     mFusionMapper = NULL;
 529   }
 530   if (actor_type == "contour") {
 531     Renderer->RemoveActor(this->mSurfaceCutActors[overlay_index]->GetActor());
 532     mSurfaceCutActors.erase(mSurfaceCutActors.begin()+overlay_index);
 533   }
 534 }
 535 //------------------------------------------------------------------------------
 536
 537
 538 //------------------------------------------------------------------------------
 539 void vvSlicer::SetVFSubSampling(int sub)
 540 {
 541   if (mVOIFilter) {
 542     mVOIFilter->SetSampleRate(mSubSampling,mSubSampling,mSubSampling);
 543     mSubSampling = sub;
 544   }
 545   UpdateDisplayExtent();
 546   Render();
 547 }
 548 //------------------------------------------------------------------------------
 549
 550
 551 //------------------------------------------------------------------------------
 552 void vvSlicer::SetVFScale(int scale)
 553 {
 554   mScale = scale;
 555   if (mArrow)
 556     mArrow->SetScale(mScale);
 557   UpdateDisplayExtent();
 558   Render();
 559 }
 560 //------------------------------------------------------------------------------
 561
 562 //------------------------------------------------------------------------------
 563 void vvSlicer::SetVFWidth(int width)
 564 {
 565   mVFWidth = width;
 566   if (mVFActor)
 567     mVFActor->GetProperty()->SetLineWidth(mVFWidth);
 568   UpdateDisplayExtent();
 569   Render();
 570 }
 571 //------------------------------------------------------------------------------
 572
 573
 574 //------------------------------------------------------------------------------
 575 void vvSlicer::SetVFLog(int log)
 576 {
 577   mVFLog = log;
 578   if (mGlyphFilter) {
 579     mGlyphFilter->SetUseLog(mVFLog);
 580     mGlyphFilter->Modified();
 581   }
 582   UpdateDisplayExtent();
 583   Render();
 584 }
 585 //------------------------------------------------------------------------------
 586
 587
 588 //------------------------------------------------------------------------------
 589 void vvSlicer::SetTSlice(int t)
 590 {
 591   if (t < 0)
 592     t = 0;
 593   else if ((unsigned int)t >= mImage->GetVTKImages().size())
 594     t = mImage->GetVTKImages().size() -1;
 595
 596   if (mCurrentTSlice == t) return;
 597
 598   mCurrentTSlice = t;
 599   this->SetInput(mImage->GetVTKImages()[t]);
 600   if (mVF && mVFActor->GetVisibility()) {
 601     if (mVF->GetVTKImages().size() > (unsigned int)mCurrentTSlice)
 602       mVOIFilter->SetInput(mVF->GetVTKImages()[mCurrentTSlice]);
 603   }
 604   if (mOverlay && mOverlayActor->GetVisibility()) {
 605     if (mOverlay->GetVTKImages().size() > (unsigned int)mCurrentTSlice)
 606       mOverlayMapper->SetInput(mOverlay->GetVTKImages()[mCurrentTSlice]);
 607   }
 608   if (mFusion && mFusionActor->GetVisibility()) {
 609     if (mFusion->GetVTKImages().size() > (unsigned int)mCurrentTSlice)
 610       mFusionMapper->SetInput(mFusion->GetVTKImages()[mCurrentTSlice]);
 611   }
 612   if (mSurfaceCutActors.size() > 0)
 613     for (std::vector<vvMeshActor*>::iterator i=mSurfaceCutActors.begin();
 614          i!=mSurfaceCutActors.end(); i++)
 615       (*i)->SetTimeSlice(mCurrentTSlice);
 616   UpdateDisplayExtent();
 617 }
 618 //------------------------------------------------------------------------------
 619
 620
 621 //------------------------------------------------------------------------------
 622 int vvSlicer::GetTSlice()
 623 {
 624   return mCurrentTSlice;
 625 }
 626 //------------------------------------------------------------------------------
 627
 628
 629 //------------------------------------------------------------------------------
 630 void vvSlicer::SetSliceOrientation(int orientation)
 631 {
 632   //if 2D image, force to watch in Axial View
 633   int extent[6];
 634   this->GetInput()->GetWholeExtent(extent);
 635   if (extent[5]-extent[4] <= 2)
 636     orientation=2;
 637
 638   if (orientation < vtkImageViewer2::SLICE_ORIENTATION_YZ ||
 639       orientation > vtkImageViewer2::SLICE_ORIENTATION_XY) {
 640     vtkErrorMacro("Error - invalid slice orientation " << orientation);
 641     return;
 642   }
 643
 644   this->SliceOrientation = orientation;
 645
 646   // Update the viewer
 647   int *range = this->GetSliceRange();
 648   if (range)
 649     this->Slice = static_cast<int>((range[0] + range[1]) * 0.5);
 650
 651   this->UpdateOrientation();
 652   this->UpdateDisplayExtent();
 653
 654   if (this->Renderer && this->GetInput()) {
 655     double scale = this->Renderer->GetActiveCamera()->GetParallelScale();
 656     this->Renderer->ResetCamera();
 657     this->Renderer->GetActiveCamera()->SetParallelScale(scale);
 658   }
 659
 660   SetContourSlice();
 661 }
 662 //----------------------------------------------------------------------------
 663
 664
 665 //----------------------------------------------------------------------------
 666 int * vvSlicer::GetExtent()
 667 {
 668   int *w_ext;
 669   if (mUseReducedExtent) {
 670     w_ext = mReducedExtent;
 671   } else w_ext = GetInput()->GetWholeExtent();
 672   return w_ext;
 673 }
 674 //----------------------------------------------------------------------------
 675
 676
 677 //----------------------------------------------------------------------------
 678 int vvSlicer::GetOrientation()
 679 {
 680   return this->SliceOrientation;
 681 }
 682 //----------------------------------------------------------------------------
 683
 684
 685 //----------------------------------------------------------------------------
 686 void vvSlicer::UpdateDisplayExtent()
 687 {
 688   vtkImageData *input = this->GetInput();
 689   if (!input || !this->ImageActor) {
 690     return;
 691   }
 692   input->UpdateInformation();
 693   int *w_ext;// = input->GetWholeExtent();
 694
 695   if (mUseReducedExtent) {
 696     w_ext = mReducedExtent;
 697   } else w_ext = input->GetWholeExtent();
 698
 699   switch (this->SliceOrientation) {
 700   case vtkImageViewer2::SLICE_ORIENTATION_XY:
 701     this->ImageActor->SetDisplayExtent(
 702       w_ext[0], w_ext[1], w_ext[2], w_ext[3], this->Slice, this->Slice);
 703     if (mVF && mVFActor->GetVisibility()) {
 704       int vfExtent[6];
 705       ComputeVFDisplayedExtent(w_ext[0], w_ext[1], w_ext[2], w_ext[3], this->Slice, this->Slice,vfExtent);
 706       mVOIFilter->SetVOI(vfExtent);
 707       mGlyphFilter->SetOrientation(1,1,0);
 708       mVFMapper->Update();
 709       // put the vector field between the image and the camera
 710       if (Renderer->GetActiveCamera()->GetPosition()[2] > this->Slice)
 711         mVFActor->SetPosition(0,0,ImageActor->GetBounds()[5]+2);
 712       else
 713         mVFActor->SetPosition(0,0,ImageActor->GetBounds()[4]-2);
 714     }
 715     if (mOverlay && mOverlayActor->GetVisibility()) {
 716       int overExtent[6];
 717       ComputeOverlayDisplayedExtent(w_ext[0], w_ext[1], w_ext[2], w_ext[3], this->Slice, this->Slice,overExtent);
 718       mOverlayActor->SetDisplayExtent(overExtent);
 719       if (Renderer->GetActiveCamera()->GetPosition()[2] > this->Slice)
 720         mOverlayActor->SetPosition(0,0,1);
 721       else
 722         mOverlayActor->SetPosition(0,0,-1);
 723     }
 724     if (mFusion && mFusionActor->GetVisibility()) {
 725       int fusExtent[6];
 726       ComputeFusionDisplayedExtent(w_ext[0], w_ext[1], w_ext[2], w_ext[3], this->Slice, this->Slice,fusExtent);
 727       mFusionActor->SetDisplayExtent(fusExtent);
 728       if (Renderer->GetActiveCamera()->GetPosition()[2] > this->Slice)
 729         mFusionActor->SetPosition(0,0,1.5);
 730       else
 731         mFusionActor->SetPosition(0,0,-1.5);
 732     }
 733     if (mLandActor) {
 734       if (mClipBox) {
 735         double bounds [6];
 736         bounds[0] = ImageActor->GetBounds()[0];
 737         bounds[1] = ImageActor->GetBounds()[1];
 738         bounds[2] = ImageActor->GetBounds()[2];
 739         bounds[3] = ImageActor->GetBounds()[3];
 740         bounds[4] = ImageActor->GetBounds()[4]-fabs(0.5/this->GetInput()->GetSpacing()[2]);
 741         bounds[5] = ImageActor->GetBounds()[5]+fabs(0.5/this->GetInput()->GetSpacing()[2]);
 742         mClipBox->SetBounds(bounds);
 743         UpdateLandmarks();
 744       }
 745       if (Renderer->GetActiveCamera()->GetPosition()[2] > this->Slice)
 746         mLandActor->SetPosition(0,0,1.5);
 747       else
 748         mLandActor->SetPosition(0,0,-1.5);
 749     }
 750     break;
 751
 752   case vtkImageViewer2::SLICE_ORIENTATION_XZ:
 753     this->ImageActor->SetDisplayExtent(
 754       w_ext[0], w_ext[1], this->Slice, this->Slice, w_ext[4], w_ext[5]);
 755     if (mVF && mVFActor->GetVisibility()) {
 756       int vfExtent[6];
 757       ComputeVFDisplayedExtent(w_ext[0], w_ext[1], this->Slice, this->Slice, w_ext[4], w_ext[5],vfExtent);
 758       mVOIFilter->SetVOI(vfExtent);
 759       mGlyphFilter->SetOrientation(1,0,1);
 760       mVFMapper->Update();
 761       // put the vector field between the image aSpacingnd the camera
 762       if (Renderer->GetActiveCamera()->GetPosition()[1] > this->Slice)
 763         mVFActor->SetPosition(0,ImageActor->GetBounds()[3]+2,0);
 764       else
 765         mVFActor->SetPosition(0,ImageActor->GetBounds()[2]-2,0);
 766     }
 767     if (mOverlay && mOverlayActor->GetVisibility()) {
 768       int overExtent[6];
 769       ComputeOverlayDisplayedExtent(w_ext[0], w_ext[1], this->Slice, this->Slice, w_ext[4], w_ext[5],overExtent);
 770       mOverlayActor->SetDisplayExtent(overExtent);
 771       if (Renderer->GetActiveCamera()->GetPosition()[1] > this->Slice)
 772         mOverlayActor->SetPosition(0,1,0);
 773       else
 774         mOverlayActor->SetPosition(0,-1,0);
 775     }
 776     if (mFusion && mFusionActor->GetVisibility()) {
 777       int fusExtent[6];
 778       ComputeFusionDisplayedExtent(w_ext[0], w_ext[1], this->Slice, this->Slice, w_ext[4], w_ext[5],fusExtent);
 779       mFusionActor->SetDisplayExtent(fusExtent);
 780       if (Renderer->GetActiveCamera()->GetPosition()[1] > this->Slice)
 781         mFusionActor->SetPosition(0,1.5,0);
 782       else
 783         mFusionActor->SetPosition(0,-1.5,0);
 784     }
 785     if (mLandActor) {
 786       if (mClipBox) {
 787         double bounds [6];
 788         bounds[0] = ImageActor->GetBounds()[0];
 789         bounds[1] = ImageActor->GetBounds()[1];
 790         bounds[2] = ImageActor->GetBounds()[2]-fabs(0.5/this->GetInput()->GetSpacing()[1]);
 791         bounds[3] = ImageActor->GetBounds()[3]+fabs(0.5/this->GetInput()->GetSpacing()[1]);
 792         bounds[4] = ImageActor->GetBounds()[4];
 793         bounds[5] = ImageActor->GetBounds()[5];
 794         mClipBox->SetBounds(bounds);
 795         UpdateLandmarks();
 796       }
 797       if (Renderer->GetActiveCamera()->GetPosition()[1] > this->Slice)
 798         mLandActor->SetPosition(0,1.5,0);
 799       else
 800         mLandActor->SetPosition(0,-1.5,0);
 801     }
 802     break;
 803
 804   case vtkImageViewer2::SLICE_ORIENTATION_YZ:
 805     this->ImageActor->SetDisplayExtent(
 806       this->Slice, this->Slice, w_ext[2], w_ext[3], w_ext[4], w_ext[5]);
 807     if (mVF && mVFActor->GetVisibility()) {
 808       int vfExtent[6];
 809       ComputeVFDisplayedExtent(this->Slice, this->Slice, w_ext[2], w_ext[3], w_ext[4], w_ext[5],vfExtent);
 810       mVOIFilter->SetVOI(vfExtent);
 811       mGlyphFilter->SetOrientation(0,1,1);
 812       mVFMapper->Update();
 813       // put the vector field between the image and the camera
 814       if (Renderer->GetActiveCamera()->GetPosition()[0] > this->Slice)
 815         mVFActor->SetPosition(ImageActor->GetBounds()[1]+2,0,0);
 816       else
 817         mVFActor->SetPosition(ImageActor->GetBounds()[0]-2,0,0);
 818     }
 819     if (mOverlay && mOverlayActor->GetVisibility()) {
 820       int overExtent[6];
 821       ComputeOverlayDisplayedExtent(this->Slice, this->Slice, w_ext[2], w_ext[3], w_ext[4], w_ext[5],overExtent);
 822       mOverlayActor->SetDisplayExtent(overExtent);
 823       if (Renderer->GetActiveCamera()->GetPosition()[0] > this->Slice)
 824         mOverlayActor->SetPosition(1,0,0);
 825       else
 826         mOverlayActor->SetPosition(-1,0,0);
 827     }
 828     if (mFusion && mFusionActor->GetVisibility()) {
 829       int fusExtent[6];
 830       ComputeFusionDisplayedExtent(this->Slice, this->Slice, w_ext[2], w_ext[3], w_ext[4], w_ext[5],fusExtent);
 831       mFusionActor->SetDisplayExtent(fusExtent);
 832       if (Renderer->GetActiveCamera()->GetPosition()[0] > this->Slice)
 833         mFusionActor->SetPosition(1.5,0,0);
 834       else
 835         mFusionActor->SetPosition(-1.5,0,0);
 836     }
 837     if (mLandActor) {
 838       if (mClipBox) {
 839         double bounds [6];
 840         bounds[0] = ImageActor->GetBounds()[0]-fabs(0.5/this->GetInput()->GetSpacing()[0]);
 841         bounds[1] = ImageActor->GetBounds()[1]+fabs(0.5/this->GetInput()->GetSpacing()[0]);
 842         bounds[2] = ImageActor->GetBounds()[2];
 843         bounds[3] = ImageActor->GetBounds()[3];
 844         bounds[4] = ImageActor->GetBounds()[4];
 845         bounds[5] = ImageActor->GetBounds()[5];
 846         mClipBox->SetBounds(bounds);
 847         UpdateLandmarks();
 848       }
 849       if (Renderer->GetActiveCamera()->GetPosition()[0] > this->Slice)
 850         mLandActor->SetPosition(1.5,0,0);
 851       else
 852         mLandActor->SetPosition(-1.5,0,0);
 853     }
 854     break;
 855   }
 856
 857   // Figure out the correct clipping range
 858
 859   if (this->Renderer) {
 860     if (this->InteractorStyle &&
 861         this->InteractorStyle->GetAutoAdjustCameraClippingRange()) {
 862       this->Renderer->ResetCameraClippingRange();
 863     } else {
 864       vtkCamera *cam = this->Renderer->GetActiveCamera();
 865       if (cam) {
 866         double bounds[6];
 867         this->ImageActor->GetBounds(bounds);
 868         double spos = (double)bounds[this->SliceOrientation * 2];
 869         double cpos = (double)cam->GetPosition()[this->SliceOrientation];
 870         double range = fabs(spos - cpos);
 871         double *spacing = input->GetSpacing();
 872         double avg_spacing =
 873           ((double)spacing[0] + (double)spacing[1] + (double)spacing[2]) / 3.0;
 874         cam->SetClippingRange(
 875           range - avg_spacing * 3.0, range + avg_spacing * 3.0);
 876       }
 877     }
 878   }
 879 }
 880 //----------------------------------------------------------------------------
 881
 882
 883 //----------------------------------------------------------------------------
 884 void vvSlicer::ComputeVFDisplayedExtent(int x1,int x2,int y1,int y2,int z1,int z2,int vfExtent[6])
 885 {
 886   vtkImageData* image=this->GetInput();
 887   vfExtent[0] = (( image->GetOrigin()[0] + x1*image->GetSpacing()[0] ) - mVF->GetOrigin()[0]) /
 888                 mVF->GetSpacing()[0];
 889   vfExtent[1] = (( image->GetOrigin()[0] + x2*image->GetSpacing()[0] ) - mVF->GetOrigin()[0]) /
 890                 mVF->GetSpacing()[0];
 891   vfExtent[2] = (( image->GetOrigin()[1] + y1*image->GetSpacing()[1] ) - mVF->GetOrigin()[1]) /
 892                 mVF->GetSpacing()[1];
 893   vfExtent[3] = (( image->GetOrigin()[1] + y2*image->GetSpacing()[1] ) - mVF->GetOrigin()[1]) /
 894                 mVF->GetSpacing()[1];
 895   vfExtent[4] = (( image->GetOrigin()[2] + z1*image->GetSpacing()[2] ) - mVF->GetOrigin()[2]) /
 896                 mVF->GetSpacing()[2];
 897   vfExtent[5] = (( image->GetOrigin()[2] + z2*image->GetSpacing()[2] ) - mVF->GetOrigin()[2]) /
 898                 mVF->GetSpacing()[2];
 899
 900   ClipDisplayedExtent(vfExtent,mVOIFilter->GetInput()->GetWholeExtent());
 901 }
 902 //----------------------------------------------------------------------------
 903
 904
 905 //----------------------------------------------------------------------------
 906 void vvSlicer::ComputeOverlayDisplayedExtent(int x1,int x2,int y1,int y2,int z1,int z2,int overExtent[6])
 907 {
 908   vtkImageData* image=this->GetInput();
 909   overExtent[0] = (( image->GetOrigin()[0] + x1*image->GetSpacing()[0] ) - mOverlay->GetOrigin()[0]) /
 910                   mOverlay->GetSpacing()[0];
 911   overExtent[1] = (( image->GetOrigin()[0] + x2*image->GetSpacing()[0] ) - mOverlay->GetOrigin()[0]) /
 912                   mOverlay->GetSpacing()[0];
 913   overExtent[2] = (( image->GetOrigin()[1] + y1*image->GetSpacing()[1] ) - mOverlay->GetOrigin()[1]) /
 914                   mOverlay->GetSpacing()[1];
 915   overExtent[3] = (( image->GetOrigin()[1] + y2*image->GetSpacing()[1] ) - mOverlay->GetOrigin()[1]) /
 916                   mOverlay->GetSpacing()[1];
 917   overExtent[4] = (( image->GetOrigin()[2] + z1*image->GetSpacing()[2] ) - mOverlay->GetOrigin()[2]) /
 918                   mOverlay->GetSpacing()[2];
 919   overExtent[5] = (( image->GetOrigin()[2] + z2*image->GetSpacing()[2] ) - mOverlay->GetOrigin()[2]) /
 920                   mOverlay->GetSpacing()[2];
 921   ClipDisplayedExtent(overExtent, mOverlayMapper->GetInput()->GetWholeExtent());
 922 }
 923 //----------------------------------------------------------------------------
 924
 925
 926 //----------------------------------------------------------------------------
 927 void vvSlicer::ComputeFusionDisplayedExtent(int x1,int x2,int y1,int y2,int z1,int z2,int fusExtent[6])
 928 {
 929   vtkImageData* image=this->GetInput();
 930   fusExtent[0] = (( image->GetOrigin()[0] + x1*image->GetSpacing()[0] ) - mFusion->GetOrigin()[0]) /
 931                  mFusion->GetSpacing()[0];
 932   fusExtent[1] = (( image->GetOrigin()[0] + x2*image->GetSpacing()[0] ) - mFusion->GetOrigin()[0]) /
 933                  mFusion->GetSpacing()[0];
 934   fusExtent[2] = (( image->GetOrigin()[1] + y1*image->GetSpacing()[1] ) - mFusion->GetOrigin()[1]) /
 935                  mFusion->GetSpacing()[1];
 936   fusExtent[3] = (( image->GetOrigin()[1] + y2*image->GetSpacing()[1] ) - mFusion->GetOrigin()[1]) /
 937                  mFusion->GetSpacing()[1];
 938   fusExtent[4] = (( image->GetOrigin()[2] + z1*image->GetSpacing()[2] ) - mFusion->GetOrigin()[2]) /
 939                  mFusion->GetSpacing()[2];
 940   fusExtent[5] = (( image->GetOrigin()[2] + z2*image->GetSpacing()[2] ) - mFusion->GetOrigin()[2]) /
 941                  mFusion->GetSpacing()[2];
 942   ClipDisplayedExtent(fusExtent, mFusionMapper->GetInput()->GetWholeExtent());
 943 }
 944 //----------------------------------------------------------------------------
 945
 946
 947 //----------------------------------------------------------------------------
 948 void vvSlicer::ClipDisplayedExtent(int extent[6], int refExtent[6])
 949 {
 950   bool out = false;
 951   int maxBound = 6;
 952
 953   //2D overlay on 3D image specific case
 954   if (refExtent[4] == refExtent[5]) {
 955     maxBound = 4;
 956     extent[4] = refExtent[4];
 957     extent[5] = refExtent[5];
 958   }
 959
 960   for (int i = 0; i < maxBound; i = i+2) {
 961     //if we are totally outside the image
 962     if ( extent[i] > refExtent[i+1] || extent[i+1] < refExtent[i] ) {
 963       out = true;
 964       break;
 965     }
 966     //crop to the limit of the image
 967     extent[i] = (extent[i] > refExtent[i]) ? extent[i] : refExtent[i];
 968     extent[i] = (extent[i] < refExtent[i+1]) ? extent[i] : refExtent[i+1];
 969     extent[i+1] = (extent[i+1] > refExtent[i]) ? extent[i+1] : refExtent[i];
 970     extent[i+1] = (extent[i+1] < refExtent[i+1]) ? extent[i+1] : refExtent[i+1];
 971   }
 972   if (out)
 973     for (int i = 0; i < maxBound; i = i+2) {
 974       extent[i] = refExtent[i];
 975       extent[i+1] = refExtent[i];
 976     }
 977 }
 978 //----------------------------------------------------------------------------
 979
 980
 981 //----------------------------------------------------------------------------
 982 void vvSlicer::UpdateOrientation()
 983 {
 984   // Set the camera position
 985   vtkCamera *cam = this->Renderer ? this->Renderer->GetActiveCamera() : NULL;
 986   if (cam) {
 987     switch (this->SliceOrientation) {
 988     case vtkImageViewer2::SLICE_ORIENTATION_XY:
 989       cam->SetFocalPoint(0,0,0);
 990       cam->SetPosition(0,0,-1); // -1 if medical ?
 991       cam->SetViewUp(0,-1,0);
 992       break;
 993
 994     case vtkImageViewer2::SLICE_ORIENTATION_XZ:
 995       cam->SetFocalPoint(0,0,0);
 996       cam->SetPosition(0,-1,0); // 1 if medical ?
 997       cam->SetViewUp(0,0,1);
 998       break;
 999
1000     case vtkImageViewer2::SLICE_ORIENTATION_YZ:
1001       cam->SetFocalPoint(0,0,0);
1002       cam->SetPosition(-1,0,0); // -1 if medical ?
1003       cam->SetViewUp(0,0,1);
1004       break;
1005     }
1006   }
1007 }
1008 //----------------------------------------------------------------------------
1009
1010
1011 //----------------------------------------------------------------------------
1012 void vvSlicer::SetOpacity(double s)
1013 {
1014   this->GetImageActor()->SetOpacity(s);
1015 }
1016 //----------------------------------------------------------------------------
1017
1018
1019 //----------------------------------------------------------------------------
1020 void vvSlicer::SetRenderWindow(int orientation, vtkRenderWindow * rw)
1021 {
1022   this->Superclass::SetRenderWindow(rw);
1023   this->SetupInteractor(rw->GetInteractor());
1024   ca->SetImageActor(this->GetImageActor());
1025   ca->SetWindowLevel(this->GetWindowLevel());
1026   ca->SetText(2, "<slice>");
1027   ca->SetText(3, "<window>\n<level>");
1028
1029   double bounds[6];
1030   double max = 65000;
1031
1032   bounds[0] = -max;
1033   bounds[1] = max;
1034   bounds[2] = -max;
1035   bounds[3] = max;
1036   bounds[4] = -max;
1037   bounds[5] = max;
1038
1039   crossCursor->SetModelBounds(bounds);
1040   this->GetRenderer()->AddActor(pdmA);
1041   this->GetRenderer()->AddActor(ca);
1042   this->GetRenderer()->ResetCamera();
1043
1044   //this is just a mapping between the labeling of the orientations presented to the user and
1045   //the one used by vtk
1046   SetSliceOrientation(2-(orientation%3));
1047   ResetCamera();
1048 }
1049 //----------------------------------------------------------------------------
1050
1051
1052 //----------------------------------------------------------------------------
1053 void vvSlicer::ResetCamera()
1054 {
1055   if (this->GetInput()) {
1056     double* input_bounds=this->GetInput()->GetBounds();
1057     double bmax=input_bounds[1]-input_bounds[0];
1058     if (bmax < input_bounds[3]-input_bounds[2]) bmax=input_bounds[3]-input_bounds[2];
1059     if (bmax < input_bounds[5]-input_bounds[4]) bmax=input_bounds[5]-input_bounds[4];
1060     this->GetRenderer()->ResetCamera();
1061     this->GetRenderer()->GetActiveCamera()->SetParallelScale(bmax/2);
1062   }
1063 }
1064 //----------------------------------------------------------------------------
1065
1066
1067 //----------------------------------------------------------------------------
1068 void vvSlicer::SetDisplayMode(bool i)
1069 {
1070   this->GetImageActor()->SetVisibility(i);
1071   this->GetAnnotation()->SetVisibility(i);
1072   this->GetRenderer()->SetDraw(i);
1073   if (mLandActor)
1074     mLandActor->SetVisibility(i);
1075   pdmA->SetVisibility(i);
1076   if (i)
1077     UpdateDisplayExtent();
1078 }
1079 //----------------------------------------------------------------------------
1080
1081
1082 //----------------------------------------------------------------------------
1083 void vvSlicer::FlipHorizontalView()
1084 {
1085   vtkCamera *cam = this->Renderer ? this->Renderer->GetActiveCamera() : NULL;
1086   if (cam) {
1087     double *position = cam->GetPosition();
1088     switch (this->SliceOrientation) {
1089     case vtkImageViewer2::SLICE_ORIENTATION_XY:
1090       cam->SetPosition(position[0],position[1],-position[2]);
1091       break;
1092
1093     case vtkImageViewer2::SLICE_ORIENTATION_XZ:
1094       cam->SetPosition(position[0],-position[1],position[2]);
1095       break;
1096
1097     case vtkImageViewer2::SLICE_ORIENTATION_YZ:
1098       cam->SetPosition(-position[0],position[1],position[2]);
1099       break;
1100     }
1101     this->Renderer->ResetCameraClippingRange();
1102     this->UpdateDisplayExtent();
1103   }
1104 }
1105 //----------------------------------------------------------------------------
1106
1107
1108 //----------------------------------------------------------------------------
1109 void vvSlicer::FlipVerticalView()
1110 {
1111   vtkCamera *cam = this->Renderer ? this->Renderer->GetActiveCamera() : NULL;
1112   if (cam) {
1113     FlipHorizontalView();
1114     double *viewup = cam->GetViewUp();
1115     cam->SetViewUp(-viewup[0],-viewup[1],-viewup[2]);
1116     this->UpdateDisplayExtent();
1117   }
1118 }
1119 //----------------------------------------------------------------------------
1120
1121
1122 //----------------------------------------------------------------------------
1123 void vvSlicer::SetColorWindow(double window)
1124 {
1125   vtkLookupTable* LUT = static_cast<vtkLookupTable*>(this->GetWindowLevel()->GetLookupTable());
1126   if ( LUT ) {
1127     double level = this->GetWindowLevel()->GetLevel();
1128     LUT->SetTableRange(level-fabs(window)/4,level+fabs(window)/4);
1129     LUT->Build();
1130   }
1131   this->vtkImageViewer2::SetColorWindow(window);
1132 }
1133 //----------------------------------------------------------------------------
1134
1135
1136 //----------------------------------------------------------------------------
1137 void vvSlicer::SetColorLevel(double level)
1138 {
1139   vtkLookupTable* LUT = static_cast<vtkLookupTable*>(this->GetWindowLevel()->GetLookupTable());
1140   if ( LUT ) {
1141     double window = this->GetWindowLevel()->GetWindow();
1142     LUT->SetTableRange(level-fabs(window)/4,level+fabs(window)/4);
1143     LUT->Build();
1144   }
1145   this->vtkImageViewer2::SetColorLevel(level);
1146 }
1147 //----------------------------------------------------------------------------
1148
1149 //----------------------------------------------------------------------------
1150 // Returns the min an the max value in a 41x41 region around the mouse pointer
1151 void vvSlicer::GetExtremasAroundMousePointer(double & min, double & max)
1152 {
1153   //Get mouse pointer position in view coordinates
1154   double fLocalExtents[6];
1155   for(int i=0; i<3; i++) {
1156     fLocalExtents[i*2  ] = mCurrent[i];
1157     fLocalExtents[i*2+1] = mCurrent[i];
1158   }
1159   this->Renderer->WorldToView(fLocalExtents[0], fLocalExtents[2], fLocalExtents[4]);
1160   this->Renderer->WorldToView(fLocalExtents[1], fLocalExtents[3], fLocalExtents[5]);
1161   for(int i=0; i<3; i++) {
1162     if (i!=SliceOrientation) { //SR: assumes that SliceOrientation is valid in ViewCoordinates (???)
1163       fLocalExtents[i*2  ] -= 0.2;
1164       fLocalExtents[i*2+1] += 0.2;
1165     }
1166   }
1167   this->Renderer->ViewToWorld(fLocalExtents[0], fLocalExtents[2], fLocalExtents[4]);
1168   this->Renderer->ViewToWorld(fLocalExtents[1], fLocalExtents[3], fLocalExtents[5]);
1169
1170   //Convert to image pixel coordinates (rounded)
1171   int iLocalExtents[6];
1172   for(int i=0; i<3; i++) {
1173     fLocalExtents[i*2  ] = (fLocalExtents[i*2  ] - this->GetInput()->GetOrigin()[i])/this->GetInput()->GetSpacing()[i];
1174     fLocalExtents[i*2+1] = (fLocalExtents[i*2+1] - this->GetInput()->GetOrigin()[i])/this->GetInput()->GetSpacing()[i];
1175
1176     iLocalExtents[i*2  ] = lrint(fLocalExtents[i*2  ]);
1177     iLocalExtents[i*2+1] = lrint(fLocalExtents[i*2+1]);
1178
1179     if(iLocalExtents[i*2  ]>iLocalExtents[i*2+1])
1180       std::swap(iLocalExtents[i*2], iLocalExtents[i*2+1]);
1181   }
1182
1183   vtkSmartPointer<vtkExtractVOI> voiFilter = vtkSmartPointer<vtkExtractVOI>::New();
1184   voiFilter->SetInput(this->GetInput());
1185   voiFilter->SetVOI(iLocalExtents);
1186   voiFilter->Update();
1187   if (!voiFilter->GetOutput()->GetNumberOfPoints()) {
1188     min = 0;
1189     max = 0;
1190     return;
1191   }
1192
1193   vtkSmartPointer<vtkImageAccumulate> accFilter = vtkSmartPointer<vtkImageAccumulate>::New();
1194   accFilter->SetInput(voiFilter->GetOutput());
1195   accFilter->Update();
1196
1197   min = *(accFilter->GetMin());
1198   max = *(accFilter->GetMax());
1199 }
1200 //----------------------------------------------------------------------------
1201
1202 //----------------------------------------------------------------------------
1203 void vvSlicer::Render()
1204 {
1205   //  DD("vvSlicer::Render");
1206   // DD(SliceOrientation);
1207   if (this->GetWindowLevel()->GetLookupTable() && !this->mOverlay && !this->mFusion) {
1208     legend->SetLookupTable(this->GetWindowLevel()->GetLookupTable());
1209     legend->SetVisibility(1);
1210   } else legend->SetVisibility(0);
1211
1212   if (ca->GetVisibility()) {
1213     std::string worldPos = "";
1214     std::stringstream world1;
1215     std::stringstream world2;
1216     std::stringstream world3;
1217     world1 << (int)mCurrent[0];
1218     world2 << (int)mCurrent[1];
1219     world3 << (int)mCurrent[2];
1220     double X = (mCurrent[0] - this->GetInput()->GetOrigin()[0])/this->GetInput()->GetSpacing()[0];
1221     double Y = (mCurrent[1] - this->GetInput()->GetOrigin()[1])/this->GetInput()->GetSpacing()[1];
1222     double Z = (mCurrent[2] - this->GetInput()->GetOrigin()[2])/this->GetInput()->GetSpacing()[2];
1223
1224     if (pdmA->GetVisibility()) {
1225       double x = mCursor[0];
1226       double y = mCursor[1];
1227       double z = mCursor[2];
1228       double xCursor = (x - this->GetInput()->GetOrigin()[0])/this->GetInput()->GetSpacing()[0];
1229       double yCursor = (y - this->GetInput()->GetOrigin()[1])/this->GetInput()->GetSpacing()[1];
1230       double zCursor = (z - this->GetInput()->GetOrigin()[2])/this->GetInput()->GetSpacing()[2];
1231
1232       if (xCursor >= this->GetImageActor()->GetDisplayExtent()[0] &&
1233           xCursor < this->GetImageActor()->GetDisplayExtent()[1]+1 &&
1234           yCursor >= this->GetImageActor()->GetDisplayExtent()[2] &&
1235           yCursor < this->GetImageActor()->GetDisplayExtent()[3]+1 &&
1236           zCursor >= this->GetImageActor()->GetDisplayExtent()[4] &&
1237           zCursor < this->GetImageActor()->GetDisplayExtent()[5]+1 ) {
1238         vtkRenderer * renderer = this->Renderer;
1239
1240         renderer->WorldToView(x,y,z);
1241         renderer->ViewToNormalizedViewport(x,y,z);
1242         renderer->NormalizedViewportToViewport(x,y);
1243         renderer->ViewportToNormalizedDisplay(x,y);
1244         renderer->NormalizedDisplayToDisplay(x,y);
1245         crossCursor->SetFocalPoint(x,y,z);
1246       } else
1247         crossCursor->SetFocalPoint(-1,-1,z);
1248     }
1249
1250     if (X >= this->GetInput()->GetWholeExtent()[0] &&
1251         X <= this->GetInput()->GetWholeExtent()[1] &&
1252         Y >= this->GetInput()->GetWholeExtent()[2] &&
1253         Y <= this->GetInput()->GetWholeExtent()[3] &&
1254         Z >= this->GetInput()->GetWholeExtent()[4] &&
1255         Z <= this->GetInput()->GetWholeExtent()[5]) {
1256       std::stringstream pixel1;
1257       std::stringstream pixel2;
1258       std::stringstream pixel3;
1259       std::stringstream temps;
1260       pixel1 << (int)X;
1261       pixel2 << (int)Y;
1262       pixel3 << (int)Z;
1263       temps << mCurrentTSlice;
1264       double value = this->GetInput()->GetScalarComponentAsDouble(lrint(X),
1265                      lrint(Y),
1266                      lrint(Z),0);
1267
1268       std::stringstream val;
1269       val << value;
1270       worldPos += "data value : " + val.str();
1271       worldPos += "\n mm : " + world1.str() + " " + world2.str() + " " +
1272                   world3.str() + " " + temps.str();
1273       worldPos += "\n pixel : " + pixel1.str() + " " + pixel2.str() + " " +
1274                   pixel3.str() + " " + temps.str();
1275     }
1276     ca->SetText(1,worldPos.c_str());
1277   }
1278   if (mOverlay && mOverlayActor->GetVisibility()) {
1279     mOverlayMapper->SetWindow(this->GetColorWindow());
1280     mOverlayMapper->SetLevel(this->GetColorLevel());
1281     mOverlayMapper->Update();
1282   }
1283   if (mLandMapper)
1284     UpdateLandmarks();
1285   //this->Superclass::Render();
1286   this->GetRenderWindow()->Render();
1287 }
1288 //----------------------------------------------------------------------------
1289
1290
1291 //----------------------------------------------------------------------------
1292 void vvSlicer::UpdateCursorPosition()
1293 {
1294   if (this->GetImageActor()->GetVisibility()) {
1295     pdmA->SetVisibility(true);
1296     mCursor[0] = mCurrent[0];
1297     mCursor[1] = mCurrent[1];
1298     mCursor[2] = mCurrent[2];
1299     mCursor[3] = mCurrentTSlice;
1300   }
1301 }
1302 //----------------------------------------------------------------------------
1303
1304
1305 //----------------------------------------------------------------------------
1306 void vvSlicer::UpdateLandmarks()
1307 {
1308   vtkPolyData *pd = static_cast<vtkPolyData*>(mLandClipper->GetInput());
1309   if (pd->GetPoints()) {
1310     mLandGlyph->SetRange(0,1);
1311     mLandGlyph->Modified();
1312     mLandGlyph->Update();
1313
1314     mClipBox->Modified();
1315     mLandClipper->Update();
1316     mLandMapper->Update();
1317   }
1318
1319 }
1320 //----------------------------------------------------------------------------
1321
1322
1323 //----------------------------------------------------------------------------
1324 void vvSlicer::SetSlice(int slice)
1325 {
1326   int *range = this->GetSliceRange();
1327   if (range) {
1328     if (slice < range[0]) {
1329       slice = range[0];
1330     } else if (slice > range[1]) {
1331       slice = range[1];
1332     }
1333   }
1334
1335   if (this->Slice == slice) {
1336     return;
1337   }
1338
1339   this->Slice = slice;
1340   SetContourSlice();
1341   this->Modified();
1342   this->UpdateDisplayExtent();
1343
1344   //  DD("SetSlice de slicer = Render");
1345
1346   // Seems to work without this line
1347   //  this->Render();
1348 }
1349 //----------------------------------------------------------------------------
1350
1351
1352 //----------------------------------------------------------------------------
1353 void vvSlicer::SetContourSlice()
1354 {
1355   if (mSurfaceCutActors.size() > 0)
1356     for (std::vector<vvMeshActor*>::iterator i=mSurfaceCutActors.begin();
1357          i!=mSurfaceCutActors.end(); i++)
1358       (*i)->SetCutSlice((this->Slice)*this->GetImage()->GetSpacing()[this->SliceOrientation]+
1359                         this->GetImage()->GetOrigin()[this->SliceOrientation]);
1360 }
1361 //----------------------------------------------------------------------------
1362
1363
1364 //----------------------------------------------------------------------------
1365 void vvSlicer::ForceUpdateDisplayExtent()
1366 {
1367   this->UpdateDisplayExtent();
1368 }
1369 //----------------------------------------------------------------------------
1370
1371
1372 //----------------------------------------------------------------------------
1373 int* vvSlicer::GetDisplayExtent()
1374 {
1375   return this->GetImageActor()->GetDisplayExtent();
1376 }
1377 //----------------------------------------------------------------------------
1378
1379
1380 //----------------------------------------------------------------------------
1381 void vvSlicer::PrintSelf(ostream& os, vtkIndent indent)
1382 {
1383   this->Superclass::PrintSelf(os, indent);
1384 }
1385 //----------------------------------------------------------------------------
1386
1387
1388
1389
1390
1391
1392