]> Creatis software - bbtk.git/blob - packages/wxvtk/src/wxvtkImageViewer2.cxx
1.6
[bbtk.git] / packages / wxvtk / src / wxvtkImageViewer2.cxx
1 /*=========================================================================
2
3   Program:   Visualization Toolkit
4   Module:    $RCSfile: wxvtkImageViewer2.cxx,v $
5
6   Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7   All rights reserved.
8   See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9
10      This software is distributed WITHOUT ANY WARRANTY; without even
11      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12      PURPOSE.  See the above copyright notice for more information.
13
14 =========================================================================*/
15 #include "wxvtkImageViewer2.h"
16
17 #include "vtkCamera.h"
18 #include "vtkCommand.h"
19 #include "vtkImageActor.h"
20 #include "vtkImageData.h"
21 #include "vtkImageData.h"
22 #include "vtkImageMapToWindowLevelColors.h"
23 #include "vtkInteractorStyleImage.h"
24 #include "vtkObjectFactory.h"
25 #include "vtkRenderWindow.h"
26 #include "vtkRenderWindowInteractor.h"
27 #include "vtkRenderer.h"
28
29 vtkCxxRevisionMacro(wxvtkImageViewer2, "$Revision: 1.3 $");
30 vtkStandardNewMacro(wxvtkImageViewer2);
31
32 //----------------------------------------------------------------------------
33 wxvtkImageViewer2::wxvtkImageViewer2()
34 {
35   this->RenderWindow    = NULL;
36   this->Renderer        = NULL;
37   this->ImageActor      = vtkImageActor::New();
38   this->WindowLevel     = vtkImageMapToWindowLevelColors::New();
39   this->Interactor      = NULL;
40   this->InteractorStyle = NULL;
41
42   this->Slice = 0;
43   this->FirstRender = 1;
44   this->SliceOrientation = wxvtkImageViewer2::SLICE_ORIENTATION_XY;
45
46   // Setup the pipeline
47
48   vtkRenderWindow *renwin = vtkRenderWindow::New();
49   this->SetRenderWindow(renwin);
50   renwin->Delete();
51
52   vtkRenderer *ren = vtkRenderer::New();
53   this->SetRenderer(ren);
54   ren->Delete();
55
56   this->InstallPipeline();
57 }
58
59 //----------------------------------------------------------------------------
60 wxvtkImageViewer2::~wxvtkImageViewer2()
61 {
62   if (this->WindowLevel)
63     {
64     this->WindowLevel->Delete();
65     this->WindowLevel = NULL;
66     }
67
68   if (this->ImageActor)
69     {
70     this->ImageActor->Delete();
71     this->ImageActor = NULL;
72     }
73
74   if (this->Renderer)
75     {
76     this->Renderer->Delete();
77     this->Renderer = NULL;
78     }
79
80   if (this->RenderWindow)
81     {
82     this->RenderWindow->Delete();
83     this->RenderWindow = NULL;
84     }
85
86   if (this->Interactor)
87     {
88     this->Interactor->Delete();
89     this->Interactor = NULL;
90     }
91
92   if (this->InteractorStyle)
93     {
94     this->InteractorStyle->Delete();
95     this->InteractorStyle = NULL;
96     }
97 }
98
99 //----------------------------------------------------------------------------
100 void wxvtkImageViewer2::SetupInteractor(vtkRenderWindowInteractor *arg)
101 {
102   if (this->Interactor == arg)
103     {
104     return;
105     }
106
107   this->UnInstallPipeline();
108
109   if (this->Interactor)
110     {
111     this->Interactor->UnRegister(this);
112     }
113     
114   this->Interactor = arg;
115   
116   if (this->Interactor)
117     {
118     this->Interactor->Register(this);
119     }
120
121   this->InstallPipeline();
122
123   if (this->Renderer)
124     {
125     this->Renderer->GetActiveCamera()->ParallelProjectionOn();
126     }
127 }
128
129 //----------------------------------------------------------------------------
130 void wxvtkImageViewer2::SetRenderWindow(vtkRenderWindow *arg)
131 {
132   if (this->RenderWindow == arg)
133     {
134     return;
135     }
136
137   this->UnInstallPipeline();
138
139   if (this->RenderWindow)
140     {
141     this->RenderWindow->UnRegister(this);
142     }
143     
144   this->RenderWindow = arg;
145   
146   if (this->RenderWindow)
147     {
148     this->RenderWindow->Register(this);
149     }
150
151   this->InstallPipeline();
152 }
153
154 //----------------------------------------------------------------------------
155 void wxvtkImageViewer2::SetRenderer(vtkRenderer *arg)
156 {
157   if (this->Renderer == arg)
158     {
159     return;
160     }
161
162   this->UnInstallPipeline();
163
164   if (this->Renderer)
165     {
166     this->Renderer->UnRegister(this);
167     }
168     
169   this->Renderer = arg;
170   
171   if (this->Renderer)
172     {
173     this->Renderer->Register(this);
174     }
175
176   this->InstallPipeline();
177   this->UpdateOrientation();
178 }
179
180 //----------------------------------------------------------------------------
181 void wxvtkImageViewer2::SetSize(int a,int b) 
182 {
183   this->RenderWindow->SetSize(a, b);
184 }
185
186 //----------------------------------------------------------------------------
187 int* wxvtkImageViewer2::GetSize() 
188 {
189   return this->RenderWindow->GetSize();
190 }
191
192 //----------------------------------------------------------------------------
193 void wxvtkImageViewer2::GetSliceRange(int &min, int &max)
194 {
195   vtkImageData *input = this->GetInput();
196   if (input)
197     {
198     input->UpdateInformation();
199     int *w_ext = input->GetWholeExtent();
200     min = w_ext[this->SliceOrientation * 2];
201     max = w_ext[this->SliceOrientation * 2 + 1];
202     }
203 }
204
205 //----------------------------------------------------------------------------
206 int* wxvtkImageViewer2::GetSliceRange()
207 {
208   vtkImageData *input = this->GetInput();
209   if (input)
210     {
211     input->UpdateInformation();
212     return input->GetWholeExtent() + this->SliceOrientation * 2;
213     }
214   return NULL;
215 }
216
217 //----------------------------------------------------------------------------
218 int wxvtkImageViewer2::GetSliceMin() 
219 {
220   int *range = this->GetSliceRange();
221   if (range)
222     {
223     return range[0];
224     }
225   return 0;
226 }
227
228 //----------------------------------------------------------------------------
229 int wxvtkImageViewer2::GetSliceMax() 
230 {
231   int *range = this->GetSliceRange();
232   if (range)
233     {
234     return range[1];
235     }
236   return 0;
237 }
238
239 //----------------------------------------------------------------------------
240 void wxvtkImageViewer2::SetSlice(int slice)
241 {
242   int *range = this->GetSliceRange();
243   if (range)
244     {
245     if (slice < range[0])
246       {
247       slice = range[0];
248       }
249     else if (slice > range[1])
250       {
251       slice = range[1];
252       }
253     }
254
255   if (this->Slice == slice)
256     {
257     return;
258     }
259
260   this->Slice = slice;
261   this->Modified();
262
263   this->UpdateDisplayExtent();
264   this->Render();
265 }
266
267 //----------------------------------------------------------------------------
268 void wxvtkImageViewer2::SetSliceOrientation(int orientation)
269 {
270   if (orientation < wxvtkImageViewer2::SLICE_ORIENTATION_YZ ||
271       orientation > wxvtkImageViewer2::SLICE_ORIENTATION_XY)
272     {
273     vtkErrorMacro("Error - invalid slice orientation " << orientation);
274     return;
275     }
276   
277   if (this->SliceOrientation == orientation)
278     {
279     return;
280     }
281
282   this->SliceOrientation = orientation;
283
284   // Update the viewer 
285
286   int *range = this->GetSliceRange();
287   if (range)
288     {
289     this->Slice = static_cast<int>((range[0] + range[1]) * 0.5);
290     }
291
292   this->UpdateOrientation();
293   this->UpdateDisplayExtent();
294
295   if (this->Renderer && this->GetInput())
296     {
297     double scale = this->Renderer->GetActiveCamera()->GetParallelScale();
298     this->Renderer->ResetCamera();
299     this->Renderer->GetActiveCamera()->SetParallelScale(scale);
300     }
301
302   this->Render();
303 }
304
305 //----------------------------------------------------------------------------
306 void wxvtkImageViewer2::UpdateOrientation()
307 {
308   // Set the camera position
309
310   vtkCamera *cam = this->Renderer ? this->Renderer->GetActiveCamera() : NULL;
311   if (cam)
312     {
313     switch (this->SliceOrientation)
314       {
315       case wxvtkImageViewer2::SLICE_ORIENTATION_XY:
316         cam->SetFocalPoint(0,0,0);
317         cam->SetPosition(0,0,1); // -1 if medical ?
318         cam->SetViewUp(0,1,0);
319         break;
320         
321       case wxvtkImageViewer2::SLICE_ORIENTATION_XZ:
322         cam->SetFocalPoint(0,0,0);
323         cam->SetPosition(0,-1,0); // 1 if medical ?
324         cam->SetViewUp(0,0,1);
325         break;
326         
327       case wxvtkImageViewer2::SLICE_ORIENTATION_YZ:
328         cam->SetFocalPoint(0,0,0);
329         cam->SetPosition(1,0,0); // -1 if medical ?
330         cam->SetViewUp(0,0,1);
331         break;
332       }
333     }
334 }
335
336 //----------------------------------------------------------------------------
337 void wxvtkImageViewer2::UpdateDisplayExtent()
338 {
339   vtkImageData *input = this->GetInput();
340   if (!input || !this->ImageActor)
341     {
342     return;
343     }
344
345   //  std::cout << "--- wxvtkImageViewer2::UpdateDisplayExtent()"<<std::endl;
346   input->UpdateInformation();
347   int *w_ext = input->GetWholeExtent();
348
349   //    std::cout << "ext = "
350   //    <<w_ext[0]<<" - "<<w_ext[1]<<" ; "
351   //            <<w_ext[2]<<" - "<<w_ext[3]<<" ; "
352   //            <<w_ext[4]<<" - "<<w_ext[5]
353   //            <<std::endl;
354       // Is the slice in range ? If not, fix it
355
356   int slice_min = w_ext[this->SliceOrientation * 2];
357   int slice_max = w_ext[this->SliceOrientation * 2 + 1];
358   if (this->Slice < slice_min || this->Slice > slice_max)
359     {
360     this->Slice = static_cast<int>((slice_min + slice_max) * 0.5);
361     }
362
363   // Set the image actor
364
365   switch (this->SliceOrientation)
366     {
367     case wxvtkImageViewer2::SLICE_ORIENTATION_XY:
368       this->ImageActor->SetDisplayExtent(
369         w_ext[0], w_ext[1], w_ext[2], w_ext[3], this->Slice, this->Slice);
370       break;
371
372     case wxvtkImageViewer2::SLICE_ORIENTATION_XZ:
373       this->ImageActor->SetDisplayExtent(
374         w_ext[0], w_ext[1], this->Slice, this->Slice, w_ext[4], w_ext[5]);
375       break;
376
377     case wxvtkImageViewer2::SLICE_ORIENTATION_YZ:
378       this->ImageActor->SetDisplayExtent(
379         this->Slice, this->Slice, w_ext[2], w_ext[3], w_ext[4], w_ext[5]);
380       break;
381     }
382
383   // Figure out the correct clipping range
384
385   if (this->Renderer)
386     {
387     if (this->InteractorStyle && 
388         this->InteractorStyle->GetAutoAdjustCameraClippingRange())
389       {
390       this->Renderer->ResetCameraClippingRange();
391       }
392     else
393       {
394       vtkCamera *cam = this->Renderer->GetActiveCamera();
395       if (cam)
396         {
397         double bounds[6];
398         this->ImageActor->GetBounds(bounds);
399         double spos = bounds[this->SliceOrientation * 2];
400         double cpos = cam->GetPosition()[this->SliceOrientation];
401         double range = fabs(spos - cpos);
402         double *spacing = input->GetSpacing();
403         double avg_spacing = 
404           //(spacing[0] + spacing[1] + spacing[2]) / 3.0;
405           spacing[2]; // JPR??
406         cam->SetClippingRange(
407           range - avg_spacing * 3.0, range + avg_spacing * 3.0);
408         }
409       }
410     }
411 }
412
413 //----------------------------------------------------------------------------
414 void wxvtkImageViewer2::SetPosition(int a,int b) 
415 {
416   this->RenderWindow->SetPosition(a, b);
417 }
418
419 //----------------------------------------------------------------------------
420 int* wxvtkImageViewer2::GetPosition() 
421 {
422   return this->RenderWindow->GetPosition();
423 }
424
425 //----------------------------------------------------------------------------
426 void wxvtkImageViewer2::SetDisplayId(void *a) 
427 {
428   this->RenderWindow->SetDisplayId(a);
429 }
430
431 //----------------------------------------------------------------------------
432 void wxvtkImageViewer2::SetWindowId(void *a) 
433 {
434   this->RenderWindow->SetWindowId(a);
435 }
436
437 //----------------------------------------------------------------------------
438 void wxvtkImageViewer2::SetParentId(void *a) 
439 {
440   this->RenderWindow->SetParentId(a);
441 }
442
443 //----------------------------------------------------------------------------
444 double wxvtkImageViewer2::GetColorWindow() 
445 {
446   return this->WindowLevel->GetWindow();
447 }
448
449 //----------------------------------------------------------------------------
450 double wxvtkImageViewer2::GetColorLevel() 
451 {
452   return this->WindowLevel->GetLevel();
453 }
454
455 //----------------------------------------------------------------------------
456 void wxvtkImageViewer2::SetColorWindow(double s) 
457 {
458   this->WindowLevel->SetWindow(s);
459 }
460
461 //----------------------------------------------------------------------------
462 void wxvtkImageViewer2::SetColorLevel(double s) 
463 {
464   this->WindowLevel->SetLevel(s);
465 }
466
467 //----------------------------------------------------------------------------
468 class wxvtkImageViewer2Callback : public vtkCommand
469 {
470 public:
471   static wxvtkImageViewer2Callback *New() { return new wxvtkImageViewer2Callback; }
472   
473   void Execute(vtkObject *caller, 
474                unsigned long event, 
475                void *vtkNotUsed(callData))
476     {
477       if (this->IV->GetInput() == NULL)
478         {
479         return;
480         }
481
482       // Reset
483
484       if (event == vtkCommand::ResetWindowLevelEvent)
485         {
486         this->IV->GetInput()->UpdateInformation();
487         this->IV->GetInput()->SetUpdateExtent
488           (this->IV->GetInput()->GetWholeExtent());
489         this->IV->GetInput()->Update();
490         double *range = this->IV->GetInput()->GetScalarRange();
491         this->IV->SetColorWindow(range[1] - range[0]);
492         this->IV->SetColorLevel(0.5 * (range[1] + range[0]));
493         this->IV->Render();
494         return;
495         }
496
497       // Start
498
499       if (event == vtkCommand::StartWindowLevelEvent)
500         {
501         this->InitialWindow = this->IV->GetColorWindow();
502         this->InitialLevel = this->IV->GetColorLevel();
503         return;
504         }
505       
506       // Adjust the window level here
507
508       vtkInteractorStyleImage *isi = 
509         static_cast<vtkInteractorStyleImage *>(caller);
510
511       int *size = this->IV->GetRenderWindow()->GetSize();
512       double window = this->InitialWindow;
513       double level = this->InitialLevel;
514       
515       // Compute normalized delta
516
517       double dx = 4.0 * 
518         (isi->GetWindowLevelCurrentPosition()[0] - 
519          isi->GetWindowLevelStartPosition()[0]) / size[0];
520       double dy = 4.0 * 
521         (isi->GetWindowLevelStartPosition()[1] - 
522          isi->GetWindowLevelCurrentPosition()[1]) / size[1];
523       
524       // Scale by current values
525
526       if (fabs(window) > 0.01)
527         {
528         dx = dx * window;
529         }
530       else
531         {
532         dx = dx * (window < 0 ? -0.01 : 0.01);
533         }
534       if (fabs(level) > 0.01)
535         {
536         dy = dy * level;
537         }
538       else
539         {
540         dy = dy * (level < 0 ? -0.01 : 0.01);
541         }
542       
543       // Abs so that direction does not flip
544
545       if (window < 0.0) 
546         {
547         dx = -1*dx;
548         }
549       if (level < 0.0) 
550         {
551         dy = -1*dy;
552         }
553       
554       // Compute new window level
555
556       double newWindow = dx + window;
557       double newLevel;
558       newLevel = level - dy;
559       
560       // Stay away from zero and really
561
562       if (fabs(newWindow) < 0.01)
563         {
564         newWindow = 0.01*(newWindow < 0 ? -1 : 1);
565         }
566       if (fabs(newLevel) < 0.01)
567         {
568         newLevel = 0.01*(newLevel < 0 ? -1 : 1);
569         }
570       
571       this->IV->SetColorWindow(newWindow);
572       this->IV->SetColorLevel(newLevel);
573       this->IV->Render();
574     }
575   
576   wxvtkImageViewer2 *IV;
577   double InitialWindow;
578   double InitialLevel;
579 };
580
581 //----------------------------------------------------------------------------
582 void wxvtkImageViewer2::InstallPipeline()
583 {
584   if (this->RenderWindow && this->Renderer)
585     {
586     this->RenderWindow->AddRenderer(this->Renderer);
587     }
588
589   if (this->Interactor)
590     {
591     if (!this->InteractorStyle)
592       {
593       this->InteractorStyle = vtkInteractorStyleImage::New();
594       wxvtkImageViewer2Callback *cbk = wxvtkImageViewer2Callback::New();
595       cbk->IV = this;
596       this->InteractorStyle->AddObserver(
597         vtkCommand::WindowLevelEvent, cbk);
598       this->InteractorStyle->AddObserver(
599         vtkCommand::StartWindowLevelEvent, cbk);
600       this->InteractorStyle->AddObserver(
601         vtkCommand::ResetWindowLevelEvent, cbk);
602       cbk->Delete();
603       }
604     
605     this->Interactor->SetInteractorStyle(this->InteractorStyle);
606     this->Interactor->SetRenderWindow(this->RenderWindow);
607     }
608
609   if (this->Renderer && this->ImageActor)
610     {
611     this->Renderer->AddViewProp(this->ImageActor);
612     }
613
614   if (this->ImageActor && this->WindowLevel)
615     {
616     this->ImageActor->SetInput(this->WindowLevel->GetOutput());
617     }
618 }
619
620 //----------------------------------------------------------------------------
621 void wxvtkImageViewer2::UnInstallPipeline()
622 {
623   if (this->ImageActor)
624     {
625     this->ImageActor->SetInput(NULL);
626     }
627
628   if (this->Renderer && this->ImageActor)
629     {
630     this->Renderer->RemoveViewProp(this->ImageActor);
631     }
632
633   if (this->RenderWindow && this->Renderer)
634     {
635     this->RenderWindow->RemoveRenderer(this->Renderer);
636     }
637
638   if (this->Interactor)
639     {
640     this->Interactor->SetInteractorStyle(NULL);
641     this->Interactor->SetRenderWindow(NULL);
642     }
643 }
644
645 //----------------------------------------------------------------------------
646 void wxvtkImageViewer2::Render()
647 {
648   if (this->FirstRender)
649     {
650     // Initialize the size if not set yet
651
652     vtkImageData *input = this->GetInput();
653     if (this->RenderWindow->GetSize()[0] == 0 && 
654         input)
655       {
656         
657       input->UpdateInformation();
658       int *w_ext = input->GetWholeExtent();
659       int xs = 0, ys = 0;
660       
661       //        std::cout << "wxvtkImageViewer2::Render ext = "
662       //        <<w_ext[0]<<" - "<<w_ext[1]<<" ; "
663       //                <<w_ext[2]<<" - "<<w_ext[3]<<" ; "
664       //                <<w_ext[4]<<" - "<<w_ext[5]
665       //                <<std::endl;
666       
667       switch (this->SliceOrientation)
668         {
669         case wxvtkImageViewer2::SLICE_ORIENTATION_XY:
670         default:
671           xs = w_ext[1] - w_ext[0] + 1;
672           ys = w_ext[3] - w_ext[2] + 1;
673           //      std::cout << "SLICE_ORIENTATION_XY" << std::endl;
674           break;
675
676         case wxvtkImageViewer2::SLICE_ORIENTATION_XZ:
677           xs = w_ext[1] - w_ext[0] + 1;
678           ys = w_ext[5] - w_ext[4] + 1;
679           //      std::cout << "SLICE_ORIENTATION_XZ" << std::endl;
680           break;
681
682         case wxvtkImageViewer2::SLICE_ORIENTATION_YZ:
683           xs = w_ext[3] - w_ext[2] + 1;
684           ys = w_ext[5] - w_ext[4] + 1;
685           //      std::cout << "SLICE_ORIENTATION_YZ" << std::endl;
686           break;
687         }
688
689       // if it would be smaller than 150 by 100 then limit to 150 by 100
690       this->RenderWindow->SetSize(
691         xs < 150 ? 150 : xs, ys < 100 ? 100 : ys);
692
693       //      std::cout << "wxvtkImageViewer2::Render() : "<<xs<<"-"<<ys<<std::endl;
694       if (this->Renderer)
695         {
696         this->Renderer->ResetCamera();
697         this->Renderer->GetActiveCamera()->SetParallelScale(
698           xs < 150 ? 75 : (xs - 1 ) / 2.0);
699         }
700       this->FirstRender = 0;  
701
702       }
703     }
704   if (this->GetInput())
705     {
706     this->RenderWindow->Render();
707     }
708 }
709
710 //----------------------------------------------------------------------------
711 const char* wxvtkImageViewer2::GetWindowName() 
712 {
713   return this->RenderWindow->GetWindowName();
714 }
715
716 //----------------------------------------------------------------------------
717 void wxvtkImageViewer2::SetOffScreenRendering(int i)
718 {
719   this->RenderWindow->SetOffScreenRendering(i);
720 }
721
722 //----------------------------------------------------------------------------
723 int wxvtkImageViewer2::GetOffScreenRendering()
724 {
725   return this->RenderWindow->GetOffScreenRendering();
726 }
727
728 //----------------------------------------------------------------------------
729 void wxvtkImageViewer2::SetInput(vtkImageData *in) 
730 {
731   //  std::cout << "### wxvtkImageViewer2::SetInput"<<std::endl;
732   this->WindowLevel->SetInput(in);
733   this->UpdateDisplayExtent();
734   // LG 03/12/08
735   //  FirstRender = 1;
736 }
737 //----------------------------------------------------------------------------
738 vtkImageData* wxvtkImageViewer2::GetInput()
739
740   return vtkImageData::SafeDownCast(this->WindowLevel->GetInput());
741 }
742
743 //----------------------------------------------------------------------------
744 void wxvtkImageViewer2::SetInputConnection(vtkAlgorithmOutput* input) 
745 {
746   this->WindowLevel->SetInputConnection(input);
747   this->UpdateDisplayExtent();
748 }
749
750 //----------------------------------------------------------------------------
751 #ifndef VTK_LEGACY_REMOVE
752 int wxvtkImageViewer2::GetWholeZMin()
753 {
754   VTK_LEGACY_REPLACED_BODY(wxvtkImageViewer2::GetWholeZMin, "VTK 5.0",
755                            wxvtkImageViewer2::GetSliceMin);
756   return this->GetSliceMin();
757 }
758 int wxvtkImageViewer2::GetWholeZMax()
759 {
760   VTK_LEGACY_REPLACED_BODY(wxvtkImageViewer2::GetWholeZMax, "VTK 5.0",
761                            wxvtkImageViewer2::GetSliceMax);
762   return this->GetSliceMax();
763 }
764 int wxvtkImageViewer2::GetZSlice()
765 {
766   VTK_LEGACY_REPLACED_BODY(wxvtkImageViewer2::GetZSlice, "VTK 5.0",
767                            wxvtkImageViewer2::GetSlice);
768   return this->GetSlice();
769 }
770 void wxvtkImageViewer2::SetZSlice(int s)
771 {
772   VTK_LEGACY_REPLACED_BODY(wxvtkImageViewer2::SetZSlice, "VTK 5.0",
773                            wxvtkImageViewer2::SetSlice);
774   this->SetSlice(s);
775 }
776 #endif
777
778 //----------------------------------------------------------------------------
779 void wxvtkImageViewer2::PrintSelf(ostream& os, vtkIndent indent)
780 {
781   this->Superclass::PrintSelf(os, indent);
782
783   os << indent << "RenderWindow:\n";
784   this->RenderWindow->PrintSelf(os,indent.GetNextIndent());
785   os << indent << "Renderer:\n";
786   this->Renderer->PrintSelf(os,indent.GetNextIndent());
787   os << indent << "ImageActor:\n";
788   this->ImageActor->PrintSelf(os,indent.GetNextIndent());
789   os << indent << "WindowLevel:\n" << endl;
790   this->WindowLevel->PrintSelf(os,indent.GetNextIndent());
791   os << indent << "Slice: " << this->Slice << endl;
792   os << indent << "SliceOrientation: " << this->SliceOrientation << endl;
793   os << indent << "InteractorStyle: " << endl;
794   if (this->InteractorStyle)
795     {
796     os << "\n";
797     this->InteractorStyle->PrintSelf(os,indent.GetNextIndent());
798     }
799   else
800     {
801     os << "None";
802     }
803 }