reconocimiento de la velocidad máxima...

PID - GIITI

Julio Conejo Benavides

Manuel Alejandro Campos Díaz

PID - GIITI

Reconocimiento de la velocidad máxima permitida desde vídeo

Reconocimiento de la velocidad máxima permitida PID G.II-TI 14/15

2

ÍNDICE

RESUMEN ................................................................................................................................. 3

INTRODUCCIÓN ........................................................................................................................ 3

PLANTEAMIENTO TEÓRICO ....................................................................................................... 4

Inicio ..................................................................................................................................... 4

Binarización .......................................................................................................................... 4

Operaciones morfológicas y aplicación de filtros ................................................................... 5

Búsqueda de círculos dentro de la imagen ............................................................................ 5

Búsqueda de patrones en la señal ......................................................................................... 6

RESOLUCIÓN PRÁCTICA............................................................................................................. 6

Principales obstáculos ........................................................................................................... 6

Sistemas utilizados ................................................................................................................ 7

Pseudocódigo ....................................................................................................................... 8

FUNCIONAMIENTO. MANUAL DE USUARIO ............................................................................... 9

Vídeo .................................................................................................................................... 9

Imagen ................................................................................................................................ 12

CONCLUSIONES ....................................................................................................................... 14

REFERENCIAS .......................................................................................................................... 15

ANEXO: Tablas de tiempo ....................................................................................................... 15

Tabla de Julio Conejo Benavides .......................................................................................... 15

Tabla de Manuel Alejandro Campos Díaz ............................................................................. 16


3

RESUMEN

En la documentación que se presenta se expondrá una aplicación capaz de reconocer la

velocidad máxima en un tramo de carretera a partir de imágenes de vídeo. Esta tarea tiene

una gran aplicación en el mundo real, como por ejemplo en la mejora de la seguridad vial,

métodos de ayuda al piloto e incluso en la conducción automática. Nuestra aplicación sólo

aborda señales verticales de velocidad, pero es perfectamente ampliable a otro tipo de señales

verticales como son la de stop, ceda el paso o dirección prohibida. Nuestro objetivo es

mantener en todo momento al piloto informado de cuál es la velocidad máxima permitida en

el tramo por el que está conduciendo mediante el procesamiento de imágenes digitales

aportadas por una cámara que grabe la carretera.

INTRODUCCIÓN

El reconocimiento de señales de tráfico es un reto actualmente para las compañías

automovilísticas, un paso hacia el futuro de la conducción automática que necesita el uso de

imágenes digitales para poder conseguir su objetivo. En el mundo real, una aplicación como

esta significaría la asistencia continua por parte del sistema al conductor, la prevención de

accidentes de tráfico y finalmente la conducción sin piloto humano. Obviamente esto supone

un reto por las numerosas dificultades que conlleva analizar las distintas señales, las diferentes

condiciones lumínicas causadas por la hora del día o la meteorología. Por ello se debe

desarrollar un algoritmo capaz de adaptarse a las diferentes situaciones en las que se esté

ejerciendo la conducción.

El problema se divide en tres partes bien marcadas, la adquisición de los frames del vídeo, la

localización de la señal dentro del frame y el reconocimiento de la velocidad dentro de la

señal. Para el desarrollo de la aplicación hemos usado los conocimientos en Procesamiento de

Imágenes Digitales y los hemos programado haciendo uso de OpenCV conjuntamente del

lenguaje Python.


4

PLANTEAMIENTO TEÓRICO

A continuación se detalla la teoría del algoritmo que hemos implementado. El procedimiento

se ha dividido en pasos para que sea más sencillo su interpretación y comprensión.

INICIO

Inicialmente hemos de cargar el vídeo, de este iremos leyendo todos los frames, pero solo

analizaremos uno de cada diez, esto es, uno cada medio segundo. Nos hemos visto obligados a

esto para conseguir cierta fluidez de la ejecución en tiempo real.

BINARIZACIÓN

Nuestro primer problema es encontrar las zonas de cada frame donde se encuentra el color

rojo característico de las señales de velocidad, para ello cambiaremos el espacio de colores de

RGB a HSV. El modelo HSV se compone de tres valores, H de Hue (Matiz), S de Saturation

(Saturación) y V de Value (Valor).

Este modelo favorece la selección

de los rangos por colores ya que

solo afecta el parámetro H.

Seleccionando el rango adecuado

de HSV para el color rojo

aplicaremos la binarización,

dejando los valores de la imagen

pertenecientes al rango como

blanco y las no pertenecientes

como negro.


5

OPERACIONES MORFOLÓGICAS Y APLICACIÓN DE FILTROS

A continuación aplicaremos transformaciones

morfológicas. Específicamente dilataremos la

imagen usando 5 iteraciones del algoritmo de

