tesis de maestría - cimat.repositorioinstitucional.mx 282.pdf ·...

Centro de Investigación en Matemáticas, A.C.

Segmentación binaria del video de una webcam en tiempo real

Tesis

que para obtener el grado de

Maestro en Ciencias con Especialidad en Computación yMatemáticas Industriales

presenta

Francisco Javier Hernández López

Director de Tesis

Dr. Mariano José Juan Rivera Meraz

Guanajuato, Gto. Enero de 2009

A mi hermano Paulino y a mi hija Megan Esmeralda

iii

Agradecimientos

Agradezco a Dios por permitirme estar vivo. A mi familia por que siempre me brindan su apoyoy comprensión. Gracias mamá y papá por sus consejos y por dejarme seguir adelante a pesar de ladistancia, hermano e hija, espero ser un buen ejemplo para ustedes y que siempre cuenten conmigo.Gracias abuelita por pedirle a Dios que me ilumine en mi camino y por enseñarme a ser humilde,abuelo, aunque ya no estés con nosotros sabes que siempre estas en mi corazón (tu nieto al que lleva-bas a pre-escolar y no sabia los colores se esta superando). A mis tíos y tías, gracias por enseñarmeque luchando se consiguen las cosas, a mis primos y primas gracias por darme ánimos y echarmeporras. Gracias Norma, por estar a mi lado en todo momento y por el amor que nos une.

A mi asesor el Dr. Mariano Rivera, gracias por su ayuda y comprensión durante la elaboraciónde la tesis, gracias a todos mis profesores por sus enseñanzas, a mis compañeros, a mis amigos y atoda la comunidad del CIMAT.

Finalmente agradezco a CONACyT y CONCyTEG por haberme apoyado económicamente paraque pudiera llevar a cabo mis estudios de maestría.

v

Índice general

Resumen xiii

1. Introducción 11.1. Motivación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.2. Planteamiento del Problema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2. Marco teórico 72.1. Substracción del Fondo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2.1.1. Trabajo relacionado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.2. Método QMPF para la segmentación binaria de imágenes . . . . . . . . . . . . . . . 102.3. Detección y estimación del movimiento . . . . . . . . . . . . . . . . . . . . . . . . . . 14

2.3.1. Detección del movimiento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142.3.2. Estimación del movimiento . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

2.4. Flujo Óptico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

3. Propuesta 213.1. Verosimilitud de pertenecer al fondo . . . . . . . . . . . . . . . . . . . . . . . . . . . 213.2. Segmentación con el método QMPF y sustitución del fondo . . . . . . . . . . . . . . 233.3. Modificación de la intensidad (MI) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243.4. Detección de sombras (DS) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263.5. Corrección de semejanza del color (CSC) . . . . . . . . . . . . . . . . . . . . . . . . . 28

4. Implementación 314.1. Programación en CUDA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314.2. Segmentación del primer plano . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334.3. Modificación de la intensidad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364.4. Detección de sombras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384.5. Corrección de semejanza del color . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

5. Experimentos 415.1. Resultados del método en nuestro escenario . . . . . . . . . . . . . . . . . . . . . . . 415.2. Resultados del método en otros escenarios . . . . . . . . . . . . . . . . . . . . . . . . 425.3. Comparación cualitativa con otros métodos . . . . . . . . . . . . . . . . . . . . . . . 46

vii

viii ÍNDICE GENERAL

6. Conclusiones y Trabajo a futuro 556.1. Conclusiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 556.2. Trabajo a futuro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

A. Tutorial del lenguaje de programación CUDA 57A.1. Configuración de CUDA en Visual C++ 2005 Express Edition . . . . . . . . . . . . 62A.2. Conceptos básicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65A.3. Ejemplos de programación en CUDA . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

Índice de figuras

1.1. Video-conferencia 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.2. Sustitución de Fondo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2.1. Regiones de soporte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

3.1. Diagrama a bloque de la Propuesta . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223.2. Verosimilitud de pertenecer al fondo . . . . . . . . . . . . . . . . . . . . . . . . . . . 233.3. Método QMPF c/s MGrid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243.4. Imágenes mal adquiridas por la WebCam . . . . . . . . . . . . . . . . . . . . . . . . 253.5. VB(x) bajo un cambio de iluminación . . . . . . . . . . . . . . . . . . . . . . . . . . 263.6. Verosimilitudes y función S(x) aplicando la DS . . . . . . . . . . . . . . . . . . . . . 273.7. Corrección de semejanza del color . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293.8. Derivadas parciales y flujo óptico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293.9. Mejora en el cálculo de VB(x) aplicando la CSC . . . . . . . . . . . . . . . . . . . . . 30

4.1. Diagrama de flujo principal del método . . . . . . . . . . . . . . . . . . . . . . . . . 324.2. Estructura de nuestros programas Kernel . . . . . . . . . . . . . . . . . . . . . . . . 334.3. Diagrama a bloque de la segmentación del primer plano . . . . . . . . . . . . . . . . 364.4. Estructura Piramidal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364.5. Diagrama a bloque de la modificación de la intensidad . . . . . . . . . . . . . . . . . 374.6. Diagrama a bloque de la detección de sombras . . . . . . . . . . . . . . . . . . . . . 384.7. Diagrama a bloque de la corrección de semejanza del color . . . . . . . . . . . . . . . 40

5.1. Ajuste de iluminación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435.2. Corrección de semejanza del color . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445.3. Ajuste de iluminación y Corrección de semejanza del color . . . . . . . . . . . . . . . 445.4. Detección de sombras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455.5. Resultados con el archivo video7_long . . . . . . . . . . . . . . . . . . . . . . . . . . 475.6. Resultados con el archivo vide6_long . . . . . . . . . . . . . . . . . . . . . . . . . . . 475.7. Resultados con el archivo intelligentroom_raw . . . . . . . . . . . . . . . . . . . . . 485.8. Resultados con el archivo highway_raw . . . . . . . . . . . . . . . . . . . . . . . . . 495.9. Resultados con videos “You Tube” . . . . . . . . . . . . . . . . . . . . . . . . . . . . 495.10. Comparación con otros métodos utilizando el archivo intelligentroom_raw . . . . . . 51

ix

x ÍNDICE DE FIGURAS

5.11. Comparación con otros métodos utilizando el archivo Curtain . . . . . . . . . . . . . 525.12. Comparación con otros métodos utilizando el archivo Fountain . . . . . . . . . . . . 525.13. Comparación con otros métodos utilizando el archivo WaterSurface . . . . . . . . . . 53

6.1. Aplicaciones considerando la cámara en movimiento . . . . . . . . . . . . . . . . . . 56

A.1. Organización del conjunto de hilos que ejecuta un Kernel . . . . . . . . . . . . . . . 60A.2. Flujo de compilación de un programa en CUDA (.cu a .cu.c) . . . . . . . . . . . . . 61A.3. Abrir proyecto en modo consola . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63A.4. Ventana de dialogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64A.5. Valores de la aplicación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64A.6. Ventana del proyecto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65A.7. Resultado de la Difusión 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85A.8. Resultado de la Difusión 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85A.9. Kernel de primera derivada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86A.10.Operadores en Imágenes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86

Índice de cuadros

1.1. Casos del problema de segmentación del primer plano. . . . . . . . . . . . . . . . . . 5

5.1. Parámetros del método. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

xi

xii ÍNDICE DE CUADROS

Resumen

El punto central de esta tesis, es la segmentación de secuencias de video en tiempo real, tratandode separar lo que es el primer plano del fondo y considerando que pueden existir diversos problemasque afecten en el cálculo de esta separación. La segmentación de secuencias de video, es uno de losproblemas que aún permanecen en la investigación, debido a las diversas aplicaciones en que estase utiliza, como por ejemplo: las video-conferencias, el análisis de video-vigilancia, análisis en videosde deportes, bases de datos, detección de métricas bio-médicas, etc.

La idea principal de nuestra propuesta, está basada en la suposición de que podemos tenerconocimiento del fondo, y que en toda la secuencia de video el fondo es estático y el primer planopuede estar estático o móvil. Para realizar la segmentación, se utiliza un algoritmo propuesto porRivera y otros [1] basado en Campos Aleatorios Markovianos, además se agregan tres partes im-portantes (“Modificación de la Intensidad”, “Detección de Sombras” y “Corrección de Semejanza delColor”) para que la segmentación sea robusta ante los cambios de iluminación en la escena, sombrasque proyecta el objeto que deseamos segmentar y semejanza del color entre el primer plano y elfondo, durante toda la secuencia de video.

Es difícil que una implementación en la CPU (Unidad de Procesamiento Central) de un métodorobusto de segmentación de video se procese en tiempo real, afortunadamente, existe la posibilidadde acelerar el proceso de cómputo utilizando la arquitectura GPU (Unidad de Procesamiento Gráfi-ca), la cual fue la principal herramienta utilizada en esta tesis para lograr el tiempo real del métodoque proponemos.

A continuación se da una breve descripción de cada capítulo de la tesis.

Capítulo 1. Introducción: En este capítulo se describe la segmentación de secuencias de video,la importancia que tiene en diversas aplicaciones, así como los factores y problemas a los quenos enfrentamos para obtener un método robusto.

Capítulo 2. Marco Teórico: Aquí se describen algunos de los trabajos que existen sobre la subs-tracción del fondo, después se presenta el algoritmo propuesto por Rivera y otros [1], basadoen Campos Aleatorios Markovianos para la segmentación binaria de imágenes, luego se definenlos conceptos básicos en cuanto al movimiento (Detección y Estimación) y finalmente se dauna aproximación para el cálculo del Flujo Óptico.

xiii

xiv RESUMEN

Capítulo 3. Propuesta: Se describe el método que proponemos para sustituir el fondo de todauna secuencia de video, así como nuestras contribuciones para obtener un método robusto acambios de iluminación, sombras y semejanza del color.

Capítulo 4. Implementación: En este capítulo se presenta el diagrama de flujo del método com-pleto, se da una descripción del lenguaje de programación CUDA para poder utilizar la arqui-tectura GPU y de esta forma acelerar el tiempo de ejecución de los procesos, y por último sedetallan las funciones más importantes del método.

Capítulo 5. Experimentos: Se prueba la robustez del método a cambios de iluminación, sombrasy semejanza del color, primero en videos de nuestro escenario adquiridos con una WebCamen tiempo real y después en videos de prueba del estado del arte. Finalmente se realiza unacomparación cualitativa de los resultados de nuestro método con los de otros métodos delestado del arte.

Capítulo 1

Introducción

A partir de las imágenes, los seres humanos obtenemos la mayor parte de la información del mundoreal. Para percibir mejor las imágenes y obtener más información de esta percepción, diferentestécnicas han sido desarrolladas y muchas aplicaciones se han descubierto. Desde hace 44 años, lasegmentación de imágenes digitales ha ido evolucionando muy rápidamente, en 1965, fue introducidoun operador para la detección de bordes entre las diferentes partes de una imagen (también conocidocomo “operador de bordes de Robert”), este detector, fue el primer paso hacia la descomposiciónde una imagen en las partes que la constituyen [2]. Desde entonces, un gran número de técnicas yalgoritmos para la segmentación de imágenes se han propuesto. A finales de los años noventa, muchoscentros de investigación en todo el mundo, desarrollaron algunos algoritmos sobre el procesamientode vídeo inteligente y diseñaron sistemas específicos para aplicaciones de seguridad. El alcance delas imágenes, así como los conceptos y técnicas de segmentación, se han ampliado enormemente,debido a los cambios que han surgido a través del tiempo, tales como: la extensión de las imágenes2D a 3D, el pasar de imágenes fijas a secuencias de imágenes (video), de imágenes en niveles de grisa imágenes a color, etc. En las siguientes secciones de este capítulo se describen algunas de las áreasen donde se utilizan algoritmos de segmentación para el análisis de video, después se describen losfactores que afectan en la elección de un método específico de segmentación, y finalmente se definenlos problemas que se van a abordar en la tesis.

1.1. Motivación

Novedosas herramientas de edición de imágenes aparecen todo el tiempo, los usuarios puedendescargar videos de Internet y las cámaras (WebCam´s) son más accesibles, por lo que cada vez esmás importante la capacidad de procesar las imágenes para modificar su naturaleza. Una de estasherramientas que sigue estando en la investigación es la sustitución del fondo de una secuencia devideo, los usuarios podrían utilizar esta herramienta por razones de privacidad, seguridad o simple-mente por estética.

Hoy en día, es frecuente encontrar publicaciones de investigadores en todo el mundo, acercade la segmentación de secuencias de video, apoyados en los últimos avances tecnológicos de hardware

1

2 CAPÍTULO 1. INTRODUCCIÓN

y software (un ejemplo son las tarjetas de video, las cuales aceleran el procesamiento de imágenesconsiderablemente). La segmentación de secuencias de video se puede utilizar en una amplia gamade aplicaciones, algunas de ellas pueden ser:

Video-conferencias. La video-conferencia, es la comunicación simultánea bidireccional deaudio y video, permitiendo las reuniones con grupos de personas situadas en lugares alejados,adicionalmente, se pueden ofrecer facilidades telemáticas o de otro tipo, como el intercambiode informaciones gráficas, imágenes fijas, transmisión de ficheros, etc. Recientemente, se hanestado desarrollando sistemas para video-conferencia en 3D, en el articulo de Peter y otros [3],proponen un sistema de video-conferencia 3D utilizando una representación natural de losparticipantes, inmersos en un espacio virtual, así como se observa en la Figura (1.1).

Análisis de video-vigilancia. Actualmente, los sistemas de vigilancia, aún no son sistemasinteligentes, el análisis se realiza mediante la observación de los videos, ya sea en tiempo real opreviamente grabados. En uno de los informes de Simon Harris del IMS (IP Multimedia Sub-systems) Research, sugiere el desarrollo de sistemas de video inteligente, ya que los operadoresde circuitos cerrados de televisión (CCTV), están siendo sobrecargados con un contenido devideo que no pueden vigilar de forma eficiente. Experimentos han demostrado que después de22 minutos, los operadores que visualizan simultáneamente varios monitores de vídeo, puedenpasar por alto acciones peligrosas que suceden en las escenas vigiladas. Lo sistemas de vigilan-cia automática pueden ayudar en esta situación, ya sea, realizando un análisis completamenteautomático o mediante una pre-alarma, indicando situaciones que requieran la atención deloperador.

Deportes. Otra aplicación es el análisis automático de acontecimientos deportivos como enel tenis o en el fútbol (por ejemplo, el “fuera de lugar”). El análisis de videos de deportes au-tomático, puede extraer información sobre el juego o los jugadores, esta información, puede serutilizada para enriquecer el deporte, con información adicional sobre el rendimiento del jugador(para el entretenimiento de los espectadores), pero también puede proporcionar informaciónvaliosa a los entrenadores para analizar las fortalezas y debilidades de sus propios atletas ocompetidores.

Bases de datos. Los gastos en almacenamiento de datos de video son cada vez mayores.La búsqueda y recuperación en estas bases de datos, plantean el nuevo problema de buscareficientemente en los datos de video. Un sistema óptimo de consulta debe ser capaz de transferiruna descripción lingüística de la escena para una consulta adecuada. Otro de los requerimientosen el uso de bases de datos de video, es la rápida navegación en el archivo, se puede reducir lacantidad de video que debe ser visto, por la preselección de las escenas más importantes.

Médicas. Últimamente se han estado desarrollando muchos algoritmos de segmentación, paraaplicaciones bio-médicas. El objetivo aquí, es desarrollar nueva tecnología para apoyar en eldiagnóstico y la práctica clínica, tanto en el aumento de la aportación visual presentada a losexpertos (por ejemplo, radiólogos), así como en la extracción de las medidas cuantitativas apartir de los datos.

1.2. PLANTEAMIENTO DEL PROBLEMA 3

Figura 1.1: Video-conferencia 3D. (a) Ejemplo de un montaje virtual. (b) Escenario final conteniendográficos y objetos de video. (Crédito: [3])

1.2. Planteamiento del Problema

La segmentación de imágenes es a menudo descrita como el proceso que subdivide a una ima-gen en sus partes constituyentes y extrae las partes de interés. Es una de las tareas más críticasen el análisis de imágenes, ya que la segmentación afecta todo el proceso subsecuente, tal como larepresentación del objeto, descripción del objeto, la clasificación del objeto y la interpretación dela escena. La segmentación de video, suele ser diferente a la segmentación de una sola imagen, enel sentido de que pueden existir varias soluciones correctas para segmentar una sola imagen, sinembargo, es necesario que haya una coherencia entre las segmentaciones de cada frame del video.

La segmentación de video es una parte integral de muchos problemas de análisis de video ycodificación, incluyendo:

Resumen, indexación y recuperación de video.

Codificación de video avanzado.

Edición de video.

Estimación de movimiento mejorado, por ejemplo el flujo óptico.

Movimiento 3D y estimación de estructura con múltiples objetos en movimiento.

Las primeras tres aplicaciones se utilizan en servicios multimedia en los cuales se requiere deuna segmentación de video temporal. También pueden beneficiarse a partir de la segmentación devideo espacio-temporal para mejorar la descripción del contenido, la edición del video basado enobjetos y la rápida asignación. Las últimas dos aplicaciones son de visión computacional, donde lasegmentación espacio-temporal ayuda a identificar el flujo óptico en las fronteras (movimiento debordes) y regiones ocluidas, entonces, la restricción común de suavidad podría ser desactivada parapoder obtener una mejor estimación del flujo óptico.


La segmentación de video, consiste en particionar el video en regiones espacio-temporales que sonhomogéneas en sus características espaciales. Como un problema de segmentación, la segmentaciónde video requiere seleccionar características apropiadas (intensidad, color, textura o movimiento) yusar una medida de distancia adecuada que permita comparar estas características seleccionadas. Di-ferentes características y criterios de homogeneidad generalmente conducen a diferentes segmenta-ciones del mismo video. Por otro lado, esto no garantiza que algunos de estos resultados de seg-mentación automática sean significativamente buenos. Métodos específicos de segmentación de videopueden ser considerados en el contexto de los requerimientos de la aplicación para el cual son usados.

Factores que afectan la elección de un método específico de segmentación incluyen:

Ejecución en tiempo real: Si la segmentación debe ser ejecutada en tiempo real, por ejemploen video-conferencias, entonces deben utilizarse algoritmos simples y completamente automáti-cos, o podría implementarse el algoritmo utilizando la arquitectura GPU. Por otro lado, unopuede emplear algoritmos interactivos semiautomáticos para aplicaciones como indexación devideo o codificación de video fuera de línea, para obtener una segmentación significativamentebuena.

Precisión en la segmentación: Si la segmentación es empleada para mejorar la eficienciaen la compresión o control de velocidad, entonces cierta desalineación entre los resultados dela segmentación y los bordes del objeto procesado no es de importancia. Por otro lado, sila segmentación es para la edición de video basado en objetos o emparejamiento de formassimilares, entonces es de mayor importancia que las fronteras estimadas se alineen con lasfronteras del objeto procesado perfectamente, en este caso un simple pixel de error podría noser tolerable.

Complejidad de la escena: La complejidad del contenido del video puede ser modelado entérminos de la cantidad de movimiento de la cámara, uniformidad de textura y color dentrode los objetos, contraste entre los objetos, suavidad en el movimiento de los objetos, existenciao no de objetos entrando y saliendo de la escena. Claramente, escenas complejas requierensofisticados algoritmos de segmentación.

Un problema común en el análisis de secuencias de video, es segmentar el primer plano (Fore-ground) del fondo (Background) en tiempo real, sin embargo, existen diferentes casos que se puedenpresentar al procesar una secuencia de video (ver Tabla 1.1), de los cuales, surgen diversas suposi-ciones acerca de como poder resolver los problemas en aplicaciones especificas. Nuestra investigación,se enfoca principalmente en el problema de sustituir el fondo de una secuencia de video en tiem-po real (ver Figura 1.2), suponiendo que se nos presentan durante toda la secuencia de video loscasos I y IV de la Tabla 1.1, en donde el fondo es estático y el primer plano puede ser móvil o estático.

