c++ - tipos - Proyección de mapas con Kinect y OpenGL

que proyeccion cartografica se usa en colombia

Question

Actualmente estoy usando un software JavaCV llamado procamcalib para calibrar una configuración Kinect-Projector, que tiene la cámara Kinect RGB como origen. Esta configuración consiste únicamente en una cámara Kinect RGB (estoy usando aproximadamente el Kinect como una cámara ordinaria en este momento) y un proyector. Este software de calibración utiliza LibFreenect (OpenKinect) como el controlador de Kinect.

Una vez que el software complete su proceso, me dará los parámetros intrínsecos y extrínsecos de la cámara y el proyector, que se lanzarán a un software OpenGL para validar la calibración y es donde comienzan algunos problemas. Una vez que la proyección y la vista de modelo estén correctamente configuradas, debería poder adaptar lo que Kinect ve a lo que se proyecta, pero para lograrlo tengo que hacer una traducción manual en los 3 ejes y esta última parte no está haciendo cualquier sentido para mí! ¿Podrían por favor ayudarme a resolver esto? El SDK utilizado para recuperar datos de Kinect es OpenNI (no es la última versión 2.x, debería ser 1.5.x)

Explicaré exactamente lo que estoy haciendo para reproducir este error. Los parámetros de calibración se usan de la siguiente manera:

La matriz de proyección se establece como (basada en http://sightations.wordpress.com/2010/08/03/simulating-calibrated-cameras-in-opengl/ ):

r = width/2.0f;         l = -width/2.0f;
t = height/2.0f;        b = -height/2.0f;

alpha = fx;      beta = fy;
xo    = cx;      yo   = cy;

X = kinectCalibration.c_near + kinectCalibration.c_far;
Y = kinectCalibration.c_near*kinectCalibration.c_far;

d = kinectCalibration.c_near - kinectCalibration.c_far;


float* glOrthoMatrix = (float*)malloc(16*sizeof(float));

glOrthoMatrix[0] = 2/(r-l); glOrthoMatrix[4] = 0.0f;        glOrthoMatrix[8] = 0.0f;        glOrthoMatrix[12] = (r+l)/(l-r);
glOrthoMatrix[1] = 0.0f;    glOrthoMatrix[5] = 2/(t-b);     glOrthoMatrix[9] = 0.0f;        glOrthoMatrix[13] = (t+b)/(b-t);
glOrthoMatrix[2] = 0.0f;    glOrthoMatrix[6] = 0.0f;        glOrthoMatrix[10] = 2/d;        glOrthoMatrix[14] = X/d;
glOrthoMatrix[3] = 0.0f;    glOrthoMatrix[7] = 0.0f;        glOrthoMatrix[11] = 0.0f;       glOrthoMatrix[15] = 1;
printM( glOrthoMatrix, 4, 4, true, "glOrthoMatrix" );


float* glCameraMatrix = (float*)malloc(16*sizeof(float));

glCameraMatrix[0] = alpha;  glCameraMatrix[4] = skew;   glCameraMatrix[8] = -xo;    glCameraMatrix[12] = 0.0f;
glCameraMatrix[1] = 0.0f;   glCameraMatrix[5] = beta;   glCameraMatrix[9] = -yo;    glCameraMatrix[13] = 0.0f;
glCameraMatrix[2] = 0.0f;   glCameraMatrix[6] = 0.0f;   glCameraMatrix[10] = X;     glCameraMatrix[14] = Y;
glCameraMatrix[3] = 0.0f;   glCameraMatrix[7] = 0.0f;   glCameraMatrix[11] = -1;    glCameraMatrix[15] = 0.0f;

float* glProjectionMatrix = algMult( glOrthoMatrix, glCameraMatrix );

Y la matriz Modelview está configurada como:

proj_loc = new Vec3f(   proj_RT[12], proj_RT[13], proj_RT[14] );    
proj_fwd = new Vec3f(   proj_RT[8],  proj_RT[9],  proj_RT[10] );
proj_up  = new Vec3f(   proj_RT[4],  proj_RT[5],  proj_RT[6]  );
proj_trg = new Vec3f(   proj_RT[12] + proj_RT[8], 
                        proj_RT[13] + proj_RT[9], 
                        proj_RT[14] + proj_RT[10] );

gluLookAt( proj_loc[0], proj_loc[1], proj_loc[2],
           proj_trg[0], proj_trg[1], proj_trg[2],
           proj_up[0],  proj_up[1],  proj_up[2] );

Y finalmente la cámara se muestra y se mueve con:

glPushMatrix();
glTranslatef(translateX, translateY, translateZ); 
drawRGBCamera();
glPopMatrix();

donde los valores de traducción se ajustan manualmente con el teclado hasta que tenga una coincidencia visual (estoy proyectando en la placa de calibración lo que está viendo la cámara Kinect-rgb, entonces ajusto manualmente la cámara abierta hasta que el patrón proyectado coincida con el patrón impreso )

Mi pregunta aquí es ¿POR QUÉ tengo que hacer este ajuste manual? La vista de modelo y la configuración de proyección deberían solucionarlo.

También estaba deambulando si hay algún problema al cambiar los controladores de esa manera, ya que OpenKinect se utiliza para la calibración y OpenNI para la validación. Esto vino a la mente cuando se investigaba otra herramienta de calibración popular llamada RGBDemo, donde dice que si se utiliza el backend LibFreenect, se necesita una calibración Kinect.

Entonces, ¿una calibración saldrá mal si se hace con un controlador y se muestra con otro?

¿Alguien piensa que será más fácil lograr el éxito si esto se hace con OpenCV en lugar de OpenGL?

Referencia de JavaCV: https://code.google.com/p/javacv/
"Papel corto" Procamcalib: http://www.ok.ctrl.titech.ac.jp/~saudet/research/procamcalib/
Código fuente de Procamcalib: https://code.google.com/p/javacv/source/browse?repo=procamcalib
Referencia de calibración RGBDemo: http://labs.manctl.com/rgbdemo/index.php/Documentation/Calibration

Puedo subir más cosas si es necesario, solo díganme qué necesitan para ayudarme :)

