Visualizzatore di nuvole di punti con GLFW e PCL

Per imparare un po' di librerie mi sono fatto il mio visualizzatore di nuvole di punti

Volevo includere ImGui o NanoGui per settare i valori delle variabili ma non riesco a trovare il modo di compilarli

 https://github.com/c1p81/cloudpoint_glfw

La visualizzazione si modifica con i tasti freccia/pg up-down ed il mouse

Compilare OpenGl con CodeBlocks

Per compilare gli esempi di OpenGL derivanti dal sito Nehe in Windows si puo' prima installare Code::Blocks con MingW
Successivamente si installa la libreria OpenGL scaricando questo file (vedi sito originale)
A questo punto si copia manualmente.
1) il file glut32.dll in C:\Windows\System32
2) il file libglut32.a in C:\Programmi\CodeBlocks\MinGW\lib
3) il file glut.h in C:\Programmi\CodeBlocks\MinGW\include


Fatto cio' si puo' creare un nuovo progetto vuoto e con clic destro si selezionano le Build Options (vedi figura sottostante)

Nel tab Linker Settings si aggiungono opengl32, glu32 e glut32

Si puo' quindi procedere con la compilazione con il primo degli esempi OpenGl di Nehe

Errore OpenGl (FreeGlut) in Virtualbox

UPDATE 2

------------------------------------------------------------

Dopo un po' di prove ho isolato il problema

Il programma che disegna il cubo e che funzionava in CentOS e non in Debian ha smesso di funzionare nel momento in cui ho installato le Guest Additions alla macchina CentOS.

Per cui il difetto non e' nelle librerie OpenGL ma nell'implementazione OpenGL fatta da Virtualbox nelle Guest Additions

--------------------------------------------------------------

UPDATE

------------------------------------------------------------

ho riprovato dopo un po' di tempo e mi sono reso conto che l'errore di segmentazione su VirtualBox delle OpenGL non e' totalmente a carico di software di virtualizzazione

Infatti questo codice

//////////////////////////////////////////////////////////////

#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>

void init(void) 
{
   glClearColor (0.0, 0.0, 0.0, 0.0);
   glShadeModel (GL_FLAT);
}

void display(void)
{
   glClear (GL_COLOR_BUFFER_BIT);
   glColor3f (1.0, 1.0, 1.0);
   glLoadIdentity ();             /* clear the matrix */
           /* viewing transformation  */
   gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
   glScalef (1.0, 2.0, 1.0);      /* modeling transformation */ 
   glutWireCube (1.0);
   glFlush ();
}

void reshape (int w, int h)
{
   glViewport (0, 0, (GLsizei) w, (GLsizei) h); 
   glMatrixMode (GL_PROJECTION);
   glLoadIdentity ();
   glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
   glMatrixMode (GL_MODELVIEW);
}

int main(int argc, char** argv)
{
   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
   glutInitWindowSize (500, 500); 
   glutInitWindowPosition (100, 100);
   glutCreateWindow (argv[0]);
   init ();
   glutDisplayFunc(display); 
   glutReshapeFunc(reshape);
   glutMainLoop();
   return 0;
}

//////////////////////////////////////////////////////////////

compilato con 

gcc cubo.cpp -lglut -lGLU

Su Debian Testing in Virtuabox crasha brutalmente

Invece su CentOS , installando le librerie come segue

yum install freeglut freeglut-devel libX11-devel mesa-libGLU-devel

il programma funziona correttamente

c'e' da dire che CentOS usa generalmente librerie e programmi piu' vecchi rispetto a Debian Testing per cui il problema potrebbe essere proprio da ricercare nelle librerie OpenGL ed il non aggiornamento di Virtualbox

------------------------------------------------------------

Tentando di compilare il sorgente sottostante (un esempio di OpenGl) in una Debian Box in VirtualBox e' comparso il seguente messaggio


OpenGL Warning: XGetVisualInfo returned 0 visuals for 0x8807240
OpenGL Warning: Retry with 0x8002 returned 0 visuals

Errore di segmentazione

----------------------------------------
#include "GL/freeglut.h"
#include "GL/gl.h"

/* display function - code from:
     http://fly.cc.fer.hr/~unreal/theredbook/chapter01.html
This is the actual usage of the OpenGL library. 
The following code is the same for any platform */
void renderFunction()
{
    glClearColor(0.0, 0.0, 0.0, 0.0);
    glClear(GL_COLOR_BUFFER_BIT);
    glColor3f(1.0, 1.0, 1.0);
    glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
    glBegin(GL_POLYGON);
        glVertex2f(-0.5, -0.5);
        glVertex2f(-0.5, 0.5);
        glVertex2f(0.5, 0.5);
        glVertex2f(0.5, -0.5);
    glEnd();
    glFlush();
}