Durante la segmentación de las secuencias de video, tenemos que considerar los siguientes proble-mas para obtener un método robusto:

Cambios de iluminación en la escena. La iluminación de las imágenes puede variar através del tiempo de forma gradual o brusca. Esta variación puede darse en toda la imagen

1.2. PLANTEAMIENTO DEL PROBLEMA 5

Espacio Caso I Caso II Caso III Caso IVPrimer Plano Móvil Móvil Estático Estático

Fondo Estático Móvil Móvil Estático

Cuadro 1.1: Casos del problema de segmentación del primer plano.

Figura 1.2: Sustitución de Fondo. (a) Imagen original. (b) Imagen modificada

o solo en algunas regiones de la imagen y puede ser causada por diversos factores (el soldesapareciendo de repente detrás de las nubes, lámparas, sensibilidad de la cámara, activaciónde luces artificiales, entre otros).

Sombras. Los objetos que deseamos segmentar, pueden tener sombras, proyectadas en el fondode la escena, esto puede conducir a un error en aplicaciones donde la forma del objeto juega unpapel importante. Por esta razón, muchos algoritmos para identificar y eliminar las sombrashan sido propuestos.

Semejanza del color entre el objeto móvil y el fondo. Cuando aplicamos un modelo,en el que utilizamos las intensidades de las imágenes para tratar de separar lo que es primerplano del fondo, generalmente, en las partes en donde el objeto a segmentar y el fondo tienenuna intensidad similar, la segmentación puede resultar errónea.

Capítulo 2

Marco teórico

Para el observador humano de una secuencia de video es sencillo separar el primer plano delfondo, sin embargo, desde el punto de vista computacional, esto no es sencillo, ya que el ruido deadquisición en la cámara, los cambios de iluminación, las sombras y las regiones en las que el objetotiene el mismo color que el fondo, hacen que este cálculo sea difícil. En las siguientes secciones deeste capítulo, se da una descripción de algunos de los trabajos realizados en el estado del arte acercade la substracción del fondo, se presenta un método basado en Campos Markovianos Aleatorios(MRF por sus siglas en inglés) para la segmentación binaria de imágenes. Posteriormente se describela detección y estimación del movimiento, ya que es una parte fundamental en la segmentación devideo, y finalmente, se da una aproximación para el cálculo del flujo óptico.

2.1. Substracción del Fondo

La técnica de substracción del fondo, consiste en combinar varios cuadros (frames) del video parareconstruir el fondo excluyendo los objetos del primer plano, posteriormente podemos comparar es-ta combinación con los siguientes frames, y de esta manera marcar las diferencias como primer plano.

La substracción del fondo es muy popular en aplicaciones de video-vigilancia, ya que es unatécnica computacionalmente eficiente y las imágenes de las cámaras de vigilancia estática son rela-tivamente fáciles de obtener. Cuando la escena del fondo está disponible, la segmentación se puedeobtener mediante la detección de cambios entre la imagen del fondo y la entrada de imágenes. Paraalgunas aplicaciones, la imagen del fondo puede ser capturada previamente, sin embargo, en otroscasos es poco práctico esperar un momento en el que solamente se muestre el fondo del escenario,por ejemplo, en una carretera con demasiado tráfico.

2.1.1. Trabajo relacionado

El problema de substracción del fondo, se ha venido estudiando para una gran variedad de aplica-ciones, entre las más importantes están la video-vigilancia, las video-conferencias y los diagnósticosmédicos. En estas aplicaciones, el objetivo es comparar una imagen con otra que represente el fondo,

7

8 CAPÍTULO 2. MARCO TEÓRICO

y de esta manera, identificar las regiones en donde ocurren cambios. La mayor parte de los algo-ritmos desarrollados, integran información de contexto, para mejorar la robustez. Las técnicas másdestacadas son los modelos estadísticos, los modelos basados en MRF, o algoritmos que combinanlas diferencias entre la intensidad y textura. A continuación, se describen algunas de las propuestasdel estado del arte clasificadas por el objetivo del método que implementan:

Métodos de segmentación fondo-frente.

En Criminisi y otros [4] 2006, se presenta un algoritmo capaz de separar en tiempo real elprimer plano del fondo en una secuencia de video monocular, el modelo que utilizan para seg-mentar es un Campo Aleatorio Condicional (CRF), basado en derivadas espacio-temporalesy condiciones en cada par de imágenes, evitando el cálculo del flujo óptico (ya que computa-cionalmente es caro), finalmente utilizan el método Graph Cut para segmentar.

En Sooyeong y otros [5] 2008, se propone una sustitución del fondo segmentando el primerplano, con una cámara monocular (ó con una lente) estática. Para segmentar el primer plano,suponen que no está presente el objeto en los primeros frames de la secuencia, lo cual habilitala posibilidad de crear un modelo del fondo, después de terminar este proceso, el objeto entra ala escena. Para la precisión de la segmentación del primer plano, utilizan un modelo de proba-bilidad temporal (TFPM) y para sustituir el fondo, hacen una corrección del color e intensidad,de esta forma obtienen imágenes fotomontadas con un aspecto más realista. El sistema corre a15 f/s (frames por segundo) y fué implementado en C/C++, en una computadora Pentium 4a 3.0GHz con 2G de RAM, las imágenes de 320x240 pixels, fueron adquiridas de una cámaraLogitech QuickCam IM (1.3 megapixels).

Métodos que detectan movimiento.

En Stefano y otros [6] 2005, se propone un algoritmo basado en el filtro de Kalman aplicadopixel a pixel, para actualizar el fondo de una imagen en una secuencia de video. El algoritmoes capaz de enfrentarse a cambios de iluminación graduales o bruscos globales. La idea básicaes medir el cambio de iluminación global y utilizarla como un control externo del filtro. Otrapropuesta que se basa en el filtro de Kalman aplicado pixel a pixel es el de Christof y otros [7]1995.

En Kyungnam y otros [8] 2005, se propone evaluar los valores de cada pixel para cuanti-zarlos en “codebooks”, los cuales representan el modelo del fondo, para una larga secuencia deimágenes con memoria limitada. El método puede funcionar en escenas con movimiento en elfondo y pequeños cambios de iluminación.

2.1. SUBSTRACCIÓN DEL FONDO 9

Métodos para detectar y eliminar sombras.

En Salvador y otros [9] 2001, se propone la utilización de modelos invariantes al color paraidentificar y clasificar las sombras en las imágenes digitales. Primero extraen los pixels queson candidatos a ser sombras, a continuación, utilizando características invariantes al color,clasifican los pixels como sombras que emite un objeto y como sombras propias. Después enel 2004 [10], presentan un algoritmo para detectar cambios de iluminación debido a sombras,en secuencias del mundo real. Primero, utilizan la información del color, basándose en el es-pacio RGB y en características invariantes fotométricas, finalmente, realizan una verificaciónespacio-temporal para refinar los resultados.

En Jianguang y otros [11] 2002, se propone detectar objetos en movimiento utilizando un filtropasa-bajas para obtener un algoritmo robusto a cambios de iluminación y sombras. Primero,construyen un modelo del fondo, después, definen las intensidades del pixel como un productode los componentes de iluminación y reflexión, aplican el filtro pasa-bajas y finalmente, clasi-fican el pixel por medio de un umbral, el cual puede ser seleccionado automáticamente.

En George y otros [12] 2002, se propone un método efectivo para la detección de sombras,mediante la observación de las características de la sombra en los dominios de la luminancia,crominancia, densidad del gradiente y la geometría. Estas observaciones se combinan paraeliminar las sombras que proyectan los objetos que desean segmentar. La aplicación de estemétodo lo centran en las secuencias de tráfico (automóviles).

En Spagnolo y otros [13] 2004, se propone un algoritmo de detección de movimiento, basado enla substracción del fondo y eliminación de sombras. Utilizan la correlación entre la imagen dereferencia y la imagen actual para detectar el primer plano, sin sus propias sombras, además,actualizan el modelo de referencia, con la idea de que las variaciones de intensidad de cadapixel del modelo del fondo, sean estimadas considerando las variaciones de todos los pixels conel mismo valor de intensidad.

En Monteiro y otros [14] 2008, se propone un método de substracción del fondo, para de-tectar incidentes en carreteras. Utilizan tres modelos del fondo, dos de ellos para contemplarlas variaciones del fondo y el tercero, para prevenir el ruido en el modelo, dos umbrales, unopara la adaptación robusta a variaciones del escenario, y el otro para eliminar el ruido enla cámara. También utilizan una actualización del fondo y eliminan las sombras mediante lacorrelación cruzada del modelo del fondo y la imagen actual, transformando los colores delpixel a un espacio HSL (Hue, Saturation, Lightness). Este sistema puede segmentar vehículosen imágenes de 320x240 pixels a 9 f/s en un procesador Intel Pentium 4 a 3.2 GHz. bajo elsistema operativo Linux.


Métodos usando hardware.

En Andreas [15] 2005, se propone un algoritmo de segmentación del primer plano del fon-do utilizando la arquitectura GPU (Graphic Processing Unit), basándose en un criterio desimilitud del color, en una pequeña vecindad del pixel entre la imagen de referencia (fondo) yla imagen nueva, combinado con un modelo basado en MRF y de algunas reglas de decisiónpara el refinamiento. Para la implementación, utilizó OpenGL NV30, una tarjeta NVIDIAGeForce 6800GT con 256 MB, lenguaje Cg (C para gráficos). El sistema procesa imágenes de640x480 pixels y el tiempo de procesamiento es de 4 ms por imagen.

En FUKUI y otros [16] 2008, se propone un algoritmo basado en GPU (Graphic ProcessingUnit), para extraer en tiempo real, objetos en movimiento. Es robusto a cambios de iluminacióny utilizan el espacio de color CIELAB para eliminar las sombras. Aplican la substracción delfondo, generando una imagen del fondo y comparándola con la imagen actual. Para la imple-mentación utilizan una computadora Core2 Duo E6600, con 1G de RAM, una tarjeta GeForce8800GTX, DirectX 9.0c, HLSL, bajo un sistema operativo Windows XP. El tiempo total querequiere el método en procesar una imagen de 1440x1080, es de 0.32 ms, aclarando que estetiempo es sin considerar el tiempo de transferencia de los datos de CPU a GPU. Como trabajoa futuro, proponen una actualización automática del fondo.

2.2. Método QMPF para la segmentación binaria de imágenes

Los métodos basados en MRFs, han llegado a ser populares para el diseño de algoritmos desegmentación, debido a la flexibilidad de adaptarse a diferentes características de la imagen como:color, componentes conectados, movimiento, disparidad estéreo, entre otros [17, 18, 19]. Los MRFspermiten asignar una etiqueta (designación significativa) a un pixel llevando el problema a unafunción de energía, que incluye información de contexto para cada pixel y de este modo promuevesegmentaciones suaves. Frecuentemente el problema de segmentación es expresada en términos deun problema de optimización combinatorio, por este camino técnicas basadas en el método GraphCut [20,17,21] y métodos espectrales [22,23] son de los algoritmos más exitosos.

A continuación se presenta el método de Campos Markovianos de Probabilidad Cuadráticos(QMPF por sus siglas en inglés) para la segmentación binaria de imágenes [1], basado en MRF, eneste contexto la idea principal es calcular la probabilidad de un pixel dado un modelo generativoparticular, esta propuesta transforma un problema de optimización combinatorio en un problemade optimización de variables reales, basado en minimizar una función de energía cuadrática, el cualcorresponde a resolver un sistema lineal de ecuaciones con algoritmos iterativos como Gauss-Seidel(GS) o Gradiente Conjugado (GC) [24].

Asumiendo que la imagen g es generada con el modelo:

g(x) = α(x)I1(x) +(1− α(x)

)I2(x), (2.1)

2.2. MÉTODO QMPF PARA LA SEGMENTACIÓN BINARIA DE IMÁGENES 11

donde x ∈ R ⊆ L denota un pixel en la región R dentro de la malla regular L; I1 e I2 son dosimágenes de composición, α se denomina matting factor. Podemos generalizar el modelo (2.1) parael caso de multiples regiones de la siguiente manera:

g(x) =∑k

αk(x) ∗ (Ik(x) + nk(x)) (2.2)

donde k = 1, 2, 3...K, ηk es una imagen de ruido con distribución conocida y las αk satisfacen:

K∑k=1

αk(x) = 1, x ∈ R (2.3)

αk(x) ≥ 0, k = 1, · · · ,K (2.4)

αi(x)αj(x) ≈ 0, si i 6= j (2.5)

α(x) ≈ α(y), y ∈ Nx (2.6)

donde Nx denota el conjunto de vecinos de x : Nx = {y ∈ R : |x− y| = 1}. Note que, debidoa (2.3) y (2.4), α puede ser interpretado como un campo de probabilidad donde αk(x) se entiendecomo la probabilidad de producir la observación g(x) usando la imagen Ik(x). Adicionalmente laecuación (2.5) introduce la restricción en el vector de probabilidad α(x) para tener baja entropía.Juntando las ecuaciones (2.3) y (2.4) y la restricción (2.5) nos indican que solamente una entradadel vector α(x) tiene un valor cercano a uno mientras los otros tienen valores cercanos a cero. Larestricción (2.6) promueve suavidad espacial sobre el campo de probabilidad α.

La segmentación de la imagen compuesta, g, puede observarse como la solución de un problemainverso mal planteado en (2.2) sujeto a las restricciones fuertes (2.3) y (2.4) y a las restriccionessuaves (2.5) y (2.6). Dicho problema inverso puede entenderse como calcular los matting factors αky las imágenes originales Ik, o al menos las imágenes parciales αkIk a partir de la imagen observada g.

En el marco de Regularización Bayesiana (BR por sus siglas en inglés), uno calcula la solu-ción (α∗, I∗) como un estimador de la distribución a posteriori P (α, I|g). Entonces usando la reglade Bayes tenemos:

P (α, I|g) =1ZP (g|α, I)P (α, I), (2.7)

donde P (g|α, I) es la probabilidad condicional de los datos dados (α, I), P (α, I) es la distribu-ción a priori y Z = P (g) es una constante de normalización (independiente de (α, I)). Entonces, laprobabilidad condicional P (g|α, I) la podemos derivar a partir de la distribución del ruido y de laecuación (2.2).

En general, la inferencia de las imágenes Ik a partir de g es un problema inverso complica-do: aún si α es dada, sólo se podrían recuperar las fracciones αkIk de las imágenes completas. Porlo tanto, es importante realizar ciertas suposiciones, como considerar que tales imágenes puedenser representadas por una función paramétrica Ik(x) = Φ(x, β), con parámetros β. Para simplificarla notación, el desarrollo a continuación se hará en términos de I en lugar de los parámetros β.


Otra forma popular de introducir conocimiento a priori de alto nivel para segmentar imágenes conescenarios complicados es la interacción con el usuario. Bajo ese esquema el usuario etiqueta a manounos subconjuntos de pixels, para posteriormente etiquetar los restantes con un algoritmo de seg-mentación que toma en cuenta la distribución de los pixels etiquetados y la suavidad de las regionesa segmentar. Para obtener P (g|α, I) se asume que ηk es ruido Gaussiano i.i.d. (independiente eidénticamente distribuido) con media cero y varianza σ2

k, i.e.:

P (ηk(x)) = Gσk(ηk(x)) (2.8)

donde Gσ(z)def= 1√

2πσexp

[− z2

2σ2

]. A partir de (2.2) se tiene αk(x)ηk(x) = αk(x)(g(x) − Ik(x)).

Como αk es casi binaria [por (2.6)], entonces para αk(x) ≈ 1 uno puede esperar una distribuciónsimilar tanto de αk(x)ηk(x) y ηk(x). Por lo tanto, definiendo rk(x) = g(x) − Ik(x) y por identidadde exponentes se tiene que:

P (αkg|αkIk, σ2k) =

∏x

Gσk(αk(x)rk(x))

=∏x

Gσk(rk(x))α

2k(x). (2.9)

Ahora, removiendo la suposición de ruido Gaussiano, primero se debe considerar que cualquierdistribución de densidad suave vk puede ser expresada como un mezcla de Gaussianas:

vk(x, θk) =M∑i=1

πkiGσk(rk(x)−mki) (2.10)

con θ = (σk, πk,mk); donde πki ≥ 0 son los coeficientes de la mezcla (con∑i πki = 1), M es el

número de Gaussianas de la mezcla, mk = (mk1,mk2, · · · ,mkM ) son las medias de las Gaussianasy σk son sus varianzas. Se asume que los parámetros de la mezcla son conocidos, i.e. se asume ladistribución de ruido conocida. Entonces en límite de baja entropía se puede aproximar por:

P (αkg|αkIk, θk) =∏x

[M∑i=1

πkiGσ(rk(x)−mki)α2k(x)

](2.11)

≈∏x

[M∑i=1

πkiGσ(rk(x)−mki)

]α2k(x)

=∏x

vk(x, θk)α2k(x) (2.12)

Si se asume independencia entre αiIi y αjIj (para i 6= j), entonces la verosimilitud de la imagencompuesta g está dada por

P (g|α, I, θ) =∏k

P (αkg|αkIk, θk) (2.13)

En particular, tal independencia ocurre si se satisface (2.5).

2.2. MÉTODO QMPF PARA LA SEGMENTACIÓN BINARIA DE IMÁGENES 13

Para imponer un control de la entropía, se propone usar el potencial de Gini µ(1 −∑k α

2k(x))

(con µ > 0 se promueve baja entropía y con µ < 0 alta entropía [25]). Además una distribución Gibb-siana basada en modelos MRF, controla la granularidad de las regiones (i.e. para promover regionessuaves). Al asumir independencia entre I y α se puede usar P (α, I) ∝ P (α) como proba-bilidad apriori y una distribución uniforme en I. Finalmente se obtiene la distribución a priori como:

P (α) =1Z ′

exp

∑x∈R

µ(1− ‖α(x)‖2)− λ

∑y∈Nx

‖α(x)− α(y)‖2 (2.14)

donde Z ′ es una constante de normalización y λ es un parámetro positivo que controla la suavi-dad. Entonces la distriución a posteriori toma la forma P (α, θ|g) ∝ exp [−U(α, θ)] y el estimadorMAP(Maximum A Posteriori) se calcula minimizando la función de costo:

U(α, θ) =∑x∈R

K∑k=1

α2k(x) [− log vk(x, θ)− µ] +

λ

2

∑y∈Nx

|α(x)− α(y)|2 (2.15)

sujeto a las restricciones (2.3) y (2.4). Este problema se puede resolver con cualquier estrategia deoptimización con restricciones para problemas cuadráticos (programación cuadrática).

Ahora, para el caso particular de Segmentación Binaria de Imágenes (IBS, por sus siglas eninglés), podemos usar una estrategia de eliminación de variables (α1 = 1− α2) y el problema puedeser formulado como la minimización de la función de costo cuadrática:

Q(α) =∑x∈R

{α2(x)[d1(x)− µ] + [1− α(x)]2[d2(x)− µ] + λ

∑y∈Nx

(α(x)− α(y)

)2} (2.16)

donde dk(x)def= −logvk(x, θk), vk(x, θk) = vk(x,θk)

s(x,θ) y s(x, θ) def=∑k vk(x, θk), para k = 1, 2. Sujeta a

la restricción de no-negatividad (2.4). Ahora, si el valor de µ es elegido tal que (2.16) sea convexa,entonces el mínimo no restringido de (2.16) satisface automáticamente la restricción de nonegativi-dad [26].

Podemos reemplazar el término de regularización espacial en (2.16) por:

λ∑y∈Nx

(α(x)− α(y)

)2Wxy, (2.17)

dondeWxy =

γ

γ + ‖g(x)− g(y)‖2(2.18)

es una medida de afinidad que toma valores cercanos a 1 si los pixels vecinos x y y tienen coloressimilares y cercanos a 0 en caso contrario, en la literatura comúnmente son reportados como pesosque dependen de la magnitud del gradiente, γ es el parámetro que controla la sensibilidad paradetectar los bordes.


