Viewer3D.h

 
#pragma once
 
#if defined(Viewer3D_RECURSES)
#error Recursive header files inclusion detected in Viewer3D.h
#else // defined(Viewer3D_RECURSES)
#define Viewer3D_RECURSES
 
#if !defined Viewer3D_h
#define Viewer3D_h
 
// Inclusions
#include "DGtal/base/Common.h"
 
#include <iostream>
#include <vector>
#include <algorithm>
#ifdef WIN32
#include <windows.h>
#endif
 
#ifdef APPLE
/* Defined before OpenGL and GLUT includes to avoid deprecation messages */
#define GL_SILENCE_DEPRECATION
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#else
#include <GL/gl.h>
#include <GL/glu.h>
#endif
 
#include <QApplication>
 
#include <QGLViewer/qglviewer.h>
#include <QGLWidget>
#include <QKeyEvent>
 
#include "DGtal/kernel/SpaceND.h"
#include "DGtal/topology/KhalimskySpaceND.h"
#include "DGtal/base/CountedPtr.h"
#include "DGtal/io/Display3D.h"
#include "DGtal/math/BasicMathFunctions.h"
 
#include "DGtal/kernel/CSpace.h"
 
 
namespace DGtal
{
 
  // class Viewer3D
  template <typename TSpace  = SpaceND<3>,
            typename TKSpace = KhalimskySpaceND<3>>
  class Viewer3D : public QGLViewer, public Display3D<TSpace, TKSpace>
  {
 
    BOOST_CONCEPT_ASSERT( (concepts::CSpace<TSpace>));
 
    //---------------overwritting some functions of Display3D -------------------
 
    // ----------------------- public types ------------------------------
  public:
  typedef TSpace Space;
  typedef TKSpace KSpace;
  typedef Viewer3D<Space, KSpace> Self;
  typedef Display3D<Space, KSpace> Display;
  typedef typename Display::SelectCallbackFct SelectCallbackFct;
  typedef typename Display::RealPoint RealPoint;
  using Display::getSelectCallback3D;
 
  enum RenderingMode
  {
    RenderingDefault,
    RenderingMetallic,
    RenderingPlastic,
    RenderingLambertian
  };
 
  struct Extension
  {
    typedef Viewer3D<Space, KSpace> Viewer;
 
    virtual ~Extension() = default;
    
    virtual bool keyPressEvent( Viewer & viewer, QKeyEvent * event )
    {
      boost::ignore_unused_variable_warning( viewer );
      boost::ignore_unused_variable_warning( event );
      return false;
    }
 
    virtual void drawWithNames( Viewer & viewer )
    {
      boost::ignore_unused_variable_warning( viewer );
    }
 
    virtual void draw( Viewer & viewer )
    {
      boost::ignore_unused_variable_warning( viewer );
    }
 
    virtual void init( Viewer & viewer )
    {
      boost::ignore_unused_variable_warning( viewer );
    }
 
    virtual QString helpString( const Viewer & viewer ) const
    {
      boost::ignore_unused_variable_warning( viewer );
      return "";
    }
 
    virtual bool postSelection( const Viewer & viewer, const QPoint & point )
    {
      boost::ignore_unused_variable_warning( viewer );
      boost::ignore_unused_variable_warning( point );
      return false;
    }
 
    virtual bool mouseMoveEvent( const Viewer & viewer, QMouseEvent * event )
    {
      boost::ignore_unused_variable_warning( viewer );
      boost::ignore_unused_variable_warning( event );
      return false;
    }
 
    virtual bool mousePressEvent( const Viewer & viewer, QMouseEvent * event )
    {
      boost::ignore_unused_variable_warning( viewer );
      boost::ignore_unused_variable_warning( event );
      return false;
    }
 
    virtual bool mouseReleaseEvent( const Viewer & viewer, QMouseEvent * event )
    {
      boost::ignore_unused_variable_warning( viewer );
      boost::ignore_unused_variable_warning( event );
      return false;
    }
  };
 
  // ----------------------- Standard services ------------------------------
  public:
 
  Viewer3D() : QGLViewer(), Display3D<Space, KSpace>(), myExtension( 0 )
  {
    resize( 800, 600 );
    };
 
    Viewer3D( const KSpace & KSEmb )
      : QGLViewer(), Display3D<Space, KSpace>( KSEmb ), myExtension( 0 )
    {
      resize(800,600);
    }
 
    void setExtension( Extension * ext )
    {
      if ( myExtension != 0 )
        delete myExtension;
      myExtension = ext;
    }
 
    void removeExtension()
    {
      if ( myExtension != 0 )
        delete myExtension;
      myExtension = 0;
    }
 
    void setCameraPosition(double ax, double ay, double az)
    {
      camera_position[0] = ax; camera_position[1] = ay; camera_position[2] = az;
    }
 
