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 <iostream>
#include <vector>
#include <algorithm>

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


#include <QGLViewer/qglviewer.h>
#include <QGLWidget>
#include <QKeyEvent>

#include "DGtal/base/Common.h"
#include "DGtal/base/CountedPtr.h"
#include "DGtal/io/Display3D.h"






namespace DGtal
{



// class Viewer3D
class Viewer3D : public QGLViewer, public Display3D
{
    // ----------------------- Standard services ------------------------------
public:

    Viewer3D() :QGLViewer(), Display3D()
    {

    };




    DGtal::Color myDefaultBackgroundColor;
    DGtal::Color myDefaultColor;
    bool myIsBackgroundDefault;
  bool myViewWire;
  
  
    Viewer3D & operator<< ( const DGtal::Color & aColor );



    Viewer3D & operator<< ( const Display3D::StreamKey  & key );





    void sortSurfelFromCamera();

  void sortTriangleFromCamera();
  void sortQuadFromCamera();


  void sortPolygonFromCamera();
    

    template <typename TDrawableWithDisplay3D>
    Viewer3D & operator<< ( const  TDrawableWithDisplay3D & object );



    // ----------------------- Interface --------------------------------------
public:

    void selfDisplay ( std::ostream & out ) const;

    bool isValid() const;

  


    // ------------------------- Protected Datas ------------------------------
private:



public:



    // ------------------------- Private Datas --------------------------------
private:


  GLuint myListToAff;
  unsigned int myNbListe;
  qglviewer::Vec myOrig, myDir, myDirSelector, mySelectedPoint;
  QPoint myPosSelector;
  
public:

    // ------------------------- Hidden services ------------------------------
protected:
  

    void updateList ( bool needToUpdateBoundingBox=true );


    void glDrawGLLinel ( lineD3D aLinel );




    void glDrawGLPointel ( pointD3D pointel );




    virtual void keyPressEvent ( QKeyEvent *e );


    struct compFarthestVoxelFromCamera
    {
        qglviewer::Vec posCam;
        bool operator() ( voxelD3D s1, voxelD3D s2 )
        {
            double dist1= sqrt ( ( posCam.x-s1.x ) * ( posCam.x-s1.x ) + ( posCam.y-s1.y ) * ( posCam.y-s1.y ) + ( posCam.z-s1.z ) * ( posCam.z-s1.z ) );
            double dist2= sqrt ( ( posCam.x-s2.x ) * ( posCam.x-s2.x ) + ( posCam.y-s2.y ) * ( posCam.y-s2.y ) + ( posCam.z-s2.z ) * ( posCam.z-s2.z ) );
            return dist1>dist2;
        }
    }
    ;


    struct compFarthestTriangleFromCamera
    {
      qglviewer::Vec posCam;
      bool operator() ( triangleD3D t1, triangleD3D t2 )
      {
            qglviewer::Vec center1 ( ( t1.x1+t1.x2+t1.x3 ) /3.0, ( t1.y1+t1.y2+t1.y3 ) /3.0, ( t1.z1+t1.z2+t1.z3 ) /3.0 );
            qglviewer::Vec center2 ( ( t2.x1+t2.x2+t2.x3 ) /3.0, ( t2.y1+t2.y2+t2.y3 ) /3.0, ( t2.z1+t2.z2+t2.z3 ) /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() ( quadD3D q1, quadD3D q2 )
        {

        qglviewer::Vec center1 ( ( q1.x1+q1.x2+q1.x3+q1.x4 ) /4.0, ( q1.y1+q1.y2+q1.y3+q1.y4 ) /4.0, ( q1.z1+q1.z2+q1.z3+q1.z4 ) /4.0 );
        qglviewer::Vec center2 ( ( q2.x1+q2.x2+q2.x3+q2.x4 ) /4.0, ( q2.y1+q2.y2+q2.y3+q2.y4 ) /4.0, ( q2.z1+q2.z2+q2.z3+q2.z4 ) /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() ( polygonD3D q1, polygonD3D q2 )
      {
        double c1x, c1y, c1z=0.0;
        double c2x, c2y, c2z=0.0;
        for(unsigned int i=0; i< q1.vectPoints.size(); i++){
          c1x+=q1.vectPoints.at(i).x;
          c1y+=q1.vectPoints.at(i).y;
          c1z+=q1.vectPoints.at(i).z;
        }
        for(unsigned int i=0; i< q2.vectPoints.size(); i++){
          c2x+=q2.vectPoints.at(i).x;
          c2y+=q2.vectPoints.at(i).y;
          c2z+=q2.vectPoints.at(i).z;
        }
        
        qglviewer::Vec center1 ( c1x/(double)q1.vectPoints.size(),c1y/(double)q1.vectPoints.size(), c1z/(double)q1.vectPoints.size() );
        qglviewer::Vec center2 ( c2x/(double)q2.vectPoints.size(),c2y/(double)q2.vectPoints.size(), c2z/(double)q2.vectPoints.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;
      }
  };







protected :
    virtual void drawWithNames();
    virtual void draw();
    virtual void init();
    virtual QString helpString() const;
    virtual void postSelection ( const QPoint& point );



    // ------------------------- Internals ------------------------------------
private:






}; // end of class Viewer3D








std::ostream&
operator<< ( std::ostream & out, const Viewer3D & object );


} // namespace DGtal




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

//                                                                           //

#endif // !defined Viewer3D_h

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