evaluación de técnicas para la detección de las partes ... · este trabajo de investigación...

Evaluación de técnicas para la detección de las partes estáticas y las partes móviles de una escena en secuencias de video Aimer Christian Vidal González

Febrero 2014 Página 2



Agradecimientos Al Consejo Nacional de Ciencia y Tecnología (CONACyT) por el apoyo económico que me proporcionó a lo largo de mis estudios de maestría. Al Centro Nacional de Investigación y Desarrollo Tecnológico (CENIDET) por el conocimiento adquirido en estos dos años de aprendizaje. A Dios por darme la oportunidad de comenzar y concluir mis estudios de maestría. Un especial agradecimiento a mi familia, mis padres, hermanos y abuelos por su apoyo incondicional en esta aventura y sobre todo por el gran amor que me han brindado en todos mis años de vida. A mi director el Dr. José Ruíz Ascencio por orientarme y guiarme para alcanzar los objetivos planteados, por sus enseñanzas, por la confianza que me tuvo. A mis revisores el Dr. Raúl Pinto Elías y el Dr. Manuel Mejía Lavalle por su tiempo, comentarios, consejos, observaciones e interés mostrado en esta investigación. A mis amigos Edgar López, Jaime Boanerjez, Cruz Lázaro, Cesar Geovani, Jesse Rumbo, Said Martagón, Raquel Ortiz, Ricardo Lozano, Emanuel Sosa, Flavio Aquiles, Gaby De León, Uriel García, Diana Evangelista, Clarisa Sarabia, Jessica González, Jorge Fuentes, Lety Aponte, Liz Sánchez, Fernando Castro, Ale Molina, Wendy Sánchez, Adrián Cruz, Ale Moreno, Armando López, Carlos Pérez, Francisco Barrera, Cesar Octavio, Héctor Uriel, Irving Omar, Julio Rodríguez, Karla Membrila, Selene Yosahandy, Israel Galán, Oscar Lozano, Yazmin Ávila, Salvador Escorcia, Elizabeth Cadenas, Rubí Martínez, Rafael Alcantar, Verónica Ortega, Abel Vázquez, Jesús Rodríguez, Eduardo Pedroza, Alberto Ocampo, Celestino Estrada, Andrés Vergara por su amistad y apoyo en los buenos y malos ratos; así para algunos por sus consejos y asesorías que me ayudaron a aclarar ideas durante el desarrollo de la tesis. A todos los amigos que conocí aquí en Cuernavaca, Puebla, Acapulco y Cd. de México sin los cuales no habría sido lo mismo.



Resumen Este trabajo de investigación aborda la detección de las partes estáticas y las partes móviles de una escena en secuencias de video. Para secuencias tomadas por una cámara estática usa como caso de estudio a los sistemas de videovigilancia y para las secuencias de cámara móvil toma recorridos de la robótica móvil. Realiza un estudio, implementación y evaluación de las principales técnicas usadas para diferenciar las partes estáticas de las móviles de una escena en secuencias de video y realiza una categorización de las técnicas basada en la velocidad de procesamiento y precisión de la segmentación. En aplicaciones de videovigilancia, los ejemplos tienen el objetivo de realizar una segmentación a la imagen para diferenciar las partes de interés de las que no lo son, así como seguir y caracterizar un objeto móvil dentro de una secuencia de imágenes; mientras que en aplicaciones de robótica móvil, el objetivo es mapeo y localización del robot y la evasión de obstáculos (estáticos o móviles) en la escena. Se incluye un estudio de los antecedentes, estado del arte, objetivos, motivaciones, alcances de este tema de investigación y se describe un sistema desarrollado con las funcionalidades necesarias para poder utilizar y evaluar las técnicas estudiadas. El sistema ha sido diseñado para ser configurado de acuerdo a las necesidades del usuario, lo cual permite adaptar el sistema a diferentes ambientes y ver qué configuración se desempeña mejor, tal desarrollo se hizo con la finalidad de facilitar la experimentación en futuras investigaciones.



Abstract This research addresses the detection of static parts and moving parts of a scene in video sequences. For sequences recorded with a static camera, it uses video surveillance systems as a case study, and for mobile camera sequences it uses tours of mobile robots. It includes study, implementation and evaluation of the main techniques used to differentiate static from moving parts from a scene in video sequences, and carries out a categorization of techniques based on processing speed and accuracy of the segmentation. In video surveillance applications, examples have the goal of performing image segmentation to differentiate the parts of interest, as well as track and characterize a moving object in an image sequence, while mobile robotics applications have mapping and localization as objectives, and also obstacle avoidance (static or moving) in the scene. A study is done of previous work, state of the art, objectives, motivations, implications of this research topic and a workbench system with the functionality needed to support and evaluate the techniques used to separate the parts of a scene in video sequences is developed. The workbench has been designed to be configured according to user needs, allowing the system to adapt to different environments and choose a configuration that performs best, such a development was made in order to facilitate experimentation in future research.



Índice Agradecimientos .................................................................................................................. 4 Resumen ................................................................................................................................ 5 Abstract ................................................................................................................................. 6 Capitulo 1: Introducción ...................................................................................................... 8

1.1 Descripción del problema ..................................................................................... 8 1.2 Antecedentes ......................................................................................................... 9 1.2.1 Cámara estática .......................................................................................... 9 1.2.2 Cámara móvil ............................................................................................ 11 1.3 Objetivos ............................................................................................................... 12 1.3.1 Objetivo general ....................................................................................... 12 1.3.2 Objetivos especificos .............................................................................. 12 1.4 Motivaciones ........................................................................................................ 13 1.5 Metodología de solución..................................................................................... 14 1.6 Alcances ............................................................................................................... 14 1.7 Organización del documento ............................................................................. 17

Capitulo 2: Trabajos relacionados ................................................................................... 18 2.1 Descripción de las técnicas de segmentación de imágenes en secuencias de

video con cámara estática ..................................................................................... 18 2.2 Descripción de las técnicas de correspondencia de puntos en secuencias de

video con cámara móvil ......................................................................................... 21 2.3 Descripción de la evaluación ................................................................................ 24 2.4 Base de datos de videos ........................................................................................ 29 2.5 Discusión ................................................................................................................. 33

Capitulo 3: Implementaciones .......................................................................................... 34 3.1 Implementación de las técnicas de segmentación de imágenes en secuencias

de video con cámara estática ............................................................................... 34 3.2 Implementación de las técnicas de correspondecia de puntos en secuencias

de video con cámara móvil.................................................................................... 39 3.3 Implementación de la evaluación ......................................................................... 45 3.4 Herramientas para el desarrollo del sistema ...................................................... 58 3.5 Interfaz gráfica ........................................................................................................ 58 3.6 Discusión ................................................................................................................. 60

Capitulo 4: Evaluaciones y resultados ............................................................................ 61 4.1 Especificaciones técnicas ..................................................................................... 61 4.2 Evaluaciones de las técnicas usadas para diferenciar las partes estáticas de

las partes móviles de una escena en secuencias de video .............................. 61 4.3 Resultados de las evaluaciones con videos de cámara estática ..................... 63 4.4 Resultados de las evaluaciones con videos de cámara móvil ......................... 73 4.5 Discusión ................................................................................................................. 76

Capitulo 5: Conclusiones .................................................................................................. 78 5.1 Conclusiones finales .............................................................................................. 78 5.2 Aportaciones y productos ..................................................................................... 78 5.3 Lecciones aprendidas ............................................................................................ 79 5.4 Trabajos futuros ..................................................................................................... 79

Referencias ......................................................................................................................... 80 Anexo ................................................................................................................................... 86



Capítulo 1: Introducción En este capítulo se presenta el problema a resolver y la metodología que se usará para solucionarlo, así como los antecedentes, los objetivos, las motivaciones y los alcances de este trabajo de investigación.

1.1. Descripción del problema La segmentación de objetos en movimiento presenta la necesidad de una mayor automatización y autonomía en los sistemas inteligentes provistos de visión artificial. Hay un gran número de sistemas que requieren este tipo de análisis pero este trabajo se centrará principalmente en dos: los de videovigilancia (Fig.1.1) y los de robótica móvil (Fig.1.2). Se busca que el procesamiento de los videos producidos por la videovigilancia se haga en un menor tiempo y con una mayor automatización; se pretende que el funcionamiento de los sistemas de robótica móvil sea en tiempo real, de forma continua y sobre todo autónomos.

Figura 1.1 Videovigilancia Figura 1.2 Robótica móvil

La dificultad principal que se tiene en los sistemas de videovigilancia y robótica móvil es el de una correcta separación de las partes estáticas de las móviles. Esto con el fin de realizar una segmentación a la imagen para diferenciar las partes de interés de las que no lo son, así como seguir y caracterizar un objeto, el mapeo y localización del robot móvil, la evasión de obstáculos (estáticos o móviles) en la escena, estas por mencionar algunas necesidades que tiene la visión por computadora. El problema que se pretende solucionar con este trabajo de tesis es la detección de las partes estáticas y las partes móviles de una escena en secuencias de video. Cabe mencionar que las partes estáticas de una escena son el fondo y las partes móviles (objetos en movimiento) de una escena constituyen el primer plano. Para realizar esta tarea es necesario hacer primero el modelado de fondo de la escena y posteriormente la detección del primer plano, por eso, este trabajo de tesis se valdrá de las técnicas usadas para diferenciar las partes estáticas de las partes móviles de una escena en secuencias de video para realizar su objetivo [Leal, 2010]. La segmentación de objetos en movimiento sigue siendo un reto hoy en día en el procesamiento de secuencias de alta complejidad, ya que los algoritmos de segmentación de objetos basados en modelado de fondo diseñados para modelar este tipo de secuencias, no son capaces de extraer un objeto en movimiento correcto si los pixeles de fondo presentan una variación más significativa que los del objeto [Sonsoles, 2009]. Los problemas que se presentan al querer detectar las partes de una escena en un video son dos básicamente, uno para cámara estática y otro más complicado para cámara móvil.



Con cámara estática la situación no está completamente resuelta porque en realidad el fondo no está completamente estático como se quisiera e influyen factores como sombras, luces, ruido y muchas condiciones cambiantes en los entornos no controlados [Toscano, 2011]. Con cámaras móviles es mucho más complejo, porque tiene los factores influyentes de la cámara estática y aparte se le suma el movimiento de la cámara, por eso esta tarea no es fácil y no ha sido resuelta en definitiva [López-Paredes, 2011]. La complejidad del problema recae principalmente en las técnicas usadas para detectar las partes estáticas y móviles de una escena en secuencias de video; ya que las técnicas que son usadas para cámara estática no se pueden usar para cámara móvil [López-Paredes, 2011], sin embargo las técnicas de cámara móvil sí pueden ser utilizadas en cámara estática, pero teniendo en cuenta que las técnicas para cámara móvil tienen un mayor uso de recursos computacionales [López-Gutiérrez, 2002]. Detallando la complejidad del problema, se puede decir que la detección del fondo y los objetos en movimiento en el caso de cámara móvil son la parte más difícil a resolver, ya que engloba los problemas que se presentan para el caso de cámara estática y además el movimiento de la cámara; y desde el estudio e implementación de las técnicas para el caso de cámara móvil, se puede decir que por sí solas las técnicas tiene una mayor dificultad para ser estudiadas e implementadas ya que lo que pretenden solucionar es mucho más complejo. La evaluación de las técnicas de segmentación de imágenes es otro problema a tratar, es muy difícil lograr una correcta evaluación de las técnicas ya que para hacerlo se tienen que considerar mucho factores involucrados, por ejemplo la realización de los pseudocódigos, el orden de complejidad de las técnicas, las características de la computadora donde se va a realizar las pruebas y los criterios que se tomarán en cuenta para llevarlas a cabo [Prati, 2003]. Explicando más la complejidad que conlleva la evaluación, se puede decir que otros factores a considerar son: los videos que se elegirán para evaluar, los procesos del sistema operativo que podrían cambiar el rendimiento de la aplicación y afectar la evaluación, la diversa cantidad de parámetros que usan algunas técnicas y por último el gran número de corridas que se tienen que hacer y que a su vez genera una gran cantidad de imágenes a evaluar [Tiburzi, 2008].

1.2. Antecedentes Se muestran algunos trabajos que fueron realizados en el Centro Nacional de Investigación y Desarrollo Tecnológico (CENIDET) relacionados con el tema de tesis y las diferencias con el trabajo de investigación que se propone.

1.2.1. Cámara estática Caracterización visual de movimientos sospechosos de personas en estacionamientos [Alcantar, 2013] En estacionamientos existe la necesidad de adoptar nuevas tecnologías que permitan hacer una detección temprana y automática de movimientos de personas caracterizados como “sospechosos” que pudieran dar lugar a un daño o robo vehicular.



En este trabajo de investigación se busca el desarrollo de un sistema de vigilancia inteligente, que sea capaz de detectar a las personas dentro del estacionamiento y hacer un seguimiento de las mismas, y en segundo lugar hacer una caracterización de movimientos de personas que sean considerados como “sospechosos”, estos movimiento son: correr, agacharse, ondear una o ambas manos, merodear y acostarse; utilizando los segmentos corporales de interés (Fig. 1.3).

Figura 1.3 Segmentos Corporales de interés [Alcantar, 2013]

Seguimiento y caracterización del comportamiento de varios objetos en movimiento [Toscano, 2011]

Se desarrolló un sistema que permite la detección, seguimiento y caracterización del comportamiento de varios objetos en movimiento mediante la utilización de conocimientos de inteligencia artificial y visión por computadora (Fig. 1.4). El sistema está conformado por 7 módulos (1.- Modelo de fondo, 2.- Detección de primer plano, 3.- Validación de persona, 4.- Segmentación fina, 5.- Descripción del movimiento, 6.- Seguimiento de personas y partes, 7.- Caracterización de la acción).

Figura 1.4 Comportamiento de objetos en movimiento [Toscano, 2011]

La detección de objetos aún sigue siendo objeto de investigación debido a diferentes factores como: sombras, movimiento del sol, nubes, reflejos, nuevas edificaciones, etc. Los problemas para la detección de objetos pueden ser atribuidos a diferentes factores como por ejemplo problemas con las cámaras, fondos dinámicos, detección en tiempo real o casi real, desconocimiento de información previa del objeto a detectar, sombras, reflejos, oclusiones, entre otros factores. Los algoritmos utilizados para poder realizar el sistema fueron: Promediado de imágenes, Diferencia frente al fondo, Modelo de color CIE-Lab, Umbralización Otsu, Operaciones morfológicas de erosión y dilatación, Correlación de plantillas, Modelado del cuerpo humano, Relocalización de puntos, Evaluador de subconjuntos CFS, Seleccionador de atributos Relief-F, Clasificación J48. La aportación de este trabajo de investigación es que existe una gran variedad de técnicas para poder realizar la detección de objetos y a continuación se muestra una lista de las mencionadas en esta tesis, cabe recalcar que en esta tesis sólo se mencionan, mas no se



realiza algún estudio o investigación de ellas: Diferencia de imágenes, Asociaciones jerárquicas, Agrupación de pixeles, Clasificadores estadísticos, Selección de semillas, Flujo óptico, Campos aleatorios de Markov, Emparejamiento de Plantillas, Histogramas orientados a gradientes. Caracterización automática de una muestra de acciones en video [Dávila, 2009] Se desarrolló un sistema de visión artificial capaz de caracterizar numéricamente una muestra de acciones humanas en video de manera automática (Fig. 1.5). La caracterización numérica consiste en medidas geométricas entre regiones de piel y movimiento y zonas de referencia durante la secuencia. Las principales técnicas utilizadas fueron sustracción de fondo para detectar movimiento y segmentación de imágenes por color para extraer regiones de piel.

Figura 1.5 Caracterización de una muestra [Dávila, 2009]

Los objetivos presentados en esta tesis son: Detectar Objetos de Interés, Seguir Objetos de Interés, Caracterizar Objetos de Interés, Cuantificar de manera automática los cambios presentados por partes del cuerpo humano en movimiento. Las fases de solución propuestas para esta tesis son: detección de movimiento, segmentación por color piel, eliminar ruido, localización de regiones de interés y el seguimiento de las regiones u objetos. Para lograr la detección de movimiento se propusieron dos técnicas de segmentación de imágenes en secuencias de video, una fue la de diferencia de frames y la otra la de flujo óptico.

1.2.2. Cámara móvil Comparación de algoritmos de extracción y asociación de rasgos para visión robótica [Fernández, 2012] Para una persona la capacidad de reconocer una escena es algo innato y por lo tanto no sabe ni qué características o rasgos de la escena deben ser extraídos y el detalle de esta extracción, además, no se preocupa por la forma en cómo almacenar esta información ni cómo hacer coincidir la nueva información con la almacenada previamente. Este trabajo presenta el desarrollo de un sistema cuyo objetivo es reconocer escenas vistas anteriormente, o de lo contrario almacenarlas en una base de datos. El sistema consta de tres módulos: 1) Adquisición, 2) Extracción y 3) Asociación. El módulo de adquisición es capaz de capturar imágenes monoculares e imágenes estéreo binoculares (Fig. 1.6). El módulo de extracción se desarrolló utilizando un enfoque basado en características locales, por lo que este módulo se compone de un algoritmo de detección (ASIFT, MSER, Hesse afín, Harris afín) y un algoritmo de descripción (SIFT), además, este módulo se basan en un filtro seguimiento y rechazo de frames para tratar de obtener características confiables. El módulo de asociación fue desarrollado considerando técnicas de



recuperación de información, implementando por esta razón dos algoritmos de asociación (Bolsa de palabras y el Árbol de vocabulario) con su respectivo índice invertido.

Figura 1.6 Imágenes correspondientes al sistema de visión binocular [Fernández, 2012]

Análisis de algoritmos de correspondencia para visión estéreo [Luna, 2011] En esta tesis de maestría se evaluó el desempeño de doce algoritmos de correspondencia en imágenes provenientes de entornos acuáticos y terrestres (Fig. 1.7). Este análisis se llevó a cabo a través de la comparación de la precisión y del tiempo que arrojaron estos algoritmos cuando se aplicaron a imágenes muestra, las cuales se seleccionaron tanto de un conjunto de imágenes texturizadas como de un conjunto de imágenes estructuradas. La clasificación del conjunto total de imágenes, en texturizadas o estructuradas, se realizó a través de una forma que se propuso en este trabajo.

Figura 1.7 Ejemplo de una correspondencia verdadera [Luna, 2011]

Los doce algoritmos de correspondencia fueron el resultado de la composición de algunos algoritmos de detección de características destacadas, búsqueda y emparejamiento que se identificaron en la literatura. Como resultado de este trabajo de tesis se presentó un estudio exploratorio que facilita identificar la predominancia del tipo de escena, texturizada o estructurada, inmersa en un entorno acuático o terrestre. Asimismo este estudio posibilita establecer, por lo menos para la muestra analizada, relaciones entre el tipo de escena y la respuesta del algoritmo de correspondencia aplicado.

1.3. Objetivos Se presenta el objetivo general, así como los objetivos específicos del trabajo de investigación.

1.3.1. Objetivo general Estudiar, implementar y evaluar las técnicas usadas para diferenciar las partes estáticas de las partes móviles de una escena en secuencias de video.

1.3.2. Objetivos específicos Probar las técnicas de cámara móvil en videos tomados con cámara estática.



Evaluar el desempeño de cada técnica.

Definir cuál de las técnicas probadas es mejor para cada situación, ya sea cámara estática o cámara en movimiento.

Crear las bases de datos de videos para el caso de cámara estática y el caso de cámara móvil.

Definir en cada situación lo que es fondo y primer plano.

1.4. Motivaciones La separación del primer plano del fondo tiene dos casos: la de cámara estática que se ejemplifica por las secuencias de videovigilancia y la de cámara móvil representada por las secuencias de robótica móvil. Como ejemplos de aplicaciones de la videovigilancia tenemos la detección, seguimiento y caracterización de una persona en un metro, estacionamiento o en un supermercado, la vigilancia de animales en su hábitat para conocer su comportamiento, otra más es la necesidad que se tiene de recordar que un objeto móvil es en realidad un móvil y no parte del fondo aunque ya allá permanecido ahí una gran cantidad de tiempo. Como ejemplos de aplicaciones de cámara móvil nos encontramos con el mapeo y localización de robots móviles en un determinado espacio de terreno o hasta en el mundo, la evasión de obstáculos (estáticos o móviles) en la escena y por último el gran problema que se tiene con el seguimiento de móviles dentro de la robótica civil y militar, por mencionar algunos. Ninguno de los trabajos desarrollados en CENIDET realiza una evaluación de las técnicas

usadas para diferenciar las partes estáticas de las partes móviles de una escena en secuencias de video; por esto mismo existe muy poca información que compare estas técnicas y que muestre una evaluación de ellas con respecto a los criterio de velocidad de procesamiento y precisión de la segmentación. En el caso de cámara estática existen dentro del estado del arte trabajos que realizan un estudio de las técnicas de segmentación de imágenes en secuencias de video [Piccardi, 2004] [Cheung1, 2004] [Cheung2, 2004] [El Baf, 2007] [Parks, 2008] [Sonsoles, 2009] [Cervera, 2010] [Leal, 2010] [Rodríguez, 2010]. Algunos de los trabajos anteriores además realizan una evaluación de las técnicas de segmentación de imágenes en secuencias de video (pero de una manera diferente a la que se realizara en este trabajo) [Sonsoles, 2009] [Prati, 2003] [Cheung2, 2004] [Hassanpour, 2011] [El Baf, 2007] [Parks, 2008] [Piccardi, 2004]. Para el caso de cámara móvil, en el estado del arte se puede decir que hay pocos trabajos [López-Gutiérrez, 2002] [López-Paredes, 2011] [Shibata, 2008] [Mora, 2010] que realizan un estudio de las técnicas de correspondencia de puntos en secuencias de video, y ninguno realiza una evaluación de las técnicas de correspondencia de puntos en secuencias de video, por eso para este tipo de situación se puede decir que es un campo que no ha sido explotado del todo y que aún le falta mucho para poder llegar a su madurez. Esto resalta la importancia de este trabajo de investigación, ya que tendrá como beneficios el estudio, la implementación y la evaluación de las técnicas usadas para diferenciar las partes estáticas de las partes móviles de una escena en secuencias de video con cámara estática y cámara móvil englobadas en un solo trabajo de investigación.