    void setCameraDirection(double ax, double ay, double az)
    {
      camera_direction[0] = ax; camera_direction[1] = ay; camera_direction[2] = az;
    }
 
    void setCameraUpVector(double ax, double ay, double az)
    {
      camera_upVector[0] = ax; camera_upVector[1] = ay; camera_upVector[2] = az;
    }
 
    void setNearFar(double _near, double _far)
    {
      ZNear = _near; ZFar = _far;
    }
 
    void setGLScale(float sx, float sy, float sz)
    {
      myGLScaleFactorX=sx;
      myGLScaleFactorY=sy;
      myGLScaleFactorZ=sz;
      // In order to have the light source rendering the same as wtih the default scale 1. 
      glEnable(GL_NORMALIZE);  
    }
 
 
    void setGLDoubleRenderingMode(bool doubleSidedRendering);
 
    
    void setGLMaterialShininessCoefficient(const GLfloat matShininessCoeff);
 
    
    void setGLLightAmbientCoefficients(const GLfloat lightAmbientCoeffs [4]);
 
    void setGLLightDiffuseCoefficients(const GLfloat lightDiffuseCoeffs [4]);
 
 
    void setGLLightSpecularCoefficients(const GLfloat lightSpecularCoeffs [4]);
    
 
 
    void setUseGLPointForBalls(bool useOpenGLPt);
 
    
    void updateRenderingCoefficients(const RenderingMode aRenderMode, bool displayState=true);
    
    
    enum ImageDirection {xDirection, yDirection, zDirection, undefDirection };
    enum TextureMode {RGBMode, GrayScaleMode };
 
    DGtal::Color myDefaultBackgroundColor;
    DGtal::Color myDefaultColor;
    bool myIsBackgroundDefault;
    bool myViewWire;
    double myGLPointMinWidth = 1.5; 
    double myGLLineMinWidth = 1.5; 
    bool myAutoSaveState;
    // define the default rendering mode of the viewer
    RenderingMode myRenderingMode = RenderingDefault;
    
    struct Image2DDomainD3D
    {
 
      RealPoint point1;
      RealPoint point2;
      RealPoint point3;
      RealPoint point4;
      DGtal::Color color;
      unsigned int myDomainWidth;
      unsigned int myDomainHeight;
      ImageDirection myDirection;
      std::string myMode;
      std::size_t myLineSetIndex;
 
      template<typename TDomain>
      Image2DDomainD3D( TDomain aDomain, ImageDirection normalDir=zDirection,
                        double xBottomLeft=0.0, double yBottomLeft=0.0, double zBottomLeft=0.0, std::string mode= "BoundingBox")
      {
        BOOST_CONCEPT_ASSERT(( concepts::CDomain < TDomain >));
        myMode = mode;
        myDirection=normalDir;
        myDomainWidth = (aDomain.upperBound())[0]-(aDomain.lowerBound())[0]+1;
        myDomainHeight = (aDomain.upperBound())[1]-(aDomain.lowerBound())[1]+1;
        updateDomainOrientation(normalDir, xBottomLeft, yBottomLeft, zBottomLeft);
      }
 
 
      void updateDomainOrientation( ImageDirection normalDir,
                                    double xBottomLeft, double yBottomLeft, double zBottomLeft);
 
 
      void translateDomain(double xTranslation=0.0,
                           double yTranslation=0.0, double zTranslation=0.0);
 
    };
 
 
    struct TextureImage
    {
 
      RealPoint point1;
      RealPoint point2;
      RealPoint point3;
      RealPoint point4;
 
      ImageDirection myDirection; 
 
      unsigned int myImageWidth;
      unsigned int myImageHeight;
      //TODO complete desc attribute
      unsigned int * myTabImage; 
 
      bool myDrawDomain; 
      unsigned int myIndexDomain; 
      TextureMode myMode; 
 
      ~TextureImage()
      {
        delete [] myTabImage;
      };
 
      TextureImage(const TextureImage & img): point1(img.point1), point2(img.point2),
                point3(img.point3), point4(img.point4),
                myDirection(img.myDirection), myImageWidth(img.myImageWidth),
                myImageHeight(img.myImageHeight),
                myTabImage(img.myTabImage),
                myDrawDomain(img.myDrawDomain),
                myIndexDomain(img.myIndexDomain),
                myMode(img.myMode)
      {
 
        if(img.myImageHeight>0 && img.myImageWidth>0)
          {
            myTabImage = new unsigned int [img.myImageWidth*img.myImageHeight];
            for(unsigned int i=0; i<img.myImageWidth*img.myImageHeight; i++)
              {
                myTabImage[i] = img.myTabImage[i];
              }
          }else
          {
            myTabImage=img.myTabImage;
          }
      };
 
 
 
      template <typename TImageType, typename TFunctor>
 
