otbVectorDataGlComponent.h

Go to the documentation of this file.

/*=========================================================================

  Program:   ORFEO Toolbox
  Language:  C++
  Date:      $Date$
  Version:   $Revision$


  Copyright (c) Centre National d'Etudes Spatiales. All rights reserved.
  See OTBCopyright.txt for details.


     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __otbVectorDataGlComponent_h
#define __otbVectorDataGlComponent_h

#include "otbGlComponent.h"
#include "itkPreOrderTreeIterator.h"

#  ifdef __APPLE__
#    include <OpenGL/glu.h>
#  else
#    include <GL/glu.h>
#  endif

// There are function prototype conflits under cygwin between standard w32 API
// and standard C ones
#ifndef CALLBACK
#if defined(_WINDOWS) || defined(__CYGWIN__)
#define CALLBACK __stdcall
#else
#define CALLBACK
#endif
#endif

namespace otb
{
template <class TVectorData>
class VectorDataGlComponent
  : public GlComponent
{
public:
  typedef VectorDataGlComponent           Self;
  typedef GlComponent                     Superclass;
  typedef itk::SmartPointer<Self>         Pointer;
  typedef itk::SmartPointer<const Self>   ConstPointer;
  typedef typename Superclass::RegionType RegionType;

  // affine transform
  typedef Superclass::AffineTransformType      AffineTransformType;
  typedef AffineTransformType::InputPointType  PointType;
  typedef AffineTransformType::InputVectorType VectorType;
  typedef Superclass::ColorType                ColorType;

  typedef TVectorData                                     VectorDataType;
  typedef typename VectorDataType::Pointer                VectorDataPointerType;
  typedef typename VectorDataType::DataNodeType           DataNodeType;
  typedef typename DataNodeType::Pointer                  DataNodePointerType;
  typedef typename DataNodeType::ConstPointer             DataNodeConstPointerType;
  typedef typename VectorDataType::DataTreeType           DataTreeType;
  typedef typename DataNodeType::LineType                 LineType;
  typedef typename DataNodeType::PolygonType              PolygonType;
  typedef typename DataNodeType::PolygonListType          PolygonListType;
  typedef typename DataTreeType::TreeNodeType             InternalTreeNodeType;
  typedef typename InternalTreeNodeType::ChildrenListType ChildrenListType;

  itkTypeMacro(VectorDataGlComponent, GlComponent);

  itkNewMacro(Self);

  virtual void  Render(const RegionType& extent, const AffineTransformType * space2ScreenTransform);

  itkSetMacro(Spacing, VectorType);
  itkGetConstReferenceMacro(Spacing, VectorType);

  itkSetMacro(Origin, PointType);
  itkGetConstReferenceMacro(Origin, PointType);

  itkSetObjectMacro(VectorData, VectorDataType);
  itkGetObjectMacro(VectorData, VectorDataType);

  itkSetMacro(Color, ColorType);
  itkGetConstReferenceMacro(Color, ColorType);

  itkSetMacro(LineWidth, double);
  itkGetMacro(LineWidth, double);

  itkSetMacro(CrossWidth, double);
  itkGetMacro(CrossWidth, double);

  itkSetMacro(RenderPolygonBoundariesOnly, bool);
  itkGetMacro(RenderPolygonBoundariesOnly, bool);
  itkBooleanMacro(RenderPolygonBoundariesOnly);

protected:
  VectorDataGlComponent();
  virtual ~VectorDataGlComponent();
  virtual void PrintSelf(std::ostream& os, itk::Indent indent) const
  {
    Superclass::PrintSelf(os, indent);
  }

  virtual void RenderPoint(DataNodePointerType dataNode,
                           const RegionType& extent,
                           const AffineTransformType * transform);
  virtual void RenderLine(DataNodePointerType dataNode, const RegionType& extent, const AffineTransformType * transform);
  // Render a complex polygon (with holes)
  virtual void RenderPolygon(DataNodePointerType dataNode,
                             const RegionType& extent,
                             const AffineTransformType * transform);

  // Recursive rendering method
  virtual void Render(InternalTreeNodeType * node,
                      const RegionType& extent,
                      const AffineTransformType * space2ScreenTransform);

  //void FramePoint(const PointType & p);

private:
  VectorDataGlComponent(const Self&); // purposely not implemented
  void operator =(const Self&);        // purposely not implemented

  // Function pointer typedef
  typedef GLvoid (CALLBACK * FunctionPointerType)();

  // Static Combine callback for tesselation
  static void CALLBACK TesselationCombineCallback(GLdouble coords[3],
                                                  GLdouble * /*data*/[4],
                                                  GLfloat /*weights*/[4],
                                                  GLdouble **dataOut)
  {
    GLdouble * vertex = new GLdouble[3];
    vertex[0] = coords[0];
    vertex[1] = coords[1];
    vertex[2] = coords[2];
    *dataOut = vertex;
  }

  // Static error callback fir tesselation
  static void CALLBACK TesselationErrorCallback(GLenum errorCode)
  {
    const GLubyte * estring = gluErrorString(errorCode);
    otbMsgDevMacro(<< "Glu Tesselation error: " << estring);
    //estring = 0; // avoid unused variable warning
  }

  // Static begin callback for tesselation
  static void CALLBACK BeginCallback(GLenum prim)
  {
    glBegin(prim);
  }

  // Static end callback for tesselation
  static void CALLBACK EndCallback()
  {
    glEnd();
  }

  // static vertex callback for tesselation
  static void CALLBACK VertexCallback(void * data)
  {
    glVertex3dv((GLdouble*) data);
  }

  VectorDataPointerType m_VectorData;

  VectorType m_Spacing;

  PointType m_Origin;

  GLUtesselator * m_GluTesselator;

  ColorType m_Color;

  double m_LineWidth;

  double m_CrossWidth;

  bool m_RenderPolygonBoundariesOnly;

}; // end class
} // end namespace otb

#ifndef OTB_MANUAL_INSTANTIATION
#include "otbVectorDataGlComponent.txx"
#endif

#endif