PROTOTIPO DE SISTEMA DE CONTEO VEHICULAR EN …

UNIVERSIDAD ANDRÉS BELLO

Facultad de Ingeniería

Escuela de Industrias

PROTOTIPO DE SISTEMA DE CONTEO VEHICULAR EN AUTOPISTAS

BASADO EN VISIÓN ARTIFICIAL

Tesis de pregrado para optar al título de Ingeniero en Automatización y Robótica

Autor:

Fabian Quintana Marín

Profesor Guía:

Néstor Palominos González

Santiago de Chile, 2016

2

UNIVERSIDAD ANDRES BELLO

FACULTAD DE INGENIERÍA

ESCUELA DE INDUSTRIAS

INGENIERÍA EN AUTOMATIZACIÓN Y ROBÓTICA

DECLARACIÓN DE ORIGINALIDAD Y PROPIEDAD

Yo, Fabian Antonio Quintana Marin, declaro que este documento no incorpora material de

otros autores sin identificar debidamente la fuente.

Santiago de Chile, 2016

_________________________

Firma del alumno

3

Agradecimientos

Agradecimientos especiales a mi familia que siempre confió en mí y me apoyó en

todo lo necesario, siempre se hicieron el tiempo para estar conmigo y preocuparse

por lo que estuviera haciendo.

A mis maestros los cuales nunca dejaron de enseñarme, a todos aquellos que

sabían lo que podía dar.

A mis compañeros los cuales me apoyaron en todo lo que podían, ya sea con

materiales o con conocimiento.

4

Dedico esta tesis tanto a mi madre como a mi padre por

formarme como persona, por darme siempre la confianza para

avanzar, por apoyarme en cada paso que he dado en mi vida.

Además dedico esta tesis a todos los profesores que han creído

en mí y me han apoyado en mi formación como ingeniero.

5

Índice general

Agradecimientos ................................................................................................................................. 3

Índice general ...................................................................................................................................... 5

Índice figuras ....................................................................................................................................... 7

Resumen ............................................................................................................................................ 11

Abstract ............................................................................................................................................. 12

1 – Antecedentes generales .............................................................................................................. 13

1.1 – Introducción ......................................................................................................................... 13

1.2 – Objetivos .............................................................................................................................. 14

1.2.1 – Objetivo general ................................................................................................................ 14

1.2.2 – Objetivos específicos ..................................................................................................... 14

2 –Marco Teórico .............................................................................................................................. 15

2.1 – Estado del arte...................................................................................................................... 15

Percepción del objeto. .................................................................................................................. 15

2.1.1 – Ultrasonido .................................................................................................................... 16

2.1.2 – Foreground mask ........................................................................................................... 18

2.1.3 – Template matching........................................................................................................ 19

2.1.4 – Haarcascade .................................................................................................................. 21

2.1.4.1 – Conteo .................................................................................................................... 23

2.1.4.2 – Grafico .................................................................................................................... 24

2.1.4.3 – Haar-like Features .................................................................................................. 26

2.2 – Herramientas utilizadas ........................................................................................................ 28

2.2.1 – Hardware ....................................................................................................................... 28

2.2.1.1 – Computador ........................................................................................................... 28

2.2.1.2 – Cámara webcam ..................................................................................................... 28

2.2.2 – Software ........................................................................................................................ 30

2.2.2.1 – Python2.7 ............................................................................................................... 30

2.2.2.2 – OpenCV 3.1.0 .......................................................................................................... 31

2.2.2.3 – HaarCascade ........................................................................................................... 32

6

2.2.2.4 – LabVIEW ................................................................................................................. 34

3 - Desarrollo del proyecto ................................................................................................................ 35

3.1- Moldeamiento de la solución ................................................................................................ 35

3.1.1- Detectar en imagen ......................................................................................................... 35

3.1.2- Detectar en video ............................................................................................................ 46

3.1.3- Detectar en cámaras ip ................................................................................................... 52

3.1.4- Guardar valores en texto ................................................................................................ 55

3.1.5- Graficar datos Labview .................................................................................................... 56

4.- Limitaciones ................................................................................................................................. 66

Código ............................................................................................................................................... 68

Analizar imagen ............................................................................................................................. 68

Contar en imagen .......................................................................................................................... 69

Analiza video ................................................................................................................................. 70

Analiza cámara IP .......................................................................................................................... 71

Analiza video y guarda en archivo ................................................................................................. 73

Referencias ........................................................................................................................................ 79

7

Índice figuras

Fig.1 (ultrasonido, origen“ultrasonido-hc-sr04”, zona maker) ......................................... 16

Fig.2 (ultrasonido diagrama de bloque, origen propio) .................................................... 17

Fig.3 (ultrasonido rango, origen“ultrasonido-hc-sr04”, zona maker) ............................... 17

Fig.4 (foreground mask, origen “vehicle detection, tracking and couting“) ..................... 18

Fig.5 (foregroung mask diagrama, origen propio) ............................................................ 18

Fig.6 (Template matching, origen “Open CV docs”) ......................................................... 19

Fig.7 (template matching diagrama, origen propio) ......................................................... 20

Fig.8 (Diagrama HaarCascade, origen propio)................................................................... 21

Fig.9 (HaarCascade ejemplo, origen propio) ..................................................................... 22

Fig.10 (OpenCV Líneas finales, origen propio) .................................................................. 23

Fig.11 (LabVIEW Grafico, origen National Instrument) ..................................................... 24

Fig.12 (Datos, origen propio) ............................................................................................. 25

Fig.13 (LabVIEW diagrama, origen propio) ....................................................................... 25

Fig.14 (Conjunto de caracteristicas, origen Docs OpenCV ) .............................................. 26

Fig.15 (Conjunto ampliado, origen Docs OpenCV ) ........................................................... 27

Fig.16 (SAT y RSAT, origen docs Opencv) .......................................................................... 27

Fig.17 (Cámara, origen “Camera web INTEX”) .................................................................. 28

Fig.18 (Python logo, origen Python ) ................................................................................. 30

Fig.19 (OpenCV Logo, origen “Open CV”) ......................................................................... 31

Fig.20 (OpenCV y Python, origen propio) .......................................................................... 31

Fig.21 (LabVIEW Logo, origen National Instrument) ......................................................... 32


Fig.23 (Diagrama de flujo, origen propio) ......................................................................... 35

Fig.24 (Diagrama de bloque, origen propio) ..................................................................... 36

Fig.25 (posición puntos en imagen, origen propio) .......................................................... 38

Fig.26 (Diagrama de flujo opencv-python, origen propio) ................................................ 40

Fig.27 (auto sin modificar, origen propio) ......................................................................... 42

Fig.28 (auto encontrado, origen propio) ........................................................................... 42

Fig.29 (conjunto imagenes, origen propio) ....................................................................... 42

8

Fig.30 (conjunto encontrado, origen propio) .................................................................... 42



Fig.33 (Diagrama de flujo python video, origen propio) ................................................... 48