La formulación del problema IBS, como una minimización de una función de energía cuadráti-ca definida positiva sin restricciones, tiene la ventaja de haber conseguido algoritmos computa-cionalmente eficientes (GC o una implementación Gauss-Seidel multigrid). Aunque una inicializacióncualquiera no determine la convergencia al mínimo global, con un buen punto inicial se puede acelerarla velocidad de convergencia.

2.3. Detección y estimación del movimiento

Las secuencias de video son una fuente rica para la visualización de información, esto se debe ala captura de movimiento, mientras en una simple imagen se captura una escena, en una secuenciade imágenes se registra el movimiento de dicha escena. El movimiento es importante para el proce-samiento de video y la compresión por dos razones. Primero, el movimiento contiene informaciónsobre la relación espacio-temporal de los objetos en la imagen. Esta información puede ser utiliza-da en aplicaciones como monitoreo de tráfico, vigilancia y seguridad, por ejemplo para identificarobjetos entrando y/o saliendo de la escena u objetos que simplemente se movieron. Segundo, laspropiedades de la imagen, tales como intensidad o color, tienen una muy alta correlación en la di-rección del movimiento, por ejemplo, el color de un auto no cambia como el movimiento del auto através de la imagen, esto puede ser usado para remover la redundancia temporal del video, en unasituación ideal solamente se necesitan la primera imagen y el movimiento subsiguiente para la trans-misión del video. El movimiento puede ser utilizado también por filtros temporales, en este caso,filtros temporales en una dimensión a lo largo de una trayectoria de movimiento, pueden reducir elruido o realizar una interpolación temporal sin afectar el detalle espacial en la imagen.

Las aplicaciones antes descritas requieren que los puntos en la imagen sean identificados co-mo móvil o estático, o la medida de su movimiento. La primera tarea es frecuentemente conocidacomo detección del movimiento mientras a la segunda se le denomina estimación del movimiento.

2.3.1. Detección del movimiento

La detección del movimiento, es indiscutiblemente, la más simple de las tres tareas en relación almovimiento (detección, estimación y segmentación). La idea principal es identificar cuales puntos enla imagen, o más general, cuales regiones de la imagen se han movido entre dos instantes de tiempo.Se aplica solo a imágenes adquiridas con una cámara estática, sin embargo, si el movimiento de lacámara se puede contrarrestar, por ejemplo por estimación del movimiento global y compensación(aplicando los movimientos estimados para reconstruir la imagen), entonces, el método igualmentese aplica para imágenes adquiridas de una cámara en movimiento.

En esencia, la obtención del movimiento de los puntos en la imagen, se realiza a través delos cambios de intensidad, sin embargo, tales cambios de intensidad a lo largo del tiempo, puedenser también inducidos por ruido en la cámara o cambios de iluminación, claramente, la detección demovimiento basado en imágenes que varían en el tiempo no es una tarea sencilla.

2.3. DETECCIÓN Y ESTIMACIÓN DEL MOVIMIENTO 15

2.3.2. Estimación del movimiento

Para desarrollar un algoritmo de estimación de movimiento, es necesario considerar tres elemen-tos importantes: modelos, criterio de estimación y estrategias de búsqueda. Aunque no se considerancomo un esquema universal, se han utilizado en diversas propuestas.

Existen esencialmente dos modelos en la estimación del movimiento:

Modelo del movimiento. Como se representa el movimiento en una secuencia de imágenes.

Modelo de observación. Relacionado con los parámetros del movimiento a partir de las inten-sidades de la imagen.

2.3.2.1. Modelos de movimiento espacial

El objetivo es estimar el movimiento de los puntos de la imagen, tal movimiento es una combi-nación de proyecciones del movimiento de los objetos en una escena 3D y el movimiento de la cámara.Mientras que el movimiento de la cámara afecta todos los puntos de la imagen, el movimiento 3Dde los objetos solo afectan un subconjunto de puntos de la imagen correspondientes a la proyecciónde dichos objetos. En principio, el movimiento inducido por la cámara puede ser compensado porestimación del movimiento global, entonces solo faltaría el modelo de movimiento inducido por elobjeto, tal movimiento depende de:

1. El modelo de la formación de la imagen, por ejemplo, perspectiva o proyección ortográfica.

2. El modelo del movimiento del objeto 3D, por ejemplo, un cuerpo rígido con traslación y rotación3D o movimiento affine 3D.

3. El modelo de la superficie del objeto 3D, por ejemplo, planar o parabólico.

Para una proyección ortográfica y una superficie arbitraria 3D bajo una traslación 3D, el resultadode la velocidad instantánea 2D de la posición x, en el plano de la imagen, puede ser descrito por

v(x) =

(b1

b2

), (2.19)

donde, los parámetros b = (b1, b2)T = (v1, v2)T dependen de la geometría de la cámara y los paráme-tros de traslación 3D. Este modelo ha sido muy poderoso en la práctica, especialmente en compresiónde video. Un segundo modelo podría ser la proyección ortográfica combinada con el movimiento affine3D de una superficie plana, de esta forma tenemos que

v(x) =

(b1

b2

)+

(b3 b4

b5 b6

)x, (2.20)

donde, b = (b1,...,b6)T es un vector de parámetros. Este es un caso especial del modelo affine. Muchosmodelos complejos se han reportado en el estado del arte, pero dependiendo de la aplicación, nosiempre mejoran la estimación del campo de movimiento. En general, a mayor número de parámetros


para el movimiento, mayor es la precisión del campo de movimiento, si embargo, un excesivo númerode parámetros podría decrementar el desempeño. Esto va a depender del número de grados delibertad (complejidad del modelo) y el tamaño de la región de soporte. Un modelo complejo, aplicadoa una región de soporte pequeña, puede conducir a un incremento en el error de estimación.

2.3.2.2. Modelos de movimiento temporal

En el caso más simple, las trayectorias de los puntos de una imagen en el espacio (x, t) (conx = (x1, x2)), son lineales. Asumiendo que la velocidad vt(x) es constante entre t = tk − 1 yτ(τ > t), entonces podemos expresar una trayectoria lineal de la siguiente manera:

x(τ) = x(t) + vt(x)(τ − t) = x(t) + dt,τ (x), (2.21)

donde, dt,τ (x) = vt(x)(τ−t) es un vector de desplazamiento en dirección positiva del tiempo (desde ta τ). Por lo tanto, para un movimiento lineal, la tarea es encontrar las dos componentes de velocidadv o desplazamiento d para cada x. Una extensión del modelo lineal es un modelo de trayectoriacuadrático, el cual puede ser descrito por

x(τ) = x(t) + vt(x)(τ − t) +12at(x)(τ − t)2, (2.22)

este modelo contiene dos variables de velocidad (lineales) y dos variables de aceleración (cuadráticos)a = (ax, ay)T .

Estos modelos, requieren dos parámetros en la ecuación (2.21) o cuatro en la ecuación (2.22)para cada posición x, entonces, para reducir la carga computacional, modelos de movimiento espa-cial, pueden ser combinados con los modelos temporales, por ejemplo, el modelo affine de la ecuación(2.20) puede ser utilizado para sustituir la velocidad vt en la ecuación (2.21) y de esta forma, seaplica el modelo en una región de soporte adecuada.

2.3.2.3. Región de soporte

Al conjunto de puntos x, en el cual se aplica un modelo de movimiento espacial y temporal, sele denomina “región de soporte”, denotado por R. La selección de un modelo de movimiento y laregión de soporte es uno de los principales factores que determinan la precisión de la estimación delmovimiento. Usualmente, para un modelo de movimiento dado, la más pequeña región de soporteR, proporciona una mejor aproximación del movimiento. Típicamente, la región de soporte para unmodelo de movimiento es uno de los cuatro tipos que se muestran en la Figura 2.1 [27].

1. Imagen Completa. Aquí, el modelo de movimiento se aplica a todos los puntos de la imagen.Este modelo es apropiado para la estimación del movimiento inducido por la cámara, es de losmodelos más restringidos (muy pocos campos de movimiento pueden ser representados) peroque tienen pocos parámetros para estimar el movimiento.

2. Pixel. El modelo se aplica a un simple punto de la imagen (posición x). Típicamente se utilizael modelo espacial (2.19) con alguno de los modelos temporales (2.21) o (2.22). Un número muy

2.3. DETECCIÓN Y ESTIMACIÓN DEL MOVIMIENTO 17

Figura 2.1: Regiones de soporteR (a) Imagen completa. (b) Pixel. (c) Bloque de pixels. (d) Regiones.(Crédito: [27])

alto de campos de movimiento pueden ser representados por todas las posibles combinacionesde los valores de los parámetros, pero la complejidad computacional es, en general, alta.

3. Bloque de pixels. El modelo se aplica a un bloque rectangular o cuadrado de puntos dela imagen. En el caso más simple, los bloques no están traslapados y su union cubre toda laimagen. Un movimiento espacial 2.19 y temporal 2.21 de un bloque rectangular de pixels, hademostrado ser un modelo muy poderoso y es utilizado hoy en día en todos los estándares decompresión de video digital (por ejemplo, H.261,H.263,H.264,MPEG-1 y MPEG-2).

4. Regiones. El modelo se aplica a todos los pixels en una región (de forma irregular) R. Es delos modelos más avanzados que se han encontrado, por ejemplo, un bloque cuadrado divididoen partes de formas arbitrarias, cada una con movimiento independiente, es utilizado en elestándar MPEG-4.

2.3.2.4. Modelos de observación

Se basan en las variaciones de intensidad y/o color para la estimación del movimiento. La relaciónentre los parámetros del movimiento y las intensidades de la imagen juegan un papel muy impor-tante. Lo usual es asumir que las intensidades de la imagen permanecen constantes a lo largo dela trayectoria de movimiento, es decir, que los objetos no cambian su luminosidad y color cuandose mueven. Para una muestra temporal de imágenes, esto significa que Itk(x(tk)) = Itk−1(x(tk−1)).Usando la relación (2.21), con t = tk−1 y τ = tk y asumiendo una muestra espacial de imágenes, lacondición puede ser expresada de la siguiente manera:

Ik[x] = Ik−1[x− ρ]. (2.23)

Sin embargo, la ecuación (2.23) no puede ser usada directamente para calcular ρ, debido al ruido q,distorsión, etc., que se presentan en la imagen, esto es: Ik[x] = Ik−1[x − ρ] + q[x], por lo tanto, ρdebe ser calculada minimizando una función de error entre Ik[x] y Ik−1[x− ρ].


2.3.2.5. Criterio de estimación

Los modelos del movimiento, necesitan estar dentro de un criterio de estimación, el cual seráoptimizado. No existe un criterio único para la estimación del movimiento, depende del problemaque queremos resolver. Muchos de los criterios surgen a partir de la suposición de la intensidadconstante (2.23), minimizando una función (por ejemplo, el valor absoluto) del error de predicción:

εk[x] = Ik[x]− Ik[x],∀xεL (2.24)

donde Ik[x] = Ik−1[x − ρ[x]], en general ρ es un valor real, entonces las intensidades en la posiciónx− ρ que estén fuera de la malla L, deben ser recuperados por alguna adecuada interpolación.

2.3.2.6. Estrategias de búsqueda

Ya que se ha definido el modelo que resume el conocimiento que se tiene del movimiento y dela imagen y que se ha elegido un criterio de estimación, el último paso, es definir un procedimientopara seleccionar de entre el espacio de todos los movimientos posibles, definidos por el modelo, aquelque optimiza el criterio elegido.

Para un pequeño número de parámetros del movimiento, la estrategia más común es el matching,en esta propuesta, las predicciones Ik[x] = Ik−1[x − ρ[x]] para varios candidatos del movimiento ρ,son comparados (matched) con la imagen original Ik(x), dentro de la región de soporte del modelode movimiento (pixel, bloque, etc.), por último, se elige al candidato que optimiza el criterio deestimación. En contraposición al matching, técnicas basadas en el gradiente, requieren de un criteriode estimación ε que es diferenciable, ya que este criterio depende de los parámetros del movimientoque se evalúan dentro de la función de la imagen, por ejemplo, en Ik−1[x− ρ[x]]. Para prevenir unaoptimización no lineal, I es comúnmente linealizada usando la expansión de Taylor con respecto aρ[x]. La deficiencia al utilizar la expansión de Taylor, es que el modelo debe aplicarse a regionesdonde el movimiento sea pequeño, sin embargo, esta deficiencia se podría compensar utilizando unaimplementación MultiGrid (MGrid).

2.4. Flujo Óptico

El flujo óptico, es el patrón de movimiento aparente de los objetos, superficies y bordes en unaescena visual, causada por el movimiento relativo entre un observador (un ojo o una cámara) y laescena. Dicho movimiento es utilizado en técnicas como: detección de movimiento, segmentación delobjeto, medición de disparidad estéreo, entre otros.

El movimiento bidimensional en una imagen es la proyección del movimiento tridimensionalde los objetos, en relación al obervador en el plano de la imagen. Secuencias ordenadas de imágenespermiten la estimación del movimiento bidimensional como velocidades instantaneas o desplazamien-tos discretos, éstos suelen ser llamados campo de flujo óptico o campo de velocidades de la imagen.

Basándonos en el articulo de Lucas-Kanade [28], en la parte de generalización a múltiples dimen-

2.4. FLUJO ÓPTICO 19

siones proponen minimizar la ecuación (2.25), consideran que el vector de movimiento es constanteen la región de interés R y se puede calcular mediante mínimos cuadrados:

E =∑x∈R

[F (x+ h)−G(x)]2 , (2.25)

donde F y G son dos imágenes, x y h son dos vectores n-dimensionales. Lo que se quiere es calcularel vector de disparidad h, el cual minimiza la medida de error entre F (x + h) y G(x) para x enalguna región de interés R.

Utilizando la siguiente aproximación lineal:

F (x+ h) ≈ F (x) + hT∇F, (2.26)

donde ∇F =(∂F∂x

)Tes el operador gradiente con respecto a x, minimizamos E de la siguiente

manera:

∂

∂hE ≈ ∂

∂h

∑x

[F (x) + hT∇F −G(x)

]2=

∑x

2∇F[F (x) + hT∇F −G(x)

]= 0,

finalmente se tiene que

h ≈

[∑x

(∇F )T [G(x)− F (x)]

][∑x

(∇F )T (∇F )

]−1

, (2.27)

para el caso de dos dimensiones se requiere acumular la suma de cinco productos ((G − F )Fx,(G− F )Fy, F 2

x , F2y y FxFy) sobre la región R y resolver el sistema de ecuaciones Aν = b (2.28).

( ∑x∈R F

2x (x)

∑x∈R Fx(x)Fy(x)∑

x∈R Fx(x)Fy(x)∑x∈R F

2y (x)

)ν =

( ∑x∈R(G(x)− F (x))Fx(x)∑x∈R(G(x)− F (x))Fy(x)

)(2.28)

Capítulo 3

Propuesta

Para la segmentación de secuencias de video, es importante obtener primeramente un buenmodelo del fondo, lo cual permita tener un método que distinga lo que es primer plano y fondo.Pensando en aplicaciones en donde se tiene conocimiento del fondo, como también lo hacen en [5],[15], entre otros, la idea principal de nuestra propuesta se muestra en la Figura (3.1), consiste entomar la primera secuencia de imágenes desde la WebCam solamente del fondo estático (para obtenerun modelo del fondo), después leemos las siguientes imágenes suponiendo que ya hay movimientoen la escena, entonces mediante una relación de verosimilitud tratamos de separar el primer planodel fondo, después aplicamos el método de segmentación QMPF (para obtener una buena solución)y por último cambiamos el fondo. Sin embargo, con este enfoque se tienen algunas deficienciaspara segmentar el fondo en una secuencia de video. Los problemas que en nuestros experimentosobservamos son:

1. Cambios de iluminación en la escena.

2. Sombras en la escena que pueden ser clasificadas como primer plano.

3. Semejanza del color entre el fondo y lo que se está moviendo, lo cual afecta la calidad de ladetección fondo/objeto.

Para el problema del cambio de iluminación en la escena proponemos una “Modificación de laIntensidad” (MI), para el problema de sombras una “Detección de Sombras” (DS) y para el problemade semejanza del color una “Corrección de Semejanza del Color” (CSC), obteniendo de esta forma,un método robusto para la segmentación de secuencias de video. En las siguientes secciones de estecapítulo, se explica cada una de estas partes principales de la propuesta.

3.1. Verosimilitud de pertenecer al fondo

Con la primera secuencia de N imágenes (10 para nuestros experimentos), en donde solo se cap-tura el fondo estático, generamos un modelo del fondo, de esta forma, podemos comparar cada unade las siguientes imágenes de la secuencia de video con el modelo del fondo, y etiquetar las diferenciasgrandes como primer plano.

21

22 CAPÍTULO 3. PROPUESTA

Figura 3.1: Diagrama a bloque de la Propuesta. (a) WebCam. (b) Tomamos N imágenes y calculamosµ(x). (c) Leemos la siguiente imagen IS(x). (d) Calculamos la verosimilitud de ser fondo VB(x). (e)Segmentamos con QMPF y sustituimos el fondo.

Para medir estas diferencias, primeramente probamos con una distribución gaussiana (3.1), cal-culando la media µ(x) y la varianza σ(x) para cada pixel. Sin embargo, observamos que la estimaciónde la varianza no es robusta, esto se debe a que la secuencia de imágenes es adquirida de un forma-to MPEG-4 (comprimido), provocando que la distribución de los valores del pixel se vea afectada,este problema lo presentan también en el articulo de Kyungnam y otros [8]. Después, probamoscon la correlación normalizada (3.2), observamos que el error en la parte del fondo disminuye encomparación con los resultados de la distribución gaussiana, sin embargo, en la parte del primerplano aumenta. Finalmente probamos con la distribución exponencial (3.3), aquí nos dimos cuentaque aplicando un umbral (0.99 para nuestros experimentos) al resultado de la distribución exponen-cial, se logra separar de una mejor manera el primer plano del fondo (ver Figura 3.2). Además alutilizar la distribución exponencial evitamos el cálculo de la varianza σ(x) o de los promedios µ1

y µ2, reduciendo el costo computacional. Por esta razón, elegimos la distribución exponencial paradeterminar cuáles pixels son más probables a ser fondo (verosimilitud de pertenecer al fondo), laexpresión matemática de las distribuciones probadas son:

VB(x) =1√

2πσ(x)exp

(− 1

2σ2(x)

∥∥IS(x)− µ(x)∥∥2)

(3.1)

VB(x) =

∑w∈W

((IS(x+ w)− µ1) (µ(x+ w)− µ2)

)√∑

w∈W

((IS(x+ w)− µ1)2

)∑w∈W

((µ(x+ w)− µ2)2

) , (3.2)

donde µ1 y µ2 son los promedios de los pixels en la ventana W de las imágenes IS(x) y µ(x),respectivamente.

VB(x) = exp(−∥∥IS(x)− µ(x)

∥∥2)

(3.3)

3.2. SEGMENTACIÓN CON EL MÉTODO QMPF Y SUSTITUCIÓN DEL FONDO 23

Figura 3.2: Verosimilitud de pertenecer fondo. (a) Distribución Gaussiana. (b) Correlación norma-lizada. (c) Distribución exponencial.

3.2. Segmentación con el método QMPF y sustitución del fon-do

Siguiendo el método de segmentación QMPF, podemos tener el siguiente funcional:

U(P (x)

)=

12

∑x

(P 2(x)dF (x) + [1− P (x)]2dB(x) + λ

∑<x,y>

([P (x)− P (y)]2Wγ(x, y)

))(3.4)

donde:dF (x) = − log[1− VB(x)],dB(x) = − log[VB(x)],Wγ(x, y) = γ

γ+∥∥IS(x)−IS(y)

∥∥2 ,

con VB(x) normalizada [0,1] y definida en (3.2).

Derivando el funcional U(P (x)

)con respecto a P (x) e igualando a cero obtenemos la ecuación

(3.5) que es la probabilidad de ser primer plano, esta ecuación la podemos resolver por el métodode Gauss-Seidel, el cual nos permite obtener una mejor solución en cada iteración y converge rápi-damente si iniciamos con una buena aproximación, en nuestro caso podemos iniciar con P 0(x) =1− VB(x), donde VB(x) es la verosimilitud pertenecer al fondo.

