Initialisation des premières classes de la Visu.

Code/Visu/CMakeLists.txt

+#FILE(GLOB OTBVisu_SRCS "*.cxx" )
+SET ( OTBVisu_SRCS 
+        toto.cxx
+)
+
+#FILE(GLOB OTBVisu_GUI_SRCS "*.fl" )
+
+SET ( OTBVisu_GUI_SRCS 
+        otbImageViewerGUI.fl
+)
+
+
+IF(WIN32)
+  ADD_DEFINITIONS(-DWIN32)
+ENDIF(WIN32)
+
+INCLUDE_DIRECTORIES(
+  ${OTB_SOURCE_DIR}/Code/Visu
+  ${OTB_BINARY_DIR}/Code/Visu
+)
+
+# Take the list of GUI files, generate .cxx and .h from them and add
+# them to the build process of the target
+FLTK_WRAP_UI(OTBVisu ${OTBVisu_GUI_SRCS} )
+
+ADD_LIBRARY(OTBVisu ${OTBVisu_SRCS} ${OTBVisu_FLTK_UI_SRCS})
+ADD_LIBRARY(OTBVisu ${OTBVisu_SRCS} )
+INSTALL_FILES(/include/otb/Visu "(\\.h|\\.txx)$")
+INSTALL_TARGETS(/lib OTBVisu)
+
+TARGET_LINK_LIBRARIES(OTBVisu ${FLTK_LIBRARIES} ${OPENGL_glu_LIBRARY}
+                      ${OPENGL_LIBRARIES})
+
+# The fluid-generated fltk sources have many warnings.  Disable
+# warnings for the generated files on some compilers.
+IF(${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 1.6)
+  IF(CMAKE_COMPILER_IS_GNUCXX)
+    FOREACH(f ${OTBVisu_GUI_SRCS})
+      STRING(REGEX REPLACE "\\.fl$" ".cxx" SRC "${f}")
+      SET(SRC ${OTB_BINARY_DIR}/Code/Visu/${SRC})
+      SET_SOURCE_FILES_PROPERTIES(${SRC} PROPERTIES COMPILE_FLAGS -w)
+    ENDFOREACH(f)
+  ENDIF(CMAKE_COMPILER_IS_GNUCXX)
+ENDIF(${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 1.6)

Code/Visu/otbColorImageViewer.h

+#ifndef __otbColorImageViewer_h
+#define __otbColorImageViewer_h
+
+#include "otbGLColorImageView.h"
+#include "otbImageViewerGUI.h"
+#include "itkImage.h"
+#include "itkRGBPixel.h"
+
+namespace otb
+{
+
+template <class ImagePixelType, class OverlayPixelType>
+class ColorImageViewer : public otbImageViewerGUI
+{
+public:
+
+   /**
+   * Standard "Self" typedef.
+   */
+  typedef ColorImageViewer         Self;
+
+  /** 
+   * Smart pointer typedef support.
+   */
+  typedef itk::SmartPointer<Self>        Pointer;
+  typedef itk::SmartPointer<const Self>  ConstPointer;
+
+ 
+  typedef itk::Image< itk::RGBPixel<ImagePixelType>, 3 >   ImageType;
+  typedef itk::Image< OverlayPixelType, 3 > OverlayType;
+  typedef GLColorImageView< ImagePixelType, OverlayPixelType > GLColorImageViewType;
+  typedef typename GLColorImageViewType::ColorTablePointer ColorTablePointer;
+
+
+    
+  ColorImageViewer();
+  virtual ~ColorImageViewer();
+  virtual void SetImage(itk::ImageBase<3> * img);
+  virtual void SetOverlay(itk::ImageBase<3> * img);
+  virtual void Show(void);
+  virtual void Hide(void);
+  virtual void Update(void);
+  virtual void Synchronize(void);
+  virtual void ImageMode(ImageModeType mode);
+  virtual void SelectSlice(unsigned int num);
+  virtual void SetIntensityWindowingMin(float val);
+  virtual void SetIntensityWindowingMax(float val);
+  virtual void CenterWindow(void);
+  virtual void ZoomIn(void);
+  virtual void ZoomOut(void);
+  virtual void ShiftUp(void);
+  virtual void ShiftDown(void);
+  virtual void ShiftLeft(void);
+  virtual void ShiftRight(void);
+  virtual void SetOrientation(void);
+  virtual void CreateGLSliceView( Fl_Group * g , Fl_Gl_Window * w );
+  virtual void SetLabel( const char * );
+  virtual void ShowClickedPointsWindow(void);
+  virtual void UpdateClickedPoints(void);
+  virtual void ClearClickedPoints(void);
+  virtual void ClickSelectCallBack(
+                void (*newClickSelectArgCallBack)(float, float,
+                                                  float, float,
+                                                  void *),
+                     void * newClickSelectArg);
+
+  
+  virtual void ViewDetails(bool detail);
+  virtual void ViewValue(bool value);
+  virtual void ViewCrosshairs(bool crosshairs);
+
+  /** Specify the opacity of the overlay */
+  virtual void  SetOverlayOpacity(float newOverlayOpacity);
+  
+  /** Get the opacity of the overlay */
+  virtual float GetOverlayOpacity(void) const;
+  
+  /** Show slider to control overlay opacity */
+  virtual void ShowOverlayOpacityControl(void);
+  
+  /** Get the ColorTable for the Overlay */
+  virtual ColorTablePointer GetOverlayColorTable(void);
+
+  /** Set the ColorTable for the Overlay */
+  virtual void SetOverlayColorTable(ColorTablePointer newColorTable);
+
+  void SetOverlayColorIndex( unsigned int c )
+    { 
+    glSliceView->SetOverlayColorIndex( c );
+    }
+
+
+private:
+  GLColorImageViewType * glSliceView;
+};
+
+
+} // end namespace otb
+
+#ifndef OTB_MANUAL_INSTANTIATION
+#include <otbColorImageViewer.txx>
+#endif
+
+
+
+
+#endif

Code/Visu/otbColorImageViewer.txx

+
+#include "otbColorImageViewer.h"
+
+
+namespace otb
+{
+  
+template <class ImagePixelType, class OverlayPixelType>
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::ColorImageViewer()
+{
+  glSliceView = 0;
+  CreateGUI();
+}
+
+
+  
+template <class ImagePixelType, class OverlayPixelType>
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::~ColorImageViewer()
+{
+
+}
+
+
+
+
+template <class ImagePixelType, class OverlayPixelType>
+void
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::SetImage(itk::ImageBase<3> * img)
+{
+  ImageType * image = dynamic_cast<ImageType *>( img );
+  glSliceView->SetInputImage( image );
+  Synchronize();
+}
+
+
+template <class ImagePixelType, class OverlayPixelType>
+void
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::SetOverlay(itk::ImageBase<3> * img)
+{
+  OverlayType * overlay = dynamic_cast<OverlayType *>( img );
+  glSliceView->SetInputOverlay( overlay );
+  Synchronize();
+}
+
+/* Specify the opacity of the overlay */
+template <class ImagePixelType, class OverlayPixelType>
+void
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::SetOverlayOpacity(float newOverlayOpacity)
+{
+  glSliceView->OverlayOpacity( newOverlayOpacity );
+  glSliceView->update();
+}
+
+
+/* Get the opacity of the overlay */
+template <class ImagePixelType, class OverlayPixelType>
+float
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::GetOverlayOpacity(void) const
+{
+  return glSliceView->OverlayOpacity();
+}
+
+
+/* Get the ColorTable for the Overlay */
+template <class ImagePixelType, class OverlayPixelType>
+typename ColorImageViewer<ImagePixelType, OverlayPixelType>::ColorTablePointer
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::GetOverlayColorTable(void)
+{
+  return glSliceView->GetColorTable();
+}
+
+/* Set the ColorTable for the Overlay */
+template <class ImagePixelType, class OverlayPixelType>
+void
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::SetOverlayColorTable(ColorTablePointer newColorTable)
+{
+  glSliceView->SetColorTable(newColorTable);
+}
+
+
+
+template <class ImagePixelType, class OverlayPixelType>
+void 
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::Show(void)
+{
+  static bool firstTime = true;
+  iviewWindow->show();
+  glSliceView->show();
+  glSliceView->update();
+  if( firstTime )
+  {
+    firstTime = false;
+    Fl::check();
+    glSliceView->redraw();
+    Fl::check();
+  }
+}
+
+
+
+
+
+template <class ImagePixelType, class OverlayPixelType>
+void 
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::Hide(void)
+{
+  iviewWindow->hide();
+  clickedPointsWindow->hide();
+  overlayOpacityControlWindow->hide();
+}
+
+
+
+
+
+
+template <class ImagePixelType, class OverlayPixelType>
+void 
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::Update(void)
+{
+  glSliceView->update();
+}
+
+
+
+
+
+
+template <class ImagePixelType, class OverlayPixelType>
+void 
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::ImageMode(ImageModeType mode)
+{
+  glSliceView->imageMode(mode);
+  glSliceView->update();
+}
+
+
+
+
+
+
+
+template <class ImagePixelType, class OverlayPixelType>
+void
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::Synchronize(void) 
+{
+  float iwDiff  = glSliceView->iwMax() - glSliceView->iwMin();
+  float b       = (float)((int)log10(iwDiff)-2);
+  double iwMin  = ((int)(glSliceView->iwMin()*pow((float)10, (float)-b)))/pow((float)10,(float)-b);
+  double iwMax  = ((int)(glSliceView->iwMax()*pow((float)10, (float)-b)))/pow((float)10,(float)-b);
+  double iwStep = (iwMax-iwMin)/100.0;
+  sliceNumberSlider->range( 0.0f, glSliceView->numSlices() );
+  intensityWindowingMinSlider->range(iwMin-iwStep,iwMax+iwStep);
+  intensityWindowingMaxSlider->range(iwMin-iwStep,iwMax+iwStep);
+  sliceNumberSlider->value((float)glSliceView->sliceNum());
+  intensityWindowingMinSlider->step(iwStep);
+  intensityWindowingMaxSlider->step(iwStep);
+  intensityWindowingMinSlider->value(iwMin);
+  intensityWindowingMaxSlider->value(iwMax);
+}
+
+
+
+
+
+
+
+template <class ImagePixelType, class OverlayPixelType>
+void 
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::SelectSlice(unsigned int num)
+{
+  sliceNumberSlider->value(num);
+  glSliceView->sliceNum((int)sliceNumberSlider->value());
+  glSliceView->update();
+}
+
+
+
+
+
+
+
+template <class ImagePixelType, class OverlayPixelType>
+void 
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::SetIntensityWindowingMin(float val)
+{
+  intensityWindowingMinSlider->value(val);
+  glSliceView->iwMin(intensityWindowingMinSlider->value());  
+  glSliceView->update();
+}
+
+
+
+
+
+
+
+
+template <class ImagePixelType, class OverlayPixelType>
+void 
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::SetIntensityWindowingMax(float val)
+{
+  intensityWindowingMaxSlider->value(val);
+  glSliceView->iwMax(intensityWindowingMaxSlider->value());  
+  glSliceView->update();
+}
+
+
+
+
+
+
+template <class ImagePixelType, class OverlayPixelType>
+void
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::CenterWindow(void)
+{
+  glSliceView->winCenter();
+  glSliceView->update();
+}
+
+
+
+
+
+
+template <class ImagePixelType, class OverlayPixelType>
+void
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::ZoomIn(void)
+{
+  glSliceView->winZoom(glSliceView->winZoom()*2.0f);
+ glSliceView->update();
+}
+
+
+
+
+
+
+
+template <class ImagePixelType, class OverlayPixelType>
+void
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::ZoomOut(void)
+{
+  glSliceView->winZoom(glSliceView->winZoom()/2.0f);
+  glSliceView->update();
+}
+
+
+
+
+
+
+
+template <class ImagePixelType, class OverlayPixelType>
+void
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::ShiftUp(void)
+{
+  glSliceView->winShift(1,0);
+  glSliceView->update();
+}
+
+
+
+
+
+
+
+template <class ImagePixelType, class OverlayPixelType>
+void
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::ShiftDown(void)
+{
+  glSliceView->winShift(-1,0);
+  glSliceView->update();
+}
+
+
+
+
+
+
+
+
+template <class ImagePixelType, class OverlayPixelType>
+void
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::ShiftLeft(void)
+{
+  glSliceView->winShift(0,-1);
+  glSliceView->update();
+}
+
+
+
+
+
+
+
+template <class ImagePixelType, class OverlayPixelType>
+void
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::ShiftRight(void)
+{
+  glSliceView->winShift(0,1);
+  glSliceView->update();
+}
+
+
+
+
+
+
+template <class ImagePixelType, class OverlayPixelType>
+void
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::SetLabel(const char * label)
+{
+  iviewWindow->label( label );
+}
+
+
+
+
+
+template <class ImagePixelType, class OverlayPixelType>
+void
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::SetOrientation(void)
+{
+  glSliceView->orientation( orientationChoice->value() );
+  glSliceView->update();
+  Synchronize();
+}
+
+
+
+
+
+
+
+
+
+template <class ImagePixelType, class OverlayPixelType>
+void
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::CreateGLSliceView( Fl_Group * group, Fl_Gl_Window * original )
+{
+
+  short int x = original->x();
+  short int y = original->y();
+  short int w = original->w();
+  short int h = original->h();
+
+  const char * label = original->label();
+
+
+  this->glSliceView = new GLColorImageViewType(x,y,w,h,label);
+
+  glSliceView->box( FL_EMBOSSED_BOX );
+
+  group->remove( original );
+
+  delete original;
+
+
+}
+
+
+
+
+
+
+
+template <class ImagePixelType, class OverlayPixelType>
+void 
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::ShowClickedPointsWindow(void)
+{
+  clickedPointsWindow->show();
+}
+
+
+
+
+
+template <class ImagePixelType, class OverlayPixelType>
+void 
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::ClearClickedPoints(void)
+{
+  glSliceView->clearClickedPointsStored();
+  clickedPointsBrowser->clear();
+}
+
+
+
+
+template <class ImagePixelType, class OverlayPixelType>
+void 
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::UpdateClickedPoints(void)
+{
+  clickedPointsBrowser->clear();
+  char buffer[200];
+  const int numPoints = glSliceView->numClickedPointsStored();
+
+  for(int i=numPoints-1; i>=0; i--)
+    {
+    ClickPoint point;
+    if( glSliceView->getClickedPoint(i,point) )
+      {
+      const int x = (int)(point.x);
+      const int y = (int)(point.y);
+      const int z = (int)(point.z);
+      const float value = point.value;
+      sprintf(buffer,"%3d %3d %3d %f",x,y,z,value);
+      clickedPointsBrowser->add( buffer );
+      }
+    }
+
+}
+
+
+
+template <class ImagePixelType, class OverlayPixelType>
+void 
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::ClickSelectCallBack( void (*newClickSelectArgCallBack)(float, float,
+                                                         float, float,
+                                                         void *),
+                                                         void * newClickSelectArg)
+{
+  glSliceView->clickSelectCallBack( newClickSelectArgCallBack, 
+                                    newClickSelectArg           ); 
+}
+
+
+template <class ImagePixelType, class OverlayPixelType>
+void 
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::ViewDetails(bool detail)
+{
+  glSliceView->viewDetails(detail);
+}
+  
+  
+template <class ImagePixelType, class OverlayPixelType>
+void 
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::ViewValue(bool value)
+{
+  glSliceView->viewValue(value);
+}
+  
+template <class ImagePixelType, class OverlayPixelType>
+void 
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::ViewCrosshairs(bool crosshairs)
+{
+  glSliceView->viewCrosshairs(crosshairs);
+}
+
+
+
+
+  
+template <class ImagePixelType, class OverlayPixelType>
+void 
+ColorImageViewer<ImagePixelType,OverlayPixelType>
+::ShowOverlayOpacityControl()
+{
+  overlayOpacitySlider->value( this->GetOverlayOpacity() );
+  overlayOpacityControlWindow->show();
+}
+
+
+
+} // end namespace otb

Code/Visu/otbImageViewer.h

+#ifndef __otbImageViewer_h
+#define __otbImageViewer_h
+
+#include "otbGLImageView.h"
+#include "otbImageViewerGUI.h"
+
+namespace otb
+{
+
+template <class ImagePixelType, class OverlayPixelType>
+class ImageViewer : public otbImageViewerGUI
+{
+public:
+
+   /**
+   * Standard "Self" typedef.
+   */
+  typedef ImageViewer         Self;
+
+  /** 
+   * Smart pointer typedef support.
+   */
+  typedef itk::SmartPointer<Self>        Pointer;
+  typedef itk::SmartPointer<const Self>  ConstPointer;
+
+ 
+  typedef itk::Image< ImagePixelType, 3 >   ImageType;
+  typedef itk::Image< OverlayPixelType, 3 > OverlayType;
+  typedef GLImageView< ImagePixelType, OverlayPixelType > GLImageViewType;
+  typedef typename GLImageViewType::ColorTablePointer ColorTablePointer;
+
+
+    
+  ImageViewer();
+  virtual ~ImageViewer();
+  virtual void SetImage(itk::ImageBase<3> * img);
+  virtual void SetOverlay(itk::ImageBase<3> * img);
+  virtual void Show(void);
+  virtual void Hide(void);
+  virtual void Update(void);
+  virtual void Synchronize(void);
+  virtual void ImageMode(ImageModeType mode);
+  virtual void SelectSlice(unsigned int num);
+  virtual void SetIntensityWindowingMin(float val);
+  virtual void SetIntensityWindowingMax(float val);
+  virtual void CenterWindow(void);
+  virtual void ZoomIn(void);
+  virtual void ZoomOut(void);
+  virtual void ShiftUp(void);
+  virtual void ShiftDown(void);
+  virtual void ShiftLeft(void);
+  virtual void ShiftRight(void);
+  virtual void SetOrientation(void);
+  virtual void CreateGLSliceView( Fl_Group * g , Fl_Gl_Window * w );
+  virtual void SetLabel( const char * );
+  virtual void ShowClickedPointsWindow(void);
+  virtual void UpdateClickedPoints(void);
+  virtual void ClearClickedPoints(void);
+  virtual void ClickSelectCallBack(
+                void (*newClickSelectArgCallBack)(float, float,
+                                                  float, float,
+                                                  void *),
+                     void * newClickSelectArg);
+
+  
+  virtual void ViewDetails(bool detail);
+  virtual void ViewValue(bool value);
+  virtual void ViewCrosshairs(bool crosshairs);
+
+  /** Specify the opacity of the overlay */
+  virtual void  SetOverlayOpacity(float newOverlayOpacity);
+  
+  /** Get the opacity of the overlay */
+  virtual float GetOverlayOpacity(void) const;
+  
+  /** Show slider to control overlay opacity */
+  virtual void ShowOverlayOpacityControl(void);
+  
+  /** Get the ColorTable for the Overlay */
+  virtual ColorTablePointer GetOverlayColorTable(void);
+
+  /** Set the ColorTable for the Overlay */
+  virtual void SetOverlayColorTable(ColorTablePointer newColorTable);
+
+  void SetOverlayColorIndex( unsigned int c )
+    { 
+    glSliceView->SetOverlayColorIndex( c );
+    }
+
+
+private:
+  GLImageViewType * glSliceView;
+};
+
+
+} // end namespace otb
+
+#ifndef OTB_MANUAL_INSTANTIATION
+#include <otbImageViewer.txx>
+#endif
+
+
+
+
+#endif

Code/Visu/otbImageViewerGUI.fl

+# data file for the Fltk User Interface Designer (fluid)
+version 1.0107 
+header_name {.h} 
+code_name {.cxx}
+class otbImageViewerGUI {open
+} {
+  Function {otbImageViewerGUI()} {} {}
+  Function {~otbImageViewerGUI()} {selected return_type virtual
+  } {}
+  Function {CreateGUI()} {open
+  } {
+    Fl_Window iviewWindow {
+      xywh {855 29 295 400} type Double labelsize 10 resizable visible
+    } {
+      Fl_Group glWindowGroup {
+        xywh {0 25 260 320}
+      } {
+        Fl_Choice orientationChoice {
+          callback {SetOrientation();} open
+          xywh {20 325 50 20} down_box BORDER_BOX
+        } {
+          MenuItem {} {
+            label X
+            xywh {0 0 100 20}
+          }
+          MenuItem {} {
+            label Y
+            xywh {0 0 100 20}
+          }
+          MenuItem {} {
+            label Z
+            xywh {10 10 100 20}
+          }
+        }
+        Fl_Box {} {
+          label {3D Win}
+          xywh {0 25 260 250} box EMBOSSED_BOX
+          code0 {\#include <GLSliceView.h>}
+          code1 {CreateGLSliceView( glWindowGroup, o );}
+          class Fl_Gl_Window
+        }
+      }
+      Fl_Menu_Bar {} {
+        xywh {0 0 260 25}
+        code0 {AddMenuBarOptions();}
+      } {
+        Submenu {} {
+          label Filter open
+          xywh {0 0 100 20}
+          code0 {AddFilterMenuOptions();}
+        } {
+          MenuItem {} {
+            label Value
+            callback {ImageMode(itk::IMG_VAL);}
+            xywh {0 0 100 20}
+          }
+          MenuItem {} {
+            label Log
+            callback {ImageMode(itk::IMG_LOG);}
+            xywh {10 10 100 20}
+          }
+        }
+        Submenu {} {
+          label Overlay
+          xywh {10 10 100 20}
+          code0 {AddFilterMenuOptions();}
+        } {
+          MenuItem {} {
+            label Opacity
+            callback {ShowOverlayOpacityControl();}
+            xywh {10 10 100 20}
+          }
+        }
+      }
+      Fl_Value_Slider sliceNumberSlider {
+        label Slice
+        callback {SelectSlice((unsigned int)o->value());}
+        xywh {270 25 20 250} type {Vert Knob} labelsize 10 align 1 step 1 textsize 9
+      }
+      Fl_Value_Slider intensityWindowingMinSlider {
+        callback {SetIntensityWindowingMin(o->value());}
+        xywh {0 360 300 20} type {Horz Fill} selection_color 32 labeltype NO_LABEL labelsize 9 step 1 value 1 textsize 9
+      }
+      Fl_Value_Slider intensityWindowingMaxSlider {
+        callback {SetIntensityWindowingMax(o->value());}
+        xywh {0 380 300 20} type {Horz Fill} color 55 selection_color 47 labeltype NO_LABEL labelsize 9 step 1 value 1 textsize 9
+      }
+      Fl_Button {} {
+        label {Zoom In}
+        callback {ZoomIn();}
+        xywh {170 280 55 20} labelsize 10
+      }
+      Fl_Button {} {
+        label {Zoom Out}
+        callback {ZoomOut();}
+        xywh {170 335 55 20} labelsize 10
+      }
+      Fl_Button {} {
+        label U
+        callback {ShiftUp();}
+        xywh {110 280 35 35} box DIAMOND_UP_BOX labelsize 10
+      }
+      Fl_Button {} {
+        label Reset
+        callback {CenterWindow();}
+        xywh {180 305 35 25} box ROUND_UP_BOX labelsize 10
+      }
+      Fl_Button {} {
+        label R
+        callback {ShiftRight();}
+        xywh {130 300 35 35} box DIAMOND_UP_BOX labelsize 10
+      }
+      Fl_Button {} {
+        label L
+        callback {ShiftLeft();}
+        xywh {90 300 35 35} box DIAMOND_UP_BOX labelsize 10
+      }
+      Fl_Button {} {
+        label D
+        callback {ShiftDown();}
+        xywh {110 320 35 35} box DIAMOND_UP_BOX labelsize 10
+      }
+      Fl_Button {} {
+        label Points
+        callback {ShowClickedPointsWindow();}
+        xywh {15 290 55 20} labelsize 10
+      }
+    }
+    Fl_Window clickedPointsWindow {
+      label {Clicked Points}
+      xywh {548 29 290 405} type Double visible
+    } {
+      Fl_Browser clickedPointsBrowser {
+        xywh {10 15 270 345} textfont 4
+      }
+      Fl_Button {} {
+        label Update
+        callback {UpdateClickedPoints();}
+        xywh {27 370 65 25}
+      }
+      Fl_Button {} {
+        label Clear
+        callback {ClearClickedPoints();}
+        xywh {115 370 65 25}
+      }
+      Fl_Button {} {
+        label Close
+        callback {clickedPointsWindow->hide();}
+        xywh {200 370 65 25}
+      }
+    }
+    Fl_Window overlayOpacityControlWindow {
+      label {Overlay Opacity} open
+      xywh {502 506 400 100} type Double visible
+    } {
+      Fl_Button {} {
+        label Close
+        callback {overlayOpacityControlWindow->hide();}
+        xywh {145 64 115 25}
+      }
+      Fl_Value_Slider overlayOpacitySlider {
+        label Opacity
+        callback {SetOverlayOpacity( o->value() );}
+        xywh {25 29 360 25} type {Horz Fill} color 29 selection_color 21 align 1 step 0.01 value 0.5
+      }
+    }
+  }
+  Function {CreateGLSliceView( Fl_Group *,Fl_Gl_Window * w )} {return_type {virtual void}
+  } {}
+  Function {AddMenuBarOptions(void)} {return_type {virtual void}
+  } {}
+  Function {AddFilterMenuOptions()} {return_type {virtual void}
+  } {}
+  Function {AddFileMenuOptions()} {return_type {virtual void}
+  } {}
+  Function {SetImage( itk::ImageBase<3> * img )} {return_type {virtual void}
+  } {}
+  Function {Show(void)} {return_type {virtual void}
+  } {}
+  Function {Hide(void)} {return_type {virtual void}
+  } {}
+  Function {Update(void)} {return_type {virtual void}
+  } {}
+  Function {Synchronize(void)} {return_type {virtual void}
+  } {}
+  Function {ImageMode(itk::ImageModeType mode)} {return_type {virtual void}
+  } {}
+  Function {SelectSlice(unsigned int)} {return_type {virtual void}
+  } {}
+  Function {SetIntensityWindowingMin(float)} {return_type {virtual void}
+  } {}
+  Function {SetIntensityWindowingMax(float)} {return_type {virtual void}
+  } {}
+  Function {CenterWindow(void)} {return_type {virtual void}
+  } {}
+  Function {ZoomIn(void)} {return_type {virtual void}
+  } {}
+  Function {ZoomOut(void)} {return_type {virtual void}
+  } {}
+  Function {ShiftUp(void)} {return_type {virtual void}
+  } {}
+  Function {ShiftDown(void)} {return_type {virtual void}
+  } {}
+  Function {ShiftLeft(void)} {return_type {virtual void}
+  } {}
+  Function {ShiftRight(void)} {return_type {virtual void}
+  } {}
+  Function {SetOrientation(void)} {return_type {virtual void}
+  } {}
+  Function {ShowClickedPointsWindow(void)} {return_type {virtual void}
+  } {}
+  Function {ClearClickedPoints(void)} {return_type {virtual void}
+  } {}
+  Function {ShowOverlayOpacityControl(void)} {return_type {virtual void}
+  } {}
+  Function {SetOverlayOpacity(float)} {return_type {virtual void}
+  } {}
+  Function {UpdateClickedPoints()} {return_type {virtual void}
+  } {}
+}