Infant Finalista CUSL Madrid

Dicen que lo importante es participar y en esta ocasión es verdad ya que a parte de conocer a varias personas relacionadas con el software libre de la Comunidad de Madrid hemos tratado como podemos mejorar y contribuir a futuras ediciones de esta fase local para que sea más visible y más participativa.
Los resultados de la final (dictados por un jurado compuesto por profesionales y profesores de diferentes universidades) y otros detalles los tenéis en esta noticia en la web del CUSL de Madrid, desde aquí felicitar a los proyectos PiranaFS y Cormoran por sus premios y que los disfrutéis!
Por mi parte y para que podáis imaginaros como fue la presentación he subido a la forja la presentación en formato Impress de OpenOffice, para que le podáis echar un vistazo.

A parte y para que podáis ver el avance actual de la aplicación también presente una pequeña demo de como funciona actualmente la aplicación lo que podéis ver en este video realizado con RecordMyDesktop y en el que se ve como reconoce formas geométricas simples previamente aprendidas.

Documentación proyecto con Doxygen

Como Infant finalmente se publicará en forma de librería hay que documentar de la mejor forma posible cada una de las clases disponibles para que sea posible su uso por terceras personas. Para ello a partir de un código bien comentado y por medio de Doxygen podemos generar de forma casi automática esa documentación permitiendo publicarla en formatos como HTML, LATEX, XML, PDF o RTF. Una vez descargada e instalada la herramienta los pasos a seguir son:

0. Comentar el código usando una de las siguientes posibilidades (que podéis emplear según vuestro gusto, la forma de darle visibilidad al comentario, etc. además en el manual oficial hay aun más formas como comentarios ) para marcar que se trata de un comentario que queremos procesar con Doxygen:

/**

* ... text ...

*/

/*!

* ... text ...

*/

///

/// ... text ...

///

//!

//!... text ...

//!

/********************************************//**

* ... comentario visible…

***********************************************/

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

/// ... comentario visible…

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

int variable; /**< comentario tras definición en una linea */

Por otro lado para definir del tipo de dato que se trata podemos emplear los siguientes comandos dentro de los comentarios precedidos o bien por „\” o por „@”.

· \class para documentar una clase.

· \struct para documentar un struct.

· \union para documentar una unión.

· \enum para documentar un tipo enumerado

· \fn para documentar funciones.

· \var para documentar una variable, un typedef o un valor enum.

· \def para documentar un #define.

· \typedef para documentar una definición de tipo.

· \file para documentar un fichero.

· \namespace para documentar un namespace.

· \package para documentar paquetes en Java.

· \interface para documentar interfaces.

Además y para definir otros datos que puedan ayudar a mejorar la documentación.

· \author para determinar el autor o autores (\autors) del código.

· \date para documentar la fecha del código o última modificación.

· \deprecated para indicar que el código está obsoleto.

· \example para mostrar ejemplos de código del uso de una clase.

· \include incluye datos de un determinado fichero.

· \param [dir] indica que se está describiendo el parametro nom_parametro y su dirección, que puede ser in, out o in,out.

· \return describe el valor devuelto por una función por ejemplo.

· \todo para marcar tareas pendientes.

· \version para indicar

1. Crear el fichero de configuración para el proyecto que queremos documentar. Podemos crear uno automático y completar los campos más importantes como nombre del proyecto, ruta, logo, ruta de salida, etc. en el fichero generado con el que no deberíais tener problemas ya que la plantilla generada está muy bien documentada. Para generar este documento tan solo debemos escribir el comando:

doxygen -g nombre_fichero

Los campos más importantes a completar en este fichero son:

PROJECT_NAME = nombre del proyecto

PROJECT_NUMBER = versión

PROJECT_BRIEF = resumen o descripción

PROJECT_LOGO = bueno este no es importante pero personaliza mucho la documentación y es la ruta de una imagen con dimensiones máximas de 50 x 200px con el logo del proyecto.

OUTPUT_DIRECTORY = directorio en el que se genera la documentación

INPUT = directorio en el que se encuentra el código a documentar

FILE_PATTERNS = si queremos que solo se documente ficheros de un tipo, p.e. *.cpp, *.h, etc.

2. Una vez generado y completado este fichero lo único que hay que hacer es ejecutar el comando siguiente lo que automáticamente generará (si no hemos modificado esta configuración en el fichero) documentación en HTML y LATEX.

doxygen nombre_fichero

Para que veáis como va quedando en el caso de la documentación de Infant os dejo una captura de una de las clases del proyecto creado solo a partir de la modificación de los parámetros del punto 1 del fichero de configuración ya que después podemos personalizar desde la cabecera HTML hasta los colores de la documentación.

Presentación Infant