      TextureImage( const TImageType & image, const TFunctor &aFunctor,
                    ImageDirection normalDir=zDirection,
                    double xBottomLeft=0.0, double yBottomLeft=0.0, double zBottomLeft=0.0,
                    TextureMode aMode= GrayScaleMode)
      {
        BOOST_CONCEPT_ASSERT(( concepts::CConstImage < TImageType > ));
        BOOST_CONCEPT_ASSERT(( concepts::CUnaryFunctor<TFunctor, typename TImageType::Value, unsigned int> )) ;
        myDrawDomain=false;
        myDirection=normalDir;
        myImageWidth = (image.domain().upperBound())[0]-(image.domain().lowerBound())[0]+1;
        myImageHeight = (image.domain().upperBound())[1]-(image.domain().lowerBound())[1]+1;
        myTabImage = new unsigned int [myImageWidth*myImageHeight];
        updateImageOrientation(normalDir, xBottomLeft, yBottomLeft, zBottomLeft);
        myMode=aMode;
        updateImageDataAndParam(image, aFunctor);
      }
 
      void updateImageOrientation( ImageDirection normalDir,
                                   double xBottomLeft, double yBottomLeft, double zBottomLeft);
 
 
      void
      updateImage3DEmbedding( RealPoint aPoint1,
                              RealPoint aPoint2,
                              RealPoint aPoint3,
                              RealPoint aPoint4)
      {
        point1 = aPoint1;  point2 = aPoint2; point3 = aPoint3;   point4 = aPoint4;
        myDirection=undefDirection;
      }
 
 
      template <typename TImageType, typename TFunctor>
      void updateImageDataAndParam(const TImageType & image, const TFunctor &aFunctor, double xTranslation=0.0,
                                   double yTranslation=0.0, double zTranslation=0.0)
      {
        BOOST_CONCEPT_ASSERT(( concepts::CConstImage < TImageType > ));
        BOOST_CONCEPT_ASSERT(( concepts::CUnaryFunctor<TFunctor, typename TImageType::Value, unsigned int> )) ;
        assert ( (image.domain().upperBound())[0]-(image.domain().lowerBound())[0]+1== static_cast<int>(myImageWidth) &&
                 (image.domain().upperBound())[1]-(image.domain().lowerBound())[1]+1== static_cast<int>(myImageHeight));
 
        point1[0] += xTranslation; point1[1] += yTranslation; point1[2] += zTranslation;
        point2[0] += xTranslation; point2[1] +=yTranslation; point2[2] += zTranslation;
        point3[0] += xTranslation; point3[1] += yTranslation; point3[2] += zTranslation;
        point4[0] += xTranslation; point4[1] += yTranslation; point4[2] += zTranslation;
 
        unsigned int pos=0;
        for(typename TImageType::Domain::ConstIterator it = image.domain().begin(), itend=image.domain().end();
            it!=itend; ++it)
          {
            myTabImage[pos]= aFunctor(image(*it));
            pos++;
          }
      }
 
      std::string className() const;
 
    private:
      TextureImage()
      {};
    };
 
    Viewer3D<Space, KSpace> & operator<< ( const DGtal::Color & aColor );
 
 
    Viewer3D<Space, KSpace> & operator<< ( const typename Viewer3D<Space, KSpace>::StreamKey & key );
 
 
    void sortSurfelFromCamera();
 
    void sortTriangleFromCamera();
 
    void sortQuadFromCamera();
 
    void sortPolygonFromCamera();
 
 
 
    template <typename TDrawableWithViewer3D>
    Viewer3D<Space, KSpace> & operator<< ( const TDrawableWithViewer3D & object );
 
 
 
    // ----------------------- Interface --------------------------------------
  public:
 
    void selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const;
 
 
 
    virtual unsigned int getCurrentDomainNumber();
 
    virtual unsigned int getCurrentGLImageNumber();
 
 
    virtual void paintGL();
 
 
    virtual void show();
 
 
    void addTextureImage(const TextureImage &image);
 
 
    template <typename TImageType, typename TFunctor>
 
    void updateTextureImage(unsigned int imageIndex, const TImageType & image, const TFunctor & aFunctor,
                            double xTranslation=0.0, double yTranslation=0.0, double zTranslation=0.0,
          double rotationAngle=0.0, ImageDirection rotationDir=zDirection);
 
 
 
 
    void updateOrientationTextureImage(unsigned int imageIndex,
                                       double xPosition, double yPosition,
                                       double zPosition, ImageDirection newDirection);
 
 
 
    void updateEmbeddingTextureImage(unsigned int anImageIndex,
                                     typename Space::Point aPoint1, typename Space::Point aPoint2,
                                     typename Space::Point aPoint3, typename Space::Point aPoint4);
 
 
 
    template<typename TDomain>
    void addImage2DDomainD3D(const TDomain &anImageDomain, std::string mode,
                             const DGtal::Color &aColor=DGtal::Color::Red );
 
 
    void updateAn2DDomainOrientation(unsigned int imageIndex,
                                     double xPosition, double yPosition,
                                     double zPosition, ImageDirection newDirection);
 