P (x) =dB(x) + λ

∑<x,y>

(P (y)Wγ(x, y)

)dF (x) + dB(x) + λ

∑<x,y>Wγ(x, y)

(3.5)

Note que dado que VB , 1 − VB > 0, la energía resultante es convexa y la iteración de (3.5) con-verge al mínimo global no-negativo.

Utilizamos el método QMPF con MGrid, ya que sin la estructura piramidal necesitaríamos in-crementar el número de iteraciones, provocando lentitud en el método. Como se observa en la Figura


Figura 3.3: Método QMPF con y sin MGrid. (a) MGrid (10 iter/nivel), Sin MGrid(20 iter). (b)MGrid (10 iter/nivel), Sin MGrid (100 iter).

3.3, se obtiene mejor resultado con MGrid, aclararando que las iteraciones del método con MGridson para cada nivel de la pirámide, de esta forma con 20 iteraciones del método sin MGrid tenemosla misma velocidad que con 10 iteraciones por nivel del MGrid, sin embargo, observamos que senecesitan 100 iteraciones del método sin MGrid para alcanzar una solución similar a la del métodocon MGrid (10 iteraciones por nivel), por lo tanto, el método con MGrid es 5 veces más rápido queel método sin MGrid.

Con la solución P (x) de la segmentación QMPF con MGrid, ahora podemos cambiar el fon-do de la imagen IS(x) por el nuevo fondo FN(x) de la siguiente forma:

1. Si P (x) > Umbral entoncesISEG(x) = IS(x)

2. De lo contrarioISEG(x) = FN(x)

donde, Umbral = 0,5 con P (x) normalizada [0, 1].

3.3. Modificación de la intensidad (MI)

Pueden existir diversos factores que provoquen un cambio de iluminación en la escena, por ejem-plo las lámparas, si tenemos ventanas y una nube está pasando, o en particular cuando nos acercamosa la WebCam. En los experimentos que realizamos, observamos que se obtiene una segmentacióncorrecta para las primeras imágenes, pero en el transcurso del tiempo van surgiendo cambios deiluminación, los cuales provocan que la nueva imagen sea muy diferente al modelo que tenemos delfondo, teniendo como resultado malas segmentaciones. Por tal motivo incluimos una corrección deiluminación basándonos en el articulo de Spagnolo [13], en donde implementan un método robusto,para segmentar objetos en movimiento utilizando un proceso de actualización del fondo, la dife-rencia es que en nuestro método no actualizamos el fondo, lo que hacemos es actualizar la imagenactual, con esto prevenimos errores con imágenes mal adquiridas por la WebCam, en la Figura (3.4)mostramos algunas de estas imágenes.

3.3. MODIFICACIÓN DE LA INTENSIDAD (MI) 25

Figura 3.4: Imágenes mal adquiridas por la WebCam

Considerando que en las primeras imágenes, la segmentación resulta ser buena, entonces po-dríamos hacer lo siguiente:

1. Sean µ(x) la imagen promedio de las N imágenes de entrada del fondo estático, IS(x) elframe actual y P t−1(x) la probabilidad de pertenecer al primer plano del frame anterior;calculamos la división Div(x) = µ(x)/IS(x) (o ganancia fotométrica) restringida al área endonde P t−1(x) < Umbral (donde estamos seguros que es fondo).

2. Calculamos el promedio en los tres canales R, G y B con:

µ(bi) =1

N(bi)

∑x∈IS |IS(x)=bi

Div(x) (3.6)

donde, {bi}i=1...n son los n valores de intensidad que puede tomar un pixel.

3. Ahora aplicamosIS(x) = βIS(x)µ(IS(x)) + (1− β)IS(x), (3.7)

donde β es un parámetro libre (0.75 para nuestros experimentos).

4. Finalmente calculamos la verosimilitud de pertenecer al fondo con (3.2), esta salida la podemosconectar directamente al proceso de segmentación sin pasar por los procesos de Detección deSombras y Corrección de Semejanza del Color explicados mas adelante.

En la Figura (3.5), podemos observar que se obtiene un mejor resultado de la verosimilitud depertenecer al fondo VB(x) con la modificación de la intensidad, bajo un cambio de iluminación enla escena.


Figura 3.5: VB(x) bajo un cambio de iluminación en la escena. (a) IS(x)t−1. (b) IS(x)t. (c) VB(x)sin MI. (d) VB(x) con MI.

3.4. Detección de sombras (DS)

Cuando en la escena aparecen sombras, estas pueden ocasionar errores en la segmentación. Di-versos artículos en el estado del arte se han enfocado en resolver este problema, comúnmente lo quese hace es cambiar del espacio de color RGB a otro, en donde se pueda separar la Luminancia yla Crominancia, y de esta forma aplicar una serie de umbrales que clasifiquen al pixel como fondo,objeto o sombra. Basándonos en el artículo de George y otros [12], donde el objetivo es detectarsombras asociadas al objeto que esta en movimiento, proponemos lo siguiente:

1. Después de calcular la verosimilitud de ser fondo VB(x), podemos utilizar esta aproximacióncomo máscara, para calcular las verosimilitudes en luminancia, crominancia y magnitud delGradiente suavizado (VL(x),VC(x) y VG(x) respectivamente) en la región marcada como primerplano. La diferencia es que en nuestra propuesta no utilizamos umbrales para el cálculo de cadauna de las verosimilitudes como lo hacen en George [12], en su lugar, utilizamos la distribuciónexponencial (3.2) como se muestra en las siguientes relaciones:

VL(x) = exp(−∥∥IS(x)− µ(x)

∥∥2), (3.8)

VC(x) = exp(−(∣∣IC1

S (x)− µC1(x)∣∣+∣∣IC2S (x)− µC2(x)

∣∣+∣∣IC3S (x)− µC3(x)

∣∣)) , (3.9)

VG(x) = exp(−∥∥IGS (x)− µG(x)

∥∥2), (3.10)

donde ICS (x) y µC(x), son las imágenes IS(x) y µ(x) convertidas del espacio de color RGB ac1c2c3 (en [9] eligen este modelo de entre los espacios “RGB normalizado”, “HS (Hue, Satura-tion)” y “l1l2l3”) mediante las siguientes ecuaciones

c1 = arctan( R

max(G,B)

),

c2 = arctan( G

max(R,B)

),

c3 = arctan( B

max(R,G)

), (3.11)

3.4. DETECCIÓN DE SOMBRAS (DS) 27

Figura 3.6: Verosimilitudes y función S(x) aplicando la DS. (a) Fondo. (b) IS(x)t. (c) Verosimilituden el dominio de la Luminancia VL(x). (d) Verosimilitud en el dominio de la Crominancia VC(x).(e) Verosimilitud en el dominio de la magnitud del Gradiente suavizado VG(x). (f) Combinación delas verosimilitudes S(x).

IGS (x) y µG(x) son las magnitudes del gradiente de las imágenes IS(x) y µ(x) suavizadas.

2. Ahora combinamos las tres verosimilitudes calculadas en los diferentes dominios (como lo hacenen George [12]), de la siguiente manera:

S(x) = VL(x)× VC(x)× VG(x). (3.12)

3. Finalmente modificamos la VB(x), aplicando un umbral (0.92 para nuestros experimentos) a lafunción S(x) para asignarle a los pixels que son sombra (o que están por encima del umbral) unaprobabilidad alta de pertenecer al fondo. Aclarando que en George [12] aplican una envolventeconvexa después de calcular S(x), con la finalidad de rellenar los huecos o errores en donde seconfunde el primer plano con el fondo. Lo que nosotros proponemos para eliminar estos huecos,es introducir la VB(x) modificada al proceso de Corrección de Semejanza del Color explicadoen la sección 3.5.

En la Figura 3.6, se muestra uno de los resultados de las verosimilitudes y la función S(x).Observamos que en la función S(x) se detectan las sombras, entonces, lo que podemos hacer esmodificar la VB(x) asignándole a los pixels que son sombra, una probabilidad alta de ser fondo, conla finalidad de eliminar las sombras en la secuencia de video.


3.5. Corrección de semejanza del color (CSC)

Si el objeto móvil tiene colores que son muy parecidos a los colores del fondo de la escena, elmétodo puede confundir el primer plano con el fondo. Este problema se ilustra en la Figura (3.7), endonde se quiere segmentar el objeto móvil (circulo) para después cambiar el fondo (a) por el fondonuevo (b). En (c) y (d) observamos que no hay problema con la segmentación y sustitución del fondo,ya que el objeto móvil no se confunde con el fondo. Sin embargo, en (e) y (f) observamos que hayproblema al sustituir el fondo, esto se debe a que una parte del objeto móvil es semejante al colordel fondo, lo cual provocó un error en la segmentación. Lo ideal sería que el método segmentara elobjeto móvil y sustituyera el fondo como se muestra en (g).

Para resolver este problema, nosotros proponemos una “Corrección de Semejanza del Color”en donde la idea principal es que la probabilidad que tiene cada pixel de ser primer plano o fondo,no sufra un cambio tan brusco de un frame al siguiente, en caso contrario lo que se busca es que elcambio de la probabilidad sea menor. Para realizar esto, hacemos lo siguiente:

1. Calculamos el Flujo Óptico (FO) usando el método de Lucas-Kanade [28] para detectar lo quese esta moviendo entre cada par de imágenes de la secuencia de video, de esta forma obtenemosel desplazamiento d(x) que hay entre las imágenes IS(x)t−1 y IS(x)t.

2. Sean d(x) el desplazamiento calculado en el paso anterior y P t−1(x) la probabilidad de perteneceral primer plano calculado en el frame anterior; entonces la verosimilitud de pertenecer al fondoVB(x) en el frame actual, la modificamos de la siguiente manera:

Si(P t−1

(x− d(x)

)> Umbral AND VB(x) > Umbral

)entonces

VB(x) = 12

Lo que hacemos aquí es modificar el valor de VB(x), tal que si un pixel era primer plano en lasolución anterior P t−1(x) y ahora es clasificado como fondo, entonces le asignamos 1

2 (no sabemos sies fondo o primer plano). En la Figura (3.8), se muestran los resultados de las derivadas parciales yla magnitud del flujo óptico. Con la velocidad de procesamiento del método, consideramos que entrecada par de imágenes a través del tiempo no existen movimientos grandes, sin embargo, podemosobservar que se detecta movimiento en el fondo “estático”, esto se debe al problema que mencionamosanteriormente de que las imágenes son adquiridas de un formato comprimido. En la figura (3.9), semuestra como cambia la VB(x) aplicando la CSC, observamos que hay una mejora en la parte interiordel objeto que vamos a segmentar, sin embargo, se puede apreciar que existen ciertos errores en elcontorno, estos errores van a depender de que tan rápido sea el movimiento en la escena.

3.5. CORRECCIÓN DE SEMEJANZA DEL COLOR (CSC) 29

Figura 3.7: Corrección de semejanza del color. (a) Fondo. (b) Fondo Nuevo. (c) IS(x)t. (e) IS(x)t+1.(d), (f) Resultados de la segmentación y sustitución de fondo. (g) Resultado deseado con la correcciónde semejanza del color.

Figura 3.8: Derivadas parciales y flujo óptico. (a) Derivada parcial en x. (b) Derivada parcial en y.(c) Derivada parcial en t. (d) Magnitud del flujo óptico.


Figura 3.9: Mejora en el cálculo de VB(x) aplicando la CSC. (a) Fondo. (b) IS(x)t. (c) VB(x) sinCSC. (d) VB(x) con CSC.

Capítulo 4

Implementación

El método propuesto fue implementado en Visual C++ 2005 Express Edition, utilizando:

Arquitectura GPU (Tarjeta de Video NVIDIA GeForce 8800 GT 512 MB, Lenguaje de pro-gramación CUDA (Compute Unified Device Architecture))

OpenCV. Software libre que contiene una librería de visión computacional desarrollada origi-nalmente por Intel.

WebCam Creative.

Computadora Pentium 4 con CPU a 3.40 GHz y 512 MB de RAM.

Sistema Operativo Windows XP.

En la Figura (4.1) podemos observar el flujo del método completo, identificamos las cuatro partesprincipales: Segmentación del primer plano, Modificación de la intensidad, Detección de sombras yCorrección de semejanza del color. Además podemos ver mediante las etiquetas GPU, OpenCV yCPU que la mayor parte de los procesos se desarrollaron en GPU, esto para lograr el tiempo real.En las siguientes secciones de este capítulo, se da una breve introducción acerca del lenguaje deprogramación CUDA y la descripción de la implementación de las funciones más importantes de lascuatro partes principales del método.

4.1. Programación en CUDA

La tecnología CUDA, es un entorno del lenguaje C que permite que los programadores y desa-rrolladores escriban software para resolver problemas computacionales complejos en una fracción deltiempo, utilizando el poder de procesamiento paralelo de múltiples núcleos de la GPU (GraphicsProcessing Unit). Con millones de GPU compatibles con CUDA, miles de programadores de soft-ware ya están usando las herramientas de software CUDA gratuitas para acelerar aplicaciones, desdecodificación de audio y video, exploración de gas y petróleo y diseño de producto, hasta imágenesmédicas e investigación científica.

Las herramientas de desarrollo CUDA, de NVIDIA, brindan tres componentes principales:

31

32 CAPÍTULO 4. IMPLEMENTACIÓN

Figura 4.1: Diagrama de flujo principal del método

4.2. SEGMENTACIÓN DEL PRIMER PLANO 33

Figura 4.2: Estructura de nuestros programas Kernel

La última versión del manejador de CUDA.

Un kit completo de herramientas CUDA.

Ejemplos de código CUDA SDK.

En la implementación de nuestro método todas las funciones (Kernel) que utilizamos tienen unaestructura como se muestra en la Figura (4.2). Ver Apéndice (A) para mayor información acerca dela programación en CUDA.

4.2. Segmentación del primer plano

Como se muestra en el diagrama de la Figura 4.3, necesitamos como entrada la verosimilitudde pertenecer fondo, la cual calculamos con la ecuación (3.2), después calculamos las distancias ypesos para utilizarlos en el método iterativo de Gauss-Seidel y obtener la solución P (x). Todo esteproceso se implementó en GPU utilizando una estructura piramidal (con 4 niveles) o también cono-cido como MultiGrid (MGrid), sin necesidad de generar memoria para toda la pirámide. Como sepuede observar en la Figura (4.4) solo basta con conocer las posiciones en la imagen original de lossiguientes subniveles de la pirámide.


Funciones principales:

__global__ void Calcular_Distancias_Pesos_GPU (DOBJ, DBACK, PK, WX, WY, im-ageW, imageH, K, gamma)donde:

DOBJ: Distancia al objeto o foreground.

DBACK: Distancia al fondo o background.

PK: Para inicializar la solución.

WX: Pesos en x.

WY: Pesos en y.

imageW: Ancho de la imagen.

imageH: Alto de la imagen.

K: Valor entero (255) que sirve para realizar las operaciones en punto fijo.

gamma: Parámetro que controla la sensibilidad para detectar los bordes.

Esta función se encarga de calcular las distancias y pesos en punto fijo, tiene como entrada laVB(x) guardada en una texture en gris y la imagen actual en una texture en RGB.

1. pix11back ← VB(x, y)pix11← texImage(x, y)pix01← texImage(x− 1, y)pix10← texImage(x, y − 1)

2. Calculamos las distancias:vb← pix11backpb← vb/K

po← 1− pbAsignamos a DOBJ y DBACK el − log de po y pb, en caso de que po o pb sea cero entoncesasignar un valor grande (10*K).

3. Calculamos los pesos:gamma← gamma ∗K2

val1← pix11− pix01val2← pix11− pix10WX ← gamma

gamma+|val1| ∗KWY ← gamma

gamma+|val2| ∗K

4. Finalmente aprovechamos a inicializar PK:PK ← 255− vb

Metodo_Segmentacion_MGrid_fast()Procedimiento que se encarga de realizar la segmentación por el método Gauss-Seidel con unaestructura MGrid (ver Figura 4.4) y Punto Fijo.

Para cada nivel de la pirámide:

4.2. SEGMENTACIÓN DEL PRIMER PLANO 35

1. iter ← 0, MaxIter

2. Mientras iter < MaxIter

2.1. Resolvemos la ecuación (3.5).

3. Fin Mientras.

__global__ void MGrid_GS_PF_escala (PK_Result, DOBJ, DBACK, PK, WX, WY, w,h, K, lambda, escala)donde:

PK_Result: Donde se guarda la solución.

DOBJ: Distancia al objeto o foreground.

DBACK: Distancia al fondo o background.

PK: Solución previamente inicializada.

WX: Pesos en x.

WY: Pesos en y.

w, h: Tamaño de la imagen.

K: Valor entero (255) que sirve para realizar las operaciones en punto fijo.

lambda: Parámetro que controla la suavidad espacial.

escala: Sirve para encontrar las posiciones de un subnivel en la imagen original.

Esta función se encarga de resolver la ecuación (3.5), tiene como entrada los arreglos DOBJ,DBACK, PK, WX y WY.

1. pix11Dback ← DBACK[w ∗ iy ∗ escala+ ix ∗ escala]pix11Dobj ← DOBJ [w ∗ iy ∗ escala+ ix ∗ escala]pix21PK ← PK[w ∗ iy ∗ escala+ ix ∗ escala+ escala]pix12PK ← PK[w ∗ (iy ∗ escala+ escala) + ix ∗ escala]pix01PK ← PK[w ∗ iy ∗ escala+ (ix ∗ escala− escala)]pix10PK ← PK[w ∗ (iy ∗ escala− escala) + ix ∗ escala]pix11Wx←WX[w ∗ iy ∗ escala+ ix ∗ escala]pix11Wy ←WY [w ∗ iy ∗ escala+ ix ∗ escala]pix21Wx←WX[w ∗ iy ∗ escala+ ix ∗ escala+ escala]pix12Wy ←WY [w ∗ (iy ∗ escala+ escala) + ix ∗ escala]

2. Aplicamos la ecuación (3.5)num← pix11Wx ∗ pix01PKden← pix11Wx

num← pix11Wy ∗ pix10PKden← pix11Wy

num← pix21Wx ∗ pix21PKden← pix21Wx

num← pix12Wy ∗ pix12PKden← pix12Wy

PK_Result← K∗pix11Dback+lambda∗numpix11Dobj+pix11Dback+lambda∗den


Figura 4.3: Diagrama a bloque de la segmentación del primer plano

Figura 4.4: Estructura Piramidal

4.3. Modificación de la intensidad

Como se muestra en el diagrama de la Figura (4.5), necesitamos como entrada la solución ante-rior Pant(x) para después calcular la división entre la media y la imagen actual restringida al áreadonde estamos seguros que es fondo, esto lo implementamos en GPU ya que podemos realizar ladivisión en paralelo sobre todos los pixels, después en CPU, calculamos el promedio µ(bi) mediantela ecuación 3.6 y actualizamos la imagen IS(x) con la ecuación 3.7.


__global__ void Dividir_Imagenes(Imag_R, w, h, PK_ant, K)donde:

Imag_R: Donde se guarda el resultado de la división.

w, h: Ancho y alto de la imagen.

PK_ant: Solución al tiempo t− 1 de la segmentación.

K: Valor entero (255), para tener un Umbral (K/2) y saber si un pixel es fondo o no.

Esta función se encarga de dividir la imagen promedio µ(x) entre la imagen actual IS(x)guardadas en texture en RGB.

1. pix11a← texImage(x, y) //Imagen Actual.pix11b← texImage_M(x, y) //Imagen promedio.pix11PK ← PK_ant[w ∗ iy + ix]

2. Si (pix11PK < K/2) //Si el pixel es fondo

2.1. div ← pix11bpix11a //Cuidando la división entre cero.

3. de lo contrario

3.1. div ← Etiqueta (que indique que el pixel no es fondo).

4.3. MODIFICACIÓN DE LA INTENSIDAD 37

Figura 4.5: Diagrama a bloque de la modificación de la intensidad

4. Imag_R← div

void Modificar_ImagenActual

