Ubicando mi proyecto: Publicidad y Realidad Aumentada

Numerosísimos son los ejemplos de utilidad y aplicación de la Realidad Aumentada que en la actualidad existen en el campo de la Publicidad. Igualmente, y en consecuencia si se tiene en cuenta la aplicación de estas innovadoras tecnologías en otros muchos campos, existen numerosas propuestas técnicas desarrolladas y/o en continuo desarrollo que posibilitan la creación de aplicaciones y la explotación de todas las posibilidades que la Realidad Aumentada ofrece. En este post citaré algunas aplicaciones representativas que me han llevado a descubrir la necesidad de proponer una solución técnica a las necesidades de detección y localización de objetos planos en una imagen real sin la existencia de marcadores y el “blending” de una imagen virtual 2D sobre estos que se proponen en este proyecto.  

London National Gallery

AR London National Gallery

Los principales museos del mundo están apuntándose al uso de la Realidad Aumentada para publicitarse y para potenciar la iteración de los visitantes con sus colecciones. La London National Gallery   hizo una campaña publicitaria en Trafalgar Square para publicitarse. En ella,  apuntando con un dispositivo móvil hacia la fachada del museo aparecía un anuncio publicitario sobre sus nuevas aplicaciones, apuntando hacia una de las estatuas de la plaza aparecía un vídeo explicativo, o en las escaleras de la Galería aparecía un dragón. Este es un buen ejemplo de detección y localización en exteriores y sin marcadores.


Catálogo IKEA
No por archiconocido y renombrado se puede dejar de nombrar un clásico en el mundo de la publicidad con realidad aumentada. Desde hace algunos años, la marca IKEA  permite al cliente visualizar sus productos y colocarlos en su ubicación final, perfectamente alineados con el entorno real. Este es un buen ejemplo de utilización de marcadores en ambiente interior. La solución que se propone en este proyecto puede evitar el uso de marcadores para conseguir las mismas prestaciones.

AR en el catálogo de IKEA

Edificio N Building

AR en edificio N Building

N building es un edificio comercial que está situado cerca de Tachikawa (Tokio). Su principal característica son sus paredes, forradas de códigos QR permiten dar información a sus visitantes sobre los establecimientos que allí se encuentran y sobre sus productos y servicios. Mediante la descarga de una aplicación para Smartphones, es posible enfocar su cámara sobre el edificio y obtener abundante información sobre los establecimientos presentes. Éstos pueden publicitarse y, además, según la época del año mostrar algún otro tipo de información; por ejemplo, un árbol de navidad en diciembre.

Este es otro buen ejemplo de utilización de marcadores en ambiente exterior. Al igual que en el ejemplo anterior, la solución propuesta puede evitar el uso de marcadores para conseguir las mismas prestaciones.

Mejoramos nuestra aplicación RA: estabilizamos el tracking

Os presento ahora una importante mejora que podemos introducir en nuestros programas de Realidad Aumentada: se trata de mejorar el tracking de marcadores para conseguir una imagen capturada más estabilizada. Para ello, utilizaremos la función histórica de ARToolKit.

ARToolKit incorpora una función de tratamiento del histórico de percepciones para estabilizar el tracking. Este histórico se implementa en una función alternativa a arGetTransMat que, en realidad, utiliza únicamente la percepción anterior, llamada arGetTransMatCont. Mediante el uso de esta función se elimina gran parte del efecto de registro tembloroso.

Salida del programa con histórico

La función histórica requiere como parámetro la percepción anterior y no podrá utilizarse hasta que no dispongamos (al menos) de una percepción. Por esta razón, es necesario llamar primero a la función sin histórico arGetTransMat y, con la primera percepción, llamar a la función de histórico arGetTransMatCont. Esto lo conseguimos modificando ligeramente el código de la función mainLoop, una vez detectado el marcador, de la siguiente forma:

   if(k != -1) {   // Si ha detectado el patron en algun sitio... obtenemos
                   // transformacion relativa entre marca y la camara real
      if (useCont && contAct) {
            arGetTransMatCont(&marker_info[k], patt_trans, p_center,
            p_width, patt_trans);
            printf ("Usando historico!!!\n");
         }
      else {
            useCont = 1;      // En la siguiente iteracion lo podemos usar!
            arGetTransMat(&marker_info[k], p_center, p_width, patt_trans);
            printf ("Sin historico...\n");
         }
      draw();       // Dibujamos los objetos de la escena
  } else {
      useCont = 0;
      printf ("Reset Historico (fallo de deteccion)\n");
  } 

