]> Creatis software - clitk.git/blob - vv/vvSlicer.cxx
Add clitkImage2DicomSeries tool to write a Dicom Series from an image without a corre...
[clitk.git] / 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://www.centreleonberard.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 <QMessageBox>
20 #include <QString>
21
22 #include "vvSlicer.h"
23 #include "vvImage.h"
24 #include "vvSlicerManagerCommand.h"
25 #include "vvGlyphSource.h"
26 #include "vvGlyph2D.h"
27
28 #include <vtkVersion.h>
29 #include <vtkExtentTranslator.h>
30 #include <vtkAlgorithm.h>
31 #include <vtkExecutive.h>
32 #include <vtkStreamingDemandDrivenPipeline.h>
33 #include <vtkInformation.h>
34 #include <vtkTextProperty.h>
35 #include <vtkTextActor.h>
36 #include <vtkTextSource.h>
37 #include <vtkActor2D.h>
38 #include <vtkCursor2D.h>
39 #include <vtkPolyDataMapper2D.h>
40 #include <vtkProperty2D.h>
41 #include <vtkCornerAnnotation.h>
42 #include <vtkImageMapToWindowLevelColors.h>
43 #include <vtkImageData.h>
44 #include <vtkImageActor.h>
45 #include <vvBlendImageActor.h>
46 #include <vtkToolkits.h>
47 #include <vtkObjectFactory.h>
48 #include <vtkPointData.h>
49 #include <vtkDataArray.h>
50 #include <vtkFloatArray.h>
51 #include <vtkClipPolyData.h>
52 #include <vtkActor2DCollection.h>
53 #include <vtkGlyph3D.h>
54 #include <vtkMath.h>
55 #include <vtkCursor3D.h>
56 #include <vtkProperty.h>
57 #include <vtkLight.h>
58 #include <vtkLightCollection.h>
59 #include <vtkScalarBarActor.h>
60 #include <vtkLookupTable.h>
61
62 #include <vtkRenderer.h>
63 #include <vtkRendererCollection.h>
64 #include <vtkRenderWindow.h>
65 #include <vtkRenderWindowInteractor.h>
66 #include <vtkCamera.h>
67 #include <vtkCallbackCommand.h>
68 #include <vtkCommand.h>
69 #include <vtkPolyDataMapper.h>
70 #include <vtkBox.h>
71
72 #include <vtkExtractVOI.h>
73 #include <vtkSphereSource.h>
74 #include <vtkCutter.h>
75 #include <vtkAssignAttribute.h>
76 #include <vtkImageAccumulate.h>
77 #include <vtkImageReslice.h>
78 #if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10)
79 #  include <vtkOpenGLImageSliceMapper.h>
80 #  include <vtkImageMapper3D.h>
81 #  include <vtkImageSliceMapper.h>
82 #endif
83
84 vtkStandardNewMacro(vvSlicer);
85 static void copyExtent(int* in, int* to){
86  for(int i=0; i<6; ++i) 
87  {
88         to[i]=in[i];
89  } 
90 }
91 //------------------------------------------------------------------------------
92 vvSlicer::vvSlicer()
93
94         mFusionSequenceCode = -1;
95   this->UnInstallPipeline();
96   mImage = NULL;
97   mReducedExtent = new int[6];
98   mRegisterExtent = NULL;
99   mCurrentTSlice = 0;
100   mCurrentFusionTSlice = 0;
101   mCurrentOverlayTSlice = 0;
102   mUseReducedExtent = false;
103
104   mCurrent[0] = -VTK_DOUBLE_MAX;
105   mCurrent[1] = -VTK_DOUBLE_MAX;
106   mCurrent[2] = -VTK_DOUBLE_MAX;
107
108   mCursor[0] = 0;//-VTK_DOUBLE_MAX;
109   mCursor[1] = 0;//-VTK_DOUBLE_MAX;
110   mCursor[2] = 0;//-VTK_DOUBLE_MAX;
111   mCursor[3] = 0;//-VTK_DOUBLE_MAX;
112
113   mSubSampling = 5;
114   mScale = 1;
115   mVFLog = 0;
116   mVFWidth = 1;
117   mVFColor[0] = 0;
118   mVFColor[1] = 1;
119   mVFColor[2] = 0;
120
121   crossCursor = vtkSmartPointer<vtkCursor2D>::New();
122   crossCursor->AllOff();
123   crossCursor->AxesOn();
124   crossCursor->SetTranslationMode(1);
125   crossCursor->SetRadius(2);
126
127   pdm = vtkSmartPointer<vtkPolyDataMapper2D>::New();
128 #if VTK_MAJOR_VERSION <= 5
129   pdm->SetInput(crossCursor->GetOutput());
130 #else
131   pdm->SetInputConnection(crossCursor->GetOutputPort(0));
132 #endif
133
134   pdmA = vtkSmartPointer<vtkActor2D>::New();
135   pdmA->SetMapper(pdm);
136   pdmA->GetProperty()->SetColor(255,10,212);
137   pdmA->SetVisibility(0);
138   pdmA->SetPickable(0);
139
140   ca = vtkSmartPointer<vtkCornerAnnotation>::New();
141   ca->GetTextProperty()->SetColor(255,10,212);
142   ca->SetVisibility(1);
143   mFileName = "";
144
145   mVF = NULL;
146   mOverlay = NULL;
147   mFusion = NULL;
148   mLandmarks = NULL;
149
150   legend = vtkSmartPointer<vtkScalarBarActor>::New();
151   //legend->SetTitle("test!");
152   legend->SetPosition(0.82,0.18);
153   legend->SetWidth(0.1);
154   legend->SetVisibility(0);
155   legend->SetLabelFormat("%.1f");
156   this->GetRenderer()->AddActor(legend);
157   showFusionLegend = false;
158
159   this->InstallPipeline();
160
161   mLinkOverlayWindowLevel = true;
162   mImageVisibility = true;
163
164 #if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10)
165   this->GetImageActor()->GetMapper()->BorderOn();
166 #endif
167
168   mSlicingTransform = vtkSmartPointer<vtkTransform>::New();
169   mConcatenatedTransform = vtkSmartPointer<vtkTransform>::New();
170   mConcatenatedFusionTransform = vtkSmartPointer<vtkTransform>::New();
171   mConcatenatedOverlayTransform = vtkSmartPointer<vtkTransform>::New();
172   mFirstSetSliceOrientation = true;
173 }
174 //------------------------------------------------------------------------------
175
176
177 //------------------------------------------------------------------------------
178 vtkImageMapToWindowLevelColors* vvSlicer::GetOverlayMapper()
179
180   return mOverlayMapper.GetPointer();
181 }
182 //------------------------------------------------------------------------------
183
184
185 //------------------------------------------------------------------------------
186 vvBlendImageActor* vvSlicer::GetOverlayActor()
187
188   return mOverlayActor.GetPointer();
189 }
190 //------------------------------------------------------------------------------
191
192
193 //------------------------------------------------------------------------------
194 vtkImageMapToColors* vvSlicer::GetFusionMapper()
195
196   return mFusionMapper.GetPointer();
197 }
198 //------------------------------------------------------------------------------
199
200
201 //------------------------------------------------------------------------------
202 vtkImageActor* vvSlicer::GetFusionActor()
203
204   return mFusionActor.GetPointer();
205 }
206 //------------------------------------------------------------------------------
207
208
209 //------------------------------------------------------------------------------
210 vtkActor* vvSlicer::GetVFActor()
211
212   return mVFActor.GetPointer();
213 }
214 //------------------------------------------------------------------------------
215
216
217 //------------------------------------------------------------------------------
218 vtkCornerAnnotation* vvSlicer::GetAnnotation()
219
220   return ca.GetPointer();
221 }
222 //------------------------------------------------------------------------------
223
224
225 //------------------------------------------------------------------------------
226 void vvSlicer::EnableReducedExtent(bool b)
227
228   mUseReducedExtent = b;
229 }
230 //------------------------------------------------------------------------------
231
232
233 //------------------------------------------------------------------------------
234 void vvSlicer::SetReducedExtent(int * ext)
235
236   copyExtent(ext, mReducedExtent);
237 }
238 //------------------------------------------------------------------------------
239
240
241 //------------------------------------------------------------------------------
242 void vvSlicer::AddContour(vvMesh::Pointer contour,bool propagate)
243
244
245   mSurfaceCutActors.push_back(new vvMeshActor());
246   if (propagate)
247     mSurfaceCutActors.back()->Init(contour,mCurrentTSlice,mVF);
248   else
249     mSurfaceCutActors.back()->Init(contour,mCurrentTSlice);
250   mSurfaceCutActors.back()->SetSlicingOrientation(SliceOrientation);
251   this->GetRenderer()->AddActor(mSurfaceCutActors.back()->GetActor());
252
253   SetContourSlice();
254 }
255 //------------------------------------------------------------------------------
256
257
258 //------------------------------------------------------------------------------
259 void vvSlicer::ToggleContourSuperposition()
260
261   for (std::vector<vvMeshActor*>::iterator i=mSurfaceCutActors.begin();
262        i!=mSurfaceCutActors.end(); i++)
263     (*i)->ToggleSuperposition();
264 }
265 //------------------------------------------------------------------------------
266
267
268 //------------------------------------------------------------------------------
269 void vvSlicer::SetCursorColor(int r,int g, int b)
270
271   pdmA->GetProperty()->SetColor(r,g,b);
272 }
273 //------------------------------------------------------------------------------
274
275
276 //------------------------------------------------------------------------------
277 void vvSlicer::SetCursorVisibility(bool s)
278
279   pdmA->SetVisibility(s);
280 }
281 //------------------------------------------------------------------------------
282
283
284 //------------------------------------------------------------------------------
285 bool vvSlicer::GetCursorVisibility()
286
287   return pdmA->GetVisibility();
288 }
289 //------------------------------------------------------------------------------
290
291
292 //------------------------------------------------------------------------------
293 void vvSlicer::SetCornerAnnotationVisibility(bool s)
294
295   ca->SetVisibility(s);
296 }
297 //------------------------------------------------------------------------------
298
299
300 //------------------------------------------------------------------------------
301 bool vvSlicer::GetCornerAnnotationVisibility()
302
303   return ca->GetVisibility();
304 }
305 //------------------------------------------------------------------------------
306
307
308 //------------------------------------------------------------------------------
309 vvSlicer::~vvSlicer()
310
311   for (std::vector<vvMeshActor*>::iterator i=mSurfaceCutActors.begin();
312        i!=mSurfaceCutActors.end(); i++)
313     delete (*i);
314   delete [] mReducedExtent;
315 }
316 //------------------------------------------------------------------------------
317
318 //------------------------------------------------------------------------------
319 double* vvSlicer::GetCurrentPosition()
320
321   return mCurrentBeforeSlicingTransform;
322 }
323 //------------------------------------------------------------------------------
324
325 //------------------------------------------------------------------------------
326 void vvSlicer::SetCurrentPosition(double x, double y, double z, int t)
327
328   mCurrentBeforeSlicingTransform[0]=x;
329   mCurrentBeforeSlicingTransform[1]=y;
330   mCurrentBeforeSlicingTransform[2]=z;
331   mSlicingTransform->GetInverse()->TransformPoint(mCurrentBeforeSlicingTransform,mCurrent);
332   if (t>=0) SetTSlice(t);
333 }
334 //------------------------------------------------------------------------------
335
336
337 //------------------------------------------------------------------------------
338 void vvSlicer::SetImage(vvImage::Pointer image)
339
340   if (image->GetVTKImages().size()) {
341     mImage = image;
342
343     if (!mImageReslice) {
344       mImageReslice = vtkSmartPointer<vtkImageReslice>::New();
345       mImageReslice->SetInterpolationModeToLinear();
346       mImageReslice->AutoCropOutputOn();
347       mImageReslice->SetBackgroundColor(-1000,-1000,-1000,1);
348     }
349
350     mConcatenatedTransform->Identity();
351     mConcatenatedTransform->Concatenate(mImage->GetTransform()[0]);
352     mConcatenatedTransform->Concatenate(mSlicingTransform);
353     mImageReslice->SetResliceTransform(mConcatenatedTransform);
354 #if VTK_MAJOR_VERSION <= 5
355     mImageReslice->SetInput(0, mImage->GetFirstVTKImageData());
356 #else
357     mImageReslice->SetInputData(0, mImage->GetFirstVTKImageData());
358 #endif
359     mImageReslice->UpdateInformation();
360
361 #if VTK_MAJOR_VERSION <= 5
362     this->Superclass::SetInput(mImageReslice->GetOutput());
363 #else
364     this->Superclass::SetInputConnection(mImageReslice->GetOutputPort());
365 #endif
366
367     int extent[6];
368 #if VTK_MAJOR_VERSION <= 5
369     this->GetInput()->GetWholeExtent(extent);
370 #else
371     int* ext = mImageReslice->GetInputInformation()->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT());
372     copyExtent(ext, extent);
373 #endif
374
375     // Prevent crash when reload -> change slice if outside extent
376     if (Slice < extent[SliceOrientation*2] || Slice>=extent[SliceOrientation*2+1]) {
377       Slice = (extent[SliceOrientation*2+1]+extent[SliceOrientation*2])/2.0;
378     }
379
380     // Make sure that the required part image has been computed
381     extent[SliceOrientation*2] = Slice;
382     extent[SliceOrientation*2+1] = Slice;    
383 #if VTK_MAJOR_VERSION <= 5
384     mImageReslice->GetOutput()->SetUpdateExtent(extent);
385     mImageReslice->GetOutput()->Update();
386 #else
387     //mImageReslice->SetUpdateExtent(extent);
388     mImageReslice->Update();
389 #endif
390
391     this->UpdateDisplayExtent();
392
393     mCurrentTSlice = 0;
394     ca->SetText(0,mFileName.c_str());
395   }
396 }
397 //------------------------------------------------------------------------------
398
399
400 //------------------------------------------------------------------------------
401 void vvSlicer::SetOverlay(vvImage::Pointer overlay)
402
403   if (overlay->GetVTKImages().size()) {
404     mOverlay = overlay;
405     mOverlayVisibility = true;
406     
407     if (!mOverlayReslice) {
408       mOverlayReslice = vtkSmartPointer<vtkImageReslice>::New();
409       mOverlayReslice->SetInterpolationModeToLinear();
410       mOverlayReslice->AutoCropOutputOn();
411       mOverlayReslice->SetBackgroundColor(-1000,-1000,-1000,1);
412     }
413
414     mConcatenatedOverlayTransform->Identity();
415     mConcatenatedOverlayTransform->Concatenate(mOverlay->GetTransform()[0]);
416     mConcatenatedOverlayTransform->Concatenate(mSlicingTransform);
417     mOverlayReslice->SetResliceTransform(mConcatenatedOverlayTransform);
418 #if VTK_MAJOR_VERSION <= 5
419     mOverlayReslice->SetInput(0, mOverlay->GetFirstVTKImageData());
420     mImageReslice->UpdateInformation();
421 #else
422     mOverlayReslice->SetInputData(0, mOverlay->GetFirstVTKImageData());
423 #endif
424     mOverlayReslice->Update();
425
426     if (!mOverlayMapper)
427       mOverlayMapper = vtkSmartPointer<vtkImageMapToWindowLevelColors>::New();
428 #if VTK_MAJOR_VERSION <= 5
429     mOverlayMapper->SetInput(mOverlayReslice->GetOutput());
430 #else
431     mOverlayMapper->SetInputConnection(mOverlayReslice->GetOutputPort(0));
432 #endif
433
434     if (!mOverlayActor) {
435       mOverlayActor = vtkSmartPointer<vvBlendImageActor>::New();
436 #if VTK_MAJOR_VERSION <= 5
437       mOverlayActor->SetInput(mOverlayMapper->GetOutput());
438 #else
439       mOverlayActor->GetMapper()->SetInputConnection(mOverlayMapper->GetOutputPort());
440 #endif
441       mOverlayActor->SetPickable(0);
442       mOverlayActor->SetVisibility(true);
443       mOverlayActor->SetOpacity(0.5);
444 #if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10)
445       mOverlayActor->GetMapper()->BorderOn();
446 #endif
447       }
448
449     //stupid but necessary : the Overlay need to be rendered before fusion
450     if (mFusionActor) {
451       this->GetRenderer()->RemoveActor(mFusionActor);
452       this->GetRenderer()->AddActor(mOverlayActor);
453       this->GetRenderer()->AddActor(mFusionActor);
454     } else
455       this->GetRenderer()->AddActor(mOverlayActor);
456
457     //Synchronize orientation and slice
458     AdjustResliceToSliceOrientation(mOverlayReslice);
459     this->UpdateDisplayExtent();
460     this->SetTSlice(mCurrentTSlice);
461   }
462 }
463 //------------------------------------------------------------------------------
464
465
466 //------------------------------------------------------------------------------
467 void vvSlicer::SetFusion(vvImage::Pointer fusion, int fusionSequenceCode)
468
469         mFusionSequenceCode = fusionSequenceCode;
470   if (fusion->GetVTKImages().size()) {
471     mFusion = fusion;
472     mFusionVisibility = true;
473
474     if (!mFusionReslice) {
475       mFusionReslice = vtkSmartPointer<vtkImageReslice>::New();
476       mFusionReslice->SetInterpolationModeToLinear();
477       mFusionReslice->AutoCropOutputOn();
478       mFusionReslice->SetBackgroundColor(-1000,-1000,-1000,1);
479     }
480
481     mConcatenatedFusionTransform->Identity();
482     mConcatenatedFusionTransform->Concatenate(mFusion->GetTransform()[0]);
483     mConcatenatedFusionTransform->Concatenate(mSlicingTransform);
484     mFusionReslice->SetResliceTransform(mConcatenatedFusionTransform);
485 #if VTK_MAJOR_VERSION <= 5
486     mFusionReslice->SetInput(0, mFusion->GetFirstVTKImageData());
487     mFusionReslice->UpdateInformation();
488 #else
489     mFusionReslice->SetInputData(0, mFusion->GetFirstVTKImageData());
490 #endif
491     mFusionReslice->Update();
492
493     if (!mFusionMapper)
494       mFusionMapper = vtkSmartPointer<vtkImageMapToColors>::New();
495
496     vtkSmartPointer<vtkLookupTable> lut = vtkLookupTable::New();
497     lut->SetRange(0, 1);
498     lut->SetValueRange(0, 1);
499     lut->SetSaturationRange(0, 0);
500     lut->Build();
501     mFusionMapper->SetLookupTable(lut);
502 #if VTK_MAJOR_VERSION <= 5
503     mFusionMapper->SetInput(mFusionReslice->GetOutput());
504 #else
505     mFusionMapper->SetInputConnection(mFusionReslice->GetOutputPort(0));
506 #endif
507     
508     if (!mFusionActor) {
509       mFusionActor = vtkSmartPointer<vtkImageActor>::New();
510 #if VTK_MAJOR_VERSION <= 5
511       mFusionActor->SetInput(mFusionMapper->GetOutput());
512 #else
513       mFusionActor->GetMapper()->SetInputConnection(mFusionMapper->GetOutputPort());
514 #endif
515       mFusionActor->SetPickable(0);
516       mFusionActor->SetVisibility(true);
517       mFusionActor->SetOpacity(0.7);
518 #if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10)
519       mFusionActor->GetMapper()->BorderOn();
520 #endif
521
522       this->GetRenderer()->AddActor(mFusionActor);
523     }
524
525     //Synchronize orientation and slice
526     AdjustResliceToSliceOrientation(mFusionReslice);
527     this->UpdateDisplayExtent();
528     this->SetTSlice(mCurrentTSlice);
529   }
530 }
531 //------------------------------------------------------------------------------
532
533
534 //------------------------------------------------------------------------------
535 bool vvSlicer::GetActorVisibility(const std::string& actor_type, int overlay_index)
536
537   bool vis = false;
538   if (actor_type == "image")
539     vis = mImageVisibility;
540   else if (actor_type == "vector")
541     vis = mVFVisibility;
542   else if (actor_type == "overlay")
543     vis = mOverlayVisibility;
544   else if ( (actor_type == "fusion") || (actor_type == "fusionSequence") )
545     vis = mFusionVisibility;
546   else if (actor_type == "contour")
547     vis = this->mSurfaceCutActors[overlay_index]->GetActor()->GetVisibility();
548   return vis;
549 }
550 //------------------------------------------------------------------------------
551
552 //------------------------------------------------------------------------------
553 void vvSlicer::SetActorVisibility(const std::string& actor_type, int overlay_index ,bool vis)
554
555   if (actor_type == "image")
556     mImageVisibility = vis;
557   else if (actor_type == "vector")
558     mVFVisibility = vis;
559   else if (actor_type == "overlay")
560     mOverlayVisibility = vis;
561   else if ( (actor_type == "fusion") || (actor_type == "fusionSequence") )
562     mFusionVisibility = vis;
563   else if (actor_type == "contour")
564     this->mSurfaceCutActors[overlay_index]->GetActor()->SetVisibility(vis);
565   UpdateDisplayExtent();
566 }
567 //------------------------------------------------------------------------------
568
569 //------------------------------------------------------------------------------
570 void vvSlicer::SetVF(vvImage::Pointer vf)
571
572   if (vf->GetVTKImages().size()) {
573     mVF = vf;
574     mVFVisibility = true;
575
576     if (!mAAFilter) {
577       mAAFilter= vtkSmartPointer<vtkAssignAttribute>::New();
578       mVOIFilter = vtkSmartPointer<vtkExtractVOI>::New();
579       mVOIFilter->SetSampleRate(mSubSampling,mSubSampling,mSubSampling);
580     }
581 #if VTK_MAJOR_VERSION <= 5
582     mVOIFilter->SetInput(vf->GetFirstVTKImageData());
583     mAAFilter->SetInput(mVOIFilter->GetOutput());
584 #else
585     mVOIFilter->SetInputData(vf->GetFirstVTKImageData());
586     mAAFilter->SetInputConnection(mVOIFilter->GetOutputPort());
587 #endif
588     ///This tells VTK to use the scalar (pixel) data of the image to draw the little arrows
589     mAAFilter->Assign(vtkDataSetAttributes::SCALARS, vtkDataSetAttributes::VECTORS, vtkAssignAttribute::POINT_DATA);
590
591     if (!mArrow)
592       mArrow = vtkSmartPointer<vvGlyphSource>::New();
593     mArrow->SetGlyphTypeToSpecificArrow();
594     mArrow->SetScale(mScale);
595     mArrow->FilledOff();
596
597     // Glyph the gradient vector (with arrows)
598     if (!mGlyphFilter)
599       mGlyphFilter = vtkSmartPointer<vvGlyph2D>::New();
600 #if VTK_MAJOR_VERSION <= 5
601     mGlyphFilter->SetInput(mAAFilter->GetOutput());
602     mGlyphFilter->SetSource(mArrow->GetOutput());
603 #else
604     mGlyphFilter->SetInputConnection(mAAFilter->GetOutputPort());
605     mGlyphFilter->SetSourceConnection(mArrow->GetOutputPort());
606 #endif
607     mGlyphFilter->ScalingOn();
608     mGlyphFilter->SetScaleModeToScaleByVector();
609     mGlyphFilter->OrientOn();
610     mGlyphFilter->SetVectorModeToUseVector();
611     mGlyphFilter->SetColorModeToColorByVector();
612
613     if (!mVFColorLUT)
614       mVFColorLUT = vtkSmartPointer<vtkLookupTable>::New();
615
616     double mVFColorHSV[3];
617     vtkMath::RGBToHSV(mVFColor, mVFColorHSV);
618     mVFColorLUT->SetHueRange(mVFColorHSV[0], mVFColorHSV[0]);
619     mVFColorLUT->SetSaturationRange(mVFColorHSV[1],mVFColorHSV[1]);
620     mVFColorLUT->SetValueRange(mVFColorHSV[2], mVFColorHSV[2]);
621
622     if (!mVFMapper)
623       mVFMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
624 #if VTK_MAJOR_VERSION <= 5
625     mVFMapper->SetInput(mGlyphFilter->GetOutput());
626 #else
627     mVFMapper->SetInputConnection(mGlyphFilter->GetOutputPort());
628 #endif
629     mVFMapper->ImmediateModeRenderingOn();
630     mVFMapper->SetLookupTable(mVFColorLUT);
631
632     if (!mVFActor)
633       mVFActor = vtkSmartPointer<vtkActor>::New();
634     mVFActor->SetMapper(mVFMapper);
635     mVFActor->SetPickable(0);
636     mVFActor->GetProperty()->SetLineWidth(mVFWidth);
637     this->UpdateDisplayExtent();
638     this->GetRenderer()->AddActor(mVFActor);
639
640     //Synchronize slice
641     SetTSlice(mCurrentTSlice);
642   }
643 }
644 //------------------------------------------------------------------------------
645
646
647 //------------------------------------------------------------------------------
648 void vvSlicer::SetLandmarks(vvLandmarks* landmarks)
649
650   mLandmarks = landmarks;
651   if (landmarks) {
652
653     if (!mCross)
654       mCross = vtkSmartPointer<vtkCursor3D>::New();
655         if (!mClipBox)
656       mClipBox = vtkSmartPointer<vtkBox>::New();
657     if (!mLandClipper)
658       mLandClipper = vtkSmartPointer<vvClipPolyData>::New();
659     if (!mLandGlyph)
660       mLandGlyph = vtkSmartPointer<vtkGlyph3D>::New();
661     if (!mLandMapper)
662       mLandMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
663     if (!mLandActor)
664       mLandActor = vtkSmartPointer<vtkActor>::New();
665
666     mCross->SetFocalPoint(0.0,0.0,0.0);
667     mCross->SetModelBounds(-10,10,-10,10,-10,10);
668     mCross->AllOff();
669     mCross->AxesOn();
670
671     mLandClipper->SetClipFunction(mClipBox);
672     mLandClipper->InsideOutOn();
673 #if VTK_MAJOR_VERSION <= 5
674     mLandmarkTransform = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
675     mLandmarkTransform->SetInput(mLandmarks->GetOutput());
676     mConcatenatedTransform->Identity();
677     mConcatenatedTransform->Concatenate(mImage->GetTransform()[0]);
678     mConcatenatedTransform->Concatenate(mSlicingTransform);
679     mLandmarkTransform->SetTransform(mConcatenatedTransform->GetInverse());
680     mLandClipper->SetInput(mLandmarkTransform->GetOutput());
681
682     mLandGlyph->SetSource(mCross->GetOutput());
683     mLandGlyph->SetInput(mLandClipper->GetOutput());
684 #else
685     mLandmarkTransform = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
686     mLandmarkTransform->SetInputData(mLandmarks->GetOutput());
687     mConcatenatedTransform->Identity();
688     mConcatenatedTransform->Concatenate(mImage->GetTransform()[0]);
689     mConcatenatedTransform->Concatenate(mSlicingTransform);
690     mLandmarkTransform->SetTransform(mConcatenatedTransform->GetInverse());
691     mLandClipper->SetInputConnection(mLandmarkTransform->GetOutputPort());
692
693     mLandGlyph->SetSourceConnection(mCross->GetOutputPort());
694     mLandGlyph->SetInputConnection(mLandClipper->GetOutputPort());
695 #endif
696     //mLandGlyph->SetIndexModeToScalar();
697     //mLandGlyph->SetRange(0,1);
698     //mLandGlyph->ScalingOff();
699
700     //mLandGlyph->SetColorModeToColorByScalar();
701     
702     mLandGlyph->SetScaleModeToDataScalingOff();
703     mLandGlyph->SetIndexModeToOff();
704
705     mLandMapper->SetInputConnection(mLandGlyph->GetOutputPort());
706     //mLandMapper->ScalarVisibilityOff();
707
708     mLandActor->SetMapper(mLandMapper);
709     mLandActor->GetProperty()->SetOpacity(0.995);  //in order to get VTK to turn on the alpha-blending in OpenGL
710     mLandActor->GetProperty()->SetColor(255,10,212);
711     mLandActor->SetPickable(0);
712     mLandActor->SetVisibility(true);
713     this->UpdateDisplayExtent();
714   }
715 }
716 //------------------------------------------------------------------------------
717
718 //------------------------------------------------------------------------------
719 //FIXME: this function leaks memory, we should fix it someday :)
720 void vvSlicer::RemoveActor(const std::string& actor_type, int overlay_index)
721
722   if (actor_type == "vector") {
723     Renderer->RemoveActor(mVFActor);
724     mGlyphFilter=NULL;
725     mVF = NULL;
726     mArrow = NULL;
727     mAAFilter=NULL;
728     mVOIFilter = NULL;
729     mVFMapper = NULL;
730     mVFActor = NULL;
731   }
732   if (actor_type == "overlay") {
733     Renderer->RemoveActor(mOverlayActor);
734     mOverlay = NULL;
735     mOverlayActor = NULL;
736     mOverlayMapper = NULL;
737   }
738   if ( (actor_type == "fusion") || (actor_type == "fusionSequence") ) {
739     Renderer->RemoveActor(mFusionActor);
740     mFusion = NULL;
741     mFusionActor = NULL;
742     mFusionMapper = NULL;
743   }
744   if (actor_type == "contour") {
745     Renderer->RemoveActor(this->mSurfaceCutActors[overlay_index]->GetActor());
746     mSurfaceCutActors.erase(mSurfaceCutActors.begin()+overlay_index);
747   }
748 }
749 //------------------------------------------------------------------------------
750
751
752 //------------------------------------------------------------------------------
753 void vvSlicer::SetVFSubSampling(int sub)
754
755   if (mVOIFilter) {
756     mVOIFilter->SetSampleRate(mSubSampling,mSubSampling,mSubSampling);
757     mSubSampling = sub;
758   }
759   UpdateDisplayExtent();
760   Render();
761 }
762 //------------------------------------------------------------------------------
763
764
765 //------------------------------------------------------------------------------
766 void vvSlicer::SetVFScale(int scale)
767
768   mScale = scale;
769   if (mArrow)
770     mArrow->SetScale(mScale);
771   UpdateDisplayExtent();
772   Render();
773 }
774 //------------------------------------------------------------------------------
775
776 //------------------------------------------------------------------------------
777 void vvSlicer::SetVFWidth(int width)
778
779   mVFWidth = width;
780   if (mVFActor)
781     mVFActor->GetProperty()->SetLineWidth(mVFWidth);
782   UpdateDisplayExtent();
783   Render();
784 }
785 //------------------------------------------------------------------------------
786
787
788 //------------------------------------------------------------------------------
789 void vvSlicer::SetVFLog(int log)
790
791   mVFLog = log;
792   if (mGlyphFilter) {
793     mGlyphFilter->SetUseLog(mVFLog);
794     mGlyphFilter->Modified();
795   }
796   UpdateDisplayExtent();
797   Render();
798 }
799 //------------------------------------------------------------------------------
800
801
802 //------------------------------------------------------------------------------
803 void vvSlicer::SetTSlice(int t, bool updateLinkedImages)
804
805         if (!updateLinkedImages) {
806                 mCurrentTSlice = t;
807 #if VTK_MAJOR_VERSION <= 5
808                 mImageReslice->SetInput( mImage->GetVTKImages()[mCurrentTSlice] );
809 #else
810                 mImageReslice->SetInputData( mImage->GetVTKImages()[mCurrentTSlice] );
811 #endif
812                 // Update transform
813                 mConcatenatedTransform->Identity();
814                 mConcatenatedTransform->Concatenate(mImage->GetTransform()[mCurrentTSlice]);
815                 mConcatenatedTransform->Concatenate(mSlicingTransform);
816                 UpdateDisplayExtent();
817                 return;
818         }
819   if (t < 0)
820     mCurrentTSlice = 0;
821   else if ((unsigned int)t >= mImage->GetVTKImages().size())
822     mCurrentTSlice = mImage->GetVTKImages().size() -1;
823   else
824     mCurrentTSlice = t;
825
826   // Update transform
827   mConcatenatedTransform->Identity();
828   mConcatenatedTransform->Concatenate(mImage->GetTransform()[mCurrentTSlice]);
829   mConcatenatedTransform->Concatenate(mSlicingTransform);
830
831   // Update image data
832 #if VTK_MAJOR_VERSION <= 5
833    mImageReslice->SetInput( mImage->GetVTKImages()[mCurrentTSlice] );
834 #else
835   mImageReslice->SetInputData( mImage->GetVTKImages()[mCurrentTSlice] );
836 #endif
837   if (mVF && mVFActor->GetVisibility()) {
838     if (mVF->GetVTKImages().size() > (unsigned int)mCurrentTSlice)
839 #if VTK_MAJOR_VERSION <= 5
840       mVOIFilter->SetInput(mVF->GetVTKImages()[mCurrentTSlice]);
841 #else
842       mVOIFilter->SetInputData(mVF->GetVTKImages()[mCurrentTSlice]);
843 #endif
844   }
845   //update the overlay
846   if (mOverlay && mOverlayActor->GetVisibility()) {
847     if (mOverlay->GetVTKImages().size() > (unsigned int)t) {
848       mCurrentOverlayTSlice = t;
849 #if VTK_MAJOR_VERSION <= 5
850       mOverlayReslice->SetInput( mOverlay->GetVTKImages()[mCurrentOverlayTSlice] );
851 #else
852       mOverlayReslice->SetInputData( mOverlay->GetVTKImages()[mCurrentOverlayTSlice] );
853 #endif
854       // Update overlay transform
855       mConcatenatedOverlayTransform->Identity();
856       mConcatenatedOverlayTransform->Concatenate(mOverlay->GetTransform()[mCurrentOverlayTSlice]);
857       mConcatenatedOverlayTransform->Concatenate(mSlicingTransform);
858     }
859   }
860   //update the fusion ; except in case this is a fusionSequence, in which case both 'times' should be independent.
861   if (mFusion && mFusionActor->GetVisibility() && (mFusionSequenceCode<0)) {
862     if (mFusion->GetVTKImages().size() > (unsigned int)t) {
863       mCurrentFusionTSlice = t;
864 #if VTK_MAJOR_VERSION <= 5
865       mFusionReslice->SetInput( mFusion->GetVTKImages()[mCurrentFusionTSlice]);
866 #else
867       mFusionReslice->SetInputData( mFusion->GetVTKImages()[mCurrentFusionTSlice]);
868 #endif
869
870       // Update fusion transform
871       mConcatenatedFusionTransform->Identity();
872       mConcatenatedFusionTransform->Concatenate(mFusion->GetTransform()[mCurrentFusionTSlice]);
873       mConcatenatedFusionTransform->Concatenate(mSlicingTransform);
874     }
875   }
876   if (mSurfaceCutActors.size() > 0)
877     for (std::vector<vvMeshActor*>::iterator i=mSurfaceCutActors.begin();
878          i!=mSurfaceCutActors.end(); i++)
879       (*i)->SetTimeSlice(mCurrentTSlice);
880   UpdateDisplayExtent();
881 }
882 //------------------------------------------------------------------------------
883
884
885 //------------------------------------------------------------------------------
886 void vvSlicer::SetFusionSequenceTSlice(int t)
887
888   if (mFusion && mFusionActor->GetVisibility() && (mFusionSequenceCode>=0)) {
889     if (mFusion->GetVTKImages().size() > (unsigned int)t) {
890       mCurrentFusionTSlice = t;
891 #if VTK_MAJOR_VERSION <= 5
892       mFusionReslice->SetInput( mFusion->GetVTKImages()[mCurrentFusionTSlice] );
893 #else
894       mFusionReslice->SetInputData( mFusion->GetVTKImages()[mCurrentFusionTSlice] );
895 #endif
896       // Update fusion transform
897       mConcatenatedFusionTransform->Identity();
898       mConcatenatedFusionTransform->Concatenate(mFusion->GetTransform()[mCurrentFusionTSlice]); //not really useful...
899       mConcatenatedFusionTransform->Concatenate(mSlicingTransform);
900     }
901   }
902
903   UpdateDisplayExtent();
904 }
905 //------------------------------------------------------------------------------
906
907
908 //------------------------------------------------------------------------------
909 int vvSlicer::GetTSlice()
910
911   return mCurrentTSlice;
912 }
913 //------------------------------------------------------------------------------
914
915 //------------------------------------------------------------------------------
916 int vvSlicer::GetMaxCurrentTSlice()
917
918   int t = mCurrentTSlice;
919   if(mOverlay)
920     t = std::max(t, mCurrentOverlayTSlice);
921   if(mFusion&& (mFusionSequenceCode<0)) //ignore fusionSequence data: for these, the times are not to be related (this way)
922     t = std::max(t, mCurrentFusionTSlice);
923   return t;
924 }
925 //------------------------------------------------------------------------------
926
927 //------------------------------------------------------------------------------
928 int vvSlicer::GetFusionTSlice()
929
930   return mCurrentFusionTSlice;
931 }
932 //------------------------------------------------------------------------------
933
934 //------------------------------------------------------------------------------
935 int vvSlicer::GetOverlayTSlice()
936
937   return mCurrentOverlayTSlice;
938 }
939 //------------------------------------------------------------------------------
940
941 //------------------------------------------------------------------------------
942 void vvSlicer::SetSliceOrientation(int orientation)
943
944   //if 2D image, force to watch in Axial View
945   int extent[6];
946 #if VTK_MAJOR_VERSION <= 5
947     this->GetInput()->GetWholeExtent(extent);
948 #else
949     int* ext = mImageReslice->GetInputInformation()->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT());
950     copyExtent(ext, extent);
951 #endif
952
953   if (extent[5]-extent[4] <= 2)
954     orientation = vtkImageViewer2::SLICE_ORIENTATION_XY;
955
956   if (orientation < vtkImageViewer2::SLICE_ORIENTATION_YZ ||
957       orientation > vtkImageViewer2::SLICE_ORIENTATION_XY) {
958     vtkErrorMacro("Error - invalid slice orientation " << orientation);
959     return;
960   }
961   
962   this->SliceOrientation = orientation;
963
964   if(mFusion)
965     AdjustResliceToSliceOrientation(mFusionReslice);
966
967   if(mOverlay)
968     AdjustResliceToSliceOrientation(mOverlayReslice);
969
970   // Update the viewer
971   
972   // Go to current cursor position
973   // double* cursorPos = GetCursorPosition();
974   // DDV(cursorPos, 3);
975   // SetCurrentPosition(cursorPos[0],cursorPos[1],cursorPos[2],cursorPos[3]);
976
977   if (mFirstSetSliceOrientation) {
978     int *range = this->GetSliceRange();
979     if (range)
980       this->Slice = static_cast<int>((range[0] + range[1]) * 0.5);
981 #if VTK_MAJOR_VERSION <= 5
982       mFirstSetSliceOrientation = false;
983 #endif
984   }
985   else if (this->Renderer && this->GetInput()) {
986     double s = mCursor[orientation];
987     double sCursor = (s - this->GetInput()->GetOrigin()[orientation])/this->GetInput()->GetSpacing()[orientation];
988     this->Slice = static_cast<int>(sCursor);
989   }
990
991   this->UpdateOrientation();
992   
993   this->UpdateDisplayExtent();
994   
995   if (mFirstSetSliceOrientation) {
996     mFirstSetSliceOrientation = false;
997   }
998   
999   if (this->Renderer && this->GetInput()) {
1000     double scale = this->Renderer->GetActiveCamera()->GetParallelScale();
1001     this->Renderer->ResetCamera();
1002     this->Renderer->GetActiveCamera()->SetParallelScale(scale);
1003   }
1004
1005   SetContourSlice();
1006 }
1007 //----------------------------------------------------------------------------
1008
1009 //------------------------------------------------------------------------------
1010 // This function ensures that we sample the slices of a vtkImageReslice filter
1011 // in the direction of the slicer (SliceOrientation) similarly as mImageReslice.
1012 // In other words, we change the grid of the reslice in the same way as the grid
1013 // of the displayed image in the slicing direction.
1014 void vvSlicer::AdjustResliceToSliceOrientation(vtkImageReslice *reslice)
1015
1016   // Reset autocrop and update output information
1017   reslice->SetOutputOriginToDefault();
1018   reslice->SetOutputSpacingToDefault();
1019 #if VTK_MAJOR_VERSION <= 5
1020   reslice->GetOutput()->UpdateInformation();
1021 #else
1022   reslice->UpdateInformation();
1023 #endif
1024
1025   // Ge new origin / spacing
1026   double origin[3];
1027   double spacing[3];
1028   reslice->GetOutput()->GetOrigin(origin);
1029   reslice->GetOutput()->GetSpacing(spacing);
1030
1031   // Use similar spacing as the image in the direction SliceOrientation
1032   spacing[this->SliceOrientation] = mImageReslice->GetOutput()->GetSpacing()[this->SliceOrientation];
1033
1034   // Modify origin to be on the image grid in the direction SliceOrientation in 3 steps
1035   // Step 1: from world coordinates to image coordinates
1036   origin[this->SliceOrientation] -= mImageReslice->GetOutput()->GetOrigin()[this->SliceOrientation];
1037   origin[this->SliceOrientation] /= mImageReslice->GetOutput()->GetSpacing()[this->SliceOrientation];
1038
1039   // Step 2: round to nearest grid positionInc. This has been validated as the only
1040   // way to have something consistent with the thickness of a 2D slice visible on the
1041   // other slices. The thickness is accounted for so if the 2D slice is to thin and
1042   // between two slices, one will never be able to see this 2D slice (bug #1883).
1043   origin[this->SliceOrientation] = itk::Math::Round<double>(origin[this->SliceOrientation]);
1044
1045   // Step 3: back to world coordinates
1046   origin[this->SliceOrientation] *= mImageReslice->GetOutput()->GetSpacing()[this->SliceOrientation];
1047   origin[this->SliceOrientation] += mImageReslice->GetOutput()->GetOrigin()[this->SliceOrientation];
1048
1049   // Set new spacing and origin
1050   reslice->SetOutputOrigin(origin);
1051   reslice->SetOutputSpacing(spacing);
1052   reslice->UpdateInformation();
1053 #if VTK_MAJOR_VERSION <= 5
1054   reslice->GetOutput()->UpdateInformation();
1055 #endif
1056 }
1057 //------------------------------------------------------------------------------
1058
1059 //----------------------------------------------------------------------------
1060 int * vvSlicer::GetExtent()
1061
1062   int *w_ext;
1063   if (mUseReducedExtent) {
1064     w_ext = mReducedExtent;
1065   }
1066   else {
1067 #if VTK_MAJOR_VERSION <= 5
1068     w_ext = GetInput()->GetWholeExtent();
1069 #else
1070     w_ext = mImageReslice->GetInputInformation()->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT());
1071 #endif
1072   }
1073   return w_ext;
1074 }
1075 //----------------------------------------------------------------------------
1076
1077
1078 //----------------------------------------------------------------------------
1079 int vvSlicer::GetOrientation()
1080
1081   return this->SliceOrientation;
1082 }
1083 //----------------------------------------------------------------------------
1084
1085
1086 //----------------------------------------------------------------------------
1087 void vvSlicer::UpdateDisplayExtent()
1088
1089   emit UpdateDisplayExtentBegin(mSlicerNumber);
1090   vtkImageData *input = this->GetInput();
1091   if (!input || !this->ImageActor) {
1092     return;
1093   }
1094
1095 #if VTK_MAJOR_VERSION <= 5
1096   input->UpdateInformation();
1097 #else
1098   mRegisterExtent = mImageReslice->GetOutputInformation(0)->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT());
1099 #endif
1100   this->SetSlice( this->GetSlice() ); //SR: make sure the update let the slice in extents
1101
1102   // Local copy of extent
1103   int w_ext[6];
1104 #if VTK_MAJOR_VERSION <= 5
1105   int* ext = GetExtent();
1106 #else
1107   int* ext = mImageReslice->GetOutputInformation(0)->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT());
1108 #endif
1109   copyExtent(ext, w_ext);
1110   if (mUseReducedExtent) {
1111         copyExtent(mReducedExtent, w_ext);
1112     }
1113   // Set slice value
1114
1115   w_ext[ this->SliceOrientation*2   ] = this->Slice;
1116   w_ext[ this->SliceOrientation*2+1 ] = this->Slice;
1117   
1118   // Image actor
1119   this->ImageActor->SetVisibility(mImageVisibility);
1120   this->ImageActor->SetDisplayExtent(w_ext);
1121   
1122 #if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10)
1123   // Fix for bug #1882
1124   dynamic_cast<vtkImageSliceMapper *>(this->ImageActor->GetMapper())->SetOrientation(this->GetOrientation());
1125 #endif
1126
1127   // Overlay image actor
1128   if (mOverlay && mOverlayVisibility) {
1129     AdjustResliceToSliceOrientation(mOverlayReslice);
1130     int overExtent[6];
1131 #if VTK_MAJOR_VERSION <= 5
1132     this->ConvertImageToImageDisplayExtent(input, w_ext, mOverlayReslice->GetOutput(), overExtent);
1133     bool out = ClipDisplayedExtent(overExtent, mOverlayMapper->GetInput()->GetWholeExtent());
1134 #else
1135     this->ConvertImageToImageDisplayExtent(mImageReslice->GetOutputInformation(0), w_ext, mOverlayReslice->GetOutput(), overExtent);
1136     bool out = ClipDisplayedExtent(overExtent, mOverlayMapper->GetInputInformation()->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT()));
1137 #endif
1138     mOverlayActor->SetVisibility(!out);
1139     mOverlayActor->SetDisplayExtent( overExtent );
1140 #if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10)
1141     // Fix for bug #1882
1142     dynamic_cast<vtkImageSliceMapper *>(mOverlayActor->GetMapper())->SetOrientation(this->GetOrientation());
1143 #endif
1144   }
1145   else if(mOverlay)
1146     mOverlayActor->SetVisibility(false);
1147
1148   // Fusion image actor
1149   if (mFusion && mFusionVisibility) {
1150     AdjustResliceToSliceOrientation(mFusionReslice);
1151     int fusExtent[6];
1152 #if VTK_MAJOR_VERSION <= 5
1153     this->ConvertImageToImageDisplayExtent(input, w_ext, mFusionReslice->GetOutput(), fusExtent);
1154     bool out = ClipDisplayedExtent(fusExtent, mFusionMapper->GetInput()->GetWholeExtent());
1155 #else
1156     this->ConvertImageToImageDisplayExtent(mImageReslice->GetOutputInformation(0), w_ext, mFusionReslice->GetOutput(), fusExtent);
1157     bool out = ClipDisplayedExtent(fusExtent, mFusionMapper->GetInputInformation()->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT()));
1158 #endif
1159     mFusionActor->SetVisibility(!out);
1160     mFusionActor->SetDisplayExtent( fusExtent );
1161 #if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10)
1162     // Fix for bug #1882
1163     dynamic_cast<vtkImageSliceMapper *>(mFusionActor->GetMapper())->SetOrientation(this->GetOrientation());
1164 #endif
1165   }
1166   else if(mFusion)
1167     mFusionActor->SetVisibility(false);
1168   // Vector field actor
1169   double* camera = Renderer->GetActiveCamera()->GetPosition();
1170   double* image_bounds = ImageActor->GetBounds();
1171   double position[3] = {0, 0, 0};
1172   position[this->SliceOrientation] = image_bounds[this->SliceOrientation*2]; 
1173
1174   //print_vector<double, 6>("camera", camera);
1175   //print_vector<double, 6>("image_bounds", image_bounds);
1176   //print_vector<double, 3>("position", position);
1177
1178   // find where to place the VF actor. to deal with
1179   // z-buffer issues, the VF is placed right in front of the image,
1180   // subject to a small offset. the position actually depends on the
1181   // the location of the camera relative to the image. 
1182   double offset = 1;
1183   if (camera[this->SliceOrientation] < image_bounds[this->SliceOrientation*2])
1184     offset = -1;
1185   
1186   if (mVF && mVFVisibility) {
1187     int vfExtent[6];
1188 #if VTK_MAJOR_VERSION <= 5
1189     mVF->GetVTKImages()[0]->UpdateInformation();
1190     this->ConvertImageToImageDisplayExtent(input, w_ext, mVF->GetVTKImages()[0], vfExtent);
1191     bool out = ClipDisplayedExtent(vfExtent, mVOIFilter->GetInput()->GetWholeExtent());
1192 #else
1193     mVOIFilter->Update();
1194     this->ConvertImageToImageDisplayExtent(mImageReslice->GetOutputInformation(0), w_ext, mVF->GetVTKImages()[0], vfExtent);
1195     bool out = ClipDisplayedExtent(vfExtent, mVOIFilter->GetInputInformation()->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT()));
1196 #endif
1197     mVFActor->SetVisibility(!out);
1198     mVOIFilter->SetVOI(vfExtent);
1199     int orientation[3] = {1,1,1};
1200     orientation[this->SliceOrientation] = 0;
1201     mGlyphFilter->SetOrientation(orientation[0], orientation[1], orientation[2]);
1202     position[this->SliceOrientation] += offset;
1203     mVFActor->SetPosition(position);
1204     mVFActor->GetProperty()->SetOpacity(0.995); //in order to get VTK to turn on the alpha-blending in OpenGL
1205     mVFMapper->Update();
1206
1207   }
1208   else if(mVF)
1209     mVFActor->SetVisibility(false);
1210     
1211     
1212     double boundsT [6];
1213       for(unsigned int i=0; i<6; i++)
1214         boundsT[i] = ImageActor->GetBounds()[i];
1215       boundsT[ this->SliceOrientation*2   ] = ImageActor->GetBounds()[ this->SliceOrientation*2  ]-fabs(this->GetInput()->GetSpacing()[this->SliceOrientation]);
1216       boundsT[ this->SliceOrientation*2+1 ] = ImageActor->GetBounds()[ this->SliceOrientation*2+1 ]+fabs(this->GetInput()->GetSpacing()[this->SliceOrientation]);
1217
1218
1219   // Landmarks actor
1220   if (mLandActor) {
1221     if (mClipBox) {
1222       RemoveLandmarks();
1223     }
1224     
1225     position[this->SliceOrientation] = offset;
1226     mLandActor->SetPosition(position);
1227   }
1228
1229   // Figure out the correct clipping range
1230   if (this->Renderer) {
1231     if (this->InteractorStyle &&
1232         this->InteractorStyle->GetAutoAdjustCameraClippingRange()) {
1233       this->Renderer->ResetCameraClippingRange();
1234     } else {
1235       vtkCamera *cam = this->Renderer->GetActiveCamera();
1236       if (cam) {
1237         double bounds[6];
1238         this->ImageActor->GetBounds(bounds);
1239         double spos = (double)bounds[this->SliceOrientation * 2];
1240         double cpos = (double)cam->GetPosition()[this->SliceOrientation];
1241         double range = fabs(spos - cpos);
1242         double *spacing = input->GetSpacing();
1243         double sumSpacing = spacing[0] + spacing[1] + spacing[2];
1244         cam->SetClippingRange(range - sumSpacing, range + sumSpacing);
1245       }
1246     }
1247     
1248     if (mLandActor) {
1249         if (mClipBox) {
1250             DisplayLandmarks();
1251         }
1252     }
1253   }
1254   emit UpdateDisplayExtentEnd(mSlicerNumber);
1255 }
1256 //----------------------------------------------------------------------------
1257
1258 //----------------------------------------------------------------------------
1259 void vvSlicer::ConvertImageToImageDisplayExtent(vtkInformation *sourceImage, const int sourceExtent[6],
1260                                                 vtkImageData *targetImage, int targetExtent[6])
1261
1262   double dExtents[6];
1263   double *origin, *spacing;
1264   origin = sourceImage->Get(vtkDataObject::ORIGIN());
1265   spacing = sourceImage->Get(vtkDataObject::SPACING());
1266   for(unsigned int i=0; i<6; i++) {
1267     // From source voxel coordinates to world coordinates
1268     dExtents[i] = origin[i/2] + spacing[i/2] * sourceExtent[i];
1269
1270     // From world coordinates to floating point target voxel coordinates
1271     dExtents[i] = (dExtents[i]- targetImage->GetOrigin()[i/2]) / targetImage->GetSpacing()[i/2];
1272     
1273     // Round to current slice or larger extent
1274     if(i/2==this->GetOrientation())
1275       targetExtent[i] = itk::Math::Round<double>(dExtents[i]);
1276     else if(i%2==1)
1277       targetExtent[i] = itk::Math::Ceil<double>(dExtents[i]);
1278     else
1279       targetExtent[i] = itk::Math::Floor<double>(dExtents[i]);
1280   }
1281 }
1282 //----------------------------------------------------------------------------
1283
1284 //----------------------------------------------------------------------------
1285 void vvSlicer::ConvertImageToImageDisplayExtent(vtkImageData *sourceImage, const int sourceExtent[6],
1286                                                 vtkImageData *targetImage, int targetExtent[6])
1287 {
1288   double dExtents[6];
1289   for(unsigned int i=0; i<6; i++) {
1290     // From source voxel coordinates to world coordinates
1291     dExtents[i] = sourceImage->GetOrigin()[i/2] + sourceImage->GetSpacing()[i/2] * sourceExtent[i];
1292
1293     // From world coordinates to floating point target voxel coordinates
1294     dExtents[i] = (dExtents[i]- targetImage->GetOrigin()[i/2]) / targetImage->GetSpacing()[i/2];
1295     
1296     // Round to current slice or larger extent
1297     if(i/2==this->GetOrientation())
1298       targetExtent[i] = itk::Math::Round<double>(dExtents[i]);
1299     else if(i%2==1)
1300       targetExtent[i] = itk::Math::Ceil<double>(dExtents[i]);
1301     else
1302       targetExtent[i] = itk::Math::Floor<double>(dExtents[i]);
1303   }
1304 }
1305 //----------------------------------------------------------------------------
1306
1307 //----------------------------------------------------------------------------
1308 bool vvSlicer::ClipDisplayedExtent(int extent[6], int refExtent[6])
1309
1310   bool out = false;
1311   int maxBound = 6;
1312
1313   for (int i = 0; i < maxBound; i = i+2) {
1314     //if we are totally outside the image
1315     if ( extent[i] > refExtent[i+1] || extent[i+1] < refExtent[i] ) {
1316       out = true;
1317       break;
1318     }
1319     //crop to the limit of the image
1320     extent[i] = std::max(extent[i], refExtent[i]);
1321     extent[i] = std::min(extent[i], refExtent[i+1]);;
1322     extent[i+1] = std::max(extent[i+1], refExtent[i]);
1323     extent[i+1] = std::min(extent[i+1], refExtent[i+1]);;
1324   }
1325   if (out)
1326     for (int i = 0; i < maxBound; i = i+2) {
1327       extent[i] = refExtent[i];
1328       extent[i+1] = refExtent[i];
1329     }
1330   return out;
1331 }
1332 //----------------------------------------------------------------------------
1333
1334
1335 //----------------------------------------------------------------------------
1336 void vvSlicer::UpdateOrientation()
1337
1338   // Set the camera position
1339   vtkCamera *cam = this->Renderer ? this->Renderer->GetActiveCamera() : NULL;
1340   if (cam) {
1341     switch (this->SliceOrientation) {
1342     case vtkImageViewer2::SLICE_ORIENTATION_XY:
1343       cam->SetFocalPoint(0,0,0);
1344       cam->SetPosition(0,0,-1); // -1 if medical ?
1345       cam->SetViewUp(0,-1,0);
1346       break;
1347
1348     case vtkImageViewer2::SLICE_ORIENTATION_XZ:
1349       cam->SetFocalPoint(0,0,0);
1350       cam->SetPosition(0,-1,0); // 1 if medical ?
1351       cam->SetViewUp(0,0,1);
1352       break;
1353
1354     case vtkImageViewer2::SLICE_ORIENTATION_YZ:
1355       cam->SetFocalPoint(0,0,0);
1356       cam->SetPosition(-1,0,0); // -1 if medical ?
1357       cam->SetViewUp(0,0,1);
1358       break;
1359     }
1360   }
1361 }
1362 //----------------------------------------------------------------------------
1363
1364
1365 //----------------------------------------------------------------------------
1366 void vvSlicer::SetOpacity(double s)
1367
1368   this->GetImageActor()->SetOpacity(s);
1369 }
1370 //----------------------------------------------------------------------------
1371
1372
1373 //----------------------------------------------------------------------------
1374 void vvSlicer::SetRenderWindow(int orientation, vtkRenderWindow * rw)
1375
1376   this->Superclass::SetRenderWindow(rw);
1377   this->SetupInteractor(rw->GetInteractor());
1378   ca->SetImageActor(this->GetImageActor());
1379   ca->SetWindowLevel(this->GetWindowLevel());
1380   ca->SetText(3, "<window>\n<level>");
1381
1382   double bounds[6];
1383   double max = 65000;
1384
1385   bounds[0] = -max;
1386   bounds[1] = max;
1387   bounds[2] = -max;
1388   bounds[3] = max;
1389   bounds[4] = -max;
1390   bounds[5] = max;
1391   crossCursor->SetModelBounds(bounds);
1392
1393   this->GetRenderer()->AddActor(pdmA);
1394   this->GetRenderer()->AddActor(ca);
1395   this->GetRenderer()->ResetCamera();
1396
1397   //this is just a mapping between the labeling of the orientations presented to the user and
1398   //the one used by vtk
1399   SetSliceOrientation(2-(orientation%3));
1400   ResetCamera();
1401 }
1402 //----------------------------------------------------------------------------
1403
1404
1405 //----------------------------------------------------------------------------
1406 void vvSlicer::ResetCamera()
1407
1408   this->GetRenderer()->ResetCamera();
1409 }
1410 //----------------------------------------------------------------------------
1411
1412
1413 //----------------------------------------------------------------------------
1414 void vvSlicer::SetDisplayMode(bool i)
1415
1416         this->GetRenderer()->SetDraw(i);
1417         if (i) UpdateDisplayExtent();
1418 }
1419 //----------------------------------------------------------------------------
1420
1421
1422 //----------------------------------------------------------------------------
1423 void vvSlicer::FlipHorizontalView()
1424
1425   vtkCamera *cam = this->Renderer ? this->Renderer->GetActiveCamera() : NULL;
1426   if (cam) {
1427     double *position = cam->GetPosition();
1428     double factor[3] = {1, 1, 1};
1429     factor[this->SliceOrientation] = -1;
1430     cam->SetPosition(factor[0]*position[0],factor[1]*position[1],factor[2]*position[2]);
1431     
1432 /*    switch (this->SliceOrientation) {
1433     case vtkImageViewer2::SLICE_ORIENTATION_XY:
1434       cam->SetPosition(position[0],position[1],-position[2]);
1435       break;
1436
1437     case vtkImageViewer2::SLICE_ORIENTATION_XZ:
1438       cam->SetPosition(position[0],-position[1],position[2]);
1439       break;
1440
1441     case vtkImageViewer2::SLICE_ORIENTATION_YZ:
1442       cam->SetPosition(-position[0],position[1],position[2]);
1443       break;
1444     }*/
1445
1446     this->Renderer->ResetCameraClippingRange();
1447     this->UpdateDisplayExtent();
1448   }
1449 }
1450 //----------------------------------------------------------------------------
1451
1452
1453 //----------------------------------------------------------------------------
1454 void vvSlicer::FlipVerticalView()
1455
1456   vtkCamera *cam = this->Renderer ? this->Renderer->GetActiveCamera() : NULL;
1457   if (cam) {
1458     FlipHorizontalView();
1459     double *viewup = cam->GetViewUp();
1460     cam->SetViewUp(-viewup[0],-viewup[1],-viewup[2]);
1461     this->UpdateDisplayExtent();
1462   }
1463 }
1464 //----------------------------------------------------------------------------
1465
1466
1467 //----------------------------------------------------------------------------
1468 void vvSlicer::SetColorWindow(double window)
1469
1470   vtkLookupTable* LUT = static_cast<vtkLookupTable*>(this->GetWindowLevel()->GetLookupTable());
1471   if ( LUT ) {
1472     double level = this->GetWindowLevel()->GetLevel();
1473     LUT->SetTableRange(level-fabs(window)/2,level+fabs(window)/2);
1474     LUT->Build();
1475   }
1476   this->vtkImageViewer2::SetColorWindow(window);
1477 }
1478 //----------------------------------------------------------------------------
1479
1480 //----------------------------------------------------------------------------
1481 void vvSlicer::SetColorLevel(double level)
1482
1483   vtkLookupTable* LUT = static_cast<vtkLookupTable*>(this->GetWindowLevel()->GetLookupTable());
1484   if ( LUT ) {
1485     double window = this->GetWindowLevel()->GetWindow();
1486     LUT->SetTableRange(level-fabs(window)/2,level+fabs(window)/2);
1487     LUT->Build();
1488   }
1489   this->vtkImageViewer2::SetColorLevel(level);
1490 }
1491 //----------------------------------------------------------------------------
1492
1493 //----------------------------------------------------------------------------
1494 double vvSlicer::GetOverlayColorWindow()
1495
1496   if(mOverlayMapper)
1497     return mOverlayMapper->GetWindow();
1498   else
1499     return 0.;
1500 }
1501 //----------------------------------------------------------------------------
1502
1503 //----------------------------------------------------------------------------
1504 double vvSlicer::GetOverlayColorLevel()
1505
1506   if(mOverlayMapper)
1507     return mOverlayMapper->GetLevel();
1508   else
1509     return 0.;
1510 }
1511 //----------------------------------------------------------------------------
1512
1513 //----------------------------------------------------------------------------
1514 void vvSlicer::SetOverlayColorWindow(double window)
1515
1516   if(mOverlayMapper)
1517     mOverlayMapper->SetWindow(window);
1518 }
1519 //----------------------------------------------------------------------------
1520
1521 //----------------------------------------------------------------------------
1522 void vvSlicer::SetOverlayColorLevel(double level)
1523
1524   if(mOverlayMapper)
1525     mOverlayMapper->SetLevel(level);
1526 }
1527 //----------------------------------------------------------------------------
1528
1529 //----------------------------------------------------------------------------
1530 // Returns the min an the max value in a 20%x20% region around the mouse pointer
1531 void vvSlicer::GetExtremasAroundMousePointer(double & min, double & max, vtkImageData *image, vtkTransform *transform)
1532
1533   //Get mouse pointer position in view coordinates
1534   double corner1[3];
1535   double corner2[3];
1536   for(int i=0; i<3; i++) {
1537     corner1[i] = mCurrent[i];
1538     corner2[i] = mCurrent[i];
1539   }
1540
1541   this->Renderer->WorldToView(corner1[0], corner1[1], corner1[2]);
1542   this->Renderer->WorldToView(corner2[0], corner2[1], corner2[2]);
1543
1544   // In view coordinates, x is the slicer width and y is the slicer height are the in-plane axis
1545   int w, h;
1546   this->Renderer->GetTiledSize(&w, &h);
1547   corner1[0] -= 0.2*h/(double)w;
1548   corner2[0] += 0.2*h/(double)w;
1549   corner1[1] -= 0.2;
1550   corner2[1] += 0.2;
1551   this->Renderer->ViewToWorld(corner1[0], corner1[1], corner1[2]);
1552   this->Renderer->ViewToWorld(corner2[0], corner2[1], corner2[2]);
1553
1554   //Convert to image pixel coordinates (rounded)
1555   transform->TransformPoint(corner1, corner1);
1556   transform->TransformPoint(corner2, corner2);
1557   int iLocalExtents[6];
1558   for(int i=0; i<3; i++) {
1559     corner1[i] = (corner1[i] - image->GetOrigin()[i])/image->GetSpacing()[i];
1560     corner2[i] = (corner2[i] - image->GetOrigin()[i])/image->GetSpacing()[i];
1561
1562     iLocalExtents[i*2  ] = lrint(corner1[i]);
1563     iLocalExtents[i*2+1] = lrint(corner2[i]);
1564
1565     if(iLocalExtents[i*2  ]>iLocalExtents[i*2+1])
1566       std::swap(iLocalExtents[i*2], iLocalExtents[i*2+1]);
1567
1568 #if VTK_MAJOR_VERSION > 5
1569     for(int j=0;j<2; j++) {
1570       if(iLocalExtents[i*2+j]< mImageReslice->GetInputInformation()->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT())[2*i])
1571         iLocalExtents[i*2+j] = mImageReslice->GetInputInformation()->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT())[2*i];
1572
1573       if(iLocalExtents[i*2+j]> mImageReslice->GetInputInformation()->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT())[2*i+1])
1574         iLocalExtents[i*2+j] = mImageReslice->GetInputInformation()->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT())[2*i+1];
1575     }
1576 #endif
1577   }
1578
1579   vtkSmartPointer<vtkExtractVOI> voiFilter = vtkSmartPointer<vtkExtractVOI>::New();
1580 #if VTK_MAJOR_VERSION <= 5
1581   voiFilter->SetInput(image);
1582 #else
1583   voiFilter->SetInputData(image);
1584 #endif
1585   voiFilter->SetVOI(iLocalExtents);
1586   voiFilter->Update();
1587   if (!voiFilter->GetOutput()->GetNumberOfPoints()) {
1588     min = 0;
1589     max = 0;
1590     return;
1591   }
1592
1593   vtkSmartPointer<vtkImageAccumulate> accFilter = vtkSmartPointer<vtkImageAccumulate>::New();
1594 #if VTK_MAJOR_VERSION <= 5
1595   accFilter->SetInput(voiFilter->GetOutput());
1596 #else
1597   accFilter->SetInputConnection(voiFilter->GetOutputPort(0));
1598 #endif
1599   accFilter->Update();
1600
1601   min = *(accFilter->GetMin());
1602   max = *(accFilter->GetMax());
1603 }
1604 //----------------------------------------------------------------------------
1605
1606 //----------------------------------------------------------------------------
1607 double vvSlicer::GetScalarComponentAsDouble(vtkImageData *image, double X, double Y, double Z, int &ix, int &iy, int &iz, int component)
1608
1609   ix = lrint(X);
1610   iy = lrint(Y);
1611   iz = lrint(Z);
1612 #if VTK_MAJOR_VERSION <= 5
1613   if (ix < image->GetWholeExtent()[0] ||
1614       ix > image->GetWholeExtent()[1] ||
1615       iy < image->GetWholeExtent()[2] ||
1616       iy > image->GetWholeExtent()[3] ||
1617       iz < image->GetWholeExtent()[4] ||
1618       iz > image->GetWholeExtent()[5] )
1619     return std::numeric_limits<double>::quiet_NaN();
1620   image->SetUpdateExtent(ix, ix, iy, iy, iz, iz);
1621   image->Update();
1622 #else
1623   if (ix < image->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[0] ||
1624       ix > image->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[1] ||
1625       iy < image->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[2] ||
1626       iy > image->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[3] ||
1627       iz < image->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[4] ||
1628       iz > image->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[5] )
1629     return std::numeric_limits<double>::quiet_NaN();
1630   //image->SetUpdateExtent(ix, ix, iy, iy, iz, iz);
1631   //image->Update();
1632 #endif
1633
1634   return image->GetScalarComponentAsDouble(ix, iy, iz, component);
1635 }
1636 //----------------------------------------------------------------------------
1637
1638 //----------------------------------------------------------------------------
1639 void vvSlicer::Render()
1640
1641   if (this->mFusion && mFusionActor->GetVisibility() && showFusionLegend) {
1642     legend->SetLookupTable(this->GetFusionMapper()->GetLookupTable());
1643     legend->UseOpacityOn();
1644     legend->SetVisibility(1);
1645   }
1646   else if (this->GetWindowLevel()->GetLookupTable() && !this->mOverlay)  {
1647     legend->SetLookupTable(this->GetWindowLevel()->GetLookupTable());
1648     legend->UseOpacityOff();
1649     legend->SetVisibility(1);
1650   } else legend->SetVisibility(0);
1651
1652   if (ca->GetVisibility()) {
1653
1654     std::stringstream worldPos(" ");
1655     double pt[3];
1656     mConcatenatedTransform->TransformPoint(mCurrent, pt);
1657     double X = (pt[0] - mImage->GetVTKImages()[mCurrentTSlice]->GetOrigin()[0])/mImage->GetVTKImages()[mCurrentTSlice]->GetSpacing()[0];
1658     double Y = (pt[1] - mImage->GetVTKImages()[mCurrentTSlice]->GetOrigin()[1])/mImage->GetVTKImages()[mCurrentTSlice]->GetSpacing()[1];
1659     double Z = (pt[2] - mImage->GetVTKImages()[mCurrentTSlice]->GetOrigin()[2])/mImage->GetVTKImages()[mCurrentTSlice]->GetSpacing()[2];
1660 #if VTK_MAJOR_VERSION <= 5
1661     if (X >= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[0]-0.5 &&
1662         X <= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[1]+0.5 &&
1663         Y >= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[2]-0.5 &&
1664         Y <= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[3]+0.5 &&
1665         Z >= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[4]-0.5 &&
1666         Z <= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[5]+0.5) {
1667
1668       
1669       int ix, iy, iz;
1670       double value = this->GetScalarComponentAsDouble(mImage->GetVTKImages()[mCurrentTSlice], X, Y, Z, ix, iy, iz);
1671
1672       if(ImageActor->GetVisibility())
1673         worldPos << "data value : " << value << std::endl;
1674
1675       worldPos << "mm : " << lrint(mCurrentBeforeSlicingTransform[0]) << ' '
1676                           << lrint(mCurrentBeforeSlicingTransform[1]) << ' '
1677                           << lrint(mCurrentBeforeSlicingTransform[2]) << ' '
1678                           << mCurrentTSlice
1679                           << std::endl;
1680       worldPos << "pixel : " << ix << ' '
1681                              << iy << ' '
1682                              << iz << ' '
1683                              << mCurrentTSlice
1684                              << std::endl;
1685     }
1686 #else
1687     if (X >= mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[0]-0.5 &&
1688         X <= mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[1]+0.5 &&
1689         Y >= mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[2]-0.5 &&
1690         Y <= mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[3]+0.5 &&
1691         Z >= mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[4]-0.5 &&
1692         Z <= mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[5]+0.5) {
1693
1694       int ix, iy, iz;
1695       double value = this->GetScalarComponentAsDouble(mImage->GetVTKImages()[mCurrentTSlice], X, Y, Z, ix, iy, iz);
1696
1697       if(ImageActor->GetVisibility())
1698         worldPos << "data value : " << value << std::endl;
1699
1700       worldPos << "mm : " << lrint(mCurrentBeforeSlicingTransform[0]) << ' '
1701                           << lrint(mCurrentBeforeSlicingTransform[1]) << ' '
1702                           << lrint(mCurrentBeforeSlicingTransform[2]) << ' '
1703                           << mCurrentTSlice
1704                           << std::endl;
1705       worldPos << "pixel : " << ix << ' '
1706                              << iy << ' '
1707                              << iz << ' '
1708                              << mCurrentTSlice
1709                              << std::endl;
1710     
1711     }
1712 #endif
1713     ca->SetText(1,worldPos.str().c_str());
1714
1715     std::stringstream slicePos;
1716     slicePos << "Slice: " << this->GetSlice();
1717     ca->SetText(2, slicePos.str().c_str());
1718   }
1719
1720   if (pdmA->GetVisibility()) {
1721     double x = mCursor[0];
1722     double y = mCursor[1];
1723     double z = mCursor[2];
1724     double xCursor = (x - this->GetInput()->GetOrigin()[0])/this->GetInput()->GetSpacing()[0];
1725     double yCursor = (y - this->GetInput()->GetOrigin()[1])/this->GetInput()->GetSpacing()[1];
1726     double zCursor = (z - this->GetInput()->GetOrigin()[2])/this->GetInput()->GetSpacing()[2];
1727 #if VTK_MAJOR_VERSION <= 5    
1728     if (xCursor >= this->GetImageActor()->GetDisplayExtent()[0]-0.5 &&
1729         xCursor < this->GetImageActor()->GetDisplayExtent()[1]+0.5 &&
1730         yCursor >= this->GetImageActor()->GetDisplayExtent()[2]-0.5 &&
1731         yCursor < this->GetImageActor()->GetDisplayExtent()[3]+0.5 &&
1732         zCursor >= this->GetImageActor()->GetDisplayExtent()[4]-0.5 &&
1733         zCursor < this->GetImageActor()->GetDisplayExtent()[5]+0.5 ) {
1734       vtkRenderer * renderer = this->Renderer;
1735
1736       renderer->WorldToView(x,y,z);
1737       renderer->ViewToNormalizedViewport(x,y,z);
1738       renderer->NormalizedViewportToViewport(x,y);
1739       renderer->ViewportToNormalizedDisplay(x,y);
1740       renderer->NormalizedDisplayToDisplay(x,y);
1741       crossCursor->SetFocalPoint(x,y,z);
1742     } else
1743       crossCursor->SetFocalPoint(-1,-1,z);
1744     crossCursor->Update();
1745   }
1746 #else
1747     vtkSmartPointer<vtkOpenGLImageSliceMapper> mapperOpenGL= vtkSmartPointer<vtkOpenGLImageSliceMapper>::New();
1748     try {
1749         mapperOpenGL = dynamic_cast<vtkOpenGLImageSliceMapper*>(GetImageActor()->GetMapper());
1750     } catch (const std::bad_cast& e) {
1751                 std::cerr << e.what() << std::endl;
1752                 std::cerr << "Conversion error" << std::endl;
1753                 return;
1754         }
1755
1756     if (xCursor >= mapperOpenGL->GetCroppingRegion()[0]-0.5 &&
1757         xCursor < mapperOpenGL->GetCroppingRegion()[1]+0.5 &&
1758         yCursor >= mapperOpenGL->GetCroppingRegion()[2]-0.5 &&
1759         yCursor < mapperOpenGL->GetCroppingRegion()[3]+0.5 &&
1760         zCursor >= mapperOpenGL->GetCroppingRegion()[4]-0.5 &&
1761         zCursor < mapperOpenGL->GetCroppingRegion()[5]+0.5 ) {
1762       vtkRenderer * renderer = this->Renderer;
1763
1764       renderer->WorldToView(x,y,z);
1765       renderer->ViewToNormalizedViewport(x,y,z);
1766       renderer->NormalizedViewportToViewport(x,y);
1767       renderer->ViewportToNormalizedDisplay(x,y);
1768       renderer->NormalizedDisplayToDisplay(x,y);
1769       crossCursor->SetFocalPoint(x,y,z);
1770     } else
1771       crossCursor->SetFocalPoint(-1,-1,z);
1772     crossCursor->Update();
1773   }
1774 #endif
1775
1776   if (mOverlay && mOverlayActor->GetVisibility()) {
1777     if(mLinkOverlayWindowLevel) {
1778       mOverlayMapper->SetWindow(this->GetColorWindow());
1779       mOverlayMapper->SetLevel(this->GetColorLevel());
1780     }
1781 #if VTK_MAJOR_VERSION <= 5
1782     mOverlayMapper->GetOutput()->SetUpdateExtent(mOverlayActor->GetDisplayExtent());
1783 #else
1784     mOverlayMapper->SetUpdateExtent(mOverlayActor->GetDisplayExtent());
1785 #endif
1786     mOverlayMapper->Update();
1787   }
1788   if (mFusion && mFusionActor->GetVisibility()) {
1789 #if VTK_MAJOR_VERSION <= 5
1790     mFusionMapper->GetOutput()->SetUpdateExtent(mFusionActor->GetDisplayExtent());
1791 #else
1792     mFusionMapper->SetUpdateExtent(mFusionActor->GetDisplayExtent());
1793 #endif
1794     mFusionMapper->Update();
1795   }
1796   if (mLandMapper) {
1797     RemoveLandmarks();
1798     DisplayLandmarks();
1799   }
1800
1801     this->GetRenderWindow()->Render();
1802 }
1803 //----------------------------------------------------------------------------
1804
1805
1806 //----------------------------------------------------------------------------
1807 void vvSlicer::UpdateCursorPosition()
1808
1809   pdmA->SetVisibility(true);
1810   mCursor[0] = mCurrent[0];
1811   mCursor[1] = mCurrent[1];
1812   mCursor[2] = mCurrent[2];
1813   mCursor[3] = mCurrentTSlice;
1814 }
1815 //----------------------------------------------------------------------------
1816
1817
1818 //----------------------------------------------------------------------------
1819 void vvSlicer::RemoveLandmarks()
1820
1821   vtkPolyData *pd = static_cast<vtkPolyData*>(mLandmarks->GetOutput());
1822   if (pd->GetPoints()) {
1823
1824     //First remove all captions:
1825     for(unsigned int i=0;i<mLandLabelActors.size();i++) {
1826         this->Renderer->RemoveActor2D(mLandLabelActors[i]);
1827         //allActors2D->Remove (mLandLabelActors[i]);
1828     }
1829     mLandLabelActors.clear();
1830   }
1831 }
1832 //----------------------------------------------------------------------------
1833
1834
1835 //----------------------------------------------------------------------------
1836 void vvSlicer::DisplayLandmarks()
1837
1838
1839   double bounds [6];
1840   for(unsigned int i=0; i<6; i++)
1841     bounds[i] = ImageActor->GetBounds()[i];
1842   bounds[ this->SliceOrientation*2   ] = ImageActor->GetBounds()[ this->SliceOrientation*2  ]-fabs(this->GetInput()->GetSpacing()[this->SliceOrientation]);
1843   bounds[ this->SliceOrientation*2+1 ] = ImageActor->GetBounds()[ this->SliceOrientation*2+1 ]+fabs(this->GetInput()->GetSpacing()[this->SliceOrientation]);
1844   mClipBox->SetBounds(bounds);
1845
1846
1847   vtkPolyData *pd = static_cast<vtkPolyData*>(mLandmarks->GetOutput());
1848   if (pd->GetPoints()) {
1849     this->GetRenderer()->AddActor(mLandActor);
1850     //mLandGlyph->SetRange(0,1);
1851     //mLandGlyph->Modified();
1852     //mLandGlyph->Update();
1853     mClipBox->Modified();
1854     mLandClipper->Update();
1855     mLandMapper->Update();
1856     //Next add the captions to the displayed points
1857     for (vtkIdType id=0; id<mLandClipper->GetOutput()->GetNumberOfPoints(); id++) {
1858           double *position = mLandClipper->GetOutput()->GetPoint(id);
1859       vtkStdString label = static_cast<vtkStringArray*>(mLandClipper->GetOutput()->GetPointData()->GetAbstractArray("labels"))->GetValue(id);
1860       vtkSmartPointer<vtkCaptionActor2D> label_actor = vtkSmartPointer<vtkCaptionActor2D>::New();
1861       label_actor->SetCaption(label);
1862       label_actor->SetAttachmentPoint(position);
1863       label_actor->GetCaptionTextProperty()->SetColor(1,0,0);
1864       label_actor->GetCaptionTextProperty()->SetOrientation(33.333333);
1865       label_actor->GetCaptionTextProperty()->SetFontFamilyToTimes();
1866       label_actor->GetCaptionTextProperty()->SetBold(0);
1867       label_actor->GetCaptionTextProperty()->SetFontSize(6);
1868       label_actor->BorderOff();
1869       label_actor->LeaderOff();
1870       label_actor->ThreeDimensionalLeaderOff();
1871       mLandLabelActors.push_back(label_actor);
1872       this->Renderer->AddActor2D(mLandLabelActors[id]);
1873      }
1874   }
1875
1876 }
1877 //----------------------------------------------------------------------------
1878
1879
1880 //----------------------------------------------------------------------------
1881 void vvSlicer::SetSlice(int slice)
1882
1883   int *range = this->GetSliceRange();
1884   if (range) {
1885     if (slice < range[0]) {
1886       slice = range[0];
1887     } else if (slice > range[1]) {
1888       slice = range[1];
1889     }
1890   }
1891
1892   if (this->Slice == slice) {
1893     return;
1894   }
1895
1896   this->Slice = slice;
1897   SetContourSlice();
1898   this->Modified();
1899   this->UpdateDisplayExtent();
1900
1901   // Seems to work without this line
1902   //this->Render();
1903 }
1904 //----------------------------------------------------------------------------
1905
1906 //----------------------------------------------------------------------------
1907 int vvSlicer::GetTMax() 
1908
1909   int tmax = (int)mImage->GetVTKImages().size() - 1;
1910   if(mOverlay)
1911     tmax = std::max(tmax, (int)mOverlay->GetVTKImages().size()-1);
1912   return tmax;
1913 }
1914 //----------------------------------------------------------------------------
1915
1916 //----------------------------------------------------------------------------
1917 void vvSlicer::SetContourSlice()
1918
1919   if (mSurfaceCutActors.size() > 0)
1920     for (std::vector<vvMeshActor*>::iterator i=mSurfaceCutActors.begin();
1921          i!=mSurfaceCutActors.end(); i++) {
1922          
1923       (*i)->SetSlicingOrientation(this->SliceOrientation);
1924       (*i)->SetCutSlice((this->Slice)*this->GetImage()->GetSpacing()[this->SliceOrientation]+
1925                         this->GetImage()->GetOrigin()[this->SliceOrientation]);
1926     }
1927 }
1928 //----------------------------------------------------------------------------
1929
1930
1931 //----------------------------------------------------------------------------
1932 void vvSlicer::ForceUpdateDisplayExtent()
1933
1934   this->UpdateDisplayExtent();
1935 }
1936 //----------------------------------------------------------------------------
1937
1938
1939 //----------------------------------------------------------------------------
1940 int* vvSlicer::GetDisplayExtent()
1941
1942   return this->GetImageActor()->GetDisplayExtent();
1943 }
1944 //----------------------------------------------------------------------------
1945
1946
1947 //----------------------------------------------------------------------------
1948 void vvSlicer::PrintSelf(ostream& os, vtkIndent indent)
1949
1950   this->Superclass::PrintSelf(os, indent);
1951 }
1952 //----------------------------------------------------------------------------
1953
1954
1955 //----------------------------------------------------------------------------
1956 void vvSlicer::SetVFColor(double r, double g, double b)
1957
1958   double mVFColorHSV[3];
1959   mVFColor[0] = r;
1960   mVFColor[1] = g;
1961   mVFColor[2] = b;
1962
1963   vtkMath::RGBToHSV(mVFColor, mVFColorHSV);
1964   mVFColorLUT->SetHueRange(mVFColorHSV[0], mVFColorHSV[0]);
1965   mVFColorLUT->SetSaturationRange(mVFColorHSV[1],mVFColorHSV[1]);
1966   mVFColorLUT->SetValueRange(mVFColorHSV[2], mVFColorHSV[2]);
1967
1968   this->Render();
1969 }  
1970 //----------------------------------------------------------------------------
1971
1972
1973 //----------------------------------------------------------------------------
1974 void vvSlicer::SetRegisterExtent(int ext[6])
1975
1976     copyExtent(ext, mRegisterExtent);
1977 }
1978 //----------------------------------------------------------------------------
1979
1980
1981 //----------------------------------------------------------------------------
1982 void vvSlicer::GetRegisterExtent(int ext[6])
1983
1984     copyExtent(mRegisterExtent, ext);
1985 }
1986 //----------------------------------------------------------------------------
1987