Fig.34 (video detectado, origen propio) ............................................................................ 48

Fig.35 (dimensiones imagen, origen propio)..................................................................... 49

Fig.36 (Linea final, origen propio) ..................................................................................... 50


Fig.38 (Diagrama de flujo, origen propio) ......................................................................... 56

Fig.38 (Open/Create/Replace file, origen Labview) .......................................................... 57

Fig.39 (Conexión Open/Create/Replace file, origen propio) ............................................. 57

Fig.40 (Get File Size, origen Labview) ................................................................................ 57

Fig.41 (Conexión Get File Size, origen propio) .................................................................. 58

Fig.42 (While Loop, origen Labview) ................................................................................. 58

Fig.43 (Conexión While Loop Izquierdo, origen propio) ................................................... 58

Fig.44 (Wait Until Next ms Multiple, origen Labview) ...................................................... 59

Fig.45 (Conexión Wait Until Next ms Multiple, origen propio) ......................................... 59

Fig.46 (Set File Position, origen Labview) .......................................................................... 59

Fig.47 (conexión Set File Position, origen propio) ............................................................. 59

Fig.48 (Read from Text File, origen Labview) .................................................................... 60

Fig.49 (Conexión Read from Text File, origen propio) ...................................................... 60

Fig.50 (Fract/Ext String To Number, origen Labview) ....................................................... 60

Fig.51 (Conexión Fract/Ext String To Number, origen propio) .......................................... 61

Fig.52 (Waveform panel frontal, origen Labview) ............................................................ 61

Fig.53 (Posicion actual, origen propio) .............................................................................. 62

Fig.54 (Conexión stop, origen propio) ............................................................................... 62

Fig.55 (Close File, origen Labview) .................................................................................... 62

Fig.56 (Conexión Close File, origen propio) ....................................................................... 63

Fig.57 (Simple Error Handler.vi, origen Labview) .............................................................. 63

Fig.58 (Conexión Simple Error Handler.vi, origen Labview) .............................................. 63

Fig.59 (Conexión Diagrama de bloque, origen propio) ..................................................... 64

9

Fig.60 (números con 6 decimales random, origen Propio) ............................................... 64

Fig.61 (Waveform grafico, origen propio) ......................................................................... 65

11

Resumen

Este documento presenta una respuesta a la pregunta de cómo tener un control

del número de vehículos que pasan por la autopista para poder establecer una

relación adecuada entre los vehículos que entran y salen de Santiago, buscando

reducir los denominados “tacos”.

Lo primero es determinar la forma de obtener la imagen para trabajar, el cual fue

por medio de webcam, el medio para recopilar las imágenes es por OpenCV 3.1.0

el cual puede funcionar para C# o para Python, este último es el que se usará,

este es usado en su versión 2.7, una vez se ha determinado el medio de obtención

de imagen es necesario encontrar un medio que pueda determinar donde se

encuentra el vehículo en la imagen, se determinó usar Haarcascade, el cual

corresponde a una herramienta de OpenCV la cual consta de una base de

imágenes la que compara con la imagen que se obtuvo por la webcam, y OpenCV

se encarga de enmarcar en un rectángulo la posición del automóvil, después de

tener enmarcado el auto con los elementos ya descritos se necesita conocer la

cantidad de autos que ciertamente pasan por esta autopista, esto se logro con los

puntos que nos envía el Haarcascade, con esto se genera una línea final la cual

sumara uno al contador de autos de dicha autopista.

Los problemas a los que se enfrenta el programa es que pasen autos demasiado

juntos entre sí, otro factor importante son elementos semejante a autos los cuales

el programa puede determinar cómo vehículos, o vehículos que no son detectados

ya sea por color o forma.

Esto se validó con un video y capturas de cámara en tiempo real, con una

precisión de 86%, en el cual el programa contó 19 autos de 22.

Palabras claves: (Python, OpenCV, Visión, Artificial, Haarcascade,

Automóviles, Camaras)

12

Abstract

This paper presents an answer to the question of how to control the number of

vehicles passing through the highway to establish a proper relationship between

vehicles entering and leaving Santiago , seeking to reduce the so-called " tacos".

The first is to determine how to get the image to work, which was through webcam,

the way to collect the images is by OpenCV 3.1.0 which can work for C # or

Python, the last one is the used in this paper and is used in his version 2.7, once

you have determined the means of obtaining image is necessary to find a medium

that can determine where the vehicle are in the image, it was determined using

Haarcascade, this is a tool for OpenCV which It consists of a base of images which

compares the image obtained by the webcam, and OpenCV is responsible for

framing a rectangle the position of the car, after having framed the car with the

elements already described will need to knowhow many cars are going througt the

roadway this was obtanaible with the points that Haarsccascade give, wich was

used to put a finish line, everytime a car pass that line the count will increase in

one.

The problems with that this program face are that cars going a little bit closer,

another thing is that the program will frame things that are similar to cars, and

some cars will not be frame at all becouse of form or color.

This was validated with a video and captures of a camera in real time, with a

precission of 86%, it counted 19 of 22 vehicles.

Keyword: (Python, OpenCV, Vision, Artificial, Haarcascade, Cars, Cameras)

13

1 – Antecedentes generales

1.1 – Introducción

La cantidad de congestiones a la que se enfrenta Santiago en los horarios de

punta es un tema del cual todos han oído hablar, bajo la premisa de poder calcular

la cantidad de vehículos que pasan por las calles más transitadas se gestiono este

proyecto, este documento muestra los medios para llegar a esa meta.

Este proyecto se enfoca en la cantidad de vehículos que pasan en una calle

determinada, como respuesta a esto se decidió implementar un sistema, el cual

registra la cantidad de vehículos que pasan y la hora a la que estos transitaron

guardando la cantidad total de vehículos que transita por hora en un archivo, con

esto en mente se aplicó visión artificial la cual se lleva a cabo con OpenCV en el

entorno de Python, dicho sistema de conteo se implementara en el costado de una

calle, con esto se espera observar cual es el volumen de autos que pasan en

dicha vía y las horas punta, todo esto se plantea para que se pueda evaluar si la

calle en si da abasto a la cantidad de vehículos que por ella transitan.

Para el cálculo de la cantidad de vehículos se ha hecho uso de Haarcascade para

OpenCV lo cual permite identificar los autos presentes en cada frame del video,

este programa los encuentra y devuelve los puntos para enmarcarlos, luego se

usa la opción de dibujo de OpenCV y se enmarcan en el frame final, ahora esto lo

hace por cada frame del video, dando la sensación de que presenta un video

siendo que solo está evaluando cuadro a cuadro, dado a esto se necesita generar

una línea para determinar la parte final de la carretera para poder contar la

cantidad de autos sin repetirse.

Una vez traspasada una hora se genera un archivo con el numero de todos los

autos que han transitado en dicha hora, para después ser representados en un

grafico, dicho grafico fue diseñado en Labview.

