*** empty log message ***

[bbtk.git] / packages / wxvtk / src / wxvtkImageViewer2.cxx

diff --git a/packages/wxvtk/src/wxvtkImageViewer2.cxx b/packages/wxvtk/src/wxvtkImageViewer2.cxx
index e0fca3a565c3ee6ebad91f7d4253ac71b9ae7480..533677cc130ffaceecfe62a55c45a7653bdbd26b 100644 (file)
--- a/packages/wxvtk/src/wxvtkImageViewer2.cxx
+++ b/packages/wxvtk/src/wxvtkImageViewer2.cxx
@@ -21,12 +21,12 @@
 #include "vtkImageData.h"
 #include "vtkImageMapToWindowLevelColors.h"
 #include "vtkInteractorStyleImage.h"
-#include "vtkObjectFactory.h"
+#include "vtk.h"
 #include "vtkRenderWindow.h"
 #include "vtkRenderWindowInteractor.h"
 #include "vtkRenderer.h"
 
-vtkCxxRevisionMacro(wxvtkImageViewer2, "$Revision: 1.3 $");
+vtkCxxRevisionMacro(wxvtkImageViewer2, "$Revision: 1.4 $");
 vtkStandardNewMacro(wxvtkImageViewer2);
 
 //----------------------------------------------------------------------------
@@ -110,9 +110,9 @@ void wxvtkImageViewer2::SetupInteractor(vtkRenderWindowInteractor *arg)
     {
     this->Interactor->UnRegister(this);
     }
-    
+
   this->Interactor = arg;