Esta función se encarga de calcular el promedio µ(bi) y actualizar la imagen IS(x). Ya que elcálculo del promedio µ(bi) no se puede resolver de forma paralela, optamos por implementaresta función en CPU.

1. Inicializamos los arreglos Mu_R[255], Mu_G[255], Mu_B[255], cont_R[256], cont_G[256]y cont_B[256] a cero.

2. Para cada pixel en la imagen

2.1. pixDiv_R, pixDiv_G, pixDiv_B //valores de Div(x).pixI_R, pixI_G, pixI_B //valores de IS(x)

2.2. Si (pixDiv_R <> Etiqueta) //Si esta dentro del área del fondo.

2.2.1. Mu_R(pixI_R)←Mu_R(pixI_R) + pixDiv_R

2.2.2. cont_R(pixI_R)← cont_R(pixI_R) + 1

2.3. Si (pixDiv_G <> Etiqueta)

2.3.1. Mu_G(pixI_G)←Mu_G(pixI_G) + pixDiv_G

2.3.2. cont_G(pixI_G)← cont_G(pixI_G) + 1

2.4. Si (pixDiv_B <> Etiqueta)

2.4.1. Mu_B(pixI_B)←Mu_B(pixI_B) + pixDiv_B

2.4.2. cont_B(pixI_B)← cont_B(pixI_B) + 1

3. Fin Para

4. Calculamos el promedio cuidando la división entre cero.Mu_R←Mu_R/cont_RMu_G←Mu_G/cont_GMu_B ←Mu_B/cont_B

5. Para cada pixel en la imagenAplicamos la ecuación 3.7 a la imagen IS(x) en el host.

6. Fin Para


Figura 4.6: Diagrama a bloque de la detección de sombras

4.4. Detección de sombras

Como se muestra en el diagrama de la Figura (4.6), necesitamos como entrada la verosimilitudde ser fondo VB(x), luego detectamos las sombras calculando la función S(x) con la ecuación 3.12, deesta forma podemos modificar la VB(x) con la intensión de eliminar las sombras. Todo este procesose implementó en GPU.


__global__ void Producto_SCS(Nueva_VB,V_L,V_C,V_G,w,h,V_B,K)donde:

Nueva_VB Donde guardamos la nueva verosimilitud de ser fondo.

V_L Verosimilitud en Luminancia.

V_C Verosimilitud en Crominancia.

V_G Verosimilitud en magnitud del Gradiente suavizado.


V_B: Verosimilitud de ser fondo.

K: Valor entero (255), para tener un Umbral (K/2) y saber si un pixel es fondo o no.

Esta función se encarga de modificar la VB(x), detectando las sombras mediante el cálculo dela función S(x) y asignándoles una probabilidad alta de ser fondo.

1. pix11V B ← V_B[w ∗ iy + ix]

2. Si (pix11V B > K/2) //Si el pixel es primer plano

2.1. pix_L← V_L[w ∗ iy + ix]pix_C ← V_C[w ∗ iy + ix]pix_G← V_G[w ∗ iy + ix]

2.2. prod← (pix_L ∗ pix_C ∗ pix_G)

2.3. Si prod < (K − 20) entonces prod← 0de lo contrario prod← K

2.4. Nueva_V B ← prod

3. de lo contrario Nueva_V B ← K

4.5. CORRECCIÓN DE SEMEJANZA DEL COLOR 39

4.5. Corrección de semejanza del color

Como se muestra en el diagrama de la Figura (4.7), necesitamos como entrada la verosimilitudde ser fondo VB(x) y la solución anterior Pant(x), luego calculamos el flujo óptico con el método deLucas-Kanade, finalmente modificamos el valor de la VB(x) con la idea de que si un pixel era primerplano en la Pant(x) y ahora es clasificado como fondo por la VB(x), entonces le asignamos 1

2 (nosabemos si es fondo o primer plano). Todo este proceso se implementó en GPU.


__global__ void Derivadas_parciales_xyt(Dx, Dy, Dt, w, h)donde:

Dx: Donde se guarda la derivada parcial en x.

Dy: Donde se guarda la derivada parcial en y.

Dt: Donde se guarda la derivada parcial en t.


Esta función se encarga de calcular las derivadas parciales con respecto a x, y y t, para despuésser utilizadas en el cálculo del flujo óptico. Tiene como entrada las imágenes IS(x)t y IS(x)t+1

guardadas en texture en Gris.

1. pix11_imag1← texImage1(x, y) //de la imagen IS(x)t

pix21_imag1← texImage1(x+ 1, y)pix01_imag1← texImage1(x− 1, y)pix12_imag1← texImage1(x, y + 1)pix10_imag1← texImage1(x, y − 1)pix11_imag2← texImage2(x, y) //de la imagen IS(x)t+1

2. Calculamos las derivadas parciales:Dx← pix21_imag1− pix01_imag1Dy ← pix12_imag1− pix10_imag1Dt← pix11_imag2− pix11_imag1

__global__ void Calculo_FO_Nueva_VB(Nueva_VB, Vback, PK_ant, Dx, Dy, Dt, w, h)donde:

Nueva_VB Donde guardamos la nueva verosimilitud de ser fondo.

Vback Verosimilitud de ser fondo.

PK_ant Solución al tiempo t− 1.

Dx: Derivada parcial en x.

Dy: Derivada parcial en y.

Dt: Derivada parcial en t.



Figura 4.7: Diagrama a bloque de la corrección de semejanza del color

Esta función se encarga de calcular el flujo óptico mediante Lucas-Kanade, al mismo tiempomodifica la verosimilitud de ser fondo con la idea antes mencionada.

1. Llenamos la matriz A y el vector b del sistema de ecuaciones (2.28).

2. Resolvemos el sistema de ecuaciones:detA← (a1 ∗ a4)− (a2 ∗ a2)dist_x← a4∗b1−a2∗b2

detA

dist_y ← −a2∗b1+a1∗b2detA

3. Nos posicionamos en la PK_ant mediante los desplazamientos encontradospos_x← ix− dist_x //Cuidando no pasarnos de los limites de la imagen.pos_y ← iy − dist_ypixPKant← PK_ant[posy ∗ w + posx]

4. pixV B ← V back[w ∗ iy + ix]

5. Si (pixPKant > K2 AND pixV B > K

2 )

5.1. Nueva_V B ← K2

6. de lo contrario

6.1. Nueva_V B ← pixV B

Capítulo 5

Experimentos

Los experimentos fueron realizados con imágenes de 320x240 pixels adquiridas de una WebCamen tiempo real y de archivos de video. Los valores de los parámetros del método utilizados en todoslos experimentos se muestran en la Tabla 5.1, teniendo como parámetros sensibles a los umbrales.Primero se presentan los resultados obtenidos en nuestro escenario, probando que el método esrobusto a cambios de iluminación, sombras y semejanza del color, después se presentan resultadoscon videos de prueba del estado del arte y por último se realiza una comparación cualitativa de losresultados de nuestro método con los resultados de otros métodos del estado del arte.

5.1. Resultados del método en nuestro escenario

A continuación, presentamos los resultados que obtenemos en nuestro escenario (cubículo de tra-bajo), probando que el método es robusto a cambios de iluminación, sombras y semejanza del color,el método completo (con Modificación de Intensidad (MI), Detección de Sombras (DS) y Correcciónde Semejanza del Color (CSC)) corre a 38 f/s (frames por segundo) y sin la MI, DS y CSC correa 66 f/s. Aclarando que la velocidad se calcula tomando en cuenta el tiempo que tarda nuestro sis-tema en adquirir la imagen de la WebCam, en pasar la imagen de CPU a GPU para procesarla y enpasar los resultados de GPU a CPU para mostrar la imagen ya segmentada y con un fondo diferente.

En la Figura (5.1) podemos observar que el método con MI, es robusto a los cambios de ilu-

Parámetros Valor DescripciónUmbral_1 0.99 Umbral para el cálculo de la VB(x) (3.3).

λ 300 Controla la suavidad del funcional QMPF (3.4).γ 0.01 Controla la sensibilidad para detectar los bordes. QMPF (3.4).

MaxIter 10 Controla el Máximo de Iteraciones del método QMPF. sección 3.2.Umbral_2 0.5 Umbral para la sustitución del fondo. sección 3.2.

β 0.75 Controla la Modificación de Intensidad (3.7).Umbral_3 0.92 Umbral aplicado a la función S(x) para detectar sombras. sección 3.4

Cuadro 5.1: Parámetros del método.

41

42 CAPÍTULO 5. EXPERIMENTOS

minación, lo que hicimos para provocar el cambio de iluminación en la escena, fue acercarnos unpoco a la cámara, en los resultados del método sin MI observamos errores muy grandes, hasta elgrado de llegar a clasificar a toda la imagen como primer plano, mientras que con la MI observamosque se corrigen dichos errores.

En la Figura (5.2), observamos que el método con MI y CSC es robusto a la semejanza delcolor entre lo que se esta moviendo y el fondo, vemos que el método sin CSC se equivoca cuando elcabello de la persona que estamos segmentando está tapando la silla que esta en el fondo, dejandohuecos en la persona, en cambio con la CSC vemos que se logran tapar dichos huecos.

Luego probamos como funciona el método con MI y CSC, cuando se presentan los problemasde cambios de iluminación y semejanza del color al mismo tiempo, en la Figura (5.3) se muestranalgunos de los resultados, podemos observar que el método con MI y CSC funciona muy bien bajoestos dos problemas, mientras que con el método sin MI y CSC se obtienen malos resultados.

Ahora probamos el método cuando existen sombras proyectadas por la persona que deseamossegmentar, en la Figura (5.4) se muestran algunos resultados del método con la DS, observamos queel método sin MI, DS y CSC segmenta las sombras como primer plano, el método con MI y DSdetecta y elimina las sombras, sin embargo, tiene algunos errores en la parte interna de la persona,finalmente observamos que el método completo corrige dichos errores con la CSC.

5.2. Resultados del método en otros escenarios

Ahora, probamos nuestro método en otros escenarios, utilizando algunos de los videos de prueba(con ground truth) de Eva y Rainer [29], quienes hicieron un llamado en Agosto del 2006, a unacompetencia de algoritmos de segmentación de primer plano/fondo, ya que existe una gran variedadde algoritmos propuestos. Sin embargo, la comparación entre estos resulta ser difícil, ya sea por noproporcionar el código fuente o por que las pruebas se realizan para diferentes conjuntos de datos ybajo diversas condiciones. También, probamos el método con videos del equipo de investigación enVisión Computacional y Robótica del UCSD [30]. Por último, mostramos algunos de los resultadosdel método utilizando videos de Internet.

En la Figura 5.5 comparamos el resultado de nuestro método sin DS con la segmentación ver-dadera que reportan del archivo “video7_long.avi” [29], observamos que nuestro método se equivocaen la parte donde las ramas de los árboles se están moviendo, la razón, es que en nuestra im-plementación es necesario que el fondo sea totalmente estático, sin embargo, vemos que detectaaproximadamente bien el auto y las chicas del Kung-Fu, para toda la secuencia del video resultó sermás exacto el método sin MI y CSC que el método con MI y CSC.

Al inicio del archivo “vide6_long” [29], hay tres imágenes del fondo, las cuales podemos utilizarpara calcular nuestro modelo del fondo, aunque, sabemos que la intensión aquí es de segmentar sinconocimiento del fondo. En la Figura 5.6, se muestran los resultados obtenidos con y sin conocimien-

5.2. RESULTADOS DEL MÉTODO EN OTROS ESCENARIOS 43

Figura 5.1: Ajuste de iluminación. (a) Fondo. (b) IS(x)t. (c) Método sin MI, DS y CSC (66 f/s). (d)Método con MI (43 f/s).


Figura 5.2: Corrección de semejanza del color. (a) Fondo. (b) IS(x)t. (c) Método sin MI, DS y CSC(66 f/s). (d) Método con MI y CSC (40 f/s).

Figura 5.3: Ajuste de iluminación y Corrección de semejanza del color. (a) Fondo. (b) IS(x)t. (c)Método sin MI, DS y CSC (66 f/s). (d) Método con MI y CSC (40 f/s).

5.2. RESULTADOS DEL MÉTODO EN OTROS ESCENARIOS 45

Figura 5.4: Detección de sombras. (a) Fondo 1. (b) Fondo 2. (c) IS(x)t. (d) Método sin MI, DS yCSC (66 f/s). (e) Método con MI y DS (40 f/s). (f) Método completo (38 f/s)


to del fondo. Nuevamente resultó ser mejor el método sin MI y CSC que el método con MI y CSC.Esto se debe a que en toda la secuencia de los videos “video7_long.avi” y “video6_long.avi” no haycambios de iluminación en los que se pueda ver afectado el método sin la MI, y como los movimientosno son tan suaves, al agregar la CSC provoca que la definición espacial sea más imprecisa.

En la Figura 5.7, mostramos algunos resultados utilizando el archivo “intelligentroom _raw” [30],utilizando la DS, aclarando que en la columna (c), se aplicó el método con MI y DS sin la seg-mentación QMPF binaria, solo para mostrar las sombras detectadas. Observamos en (c) que sedetecta aproximadamente bien las sombras que se proyectan en las paredes y en el suelo, dichassombras se detectan y eliminan con la DS, sin embargo, quedan pequeños huecos en la personasegmentada, los cuales se corrigen con la CSC. En (d) podemos observar que el método completo seencarga de segmentar de una mejor manera a la persona que aparece en la escena.

En la Figura 5.8, mostramos algunos resultados utilizando los archivos “highway_raw” I y II [30],observamos que aunque no existe conocimiento del fondo, la DS ayudó a que, al realizar el modelodel fondo, el método no se confundiera en las partes donde los autos taparon el fondo. Para toda lasecuencia del video, el método completo detecta mejor los autos que el método sin MI, DS y CSC.

Finalmente, buscamos videos en Internet (en la página “You Tube”), para probar el métodoen diferentes escenarios. En la Figura 5.9 mostramos algunos resultados. En el video de la fila 1 sedetectaron y eliminaron las sombras proyectadas en el suelo por la persona que esta bailando, estose logró con la DS. En el video de la fila 2 observamos que el fondo en toda la secuencia es casiblanco, solamente en la parte inferior es como una sombra, entonces, probando con un modelo delfondo totalmente blanco, nos dimos cuenta que el método con DS detecta y elimina dicha sombra,además, observamos que habían errores en la camisa de uno de los personajes cuando aplicamosel método sin la CSC, ya que el color de la camisa es semejante al color del fondo, sin embargo,esto se puede corregir agregando la CSC. En el video de la fila 3 es importante agregar la DS paradetectar y eliminar las sombras del jugador de tenis, de lo contrario, estas sombras aparecen en elvideo segmentado. En el video de la última fila, el color de la camisa del personaje es semejante alcolor del fondo, provocando errores parecidos a los del video de la fila 2, sin embargo, con la CSCse logran corregir dichos errores, al final del video hay un cambio de intensidad en la escena, el cualse corrige con la MI. Observamos que con el método completo se obtienen muy buenos resultados.

5.3. Comparación cualitativa con otros métodos

A continuación, presentamos algunos resultados de nuestro método comparándolos cualitativa-mente con los resultados de otros métodos del estado del arte. Primero comparamos nuestro métodocon métodos que detectan sombras utilizando el archivo de video “intelligentroom_raw”, el cualpuede descargarse de [30]. Finalmente comparamos nuestro método con métodos que detectan ysegmentan el primer plano utilizando los archivos de video “Curtain”, “Fountain” y “WaterSurface”,los cuales pueden descargarse de [31].

5.3. COMPARACIÓN CUALITATIVA CON OTROS MÉTODOS 47

Figura 5.5: Resultados con el archivo video7_long. (a) Fondo. (b) IS(x)t. (c) Método sin MI y CSC.(d) Método con MI y CSC. (e) Ground truth

Figura 5.6: Resultados con el archivo video6_long. (a) Fondo 1. (b) Fondo 2. (c) IS(x)t. (d) Métodosin MI y CSC. (e) Método con MI y CSC. (f) Ground truth


Figura 5.7: Resultados con el archivo intelligentroom_raw. (a) Fondo. (b) IS(x)t. (c) Método conMI y DS sin la segmentación QMPF. (d) Método Completo. (e) Ground truth. Rojo: Sombras. Azul:Objeto.


Figura 5.8: Resultados con el archivo highway_raw. (a) Fondo 1. (b) Fondo 2. (c) IS(x)t. (d) Métodosin MI, DS y CSC. (e) Método con MI y DS sin la segmentación QMPF. (f) Método Completo.

Figura 5.9: Resultados con videos “You Tube”. (a) Fondo. (b) IS(x)t. (c) Sustitución del fondo conel método completo.


En el articulo de Prati y otros [32], realizan una comparación de dos métodos estadísticos (SNPy SP) y dos deterministas (DNM1 y DNM2) para la detección de sombras, concluyen que para unsistema de detección de sombras de propósito general, se obtienen mejores resultados utilizando elmétodo DNM1. Si el escenario es en interiores, una aproximación estadística es más fiable, ya quela escena es constante y una descripción estadística es muy eficaz. Si hay diferentes planos en losque las sombras se pueden emitir, un enfoque como SNP es la mejor opción. Utilizando el archivo“intelligentroom_raw”, observamos que nuestro método detecta menor cantidad de sombras que losmétodos señalados anteriormente, sin embargo, se equivoca menos en la segmentación de la persona.

En la Figura 5.10 mostramos uno de los resultados reportados en [32] y el resultado que obtene-mos con nuestro método, observamos que los métodos (b) SNP, (c) SP y (d) DNM1 se equivocan enla sombra que proyecta la persona cerca de sus pies, en el método (e) DNM2 las sombras consumenparte de la persona, en nuestro método (f) observamos que se detecta aproximadamente bien lasombra que esta por los pies y los huecos que aparecen en la persona se logran rellenar con nuestrométodo completo (g). Para toda la secuencia, nuestro método completo detecta mejor a la persona.

En el articulo de Li y otros [33], proponen un método para la detección y segmentación delprimer plano, a partir de un video en el que el fondo puede ser estacionario o móvil y bajo cambiosgraduales o repentinos. Las imágenes de los videos de prueba son de 160x128 pixels, casi la mitad deltamaño de las imágenes que procesamos en nuestros experimentos, por lo cual nuestro método correa una velocidad mayor. Aprovechando esta ventaja de la velocidad, modificamos los parámetros delmétodo QMPF (λ = 200 y MaxIter=60), reduciendo la velocidad a 32 f/s, pero obteniendo mejoresresultados en la segmentación.

En las Figuras 5.11, 5.12 y 5.13 se muestran algunos resultados del método MoG, del méto-do propuesto por [33] y de nuestro método completo, utilizando los archivos de video “Curtain”,“Fountain” y “WaterSurface”. En el archivo “Curtain”, hay una cortina que se esta moviendo en elfondo, en el archivo “Fountain” hay movimiento en el fondo provocado por el flujo de agua de unafuente y en el archivo “WaterSurface” tenemos el movimiento del mar como fondo. Cuando probamosnuestro método sin MI, DS y CSC, dichos movimientos en el fondo son detectados como primer plano,sin embargo, cuando probamos el método completo, observamos que se logra segmentar como primerplano únicamente a las personas que pasan por estos diferentes escenarios, los movimientos en elfondo son eliminados por la DS de nuestro método.

En la Figura 5.11, observamos que nuestro método completo obtiene resultados parecidos alos del método propuesto por [33] y mejores que los resultados del método MoG. En la Figura 5.12,observamos que nuestro método elimina las sombras que se proyectan por los pies de las personas,sin embargo, corta una parte de sus piernas causando errores, esto depende de nuestro parámetroUmbral_3, el cual si es mayor que el valor que registramos en la Tabla 5.1, detecta menos sombraspero empieza a segmentar el movimiento en el fondo como primer plano, nosotros optamos por nomodificar este parámetro para obtener menor error en el fondo. En la última fila de la Figura 5.12podemos observar que nuestro método completo se equivoca menos en el fondo que los otros dos