/* Main method - main entry point of application
the freeglut library does the window creation work for us, 
regardless of the platform. */
int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE);
    glutInitWindowSize(500,500);
    glutInitWindowPosition(100,100);
    glutCreateWindow("OpenGL - First window demo");
    glutDisplayFunc(renderFunction);
    glutMainLoop();    
    return 0;
}
----------------------------------------

Il problema e' relativo alla software di virtualizzazione (Virtualbox) che, nonostante sia spuntato l'utilizzo dell'accelerazione 3D, non gestisce in modo corretto OpenGL e quindi genera un errore che su una macchina reale sarebbe assente

Mandelbrot in OpenGL su Linux/Debian

In questo post viene presentato un programma per creare l'insieme di Mandelbrot in OpenGL.
Questa specifica permette di scrivere codice astraendosi dai differenti acceleratori grafici con API uniformi tra le varie piattaforme in cui e' implementata OpenGL ed e' necessario avere una scheda grafica abilitata per poter funzionare

In Debian, per programmare in OpenGL, si deve installare FreeGlut (Glut e' una estensione ad OpenGL che permette di gestire la creazione delle finestre e gli eventi da tastiera anche questa indipendente tra varie piattaforme)

apt-get install freeglut3-dev

Mandelbrot in OpenGL

Per compilare il codice sottostante si usa la seguente stringa

g++ -Wall -O3 mandel.cpp -o mandel -lglut -lGLU

il codice utilizzato e' sempre quello di base gia' presentato nei precedenti esempi e sono evidenziate in giallo le direttive tipiche di OpenGL
Si deve evidenziare che in questo caso viene utilizzato un Double Buffering RGB
La cosa curiosa utilizzando OpenGL (rispetto all'esperienza con altre librerie) e' il modo di mappare i pixel
In pratica il numero di pixel non e' per definizione quella massima della finestra creata ma deve essere esplicitamente definito da gluOrtho2D(0.0,640.0,0.0,480.0);
Nel caso in cui non si glVertex2i (che accetta come input coordinate intere) ma glVertex2f (coordinate float) lo spazio delle coordinate e' compreso tra -1.0 e 1.0
--------------------------------------------------
#include <GL/gl.h>
#include <GL/glut.h>

#include <stdio.h>

#define SCREEN_WIDTH 640
#define SCREEN_HEIGHT 480


float re_min = -2.0;
float im_min = -1.2;

float re_max = 1.0;
float im_max = 1.2;

int iterazioni = 1024;


float a,b;
float x,y,x_new,y_new;

int test;

int k,j,i;
 
void disegna()
{

    float re_factor = (re_max-re_min);
    float im_factor = (im_max-im_min);
   
    glColor3f(1, 1, 1);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();


    glClear(GL_COLOR_BUFFER_BIT);
    glBegin (GL_POINTS);

    for (i=0;i<SCREEN_HEIGHT;i++)
     {
     for (j=0;j<SCREEN_WIDTH;j++)
      {
      a = re_min+(j*re_factor/SCREEN_WIDTH);
      b = im_min+(i*im_factor/SCREEN_HEIGHT);
     
      x = 0;
      y = 0;
      test = 0;
     
      for (k=0;k<iterazioni;k++)
       {
       x_new = (x*x)-(y*y)+a;
       y_new = (2*x*y)+b;
       if (((x_new*x_new)+(y_new*y_new))>4)
        {
        test = k;
        if (k%2 == 0) glVertex2i(j,i);        
        break;
        }
       x = x_new;
       y = y_new;
       }
            
      }
   
     }
    glEnd();            
    glutSwapBuffers();   
}

int main(int argc, char* argv[])
{
    glutInit (&argc, argv);
    glutInitDisplayMode (GLUT_RGB|GLUT_DOUBLE);
    glutInitWindowSize(SCREEN_WIDTH, SCREEN_HEIGHT);
    glutInitWindowPosition(0, 0);
    glutCreateWindow("Mandelbrot");
    gluOrtho2D(0.0,640.0,0.0,480.0);
    glutDisplayFunc(disegna);
    glutMainLoop();
    return 0;
}

Freeglut su Virtualbox

Per fare qualche prova ho deciso di provare FreeGlut su una macchina virtuale
Per prima cosa si deve abilitare il supporto di accelerazione 3D alla macchina virtuale (altrimenti le librerie FreGlut si rifiutano di funzionare)òl

per il test ho provato ad usare il codice presente a questo link compilando mediante la riga di comando
g++ test.cpp -o test -lglut

lanciando l'eseguibile viene risposto con il seguente errore

-------------------------------------------

luca@debian:~$ ./test 
OpenGL Warning: XGetVisualInfo returned 0 visuals for 0x8b484e8
OpenGL Warning: Retry with 0x8002 returned 0 visuals
Errore di segmentazione

-------------------------------------------

la soluzione a questo errore, ripresa da questo sito, e' la seguente

-------------------------------------------

export LIBGL_ALWAYS_INDIRECT=1

-------------------------------------------

una volta modificata questa variabile di ambiente rilanciando l'eseguibile il risultato e' quello atteso