Utilizamos la variable  useCont (definida anteriormente) para indicarnos si ya podemos utilizar la función con histórico o no, en función de que tengamos capturado o no el primer frame. Esta variable de comportamiento booleano se tendrá que poner a false (valor 0) cuando no se detecte la marca. De este modo, si el usuario activó el uso del histórico (y ya tenemos al menos una percepción previa de la marca, utilizamos la función con histórico. En otro caso, llamaremos a la función de detección sin histórico y activaremos el uso del histórico para la siguiente llamada.

En nuestro programa, imtroducimos también una función de callback de teclado que permite activar el uso del histórico mediante la tecla h:

  // ======== keyboard ================================================
  static void keyboard(unsigned char key, int x, int y) {
  switch (key) {
      case 'H': case 'h':
                if (contAct) {contAct = 0; printf("Historico Desactivado\n");}
                else {contAct = 1; printf("Historico Activado\n");} 
                break;
      case 0x1B: case 'Q': case 'q':
                cleanup(); exit(1); 
                break;
      }
   }

Salida del programa

Salida del programa 

Esta es la salida del programa y los siguientes enlaces permiten descargar el código y el marcador utilizado (imagen para impresión y datos para el programa) y los ficheros de inicialización de la cámara. Todos los ficheros deberán estar en ...artoolkit\bin\Data.

código del programa histórico
marcador meditel
ficheros cámara

Modificamos nuestra aplicación RA para detectar varios patrones

Con unos sencillos cambios podemos modificar nuestra primera aplicación de Realidad Aumentada para que reconozca en la escena varios marcadores, asociando a cada uno de ellos una imagen tridimensional diferente. Os mostraré cómo reconocer cinco marcadores para dibujar cinco objetos diferentes. Podéis descargaros el código y los ficheros necesarios mediante los links correspondientes en este post.

A la hora de realizar una aplicación de Realidad Aumentada que sea capaz de reconocer diferentes patrones asignando imágenes u objetos 3D distintos a cada uno de ellos, tendremos que tener en cuenta las siguientes cambios: (en la imagen se ve la salida del programa ejemplo para dos marcadores distintos)

1. Cargaremos un fichero de datos que contenga información sobre varios patrones en lugar del fichero de patrón ya utilizado pattMeditel.
2. Utilizaremos, también, una estructura de datos asociada a los patrones diferente; que permita almacenar varios patrones.
3. Modificaremos la función de dibujo draw para poder dibujar diferentes objetos en función del patron detectado.

Carga del fichero de datos de los patrones

El fichero de datos que contiene información de todos los marcadores es mi_object_data (es un fichero de texto con una estructura muy sencilla que contiene, para cada marcador, su nombre, el nombre de su fichero de datos y la anchura y centro del marcador; puedes descargarlo aquí). Para cargarlo en el programa, primero definiremos las variables:

   // ==== Fichero Object Data =========================================
   char            *model_name = "Data/mi_object_data";
   ObjectData_T    *object;

   int             objectnum;

A continuación, en la función init, cargamos el fichero mediante una función de ARToolKit definida en object.c llamada read_ObjData a la que le pasamos el fichero de datos y el número de marcadores definidos en él. Los datos referentes a las marcas quedan almacenados en una estructura de datos ObjectData_T específica de ARToolKit. Aquí os dejo el código que hace esto:

  // Cargamos el fichero mi_object_data 

  if ((object = read_ObjData(model_name, &objectnum)) == NULL) exit(0);

  printf("Objectfile num = %d\n", objectnum);

Detección de patrones

ARToolKit puede ahora tratar de identificar varios patrones en la rutina arDetectMarker. Puesto que ahora la detección es para múltiples marcadores, una vez detectado una marca con mayor fiabilidad, habrá que comprobar si se trata de un patrón conocido (presente en el fichero cargado). En este ejemplo, dibujamos también sus bordes cuando esto ocurre. Por otra parte, también es necesario mantener la transformación específica para cada uno de los marcadores detectados. La parte de código que hace esto será:

   // busca patrones conocidos en los marcadores detectados y dibuja un cuadrado

   // de otro color sobre los patrones reconocidos

   for (i = 0; i < objectnum; i++) {

      k = -1;

      for (j = 0; j < marker_num; j++) {

      if (object[i].id == marker_info[j].id) {   //si reconoce un patron

          glColor3f(0.0, 1.0, 0.0);

          argDrawSquare(marker_info[j].vertex, 0, 0);

              if (k == -1) k = j;

          else       // Vemos donde detecta el patron con mayor fiabilidad

           if (marker_info[k].cf < marker_info[j].cf) k = j;

         }

      }

       if (k == -1) {

          object[i].visible = 0;

          continue;

          }

       // calculamos la transformada para cada patron reconocido.

       object[i].visible = 1;

       arGetTransMat(&marker_info[k], object[i].marker_center, 

       object[i].marker_width,

       object[i].trans);

    }

Hay una bandera del visiblitdad asociada con cada marcador, y se realizará una nueva transformación para cada marcador detectado.

Dibujado del objeto asociado al marcador

Para dibujar el objeto asociado al marcador detectado, se llama a la función draw con la estructura ObjectData_T  y el número de objetos como parámetros. Dentro de esta función, se convertimos la matriz de transformación a formato openGL para cada marcador detectado:

    for (i = 0; i < objectnum; i++) {

      if (object[i].visible == 0) continue;

      argConvGlpara(object[i].trans, gl_para);  

          draw_object(object[i].id, gl_para);

    }

Finalmente, dibujamos el objeto asociado al marcador detectado a través de la subrutina draw_object que, mediante la anidación de funciones if selecciona el objeto para cada marcador (pondré solo un ejemplo):

    if (obj_id == 0){

       glMaterialfv(GL_FRONT, GL_SPECULAR, mat_flash_collide);

       glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient_collide);

       glTranslatef(0.0, 0.0, 30.0);

       glutSolidSphere(30, 12, 6);    // dibujamos una esfera

    }