14

1.2 – Objetivos

1.2.1 – Objetivo general

Desarrollar un sistema que cuente el flujo de vehículos en una calle, para saber

cuántos autos pasan por de ella y a qué hora transitan más vehículos.

1.2.2 – Objetivos específicos

Desarrollar sistema de visión artificial, que detecte la posición de los

vehículos

Crear un sistema de conteo de vehículos, que tenga una precisión mayor al

80%.

Desarrollar una base de datos que guarde la hora a la que pasan los

vehículos.

Crear una aplicación que determine la proporción que debe tener la

autopista en vigilancia para que se pueda generar un flujo acorde a la

cantidad de vehículos que entran o salen de Santiago.

15

2 –Marco Teórico

2.1 – Estado del arte

Hoy en día se precisa de un sistema de monitoreo continuo y autómata respecto a

control vehicular, con esto se ha implementado un sistema que pueda contabilizar

automóviles, con este objetivo en mente en distintas partes del mundo se han

implementado distintos tipos de sistemas específicamente diseñados para control

vehicular algunos de estos métodos son por ultrasonido o por visión artificial.

Percepción del objeto.

Se ha implementado diversas formas para ubicar los vehículos, algunos métodos

utilizan ultrasonido, otros con visión artificial, ahora hablaremos de ambos

métodos.

16

2.1.1 – Ultrasonido

La detección por ultrasonido puede proporcionar una estimación de la distancia

entre el objetivo medido y nuestro punto de referencia, el problema radica

principalmente en que no se puede verificar si el objeto es o no un vehículo, para

lo cual se ha de implementar una relación que evalué los movimientos y determine

que es un vehículo por ende se decidió no utilizar este método.

Fig.1 (ultrasonido, origen“ultrasonido-hc-sr04”, zona maker)

17

Su funcionamiento es que “genera un impulso ultrasónico. Los impulsos emitidos

viajan a la velocidad del sonido hasta alcanzar un objeto, entonces el sonido es

reflejado y captado de nuevo por el receptor de ultrasonido. Se cuenta el tiempo

que tarde en llegar el eco. Este tiempo se traduce en un pulso de eco de anchura

proporcional a la distancia a la que se encuentra el objeto” (Coe Gerald, 2016)

Fig.2 (ultrasonido diagrama de bloque, origen propio)

Fig.3 (ultrasonido rango, origen“ultrasonido-hc-sr04”, zona maker)

18

2.1.2 – Foreground mask

El control por medio de visión artificial por su parte cuenta con distintos tipos de

detección entre los cuales se hallan las siguientes, primero hablaremos de resta

de ambiente, “al comparar una imagen con un auto y otra imagen con el ambiente

sin el automóvil, podemos determinar donde se encuentran los objetos nuevos los

cuales son los automóviles” (Sobral Andrew, 2015) con este método solo aparece

en la imagen unas partes blancas las cuales se determina que son los autos.

Fig.4 (foreground mask, origen “vehicle detection, tracking and couting“)

Fig.5 (foregroung mask diagrama, origen propio)

19

2.1.3 – Template matching

Una forma de detectar por medio de visión artificial es con template matching el

cual requiere 2 cosas primordiales una imagen de fuente y la imagen que

queremos encontrar, la forma en la que funciona esta técnica es que la imagen

que queremos encontrar se moverá pixel por pixel en la imagen de fuente hasta

que se encuentre la coincidencia más alta. (Roberto Brunelli, 2009)

Fig.6 (Template matching, origen “Open CV docs”)

20

El problema más grande de este método es el hecho de que deberíamos tener

una imagen para cada tipo de auto y comparar todos los autos con el frame de

video, además de que la imagen del auto que debemos proporcionar debe

coincidir completamente, lo cual deja este método inutilizable dado a que

requeriría demasiado tiempo para evaluar la imagen de todos los autos con todos

los pixeles de la imagen hasta que los detecte a todos.

Fig.7 (template matching diagrama, origen propio)

21

2.1.4 – Haarcascade

Ahora se describirá la detección por medio de haarcascade, este método usa

openCV él cual se encuentra tanto para Python como para C#, el método en

cuestión consiste en que se toma la imagen actual completa, y la traduce en una

escala de colores grises, para después compararlo con su base de datos, donde

tiene almacenada distintas imágenes de autos todos en un tamaño determinado y

en escala de colores grises, si se encuentra una relación entre la imagen enviada

y las pertenecientes a su base de datos entonces devuelve al programa los datos

(x, y, h, w) que indica los lugares donde se encuentra dicha coincidencia en

nuestra imagen, con (x,y) tenemos el primer punto en el borde superior izquierdo y

con (x+w, y+h) tendremos el segundo punto en el borde inferior derecho, como lo

muestra la siguiente imagen.

Fig.8 (Diagrama HaarCascade, origen propio)

22

A continuación se les presentara un ejemplo de haarcascade, la primera imagen

muestra la fotografía sin modificar tomada a un vehículo, la segunda imagen

muestra como haarcascade y opencv encierran dicho vehículo en un rectángulo, la

tercera imagen muestra donde se encuentran los dos puntos necesarios para

poder enmarcar el vehículo.

Fig.9 (HaarCascade ejemplo, origen propio)

23

2.1.4.1 – Conteo

El conteo de los vehículos se logró con openCV dado a que haarcascade envía los

puntos donde se encuentra los objetos identificados en cada imagen, si se analiza

una sola imagen entonces se agrega un contador por cada cuadrado creado en

OpenCV.

Al analiza un video se debe asegurarse de no contar más de una vez cada

vehículo lo cual se logró delimitando una línea final y una pequeña área de

seguridad a esa línea, cuando un objeto identificado como un auto entra en el

área se guarda la posición en “x” donde se encuentra y se guarda como prevx, si

entra un objeto a la línea final y la diferencia entre “prevx” y el “x” actual es mayor

a un rango dado entonces podemos asumir que es otro vehículo que se encuentra

en otro carril, la desventaja de esto es cuando dos autos vienen muy cerca y por el

mismo carril puede que no cuente todos los vehiculos.

Fig.10 (OpenCV Líneas finales, origen propio)

24

2.1.4.2 – Grafico

Una vez terminada una hora la cantidad de autos que se detectaron en dicha hora

pasaran a un archivo para que más tarde sean representados en una grafica, esta

grafica se realiza con Labview, cada dato guardado debe tener un formato

establecido y debe coincidir con el de labview, esto para que labview lea la

cantidad exacta en cada línea y no se exceda o quede sin algún numero en su

lectura.

Labview abrirá el archivo, obtendrá su tamaño, leerá línea a línea el archivo,

transformara lo que lee a numero y lo graficara, si no detecta mas información el

programa o si detecta algún error se detendrá.

Fig.11 (LabVIEW Grafico, origen National Instrument)

25

Fig.12 (Datos, origen propio)

Cada numero tiene 4 dígitos, además de /n para señalar el salto de pagina, por lo

