Metodología para el Análisis de Requisitos de Sistemas Software
Sistema de Captura de Movimiento de Bajo Costo
1. UNIVERSIDAD DEL QUINDÍO - FACULTAD DE INGENIERÍA
INFORME FINAL
SISTEMADECAPTURADEMOVIMIENTODEBAJO
COSTO
ALEXANDER FLÓREZ QUINTERO
JHEISON ALEXANDER MEJÍA ZAMBRANO
Noviembre - 23 – 2011
Facultad de Ingeniería – Programa de Ingeniería Electrónica
Universidad del Quindío
2. 2
SISTEMA DE CAPTURA DE MOVIMIENTO DE BAJO COSTO
ALEXANDER FLÓREZ QUINTERO
JHEISON ALEXANDER MEJÍA ZAMBRANO
TRABAJO DE GRADO PARA OPTAR POR EL TITULO DE
INGENIERO ELECTRONICO
Director
MSC. ALEXANDER LÓPEZ PARRADO
Noviembre - 23 – 2011
Facultad de Ingeniería – Programa de Ingeniería Electrónica
Universidad del Quindío
3. 3
Este trabajo investigativo está dedicado a todos
los seres que nos aman y que nosotros amamos,
sólo Dios sabe lo trascendental y lo importante que
cada uno significa en nuestras vidas, por vivir lo
que vivimos, por que juntos soñamos y hacemos
de estos sueños una linda realidad
4. 4
AGRADECIMIENTOS
De manera muy especial quienes participamos en la realización de este trabajo expresamos un
profundo agradecimiento:
A Dios por el don de la vida, la inteligencia, sabiduría y todas las capacidades con las que
trabajamos día a día por una sociedad mejor.
A la Universidad del Quindío por brindarnos la oportunidad de avanzar en nuestro proyecto de
vida.
Al decano, director de programa, docentes y nuestros queridos asesores Jhon James Quintero
Osorio, Alexander López Parrado y Luis Miguel Capacho Valbuena, por sus valiosas
orientaciones y apoyo en la construcción de este proyecto investigativo.
A nuestros padres y familiares por su apoyo incondicional y darnos con su amor y ejemplo
herramientas que cimientan en nosotros valores que nos permiten crecer y ser mejores seres
humanos.
A nuestros amigos y amigas quienes con su cariño, tolerancia y apoyo nos brindaron entre risas y
llantos sus mejores consejos.
5. 5
TABLA DE CONTENIDO
LISTA DE TABLAS......................................................................................................................................7
TABLA DE FIGURAS..................................................................................................................................8
GLOSARIO..................................................................................................................................................11
RESUMEN...................................................................................................................................................12
ABSTRACT.................................................................................................................................................12
INTRODUCCIÓN .......................................................................................................................................13
1. PLANTEAMIENTO DEL PROBLEMA.............................................................................................14
1.1 Alcance y Delimitaciones.............................................................................................................14
2. JUSTIFICACIÓN Y OBJETIVOS ......................................................................................................15
2.1 Justificación..................................................................................................................................15
2.2 Objetivo General ..........................................................................................................................15
2.3 Objetivos Específicos...................................................................................................................15
3. MARCO TEÓRICO.............................................................................................................................16
3.1 SISTEMA DE CAPTURA DE MOVIMIENTO .........................................................................16
3.1.1 PYTHON..............................................................................................................................16
3.1.2 OPEN CV.............................................................................................................................16
3.2 SINCRONIZACION DE CAMARAS.........................................................................................17
3.3 CALIBRACIÓN DE CÁMARAS ...............................................................................................17
3.3.1 MODELO PINHOLE...........................................................................................................17
3.4 PROCESAMIENTO DE IMÁGENES (2D)................................................................................18
3.5 DETECCION DE MARCAS.......................................................................................................18
3.5.1 MODELO DE ALAMBRE..................................................................................................18
3.5.2 TÉCNICAS DE CORRESPONDENCIA ............................................................................18
3.6 CORRESPONDENCIA ESPACIAL ...........................................................................................19
3.7 RECOSTRUCCIÓN 3D...............................................................................................................19
3.8 CORRESPONDECIA TEMPORAL............................................................................................19
3.9 POST-PROCESAMIENTO .........................................................................................................19
3.10 SOFTWARE LIBRE....................................................................................................................19
7. 7
LISTA DE TABLAS
Tabla 1. Puntos 2D y Punto 3D de la Variación de 1 Marca en las dos cámaras utilizando
Reconstruction.py.
Tabla 2. Puntos 2D y Punto 3D de la Variación de 1 Marca en las dos cámaras utilizando
TriangulationP.py.
Tabla 3. Presupuesto del Sistema de Adquisición de Movimiento.
8. 8
TABLA DE FIGURAS
Figura 1. Modelo Pinhole.
Figura 2. Bloques Necesarios para el procesamiento de imágenes.
Figura 3. (a) Lenguaje de Programación Python.
(b) Librería de Procesamiento de imágenes OpenCV.
(c) Plataforma de desarrollo Eclipse.
(d) Software de visualización Blender.
Figura 4. Cámaras Web Genius FACECAM 310.
Figura 5. (a) Diseño de la base en 3D.
(b) Diseño de la base Real.
Figura 6. Grados de libertad en la base.
Figura 7. Etapas del Sistema.
Figura 8. Chessboard
Figura 9. Calibración de las cámaras.
Figura 10. Detección de esquinas del chessboard.
Figura 11. Detección de puntos en el chessboard en calibración estéreo.
Figura 12. (a) Traje con marcas luz normal.
(b) Traje con marcas luz negra.
Figura 13. Luz Negra.
Figura 14. Sistema de Captura con iluminación y sensores refractivos.
Figura 15. Sistema de Captura sin iluminación con sensores infrarrojos.
Figura 16. (a) Sistema de Captura con iluminación real.
(b) Sistema de Captura con iluminación controlada.
9. 9
Figura 17. (a) Marcas Detectadas con la cámara izquierda
(b) Marcas Detectadas con la cámara derecha
Figura 18. Umbralización de las Imágenes.
Figura 19. Binarización de las Imágenes.
Figura 20. Dilatación de las marcas.
Figura 21. Obtención de Contornos.
Figura 22. Correspondencia, seguimiento y tracking del par stereo.
Figura 23. (a) Sistema de Captura Completo Cámara Izquierda.
(b) Sistema de Captura Completo Cámara Derecha.
Figura 24. Interfaz de Blender, generando modelo de puntos en 3D.
Figura 25. (a) Visualización de los puntos 3D
(b) Modelo de Alambre de los puntos 3D
Figura 26. (a) Calibración de Cámara Izquierda Arriba
(b) Calibración de Cámara Derecha Abajo
Figura 27. Prueba 1 marca Visión Stereo (a) centro (b) Eje X Izquierdo (c) Eje X Derecho
(d) Eje Y Arriba (e) Eje Y Abajo (f) Eje Z Cerca (g) Eje Z Lejos.
Figura 28. Visualización en 3D de los puntos reconstruidos.
Figura 29. (a) Sistema de Captura 8 Puntos Cámara Izquierda.
(b) Sistema de Captura 8 Puntos Cámara Derecha.
Figura 30. Visualización 3D de 8 Puntos.
Figura 31. (a) Sistema de Captura 10 Puntos Cámara Izquierda.
(b) Sistema de Captura 10 Puntos Cámara Derecha.
Figura 32. Visualización 3D de 10 Puntos.
Figura 33. (a) Sistema de Captura 14 Puntos Cámara Izquierda
10. 10
(b) Sistema de Captura 14 Puntos Cámara Derecha
Figura 34. Visualización 3D de 14 Puntos
11. 11
GLOSARIO
Background: Fondo u objetos de segundo plano de una imagen, escena o representación. [3]
Captura de movimiento: Es una técnica de fotogrametría que realiza la medición de
coordenadas 3D mediante fotografías u otros sistemas de percepción remota para almacenar
digitalmente movimientos del cuerpo humano. Es usado principalmente en la industria del
entretenimiento, deporte o con fines médicos. [1]
Estereoscopia: Llamada también visión en tres dimensiones, o visión en relieve, resulta de la
capacidad del sistema visual de dar aspecto tridimensional a los objetos a partir de las imágenes
en dos dimensiones obtenidas en cada una de las retinas de los ojos. Estas imágenes son
procesadas y comparadas por el cerebro, el cual acaba creando una sensación espacial. [2]
Foreground: Es la parte más importante en una imagen, escena o representación, proporcionada
por objetos en movimiento del primer plano. [3]
Frame: Es una imagen determinada en un conjunto de imágenes sucesivas que forman una
animación, la sucesión de estas imágenes produce la sensación de movimiento.
Pixel: Es la menor unidad homogénea en color que forma parte de una imagen digital.
Visión por computador: También conocida como Visión artificial o Visión técnica, es un sub-
campo de la inteligencia artificial. El propósito de la visión artificial es programar un computador
para que "entienda" una escena o las características de una imagen. Los objetivos típicos de la
visión artificial incluyen la detección, segmentación, localización y reconocimiento de ciertos
objetos en imágenes, por ejemplo, caras humanas. [4]
Es empleada para obtener una idea de profundidad que puede ser medida a través de
triangulación obteniendo una idea de tridimensionalidad. [5]
12. 12
RESUMEN
El mundo 3D es un medio virtual que ayuda a innovar, entretener y comprender muchos campos del
mundo real. Para poder obtenerlo se diseñó e implementó un sistema de captura de movimiento a bajo
costo; se determinó el software y hardware que cumpliera el objetivo principal del proyecto, reducir los
costos, estableciendo el tipo de sensores, la iluminación y los algoritmos necesarios para reconstruir y
visualizar en 3D dos imágenes previamente segmentadas, correspondidas entre si y capturadas por un par
estéreo de cámaras web. Todo esto con el fin de crear en la Universidad del Quindío más investigación
acerca del tema, prácticas de laboratorios, trabajos de grado, entre otros.
ABSTRACT
The 3D world is a virtual environment that helps to innovate, entertain and understand many areas of the
real world. To get this virtual world done, a low-cost motion capture system was designed and
implemented; it was determined the software and hardware that could satisfy the primary objective of the
project, reduce costs, choosing the type of sensors, lighting conditions and necessary algorithms to re-
build and visualize on 3D two images previously segmented, matched and captured from a stereo-pair of
webcams. All of this work, aimed to create in the University of Quindío more research, laboratory
practices, thesis, among others, related to this topic.
13. 13
INTRODUCCIÓN
La tecnología sigue modificando el estilo de vida del mundo, y tiene como objetivo facilitar algunos
procesos cotidianos y/o reducir errores en otros. En el campo de animaciones para juegos y películas, en el
análisis de movimientos para diagnósticos médicos, ciencia deportiva y otros, la tecnología ha diseñado
sistemas de captura de movimiento y junto a la visión artificial, estiman movimientos humanos en 3D,
facilitando muchos procesos en este campo.
Los sistemas de captura de movimiento actuales tienen un costo elevado en el mercado ya que utilizan
sistemas de adquisición de imágenes de altas especificaciones, además de utilizar sensores con un
considerable precio para una mejor captura del movimiento y software con licencias no accesibles a un
usuario promedio.
Son pocas las exploraciones realizadas en el campo de la visión artificial y el mundo 3D en la academia de
la Universidad del Quindío, por lo cual, se diseñó un Sistema de Captura de Movimiento a Bajo Costo,
con el fin de abrir paso a nuevas investigaciones y motivaciones por el tema.
El objetivo principal en el desarrollo del proyecto es reducir los costos, de manera tal que se pudieran
tener estos sistemas al alcance, con un costo moderado, aportando una idea hacia la comunidad
universitaria para realizar más investigación acerca del tema, prácticas de laboratorios, trabajos de grado,
entre otros, para así obtener beneficios científicos, sociales, culturales, deportivos, etc.
Por lo cual en este proyecto se presentan inicialmente las herramientas de soporte software utilizadas para
la creación y pruebas de 4 subsistemas, y posteriormente el diseño de la base para las dos cámaras web. El
primer subsistema contiene la etapa de calibración de las cámaras mediante un chessboard, para el
segundo se adhiere una forma de iluminación mediante luz negra que simplifica la segmentación sobre las
imágenes detectando las marcas 2D del cuerpo humano, para utilizarlas posteriormente en el tercer
subsistema que realiza la reconstrucción 3D, llegando a la visualización como último bloque.
14. 14
1. PLANTEAMIENTO DEL PROBLEMA
El análisis del movimiento para diversas aplicaciones de carácter científico, deportivo, social,
cultural, entre otros, ha creado una necesidad de un subsecuente análisis de la tercera dimensión, para
lo cual se han diseñado sistemas de captura de movimiento, pero algunos de ellos poseen un costo
muy elevado para un usuario normal, por lo cual personas que desearían investigar y crear nuevas
ideas acerca de este tema se ven limitadas por cuestiones económicas. Además es importante tener en
cuenta la existencia de pocos proyectos en la Universidad del Quindío relacionados con dicho tema.
1.1 Alcance y Delimitaciones
El proyecto es exploratorio para la generación de modelos 3D usando visión por computador, y hace
parte de otro proyecto mayor, por lo tanto este sistema de captura de movimiento de bajo costo se
diseñará e implementará teniendo presentes las condiciones necesarias para ser utilizado en el área
deportiva, así que brindara al usuario una interfaz para obtener datos de cámaras y su visualización
será en tercera dimensión con el fin de poder realizar una comparación de las técnicas de deportistas
para mejorar su rendimiento. Por lo tanto este proyecto construirá un sistema de adquisición con
cámaras y un software que brinde al usuario una interfaz amigable y trasparente, para que en trabajos
posteriores se utilicen el pre-procesamiento, segmentación, representación y descripción más
detallada para así llegar a un reconocimiento e interpretación de resultados en diferentes ámbitos.
15. 15
2. JUSTIFICACIÓN Y OBJETIVOS
2.1Justificación
Además de tener un gusto muy grande por el procesamiento de imágenes, la visión artificial y el
mundo 3D, se desea crear en la academia de la Universidad del Quindío una visión más cercana de un
sistema de captura de movimiento abriendo paso a nuevas investigaciones y motivaciones por el tema,
ya que son pocas las exploraciones en la Universidad del Quindío acerca de este tema. Por otra parte
los sistemas de captura de movimiento actuales tienen un alto costo en el mercado ya que utilizan
sistemas de adquisición de imágenes de muy altas especificaciones, además de utilizar sensores con
un alto precio para una mejor captura del movimiento y software con licencias no accesibles a un
usuario medio. El proyecto tiene como objetivo reducir los gastos, tal que se puedan tener estos
sistemas al alcance, con un costo moderado, creando más investigación acerca del tema, prácticas de
laboratorios, trabajos de grado, entre otros, para así obtener beneficios científicos, sociales, culturales,
deportivos, etc. La estimación de movimientos humanos en 3D es una solución a muchas
aplicaciones, incluyendo la animación de un personaje para juegos y películas, o para análisis de
movimiento para diagnósticos médicos y ciencia deportiva. Una aplicación de dicho sistema seria el
análisis mediante comparación de movimientos de deportistas con el fin de mejorar su capacidad en
algún deporte y optimizar sus técnicas.
2.2Objetivo General
Diseñar e implementar un sistema de captura de movimiento de bajo costo
2.3Objetivos Específicos
Determinar los tipos de sensores para realizar la detección de las marcas.
Implementar algoritmos de mejoramiento y segmentación de las imágenes.
Utilizar algoritmos de correspondencia espacial para las marcas.
Construir y visualizar un modelo de alambre en una herramienta libre.
16. 16
3. MARCO TEÓRICO
En este capítulo se dan las bases, conceptos y terminologías necesarias para comprender las técnicas
utilizadas en el diseño e implementación del sistema presentado en este trabajo.
3.1 SISTEMA DE CAPTURA DE MOVIMIENTO
Es aquel que posee características suficientes y los módulos necesarios para capturar el movimiento
de un objeto o persona, los módulos necesarios en este sistema de captura de movimiento son:
iluminación, un cierto número de cámaras sincronizadas, un sistema de adquisición, un traje
adecuado con marcas y un ordenador para el control y visualización. Las aplicaciones de dichos
sistemas abarcan desde las industrias de animación, televisión y videojuegos, hasta el análisis de
movimiento para diagnósticos médicos y ciencia deportiva, entre otros. [6] [7]
3.1.1 PYTHON
Lenguaje de programación dinámica interpretado, no es necesario compilar ni enlazar, tiene
una amplia variedad de dominios de aplicación, es comparado con diferentes lenguajes
como Perl, Ruby o Java, entre otros. Entre sus características más importantes esta:
Sintaxis legible y clara
Grandes capacidades de Introspección
Orientación a objetos
Modularidad completa
Un alto nivel en los tipos de datos dinámicos
Extensas librerías y módulos para prácticamente todas las tareas
Python funciona lo suficientemente rápido para la mayoría de las aplicaciones. Ofrece una
amplia gama de opciones para el desarrollo web como escrituras de scripts CGI, soluciones
de gama alta como Zope, un amplio soporte para HTML y XML, E-mail de procesamiento.
Interfaces personalizadas para MySQL, Oracle, MS SQL, Server, PostgreSQL, SybODBC, y
otros están disponibles para su descarga.
Python puede integrarse con objetos COM, .NET y CORBA, también es compatible con el
motor de comunicaciones de internet (ICE) y muchas otras tecnologías de integración y
finalmente Python funciona sobre los principales sistemas operativos como Windows,
Linux, OS/2, MAC y algunas otras aplicaciones [19] [20]
3.1.2 OPEN CV
Son un conjunto de librerías de C y C++ de código libre o “Open Source”, orientada a la
visión por computador, puede ser usado en Windows, Linux y MacOS. Existen interfaces
para Python, Octave y Matlab bajo desarrollo.
17. 17
Debido a su licencia Open Source, permite desarrollo con las librerías, incluso la
modificación y distribución de las mismas, también la exploración investigativa y
comercial. Sus librerías más importantes son la CXCORE, CV, HighGUI, ML y CvAux.
Contiene un gran número de funcionalidades para procesamiento de imágenes, tales como,
filtrados, derivación, bordes, imágenes integrales, pirámides gausianas, morfología
matemática, método de Lucas-Kanade (Tracking), histogramas. [18] [21] [22] [23]
3.2 SINCRONIZACION DE CAMARAS
Es una parte esencial en un sistema de captura de movimiento, ya que al utilizar una visión con n
cámaras se hace necesario sincronizar, calibrar y sintonizar al máximo cada cámara para minimizar
errores entre frames de captura, obtener mejor información de la captura y facilitar el procesamiento
del movimiento. [6] [8]
3.3 CALIBRACIÓN DE CÁMARAS
La calibración de las cámaras es el proceso mediante el cual se obtienen los parámetros que definen
las condiciones de formación de la imagen, incluyendo geometría interna y óptica de la cámara,
además de obtener la orientación y posición de la misma, respecto a un objeto de referencia,
conociendo la forma en la que la cámara proyecta los objetos 3D en una imagen 2D, para así poder
extraer información métrica a partir de las imágenes. [9][18]
3.3.1 MODELO PINHOLE
El modelo Pinhole que es un modelo coplanar, siendo este un modelo proyectivo y finito
que representa la forma como se proyectan los objetos tridimensionales en las imágenes,
dicho modelo maneja diferentes coordenadas como lo son las coordenadas del mundo
(Xm,Ym,Zm), las coordenadas de la cámara (Xc,Yc,Zc), las coordenadas del sensor (Xs,Ys) y
las coordenadas de la imagen (Xi,Yi). [16]
Todos los rayos de luz se proyectan sobre un plano sensor, tras atravesar un único punto en
el espacio, este punto es llamado punto focal de la cámara. Pero hay un problema con este
modelo y es que es imposible ampliar o reducir la imagen (zoom) y la intensidad de la luz
que alcanza el sensor, está muy limitada por el tamaño del orificio de la cámara. En el caso
de utilizar dos cámaras en este modelo, el eje óptico no es necesariamente perpendicular al
plano de la imagen (Figura 1) por lo cual se obtienen las relaciones matemáticas entre las
coordenadas de un punto en la escena y la imagen.
Figura 1. Modelo Pinhole
18. 18
3.4 PROCESAMIENTO DE IMÁGENES (2D)
Es el procedimiento de manipulación y análisis de la información contenida en una imagen digital
por medio de un computador, lo cual sirve para mejorar la calidad de la imagen, corregir defectos,
analizar el contenido, entre otros.
En la Figura 2 se puede observar los bloques necesarios para dicho proceso, se empieza con la
formación o adquisición de una imagen, posterior almacenamiento por medio de algún dispositivo
de captura obteniendo la imagen digital, la cual se puede modificar de diferentes formas como,
restauración o reconstrucción, correcciones de degradación, también es posible hacer una
reconstrucción de la imagen para obtener mejores resultados como se hace en tomografías o
proyecciones múltiples.
Figura 2. Bloques necesarios para el procesamiento de imágenes
El siguiente paso es llamado “pre-procesamiento”, en el cual se mejoran detalles de la imagen,
mediante el aumento del contraste o luminosidad, realce de bordes o contornos y reducción de
ruido. Cuando se tiene un procesamiento deseado, se procede a hacer una segmentación de la
imagen en la cual se van a extraer algunas estructuras de la imagen como lo son detección de
movimiento, detección de regiones y extracción de contornos entre otros.
Finalmente se procede a hacer un análisis de las formas de la imagen y así poder extraer
información importante como es el área, el perímetro en general como descripción de las texturas y
así determinar diferentes clases de objetos con reconocimiento de patrones o redes neuronales. [10]
3.5 DETECCION DE MARCAS
Para un sistema de captura de movimiento se hace necesario tener una detección de marcas, ya sea
en un traje con sensores para un sujeto, por ejemplo articulaciones, o marcas en el área de la
imagen, resaltando los pixeles importantes en la imagen, con el fin de facilitar el reconocimiento del
sujeto u objeto. [6]
3.5.1 MODELO DE ALAMBRE
Es la forma cómo se pueden representar objetos físicos o representación electrónica de las
tres dimensiones (3D). Dicho modelo es creado, especificando los bordes del objeto donde
hay satisfacción matemática de superficies lisas continuas o donde hay una conexión de
objetos, usando líneas rectas o curvas. Dicho objeto se visualiza en un computador donde se
dibujan las líneas de localización de cada borde, gracias a la visualización de este modelo es
posible determinar cuál es el objeto que se está visualizando. [11]
3.5.2 TÉCNICAS DE CORRESPONDENCIA
Las técnicas de correspondencia son necesarias en el análisis y creación de un sistema de
captura de movimiento, ya que para obtener una idea de tridimensionalidad se debe tener en
19. 19
cuenta ciertas restricciones sobre el modelo geométrico de las cámaras, la fotometría de los
objetos, ya que ayudan a corresponder un mismo punto de distintas escenas o imágenes.
Algunas de las técnicas de correspondencia son basadas en área o en características, hay
técnicas jerárquicas, programación dinámica, y basadas en más de una vista. [6] [12]
3.6 CORRESPONDENCIA ESPACIAL
La reconstrucción espacial se hace comparando las imágenes adquiridas de los distintos sistemas de
adquisición y buscando una coincidencia de la posición entre las mismas, interpretando las
distancias en las cuales están ubicados los objetos. [7] [11] [6]
3.7 RECOSTRUCCIÓN 3D
Es el proceso mediante el cual, objetos reales capturados en imágenes 2D, son reconstruidos
mediante algoritmos software, manteniendo sus características físicas como dimensiones, volumen
y forma. [13]
3.8 CORRESPONDECIA TEMPORAL
También llamada seguimiento consiste en buscar la coincidencia de puntos 3D en dos fotogramas
consecutivos, creando una pista o rastro de cada marcador del sujeto en función del tiempo. [6]
3.9 POST-PROCESAMIENTO
Se usa para filtrar ruidos, corregir pequeños problemas y realizar mejoras de presentación utilizando
métodos como reconstrucción volumétrica (crear movimiento 3-D por la emisión, dispersándose, o
transmitiendo la iluminación de regiones bien definidas en el espacio (x, y, z)), cinemática inversa,
y dinámica inversa. [28]
3.10 SOFTWARE LIBRE
Es la libertad que tienen las personas como usuarias para disponer de un software como producto
adquirido y tener la capacidad de usarlo, modificarlo, copiarlo, estudiarlo cambiarlo entre otros.
[15]
3.10.1 ECLIPSE
La plataforma Eclipse consiste en un Entorno de Desarrollo Integrado (IDE, Integrated
Development Environment) abierto y extensible. Es una herramienta para todo, y para nada
en particular, está diseñada para la construcción de entornos de desarrollo que puedan ser
utilizados para la construcción de aplicaciones web, aplicaciones java de todo tipo,
programas C++ y Enterprise JavaBeans (EJBs). Permite descubrir, e invocar funcionalidad
implementada en componentes llamados plugins. Está diseñada para afrontar las siguientes
necesidades:
Soportar la construcción de gran variedad de herramientas de desarrollo
Soportar herramientas que permitan manipular diferentes contenidos (HTML, Java,
C, JSP, entre otros)
Proporciona entornos de desarrollos gráficos (GUI).
20. 20
Es compatible con diferentes sistemas operativos incluyendo Windows y Linux.
El principal objetivo de la plataforma eclipse es proporcionar mecanismos, reglas que
puedan ser, seguidas por los fabricantes para integrar de manera transparente sus
herramientas. Estos mecanismos se exponen mediante interfaces APIs, clases y métodos.
Cuenta con un editor de código, un compilador/ interprete y un depurador.
Eclipse se distribuye bajo licencia EPL (Eclipse Public License). Esta licencia es
considerada como libre por la FSF y por la OSI. Esta licencia permite usar, modificar,
copiar y distribuir nuevas versiones del producto licenciado. El antecesor de EPL es CPL
(Common Public Licencse). CPL fue escrita por IBM, mientras que EPL es obra del
consorcio Eclipse. El código fuente que compone Eclipse está distribuido en numerosos
proyectos y repositorios de software. [24] [25] [26]
3.10.2 BLENDER
Blender es un programa de modelado, que permite la creación de un amplio rango de
contenidos 3D, apoyado por varias herramientas. Puede ser usado para crear
visualizaciones 3D, tanto imágenes estáticas como vídeos de alta calidad. También
incorpora un motor de 3D en tiempo real el cual permite la creación de contenido
tridimensional interactivo que puede ser reproducido de forma independiente.
Originalmente desarrollado por la compañía 'Not a Number' (NaN), Blender es ahora
desarrollado como 'Software Libre', con el código fuente disponible bajo la licencia GNU
GPL, su descarga y su uso es completamente gratuito Sus características principales son:
Paquete de creación totalmente integrado, ofreciendo un amplio rango de
herramientas esenciales para la creación de contenido 3D, incluyendo modelado,
mapeado uv, texturizado, rigging, weighting, animación, simulación de partículas y
otros, scripting, renderizado, composición, post-producción y creación de juegos.
Multiplataforma, con una interfaz unificada para todas las plataformas basada en
OpenGL, listo para ser usado en todas las versiones de Windows (98, NT, 2000,
XP, Vista 32 y 64, Seven 32 y 64), Linux, OSX, FreeBSD, Irix, Sun, entre otros
sistemas operativos.
Arquitectura 3D de alta calidad potente y versátil permitiendo un rápido desarrollo.
Una comunidad mundial de más de 250.000 usuarios.
Tamaño pequeño del ejecutable para una fácil distribución.
Capacidad de Importar y exportar de múltiples formatos 3D.
Un amplio manual multilenguaje en línea.
Un archivo ejecutable pequeño que permite una fácil distribución.
No son necesarios números de serie y activaciones.
Múltiples plugins también gratuitos que expanden las posibilidades del programa.
Existe la posibilidad de modificar el código fuente si se tienen las bases necesarias
para hacerlo. [27] [28] [29]
21. 21
4. DISEÑO DEL SISTEMA
En la construcción del Sistema de Captura de Movimiento a Bajo Costo, inicialmente se determina las
herramientas de soporte software y hardware necesarias para un correcto funcionamiento del mismo, para
las primeras, se utiliza Software Libre, el lenguaje de programación elegido es Python (Figura 3-a), ya que
es de código abierto, puede ser utilizado con diferentes interfaces GUI (Tk, GTK, Qt, WxWidgets), es un
lenguaje de programación interpretado, además de ser un lenguaje innovador en la Universidad del
Quindío; para la calibración de cámaras, el procesamiento de imágenes y la visión artificial, se adopta la
librería libre OpenCV (Figura 3-b), la cual además de ser multiplataforma, es una librería amigable y veloz
para todos los procesos de visión por computador, facilitando las implementaciones de los subsistemas.
Para trabajar sobre una interfaz de usuario se elige la Plataforma de Desarrollo Eclipse (Figura 3-c), la
cual es de código abierto, tiene entornos de desarrollo integrados como editores de texto, interprete,
interfaces GUI y soporta lenguajes como C/C++, Ada, Perl y Python. Para la visualización del modelo 3D
se utiliza la herramienta Blender (Figura 3-d), dicho Software permite hacer una conexión directa con
Eclipse y los programas diseñados, logrando así poder visualizar cualquier cambio que ocurra.
Figura 3. (a) Lenguaje de Programación Python, (b) Librería de Procesamiento de imágenes OpenCV,
(c) Plataforma de desarrollo Eclipse (d) Software de visualización Blender
Para las herramientas de Soporte Hardware, se trabaja con Cámaras Web de fácil adquisición (Figura 4),
estas son cámaras Genius FACECAM 310, las cuales tienen un costo muy reducido en el mercado, tienen
un tamaño de captura de 640x480 pixeles por cada imagen de 8 MPixeles gracias a sensores VGA, captura
solo 30 frames por segundo, por lo cual algunos movimientos de mucha velocidad no son detectados
correctamente.
Figura 4. Cámaras Web Genius FACECAM 310
22. 22
El diseño de la base para las cámaras observado en la Figura 5-a cuenta con varios grados de libertad para
tener acceso a diferentes posiciones y vistas de las cámaras, en la Figura 5-b se observa la base real
construida en madera en forma de trípode, permite tres grados de libertad (Figura 6) en la localización de
las cámaras, lo que facilita el cambio de vistas en el mismo campo sin necesidad de mover dicha base,
además de tener la posibilidad de extender o disminuir su altura debido a las bases graduables. Además las
cámaras tienen un espacio especial en la base, en el cual se puede variar la separación entre ellas, por lo
tanto se puede realizar diferentes pruebas variando tanto los grados de libertad, la altura de la base, la
separación entre dichas cámaras y la rotación que permiten las mismas.
Figura 5. (a) Diseño de la base en 3D, (b) Diseño de la base Real
Figura 6. Grados de libertad en la base
23. 23
Teniendo identificadas cada una de las herramientas con las que se desea trabajar, se inicia el proceso de
construcción del sistema de captura de movimiento mediante las etapas observadas en la Figura 7.
Figura 7. Etapas del Sistema
Calibración de la Cámara y su par Stereo
Para el proceso de calibración de las cámaras, se deben determinar las características internas, geométricas
y ópticas de la cámara (parámetros intrínsecos) [16] y la posición 3D del marco de la cámara respecto a un
cierto sistema de coordenadas (parámetros extrínsecos) [16] y como el rendimiento del sistema, en la
mayoría de los casos depende de la calibración de las cámaras, entonces se le da un enfoque especial, sin
despreciar cada uno de los demás procedimientos. Para la calibración de las cámaras hay diferentes
métodos, pero generalmente hay un enfoque mayor en los métodos coplanares o no coplanares.
El modelo usado en este proyecto para la calibración, fue el modelo Pinhole, método coplanar que brinda
un procedimiento especial para poder obtener los parámetros requeridos, inicialmente se usa un objeto
llamado rejilla de calibración o chessboard, en el momento de tener dicho objeto listo para usarse se
diseña el Script cam_calibracion.py realizado en código en python utilizando funciones de la librería de
procesamiento de Imágenes Open CV, el cual necesita conocer el número de imágenes M que se desea
capturar (numPictures=8), se recomienda capturar más de 12 imágenes para minimizar errores variando la
distancia entre las cámaras y el objeto de calibración, además de rotar y trasladar el mismo (Figura 9). En
la Figura 8 se observa un Chessboard de 8x8 cuadros (se recomienda numero de filas y columnas iguales)
en donde se tienen 7x7 esquinas (corners1=7) de intersección entre los tonos negros y blancos, teniendo
en total K=49 puntos en el objeto de calibración. Además se ingresan 2 nombres utilizados para guardar
datos e imágenes.
Figura 8. Chessboard
24. 24
Figura 9. Calibración de las cámaras
Con dichos valores se calcula el parámetro N (tam) el cual es calculado con la multiplicación de las
esquinas verticales, horizontales del chessboard y el número de imágenes a capturar. Para la calibración
de las cámaras se utiliza la función cv.CalibrateCamera2 [18] que utiliza el Método de Zhang [17] para
encontrar las longitudes focales y el centro de la imagen, parámetros que conforman la Matriz Intrínseca
M derivada del método de Heikkila y Silven [18], dicha función también calcula los offsets del vector de
traslación y los ángulos del vector de rotación, además de utilizar el Método de Brown para encontrar los
parámetros de distorsión radiales o tangenciales, producidos por el lente “esférico”, el algoritmo para
cámaras Web utiliza los primeros 2 a 3 términos de la expansión en serie de Taylor alrededor de r=0.
cv.CalibrateCamera2 (objetsPoints, ImagePoints, pointCounts, imageSize, CameraMatrix,
DistCoeffs, RVecs, TVecs)
El primer parámetro objetsPoints contiene las coordenadas físicas de los K puntos encontrados en las M
imágenes, dicho parámetro es de tamaño Nx3 para tener las tres coordenadas XYZ, para facilitar el
procesamiento el valor de Z=0 y la distancia entre los puntos del chessboard es igual a 1 cuadro, por lo
tanto todos los resultados se tendrán en cuadros, cada cuadro equivale a 0.23cm, parámetro utilizado al
final del procesamiento; para el cálculo de la matriz objetsPoints se crea una función createObjetPoints:
createObjetPoints (numberPoints, numberPictures, objetsPoints)
La cual recibe los 7 puntos (esquinas) y las M imágenes a capturar y retorna en objetsPoints las
coordenadas físicas de forma que se tenga (0,0) como la primer esquina capturada, (0,1) como la siguiente
en la misma fila hasta llegar a la posición (0, corners1) de dicha fila; el proceso se realiza por las 7
columnas hasta llegar a la posición (corners1, corners1). La función createObjetPoints requiere que la
variable objetsPoints sea de tipo cv.Mat por lo cual se crea dicho tipo de datos utilizados en OpenCV y se
inicializan como se observa:
25. 25
Mat = cv.CreateMat (rows, cols, type)
cv.Set (Mat, value)
La función cv.CreateMat recibe el número de filas y columnas, además del tipo utilizado en los elementos
de dicha matriz (ej. cv.CV_32FC1 para tener números flotantes de 32 bits de un solo canal), mientras la
función cv.Set pone un valor en la matriz que se desee. Por último se utiliza la función cv.save para
guardar los datos que se deseen en un archivo que recibe el nombre y la extensión .xml
cv.Save("name.xml", Mat)
El segundo parámetro ImagePoints de la función cv.CalibrateCamera2 es una matriz de Nx2 que contiene
las coordenadas en pixeles de los K puntos en las M imágenes, para obtener dicho parámetro se crea la
función stereo_img:
stereo_img (numberPictures, namePictureLeft, namePictureRigth, numberPoints,
numberCameraLeft, numberCameraRigth, LeftImagePointsStereo, RightImagePointsStereo)
La función recibe las M imágenes, los 2 nombres para guardar datos, los 7 puntos del chessboard, los
números de los puertos USB donde están conectadas las cámaras Web (generalmente 0 y 1), las cámaras
no deben compartir el mismo HUB porque pueden presentarse errores de captura, además retorna las
matrices cv.Mat de coordenadas en pixeles de las dos cámaras. Para el proceso se utilizan las siguientes
funciones:
Capture = cv.CaptureFromCAM (int (numberCamera))
img = cv.QueryFrame (capture)
found_all1, corners = cv.FindChessboardCorners (img, chessboard_dim)
La función cv.CaptureFromCAM es un handle al dispositivo de captura que permite acceder al video
proporcionado por la cámara conectada en el puerto number y guardar temporalmente dicho handle en
Capture, mientras que cv.QueryFrame captura el frame de dicha captura de video guardando la imagen en
img, la cual es utilizada en la función cv.FindChessboardCorners [18] junto a la dimensión del
chessboard, retornando los K puntos en pixeles de las M imágenes en corners y una bandera found_all en
1 para saber si la búsqueda y captura fue correcta, además se calcula un rango de error para que siempre
tome las imágenes de forma horizontal y no vertical, ya que el objetsPoints contiene la matriz de
posiciones de forma horizontal.
cv.DrawChessboardCorners (img, chessboard_dim, corners, found_all)
cv.SaveImage ("nameImg.jpg", img)
cv.ShowImage (name_img, img)
cv.WaitKey (10) == 27:
26. 26
Posteriormente se utiliza la función cv.DrawChessboardCorners [18] para observar en la (Figura 10) los
puntos calculados sobre la imagen actual, cada imagen correcta es almacenada en una imagen .jpg con la
función cv.SaveImage y mostrada en una ventana nueva con la función cv.ShowImage. Todo este proceso
se realiza hasta que se presione la tela Esc, la cual se detecta con la llamada a la función cv.WaitKey, o el
proceso termine satisfactoriamente.
El tercer parámetro de la función cv.CalibrateCamera2 es pointsCounts, el cual indica el número de
puntos en cada una de las M imágenes, es de tipo cv.Mat de tamaño de Mx1, y en cada punto del mismo se
tiene el valor K.
El cuarto parámetro es imageSize siendo el tamaño de las imágenes, el cual puede ser calculado por la
función cv.GetSize, el cual recibe como parámetro la imagen y retorna el número de filas y columnas de la
imagen (640x480).
Figura 10. Detección de esquinas del chessboard
Los parámetros 5 y 6 retornados de la función cv.CalibrateCamera2, CameraMatrix y DistCoeffs,
constituyen los parámetros intrínsecos de la cámara. El primero es la Matriz Intrínseca de la Cámara
(Ecuación 1), de tipo cv.Mat con tamaño de 3x3, la cual contiene las distancias focales (fx, fy) y el centro
aproximado de las imágenes de la cámara (cx, cy).
100
0
0
cyfy
cxfx
M (1)
Por lo general los coeficientes de distorsión son 5 valores para cámaras web, la distorsión radial retorna 3
(k1, k2, k3), mientras la tangencial retorna 2 (p1, p2), formando una matriz de tipo cv.Mat de 5x1, dichos
valores son utilizados para la corrección de las coordenadas en la imagen como se observa en las
Ecuaciones 2-a y 2-b respectivamente.
6
3
4
2
2
1
6
3
4
2
2
1
1
1
rkrkrkyy
rkrkrkxx
corrected
corrected
(2a)
27. 27
xpyrpyy
xrpypxx
corrected
corrected
2
22
1
22
21
22
22
(2b)
Los últimos dos argumentos RVecs y TVecs son los parámetros intrínsecos de rotación y traslación
respectivamente, las dos retornan matrices de tamaño Mx3 y de tipo cv.Mat, describiendo los ángulos y
offsets de las distintas capturas.
Los 4 parámetros retornados por la función cv.CalibrateCamera2 son almacenados en archivos .xml,
dicha función es utilizada tanto con la Cámara Izquierda como con la Derecha, con el fin de encontrar 4
parámetros intrínsecos necesarios para la Calibración Stereo [16] y utilizados en la función
cv.StereoCalibrate. [18]
cv.StereoCalibrate (
objetsPoints,
LeftImagePointsStereo,
RightImagePointsStereo,
pointCounts,
LeftCameraMatrixStereo,
LeftDistCoeffsStereo,
RightCameraMatrixStereo,
RightDistCoeffsStereo,
imageSize, R, T
)
Los tres primeros parámetros objetsPoints, LeftImagesPointsStereo y RightImagePointsStereo fueron
calculados anteriormente con las funciones createObjetPoints y stereo_img, en la Figura 11 se observa el
reconocimiento de un chessboard de 7x7 y la obtención de los 49 puntos del mismo en cada imagen de las
dos cámaras. Se tiene también los parámetros pointsCounts e imageSize y los parámetros intrínsecos para
las dos cámaras retornados por la función cv.CalibrateCamera2, los cuales van a ser modificados y
guardados en las misma variables obteniendo las matrices intrínsecas de las cámaras en Visión Stereo y
los coeficientes de distorsión de las mismas.
Figura 11. Detección de puntos en el chessboard en Calibración estéreo
28. 28
Además se crean dos nuevas matrices tipo cv.Mat, R y T, la primera es la matriz 3x3 de rotación Stereo y
la segunda es el vector columna de traslación Stereo de tamaño 3x1. Estos dos parámetros extrínsecos
junto a las matrices intrínsecas izquierda y derecha Stereo, son utilizadas en la reconstrucción de 2D a 3D.
Los 4 parámetros intrínsecos y los 2 extrínsecos retornados por la función cv.StereoCalibrate son
almacenados en archivos .xml
Iluminación
Al finalizar el proceso de calibración Stereo de las cámaras, el paso a seguir es empezar a capturar el
movimiento de un personaje con marcas (Figura 12-a), las cuales van a ser segmentadas para la obtención
de los puntos en pixeles de las mismas y la correspondencia entre las cámaras; la iluminación es una parte
muy importante para facilitar el análisis y segmentación de las marcas, se utiliza un bombillo de luz negra
(Figura 13), el cual cumple con la función de resaltar los colores fluorescentes, por lo tanto se decide tener
como marcas, bolas de icopor pintadas con una pintura especial fluorescente (Figura 12-b), resaltando y
mejorando las marcas y la visualización de las mismas.
Figura 12 (a). Traje con marcas luz normal, (b). Traje con marcas luz negra
29. 29
Figura 13. Luz Negra
Segmentación de las imágenes
Para la segmentación inicialmente se trabajo con marcas de colores brillantes (Figura 14), los resultados
para una segmentación inicial y un ambiente de iluminación sin controlar se observan en la parte inferior
de la Figura 4, en donde la obtención del background y foreground no tuvo éxito. Posteriormente se
utilizaron sensores infrarrojos (Figura 15) con el fin de tener diferentes rangos de frecuencia y
luminosidad en las marcas pero al tener una distancia lejana entre las cámaras y los sensores, las marcas se
perdían, además de necesitar una fuente de energía para trabajar con dichos sensores.
Figura 14. Sistema de Captura con iluminación y sensores refractivos
Figura 15. Sistema de Captura sin iluminación con sensores infrarrojos
30. 30
Por lo cual se escoge la luz negra que reconoce fácilmente las marcas fluorescentes (Figura 14-b) y
presentan un daño igual o inferior al ojo humano, y así se diseña un traje de color negro en licra que
facilita mas los movimientos gracias a su elasticidad y se añaden las marcas (Figura 16-a). Para que todo
el sistema de captura de movimiento funcione de una mejor manera se debe tener en cuenta la iluminación
mencionada anteriormente apreciando los resultados en la Figura 16-b.
Figura 16 (a). Sistema de Captura con iluminación real, (b). Sistema de Captura con iluminación controlada
Para el proceso de segmentación, detección de marcas y correspondencia se diseña un Script llamado
CapturePoints.py, el cual captura el video con la función cv.CaptureFromCam de las dos cámaras, toma
cada imagen (frame) original iluminada con luz negra con la función cv.QueryFrame y las muestra de
forma paralela con la función cv.ShowImage (Figura 17).
Figura 17 (a). Marcas Detectadas con la cámara izquierda, (b). Marcas Detectadas con la cámara derecha
31. 31
Ya que las imágenes a color demandan más recursos para su procesamiento, el primer paso es transformar
dichas imágenes a escala de grises mediante una umbralización de las mismas (Figura 18), obteniendo
entonces un realce de las partes que interesan y descartando el resto de la imagen que no es útil para el
proceso, mediante la función cv.InRangeS
cv.InRangeS (ImageSrc, (B-tolB, G-tolG, R-tolR), (B+tolB, G+tolG, R+tolR), ImageTh)
El primer parámetro es la imagen original, los dos siguientes reciben vectores fila de 1x3, los cuales tienen
los valores aproximados del color fluorescente en los tres espacios Red=51, Green=127 y Blue=33
(RGB), además de tolerancias tolR=50, tolG=80 y tolB=50 como factores de cambio debido a la
iluminación, con el fin de no perder las marcas. La función cv.InRangeS retorna imágenes de tipo
cv.Image creadas mediante la función cv.CreateImage
cv.CreateImage (size, depth, channels)
Dicha función recibe el tamaño de la imagen, la intensidad de la misma (ej. cv.IPL_DEPTH_8U para
tener valores entre 0-255 en una imagen a escala de grises) y el número de canales.
Figura 18. Umbralización de las Imágenes
Debido a que dicha umbralización tiene valores en escala de grises es necesario binarizar la imagen para
tener solo dos valores en la imagen que simbolicen el background en un valor igual a 0 y el foreground
con un valor de 255 (Figura 19). Existen tres funciones de la librería OpenCV para realizar dicha labor,
cv.AdaptiveThreshold no realiza lo que se desea, por lo cual se puede utilizar las funciones cv.Canny y
cv.Threshold, la primera recibe la imagen a filtrar, la imagen de destino y dos valores para escoger un
rango de pixeles para la mejora de las marcas, mientras que la segunda define un rango entre el parámetro
ingresado y 255, recibe el valor que obtendrá el foreground y tiene una bandera
(cv.CV_THRESH_BINARY) que permite realizar umbralización binaria, por lo cual se escoge entre las
tres cv.Threshold
32. 32
cv.Threshold (ImageTh, ImageBin, threshold, maxValue, ThresholdType);
Figura 19. Binarización de las Imágenes
Siguiendo con el proceso de segmentación y teniendo las imágenes binarizadas, se utiliza la función
cv.Dilate, la cual realiza la dilatación de las marcas el número de veces que sean ingresadas en el Script
(Figura 20), para así mejorar su resolución evitando ruidos y puntos huecos, mejorando la resolución de
las marcas, logrando con esto una mejor fiabilidad en la obtención de las mismas.
cv.Dilate(ImageBin, ImageDil)
Figura 20. Dilatación de las marcas
Finalmente en el proceso de segmentación se hace la detección de los contornos (Figura 21) de la imagen
dilatada, esto se hace con el fin de obtener la posición de cada una de las marcas que se encuentran en las
imágenes, mediante la función cv.FindContours.
33. 33
Contours = cv.FindContours (ImageDil, storage, mode, method, offset)
cv.CreateMemStorage (0)
Para obtener Contours en un archivo tipo cv.MemStorage, el primer parámetro que recibe es la imagen
dilatada de tipo cv.Image con un solo canal de 8 bits, el segundo es un parámetro de tipo cv.MemStorage
el cual guarda las posiciones de los bordes de cada una de las marcas, para crear un parámetro de este tipo
se utiliza la función cv.CreateMemStorage y se le envía el valor en 0 para que tome un tamaño de
memoria por defecto. El tercer parámetro es el modo de guardar los bordes de las distintas marcas, se
envía cv.CV_RETR_LIST para guardarlos en forma de lista, el cuarto parámetro es el método de
aproximación, se utiliza cv.CV_CHAIN_APPROX_SIMPLE que utiliza compresión horizontal, vertical y
retorna solo el último punto capturado, y por último el offset para darle corrimiento si se desea o es
necesario, siendo este un vector (x, y).
Para graficar los bordes OpenCV tiene una función llamada cv.DrawContours, la cual recibe como primer
parámetro una imagen de fondo en donde se van a pintar los contornos encontrados, el segundo parámetro
son los resultados arrojados por la función cv.FindContours, el tercer y cuarto parámetro son los colores
externos igual a 200, valor en pixeles, e internos 150, y el ultimo es una bandera en 1 para graficar
únicamente los bordes encontrados.
cv.DrawContours(ImageDilContours, Contours, 200, 150, 1)
Para encontrar el punto 2D del contorno de las marcas, se crea la función Detect, la cual recibe como
parámetro Contours, el cual se mueve a través del cv.MemStorage por cada una de las marcas sumando
los pixeles del contorno, haciendo una media con los mismos y guardando con un nombre name su
resultado en la matriz cv.Mat Points2D de tamaño número de puntos por 2.
Detect (contours, name, Points2D)
Figura 21. Obtención de Contornos
34. 34
Correspondencia y seguimiento
Los puntos 2D son guardados en una matriz cv.Mat, pero el orden de los puntos calculados en la imagen
izquierda no es el mismo que el orden de la imagen derecha, por lo cual, el siguiente paso es realizar una
correspondencia entre las dos cámaras, se utiliza la función cv.CalcOpticalFlowPyrLK para calcular el
flujo óptico utilizando el método iterativo de Lucas-Kanade con pirámides. [30] [31] [32]
RightPoints2DPyr = cv.CalcOpticalFlowPyrLK (LeftImageDil, RightImageDil, LeftPyr,
RightPyr, LeftPoints2D, (15, 15), 5, (cv.CV_TERMCRIT_ITER, 10, 0), 0)
Los primeros dos parámetros son las imágenes dilatadas de la cámara izquierda y derecha, los dos
siguientes son dos matrices temporales cv.Mat de tamaño widthL+8 por heightR/3, el cálculo del tamaño
de estos dos parámetros se obtiene utilizando la función cv.GetSize
heightL, widthL = cv.GetSize (LeftImage)
heightR, widthR = cv.GetSize (RightImage)
El quinto parámetro son los puntos 2D pero son de tipo cv.Point2D32f, por lo cual los puntos que se
calcularon no se pueden enviar hacia esta función ya que son de tipo cv.Mat, el problema se resuelve con
la función cv.GoodFeaturesToTrack, que también calcula los puntos 2D y los guarda los resultados
directamente en una variable del tipo cv.Point2D32f. Solo se utiliza esta función para encontrar los puntos
de cada marca de la cámara izquierda, ya que los puntos 2D de la cámara derecha son estimados con la
función cv.CalcOpticalFlowPyrLK. [30] [31] [32]
LeftPoints2D = cv.GoodFeaturesToTrack (LeftImageDil, LeftEig, LeftTemp, Points,
0.005, Distance)
La función recibe la imagen dilatada, dos matrices cv.Mat del mismo tamaño de las imágenes originales
con los datos representados por flotantes de 32 bits (cv.IPL_DEPTH_32F) y de un solo canal, el cuarto
parámetro es el número de puntos que se desea obtener, el quinto es un factor de multiplicación para
obtener mejores niveles en el reconocimiento, y por último se envía la distancia mínima entre marcas para
la detección.
Al tener los puntos 2D de la imagen izquierda como resultado de la función cv.GoodFeaturesToTrack en
un tipo de variable cv.Point2D32f , se obtiene el quinto parámetro de la función
cv.CalcOpticalFlowPyrLK, el sexto parámetro es el tamaño de la ventana de búsqueda por cada nivel de
la pirámide, el siguiente es el numero de niveles de la pirámide, el octavo termino recibe cv.TermCriteria
que indica cuando el proceso del flujo óptico entre cada punto y el nivel de la pirámide es satisfactorio
encontrando correspondencia, y como ultimo parámetro una bandera en 0. Obteniendo a la salida de la
función cv.CalcOpticalFlowPyrLK el cálculo de los puntos 2D de la imagen derecha.
35. 35
Con los puntos 2D de la cámara izquierda y derecha es posible hacer un seguimiento continuo del
movimiento del personaje con las marcas, debido a que el Script CapturePoints.py funciona con el video
de las dos cámaras, haciendo un análisis de las capturas y determinando en qué posición se encuentra cada
marca en la misma, obteniendo el tracking de cada punto, logrando así el Seguimiento Completo de los
movimientos.
En la Figura 22 se observa la correspondencia entre las dos cámaras, creando con la función cv.Line líneas
que unen los puntos de la imagen izquierda con sus respectivos puntos en la imagen derecha, dicha líneas
son pintadas con un color seleccionado con la función cv.CV_RGB que recibe los tres valores en pixeles
de 0-255, a demás se envía el ancho de las mismas.
cv.Line (LeftImage, ptLeft, ptRight, cv.CV_RGB (255, 255, 255), 4)
Figura 22. Correspondencia, seguimiento y Tracking del par Stereo
En la Figura 22 se observa que el sistema está haciendo el seguimiento de cada marca, en la imagen de la
izquierda se observa como se supone que fue el movimiento visto desde la derecha y en la imagen de la
derecha se observa el mismo resultado pero visto desde la imagen izquierda.
En la Figura 23 se observa los subsistemas de segmentación y correspondencia de todo el sistema, con la
cámara izquierda (Figura 23-a, Parte Superior), y la cámara derecha (Figura 23-b, Parte Inferior), pasando
por todo el proceso de izquierda a derecha desde la imagen original, la umbralización, binarización, la
dilatación, obtención de los contornos y finalmente el seguimiento de cada punto, guardando en archivos
.xml los puntos 2D de la cámara izquierda y derecha.
36. 36
Figura 23. (a) Sistema de Captura Completo Cámara Izquierda, (b) Sistema de Captura Completo Cámara Derecha
Reconstrucción 3D
La reconstrucción se entiende como los algoritmos matemáticos que permiten calcular puntos en el
espacio tridimensional (X, Y, Z), a partir de la información de las dos imágenes, tanto izquierda como
derecha (visión estereoscópica) y de los datos resultantes de la calibración [16], El script
cam_calibracion.py guarda las matrices intrínsecas de calibración, rotación y traslación del mundo según
como lo ve la cámara izquierda, con dichas matrices es posible hacer una reconstrucción de dos puntos
(X1, Y1) y (X2, Y2) almacenados desde el Script CapturePoints.py, logrando así obtener un punto en 3D
(X, Y, Z).
Para comprobar dicha reconstrucción se diseñan dos Scripts Reconstruction.py y TriangulationP.py, el
primero calcula las operaciones observadas en la Ecuación 3-b, las cuales se observan de forma matricial
siguiendo el algoritmo de la Ecuación 3-a
r
TT
r
T
lll pbRTRPRpcapcwap )( [3a]
De forma matricial se tiene:
z
y
x
T
r
r
Rigth
yy
xx
T
l
l
left
yy
xx
r
r
Rigth
yy
xx
T
l
l
left
yy
xx
T
T
T
Ry
x
cf
cf
rrr
rrr
rrr
Xy
x
cf
cf
C
y
x
cf
cf
rrr
rrr
rrr
by
x
cf
cf
a
1100
0
0
1100
0
0
1100
0
0
1100
0
0
1
333231
232212
131211
1
1
333231
232212
131211
1
[3b]
Se renombran las operaciones para minimizar en vectores columna la matriz A
38. 38
Para crear el Script de TriangulationP.py se utiliza el algoritmo de la Ecuación 4-a, el cual requiere los
puntos 2D calculados y encontrar las matrices de proyección de la cámara izquierda (Ecuación 4-b) y
derecha (Ecuación 4-c), para lo cual se cargan los resultados del script cam_calibracion.py, las matrices
intrínsecas, los parámetros extrínsecos de rotación y traslación, y se utiliza además de las funciones ya
mencionadas, cv.GetRow, encargada de obtener la fila de una matriz ingresada en el primer parámetro,
cv.GetCol, obtiene la columna de una matriz, y cv.GetCols un rango de columnas desde una columna
inicial hasta una final.
dst = cv.GetRow (Mat, NumRow)
dst = cv.GetCol (Mat, NumCol)
dst = cv.GetCols (Mat, MinCol, MaxCol)
TT
TT
TT
TT
ppy
ppx
ppy
ppx
2
2
3
22
1
2
3
22
2
1
3
11
1
1
3
11
A [4-a]
0100
0010
0001
0|| 1int1int111int431 MIMTRMP )x(
[4-b]
TRMP )x( 222int432 | [4-c]
Al obtener las matrices de proyección se procede a calcular la matriz A mediante la ecuación 4-a
utilizando los puntos en 2D cargados, posteriormente se utiliza la función cv.SVD la cual realiza la
descomposición de valores singulares sobre la matriz A retornando las matrices W, U y V, para obtener el
punto 3D y almacenarlo se selecciona la última columna de V, de la cual los valores de las 3 primeras
filas son divididos por un factor de escala siendo la cuarta fila de dicha columna.
Visualización
Finalmente en la Figura 24 se visualiza el resultado del proceso de reconstrucción 3D de las imágenes,
mediante la herramienta software Blender, se diseña un script en lenguaje python llamado
Visualitation3D.blend, el cual utiliza los puntos 3D obtenidos en el script TriangulationP.py y visualiza
las marcas en coordenadas 3D (Figura 25-a), posteriormente con la ayuda de la herramienta de
visualización se trazan manualmente líneas 3D para obtener el modelo en malla (Figura 25-b).
39. 39
Figura 24. Interfaz de Blender, generando modelo de puntos en 3D
Figura 25. (a) Visualización de los puntos 3D (b) Modelo de Alambre de los puntos 3D
40. 40
5. RESULTADOS
La Calibración del Sistema funciona correctamente variando el chessboard en distintas posiciones de
rotación y traslación (Figura 26)
Figura 26. (a) Calibración de Cámara Izquierda Arriba, (b) Calibración de Cámara Derecha Abajo
La Matriz Intrínseca de la Cámara Izquierda tiene valores muy parecidos a la Matriz Intrínseca de la
cámara Derecha, y tiene sentido ya que son las mismas cámaras Web y la distancia focal es manipulada
físicamente de tal forma que ante el ojo humano son muy parecidas las vistas. A demás de los centros de
las imágenes son muy aproximados a las reales que serian la mitad del tamaño de la imagen de 640x480
dando un resultado de Cx=320 y Cy=240.
100
231.294235751.2907100
312.5939330753.609314
intLeftM
100
226.731567738.2843020
287.8906560738.546143
intRightM
41. 41
La matriz de rotación cumple con la propiedad de que su inversa es su traspuesta, además de
IRRRR TT
570.0123735630.18608771-147500.00009299-
226.73156710.99776399300.06683546
20.18649861370.0656801520.98025733
Rotation
El vector columna de translación se comparo con mediciones de las distancias en cuadros del chessboard
en el mundo real, las distancias Y y Z fueron muy pequeñas casi imperceptibles ante el ojo humano por lo
cual no se hicieron mediciones físicas y comparando con los resultados del vector de traslación
concuerdan, mientras la separación entre las cámaras fue de aproximadamente 19cm, si cada cuadro
equivale a 2.3cm, el vector de translación en X después de la calibración Stereo asume una distancia de
8.02cuadros, lo que equivale a 18.44cm.
20.47941461
80.25586950
8.02052879-
nTranslatio
Se realizaron 4 pruebas de segmentación, detección de puntos (1, 8, 10, 14), correspondencia,
reconstrucción y visualización. Para la primera se vario una sola marca cambiándola de posición del
centro hacia los 3 ejes aumentando y disminuyendo para cada uno como se observa en la Figura 27, dichas
marcas son segmentadas y detectadas en coordenadas 2D de correspondencia, y en la Tabla 1 se calcula
para con los puntos 2D de la cámara izquierda y derecha, el punto 3D con el Script Reconstruction.py y la
Tabla 2 es construida a partir de TriangulationP.py, los puntos 3D de la segunda tabla son utilizados para
la visualización en Blender, la cual es modificada con modelos de líneas 3D uniendo todos los 7 puntos al
punto central, como se observa en la Figura 28.
Las Tablas muestran el cambio de las coordenadas en su respectivo eje 3D al realizarse un movimiento en
dicho eje en las 2 cámaras. El eje X hacia la izquierda disminuye mientras hacia la derecha aumenta, el eje
Y hacia arriba disminuye y hacia abajo aumenta, mientras el eje Z si se acerca disminuye y si se aleja
aumenta.
Las 3 pruebas siguientes muestran todo el proceso desde el sistema de captura de movimiento en las dos
camaras hasta la visualización 3D en Blender, cambiando el número de puntos inicialmente en 8 (Figuras
29-30) donde se tiene la parte superior del cuerpo, 10 (Figuras 31-32) donde se añade las dos marcas de la
cintura y 14 (Figuras 33-34) donde se tienen todas las marcas.
42. 42
Figura 27. Prueba 1 marca Visión Stereo (a) centro (b) Eje X Izquierdo (c) Eje X Derecho
(d) Eje Y Arriba (e) Eje Y Abajo (f) Eje Z Cerca (g) Eje Z Lejos
Tabla 1. Puntos 2D y Punto 3D de la Variación de 1 Marca en las dos cámaras utilizando Reconstruction.py
Localitation Left Point 2D Rigth Point 2D Point 3D
Center (331,261) (261,255) (-4.72, 1.19, 30.38)
XLeft (168,266) (103,274) (-10.94, 1.40, 28.22)
XRigth (463,231) (390,214) (0.77, -0.09, 30.62)
Yup (351,155) (267,150) (-3.89, -3.08, 29.44)
YDown (318,413) (269,409) (-5.33, 7.94, 32.17)
ZNear (363,334) (193,340) (-3.64, 2.80, 19.83)
ZFar (320,180) (290,175) (-5.49, -2.73, 39.55)
Tabla 2. Puntos 2D y Punto 3D de la Variación de 1 Marca en las dos cámaras utilizando TriangulationP.py
Localitation Left Point 2D Rigth Point 2D Point 3D
Center (331,261) (261,255) (-0.63, 1.49, 31.00)
XLeft (168,266) (103,274) (-6.85, 1.65, 28.82)
XRigth (463,231) (390,214) (4.86, 0.15, 31.24)
Yup (351,155) (267,150) (0.19, -2.83, 30.05)
YDown (318,413) (269,409) (-1.23, 8.19, 32.77)
ZNear (363,334) (193,340) (0.44, 3.11, 20.29)
ZFar (320,180) (290,175) (-1.40, -2.49, 40.18)
43. 43
Figura 28. Visualización en 3D de los puntos reconstruidos
Figura 29. (a) Sistema de Captura 8 Puntos Cámara Izquierda, (b) Sistema de Captura 8 Puntos Cámara Derecha
44. 44
Figura 30. Visualización 3D de 8 Puntos
Figura 31. (a) Sistema de Captura 10 Puntos Cámara Izquierda, (b) Sistema de Captura 10 Puntos Cámara Derecha
Figura 32. Visualización 3D de 10 Puntos
45. 45
Figura 33. (a) Sistema de Captura 14 Puntos Cámara Izquierda, (b) Sistema de Captura 14 Puntos Cámara Derecha
Figura 34. Visualización 3D de 14 Puntos
Finalmente se tiene en la Tabla 3 los costos totales del Sistema de Adquisición de Movimiento a Bajo
Costo
Tabla 3. Presupuesto del Sistema de Adquisición de Movimiento
HERRAMIENTAS CANTIDAD VALOR/UNIDAD TOTAL
Cámaras 2 35000 70000
Base 1 75000 75000
Pintura Base 1 35000 35000
Traje 1 70000 70000
Bolas Icopor 15 400 6000
Pintura Fluorescente 1 7000 7000
Bombillo Luz Negra 1 20000 20000
TOTAL 251500
46. 46
6. CONCLUSIONES
Se presenta un Sistema de Adquisición de Movimiento que puede ser reproducido mediante
herramientas de soporte hardware de bajo costo, adicionalmente las herramientas software son de
distribución libre evitando el pago de licencias privativas.
El Sistema de Adquisición de Movimiento de Bajo Costo es adaptable a otros sistemas de captura
de mejor calidad, esquemas de iluminación, ambientes de trabajo, gracias a que todo el
procesamiento reside en el software.
Se recomienda durante la calibración utilizar una cantidad de imágenes superior o igual a doce,
con el fin de producir suficientes variaciones de la distancia entre las cámaras y el chessboard, de
tal forma que se obtenga un nivel de calibración para una región espacial de mayor tamaño.
Las dimensiones de la rejilla de calibración o chessboard deben ser de NxN para que el algoritmo
en el proceso de calibración arroje los resultados deseados, de lo contrario, el proceso de
reconstrucción 3D será erróneo.
Se debe procurar hacer que las funciones desarrolladas para una aplicación que utiliza OpenCV
sean compatibles con los tipos de datos de esta librería.
Los algoritmos de segmentación y seguimiento son sensibles a la distancia a la cual se encuentran
las marcas, esto hace necesario el ajuste manual de algunos parámetros en cada algoritmo. Para la
segmentación el parámetro es el nivel de dilatación, mientras que para el seguimiento es el tamaño
de la pirámide del algoritmo de Lucas Kanade.
No existe una notación estandarizada para los procesos de calibración y reconstrucción en el
estado del arte, lo cual dificulta el diseño e implementación en campos de investigación de
sistemas de captura de movimiento.
Es necesario ejecutar una nueva calibración del sistema cada vez que se realice un cambio en la
posición del soporte o ubicación de las cámaras.
47. 47
7. RECOMENDACIONES
Al iniciar un proyecto en donde muchos conceptos son ambiguos es necesario analizar el estado del arte
del mismo, comprender la literatura ya existente, y diseñar un marco teórico para obtener los conceptos y
terminologías necesarios. Es de mucha importancia comentar cada algoritmo, función y/o programa que
diseñe, además de llevar un seguimiento escrito de cada detalle realizado, ya que simplifica la redacción
de informes, artículos y/o documentos.
Para facilitar el funcionamiento de un sistema de reconocimiento de marcas, es necesario tener un
ambiente controlado, y uno de los subsistemas más importantes para facilitar los procesos siguientes, es la
iluminación, debido a que los factores ambientales externos alteran en el funcionamiento del sistema,
creando ciertas fallas en los algoritmos.
Al realizar pruebas con el sistema presentado en este trabajo, se debe adecuar la base de tal forma que esta
no se tenga que mover durante todo el proceso, ya que la calibración de cámaras da como resultados
matrices calculadas con las posiciones actuales del sistema, y si estas se llegan a mover por algún motivo,
se debe realizar nuevamente el proceso de calibración desde el principio para obtener resultados
adecuados.
La parte de segmentación de las imágenes es muy importante, debido a que este subsistema logra extraer
la información necesaria para realizar un procesamiento del movimiento más fácil y utilizar menos
recursos computacionales.
Es muy importante tener en cuenta que la ubicación de las cámaras en la base es fundamental, debido a
que el eje óptico de ambas cámaras se debe cruzar en algún punto, o al menos estimar que eso está
sucediendo para obtener buenos resultados en el seguimiento, por lo tanto hay que evitar que las cámaras
queden ubicadas con una vista paralela sino con una vista diagonal para garantizar este cruce, ya que esto
va a asegurar que todo el proceso que se está haciendo funcione, de lo contrario, el proceso a seguir es
diferente.
Debido a que las cámaras son de baja resolución, es recomendable usar un chessboard de un tamaño
adecuado, el cual pueda ser capturado a diferentes distancias, para así lograr unos buenos resultados.
8. TRABAJOS FUTUROS
Dotar al Sistema de Auto calibración.
Realizar la calibración con otros modelos
Usar cámaras sincronizadas de gama media o alta.
Realizar la Correspondencia y Reconstrucción 3D con otros modelos.
Experimentar con cámaras de mejor resolución.
Experimentar con distintos tipos de marcas e iluminaciones.
48. 48
BIBLIOGRAFIA
[1] [José Antonio Sánchez Sobrino, E.T.S.I Caminos, Canales y puertos, 2006-2007] Introducción a la
Fotogrametría. ftp://ftp.unsj.edu.ar/agrimensura/Fotogrametria/Unidad6/Introduccion_a_la_Fotogrametria.pdf
[2] [Manuel Fernández, Imágenes en tres dimensiones, 2000] Estereoscopia o Visión en 3D.
http://sophia.javeriana.edu.co/~cbustaca/Realidad%20Virtual/material/clase14/estereoscopia.pdf.
[3] [Álvaro Bayona Gómez, 2009] Detección de objetos abandonados/robados en secuencias de vídeo-
seguridad. http://arantxa.ii.uam.es/~jms/pfcsteleco/lecturas/20090921AlvaroBayona.pdf.
[4] [WM. H. Dobelle, 2000] Artificial Vision for the Blind by Connecting a Television Camera to the
Visual Cortex. http://biomed.brown.edu/Courses/BI108/2006-108websites/group03retinalimplants/multimedia/article.pdf.
[5] [Carlos R. Moreno]. Visión Computacional, retos científicos de la computación. Visión estereoscópica.
Técnicas de Correspondencia. http://www.vhtm.com/DIVULGACION/Vision%20Estereoscopica%20por%20CarlosRuiz.pdf.
[6] [Yiannis Aloimonos, Gutemberg Guerra-Fiho] Optical Motion Capture.
http://ranger.uta.edu/~guerra/OpticalMotionCapture.html
[7] [Motion Captor RT]. Captura de Movimiento en tiempo real.
http://www.stt.es/2009/descargas/descripcion_MotionCaptor.pdf
[8] [M. Gutiérrez Dávila, J. A. Martínez Corral] Método matemático para la sincronización de las
cámaras mediante la utilización de algoritmos DDT. http://upcommons.upc.edu/revistes/bitstream/2099/5433/1/article9.pdf
[9] [Josep Isern González, 2003] Estúdio experimental de métodos de calibración y autocalibración de
cámaras. http://gias720.dis.ulpgc.es/Gias/josep/TesisJosep.pdf
[10] Rafael C. Gonzales, Richard E. Woods (1996). Tratamiento Digital de Imágenes.
http://books.google.com/books?id=TQT6DF3_YgkC&printsec=frontcover&hl=es&source=gbs_ge_summary_r&cad=0#v=onepage&q&f=false
[11] WorldLingo. Modelo de Marco de Alambre. http://www.worldlingo.com/ma/enwiki/es/Wire_frame_model
[12] José M. López, Antonio Fernández Caballero, Miguel A. Fernández. (2005). Conceptos y Técnicas
de Estereovisión por computador. Inteligencia Artificial. Revista Iberoamericana de Inteligencia
Artificial, 35-62. http://redalyc.uaemex.mx/pdf/925/92502703.pdf
[13] Reconstrucción 3D. http://www.elai.upm.es:8009/spain/Investiga/GCII/personal/lrodriguez/web3D/reconstruccion_3d.htm
[14]Capitulo 3. Visualización. http://catarina.udlap.mx/u_dl_a/tales/documentos/lis/cardona_a_jf/capitulo3.pdf
[15] [Vicente M. Olivera, Jesús M. González, Pedro de las Heras, Gregorio R. Martínez] Sobre Software
Libre Compilación de ensayos sobre software libre. http://gsyc.es/~grex/sobre-libre/libro-libre.pdf
49. 49
[16] [José Gabriel Hoyos, Jaiber Evelio Cardona, Luis Miguel Capacho, Luis Felipe Orozco, Universidad
del Quindío, Programa de Tecnología en Electrónica, Grupo GAMA, Programa Ingeniería Electrónica,
2010] Tesis de Pregado Técnicas de Calibración de Cámaras para visión estéreo y reconstrucción.
[17] [Zhengyou Zhang, 1999] Flexible Camera Calibration By Viewing a Plane From Unknown
Orientations. http://www.cse.iitk.ac.in/users/vision/dipakmj/papers/zhan99.pdf
[18] [Gary Bradski, Adrian Kaebler, 2008] Learning OpenCV Computer Vision with the OpenCV
Library. http://www.cse.iitk.ac.in/users/vision/dipakmj/papers/OReilly%20Learning%20OpenCV.pdf
[19] [Python Software Foundation, 1990-2011] http://python.org/about/
[20] [Python Software Foundation, 1990-2011] http://www.python.org/about/apps/
[21] [Francisco Carlos Calderón] OpenCV. http://opencvjaveriana.wikispaces.com/file/view/OpenCV-1.pdf
[22] [J. B. Hayet, 2007] Introducción al uso de OpenCV. http://www.cimat.mx/~jbhayet/CLASES/VISIONROB/opencv2.pdf
[23] [OpenCV] http://opencv.willowgarage.com/documentation/python/index.html
[24] [Jesús Manuel Montero Garrido] Plataforma Eclipse. Introducción Técnica.
http://150.244.56.228/descargas_web/cursos_verano/20040801/Jesus_Montero/documentacion_eclipse.pdf
[25] [Jesús M. González Barahona, Joaquín Seoane Pascual, Gregorio Robles] Introducción al software
libre. http://www.atenas.cult.cu/rl/informatica/manuales/sl/introduccion_al_SL/eclipse.html
[26] [Eclipse Foundation] http://www.eclipse.org/
[27] [Ton Roosendaal, Stefano Selleri] Blender 2.3 Guia. La Suit Abierta de Creación 3D.
http://www.futureworkss.com/tecnologicos/informatica/tutoriales/Manual_de_Blender.pdf
[28] ¿Qué es Blender? http://www.renderati.com/render/%C2%BFque-es-blender/
[29] [Blender Foundation] http://www.blender.org/
[30] [Bruce D. Lucas Takeo Kanade, 1981] An Iterative Image Registration Technique with an
Application to Stereo Vision http://www.ri.cmu.edu/pub_files/pub3/lucas_bruce_d_1981_1/lucas_bruce_d_1981_1.pdf
[31] [David Mora, Andrés Páez, Julián Quiroga Sepúlveda, 2009] Detección de Objetos Móviles en una
Escena Utilizando Flujo Óptico. http://pwp.etb.net.co/gaquirogar/files/STSIVA09%28Mov%29.pdf
[32] [Jean-Yves Bouget] Pyramidal Implementation of Lucas Kanade Feature Tracker Description of the
algorithm. http://robots.stanford.edu/cs223b04/algo_tracking.pdf