-  
+
   if (this->Interactor)
     {
     this->Interactor->Register(this);
@@ -140,9 +140,9 @@ void wxvtkImageViewer2::SetRenderWindow(vtkRenderWindow *arg)
     {
     this->RenderWindow->UnRegister(this);
     }
-    
+
   this->RenderWindow = arg;
-  
+
   if (this->RenderWindow)
     {
     this->RenderWindow->Register(this);
@@ -165,9 +165,9 @@ void wxvtkImageViewer2::SetRenderer(vtkRenderer *arg)
     {
     this->Renderer->UnRegister(this);
     }
-    
+
   this->Renderer = arg;
-  
+
   if (this->Renderer)
     {
     this->Renderer->Register(this);
@@ -178,13 +178,13 @@ void wxvtkImageViewer2::SetRenderer(vtkRenderer *arg)
 }
 
 //----------------------------------------------------------------------------
-void wxvtkImageViewer2::SetSize(int a,int b) 
+void wxvtkImageViewer2::SetSize(int a,int b)
 {
   this->RenderWindow->SetSize(a, b);
 }
 
 //----------------------------------------------------------------------------
-int* wxvtkImageViewer2::GetSize() 
+int* wxvtkImageViewer2::GetSize()
 {
   return this->RenderWindow->GetSize();
 }
@@ -215,7 +215,7 @@ int* wxvtkImageViewer2::GetSliceRange()
 }
 
 //----------------------------------------------------------------------------
-int wxvtkImageViewer2::GetSliceMin() 
+int wxvtkImageViewer2::GetSliceMin()
 {
   int *range = this->GetSliceRange();
   if (range)
@@ -226,7 +226,7 @@ int wxvtkImageViewer2::GetSliceMin()
 }
 
 //----------------------------------------------------------------------------
-int wxvtkImageViewer2::GetSliceMax() 
+int wxvtkImageViewer2::GetSliceMax()
 {
   int *range = this->GetSliceRange();
   if (range)
@@ -273,7 +273,7 @@ void wxvtkImageViewer2::SetSliceOrientation(int orientation)
     vtkErrorMacro("Error - invalid slice orientation " << orientation);
     return;
     }
-  
+
   if (this->SliceOrientation == orientation)
     {
     return;
@@ -281,7 +281,7 @@ void wxvtkImageViewer2::SetSliceOrientation(int orientation)
 
   this->SliceOrientation = orientation;
 
-  // Update the viewer 
+  // Update the viewer
 
   int *range = this->GetSliceRange();
   if (range)
@@ -317,13 +317,13 @@ void wxvtkImageViewer2::UpdateOrientation()
         cam->SetPosition(0,0,1); // -1 if medical ?
         cam->SetViewUp(0,1,0);
         break;
-        
+
       case wxvtkImageViewer2::SLICE_ORIENTATION_XZ:
         cam->SetFocalPoint(0,0,0);
         cam->SetPosition(0,-1,0); // 1 if medical ?
         cam->SetViewUp(0,0,1);
         break;
-        
+
       case wxvtkImageViewer2::SLICE_ORIENTATION_YZ:
         cam->SetFocalPoint(0,0,0);
         cam->SetPosition(1,0,0); // -1 if medical ?
@@ -384,7 +384,7 @@ void wxvtkImageViewer2::UpdateDisplayExtent()
 
   if (this->Renderer)
     {
-    if (this->InteractorStyle && 
+    if (this->InteractorStyle &&
         this->InteractorStyle->GetAutoAdjustCameraClippingRange())
       {
       this->Renderer->ResetCameraClippingRange();
@@ -400,7 +400,7 @@ void wxvtkImageViewer2::UpdateDisplayExtent()
         double cpos = cam->GetPosition()[this->SliceOrientation];
         double range = fabs(spos - cpos);
         double *spacing = input->GetSpacing();
-        double avg_spacing = 
+        double avg_spacing =
           //(spacing[0] + spacing[1] + spacing[2]) / 3.0;
          spacing[2]; // JPR??
         cam->SetClippingRange(
@@ -411,55 +411,55 @@ void wxvtkImageViewer2::UpdateDisplayExtent()
 }
 
 //----------------------------------------------------------------------------
-void wxvtkImageViewer2::SetPosition(int a,int b) 
+void wxvtkImageViewer2::SetPosition(int a,int b)
 {
   this->RenderWindow->SetPosition(a, b);
 }
 
 //----------------------------------------------------------------------------
-int* wxvtkImageViewer2::GetPosition() 
+int* wxvtkImageViewer2::GetPosition()
 {
   return this->RenderWindow->GetPosition();
 }
 
 //----------------------------------------------------------------------------
-void wxvtkImageViewer2::SetDisplayId(void *a) 
+void wxvtkImageViewer2::SetDisplayId(void *a)
 {
   this->RenderWindow->SetDisplayId(a);
 }
 
 //----------------------------------------------------------------------------
-void wxvtkImageViewer2::SetWindowId(void *a) 
+void wxvtkImageViewer2::SetWindowId(void *a)
 {
   this->RenderWindow->SetWindowId(a);
 }
 
 //----------------------------------------------------------------------------
-void wxvtkImageViewer2::SetParentId(void *a) 
+void wxvtkImageViewer2::SetParentId(void *a)
 {
   this->RenderWindow->SetParentId(a);
 }
 
 //----------------------------------------------------------------------------
-double wxvtkImageViewer2::GetColorWindow() 
+double wxvtkImageViewer2::GetColorWindow()
 {
   return this->WindowLevel->GetWindow();
 }
 
 //----------------------------------------------------------------------------
-double wxvtkImageViewer2::GetColorLevel() 
+double wxvtkImageViewer2::GetColorLevel()
 {
   return this->WindowLevel->GetLevel();
 }
 
 //----------------------------------------------------------------------------
-void wxvtkImageViewer2::SetColorWindow(double s) 
+void wxvtkImageViewer2::SetColorWindow(double s)
 {
   this->WindowLevel->SetWindow(s);
 }
 
 //----------------------------------------------------------------------------
-void wxvtkImageViewer2::SetColorLevel(double s) 
+void wxvtkImageViewer2::SetColorLevel(double s)
 {
   this->WindowLevel->SetLevel(s);
 }
@@ -469,9 +469,9 @@ class wxvtkImageViewer2Callback : public vtkCommand
 {
 public:
   static wxvtkImageViewer2Callback *New() { return new wxvtkImageViewer2Callback; }
-  
-  void Execute(vtkObject *caller, 
-               unsigned long event, 
+
+  void Execute(vtkObject *caller,
+               unsigned long event,
                void *vtkNotUsed(callData))
     {
       if (this->IV->GetInput() == NULL)
@@ -502,25 +502,25 @@ public:
         this->InitialLevel = this->IV->GetColorLevel();
         return;
         }
-      
+
       // Adjust the window level here
 
-      vtkInteractorStyleImage *isi = 
+      vtkInteractorStyleImage *isi =
         static_cast<vtkInteractorStyleImage *>(caller);
 
       int *size = this->IV->GetRenderWindow()->GetSize();
       double window = this->InitialWindow;
       double level = this->InitialLevel;
-      
+
       // Compute normalized delta
 
-      double dx = 4.0 * 
-        (isi->GetWindowLevelCurrentPosition()[0] - 
+      double dx = 4.0 *
+        (isi->GetWindowLevelCurrentPosition()[0] -
          isi->GetWindowLevelStartPosition()[0]) / size[0];
-      double dy = 4.0 * 
-        (isi->GetWindowLevelStartPosition()[1] - 
+      double dy = 4.0 *
+        (isi->GetWindowLevelStartPosition()[1] -
          isi->GetWindowLevelCurrentPosition()[1]) / size[1];
-      
+
       // Scale by current values
 
       if (fabs(window) > 0.01)
@@ -539,24 +539,24 @@ public:
         {
         dy = dy * (level < 0 ? -0.01 : 0.01);
         }
-      
+
       // Abs so that direction does not flip
 
-      if (window < 0.0) 
+      if (window < 0.0)
         {
         dx = -1*dx;
         }
-      if (level < 0.0) 
+      if (level < 0.0)
         {
         dy = -1*dy;
         }
-      
+
       // Compute new window level
 
       double newWindow = dx + window;
       double newLevel;
       newLevel = level - dy;
-      
+
       // Stay away from zero and really
 
       if (fabs(newWindow) < 0.01)
@@ -567,12 +567,12 @@ public:
         {
         newLevel = 0.01*(newLevel < 0 ? -1 : 1);
         }
-      
+
       this->IV->SetColorWindow(newWindow);
       this->IV->SetColorLevel(newLevel);
       this->IV->Render();
     }
-  
+
   wxvtkImageViewer2 *IV;
   double InitialWindow;
   double InitialLevel;
@@ -601,7 +601,7 @@ void wxvtkImageViewer2::InstallPipeline()
         vtkCommand::ResetWindowLevelEvent, cbk);
       cbk->Delete();
       }
-    
+
     this->Interactor->SetInteractorStyle(this->InteractorStyle);
     this->Interactor->SetRenderWindow(this->RenderWindow);
     }
@@ -650,20 +650,20 @@ void wxvtkImageViewer2::Render()
     // Initialize the size if not set yet
 
     vtkImageData *input = this->GetInput();
-    if (this->RenderWindow->GetSize()[0] == 0 && 
+    if (this->RenderWindow->GetSize()[0] == 0 &&
        input)
       {
-       
+
       input->UpdateInformation();
       int *w_ext = input->GetWholeExtent();
       int xs = 0, ys = 0;
-      
+
       //       std::cout << "wxvtkImageViewer2::Render ext = "
       //       <<w_ext[0]<<" - "<<w_ext[1]<<" ; "
       //               <<w_ext[2]<<" - "<<w_ext[3]<<" ; "
       //               <<w_ext[4]<<" - "<<w_ext[5]
       //               <<std::endl;
-      
+
       switch (this->SliceOrientation)
         {
         case wxvtkImageViewer2::SLICE_ORIENTATION_XY:
@@ -697,7 +697,7 @@ void wxvtkImageViewer2::Render()
         this->Renderer->GetActiveCamera()->SetParallelScale(
           xs < 150 ? 75 : (xs - 1 ) / 2.0);
         }
-      this->FirstRender = 0;  
+      this->FirstRender = 0;
 
       }
     }
@@ -708,7 +708,7 @@ void wxvtkImageViewer2::Render()
 }
 
 //----------------------------------------------------------------------------
-const char* wxvtkImageViewer2::GetWindowName() 
+const char* wxvtkImageViewer2::GetWindowName()
 {
   return this->RenderWindow->GetWindowName();
 }
@@ -726,7 +726,7 @@ int wxvtkImageViewer2::GetOffScreenRendering()
 }
 
 //----------------------------------------------------------------------------
-void wxvtkImageViewer2::SetInput(vtkImageData *in) 
+void wxvtkImageViewer2::SetInput(vtkImageData *in)
 {
   //  std::cout << "### wxvtkImageViewer2::SetInput"<<std::endl;
   this->WindowLevel->SetInput(in);
@@ -736,12 +736,12 @@ void wxvtkImageViewer2::SetInput(vtkImageData *in)
 }
 //----------------------------------------------------------------------------
 vtkImageData* wxvtkImageViewer2::GetInput()
-{ 
+{
   return vtkImageData::SafeDownCast(this->WindowLevel->GetInput());
 }
 
 //----------------------------------------------------------------------------
-void wxvtkImageViewer2::SetInputConnection(vtkAlgorithmOutput* input) 
+void wxvtkImageViewer2::SetInputConnection(vtkAlgorithmOutput* input)
 {
   this->WindowLevel->SetInputConnection(input);
   this->UpdateDisplayExtent();