cual al leer un numero en Labview hemos de asegurarnos que este avance de 6

en 6 cada vez que lee un numero

Fig.13 (LabVIEW diagrama, origen propio)

26

2.1.4.3 – Haar-like Features

Este proyecto detecta imágenes por medio de un sistema conocido por Haarlike

features, a diferencia de Templete matching que comprueba la imagen pixel por

pixel para buscar la similitud este método busca características Haar-like, este se

basa en la diferencia entre la suma de todos los pixeles en algunas regiones

rectangulares contiguas, estas características no varían por escala o por

luminosidad además de ser robustas al ruido de la imagen.

Este método fue propuesto por Paul Viola y Michael Jones y mejorado por Rainer

Lienhart y Jochen Maydt.

El método propuesto en un principio constaba con el siguiente conjunto de

características

Fig.14 (Conjunto de caracteristicas, origen Docs OpenCV )

27

Al extender el primer conjunto el conjunto de característica resultante fue

Fig.15 (Conjunto ampliado, origen Docs OpenCV )

Estas características son determinadas con la imagen principal o SAT (Summed

Area Table) y la imagen principal rotada 45° o RSAT (Rotate Summed Area Table)

En la imagen SAT cada pixel SAT(x,y) contiene la suma de todos los pixeles, y en

la imagen RSAT cada pixel del cuadrado rotado 45° es sumado

Fig.16 (SAT y RSAT, origen docs Opencv)

28

2.2 – Herramientas utilizadas

2.2.1 – Hardware

2.2.1.1 – Computador

Se utiliza un computador con las siguientes especificaciones: Windows 10, 4gb de ram, 1,7ghz.

Se puede usar una Raspberry pi 2 o la Raspberry pi B+ como cambio de hardware dado a que este permite la instalación de Python, OpenCV y un módulo de cámara.(Adrian Rosebrock, 2015,“install opencv and python on your Raspberry pi 2 and B+”, “Pyimagesearch”)

2.2.1.2 – Cámara webcam

Cualquier webcam sirve para el propósito de captar automóviles, se recomienda

usar alguna con una definición media, se utiliza la HP TrueVision HD con una

resolución de 0,9 megapixeles la cual viene integrada en notebook

Fig.17 (Cámara, origen “Camera web INTEX”)

29

2.2.1.3 – Cámara IP

Se utiliza una cámara ip para poder observar carreteras o calles sin tener que

estar específicamente en el lugar, utilizando la dirección web de la cámara para

visualizar el video que este trasmite, se utiliza una cámara IP con el código de

MXC CIP-197380 tiene Pan-tilt resolución 720p (1280x720) 25 fps y distancia

infrarrojo de 10 metros.

Fig.17 (Cámara IP, origen Mirax)

30

2.2.2 – Software

2.2.2.1 – Python2.7

Es un lenguaje de programación, creado por un europeo llamado Guido Van

Rossum, el cual usaremos para poder comandar la cámara web, a este entorno de

programación le agregaremos la librería OpenCV 3.1.0 para poder conectarnos a

la cámara, además de agregar unos archivos (XML) de haarcascade para el

reconocimiento de autos.

Este es un lenguaje de programación de propósito general orientado a objetos, es

un lenguaje de script independiente de la plataforma preparado para realizar

cualquier tipo de programa entre sus beneficios se encuentra la cantidad de

librerías que contiene y las funciones incorporadas en el mismo lenguaje, la

sencillez con la que se puede crear programas y la cantidad de plataformas donde

se puede trabajar.

Dado a que es un lenguaje de propósito general se puede crear cualquier tipo de

programa, en cuanto a su independencia de la plataforma quiere decir que se

puede implementar en distintos sistemas informáticos.

Fig.18 (Python logo, origen Python )

31

2.2.2.2 – OpenCV 3.1.0

OpenCV es una librería de Python y de otros lenguajes de comunicación, lo que

esta librería hace es crear un medio entre Python y las cámaras conectadas al

computador, además de que incluye funciones para grabado de video, fotografías

o modificaciones de colores a las imágenes, además de poder modificar imágenes

agregando líneas o figuras a nuestra disposición, para unir opencv a python es

necesario mandar un archivo llamado cv2.pyd que se encuentra en la carpeta de

Opencv a la carpeta site-package de python dentro de Lib.

Fig.19 (OpenCV Logo, origen “Open CV”)

Fig.20 (OpenCV y Python, origen propio)

32

2.2.2.3 – HaarCascade

El HaarCascade es un clasificador (clasificador en cascada), creado por Paul Viola

y mejorado por Rainer Lienhart, el cual compara la imagen enviada con una base

de datos que tiene, este clasificador tiene apartados para distintos tipos de objetos

los cuales incluyen caras, autos, manos u ojos, etc.

HaarCascade tiene una gama de fotos tomadas, las cuales se dividen en dos

grupos, positivas y negativas, el grupo de imágenes positivas son similares al

objeto en cuestión en una escala de grises, el grupo de imágenes negativas son

objetos que puede haber en la región de la imagen y que no se quiere que

resalten, la imagen que se manda debe estar en una escala de colores grises para

que HaarCascade la reconozca, una vez ya la ha reconocido envía al programa

las coordenadas X, Y, W, H donde encontró el objeto.

Al recibir en el programa las coordenadas x, y, w, h se genera un rectángulo para

enmarcar dicho objeto.

Fig.21 (LabVIEW Logo, origen National Instrument)

33

Para crear un Cascade se necesitan 3 carpetas una donde estén ubicadas las

imágenes negativas, anteriormente descritas como objetos distintos al se quiere

ubicar, otra carpeta para las imágenes positivas que si pertenece al objeto se

quiere ubicar, y la tercera es donde se guardara el archivo XML se crea un archivo

de texto llamado negative.txt donde se agregaran las rutas a todas las imágenes

negativas, se crea un segundo archivo llamado positive.txt donde se encentre las

rutas a todas las imágenes positivas además de la posición donde ese encuentra

el objeto u objetos en la imagen y cuantas veces se encuentran en la imagen,

ubicándose en la pantalla de comandos de python en el apartado de herramientas

se agrega el texto

opencv_createsamples.exe -vec bin_desc.vec -info positive.txt -bg negative.txt

Con lo que se crea un archivo llamado bin_desc.vec el cual llamaremos usando

opencv_traincascade.exe -data cascade -vec bin_desc -bg negative.txt

Creando el archivo llamado cascade.xml que es donde se encuentra el nuevo

cascade para usar.

34

2.2.2.4 – LabVIEW

LabVIEW es una plataforma y entorno de desarrollo con un lenguaje gráfico, este

programa fue creado por National Instrument, los programas desarrollados se

denominan VI’s o Instrumentos virtuales, se caracteriza por su facilidad de uso,

con este se puede desarrollar programas realmente complejos imposibles de

desarrollar en otros lenguajes tradicionales.


35