    void translateAn2DDomain(unsigned int domainIndex, double xTranslation,
                             double yTranslation, double zTranslation);
 
    std::vector<typename DGtal::Viewer3D< Space , KSpace >::LineD3D>
    compute2DDomainLineRepresentation( Image2DDomainD3D &anImageDomain, double delta );
 
    std::vector<typename DGtal::Viewer3D< Space , KSpace >::LineD3D>
    compute2DDomainLineRepresentation( Image2DDomainD3D &anImageDomain);
 
 
    template < typename TContainer >
    void  rotateLineD3D(typename DGtal::Display3D<Space, KSpace>::LineD3D &aLine, DGtal::PointVector<3, int, TContainer> pt,
      double angleRotation, ImageDirection dirRotation);
 
 
 
    void  rotateDomain(Image2DDomainD3D &anDom, double angle, ImageDirection rotationDir);
 
 
 
 
    
 
    // ------------------------- Protected Datas ------------------------------
  private:
 
 
 
  public:
  void drawSomeLight( GLenum light ) const
  {
    QGLViewer::drawLight( light );
  }
  void drawSomeLight( GLenum light, float zoom ) const
  {
    QGLViewer::drawLight( light, zoom );
  }
 
  // ------------------------- Hidden services ------------------------------
  // protected:
 
  void updateList( bool needToUpdateBoundingBox = true );
 
  void glDrawGLBall( const typename Viewer3D<Space, KSpace>::BallD3D & aBall );
 
  virtual void keyPressEvent( QKeyEvent * e );
 
  virtual void mouseMoveEvent( QMouseEvent * e );
 
  virtual void mousePressEvent( QMouseEvent * e );
 
  virtual void mouseReleaseEvent( QMouseEvent * e );
 
  struct CompFarthestVoxelFromCamera
  {
    qglviewer::Vec posCam;
    bool operator()( typename Viewer3D<Space, KSpace>::CubeD3D s1,
                     typename Viewer3D<Space, KSpace>::CubeD3D s2 )
    {
      double dist1 =
      sqrt( ( posCam.x - s1.center[ 0 ] ) * ( posCam.x - s1.center[ 0 ] ) +
            ( posCam.y - s1.center[ 1 ] ) * ( posCam.y - s1.center[ 1 ] ) +
            ( posCam.z - s1.center[ 2 ] ) * ( posCam.z - s1.center[ 2 ] ) );
      double dist2 =
      sqrt( ( posCam.x - s2.center[ 0 ] ) * ( posCam.x - s2.center[ 0 ] ) +
            ( posCam.y - s2.center[ 1 ] ) * ( posCam.y - s2.center[ 1 ] ) +
            ( posCam.z - s2.center[ 2 ] ) * ( posCam.z - s2.center[ 2 ] ) );
      return dist1 > dist2;
    }
    };
 
 
    struct CompFarthestTriangleFromCamera
    {
      qglviewer::Vec posCam;
      bool operator() ( typename Viewer3D<Space,KSpace>::TriangleD3D t1,
                        typename Viewer3D<Space,KSpace>::TriangleD3D t2 )
      {
        qglviewer::Vec center1 ( ( t1.point1[0]+t1.point2[0]+t1.point3[0] ) /3.0, ( t1.point1[1]+t1.point2[1]+t1.point3[1] ) /3.0, ( t1.point1[2]+t1.point2[2]+t1.point3[2] ) /3.0 );
        qglviewer::Vec center2 ( ( t2.point1[0]+t2.point2[0]+t2.point3[0] ) /3.0, ( t2.point1[1]+t2.point2[1]+t2.point3[1] ) /3.0, ( t2.point1[2]+t2.point2[2]+t2.point3[2] ) /3.0 );
        double dist1= sqrt ( ( posCam.x-center1.x ) * ( posCam.x-center1.x ) + ( posCam.y-center1.y ) * ( posCam.y-center1.y ) + ( posCam.z-center1.z ) * ( posCam.z-center1.z ) );
        double dist2= sqrt ( ( posCam.x-center2.x ) * ( posCam.x-center2.x ) + ( posCam.y-center2.y ) * ( posCam.y-center2.y ) + ( posCam.z-center2.z ) * ( posCam.z-center2.z ) );
 
        return dist1>dist2;
      }
    };
 
