Fix Circular_kernel and PCA demo

AABB_tree/demo/AABB_tree/Scene.cpp

@@ -613,7 +613,6 @@ void Scene::draw(CGAL::QGLViewer* viewer)
     }
     if(m_view_points && pos_points.size()>0)
     {
-        gl->glPointSize(2.0f);
         vao[0].bind();
         attrib_buffers(viewer);
         rendering_program.bind();

Circular_kernel_3/demo/Circular_kernel_3/Viewer.cpp

@@ -116,6 +116,7 @@ void Viewer::compile_shaders()
                  "uniform highp mat4 mvp_matrix;\n"
                  "void main(void)\n"
                  "{\n"
+                 "   gl_PointSize = 4.0;\n"
                  "   gl_Position = mvp_matrix * vertex;\n"
                  "}"
              };
@@ -813,12 +814,10 @@ void Viewer::draw()
     }
     else
     {
-        glPointSize(4.0f);
         rendering_program_no_ext.bind();
         rendering_program_no_ext.setUniformValue(colorLocation, color);
         glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(pos_points.size()/3));
         rendering_program_no_ext.release();
-        glPointSize(1.0f);
     }
 
     vao[2].release();

Principal_component_analysis/demo/Principal_component_analysis/Scene.cpp

@@ -16,15 +16,14 @@
 #include <CGAL/centroid.h>
 #include <CGAL/linear_least_squares_fitting_3.h>
 
-
-#include "render_edges.h"
-
 Scene::Scene()
 {
+  is_gl_init = false;
     m_pPolyhedron = NULL;
 
     // view options
     m_view_polyhedron = true;
+    
 }
 
 Scene::~Scene()