3 - Desarrollo del proyecto

3.1- Moldeamiento de la solución

3.1.1- Detectar en imagen

La estructura del proyecto comienza con un sistema encargado de la adquisición

de datos, en este sistema se encuentra la cámara y Haarcascade, estos entregan

la imagen del entorno y la posición de los autos. El video entregado por la cámara

esta simulada con un video previamente obtenido donde se observan distintos

autos en una carretera. En una implementación futura se deberá cambiar el video

por una cámara en tiempo real.

Fig.23 (Diagrama de flujo, origen propio)

36

Haarcascade nos devuelve los puntos donde se encuentra los autos en base al

video obtenido.

Para poder usar la cámara en Python se ha de instalar OpenCV a este, para

lograrlo se debe enviar el archivo cv2.pyd a la librería de python “site-package”

Ya en el entorno de programación de python lo primero que se debe hacer será

importar cv2 con el comando

import cv2

Paso seguido se identifica el haarcascade a utilizar con el comando

cv2.CascadeClassifier('')

autocascade = cv2.CascadeClassifier('/Users/aa/Desktop/FaceDetect-

master/cars3.xml')

Se guarda el video capturado en una variable, para el video se usa el comando

cv2.VideoCapture

video = cv2.VideoCapture('/Users/aa/Desktop/FaceDetect-master/video

frente.mp4')

Fig.24 (Diagrama de bloque, origen propio)

37

Procesamiento de imagen es el siguiente proceso por el que se pasara, después

de obtener la imagen se usa haarcascade para que nos dirá donde se encuentra

cada auto en dicha imagen, y se usara OpenCV para modificar la imagen donde

se encuentran los objetos, se dibujaran recuadros enmarcando a cada auto que el

programa reconozca, además de agregar una línea final que se usara más

adelante.

Para realizar una pequeña prueba se usaron distintas imagen con autos presente,

y se modificó el código en la recepción del video, reemplazamos


frente.mp4')

Con

imagen = cv2.imread('/Users/aa/Desktop/FaceDetect-master/autos1.jpg')

Se agrega al código

while True:

gris = cv2.cvtColor(imagen, cv2.COLOR_BGR2GRAY)

auto = autocascade.detectMultiScale(gris, 1.8, 6)

Con el cual se cambia los colores de la imagen a una escala de colores con el

código

cv2.cvtColor(imagen, cv2.COLOR_BGR2GRAY)

38

Se aplica el haarcascade con el código

autocascade.detectMultiScale(gris, 1.8, 6)

En el cual “gris” es la imagen modificada y “1.8” es el factor de escalado y “6” es el

tamaño mínimo del objeto, es posible agregar otro valor después de este seguido

con una “,” extra indicando el tamaño máximo

El cascade nos devolverá los puntos (x, y, w, h) halladas en “auto”

Fig.25 (posición puntos en imagen, origen propio)

39

Se agrega al código:

for (x, y, w, h) in auto:

cv2.rectangle(imagen, (x, y), (x+w, y+h), (0, 0, 255), 3)

cv2.imshow('imagen auto', imagen)

Donde cv2.rectangle genera un rectángulo en la imagen titulada “imagen” cuyo

primer punto se encuentra en (x,y) y su segundo punto se encuentra en (x+w ,

y+h) y despues se le da el color con la forma (0, 0, 255)siendo este en base a

RGB donde está representado (AZUL,VERDE,ROJO) siendo 255 el color máximo

de cada uno y al final se determina el grosor de la línea

Y cv2.imshow muestra una ventana titulada ‘imagen auto’ donde se muestra la

imagen guardada con el nombre “imagen”, esta imagen es la misma imagen que

modificaron al agregare el rectángulo

Al final se agrega

if cv2.waitKey(1) & 0xFF == ord('e'):

break

cv2.destroyAllWindows()

Para poder terminar el programa se presiona la tecla “e” en la ventana creada con

el título de “imagen auto”.

40

Fig.26 (Diagrama de flujo opencv-python, origen propio)

41

Al final el código de prueba queda de la siguiente forma

import cv2


master/cas4.xml')


while True:


auto = autocascade.detectMultiScale(gris, 1.8, 6, 9)





break


42

Se prueba que el programa puede reconocer autos usando distintas imágenes

Fig.27 (auto sin modificar, origen propio)

Fig.28 (auto encontrado, origen propio)

Fig.29 (conjunto imagenes, origen propio)

Fig.30 (conjunto encontrado, origen propio)

43

Para contar la cantidad de autos en la imagen se agrega al código antes de entrar

al for :

font=cv2.FONT_HERSHEY_SIMPLEX

Con el cual se define la fuente con la que escribirá en la imagen

nauto = 0

Se define un nauto que representara el numero de autos en la imagen

Y después de entrar al for se agregara un

nauto=nauto+1

Con el cual cada vez que se entre a este for se sumara un auto al contador y

después transformamos el numero a string

txt=str(nauto)

Una vez transformado el numero a string agregamos la siguiente línea al código

cv2.putText(img,'autos: '+txt,(30,60),font,2,(0, 0, 0),1,cv2.LINE_AA)

Se define el texto que irá en la imagen, este texto debe estar después del ciclo for

44

Quedando el código estructurado de la siguiente manera

import cv2



master/cas4.xml')

img = cv2.imread('muchos autos.png')

gris = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

fh, fw, fd = img.shape



nauto = 0


cv2.rectangle(img, (x, y), (x+w, y+h), (0, 0, 255), 3)

nauto=nauto+1

txt=str(nauto)


cv2.imshow('img',img)

cv2.waitKey(0)


45

Una vez terminado de modificar el código se prueba si funciona utilizando un

conjunto de autos más grande, se prueba si puede contarlos en una imagen

estática



46

3.1.2- Detectar en video

Ahora se prueba con un video

Se reemplaza

imagen = cv2.imread('/Users/aa/Desktop/FaceDetect-

master/autos1.jpg')

Con


frente.mp4')

Este código guarda el video a reproducir en la variable llamada video

Se le agrega el siguiente código después del while true

ret, img = video.read()

Esta línea guarda la imagen actual del video en la variable img

47

Se cambia las variables con nombre “imagen” por “img” dejando el código de esta

manera

import cv2


master/cars3.xml')


frente.mp4')

while True:






cv2.imshow('imagen auto', img)


break

cv2.release()


48

Fig.33 (Diagrama de flujo python video, origen propio)

Fig.34 (video detectado, origen propio)

49

Después de obtener los datos y modificar la imagen se pasa a determinar la

cantidad de autos pasando por esta carretera, este punto se logro con la posición

final de cada auto y una línea para comparar.

Con este fin agregamos


Con el cual se obtiene las dimensiones de la imagen.

Donde fh representa la cantidad de filas que tiene la imagen fw representa la

cantidad de columnas que tiene la imagen y fd representa la cantidad de colores.

Fig.35 (dimensiones imagen, origen propio)

50

Se agrega

cv2.line(img ,(0,int(fh*0.6)), (int(fw),int(fh*0.6)) ,(255,0,0),4)

El cual dibuja una línea ubicada en un 60% desde el comienzo de la imagen hasta

el final con un color azul, para generar una línea en opencv se necesita usar un

código con la siguiente forma

cv2.line(imagen a modificar,primer punto inicial(x,y),segundo punto final

(x,y),color en RGB (AZUL,VERDE,ROJO),grosor de línea)

En la siguiente imagen se generaron 3 líneas, 2 de las cuales tienen distinto

tamaño

Fig.36 (Linea final, origen propio)

51

Una vez se tiene la línea final y las posiciones de los autos se pueden comparar, si

un automóvil atraviesa la línea inferior entonces un contador de autos aumentara,

con esto nos aseguramos de contar solo elementos móviles y no contar falsos

positivos “objetos parecidos a autos”, además de que nos aseguramos de no

contar vehículos de otra autopista o en dirección contraria.


52

3.1.3- Detectar en cámaras ip

Pruebas con cámaras IP, para utilizar una cámara IP se necesita conocer la

dirección web a la que se redirige la cámara, además de usuario y contraseña si

fuese necesario, primero que nada se debe importar vlc, este es un reproductor de

videos con la cualidad de poder reproducir videos desde urls

Fig.37 (Diagrama de flujo cámara ip, origen propio)

53

Primero se importa vlc al código, este se importa para poder reproducir el formato

de video de la cámara ip

import vlc

Se agrega al codigo

player=vlc.MediaPlayer('direccion url')

player.play()

Con lo cual se guarda el video que se encuentra en la dirección proporcionada con

el nombre de player, paso seguido se reproduce el video que se encuentra

guardado en player.

Se agrega el siguiente código dentro del while

player.video_take_snapshot(0, '.snapshot.tmp.jpg', 0, 0)

frame = cv2.imread('.snapshot.tmp.jpg')

Con este fragmento el reproductor toma un snapshot del video actual y después el

frame lo lee

54

El código debería quedar de la siguiente forma

import cv2

import vlc


master/cas3.xml')

player=vlc.MediaPlayer('rtsp://192.168.0.100/onvif2')

player.play()

while True:



gris = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)



cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 0, 255), 1)