1.5. Metodología de solución La metodología que se propone para resolver este problema involucra las siguientes actividades:

1. Recopilar información del estado del arte. 2. Estudiar y analizar las técnicas de segmentación de imágenes en secuencias de

video con cámara estática. 3. Elegir las técnicas de segmentación de imágenes en secuencias de video para

cámara estática a implementar. 4. Crear las bases de datos de videos para el caso de cámara estática. 5. Implementación de las técnicas con cámara estática. 6. Evaluación de las técnicas con cámara estática. 7. Estudiar y analizar las técnicas de correspondencia de puntos en secuencias de

video con cámara móvil. 8. Elegir las técnicas de correspondencia de puntos en secuencias de video para

cámara móvil a implementar. 9. Crear las bases de datos de videos para el caso de cámara móvil. 10. Implementación de las técnicas con cámara móvil. 11. Evaluación de las técnicas con cámara móvil. 12. Evaluación de las técnicas de cámara móvil en situaciones de cámara estática. 13. Presentación de resultados al asesor. 14. Redactar la documentación de la tesis.

1.6. Alcances El objetivo es separar las partes estáticas de las móviles en una escena, y esto se realizará en secuencias de video proporcionadas por una cámara estática o una cámara móvil, para poder lograr esto se usará el método de modelado de fondo y detección del primer plano (Diagrama 1.1) (Fig.1.8) [Cervera, 2010] [Sonsoles, 2009].

Diagrama 1.1 Detección de las partes de una escena en secuencias de video [Sonsoles, 2009]



Figura 1.8 Modelado de fondo y detección del primer plano

Este método se puede realizar con técnicas usadas para diferenciar las partes estáticas de las partes móviles de una escena en secuencias de video. Estas técnicas se dividen en las que son para cámara estática y en las que son para cámara móvil [Cervera, 2010] [López-Paredes, 2011]. En la tabla 1.1 se muestran las técnicas más mencionadas en la literatura.

Tabla 1.1 Tecnicas mas mencionadas para la detección de partes estáticas y móviles en secuencias de video

Cámara estática Cámara móvil

Densidad de núcleo.

Eigenbackgrounds.

Filtro de Kalman.

Filtro de mediana.

Filtro de mediod.

Filtro lineal predictivo.

Filtro promedio temporal.

Gaussiana simple.

Basadas en códigos.

Mezcla de gaussianas.

Modelos ocultos de Markov.

Promedio total de imágenes.

Promedio “n” últimas imágenes.

Resta de imágenes

Correspondencia de puntos.

Derivada temporal.

Flujo óptico.

Modelo elástico.

Template matching.

Resumiendo las diferencias a tratar, se puede decir que hablando de cámara estática influyen factores como sombras, luces, ruidos y las condiciones cambiantes en los entornos no controlados, y hablando de cámara móvil es más complejo, porque influyen todos los factores de cámara estática y además se le suma el movimiento de la cámara. Las técnicas de cámara estática son conocidas en la literatura como técnicas de segmentación de imágenes en secuencias de video, tienen este nombre ya que dentro del proceso para detectar las partes estáticas y móviles de una escena generan la imagen binaria ya segmentada [Sonsoles, 2009]. En el caso de cámara móvil son conocidas como técnicas de correspondencia de puntos en secuencias de video porque realizan una previa detección de puntos destacados en la imagen para después hacer la correspondencia de ellos [López-Paredes, 2011]. En cámara estática se estudiaron y analizaron ocho técnicas, se eligieron cinco de las cuales se realizaron diez implementaciones y se reporta la evaluación de seis (Tabla 2). En cámara móvil se estudiaron y analizaron dos técnicas, se realizaron tres implementaciones, y se evaluaron dos (Tabla 1.2). Las razones por las cuales fueron descartadas las técnicas



para ambos casos son: no se encontró suficiente información de ellas en la literatura y tienen un mayor uso de recursos computacionales.

Tabla 1.2 Estudio, implementación y evaluación de técnicas

Actividad Cámara estática Cámara móvil Total

Estudio y Análisis 8 2 10

Implementaciones 10 3 13

Evaluaciones 6 2 8

La base de datos de videos que se usa para la evaluación de las técnicas, consta de un total de veinte videos; diez videos para cámara estática, cuatro de ellos con su ground truth

(imágenes binarias perfectas generadas a mano de la secuencia analizada) y seis videos para cámara móvil. Se toman dos puntos principales para evaluar cada técnica: el enfoque teórico que usa el pseudocódigo para determinar la complejidad y el enfoque empírico que usa los criterios, los cuales son: velocidad de procesamiento y precisión de la segmentación. La aplicación cuenta con un total de cuatro módulos (Fig. 1.9); el primero es el de menú y sirve para abrir los videos a utilizar, también se puede detener el video y salir de la aplicación; el segundo contiene las técnicas de cámara estática que se pueden utilizar; el tercero tiene las técnicas de cámara móvil que se pueden utilizar; y por último el cuarto modulo que es de herramientas que se puedan llegar a necesitar en determinado momento para facilitar el uso y evaluación de las técnicas, por ejemplo: grabación de imágenes en tiempo real desde la cámara de la computadora, convertidor de imágenes a 320x240, convertidor de imágenes a un video y por último el comparador de salidas que se usa para la evaluación de la precisión de las técnicas.

Figura 1.9 Aplicación del sistema

Durante la implementación de las técnicas se usaron funciones de OpenCV [OpenCV, 2012], las funciones que se usaron se dividen en dos tipos: las básicas y unas más complejas. Las funciones básicas que se usaron son: cargar un video, abrir una imagen, guardar una imagen, cargar una imagen en una matriz para su procesado y diferencia de imágenes, cabe mencionar que estas fueron usadas para facilitar y agilizar el procesamiento de los videos con las técnicas. Las funciones más complejas que se usaron son: mezcla de gaussianas, detección de puntos, descripción de puntos, correspondencia de puntos y cálculo de flujo óptico; estas funciones se usaron por dos razones, una para poder comparar los resultados que se obtuvieran con las implementaciones de OpenCV con las realizadas en esta tesis y la otra para poder agilizar en gran medida las implementaciones de cámara móvil.



1.7. Organización del documento El capítulo 1 (Introducción) contiene la información para situar al lector en el contexto del trabajo realizado; puntualizar el objetivo, el problema que se plantea, los alcances, los antecedentes y las motivaciones de la tesis, así como la metodología de solución. En el capítulo 2 (Trabajos relacionados) se presentan descripciones de las técnicas usadas para diferenciar las partes estáticas de las partes móviles de una escena en secuencias de video, así como de la evaluación y de los videos usados. Contiene conceptos y términos relacionados con la tesis y que resultan relevantes para el entendimiento de ésta. El capítulo 3 (Implementaciones) se refiere a la implementación de las técnicas, al software desarrollado, las características y funciones del mismo así como las imágenes de salida generadas. En el capítulo 4 (Evaluaciones y resultados) se describen las diferentes evaluaciones

realizadas para validar el sistema y un análisis de los resultados obtenidos de las evaluaciones demostrando el cumplimiento de los objetivos planteados. En el capítulo 5 (Conclusiones) se presentan las aportaciones, productos, lecciones

aprendidas, trabajos futuros y conclusiones finales.



Capítulo 2: Trabajos relacionados

Aquí se presenta un estado del arte clasificando los trabajos por la técnica que emplean; se ha tratado de hacer una síntesis de contenidos parecida a la exigida por un artículo técnico.

2.1. Descripción de las técnicas de segmentación de imágenes en secuencias de video con cámara estática

Resta de imágenes:

La técnica de resta de imágenes [Chaohui, 2007] [Cui, 2012] [Leal, 2010], es posiblemente la forma más sencilla de sustracción de fondo que existe. Utiliza como modelo de fondo (𝐵𝑡) para la imagen de la secuencia en el instante (𝐼𝑡), la imagen anterior, es decir, la imagen del instante de tiempo t – 1.

𝐵𝑡=𝐼𝑡−1 Como ventajas, esta técnica posee una baja carga computacional, y el frente se adapta bien a los cambios rápidos. Esta técnica es sensible al ruido y a las variaciones de iluminación. Además, debido a que sólo utiliza una única imagen anterior como modelo de fondo, la diferencia con el cuadro anterior no es capaz de identificar el interior de los objetos en movimiento, puesto que entre imágenes consecutivas, esos pixeles se mantienen invariantes. Promediado total y resta de imágenes: La técnica de promediado total y resta de imágenes [Chaohui, 2007] [Cui, 2012] [Leal, 2010], realiza el mismo tipo de resta de imágenes que la técnica tradicional, lo que cambia es la forma en cómo se modela el fondo (𝐵𝑡), ya que para modelar el fondo realiza un promedio de todas las imágenes que van en la escena.

𝐵𝑡=𝐼1+ 𝐼2+⋯+ 𝐼𝑡

𝑡

Como ventajas, esta técnica posee una baja carga computacional, y el frente se adapta bien a los cambios rápidos. Esta técnica es sensible al ruido y a las variaciones de iluminación. Su desventaja es que después de una gran cantidad de cuadros analizados el fondo tiende a volverse muy duro y esto afecta en gran parte a la detección del primer plano. Promediado “n” últimas imágenes y resta de imágenes: La técnica de promediado de las "n" últimas imágenes y resta de imágenes [Chaohui, 2007] [Cui, 2012] [Leal, 2010], realiza el mismo tipo de resta de imágenes que la técnica

tradicional, lo que cambia es la forma en cómo se modela el fondo (𝐵𝑡), ya que para modelar el fondo realiza un promedio de las "n" últimas imágenes de la escena.

SI (nImg ≤ nImgE) → 𝐵𝑡=𝑇𝑜𝑡𝑎𝑙_𝐼𝑚𝑔 + 𝑁𝑢𝑒𝑣𝑎_𝐼𝑚𝑔

𝑛𝐼𝑚𝑔

Ecuación 2.1

Ecuación 2.2

Ecuación 2.3



SI (nImg > nImgE) → 𝐵𝑡=𝑇𝑜𝑡𝑎𝑙_𝐼𝑚𝑔 + 𝑁𝑢𝑒𝑣𝑎_𝐼𝑚𝑔 − 𝑉𝑖𝑒𝑗𝑎_𝐼𝑚𝑔

𝑛𝐼𝑚𝑔𝐸

Donde: nImg = número de imágenes en el tiempo (t). nImgE = número de imágenes elegidas por el usuario, es decir las “n” imágenes. Como ventajas, esta técnica posee una baja carga computacional, y el frente se adapta bien a los cambios rápidos. Esta técnica es sensible al ruido y a las variaciones de iluminación. Su desventaja es que hay que guardar en memoria las "n" imágenes para poder realizar el modelado de fondo y entre más imágenes son, mayor es el costo computacional. Gaussiana simple: La técnica de la gaussiana simple [Su, 2008] [Hassanpour, 2011] [Sonsoles, 2009] modela los pequeños cambios que ocurren en la imagen de fondo (𝐵𝑡) representando cada pixel con una distribución unimodal Gaussiana definida por dos parámetros: la media (µ) y la desviación estándar (σ). En cada instante “t” se determina si un pixel pertenece al fondo 𝐵𝑡(𝑥, 𝑦), esto quiere decir

que si el valor de dicho pixel en la imagen recae dentro de la gaussiana definida para ese pixel, es decir, si la diferencia entre el valor del pixel y el de la media (µ) de dicho pixel (x, y) es menor a la desviación estándar (σ) multiplicada por 2 ó 3 (umbral) es considerado

como fondo, caso contrario es considerado primer plano (𝐹𝑡) (Fig. 2.1).

Figura 2.1 Distribución gaussiana de un pixel [Sonsoles, 2009]

Una de las desventajas de esta técnica es que no es capaz de adaptarse a fondos multimodales, en los que cada pixel de fondo puede tomar valores muy diferentes. Mezcla de gaussianas:

En fondos multimodales, que contienen objetos no estáticos, tales como hojas de árboles en movimiento, olas, etc., hay pixeles cuyos valores de intensidad varían entorno a un conjunto finito de valores característicos. Por este motivo, un pixel no puede modelarse por medio de un valor (una media) y un conjunto en torno a éste (la desviación estándar) utilizando una distribución Gaussiana. La mezcla de gaussianas [Rodríguez, 2010] [Hassanpour, 2011] propone una solución a este problema que consiste en modelar la intensidad de los pixeles con una mezcla de “k” distribuciones gaussianas (donde “k” es un

Ecuación 2.4



número pequeño, frecuentemente se utiliza de 3 a 5) definidas por los siguientes parámetros: media (µ), desviación estándar (σ) y pesos (ɯ) (Fig. 2.2).

Figura 2.2. Distribución de la mezcla de gaussiana de un pixel [Sonsoles, 2009]

No obstante, la mezcla de gaussianas también posee inconvenientes. En primer lugar, conlleva una alta carga computacional. Por otro lado, es muy poco robusta a cambios repentinos de iluminación. Además, los fondos multimodales requieren un número de distribuciones “k” elevado para modelar cada pixel, lo cual implica un incremento en la carga

computacional. En este método de representación del fondo es muy importante la forma de actualizar las medias (µ) y las desviaciones estándar (σ) para adaptarse a los cambios del fondo. Densidad de núcleo: La técnica de representación del fondo (𝐵𝑡) por medio de la densidad de núcleo [Elgammal, 2003] [Sonsoles, 2009] [Mittal, 2004] estima la función de densidad de probabilidad de cada pixel de la imagen de fondo en cada instante de tiempo. Esta operación se realiza gracias a la información de la historia reciente de dicho pixel que se haya almacenada en un buffer. El objetivo es obtener mayor sensibilidad de detección que utilizando un método de representación de fondo con una distribución de probabilidad fija [Culibrk, 2006]. El modelo KDE soporta parpadeo de fondo, ruido en la imagen y es capaz de adaptarse a los cambios rápidos y progresivos del fondo. No obstante, posee un requisito muy importante que es la alta carga computacional [Han, 2004]. Filtro de mediana: En esta técnica [Hung, 2010] [Parks, 2008] [Sonsoles, 2009], se almacena en un buffer los valores de los pixeles en un conjunto de imágenes. El fondo (𝐵𝑡) se define en cada pixel

como la mediana de los valores almacenados en el buffer. Es un método robusto cuyos resultados se asemejan a los de los métodos complejos. Se utiliza en los modelos de fondo elaborados en sistemas de vigilancia de tráfico urbano, donde la estimación de la mediana se incrementa por uno si el pixel de entrada es mayor que la estimación y disminuye en caso contrario.



Esta estimación converge a un valor tal que la mitad de los pixeles de entrada son mayores a él y la otra mitad son inferiores, es decir, es un estimador de la mediana. El único inconveniente de este método es que se adapta lentamente cuando se produce un cambio en el fondo. No obstante, existen técnicas para considerar la región del fondo descubierta por un objeto que se mueve después de haber permanecido estático durante un largo periodo [Perreault, 2007]. Filtro de promedio temporal:

En el filtro de promedio [Cervera, 2010] [Sonsoles, 2009], el modelo de fondo (𝐵𝑡) se calcula

como una imagen estática hasta que se producen movimientos, en cuyo caso, el “𝐵𝑡" corresponde al promedio de un conjunto de imágenes consecutivas en el tiempo. Este modelo no es robusto en secuencias con muchos objetos en movimiento sobre todo si se mueven lentamente. Además, no puede manejar fondos multimodales, se adapta lentamente a las variaciones del fondo y posee un único umbral para toda la imagen. Uno de los problemas que presenta esta técnica es que la información de movimiento se utiliza para actualizar el fondo. Si los objetos se mueven lentamente, no serán detectados. Por este motivo, una posible solución sería utilizar también la información de los pixeles no considerados objetos en movimiento para actualizar el fondo.

2.2. Descripción de las técnicas de correspondencia de puntos en secuencias de video con cámara móvil

Correspondencia de puntos:

La correspondencia de puntos consiste en aparear un mismo punto en dos imágenes distintas de una misma escena. Primeramente se analizan las imágenes para detectar puntos con unas determinadas características (Fig. 2.3) [Tuytelaars, 2008] [Zuliani, 2004]. Después de que tenemos los puntos encontrados en las imágenes procedemos a describirlos [Grabner, 2006] [Mikolajczyk, 2005]. Seguidamente se intentan relacionar puntos comunes entre las dos imágenes que ponga en correspondencia a los puntos (Fig. 2.4) [Agrawal, 2008] [Luna, 2011] [López-Paredes, 2011].

Figura 2.3 Características del mundo real son detectadas desde diferentes vistas [Rosten, 2006]



Figura 2.4. Ejemplo de una correspondencia verdadera [Luna, 2011]

Detección de puntos (Fig. 2.5). Dentro de la imagen existen puntos destacados que

tienen la propiedad de ser reconocibles por algoritmos apropiados y se puede trabajar con ellos en vez de con toda la imagen, por ejemplo las esquinas. La detección de puntos destacados es la base para los procesos de la visión robótica. Se necesita una gran cantidad de puntos destacados para hacer una buena separación entre móvil y fondo. En nuestra implementación hemos utilizado un algoritmo conocido en la literatura con el nombre de FAST [Rosten, 2006].

Figura 2.5. Detección de puntos en una imagen

Descripción de puntos (Listado 1). La descripción de puntos se refiere a su posición,

color y datos de sus pixeles vecinos. Un buen descriptor de puntos es aquel que cambia poco al moverse el móvil y/o la cámara, por consiguiente permite reconocer el punto destacado y establecer una buena correspondencia. SIFT es un algoritmo de análisis de imagen que sirve para describir características locales en las imágenes [Lowe, 2004]. Los descriptores de puntos que proporciona SIFT son invariantes a la escala, orientación, distorsión afín y parcialmente invariantes a los cambios de iluminación [Mikolajczyk, 2004] [Mikolajczyk, 2005]. Gracias a estas propiedades, los puntos de las dos imágenes pueden relacionarse con éxito en la fase posterior del matching.

Listado 2.1 Descripción de puntos para correspondencias

Correspondencia de puntos (Matching) (Fig. 2.6): La correspondencia de puntos consiste en aparear el mismo punto extraído (detectado y descrito) en las dos imágenes que lo contienen [López-Paredes, 2011]. Para lograr esto hemos utilizado en nuestra implementación el algoritmo de BruteForce (Fuerza Bruta). Esta etapa recibe como entrada



dos matrices de datos, las cuales están conformadas por los vectores de descripción de los puntos detectados en las imágenes. Esta etapa da como salida una matriz con las coordenadas de los puntos (X1, X2, Y1, Y2) que obtuvieron correspondencia entre las dos imágenes y la distancia en el espacio descripción [Fernández, 2012] [Luna, 2011]. X1 = Coordenada en el eje X de la imagen1. Y1 = Coordenada en el eje Y de la imagen1. X2 = Coordenada en el eje X de la imagen2. Y2 = Coordenada en el eje Y de la imagen2. Grado de correlación = Se consideran correctas aquellas correspondencias cuyo grado de correlación sea mayor a un umbral, estas son llamadas buenas correspondencias.

Figura 2.6. Correspondencia de puntos entre dos imágenes

Flujo óptico:

El flujo óptico juega un papel importante en la estimación y descripción del movimiento, por lo cual es comúnmente utilizado en tareas de detección, segmentación y seguimiento de objetos móviles en una escena a partir de un conjunto de imágenes [Fernando, 2007] [Mora, 2009] [Mora, 2010]. El flujo óptico puede ser definido como el movimiento aparente de los patrones de intensidad en una imagen. La palabra aparente indica que el movimiento espacial de los objetos puede coincidir o no con el flujo estimado. No obstante, en situaciones en las cuales el movimiento de los objetos implica un movimiento de sus patrones de intensidad en el plano imagen, el flujo óptico puede ser directamente relacionado con el movimiento de los objetos en la escena [Mora, 2009] [Shibata, 2008]. La mayoría de las técnicas existentes para la estimación del flujo óptico se pueden clasificar en 4 categorías: las basadas en gradientes espacio-temporales, las basadas en comparación de regiones, las basadas en fase y las basadas en energía. En todas las estrategias de estimación de flujo óptico se parte de la hipótesis de que los niveles de gris permanecen constantes ante movimientos espaciales en un tiempo dado [Mora, 2009] [Mora, 2010]. El conocimiento preciso sobre el flujo óptico en una secuencia temporal de imágenes nos puede aportar gran cantidad de información sobre la escena que la ha generado, por lo que su gama de aplicación resulta muy variado: interpretación de escenas, compresión de vídeo, estimación del movimiento del observador, sistemas automáticos de navegación, vigilancia automática, entre otras [López-Gutiérrez, 2002]. Se presenta una implementación piramidal de la técnica de Lucas-Kanade en la cual el flujo óptico es calculado recursivamente sobre versiones de diferentes escalas de las imágenes (Fig. 2.7). En principio el flujo es estimado sobre imágenes en una escala baja para permitir grandes desplazamientos, posteriormente la escala se reduce para realizar una estimación más precisa y evitar inconsistencias de movimiento. Esto quiere decir que el flujo óptico es estimado por primera vez sobre la imagen de menor resolución, luego, dicha imagen va



creciendo en un factor de 2 hasta llegar a su tamaño de adquisición, es decir con la mayor resolución posible.

Figura 2.7. Forma piramidal del algoritmo de Lucas-Kanade [Mora, 2010]

El método de Lucas-Kanade piramidal estima el flujo óptico por medio de pirámides gaussianas de una manera iterativa tratando de minimiza el error del flujo óptico [Bouguet, 2000]. El flujo óptico es estimado sólo sobre un conjunto de puntos de la escena. Este criterio de selección tiende a elegir regiones de la imagen que presenten esquinas y puntos aislados. La magnitud y dirección del flujo óptico es encontrada en función del desplazamiento horizontal y vertical de los puntos seleccionados. El análisis del flujo óptico es un procedimiento que estudia la velocidad de los objetos a lo largo de imágenes consecutivas, definiendo como movimiento los pixeles cuyos cambios siguen una trayectoria consistente en el tiempo. Existen distintos métodos de obtención del flujo óptico basados en sistemas de derivadas parciales de la intensidad de los pixeles de la imagen como Lucas-Kanade y Horn-Schunk [Rodríguez, 2010]. Estos algoritmos son especialmente útiles en el caso de cámaras móviles, ya que permiten discriminar el movimiento de los objetos frente al de la propia cámara. La implementación de flujo óptico