Si nada ni nadie lo impide, el 15 de abril se presentará en sociedad el trabajo realizado en el proyecto en la final del Concurso de Software Libre Universitario de Madrid que se celebrará en el Madrid On Rails. Desde aquí os animo a asisitr ya que a parte de Infant se presentaran varios de los proyectos participantes de la Comunidad de Madrid siendo la agenda actual del evento la siguiente:

• 10:00 - 10:30 Presentación PirannaFS, de Jesús Leganés Combarro
  
• 10:30 - 11:00 Presentación Infant, de Krzysztof Stopa
• 11:00 - 11:30 Presentación Cormoran, de Jaime Gil de Sagredo
• 11:30 - 12:00 Presentación YUD, de Jorge Pintado de Santiago
  
• 12:00 - 12:30 Descanso
• 12:30 - 13:00 Entrega de Premios

Para más información sobre el evento, localización y como llegar podeis consultar la nota oficial sobre la final dónde también se irán actualizando los posibles cambios.

Paso de datos a LUA

Como ya hemos comentado Infant generará scripts en LUA que serán los encargados de comparar después los objetos vistos con los ya conocidos (a partir de los cuales se generarán los scripts). Tambíen vimos como pasar estos parámetros desde C++ al interpreste LUA que ejecuta los scripts.

Pero lo que aun no esta muy claro es que parámetros son los que hay que pasar desde Infant a cada uno de los scripts (y por tanto la forma en la que se definirá su estructura).

Para ello, y teniendo en cuenta que (de momento) todos los todos los objetos en infant estan divididos por niveles (contornos) y esos niveles estan compuestos por una serie de vectores que una vez pasados al sistema de coordendas de objeto definen cada uno de esos niveles. Por tanto para definir el objeto de manera similar en el script serán estos datos los más relevantes y como no podemos pasar el objeto entero (es decir la esctructura de c++) teniendo en cuenta que en lua una de las estructuras principales son la tablas cada objeto sera pasado a una tabla en la que se presentaran los niveles y sus coordendas.

La estructura de esa tabla (array más bien) será por tanto la siguiente en notacion BNF (bueno he intentado que lo sea os animo a corregirlo):

{ codigo_nivel ::= INTEGER > 1000

{

coordenada_x ::= DOUBLE

coordenada_y ::= DOUBLE

}

}

El resultado sera algo parecido a:

1001

10.12

30.33

20.34

90.0

..

1002

....

Encuesta: Forma lanzamiento

Hemos preparado una encuensta para ver si, a parte de a nosotros, os parece una buena idea a vosotros el que Infant se publique en forma de librería. Si quereis participar esta disponible en en la forja.

Vuelta al trabajo

Después de un parón de casi un mes entre Navidades, trabajos inesperados, estudios y otras distracciones ya es hora de volver a ponerse en serio con Infant y para ello y por lo menos organizarme un poco he preparado la lista de tareas para el próximo mes:

Id Tarea	Descripción de la Tarea	Fecha Inicio	Fecha Final	Porcentaje Completado
2278	Rule Generation System: Exist Point	2011-02-01 12:00	2011-02-03 12:00	0%
2279	Rule Generation System: Exist Level	2011-02-03 12:00	2011-02-05 12:00	0%
2280	Rule Generation System: Have Min - Max Vertex	2011-02-05 12:00	2011-02-07 12:00	0%
2281	Rule Generation System: Have vectors like	2011-02-07 12:00	2011-02-09 12:00	0%
2282	Rule Generation System: Have lenghts like	2011-02-09 12:00	2011-02-11 12:00	0%
2283	Rule Generation System: Have angles	2011-02-11 12:00	2011-02-13 12:00	0%
2205	Recongnize single objects with cam	2011-02-15 12:00	2011-02-20 12:00	0%
2204	Integrate rule generation system on tree structure	2011-02-20 12:00	2011-02-25 12:00	0%
2206	Create teaching interface	2011-02-25 11:00	2011-03-01 11:00	0%
2207	Create observer interface	2011-03-01 12:00	2011-03-05 12:00	0%

Y como siempre en estos casos aunque os dejo el diagrama de gantt preparado por la forja en el que se ve algo mejor la evolucion del trabajo:

SQLite 3.7.4

Aunque ya hace algo más de un mes de la noticia del lanzamiento de la nueva versión de sQLite en Infant acabamos de incorporarla a la aplicación para no quedarnos desactualizados aunque los cambios no nos influyen demasiado (así que ha sido mas que nada por provar) y lo único que se ha tenido que hacer es cambiar el amalgamation que se incluye con cada versión. Los cambios más importantes de esta nueva versión son:

• Añadida sqlite3_blob_reopen() para permitir a un objeto existente sqlite3_blob clonarse en una nueva fila.
• Mejora del rendimiento mediante sqlite3_blob_reopen() para FTS (Full Text Search)
• En los VFSes (Virtual File Systems) que no permiten memoria compartida se permite el acceso a las bases de datos WAL (Write Ahead Logging) cuando PRAGMA locking_mode es EXCLUSIVE.
• Mejoras en EXPLAIN QUERY PLAN.
• Añadido sqlite3_stmt_readonly().
• Añadido PRAGMA checkpoint_fullfsync.
• Añadida la opción SQLITE_FCNTL_FILE_POINTER a sqlite3_file_control().
• Añadido el soporte de FTS4 y mejoras en la funcion FTS matchinfo().
• Añadido el módulo test_superlock.c que muestra un ejemplo de código sobre como obtener el bloqueo exclusivo de rollbacks (vuelta hacia atrás de transacciones) y bases de datos WAL.
• Añadido el módulo test_multiplex.c que muestra un ejemplo de VFS que provee de multiplexado de una base de datos partiendola en multiples ficheros de un tamaño definido.
• Corregido bug crítico asociado con la optimización de la operación OR.

Además si le quereis echar un ojo también esta disponible la lista completa de cambios en la que se indican todos los detalles.

Un ejemplo curioso

Hoy mientras espero mi vuelo que lleva ya 5 horas de retraso me acabo de encontrar un ejemplo de un sistema parecido a Infant aunque basado en Kinekt lo cual lo diferencia ya que en el caso de Infant tan solo se necesitará una webcam e imagino que el proceso de reconocimiento será totalmente diferente aunque no he indagado demasiado en eso sino que he visto una demo que me ha impresionado y gustado bastante, os lo dejos a continuación:

Eso si sin duda lo mejor es el reconocimiento de voz como interfaz de usuario, que también es algo que tenía pensado y por eso me he encontrado este ejemplo en el blog de Sphinx que es un sistema libre de reconocimiento de voz con el cual espero trastear algo estas vacaciones.

Sistema de Coordenadas de Objeto (II)

Aunque era algo ya previsto, a la hora de trabajar con la cámara con OpenCV para el reconocimiento\aprendizaje de objetos existe un problema debido a que rara vez estos se dan en una posición perfecta sino que suelen aparecer rotados o en perspectiva.

Para solventarlo y evitar que el objeto se vuelva irreconocible simplemente debido a una mala orientación se va ha cambiar el método de selección de los vectores que definen el sistema de coordenadas del objeto que hasta ahora se basaba en los vectores que conformaban el rectángulo que envolvía al objeto y que ahora pasará a basarse en el vector de mayor módulo entre todos los puntos que conforman el nivel 0, es decir el contorno más exterior del objeto. Además en caso de que haya más de un vector con un módulo similar (p.e. en objetos simétricos) para seleccionar el vector y que sea seleccionado siempre el mismo se deberá que cumpla una serie de propiedades o condiciones (como menor angulo con respecto a la horizontal, etc.)

Una vez definido este vector se tomara como eje de giro siendo el menor angulo posible para poner dicho vector en perpendicular con respecto a la horizontal con centro en el punto medio del vector. Un vez realizado este giro se seguirá con el procedimiento actual de definir el sistema de coordenadas a partir del nuevo rectángulo que rodea al objeto tal y como se hacia hasta ahora.

Sentido de la vista

A parte de la posibilidad de cargar ficheros de imágenes, Infant permitirá obtener información y aprender a partir de lo que vea o se le enseñe si se conecta una webcam al PC.

Para facilitar esta tarea y distinguir entre lo que le enseñamos y lo que es fondo o información no relevante Infant contará con un algoritmo que analizará las zonas invariables de las diferentes capturas de la cámara creando una imagen de fondo que almacenará los valores de los pixeles que permanecen más o menos constantes a lo largo del tiempo.

Después cada una de las imágenes obtenidas se compará con esta imagen de fondo por medio de la comparación de la varianza entre los pixeles próximos de cada pixel de la imagen (con lo que se evitará en gran medida que los cambios de iluminación afecten al resultado). Para realizar esta operación de cada pixel, tanto en la imagen base con en la captura que se trata de obtener se obtendrá una matriz 3 x 3 con los siguientes valores:

donde M n,m representa el valor del pixel de la imagen original.

Finalmente las dos matrices obtenidas se restan y se obtiene una matriz final en la que si ninguna de las celdas exteriores supera un determinado valor absoluto significa que el pixel pertenece al fondo (y se actualiza la imagen de fondo con el valor del pixel de la imagen nueva) o en caso contrario es parte de un nuevo elemento en pantalla con lo que se añade a la imagen a analizar.

A continuación os dejo un video en el que podéis ver los resultados, aunque de momento solo es una prueba del algoritmo en el que en los primeros instantes se crea una imagen de fondo (todavía no he implementado el que se genere con los nuevos valores) y a continuación salgo yo haciendo el tonto y enseñándole cosas:

Por cierto, por si queréis hacer algo parecido la captura y el video han sido realizados con RecordMyDesktop.