    struct CompFarthestSurfelFromCamera
    {
      qglviewer::Vec posCam;
      bool operator() (typename Viewer3D<Space,KSpace>::QuadD3D q1,
                       typename Viewer3D<Space,KSpace>::QuadD3D q2 )
      {
 
        qglviewer::Vec center1 ( ( q1.point1[0]+q1.point2[0]+q1.point3[0]+q1.point4[0] ) /4.0, ( q1.point1[1]+q1.point2[1]+q1.point3[1]+q1.point4[1] ) /4.0, ( q1.point1[2]+q1.point2[2]+q1.point3[2]+q1.point4[2] ) /4.0 );
        qglviewer::Vec center2 ( ( q2.point1[0]+q2.point2[0]+q2.point3[0]+q2.point4[0] ) /4.0, ( q2.point1[1]+q2.point2[1]+q2.point3[1]+q2.point4[1] ) /4.0, ( q2.point1[2]+q2.point2[2]+q2.point3[2]+q2.point4[2] ) /4.0 );
 
        double dist1= sqrt ( ( posCam.x-center1.x ) * ( posCam.x-center1.x ) + ( posCam.y-center1.y ) * ( posCam.y-center1.y ) + ( posCam.z-center1.z ) * ( posCam.z-center1.z ) );
        double dist2= sqrt ( ( posCam.x-center2.x ) * ( posCam.x-center2.x ) + ( posCam.y-center2.y ) * ( posCam.y-center2.y ) + ( posCam.z-center2.z ) * ( posCam.z-center2.z ) );
        return dist1>dist2;
      }
    };
 
    struct CompFarthestPolygonFromCamera
    {
      qglviewer::Vec posCam;
      bool operator() ( typename Viewer3D<Space,KSpace>::PolygonD3D q1,
                        typename Viewer3D<Space,KSpace>::PolygonD3D q2 )
      {
        double c1x=0.0, c1y=0.0, c1z=0.0;
        double c2x=0.0, c2y=0.0, c2z=0.0;
        for(unsigned int i=0; i< q1.vertices.size(); i++){
          c1x+=q1.vertices.at(i)[0];
          c1y+=q1.vertices.at(i)[1];
          c1z+=q1.vertices.at(i)[2];
        }
        for(unsigned int i=0; i< q2.vertices.size(); i++){
          c2x+=q2.vertices.at(i)[0];
          c2y+=q2.vertices.at(i)[1];
          c2z+=q2.vertices.at(i)[2];
        }
 
        qglviewer::Vec center1 ( c1x/(double)q1.vertices.size(),c1y/(double)q1.vertices.size(), c1z/(double)q1.vertices.size() );
        qglviewer::Vec center2 ( c2x/(double)q2.vertices.size(),c2y/(double)q2.vertices.size(), c2z/(double)q2.vertices.size() );
 
        double dist1= sqrt ( ( posCam.x-center1.x ) * ( posCam.x-center1.x ) + ( posCam.y-center1.y ) * ( posCam.y-center1.y ) + ( posCam.z-center1.z ) * ( posCam.z-center1.z ) );
        double dist2= sqrt ( ( posCam.x-center2.x ) * ( posCam.x-center2.x ) + ( posCam.y-center2.y ) * ( posCam.y-center2.y ) + ( posCam.z-center2.z ) * ( posCam.z-center2.z ) );
        return dist1>dist2;
      }
    };
 
 
 
    virtual void drawWithNames();
 
    virtual void draw();
 
    virtual void init();
 
    virtual QString helpString() const;
 
    virtual void postSelection ( const QPoint& point );
 
 
 
    virtual  QDomElement domElement(const QString& name, QDomDocument& document) const;
    
 
    virtual void initFromDOMElement(const QDomElement& element);
    
    
    protected: virtual void closeEvent  (       QCloseEvent *   e       );
    
 
    
    // ------------------------- Internals ------------------------------------
  private:
 
 
    struct GLTextureImage
    {
      RealPoint point1;
      RealPoint point2;
      RealPoint point3;
      RealPoint point4;
 
      typename Viewer3D<Space, KSpace>::ImageDirection myDirection;
      unsigned int myImageWidth;
      unsigned int myImageHeight;
 
      unsigned int myBufferWidth;
      unsigned int myBufferHeight;
      GLuint myTextureName;
      typename Viewer3D<Space, KSpace>::TextureMode myMode;
      unsigned char * myTextureImageBufferGS;
      unsigned char * myTextureImageBufferRGB;
      double vectNormal[3];
 
 
      // By definition in OpenGL the image size of texture should power of 2
      double myTextureFitX;
      double myTextureFitY;
 
 
      // Destructor
      ~GLTextureImage()
      {
        if(myMode== 1)
          {
            if(myTextureImageBufferGS!=0)
              delete [] myTextureImageBufferGS;
          }
        if(myMode== Viewer3D<Space, KSpace>::RGBMode)
          {
            if(myTextureImageBufferRGB!=0)
              delete [] myTextureImageBufferRGB;
          }
 
      }
 
