pizarra virtual basada en realidad aumentada - IIT

UNIVERSIDAD PONTIFICIA COMILLAS
ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA (ICAI)
INGENIERO EN INFORMÁTICA
PROYECTO FIN DE CARRERA
PIZARRA VIRTUAL BASADA EN
REALIDAD AUMENTADA
AUTOR: SARA MIRA FERNÁNDEZ
MADRID, SEPTIEMBRE DE 2009
Autorizo la entrega del proyecto de la alumna
Sara Mira Fernández
EL DIRECTOR DEL PROYECTO
Juan Antonio Pérez-Campanero
Fdo:………………………………
Fecha: ……/……/..….
VºBº del Coordinador del Proyecto
David Contreras Bárcena
Fdo:………………………………
Fecha: ……/……/..….
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
En la última década la convergencia de capacidades de procesamiento de
imágenes de video en tiempo real, sistemas gráficos por ordenador y nuevas tecnologías
de visualización han hecho posible la obtención de una imagen virtual correctamente
insertada con la visión del entorno tridimensional que rodea al usuario. Un sistema de
Realidad Aumentada proporciona una visión compuesta para el usuario: se trata del
resultado de la combinación de una escena real y otra virtual generada por el ordenador
que complementa la primera con información adicional. El objetivo final es crear un
sistema en el que el observador no consiga discernir la diferencia entre el mundo real y
la versión aumentada del mismo.
La investigación en torno a la Realidad Aumentada se centra fundamentalmente
en dos aspectos: por una parte el desarrollo de métodos para insertar y mantener las dos
imágenes en tiempo real, y por otra, la fusión de ambas imágenes.
Los investigadores que trabajan con sistemas de Realidad Aumentada los
utilizan en diversos dominios como son: la medicina, el entretenimiento, la televisión, la
robótica, el diseño orientado al consumidor, el diseño de ingeniería, mantenimiento de
equipos, etc.
Este proyecto fin de carrera se centra en el análisis de imagen mediante un
sistema de visión artificial, para identificar aquellos objetos y regiones de interés
dibujados por el usuario.
Figura I: Detección de objetos
i
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
En este proyecto se han estudiado con detenimiento todas las opciones que
ofrece la visión artificial y con especial interés la forma de localizar y separar dentro de
la imagen, que ofrece mucha información, los objetos de interés.
El sistema de análisis de este proyecto permite la detección del área de interés,
aquello que el usuario pinta en esta región, y una vez haya finalizado, comprueba si
existe alguno objeto relevante a detectar.
Si el sistema detecta algún objeto, éste es cambiado por una imagen almacenada
en el sistema. En este caso, se ha trabajado en la detección del número 0, para enfocarlo
a la enseñanza, pudiendo aplicarse tras las oportunas modificaciones a cualquier otra
rama.
Por la gran cantidad de funciones orientadas al procesamiento de imágenes,
facilidad de uso y potencia en el desarrollo de soluciones de esta área, el proyecto ha
sido realizado en el entorno de desarrollo Visual C++ con la ayuda de las librerías de
OpenCV.
ii
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Abstract
In the last decade, the convergence of image processing capabilities of real-time
video, computer graphics systems and new display technologies have made it possible
to obtain a virtual image inserted correctly with the vision of three-dimensional
environment surrounding the user. An Augmented Reality system provides a composite
view for the user: it is the result of a combination of real and a virtual scene generated
by the computer as supplemented by additional information. The ultimate goal is to
create a system in which the observer is unable to discern the difference between the
real world and augmented version of it.
The research into Augmented Reality is focuses on two aspects: firstly the
development of methods to insert and keep the two images in real time, and secondly,
the fusion of both images.
Researches who work with Augmented reality systems, used it in different areas
like medicine, training, television, robotics, design aimed at consumers, engineering
design, computers support, …
This degree project is focused on image analysis, provided by a system of
artificial vision, to identify relevant objects and areas which are painted by the user.
Figure II: Object detection
iii
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
This Project will study carefully all options offered by the artificial vision, and
with special interest the way to locate and split relevant objects.
The image analysis system designed in this project enables to detect the relevant
area, what the user paints in it and to identify if something which was painted, it’s a
relevant object.
If the system detects some relevant object, it is change for a saved image at the
system. In this case, it’s worked with a number, 0, trying to approach it for education,
but in a future, it could be applied after appropriate modifications to any other area.
Due to the large number of functions aimed at image processing, its power to
build up solution in this area and the ease of use, this project has been developed in
Visual C++ with the OpenCV library.
iv
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Índice
1.
Introducción......................................................................................................................... 1
1.1.
Descripción ................................................................................................................... 1
1.2.
Conceptos generales ...................................................................................................... 3
1.2.1.
Píxel....................................................................................................................... 3
1.2.2.
Imagen digital ....................................................................................................... 3
1.2.3.
Clasificación de imágenes digitales ...................................................................... 4
1.2.4.
Espacio de color: Modelo RGB............................................................................. 5
1.3.
2.
3.
Ámbito del proyecto ...................................................................................................... 7
1.3.1.
Realidad Aumentada ............................................................................................. 7
1.3.2.
Visión Artificial ................................................................................................... 11
1.3.3.
El problema de la visión dinámica ...................................................................... 13
1.3.4.
El problema de la calibración: La distorsión de la lente.................................... 13
1.4.
Motivación .................................................................................................................. 19
1.5.
Objetivos y Requisitos ................................................................................................ 20
1.6.
Metodología ................................................................................................................ 21
1.7.
Recursos/ Herramientas utilizadas .............................................................................. 23
1.7.1.
OpenCV ............................................................................................................... 23
1.7.2.
C++ ..................................................................................................................... 28
1.7.3.
Microsoft Visual Studio 2008 .............................................................................. 29
Descripción de fases .......................................................................................................... 30
2.1.
Fase I: Adquisición y visualización de video .............................................................. 31
2.2.
Fase II: Detección de esquinas .................................................................................... 31
2.3.
Fase III: Sustracción de la mano ................................................................................. 31
2.4.
Fase IV: Ejecución conjunta ....................................................................................... 31
Desarrollo ........................................................................................................................... 32
3.1.
Fase I: Adquisición y visualización de video .............................................................. 32
3.1.1.
Determinar los objetivos ..................................................................................... 32
3.1.2.
Analizar los riesgos ............................................................................................. 32
3.1.3.
Desarrollar y probar ........................................................................................... 32
3.1.4.
Planificar............................................................................................................. 34
3.2.
Fase II: Detección de esquinas y patrones................................................................... 35
3.2.1.
Determinar los objetivos ..................................................................................... 49
3.2.2.
Analizar los riesgos ............................................................................................. 49
3.2.3.
Desarrollar y probar ........................................................................................... 49
v
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
3.2.4.
3.3.
Planificar............................................................................................................. 56
Fase III: Sustracción de la mano ................................................................................. 57
3.3.1.
Determinar los objetivos ..................................................................................... 58
3.3.2.
Analizar los riesgos ............................................................................................. 58
3.3.3.
Desarrollar y probar ........................................................................................... 58
3.3.4.
Planificar............................................................................................................. 61
3.4.
Fase IV: Ejecución conjunta ....................................................................................... 62
3.4.1.
Determinar los objetivos ..................................................................................... 62
3.4.2.
Desarrollar y probar ........................................................................................... 62
4.
Planificación....................................................................................................................... 64
5.
Estudio económico ............................................................................................................. 65
5.1.
Costes de Ingeniería .................................................................................................... 65
5.2.
Costes del Software Utilizado ..................................................................................... 66
5.3.
Costes del Hardware utilizado..................................................................................... 67
5.4.
Presupuesto Final ........................................................................................................ 68
6.
Conclusiones ...................................................................................................................... 69
7.
Trabajos futuros ................................................................................................................ 71
8.
Bibliografía ........................................................................................................................ 73
Anexo A – Manual de usuario .................................................................................................. 75
Anexo B - Instalación Microsoft Visual Studio 2008.............................................................. 76
Anexo C- Instalación OpenCV ................................................................................................. 80
Anexo D- Código ....................................................................................................................... 86
vi
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Listado de figuras
Figura 1: Descripción del Proyecto………………………………………..………….…2
Figura 2: Representación de un píxel…………………………………………..……..…3
Figura 3: La imagen a) corresponde a la original. La imagen b) corresponde a la
estructura matricial de la imagen…………………………………………………..…….4
Figura 4: Imagen en blanco y negro…………………………………………….…...…..4
Figura 5: Imagen en escala de grises………………………………………….…………5
Figura 6: Imagen en color…………………………………………………….………….5
Figura 7: Representación gráfica del modelo de color RGB…………………………….6
Figura 8: Display montado en la cabeza (HMD)………………………………………...8
Figura 9: Móvil con cámara en una aplicación de realidad aumentada………………….9
Figura 10: Etapas típicas en un sistema de Visión Artificial…………………..……….11
Figura 11: Fotogramas de una secuencia de imágenes a través del tiempo……………13
Figura 12: Tipos básicos de distorsión en una lente……………………………………14
Figura 13: Imagen distorsionada y posteriormente corregida………………………….15
Figura 14: Diversos patrones de calibración…………………………………………...17
Figura 15: Rotulador……………………………………………………………………20
Figura 16: Modelo en espiral………………………………………………………..….21
Figura 17: Estructura OpenCV……………………………………………...………….25
Figura 18: Estructura usada de OpenCV.……………………………………..………..27
Figura 19: Fases del Proyecto……………………………………………………...…...30
Figura 20: Captura de la webcam de un frame…………………………………………33
vii
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Figura 21: Planificación Fase II………………………………………………………..34
Figura 22: Algunos tipos de características Haar de rectángulos………………………37
Figura 23: Valor de la Imagen Integral en el punto (x,y)………………………………38
Figura 24: Proceso AdaBoost……………..………………….………………………..40
Figura 25: Cascada de clasificación……………………………………………………42
Figura 26: Funcionamiento del Haartraining……………...……………………………48
Figura 27: Reconocimiento de esquinas………………………………………………..49
Figura 28: Ejecución……………………………………………………………………51
Figura 29: Función detect_and_draw………………………………………………….52
Figura 30: Detección de esquinas………………………………………………………53
Figura 31: Coordenadas de las esquinas………………………………………………..53
Figura 32: Función puntos……………………………………………………………...54
Figura 33: Región del Frame…………………………………………………………...55
Figura 34: Planifiación Fase III………………………………………………………..56
Figura 35: Función pixel……………………………………………………………….59
Figura 36: Función ceros……………………………………………………………….60
Figura 37: Planificación Fase IV……………………………………………………….61
Figura 38: Antes de la detección del patrón……………………………………………62
Figura 39: Después de la detección del patrón…………………………………………63
Figura 40: Planificación………………………………………………………………...64
viii
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
1. Introducción
1.1. Descripción
Las personas desde siempre han tenido interés por crear cosas. Ya sea un cuadro,
una obra musical, un libro, una idea... el ser humano tiene curiosidad por la creación ya
que también, en algún momento, ha sido creado. Una de las motivaciones por las que se
quiso empezar este proyecto está precisamente relacionada con la creación. ¿Se puede
crear algo donde no hay nada con la tecnología del Siglo XXI? ¿Pueden crearse
ilusiones visuales? El cine ha demostrado en los últimos treinta años que esto es posible,
pero ¿se puede ir más allá de todo esto?
Crear ilusiones ópticas hoy en día es un problema bastante complejo, y sobre
todo extenso porque desde el punto de vista de la ingeniería, abarca diferentes áreas. Es
necesario tener conocimientos de fotografía para saber cómo una cámara (el ‘ojo’
industrial que tenemos a nuestra disposición) capta imágenes del mundo real de manera
que las podemos almacenar, imprimir, o mostrar en una pantalla de ordenador o
televisión.
También es necesario saber cómo pueden manejarse estas fotografías o vídeos
de manera que sean útiles en un ordenador. Al fin y al cabo se está manejando
información; una información bastante útil ya que establece una relación directa entre lo
que vemos y lo que hay en el mundo real. Y esta relación es matemática. El mundo de la
imagen es muy extenso, y en los últimos años han aparecido dos áreas especializadas
dedicadas a resolver el problema de la integración de objetos sintéticos en imágenes
reales: la realidad aumentada y la visión artificial.
Primeramente surgió la visión artificial para dotar a las máquinas de capacidades
visuales, similares a los humanos. Esto se ha usado muchísimo sobre todo en robótica,
pero con el avance de la tecnología se descubrieron nuevas posibilidades: la realidad
aumentada. De hecho la realidad aumentada se empezó a utilizar en el cine, para añadir
algo que no existe en imágenes captadas de la realidad. Y últimamente esto no
solamente se refiere a la creación de objetos irreales para las películas de cienciaficción, sino a añadir objetos que parezcan reales en imágenes reales.
1
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Aquí es donde entra en juego el foto-realismo, y las diferentes técnicas que
existen para generar objetos tridimensionales. La informática ha avanzado mucho en
este aspecto, apareciendo cada año nuevas técnicas, métodos y herramientas para crear
añadidos sintéticos en anuncios de televisión, películas de cine o en pantallas de
dispositivos móviles.
Éste proyecto se denomina “Pizarra virtual basada en realidad aumentada”. Lo
que busca este proyecto es la creación de una librería que capture imágenes
continuamente de una webcam, las analice y obtenga unos determinados parámetros.
Para ello se tomará como guía un folio en blanco que simulará la pantalla final del
ordenador. A medida que el usuario vaya dibujando o posicionando objetos encima del
folio, se leerán con la webcam y se mostrarán al usuario final. Se pretende que la
imagen se vaya mostrando en tiempo real, y si una vez se haya terminado de dibujar el
objeto deseado, éste es reconocido por el sistema, en vez de mostrar el dibujado se
muestre el dibujo asociado a ese objeto almacenado en memoria.
Figura 1: Descripción del Proyecto
Este proyecto no pretende dar una solución óptima para una aplicación concreta,
sino más bien una visión general de lo que puede llegar a hacerse en el campo de la
integración de objetos sintéticos con imágenes y video real. Debido al incremento de la
capacidad de proceso de los ordenadores, y al abaratamiento de las cámaras y displays
para dispositivos móviles, el mundo de la realidad aumentada está más de moda que
nunca.
2
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Muestra de ello es la gran cantidad de posibilidades que ofrece, no solamente en
aplicaciones industriales y profesionales, sino por los productos que en un futuro no
muy lejano usarán esta tecnología para que el gran público disfrute de “ilusiones
sintéticas” en primera persona.
1.2. Conceptos generales
Debido a que este proyecto se enmarca en el campo de la visión computacional,
es necesario introducir algunos de los elementos básicos de la representación de
imágenes [ESQU02].
1.2.1. Píxel
Es la abreviatura de las palabras inglesas “picture element” (figura X). Es el
menor de los elementos de una imagen al que se puede aplicar individualmente un color
o una intensidad o que se puede diferenciar de los otros mediante un determinado
procedimiento.
Figura 2: Representación de un píxel
1.2.2. Imagen digital
Una imagen digital se compone de una agrupación de píxeles, cada uno con un
valor de intensidad o brillo asociado. Una imagen digital se representa mediante una
matriz bidimensional, de forma que cada elemento de la matriz se corresponde con cada
píxel en la imagen (ver figura 3).
3
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
a)
b)
Figura 3: La imagen a) corresponde a la original. La imagen b) corresponde a la
estructura matricial de la imagen
1.2.3. Clasificación de imágenes digitales
Dependiendo del rango de los valores que pueda tomar cada píxel podemos
distinguir los siguientes tipos de imágenes:
Imágenes en blanco y negro: el rango está formado por los valores negro o blanco [0 1]
únicamente. En la figura 4 se muestra una imagen de este tipo.
Figura 4: Imagen en blanco y negro
Imágenes de intensidad: también conocidas como imágenes en escala de grises, existen
hasta 256 niveles de grises, por lo que su rango se encuentra entre [0,255].
4
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Figura 5: Imagen en escala de grises
Imágenes en color: todo color se puede componer a partir de tres componentes básicas.
El contenido de cada píxel de la imagen es una terna de valores, un valor por cada
componente de color básico.
Figura 6: Imagen en color
1.2.4. Espacio de color: Modelo RGB
Es uno de los modelos más utilizados por los sistemas informáticos para
reproducir los colores en el monitor y en el escáner [PRAD02]. Está basado en la
síntesis aditiva de las intensidades de luz relativas al rojo, al verde y al azul para
conseguir los distintos colores; incluyendo el negro y el blanco.
5
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
El nombre del modelo RGB viene de las iniciales, en inglés, de esos tres colores:
Red, Green y Blue.
Figura 7: Representación gráfica del modelo de color RGB
La representación gráfica del modelo RGB (ver figura 1.6) se realiza mediante
un cubo unitario con los ejes R, G y B. El origen (0,0,0) representa el negro y las
coordenadas (1,1,1) el blanco. Los vértices del cubo en cada eje R, G y B, de
coordenadas (1,0,0), (0,1,0) y (0,0,1) representan los colores primarios rojo, verde y
azul. Los restantes tres vértices (1,0,1), (0,1,1) y (1,1,0) al magenta, cian y amarillo
respectivamente, colores secundarios y respectivamente complementarios del verde,
rojo y azul. La diagonal del cubo representa la gama de grises desde el negro al blanco.
En esta diagonal cada punto o color se caracteriza por tener la misma cantidad de cada
color primario.
Las imágenes con modelo RGB contienen tres planos de imágenes
independientes, uno para cada color primario. Cuando estas tres imágenes son
proyectadas a un monitor RGB, la pantalla de fósforo produce una imagen de color
compuesto. El procesamiento de imágenes en color, utilizando el modelo RGB, toma
sentido cuando las imágenes se expresan naturalmente en términos de tres planos de
color. Actualmente muchas cámaras a color utilizadas para adquirir imágenes digitales,
utilizan el formato RGB.
Lo anterior convierte al modelo RGB en un modelo de gran importancia para el
procesamiento de imágenes, a pesar de que no deriva en un proceso intuitivo para
determinadas aplicaciones como por ejemplo la de comparar colores.
6
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
1.3. Ámbito del proyecto
1.3.1. Realidad Aumentada
El concepto de Augmented Reality (realidad aumentada en inglés) se originó a
partir de la unión del campo de los gráficos generados por ordenador y la visión
artificial. Los términos realidad virtual y ciberespacio se han hecho muy populares a
partir de ciertas películas de ciencia ficción como Star Trek, que no solamente
mostraron estos conceptos al gran público sino que también influenciaron enormemente
a la comunidad de ingenierios.
Estos términos suelen asociarse con la tecnología que permite navegar en un
mundo completamente sintético generado por ordenador (un entorno virtual). En este
entorno virtual, la visión, el oído, el tacto, el olfato... etc se controlan por un ordenador
mientras las acciones del usuario influyen en el estímulo producido. Probablemente el
“Holodeck” de Star Trek es uno de los ejemplos más populares. Aunque parte de la
tecnología de este dispositivo se ha podido realizar en los últimos años, la mayor parte
de su funcionamiento es todavía ciencia-ficción.
¿Qué es entonces la realidad aumentada (AR)? Alguna gente define la AR como
un caso especial de Realidad Virtural (VR); otros argumentan que la AR es un concepto
más general y que entonces la VR sería un caso especial de AR. El hecho es que en
contraste con la realidad virtual tradicional, en la realidad aumentada el entorno real no
se suprime completamente; de hecho, juega un papel importante.
En vez de introducir a una persona en un entorno totalmente virtual, la AR
intenta integrar objetos sintéticos en un entorno real (o en un vídeo del entorno real).
Esto desemboca en un problema fundamental: un entorno real es mucho más difícil de
controlar que uno sintético.
Teniendo esto en cuenta, ¿podría un monitor de TV usarse como un visualizador
de AR? La mayoría de nosotros diríamos ... ¿por qué no? Obviamente, hay muchos más
misterios por resolver antes de dar una buena respuesta a esta cuestión. La información
“aumentada” necesita un enlace mucho más fuerte con el entorno real que la realidad
virtual. Este enlace básicamente es una relación espacial entre el “aumento” y el entorno
real. A esto se le llama link registration.
7
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
La proyección espacial de la Princesa Leia en Star Wars por R2-D2 es un buen
ejemplo de realidad aumentada. Algunos acercamientos tecnológicos que emulan la
proyección espacial holográfica, como el Holodeck, pueden verse hoy en día. Pero la
implementación de Star Wars todavía es una ilusión creada por Hollywood. Sin
embargo, a finales de los años 50 ya se propusieron algunas ideas para fabricar un
display virtual.
Sutherland desarrolló el primer display montado en la cabeza (Head Mounted
Display HMD) que ayudó al nacimiento de la realidad aumentada. El sistema se basaba
en dos espejos dispuestos de forma que el usuario podía ver tanto las imágenes
generadas por ordenador reflejadas por los tubos de rayos catódicos (CRT), como los
objetos reales de la estancia. Aparte de esto, también se usaban sensores mecánicos y de
ultrasonidos para medir la posición de la cabeza del usuario.
Figura 8: Display montado en la cabeza (HMD)
Hoy en día, el reto a batir en la realidad aumentada sigue siendo el desarrollo de
algoritmos sólidos para integrar de la mejor manera posible elementos sintéticos y
elementos reales. Por ejemplo, si el usuario se mueve, el sistema debe determinar
continuamente su posición en el entorno real. El tracking y el registro de puntos
característicos son los dos mayores problemas de la integración 2D-3D.
En general, se puede diferenciar entre tracking “externo” y tracking “interno”
dependiendo de si se trabaja o no con un sistema global de coordenadas. El primer tipo,
el “externo”, se refiere a los sistemas que usan sensores fijos en el entorno para realizar
un seguimiento de emisores colocados en los objetos que se mueven.
8
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
El segundo tipo, “interno”, usa sensores que están en los propios objetos en
movimiento. Estos sensores son capaces de determinar las posiciones relativas con
respecto a los emisores fijos del entorno real. Normalmente estos dos tipos de tracking
se emplean solamente para calcular aproximaciones de los parámetros de cámara, pero
también son adecuados para apoyar a otras tecnologías de seguimiento.
Aparte del tracking electromagnético y mecánico, el tracking óptico se ha hecho
muy popular. Mientras que las soluciones basadas en infrarrojos pueden obtener una
gran precisión y velocidad de seguimiento, el basado en patrones y cámaras
convencionales es una buena solución de bajo coste. Las soluciones de tracking que no
requieren marcadores o patrones (markless tracking en la terminología inglesa), son
desde luego las más complejas y desafiantes al mismo tiempo que prometedoras de cara
a un futuro cercano.
Actualmente se está empleando mucho esfuerzo y tiempo en mejorar el
rendimiento, precisión, robustez y accesibilidad de los sistemas de realidad aumentada.
Hacer un buen tracking en entornos con profundidad de campo muy grande, como en
exteriores, todavía es difícil de conseguir aún usando otras tecnologías como GPS en
combinación con giróscopos y acelerómetros.
La tecnología de los displays, aparte del problema del tracking, es otro pilar
básico de la realidad aumentada. Los HMD son la tecnología predominante hoy en día,
sin embargo todavía sufren de limitaciones ópticas (campo visual y enfoque fijo),
técnicas (resolución de imagen e inestabilidad) y físicas (el peso y el tamaño de los
dispositivos HMD). Últimamente la tendencia pasa por utilizar las pantallas de los
teléfonos móviles y PDAs como displays de realidad aumentada, lo que ofrece un futuro
prometedor en este campo.
Figura 9: Móvil con cámara en una aplicación de realidad aumentada
9
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
El tercer elemento básico de la realidad aumentada es el render en tiempo real.
Ya que la AR principalmente se basa en componer objetos sintéticos en un entorno real,
se deben utilizar los métodos de integración más rápidos y reales que sean posibles para
la representación. Hay que tener en cuenta que en general todas las aplicaciones de
realidad aumentada no necesitan ofrecer el mayor realismo posible. En caso de que así
fuera, sería necesario utilizar un rendering foto-realístico. También hay que tener en
cuenta las oclusiones, y el trazado correcto de sombras y reflexiones.
En el caso de no tener que ofrecer interactividad, hoy en día se pueden utilizar
técnicas de iluminación como la radiosidad y trazado de rayos (ray tracing). Aún con
menos foto-realismo dan poco rendimiento en el caso de que el usuario se mueva
rápidamente (debido a los complejos cálculos de iluminación que deben hacerse),
incluso usando aceleración por hardware. La clave de todo esto, por tanto, se encuentra
en el desarrollo una buena cadena programable de rendering (programmable pipeline)
de forma que se consiga la representación de objetos sintéticos más realista posible en
aplicaciones de realidad aumentada.
Recientemente están emergiendo nuevas ideas y metodologías para el desarrollo
de nuevas técnicas de representación, generación de contenidos y dispositivos para
aplicaciones de AR. Algunas de ellas se basan de desarrollos procedentes del mundo de
la realidad virtual, el multimedia o la comunicación digital. El mayor problema de todo
esto es la juventud de la realidad aumentada.
Mientras que los fundamentos de la realidad virtual ya están bastante maduros y
definidos, este no es el caso de la realidad aumentada ya que es un campo más reciente.
Pero en cuanto la base de la AR crezca y se haga más sólida, el campo de aplicaciones
empezará a crecer exponencialmente.
En los últimos años ha surgido otra nueva rama de investigación, como es la
realidad aumentada espacial (Spatial AR), que básicamente es una ampliación de la
realidad aumentada hacia el propio mundo real. Es decir, la proyección de objetos
sintéticos mediante técnicas láser, holografía, pantallas transparentes o proyectores de
vídeo.
10
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
1.3.2. Visión Artificial
La visión Artificial es una disciplina que tiene como finalidad la extracción de
información del mundo físico a partir de imágenes, utilizando para ello un computador.
Se trata de un campo de conocimiento con un objetivo ambicioso y complejo que en los
últimos años ha evolucionado de manera drástica con el desarrollo de los ordenadores y
sensores de captura de imágenes.
Un sistema de Visión Artificial actúa sobre una representación de una realidad
que le proporciona información sobre brillo, colores, formas, etc. Estas representaciones
se pueden agrupar principalmente en imágenes estáticas, escenas tridimensionales e
imágenes en movimiento [SANC03]
La Visión Artificial, también llamada Visión Computacional, pretende con
determinadas restricciones reproducir el comportamiento del ser humano. En un sistema
de Visión Artificial se definen las siguientes cuatro fases bien diferenciadas en el
procesamiento de imágenes, mostradas en la Figura 1.1:
Figura 10: Etapas típicas en un sistema de Visión Artificial
-
La primera fase, consiste en la Captura o Adquisición de las imágenes digitales
mediante algún tipo de sensor, fundamentalmente una cámara. Una imagen que
es capturada a través de un sensor, se guarda en la memoria de la computadora
como un arreglo o matriz de puntos, llamados píxeles.
Dependiendo del tipo de imágenes que se traten, cada punto representará la
intensidad o brillo de la imagen, si se trabaja con imágenes en blanco y negro; o
tres matrices de puntos, uno para rojo, otro para verde y otro para azul si lo
hacemos con imágenes a color; su combinación representa los diferentes colores.
11
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
-
La segunda etapa tiene por objeto el tratamiento digital de imágenes para
facilitar las etapas posteriores. En esta fase, conocida como Preprocesamiento,
mediante filtros y transformaciones geométricas se tratan de eliminar partes
indeseables de la imagen y realzar los detalles de interés para su posterior
análisis.
-
La Segmentación es la siguiente fase, y consiste en particionar una imagen en
regiones homogéneas con el fin de extraer características de dichas regiones
(color, textura, forma,…) para la posterior etapa de reconocimiento.
-
Para finalizar, se llega a la etapa denominada de Reconocimiento o
Clasificación. Valiéndose del análisis de ciertas características que se establecen
previamente para diferenciar los objetos segmentados, se pretende discernir
entre unos y otros.
Diferentes aspectos han ayudado a llevar a la Visión Artificial al campo de las
aplicaciones industriales como: el aumento de las prestaciones de los ordenadores,
desarrollo de técnicas algorítmicas eficientes para el abordaje de los problemas, etc.
Estos aspectos han permitido realizar el tratamiento de imágenes en tiempo real.
La Visión Artificial incluye, entre otras, las siguientes aplicaciones [WIKI09]:
- La detección, segmentación, localización y reconocimiento de ciertos objetos en
imágenes.
- La evaluación de los resultados.
- Registro de diferentes imágenes de una misma escena u objeto, hacer concordar un
mismo objeto en diversas imágenes.
- Seguimiento de objetos en secuencias de imágenes.
- Mapeo de una escena para generar un modelo tridimensional de la escena.
- Estimación de las posturas tridimensionales de humanos.
- Búsqueda de imágenes digitales por su contenido.
12
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
1.3.3. El problema de la visión dinámica
Una escena dinámica se compone de una secuencia de frames o fotogramas
interrelacionados, donde cada fotograma representa la escena en un determinado
instante de tiempo t.
Figura 11: Fotogramas de una secuencia de imágenes a través del tiempo
Debemos entender un sistema de visión dinámica como un conjunto de
coordenadas espaciales (x,y) dentro de cada fotograma y además añadir un tercer
parámetro como sería el tiempo t, permitiéndonos su combinación la descripción de la
entrada de un sistema de visión dinámica como una función F(x,y,t).
La entrada en juego del parámetro t es fácil de entender si se tiene en cuenta los
posibles cambios que pueden darse en la escena, ya sea debido al movimiento de la
escena en sí misma, de la cámara o de ambos. En el trabajo que se trata, ese
movimiento de cámara no va a producirse, debido a que las secuencias de imágenes
serán captadas mediante una cámara estática.
Para procesar información dinámica se podrán aplicar técnicas estáticas a cada
fotograma por separado o analizar una secuencia de forma continua.
1.3.4. El problema de la calibración: La distorsión de la lente
Con frecuencia se tiene en cuenta una proyección ideal y perfecta de la cámara
(modelo pinhole según la nomenclatura). En la realidad esto no es así, y uno de los
factores que más influyen en que la cámara obtenga imágenes deformadas con respecto
a la realidad es la distorsión de la lente. Esto sobre todo se observa de forma acusada en
lentes de bajo coste como las usadas en la fabricación de webcams y algunas cámaras de
vídeo baratas.
13
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Podemos encontrar dos tipos básicos de distorsión de lente: radial y tangencial,
como se muestra en la figura 12.
Figura 12: Tipos básicos de distorsión en una lente
Se caracteriza la distorsión radial (normalmente la más predominante) a partir de
la definición de la ecuación de la circunferencia. Podemos definir las coordenadas de un
punto proyectado idealmente (no distorsionado) por ( , ). Por tanto para un punto X
tenemos:
, ,1)T I | 0 X cam
siendo Xcam el punto 3D en coordenadas de cámara, y relacionado con las coordenadas
del mundo. Por tanto el punto proyectado se relaciona con el punto ideal con un
desplazamiento radial. Por tanto, la distorsión radial se puede modelar como la
expresión
̃
siendo ( , ) la posición ideal de la imagen (obtenida por una proyección lineal.
(xd, yd), es la posición final de la imagen, después de aplicar distorsión radial.
es la
distancia radial
desde el centro de distorsión. L( )es un factor de distorsión,
que es función del radio
. En coordenadas de píxel, la corrección se escribe como:
= xc + L(r)(x-xc)
= yc + L(r)(y-yc)
14
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
donde (x, y) son las coordenadas medidas, ( ,
) son las coordenadas corregidas, y
(xc, yc ) es el centro de la distorsión radial, con r2 = (x-xc)2 + (y-yc)2. Hay que remarcar
que si la relación de aspecto no es la unidad entonces es necesario corregir esto antes de
calcular r.
En cuanto a la elección de la función de distorsión y su centro, la función L(r)
sólo está definida para valores positivos de r y en L(0) = 1. Una aproximación a la
función que modela la distorsión radial se puede dar a través de un polinomio de Taylor
de la forma L(r) = 1+ k1r + k2r2 + ... Los coeficientes para la corrección radial
{k1,k2,k3,…,xc,yc} se consideran parte de la calibración interna de la cámara.
El punto principal de la proyección suele usarse como centro inicial para la
distorsión radial, aunque no necesariamente deben coincidir exactamente. Hay que
apuntar que la corrección radial será más precisa en cuanto se usen más coeficientes ki
para el modelado de la distorsión. Normalmente suelen utilizarse los dos primeros
{k1,k2 } aunque puede tomarse todos los parámetros que se quieran para una estimación
más exacta de la distorsión de la lente.
Figura 13: Imagen distorsionada obtenida por una cámara (izquierda). Imagen corregida
(derecha).
Hay diversos métodos para calibrar una cámara. Pueden utilizarse patrones de
calibración o realizar la llamada autocalibración.
Los métodos de calibración clásicos se pueden clasificar en función de diferentes
criterios [ISER03]:
15
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA

Computación lineal vs no lineal:
-
Lineal. Usan técnicas de resolución de sistemas de ecuaciones lineales. Son
muy simples de implementar y muy rápidos (como el DLT).
-
No lineal. Se basan en el uso de métodos iterativos, como el algoritmo Gold
Standard. Generalmente, se requiere un buena aproximación inicial obtenida de un
método lineal. Son mucho más lentos, pero permiten resolver modelos de cámara más
complejos (ej: modelar la distorsión) que incluyen un mayor número de parámetros.

Calibración explícita vs implícita
-
Explícita. Se obtienen los valores de cada uno de los parámetros que
forman el modelo.
-
Implícita. Se obtienen, generalmente, matrices de transformación que
contienen el conjunto de todos los parámetros. No se puede conocer el valor
exacto de algunos parámetros.

Calibración en un paso vs multipaso
-
Un solo paso. En cada ciclo del proceso de resolución se actualizan todos
los parámetros a la vez.
-
Multipaso. En cada fase se obtiene un conjunto distinto de parámetros,
usándose aproximaciones en los primeros pasos para aquellos que aún no se
hayan calculado y aplicándose los resultados que se van obteniendo en los
siguientes pasos.

Patrón en un plano vs múltiples planos
-
Un plano. Todos los puntos del patrón están en el mismo plano. Por tanto,
tienen la ventaja de reducir el ruido en las coordenadas del patrón, ya que
una de las coordenadas 3D es nula.
-
Múltiples planos. Dentro de este grupo se pueden distinguir dos tipos. Por
un lado, aquellos que necesitan conocer la relación entre los planos,
generalmente, se opta por que formen un diedro, es decir, dos planos que
forman un ángulo de 90 grados (en este caso se introduce un elemento que
puede generar errores como es el ángulo entre los dos planos [TSAI86]).
16
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Por otro lado, aquellos en los que no es necesario conocer la relación entre
las posiciones de los planos. Generalmente, pueden ser adquisiciones sobre
el mismo patrón variando la colocación del mismo o realizando
movimientos de la cámara [ZHAN00].
Dependiendo del algoritmo utilizado para obtener la matriz de cámara,
harán falta patrones con formas diversas (Figura 14)
Figura 14: Diversos patrones de calibración
Sobre los métodos de autocalibración se puede realizar las siguientes
clasificaciones: según el tipo de movimiento que es necesario realizar y según si los
parámetros intrínsecos pueden variar o no.

Tipos de movimientos
-
General: Permiten cualquier tipo de desplazamiento, orientado por tanto a
cámaras situadas sobre plataformas móviles. En algunos casos, pueden tener
problemas con movimientos específicos, por ejemplo, con traslaciones o
rotaciones puras.
17
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
-
Rotaciones Puras: Orientados a cámaras fijas como pueden ser, por
ejemplo, cámaras de vigilancia o para retransmisiones deportivas. Sólo se
permite realizar giros, habitualmente azimut y elevación.
-
Traslaciones Puras: Sólo se efectúan traslaciones, por tanto, no existen
cambios en la orientación, lo que permite simplificar las ecuaciones. En
general, se intenta buscar que los desplazamientos sean ortogonales entre sí.
-
En un plano: Útil en aquellos casos en los que los desplazamientos se
realizan en un mismo plano, aunque se permiten tanto rotaciones como
traslaciones. Están orientados a cámaras situadas sobre objetos que se
desplacen sobre una superficie plana.

Parámetros intrínsecos
-
Fijos: Son los métodos más antiguos, en los cuáles se supone que la
configuración de la cámara permanece estable entre las diferentes tomas de
imagen. En el caso de que haya alguna variación se hace necesario repetir
todo el proceso de calibración.
-
Variables: En general, se estudia principalmente el efecto de la variación
del zoom. En algunos métodos se presupone que el zoom sólo afecta a la
distancia focal, por lo que sólo este parámetro junto con los extrínsecos se
consideran distintos de unas imágenes a otras. En otros, se supone que el
zoom también puede afectar al valor del centro del eje óptico, pudiéndose
variar este parámetro también. Existen algunos métodos que toleran que
otros parámetros pueden variar de una imagen a otra (ratio del pixel,
coeficientes de distorsión, etc.).
18
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
1.4. Motivación
Cada vez son más comunes las teleconferencias y los sistemas de trabajo
colaborativo.
◦
Teleconferencias, videoconferencias
◦
Teleformación, pizarras electrónicas en PC
La realidad aumentada ofrece la posibilidad de convertir una imagen real en otra
virtual transformada.
Todo ello proporciona facilidades para crear la pizarra virtual que sirva como un
elemento más en los sistemas de trabajo colaborativo
19
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
1.5. Objetivos y Requisitos
Los objetivos de este proyecto se pueden definir y quedar claramente
clasificados como el desarrollo de una aplicación que sea capaz de realizar los
siguientes puntos, (posteriormente definidos algunos de ellos como las fases del
proyecto):

Obtener imágenes desde una webcam

Mostrar tanto imágenes como video de lo captado por la webcam en tiempo real

Reconocimiento del patrón esquina, de modo que se pueda establecer la región a
mostrar
en
la
ventana
final,
descartando
toda
aquella
información
complementaria

Mostrar lo que el usuario pinta en la hoja de modo que sólo aparezca el trazo del
dibujo y no su mano. Para ello, es necesario que se utilice un rotulador de color
rojo, a poder ser el siguiente modelo o similar.
Figura 15: Rotulador

Detectar similitudes entre lo que el usuario ha dibujado y los patrones
establecidos, de modo que si alguno es localizado, se sustituya la parte
reconocida por la almacenada en la base de datos
20
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
1.6. Metodología
La metodología utilizada para desarrollar este proyecto ha sido la basada en el
modelo en espiral
Figura 16: Modelo en espiral
El modelo de desarrollo en espiral tiene 4 actividades por ciclo:
-
Determinar los objetivos de lo que se construirá en la iteración
-
Analizar los riesgos que ello conlleva
-
Desarrollar y probar
-
Planificar para el siguiente ciclo.
Este enfoque ofrece un dinamismo alto, que se corresponde con el método de
investigación y producción que se ha usado en el proyecto ya que es necesario diseñar
un plan de trabajo sobre una cuestión en particular sobre la que se desea experimentar,
comprobar que el enfoque funciona correctamente y luego incorporarlo al cuerpo de
trabajo ya realizado. De esta forma, el modelo encaja con la forma de trabajo usada.
Una de las principales ventajas de este modelo es que permite utilizar lo que se
ha aprendido en un ciclo para el siguiente. Esto reduce los riesgos de una sección que
finalmente no muestra los resultados esperados ya que al menos se saca algo del ciclo y
se puede corregir en el siguiente, aunque no puede ser incorporada al cuerpo de trabajo.
Además, es posible tener en cuenta mejoras o nuevos requerimientos sin romper
la metodología ya que el propio modelo tiene en cuenta la posibilidad.
21
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
El hecho de que, tras un ciclo la aplicación pueda ser usable, nos da la
posibilidad de aprender también de su uso además de su desarrollo. En el caso de
interés, el filtro de partículas básico conforma las primeras etapas de desarrollo en las
que se produce un software usable, ayuda a comprender el funcionamiento de dicho
filtro y permite que se aprenda tanto de la estructura interna como del uso del mismo y
su comportamiento con videos de prueba.
De este modo las mejoras aplicadas al filtro de partículas son, en esencia, nuevas
iteraciones del ciclo que permiten una reutilización de recursos y de información
obtenida en etapas anteriores. En la iteración inicial se planteó como propósito
conseguir un software sobre el que el usuario (el desarrollador y los tutores) pudiesen
replantearse decisiones.
Otro objetivo era conseguir una idea de los aspectos que serían clave en los
posteriores ciclos y presentar una solución que fuese lo suficientemente simple como
para crear un primer prototipo fácil de implementar y entender. Una vez terminada la
iteración, incluimos en la lista de control del proyecto las mejoras necesarias.
La realimentación entre el desarrollo y las nuevas ideas a incluir ha sido
fundamental y gracias al método de desarrollo elegido el proceso ha sido natural y
provechoso.
22
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
1.7. Recursos/ Herramientas utilizadas
1.7.1. OpenCV
El 13 de Junio de 2000, Intel Corporation anunció que estaba trabajando en la
realización de una nueva biblioteca de estructuras/funciones en lenguaje C junto con un
grupo de prestigiosos investigadores (Jitendra Malik, University of California Berkeley;
Takeo Kanade, Carnegie, Mellon University; Pietro Perona, NSF Engineering Research
Center…) en visión por computador.
De esta forma nació The Open Source Computer Vision Library (OpenCV),
especialmente diseñado para el tratamiento, captura y visualización de imágenes en
áreas como interacción hombre-máquina, robótica, monitorización, biométrica,
segmentación y reconocimiento de objetos y seguridad y que proporciona bibliotecas de
tipos de datos estáticos y dinámicos (matrices, grafos, árboles, etc.). Está optimizada
para ser usado bajo procesadores Intel, particularmente para la tecnología MMX,
Pentium Pro, Pentium III y Pentium 4, pero puede ser usada bajo cualquier otro tipo de
procesadores.
OpenCV es ampliamente utilizado en entornos de vigilancia y seguimiento de
objetos. Ha sido utilizado en grandes proyectos como el DARPA Grand Challenge
[BRAD08] por el equipo ganador y en la herramienta SwisTrack [BRAD08] para
navegación de robots.
La biblioteca OpenCV es una API de más de 300 funciones escritas en lenguaje
C y que tienen las siguientes características:

Su uso es libre tanto para uso comercial como no comercial.

No utiliza bibliotecas numéricas externas, aunque puede hacer uso de alguna de
ellas en tiempo de ejecución si están disponibles.

Es compatible con IPL (Intel Procesing Library) y utiliza IPP (Intel Integrated
Permormance Primitives) para mejorar su rendimiento, si están disponibles en el
sistema.
23
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Además, OpenCV dispone de interfaces para otros lenguajes y entornos como:

EiC – Intérprete ANSI C escrito por Ed Breen, actualmente se encuentra en
desuso. Hawk y CvEnv son entornos interactivos (escritos en MFC y TCL,
respectivamente).

Ch – Intérprete ANSI C/C++ con algunas características de scripting,
desarrollado
y
mantenido
por
la
compañía
SoftIntegration®
(http://www.softintegration.com). Los wrappers para Ch están disponibles en
opencv/interfaces/ch.

MATLAB - Entorno para procesamiento numérico y simbólico desarrollado por
Mathworks. El interfaz de MATLAB para algunas funciones de OpenCV se
encuentra disponible en opencv/interfaces/matlab/toolbox. En cuanto a la
integración con Matlab, OpenCV puede utilizar las estructuras nativas de
Matlab, y es compatible con el Image Processing Toolbox.
Estructura
Todas las herramientas de alto nivel de OpenCV hacen uso de un paquete de
clases C++ y funciones C que usan a su vez funciones muy eficientes escritas en C.
Concretamente, el conjunto de funciones suministradas por la librería OpenCV pueden
agruparse en los siguientes bloques:

Estructuras y operaciones básicas.

Procesamiento y análisis de imágenes: filtros, momentos, histogramas…

Análisis estructural: geometría, procesamiento del contorno, etc.

Análisis del movimiento y seguimiento de objetos: plantillas de movimiento,
seguidores, flujo óptico, etc.

Reconocimiento de objetos: objetos propios (eigen objects), modelos HMM, etc.

Calibración de la cámara: morphing, geometría epipolar, estimación de la pose,
etc.

Reconstrucción tridimensional (funcionalidad experimental): detección de
objetos, seguimiento de objetos tridimensionales, etc.

24
Interfaces gráficos de usuarios y adquisición de video.
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
OpenCV se puede dividir en varias partes bien diferenciadas para su uso, que están a su
vez divididas en cabeceras (*.h) y son las siguientes: Cv, CvAux, HighGUI y CvCam.
Figura 17: Estructura OpenCV
Cada parte está especializada en una cosa en concreto:

En las bibliotecas Cv podremos encontrar los operadores estándar para el
cálculo de gradientes, detección de bordes, esquinas y contornos, conversión de
modelos de color, operaciones morfológicas como dilatación, erosión y
adelgazamiento,
transformadas
geométricas
(Hough),
operaciones
con
momentos (momento central, momentos invariantes, etc.), operaciones con
histogramas, y de matching.
Sobre
procesamiento
análisis
de
estructural,
contornos
podemos
(momentos,
encontrar
representación
funciones
jerárquica
para
de
contornos…) y computación geométrica. También encontraremos funciones para
tratar aspectos de análisis de movimiento y seguimiento de objetos,
procesamiento de flujo óptico, reconocimiento de patrones y estimación de la
pose de objetos, así como funciones para reconstrucción en 3D (calibración de la
webcam, reconocimiento de gestos…).

En CvAux están las funciones en fase de prueba o experimentales, como pueden
ser algoritmos para visión estéreo, seguimiento 3D…
25
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA

HighGUI permite la escritura/lectura de imágenes en numerosos formatos
(BMP, JPEG, TIFF, PxM, Sun Raster, etc.) y la captura de stream de video de
capturadotas Martos® y cámaras/capturadoras con controlador VFW/WDM (la
mayoría del mercado).
También permite la creación de ventanas para visualizar imágenes en
ellas. Estas ventanas recuerdan su contenido (no es necesario implementar
callbacks de repintado) y además, nos proporciona mecanismos muy fáciles para
interaccionar con ellas: trackbars que capturan la entrada del teclado y el ratón.

CvCam nos proporciona un único interfaz de captura y reproducción bajo Linux
y Win32; callbacks para la gestión de stream de video o ficheros AVI y un
mecanismo fácil para implementar visión estéreo con dos cámaras USB o
estéreo-cámara.
A partir de la versión 0.9.6. Estas funciones específicas de cámara se
eliminaron para el sistema GNU/Linux, dejando solamente operativas para el
trabajo con cámaras el módulo HighGUI.

CxCore dispone de estructuras de datos dinámicas y operadores para estas
estructuras. Entre estas estructuras de datos podemos encontrar vectores (cvArr),
matrices (cvMat), imágenes, grafos, etc.

La mayoría recibe por parámetro un vector máscara para especificar sobre qué
elementos de la estructura se aplica el operador. Podremos encontrar operadores
aritméticos (Add, Mult, Sub, AbsDiff…), lógicos (AND, OR, NOT, XOR), de
comparación, etc., así como funciones para aplicar cálculos estadísticos (SUM,
MAX, MIN, AVG…) y operadores de conversión de tipo o escala de colores
(ConvertScale).
En este proyecto, se han usado los módulos: Cv, CvAux, HighGUI y CxCore,
que tienen la siguiente interconexión estructural:
26
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Figura 18: Estructura usada de OpenCV
Convenciones
El software de OpenCV sigue las siguientes convenciones:

Los
identificadores
constantes
están
en
mayúsculas;
por
ejemplo,
CV_SEQ_KIND_GRAPH.

Todos los nombres de las funciones usadas para el procesado de imágenes tienen
el prefijo cv, por ejemplo: cvCreateImage, cvSobel, cvAdd. . .

Todas las funciones externas de OpenCV empiezan con el prefijo cv, y todas las
estructuras con prefijo Cv. Cada nueva parte de una función empieza con un
carácter en mayúscula, por ejemplo: cvContourTree.

Los nombres de funciones en OpenCV tienen el siguiente formato: cv [action]
[target] [mod] () donde:
-
action: la acción indica la funcionalidad del centro, por ejemplo, -Set-, -Create-,
-Convert
-
target: indica el área donde el procesado de la imagen está siendo establecido, por
ejemplo: -FindContours, -ApproxPoly. La mayoría de las veces “target” consta de
tres palabras, como MatchContourTree.
-
mod: es un campo opcional; indica una modificación de la funcionalidad de la
función. Por ejemplo: en la función cvFindExtrinsicCameraParams_64d, _64d,
indica que es una función constante particular de 64d valores.
27
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
1.7.2. C++
El comité para el estándar ANSI C fue formado en 1983 con el objetivo de crear
un lenguaje uniforme a partir del C original, desarrollado por Kernighan y Ritchie en
1972, en la ATT. Hasta entonces el estándar lo marcaba el libro escrito en 1978 por
estos dos autores. El lenguaje C++ se comenzó a desarrollar en 1980. Su autor fue B.
Stroustrup [STRO02], también de la ATT. Al comienzo era una extensión del lenguaje
C que fue denominada C with classes. Este nuevo lenguaje comenzó a ser utilizado
fuera de la ATT en 1983.
El nombre C++ es también de ese año, y hace referencia al carácter del operador
incremento de C (++). Ante la gran difusión y éxito que iba obteniendo en el mundo de
los programadores, la ATT comenzó a estandarizarlo internamente en 1987.
En 1989 se formó un comité ANSI (seguido algún tiempo después por un comité
ISO) para estandarizarlo a nivel americano e internacional. En la actualidad, C++ es un
lenguaje versátil, potente y general. Su éxito entre los programadores profesionales le ha
llevado a ocupar el primer puesto como herramienta de desarrollo de aplicaciones.
El lenguaje C++ mantiene las ventajas de C en cuanto a riqueza de operadores y
expresiones, flexibilidad, concisión y eficiencia. Además, ha eliminado algunas de las
dificultades y limitaciones del C original. La evolución de C++ ha continuado con la
aparición de Java, un lenguaje creado simplificando algunas características de C++ y
añadiendo otras, que se utiliza para realizar aplicaciones en Internet.
Las principales características del lenguaje C++ son:
-
Abstracción (encapsulación).
-
Soporte para programación orientada a objetos (polimorfismo).
-
Soporte de plantillas o programación genérica (templates).
Se puede decir que C++ es un lenguaje que abarca tres paradigmas de
programación: programación estructurada, programación genérica y programación
orientada a objetos. Además, añade una serie de propiedades que se encuentran más
difícilmente en otros lenguajes de alto nivel:
28
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
-
Posibilidad de redefinir los operadores.
-
Identificación de tipos en tiempo de ejecución (Runtime Type Information,
RTTI).
C++ está considerado por muchos como el lenguaje más potente, permitiendo
trabajar tanto a alto como a bajo nivel. Por otro lado, es uno de los lenguajes que
contiene menos automatismos1, lo que dificulta su aprendizaje.
1.7.3. Microsoft Visual Studio 2008
Microsoft Visual Studio es un entorno de desarrollo integrado (IDE, por sus
siglas en inglés) para sistemas Windows. Soporta varios lenguajes de programación tales
como Visual C++, Visual C #, Visual J #, ASP.NET y Visual Basic .NET, la
programación orientada a objetos conjuntamente con el sistema de desarrollo SDK2 de
Windows [ZARA99], aunque actualmente se han desarrollado las extensiones
necesarias para muchos otros.
Visual Studio permite crear aplicaciones, sitios y aplicaciones web, así como
servicios web en cualquier entorno que soporte la plataforma .NET. Así se pueden crear
aplicaciones que se intercomuniquen entre estaciones de trabajo, páginas web y
dispositivos móviles.
29
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
2. Descripción de fases
Como se ha mencionado anteriormente, en el punto 1.4 (Metodología), para el
desarrollo del proyecto se ha seguido una metodología en espiral. Por ello, se han
llevado a cabo cuatro iteraciones.
Cada una de estas iteraciones corresponde con uno de los grandes objetivos a
realizar en el proyecto. Por ello, y debido a la complejidad de cada uno de ellos, se
dividieron del siguiente modo:
I: Adquisición y visualización de video
II: Detección de esquinas
III: Sustracción de la mano
Una vez se ha conseguido la realización de cada una de estas fases con éxito y el
consiguiente cumplimiento de los objetivos, se lleva a cabo una nueva iteración en la
cual se desarrolla y ejecuta el proyecto final:
IV: Ejecución conjunta
Adquisición y
visualización
de video
Detección de
esquinas
Sustracción de
la mano
Ejecución conjunta
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Figura 19: Fases del Proyecto
A continuación se va a proceder a explicar lo realizado y desarrollado en cada
una de estas iteraciones.
30
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
2.1. Fase I: Adquisición y visualización de video
Esta iteración consiste fundamentalmente en una toma inicial de contacto con el
lenguaje C++ y la librería OpenCV. Para ello, se llevará a cabo la realización de un
simple programa que capte imágenes mediante una webcam, y se muestren en un frame
en tiempo real a modo de video.
2.2. Fase II: Detección de esquinas
Esta fase es una de las más importantes y costosas del proyecto. Como se mencionó en
la descripción del proyecto, el usuario debe limitar la zona a mostrar en el frame mediante
cuatro aspas. El programa una vez las haya detectado, será capaz de tomar sus posiciones. De
este modo, la aplicación es capaz de mostrar al usuario la zona deseada.
2.3. Fase III: Sustracción de la mano
Una vez que ya se sabe mostrar por pantalla lo que capturamos por la webcam,
se ha de “estudiar” la captura, para sólo mostrar lo que el usuario va dibujando,
consiguiendo eliminar su mano. Para ello, se llevaron a cabo varias opciones:
-detector de piel,
-detector de lo pintado,
las cuales serán explicadas en el apartado 3.3.3.
2.4. Fase IV: Ejecución conjunta
Llegados a esta iteración, ya se han cumplido los objetivos del proyecto por
separado. Por ello, se lleva a cabo una última iteración en la que se integre todo lo
aprendido y desarrollado en una única aplicación que corresponda con el proyecto final
a desarrollar.
31
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
3. Desarrollo
3.1. Fase I: Adquisición y visualización de video
3.1.1. Determinar los objetivos
Lo fundamental a conseguir en esta fase, es una primera toma de contacto con el
entorno y la librería OpenCV, ya que anteriormente no había hecho uso de ella. Por lo
tanto, al finalizar esta fase, se ha de ser capaz de:
-
Mostrar una imagen en un frame.
-
Mostrar en un frame la captura de la webcam, tanto una imagen como un video.
-
Guardar la captura de la webcam en un archivo.
3.1.2. Analizar los riesgos
Como ya se menciono anteriormente, ésta es una de las fases más sencillas por
lo que se ha de llevar a cabo, pero aún así supone un riesgo ya que implica el uso de
herramientas y lenguajes que anteriormente no he utilizado.
3.1.3. Desarrollar y probar
El desarrollo de esta fase fue bastante sencillo, ya que todo lo mencionado
anteriormente se realiza a través de unas simples funciones y en Internet existen muchos
manuales.
 Para mostrar una imagen, se ha de seguir el siguiente procedimiento:
1. Cargamos la imagen desde el fichero
IplImage *img = cvLoadImage(char[ ] filename, int type), siendo
Filename: la imagen a cargar
Type: hace referencia a los colores de la imagen
CV_LOAD_IMAGE_COLOR = 1, la imagen resultante es en color.
CV_LOAD_IMAGE_GRAYSCALE = 0, la imagen es en escala de grises.
32
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
2. Creamos la ventana donde se mostrará la imagen
cvNamedWindow(const *char name, int flags), siendo
name: nombre con el que se identificará la ventana
flags:
3. Mostramos la imagen
cvShowImage(const *char name, const CvArr* img), siendo
name: la ventana donde se va a mostrar la imagen
img: la imagen a mostrar
 Mostrar la captura de la webcam:
1. Iniciamos la webcam
capture=cvCreateCameraCapture( int index ), siendo
index: el índice aociado a la webcam (normalmente 0)
2. Captura por la webcam
img=cvQueryFrame (CvCapture *capture), siendo
capture: la estructura creado anteriormente asociada a la webcam
3. Mostrar la captura
cvShowImage(const *char name, const CvArr* img), siendo
name: la ventana donde se va a mostrar la imagen
img: la imagen a mostrar
Figura 20: Captura de la webcam en un frame
33
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
 Guardar la captura
1. Iniciamos la webcam y capturamos
Igual que en el anterior
2. Guardamos la captura
cvSaveImage(const char* filename, const CvArr* image), siendo
filename: el nombre de archive donde se guargará
image: la imagen que se desea guardar
3.1.4. Planificar
Para la siguiente fase se van a dedicar dos meses, durante los cuales se llevará a
cabo la técnica de Haartraining, explicada posteriormente, para el reconocimiento de las
esquinas del folio, donde previamente se haya dibujado una X.
Ésta parte no se puede establecer un período exacto de duración ya que depende
mucho del ordenador donde se lleve a cabo, las imágenes con las que trabaje, … Por
ello se le asigna un mes y medio de duración, prácticamente la duración total de la fase.
Figura 21: Planificación Fase II
34
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
3.2. Fase II: Detección de esquinas y patrones
El sistema de reconocimiento de objetos en imágenes ha despertado en los
últimos años un gran interés debido a sus posibilidades de aplicación en diversos
campos.
El objetivo es encontrar un objeto predefinido en una imagen estática. A veces
esta tarea consiste en extraer una cierta característica o rasgo de la imagen, como
pueden ser bordes, zonas de color, texturas, contornos, etc. y después usar métodos
heurísticos para encontrar alguna configuración o combinación de esos rasgos
específicos en el objeto de interés.
Para objetos complejos, como caras humanas, células, etc., es difícil encontrar
reglas que puedan manejar la gran variedad de casos y diferencias que dichos objetos
pueden albergar. Por ejemplo, en el caso de la detección de células, tenemos la distinta
forma de las mismas, variedad de tamaños de sus núcleos, la nitidez de las imágenes
tomadas, las distintas tonalidades que provocan los tintes aplicados, etc. A la hora de
detectar caras humanas, podemos encontrarnos con caras giradas, gafas, bigotes,
barbas…
Un sistema de detección de objetos en imágenes consiste en dividir primero la
imagen en subventanas y después evaluar cada una para averiguar si contiene o no al
objeto que buscamos. La forma en que se decide si esa subventana contiene al objeto
depende del método que se utilice, pero el sistema de detección siempre se basará en
ciertas características propias del objeto en cuestión. Para decidir si una subventana es el
objeto a buscar o no, OpenCV utiliza técnicas “boosting”; actualmente son usadas
Discrete Adaboost, Real Adaboost, Gentle Adaboost y Logitboost.
El boosting se basa en la aplicación de sencillas reglas, a las que únicamente se
les exige que sean un poco mejores que si se tomara la decisión sobre la subventana de
forma aleatoria. La combinación de varias de esas reglas son las que permiten obtener
un buen sistema de detección. El boosting será el método que permite combinar esas
reglas y construir el detector de objetos.
35
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Como ya hemos comentado, para construir un detector de objetos se requiere de
un proceso denominado “entrenamiento”, que se puede considerar como un aprendizaje
de la máquina sobre el objeto que deberá detectar en las imágenes. El entrenamiento es
el proceso donde se aplicará el boosting, y consiste en encontrar las reglas que mejor
clasifiquen el objeto y combinarlas para cada etapa del detector.
Durante el entrenamiento, distintos rasgos son extraídos de las imágenes y los
rasgos más distintivos pueden ser usados para clasificar el objeto seleccionado. Esta
información se introduce como parámetros del modelo estadístico. En el entrenamiento
se pueden producir dos errores: no detectar un objeto (falso negativo) o detectarlo
erróneamente (falso positivo).
Estas dos circunstancias anteriores son muy importantes. Para que un sistema de
detección de objetos se considere de buena calidad, se han de tener en cuenta
básicamente dos valores, que son la probabilidad de detección y la probabilidad de falso
positivo. La primera de ellas se obtiene como el número de objetos reales que ha
detectado el sistema frente el número de objetos que hay realmente en un conjunto de
imágenes. Este valor será el que cualquier sistema de detección de objetos intentará
maximizar.
En cuanto a la probabilidad de falso positivo, la obtendremos como el número de
detecciones incorrectas que ha realizado el sistema, es decir, el número de veces que el
sistema ha encontrado un objeto donde realmente no lo había, frente al número total de
detecciones. Y ese valor es el que siempre querremos minimizar, teniendo en cuenta que
ambos valores mantienen una relación directa: si uno de ellos aumenta, el otro también
lo hará.
El entrenamiento está basado en dos tipos de imágenes. El primer grupo consiste
en tomar múltiples instancias de la clase objeto de interés. A estas instancias las
llamaremos “muestras positivas” (deben contener los objetos que queremos que el
sistema detecte como, por ejemplo, caras, coches, células…). Junto a ellas, debemos
contar con una colección de imágenes donde no se encuentren dichos objetos que
pretendemos detectar. A este grupo lo llamaremos “muestras negativas”.
36
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
En un caso ideal, el algoritmo partirá del total del espacio muestral, distribuido
en las muestras positivas y negativas. Así, el clasificador obtenido tendría una
probabilidad de detección máxima y la probabilidad de falso positivo sería mínima. Sin
embargo, esto es imposible, por lo que resulta fundamental realizar un muestreo
adecuado.
Reglas (características Haar)
Como ya hemos visto, la detección se basa en unas reglas también denominadas
hipótesis o características débiles. Viola y Jones empezaron a introducir en sus
investigaciones con el boosting un tipo de características de la familia de las funciones
Haar. Podemos ver su representación gráfica en la siguiente figura:
Figura 22: Algunos tipos de características Haar de rectángulos
Estas reglas son llamadas características Haar porque derivan de las funciones
base de las ondículas de Haar.
Cada regla o característica corresponde a la diferencia de las sumas de los
píxeles de los rectángulos negros y blancos. OpenCV utiliza estas 3 reglas de la figura
anterior, pudiendo girarlas 45º para obtener más casos.
Con cada una de estas reglas es posible crear un clasificador débil como el
siguiente:
1
1
donde x es la sub-imagen analizada, zK(x) es la k-ésima regla y TK es el umbral
correspondiente.
A partir de estas reglas débiles se construyen clasificadores fuertes de mayor
complejidad y mayor eficacia.
37
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Un clasificador fuerte se crea a partir de la combinación lineal de clasificadores
débiles,
HM x
∑M α h
∑M α
x
donde αm ≥ 0, y corresponden a los pesos de cada clasificador débil y la decisión se
toma según el signo de HM(x).
El clasificador fuerte es entrenado por medio del algoritmo boosting (AdaBoost)
que, como ya mencionamos, buscan, a partir de la combinación de varios clasificadores
débiles, obtener un clasificador potente.
Estas reglas anteriores son muy sencillas de calcular, pero tienen un coste
computacional ligeramente alto.
Como ya dijimos, para evaluar toda la imagen la dividirá en subventanas que
serán sobre las que se calcularán estas reglas y además las subventanas de una misma
imagen se calcularán para diferentes escalas, por tanto, además de ser sencillas deben
poderse calcular con el menor número de operaciones posible. Para solucionar esto se
utiliza la Imagen Integral.
La Imagen Integral es una forma de representar una imagen para conseguir una
evaluación de las hipótesis muy rápida. Fue introducida por Viola y Jones en su sistema
de detección. Permite evaluar características de tipo rectangular, de una forma muy
rápida a muchas escalas diferentes. Además, su cálculo es muy sencillo ya que requiere
un número de operaciones muy reducido por píxel. La forma de calcularla es la
siguiente:
La Imagen Integral en el punto (x, y) de una imagen contiene la suma de todos
aquellos píxeles que queden por arriba y a la izquierda de dicho punto
(incluyendo la suma del punto en cuestión).
Matemáticamente:
SAT (x, y) = ∑
,
I x’, y’
donde SAT (x, y) es la imagen integral (Summed Area Table) e I(x’, y’) es la
imagen original.
38
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Gráficamente podemos verlo en la siguiente figura, donde el valor de la imagen
integral del punto (x,y) es la suma de todos los píxeles que quedan por encima y
a la izquierda de éste.
Figura 23: Valor de la Imagen Integral en el punto (x,y)
Para su cálculo se puede utilizar la siguiente ley recursiva:
S (x, y) = S (x, i−1) + I (x, y)
SAT (x, y) = SAT (x−1, y) + S(x, y)
donde S (x, y) es la suma de las intensidades de los píxeles de la fila en la que se
encuentra el punto, hasta y, con S(x, −1) = 0 y SAT (−1, y) = 0. De este modo la imagen
integral para cualquier punto se puede calcular en un solo paso sobre la imagen original.
AdaBoost
El boosting es uno de los más eficientes métodos para la construcción de
conjuntos de clasificadores. Sin embargo, hay una serie de problemas de clasificación
donde su rendimiento no es plenamente satisfactorio.
Donde mayores dificultades encuentra es en conjunto de datos con ruido, bien
porque hay atributos cuyo valor es erróneo, o bien porque hay ejemplos con la clase mal
asignada, por lo que en ocasiones nos podemos encontrar con problemas de
generalización.
39
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Boosting genera un conjunto de clasificadores y luego realiza una votación entre
ellos. Esta generación se realiza dependiendo de unos pesos asignados en función a los
resultados obtenidos previamente por el clasificador, con el objeto de minimizar el error
esperado en las diferentes distribuciones de salida.
AdaBoost fue presentado en 1995 por Y. Freund y R. Schapire y debe su nombre
a que es un tipo de boosting que se ajusta adaptativamente a los errores de las reglas de
clasificación débiles que genera el WeakLearn evaluadas sobre los ejemplos positivos.
La siguiente figura muestra el método AdaBoost. Cada ejemplo xi pertenece a
un dominio X y tiene asociada una etiqueta binaria yi que se codifica como +1 y −1.
AdaBoost asocia a cada ejemplo xi un peso, que en la iteración t se denomina Dt(xi). El
método base genera un clasificador base ht, teniendo en cuenta los pesos. Se selecciona
un valor real αt, el peso del clasificador base, que depende del error cometido por ese
clasificador. Entonces, se reajustan los pesos.
Dados (x1, y1), ..., (xm, ym) donde xi Є C, yi Є{ -1, +1}
Inicializar D1(i) = 1 / (m)
Para t = 1, ..., T:
-
Entrenar clasificador base utilizando la distribución Dt
-
Obtener clasificador base ht: X->
-
Seleccionar αt Є Î (en función del error cometido por ht sobre Dt)
-
Actualizar
D
i
D i exp
α yh x
donde Zt es un factor de normalización (elegido de modo que Dt+1 sea una
distribución).
El clasificador final es:
H x
signo
Figura 24: Proceso AdaBoost
40
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Podemos ver que hace falta un número elevado de reglas débiles para construir
un detector con unas tasas de detección y falsa alarma aceptables. Este conjunto de
reglas que componen el detector, van a ser evaluadas sobre cada subventana en la que se
dividirán las imágenes, y cada imagen se barre a varias escalas. Con lo que, pese a que
las reglas débiles son muy sencillas y se calculan fácilmente gracias a la Imagen
Integral, para cada imagen se debería hacer un importante número de operaciones para
la detección de un objeto. Esto supone que los clasificadores obtenidos tienen un alto
coste computacional.
P. Viola y J. Jones idearon un método para combinar clasificadores cada vez más
complejos en una estructura de árbol jerárquico o cascada, que incrementa la velocidad
del detector. Éste centra su atención en las zonas más prometedoras dentro de la imagen.
Es decir, se trata de averiguar rápidamente dónde no se encuentra el objeto.
Así, se reservan las operaciones más complejas y con mayor coste
computacional sólo a las zonas seleccionadas. Con este sistema, los clasificadores que
ocupan los primeros puestos dentro de toda la cascada, son los encargados de rechazar
la mayoría de subventanas que componen la imagen.
Resumiendo, una cascada de clasificación puede ser entendida como un conjunto
de clasificadores sencillos que se agrupan formando distintas etapas, dentro de las
cuales se evaluaría cada subventana y según si el resultado de esa evaluación (se detecta
o no el objeto), esa subventana pasaría a ser evaluada por la siguiente etapa o no
respectivamente.
Las etapas que componen la cascada se construyen con clasificadores entrenados
con AdaBoost. La llamada cascada de clasificación es lo que se conoce como árbol de
decisión degenerado. Si los primeros clasificadores de ese árbol dan una respuesta
positiva a la subimagen de entrada, la siguiente etapa procesa dicha subimagen, y así
hasta el final del árbol. En caso contrario se rechaza la imagen inmediatamente.
Dentro de una imagen, la mayoría de las subimágenes serán clasificadas como
negativas. De esta forma la cascada tiende a rechazar la mayoría de las subventanas que
componen una imagen en etapas tempranas.
41
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Figura 25: Cascada de clasificación
Falso positivo y detección
El proceso de diseño de la cascada se caracteriza por unas tasas de detección y
falso positivo que previamente nosotros decidimos cuáles deben ser. Es decir, partimos
de los valores para las probabilidades de detección y falso positivo que queramos que
tenga nuestro detector. El número de etapas que formen la cascada y el número de
reglas débiles que compongan cada etapa deben ser suficientes para conseguir unas
tasas suficientemente altas.
La tasa de falso positivo viene dada por:
FA
siendo K el número de etapas y fi la tasa de falso positivo de cada una de las etapas por
separado.
La tasa de detección es:
D
siendo di la tasa de detección de cada una de las etapas de la cascada.
42
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
De esta forma, habiendo concretado los valores que deseamos conseguir para las
probabilidades de detección y falsa alarma, podremos saber lo que tendría que cumplir
cada etapa por separado. Por ejemplo, una tasa de detección de 0,9 se puede conseguir
con 10 etapas con tasas de detección de 0,99, puesto que 0,9910 ≈ 0,9.
Podría parecer que obtendríamos una detección mayor con una sola de esas
etapas, pero entonces la tasa de falsos positivos se dispararía por encima del 30%, que
en un sistema real no resulta aceptable. Con una cascada de 10 etapas, la reduciríamos
hasta 0,310 ≈ 6 · 10-6.
Para llevar a cabo el entrenamiento, OpenCV proporciona una herramienta
denominada Haartraining desarrollada en lenguaje C++ por R. Lienhart.
Creación del árbol de detección
R. Lienhart y su equipo diseñaron una estructura de clasificación que se puede
interpretar como un árbol cuyas ramas estarán formadas por cascadas de clasificadores
especializadas como varias etapas de detección, cada una formada por varios
clasificadores o reglas débiles, siempre que esto suponga una mejora en la detección y
no aumente el coste computacional.
El entrenamiento de un árbol de estas características partiría del nodo raíz. Éste
se diferencia del resto de nodos en que no depende de ningún otro nodo padre. El
conjunto de muestras de entrenamiento positivas para el nodo raíz será el conjunto
positivo completo del que se disponga para todo el entrenamiento.
El algoritmo propuesto por Lienhart y sus colaboradores es un procedimiento
recursivo. En cada nodo, todas las muestras positivas y negativas transmitidas por el
nodo padre, se utilizan para entrenar un clasificador mediante Adaboost. La
complejidad computacional está linealmente relacionada con el número de
clasificadores débiles que componen cada rama, que es una cascada de clasificación de
las vistas en la sección anterior.
43
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Después de entrenar el nodo padre, el árbol se empieza a dividir en estas ramas
llamadas splits. Para el entrenamiento de cada una, se empleará el total de muestras
negativas y la parte correspondiente de positivas que habrá resultado de dividir las que
provenían del nodo padre en tantos subconjuntos como ramas se hayan desplegado. Si
el número total del características de todos los clasificadores que componen el árbol, es
menor que el empleado para construir un clasificador monolítico, entonces esta
estructura será más eficiente computacionalmente. El algoritmo recursivo de
construcción de las ramas se repetirá sucesivamente hasta que se alcance la profundidad
requerida para los objetivos de detección especificados.
Una vez construido el árbol, el proceso de clasificación de una subventana (el
proceso para decidir si esa subventana contiene al objeto o no) será el siguiente: el
candidato empezará siendo evaluado por el nodo raíz (el de la primera etapa). Si éste ya
lo rechaza, la subimagen será etiquetada como negativa y el proceso de detección habrá
finalizado.
Si por el contrario el nodo raíz acepta la muestra, ésta pasará a una de las ramas
en las que se habrá dividido el nodo raíz. Si la rama da al candidato como negativo, la
muestra probará suerte por la otra rama, y así hasta encontrar un camino de aceptación
que permita a la muestra alcanzar el final de árbol y pasar a la siguiente etapa. Si las
supera todas entonces será clasificada como positiva. Si, por el contrario, en algún
punto del árbol, ya están explorados todos los caminos posibles y la muestra ha sido
rechazada por todos, ya se etiquetará como negativa y se terminará el proceso.
Haartraining
La aplicación Haartraining fue creada por Intel en el año 2000 con objeto de
investigar sobre algoritmos de boosting aplicados a la detección de objetos en tiempo
real, en concreto, de rostros humanos.
El programa de entrenamiento Haartraining implementa todo un proceso de
construcción de los clasificadores de objetos que es considerablemente complejo tanto
de entender como en su ejecución.
44
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Una explicación breve de los pasos que sigue Haartraining para la realización
del clasificador es la siguiente:
1. Reserva de memoria: Primeramente, se reserva la memoria necesaria para albergar
el clasificador con el número de etapas solicitadas desde la llamada. Esta tarea la
realiza la función icvCreateCascadeHaarClassifier.
2. Almacenamiento de imágenes en vector: El fichero que contiene las imágenes de
fondo (ejemplos negativos) se abre para lectura y se almacenan todas las imágenes en
un vector. Este punto es realizado por dos funciones: icvInitBackgroundReaders e
icvCreateBackgroundData.
3. Preparación de la matriz: Tanto las muestras positivas como negativas que se
emplearán para construir el clasificador se almacenan en una estructura de datos
compuesta por matrices y campos numéricos.
El tamaño de las matrices depende del número de muestras de las que se
disponga y contendrán desde las imágenes en sí hasta sus pesos y factores de
normalización. Los campos numéricos son datos como las dimensiones de las muestras
o su número. Esta estructura de datos se llama CvHaartrainingData y se manejará
durante todo el entrenamiento para extraer información para el aprendizaje.
4. Construcción de las reglas: Se construyen todas las reglas posibles para el tamaño
de la muestra que se ha elegido desde la llamada al programa. La función utilizada en
este paso es icvCreateIntHaarFeatures. A partir de este momento, entramos en un bucle
cuyas acciones construyen una de las etapas del clasificador. En cada una de las vueltas
se construye (o se carga en memoria si ya está hecha) una etapa.
5. Comprobación de la existencia de la etapa: Haartraining es capaz de seguir
entrenando un clasificador que ya contiene alguna etapa. Si se da este caso, el programa
comenzaría su ejecución con la construcción de la etapa siguiente a la última que ya hay
construida. Si la etapa existe, el programa pasará directamente a la siguiente. Si no
existe, creará el directorio que la albergará. icvLoadCARTStageHaarClassifier será la
encargada de realizar esta etapa.
45
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
6. Obtención de las muestras positivas: Se abre el fichero que contiene las muestras
positivas, se comprueba su número y su tamaño y se van evaluando una a una para
contar sólo las que obtienen un resultado distinto de cero de la cascada. La función
usada es icvGetHaartrainingDataFromVec.
7. Búsqueda de candidatos negativos: A partir de las imágenes que se proporcionan en
el fichero de fondos (background) se han de extraer los candidatos negativos que
tendrán el mismo tamaño que las muestras positivas. El proceso de búsqueda es el
siguiente: se cargan las imágenes del fichero una a una y se parte desde el origen (x0 =
0; y0 = 0) de cada imagen.
A partir de ese punto se toma una subventana del tamaño de la nueva muestra y
se evalúa con la cascada de clasificación. Si el resultado es distinto de cero, esa
subventana se computa como candidato negativo. Después se pasa a evaluar la siguiente
subventana, cuyo origen se situará en (x0 + ancho + 1, y0) y se hará lo mismo. Así se
barren todas las x. Se hará lo mismo para las y, de modo que al final se barre toda la
imagen extrayendo los candidatos negativos que existen en ella.
Al terminar de barrer una imagen se pasa a la siguiente y se realiza la misma
operación. Al finalizar todas las imágenes de fondos que se tenían se vuelve a empezar
por la primera de ellas pero esta vez se toma como origen (x0 = 1, y0 = 1), de forma que
no se vuelven a repetir los candidatos vistos en la ronda anterior. Esta búsqueda finaliza
en el momento en el que se llega a reunir el número de candidatos negativos que se han
solicitado al Haartraining desde la llamada. Esta tarea de obtención de los candidatos
negativos, se repite al inicio de la construcción de cada etapa.
Sin embargo, el programa tiene memoria y empieza a buscar en el punto en que
se quedó, es decir, el proceso no empieza desde el principio de cada vez, sino que para
cada etapa consigue información nueva con la que poder continuar el aprendizaje. Se ve
aquí la importancia de proporcionar un fichero con un número de imágenes de fondo
suficientes como para que el programa pueda encontrar en ellas un número de
candidatos igual al número de etapas que se van a construir por el número de candidatos
negativos que se le han solicitado desde la llamada. Es decir, óptimamente se debería
cumplir que: Ncandidatos_totales ≥ Netapas_candidatos_solicitados.
46
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Si el número de imágenes es menor, el programa empieza a barrer subventanas
que ya utilizó, con lo que será más complicado extraer información, y por tanto el coste
computacional que requerirá Haartraining para finalizar el entrenamiento será mayor en
cada etapa.
8. Asignación de pesos: Tal como mencionamos anteriormente, es necesario otorgar
más importancia a unas muestras sobre otras, con el fin de que el clasificador centre su
aprendizaje en las más difíciles. Inicialmente todas tienen pesos iguales. Dicho peso se
calcula según la expresión:
1
siendo Nneg y Npos el número de muestras positivas y de negativas que se especifica en
la llamada al programa.
En caso de estar construyendo la Etapa 0, los pesos de las muestras se dejan con
este valor único para todas, pero para cualquier otra etapa, hemos de reasignarlo para
conseguir el efecto deseado, evaluando todo el conjunto muestral y ordenándolo según
su dificultad.
9. Elección y combinación de las mejores reglas: En esta etapa el programa está listo
para aplicar el boosting al disponer de las reglas necesarias, del espacio muestral
ordenado y de memoria suficiente. Por lo tanto entran en juego las funciones que
aplican el boosting para así seleccionar las mejores características de las disponibles y
combinarlas de la forma que mejor clasifiquen al conjunto muestral concreto del que se
dispone en al etapa en la que nos encontramos.
La función principal usada es icvCreateCARTStageClassifier, mientras que el
resto de subfunciones usadas en este paso se encuentran en el archivo cvboost.cpp.
10. Guardamos la etapa recién construida: Se almacena la etapa que acabamos de
construir en un archivo, que en este caso se llamará AdaBoostCARTHaarClassifier.txt
del directorio correspondiente a la etapa.
47
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
11. Finalización: Se repite el proceso para todas las etapas que se tengan que construir
y al finalizar la última se liberará toda la memoria reservada al principio y el programa
finaliza.
A continuación se muestra un esquema del proceso de funcionamiento del
Haartraining:
Figura 26: Funcionamiento del Haartraining
48
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
3.2.1. Determinar los objetivos
La finalidad de esta etapa consiste en que la webcam sea capaz de detectar el
área designada por el usuario como importante, para posteriormente mostrarla por la
pantalla, rechazando el resto de información que capture de alrededor. Para ello, el
usuario previamente ha debido marcar las esquinas de la región que desee con una X.
Del mismo modo, debido a su similitud en esta fase, se establece como objetivo
el reconocimiento de patrones en lo pintado por el usuario para su posterior cambio por
una imagen almacenada. Sólo se reconocerá el 0.
3.2.2. Analizar los riesgos
Uno de los mayores riesgos a considerar en esta etapa es el tiempo. Esto es
debido, ya que la técnica de HaarTraining es muy costosa y supone mucho tiempo de
espera, sin garantizar unos resultados óptimos a su finalización.
Otro de los riesgos a tener en cuenta, y que está presente a lo largo de todo el
proyecto, es la iluminación. El efecto de la luz provoca brillos y tonalidades no
deseadas, lo que implica que una misma X sea reconocida o no dependiendo de si hay
mucha o poca luz alrededor.
3.2.3. Desarrollar y probar
Como ya se ha comentado anteriormente, para la realización de ésta fase son
necesarias fotografías donde aparezca el objeto que posteriormente se quiere reconocer
y fotografías donde no aparezca.
Tanto en el caso de las X como del o el procedimiento es el mismo, por lo que
voy a limitarme a contar el procedimiento llevado a cabo en uno de los casos, X.
Para ello se tomaron 1023 fotografías donde el objeto aparecía, como la Figura
27 mostrada a continuación y 2251 como fotografías donde el objeto no aparecía.
49
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Figura 27: Reconocimiento de esquinas
A cada una de esas imágenes “positivas” se le va seleccionando la región, ancho
y alto donde se localizaba el objeto en la imagen y esa información se recopila en un
fichero de texto.
Una vez se tiene localizado en cada imagen el objeto de interés se crea un
archivo .vec que recoge esa información mediante
createsamples.exe –info positives/info.txt –vec data/vector.vec –num 1023 –w 24 –h 24
A partir de este momento comienza el proceso de HaarTraining propiamente
dicho. Para realizarlo correctamente se ha tenido que hacer uso de un ordenador de
sobremesa con mejores prestaciones que el portátil, ya que requiere de un alto consumo
de memoria RAM.
Para su realización se ejecuta la siguiente instrucción:
haartraining.exe –data data/cascade –vec data/vector.vec –bg negative/infofile.txt –npos
1023 –nneg 2251 –nstages 20 -mem 1024 –mode ALL –w 24 –h 24 –nonsym
siendo,
data: localización donde guarder la información generada
vec: archive con la información de las imágenes positivas
bg: localización del fichero con la información de las imágenes negativas
npos: número de imágenes positivas a analizar
nneg: número de imágenes negativas
nstages: número de iteracioes
50
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
mem: memoria dedicada al proceso
mode: modo de ejecución
w: ancho
h: alto
nonsym:
Mientras se está ejecutando genera una salida de pantalla similar a:
[…]
STAGE TRAINING TIME: 5037.31
STAGE: 17
POS: 1023 1023 1.000000
NEG: 2251 1308777143 0.000004
BACKGROUND PROCESSING
TIME: 26671.78
PRECALCULATION TIME: 108.59
[…]
STAGE TRAINING TIME: 5389.59
STAGE: 18
POS: 1023 1023 1.000000
NEG: 2251 -1465156860 -0.000003
BACKGROUND PROCESSING
TIME: 58371.50
PRECALCULATION TIME: 108.56
Figura 28:Ejecución Haartraining
Una vez ha finalizado de ejecutarse, vamos a la carpeta data/cascade, donde
tenemos los archivos creados en el paso anterior y necesarios para crear el fichero .xml.
haarconv.exe data output.xml 24 24
siendo,
data: directorio donde tenemos los ficheros generados anteriormente
output.xml: nombre a dar al fichero que se genera
24: ancho
24: alto
Para la finalización de esta fase, sólo queda comprobar el correcto
funcionamiento de los ficheros xml. Para ello se hace uso de la función llamada
51
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
detect_and_draw del Anexo D: Código (Figura 29). De este modo, localiza los objetos
establecidos como patrones en la imagen, y uno por uno va pintando un rectángulo
alrededor, para luego mostrarlo por pantalla (Figura 30).
int detect_and_draw( IplImage* img )
{
int scale = 1;
IplImage* temp = cvCreateImage( cvSize(img->width/scale,img->height/scale),8,3);
CvPoint pt1, pt2;
int i;
CvSeq* object;
cvClearMemStorage( storage );
if( cascade )
{
object = cvHaarDetectObjects( img, cascade, storage,1.1, 2,
CV_HAAR_DO_CANNY_PRUNING,cvSize(40, 40) );
if(object->total!=0){
if(object->total>4)
object->total=4;
for( i = 0; i < object->total; i++ )
{
CvRect* r = (CvRect*)cvGetSeqElem( object, i );
pt1.x = r->x*scale;
pt2.x = (r->x+r->width)*scale;
pt1.y = r->y*scale;
pt2.y = (r->y+r->height)*scale;
//pinto el rectangulo, donde ha detectado el objeto
cvRectangle( img, pt1, pt2, CV_RGB(255,0,0), 3, 8, 0 );
//Guardo los puntos
puntosx1[i]=pt1.x;
puntosx2[i]=pt2.x;
puntosy1[i]=pt1.y;
puntosy2[i]=pt2.y;
}
}
}
cvReleaseImage( &temp );
return (object->total);
}
Figura 29: Función detect_and_draw
52
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Figura 30: Detección de esquinas
Una vez conseguido esto, lo importante es centrarnos en la región interior
delimitada por el usuario. Para ello, al dibujar los rectángulos en las zonas detectadas,
guardamos las coordenadas de los mismos.
(X1,Y1)
(X2,Y2)
Figura 31: Coordenadas de las esquinas
Cuando se hayan obtenido estos cuatro valores, se ordenan atendiendo a X1,
para saber la esquina superior izquierda, y por tanto el punto desde el cual debemos
recortar el frame captado por la webcam. En este punto sólo nos falta saber el ancho y el
alto de la región a mostrar.
Para ello comparamos entre sí los valores de las X e Y de los cuatro puntos.
Todos estos valores se establecen en la función puntos del Anexo D: Código (Figura 32)
53
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
void puntos(){
for(k=0;k<3;k++){
for(j=1;j<4;j++){
//ordeno segun la x
if(puntosx1[j]<puntosx1[j-1]){
aux=puntosx1[j];
puntosx1[j]=puntosx1[j-1];
puntosx1[j-1]=aux;
aux=puntosx2[j];
puntosx2[j]=puntosx2[j-1];
puntosx2[j-1]=aux;
aux=puntosy1[j];
puntosy1[j]=puntosy1[j-1];
puntosy1[j-1]=aux;
aux=puntosy2[j];
puntosy2[j]=puntosy2[j-1];
puntosy2[j-1]=aux;
}
}
}
if(puntosy1[0]<puntosy1[1]){
puntoIni.x=puntosx2[0];
puntoIni.y=puntosy2[0];
}else{
puntoIni.x=puntosx2[1];
puntoIni.y=puntosy2[1];
}
for(j=0;j<4;j++){
if((puntosy2[j]!=puntoIni.y)&& (puntosx2[j]!=puntoIni.x)){
//hallamos el ancho y alto del rectangulo a mostrar en el frame
if((puntosy2[j]>(puntoIni.y-50))&&
(puntosy2[j]<(puntoIni.y+50))){
width=puntosx1[j]-puntoIni.x;
}
if((puntosx2[j]>puntoIni.x-40)&& (puntosx2[j]<puntoIni.x+40)){
height=puntosy1[j]-puntoIni.y;
}
}
}
54
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
//reajustamos los valores
puntoIni.x=puntoIni.x-20;
puntoIni.y=puntoIni.y-50;
width=width+50;
height=height+80;
if(width%4!=0){
width=((width/4)+1)*4;
}
if(height%4!=0){
height=((height/4)+1)*4;
}
}
Figura 32: Función puntos
Gracias a esta función ya podemos saber la región mostrar, y por lo tanto el
frame que el usuario verá (Figura 33).
Figura 33: Región del frame
55
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
3.2.4. Planificar
Una vez logrado esto, tenemos la mayor parte del proyecto finalizada, quedando
por desarrollar el análisis de la captura para sólo mostrar aquella información de interés,
como es el trazo de lo que el usuario va dibujando.
Para ello se va a dedicar un mes, como se muestra a continuación.
Figura 34: Planificación Fase III
56
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
3.3. Fase III: Sustracción de la mano
-Detector de piel
El objetivo final del modelado del color de la piel es construir una regla de
decisión que discrimine o diferencie entre los píxeles de una imagen que corresponden
al color de la piel y aquéllos que no. En la actualidad existen diferentes métodos
[VEZH03] para poder llevar a cado la detección de piel:
Definiciones explícitas de regiones de color
Un método para construir un clasificador de piel consiste en definir
específicamente los límites de la región correspondiente al color de la piel, a través de
unas reglas numéricas. Este método es aplicable en diferentes espacios de color. En el
trabajo [PEER03] la regla para una imagen en RGB es:
((R>45) && (G>40) && (B>20) && ((maxi(R,G,B))- (mini(R,G,B))>15) &&
(v_abs(R,G)>15) && (R>G) && (R>B))
siendo R=rojo, G=verde y B=azul.
La simplicidad de este método ha atraído y atrae el interés de muchas
investigaciones [PEER03], [AHJB99], [FLEC02], [JORD99]. La ventaja de este método
es la simplicidad de las reglas de detección de piel que permiten la clasificación rápida
de píxeles. La principal desventaja de este método es la robustez, debido a la necesidad
de encontrar espacios de color buenos y reglas de decisión empíricas adecuadas.
Recientemente, ha sido propuesto un método que usa algoritmos de aprendizaje
para encontrar espacios de color apropiados que lleven a cabo altas tasas de
reconocimiento. Algunos autores [GOME02] trabajan en el espacio rgb (RGB
normalizado) y aplican un algoritmo para crear nuevos conjuntos de 3 atributos a partir
de las componentes r, g, b y la constante 1/3 a través de operaciones algorítmicas
básicas.
57
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
-Detector de lo pintado
Basándome en el método anterior, ya que no cumplía del todo mis expectativas
plantee el problema desde otro punto de vista. En vez de eliminar información (la piel)
de la imagen que iba capturando, opte por tomar la información que era de interés (el
trazo de lo que se está pintando).
3.3.1. Determinar los objetivos
Esta fase tiene un solo objetivo, pero éste está bien definido. Consiste en analizar
la imagen que capta la webcam, y decidir qué información es relevante y cual no. Es
decir, analizar pixel por pixel la imagen y quedarnos con el trazo del dibujo que el
usuario realice.
3.3.2. Analizar los riesgos
Una vez más el mayor problema es la iluminación, ya que según la luminosidad
de la habitación, los colores son detectados bajo unos valores RGB u otros, pudiendo
darse que se queden fuera del rango de valores establecidos como los válidos para
considerarse el trazo del dibujo.
3.3.3. Desarrollar y probar
Lo primero a definir es el criterio por el cual se establece si el píxel analizado es
útil o no. Tras muchas pruebas se define la siguiente regla a seguir:
((r>220) && (40<g<100) && (35<b<100))
siendo,
r ,g y b los valores rojo verde y azul del píxel.
Una vez que se sabe si el píxel es parte de la información buscada, este en caso
de serlo, se escribe en una imagen inicial. De modo que según el usuario va pintando,
ese trazo se va incorporando a la imagen inicial que se estableció según las esquinas.
Así se consigue que se vaya mostrando todos los trazos, los que se están pintando y los
ya pintados anteriormente.
Todo es llevado a cabo por la función pixel del Anexo D: Código.
58
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
void pixel(IplImage *frame,IplImage *frameinicial){
int i;
int j;
int b,g,r;
//recorremos la imagen para obtener lo pintado en rojo
for ( i = 0; i < frame->width; i++ ){
for ( j = 0; j < frame->height; j++ ){
b = ((uchar *)(frame->imageData + frame->widthStep*j))[i*3];
g =((uchar *)(frame->imageData + frame->widthStep*j))[i*3+1];
r = ((uchar *)(frame->imageData + frame->widthStep*j))[i*3+2];
//si es el trazo de boli
if(r>220&&(40<g<100)&&(35<b<100)){
((uchar *)(frameinicial->imageData + frameinicial>widthStep*j))[i*3]=b;
((uchar *)(frameinicial->imageData + frameinicial>widthStep*j))[i*3+1]=g;
((uchar *)(frameinicial->imageData + frameinicial>widthStep*j))[i*3+2]=r;
}
}
}
}
Figura 35: Función pixel
Cuando el usuario ha terminado de pintar, la aplicación comienza el segundo
proceso de reconocimiento de patrones, buscando un 0. En caso de detectar alguno, lo
reemplaza por otro almacenado en una imagen en el sistema.
Para ello se sigue el siguiente procedimiento:

Se localizan los 0 y se guardan los puntos (x,y) donde han sido encontrados.

Se establece la dimensión de la imagen del sistema, para que sea similar a la
pintada.

Se recorre píxel por píxel el frame donde el usuario ha pintado en la región
donde se ha localizado el 0, para ir cambiando el píxel por el de la imagen del
sistema.

Una vez ha finalizado, la imagen ya ha sido sustituida por una guardada en el
sistema.
59
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
void ceros(IplImage *frame,int num){
IplImage *cero= cvLoadImage("cero.jpg",1);
int w,h,b,g,r,x,z;
for(i=0;i<num;i++){
w=puntosx2[i]-puntosx1[i];
h=puntosy2[i]-puntosy1[i];
IplImage *cero0=cvCreateImage(cvSize(w,h),cero->depth,cero>nChannels);
//ajusto el tamaño del cero a mostrar segun lo pintado
cvResize(cero,cero0,1);
x=0;
for(j=puntosx1[i];j<puntosx2[i];j++){
z=0;
for(k=puntosy1[i];k<puntosy2[i];k++){
b = ((uchar *)(cero0->imageData + cero0->widthStep*z))[x*3];
g = ((uchar *)(cero0->imageData + cero0>widthStep*z))[x*3+1];
r = ((uchar *)(cero0->imageData + cero0->widthStep*z))[x*3+2];
((uchar *)(frame->imageData + frame->widthStep*k))[j*3]=b;
((uchar *)(frame->imageData + frame->widthStep*k))[j*3+1]=g;
((uchar *)(frame->imageData + frame->widthStep*k))[j*3+2]=r;
z++;
}
x++;
}
}
}
Figura 36: Función ceros
60
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
3.3.4. Planificar
Para la fase siguiente se van a dedicar 3 semanas, ya que consiste en poner en
común todo lo anteriormente desarrollado y solucionar algún problema si es que surge.
Figura 37: Planificación Fase IV
61
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
3.4. Fase IV: Ejecución conjunta
3.4.1. Determinar los objetivos
Al ser la última fase del proyecto se pretende conseguir un correcto
funcionamiento de la aplicación. Para ello, habrán de ser capaz de obtener
simultáneamente todos los objetivos de las fases anteriores.
3.4.2. Desarrollar y probar
En esta última fase se ha conseguido unificar todo lo realizado en fases
anteriores, dando lugar a la aplicación final.
Por lo tanto, a modo de resumen la aplicación se ejecuta del siguiente modo:




Detecta las esquinas
Selecciona la región delimitada por las esquinas como región a mostrar
Muestra los trazos de los dibujos que el usuario realiza en tiempo real
Cuando el usuario finaliza, localiza el patrón 0.
En esta imagen se puede ver como una vez el usuario a terminado de pintar
(Figura 38), tras un breve período el sistema detecta que ha pintado un 0 y lo sustituye
por el almacenado en el sistema para ello (Figura 39).
Figura 38: Antes de detectar el patrón
62
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Figura 39: Después de detectar el patrón
63
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
4. Planificación
El total de horas trabajadas (440 horas) equivale a 55 días laborables con jornadas de 8 horas laborables.
Debido a que no puedo dedicar las 8 horas diarias a la realización del proyecto, al compaginar la realización del mismo con los estudios,
se ha decidido tomar como planificación a seguir la siguiente:
64
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
5. Estudio económico
5.1. Costes de Ingeniería
Los costes de ingeniería se refieren a las horas necesarias para la realización del
proyecto. Se estimarán según las fases establecidas:

Adquisición y visualización de video: 40 horas

Detección de esquinas: 150 horas

Sustracción de la mano: 150 horas

Ejecución conjunta: 40 horas

Documentación: 60 horas
Total de horas invertidas: 440 horas, repartidas del siguiente modo
Fase
Adquisición y visualización de video
Detección de esquinas
Sustracción de la mano
Ejecución conjunta
Documentación
Total Horas
Director de
proyecto
5
10
10
5
5
35
Teniendo en cuenta los siguientes salarios por rol

Director de proyecto: 60 €/hora

Analista: 30 €/hora

Programador: 20€/hora
Por ello, el coste de ingeniería asciende a 11.200 €
65
Analista
Programador
10
30
30
10
20
25
110
110
25
35
100
305
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
5.2. Costes del Software Utilizado
Se valorarán:
En este apartado se desarrollarán los costes de las aplicaciones que tengan
cargos económicos necesarios tanto para el desarrollo del software como para la
documentación.

SO Windows XP Professional: 60 €

Microsoft Office: 100 €

Acrobat Professional: 125 €

Microsoft Visual Studio 2008 Professional Edition: 1.000€
Coste total del software utilizado: 1.285 €
66
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
5.3. Costes del Hardware utilizado

Portátil HP: 1.200 €

Webcam: 100 €

PC de sobremesa para haartraing: 500 €
Total del hardware utilizado: 1.800 €
67
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
5.4. Presupuesto Final
La suma de los apartados anteriores genera el presupuesto final del proyecto:
Coste
Coste de Ingeniería
Coste de Software
Coste de Hardware
TOTAL
68
Importe
11.200 €
1.285 €
1.800 €
14.285 €
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
6. Conclusiones
Para el desarrollo del proyecto he tenido que profundizar y mejorar mis
conocimientos de la librería OpenCV, el lenguaje C++ y la técnica que permite
conseguir nuestro objetivo de detección, el haartraining. Por tanto, he profundizado
suficientemente en él como para conocer su gran potencial, pero también sus puntos
débiles o limitaciones.
El método requiere como entrada principal el conjunto muestral del que aprende
las características del objeto que se desea reconocer. Éste se ha de componer, de dos
subconjuntos; el positivo que contiene ejemplos del objeto y el negativo, con imágenes
que no lo contengan. Tras diversas pruebas, he comprobado que el número de imágenes,
ya sean positivas como negativas, ha de ser bastante elevado.
Las imágenes positivas han de ser de muy buena calidad y deben incorporar el
objeto en todas las posiciones y circunstancias posibles. A la hora de detectar la
posición del objeto en la imagen hay que ser muy cuidadoso e intentar ajustar al
máximo. Debido a la precisión y la dedicación puesta en el desarrollo de esta parte del
proyecto, ya que es indispensable para el correcto funcionamiento del proyecto, ésto me
supuso muchas horas de trabajo.
En cuanto a las herramientas utilizadas, he de decir, que OpenCV ha sido de
gran utilidad ya que incorpora un gran número de funciones para el tratamiento de las
imágenes y en este caso era necesario.
Este proyecto puede ser de gran utilidad para diversos campos del mundo de hoy
en día, sin necesidad de tener relación con el mundo de la tecnología. No es necesario
estar dotado de la última tecnología ni de los últimos conocimientos para poder pintar
en un folio y que el propio sistema sepa qué tiene que hacer y buscar. Sólo requerimos
de un ordenador y una webcam.
La mayor dificultad que he encontrado para la realización de este proyecto, es
lidiar con la iluminación del entorno, ya que a la vista del ojo humano, los colores y los
objetos parecen no variar, pero al captar la imagen por la cámara, éstos cambios son
bastante significativos, ya que por ejemplo, suponen una cambio en los valores RGB.
69
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Al haber tomado un criterio para la selección del trazo del dibujo pintado en la
fase de sustracción de la mano, si estos valores RGB varían, pueden quedarse fuera de
la región de interés y no mostrarse en la ventana final. Por ello, decidí trabajar con luz
natural siempre y cuando no incida directamente sobre el folio donde se está dibujando.
La realización de este proyecto me ha supuesto una gran satisfacción personal,
ya que he tenido que trabajar con herramientas con las cuales no estaba familiarizada y
tras muchas horas de trabajo, he conseguido un gran dominio de las mismas.
Del mismo modo, me parece interesante el haber realizado el proyecto en esta
línea de trabajo, ya que siento un gran interés por el diseño y la investigación; pudiendo
ser interesante la realización del proyecto para experiencias futuras del mundo laboral.
70
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
7. Trabajos futuros
La capacidad de proceso de los ordenadores aumenta cada año, pero esto no es
suficiente para algunas aplicaciones de integración 2D-3D. Como se ha reflejado en
varias partes del proyecto, lo difícil no es conseguir hacer la integración sino obtener un
buen resultado visual. Y eso depende mucho de los mecanismos actuales de render, las
tarjetas gráficas y el hardware disponible que todavía no ofrecen resultados fotorealistas en tiempo real.
Otro problema sigue siendo el seguimiento de puntos. Aunque cada vez
aparecen herramientas de tracking mejores y más precisas, todavía sigue siendo
necesaria la intervención de la mano humana y el uso de patrones o marcas para
conseguir un resultado óptimo. Todo esto condiciona el retraso en la implantación de
ciertas tecnologías de realidad aumentada para el público en general, aunque
actualmente se están consiguiendo buenos resultados en plataformas móviles.
Desde luego que otro de los campos que más se puede beneficiar de la realidad
aumentada y la visión artificial es el de las interfaces de usuario. Aquí hay un gran
camino por recorrer, sobre todo lo relacionado al desarrollo de sistemas educativos.
Para finalizar esta parte relativa a conclusiones, se proponen estas ideas:
 Realidad aumentada en aplicaciones de audio y música. Aprovechando el
conocimiento de la situación de la cámara y de ciertos objetos y personajes en una
escena, esta información puede utilizarse para desarrollar sistemas de estimación
espacial de fuentes de sonido. Esto permitiría facilitar el proceso de mezcla y
localización Surround en producciones de cine o televisión.
 Reconstrucción 3D de películas. Rodando una escena desde varios puntos de
vista, ésta puede reconstruirse tridimensionalmente. De esta forma podría ofrecerse al
consumidor final la posibilidad de elegir desde dónde quiere ver la historia.
 Telepresencia foto-realística. Esto ofrecería la posibilidad de visitar virtualmente
otros lugares, como exposiciones o museos.
71
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
 Enseñanza. Ampliando las imágenes almacenadas para reconocer y sustituir, en
el frame mostrado, podrá aplicarse a la hora de enseñar a alumnos la materia en clase,
ya que se aprende mejor visualmente
72
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
8. Bibliografía
[AHLB99] J. Ahlberg. A system for face localization and facial feature extraction.
Tech. Rep., 1999. Linkoping University.
[BRAD08] G. Bradski, Adrian Kaehler. Learning OpenCV: Computer Vision with the
OpenCV Library. O’Reilly Media, Inc., 2008.
[ESQU02] J.J. Esqueda. Fundamentos de procesamientos de imágenes. CONACTEC
2002. Instituto Tecnológico de Ciudad Madero. México.
[FLEC02] M. Fleck, D. A. Forsyth, C. Bregler. Finding nacked people. Proc. of the
ECCV. 2002.
[GOME02] G. Gómez, E. Morales. Automatic feature construction and a simple rule
induction algorithm for skin detection. In Proc. of the ICML Workshop on
Machine Learning in Computer Vision. 2002.
[ISER03] J. Isern González. “Estudio experimental de métodos de calibración y
autocalibración de cámaras” UPGC, Julio 2003.
[JORD99] L. Jordao, M. Perrone, J. Costeira, J. Santos-Victor, J. Active face and
feature tracking. In Proceeding of the 10th International Conference on
Image Analysis and Processing. 1999.
[PEER03] P. Peer, J. Kovac, F. Solina. Human skin colour clustering for face detection.
In submitted to EUROCON 2003 – International Conference on Computer
as a Tool. 2003
[PRAD02] R. Prádanos, J.M. Sanz, M. Domínguez, M. Espinosa. Perspectivas de futuro
en la variable color en ingeniería gráfica. En XIV Congreso Internacional de
Ingeniería Gráfica. Santander. 2002.
[SANC03] Ángel Sánchez, José L. Esteban, José F. Vélez, Ana Belén Moreno. Visión
por Computador. Dykinson, 2003
[STRO02] Bjarne Stroustrup. El lenguaje de programación C++. Addison Wesley,
2002.
[TSAI86]R. Y. Tsai. ‘An efficient and accurate camera calibration technique for
3dmachine vision’ en ‘Proceedings of IEEE Conference on Computer
Vision and Pattern Recognition’ IEEE, Florida, USA 1986.
73
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
[VEZH03] V. Vezhnevets, V. Sazonov, A. Andreeva. A Survey on Pixel-Based Skin
Color Detection Techniques. In Proc. Graphicon 2003.
[WIKI09] Wikipedia, La enciclopedia libre, http://es.wikipedia.org.
[ZARA99] Beck Zaratian. Microsoft Visual C++ 6.0 Manual de programador.
MCGraw-Hill, 1999.
[ZHAN00] Z. Zhang. “A flexible new technique for camera calibration” en “IEEE
Transactions on Pattern Analysis and Machine Intelligence”. 2000.
74
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Anexo A – Manual de usuario
La utilización de esta aplicación es muy sencilla.
Una vez tengamos instalado Visual Studio, ya podremos compilar y ejecutar
nuestro programa. Tenemos que asegurarnos de que tengamos la webcam conectada, ya
que si no daría error. En caso de estar conectada y seguir dando error, deberíamos
cambiar el valor de CvCapture, ya que puede que nuestra webcam no se asocie al 0 si no
al 1. Por lo tanto deberíamos cambiar y dejarlo como:
CvCapture *capture=cvCreateCameraCapture(1);
Una vez arranque la aplicación, simplemente deberemos colocar el folio frente a
la webcam, al cual anteriormente le habremos dibujado en las esquinas unas X para
delimitar la zona.
El propio programa se encargará de localizarlas y establecer el tamaño de la
ventana que se mostrará al de la región marcada por las X. Según se vaya pintando, irá
apareciendo el trazo del dibujo. Para ello es necesario que se dibuje con un rotulador de
color rojo, a poder ser un edding 1200.
Cuando hayamos finalizado nuestros dibujos, el programa detectará si alguno de
ellos es reconocido como patrón y en ese caso, lo modificará por una imagen
almacenada previamente.
75
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Anexo B - Instalación Microsoft Visual Studio 2008
Por lo visto hay un componente de InfoPath 2007 (concretamente el pack
multilenguaje) que si está instalado en el ordenador, da incompatibilidad con la
instalación de Visual Studio 2008. Por ello, para la correcta instalación del programa
hay que previamente, o bien desinstalar Office, o una mejor opción ejecutar los
siguientes pasos:
 Desactivar en Windows Vista el (UAC) Turn on User Account Control.
 Id a Inicio -> Ejecutar y colocad la siguiente linea de comando "msiexec /x
{30120000-0044-0C0A-0000-0000000FF1CE}"
componente de InfoPath.
para
desinstalar
el
Una vez finalizada la desinstalación podemos proceder a instalar Microsoft Visual
Studio 2008 sin problemas.
76
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Introducimos el número de serie del producto y aceptamos las condiciones de la
licencia del producto.
77
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Seleccionamos la opción a instalar más adecuada según el uso que se le vaya a
dar, al programa. En este caso, se ha seleccionada una instalación completa del
programa.
Tras este paso, comenzará la instalación del programa.
78
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Si todo ha finalizado correctamente, nos saldrá esta ventan. En caso contrario,
nos indicará el error ocurrido y un link a visitar para intentar solucionarlo.
79
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Anexo C- Instalación OpenCV
80
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Tras esto, OpenCV se instaló correctamente y ahora se procederá a configurar
Microsoft Visual Studio 2008.
81
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
1º Abrir el Visual Studio. En la barra de menus elegir Tools->Options
2º Elegir Projects->VC++ Directories.
-Primero, seleccionar Library files de la lista “Show Directories for”.



Inserta una librería nueva, para ello hay que pulsar el icono Insert New
buscar la carpeta en la que está instalado OpenCV.
Considerar que está instalado en “C:/Program Files/OpenCV”.
En la lista Library files list, se añadirá:
“C:\Program Files\OpenCV\lib”
82
,y
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA

Ahora elegir en la lista “Include files”, y añadir los siguientes directorios:
“C:\Program Files\OpenCV\cv\include”
“C:\Program Files\OpenCV\cxcore\include”
“C:\Program Files\OpenCV\otherlibs\highgui”
“C:\Program Files\OpenCV\cvaux\include”
“C:\Program Files\OpenCV\otherlibs\_graphics\include”

A continuación, seleccionar en la lista “Source files”, y añadir los siguientes
directorios:
“C:\Program Files\OpenCV\cv\src”
“C:\Program Files\OpenCV\cxcore\src”
“C:\Program Files\OpenCV\cvaux\src”
“C:\Program Files\OpenCV\otherlibs\highgui”
“C:\Program Files\OpenCV\otherlibs\cvcam\src\windows”
Una vez realizado ésto, pulsar OK y estará realizada la configuración global del
entorno.
83
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Para crear un nuevo Proyecto, el cual haga uso de OpenCV se deberán seguir los
siguientes pasos:
-
Seleccionar en el menu “File”->”New…”->”Projects”.
Elegir “Win32 Application” o “Win32 console application”, las acciones
siguientes son iguales para ambos tipos de proyecto.
Escribir el nombre de tu proyecto y la ruta en la que se guardará.
-
Pulsar OK en la ventana, y a continuación pulsar Finish.
84
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
-
Abrir el fichero Proyecto.cpp, e incluir la siguientes directives de OpenCV
#include:
#include <cv.h>
#include <cxcore.h>
#include <highgui.h>
-
-
-
85
Estos #include han de ser insertados tras stdafx.h o puede que se generen
errores.
Añadir dependencias del proyecto al entorno de trabajo, ya que si no darán
errores de linkado.
Elige del menu: “Project” -> “Properties”.
Elige “Linker” tab -> “Input” categoria -> “Additional Dependencies:”.
Añade las rutas para todas las librerias importadas (cxcore.lib cv.lib highgui.lib
cvaux.lib cvcam.lib)
Tras estos pasos ya está todo configurado de modo que garantice su correcto
funcionamiento.
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
Anexo D- Código
//PFC
#include "stdafx.h"
#include "cv.h"
#include "highgui.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <math.h>
#include <float.h>
#include <limits.h>
#include <time.h>
#include <ctype.h>
#include <iostream>
using namespace std;
static CvMemStorage* storage = 0;
static CvHaarClassifierCascade* cascade = 0;
int detect_and_draw( IplImage* image );
void puntos();
void ceros(IplImage *frame,int num_obj);
void pixel (IplImage *frame,IplImage *frameinicial);
int
int
int
int
puntosx1[5];
puntosx2[5];
puntosy1[5];
puntosy2[5];
CvPoint puntoIni;
int width,height,aux=0;
int i,j,k;
int igual=0;
const char* cascade_esquinas =
"esquinas.xml";
const char* cascade_ceros =
"ceros.xml";
int main( int argc, char** argv )
{
CvCapture* capture = 0;
IplImage *frame, *frame_copy = 0;
int obj;
//cargamos el fichero xml para reconocer las esquinas
cascade =(CvHaarClassifierCascade*)cvLoad(cascade_esquinas,0,0,0);
if( !cascade )
{
fprintf(stderr, "ERROR: Could not load classifier cascade\n");
return -1;
}
86
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
storage = cvCreateMemStorage(0);
CvCapture *capture1=cvCreateCameraCapture(0);
capture = cvCreateCameraCapture(0);
cvNamedWindow("Imagen inicial", 1 );
cvNamedWindow("Frame", 1 );
if( capture )
{
frame=cvQueryFrame(capture1);
frame=cvQueryFrame(capture1);
frame=cvQueryFrame(capture1);
if( !frame_copy )
frame_copy = cvCreateImage( cvSize(frame>width,frame->height),IPL_DEPTH_8U, frame->nChannels );
if( frame->origin == IPL_ORIGIN_TL )
cvCopy( frame, frame_copy, 0 );
else
cvFlip( frame, frame_copy, 0 );
//detectamos las esquinas
obj=detect_and_draw( frame_copy );
cvShowImage("Imagen inicial", frame_copy);
cvSaveImage("Imagen.jpg",frame_copy);
//detectamos los valores para la region a mostrar
puntos();
//establecemos la region a mostrar
IplImage* frameinicial =
cvCreateImage(cvSize(width,height),frame_copy->depth,frame_copy>nChannels);
IplImage* region =
cvCreateImage(cvSize(width,height),frame_copy->depth,frame_copy>nChannels);
//videos para mostrar
CvVideoWriter *writerIni =
cvCreateVideoWriter("VideoInicial.avi",-1,25,cvSize(width,height),1);
CvVideoWriter *writerFin =
cvCreateVideoWriter("VideoFinal.avi",-1,25,cvSize(width,height),1);
cvSetImageROI(frame,
cvRect(puntoIni.x,puntoIni.y,width,height));
cvCopy(frame,frameinicial);
cvResetImageROI(frame);
for(i=0;i<600;i++){
frame=cvQueryFrame(capture);
igual=0;
//establecemos la region a mostrar
cvSetImageROI(frame,
cvRect(puntoIni.x,puntoIni.y,width,height));
87
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
cvCopy(frame,region);
cvResetImageROI(frame);
cvWriteFrame(writerIni,region);
pixel(region,frameinicial);
cvShowImage("Frame",frameinicial);
cvWriteFrame(writerFin,frameinicial);
if(cvWaitKey(10)==27)
break;
}
cascade= (CvHaarClassifierCascade*)cvLoad
(cascade_ceros,0,0,0);
obj=detect_and_draw(frameinicial);
cvShowImage("Frame",frameinicial);
cvWriteFrame(writerFin,frameinicial);
ceros(frameinicial,obj);
cvShowImage("Frame",frameinicial);
cvWriteFrame(writerFin,frameinicial);
cvWriteFrame(writerFin,frameinicial);
cvWriteFrame(writerFin,frameinicial);
cvWriteFrame(writerFin,frameinicial);
cvWriteFrame(writerFin,frameinicial);
cvWriteFrame(writerFin,frameinicial);
cvWriteFrame(writerFin,frameinicial);
cvWaitKey(0);
cvReleaseImage(&frame_copy);
cvReleaseImage(&frame);
cvReleaseImage(&region);
cvReleaseImage(&frameinicial);
cvReleaseVideoWriter( &writerIni );
cvReleaseVideoWriter( &writerFin );
cvReleaseCapture( &capture );
}
cvDestroyWindow("Imagen inicial");
cvDestroyWindow("Frame");
return 0;
}
88
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
int detect_and_draw( IplImage* img )
{
int scale = 1;
IplImage* temp = cvCreateImage( cvSize(img->width/scale,img>height/scale), 8, 3 );
CvPoint pt1, pt2;
int i;
CvSeq* object;
cvClearMemStorage( storage );
if( cascade )
{
object = cvHaarDetectObjects( img, cascade, storage,1.1, 2,
CV_HAAR_DO_CANNY_PRUNING,cvSize(40, 40) );
if(object->total!=0){
if(object->total>4)
object->total=4;
for( i = 0; i
{
CvRect*
pt1.x =
pt2.x =
pt1.y =
pt2.y =
< object->total; i++ )
r = (CvRect*)cvGetSeqElem( object, i );
r->x*scale;
(r->x+r->width)*scale;
r->y*scale;
(r->y+r->height)*scale;
//pinto el rectángulo al detectar el objeto
cvRectangle( img, pt1, pt2, CV_RGB(255,0,0), 3,
8, 0 );
//Guardo los puntos
puntosx1[i]=pt1.x;
puntosx2[i]=pt2.x;
puntosy1[i]=pt1.y;
puntosy2[i]=pt2.y;
}
}
}
cvReleaseImage( &temp );
return (object->total);
}
89
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
void puntos(){
for(k=0;k<3;k++){
for(j=1;j<4;j++){
//ordeno segun la x
if(puntosx1[j]<puntosx1[j-1]){
aux=puntosx1[j];
puntosx1[j]=puntosx1[j-1];
puntosx1[j-1]=aux;
aux=puntosx2[j];
puntosx2[j]=puntosx2[j-1];
puntosx2[j-1]=aux;
aux=puntosy1[j];
puntosy1[j]=puntosy1[j-1];
puntosy1[j-1]=aux;
aux=puntosy2[j];
puntosy2[j]=puntosy2[j-1];
puntosy2[j-1]=aux;
}
}
}
if(puntosy1[0]<puntosy1[1]){
puntoIni.x=puntosx2[0];
puntoIni.y=puntosy2[0];
}else{
puntoIni.x=puntosx2[1];
puntoIni.y=puntosy2[1];
}
for(j=0;j<4;j++){
if((puntosy2[j]!=puntoIni.y)&& (puntosx2[j]!=puntoIni.x)){
//hallamos el ancho y alto del rectangulo a mostrar
if((puntosy2[j]>(puntoIni.y-50))&&
(puntosy2[j]<(puntoIni.y+50))){
width=puntosx1[j]-puntoIni.x;
}
if((puntosx2[j]>puntoIni.x-40)&&
(puntosx2[j]<puntoIni.x+40)){
height=puntosy1[j]-puntoIni.y;
}
}
}
//reajustamos los valores
puntoIni.x=puntoIni.x-20;
puntoIni.y=puntoIni.y-50;
width=width+50;
height=height+80;
if(width%4!=0){
width=((width/4)+1)*4;
}
if(height%4!=0){
height=((height/4)+1)*4;
}
}
90
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
void pixel(IplImage *frame,IplImage *frameinicial){
int i;
int j;
int b,g,r;
//recorremos la imagen para obtener lo pintado en rojo
for ( i = 0; i < frame->width; i++ ){
for ( j = 0; j < frame->height; j++ ){
b = ((uchar *)(frame->imageData + frame>widthStep*j))[i*3];
g =((uchar *)(frame->imageData + frame>widthStep*j))[i*3+1];
r = ((uchar *)(frame->imageData + frame>widthStep*j))[i*3+2];
if(r>220&&(40<g<100)&&(35<b<100)){
((uchar *)(frameinicial->imageData +
frameinicial->widthStep*j))[i*3]=b;
((uchar *)(frameinicial->imageData +
frameinicial->widthStep*j))[i*3+1]=g;
((uchar *)(frameinicial->imageData +
frameinicial->widthStep*j))[i*3+2]=r;
}
}
}
}
91
PIZARRA VIRTUAL BASADA EN REALIDAD AUMENTADA
void ceros(IplImage *frame,int num){
IplImage *cero= cvLoadImage("cero.jpg",1);
int w,h,b,g,r,x,z;
for(i=0;i<num;i++){
w=puntosx2[i]-puntosx1[i];
h=puntosy2[i]-puntosy1[i];
IplImage *cero0=cvCreateImage(cvSize(w,h),cero->depth,cero>nChannels);
//ajusto el tamaño del cero a mostrar segun lo pintado
cvResize(cero,cero0,1);
x=0;
for(j=puntosx1[i];j<puntosx2[i];j++){
z=0;
for(k=puntosy1[i];k<puntosy2[i];k++){
b = ((uchar *)(cero0->imageData + cero0>widthStep*z))[x*3];
g = ((uchar *)(cero0->imageData + cero0>widthStep*z))[x*3+1];
r = ((uchar *)(cero0->imageData + cero0>widthStep*z))[x*3+2];
//cambio el valor del pixel del frame mostrado
((uchar *)(frame->imageData + frame>widthStep*k))[j*3]=b;
((uchar *)(frame->imageData + frame>widthStep*k))[j*3+1]=g;
((uchar *)(frame->imageData + frame>widthStep*k))[j*3+2]=r;
z++;
}
x++;
}
}
}
92