Salida del programa

La salida de este programa detectando dos marcadores diferentes, con sus correspondientes objetos asociados (en este caso una esferarosa y un conjunto esfera-toroide azul) puede verse en la imagen siguiente:

Salida del programa de detección de varios marcadores

Creando mis propios marcadores

ARToolKit pone a nuestra disposición una serie de marcadores reconocibles y utilizables por sus funciones. Pero, ¿por qué no utilizar nuestros propios marcadores? ¿por qué no personalizar o utilizar nuestro logo o nuestras imágenes favoritas como patrón de un marcador?

Existen muchos métodos para realizar un marcador. De hecho, lo más sencillo es partir de una plantilla de marcador en blanco y con cualquier programa de imagen, insertar nuestro patrón en su interior. Pero con cuidado, tenemos que respetar algunas restricciones si queremos que nuestra marca pueda ser detectada sin problemas. Al final del post os dejo algunos consejos.

Generación de marcadores con mk_patt

Una vez creado el marcador, tiene que ser reconocido por ARToolKit y entrenado para generar su fichero de datos correspondiente. Para ello, ARToolKit proporciona una sencilla aplicación, mk_patt, que nos pedirá el fichero de parámetros de la cámara y abrirá una ventana de vídeo. Entonces mostraremos a la cámara nuestro marcador impreso y aparecerán en su contorno una esquina roja y otra verde. Tenemos que orientar la cámara hasta situar el contorno rojo en la esquina superior izquierda de nuestro marcador y, en ese momento, pulsar el botón izquierdo del ratón para generar el fichero del marcador. Este fichero se introduce como dato en nuestros programas ARToolKit.

Este proceso de generación de marcadores están perfectamente definidos en el apartado de documentación de la web de ARToolKit. Os dejo también un acceso a la plantilla de marcador en blanco.

Consejos sobre marcadores

• El patrón debe ser sencillo. El rango de detección se ve afectado por la complejidad de la marca. Los patrones simples (con grandes áreas de color blanco o negro) son detectados mejor.
• No debe tener simetrías.
• Cuanto mayor es la resolución del patrón reescalado, mayor es la precisión de ARToolKit, pero requiere más capacidad de cómputo para realizar las operaciones.
• El tamaño físico de la marca afecta directamente a la facilidad de detección; a mayor tamaño de marca, mayor distancia puede ser cubierta. Por ejemplo, marcas de 7 cm de lado pueden ser detectadas hasta una distancia máxima de 40 cm (a una resolución de 640x480 píxels). Si aumentamos el tamaño de la marca a 18cm, ésta será detectada hasta una distancia de 125cm.
• Finalmente las condiciones de iluminación afectan enormemente a la detección de las marcas. El uso de materiales que no ofrezcan brillo especular, y que disminuyan el reflejo en las marcas mejoran notablemente la detección de las marcas.

ARToolKit: funcionamiento básico

Para los que hayáis leído mi entrada "Mi primera aplicación de Realidad Aumentada" en la que explico a través de un sencillo programa la estructura y funcionamiento básico de una aplicación de Realidad Aumentada, en este post desarrollaré algo más el funcionamiento básico de ARToolKit.

Lo esencial en todas las aplicaciones de Realidad Aumentada, es la  necesidad de calcular correctamente el punto de vista de la cámara, para así poder realizar las operaciones necesarias sobre los objetos virtuales, para que estos se integren correctamente en el mundo real. Es decir, si queremos mostrar objetos virtuales, de modo que el usuario realmente crea que existen en el mundo real, tendremos que realizar transformaciones sobre dichos objetos de modo que el usuario los vea (a través de la cámara o dispositivo de captura utilizado) en la posición  con el tamaño, orientación e iluminación, en que esos objetos serían percibidos por el usuario en el mundo real en caso de que realmente estuvieran allí.