dilatación, para obtener la señal mejor

marcada y más redonda, consiguiendo así una

mejor imagen binaria que no nos ocasione

problemas futuros. Seguidamente, se aplica

un filtro de la mediana, para quitar el ruido

presente en la imagen binaria, de este modo

se evita que haya pequeños puntos en la

imagen que condicionen negativamente el

reconocimiento de la localización de la señal

dentro de la imagen.

BÚSQUEDA DE CÍRCULOS DENTRO DE LA IMAGEN

Primero cambiaremos nuevamente el espacio de representación de la imagen a RGB desde la

imagen binaria. Luego, aplicaremos la transformada de Hough para buscar formas circulares

dentro de la imagen que antes binarizamos. Esta es una técnica de detección de figuras en

imágenes digitales, que por suerte viene implementada en OpenCV. Esta técnica se basa en

transformar puntos de la imagen en un espacio de parámetros. La idea es encontrar curvas

parametrizabales como

rectas, círculos y

polinomiales. Es decir, en

nuestro caso que queremos

encontrar círculos debemos

tener en cuenta que un

círculo tiene tres parámetros,

dos para las coordenadas del

centro y otro para la longitud

del radio. Con estos

parámetros busca dentro de

la imagen aquellos que

cumplan las posibles

ecuaciones que formen los

distintos círculos.

Si se encontraron círculos se procederá al recorte de la imagen conforme a las coordenadas del

centro del círculo, en caso opuesto se descarta que haya información de señales en el frame y

se analizarán los siguientes.


6

BÚSQUEDA DE PATRONES EN LA SEÑAL

Una vez localizada la señal debemos volver a binarizar, pero

esta vez atendiendo a la siguiente condición, en caso de ser

un color RGB claro, es decir blanco, se binarizará a negro y se

binarizará a blanco en caso opuesto. Seguidamente se

buscará una base de datos de patrones de las posibles

distintas velocidades que aparecen en las señales y se hará

un matching (comparación) con todas ellas. Así según el

patrón que encaje en la imagen se conocerá la velocidad

permitida en el tramo.

Finalmente y a modo de recordatorio para el piloto se mostrará la velocidad permitida en un

dibujo de un disco de velocidad.

RESOLUCIÓN PRÁCTICA

PRINCIPALES OBSTÁCULOS

Como ya hemos mencionado nuestro algoritmo es altamente influenciable por características

del vídeo como pueden ser la meteorología, las diferencias de iluminación o las distintas

señales semejantes a las de velocidad que indican otra información como por ejemplo señales

de peso máximo permitido o altura máxima. Por todo esto, se debería conseguir un algoritmo

más robusto que reconozca las intensidades lumínicas de los frames del vídeo y de forma

automática o bien adaptase los rangos HSV para encontrar el color rojo o bien cambiara la

iluminación del propio frame.

El otro principal obstáculo al que nos hemos enfrentado ha sido el matching de los patrones

con los números de las señales. Esta función es muy sensible a cambios como por ejemplo el

tamaño de los números de la imagen recortada o las diferentes caligrafías de las señales, por


7

ello nuestro método de matching se puede catalogar como básico para el ejemplo que nos

compete.

Finalmente, debido a las características de nuestras máquinas el procesamiento del vídeo no

llega a ser del todo fluido a pesar de tomar uno de cada 10 frames. Además esta fluidez se ve

altamente deteriorada al usar una interfaz gráfica para ejecutar el programa.

SISTEMAS UTILIZADOS

Decidimos usar OpenCV para Python, lo cual al principio nos sometió a numerosos problemas

de compatibilidad. De este modo la única versión que conseguimos usar y recomendamos es:

OpenCV 2.4.10

Python 2.7

PIL

Numpy 1.9.1

Usando el entorno Eclipse para Windows 7

Para incluir OpenCV en Python se deben seguir rigurosamente los siguientes pasos:

1. Instalación de Python 2.7 y Numpy 1.9.1

2. Instalar todos los paquetes en su localización por defecto, Python se debe instalar en

C:/Python27/

3. Instalar el entorno necesario. Nosotros usamos el pluging de Eclipse pero hay muchos

más entornos disponibles como Aptana, Emacs, o el que incluye Python por defecto en

sus descargas, IDLE.

4. Probar que Numpy se instaló correctamente escribiendo en un archivo .py lo siguiente:

import numpy o si no import numpy as np

5. Descargar OpenCV y extraerlo.

6. Copiar el archivo cv2.pyd de la carpeta opencv/build/python/2.7 en la carpeta

C:/Python27/lib/site-packages

7. Para comprobar que OpenCV está correctamente integrado, en un archivo .py escribir

lo siguiente: import cv2 (salto de línea) print cv2.__version__