      //Copy constructor from a GLTextureImage
      GLTextureImage(const GLTextureImage &aGLImg): myBufferWidth(aGLImg.myBufferWidth),
                                                    myBufferHeight(aGLImg.myBufferHeight),
                                                    myTextureName(aGLImg.myTextureName),
                                                    myMode(aGLImg.myMode),
                myTextureFitX(aGLImg.myTextureFitX),
                                                    myTextureFitY(aGLImg.myTextureFitY)
 
      {
        point1[0]=aGLImg.point1[0]; point1[1]=aGLImg.point1[1]; point1[2]=aGLImg.point1[2];
        point2[0]=aGLImg.point2[0]; point2[1]=aGLImg.point2[1]; point2[2]=aGLImg.point2[2];
        point3[0]=aGLImg.point3[0]; point3[1]=aGLImg.point3[1]; point3[2]=aGLImg.point3[2];
        point4[0]=aGLImg.point4[0]; point4[1]=aGLImg.point4[1]; point4[2]=aGLImg.point4[2];
        myImageWidth=aGLImg.myImageWidth; myImageHeight=aGLImg.myImageHeight;
        myDirection = aGLImg.myDirection;
        vectNormal[0]=aGLImg.vectNormal[0];
        vectNormal[1]=aGLImg.vectNormal[1];
        vectNormal[2]=aGLImg.vectNormal[2];
 
        if(myMode== 1)
          {
            myTextureImageBufferGS = new unsigned char [myBufferHeight*myBufferWidth];
            for(unsigned int i=0; i<myBufferHeight*myBufferWidth;i++)
              {
                myTextureImageBufferGS[i]=aGLImg.myTextureImageBufferGS[i];
              }
          }else if(myMode==Viewer3D<Space, KSpace>::RGBMode)
          {
            myTextureImageBufferRGB = new unsigned char [3*myBufferHeight*myBufferWidth];
            for(unsigned int i=0; i<3*myBufferHeight*myBufferWidth;i+=3)
              {
                myTextureImageBufferRGB[i]=aGLImg.myTextureImageBufferRGB[i];
                myTextureImageBufferRGB[i+1]=aGLImg.myTextureImageBufferRGB[i+1];
                myTextureImageBufferRGB[i+2]=aGLImg.myTextureImageBufferRGB[i+2];
              }
          }
      }
 
 
      //Copy constructor from a TextureImage
      GLTextureImage(const typename Viewer3D<Space, KSpace>::TextureImage &aGSImage)
      {
        point1[0]=aGSImage.point1[0]; point1[1]=aGSImage.point1[1]; point1[2]=aGSImage.point1[2];
        point2[0]=aGSImage.point2[0]; point2[1]=aGSImage.point2[1]; point2[2]=aGSImage.point2[2];
        point3[0]=aGSImage.point3[0]; point3[1]=aGSImage.point3[1]; point3[2]=aGSImage.point3[2];
        point4[0]=aGSImage.point4[0]; point4[1]=aGSImage.point4[1]; point4[2]=aGSImage.point4[2];
        myImageWidth=aGSImage.myImageWidth; myImageHeight=aGSImage.myImageHeight;
        myDirection = aGSImage.myDirection;
        myMode= aGSImage.myMode;
        vectNormal[0]= (myDirection == Viewer3D<Space, KSpace>::xDirection)? 1.0: 0.0;
        vectNormal[1]= (myDirection == Viewer3D<Space, KSpace>::yDirection)? -1.0: 0.0;
        vectNormal[2]= (myDirection == Viewer3D<Space, KSpace>::zDirection)? 1.0: 0.0;
        if(myDirection==undefDirection){
          RealPoint v1 = point2-point1;
          RealPoint v2 = point4-point1;
          vectNormal[0] = v1[1]*v2[2] - v1[2]*v2[1];
          vectNormal[1] = v1[2]*v2[0] - v1[0]*v2[2];
          vectNormal[2] = v1[0]*v2[1] - v1[1]*v2[0];
          double norm = sqrt(vectNormal[0]*vectNormal[0]+vectNormal[1]*vectNormal[1]+vectNormal[2]*vectNormal[2]);
          vectNormal[0] /=norm; vectNormal[1] /=norm; vectNormal[2] /=norm;
        }
 
        myBufferWidth = functions::roundToUpperPowerOfTwo(myImageWidth);
        myBufferHeight = functions::roundToUpperPowerOfTwo(myImageHeight);
 
        if(myMode== 1)
          {
            myTextureImageBufferGS = new unsigned char [myBufferHeight*myBufferWidth];
            unsigned int pos=0;
            for (unsigned int i=0; i<myBufferHeight; i++)
              {
                for (unsigned int j=0; j<myBufferWidth; j++)
                  {
                    if(i<myImageHeight && j< myImageWidth)
                      {
                        myTextureImageBufferGS[pos]= aGSImage.myTabImage[i*myImageWidth+j];
                      }else{
                      myTextureImageBufferGS[pos]=0;
                    }
                    pos++;
                  }
              }
          }else if(myMode==Viewer3D<Space, KSpace>::RGBMode)
          {
            myTextureImageBufferRGB = new unsigned char [3*myBufferHeight*myBufferWidth];
            unsigned int pos=0;
            for (unsigned int i=0; i<myBufferHeight; i++)
              {
                for (unsigned int j=0; j<myBufferWidth; j++)
                  {
                    if(i<myImageHeight && j< myImageWidth)
                      {
                        DGtal::Color aCol(aGSImage.myTabImage[i*myImageWidth+j]);
                        myTextureImageBufferRGB[pos]= aCol.red();
                        myTextureImageBufferRGB[pos+1]= aCol.green();
                        myTextureImageBufferRGB[pos+2]= aCol.blue();
                      }else{
                      myTextureImageBufferRGB[pos]=0;
                      myTextureImageBufferRGB[pos+1]=0;
                      myTextureImageBufferRGB[pos+2]=0;
                    }
                    pos+=3;
                  }
              }
          }
 
        myTextureFitX = 1.0-((myBufferWidth-myImageWidth)/(double)myBufferWidth);
        myTextureFitY = 1.0-((myBufferHeight-myImageHeight)/(double)myBufferHeight);
      }
    };
 
 
 