Marcador meditel

Para ello, herramientas como ARToolKit utilizan unas plantillas (marcadores) de forma cuadrada normalmente, formadas por un cuadrado negro con un cuadrado blanco unas cuatro veces más pequeño en su centro, y un dibujo (patrón) en el interior del cuadrado blanco. Este dibujo debe ser sencillo y evitar las simetrías. Nuestro programa será capaz de detectar una de estas plantillas en las imágenes de vídeo capturadas utilizando mediante un potente algoritmo de detección de contornos implementado en las funciones y utilidades proporcionadas por ARToolKit.

Una vez detectado el marcador en una imagen, a partir de su orientación, posición y tamaño, la aplicación es capaz de calcular la posición y orientación relativa de la cámara real respecto al marcador y dibujar el objeto 3D sobre la imagen capturada de modo que aparezca sobre el marcador en la posición, orientación y tamaño correspondiente al punto de vista de la cámara (perfectamente alineado). Esto siempre que el programador de la aplicación así lo haya decidido, pues las posibilidades son muchas y pudiera ser que una vez obtenida esta información el programador decidiese utilizarla de otra forma, hacer otras operaciones distintas, etc. Para el renderizado del objeto se utilizan librerías externas a ARToolKit (por ejemplo GLUT y OpenGL).

El proceso básico de una aplicación ARToolkit es el siguiente:

Proceso de detección
de  marcas en ARToolKit

1. Primero se captura un fotograma del mundo real mediante la cámara.
2. A continuación se detectan marcas. Para ello, la imagen se convierte a escala de grises y se binariza (según parámetro umbral threshold que indica a partir de que gris todo pixel será negro, dejando blancos el resto: compromiso entre rapidez y precisión en detección). después, se detectan todas las posibles marcas y se les asigna mediante un parámetro un valor de fidelidad para decidir cual de las marcas posibles es la real. 
3. Se normaliza la marca, se detectan los contornos de la región que la contiene (vértices y lados del cuadrado) y después se extrae el contenido de la marca comparándola con patrones de las plantillas de las que se tiene información almacenada.
4. Si la forma del patrón del marcador detectado coincide con el de la plantilla almacenada, se utiliza la información y el tamaño de marcador y plantilla almacenada para calcular la posición y orientación de la cámara respecto al marcador detectado, y se guarda en una matriz llamada Matriz de Transformación. (en el post AR Conceptos II se explica con detalle cómo es esta matriz). Conociendo las posiciones 2D de las aristas y vértices que definen el marcador 2D y el modelo de proyección de la cámara (matriz de parámetros intrínsecos P) es posible estimar la posición y rotación 3D de la cámara respecto a la marca y, por tanto la matriz de transformación T (matriz de parámetros extrínsecos). Esto se hace mediante un proceso de cálculo iteractivo.
5. La matriz de Transformación se utilizará para establecer la posición y orientación de la cámara virtual (transformación de la vista), lo que equivale a una transformación de las coordenadas de la marca a las coordenadas de la cámara y por tanto se transforman las coordenadas del objeto a dibujar. Se usa la matriz T (para hacer transformaciones geométricas) e implícitamente la P (para hacer transformaciones de proyección y visualización de la cámara).
6. Al haber puesto la cámara virtual en la misma posición y orientación que la cámara real, el objeto virtual se renderiza sobre el marcador y se muestra la imagen resultante, que contiene la imagen del mundo real y el objeto virtual superpuesto, alineado sobre el marcador. Se dibujan, por tanto, los objetos 3D alineados con la escena. 
7. Se realiza el mismo proceso con los siguientes fotogramas.

Sistema de coordenadas de ARToolKit

El siguiente diagrama muestra el funcionamiento que se acaba de describir:
.

Esquema funcional de ARToolKit

Mi primera aplicación de Realidad Aumentada

Mi primera aplicación de Realidad Aumentada es un sencillo programa que, una vez compilado, es capaz de reconocer en la escena un marcador generado por nosotros para renderizar sobre él una imagen tridimensional, en mi caso una tetera. Podéis descargaros el código y los ficheros necesarios al final del post.

A continuación os muestro el código de este programa que utilizaré para explicar la estructura y funcionamiento básico de un programa de Realidad Aumentada. El programa reconoce en la escena un marcador ARToolkit creado por nosotros (en otra entrada mostraré como hacerlo) y renderizar sobre él una imagen tridimensional.