8. En caso de que se compile sin errores y se muestre la versión de OpenCV, se habrá

instalado todo con éxito.


8

PSEUDOCÓDIGO

Inicio del programa y cargado del vídeo

Declaración de las variables (Contador = 0)

o Mientras haya frames por leer

Si el frame es el elegido (uno cada medio segundo, usando el

contador)en

Transformar a HSV

Selección del umbral de rojo1

Binarización según el umbral anterior

Aplicar dilatación cinco iteraciones

Filtro de la mediana

Conversión de Gris a RGB

Función de Hough

Si hay círculos

o Dibujar los círculos en el frame

o Recorte de la señal localizada

o Redimensionado del recorte (250x250)

o Transformación de HSV a RGB

o Binarización del blanco2

o Búsqueda de patrones

o Si se encontró un patrón:

Selección del dibujo de la señal

Mostrar el dibujo

Mostrar el frame

Incrementar contador

Si no es el elegido:

Mostrar el frame

Incrementar contador

1 En OpenCV HSV se representa con valores dentro del siguiente rango [0-255, 0-255, 0-255], para

seleccionar el color rojo hemos usado el siguiente umbral: [130, 100, 60] – [200, 255, 255]. 2 Se hace una binarización inversa, el valor que separa los umbrales es 50.


9

FUNCIONAMIENTO. MANUAL DE USUARIO

La aplicación puede utilizarse en dos modos distintos. Por un lado podemos usar la aplicación

para detectar el límite de velocidad de imágenes que contienen señales de tráfico o bien

podemos utilizarlo para detectar el límite de velocidad actual durante la reproducción de un

vídeo.

VÍDEO

Si queremos utilizar esta opción la aplicación trae precargado un fragmento de un video donde

se podrá comprobar la utilidad de la aplicación así como su correcto funcionamiento.

Abrimos la aplicación, ejecutando el archivo main.exe. Podremos visualizar la siguiente

interfaz.

Interfaz de la aplicación recién iniciada

Se puede observar que existen únicamente dos botones, “Abrir Imagen” y “Frame”. En nuestro caso, queremos utilizar la funcionalidad del video, debemos pulsar el botón Frame.


10

Pulsar botón “Frame” para comenzar a analizar el video

Al hacer clic sobre dicho botón podremos visualizar en distintas zonas de la interfaz el

tratamiento del primer frame analizado del video.

Análisis del primer frame del vídeo


11

Podemos comprobar cómo se nos muestra en la parte superior la imagen original, es decir el

frame que actualmente se está analizando y en la parte inferior podemos ver la imagen

binarizada del color rojo y a su derecha la misma imagen tras un tratamiento de dilatación

para remarcar un poco más las zonas de color rojo.

Seguimos pulsando el botón “frame” para continuar con el análisis del video y llegamos al

frame en el que ya aparece una señal de tráfico en la imagen.

Análisis de un frame que contiene una señal de limitación de velocidad

En este nuevo frame analizado podemos observar como han aparecido dos nuevas imágenes.

Por un lado ha aparecido la “señal recortada” donde podremos visualizar el contenido de las

señales redondas y con contorno rojo que vayan apareciendo en el vídeo. Y por otro lado

aparece “Reconocimiento círculos” que no es más que el frame analizado junto con un circulo

que delimita la situación de la señal encontrada.

Seguimos avanzando frames hasta llegar a uno en el que se detecta el límite de velocidad y

este es mostrado en una imagen que perdurará en nuestra interfaz hasta que un nuevo límite

de velocidad haya sido detectado. (Las imágenes de “señal recortada” y “reconocimiento

círculos” también perdurarán estáticas hasta que una nueva señal sea detectada).


12

Captura de la interfaz donde se muestra el límite actual de la vía

IMAGEN

Si deseamos utilizar la aplicación para detectar las señales límite de velocidad en

imágenes simplemente debemos pulsar el botón de “Abrir Imagen” y buscar en

nuestros archivos la imagen que deseamos utilizar.

Pulsar “Abrir Imagen” para analizar una imagen


13

Junto con el ejecutable se ha añadido una imagen de prueba para poder comprobar el

funcionamiento de la aplicación. Seleccionamos nuestra imagen de prueba y seguidamente

nos aparecerá el resultado del análisis. Las distintas imágenes que se muestran son debidas al

mismo tratamiento que se realiza cuando analizamos un vídeo. Por lo tanto podemos

observar:

-La imagen que hemos seleccionado de nuestros archivos

-La imagen binarizada del color rojo

-La imagen binarizada y dilatada

-La imagen con la detección de círculos (si la aplicación ha sido capaz de detectar una

señal redonda)

-El contenido de la señal de velocidad (si la aplicación ha sido capaz de detectar una

señal redonda)