que se usa en este trabajo es la del algoritmo de Lucas-Kanade [Bouguet, 2000] y cabe mencionar que para poderla realizar se necesita una detección de puntos (FAST) [Rosten, 2006] (Fig. 2.8 y 2.9).

Figura 2.8 Detección de puntos

Figura 2.9 Flujo Óptico de Lucas y Kanade

2.3. Descripción de la evaluación Los resultados de las técnicas de segmentación de imágenes son imágenes binarias donde se indica la presencia de objeto en movimiento o la presencia de fondo de la escena para cada pixel. Este hecho, a nivel de pixel, acarrea una serie de problemas tales como: pixeles considerados como ruido, pixeles detectados aislados, agujeros en el interior de los objetos detectados [Sonsoles, 2009] [Correia, 2000] [Cucchiara, 2003]. El proceso de evaluación de datos es un conjunto de medidas que se ejecutan comparando la salida de los algoritmos de sustracción de fondo con las imágenes binarias perfectas



generadas a mano (ground truth) de la secuencia analizada (Fig. 2.10) [Tiburzi, 2008]

[Kyungnam, 2006]. En esta comparación se pueden analizar diferentes medidas: falsos positivos, verdaderos positivos, falsos negativos y verdaderos negativos [Sonsoles, 2009] [Prati, 2003] estas medidas se usan para evaluar la precisión de los algoritmos. Indicadores para evaluar el nivel de fallos:

Verdaderos positivos (VP): Corresponden a los objetos en movimiento etiquetados correctamente (con valor 1).

Verdaderos negativos (VN): Son los pixeles pertenecientes al fondo detectados correctamente (con valor 0).

Falsos positivos (FP): Son los pixeles pertenecientes al fondo etiquetados incorrectamente (con valor 1).

Falsos negativos (FN): Se producen cuando los pixeles de un objeto con movimiento han sido etiquetados como fondo (con valor 0).

Figura 2.10 Ejemplo de imagen original y ground truth [Tiburzi, 2008]

Los criterios a usar para poder evaluar las técnicas de segmentación de imágenes serán dos en total, los cuales son: velocidad de procesamiento y precisión de la segmentación [Piccardi, 2004] [Sonsoles, 2009] [Cheung1, 2004] [Cheung2, 2004].

Velocidad de procesamiento: Nos ayuda a saber cuántas imágenes por segundo

puede procesar nuestra técnica y para saber el tiempo en que se ejecuta la técnica en un video determinado.

Precisión de la segmentación: Nos da a conocer la precisión de las imágenes

binarias que son generadas en las técnicas. Por otro lado, nuestro objetivo a la hora de evaluar las imágenes binarias no es únicamente la correcta detección del objeto en movimiento, sino también que los pixeles en ausencia de movimiento sean correctamente detectados, esto supone el cálculo de precisión en los dos grupos.

Para poder decir qué técnica es la más rápida y precisa en cada situación, nos basaremos en dos puntos:

El enfoque teórico (o a priori), consiste en determinar la complejidad de cada técnica ayudándonos de su pseudocódigo. No depende del ordenador que se use, ni del lenguaje de programación empleado.

El enfoque empírico (o a posteriori) consiste en programar las técnicas candidatas y aplicarlas a diferentes secuencias con la ayuda de un ordenador. En este enfoque usaremos los criterios de evaluación: velocidad de procesamiento y precisión de la segmentación.

El pseudocódigo es una descripción informal de alto nivel de un algoritmo informático de programación, que utiliza las convenciones estructurales de un lenguaje de programación verdadero, pero que está diseñado para la lectura humana en lugar de la lectura mediante



máquina, y con independencia de cualquier otro lenguaje de programación. Normalmente, el pseudocódigo omite detalles que no son esenciales para la comprensión humana del algoritmo, tales como declaraciones de variables, código específico del sistema y algunas subrutinas. Complejidad de los algoritmos: La resolución práctica de un problema se basa en dos puntos importantes: por una parte un algoritmo y por otra un programa en un ordenador. Ambos componentes tienen su importancia, pero la del algoritmo es absolutamente esencial, mientras que la del programa puede muchas veces pasar a nivel de anécdota [CompAlgo, 2013]. A efectos prácticos, nos deben preocupar los recursos físicos necesarios para que un programa se ejecute. Aunque puede haber muchos parámetros, los más usuales son el tiempo de ejecución y la cantidad de memoria utilizada. Ocurre con frecuencia que ambos parámetros están fijados por otras razones y se plantea la pregunta inversa: ¿cuál es el tamaño del mayor problema que puedo resolver en “T” segundos y/o con “M” bytes de memoria? [CompAlgo, 2013]. Para cada problema determinaremos una medida “N” de su tamaño (número de datos) e intentaremos hallar respuestas en función de dicho “N”. El concepto exacto que mide “N” depende de la naturaleza del problema, es imposible dar una regla general, pues cada problema tiene su propia lógica de coste [CompAlgo, 2013], por ejemplo:

Para un vector se suele utilizar como “N” su longitud.

Para una matriz, el número de elementos que la componen.

Para un grafo, puede ser el número de nodos (a veces es más importante considerar el número de arcos, dependiendo del tipo de problema a resolver).

Para un fichero se suele usar el número de registros. Tiempo de Ejecución: Una medida que suele ser útil conocer es el tiempo de ejecución de un programa en función de “N”, lo que denominaremos T(N). Esta función se puede medir físicamente (ejecutando el programa, reloj en mano), o calcularse sobre el código contando instrucciones a ejecutar y multiplicando por el tiempo requerido por cada instrucción. Así, un trozo sencillo de programa como: S1; for (int i= 0; i < N; i++) S2; requiere T(N)= t1 + t2*N siendo “t1” el tiempo que lleve ejecutar la serie "S1" de sentencias, y “t2” el que lleve la serie "S2" [Aho, 1988] [CompAlgo, 2013]. Prácticamente todos los programas reales incluyen alguna sentencia condicional, haciendo que las sentencias efectivamente ejecutadas dependan de los datos concretos que se le presenten. Esto hace que más que un valor T(N) debamos hablar de un rango de valores: Tmin(N) <= T(N) <= Tmax(N) los extremos son habitualmente conocidos como "caso peor" y "caso mejor". Entre ambos se hallara algún "caso promedio" o más frecuente [Aho, 1988] [CompAlgo, 2013]. Cualquier fórmula T(N) incluye referencias al parámetro “N” y a una serie de constantes "Ti" que dependen de factores externos al algoritmo como pueden ser la calidad del código generado por el compilador y la velocidad de ejecución de instrucciones del ordenador que lo ejecuta. Dado que es fácil cambiar de compilador y que la potencia de los ordenadores crece a un ritmo vertiginoso, intentaremos analizar los algoritmos con algún nivel de independencia de estos factores; es decir, buscaremos estimaciones generales ampliamente válidas [Aho, 1988] [CompAlgo, 2013].



Asíntotas:

Por una parte necesitamos analizar la complejidad de los algoritmos independientemente de la potencia de la máquina que los ejecute e incluso de la habilidad del programador que los codifique. Por otra, este análisis nos interesa especialmente cuando el algoritmo se aplica a problemas grandes. Casi siempre los problemas pequeños se pueden resolver de cualquier forma, apareciendo las limitaciones al atacar problemas grandes, matemáticamente hablando, cuando “N” tiende a infinito, es decir, su comportamiento asintótico. No debe olvidarse que cualquier técnica de ingeniería, si funciona, acaba aplicándose al problema más grande que sea posible: las tecnologías de éxito, antes o después, acaban llevándose al límite de sus posibilidades [Aho, 1988] [CompAlgo, 2013]. Sean g(n) diferentes funciones que determinan el uso de recursos. Habrá funciones "g" de todos los tipos. Lo que vamos a intentar es identificar "familias" de funciones, usando como criterio de agrupación su comportamiento asintótico. A un conjunto de funciones que comparten un mismo comportamiento asintótico le denominaremos un orden de complejidad. Habitualmente estos conjuntos se denominan “O”, existiendo una infinidad de ellos [Aho, 1988] [CompAlgo, 2013]. Para cada uno de estos conjuntos se suele identificar un miembro f(n) que se utiliza como representante de la clase, hablándose del conjunto de funciones "g" que son del orden de f(n), denotándose como: g IN O(f(n)) con frecuencia nos encontraremos con que no es

necesario conocer el comportamiento exacto, sino que basta conocer una cota superior, es decir, alguna función que se comporte "aún peor". La definición matemática de estos conjuntos debe ser muy cuidadosa para involucrar ambos aspectos: identificación de una familia y posible utilización como cota superior de otras funciones menos malas [Aho, 1988] [CompAlgo, 2013]. Dícese que el conjunto O(f(n)) es el de las funciones de orden de f(n), que se define como: O(f(n))= {g: INTEGER -> REAL+ tales que existen las constantes “k” y “N0” tales que para todo N > N0, g(N) <= k*f(N) } en palabras, O(f(n)) está formado por aquellas funciones g(n) que crecen a un ritmo menor o igual que el de f(n). De las funciones "g" que forman este conjunto O(f(n)) se dice que "están dominadas asintóticamente" por "f", en el sentido de que para “N” suficientemente grande, y salvo una constante multiplicativa "k", f(n) es una cota superior de g(n) [Aho, 1988] [CompAlgo, 2013]. Órdenes de Complejidad: Se dice que O(f(n)) define un "orden de complejidad", escogeremos como representante de este orden a la función f(n) más sencilla del mismo (Tabla 2.1).

Tabla 2.1 Ordenes de complejidad

O(1) Orden constante

O(log n) Orden logarítmico

O(n) Orden lineal

O(n log n) Orden lineal logarítmico

O(𝑛2) Orden cuadrático

O(𝑛𝑎) Orden polinomial (a > 2)

O(𝑎𝑛) Orden exponencial (a > 2)

O(n!) Orden factorial



Se puede identificar una jerarquía de órdenes de complejidad que coincide con el orden de la tabla 2.1, jerarquía en el sentido de que cada orden de complejidad superior tiene a los inferiores como subconjuntos [CompAlgo, 2013]. O(1): Complejidad constante. Cuando las instrucciones se ejecutan una vez. O(log n): Complejidad logarítmica. Esta suele aparecer en determinados algoritmos con iteración o recursión no estructural, ejemplo la búsqueda binaria. O(n): Complejidad lineal. Es una complejidad buena y también muy usual. Aparece en la evaluación de ciclos simples siempre que la complejidad de las instrucciones interiores sea constante. O(n log n): Complejidad lineal logarítmica. Se encuentra en algoritmos de tipo divide y vencerás como por ejemplo en el método de ordenación quicksort y se considera una buena complejidad. Si “n” se duplica, el tiempo de ejecución es ligeramente mayor del doble.

O(𝒏𝟐): Complejidad cuadrática. Aparece en ciclos o ciclos doblemente anidados. Si “n” se duplica, el tiempo de ejecución aumenta cuatro veces. O(𝒏𝒂): Complejidad polinomial (a > 2). Sí “a” crece, la complejidad del programa es bastante

mala. O(𝒂𝒏): Complejidad exponencial (a > 2). No suelen ser muy útiles en la práctica por el

elevado tiempo de ejecución. Se dan en subprogramas recursivos que contengan dos o más llamadas internas. O(n!): Complejidad factorial. Este tipo de orden es el más elevado de todos, y es el que más tiempo de ejecución tiene, por lo regular son llamadas a procedimientos de elevadísima carga computacional. Reglas Prácticas: Aunque no existe una receta que siempre funcione para calcular la complejidad de un algoritmo, si es posible tratar sistemáticamente una gran cantidad de ellos, basándonos en que suelen estar bien estructurados y siguen pautas uniformes. Los algoritmos bien estructurados combinan las sentencias de alguna de las formas siguientes: sentencias sencillas, decisión (if), ciclos, llamadas a procedimientos, secuencia (;) [CompAlgo, 2013]. Sentencias sencillas: Nos referimos a las sentencias de asignación, entrada/salida, etc. siempre y cuando no trabajen sobre variables estructuradas cuyo tamaño esté relacionado con el tamaño “N” del problema. La inmensa mayoría de las sentencias de un algoritmo requieren un tiempo constante de ejecución, siendo su complejidad O(1).

Decisión (if): La condición suele ser de O(1), complejidad a sumar con la peor posible, bien en la rama THEN, o bien en la rama ELSE. En decisiones múltiples (ELSE IF, SWITCH CASE), se tomara la peor de las ramas. Ciclos: En los ciclos con contador explícito, podemos distinguir dos casos, que el tamaño “N” forme parte de los límites o que no. Si el ciclo se realiza un número fijo de veces, independiente de “N”, entonces la repetición sólo introduce una constante multiplicativa que

puede absorberse. Por ejemplo: Ej_1.- for (int i= 0; i < K; i++) { algo_de_O(1) } => K*O(1) = O(1). Si el tamaño “N” aparece como límite de iteraciones. Ej_2.- for (int i= 0; i < N; i++) { algo_de_O(1) } => N*O(1) = O(n).



Ej_3.- for (int i= 0; i < N; i++) { for (int j= 0; j < N; j++) { algo_de_O(1) } }

Tendremos N*N*O(1) = O(𝑛2). Ej_4.- for (int i= 0; i < N; i++) { for (int j= 0; j < i; j++) { algo_de_O(1) } } El ciclo exterior se realiza “N” veces, mientras que el interior se realiza 1, 2, 3,... “N” veces

respectivamente. En total, 1 + 2 + 3 +... + N = N*(1+N)/2 -> O(𝑛2).

Ej_5.- c= N; while (c > 1) { algo_de_O(1) c= c / 2; } Un razonamiento análogo nos lleva a log2(N) iteraciones y, por tanto, a un orden O(log n)

de complejidad. Ej_6.- for (int i= 0; i < N; i++) { c= i; while (c > 0) { algo_de_O(1) c= c/2; } } Tenemos un ciclo interno de orden O(log n) que se ejecuta “N” veces, luego el conjunto es de orden O(n log n). Llamadas a procedimientos: La complejidad de llamar a un procedimiento viene dada por la complejidad del contenido del procedimiento en sí. El coste de llamar no es sino una constante que podemos obviar inmediatamente dentro de nuestros análisis asintóticos. El cálculo de la complejidad asociada a un procedimiento puede complicarse notablemente si se trata de procedimientos recursivos [Aho, 1988] [CompAlgo, 2013]. Por ejemplo:

insertar(arreglo, i);

ordenar(arreglo, n);

mostrar(arreglo, n); Secuencia (fin de línea de código (;)): La complejidad de una serie de elementos de un programa es del orden de la suma de las complejidades individuales, aplicándose las operaciones arriba expuestas.

2.4. Base de datos de videos Se llevó a cabo la búsqueda y creación de videos para que conformen la base de datos para el caso de cámara estática y cámara móvil. La base de datos de cámara estática está



conformada por diez videos de los cuales cuatro tienen su ground truth y la base de datos

de cámara móvil cuenta con seis videos. Los videos son descritos a continuación. Cámara estática: Esta sección de la base de datos está conformada por diez videos diferentes, cabe recalcar que cuatro de ellos tiene su ground truth para su mejor evaluación. Los videos son de formato (.avi) y tiene un tamaño de 320x240. BDVCE1: Este video fue encontrado en la web, es una secuencia de imágenes de videovigilancia tomada en la calle, cuenta con 1175 cuadros y su frecuencia es de 25 f/s (Fig. 2.11) [VSSN06_OSAC, 2006].

Figura 2.11 Imagen de ejemplo del video

BDVCE1

BDVCE2: Este video fue encontrado en la web, es una secuencia de imágenes de videovigilancia tomada en un pasillo de una universidad, cuenta con 2882 cuadros y su frecuencia es de 9 f/s (Fig. 2.12) [VSSN06_OSAC, 2006].

Figura 2.12 Imagen de ejemplo del video BDVCE2

BDVCE3: MIT Traffic Data Set [MIT_TDS, 2012]: conjunto de videos para la investigación en el análisis de la actividad y las escenas de mucha gente, es una secuencia de imágenes de videovigilancia tomada en un crucero de calles, cuenta con 8301 cuadros y su frecuencia es de 30 f/s (Fig. 2.13).


BDVCE3

BDVCE4: Este video fue encontrado en la web, es una secuencia de imágenes de videovigilancia tomada en un túnel automovilístico, cuenta con 12000 cuadros y su frecuencia es de 25 f/s (Fig. 2.14) [VSSN06_OSAC, 2006].


BDVCE5: Este video fue creado en el laboratorio de inteligencia artificial del CENIDET, es una secuencia de imágenes de videovigilancia que cuenta con 2979 cuadros y su frecuencia es de 30 f/s (Fig. 2.15).




BDVCE6: Este video fue encontrado en la web, es una secuencia de imágenes tomada en la calle durante un desfile alegórico, cuenta con 14310 cuadros y su frecuencia es de 30 f/s (Fig. 2.16) [VSSN06_OSAC, 2006].


BDVCE7: Este video fue encontrado en la web, es una secuencia de imágenes creada artificialmente “Call for Algorithm Competition in Foreground/Background Segmentation”, tomada en un pasillo de una universidad. Su frecuencia es de 25 f/s, cuenta con 750 cuadros y su ground truth [VSSN06_OSAC, 2006] (Fig. 2.17).


BDVCE7 y su ground truth

BDVCE8: Este video fue encontrado en la web, es una secuencia de imágenes creada artificialmente “Call for Algorithm Competition in Foreground/Background Segmentation”, tomada en un jardín. Su frecuencia es de 25 f/s, cuenta con 900 cuadros y su ground truth [VSSN06_OSAC, 2006] (Fig. 2.18).



BDVCE9: Este video fue encontrado en la web, es una secuencia de imágenes creada artificialmente “Call for Algorithm Competition in Foreground/Background Segmentation”, tomada en un estacionamiento de una universidad. Su frecuencia es de 25 f/s, cuenta con 750 cuadros y su ground truth [VSSN06_OSAC, 2006] (Fig. 2.19).



BDVCE10: Este video fue encontrado en la web, es una secuencia de imágenes creada artificialmente “Call for Algorithm Competition in Foreground/Background Segmentation”, tomada en un pasillo de una universidad. Su frecuencia es de 25 f/s, cuenta con 1192 cuadros y su ground truth [VSSN06_OSAC, 2006] (Fig. 2.20).



Cámara móvil: Esta sección de la base de datos está conformada por seis videos diferentes. Los videos son de formato (.avi) y tiene un tamaño de 320x240.



BDVCM1: Este video fue creado en el laboratorio de inteligencia artificial del CENIDET, es una secuencia de imágenes donde la cámara simula el movimiento de un robot móvil, cuenta con 750 cuadros y su frecuencia es de 30 f/s (Fig. 2.21).

Figura 2.21 Imagen de ejemplo del video BDVCM1

BDVCM2: Este video fue creado en los pasillos del departamento de ciencias computacionales del CENIDET, es una secuencia de imágenes donde la cámara simula el movimiento de un robot móvil, cuenta con 750 cuadros y su frecuencia es de 30 f/s (Fig. 2.22).


BDVCM2 BDVCM3: Este video fue creado en el laboratorio de Inteligencia Artificial del CENIDET, es una secuencia de imágenes donde la cámara simula el movimiento de un robot móvil, cuenta con 750 cuadros y su frecuencia es de 30 f/s (Fig. 2.23).

Figura 2.23 Imagen de ejemplo del video BDVCM3

BDVCM4: Este video fue creado en el aula 3 del departamento de ciencias computacionales del CENIDET, es una secuencia de imágenes donde la cámara simula el movimiento de un robot móvil, cuenta con 750 cuadros y su frecuencia es de 30 f/s (Fig. 2.24).


BDVCM4

BDVCM5: Este video fue encontrado en la web, es una secuencia de imágenes del Robust Multi-Person Tracking from Mobile Platforms: video para la investigación en el análisis de la actividad y las escenas de cámara móvil, la cámara simula el movimiento de un robot móvil y fue tomada en el centro de una ciudad, cuenta con 1209 cuadros y su frecuencia es de 30 f/s [Mobile_Platforms, 2013] (Fig. 2.25).


BDVCM5



BDVCM6: Este video fue encontrado en la web, es una secuencia de imágenes del Robust Multi-Person Tracking from Mobile Platforms: video para la investigación en el análisis de la actividad y las escenas de cámara móvil, la cámara simula el movimiento de un robot móvil y fue tomada en el centro de una ciudad, cuenta con 936 cuadros y su frecuencia es de 30 f/s [Mobile_Platforms, 2013] (Fig. 2.26).


BDVCM6

2.5. Discusión En este capítulo se presentó el estado del arte de esta investigación de una forma nueva y novedosa, donde se organiza cada trabajo relacionado con la tesis con forme a la técnica que se está estudiando y analizando, esta organización fue tomada como si se quisiera representar un artículo técnico. Este capítulo tuvo como contenido las descripciones de las técnicas y sus explicaciones, también la forma en cómo se realizaran las evaluaciones más adelante y por último los videos que serán utilizados para probar y evaluar las técnicas.



Capítulo 3: Implementaciones En este capítulo se explica cómo se implementaron las técnicas de cámara estática, cámara móvil y la evaluación. Se explican las herramientas usadas para poder implementar el sistema y la interfaz gráfica que dio como resultado dichas implementaciones.

3.1. Implementación de las técnicas de segmentación de imágenes en secuencias de video con cámara estática

Las implementaciones de las técnicas para cámara estática fueron realizadas con la información más completa y clara que fue encontrada en la literatura, se realizaron un total de diez implementaciones de cinco técnicas elegidas, las cuales se explican más adelante y son:

Resta de imágenes.

Promedio total.

Promedio “n” últimas imágenes.

Gaussiana simple.

Gaussiana simple con umbral.

Mezcla de gaussianas.

Mezcla de gaussianas, promedio y umbral.

Mezcla de gaussianas OpenCV1.

Mezcla de gaussianas OpenCV2.

Fondo mezcla de gaussianas OpenCV2 con umbral Resta de imágenes, promedio total y resta de imágenes, promedio “n” últimas imágenes y resta de imágenes: El método más básico para realizar la detección del primer