@@ -96,52 +95,89 @@ void Scene::update_bbox()
 
 void Scene::draw(Viewer* viewer)
 {
-    if(m_view_polyhedron)
+  if(!is_gl_init)
-        render_polyhedron(viewer);
+    gl_init();
+  rendering_program.bind();
+  //setup mvp matrix
+  QMatrix4x4 mvp_matrix;
+  GLdouble mat[16];
+  viewer->camera()->getModelViewProjectionMatrix(mat);
+  for(int i=0; i<16; ++i)
+    mvp_matrix.data()[i] = (GLfloat)mat[i];
+  rendering_program.setUniformValue("mvp_matrix", mvp_matrix);
   
+  if(m_view_polyhedron){
+    rendering_program.setUniformValue("color", QColor(Qt::black));
+    render_polyhedron(viewer);
+  }
+  //draw points and lines
+  rendering_program.setUniformValue("color", QColor(Qt::darkBlue));
   render_line(viewer);
+  rendering_program.setUniformValue("color", QColor(Qt::red));
   render_plane(viewer);
+  rendering_program.setUniformValue("color", QColor(Qt::darkGreen));
   render_centroid(viewer);
+  rendering_program.release();
 }
 
 void Scene::render_plane(Viewer* viewer)
 {
-    viewer->glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
-    viewer->glLineWidth(3.0f);
-    viewer->glColor3ub(255,0,0);
-    viewer->glBegin(GL_QUADS);
     Point o = m_plane.projection(m_centroid);
     Point a = o + normalize(m_plane.base1()) + normalize(m_plane.base2());
     Point b = o + normalize(m_plane.base1()) - normalize(m_plane.base2());
     Point c = o - normalize(m_plane.base1()) - normalize(m_plane.base2());
     Point d = o - normalize(m_plane.base1()) + normalize(m_plane.base2());
-    viewer->glVertex3d(a.x(),a.y(),a.z());
+    GLfloat verts[12];
-    viewer->glVertex3d(b.x(),b.y(),b.z());
+    verts[0]= a.x();verts[1]=a.y();verts[2]=a.z();
-    viewer->glVertex3d(c.x(),c.y(),c.z());
+    verts[3]= b.x();verts[4]=b.y();verts[5]=b.z();
-    viewer->glVertex3d(d.x(),d.y(),d.z());
+    verts[6]= c.x();verts[7]=c.y();verts[8]=c.z();
-    viewer->glEnd();
+    verts[9]= d.x();verts[10]=d.y();verts[11]=d.z();
+    vao[0].bind();
+    buffers[0].bind();
+    buffers[0].allocate(verts, 12*sizeof(GLfloat));
+    rendering_program.setAttributeBuffer("vertex", GL_FLOAT, 0,3);
+    rendering_program.enableAttributeArray("vertex");
+    buffers[0].release();
+    
+    viewer->glDrawArrays(GL_LINE_LOOP, 0, 4);
+    vao[0].release();
+ 
+ 
 }
 
 void Scene::render_line(Viewer* viewer)
 {
-    viewer->glLineWidth(3.0f);
-    viewer->glColor3ub(0,0,255);
-    viewer->glBegin(GL_LINES);
     Point o = m_line.projection(m_centroid);
     Point a = o + normalize(m_line.to_vector());
     Point b = o - normalize(m_line.to_vector());
-    viewer->glVertex3d(a.x(),a.y(),a.z());
+    GLfloat verts[6];
-    viewer->glVertex3d(b.x(),b.y(),b.z());
+    verts[0]=a.x();verts[1]=a.y();verts[2]=a.z();
-    viewer->glEnd();
+    verts[3]=b.x();verts[4]=b.y();verts[5]=b.z();
+    
+    
+    vao[1].bind();
+    buffers[1].bind();
+    buffers[1].allocate(verts, 6*sizeof(GLfloat));
+    rendering_program.setAttributeBuffer("vertex", GL_FLOAT, 0,3);
+    rendering_program.enableAttributeArray("vertex");
+    buffers[1].release();
+    viewer->glDrawArrays(GL_LINES, 0, 2);
+    vao[1].release();
 }
 
 void Scene::render_centroid(Viewer* viewer)
 { 
-    viewer->glPointSize(10.0f);
+    GLfloat verts[3];
-    viewer->glColor3ub(0,128,0);
+    verts[0]=m_centroid.x();verts[1]=m_centroid.y();verts[2]=m_centroid.z();
-    viewer->glBegin(GL_POINTS);
+    
-    viewer->glVertex3d(m_centroid.x(),m_centroid.y(),m_centroid.z());
+    vao[2].bind();
-    viewer->glEnd();
+    buffers[2].bind();
+    buffers[2].allocate(verts, 3*sizeof(GLfloat));
+    rendering_program.setAttributeBuffer("vertex", GL_FLOAT, 0,3);
+    rendering_program.enableAttributeArray("vertex");
+    buffers[2].release();
+    viewer->glDrawArrays(GL_POINTS, 0, 1);
+    vao[2].release();
 }
 
 
@@ -155,10 +191,30 @@ void Scene::render_polyhedron(Viewer *viewer)
     // draw black edges
     if(m_pPolyhedron != NULL)
     {
-        viewer->glDisable(GL_LIGHTING);
+      typedef typename Polyhedron::Traits Kernel;
-        viewer->glColor3ub(0,0,0);
+      typedef typename Kernel::Point_3 Point;
-        viewer->glLineWidth(1.0f);
+    
-        gl_render_edges(*m_pPolyhedron, viewer);
+      std::vector<GLfloat> verts;
+      
+      typename Polyhedron::Edge_iterator he;
+      for(he = m_pPolyhedron->edges_begin();
+          he != m_pPolyhedron->edges_end();
+          he++)
+      {
+        const Point& a = he->vertex()->point();
+        const Point& b = he->opposite()->vertex()->point();
+        verts.push_back(a.x());verts.push_back(a.y());verts.push_back(a.z());
+        verts.push_back(b.x());verts.push_back(b.y());verts.push_back(b.z());
+      }
+    
+      vao[3].bind();
+      buffers[3].bind();
+      buffers[3].allocate(verts.data(), static_cast<int>(verts.size()*sizeof(GLfloat)));
+      rendering_program.setAttributeBuffer("vertex", GL_FLOAT, 0,3);
+      rendering_program.enableAttributeArray("vertex");
+      buffers[3].release();
+      viewer->glDrawArrays(GL_LINES, 0, verts.size()/3);
+      vao[3].release();
     }
 }
 
@@ -254,7 +310,60 @@ void Scene::fit_vertices()
     std::cout << "done" << std::endl;
 }
 
