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
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#else
#include <GL/gl.h>
#include <GL/glu.h>
#endif

#ifdef WITH_QT5
  #include <QApplication>
#else
  #include <QtGui/qapplication.h>
#endif

#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 Space = SpaceND<3>,
             typename KSpace = KhalimskySpaceND<3> >
  class Viewer3D : public QGLViewer, public Display3D<Space, KSpace>
  {

    BOOST_CONCEPT_ASSERT((concepts::CSpace<Space>));

    //---------------overwritting some functions of Display3D -------------------

    // ----------------------- public types ------------------------------
  public:

    typedef Display3D<Space, KSpace> Display;
    typedef typename Display::SelectCallbackFct SelectCallbackFct;
    using Display::getSelectCallback3D;
    typedef typename Display::RealPoint RealPoint;

    enum RenderingMode {RenderingDefault, RenderingMetallic, RenderingPlastic, RenderingLambertian };

    // ----------------------- Standard services ------------------------------
  public:

    Viewer3D() :QGLViewer(), Display3D<Space, KSpace>()
    {
      resize(800,600);
    };

    Viewer3D(const KSpace &KSEmb):QGLViewer(), Display3D<Space,KSpace>(KSEmb)
    {
      resize(800,600);
    }

    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;
      unsigned int 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:





    // ------------------------- 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 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;

  }; // end of class Viewer3D



  template < typename Space, typename KSpace>
  std::ostream&
  operator<< ( std::ostream & out, const Viewer3D<Space, KSpace> & object );
} // namespace DGtal


// Includes inline functions.
#include "DGtal/io/viewers/Viewer3D.ih"

// //

#endif // !defined Viewer3D_h

#undef Viewer3D_RECURSES
#endif // else defined(Viewer3D_RECURSES)