Figura 5.10: Comparación con otros métodos utilizando el archivo intelligentroom_raw. (a) IS(x)t.(b) Método SNP, (c) Método SP, (d) Método DNM1, (e) Método DNM2, (Crédito: [32]). (f) Nuestrométodo con MI y DS sin la segmentación QMPF. (g) Nuestro método completo. Rojo: Objeto. Azul:Sombras.

métodos. En la Figura 5.13, observamos que con nuestro método completo tenemos el mismo pro-blema con las sombras que en el caso anterior, si modificamos el parámetro Umbral_3 para detectarmejor las piernas de la persona, empiezan a surgir errores en el fondo, aunque nuestro método com-pleto para este caso no sea tan bueno como el propuesto por [33], resultó ser mejor que el métodoMoG.


Figura 5.11: Comparación con otros métodos utilizando el archivo Curtain. (a) IS(x)t. (b) MétodoMoG. (c) Método propuesto por [33]. (d) Nuestro método completo. (e) Ground truth.

Figura 5.12: Comparación con otros métodos utilizando el archivo Fountain. (a) IS(x)t. (b) MétodoMoG. (c) Método propuesto por [33]. (d) Nuestro método completo. (e) Ground truth.


Figura 5.13: Comparación con otros métodos utilizando el archivo WaterSurface. (a) IS(x)t. (b)Método MoG. (c) Método propuesto por [33]. (d) Nuestro método completo. (e) Ground truth.

Capítulo 6

Conclusiones y Trabajo a futuro

6.1. Conclusiones

Cuando empezamos la investigación, la implementación la hacíamos totalmente en CPU, porlo que no pensábamos en algoritmos que consumieran mucho tiempo de cómputo, ya que nuestroobjetivo era alcanzar el tiempo real (24 f/s como mínimo). Después vimos que con la utilización de laarquitectura GPU (Tarjeta de video NVIDIA, Lenguaje de programación CUDA) se puede obteneruna velocidad de procesamiento mayor que solamente utilizando la CPU, de esta forma logramos queel método corra en tiempo real, a una velocidad mayor a la que queríamos alcanzar. Adicionalmente,actualmente existen tarjetas mucho más potentes que la que utilizamos en nuestra implementación,lo que significa que el método podrá correr a una velocidad mayor a la reportada en esta tesis.

Al realizar los experimentos nos dimos cuenta que era muy difícil obtener una segmentaciónbuena después de un lapso de tiempo largo, debido a los cambios de iluminación en la escena, paraeste problema se implementó una “modificación de la intensidad” (sección 4.3), basándonos en elarticulo de Spagnolo [13], proponiendo no modificar el fondo, si no la imagen actual, ya que de estaforma prevenimos errores con imágenes mal adquiridas por la WebCam. Se probó experimentalmenteque el método es robusto a cambios de iluminación.

Otro problema que detectamos, son las sombras proyectadas por los objetos que deseamos seg-mentar, para esto implementamos una “Detección de sombras” (sección 4.4), apoyándonos en lasobservaciones de George [12]. Probamos experimentalmente que el método es robusto a las sombras,sin embargo, se encontraron pequeños detalles en la parte interna del objeto a segmentar. Afor-tunadamente el último paso del método “Corrección de semejanza del color” ayuda a corregir estedetalle.

Partes del objeto a segmentar pueden coincidir en color con el fondo del escenario, provocandoque el método confunda el primer plano con el fondo, para resolver este problema, agregamos a nues-tro método una “Corrección de semejanza del color” (sección 4.5). El método también es robustoa la semejanza del color entre el fondo y el objeto móvil, sin embargo, pueden existir errores con

55

56 CAPÍTULO 6. CONCLUSIONES Y TRABAJO A FUTURO

Figura 6.1: Aplicaciones considerando la cámara en movimiento. (a) Entrevistas. (b) Transmisionesdeportivas. (c) Películas.

movimientos muy bruscos en la escena.

6.2. Trabajo a futuro

Como trabajo a futuro queremos realizar lo siguiente:

En diversas aplicaciones de la segmentación de secuencias de video, es imposible tener conoci-miento del fondo de la escena, por ejemplo, en carreteras con demasiado tráfico. En este caso,es importante investigar de que manera podríamos construir el fondo a partir de secuenciassin ausencia del primer plano.

Resolver otros problemas que se pueden presentar durante la secuencia de video, como porejemplo la oclusión y los reflejos en superficies. La forma del objeto que deseamos segmentar,puede cambiar debido a oclusiones y esto es un problema en aplicaciones en donde se requiereque la forma del objeto no se deforme. El problema con las reflexiones es casi similar al de lassombras, sin embargo, puede ser más difícil, ya que la imagen reflejada depende de la superficiereflectante y además la reflexión puede no estar adjunta al objeto.

En aplicaciones en donde el fondo es móvil y queremos segmentar el primer plano, la cons-trucción del fondo se vuelve más difícil. Por ejemplo, si queremos segmentar a una personaque está dando una conferencia y detrás de ella tenemos proyectada su presentación. En estasituación hay que resolver los casos II y III de la Tabla 1.1 del problema de segmentación delprimer plano, en donde el fondo ahora es móvil y el primer plano puede ser estático o móvil.

Resolver el problema de segmentación del primer plano, considerando que la cámara está enmovimiento. La dificultad aquí, es la estimación del movimiento de la cámara, el cual tieneque ser robusto al movimiento del primer plano. Esto podría utilizarse en escenas típicas detelevisión, por ejemplo, entrevistas, transmisiones deportivas o películas (ver Figura 6.1).

Apéndice A

Tutorial del lenguaje deprogramación CUDA

CUDA (Compute Unified Device Architecture), es una tecnología GPGPU (General-purposecomputing on graphics processing units) que permite utilizar el lenguaje de programación C paraejecutar código en la unidad de procesamiento gráfica (GPU). CUDA ha sido desarrollado porNVIDIA y para utilizar esta arquitectura se requiere tener una tarjeta gráfica GeForce 8 series (oequivalente Quadro), ya que con este tipo de tarjetas, NVIDIA asegura que los programas desarro-llados podrán trabajar sin modificaciones en el futuro con nuevas tarjetas.

Características de CUDA:

Soporta el lenguaje de programación C estándar.

Unificación de Hardware y Software para el cómputo en paralelo.

Soporte de datos en paralelo y manejador de hilos.

Librerías para FFT (Fast Fourier Transform) y BLAS (Basic Linear Algebra Subroutines).

Opera internamente con OpenGL y DirectX.

Soporta los sistemas operativos Linux 32/64-bit, Windows XP 32/64-bit y actualmente Win-dows Vista 32/64-bit.

Modelo de Programación:

Un programa que se compila para ejecutarse en una tarjeta gráfica se le llama Kernel.

El conjunto de hilos que ejecuta un Kernel están organizados como una cuadrícula (grid) debloques de hilos como se muestra en la Figura (A.1).

Un Bloque de hilos es un conjunto de hilos que pueden cooperar juntos:

• Con rápido acceso a memoria compartida.

57

58 APÉNDICE A. TUTORIAL DEL LENGUAJE DE PROGRAMACIÓN CUDA

• Sincronizadamente.

• Con un identificador de hilos ID.

• Los Bloques pueden ser arreglos de 1, 2 o 3 dimensiones.

Un Grid de bloques de hilos:

• Tiene un número limitado de hilos en un bloque.

• Los bloques se identifican mediante un ID.

• Pueden ser arreglos de 1 o 2 dimensiones.

Calificadores de una función:

__device__

• Se ejecuta en el dispositivo.

• Llamada solamente desde el dispositivo.

__global__

• Se ejecuta en el dispositivo.

• Llamada solamente desde el host.

__host__

• Se ejecuta en el host.

• Llamada solamente desde el host.

Calificadores de una variable:

__device__

• Reside en el espacio de la memoria global.

• Tiene el tiempo de vida de una aplicación.

• Es accesible a partir de todos los hilos dentro del grid, y a partir del host a través de labiblioteca en tiempo de ejecución.

__constant__ (Opcionalmente se utiliza junto con __device__)

• Reside en el espacio de la memoria constante.

• Tiene el tiempo de vida de una aplicación.

• Es accesible a partir de todos los hilos dentro del grid, y a partir del host a través de labiblioteca en tiempo de ejecución.

__shared__ (Opcionalmente se utiliza junto con __device__)

• Reside en el espacio de memoria compartida de un bloque de hilos.

59

• Tiene el tiempo de vida de un bloque.

• Solamente accesible a partir de los hilos que están dentro del bloque.

Llamada a una Función:

Función:__global__ void NameFunc(float *parámetros);

Debe ser llamada como sigue:NameFunc <<< Dg, Db, Ns >>> (parámetros);Donde:

Dg es de tipo dim3 dimensión y tamaño del grid. (Dg.x*Dg.y = Numero de Bloques)

Db es de tipo dim3 dimensión y tamaño de cada bloque. (Db.x*Db.y*Db.z = Numero de hilospor bloque)

Ns es de tipo size_t numero de bytes en memoria compartida que es dinámicamente asignadaen adición a la memoria estática asignada. (Ns es un argumento opcional el cual tiene valor 0)

Variables Definidas Automáticamente:

Todas las funciones __global__ y __device__ tienen acceso a las siguientes variables:

gridDim es de tipo dim3, indica la dimensión del grid.

blockIdx es de tipo uint3, indica el índice del bloque dentro del grid.

blockDim es de tipo dim3, indica la dimensión del bloque.

threadIdx es de tipo uint3, indica el índice del hilo dentro del bloque.

Compilación con NVCC

El nvcc, es un compilador que simplifica el proceso de compilación del código CUDA, el flu-jo del nvcc consiste en separar el código device del código host y compilar el código device en unaforma binaria u objeto cubin (extensión de un archivo binario en CUDA). El código host generadoes de salida, ya sea como código C que va a ser compilado con otras herramientas o directamentecomo código objeto, por la invocación del compilador host durante la última etapa de compilación.

El nvcc utiliza los siguientes compiladores para el código host:

Para plataforma Linux: compilador GNU, gcc.

Para plataforma Windows: Microsoft Visual Studio C/C++ 7.x y 8.x.


Figura A.1: Organización del conjunto de hilos que ejecuta un Kernel

Flujo de la compilación de un programa en CUDA

Como observamos en la Figura A.2, el programa de entrada es separado por el cudafe (CU-DA front end) en código host C/C++ y en código device .gpu. Dependiendo del valor de la opción-code del nvcc, el código device es traducido por el CUDA compilers/assemblers dentro del códigobinario CUDA (cubin) y/o dentro del código intermedio ptx. Este código es fusionado en un códigodevice descriptor, el cual es incluido por el código host anteriormente separado. Este descriptor seráinspeccionado por el CUDA en tiempo de ejecución cuando el código device es invocado o “llamado”por el programa host. En el actual esquema de compilación de CUDA, el cudafe es invocado dosveces. En la primera invocación se separa el código host del device, la segunda invocación es paraun detalle técnico (realiza un análisis del código en .gpu generado en la primera invocación), aunqueesto podría desaparecer en futuras versiones.

61

Figura A.2: Flujo de compilación de un programa en CUDA (.cu a .cu.c)


A.1. Configuración de CUDA en Visual C++ 2005 ExpressEdition

Primero hay que Instalar el CUDA para Windows, podemos descargarlo de [34], hay que instalarel Toolkit y el SDK. Cuando instalamos el SDK nos genera una carpeta de proyectos que ya se handesarrollado, en nuestro caso particular nos basamos del proyecto “imageDenoising” para saber comose puede realizar un procesamiento de imagenes en GPU. Una vez instalados el Toolkit y el SDK,ahora vamos a configurarlo para utilizarlo en Visual C++ 2005 Express Edition:

1. Crear una carpeta en la que vamos a guardar nuestros proyectos, por ejemplo C:\ CU-DA_PROGRAMS.

2. Copiar las carpetas bin y common de C:\Program Files\NVIDIA Corporation \NVIDIA CU-DA SDK a la carpeta que creamos C:\CUDA_PROGRAMS.

3. Abrimos un nuevo proyecto en modo consola como en la Figura (A.3), click en OK.

4. Aparece una ventana de dialogo como la Figura (A.4), click en Next.

5. Aparece otra ventana de dialogo donde definimos los valores de la aplicación como en la Figura(A.5), click en Finish.

6. Se genera un proyecto con un archivo .cpp como en la Figura (A.6), borramos el contenido delarchivo .cpp y le cambiamos la extensión a .cu.

7. Click derecho en el icono PRUEBA1, luego en la opción Properties −→

7.1. Configuration Properties −→

7.1.1. General −→ Output Directory: $(ConfigurationName)

7.2. C/C++ −→

7.2.1. General −→ Additional Include Directories: “$(CUDA_INC_PATH)” ;./; ../../ com-mon/inc

7.3. Linker −→

7.3.1. General −→ Output File: ../../bin/win32/$(ConfigurationName)/PRUEBA1.exe

7.3.2. General −→ Additional Library Directories: “$(CUDA_INC_PATH)” ;./; ../../ com-mon/lib

7.3.3. Input −→ Additional Dependencies: cudart.lib cutil32D.lib glew32.lib cv.lib cvaux.libhighgui.lib cvcam.lib cxcore.lib

7.3.4. Input −→ Ignore Specific Library: LIBCMTD.lib

7.3.5. Input −→ Debugging: $(OutDir)/ PRUEBA1.pdb

Ahora para comenzar a programar en CUDA necesitamos configurar lo siguiente en el archivoPRUEBA1.cu:

1. Click derecho en el icono PRUEBA1.cu, en la opción Properties −→

A.1. CONFIGURACIÓN DE CUDA EN VISUAL C++ 2005 EXPRESS EDITION 63

Figura A.3: Abrir proyecto en modo consola

1.1. General −→ Command Line: “$(CUDA_BIN_PATH)\ nvcc.exe” -ccbin “$ ( VCInstallDir) bin” -c -D_DEBUG -DWIN32 -D_CONSOLE -D_MBCS -Xcompiler/EHsc, /W3, /nol-ogo, /Wp64, /Od, /Zi, /RTC1, /MTd -I“$(CUDA_INC_PATH)” -I./ -I../../common/inc-o $(ConfigurationName)\ PRUEBA1.obj PRUEBA1.cu

1.2. General −→ Outputs: $(ConfigurationName)\ PRUEBA1.obj

1.3. General −→ Additional Dependencies: PRUEBA1_kernel.cu

Para que el código que escribimos en los archivos .cu tenga highlighting, tenemos que realizar losiguiente:

1. Si no tenemos el archivo usertype.dat, en el directorio “Microsoft Visual Studio 8\ Common7\IDE”, entonces lo copiamos en dicho directorio.

2. Abrimos el Visual C++ 2005 Express Edition, luego en “Tools→Options”, abrir “Text Editor”y click en “File Extension”. Escribir cu en la caja de texto “Extension”, y click en “Add”. Click“OK” en la ventana de dialogo.

3. Reiniciamos el Visual C++ 2005 Express Edition y ahora el código que escribimos va a tenerhighlighting.

Librería CUBLAS

Para utilizar la librería CUBLAS, hay que agregar los siguientes archivos al proyecto:

En Linker −→ Input −→ Additional Dependencies:cublas.lib cublasemu.lib


Figura A.4: Ventana de dialogo

Figura A.5: Valores de la aplicación

A.2. CONCEPTOS BÁSICOS 65

Figura A.6: Ventana del proyecto

A.2. Conceptos básicos

GLUT

El OpenGL Utilility Toolkit (GLUT), provee funciones para manejar eventos con ventanas, crearsimples menús, etc. Esto se utiliza para crear un contexto valido de OpenGL (permitiendo el accesoal hardware para gráficos a través del GL API) con unas cuantas líneas de código. Es independientede los sistemas operativos MS-Windows, Xfree/Xorg en Linux/Unix y Mac.

Renderización

Es el proceso de generar una imagen a partir de un modelo. Los medios por los que se puedehacer una renderización van desde lápiz, pluma, plumones o pastel, hasta medios digitales en dosy tres dimensiones. La palabra renderización proviene del inglés render, y no existe un verbo conel mismo significado en español, por lo que es frecuente usar las expresiones renderizar o renderear.La traducción más fidedigna es "interpretación", aunque se suele usar el término inglés. De estamanera podría decirse que en el proceso de renderización, la computadora "interpreta"la escena entres dimensiones y la plasma en una imagen bidimensional.

OpenGL para la Renderización

El tradicional punto final de toda operación de renderización es el frame buffer, un fragmen-to de memoria gráfica por el cual la imagen que aparece en la pantalla es leída. Dependiendo de laconfiguración de la pantalla, lo más que se puede tener son 32 bits de profundidad de color, com-partida entre los canales RGBA (Red, Green, Blue y Alpha), teniendo 8 bits para cada canal, estosuma más de 16 millones de colores diferentes.

Cuando queremos trabajar con punto flotante, los 8 bits son insuficientes con respecto a la pre-cisión, otro problema es que los datos estarán siempre sujetos al rango [0/255, 255/255], una vez quellegan al framebuffer. Afortunadamente, los valores en punto flotantes son proporcionados a través deun conjunto de extensiones del OpenGL, una extensión de OpenGL llamada EXT_framebuffer_objectpermite usar un offscreen buffer como el objeto a renderizar. Comúnmente se usa la abreviación FBOpara el framebuffer object.


Textures

Arreglos en la memoria GPU son llamados textures o texture samplers. Las dimensiones dela texture son limitadas, el máximo valor de cada dimensión puede ser obtenido con el siguientecódigo (una vez inicializado el GLUT):

int maxtexsize;//Para saber el valor máximo de cada dimensión de una textureglGetIntegerv(GL_MAX_TEXTURE_SIZE,&maxtexsize);printf(“GL_MAX_TEXTURE_SIZE:%d \ n”,maxtexsize);

Por ejemplo, al correr este código en una Tarjeta de Video NVIDIA GeForce 8800 GT 512MB, obtenemos un valor máximo de 8192, lo cual significa que podemos tener una texture en 3Dde tamaño 8192*8192*8192. En CPU utilizamos índices de arreglos, en GPU necesitamos coorde-nadas de la texture para accesar a los valores almacenados en dicha texture. Las coordenadas de latexture necesitan acceder al centro del texel, normalmente GPU trabaja con cuatro canales de color(RGBA).

A.3. Ejemplos de programación en CUDA

Ejemplo1. Leer imágenes desde la WebCam y desplegarlas utilizando una tarjeta de video.

En el archivo .cu pasamos el siguiente código:#include < stdio.h >

#include < conio.h >

#include < stdlib.h >

#include < string.h >

#include < math.h >

/*OpenGL*/#include < GL/glew.h >

#include < GL/glut.h >

/*CUDA*/#include < cuda_gl_interop.h >#include < cutil.h >

#include < cutil_gl_error.h >/*OpenCV*/#include < cv.h >

#include < cxtypes.h >

#include < highgui.h >

#include < cvaux.h >

typedef unsigned int TColor;//Tipo de dato utilizado para desplegar la imagen.void Cargar_imagen();int imageW=320, imageH=240; //Tamaño de la Imagen.

A.3. EJEMPLOS DE PROGRAMACIÓN EN CUDA 67

CvCapture *capture; //Apuntador a la WebCam.IplImage *frame=NULL;//Para guardar la imagen.

texture< uchar4, 2 > texImage;//Textura.GLuint gl_PBO, gl_Tex;//Para el buffer.

cudaChannelFormatDesc uchar4tex = cudaCreateChannelDesc< uchar4 >();//Tipo de datopara generar la memoria de la imagen en el device.cudaChannelFormatDesc uchartex = cudaCreateChannelDesc< uchar >();

uchar4 *imag_host;//Arreglo en hostcudaArray *imag_dev;//Arreglo en device

//Funciones __device__ para convertir los canales r,g,b a un tipo de dato unsigned int oTColor, y de esta forma mostrar los resultados.

__device__ TColor make_color(float r, float g, float b, float a){return ((int)(a * 255.0f) << 24) | ((int)(b * 255.0f) << 16) |((int)(g * 255.0f) << 8) | ((int)(r * 255.0f) << 0);

}

__device__ TColor make_color2(int r, int g, int b, int a){return (a << 24) | (b << 16) | (g << 8) | (r << 0);

}