Answer 1

Para la calibración de Kinect, eche un vistazo a la última versión 0.7 de RGBDemo http://labs.manctl.com/rgbdemo y la correspondiente fuente de calibración Freenect .

Desde el v0.7.0 ChangeLogs:

Nuevas características desde v0.6.1:

• Nueva demostración para adquirir modelos de objetos usando marcadores
• Modo de calibración simple para rgbd-multikinect
• Agarre mucho más rápido en rgbd-multikinect
• Agregue marcas de tiempo y números de serie de la cámara al guardar en el disco
• Compatibilidad con PCL 1.4 Varias correcciones de errores

Un buen libro para seguir es la Programación de Gráficos 3D Modernos de Jason McKesson . También puede leer la página ROS de Kinect y la página de Calibración Kinect de Nicolas .

Answer 2

Soy el autor del artículo al que se vinculó y creo que puedo ayudarlo.

El problema está en cómo está configurando su matriz de vista modelo. Está utilizando la tercera columna de proj_RT como posición de la cámara cuando llama a gluLookAt (), pero no es la posición de la cámara, es la posición del origen mundial en las coordenadas de la cámara . Escribí un artículo para mi nuevo blog que podría ayudar a aclarar esto. Describe tres formas diferentes (equivalentes) de interpretar la matriz extrínseca, con demostraciones WebGL de cada una:

http://ksimek.github.io/2012/08/22/extrinsic/

Si debe usar gluLookAt, este artículo le mostrará cómo hacerlo, pero es mucho más simple llamar a glLoadMatrix(proj_RT) .

tl; dr: reemplazar gluLookAt() con glLoadMatrix(proj_RT)