+void Scene::gl_init()
+{
+  //Vertex source code
+  const char vertex_source[] =
+  {
+      "#version 120 \n"
+      "attribute highp vec4 vertex;\n"
+      "uniform highp mat4 mvp_matrix;\n"
+      "void main(void)\n"
+      "{\n"
+      "   gl_PointSize = 10.0;\n"
+      "   gl_Position = mvp_matrix * vertex;\n"
+      "}"
+  };
+  //Vertex source code
+  const char fragment_source[] =
+  {
+      "#version 120 \n"
+      "uniform highp vec4 color; \n"
+      "void main(void) { \n"
+      "  gl_FragColor = color; \n"
+      "} \n"
+      "\n"
+  };
+  QOpenGLShader *vertex_shader = new QOpenGLShader(QOpenGLShader::Vertex);
+  if(!vertex_shader->compileSourceCode(vertex_source))
+  {
+      std::cerr<<"Compiling vertex source FAILED"<<std::endl;
+  }
 
+  QOpenGLShader *fragment_shader= new QOpenGLShader(QOpenGLShader::Fragment);
+  if(!fragment_shader->compileSourceCode(fragment_source))
+  {
+      std::cerr<<"Compiling fragmentsource FAILED"<<std::endl;
+  }
 
+  if(!rendering_program.addShader(vertex_shader))
+  {
+      std::cerr<<"adding vertex shader FAILED"<<std::endl;
+  }
+  if(!rendering_program.addShader(fragment_shader))
+  {
+      std::cerr<<"adding fragment shader FAILED"<<std::endl;
+  }
+  if(!rendering_program.link())
+  {
+      std::cerr<<"linking Program FAILED"<<std::endl;
+  }
   
+  for(int i=0; i< 4; ++i)
+  {
+    buffers[i].create();
+    vao[i].create();
+  }
+  is_gl_init = true;
+}
 

Principal_component_analysis/demo/Principal_component_analysis/Scene.h

@@ -4,7 +4,9 @@
 
 #include <iostream>
 #include <cmath>
-
+#include <QOpenGLShaderProgram>
+#include <QOpenGLBuffer>
+#include <QOpenGLVertexArrayObject>
 #include "types.h"
 class Viewer;
 
@@ -28,6 +30,11 @@ private:
     Plane m_plane;
     Point m_centroid;
     Polyhedron *m_pPolyhedron;
+    QOpenGLShaderProgram rendering_program;
+    QOpenGLBuffer buffers[4];
+    QOpenGLVertexArrayObject vao[4];
+    bool is_gl_init;
+    void gl_init();
 
     // view options
     bool m_view_polyhedron;

Principal_component_analysis/demo/Principal_component_analysis/Viewer.cpp

@@ -25,8 +25,8 @@ void Viewer::draw()
 void Viewer::initializeGL()
 {
   CGAL::QGLViewer::initializeGL();
-  makeCurrent();
+  //makeCurrent();
-  initializeOpenGLFunctions();
+  //initializeOpenGLFunctions();
   setBackgroundColor(::Qt::white);
 }
 

Principal_component_analysis/demo/Principal_component_analysis/render_edges.h

@@ -1,30 +0,0 @@
-#ifndef _GL_RENDER_EDGES_
-#define _GL_RENDER_EDGES_
-
-#include "Viewer.h"
-
-template <class Polyhedron>
-void gl_render_edges(Polyhedron& polyhedron, Viewer* viewer)
-{
-  typedef typename Polyhedron::Traits Kernel;
-  typedef typename Kernel::Point_3 Point;
-
-  viewer->glBegin(GL_LINES);
-  typename Polyhedron::Edge_iterator he;
-  for(he = polyhedron.edges_begin();
-      he != polyhedron.edges_end();
-      he++)
-  {
-    const Point& a = he->vertex()->point();
-    const Point& b = he->opposite()->vertex()->point();
-    viewer->glVertex3d(a.x(),a.y(),a.z());
-    viewer->glVertex3d(b.x(),b.y(),b.z());
-  }
-  viewer->glEnd();
-} 
-
-#endif // _GL_RENDER_EDGES_
-
-
-
-