    typedef typename std::vector<typename Viewer3D<Space, KSpace>::CubeD3D> VectorCubes;
    typedef typename std::vector<typename Viewer3D<Space, KSpace>::QuadD3D> VectorQuad;
    typedef typename std::vector<typename Viewer3D<Space, KSpace>::LineD3D> VectorLine;
    typedef typename std::vector<typename Viewer3D<Space, KSpace>::BallD3D> VectorBall;
    typedef typename std::vector<typename Viewer3D<Space, KSpace>::TriangleD3D> VectorTriangle;
    typedef typename std::vector<typename Viewer3D<Space, KSpace>::PolygonD3D> VectorPolygon;
    typedef typename std::vector<typename Viewer3D<Space, KSpace>::TextureImage> VectorTextureImage;
 
 
    typedef typename VectorCubes::iterator ItCube;
 
 
    void glCreateListCubesMaps(const typename Display3D<Space, KSpace>::CubesMap &aCubeMap, unsigned int idList);
 
 
 
    void glCreateListQuadD3D(const VectorQuad &aVectQuad, unsigned int idList);
 
 
    void glCreateListLines(const VectorLine &aVectLine, unsigned int idList);
 
 
    void glCreateListBalls(const VectorBall &aVectBall, unsigned int idList);
 
 
    void glCreateListQuadMaps(const typename Display3D<Space, KSpace>::QuadsMap &aQuadMap, unsigned int idList);
 
 
    void glCreateListQuadMapsWired(const typename Display3D<Space, KSpace>::QuadsMap &aQuadMap, unsigned int idList);
 
 
    void glCreateListTriangles(const std::vector<VectorTriangle>  &aVectTriangle, unsigned int idList);
 
 
    void glCreateListTrianglesWired(const std::vector<VectorTriangle>  &aVectTriangle, unsigned int idList);
 
 
    void glCreateListPolygons(const std::vector<VectorPolygon>  &aVectPolygon, unsigned int idList);
 
 
    void glCreateListPolygonsWired(const std::vector<VectorPolygon>  &aVectPolygon, unsigned int idList);
 
 
    void glUpdateTextureImages(const VectorTextureImage  &aVectImage);
 
 
    void glUpdateLightRenderingMode() const;
 
    void glUpdateBackground() ; 
        
    void updateLightCoordsFromCamera();
 
    void updateRelativeCameraFromLightPosition();
 
 
    
  public:
    template<typename TImageORDomain>
    static
    void
    rotateImageVertex(TImageORDomain &anImageOrDom, double angle, ImageDirection rotationDir){
      double xB = (anImageOrDom.point1[0]+anImageOrDom.point2[0]+anImageOrDom.point3[0]+anImageOrDom.point4[0])/4.0;
      double yB = (anImageOrDom.point1[1]+anImageOrDom.point2[1]+anImageOrDom.point3[1]+anImageOrDom.point4[1])/4.0;
      double zB = (anImageOrDom.point1[2]+anImageOrDom.point2[2]+anImageOrDom.point3[2]+anImageOrDom.point4[2])/4.0;
      rotatePoint( anImageOrDom.point1[0],  anImageOrDom.point1[1], anImageOrDom.point1[2],   xB, yB, zB, angle, rotationDir);
      rotatePoint( anImageOrDom.point2[0],  anImageOrDom.point2[1], anImageOrDom.point2[2],   xB, yB, zB, angle, rotationDir);
      rotatePoint( anImageOrDom.point3[0],  anImageOrDom.point3[1], anImageOrDom.point3[2],   xB, yB, zB, angle, rotationDir);
      rotatePoint( anImageOrDom.point4[0],  anImageOrDom.point4[1], anImageOrDom.point4[2],   xB, yB, zB, angle, rotationDir);
 
    }
 