1. #ifdef _WIN32
2. #include <windows.h>
3. #endif
4. #include <GL/gl.h>
5. #include <GL/glut.h>
6. #include <stdio.h>
7. #include <stdlib.h>
8. #include <AR/gsub.h>
9. #include <AR/video.h>
10. #include <AR/param.h>
11. #include <AR/ar.h>
12.  
13.  
14. // ==== Configuracion de la camara ===============
15. #ifdef _WIN32
16. char                *vconf = "Data\\WDM_camera_flipV.xml";
17. #else
18. char                *vconf = "";
19. #endif
20.  
21. // ==== Definicion de constantes y variables globales ===============
22. int    patt_id;                                // Identificador de la marca
23. double patt_trans[3][4];                       // Matriz de transformacion de la marca
24.  
25. // ==== Definicion de funciones =====================================
26. void print_error (char *error) {  printf(error); exit(0); }
27.  
28. // ======== cleanup =================================================
29. static void cleanup(void) {  
30.   arVideoCapStop();                      // Para captura de video y libera recursos
31.   arVideoClose();
32.   argCleanup();
33. }
34.  
35. // ======== draw ====================================================
36. static void draw( void ) {
37.   double  gl_para[16];                   // Matriz 4x4 de OpenGL
38.   GLfloat mat_ambient[]     = {0.0, 0.0, 1.0, 1.0};
39.   GLfloat light_position[]  = {100.0,-200.0,200.0,0.0};
40.  
41.   argDrawMode3D();                       // Activa modo presentacion 3D
42.   argDraw3dCamera(0, 0);                 // Activa vista de la camara 3D
43.   glClear(GL_DEPTH_BUFFER_BIT);          // Limpia buffer de profundidad
44.   glEnable(GL_DEPTH_TEST);
45.   glDepthFunc(GL_LEQUAL);
46.  
47.   argConvGlpara(patt_trans, gl_para);   // Convierte la matriz de la marca
48.   glMatrixMode(GL_MODELVIEW);           // para ser usada por OpenGL
49.   glLoadMatrixd(gl_para);               // Carga l matriz
50.  
51.   // Dibuja el objeto 3D
52.   glEnable(GL_LIGHTING);  glEnable(GL_LIGHT0);
53.   glLightfv(GL_LIGHT0, GL_POSITION, light_position);
54.   glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
55.     glTranslatef(0.0, 0.0, 60.0);
56.     glRotatef(90.0, 1.0, 0.0, 0.0);
57.     glutSolidTeapot(80.0);
58.   glDisable(GL_DEPTH_TEST);
59. }
60.  
61. // ======== init ====================================================
62. static void init( void ) {
63.   ARParam  wparam, cparam;        // Parametros intrinsecos de la camara
64.   int xsize, ysize;               // Tamaño del video de camara (pixels)
65.  
66.   // Abre dispositivo de video
67.   if (arVideoOpen(vconf) < 0) exit(0); 
68.   if(arVideoInqSize(&xsize, &ysize) < 0) exit(0);
69.  
70.   // Carga los parametros intrinsecos de la camara
71.   if(arParamLoad("data/camera_para.dat", 1, &wparam) < 0)  
72.     print_error ("Error en carga de parametros de camara\n");
73.  
74.   arParamChangeSize(&wparam, xsize, ysize, &cparam);
75.   arInitCparam(&cparam);                       // Inicializa la camara con "cparam"
76.  
77.   // Carga la marca
78.   if((patt_id=arLoadPatt("data/pattMeditel")) < 0)
79.     print_error ("Error en carga de patron\n");
80.  
81.   argInit(&cparam, 1.0, 0, 0, 0, 0);   // Abre la ventana grafica
82. }
83.  
84. // ======== mainLoop ================================================
85. static void mainLoop(void) {
86.   ARUint8 *dataPtr;                     // contenedor de frame activo
87.   ARMarkerInfo *marker_info;            // informacion del marcador
88.   int marker_num, j, k;
89.  
90.   double p_width     = 120.0;           // Ancho del patron (marca)
91.   double p_center[2] = {0.0, 0.0};      // Centro del patron (marca)
92.  
93.   // Captura un frame de la camara de video
94.   if((dataPtr = (ARUint8 *)arVideoGetImage()) == NULL) {
95.     // Si devuelve NULL es porque no hay un nuevo frame listo
96.     arUtilSleep(2);  return;  // Duerme el hilo 2ms y salimos
97.   }
98.  
99.   argDrawMode2D();
100.   argDispImage(dataPtr, 0,0);    // Dibuja lo que ve la camara
101.  
102.   // Detecta la marca en el frame capturado (return -1 si error y sale de programa)
103.   if(arDetectMarker(dataPtr, 100, &marker_info, &marker_num) < 0) {
104.     cleanup(); exit(0);  
105.   }
106.  
107.   arVideoCapNext();      // Captura siguiente frame
108.  
109.   // Detecta el patron con mayor fiabilidad
110.   for(j = 0, k = -1; j < marker_num; j++) {
111.     if(patt_id == marker_info[j].id) {
112.       if (k == -1) k = j;
113.       else if(marker_info[k].cf < marker_info[j].cf) k = j;
114.     }
115.   }
116.  
117. if(k != -1) {                   // Si detecta el patron obtiene transformación
118. // relativa entre la marca y la cámara real
119.     arGetTransMat(&marker_info[k], p_center, p_width, patt_trans);
120.     draw();                       // Dibuja los objetos de la escena
121.   }
122.  
123.   argSwapBuffers();                     // Cambia el buffer con lo que tenga dibujado
124. }
125.  
126. // ======== Main ====================================================
127. int main(int argc, char **argv) {
128.   glutInit(&argc, argv);                 // Crea la ventana OpenGL con Glut
129.   init();                               
130.  
131.   arVideoCapStart();                    // Crea un hilo para captura de video y
132.   argMainLoop( NULL, NULL, mainLoop );  // asocia callbacks...
133.   return (0);
134. }