__device__ TColor make_color3 (unsigned char r, unsigned char g,unsigned char b, unsigned char a){

return ((int)a << 24) | ((int)b << 16) | ((int)g << 8) | ((int)r << 0);}

//División techo.

int iDivUp(int a, int b){return ((a% b) != 0) ? (a / b + 1) : (a / b);

}

#include “Desplegar_kernel.cu”

#define BLOCKDIM_X 8#define BLOCKDIM_Y 8


dim3 threads(BLOCKDIM_X, BLOCKDIM_Y);dim3 grid(iDivUp(imageW, BLOCKDIM_X), iDivUp(imageH, BLOCKDIM_Y));

int g_Kernel = 0;bool g_FPS = false;unsigned int hTimer;const int frameN = 24;int frameCounter = 0;int GLwin;#define BUFFER_DATA(i) ((char *)0 + i)

void displayFunc(void){if(frameCounter++ == 0) cutResetTimer(hTimer);frame = cvQueryFrame( capture );if ( !frame ) {fprintf( stderr, “ERROR: frame is null...\n”);getchar();exit(0);}Cargar_imagen();CUDA_SAFE_CALL( cudaMemcpyToArray(imag_dev, 0, 0,imag_host,imageW *imageH * sizeof(uchar4), cudaMemcpyHostToDevice));TColor *d_dst = NULL;CUDA_SAFE_CALL( cudaGLMapBufferObject((void**)&d_dst,gl_PBO) );CUDA_SAFE_CALL( cudaBindTextureToArray(texImage, imag_dev));//RGBswitch (g_Kernel){

case 0: //Muestra la Imagen leída desde la WebCamDesplegar_Imagen<<<grid, threads>>>(d_dst,imageW, imageH);

break;}CUT_CHECK_ERROR(“Filtering kernel execution failed. \n”);CUDA_SAFE_CALL( cudaUnbindTexture(texImage) );CUDA_SAFE_CALL( cudaGLUnmapBufferObject(gl_PBO) );glTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, imageW, imageH, GL_RGBA,GL_UNSIGNED_BYTE, BUFFER_DATA(0)); //GL_COLOR_INDEX, GL_RED,//GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_RGBA, GL_LUMINANCE,//and GL_LUMINANCE_ALPHA.glBegin(GL_TRIANGLES);glTexCoord2f(0, 0); glVertex2f(-1, -1);glTexCoord2f(2, 0); glVertex2f(+3, -1);glTexCoord2f(0, 2); glVertex2f(-1, +3);glEnd();


glFinish();if (frameCounter == frameN){//Para mostrar la velocidad del método.frameCounter = 0;if (g_FPS){

printf(“FPS:% 3.1f \ n”, frameN /(cutGetTimerValue(hTimer) * 0.001) );g_FPS = false;

}}

}

void shutDown(unsigned char k, int x, int y){switch (k){

case ‘0’:printf(“Passthrough.\n”);g_Kernel = 0;

break;case ‘f’ : case ’F’:

g_FPS = true;break;case ‘\033’:case ‘q’:case ‘Q’:

printf(“Shutting down...\n”);CUT_SAFE_CALL( cutStopTimer(hTimer) );CUT_SAFE_CALL( cutDeleteTimer(hTimer) );CUDA_SAFE_CALL( cudaGLUnregisterBufferObject (gl_PBO) );glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, 0);glDeleteBuffers(1, &gl_PBO);glDeleteTextures(1, &gl_Tex);CUDA_SAFE_CALL( cudaFreeArray(imag_dev) );free(imag_host);printf(“Shutdown done.\n”);cvReleaseCapture( &capture );_exit(0);

break;}

}

int main(int argc, char **argv){CUT_DEVICE_INIT(); //Checa si hay un dispositivo para ejecutar código CUDA.capture= cvCaptureFromCAM(1);//Para el enlace con la WebCam.if (!cvGrabFrame(capture)){printf (“No puede grabar un frame \n” ) ;


exit(0);}frame = cvQueryFrame( capture );//Graba y retorna un frame a partir de//la cámara o archivo.if( !frame ) {fprintf( stderr, “ERROR: frame es NULL...\n” );getchar();exit(0);}imag_host = (uchar4 *)malloc(imageW * imageH * 4);//Generamos memoria//para la imagen en el host.Cargar_imagen();//Cargamos la imagen al host.CUDA_SAFE_CALL( cudaMallocArray(&imag_dev, &uchar4tex, imageW,imageH) ); //Generamos memoria para la imagen en el device.CUDA_SAFE_CALL( cudaMemcpyToArray(imag_dev,0,0,imag_host,imageW *imageH * sizeof(uchar4),cudaMemcpyHostToDevice));//Pasamos la imagen//del host al device.//Interfaz OpenGL.printf(“Inicializando GLUT...\n”);//GLUT: The OpenGL//Utility Toolkit, está diseñado para la construcción de pequeños ymedianos programas de OpenGL.glutInit(&argc, argv);glutInitDisplayMode(GLUT_RGBA | GLUT_SINGLE);glutInitWindowSize(imageW, imageH);glutInitWindowPosition(512 - imageW / 2, 384 - imageH / 2);GLwin = glutCreateWindow(“TUTORIAL CUDA”);printf(“Loading extensions:%s\n", glewGetErrorString (glewInit()));if(!glewIsSupported(“GL_VERSION_2_0 ” “GL_ARB_pixel_buffer_object”“GL_EXT_framebuffer_object ”)){fprintf(stderr, “ERROR: Support for necessary OpenGL extensionsmissing.”);fflush(stderr);return CUTFalse;}printf(“OpenGL window created.\n”);printf(“Creating GL texture...\n”);glEnable(GL_TEXTURE_2D);glGenTextures(1, &gl_Tex);//a: Especifica el número de nombres de//las texture a ser generadas. b: Especifica el arreglo en el cual//los nombres de las texture generadas son almacenadas.glBindTexture(GL_TEXTURE_2D, gl_Tex);glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);


glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, imageW, imageH, 0,GL_RGBA, GL_UNSIGNED_BYTE, imag_host);printf(“Texture created.\n”);printf(“Creating PBO...\n”);glGenBuffers(1,&gl_PBO);//a: Especifica el número de nombres de//objetos buffer a ser generados. b: Especifica el arreglo en el cual//los nombres de los buffer generado son almacenados.glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, gl_PBO);glBufferData(GL_PIXEL_UNPACK_BUFFER_ARB, imageW * imageH * 4,imag_host, GL_STREAM_COPY);CUDA_SAFE_CALL( cudaGLRegisterBufferObject(gl_PBO) );CUT_CHECK_ERROR_GL();printf(“PBO created.\n”);printf(“Starting GLUT main loop...\n”);printf(“Press [0] Para ver la Imagen\n”);printf(“Press [f] Velocidad\n”);printf(“Press [q] Salir\n”);glutIdleFunc(displayFunc);glutDisplayFunc(displayFunc);glutKeyboardFunc(shutDown);CUT_SAFE_CALL( cutCreateTimer(&hTimer) );CUT_SAFE_CALL( cutStartTimer(hTimer) );glutMainLoop();CUT_EXIT(argc, argv);

}

/*******************************************************************************PROCEDIMIENTO: Cargar_imagenPARÁMETROS: voidDESCRIPCION: Procedimiento que se encarga de pasar la imagen leída desde OpenCV comoIplImage a un tipo de dato uchar4, esto para después poder manipularla con la tarjeta devideo.********************************************************************************/

void Cargar_imagen(){int nc=imageW*3,k=0;int step= frame− >widthStep;unsigned char *data=reinterpret_cast< unsignedchar∗ >(frame− >imageData);for (int i=0;i<imageH;i++){


k=0;for (int j=0; j<nc;j+=3){

//En OpenCV el orden es BGR(imag_host)[(i * imageW + k)].x = (int)(data[j+2]);(imag_host)[(i * imageW + k)].y = (int)(data[j+1]);(imag_host)[(i * imageW + k)].z = (int)(data[j]);k++;

}data+= step;

}}

En el archivo Desplegar_kernel.cu pasamos el siguiente código:

__global__ void Desplegar_Imagen(TColor *Imag, int imageW, int imageH){const int ix = blockDim.x * blockIdx.x + threadIdx.x;const int iy = blockDim.y * blockIdx.y + threadIdx.y;//Add half of a texel to always address exact texel centersconst float x = (float)ix + 0.5f;const float y = (float)iy + 0.5f;if (ix < imageW && iy < imageH){uchar4 fresult = tex2D(texImage, x, y);Imag[imageW * iy + ix] = make_color3(fresult.x, fresult.y, fresult.z, 0);}

}

Finalmente compilamos y ejecutamos el programa.

Ejemplo2. Difusión.

Tenemos el siguiente funcional:

U (f(x)) =12

∑x

(f(x)− g(x))2 +λ

2

∑<x,y>

(f(x)− f(y))2 , (A.1)

Si derivamos A.1 con respecto a f(x) e igualamos a cero obtenemos:

f(x) =g(x) + λ

∑<x,y> f(y)

1 + λ|Nx|, (A.2)

con |Nx| = Número de vecinos del pixel. Podemos resolver A.2, iterando e inicializando f(x)0 = g(x).Para llevar esto a GPU, en el Ejemplo1 ya tenemos como pasar una imagen leída desde la WebCamal dispositivo, entonces podemos tener a las imágenes f(x) y g(x) guardadas en textures, copiamosel código del Ejemplo1 y agregamos el siguiente código, en donde vamos a utilizar las textures comouchar y como float:


En la parte de los include.#include “Difusion_Imagen_kernel.cu”

En la parte de declaración de variables.texture< uchar4, 2 > texImage2;texture< uchar4, 2, cudaReadModeNormalizedF loat > texImagef;//Texture en floattexture< uchar4, 2, cudaReadModeNormalizedF loat > texImagef2;cudaArray *imag_dev2;/*Variables para la Difusión*/int lambda=30, den=1+lambda*4, Max_Iter=50;

En la función displayFunc.CUDA_SAFE_CALL( cudaBindTextureToArray(texImage2, imag_dev) );CUDA_SAFE_CALL( cudaBindTextureToArray(texImagef, imag_dev) );//RGB float4CUDA_SAFE_CALL( cudaBindTextureToArray(texImagef2, imag_dev) );

case 1://Difusión de una Imagen en una texture en ucharfor (int iter=0;iter<Max_Iter;iter++){

Difusion_Imagen<<< grid, threads >>>(imag_desp,lambda,den,imageW,imageH);//Actualizamos la texture de la imagen f(x)CUDA_SAFE_CALL( cudaMemcpyToArray(imag_dev2, 0, 0, imag_desp,imageW * imageH * sizeof (TColor), cudaMemcpyDeviceToDevice));CUDA_SAFE_CALL( cudaBindTextureToArray(texImage2,imag_dev2));

}break;case 2://Difusión de una Imagen en una texture en float

for(int iter=0;iter<Max_Iter;iter++){Difusion_Imagenf<<< grid, threads >>>(imag_desp,lambda,den,imageW,imageH);//Actualizamos la texture de la imagen f(x)CUDA_SAFE_CALL( cudaMemcpyToArray(imag_dev2, 0, 0,imag_desp,imageW * imageH * sizeof(TColor), cudaMemcpyDeviceToDevice));CUDA_SAFE_CALL( cudaBindTextureToArray(texImagef2,imag_dev2));

}break;

En la función shutDown.

case ‘1’:printf(“Difusión con imagen en uchar.\n”);g_Kernel = 1;

break;case ‘2’:

printf(“Difusión con imagen en float.\n”);g_Kernel = 2;


break;case ‘\033’:case ‘q’:case ‘Q’:

CUDA_SAFE_CALL( cudaFreeArray(imag_dev2) );break;

En el main.CUDA_SAFE_CALL( cudaMallocArray(&imag_dev2, &uchar4tex, imageW, imageH) );printf(“Press [1] Para Difusión con imagen en uchar\n”);printf(“Press [2] Para Difusión con imagen en float\n”);

Creamos un archivo “Difusion_Imagen_kernel.cu” y agregamos el siguiente código:

__device__ uchar3 Compute_Difusion(uchar4 g,uchar4 f01,uchar4 f10,uchar4f21,uchar4 f12,int lambda,int den){

uchar3 result;result.x=(g.x+lambda*(f01.x+f10.x+f21.x+f12.x))/den;result.y=(g.y+lambda*(f01.y+f10.y+f21.y+f12.y))/den;result.z=(g.z+lambda*(f01.z+f10.z+f21.z+f12.z))/den;return result;

}__device__ float3 Compute_Difusionf(float4 g,float4 f01,float4 f10,float4f21,float4 f12,int lambda,int den){

float3 result;result.x=(g.x+lambda*(f01.x+f10.x+f21.x+f12.x))/den;result.y=(g.y+lambda*(f01.y+f10.y+f21.y+f12.y))/den;result.z=(g.z+lambda*(f01.z+f10.z+f21.z+f12.z))/den;return result;

}__global__ void Difusion_Imagen(TColor *Imag_d,int lambda,int den,int w,int h){

const int ix = blockDim.x * blockIdx.x + threadIdx.x;const int iy = blockDim.y * blockIdx.y + threadIdx.y;const float x=(float)ix+0.5f;const float y=(float)iy+0.5f;if (ix < w && iy < h){uchar4 g = tex2D(texImage, x, y);uchar4 f01 = tex2D(texImage2, x-1, y);uchar4 f10 = tex2D(texImage2, x, y-1);uchar4 f21 = tex2D(texImage2, x+1, y);uchar4 f12 = tex2D(texImage2, x, y+1);uchar3 result=Compute_Difusion(g,f01,f10,f21,f12,lambda,den);Imag_d[w*iy+ix]=make_color3(result.x, result.y, result.z,0);


}}__global__ void Difusion_Imagenf(TColor *Imag_d,int lambda,int den,int w,int h){

const int ix = blockDim.x * blockIdx.x + threadIdx.x;const int iy = blockDim.y * blockIdx.y + threadIdx.y;const float x=(float)ix+0.5f;const float y=(float)iy+0.5f;if(ix < w && iy < h){float4 g = tex2D(texImagef, x, y);float4 f01 = tex2D(texImagef2, x-1, y);float4 f10 = tex2D(texImagef2, x, y-1);float4 f21 = tex2D(texImagef2, x+1, y);float4 f12 = tex2D(texImagef2, x, y+1);float3 result=Compute_Difusionf(g,f01,f10,f21,f12,lambda,den);Imag_d[w*iy+ix]=make_color(result.x, result.y, result.z, 0);}

}

Finalmente compilamos y ejecutamos el programa.

Guardar video. Si queremos guardar el video de la imagen normal y la imagen con difusión delEjemplo 2, podemos utilizar la función “cvCreateVideoWriter” del OpenCV, para esto, agregamosel siguiente código:

En la parte de declaración de variables.CvVideoWriter* videowriter;//Para grabar el video.CvVideoWriter* videowriter_2;

En el main.videowriter = cvCreateVideoWriter(“SEC_NORMAL.avi”,CV_FOURCC(’D’,’I’,’V’,’X’),30,cvSize(imageW, imageH), 1);videowriter_2 = cvCreateVideoWriter(“SEC_DIFUSION.avi”,CV_FOURCC(’D’,’I’,’V’,’X’),30,cvSize(imageW,imageH),1);

En la función displayFunc.

case 1://Difusión de una Imagen en una texture en ucharfor (int iter=0;iter<Max_Iter;iter++){

Difusion_Imagen<<< grid, threads >>>(imag_desp,lambda,den,imageW,imageH);//Actualizamos la texture de la imagen f(x)CUDA_SAFE_CALL( cudaMemcpyToArray(imag_dev2, 0, 0, imag_desp,imageW * imageH * sizeof (TColor), cudaMemcpyDeviceToDevice));CUDA_SAFE_CALL( cudaBindTextureToArray(texImage2,imag_dev2));

}//Para grabar el video


cvWriteFrame(videowriter, frame);CUDA_SAFE_CALL( cudaMemcpy(uc4_imag_original,imag_desp, (imageW) * (imageH)*sizeof(TColor), cudaMemcpyDeviceToHost));Regresar_imagen_GPU_OPENCV();cvWriteFrame(videowriter_2, frame);

break;case 2://Difusión de una Imagen en una texture en float

for(int iter=0;iter<Max_Iter;iter++){Difusion_Imagenf<<< grid, threads >>>(imag_desp,lambda,den,imageW,imageH);//Actualizamos la texture de la imagen f(x)CUDA_SAFE_CALL( cudaMemcpyToArray(imag_dev2, 0, 0,imag_desp,imageW * imageH * sizeof(TColor), cudaMemcpyDeviceToDevice));CUDA_SAFE_CALL( cudaBindTextureToArray(texImagef2,imag_dev2));

}//Para grabar el videocvWriteFrame(videowriter, frame);CUDA_SAFE_CALL( cudaMemcpy(uc4_imag_original,imag_desp, (imageW) * (imageH)*sizeof(TColor), cudaMemcpyDeviceToHost));Regresar_imagen_GPU_OPENCV();cvWriteFrame(videowriter_2, frame);

break;

En el archivo .cu (o en el host)./*******************************************************************************PROCEDIMIENTO: Regresar_imagen_GPU_OPENCVPARÁMETROS: voidDESCRIPCION: Procedimiento que se encarga de pasar la imagen que tenemos enel host a el tipo de dato IplImage del OpenCV.********************************************************************************/

void Regresar_imagen_GPU_OPENCV(){int nc=imageW*3,k=0;int step= frame→widthStep;IplImage *frameaux;frameaux=cvCloneImage(frame);frameaux→imageData=frame→imageData;for (int i=0;i<imageH;i++){

k=0;for (int j=0; j<nc;j+=3){

//En OpenCV el orden es BGRframe→imageData[j+2]=(imag_host)[(i * imageW + k)].x;frame→imageData[j+1]=(imag_host)[(i * imageW + k)].y ;frame→imageData[j]=(imag_host)[(i * imageW + k)].z ;


k++;}frame→imageData+= step;

}frame→imageData=frameaux→imageData;}

En la parte de Declaración de funciones.void Regresar_imagen_GPU_OPENCV();


case ‘\’:case ‘q’:case ‘Q’:

cvReleaseVideoWriter(&videowriter);cvReleaseVideoWriter(&videowriter_2);

break;

Finalmente compilamos y ejecutamos el programa, entonces cuando finalicemos la ejecucióndel programa, se generarán dos archivos de video (“SEC _NORMAL.avi” y “SEC _DIFU-SION.avi”) en el directorio donde se encuentra el programa que ejecutamos.

A continuación, en las Figuras (A.7) y (A.8) se muestran algunos resultados, la primera fila deimágenes es la secuencia de video normal y la segunda fila es la secuencia de video con difusión.

Ejemplo3. Derivadas parciales, magnitud del gradiente, umbral por valor, corrimiento circu-lar y corrimiento no circular.

Para el caso de las derivadas parciales, tenemos tres formas de calcularlas, podemos convolu-cionar la imagen con cualquiera de los tres kernels de primera derivada que se muestran en la Figura(A.9). La magnitud del gradiente la calculamos mediante la relación A.3.

|∇f(z)| =√f2x(z) + f2

y (z), (A.3)

donde z = (x, y) es la posición del pixel.

Para el umbral por valor, tenemos la imagen en escala de gris entre [0, 1] y dado un valor(umbral) hacemos lo siguiente:

Si f(x) > umbral entoncesf(x)=1

de lo contrariof(x)=0


Para los corrimientos necesitamos como entrada el desplazamiento en x y en y, de esta manera,podemos tener dos tipos de corrimiento: circular y no circular. Ahora programamos esto en GPU,copiamos el código del Ejemplo1 y agregamos lo siguiente:

En la parte de los include.#include “DerivadasParciales_kernel.cu”#include “MagnitudGradiente_kernel.cu”#include “UmbralImagen_kernel.cu”#include “ShiftImagen_kernel.cu”