cv2.imshow('video', frame)


break

video.release()


55

3.1.4- Guardar valores en texto

Para guardar los números que hemos obtenido con opencv y haarcascade en un

archivo de texto necesitamos crear una variable con la siguiente configuración

Archivo = open(nombre,modo)

En nombre debemos escribir el nombre y el tipo de archivo que queremos crear ej

‘History.txt’

En la sección modo tendremos que elegir el tipo de permiso que tendrá el

programa con respecto al archivo existen 3 permisos

R con este solo se puede leer el archivo

W crea y abre el archivo para escribir en el

A abre el archivo, si no existe lo crea y después puede escribir en el

Archivo = open(‘history.txt’,’ a’)

Para escribir en el agregamos

Archivo.write(‘Texto’)

El texto que nuestro archivo tendrá es Texto, si se quiere generar un salto de línea

se agrega un /n al final

Una vez terminamos de utilizar el archivo de texto se debe de cerrar con un

Archivo.close

56

3.1.5- Graficar datos Labview

Una vez se ha guardado los datos en un documento se busca representarlos en

un grafico, dicho grafico fue desarrollado con labview.

Para representar el grafico se sigue el siguiente procedimiento

Fig.38 (Diagrama de flujo, origen propio)

57

Siguiendo el diagrama de flujo se crea un programa en labview para mostrar un

grafico con los datos reunidos.

Primero se agrega el icono de Open/Create/Replace file.

Fig.38 (Open/Create/Replace file, origen Labview)

Se crea la dirección donde se encuentra el archivo, se determina que acción

realizara el icono y que acceso tiene al documento

Fig.39 (Conexión Open/Create/Replace file, origen propio)

Se incluye Get File Size con el cual se puede obtener el tamaño del archivo que

lee desde el conector file

Fig.40 (Get File Size, origen Labview)

58

Se conecta el Get File Size con el icono anterior de la siguiente manera, el tamaño

del archivo sale desde el conector size, este valor se entrega en bytes

Fig.41 (Conexión Get File Size, origen propio)

Se agrega un While Loop que genera un ciclo el cual terminara cuando ciertas

condiciones se cumplan

Fig.42 (While Loop, origen Labview)

Se conecta Get File Size al While Loop y se cambia las entradas a shift register de

la siguiente forma, además se agrega una constante de 0 y se le cambia la

entrada a shift register

Fig.43 (Conexión While Loop Izquierdo, origen propio)

59

Se necesita agregar un Wait Until Next ms Multiple con el cual el ciclo funciona en

milisegundos multiples del numero que se le entrega al conector millisecond

multiple

Fig.44 (Wait Until Next ms Multiple, origen Labview)

Solo necesita un controlador con el múltiplo en milisegundos dentro del while loop,

con lo cual el programa funcionara en ciclos múltiplos de este milisegundo

Fig.45 (Conexión Wait Until Next ms Multiple, origen propio)

Ahora se conecta un Set File Position, este número cambia la posición donde

inicia el documento

Fig.46 (Set File Position, origen Labview)

Quedando de esta forma

Fig.47 (conexión Set File Position, origen propio)

60

Ahora se necesita conectar un Read from Text File

Fig.48 (Read from Text File, origen Labview)

En el conector de count o contador se le agrega la cantidad de decimales que

tendrá cada número en el archivo, en el conector llamado text o texto devuelve los

datos que ha leído con formato de string, en el conector file está conectado al

refnum out del icono set file position, por lo cual este icono lee 10 caracteres a la

derecha desde la posición entregada en por el set file position

Fig.49 (Conexión Read from Text File, origen propio)

Se transforma el texto en string a número con Fract/Ext String To Number

Fig.50 (Fract/Ext String To Number, origen Labview)

Una vez transformado el string a número este se conecta con un waveform chart

61

Fig.51 (Conexión Fract/Ext String To Number, origen propio)

El Waveform Chart tiene un componente en el frontal panel

Fig.52 (Waveform panel frontal, origen Labview)

62

Ahora el while loop necesita un botón para detenerse, esto se logra con la

siguiente conexión

Al dato actual se le suma 10, este número (10) debe ser igual al tamaño de cada

número contando comas y saltos, después este nuevo numero pasa con el shift

register de vuelta al comienzo del loop

Fig.53 (Posicion actual, origen propio)

Si el dato actual es igual a la cantidad de datos en el documento o si se encuentra

un error en la programación el programa se detiene.

Fig.54 (Conexión stop, origen propio)

Una vez se detiene el loop se necesita cerrar el archivo con el icono Close File

Fig.55 (Close File, origen Labview)

63

Se conecta de esta forma

Fig.56 (Conexión Close File, origen propio)