Cualquier aplicación que use ARToolKit tendrá la estructura de programa similar a la siguiente: tres grandes bloques inicialización, bucle principal y finalización (en el código están coloreados en azul, verde y rojo respectivamente):

Inicialización (función init)

Primero abre el dispositivo de vídeo con arVideoOpen (línea 67) y se obtiene el tamaño de la fuente de vídeo mediante arVideoInqSize (línea 68) (se guarda en dos variables entero el ancho y alto del vídeo). A continuación, arParamLoad (línea 71) carga en una estructura ARParam (tercer parámetro) los parámetros intrínsecos de la cámara obtenidos en la etapa de calibración (fichero genérico camera_para.dat válido para la mayoría de webcams; aunque lo ideal es trabajar con un fichero que contenga los parámetros de nuestra cámara para obtener   resultados más precisos).

Marcador meditel

Veremos cómo crear este fichero específico para cada cámara en una entrada posterior en ARexperience. Después, arParamChangeSize (línea 74) modifica los parámetros intrínsecos para la resolución en píxels con la que trabajará la cámara y se cargan en las estructuras de datos internas de ARToolKit, mediante la llamada a arInitCparam (línea 75).

Se carga el patrón asociado a la marca (línea 78). Finalmente, en la línea 81 se abre la ventana de OpenGL mediante argInit (de la librería auxiliar Gsub de ARToolKit), pasándole como primer parámetro la configuración de la cámara. El segundo parámetro indica el factor de zoom (en este caso, sin zoom).

Bucle principal
El primer lugar, se recupera un frame de la cámara de vídeo mediante la función arVideoGetImage (la llamada devuelve un puntero a un buffer donde se encuentra la imagen capturada). Si se llama a la función con mayor frecuencia de la soportada por la cámara, se duerme el hilo 2ms (línea 96) y se vuelve a ejecutar el mainLoop.

A continuación, se dibuja en la ventana (en modo 2D) el buffer que acabamos de recuperar de la cámara (línea 100) para que arDetectMarker (línea 103) localice las marcas en el buffer de entrada. El segundo parámetro de valor 100 se corresponde con el valor umbral de binarización de la imagen (a blanco y negro, explicaremos el proceso de binarización de la marca en una entrada posterior). Esta función nos devuelve en el tercer parámetro un puntero a una lista de estructuras de tipo ARMarkerInfo, que contienen información sobre las marcas detectadas (junto con un grado de fiabilidad de la detección), y como cuarto parámetro el número de marcas detectadas.

De esta forma, ARToolKit nos devuelve “posibles” posiciones para cada una de las marcas detectas. Incluso cuando estamos trabajando con una única marca, es común que sea detectada en diferentes posiciones (por ejemplo, si hay algo parecido a un cuadrado negro en la escena). ¿Cómo elegimos la correcta en el caso de que tengamos varias detecciones? ARToolKit asocia a cada percepción una probabilidad de que lo percibido sea una marca, en el campo cf (confidence value). Como se puede comprobar, todos los campos de la estructura ARMarkerInfo se refieren a coordenadas 2D, por lo que aún no se ha calculado la posición relativa de la marca con la cámara.

Campos de la estructura ARMarkerInfo