plano (𝐹𝑡) es calculando la diferencia entre dos imágenes [Cui, 2012] [Sonsoles, 2009] [Tang, 2007]: los pixeles cuyos valores de diferencia son altos normalmente corresponderán a objetos en movimiento. La diferencia entre dos imágenes se puede calcular mediante diversos métodos: el valor absoluto de la diferencia o la diferencia normalizada, a los que posteriormente se le aplica un umbral (𝜏) dado por el usuario con el que discernir los pixeles que forman parte del fondo (ausencia de movimiento) y aquéllos que pertenecen al frente (objeto en movimiento) [Ewerth, 2003] [Leng, 2005].

│𝐼𝑡(x, y) - 𝐵𝑡(x, y) │ ≤ 𝜏 → 𝐹𝑡(x, y) = 0

│𝐼𝑡(x, y) - 𝐵𝑡(x, y) │ > 𝜏 → 𝐹𝑡(x, y) = 1 Gaussiana simple: El modelado de fondo por medio de una gaussiana simple [Tang, 2007]

[Hassanpour, 2011] [Sonsoles, 2009] se basa en el ajuste de la densidad de probabilidad de una función gaussiana en cada pixel de la imagen de la secuencia de video a procesar. Para cada pixel del modelo de fondo 𝐵𝑡(x, y), se mantiene un valor de la media (µ) y un valor de la desviación estándar (σ), en este caso como se realizó con imágenes a color existe una media (µ) y una desviación estándar (σ) para cada canal de color RGB. Los pixeles de cada nueva imagen (𝐼𝑡) de la secuencia se comparan con los valores de la

media que modelan el fondo (𝐵𝑡), de forma que si la diferencia supera “c” veces la desviación establecida para cada pixel (umbral, típicamente se suele usar un valor de 2-3 desviaciones estándar), es decir, no encaja en el interior de la gaussiana que modela el

Ecuación 3.1

Ecuación 3.2



pixel, se decide que el pixel es parte del objeto en movimiento. Por el contrario, si el pixel posee un valor de entre los que se encuentran en el interior de la gaussiana (su diferencia con la media no excederá 2-3 veces la desviación estándar) se considerará pixel del fondo.

Inicialización de parámetros:

𝐵1(x, y)={𝜇1(𝑥, 𝑦) = 𝐼1(𝑥, 𝑦)

𝜎1(𝑥, 𝑦) = 𝑃

P = 5-35 (dado por el usuario), dependiendo de cuanto movimiento tenga la escena.

Estimación del fondo y del primer plano:

│𝐼𝑡(x, y) - 𝜇𝑡(x, y)│ < 𝑐𝜎𝑡(x, y) → 𝐹𝑡(x, y) = 0

│𝐼𝑡(x, y) - 𝜇𝑡(x, y)│ ≥ 𝑐𝜎𝑡(x, y) → 𝐹𝑡(x, y) = 1 c = es un valor dado por el usuario y multiplica la desviación estándar.

Actualización de los parámetros:

𝐵𝑡+1(x, y)={𝜇𝑡+1(𝑥, 𝑦) = 𝛼𝐼𝑡(𝑥, 𝑦) + (1 − 𝛼)𝜇𝑡(𝑥, 𝑦)

𝜎𝑡2(𝑥, 𝑦) = 𝛼(𝐼𝑡(𝑥, 𝑦) − 𝜇𝑡(𝑥, 𝑦))

2+ (1 − 𝛼)𝑃2

A la fórmula de la varianza se le saca la raíz para poder obtener la desviación estándar. 𝛼 = preferentemente es un valor muy pequeño, si es muy pequeño le da más valor a la imagen de fondo actual y si es muy más grande le da más valor a la imagen actual (dado por el usuario).

Gaussiana simple con umbral: En esta implementación de la técnica se usa el mismo

modelo de fondo (𝐵𝑡) que se genera en la gaussiana simple original, lo que cambia es la

forma en cómo se detecta el primer plano (𝐹𝑡), ya que esto se realiza con una resta de imágenes entre el fondo (𝐵𝑡) y la siguiente imagen en el video (𝐼𝑡) con la aplicación de un umbral (𝜏) dado por el usuario.


𝐵1(x, y)={𝜇1(𝑥, 𝑦) = 𝐼1(𝑥, 𝑦)


𝐵𝑡+1(x, y)={𝜇𝑡+1(𝑥, 𝑦) = 𝛼𝐼𝑡(𝑥, 𝑦) + (1 − 𝛼)𝜇𝑡(𝑥, 𝑦) A la fórmula de la varianza se le saca la raíz para poder obtener la desviación estándar. 𝛼 = preferentemente es un valor muy pequeño, si es muy pequeño le da más valor a la imagen de fondo actual y si es muy más grande le da más valor a la imagen actual (dado por el usuario).

Ecuación 3.3

Ecuación 3.4

Ecuación 3.6

Ecuación 3.7

Ecuación 3.8

Ecuación 3.5




│𝐼𝑡(x, y) - 𝐵𝑡(x, y) │ ≤ 𝜏 → 𝐹𝑡(x, y) = 0

│𝐼𝑡(x, y) - 𝐵𝑡(x, y) │ > 𝜏 → 𝐹𝑡(x, y) = 1 Mezcla de gaussianas: La mezcla de gaussianas es una de las técnicas complejas más utilizadas en la literatura [Darvish, 2008] [Sonsoles, 2009] [Rodríguez, 2010] [Hassanpour, 2011]. Entre sus ventajas destaca la robustez, ya que permite modelar fondos multimodales, es decir, manejar múltiples modos de distribución (o tipos de movimiento). Por ejemplo, una hoja agitándose bajo un cielo azul presenta dos modos o tipos de movimiento: el de las hojas y el cielo. En esta técnica, el fondo no se modela por los valores de una imagen sino a través de un modelo paramétrico cuyo objetivo es aproximar una función de distribución a los últimos valores de cada pixel [Lee, 2003]. Cada pixel localizado en la posición (x, y) de la imagen de fondo en el instante t se representa por un número “k” de distribuciones gaussianas cuya combinación constituye una función de densidad de probabilidad [Harville, 2002]. Cabe mencionar que la implementación realizada se hace con k = 3 y en los tres canales de color RGB. Los pixeles de una imagen nueva (𝐼𝑡) se comparan con los pixeles del fondo (𝐵𝑡) generado de las “k” posibles distribuciones gaussianas de las medias. Si se encuentra parecido, es

decir, si el valor del pixel no difiere del fondo (𝐵𝑡) en más de 2-3 veces la desviación estándar (σ), se caracteriza el pixel como fondo y se actualizan los parámetros del modelo para ese pixel. Caso contrario si el valor del pixel supera 2-3 veces la desviación estándar (σ), se caracteriza el pixel como primer plano y se actualizan los parámetros del modelo para ese pixel [Pham, 2010] [Zivkovic, 2004].


𝐵1(x, y)={ 𝑖 = 1 → 𝜇𝑖,1(𝑥, 𝑦) = 𝐼1(𝑥, 𝑦), 𝜎𝑖,1(𝑥, 𝑦) = 𝑃, ɯ𝑖,1 = 1

1 < 𝑖 ≤ 𝑘 → 𝜇𝑖,1(𝑥, 𝑦) = 𝑎𝑙𝑒𝑎𝑡𝑜𝑟𝑖𝑜, 𝜎𝑖,1(𝑥, 𝑦) = 𝑃, ɯ𝑖,1 = 0

i = 1…k=3 P = 5-35 (dado por el usuario), dependiendo de cuanto movimiento tenga la escena.

Normalización de pesos: La normalización de pesos se necesita para poder llevar acabo la generación de la imagen de fondo, ya que al hacer esto se garantiza que la suma de los pesos en cada iteración será siempre de uno.

ɯ𝑖,𝑡+1 =ɯ𝑖,𝑡

∑ ɯ𝑗,𝑡𝑗=𝑘𝑗=1

Ecuación 3.11

Ecuación 3.12

Ecuación 3.9

Ecuación 3.10



Obtención de la imagen de fondo:

𝐵𝑡(𝑥, 𝑦) = ∑ ɯ𝑖,𝑡

𝑘

𝑖=1

𝜇𝑖,𝑡(𝑥, 𝑦)

Estimación del fondo y del primer plano: Se toma el umbral (desviación por 2 ó 3) de la gaussiana de mayor peso, si la diferencia absoluta entre la imagen y el fondo obtenido supera este valor entonces el pixel se marca como primer plano, caso contrario se marca como fondo.

│𝐼𝑡(x, y) - 𝐵𝑡(x, y)│ < 𝑐𝜎𝑡(x, y) → 𝐹𝑡(x, y) = 0 │𝐼𝑡(x, y) - 𝐵𝑡(x, y)│ ≥ 𝑐𝜎𝑡(x, y) → 𝐹𝑡(x, y) = 1

c = es un valor dado por el usuario y multiplica la desviación estándar.


│𝐼𝑡(x, y) − 𝜇𝑖,𝑡(x, y)│ ≤ 𝑐𝜎𝑖,𝑡(x, y) →

{

𝜇𝑖,𝑡+1(𝑥, 𝑦) = 𝜌𝐼𝑡(𝑥, 𝑦) + (1 − 𝜌)𝜇𝑖,𝑡(𝑥, 𝑦)

𝜎𝑖,𝑡+12 (𝑥, 𝑦) = 𝜌 (𝐼𝑡(𝑥, 𝑦) − 𝜇𝑖,𝑡(𝑥, 𝑦))

2

+ (1 − 𝜌)𝑃2

ɯ𝑖,𝑡+1 = ɯ𝑖,𝑡

A la fórmula de la varianza se le saca la raíz para poder obtener la desviación estándar. 𝜌 = preferentemente es un valor muy pequeño, si es muy pequeño le da más valor a la imagen de fondo actual y si es muy más grande le da más valor a la imagen actual (dado por el usuario).

│𝐼𝑡(x, y) − 𝜇𝑖,𝑡(x, y)│ > 𝑐𝜎𝑖,𝑡(x, y) → {

𝜇𝑖,𝑡+1(𝑥, 𝑦) = 𝜇𝑖,𝑡(𝑥, 𝑦)

𝜎𝑖,𝑡+12 (𝑥, 𝑦) = 𝜎𝑖,𝑡

2 (𝑥, 𝑦)

ɯ𝑖,𝑡+1 = (1 − 𝛼)ɯ𝑖,𝑡

α = es un valor pequeño, para que el peso se haga más chico y la gaussiana de ese peso no se tome mucho en cuenta porque esos parámetro fueron actualizados como primer plano (dado por el usuario).

Mezcla de gaussianas, promedio y umbral: En esta implementación de la técnica se usa

un modelo de fondo (𝐵𝑡) muy similar al original de la mezcla de gaussianas; lo que cambia

es que en lugar de generar el fondo (𝐵𝑡) ayudado de los pesos (ɯ), se genera por el promedio de las medias (µ). También cambia la forma en cómo se detecta el primer plano (𝐹𝑡), ya que esto se realiza con una resta de imágenes entre el fondo (𝐵𝑡) y la siguiente

imagen en el video (𝐼𝑡) con la aplicación de un umbral (𝜏) dado por el usuario.

Ecuación 3.13

Ecuación 3.14

Ecuación 3.16

Ecuación 3.17

Ecuación 3.15




𝐵1(x, y)={ 𝑖 = 1 → 𝜇𝑖,1(𝑥, 𝑦) = 𝐼1(𝑥, 𝑦)

1 < 𝑖 ≤ 𝑘 → 𝜇𝑖,1(𝑥, 𝑦) = 𝑎𝑙𝑒𝑎𝑡𝑜𝑟𝑖𝑜

i = 1…k=3


│𝐼𝑡(x, y) − 𝐵𝑡(x, y)│ ≤ τ → {𝜇𝑖,𝑡+1(𝑥, 𝑦) = 𝜌𝐼𝑡(𝑥, 𝑦) + (1 − 𝜌)𝜇𝑖,𝑡(𝑥, 𝑦) A la fórmula de la varianza se le saca la raíz para poder obtener la desviación estándar. 𝜌 = preferentemente es un valor muy pequeño, si es muy pequeño le da más valor a la imagen de fondo actual y si es muy más grande le da más valor a la imagen actual (dado por el usuario).

│𝐼𝑡(x, y) − 𝐵𝑡(x, y)│ > τ → {𝜇𝑖,𝑡+1(𝑥, 𝑦) = 𝜇𝑖,𝑡(𝑥, 𝑦)

Obtención de la imagen de fondo:

𝐵𝑡(𝑥, 𝑦) = ∑ 𝜇𝑖,𝑡(𝑥, 𝑦)

𝑘

𝑖=1

/𝑘


│𝐼𝑡(x, y) - 𝐵𝑡(x, y)│ ≤ 𝜏 → 𝐹𝑡(x, y) = 0

│𝐼𝑡(x, y) - 𝐵𝑡(x, y)│ > 𝜏 → 𝐹𝑡(x, y) = 1 Mezcla de gaussianas OpenCV1 y OpenCV2: Estas implementaciones de mezclas de gaussianas fueron hechas con funciones ya establecidas de OpenCV [OpenCV, 2012] [KaewTraKulPong, 2001]:

OpenCV1 → BackgroundSubtractorMOG.

OpenCV2 → BackgroundSubtractorMOG2. Fondo mezcla de gaussianas OpenCV2 con umbral: Esta implementación de mezclas

de gaussianas fue hecha con la función ya establecida de OpenCV [OpenCV, 2012] OpenCV2 → BackgroundSubtractorMOG2. Se tomó la decisión de realizar esta implementación ya que por sí sola no genera una imagen binaria muy buena, pero al contrario si genera un excelente modelado de fondo (𝐵𝑡). Lo que se hace es tomar este

fondo (𝐵𝑡) y la imagen (𝐼𝑡) para hacer una resta de imágenes entre ellos y poder obtener la imagen binaria después de la aplicación de un umbral (𝜏) dado por el usuario.

│𝐼𝑡(x, y) - 𝐵𝑡(x, y)│ ≤ 𝜏 → 𝐹𝑡(x, y) = 0

│𝐼𝑡(x, y) - 𝐵𝑡(x, y)│ > 𝜏 → 𝐹𝑡(x, y) = 1

Ecuación 3.18

Ecuación 3.19

Ecuación 3.20

Ecuación 3.21

Ecuación 3.22

Ecuación 3.24

Ecuación 3.23

Ecuación 3.25



3.2. Implementación de las técnicas de correspondencia de puntos en secuencias de video con cámara móvil

Las implementaciones de las técnicas para cámara móvil fueron realizadas con la información más completa y clara que fue encontrada en la literatura, se realizaron un total de tres implementaciones de dos técnicas elegidas, las cuales se explican más adelante y son: correspondencia de puntos, flujo óptico y una combinación de ellas. Correspondencia de puntos: Para poder implementar la técnica de correspondencia de puntos se usaron algunos métodos de OpenCV [OpenCV, 2012], estos algoritmos ya implementados son: FastFeatureDetector [Rosten, 2006] → SiftDescriptorExtractor [Lowe, 2004] → BruteForceMatcher (Fuerza Bruta). En el diagrama 3.1 se mostrará cómo es que se realizan la detección, descripción y correspondencia de puntos con los algoritmos antes mencionados, esta es considerada la primera parte de la técnica de correspondencia de puntos.

Diagrama 3.1 Detección, descripción y correspondencia de puntos

Tenemos como salida nuestro vector de buenas correspondencias, este contiene las

coordenadas del punto en la imagen uno (𝐼1) y del punto en la imagen dos (𝐼2) que hicieron correlación (que lograron superar el umbral dado por el usuario (dist_min_por)) y con esto ya podemos dibujar nuestra imagen de buenas correspondencias (Fig. 3.1).

Figura 3.1 Imagen de buenas correspondencias

Después de haber realizado la correspondencia entre dos imágenes y teniendo el vector de buenas correspondencias, procedemos a dibujar en la imagen más actual un flujo con



líneas; esto quiere decir que tomamos como partida de la línea el punto en la imagen uno

(𝐼1) y como fin de la línea el punto de la imagen dos (𝐼2) (Fig. 3.2).

Figura 3.2 Flujo con líneas

Continuando con la explicación de la técnica de correspondencia de puntos llegamos a la parte de mayor aportación y la que ayudó a resolver el problema de cámara móvil, esta sección a su vez se divide en tres partes: La primera es el cálculo del grupo de ángulos que más se repite en la escena, esto quiere decir que se calcula por medio de las líneas un grupo de ángulo y es el que más se repite, estos son considerados como una especie de fondo. La segunda es la implementación del umbral que ayuda a dividir el fondo del primer plano. Y por último la forma como se genera la imagen binaria para la evaluación de la técnica. Cálculo del grupo de ángulos que más se repite: Primero obtenemos la delta “x” (∆𝑥) y

delta “y” (∆𝑦) de los dos puntos a procesar, segundo obtenemos la pendiente (m) de dichos

puntos, a esta pendiente le aplicamos el arc-tan, en el cálculo del arcotangente (atan (m))

la función empleada en el lenguaje de programación devuelve el valor en radianes y es por eso que necesitamos hacer la conversión a grados, para esa lo multiplicamos por 180° y lo dividimos entre PI (𝜋) y con eso tenemos el ángulo (θ) en grados de ese par de puntos,

mostrando las fórmulas que son:

∆𝑥 = 𝑃𝑢𝑛𝑡𝑜2𝑥 − 𝑃𝑢𝑛𝑡𝑜1𝑥 ∆𝑦 = 𝑃𝑢𝑛𝑡𝑜2𝑦 − 𝑃𝑢𝑛𝑡𝑜1𝑦

𝑚 =∆𝑦

∆𝑥

𝜃 =atan(𝑚) 180°

𝜋

Pero antes de proseguir nos encontramos con un inconveniente y que hace que el ángulo que obtenemos sea incorrecto, esto se debe a que las imágenes comienzan sus coordenadas en (0,0) y de ahí aumentando, esto genera un cálculo incorrecto del ángulo; pero para corregirlo hay que usar las siguientes ecuaciones, cabe mencionar que se llegó a esta conclusión por experimentos que se realizaron sobre los ángulos, las ecuaciones son:

𝑆𝑖 [(∆𝑥 > 0)&(∆𝑦 < 0)] → 𝜃 = 𝑎𝑏𝑠(𝜃) 𝑆𝑖 [(∆𝑥 < 0)&(∆𝑦 > 0)] → 𝜃 = 𝑎𝑏𝑠(𝜃) + 180°

𝑆𝑖 [(∆𝑥 > 0)&(∆𝑦 > 0)] → 𝜃 = 360° − 𝜃 𝑆𝑖 [(∆𝑥 < 0)&(∆𝑦 < 0)] → 𝜃 = 180° − 𝜃

𝑆𝑖 [(∆𝑥 > 0)&(∆𝑦 = 0)] → 𝜃 = 0°

Ecuación 3.26

Ecuación 3.27

Ecuación 3.28

Ecuación 3.29

Ecuación 3.31

Ecuación 3.32

Ecuación 3.33

Ecuación 3.34

Ecuación 3.30



𝑆𝑖 [(∆𝑥 = 0)&(∆𝑦 < 0)] → 𝜃 = 90° 𝑆𝑖 [(∆𝑥 < 0)&(∆𝑦 = 0)] → 𝜃 = 180° 𝑆𝑖 [(∆𝑥 = 0)&(∆𝑦 > 0)] → 𝜃 = 270°

Ejemplo de cómo se calcula un ángulo:

Figura 3.3 Muestra de flujo

Aplicando ecuaciones: 3.26, 3.27, 3.28 y 3.29 tenemos que: ∆𝑥 = 309 – 298 = 11

∆𝑦 = 3 – 9 = -6

𝑚 =−6

11 = - 0.545

atan(-0.545) = - 0.498 radianes

𝜃 =(−0.4989)180°

𝜋 = -28.5 grados

Por ultimo aplicando la ecuación 3.30 tenemos que: abs(-28.5) = 28.5 grados

Teniendo el tamaño de la línea y su ángulo podemos pintarlo en el plano cartesiano para visualizarlo de una mejor manera los flujos que se generan (Fig. 3.4).

Figura 3.4 Plano cartesiano con separadores

Después de haber obtenido el ángulo en grados de manera correcta procedemos a calcular el grupo de ángulos que más se repite; esto lo hacemos dividiendo el plano cartesiano en seis grupos como se muestra en la tabla 3.1 y en la figura 3.5.

Tabla 3.1 División del plano cartesiano

Ángulo Grados

1 0° a 59°

2 60° a 119°

3 120° a 179°

4 180° a 239°

5 240° a 299°

6 300° a 360°

Figura 3.5 División de los ángulos

Teniendo los grupos de ángulos ya listos, simplemente hay que calcular en cuál de los grupos se encuentra la mayor cantidad de ángulos de la escena y esto es considerado como una especie de fondo obtenido por medio de puntos destacado.

Ecuación 3.35

Ecuación 3.36

Ecuación 3.37



Umbral de separación: Para poder establecer nuestro umbral que ayude a separar el

fondo del primer plano tenemos que hacer dos cosas: la primera es calcular el tamaño de la línea generada por los dos puntos y después multiplicar este valor por un número mayor (recomendado 25) esto ayuda a aumentar el valor y poder manejar valores más grande a la hora de establecer el umbral, esto se realiza de la siguiente manera.

𝑇𝑎𝑚𝑎ñ𝑜 𝑑𝑒 𝑙𝑎 𝑙𝑖𝑛𝑒𝑎 = √∆𝑥2 + ∆𝑦2 Los valores que superen el umbral dado por el usuario serán considerados como primer plano y los que no como fondo. Cabe mencionar que para poder llegar a la aportación que ayudó a resolver el problema se hicieron varios experimentos en el plano cartesiano añadiéndole separadores de distancias circulares. Teniendo nuestro plano cartesiano con los separadores se realizaron los experimentos usando las ∆𝑥, ∆𝑦 y los θ (Fig. 3.6).

Figura 3.6 Plano cartesiano con separadores y colores

Generación de la imagen binaria: Por último, pero no menos importante viene la parte de generar la imagen binaria, en esta parte se usan los grupos de ángulos y el umbral de separación.

Primer plano (blanco): son el par de puntos que superaron el umbral y los cinco grupos de ángulos que no fueron tomados como fondo.

Fondo (negro): Es todo lo demás que no pudo superar el umbral y el grupo de ángulos que más se repite considerado como fondo.

La segmentación se realiza poniendo un pequeño círculo blanco que representa el objeto en movimiento, sobre un fondo prestablecido de color negro que sería lo que no se “mueve”. Flujo óptico: Para poder realizar la técnica de flujo óptico se usaron algunos métodos ya implementados en OpenCV [OpenCV, 2012], estos algoritmos ya implementados son: FastFeatureDetector [Rosten, 2006] → calcOpticalFlowPyrLK [Bouguet, 2000]. En el diagrama 3.2 se mostrará cómo es que se realiza la detección de los puntos destacados y el cálculo del flujo óptico (Lucas y Kanade) con los algoritmos antes mencionados, esta es considerada la primera parte de la técnica de flujo óptico.

Ecuación 3.38



Diagrama 3.2 Detección de puntos y cálculo del flujo óptico

Tenemos como salida un vector (próximo) que nos dice cuál es el punto y en donde está ubicado en la imagen más reciente, otro vector de estado que nos dice si ese punto tuvo o no flujo óptico y por último un vector que nos da el valor del error del flujo óptico en caso de que haya tenido. Después de haber obtenido los tres vectores, procedemos a dibujar en la imagen más actual el flujo óptico; esto quiere decir que tomamos como partida de la línea el punto en la imagen uno (𝐼1) que ya teníamos y como fin de la línea el punto de la imagen dos (𝐼2) que es el que nos regresa la función “calcOpticalFlowPyrLK” en su vector próximo (next) (Fig. 3.7).

Figura 3.7 Flujo óptico

Continuando con la explicación de la técnica de flujo óptico llegamos a la parte de mayor aportación y la que ayudó a resolver el problema de cámara móvil, esta sección a su vez se divide en tres partes: La primera es el cálculo del grupo de ángulos que más se repite en la escena, esto quiere decir que se calcula por medio de las líneas un grupo de ángulo y es el que más se repite, estos son considerados como una especie de fondo explicada en la página 40. La segunda es la implementación del umbral que ayuda a dividir el fondo del primer plano explicado en la página 42. Y por último la forma en que se genera la imagen binaria para la evaluación de la técnica esta explicada en la página 42. Con esto damos por finalizada la implementación del flujo óptico. Combinación de correspondencia de puntos y flujo óptico: Esta tercera implementación fue pensada para combinar la técnica de correspondencia de puntos y la de flujo óptico, los pasos que se siguieron para implementarla son los siguientes:



1) Detección de puntos en las imágenes, para el uso de ambas técnicas (Fig. 3.8).

Figura 3.8 Detección de puntos

2) Descripción de los puntos obtenido de las imágenes, solo para la técnica de correspondencia de puntos (Listado 3.1).

Listado 3.1 Descripción de puntos

3) Convertir las imágenes a escala de

gris, solo para la técnica de flujo óptico (Fig. 3.9).

Figura 3.9 Detección de puntos en gris

4) El apareamiento de los puntos para

poder obtener las correspondencias y la aplicación del umbral para quedarnos solo con las buenas correspondencias, solo para la técnica de correspondencia de puntos (Fig. 3.10).

Figura 3.10 Correspondencia de puntos

5) El cálculo del flujo óptico para la

generación de los vectores a usar, solo para la técnica de flujo óptico (Fig. 3.11).

Figura 3.11 Vectores generados

6) La generación del flujo con líneas obtenido de la correspondencia de puntos y del

flujo óptico obtenido del cálculo del flujo óptico (Fig. 3.12 y 3.13).

Figura 3.12 Flujo con líneas Figura 3.13 Flujo óptico

Sólo se pudo llegar hasta el punto seis y debido a esto lamentablemente no se pudo tener ningún resultado con ella ya que en realidad a la hora de hacer la combinación no se logró; no se pudo lograr principalmente por dos razones: primero el número de pares de puntos que son correctos en las dos técnicas es diferente, siendo mayor la de flujo óptico que la de correspondencia de puntos y esto hace que no se puedan emparejar los resultado, y por último la forma como las técnicas devuelven sus resultados (vectores de puntos) para la imagen más reciente también es diferente y esto hace que al querer compararlos no haya igualdad.



La conclusión sobre la combinación de ambas técnicas se da porque hasta ahí es que se pudo implementar la combinación, por parte de la correspondencia de puntos hasta la imagen de flujo de líneas y por parte del flujo óptico hasta la imagen del flujo óptico.

3.3. Implementación de la evaluación La implementación de los criterios de la evaluación es por separado, se explica cómo se calcula cada uno [McKoen, 2000] [Pless, 2003]: Velocidad de procesamiento: Se calcula el tiempo en segundos que tarda una técnica desde el momento que inicia hasta que termina; para esto se toma el tiempo en el momento que inicia, en el momento que termina, después se realiza una simple resta y con esto obtenemos el tiempo en segundos.

Tiempo = tiempo_2 – tiempo_1

Con el tiempo en segundos y el número de imágenes totales que proceso la técnica obtenemos los frames/segundo.

No_Img / Tiempo = no. frames/segundo

Precisión de la segmentación: Para este criterio primero debemos comparar la imagen binaria salida de la técnica con su ground truth en el mismo tiempo (t), los datos que necesitamos de la comparación son: el

número de verdaderos positivos (VP), verdaderos negativos (VN), el número total de valores cero en el ground truth y el número total de valores uno en el ground truth. Después procedemos a realizar las siguientes operaciones para obtener los porcentajes correctos de esa imagen binaria.

Porcentaje_0 = VN * 100 / total_0_ground_truth Porcentaje_1 = VP * 100 / total_1_ground_truth

Con esto obtenemos los porcentajes correctos para los pixeles que sus valores deben de ser cero (fondo) y de los pixeles de los cuales sus valores deben de ser uno (primer plano) en una imagen. Si queremos obtener los porcentajes correctos de la secuencia de imágenes lo que tenemos que hacer es sacar los porcentajes de todas las imágenes y sacar un promedio de ellos. Pseudocódigo y orden de complejidad de las técnicas: En esta parte se mostrará el pseudocódigo y el orden de complejidad de las técnicas a evaluar junto con el número de datos de entrada que necesita cada técnica. N = número de datos de entrada.

Técnicas de cámara estática:

o Resta de imágenes. o Promedio “n” últimas imágenes y resta de imágenes.

o Gaussiana simple. o Gaussiana simple con umbral. o Mezcla de gaussianas. o Fondo mezcla de gaussianas OpenCV2 con umbral.

Ecuación 3.39

Ecuación 3.40

Ecuación 3.42

Ecuación 4

Ecuación 3.41



Técnicas de cámara móvil:

o Correspondencia de puntos. o Flujo óptico.

Resta de imágenes Proceso Resta_Imagenes O(1) Definir video Como VideoCapture; O(1) Definir Original, OriginalOld, OriginalNew, Diferencia, Salida Como Mat; O(1) Definir esc Como Booleano; O(1) Definir noImg, umbral Como Entero; O(1) noImg<-0; esc<-false; O(1) Lee umbral; O(1) Mientras esc=false || video=true Hacer O(1) Lee video(Original); O(1) noImg<-noImg+1; O(1) (OriginalNew<-Original); O(1) Si noImg=1 Entonces O(1) (OriginalOld<-Original); O(1) FinSi O(1) Diferencia_de_Imagenes(Diferencia<-OriginalNew-OriginalOld); O(1) Umbralizacion_Binaria(Salida<-Diferencia,umbral); O(1) OriginalOld<-OriginalNew; O(1) Mostrar Original; O(1) Mostrar OriginalOld; O(1) Mostrar Salida; O(1) Si waitKey(10)>=0 Entonces O(1) esc=true; O(1) FinSi O(1) FinMientras O(1) FinProceso O(1)

El orden de complejidad de la técnica es: O(1), con N = 1.

Cabe mencionar que el número de datos fue igual a uno ya que para esta implementación se analizaba una imagen a la vez y la complejidad es de O(1) porque ninguna sentencia excedió ese orden de complejidad. Promedio “n” últimas imágenes y resta de imágenes Proceso Promedio_n_ultimas_imagenes_RI O(1) Definir video Como VideoCapture; O(1) Definir Original, Imagen, Fondo, Diferencia, Salida Como Mat; O(1) Definir PlanosRGB, ImagenRGB Como vector<Mat>; O(1) Definir ImgFondo(ancho_video,alto_video) Como wxImage; O(1) Definir esc Como Booleano; O(1) Definir noImg, umbral, pro_n_img, valorR, valorG, valorB Como Entero; O(1) Definir SumaR[ancho_video][alto_video] Como Entero; O(1) Definir SumaG[ancho_video][alto_video] Como Entero; O(1) Definir SumaB[ancho_video][alto_video] Como Entero; O(1) noImg<-0; esc<-false; O(1) Lee umbral, pro_n_img; O(1) Mientras esc=false || video=true Hacer O(1) Lee video(Original); O(1) noImg<-noImg+1; O(1) Si noImg <= pro_n_img Entonces O(1) Imagen<-imread(Original(noImg)); O(𝑛2) Split(Imagen,ImagenRGB); O(1) Para x<-0 Hasta x < ancho_video Con x++ Hacer O(n) Para y<-0 Hasta y < alto_video Con y++ Hacer O(𝑛2) ValorR<-ImagenRGB[2](Punto(x,y)); O(1) ValorG<-ImagenRGB[1](Punto(x,y)); O(1) ValorB<-ImagenRGB[0](Punto(x,y)); O(1) SumaR[x][y]<-SumaR[x][y] + ValorR; O(1) SumaG[x][y]<-SumaG[x][y] + ValorG; O(1) SumaB[x][y]<-SumaB[x][y] + ValorB; O(1) ImgFondo<-SetRGB(x, y, (SumaR[x][y]/noImg),

(SumaG[x][y]/noImg), (SumaB[x][y]/noImg));

O(1)

FinPara O(1) FinPara O(1)



SaveFile(FondoGenerado)<-ImgFondo; O(𝑛2) Sino O(1) Imagen<-imread(Original(noImg)); O(𝑛2) Split(Imagen,ImagenRGB); O(1) Para x<-0 Hasta x < ancho_video Con x++ Hacer O(n) Para y<-0 Hasta y < alto_video Con y++ Hacer O(𝑛2) ValorR<-ImagenRGB[2](Punto(x,y)); O(1) ValorG<-ImagenRGB[1](Punto(x,y)); O(1) ValorB<-ImagenRGB[0](Punto(x,y)); O(1) SumaR[x][y]<-SumaR[x][y] + ValorR; O(1) SumaG[x][y]<-SumaG[x][y] + ValorG; O(1) SumaB[x][y]<-SumaB[x][y] + ValorB; O(1) FinPara O(1) FinPara O(1) Imagen<-imread(Original(noImg-pro_n_img)); O(𝑛2) Split(Imagen,ImagenRGB); O(1) Para x<-0 Hasta x < ancho_video Con x++ Hacer O(n) Para y<-0 Hasta y < alto_video Con y++ Hacer O(𝑛2) ValorR<-ImagenRGB[2](Punto(x,y)); O(1) ValorG<-ImagenRGB[1](Punto(x,y)); O(1) ValorB<-ImagenRGB[0](Punto(x,y)); O(1) SumaR[x][y]<-SumaR[x][y] - ValorR; O(1) SumaG[x][y]<-SumaG[x][y] - ValorG; O(1) SumaB[x][y]<-SumaB[x][y] - ValorB; O(1) FinPara O(1) FinPara O(1) Para x<-0 Hasta x < ancho_video Con x++ Hacer O(n) Para y<-0 Hasta y < alto_video Con y++ Hacer O(𝑛2) ImgFondo<-SetRGB(x, y, (SumaR[x][y]/pro_n_img),

(SumaG[x][y]/pro_n_img), (SumaB[x][y]/pro_n_img)); O(1)

FinPara O(1) FinPara O(1) SaveFile(FondoGenerado)<-ImgFondo; O(𝑛2) FinSi O(1) Fondo<-imread(FondoGenerado); O(𝑛2) Diferencia_de_Imagenes(Diferencia<-Original-Fondo); O(1) Umbralizacion_Binaria(Salida<-Diferencia,umbral); O(1) Mostrar Original; O(1) Mostrar Fondo; O(1) Mostrar Salida; O(1) Si waitKey(10)>=0 Entonces O(1) esc=true; O(1) FinSi O(1) FinMientras O(1) FinProceso O(1)

El orden de complejidad de la técnica es: O(𝑛2), con N = 76,800.

Cabe mencionar que el número de datos fue igual a 76,800 ya que para esta implementación se analizó la imagen por pixel (ancho_video * alto_video = 320px * 240px) y la complejidad es de O(𝑛2) por los dos ciclos consecutivos que usan “N” en sus límites.

Gaussiana simple Proceso Gaussiana_simple O(1) Definir video Como VideoCapture; O(1) Definir Original, Fondo, Salida Como Mat; O(1) Definir PlanosRGB Como vector<Mat>; O(1) Definir ImgFondo(ancho_video,alto_video) Como wxImage; O(1) Definir ImgSalida(ancho_video,alto_video) Como wxImage; O(1) Definir esc Como Booleano; O(1) Definir noImg, desviacion, multiplica, alfa, valorR, valorG, valorB Como Entero; O(1) Definir umbralizacionR, umbralizacionG, umbralizacionB Como Entero; O(1) Definir ImagenR[ancho_video][alto_video] Como Entero; O(1) Definir ImagenG[ancho_video][alto_video] Como Entero; O(1) Definir ImagenB[ancho_video][alto_video] Como Entero; O(1) Definir diferenciaR, diferenciaG, diferenciaB Como Flotante; O(1) Definir MediaR[ancho_video][alto_video] Como Flotante; O(1) Definir MediaG[ancho_video][alto_video] Como Flotante; O(1) Definir MediaB[ancho_video][alto_video] Como Flotante; O(1) Definir desviacionPixelR[ancho_video][alto_video] Como Flotante; O(1)



Definir desviacionPixelG[ancho_video][alto_video] Como Flotante; O(1) Definir desviacionPixelB[ancho_video][alto_video] Como Flotante; O(1) Definir densidadPixelR[ancho_video][alto_video] Como Flotante; O(1) Definir densidadPixelG[ancho_video][alto_video] Como Flotante; O(1) Definir densidadPixelB[ancho_video][alto_video] Como Flotante; O(1) noImg<-0; esc<-false; O(1) Lee desviacion, multiplica, alfa; O(1) Mientras esc=false || video=true Hacer O(1) Lee video(Original); O(1) noImg<-noImg+1; O(1) Split(Original,PlanosRGB); O(1) Para x<-0 Hasta x < ancho_video Con x++ Hacer O(n) Para y<-0 Hasta y < alto_video Con y++ Hacer O(𝑛2) ValorR<-PlanosRGB[2](Punto(x,y)); O(1) ValorG<-PlanosRGB[1](Punto(x,y)); O(1) ValorB<-PlanosRGB[0](Punto(x,y)); O(1) ImagenR[x][y]<-ValorR; O(1) ImagenG[x][y]<-ValorG; O(1) ImagenB[x][y]<-ValorB; O(1) FinPara O(1) FinPara O(1) Para x<-0 Hasta x < ancho_video Con x++ Hacer O(n) Para y<-0 Hasta y < alto_video Con y++ Hacer O(𝑛2) Si noImg = 1 Entonces O(1) MediaR[x][y]<-ImagenR[x][y]; O(1) MediaG[x][y]<-ImagenG[x][y]; O(1) MediaB[x][y]<-ImagenB[x][y]; O(1) desviacionPixelR[x][y]<-desviacion; O(1) desviacionPixelG[x][y]<-desviacion; O(1) desviacionPixelB[x][y]<-desviacion; O(1) densidadPixelR[x][y]<-desviacionPixelR[x][y]*multiplica; O(1) densidadPixelG[x][y]<-desviacionPixelG[x][y]*multiplica; O(1) densidadPixelB[x][y]<-desviacionPixelB[x][y]*multiplica; O(1) diferenciaR<-abs(ImagenR[x][y]-MediaR[x][y]); O(1) diferenciaG<-abs(ImagenG[x][y]-MediaG[x][y]); O(1) diferenciaB<-abs(ImagenB[x][y]-MediaB[x][y]); O(1) Si (diferenciaR >= densidadPixelR[x][y] || (diferenciaG >=

densidadPixelG[x][y] || (diferenciaB >= densidadPixelB[x][y]) Entonces O(1)

umbralizacionR<-255; O(1) umbralizacionG<-255; O(1) umbralizacionB<-255; O(1) Sino O(1) umbralizacionR<-0; O(1) umbralizacionG<-0; O(1) umbralizacionB<-0; O(1) FinSi O(1) Sino O(1) MediaR[x][y]<-alfa*ImagenR[x][y]+(1-alfa)*MediaR[x][y]; O(1) MediaG[x][y]<-alfa*ImagenG[x][y]+(1-alfa)*MediaG[x][y]; O(1) MediaB[x][y]<-alfa*ImagenB[x][y]+(1-alfa)*MediaB[x][y]; O(1) desviacionPixelR[x][y]<-sqrt(alfa*pow((ImagenR[x][y]-

MediaR[x][y]),2)+(1-alfa)*pow(desviacion,2));

O(1)

desviacionPixelG[x][y]<-sqrt(alfa*pow((ImagenG[x][y]-

MediaG[x][y]),2)+(1-alfa)*pow(desviacion,2));

O(1)

desviacionPixelB[x][y]<-sqrt(alfa*pow((ImagenB[x][y]-

MediaB[x][y]),2)+(1-alfa)*pow(desviacion,2));

O(1)

densidadPixelR[x][y]<-desviacionPixelR[x][y]*multiplica; O(1) densidadPixelG[x][y]<-desviacionPixelG[x][y]*multiplica; O(1) densidadPixelB[x][y]<-desviacionPixelB[x][y]*multiplica; O(1) diferenciaR<-abs(ImagenR[x][y]-MediaR[x][y]); O(1) diferenciaG<-abs(ImagenG[x][y]-MediaG[x][y]); O(1) diferenciaB<-abs(ImagenB[x][y]-MediaB[x][y]); O(1) Si (diferenciaR >= densidadPixelR[x][y] || (diferenciaG >=

densidadPixelG[x][y] || (diferenciaB >= densidadPixelB[x][y]) Entonces O(1)

umbralizacionR<-255; O(1) umbralizacionG<-255; O(1) umbralizacionB<-255; O(1) Sino O(1) umbralizacionR<-0; O(1) umbralizacionG<-0; O(1)



umbralizacionB<-0; O(1) FinSi O(1) FinSi O(1) ImgFondo<-SetRGB(x, y, MediaR[x][y], MediaG[x][y], MediaB[x][y]); O(1) ImgSalida<-SetRGB(x, y, umbralizacionR, umbralizacionG,

umbralizacionB);

O(1)

FinPara O(1) FinPara O(1) SaveFile(FondoGenerado)<-ImgFondo; O(𝑛2) SaveFile(SalidaGenerada)<-ImgSalida; O(𝑛2) Fondo<-imread(FondoGenerado); O(𝑛2) Salida<-imread(SalidaGenerada); O(𝑛2) Mostrar Original; O(1) Mostrar Fondo; O(1) Mostrar Salida; O(1) Si waitKey(10)>=0 Entonces O(1) esc=true; O(1) FinSi O(1) FinMientras O(1) FinProceso O(1)

El orden de complejidad de la técnica es: O(𝑛2), con N = 76,800. Cabe mencionar que el número de datos fue igual a 76,800 ya que para esta implementación se analizó la imagen por pixel (ancho_video * alto_video = 320px * 240px) y la complejidad es de O(𝑛2) por los dos ciclos consecutivos que usan “N” en sus límites.

Gaussiana simple con umbral Proceso Gaussiana_simple_umbral O(1) Definir video Como VideoCapture; O(1) Definir Original, Fondo, Diferencia, Salida Como Mat; O(1) Definir ImgFondo(ancho_video,alto_video) Como wxImage; O(1) Definir esc Como Booleano; O(1) Definir noImg, umbral, alfa, valor Como Entero; O(1) Definir Imagen[ancho_video][alto_video] Como Entero; O(1) Definir Media[ancho_video][alto_video] Como Entero; O(1) noImg<-0; esc<-false; O(1) Lee umbral, alfa; O(1) Mientras esc=false || video=true Hacer O(1) Lee video(Original); O(1) noImg<-noImg+1; O(1) Para x<-0 Hasta x < ancho_video Con x++ Hacer O(n) Para y<-0 Hasta y < alto_video Con y++ Hacer O(𝑛2) Valor<-Original(Punto(x,y)); O(1) Imagen[x][y]<-Valor; O(1) FinPara O(1) FinPara O(1) Para x<-0 Hasta x < ancho_video Con x++ Hacer O(n) Para y<-0 Hasta y < alto_video Con y++ Hacer O(𝑛2) Si noImg = 1 Entonces O(1) Media[x][y]<-Imagen[x][y]; O(1) Sino O(1) Media[x][y]<-alfa*Imagen[x][y]+(1-alfa)*Media[x][y]; O(1) FinSi O(1) ImgFondo<-SetRGB(x, y, Media[x][y], Media[x][y], Media[x][y]); O(1) FinPara O(1) FinPara O(1) SaveFile(FondoGenerado)<-ImgFondo; O(𝑛2) Fondo<-imread(FondoGenerado); O(𝑛2) Diferencia_de_Imagenes(Diferencia<-Original-Fondo); O(1) Umbralizacion_Binaria(Salida<-Diferencia,umbral); O(1) Mostrar Original; O(1) Mostrar Fondo; O(1) Mostrar Salida; O(1) Si waitKey(10)>=0 Entonces O(1) esc=true; O(1) FinSi O(1) FinMientras O(1) FinProceso O(1)




Cabe mencionar que el número de datos fue igual a 76,800 ya que para esta implementación se analizó la imagen por pixel (ancho_video * alto_video = 320px * 240px)

y la complejidad es de O(𝑛2) por los dos ciclos consecutivos que usan “N” en sus límites. Mezcla de gaussianas Proceso Mezcla_gaussianas O(1) Definir video Como VideoCapture; O(1) Definir Original, Fondo, Salida Como Mat; O(1) Definir PlanosRGB Como vector<Mat>; O(1) Definir ImgFondo(ancho_video,alto_video) Como wxImage; O(1) Definir ImgSalida(ancho_video,alto_video) Como wxImage; O(1) Definir esc Como Booleano; O(1) Definir noImg, desviacion, multiplica, alfa, rho, k Como Entero; O(1) Definir valorR, valorG, valorB Como Entero; O(1) Definir umbralizacionR, umbralizacionG, umbralizacionB Como Entero; O(1) Definir ImagenR[ancho_video][alto_video] Como Entero; O(1) Definir ImagenG[ancho_video][alto_video] Como Entero; O(1) Definir ImagenB[ancho_video][alto_video] Como Entero; O(1) Definir diferenciaR, diferenciaG, diferenciaB Como Flotante; O(1) noImg<-0; esc<-false; k<-3; O(1) Definir MediaR[k][ancho_video][alto_video] Como Flotante; O(1) Definir MediaG[k][ancho_video][alto_video] Como Flotante; O(1) Definir MediaB[k][ancho_video][alto_video] Como Flotante; O(1) Definir desviacionPixelR[k][ancho_video][alto_video] Como Flotante; O(1) Definir desviacionPixelG[k][ancho_video][alto_video] Como Flotante; O(1) Definir desviacionPixelB[k][ancho_video][alto_video] Como Flotante; O(1) Definir densidadPixelR[k][ancho_video][alto_video] Como Flotante; O(1) Definir densidadPixelG[k][ancho_video][alto_video] Como Flotante; O(1) Definir densidadPixelB[k][ancho_video][alto_video] Como Flotante; O(1) Definir FondoR[ancho_video][alto_video] Como Flotante; O(1) Definir FondoG[ancho_video][alto_video] Como Flotante; O(1) Definir FondoB[ancho_video][alto_video] Como Flotante; O(1) Definir pesosR[k], pesosG[k], pesosB[k] Como Flotante; O(1) Definir sumPesosR, sumPesosG, sumPesosB Como Flotante; O(1) Definir proDensidadR, proDensidadG, proDensidadB Como Flotante; O(1) Lee desviacion, multiplica, alfa, rho; O(1) Mientras esc=false || video=true Hacer O(1) Lee video(Original); O(1) noImg<-noImg+1; O(1) Split(Original,PlanosRGB); O(1) Para x<-0 Hasta x < ancho_video Con x++ Hacer O(n) Para y<-0 Hasta y < alto_video Con y++ Hacer O(𝑛2) ValorR<-PlanosRGB[2](Punto(x,y)); O(1) ValorG<-PlanosRGB[1](Punto(x,y)); O(1) ValorB<-PlanosRGB[0](Punto(x,y)); O(1) ImagenR[x][y]<-ValorR; O(1) ImagenG[x][y]<-ValorG; O(1) ImagenB[x][y]<-ValorB; O(1) FinPara O(1) FinPara O(1) Si noImg = 1 Entonces O(1) Para z<-0 Hasta z < k Con z++ Hacer O(1) Para x<-0 Hasta x < ancho_video Con x++ Hacer O(n) Para y<-0 Hasta y < alto_video Con y++ Hacer O(𝑛2) Si z = 0 Entonces O(1) MediaR[z][x][y]<-ImagenR[x][y]; O(1) MediaG[z][x][y]<-ImagenG[x][y]; O(1) MediaB[z][x][y]<-ImagenB[x][y]; O(1) desviacionPixelR[z][x][y]<-desviacion; O(1) desviacionPixelG[z][x][y]<-desviacion; O(1) desviacionPixelB[z][x][y]<-desviacion; O(1) densidadPixelR[z][x][y]<-desviacionPixelR[z][x][y]*multiplica; O(1) densidadPixelG[z][x][y]<-desviacionPixelG[z][x][y]*multiplica; O(1) densidadPixelB[z][x][y]<-desviacionPixelB[z][x][y]*multiplica; O(1) pesosR[z]<-1.0; O(1) pesosG[z]<-1.0; O(1) pesosB[z]<-1.0; O(1)



Sino O(1) MediaR[z][x][y]<-aleatorio(0-255); O(1) MediaG[z][x][y]<-aleatorio(0-255); O(1) MediaB[z][x][y]<-aleatorio(0-255); O(1) desviacionPixelR[z][x][y]<-desviacion; O(1) desviacionPixelG[z][x][y]<-desviacion; O(1) desviacionPixelB[z][x][y]<-desviacion; O(1) densidadPixelR[z][x][y]<-desviacionPixelR[z][x][y]*multiplica; O(1) densidadPixelG[z][x][y]<-desviacionPixelG[z][x][y]*multiplica; O(1) densidadPixelB[z][x][y]<-desviacionPixelB[z][x][y]*multiplica; O(1) pesosR[z]<-0.0; O(1) pesosG[z]<-0.0; O(1) pesosB[z]<-0.0; O(1) FinSi O(1) FinPara O(1) FinPara O(1) FinPara O(1) Sino O(1) Para z<-0 Hasta z < k Con z++ Hacer O(1) Para x<-0 Hasta x < ancho_video Con x++ Hacer O(n) Para y<-0 Hasta y < alto_video Con y++ Hacer O(𝑛2) diferenciaR<-abs(ImagenR[x][y]-MediaR[z][x][y]); O(1) diferenciaG<-abs(ImagenG[x][y]-MediaG[z][x][y]); O(1) diferenciaB<-abs(ImagenB[x][y]-MediaB[z][x][y]); O(1) Si diferenciaR <= densidadPixelR[z][x][y] Entonces O(1) MediaR[z][x][y]<-rho*ImagenR[x][y]+(1-rho)*MediaR[z][x][y]; O(1) desviacionPixelR[z][x][y]<-sqrt(rho*pow(ImagenR[x][y]-

MediaR[z][x][y],2)+(1-rho)*pow(desviacion,2));

O(1)

pesosR[z]<-pesosR[z]; O(1) FinSi O(1) Si diferenciaR > densidadPixelR[z][x][y] Entonces O(1) MediaR[z][x][y]<-MediaR[z][x][y]; O(1) desviacionPixelR[z][x][y]<-desviacionPixelR[z][x][y]; O(1) pesosR[z]<-(1-alfa)*pesosR[z]; O(1) FinSi O(1) Si diferenciaG <= densidadPixelG[z][x][y] Entonces O(1) MediaG[z][x][y]<-rho*ImagenG[x][y]+(1-rho)*MediaG[z][x][y]; O(1) desviacionPixelG[z][x][y]<-sqrt(rho*pow(ImagenG[x][y]-

MediaG[z][x][y],2)+(1-rho)*pow(desviacion,2));

O(1)

pesosR[z]<-pesosR[z]; O(1) FinSi O(1) Si diferenciaG > densidadPixelG[z][x][y] Entonces O(1) MediaG[z][x][y]<-MediaG[z][x][y]; O(1) desviacionPixelG[z][x][y]<-desviacionPixelG[z][x][y]; O(1) pesosR[z]<-(1-alfa)*pesosR[z]; O(1) FinSi O(1) Si diferenciaB <= densidadPixelB[z][x][y] Entonces O(1) MediaB[z][x][y]<-rho*ImagenB[x][y]+(1-rho)*MediaB[z][x][y]; O(1) desviacionPixelB[z][x][y]<-sqrt(rho*pow(ImagenB[x][y]-

MediaB[z][x][y],2)+(1-rho)*pow(desviacion,2));

O(1)

pesosR[z]<-pesosR[z]; O(1) FinSi O(1) Si diferenciaB > densidadPixelB[z][x][y] Entonces O(1) MediaB[z][x][y]<-MediaB[z][x][y]; O(1) desviacionPixelB[z][x][y]<-desviacionPixelB[z][x][y]; O(1) pesosR[z]<-(1-alfa)*pesosR[z]; O(1) FinSi O(1) densidadPixelR[z][x][y]<-desviacionPixelR[z][x][y]*multiplica; O(1) densidadPixelG[z][x][y]<-desviacionPixelG[z][x][y]*multiplica; O(1) densidadPixelB[z][x][y]<-desviacionPixelB[z][x][y]*multiplica; O(1) FinPara O(1) FinPara O(1) FinPara O(1) FinSi O(1) sumPesosR<-pesosR[0]+pesosR[1]+pesosR[2]; O(1) sumPesosG<-pesosG[0]+pesosG[1]+pesosG[2]; O(1) sumPesosB<-pesosB[0]+pesosB[1]+pesosB[2]; O(1) Para z<-0 Hasta z < k Con z++ Hacer O(1) pesosR[z]<-pesosR[z]/sumPesosR; O(1) pesosG[z]<-pesosG[z]/sumPesosG; O(1)



pesosB[z]<-pesosB[z]/sumPesosB; O(1) FinPara O(1) Para x<-0 Hasta x < ancho_video Con x++ Hacer O(n) Para y<-0 Hasta y < alto_video Con y++ Hacer O(𝑛2) FondoR[x][y]<-pesosR[0]*MediaR[0][x][y]+ pesosR[1]*MediaR[1][x][y]+

pesosR[2]*MediaR[2][x][y];

O(1)

FondoG[x][y]<-pesosG[0]*MediaG[0][x][y]+ pesosG[1]*MediaG[1][x][y]+

pesosG[2]*MediaG[2][x][y];

O(1)

FondoB[x][y]<-pesosB[0]*MediaB[0][x][y]+ pesosB[1]*MediaB[1][x][y]+

pesosB[2]*MediaB[2][x][y];

O(1)

ImgFondo<-SetRGB(x, y, FondoR[x][y], FondoG[x][y], FondoB[x][y]); O(1) FinPara O(1) FinPara O(1) SaveFile(FondoGenerado)<-ImgFondo; O(𝑛2) Fondo<-imread(FondoGenerado); O(𝑛2) Para x<-0 Hasta x < ancho_video Con x++ Hacer O(n) Para y<-0 Hasta y < alto_video Con y++ Hacer O(𝑛2) Si pesosR[0]>pesosR[1] && pesosR[0]>pesosR[2] Entonces O(1) proDensidadR<-densidadPixelR[0][x][y]; O(1) FinSi O(1) Si pesosR[1]>pesosR[0] && pesosR[1]>pesosR[2] Entonces O(1) proDensidadR<-densidadPixelR[1][x][y]; O(1) FinSi O(1) Si pesosR[2]>pesosR[0] && pesosR[2]>pesosR[1] Entonces O(1) proDensidadR<-densidadPixelR[2][x][y]; O(1) FinSi O(1) Si pesosG[0]>pesosG[1] && pesosG[0]>pesosG[2] Entonces O(1) proDensidadG<-densidadPixelG[0][x][y]; O(1) FinSi O(1) Si pesosG[1]>pesosG[0] && pesosG[1]>pesosG[2] Entonces O(1) proDensidadG<-densidadPixelG[1][x][y]; O(1) FinSi O(1) Si pesosG[2]>pesosG[0] && pesosG[2]>pesosG[1] Entonces O(1) proDensidadG<-densidadPixelG[2][x][y]; O(1) FinSi O(1) Si pesosB[0]>pesosB[1] && pesosB[0]>pesosB[2] Entonces O(1) proDensidadB<-densidadPixelB[0][x][y]; O(1) FinSi O(1) Si pesosB[1]>pesosB[0] && pesosB[1]>pesosB[2] Entonces O(1) proDensidadB<-densidadPixelB[1][x][y]; O(1) FinSi O(1) Si pesosB[2]>pesosB[0] && pesosB[2]>pesosB[1] Entonces O(1) proDensidadB<-densidadPixelB[2][x][y]; O(1) FinSi O(1) diferenciaR<-abs(ImagenR[x][y]-FondoR[x][y]); O(1) diferenciaG<-abs(ImagenG[x][y]-FondoG[x][y]); O(1) diferenciaB<-abs(ImagenB[x][y]-FondoB[x][y]); O(1) Si diferenciaR > proDensidadR || diferenciaG > proDensidadG || diferenciaB

> proDensidadB Entonces O(1)

umbralizacionR<-255; O(1) umbralizacionG<-255; O(1) umbralizacionB<-255; O(1) Sino O(1) umbralizacionR<-0; O(1) umbralizacionG<-0; O(1) umbralizacionB<-0; O(1) FinSi O(1) ImgSalida<-SetRGB(x, y, umbralizacionR, umbralizacionG, umbralizacionB); O(1) FinPara O(1) FinPara O(1) SaveFile(SalidaGenerada)<-ImgSalida; O(𝑛2) Salida<-imread(SalidaGenerada); O(𝑛2) Mostrar Original; O(1) Mostrar Fondo; O(1) Mostrar Salida; O(1) Si waitKey(10)>=0 Entonces O(1) esc=true; O(1) FinSi O(1) FinMientras O(1) FinProceso O(1)




Cabe mencionar que el número de datos fue igual a 76,800 ya que para esta implementación se analizó la imagen por pixel (ancho_video * alto_video = 320px * 240px)

y la complejidad es de O(𝑛2) por los dos ciclos consecutivos que usan “N” en sus límites. Fondo mezcla de gaussianas OpenCV2 con umbral Proceso Fondo_mezcla_gaussianas_OpenCV2_umbral O(1) Definir video Como VideoCapture; O(1) Definir Original, ImagenFondo, Diferencia, Salida Como Mat; O(1) Definir PrimerPlano2 Como BackgroundSubtractorMOG2; O(1) Definir esc Como Booleano; O(1) Definir noImg, umbral Como Entero; O(1) noImg<-0; esc<-false; O(1) Lee umbral; O(1) Mientras esc=false || video=true Hacer O(1) Lee video(Original); O(1) noImg<-noImg+1; O(1) ImagenFondo<-GetBackgroundImage(PrimerPlano2); O(1) Diferencia_de_Imagenes(Diferencia<-Original-ImagenFondo); O(1) Umbralizacion_Binaria(Salida<-Diferencia,umbral); O(1) Mostrar Original; O(1) Mostrar ImagenFondo; O(1) Mostrar Salida; O(1) Si waitKey(10)>=0 Entonces O(1) esc=true; O(1) FinSi O(1) FinMientras O(1) FinProceso O(1)

El orden de complejidad de la técnica es: O(1), con N = 1. Cabe mencionar que el número de datos fue igual a uno ya que para esta implementación se analizaba una imagen a la vez y la complejidad es de O(1) porque ninguna sentencia

excedió ese orden de complejidad. Correspondencia de puntos Proceso Correspondencia_puntos O(1) Definir video Como VideoCapture; O(1) Definir detectorFAST Como FastFeatureDetector; O(1) Definir descriptorSIFT Como SiftDescriptorExtractor; O(1) Definir correspondenciaBFM Como BruteForceMatcher< L2<flotante> >; O(1) Definir Original_1, Original_2, Descripcion_1, Descripcion_2, Puntos Como Mat; O(1) Definir img_correspondencias, Flujo_Lineas, Flujo_Lineas2, Segmentacion Como Mat; O(1) Definir PuntosDestacados_1, PuntosDestacados_2 Como vector<KeyPoint>; O(1) Definir correspondencias, BuenasCorrespondencias Como vector<DMatch>; O(1) Definir esc Como Booleano; O(1) Definir noImg, cont Como Entero; O(1) Definir ang1, ang2,ang3, ang4, ang5, ang6, angM Como Entero; O(1) Definir noPuntos Como Entero sin signo; O(1) Definir delta_x, delta_y, m, anguloG, h Como Flotante; O(1) Definir dist, max_dist, min_dist Como Doble; O(1) #define PI 3.14159265; O(1) noImg<-0; esc<-false; O(1) Lee umbral, dist_min_por; O(1) Mientras esc=false || video=true Hacer O(1) Lee video(Original_2); O(1) noImg<-noImg+1; O(1) Puntos_destacados_2<-detectorFAST(Original_2); O(𝑛4) Puntos<-drawKeypoints(Puntos_Destacados_2); O(n) Descripcion_2<-descriptorSIFT(Puntos_Destacados_2); O(n) Si noImg > 1 Entonces O(1) cont<-0; max_dist<-0; min_dist<-100; O(1) correspondencias<-correspondenciasBFM(Descripcion_2,Descripcion_1); O(𝑛3) Para i<-0 Hasta i < Descripcion_2(rows) Con i++ Hacer O(n) dist<-correspondencias[i](distancia); O(1) Si dist < min_dist Entonces O(1) min_dist<-dist; O(1) FinSi O(1)



Si dist > max_dist Entonces O(1) max_dist<-dist; O(1) FinSi O(1) FinPara O(1) Para i<-0 Hasta i < Descripcion_2(rows) Con i++ Hacer O(n) Si correspondencias[i](distancia) <= dist_min_por*min_dist Entonces O(1) BuenasCorrespondencias<-correspondencias[i]; O(1) cont<-cont+1; O(1) FinSi O(1) FinPara O(1) img_correspondencias<-

drawMatches(Original_2,PuntosDestacados_2,Original_1,PuntosDestacados_1,BuenasCor

respondencias);

O(n)

Mostrar img_correspondencias; O(1) Flujo_Lineas<-Original_2; O(1) Flujo_Lineas2<-Original_2; O(1) noPuntos<-cont; O(1) Definir PD1(noPuntos), PD2(noPuntos) Como vector<Point2f>; O(1) ang1<-0, ang2<-0, ang3<-0, ang4<-0, ang5<-0, ang6<-0, angM<-0; O(1) Para i<-0 Hasta i < noPuntos Con i++ Hacer O(n) PD2[i]<-PuntosDestacados_2[BuenasCorrespondencias[i](Inicio)]; O(1) PD1[i]<-PuntosDestacados_1[BuenasCorrespondencias[i](Fin)]; O(1) delta_x<-PD2[i](x) – PD1[i](x); O(1) delta_y<-PD2[i](y) – PD1[i](y); O(1) m<-delta_y/delta_x; O(1) anguloG<-atan(m)*180/PI; O(1) Si anguloG >= 0 && anguloG < 60 Entonces O(1) ang1<-ang1+1; O(1) FinSi O(1) Si anguloG >= 60 && anguloG < 120 Entonces O(1) ang2<-ang2+1; O(1) FinSi O(1) Si anguloG >= 120 && anguloG < 180 Entonces O(1) ang3<-ang3+1; O(1) FinSi O(1) Si anguloG >= 180 && anguloG < 240 Entonces O(1) ang4<-ang4+1; O(1) FinSi O(1) Si anguloG >= 240 && anguloG < 300 Entonces O(1) ang5<-ang5+1; O(1) FinSi O(1) Si anguloG >= 300 && anguloG < 361 Entonces O(1) ang6<-ang6+1; O(1) FinSi O(1) FinPara O(1) Si ang1 > ang2, ang3, ang4, ang5, ang6 Entonces O(1) angM<-1; O(1) FinSi O(1) Si ang2 > ang1, ang3, ang4, ang5, ang6 Entonces O(1) angM<-2; O(1) FinSi O(1) Si ang3 > ang1, ang2, ang4, ang5, ang6 Entonces O(1) angM<-3; O(1) FinSi O(1) Si ang4 > ang1, ang2, ang3, ang5, ang6 Entonces O(1) angM<-4; O(1) FinSi O(1) Si ang5 > ang1, ang2, ang3, ang4, ang6 Entonces O(1) angM<-5; O(1) FinSi O(1) Si ang6 > ang1, ang2, ang3, ang4, ang5 Entonces O(1) angM<-6; O(1) FinSi O(1) Para i<-0 Hasta i < noPuntos Con i++ Hacer O(n) Flujo_Lineas<-line(PD1[i],PD2[i]); O(1) delta_x<-PD2[i](x) – PD1[i](x); O(1) delta_y<-PD2[i](y) – PD1[i](y); O(1) m<-delta_y/delta_x; O(1) anguloG<-atan(m)*180/PI; O(1) h<-sqrt(pow(delta_x,2)+pow(delta_y,2)); O(1)



h<-h*25; O(1) Si h > umbral Entonces O(1) Si anguloG >= 0 && anguloG < 60 && angM != 1 Entonces O(1) Flujo_Lineas2<-line(PD1[i],PD2[i],rojo); O(1) Segmentacion<-circle(PD2[i]); O(1) FinSi O(1) Si anguloG >= 60 && anguloG < 120 && angM != 2 Entonces O(1) Flujo_Lineas2<-line(PD1[i],PD2[i],verde); O(1) Segmentacion<-circle(PD2[i]); O(1) FinSi O(1) Si anguloG >= 120 && anguloG < 180 && angM != 3 Entonces O(1) Flujo_Lineas2<-line(PD1[i],PD2[i],azul); O(1) Segmentacion<-circle(PD2[i]); O(1) FinSi O(1) Si anguloG >= 180 && anguloG < 240 && angM != 4 Entonces O(1) Flujo_Lineas2<-line(PD1[i],PD2[i],cyan); O(1) Segmentacion<-circle(PD2[i]); O(1) FinSi O(1) Si anguloG >= 240 && anguloG < 300 && angM != 5 Entonces O(1) Flujo_Lineas2<-line(PD1[i],PD2[i],magenta); O(1) Segmentacion<-circle(PD2[i]); O(1) FinSi O(1) Si anguloG >= 300 && anguloG < 361 && angM != 6 Entonces O(1) Flujo_Lineas2<-line(PD1[i],PD2[i],amarillo); O(1) Segmentacion<-circle(PD2[i]); O(1) FinSi O(1) FinSi O(1) FinPara O(1) Mostrar Flujo_Lineas; O(1) Mostrar Flujo_Lineas2; O(1) Mostrar Segmentacion; O(1) Original_1<-Original_2; O(1) Descripcion_1<-Descripcion_2; O(1) PuntosDestacados_1<-PuntosDestacados_2; O(1) Si waitKey(10)>=0 Entonces O(1) esc=true; O(1) FinSi O(1) FinMientras O(1) FinProceso O(1)

El orden de complejidad de la técnica es: O(𝑛4), con N = variable.

Cabe mencionar que el número de datos es variable ya que para esta implementación se usa los puntos destacados detectados en la imagen y varia con cada una; y la complejidad es de O(𝑛4) por los ciclos que usan “N” en sus límites.

Flujo óptico Proceso Flujo_optico O(1) Definir video Como VideoCapture; O(1) Definir detectorFAST Como FastFeatureDetector; O(1) Definir Original_1, Original_2, Original_1_Gris, Original_2_Gris Como Mat; O(1) Definir Puntos, FlujoOptico1, FlujoOptico2, Segmentacion Como Mat; O(1) Definir PuntosDestacados_1, PuntosDestacados_2 Como vector<KeyPoint>; O(1) Definir esc Como Booleano; O(1) Definir noImg, noPuntos Como Entero; O(1) Definir ang1, ang2,ang3, ang4, ang5, ang6, angM Como Entero; O(1) Definir delta_x, delta_y, m, anguloG, h Como Flotante; O(1) #define PI 3.14159265; O(1) noImg<-0; esc<-false; O(1) Lee umbral; O(1) Mientras esc=false || video=true Hacer O(1) Lee video(Original_2); O(1) noImg<-noImg+1; O(1) Puntos_destacados_2<-detectorFAST(Original_2); O(𝑛4) Puntos<-drawKeypoints(Puntos_Destacados_2); O(n) Convertidor_Grises(Original_2,Original_2_Gris); O(𝑛2) Si noImg > 1 Entonces O(1) noPuntos<-PuntosDestacados_2(Tamaño); O(1) Definir PD1(noPuntos), PD2(noPuntos), PDNext(noPuntos) Como vector<Point2f>; O(1) Definir estado(noPuntos) Como vector<uchar>; O(1)



Definir err_or(noPuntos) Como vector<flotante>; O(1) Para i<-0 Hasta i < noPuntos Con i++ Hacer O(n) PD2[i]<-PuntosDestacados_2[i]; O(1) PD1[i]<-PuntosDestacados_1[i]; O(1) FinPara O(1) FlujoOptico1<-Original_2; O(1) FlujoOptico2<-Original_2; O(1) Calculo_FlujoOptico_Piramidal_LK(Original_1_Gris, Original_2_Gris, PD1,

PDNext, estado, err_or);

O(𝑛4)

ang1<-0, ang2<-0, ang3<-0, ang4<-0, ang5<-0, ang6<-0, angM<-0; O(1) Para i<-0 Hasta i < noPuntos Con i++ Hacer O(n) Si estado[i] = 1 Entonces O(1) delta_x<-PDNext[i](x) – PD1[i](x); O(1) delta_y<-PDNext[i](y) – PD1[i](y); O(1) m<-delta_y/delta_x; O(1) anguloG<-atan(m)*180/PI; O(1) Si anguloG >= 0 && anguloG < 60 Entonces O(1) ang1<-ang1+1; O(1) FinSi O(1) Si anguloG >= 60 && anguloG < 120 Entonces O(1) ang2<-ang2+1; O(1) FinSi O(1) Si anguloG >= 120 && anguloG < 180 Entonces O(1) ang3<-ang3+1; O(1) FinSi O(1) Si anguloG >= 180 && anguloG < 240 Entonces O(1) ang4<-ang4+1; O(1) FinSi O(1) Si anguloG >= 240 && anguloG < 300 Entonces O(1) ang5<-ang5+1; O(1) FinSi O(1) Si anguloG >= 300 && anguloG < 361 Entonces O(1) ang6<-ang6+1; O(1) FinSi O(1) FinSi O(1) FinPara O(1) Si ang1 > ang2, ang3, ang4, ang5, ang6 Entonces O(1) angM<-1; O(1) FinSi O(1) Si ang2 > ang1, ang3, ang4, ang5, ang6 Entonces O(1) angM<-2; O(1) FinSi O(1) Si ang3 > ang1, ang2, ang4, ang5, ang6 Entonces O(1) angM<-3; O(1) FinSi O(1) Si ang4 > ang1, ang2, ang3, ang5, ang6 Entonces O(1) angM<-4; O(1) FinSi O(1) Si ang5 > ang1, ang2, ang3, ang4, ang6 Entonces O(1) angM<-5; O(1) FinSi O(1) Si ang6 > ang1, ang2, ang3, ang4, ang5 Entonces O(1) angM<-6; O(1) FinSi O(1) Para i<-0 Hasta i < noPuntos Con i++ Hacer O(n) Si estado[i] = 1 Entonces O(1) FlujoOptico1<-line(PD1[i],PDNext[i]); O(1) delta_x<-PDNext[i](x) – PD1[i](x); O(1) delta_y<-PDNext[i](y) – PD1[i](y); O(1) m<-delta_y/delta_x; O(1) anguloG<-atan(m)*180/PI; O(1) h<-sqrt(pow(delta_x,2)+pow(delta_y,2)); O(1) h<-h*25; O(1) Si h > umbral Entonces O(1) Si anguloG >= 0 && anguloG < 60 && angM != 1 Entonces O(1) FlujoOptico2<-line(PD1[i],PDNext[i],rojo); O(1) Segmentacion<-circle(PDNext[i]); O(1) FinSi O(1) Si anguloG >= 60 && anguloG < 120 && angM != 2 Entonces O(1) FlujoOptico2<-line(PD1[i],PDNext[i],verde); O(1)



Segmentacion<-circle(PDNext[i]); O(1) FinSi O(1) Si anguloG >= 120 && anguloG < 180 && angM != 3 Entonces O(1) FlujoOptico2<-line(PD1[i],PDNext[i],azul); O(1) Segmentacion<-circle(PDNext[i]); O(1) FinSi O(1) Si anguloG >= 180 && anguloG < 240 && angM != 4 Entonces O(1) FlujoOptico2<-line(PD1[i],PDNext[i],cyan); O(1) Segmentacion<-circle(PDNext[i]); O(1) FinSi O(1) Si anguloG >= 240 && anguloG < 300 && angM != 5 Entonces O(1) FlujoOptico2<-line(PD1[i],PDNext[i],magenta); O(1) Segmentacion<-circle(PDNext[i]); O(1) FinSi O(1) Si anguloG >= 300 && anguloG < 361 && angM != 6 Entonces O(1) FlujoOptico2<-line(PD1[i],PDNext[i],amarillo); O(1) Segmentacion<-circle(PDNext[i]); O(1) FinSi O(1) FinSi O(1) FinSi O(1) FinPara O(1) Mostrar FlujoOptico1; O(1) Mostrar FlujoOptico2; O(1) Mostrar Segmentacion; O(1) Original_1<-Original_2; O(1) Original_1_Gris<-Original_2_Gris; O(1) PuntosDestacados_1<-PuntosDestacados_2; O(1) Si waitKey(10)>=0 Entonces O(1) esc=true; O(1) FinSi O(1) FinMientras O(1) FinProceso O(1)

El orden de complejidad de la técnica es: O(𝑛4), con N = variable.

Cabe mencionar que el número de datos es variable ya que para esta implementación se usa los puntos destacados detectados en la imagen y varia con cada una; y la complejidad es de O(𝑛4) por los ciclos que usan “N” en sus límites.

Tabla 3.2 Complejidad de las técnicas

Resta de imágenes O(1) 1 Se analiza una imagen a la vez y sentencias sencillas.

Promedio “n” últimas imágenes y resta de imágenes

O(n2) 76800 Se analiza la imagen por pixel y usa ciclos con “N” en sus límites.

Gaussiana simple O(n2) 76800 Se analiza la imagen por pixel y usa ciclos con “N” en sus límites.

Gaussiana simple con umbral


Mezcla de gaussianas


Fondo de mezcla de gaussianas OpenCV2 con

umbral

O(1) 1 Se analiza una imagen a la vez y sentencias sencillas.

Correspondencia de puntos

O(n4) Variable Se analizan los puntos destacados de la imagen y usa ciclos con “N” en sus

límites.

Flujo óptico O(n4) Variable Se analizan los puntos destacados de la imagen y usa ciclos con “N” en sus

límites.



3.4. Herramientas para el desarrollo del sistema Para el desarrollo del sistema se utilizaron las siguientes herramientas:

Entorno de desarrollo integrado: Code::Blocks 12.11 [CodeBlocks, 2013].

Biblioteca gráfica: wxWidgets 2.8.12 [wxWidgets, 2012].

Lenguaje de programación: C++, compilador mingw32-g++ 4.7.0 [MinGW, 2012].

Librería: OpenCV 2.4.2 (Open Source Computer Vision) [OpenCV, 2012]. Code::Blocks se eligió para el desarrollo del sistema debido a que es un entorno muy amigable, fácil de configurar y permite la fusión de las tres herramientas anteriores que son necesarias para el desarrollo del sistema, además de que es un entorno multiplataforma. El lenguaje C++ fue elegido debido a que la mayoría de las tesis que se están desarrollando en el área de Inteligencia Artificial usan este lenguaje. OpenCV, es una librería de visión por computadora para el tratamiento de imágenes destinada principalmente a aplicaciones de visión por computadora en tiempo real, es utilizada debido a que es open source y puede ser corrida en conjunto con C++; de esta forma se puede hacer uso de sus funciones y

métodos ya implementados para el propósito de este proyecto. Para hacer el sistema amigable para el usuario se realizó una interfaz gráfica, pero debido al hecho de que Code::Blocks no proporciona interfaz gráfica para C++, se tuvo que buscar

una herramienta que la proporcionara y que a la vez pudiera ser integrada con las otras herramientas usados en el desarrollo, por esa razón se eligió la biblioteca gráfica de wxWidgets.

3.5. Interfaz gráfica Con el objetivo de facilitar el uso del sistema se creó la interfaz gráfica con ayuda de la biblioteca de wxWidgets. Ésta cuenta con un panel principal para poder ver algunos datos del video e introducir los parámetros necesarios para hacer funcionar las técnicas, también cuenta con cuatro pestañas que ayudan a elegir las diferentes opciones de configuración (Fig. 3.14).

Figura 3.14 Panel principal del sistema

La primera pestaña es la de menú (Fig. 3.15), el usuario podrá abrir uno o más videos a la vez para su procesamiento, también puede detener el video o salir de la aplicación.



Figura 3.15 Pestaña de menú del sistema

La segunda pestaña es la de técnicas para cámara estática (Fig. 3.16) permite seleccionar las técnicas de segmentación de imágenes para cámara estática que se quieran utilizar para procesar los videos.

Figura 3.16 Pestaña de técnicas para cámara estática

La tercera pestaña es la de técnicas para cámara móvil (Fig. 3.17) permite seleccionar las técnicas de segmentación de imágenes para cámara móvil que se quieran utilizar para procesar los videos.

Figura 3.17 Pestaña de técnicas para cámara móvil

La cuarta y última pestaña es la de herramientas (Fig. 3.18) el usuario podrá utilizar diferentes herramientas que le ayuden al procesamiento de los videos y evaluación de las técnicas de una manera más sencilla.

Figura 3.18 Pestaña de herramientas



Se desarrolló un sistema con las funcionalidades necesarias para poder utilizar y evaluar las técnicas usadas para diferenciar las partes estáticas de las partes móviles de una escena en secuencias de video. El sistema ha sido diseñado para ser configurado de acuerdo a las necesidades del usuario, lo cual permite adaptar el sistema a diferentes ambientes y ver con qué configuración el sistema se desempeña mejor, esto sirve para que en el futuro se puedan realizar con mayor facilidad experimentos en torno al tema.

3.6. Discusión En este capítulo se explica cómo se desarrolló la implementación de las técnicas usadas para separar las partes de una escena, así como la implementación de la evaluación que se usó para evaluar dichas técnicas. También se dan a conocer las herramientas con que se desarrolló el sistema y la interfaz gráfica que se obtuvo como resultado. Una de las partes más significativa de este capítulo es la del análisis del orden de complejidad de las técnicas. Los datos que se arrojan como resultado del análisis son:

Las técnicas con menor orden de complejidad son: Resta de imágenes y fondo de mezcla de gaussianas OpenCV2 con umbral con un orden de complejidad de O(1).

Las técnicas con mayor orden de complejidad son: Promedio “n” últimas imágenes y resta de imágenes, gaussiana simple, gaussiana simple con umbral, mezcla de gaussianas, correspondencia de puntos y flujo óptico con un orden de complejidad

de O(𝒏𝟐).

El número de datos utilizados en las diferentes técnicas son: 1 cuando se analiza la imagen completa, 76,800 cuando se analiza la imagen por pixel y una cantidad variable cuando se analizan los puntos destacados de la imagen.



Capítulo 4: Evaluaciones y resultados Este capítulo explica las evaluaciones realizadas a las técnicas y los resultados obtenidos. Se complementa con las especificaciones técnicas de la computadora donde se realizaron dichas evaluaciones, así como de los parámetros usados.

4.1. Especificaciones técnicas Las evaluaciones se realizaron en una computadora de escritorio con las siguientes especificaciones:

Procesador: Cuatro núcleos y 8 procesadores lógicos a 3.4 GHz.

Memoria RAM: de 8 GB.

Sistema Operativo: Windows 8 Pro.

4.2. Evaluaciones de las técnicas usadas para diferenciar las partes estáticas de las partes móviles de una escena en secuencias de video

Para evaluar las técnicas usadas para diferenciar las partes estáticas de las partes móviles de una escena en secuencias de video se planearon diferentes pruebas, las cuales se dividieron por tipo de video, por un lado los videos grabados con cámara estática y por otro los grabados con cámara móvil. Videos con cámara estática: Con los videos de cámara estática se tomó la decisión de utilizar seis implementaciones de las técnicas para cámara estática y dos para el caso de cámara móvil, ya que son las más representativas y con más posibilidades de obtener buenos resultados según lo estudiado en la literatura. Las técnicas elegidas para evaluarse son las siguientes:

Técnicas de cámara estática:

o Resta de imágenes. o Promedio “n” últimas imágenes y resta de imágenes. o Gaussiana simple. o Gaussiana simple con umbral. o Mezcla de gaussianas. o Fondo mezcla de gaussianas OpenCV2 con umbral.

Técnicas de cámara móvil:

o Correspondencia de puntos. o Flujo óptico.

En esta parte se mostrarán los parámetros que se pueden modificar en el sistema dependiendo de la técnica a utilizar y los valores utilizados para las evaluaciones:

Resta de imágenes: o Umbral: 25, 50 y 75.

Con esta técnica se realizaron tres corridas en total, una por cada valor del umbral.



Promedio “n” últimas imágenes y resta de imágenes: o Umbral: 25, 50 y 75. o nImagenes: 25, 75 y 125.

Con esta técnica se realizaron nueve corridas en total, fue la combinación de los dos parámetros que se usan (3x3=9).

Gaussiana simple: o Desviación estándar: 10, 20 y 30. o Multiplica: 3. o Alfa: 0.2, 0.02 y 0.002.

Con esta técnica se realizaron nueve corridas en total, primero que nada porque la desviación estándar se combina con multiplica y dan lugar a un umbral, por eso las únicas que sufren modificaciones son la desviación estándar y alfa, la combinación de los dos parámetros da el total de nueve corridas (3x3=9).

Gaussiana simple con umbral: o Umbral: 25, 50 y 75. o Alfa: 0.2, 0.02 y 0.002.


Mezcla de gaussianas: o Desviación estándar: 10, 20 y 30. o Multiplica: 3. o Alfa: 0.2, 0.02 y 0.002. o Rho: 0.1, 0.01 y 0.001.

Con esta técnica se realizaron veintisiete corridas en total, porque la desviación estándar se combina con multiplica y dan lugar a un umbral, por eso las únicas que sufren modificaciones y se combinan son la desviación estándar, alfa y rho, la combinación de estos tres parámetros da el total de veintisiete corridas (3x3x3=27).

Fondo mezcla de gaussianas OpenCV2 con umbral: o Umbral: 25, 50 y 75.


Correspondencia de puntos: o Umbral: 25, 50 y 75. o Dist_min_por: 6, 12 y 18.


Flujo óptico: o Umbral: 25, 50 y 75.


Videos con cámara móvil:

Con los videos de cámara móvil se tomó la decisión de utilizar dos implementaciones de las técnicas para cámara móvil, ya que son las que se pudieron implementar de forma correcta. Las técnicas con cámara móvil elegidas para evaluarse son: correspondencia de puntos y flujo óptico.



En esta parte se mostrarán los parámetros que se pueden modificar en el sistema dependiendo de la técnica a utilizar y los valores utilizados para las evaluaciones:

Correspondencia de puntos: o Umbral: 25, 50 y 75. o Dist_min_por: 6, 12 y 18.


Flujo óptico: o Umbral: 25, 50 y 75.

Con esta técnica se realizaron tres corridas en total, una por cada valor del umbral. En el criterio de la velocidad de procesamiento se sacará un promedio de los datos obtenidos para tener un estimado más exacto de la velocidad de la técnica y con respecto al criterio de precisión de la segmentación se reportará en los resultados el mejor porcentaje obtenido en el video, cabe mencionar que para los videos de cámara estática que cuenta con su ground truth la referencia con que comparar las imágenes binarias generadas con las técnicas será su ground truth y para los que no cuentan con un ground truth la referencia

con que comparar las imágenes binarias generadas con las técnica será las imágenes binarias generadas por la técnica implementada con OpenCV, ya que esta es una librería muy importante dentro de la visión por computadora y con muy buenos resultados.

4.3. Resultados de las evaluaciones con videos de cámara estática

En esta parte se mostrarán los resultados obtenidos en las evaluaciones de los videos para cámara estática, para su mejor despliegue se mostrarán los resultados por video. BDVCE1: La tabla 4.1 y 4.2 contiene los mejores resultados obtenidos de las evaluaciones planteadas en el punto anterior para el video BDVCE1. La tabla 4.1 contiene las cifras de las evaluaciones de las técnicas y la tabla 4.2 una muestra de las imágenes binarias generadas por las técnicas en las evaluaciones.

Tabla 4.1 Cifras en el video BDVCE1

Técnica Velocidad de

procesamiento Precisión de la segmentación

Fondo (0) Primer plano (1)

Resta de imágenes 167.9 f/s 99.92% 7.18%


9.6 f/s

99.41%

71.85%

Gaussiana simple 22 f/s 99.34% 83.91%

Gaussiana simple con umbral 20.3 f/s 96.81% 44.14%

Mezcla de gaussianas 19.3 f/s 98.42% 81.11%

Fondo mezcla de gaussianas OpenCV2 con umbral

55.9 f/s

Referencia

Referencia

Correspondencia de puntos 3.7 f/s 99.77% 0.73%

Flujo óptico 15.5 f/s 99.92% 4.28%



Tabla 4.2 Muestra de las imágenes binarias en el video BDVCE1

Original

Ground truth

Sin ground truth

Resta de imágenes

Promedio “n” últimas imágenes

y resta de imágenes

Gaussiana simple


Mezcla de gaussiana

Fondo mezcla de gaussiana

OpenCV2 con umbral

Correspondencia

de puntos

Flujo óptico

BDVCE2: La tabla 4.3 y 4.4 contiene los mejores resultados obtenidos de las evaluaciones planteadas en el punto anterior para el video BDVCE2. La tabla 4.3 contiene las cifras de las evaluaciones de las técnicas y la tabla 4.4 una muestra de las imágenes binarias generadas por las técnicas en las evaluaciones.







10.6 f/s

99.59%

71.49%

Gaussiana simple 18 f/s 99.26% 87.08%




40.4 f/s

Referencia

Referencia


Flujo óptico 18.1 f/s 99.50% 16.41%




Original

Ground truth

Sin ground truth

Resta de imágenes



Gaussiana simple


Mezcla de gaussiana


OpenCV2 con umbral

Correspondencia

de puntos

Flujo óptico






Resta de imágenes 38 f/s 99.83% 18.43%


7.5 f/s

98.82%

75.63%

Gaussiana simple 10.6 f/s 98.36% 87.94%




27.4 f/s

Referencia

Referencia


Flujo óptico 12.2 f/s 99.93% 2.19%




Original

Ground truth

Sin ground truth

Resta de imágenes



Gaussiana simple


Mezcla de gaussiana


OpenCV2 con umbral

Correspondencia

de puntos

Flujo óptico








10.9 f/s

99.84%

67.58%


Gaussiana simple con umbral 22 f/s 99.95% 38.34%



36.1 f/s

Referencia

Referencia


Flujo óptico 21.4 f/s 99.90% 4.55%




Original

Ground truth

Sin ground truth

Resta de imágenes



Gaussiana simple


Mezcla de gaussiana


OpenCV2 con umbral

Correspondencia

de puntos

Flujo óptico








11.4 f/s

99.95%

74.74%





35.9 f/s

Referencia

Referencia


Flujo óptico 24.2 f/s 99.96% 12.95%




Original

Ground truth

Sin ground truth

Resta de imágenes



Gaussiana simple


Mezcla de gaussiana


OpenCV2 con umbral

Correspondencia

de puntos

Flujo óptico








10.2 f/s

97.97%

72.15%





22.9 f/s

Referencia

Referencia


Flujo óptico 13.9 f/s 99.94% 1.12%




Original

Ground truth

Sin ground truth

Resta de imágenes



Gaussiana simple


Mezcla de gaussiana


OpenCV2 con umbral

Correspondencia

de puntos

Flujo óptico






Resta de imágenes 62.5 f/s 99.8 % 53.2 %


17.2 f/s

99.79 %

82.19 %

Gaussiana simple 23 f/s 99.95 % 93.97 %

Gaussiana simple con umbral 23.8 f/s 99.93 % 61.45 %

Mezcla de gaussianas 23.5 f/s 99.86 % 94.4 %


37.5 f/s

99.98 %

85.47 %

Correspondencia de puntos 15.2 f/s 99.94 % 34.02 %

Flujo óptico 29.2 f/s 99.76 % 46.42 %




Original

Ground truth

Resta de imágenes



Gaussiana simple


Mezcla de gaussiana


OpenCV2 con umbral

Correspondencia

de puntos

Flujo óptico








9.4 f/s

94.81 %

70.06 %

Gaussiana simple 23.5 f/s 92.20 % 89.70 %




23.9 f/s

94.80 %

73.00 %


Flujo óptico 9.2 f/s 99.25 % 65.18 %




Original

Ground truth

Resta de imágenes



Gaussiana simple


Mezcla de gaussiana


OpenCV2 con umbral

Correspondencia

de puntos

Flujo óptico








10.2 f/s

97.51 %

87.90 %





22.2 f/s

98.28 %

88.67 %


Flujo óptico 14.2 f/s 99.68 % 56.97 %




Original

Ground truth

Resta de imágenes



Gaussiana simple


Mezcla de gaussiana


OpenCV2 con umbral

Correspondencia

de puntos

Flujo óptico








14.4 f/s

97.55 %

89.89 %





34.7 f/s

99.39 %

94.26 %


Flujo óptico 22.4 f/s 99.46 % 63.87 %




Original

Ground truth

Resta de imágenes



Gaussiana simple


Mezcla de gaussiana


OpenCV2 con umbral

Correspondencia

de puntos

Flujo óptico

Tabla 4.21 Resumen de resultados en videos de cámara estática

Video Técnica más rápida Técnica más precisa

BDVCE1 Resta de imágenes Gaussiana simple BDVCE2 Resta de imágenes Gaussiana simple

BDVCE3 Resta de imágenes Gaussiana simple

BDVCE4 Resta de imágenes Mezcla de gaussianas

BDVCE5 Resta de imágenes Gaussiana simple BDVCE6 Resta de imágenes Gaussiana simple



BDVCE9 Resta de imágenes Mezcla de gaussianas BDVCE10 Resta de imágenes Mezcla de gaussianas

4.4. Resultados de las evaluaciones con videos de cámara móvil En esta parte se mostrarán los resultados obtenidos en las evaluaciones de los videos para cámara móvil, para su mejor despliegue se mostrarán los resultados por video.



BDVCM1:

La tabla 4.22 y 4.23 contiene los mejores resultados obtenidos de las evaluaciones planteadas en el punto anterior para el video BDVCM1. La tabla 4.22 contiene las cifras de las evaluaciones de las técnicas y la tabla 4.23 una muestra de los flujos que se tienen como resultado de las técnicas en las evaluaciones.

Tabla 4.22 Cifras en el video BDVCM1 Técnica Velocidad de procesamiento

Correspondencia de puntos 5.6 f/s

Flujo óptico 18.4 f/s

Tabla 4.23 Muestra de los flujos en el video BDVCM1


Flujo óptico

BDVCM2: La tabla 4.24 y 4.25 contiene los mejores resultados obtenidos de las evaluaciones planteadas en el punto anterior para el video BDVCM2. La tabla 4.24 contiene las cifras de las evaluaciones de las técnicas y la tabla 4.25 una muestra de los flujos que se tienen como resultado de las técnicas en las evaluaciones.


Correspondencia de puntos 16 f/s




Flujo óptico









Flujo óptico

BDVCM4:







Flujo óptico







Flujo óptico



BDVCM6:







Flujo óptico

Tabla 4.34 Resumen de resultados en videos de cámara móvil

Video Técnica más rápida

BDVCM1 Flujo óptico


BDVCM3 Flujo óptico BDVCM4 Flujo óptico



4.5. Discusión

En este capítulo se han descrito y desarrollado cada uno de los casos de prueba realizados al sistema implementado en esta tesis, cuyo papel principal es la detección de las partes estáticas y móviles en una escena. Los resultados obtenidos más representativos son los siguientes:

La técnica más rápida en videos de cámara estática: Es resta de imágenes con 167.9 f/s en el video BDVCE1.

La técnica más rápida en videos de cámara móvil: Es flujo óptico con 32.6 f/s en el video BDVCM2.

La técnica más precisa en videos de cámara estática: Es mezcla de gaussianas con fondo (97.44 %) y primer plano (99.02 %) en el video BDVCE10.

La técnica para videos de cámara estática que mejor se desempeñó fue la de gaussiana simple; porque tiene muy buenos resultados (videos BDVCE6, BDVCE7, BDVCE10), trabaja casi en tiempo real de acuerdo a la velocidad de los videos (videos BDVCE5, BDVCE6, BDVCE10). La técnica para videos de cámara móvil que mejor se desempeñó



fue la de flujo óptico; porque tiene unos resultados muy aceptables para este tipo de problema (videos BDVCM1, BDVCM6) y no es muy lenta para procesar los videos (videos BDVCM2, BDVCM3). En la sección 4.3 y 4.4 se pusieron los mejores resultados obtenidos en las evaluaciones, pero pueden variar conforme a las necesidades del usuario que use la aplicación, esto quiere decir que la separación del primer plano del fondo está más enfocada a lo que el usuario necesita, por ejemplo:

Cámara estática: o El usuario necesita más resaltado el objeto en movimiento y no le importa el

ruido en el fondo, usa umbrales bajos. o El usuario necesita que el fondo este sin ruido y con que se note poco el

objeto en movimiento le basta, usa umbrales altos.

Cámara móvil: o El usuario necesita que el robot móvil reconozca el lugar donde ha estado,

descarta el objeto en movimiento. o El usuario necesita que el robot móvil evada obstáculos móviles, usa el

objeto en movimiento.



Capítulo 5: Conclusiones En este capítulo se presentan las conclusiones finales, las aportaciones, lecciones aprendidas y los trabajos futuros de este trabajo de investigación.

5.1. Conclusiones finales

De la experimentación realizada se concluye que: Cuando queda con ruido la imagen de salida de las técnicas de cámara estática, se pueden usar técnicas de post-procesado para limpiarla, ya que esto mejoraría la separación de las partes de la escena. Los filtros pueden ser un buen ejemplo de este tipo de técnicas de post-procesado. Para que tengan un mejor funcionamiento las técnicas de cámara móvil, el movimiento de la cámara debe ser lento relativo al móvil, ya que esto es de gran ayuda a la hora de realizar la separación entre las partes estáticas y móviles de una escena porque en este tipo de problema todo está en movimiento. La combinación entre la correspondencia de puntos y el flujo óptico no se pudo lograr por que el número de pares de puntos que son correctos en las dos técnicas es diferente, siendo mayor la de flujo óptico que la de correspondencia de puntos y esto hace que no se puedan emparejar los resultado, y por último la forma como arrojan las técnicas los resultados de sus vectores de puntos para la imagen más reciente también es diferente. El análisis del orden de complejidad de las técnicas nos da los siguientes datos como resultado:

Las técnicas con menor orden de complejidad son: Resta de imágenes y fondo de mezcla de gaussianas OpenCV2 con umbral.

Las técnicas con mayor orden de complejidad son: Promedio “n” últimas imágenes y resta de imágenes, gaussiana simple, gaussiana simple con umbral, mezcla de gaussianas, correspondencia de puntos y flujo óptico.

El número de datos utilizados en las diferentes técnicas son: 1 cuando se analiza la imagen completa, 76,800 cuando se analiza la imagen por pixel y una cantidad variable cuando se analizan los puntos destacados de la imagen.

La mejor técnica para el problema de cámara estática es la gaussiana simple, porque tiene muy buenos resultados, trabaja casi en tiempo real de acuerdo a la frecuencia de los videos. La mejor técnica para el problema de cámara móvil es el flujo óptico, porque tiene unos

resultados muy aceptables para este tipo de problema y no es muy lenta para procesar los videos.

5.2. Aportaciones y productos

Las técnicas de cámara móvil no son técnicas de segmentación de imágenes, ya que este tipo de técnicas trabajan con los puntos destacados de una imagen y en ninguna parte hacen alguna segmentación de ella. Al no ser técnicas de segmentación de imágenes las técnicas de cámara móvil, se aportaron reglas (heurísticas) para resolver el problema. Las reglas aportadas son:

Cálculo del grupo de ángulos que más se repite.

Umbral de separación.



Los productos que se hicieron son:

Interfaz gráfica para correr y evaluar las técnicas.

Comparador de salidas binarias.

Una base de datos de videos muy completa para las evaluaciones de técnicas.

Pseudocódigo y código de las implementaciones realizadas

Análisis del orden de complejidad de las técnicas evaluadas.

5.3. Lecciones aprendidas

La integración de las herramientas puede llegar a tener complicaciones por las versiones de cada una.

Al principio es complicado entender algunas cuestiones de OpenCV.

Algunas ecuaciones pueden llegar a ser complicadas, pero no imposibles. Con un poco de análisis y dedicatoria se resuelven.

La buena correspondencia de puntos es muy difícil lograrla, aunque tengas todas las herramientas. Por eso al problema de cámara móvil le falta mucho para su completa solución.

5.4. Trabajos futuros

Los trabajos futuros que habrá que realizar para mejorar la detección de las partes de una escena son:

Por parte de cámara estática: o Para las técnicas que se implementaron en un solo canal de color, hacer la

diferencia de imágenes en los tres canales de color RGB, esto ayudará a la separación de las partes de la escena porque habrá más información a la hora de hacer la diferencia.

o Probar con otro modelo de color para el procesamiento de las imágenes. o Agilizar las técnicas donde se usan gaussianas, ya que ellas tiene muy

buenos resultados pero algunas veces no son tan rápidas con respecto a la frecuencia del video.

o Aplicar técnicas de pre-procesado y post-procesado a las secuencias de imágenes para ver cómo se comportan las técnicas de segmentación de imágenes.

o Modificar el lapso de memoria de las técnicas con respecto al recuerdo de un móvil que pasa gran tiempo en la escena y se vuelve fondo, esto para identificar que este móvil sigue siendo un objeto en movimiento.

Por parte de cámara móvil: o Encontrar una mejor forma de remarcar el objeto en movimiento con

respecto al fondo, se puede utilizar una concha convexa que envuelva a los puntos que fueron detectados como primer plano.

o Mejorar el funcionamiento de las técnicas con respecto al movimiento de la cámara, para ayudar a la detección de las partes estáticas y móviles de la escena. Encontrando nuevas reglas (heurísticas) que mejoren la separación del primer plano con el fondo, por ejemplo: cálculo del grupo de ángulos o el umbral de separación.

Optimizar el código para mejorar la velocidad y funcionamiento de las técnicas.

Manual de usuario de la aplicación (Interfaz gráfica).



Referencias [Agrawal, 2008] Motilal Agrawal, Kurt Konolige, y Morten Rufus Blas.

CenSurE: center surround extremas for realtime feature detection and matching. ECCV 2008, Part IV, LNCS 5305, pp. 102–115.

[Aho, 1988] Alfred V. Aho, John E. Hopcroft, Jeffrey D. Ullman.

Estructuras de datos y algoritmos, Addison-Wesley Iberoamericana: Sistemas técnicos de edición, 1988, ISBN 968-6048-19-7.

[Bouguet, 2000] Jean-Yves Bouguet. Pyramidal Implementation of the Lucas

Kanade Feature Tracker Description of the algorithm (Flujo Óptico). Microprocessor Research Labs, 2000.

[Cervera, 2010] Pablo Cervera Benito. Integración de información de

movimiento en la segmentación de secuencias de video basada en el modelado de fondo. Proyecto Fin de Carrera Universidad Autónoma de Madrid, Escuela Politécnica Superior, 2010.

[Chaohui, 2007] Zhan Chaohui, Duan Xiaohui, Xu Shuoyu, Song Zheng, Luo

Min. An improved moving object detection algorithm based on frame difference and edge detection. Fourth International Conference on Image and Graphics, 2007.

[Cheung1, 2004] Sen-Ching S. Cheung y Chandrika Kamath. Robust

backgound subtraction with foregound validation for urban traffic video. Center for Applied Scientific Computing, Lawrence Livermore National Laboratory, 2004.

[Cheung2, 2004] Sen-Ching S. Cheung y Chandrika Kamath. Robust

techniques for background subtraction in urban traffic video. Proceedings of the Symposium on Electronic Imaging, 2004.

[CodeBlocks, 2013] Code::Blocks 12.11. http://www.codeblocks.org/ [CompAlgo, 2013] Página web que explica la complejidad de los algoritmos.

http://www.lab.dit.upm.es/~lprg/material/apuntes/o/ [Correia, 2000] Paulo Correia y Fernando Pereira. Objective evaluation of

relative segmentation quality. IEEE 2000. [Cucchiara, 2003] Rita Cucchiara, Costantino Grana, Massimo Piccardi y

Andrea Prati. Detecting moving objects, ghosts and shadows in video stream. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2003.



[Cui, 2012] Yuyong Cui, Zhiyuan Zeng, Weihong Cui, Bitao Fu. Moving object detection based frame difference and graph cuts. Journal of Computational Information Systems 8:1 (2012) 21–29.

[Culibrk,2006] Dubravko Culibrk, Daniel Socek, Oge Marques y Borko Furht.

Automatic kernel width selection for neural network based video object segmentation. In proceeding of VISAPP 2006: Proceedings of the Second International Conference on Computer Vision Theory and Applications.

[Darvish, 2008] Parisa Darvish Zadeh Varcheie, Michael Sills-Lavoie, y

Guillaume-Alexandre Bilodeau. An efficient region-based background subtraction technique. Canadian Conference on Computer and Robot Vision, 2008.

[El Baf, 2007] El Baf F. Bouwmans T. Vachon B. Comparison of Background

Subtraction Methods for a Multimedia Application. Proceedings of the 14th International Conference on systems, Signals and Image Processing, pages 385-388, Maribor, Slovenia, 2007.

[Elgammal, 2003] Ahmed Elgammal, Ramani Duraiswami y Larry S. Davis.

Efficient Kernel Density Estimation Using the Fast Gauss Transform with Applications to Color Modeling and Tracking. Pattern Analysis and Machine Intelligence, IEEE Transactions 2003.

[Ewerth, 2003] Ralph Ewerth y Bernd Freisleben. Frame difference

normalization: an approach to reduce error rates of cut detection algorithms for MPEG videos. IEEE, 2003.

[Fernández, 2012] Jaime Boanerjes Fernández Roblero. Comparación de

Algoritmos de Extracción y Asociación de Rasgos Para Visión Robótica. Tesis de maestria en el CENIDET 2012.

[Fernando, 2007] W.S.P. Fernando, Lanka Udawatta, Pubudu Pathirana.

Identification of moving obstacles with Pyramidal Lucas Kanade optical flow and k means clustering. IEEE 2007.

[Grabner, 2006] Michael Grabner, Helmut Grabner y Horst Bischof. Fast

approximated SIFT. In 7th Asian Conference of Computer Vision 2006.

[Harville, 2002] Michael Harville. A Framework for High-Level Feedback to

Adaptive, Per-Pixel, Mixture-of-Gaussian Background Models. ECCV 2002.

[Han, 2004] Bohyung Han, Dorin Comaniciu y Larry Davis. Sequential

kernel density approximation through mode propagation applications to background modeling. In proc. ACCV 2004.

http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=34




[Hassanpour, 2011] Hamid Hassanpour, Mehdi Sedighi, Ali Reza Manashty.

Video frame’s background modeling: reviewing the techniques. Journal of Signal and Information Processing, 2011, 2, 72-78.

[Hung, 2010] Mao-Hsiung Hung, Jeng-Shyang Pan, Chaur-Heh Hsieh.

Speed up temporal median filter for background subtraction. First International Conference on Pervasive Computing, Signal Processing and Applications, 2010.

[KaewTraKulPong, 2001] P. KaewTraKulPong y R. Bowden. An improved adaptive

background mixture model for realtime tracking with shadow detection. In Proc. 2nd European Workshop on Advanced Video Based Surveillance Systems, AVBS01. Sept 2001.

[Kyungnam, 2006] Kim Kyungnam, Thanarat H. Chalidabhongse, David

Harwood y Larry Davis. PDR A Performance Evaluation Method for Foreground-Background Segmentation Algorithms. EURASIP Journal on Applied Signal Processing 2006.

[Leal, 2010] Nallig Leal M. Esmeide Leal M. John Willian Branch. Sistemas

de monitoreo de tránsito vehicular basados en técnicas de segmentación de imágenes. Revista avances en sistemas e informática, vol.7 no.3, 2010, ISSN 1657-7663.

[Lee, 2003] Dar-Shyang Lee, Jonathan J. Hull y Berna Erol. A bayesian

framework for gaussian mixture background modeling. IEEE 2003.

[Leng, 2005] Bing Leng y Qionghai Dai. Video object segmentation based

on accumulative frame difference. Distinguished Young Scholars of NSFC, 2005.

[López-Paredes, 2011] Héctor López Paredes. Detección y seguimiento de objetos

con cámaras en movimiento. Proyecto Fin de Carrera Universidad Autónoma de Madrid, Escuela Politécnica Superior, 2011.

[López-Gutiérrez, 2002] Luis D. López Gutiérrez y Leopoldo Altamirano Robles.

Fusión de sensores multiespectrales para la detección y seguimiento de Objetivos usando cámaras móviles. Revista Iberoamericana de Sistemas, Cibernética e Informática 2002.

[Lowe, 2004] David G. Lowe. Distinctive Image Features from Scale-

Invariant Keypoints (SIFT). The International Journal of Computer Vision 2004.



[Luna, 2011] María del Refugio Ofelia Luna Sandoval. Análisis de Algoritmos de Correspondencia para Visión Estéreo. Tesis de maestria en el CENIDET 2011.

[McKoen, 2000] Kevin McKoen, Raquel Navarro-Prieto, Benoit Duc, Emrullah

Durucan, Francesco Ziliani y Touradj Ebrahimi. Evaluation of video segmentation methods for surveillance applications. Proc. European Signal Processing Conference 2000.

[Mikolajczyk, 2004] Krystian Mikolajczyk y Cordelia Schmid. Comparison of

affine-invariant local detectors and descriptors. 12th European Signal Processing Conference (EUSIPCO) 2004.

[Mikolajczyk, 2005] Krystian Mikolajczyk y Cordelia Schmid. A Performance

Evaluation of Local Descriptors. IEEE Transactions on Pattern Analysis and Machine Intelligence 2005.

[MinGW, 2012] Compilador mingw32-g++ 4.7.0. http://www.mingw.org/,

octubre 2012. [MIT_TDS, 2012] MIT Traffic Data Set, Noviembre 2012.

http://www.ee.cuhk.edu.hk/~xgwang/MITtraffic.html [Mittal, 2004] Anurag Mittal y Nikos Paragios. Motion-Based Background

Subtraction using Adaptive Kernel Density Estimation. Computer Vision and Pattern Recognition (CVPR) 2004. Proceedings of the 2004 IEEE Computer Society Conference.

[Mobile_Platforms, 2013] Robust Multi-Person Tracking from Mobile Platforms, Febrero

2013. http://www.vision.ee.ethz.ch/~aess/dataset/ [Mora, 2009] David Mora, Andrés Páez y Julián Quiroga Sepúlveda.

Detección de objetos móviles en una escena utilizando flujo óptico. XIV Simposio de Tratamiento de Señales, Imágenes y Visión Artificial – STSIVA 2009.

[Mora, 2010] David Mora, Andrés Páez y Julián Quiroga Sepúlveda.

Detección de objetos móviles en una escena utilizando flujo óptico. Tesis de licenciatura Pontificia Universidad Javeriana 2010.

[OpenCV, 2012] Open source computer visión, versión 2.4.2.

http://opencv.org/ [Parks, 2008] Parks Donovan H. Fels Sidney S. Evaluation of Background

Subtraction Algorithms with Post-Processing. Proceedings of the IEEE Fifth International Conference on Advanced Video and Signal Based Surveillance, pp.192-199, 2008.

http://ieeexplore.ieee.org/xpl/mostRecentIssue.jsp?punumber=9183





[Perreault, 2007] Simon Perreault y Patrick Hebert. Median Filtering in Constant Time. Image Processing, IEEE Transactions 2007.

[Piccardi, 2004] Massimo Piccardi. Background subtraction techniques: a

review. Proceedings of the IEEE International Conference on Systems, Man and Cybernetics, 2004.

[Pham, 2010] Vu Pham, Phong Vo, Vu Thanh Hung, Le Hoai Bac. GPU

implementation of extended gaussian mixture model for background subtraction. Computing and Communication Technologies, Research, Innovation, and Vision for the Future (RIVF), 2010.

[Pless, 2003] Robert Pless, John Larson, Scott Siebers y Ben Westover.

Evaluation of Local Models of Dynamic Backgrounds. Proceedings of the IEEE Computer Society Conference on Computer Vision and Pattern Recognition (CVPR) 2003.

[Prati, 2003] Andrea Prati, Ivana Mikic, Mohan M. Trivedi y Rita Cucchiara.

Detecting Moving Shadows Algorithms and Evaluation. IEEE Transactions on Pattern Analysis and Machine Intelligence 2003.

[Rodríguez, 2010] Andrea Rodríguez Calvo. Análisis de imágenes: sistema de

detección de intrusos. Proyecto Fin de Carrera Universidad Pontificia Comillas, Escuela Técnica Superior de Ingenieria, 2010.

[Rosten, 2006] Edward Rosten y Tom Drummond. Machine learning for high-

speed corner detection (FAST). In European Conference on Computer Vision 2006.

[Shibata, 2008] M. Shibata, Y. Yasuda, and M. Ito. Moving object detection for

active camera based on optical flow distortion. Proceedings of the 17th World Congress, International Federation of Automatic Control, pages 14721–14722, 2008.

[Sonsoles, 2009] Martín Sonsoles Herrero. Análisis comparativo de técnicas de

segmentación de secuencias de video basadas en el modelado del fondo. Proyecto Fin de Carrera Universidad Autónoma de Madrid, Escuela Politécnica Superior, 2009.

[Su, 2008] Shu-Te Su y Yung-Yaw Chen. Moving object segmentation

using improved running gaussian average background model. Digital Image Computing: Techniques and Applications, 2008.

[Tang, 2007] Zhen Tang, Zhenjiang Miao, y Yanli Wan. Background

subtraction using running gaussian average and frame difference. IFIP International Federation for Information Processing 2007.




[Tiburzi, 2008] Fabrizio Tiburzi, Marcos Escudero, Jesús Bescós y José M. Martínez. A ground truth for motion-based video-object segmentation IEEE 2008.

[Tuytelaars, 2008] Tinne Tuytelaars y Krystian Mikolajczyk. Local Invariant

Feature Detectors, A Survey. Foundation and Trends in Computer Graphics and Vision 2008.

[VSSN06_OSAC, 2006] Call for Algorithm Competition in Foreground/Background

Segmentation, Octubre 2006. http://mmc36.informatik.uni-augsburg.de/VSSN06_OSAC/

[wxWidgets, 2012] wxWidgets 2.8.12. http://www.wxwidgets.org/ [Zivkovic, 2004] Zoran Zivkovic. Improved adaptive gaussian mixture model

for background subtraction. In Proc. ICPR, 2004. [Zuliani, 2004] M. Zuliani, C Kenney y B. S. Manjunath. A mathematical

comparison of point detectors. Computer Vision and Pattern Recognition Workshop (CVPRW) 2004.





Anexo El CD contiene:

La tesis en PDF.

El proyecto de la aplicación (Formulario y Código).

La base de datos de videos.

evaluación de técnicas para la detección de las partes ... · este trabajo de investigación...

Documents