Y al final se agrega un Simple Error Handler.vi

Fig.57 (Simple Error Handler.vi, origen Labview)

Fig.58 (Conexión Simple Error Handler.vi, origen Labview)

Una vez conectado todo, el diagrama de bloques se debería ver de la siguiente

forma.

64

Fig.59 (Conexión Diagrama de bloque, origen propio)

El documento de texto tiene 600 números con el siguiente formato

Fig.60 (números con 6 decimales random, origen Propio)

65

Al graficar el documento completo, el programa grafica los números desde 0 a 599

Fig.61 (Waveform grafico, origen propio)

66

4.- Limitaciones

Este proyecto tiene distintos tipos de limitaciones a la hora de su implementación,

las limitaciones más severas que este tiene son las siguientes.

La primera son las horas de operación, el programa funcionara mejor durante el

día

Otra limitación es la dirección en la cámara, el proyecto reconoce autos en

posiciones muy específicas.

67

Conclusiones

Este proyecto se planteo con la problemática de evaluar el flujo de automóviles en

carreteras o calles, buscando entregar las herramientas para saber dónde y a qué

hora se congestionan.

Este desafío a presentado distintas problemáticas a la hora de implementarlo, ya

sea la luminosidad del día, la posición en la que se detectan los autos, o los

colores que estos tienen.

Aun con todas estas problemáticas se ha logrado distintos tipos de resultados,

aunque no son totalmente satisfactorios si se demuestra que se puede llegar a

implementar.

68

Código

Analizar imagen

import cv2


master/cas4.xml')


while True:


auto = autocascade.detectMultiScale(gris, 1.8, 6, 9)





break


69

Contar en imagen

import cv2



master/cas4.xml')

img = cv2.imread('autos1.jpg')





nauto = 0



nauto=nauto+1

txt=str(nauto)

cv2.putText(img,'autos: '+txt,(30,60),font,1,(255, 255,

255),1,cv2.LINE_AA)

cv2.imshow('img',img)

cv2.waitKey(0)


70

Analiza video

import cv2


master/cars3.xml')


frente.mp4')

while True:






cv2.imshow('imagen auto', img)


break

cv2.release()


71

Analiza cámara IP

import cv2

## Se importa cv2 para analizar video

import vlc

## Se importa vlc para reproducir un video con formato rtsp


master/cars3.xml')

## Se define “autocascade” con el clasificador que se usara, donde dice

/Users/aa/Desktop/FaceDetect-master/cars3.xml

## Se define la url de donde se tiene guardado el archivo xml con el

cascade que se ha de usar

player=vlc.MediaPlayer('rtsp://192.168.0.100/onvif2')

## Se define player como el video captado de la dirección establecida

player.play()

## Se reproduce el video que actualmente se encuentra en player

while True:


##Se toma un snapshot del video y se guarda con el nombre .snapshot.tmp-

jpg


## Frame se define como la imagen tomada del video

gris = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

## Se guarda frame en escala de colores grises en la variable gris


## Se aplica Haarcascade a la imagen guardada en gris

72


cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 0, 255), 1)

## Se dibuja un rectángulo en la posición donde se encuentra el auto

cv2.imshow('Video', frame)

## Se muestra la imagen en una ventana llamada Video


break

## Se cierra el while, se libera el video y se cierra las ventanas

video.release()


73

Analiza video y guarda en archivo

import cv2

## Se importa la librería para procesamiento de imagen

import datetime

## Se importa el tiempo


master/cars3.xml')

## Se define "autocascade" con el clasificador que se usara, donde dice


## Se agrega la url de donde esta guardado el archivo xml con el cascade

que se usara


## Se define un tipo de fuente

numauto = 0

numauto2 = 0

numauto3 = 0

## se crea 3 contadores distintos para poder establecer un promedio

prevy=0

prevx=0

prevx2=0

prevx3=0


frente.mp4')

## Se define la dirección del video

74

while True:

utcnow = datetime.datetime.utcnow()

## Se guarda el tiempo actual en utc en una variable llamada utcnow


## Se guarda el frame actual del video en una variable llamada img


## Se guarda las dimensiones de img


## Se le transforma la imagen a una escala de colores grises

cv2.imshow('video frente', img)

## se muestra el video en una ventana llamada video frente


## Se le aplica el clasificador a la imagen en gris


cv2.line(img ,(0,int(fh*0.6-12)), (int(fw),int(fh*0.6-12))

,(255,0,0),1)

cv2.line(img ,(0,int(fh*0.6+12)), (int(fw),int(fh*0.6+12))

,(255,0,0),1)



,(255,0,0),1)


,(255,0,0),1)



,(255,0,0),1)


,(255,0,0),1)

## Se dibujan las líneas

75

txt=str((numauto+numauto2+numauto3)/3)

minu=str(utcnow.minute)

hora=str(utcnow.hour)

segu=str(utcnow.second)

##Se genera un texto donde estará el promedio de las 3 mediciones

## Se genera variables para los segundos, minutos y horas


cv2.putText(img,'horaUTC: '+ hora +':'+ minu +':'+

segu,(600,60),font,1,(0, 0, 0),1,cv2.LINE_AA)

## Se agregan textos en la imagen indicando cuantos autos se

encuentran en la imagen, además de la hora actual en utc


if (x<fw*0.7):


cv2.imshow('webcam', img)

if (y+h <(fh*0.6+15)) & (y+h > (fh*0.6-15)) & ((prevx-x)>20):

numauto=numauto+1

if (y+h <(fh*0.6+12)) & (y+h > (fh*0.6-12)):

prevx=x

if (y+h <(fh*0.7+20)) & (y+h > (fh*0.7-29)) & ((prevx2-x)>20):

numauto2=numauto2+1

if (y+h <(fh*0.7+12)) & (y+h > (fh*0.7-12)):

prevx2=x

if (y+h <(fh*0.8+20)) & (y+h > (fh*0.8-29)) & ((prevx3-x)>20):

numauto3=numauto3+1

if (y+h <(fh*0.8+12)) & (y+h > (fh*0.8-12)):

prevx3=x

## Se restringe el modificador para que solo se evalúen los autos

en la autopista que van en un solo sentido, además se generan 3 lineas de

medición donde cada línea suma a un contador distinto

76


##Cuando la tecla “e” es presionada el while se cerrara y además

generara un archivo de texto donde se guardara la cantidad de autos

que conto, en un formato de 4 digitos desde 0000 hasta 9999

if numtxt<10:

doc = open('History.txt','a')

doc.write('000'+txt+'\n')

if numtxt<100 and numtxt>=10:



if numtxt<1000 and numtxt>=100:



if numtxt>=1000:


doc.write(txt+'\n')

break

## al salir del while se cierra el archivo, se libera el video y se

cierran todas las ventanas

doc.close()

video.release()


77

import cv2

## importamos cv2 la libreria para la camara


master/cars3.xml')

## definimos “autocascade” con el clasificador que usaremos, donde dice