Así, en las líneas 109-115 se guarda en la variable k el índice de la lista de marcas detectadas aquella percepción que tenga mayor probabilidad de ser la marca (cuyo valor de fiabilidad sea mayor). Mediante la llamada a arGetTransMat (línea 119) se obtiene la matriz de transformación relativa entre la marca y la cámara (matriz 3x4 de doubles); es decir, se obtiene la traslación y rotación de la cámara con respecto de la marca detectada. Para ello es necesario especificar el centro y ancho de la marca. Esta matriz será finalmente convertida al formato de matriz homogénea de 16 componentes utilizada por OpenGL mediante la llamada a argConvGlpara en la línea 47. Finalmente, se renderizará una imagen 3D mediante primitivas OpenGL para uso en aplicaciones de Realidad Aumentada. (líneas 51-58).

Finalización y función Main
En la función cleanup se liberan los recursos al salir de la aplicación. Se hace uso de funciones de ARToolKit para detener la cámara de vídeo, y limpiar las estructuras de datos internas de ARToolKit. En la función main se registran los callbacks mediante la función argMainLoop. En este ejemplo, se pasa como primer y segundo parámetro NULL (correspondientes a los manejadores de ratón y teclado respectivamente). Por su parte, se asocia la función que se estará llamando constantemente en el bucle principal mainLoop.

Salida del programa

Salida del programa 

Esta es la salida del programa y los siguientes enlaces permiten descargar el código y el marcador utilizado (imagen para impresión y datos para el programa) y los ficheros de inicialización de la cámara. Todos los ficheros deberán estar en ...artoolkit\bin\Data.

código del programa
marcador meditel
ficheros cámara

Métodos de tracking visual

El registro es la imagen real registrada por una cámara en el momento o previamente. Su obtención puede realizarse empleando diferentes  tipos de sensores y técnicas (las más extendidas son mediante el uso de tracking visual).

Los Métodos de Tracking tratan de obtener una estimación de la trayectoria en el espacio realizada por un objeto o sensor. Se pueden emplear diferentes tipos de sensores como mecánicos, magnéticos, ondas sonoras, inerciales o cámaras de visión.  Las cámaras están actualmente integradas en multitud de dispositivos portátiles y permiten realizar tracking a un coste reducido.

De entre estos métodos, los más utilizados son los basados en cámaras de vídeo o de Tracking visual. Este método es un subcampo del tracking 3D, y en él  se emplean técnicas de visión por computador para obtener el posicionamiento de la cámara con seis grados de libertad (tres grados de la posición y tres de la orientación).

ejemplo de tracking con marcadores

Para calcular la posición de la cámara respecto al mundo real se necesitan un conjunto de referencias tridimensionales, que pueden ser marcas con una descripción geométrica previamente conocida u objetos previamente modelados. Realizando una comparación con lo que percibe la cámara en el mundo real es posible obtener el posicionamiento relativo a estas  referencias. En la imagen de la izquierda vemos un ejemplo de tracking visual con marcadores correspondiente a uno de mis primeros aplicaciones creadas con ARToolKit.

Problemática

Los problemas que el tracking visual tiene que resolver son:

1. De identificación: oclusiones, puntos de vista, mala iluminación, etc
2. De seguimiento: inicio automático y recuperación del tracking al perder las referencias
3. En entornos no controlados: tracking sin referencias previamente conocidas

Clasificación de los métodos de tracking

Las Aproximaciones Buttom-Up tratan de obtener la posición a partir de lo que percibe la cámara. En ellas la inicialización y la recuperación al perder el tracking son automáticas, pero si no se localiza una referencia completa no son capaces de dar posiciones válidas. Existen diferentes tipos:

• Basados en marcas
• Sin marcas
• Estructuras planas
• Basadas en modelos
• Escenas sin restricciones

La siguiente imagen muestra un ejemplo de mi trabajo en el que se realiza una detección mediante tracking de estructuras planas, a partir de la detección de sus líneas de fuga y normales (en amarillo). En este caso se pretende insertar un anuncio sobre la pared detectada (en la que no hay marcas).

ejemplo de detección planar

En las Aproximeciones Top-Down, primero se estima la posición para después intentar reconocer las referencias que se espera. Por este motivo, necesitan una posición inicial aunque responden muy bien ante referencias parciales o incluso oclusiones temporales. Se utilizan modelos del movimiento basados en filtros bayesianos para predecir la posición de la cámara. A partir de esa posición de la cámara se buscan referencias en la escena que corrijan la predicción y ayuden a la creación de un modelo del entorno.

Los filtros Bayesianos pueden dividirse en dos grandes familias según trabajen con modelos de movimiento gausianos, que explotan los beneficios de los Filtros de Kalman y sus variantes, o utilicen Filtros de Partículas.

AR Conceptos I