    template <typename TValues>
    static
    void  rotatePoint(TValues &x, TValues &y, TValues &z,
          double cx, double cy, double cz,
          double rotationAngle, ImageDirection rotationDir);
 
 
 
 
 
    // ------------------------- Private Datas --------------------------------
  private:
 
    //GLuint myListToAff;
 
    GLuint myTriangleSetListId;
    GLuint myTriangleSetListWiredId;
 
    GLuint myPolygonSetListId;
    GLuint myPolygonSetListWiredId;
 
    GLuint myLineSetListId;
    GLuint myBallSetListId;
    GLuint myPrismListId;
 
    GLuint myQuadsMapId;
    GLuint myQuadsMapWiredId;
 
    GLuint myCubesMapId;
    GLuint myCubeSetListWiredId;
 
 
    unsigned int myNbListe;
    unsigned int myNbLineSetList;
    unsigned int myNbBallSetList;
    unsigned int myNbPrismSetList;
 
    int mySelectedElementId = -1;
    unsigned char mySelectionColorShift = 150;
    
    qglviewer::Vec myOrig, myDir, myDirSelector, mySelectedPoint;
    QPoint myPosSelector;
    std::vector<GLTextureImage> myVectTextureImage;
 
    bool myIsDoubleFaceRendering = true; 
    
    double camera_position[3]; 
    double camera_direction[3]; 
    double camera_upVector[3]; 
    
    bool   myLightPositionFixToCamera = true; // when false the light position is fix according to the scene.
    double myLightTheta; 
    double myLightPhi; 
    double myLightR; 
    GLfloat myLightPosition [4] = {0.0f, 0.0f, 1.0f, 1.0f}; // the light position in cartesian coordinate
    GLfloat myLightPositionRefCameraDefault [3] = {-100.0f, 100.0f, 0.0f}; // the light default position according to the camera position
    GLfloat myLightPositionRefCamera [3] = {0.0f, 0.0f, 0.0f}; // the light position according to the camera position
    GLfloat myMaterialShininessCoeff[1] =  {50.0f} ; // the material shininess coefficient used in opengl rendering 
    GLfloat myMaterialSpecularCoeffs[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; // the light specular coefficients used in opengl rendering 
    GLfloat myLightSpecularCoeffs[4] = { 0.3f, 0.3f, 0.3f, 1.0f }; // the light specular coefficients used in opengl rendering 
    GLfloat myLightAmbientCoeffs[4] = { 0.0f, 0.0f, 0.0f, 1.0f }; // the material ambient coefficients used in opengl rendering  
    GLfloat myLightDiffuseCoeffs[4] = { 0.7f, 0.7f, 0.7f, 1.0f }; // the material diffuse coefficients used in opengl rendering  
 
    const GLfloat myDefaultRenderSpec = 0.3f; // default specular coefficients for default mode rendering
    const GLfloat myDefaultRenderDiff = 0.7f; // default diffuse coefficients for metallic mode rendering    
    const GLfloat myLambertRenderSpec = 0.0f; // default specular coefficients for default mode rendering
    const GLfloat myLambertRenderDiff = 0.9f; // default diffuse coefficients for metallic mode rendering
    const GLfloat myMetallicRenderSpec = 0.5f; // default specular coefficients for metallic mode rendering
    const GLfloat myMetallicRenderDiff = 0.5f; // default diffuse coefficients for metallic mode rendering
    const GLfloat myPlasticRenderSpec = 0.8f; // default specular coefficients for platic mode rendering
    const GLfloat myPlasticRenderDiff = 0.2f; // default diffuse coefficients for platic mode rendering
    
    bool myUseGLPointsForBalls =  false; // to display balls with GL points (instead real ball) 
 
    double ZNear; 
    double ZFar; 
 
    //the default width of the mesh line
    float myMeshDefaultLineWidth;
 
    // To apply openGL ajustment only on visualisation
    float myGLScaleFactorX=1.0;
    float myGLScaleFactorY=1.0;
    float myGLScaleFactorZ=1.0;
    
    // Used to apply interactive light rotation
    double myLigthRotationStep; 
    int myRefMouseXPos; 
    int myRefMouseYPos; 
    bool myIsMovingLight; 
 
    std::vector<TextureImage> myGSImageList;
    std::vector<Image2DDomainD3D> myImageDomainList;
    Extension * myExtension;
 
  }; // end of class Viewer3D
 
  template <typename TSpace, typename TKSpace>
  std::ostream & operator<<( std::ostream & out,
                             const Viewer3D<TSpace, TKSpace> & object );
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/io/viewers/Viewer3D.ih"
 
// //
 
#endif // !defined Viewer3D_h
 
#undef Viewer3D_RECURSES
#endif // else defined(Viewer3D_RECURSES)