## agregaremos la url de donde tenemos guardado nuestro archivo xml con

el cascade que usaremos


## definimos Font como un tipo de fuente para los números y letras que

pondremos en la imagen

numauto = 0

## numauto es el contador de los autos

prevy=0

## prevy es el valor previo de y

prevx=0

## Al igual que prevy, prevx es el valor previo de x


frente.mp4')

## Video es la variable donde se guardara el video, tenemos que

determinar el lugar y el archivo por completo, incluido el formato

while True:


## img es el frame actual del video en cuestion


## fh, fw y fd son valores de la imagen que nos muestran su ancho,alto y

fondo


## Cambiamos la imagen a una escala de colores grises

cv2.imshow('video frente', img)

## Se muestra la imagen sin modificación con el titulo video frente


78

## Mandamos la imagen en la escala de grises al cascade hubicado en

autocascade

cv2.line(img,(0,int(fh*0.6)),(int(fw),int(fh*0.6)),(255,0,0),4)

## Dibujamos una linea que marca el punto medio de medida

cv2.line(img,(0,int(fh*0.6-12)),(int(fw),int(fh*0.6-12)),(255,0,0),1)

## Dibujamos una línea mostrando el punto máximo

cv2.line(img,(0,int(fh*0.6+12)),(int(fw),int(fh*0.6+12)),(255,0,0),1)

## Dibujamos la última línea que representa el punto minimo

txt=str(numauto)

## Transformamos numauto de un int a un streing para poder representarlo


## Escribimos “autos: ‘numero de autos contados’”


## Cuando Haarcascade encuentra un objeto similar a un auto envía los

datos “X”, “Y”, “W” y “H”


## Dibujamos un rectángulo en los puntos donde se encuentra el auto

cv2.imshow('Detecta', img)

## mostramos el resultado total en una ventana aparte llamada Detecta

if (y+h <(fh*0.6+15)) & (y+h > (fh*0.6-15)) & ((prevx-x)>20):

numauto=numauto+1

if (y+h <(fh*0.6+12)) & (y+h > (fh*0.6-12)):

prevx=x


break

video.release()


## si apretamos la tecla “e” el programa sale del while libera el video y

destruye las ventanas abiertas

79

Referencias

[1] S.Sivaraman, M.M.Trivedi, Lab. for Intell. & Safe Automóviles, Univ. of California San Diego, La

Jolla, CA, USA (diciembre de 2013) looking at vehicles on the road a survey of visión-based

vehicle detection, tracking and behavior.

[2] Ahmed Nabil Belbachir, Michael hofstätter, Martin Litzenberger y Peter Schön (10 de febrero de

2011) High speed embedded object analysis using a dual line timed address event temporal

contrast visión sensor.

[3] Edgar A. Bernal, Wencheng Wu, Orhan Bulan, Robert P. Loce (6-9 de octubre 2013) Monocular

visión based vehicular speed estimation from compressed video streams.

[4] Kiran Kumar KV, Pallavi Chandrakant, Santosh Kumar, Kushal KJ (8-10 de enero de 2014)

Vehicle speed detection using corner detection.

[5] A Nurhadiyatna, B. Hardjono, A. Wibisono, I. Sina, W. Jatmiko, M. Anwar Ma’sum y P.

Mursanto. (28-29 de septiembre de 2013) Improved vehicle speed estimation using gaussian

mixture model and hole filling algoritm.

[6] Zhiyuan Li, Naira Hovakimyan, Vladimir Dobrokhodov y Isaac Kaminer (15-17 de diciembre de

2010) Vision based target tracking and motion estimation using a small uav.

[8] Junda Zhu, Liang Yuan, Yuang F. Zheng, Robert L. Ewing (octubre de 2012) Stereo visual

tracking within structured envirionments for measuring vehicle speed.

[9]Wang Xiaoyong, Wang Bo, Song Lu (2012) Real time on road vehicle detection algorithm based

on monocular visión

[10] Seunghwan Baek, Heungseob Kim, Kwangsuck Boo.(10-12 de noviembre de 2014) robust

vehicle detection and tracking method for blind spot detection system using visión sensors

[11]Eric Hernandez Castillo, Zizilia Zamudio Beltran, Juan Manuel Ibarra Zannatha.(15-18 de

noviembre de 2011) Soccer ball speed estimation using optical flow for humanoid soccer

player.

[12]Lu Weina, Tian Shuyao, Zhang Lihong, Ma Jiwei, Liu Shengtao, Lin Hongju (10-11 de julio de

2010) Preceding vehicle detecting and tracking for intelligent vehicles.

[13]Tomoyuki Mori, Sebastian Scherer. ( 6-10 de mayo de 2013) First results in detecting and

avoiding frontal obstacles from a monocular camera for micro unmanned aerial vehicles.

[14]Andres Felipe Hurtado, Jairo Alejandro Gomez, Victor Manuel Peñeñory (24-27 de noviembre

2015) Proposal of a computer visión system to detect and track vehicles in real time using an

embedded platform enabled with a graphical processing unit.

80

[15]Minkyu Cheon, Wonju Lee, Changyong Yoon y Mignon Park (septiembre 2012)Vision based

vehicle detection system with consideration of the detecting location.

[16]Huasheng Zhu, Chenguang Xu, Fan li (2013) The traffic volumen count algorithm based n

computer vision

[17] Y.M.Chan, S.S.Huang, L.C.Fu, P.Y.Hsiao, M.F.Lo, (17 de abril de 2010) Vehicle detection and

tracking under various lighting conditions using a a particle filter

[18] Akhan Almagambetov, Senem Velipasalar, Mauricio caseres(5 de febrero de 2015) Robust

and computationallyu lightweight autonomous tracking of vehicle taillights and signal

detection by embedded smart cameras

[19] Youpan Hu, Qing He, Xiaobin Zhuang, Haibin Wang, Baopu Li, Zhenfu Wen, Bin Leng, Guan

Guan, Donghue Chen (diciembre de 2013) Algorith for visión based vehicle detection and

classification.

[20] Frank (16/4/2015)Car tracking with cascades. Obtenido de

Pythonspot:https://pythonspot.com/en/car-tracking-with-cascades/

[21]“AALEEKH” (2014) Python-Based-Image-Recogntion. Obtenido de

Github:https://github.com/AALEKH/Python-Based-Image-Recogntion/blob/master/cars3.xml

[22] abhi kumar (2014) CAR-DETECTION. Obtenido de Github:

https://github.com/abhi-kumar/CAR-DETECTION/blob/master/cas1.xml




[23] Andrews Sobral (2015) Vehicle Detection, Tracking and Counting. Obtenido de

Behance:https://www.behance.net/gallery/Vehicle-Detection-Tracking-and-Counting/4057777

PROTOTIPO DE SISTEMA DE CONTEO VEHICULAR EN …

Documents

Transcript of PROTOTIPO DE SISTEMA DE CONTEO VEHICULAR EN …