Muchas son las tecnologías implicadas y los conceptos técnicos asociados a la Realidad Aumentada (RA). En esta serie de entradas AR Conceptos, realizaré un listado y una breve explicación de los más importantes sin dejar, por ello, de dedicar diferentes entradas a otros tantos conceptos que requieran una explicación mayor.

La Realidad Virtual (RV)

Realidad virtual

Es una ciencia basada en el empleo de ordenadores y otros dispositivos, cuyo fin es producir una apariencia de realidad que permita al usuario tener la sensación de estar presente en ella. Se consigue mediante la generación por ordenador de un conjunto de imágenes que son contempladas por el usuario a través de un dispositivo denominado visor. A diferencia de la Realidad Aumentada, las tecnologías  de RV sumergen al usuario dentro de un entorno completamente sintético, sin  consciencia del mundo real que lo rodea.


Inteligencia Artificial (IA)
Es un área multidisciplinaria que, a través de ciencias, tales como la informática, la lógica y la filosofía, estudia la creación y diseño de entidades capaces de razonar por sí mismas utilizando como paradigma la inteligencia humana.

Visión por Computador (CV)
También llamada visión artificial o visión técnica, es un subcampo de la inteligencia artificial cuyo propósito es programar un computador para que "entienda" una escena o las características de una imagen. Entre sus objetivos se incluyen:

• La detección, segmentación, localización y reconocimiento de ciertos objetos en imágenes (por ejemplo, caras humanas).
• La evaluación de los resultados (por ejemplo, segmentación, registro).
• Registro de diferentes imágenes de una misma escena u objeto, es decir, hacer concordar un mismo objeto en diversas imágenes.
• Seguimiento de un objeto en una secuencia de imágenes.
• Mapeo de una escena para generar un modelo tridimensional de la escena; este modelo podría ser usado por un robot para navegar por la escena.
• Estimación de las posturas tridimensionales de humanos.
• Búsqueda de imágenes digitales por su contenido.

Estos objetivos se consiguen por medio de reconocimiento de patrones, aprendizaje estadístico, geometría de proyección, procesamiento de imágenes, teoría de grafos y otros campos. La visión artificial cognitiva está muy relacionada con la psicología cognitiva y la computación biológica.

Esquema de las relaciones entre la visión por computadora y otras áreas afines

Computación Gráfica (CG)
Es el campo de la informática visual, donde se utilizan computadoras tanto para generar imágenes visuales sintéticamente como para integrar o cambiar la información visual y espacial probada del mundo real. Herramientas informáticas como maya, 3D studio MAX o blender son de las más utilizadas.

Marcador artificial o Marca
Son impresiones cuadradas o circulares  normalmente en blanco y negro, utilizadas, una vez detectadas, para posicionar la cámara virtual y ubicar objetos 3D en el registro. Los principales factores que afectan a la detección de marcas son su tamaño físico, su complejidad, su orientación relativa respecto de la cámara y las condiciones de iluminación. Algunos ejemplos de marcadores son:

Plano de la imagen
En proyección, es el plano perpendicular a las líneas de mira (trayectorias paralelas desde el ojo del observador hasta un punto particular sobre el objeto observado). Este plano esta localizado entre el ojo del observador y el objeto que esta siendo mirado.

Registro o escena
Imágenes reales registradas por una cámara en el momento o previamente. El mayor problema que implica obtener el registro es calcular la posición relativa de la cámara real respecto de la escena para poder generar imágenes virtuales correctamente alineadas con esa imagen real (posición y rotación). El registro debe ser preciso (errores de muy pocos milímetros son muy sensibles en determinadas aplicaciones, como en medicina  o en soporte a las aplicaciones industriales) y robusto (debe funcionar correctamente en todo momento). El registro puede realizarse empleando diferentes  tipos de sensores y técnicas (las más extendidas son mediante el uso de tracking visual).

Tracking
Es un conjunto de métodos que tratan de obtener una estimación de la trayectoria en el espacio realizada por un objeto o sensor. Se pueden emplear diferentes tipos de sensores como mecánicos, magnéticos, ondas sonoras, inerciales o cámaras de visión.  Las cámaras están actualmente integradas en multitud de dispositivos portátiles y permiten realizar tracking a un coste reducido.

Tracking visual
El tracking basado en cámaras de vídeo es un subcampo del tracking 3D en el que se emplean técnicas de visión por computador para obtener el posicionamiento de seis grados de libertad de la cámara  (tres grados de la posición y tres de la orientación). Para calcular la posición de la cámara respecto al mundo real se necesitan un conjunto de referencias tridimensionales. Algunos  ejemplos de estas referencias pueden ser marcas con una descripción geométrica previamente conocida u objetos previamente modelados. Realizando una comparación con lo que percibe la cámara en el mundo real es posible obtener el posicionamiento relativo a estas  referencias.