En la parte de declaración de variables.texture< uchar4, 2, cudaReadModeNormalizedF loat > texImagef;//Texture float RGBtexture< unsignedchar, 2, cudaReadModeNormalizedF loat > texImagefGris;//Texture floatGrisfloat *Dx=NULL;float *Dy=NULL;float *MG=NULL;float *IUmb=NULL;float *IShift=NULL;float3 *IShiftRGB=NULL;

En la función displayFunc.CUDA_SAFE_CALL( cudaBindTextureToArray(texImagef, imag_dev) );//RGB float4 CU-DA_SAFE_CALL( cudaBindTextureToArray(texImagefGris, imag_dev) );//Gris float

case 1://Derivada Parcial en x.//Dxb<<< grid, threads >>>(Dx,imageW,imageH);//Dxf<<< grid, threads >>>(Dx,imageW,imageH);Dxc<<< grid, threads >>>(Dx,imageW,imageH);Desplegar_ArregloCUf<<< grid, threads >>>(imag_desp,Dx,imageW, imageH);break;

case 2://Derivada Parcial en y.//Dyb<<< grid, threads >>>(Dy,imageW,imageH);//Dyf<<< grid, threads >>>(Dy,imageW,imageH);Dyc<<< grid, threads >>>(Dy,imageW,imageH);Desplegar_ArregloCUf<<< grid, threads >>>(imag_desp,Dy,imageW, imageH);break;

case 3://Magnitud del Gradiente.Dxc<<< grid, threads >>>(Dx,imageW,imageH);Dyc<<< grid, threads >>>(Dy,imageW,imageH);MagnitudGradiente<<< grid, threads >>>(MG,Dx,Dy,imageW,imageH);Desplegar_ArregloCUf<<< grid, threads >>>(imag_desp,MG,imageW, imageH);break;

case 4://Umbral por valor.


Umbral_porvalor<<< grid, threads >>>(IUmb,0.5,imageW,imageH);Desplegar_ArregloCUf<<< grid, threads >>>(imag_desp,IUmb,imageW, imageH);break;

case 5://Shift Circular Gris.//ShiftCircular<<< grid, threads >>>(IShift,-15,-15,imageW,imageH);Inicializar_Cero<<< grid, threads >>>(IShift,imageW,imageH);ShiftNoCircular<<< grid, threads >>>(IShift,-15,-15,imageW,imageH);Desplegar_ArregloCUf<<< grid, threads >>>(imag_desp,IShift,imageW, imageH);break;

case 6://Shift Circular RGB.//ShiftCircularRGB<<< grid, threads >>>(IShiftRGB,-15,-15,imageW,imageH);Inicializar_CeroRGB<<< grid, threads >>>(IShiftRGB,imageW,imageH);ShiftNoCircularRGB<<< grid, threads >>>(IShiftRGB,-15,-15,imageW,imageH);Desplegar_ArregloCUf_RGB<<< grid, threads >>>(imag_desp, IShiftRGB, imageW, imageH);break;

Creamos un archivo “DerivadasParciales_kernel.cu” y agregamos el siguiente código:// Parcial con repecto a x (backwards)

__global__ void Dxb(float *Dx,int w,int h){const int ix = blockDim.x * blockIdx.x + threadIdx.x;const int iy = blockDim.y * blockIdx.y + threadIdx.y;const float x=(float)ix+0.5f;const float y=(float)iy+0.5f;if (ix < w && iy < h){float pix11=tex2D(texImagefGris, x, y);float pix10=tex2D(texImagefGris, x, y-1);Dx[w * iy + ix]=(pix11-pix10);}

}// Parcial con repecto a y (backwards)__global__ void Dyb(float *Dy,int w,int h){

const int ix = blockDim.x * blockIdx.x + threadIdx.x;const int iy = blockDim.y * blockIdx.y + threadIdx.y;const float x=(float)ix+0.5f;const float y=(float)iy+0.5f;if(ix < w && iy < h){float pix11=tex2D(texImagefGris, x, y);float pix01=tex2D(texImagefGris, x-1, y);Dy[w * iy + ix]=(pix11-pix01);}

}


// Parcial con repecto a x (forwards)__global__ void Dxf(float *Dx,int w,int h){

const int ix = blockDim.x * blockIdx.x + threadIdx.x;const int iy = blockDim.y * blockIdx.y + threadIdx.y;const float x=(float)ix+0.5f;const float y=(float)iy+0.5f;if(ix < w && iy < h){float pix11=tex2D(texImagefGris, x, y);float pix12=tex2D(texImagefGris, x, y+1);Dx[w * iy + ix]=(pix12-pix11);}

}// Parcial con repecto a y (forwards)__global__ void Dyf(float *Dy,int w,int h){

const int ix = blockDim.x * blockIdx.x + threadIdx.x;const int iy = blockDim.y * blockIdx.y + threadIdx.y;const float x=(float)ix+0.5f;const float y=(float)iy+0.5f;if(ix < w && iy < h){float pix11=tex2D(texImagefGris, x, y);float pix21=tex2D(texImagefGris, x+1, y);Dy[w * iy + ix]=(pix21-pix11);}

}// Parcial con repecto a x (centrada)__global__ void Dxc(float *Dx,int w,int h){

const int ix = blockDim.x * blockIdx.x + threadIdx.x;const int iy = blockDim.y * blockIdx.y + threadIdx.y;const float x=(float)ix+0.5f;const float y=(float)iy+0.5f;if(ix < w && iy < h){float pix10=tex2D(texImagefGris, x, y-1);float pix12=tex2D(texImagefGris, x, y+1);Dx[w * iy + ix]=(pix12-pix10);}

}// Parcial con repecto a y (centrada)__global__ void Dyc(float *Dy,int w,int h){

const int ix = blockDim.x * blockIdx.x + threadIdx.x;const int iy = blockDim.y * blockIdx.y + threadIdx.y;const float x=(float)ix+0.5f;const float y=(float)iy+0.5f;


if(ix < w && iy < h){float pix01=tex2D(texImagefGris, x-1, y);float pix21=tex2D(texImagefGris, x+1, y);Dy[w * iy + ix]=(pix21-pix01);}

}

Creamos un archivo “MagnitudGradiente_kernel.cu” y agregamos el siguiente código:// Magnitud del Gradiente dados la parcial en (x, y)

__global__ void MagnitudGradiente(float *MG,float *Dx,float *Dy,int w,int h){const int ix = blockDim.x * blockIdx.x + threadIdx.x;const int iy = blockDim.y * blockIdx.y + threadIdx.y;if (ix < w && iy < h){float d_x=Dx[w * iy + ix];float d_y=Dy[w * iy + ix];MG[w * iy + ix]=sqrt(d_x*d_x+d_y*d_y);}

}

Creamos un archivo “UmbralImagen_kernel.cu” y agregamos el siguiente código:// Umbralizar la Imagen por valor.

__global__ void Umbral_porvalor(float *IUmb,float umbral,int w,int h){const int ix = blockDim.x * blockIdx.x + threadIdx.x;const int iy = blockDim.y * blockIdx.y + threadIdx.y;const float x=(float)ix+0.5f;const float y=(float)iy+0.5f;if (ix < w && iy < h){float pix11=tex2D(texImagefGris, x, y);IUmb[w * iy + ix]=(pix11 > umbral) ? 1.0 : 0.0 ;}

}

Creamos un archivo “ShiftImagen_kernel.cu” y agregamos el siguiente código:// Shift Circular de la Imagen.

__global__ void ShiftCircular(float *IShift,int i0,int j0,int w,int h){const int ix = blockDim.x * blockIdx.x + threadIdx.x;const int iy = blockDim.y * blockIdx.y + threadIdx.y;const float x=(float)ix+0.5f;const float y=(float)iy+0.5f;i0 = (i0+w)%w;j0 = (j0+h)%h;


if (ix <w && iy <h){float pix11=tex2D(texImagefGris, x, y);IShift[(w *((iy+j0)%h)) + ((ix+i0)%w)]= pix11;}

}__global__ void Inicializar_Cero(float *Imag,int w,int h){

const int ix = blockDim.x * blockIdx.x + threadIdx.x;const int iy = blockDim.y * blockIdx.y + threadIdx.y;if(ix < w && iy < h){Imag[w*iy + ix]= 0.0;}

}// Shift No Circular de la Imagen.__global__ void ShiftNoCircular(float *IShift,int i0,int j0,int w,int h){

const int ix = blockDim.x * blockIdx.x + threadIdx.x;const int iy = blockDim.y * blockIdx.y + threadIdx.y;const float x=(float)ix+0.5f;const float y=(float)iy+0.5f;if(ix < w && iy < h){if ((ix+i0)<w && (iy+j0)<h && (ix+i0)>=0&&(iy+j0)>=0){float pix11=tex2D(texImagefGris, x, y);IShift[(w *(iy+j0)) + (ix+i0)]= pix11;}}

}// Shift Circular de la Imagen en RGB__global__ void ShiftCircularRGB(float3 *IShift,int i0,int j0,int w,int h){

const int ix = blockDim.x * blockIdx.x + threadIdx.x;const int iy = blockDim.y * blockIdx.y + threadIdx.y;const float x=(float)ix+0.5f;const float y=(float)iy+0.5f;i0 = (i0+w)%w;j0 = (j0+h)%h;if(ix < w && iy < h){float4 pix11=tex2D(texImagef, x, y);IShift[(w *((iy+j0)%h)) + ((ix+i0)%w)].x= pix11.x;IShift[(w *((iy+j0)%h)) + ((ix+i0)%w)].y= pix11.y;IShift[(w *((iy+j0)%h)) + ((ix+i0)%w)].z= pix11.z;}

}__global__ void Inicializar_CeroRGB(float3 *Imag,int w,int h){


const int ix = blockDim.x * blockIdx.x + threadIdx.x;const int iy = blockDim.y * blockIdx.y + threadIdx.y;if(ix < w && iy < h){Imag[w*iy + ix].x= 0.0;Imag[w*iy + ix].y= 0.0;Imag[w*iy + ix].z= 0.0;}

}// Shift No Circular de la Imagen en RGB.__global__ void ShiftNoCircularRGB(float3 *IShift,int i0,int j0,int w,int h){

const int ix = blockDim.x * blockIdx.x + threadIdx.x;const int iy = blockDim.y * blockIdx.y + threadIdx.y;const float x=(float)ix+0.5f;const float y=(float)iy+0.5f;if(ix < w && iy < h){if((ix+i0)<w && (iy+j0)<h && (ix+i0)>=0&&(iy+j0)>=0){float4 pix11=tex2D(texImagef, x, y);IShift[(w *(iy+j0)) + (ix+i0)].x= pix11.x;IShift[(w *(iy+j0)) + (ix+i0)].y= pix11.y;IShift[(w *(iy+j0)) + (ix+i0)].z= pix11.z;}}

}


case ‘1’:printf(“Derivada parcial en x.\n”);g_Kernel = 1;break;

case ‘2’:printf(“Derivada parcial en y.\n”);g_Kernel = 2;break;

case ‘3’:printf(“Magnitud del gradiente.\n”);g_Kernel = 3;break;

case ‘4’:printf(“Umbral por valor.\n”);g_Kernel = 4;break;


case ‘5’:printf(“Shift en Gris.\n”);g_Kernel = 5;break;

case ‘6’:printf(“Shift en RGB.\n”);g_Kernel = 6;break;

case ‘\033’:case ‘q’:case ‘Q’:

cudaFree(Dx);cudaFree(Dy);cudaFree(MG);cudaFree(IUmb);cudaFree(IShift);cudaFree(IShiftRGB);break;

En el main.cudaMalloc((void **)&Dx,imageW * imageH * sizeof(float));cudaMalloc((void **)&Dy,imageW * imageH * sizeof(float));cudaMalloc((void **)&MG,imageW * imageH * sizeof(float));cudaMalloc((void **)&IUmb,imageW * imageH * sizeof(float));cudaMalloc((void **)&IShift,imageW * imageH * sizeof(float));cudaMalloc((void **)&IShiftRGB,imageW * imageH * sizeof(float3));printf(“Press [1] Derivada parcial en x\n”);printf(“Press [2] Derivada parcial en y\n”);printf(“Press [3] Magnitud del gradiente\n”);printf(“Press [4] Umbral por valor\n”);printf(“Press [5] Shift en Gris\n”);printf(“Press [6] Shift en RGB\n”);

En el archivo “Desplegar_kernel.cu” agregamos el siguiente código://Para desplegar el arreglo ArrCU en Gris.

__global__ void Desplegar_ArregloCUf(TColor *Imag,float *ArrCU,int w,int h){const int ix = blockDim.x * blockIdx.x + threadIdx.x;const int iy = blockDim.y * blockIdx.y + threadIdx.y;if (ix < w && iy < h){float valor=ArrCU[w * iy + ix];Imag[w * iy + ix] = make_color(valor,valor,valor,0);}


Figura A.7: Resultado de la Difusión 1. Con parámetros: lambda=10 y Max_Iter=20.

Figura A.8: Resultado de la Difusión 2. Con parámetros: lambda=30 y Max_Iter=50.

}//Para desplegar el arreglo ArrCU en RGB.__global__ void Desplegar_ArregloCUf_RGB(TColor *Imag,float3 *ArrCU,int w,int h){

const int ix = blockDim.x * blockIdx.x + threadIdx.x;const int iy = blockDim.y * blockIdx.y + threadIdx.y;if(ix < w && iy < h){float3 valor=ArrCU[w * iy + ix];Imag[w * iy + ix] = make_color(valor.x,valor.y,valor.z,0);}

}

Finalmente compilamos y ejecutamos el programa, en la Figura (A.10) se muestran algunosresultados.


Figura A.9: Kernel de primera derivada. (a) hacia atrás. (b) centrada. (c) hacia adelante.

Figura A.10: Operadores en Imágenes. (a) Derivada parcial en x. (b) Derivada parcial en y. (c)Magnitud del gradiente. (d) Umbral por valor. (e) Corrimiento no circular en Gris. (f) Corrimientono circular en RGB.

Bibliografía

[1] Mariano Rivera and Pedro P. Mayorga. Quadraticmarkovian probability fields for image binarysegmentation. ICV’07, 2007.

[2] Lawrence G. Roberts. Machine perception of three-dimensional solids. Optical and electro-optical information processing, pages 159–197, 1965.

[3] Peter Kauff and Oliver Schreer. An inmersive 3d video-conferencing system using shared virtualteam user enviroments. ACM., 2002.

[4] A. Blake A. Criminisi, G. Cross and V. Kolmogorov. Bilayer segmentation of live video. Mi-crosoft Research Ltd., Cambrige., 2006.

[5] Juyong L. Hyeran B. Sooyeong K., Ilkwon P. and Guntae B. Automatic background substitutionusing monocular camera and temporal foreground probability model. ACM, ISBN(978-1-59593-993-7):506–510, 2008.

[6] Nicola S. Stefano M., Carla M. M. and Michele Z. A kalman filter based background updatingalgorithm robust to sharp illumination changes. ICIAP, vol(3617):163–170, 2005.

[7] Olaf M. Christof R. and Harald K. Adaptive background estimation and foreground detectionusing kalman-filtering. 1995.

[8] David H. Kyungnam K., Thanarat H. and Larry D. Real-time foreground-background segmen-tation using codebook model. Elseiver Ltd., 2005.

[9] A. Cavallaro E. Salvador and T. Ebrahimi. Shadow identification and classification using invari-ant color models. in Proc. Int. Conf. Acoustics, Speech, and Signal Processing., Vol(3):1545–1548, 2001.

[10] A. Cavallaro E. Salvador and T. Ebrahimi. Detecting shadows in image sequences. IEEE.,Issue(15-16):165 – 174, 2004.

[11] Weiming H. Jianguang L., Hao Y. and Tieniu T. An illumination invariant change detectionalgorithm. Asian Conference on Computer Vision (ACCV)., 2002.

[12] Grantham K.H. Pang George F.K. Fung, Nelson H.C. Yung and Andrew H.S. Lai. Effectivemoving cast shadow detection for monocular color traffic image sequences. Society of Photo-Optical Instrumentation Engineers., 41(6):1425–1440, 2002.

87

88 BIBLIOGRAFÍA

[13] T. D´Orazio P. Spagnolo, M. Leo and A. Distante. Robust moving objects segmentation bybackground subtraction. C.N.R., 2004.

[14] M. Ribeiro G. Monteiro, J. Marcos and J. Batista. Roboust segmentation process to detectincidents on highways. ICIAR, LNCS(5112):110–121, 2008.

[15] Andreas Griesser. Real-time, gpu-based foreground-background segmentation. VMV, TechnicalReport(269), 2005.

[16] Y. IWAHORI S. FUKUI and R. J. WOODHAM. Gpu based extraction of moving objectswithout shadows under intensity changes. IEEE, pages 4166–4173, 2008.

[17] Li S.Z. Markov random field modeling in image analysis. Springer-Verlag, Tokio, 2001.

[18] Geman S. and Geman D. Stochastic relaxation,gibbs distribution and thebayesian restorationof images. IEEE PAMI, 6(6):721–741, 1984.

[19] Besag J. On the statistical analisys of dirty pictures. J.R. Stat. Soc. Ser. B, Methodol(48):259–302, 1986.

[20] Veksler O. Boykov Y. and Zabih R. Fast approximate energy minimization via graph cuts.IEEE Trans. Pattern Anal. Machine Intell, 23(11):1222–1239, 2001.

[21] Blake A. Cross G. Kolmogorov V., Criminisi A. and Rother C. Probabilistic fusion of stereowith color and contrast for bi-layer segmentation. IEEE Trans. Pattern Anal. Machine Intell,28(9):1480–1492, 2006.

[22] John P. Boyd. Chebyshev and Fourier Spectral Methods. DOVER, 31 East 2nd Street Mineola,New York 11501, 2000.

[23] M. Forero-Vargas R. Redondo G. Cristobal, S. Fischer and J. Hormigo. Texture segmenta-tion and analysis using local spectral methods. Proceedings. Seventh International Symposium,1:129–132, 2003.

[24] Jorge Nocedal and Stephen J. Wright. Numerical Optimization. Springer Series in OperationResearch, 2000.

[25] Tibshirani R. Hastie T. and Friedman J. The elements of statistical learning. Springer, 2001.

[26] O. Dalmau M. Rivera and J. Tago. Image segmentation by convex quadratic programming. Int.Conf. on Pattern Recognition (ICPR08), 2008.

[27] Al Bovik. Handbook of image and video processing. Elsevier, 2005.

[28] B. Lucas and T. Kanade. An iterative image registration technique with an application to stereovision. IJCAI, pages 121–130, 1981.

[29] Eva Horster and Rainer Lienhart. Call for algorithm competition in foreground/backgroundsegmentation. Website, 2006. http://mmc36.informatik.uni-augsburg.de/VSSN06_OSAC/.

[30] ATON. Shadow detection. Website. http://cvrr.ucsd.edu/aton/shadow.

http://mmc36.informatik.uni-augsburg.de/VSSN06_OSAC/

http://cvrr.ucsd.edu/aton/shadow

BIBLIOGRAFÍA 89

[31] Statistical modeling of complex background for foreground object detection. Website. http://perception.i2r.a-star.edu.sg/bk_model/bk_index.html.

[32] Andrea Prati, Ivana Mikic, Mohan M. Trivedi, and Rita Cucchiara. Detecting moving shadows:Algorithms and evaluation. IEEE Transactions on Pattern Analysis and Machine Intelligence.,25:918–923, 2003.

[33] Liyuan Li, Weimin Huang, Irene Y. H. Gu, and Qi Tian. Foreground object detection fromvideos containing complex background. InMULTIMEDIA ’03: Proceedings of the eleventh ACMinternational conference on Multimedia, pages 2–10, New York, NY, USA, 2003. ACM.

[34] NVIDIA. Cuda zone. Website, 2008. http://www.nvidia.com/object/cuda_get.html.

http://perception.i2r.a-star.edu.sg/bk_model/bk_index.html

http://perception.i2r.a-star.edu.sg/bk_model/bk_index.html

http://www.nvidia.com/object/cuda_get.html

tesis de maestría - cimat.repositorioinstitucional.mx 282.pdf ·...

Documents