-El límite de velocidad (si la aplicación ha sido capaz de detectarlo)

Análisis de una imagen que presenta una señal de límite de velocidad


14

CONCLUSIONES

A pesar de lograr un resultado final altamente satisfactorio a nuestras expectativas se debe

reconocer que el algoritmo es también muy mejorable. Como ya hemos mencionado varias

veces, las diferentes circunstancias del momento de grabado de la carretera deben salvarse,

así como conseguir un porcentaje más alto de correctos reconocimientos de las señales y los

patrones. Hasta que no se consigan unos resultados casi perfectos el algoritmo no estaría a la

altura de las necesidades de los usuarios que puedan adquirir nuestros servicios.

Se concluye también que el algoritmo es perfectamente ampliable al reconocimiento de

distintas señales ajenas a las de velocidad como pueden ser prohibiciones de aparcamiento, de

adelantamiento, señales de recomendación de velocidad o señalizaciones de peligro.

Con algo más de esfuerzo y conocimiento se podría por ejemplo detectar con uso del

velocímetro si el piloto está excediendo el límite de velocidad, lo que evitaría cuantiosas

multas y lo que es más importante mejorar su seguridad vial.


15

REFERENCIAS

Thanh Bui-Minh, Ovidiu Ghita, Paul F. Whelan, Trang Hoang, Vinh Quang Truong. [Two

Algorithms for Detection of Mutually Occluding Traffic Signs]. International Conference

on Control, Automotion and Information Sciences ICCAIS (2012)

Carrasco Contreras, Fuentes García y Tejada Saracho. [Reconocimiento de señales de

tráfico de límite de velocidad]. Trabajo de la asignatura PID (2012)

ANEXO: TABLAS DE TIEMPO

TABLA DE JULIO CONEJ O BENAVIDES

TAREA FECHA COMIENZO DURACIÓN

Definición del proyecto 23 Noviembre 5 horas

-Proyectos anteriores 23 Noviembre 2 horas

-Artículos de referencia 23 Noviembre 3 horas

Investigación sistemas utilizados 24 Noviembre 7 horas

-Correcta instalación de versiones 24 Noviembre 7 horas

Búsqueda ejemplos OpenCV 27 Noviembre 3 horas

-Procesado de imágenes 27 Noviembre 2 horas

-Procesado de vídeo 27 Noviembre 1 hora

Pruebas de funciones básicas de OpenCV 28 Noviembre 4 horas

-En imágenes 28 Noviembre 2 horas

-En vídeo 28 Noviembre 2 horas

Implementación proyecto imágenes 16 Diciembre 22 horas

-Versión 1 16 Diciembre 10 horas




Implementación proyecto vídeo 27 Diciembre 15 horas



-Versión 3 2 Enero 3 horas


Informe TDA 27 Noviembre 1 hora

Implementación función matching 28 Diciembre 13 horas





Búsqueda de valores HSV para rojo 8 Enero 3 horas

Documentación 29 Diciembre 15 horas


16

TABLA DE MANUEL ALEJANDRO CAMPOS DÍAZ

TAREA FECHA COMIENZO DURACIÓN

Investigación del proyecto 23 Noviembre 3 horas

-Proyectos de otros alumnos 23 Noviembre 1 hora

-Proyectos por internet 23 Noviembre 1 hora

-Artículos revistas 23 Noviembre 1 hora

Investigación sistemas utilizados 24 Noviembre 7 horas

-Correcta instalación de versiones 24 Noviembre 7 horas

Instalación / Configuración sistemas 25 Noviembre 1 hora

-Instalación Python 2.7 25 Noviembre 15 min

-Instalación OpenCV 2.4.10 25 Noviembre 15 min

-Instalación PIL 1.1.7 25 Noviembre 15 min

-Instalación Numpy 1.9.1 25 Noviembre 15 min

Búsqueda ejemplos OpenCV 27 Noviembre 2 horas

-Procesado de imágenes 27 Noviembre 1 hora

-Procesado de vídeo 27 Noviembre 1 hora

Primera toma de contacto 28 Noviembre 4 hora

-Implementación ejemplos imágenes 28 Noviembre 2 horas

-Implementación ejemplos vídeo 28 Noviembre 2 horas

Grabación vídeo 15 Diciembre 1 hora

Procesamiento y recorte vídeo 15 Diciembre 1 hora

Implementación proyecto imágenes 16 Diciembre 15 horas





Implementación proyecto vídeo 27 Diciembre 10 horas




-Versión 4 3 Enero 1 hora

Investigación interfaz gráfica 3 Enero 6 horas

Implementación interfaz gráfica 4 Enero 20 horas





Documentación 2 Enero – 10 Enero 10 horas


17

reconocimiento de la velocidad máxima...

Documents