sistema de control de acceso vehicular mediante

INSTITUTO POLITÉCNICO NACIONAL ESCUELA SUPERIOR DE CÓMPUTO

ESCOM

Trabajo Terminal

Sistema de control de acceso vehicular mediante verificación de

placas

2014-B026

Presenta

José Arturo Roa García

Directores

Dr. José Félix Serrano Talamantes Dra. Yasmín Ivette Jiménez Galán

Diciembre 2015

1

INSTITUTO POLITÉCNICO NACIONAL ESCUELA SUPERIOR DE CÓMPUTO

SUBDIRECCIÓN ACADÉMICA

No de TT: 2014-B026 16/Diciembre/2015

Documento Técnico

Sistema de control de acceso vehicular mediante verificación de

placas

Presenta

José Arturo Roa García

Directores

Dr. José Félix Serrano Talamantes Dra. Yasmín Ivette Jiménez Galán

RESUMEN

En la actualidad se vive con mucha inseguridad y dentro de este rubro se busca reducir el

porcentaje de robo de automóviles al descender de su vehículo para abrir la puerta de acceso a su

unidad habitacional.

Palabras clave: Reconocimiento de patrones, Programación, Placas vehiculares,

Microcontrolador.

__________________

[email protected]

4

AGRADECIMIENTOS

Gracias a mi madre, que sin importar las circunstancias viste por mi bienestar y estuviste a mi

lado en los momentos más difíciles de mi vida, gracias porque este logro obtenido no solo es mío;

es de ambos, ya que tú me formaste y me enseñaste a ser la persona que soy; de todo corazón te

quiero.

Gracias a mi padre, que me enseñó el valor del trabajo, a ser feliz y disfrutar la vida; donde quiera

que estés siempre te llevo en mi mente y corazón. Hoy parte de mí, es tu reflejo; el cariño y amor

que me brindaste me ha hecho ser una buena persona. Te extraño inmensamente.

Gracias a mi hermano, que has sido uno de los pilares más fuertes en mi vida. Has causado en mí,

admiración por ti, cada paso que das me motiva a sacar lo mejor de mí, gracias por ser mi amigo

y tolerarme todos estos años. Gracias por cuidarme, sé que puedo contar contigo siempre y quiero

que sepas que tú también puedes contar conmigo siempre.

Gracias a mi novia, que me has dado un amor grande, cálido e incondicional, gracias por

tolerarme este año de trabajo y apoyarme en todo momento, gracias por permitirme ser parte de

tu vida y de Mitzi, gracias por hacerme reír siempre, los días a tu lado son asombrosos; Yesica te

amo.

Gracias a mi directora, que desde que la conocí ha sido una luz en mi camino, sin su gran apoyo y

dirección no hubiera llegado tan lejos, gracias por escucharme y darme sus consejos; me quedo

de usted lo que yo quiero considerar una gran amistad, la quiero mucho.

Gracias a mi director, que me ha auxiliado con su conocimiento y me ha dado todas las

herramientas para desarrollar mi trabajo terminal con éxito, gracias por su comprensión y apoyo

ante las situaciones que he pasado, lo estimo mucho.

5

Contenido Índice de ilustraciones ..................................................................................................................... 7

Índice de tablas ................................................................................................................................ 8

1. Introducción ............................................................................................................................... 10

1.1. Problemática ....................................................................................................................... 10

1.2. Justificación ........................................................................................................................ 11

1.3. Sistemas similares ............................................................................................................... 12

1.4. Objetivo .............................................................................................................................. 14

1.4.1. Objetivo general. .......................................................................................................... 14

1.4.2. Objetivos específicos. ................................................................................................... 14

2. Marco teórico ............................................................................................................................. 15

2.1. Reconocimiento de patrones ............................................................................................... 15

2.1.1. Conceptos ..................................................................................................................... 15

2.1.2. Aprendizaje .................................................................................................................. 15

2.1.3. Modelo de sistema de reconocimiento de patrones ...................................................... 16

2.1.4. Clasificador .................................................................................................................. 16

2.2. Tratamiento digital de imágenes ......................................................................................... 19

2.2.1. Segmentación de imágenes .......................................................................................... 20

2.3. Reconocimiento automático de número de placas .............................................................. 27

2.4. Reconocimiento óptico de caracteres (OCR) ...................................................................... 27

2.4.1. ¿Qué es el reconocimiento óptico de caracteres? ......................................................... 27

2.4.2. ¿Qué hay detrás de la tecnología OCR? ....................................................................... 28

3. Metodología ............................................................................................................................... 29

3.1. SCRUM aplicado al sistema ............................................................................................... 30

3.1.1. Idea del sistema ............................................................................................................ 30

3.1.2. Pila del producto ........................................................................................................... 30

3.1.3. Pila de sprint 1 .............................................................................................................. 32

3.1.4. Pila de sprint 2 .............................................................................................................. 33

3.1.5. Pila de sprint 3 .............................................................................................................. 33

3.1.6. Pila de sprint 4 .............................................................................................................. 34

3.1.7. Pila de sprint 5 .............................................................................................................. 34

3.1.8. Pila de sprint 6 .............................................................................................................. 35

6

3.1.9. Pila de sprint 7 .............................................................................................................. 35

3.1.10. Pila de sprint 8 ............................................................................................................ 36

3.1.11. Pila de sprint 9 ............................................................................................................ 36

3.1.12. Pila de sprint 10 .......................................................................................................... 37

3.1.13. Pila de sprint 11 .......................................................................................................... 37

3.1.14. Pila de sprint 12 .......................................................................................................... 38

4. Análisis del sistema ................................................................................................................... 39

4.1. Estudio de factibilidad ........................................................................................................ 39

4.2. Análisis de costos ................................................................................................................ 40

4.3. Requerimientos no funcionales ........................................................................................... 40

4.4. Requerimientos funcionales ................................................................................................ 41

4.5. Análisis de riesgos .............................................................................................................. 41

4.5.1. Listado de riesgos potenciales ...................................................................................... 42

4.5.2. Listado de priorización de riesgos ................................................................................ 42

4.5.3. Planes de prevención y contingencia ........................................................................... 43

4.6. Diagramas de casos de uso ................................................................................................. 43

4.6.1. Actores ......................................................................................................................... 43

4.6.2. Diagramas ..................................................................................................................... 43

4.7. Casos de uso ........................................................................................................................ 44

4.7.1. CU-01 Iniciar sesión como administrador ................................................................... 44

4.7.2. CU-02 Agregar placa ................................................................................................... 45

4.7.3. CU-03 Eliminar placa ................................................................................................... 46

4.7.4. CU-04 Modificar placa ................................................................................................. 47

4.7.5. CU-05 Reconocer placa ............................................................................................... 48

4.7.6. CU-06 Decidir acceso .................................................................................................. 49

4.8. Reglas del negocio .............................................................................................................. 49

4.8.1. Composición de una placa vehicular ............................................................................ 50

5. Diseño del sistema ..................................................................................................................... 51

5.1. Diagrama entidad-relación .................................................................................................. 51

5.2. Diagrama de base de datos .................................................................................................. 51

5.2. Diagrama de clases ............................................................................................................. 52

5.3. Interfaz gráfica .................................................................................................................... 53

7

5.4. Diagrama de flujo del sistema ............................................................................................ 54

5.5. Diseño de circuitos electrónicos ......................................................................................... 54

6. Implementación y pruebas ......................................................................................................... 56

6.1. Conectividad con la cámara ................................................................................................ 56

6.2. Segmentación de imagen .................................................................................................... 71

6.3. Umbralizado ........................................................................................................................ 74

6.4. Extracción de características ............................................................................................... 79

6.3. Entrenamiento ..................................................................................................................... 85

6.4. Conectividad con el circuito ............................................................................................... 86

6.5. Gestión de placas vehiculares ............................................................................................. 88

Índice de ilustraciones

Ilustración 1: modelo de sistema de reconocimiento de patrones ................................................. 16

Ilustración 2: ejemplo de un árbol de decisión .............................................................................. 18

Ilustración 3: esquema que representa el proceso de segmentación .............................................. 20

Ilustración 4: ejemplo de crecimiento de regiones por agrupamiento de píxeles .......................... 24

Ilustración 5: tipos de bordes ......................................................................................................... 25

Ilustración 6: diagrama de la metodología SCRUM ..................................................................... 29

Ilustración 7: diagrama de casos de uso del administrador ........................................................... 43

Ilustración 8: diagrama de casos de uso del inquilino ................................................................... 44

Ilustración 9: diagrama entidad – relación .................................................................................... 51

Ilustración 10: diagrama de base de datos ..................................................................................... 51

Ilustración 11: diagrama de clases ................................................................................................. 52

Ilustración 12: pantalla principal IG-01......................................................................................... 53

Ilustración 13: iniciar sesión como administrador ......................................................................... 53

Ilustración 14: gestión de placas vehiculares ................................................................................ 54

Ilustración 15: diagrama de flujo del sistema ................................................................................ 54

Ilustración 16: diseño de circuito electrónico ................................................................................ 55

Ilustración 17: conexión con cámara web ..................................................................................... 56

Ilustración 18: conexión con cámara web sin luz .......................................................................... 56

Ilustración 19: captura de cámara infrarroja .................................................................................. 57

Ilustración 20: captura de cámara infrarroja con celofán rojo ....................................................... 67

Ilustración 21: medidas del auto más bajo .................................................................................... 68

Ilustración 22: medidas del auto más alto ..................................................................................... 68

Ilustración 23: medidas de la camioneta más baja ........................................................................ 69

8

Ilustración 24: medidas de la camioneta más alta ......................................................................... 69

Ilustración 25: cámara infrarroja con medidas reales .................................................................... 69

Ilustración 26: cámara infrarroja con obstáculo ............................................................................ 70

Ilustración 27: cámara infrarroja con obstáculo 2 ......................................................................... 70

Ilustración 28: cámara infrarroja con obstáculo 3 ......................................................................... 70

Ilustración 29: división de columnas a 120 cm ............................................................................. 72



Ilustración 32: división de columnas a 90 cm ............................................................................... 73

Ilustración 33: división de filas a 100 cm ...................................................................................... 73

Ilustración 34: Placa segmentada .................................................................................................. 73

Índice de tablas

Tabla 1: sistemas similares ............................................................................................................ 13

Tabla 2: distancias para clasificador .............................................................................................. 17

Tabla 3: algoritmo K-NN .............................................................................................................. 19

Tabla 4: entorno de un píxel .......................................................................................................... 26

Tabla 5: pila de producto ............................................................................................................... 32

Tabla 6: pila de sprint 1 ................................................................................................................. 32




Tabla 10: pila de sprint 5 ............................................................................................................... 34





Tabla 15: pila de sprint 10 ............................................................................................................. 37



Tabla 18: estudio de factibilidad [software] .................................................................................. 39

Tabla 19: estudio de factibilidad [microcontrolador] .................................................................... 39

Tabla 20: análisis de costos ........................................................................................................... 40

Tabla 21: requerimientos no funcionales....................................................................................... 40

Tabla 22: requerimientos funcionales............................................................................................ 41

Tabla 23: listado de priorización de riesgos .................................................................................. 42

Tabla 24: plan de prevención y contingencia ................................................................................ 43

Tabla 25: caso de uso CU-01 ......................................................................................................... 44



9




Tabla 31: composición de una placa vehicular .............................................................................. 50

Tabla 32: vehículos más vendidos en Abril 2015 ......................................................................... 71

Tabla 33: momentos de Hu de los caracteres ................................................................................ 84

Tabla 34: archivo "entrenamiento.txt" ........................................................................................... 85

10

1. Introducción

El presente documento contempla la implementación de un sistema que será capaz de reconocer

placas vehiculares para mantener un control en el acceso mediante un vehículo a un

fraccionamiento. Cuando un auto llega a la vía de acceso el sensor de presencia detonará la

cámara de vídeo obteniendo la imagen de la placa del automóvil, estas placas deben ser claras y

visibles ya que si la placa está en mal estado no se garantiza el reconocimiento de dicha

matrícula; la imagen será analizada por un algoritmo, obteniendo la combinación alfanumérica

que representan la matrícula del vehículo; esta combinación será comparada con una base de

datos que almacena las matrículas autorizadas en el fraccionamiento y si la combinación

representativa de la placa está guardada en la base de datos, el automóvil estará autorizado para

acceder.

1.1. Problemática

Desde siempre, el hombre ha sentido la necesidad de tener seguridad tanto de su persona como de

sus pertenencias y por lo tanto ha desarrollado diversos sistemas que le permiten vivir con cierta

tranquilidad. No obstante, hoy en día la inseguridad es uno de los mayores problemas que

enfrenta la sociedad. El asalto, el secuestro, el allanamiento de morada y el robo de automóviles,

entre otros, ocupan los titulares de casi todos los medios de comunicación masiva.

El director general de la Asociación Mexicana de Instituciones de Seguros (AMIS), Ricardo

Arias, dijo que a nivel nacional se registró el robo total de 71 mil 565 Automóviles [1]. Para

disminuir lo más pronto estas cifras, el sistema será gratuito, por lo que cualquier persona

interesada en instalar su sistema de acceso vehicular tendrá que disponer de su propia cámara y

mecanismo de apertura, esto fortalecerá la seguridad en contra de los robos o asaltos efectuados

con gran frecuencia hoy en día.

Dentro de una amplia variedad de soluciones a esta problemática, están los mecanismos de

control de acceso de automóviles a fraccionamientos. Los sistemas de control de acceso vehicular

se implementan para tener el control de los vehículos que accedan y circulan por una zona

privada; y tienen como objetivo asegurar el paso a aquellos vehículos que están permitidos, ya

sea porque sus dueños viven en esa zona o bien porque son invitados de los mismos y

restringiendo a aquellos que no estén autorizados a pasar. Es decir se busca el control total, tanto

de los automóviles de los residentes como de los visitantes, para aumentar la seguridad del lugar

y tratar de evitar robos de automóviles, de personas y/o allanamientos de morada.

Existen diversos mecanismos de control, desde simples mecanismos hasta sofisticados sistemas

de reconocimiento de voz; tales como:

Barreras vehiculares que operan guardias de seguridad.

11

Barreras que operan de acuerdo a la proximidad del vehículo.

Sistemas de autenticación por medio de huella dactilar.

Sistemas de verificación mediante voz.

Sistemas biométricos

El problema relacionado con estos mecanismos y sistemas, ocurre en el momento en el que una

persona baja de su automóvil o baja la ventanilla para abrir la reja del zaguán en una unidad

habitacional ya que se expone más directamente a una situación de robo o asalto y puede estar

involucrada en un momento de inseguridad. Adicionalmente, la eficiencia de estos dependen

mucho del error humano, los guardias de seguridad y soluciones más sofisticadas resultan más

costosas para los usuarios lo que hace poco viable su implementación.

Una posible solución a la necesidad que tienen las personas de bajar de su automóvil o bajar la

ventanilla del mismo para ingresar en los fraccionamientos es el desarrollo de un sistema que

reconozca las placas de los automóviles y verifique si ese automóvil tiene permiso de acceder o

no. Para implementar este sistema se hará uso de algoritmos de reconocimiento de patrones que

permitan extraer las características más importantes de las placas y así analizarlas para dar

respuesta a la comparación de las permitidas con la previamente reconocida. El sistema deberá

ser capaz de dar una respuesta informando si se puede o no acceder a la zona privada.

Se hizo un análisis de los sistemas que se han desarrollado que tienen características similares

para poder determinar la conveniencia o no de este desarrollo.

1.2. Justificación

En la Ley de Seguridad Pública del Distrito Federal, Articulo 2° Inciso II dice: Proteger la

integridad física de las personas así como sus bienes [8].

Por tal motivo el desarrollo del sistema se apega a esta ley ayudando a proteger la integridad

física de las personas así como de sus bienes. Los posibles beneficiados son las personas que

viven en unidades habitacionales cerradas o en aquellos lugares en donde el acceso sea exclusivo

para personas que accedan por medio de un vehículo.

El desarrollo de este sistema es complejo debido al alto grado de fiabilidad que debe tener con

respecto a las placas que reconoce, estas placas pueden estar en condiciones no apropiadas, es

decir, con manchas, raspaduras y/o despintado. Dependiendo de las condiciones de la placa el

sistema debe poder analizarlo y autenticar si existe o no la placa que reconoce para así permitir o

no el acceso del vehículo. Para manejar esta complejidad se aplican conocimientos de

reconocimiento de patrones, matemáticas, electrónica e ingeniería de software.

12

1.3. Sistemas similares

Abraham Maslow define como una necesidad humana “la seguridad”. En el caso de esta

investigación se busca reducir el peligro al que está expuesto un conductor al llegar a su destino;

de esta forma esa persona tendrá seguridad.

Durante los últimos años, muchas personas han trabajado y desarrollado prototipos para mitigar

el peligro que acecha al conductor. Actualmente existen diversas aplicaciones y trabajos que se

relacionan con el proyecto a desarrollar y sirven como referencia para alcanzar los objetivos

establecidos, así como una visión más clara con la que un sistema de este tipo debe contar. Estos

sistemas se describen en la siguiente tabla:

SISTEMA CARACTERÍSTICAS PRECIO AL

PÚBLICO

Prototipo de Control de

acceso vehicular

empleando un sistema de

visión artificial con

Labview [2]

Sistema de visión artificial con LapView que utiliza como Hardware

CompactqDaq 9174 utilizando el módulo de entradas y salidas digitales

9403. Reconocimiento único de los caracteres de las placas vehiculares, la

respuesta la da mediante un algoritmo de toma de decisiones. Cámara Web que capta imágenes preestablecidas debido a la cámara de

poca resolución.

No aplica

SRACC [3] Cuenta con un pulsador para tomar foto al coche por lo que debe bajar la

ventana del automóvil. Condiciones de clima soleado seco. Reconoce matrículas del D.F. Desarrollado en el lenguaje de programación MATLAB. Utiliza redes neuronales.

No aplica

Sistema de control de

acceso vehicular mediante

Identificación por Radiofrecuencia [4]

Identificación de placas mediante tecnología por radiofrecuencia RIFD por

sus siglas en inglés. Desarrollado en JAVA y bases de datos MySQL Implementación costosa de la tecnología RIFD. La validación del sistema tarda pocos segundos. Utiliza tarjetas de proximidad CRX14, microcontrolador, transpoders

SRIX4K, antena y pluma de control de acceso.

No aplica

Paquete control de acceso Sistema que contiene las siguientes características: $ 168, 183.18

13

vehicular con

reconocimiento de placas

[5]

Software digifort LPR. Barrera WejoinSecupark. Lector de tarjetas. Cámaravivotek. Control de acceso. Sensor de masa. Fotoceldas Wejoin WJPJ101. Tag de PVC.

Barra de acceso LiftPRO

[6] • Soporta receptor RF modelo FJCWLESS. • Puede ser activada por medio de: botonera cableada (FJCTB), receptor

RF (FJCWLESS) y controles remotos (FJCREMOTE) y cualquier otro

sistema de control de acceso. • Para cierre automático de la barrera puede adicionar el detector magnético

FJCD621 y lazo magnético SYSLM4 o SYSLM6. • Incluye taquetes metálicos para la instalación.

$ 31, 014.31

Barrera Vehicular CAME

GARD4 [7]

Extensión de pluma para pasos de 4, 6 y 8 mts. Control electrónico del movimiento con detección del obstáculo (función

antiaplastamiento).

$ 29, 830.10

Sistema de control de

acceso vehicular mediante

verificación de placas

Software para el reconocimiento de placas vehiculares. Prototipo funcional (complemento al software).

$0.00

Tabla 1: sistemas similares

El sistema que se desarrollará no tendrá costo para el usuario porque se está proponiendo que sea

una aplicación de escritorio de acceso gratuito. Esto trae como beneficio que los inquilinos que

habitan en una unidad habitacional no dependan de un guardia de seguridad ya que estos pueden

llegar a tener mucha información de las personas que habitan ahí; y por descuido o

intencionalmente podrían compartir dicha información con personas que tengan malas

intenciones.

14

1.4. Objetivo

1.4.1. Objetivo general.

Desarrollar un sistema para el control del acceso vehicular mediante el reconocimiento de las

placas de los automóviles.

1.4.2. Objetivos específicos.

1. Establecer conexión entre una cámara digital y el sistema.

2. Desarrollar un algoritmo responsable de encontrar y aislar la matrícula en la imagen.

3. Desarrollar un algoritmo que pase a escala de grises la imagen.

4. Desarrollar el algoritmo de umbralización OTSU.

5. Desarrollar un algoritmo que encuentra los distintos caracteres presentes en la matrícula.

6. Desarrollar el algoritmo de los 7 momentos invariantes de Hu.

7. Desarrollar el algoritmo de entrenamiento del sistema.

8. Diseñar una base de datos.

9. Desarrollar un algoritmo clasificador.

10. Desarrollar un algoritmo que consulte el número de la placa con la base de datos

11. Desarrollar un algoritmo que decida si la placa de un vehículo pertenece a la unidad

habitacional

12. Desarrollar una interfaz gráfica.

15

2. Marco teórico

En esta sección se detallará la teoría de los componentes involucrados en el desarrollo del

sistema, como lo es el tratamiento digital de imágenes, reconocimiento de patrones,

reconocimiento óptico de caracteres, y la comunicación de un circuito electrónico con una

computadora.

2.1. Reconocimiento de patrones

2.1.1. Conceptos

El reconocimiento de patrones es una disciplina científica cuyo objetivo principal es la

clasificación de objetos en un determinado número de categorías o clases. Cada objeto posee

determinadas características que los distinguen y permiten ser diferenciados de otros, así mismo

esos rasgos les permiten ser clasificados en una clase.

Patrón: todo aquello que podemos percibir y puede ser descrito de forma cuantitativa,

cualitativa o estructural.

Rasgo: propiedad, factor o característica que describe un objeto de manera que podamos

estudiarlo más detalladamente.

Clase: conjunto de objetos que comparten características similares entre sí.

2.1.2. Aprendizaje

El aprendizaje es la forma en que los seres vivos adquieren conocimientos, extrayendo la

información del medio que los rodea, en el aspecto computacional, el aprendizaje se basa en

adquirir conocimientos a partir de datos analizados y tiene como fin mejorar el desempeño de los

programas en base a la experiencia.

Existen tres tipos de aprendizaje:

Supervisado: clasifican los objetos con base a las muestras clasificadas previamente, o en

conocimientos previamente adquiridos, además que se conocen de antemano las clases a

las que se asignarán los objetos.

No supervisado: no se conocen las clases, por lo que es necesario encontrar las clases de

las muestras que no han sido clasificadas.

Semi-supervisado: utilizan un conjunto pequeño de clases conocidas y un gran conjunto

de clases no conocidas [13].

16

2.1.3. Modelo de sistema de reconocimiento de patrones

La forma en que trabaja un sistema de reconocimiento de patrones está ejemplificado en la

siguiente ilustración:

Ilustración 1: modelo de sistema de reconocimiento de patrones

Sensor: su propósito es proporcionar una representación fiable de los elementos del universo a

ser clasificados. Es un sub-sistema crucial ya que determina los límites en el rendimiento de todo

el sistema.

Idealmente uno debería entender completamente las propiedades físicas que distinguen a los

elementos en las diferentes clases y usar ese conocimiento para diseñar el sensor, de manera que

esas propiedades pudieran ser medidas directamente. En la práctica frecuentemente esto es

imposible porque:

No se dispone de ese conocimiento

Muchas propiedades útiles no se pueden medir directamente (medición no intrusiva)

No es económicamente viable

Extractor de características: A partir del patrón de representación esta etapa se encarga de

extraer la información discriminatoria eliminando la información redundante e irrelevante. Su

principal propósito es reducir la dimensionalidad del problema de reconocimiento de patrones.

Clasificador: Es la etapa de toma de decisiones en el sistema. Su rol es asignar a la categoría

apropiada los patrones de clase desconocidas.

2.1.4. Clasificador

Después de realizar la etapa de selección y extracción de características es necesario analizar los

datos obtenidos, de tal forma que podamos asociar un objeto a una clase o categoría. El

clasificador será la herramienta o método que realizará la clasificación de los objetos de acuerdo

a las características de cada uno de ellos.

2.1.4.1. Tipos de clasificadores

17

De distancia mínima: realizan la clasificación en base a la distancia más corta de un

objeto a una clase

Probabilísticos: determina si un objeto pertenece a una clase basándose en la inferencia

probabilística de su pertenencia a ella.

Geométrico (clustering): los patrones deben ser graficables. Se emplea la geometría de

formas, vectores numéricos, etc.

Neuro-reticular: se utilizan redes neuronales, donde se emula el funcionamiento del

cerebro humano, para efectuar procesos sofisticados. Estas redes son un arreglo de

elementos de procesamiento donde sus elementos poseen un alto grado de

interconectividad.

2.1.4.1.1. Clasificador de distancia mínima

Este clasificador, probablemente, es el más utilizado en la literatura para clasificar patrones de

diferente tipo. Parte del hecho que las clases de patrones son linealmente separables. Se supone

que la pertenencia de cada patrón se conoce de antemano y que además se sabe el número de

clases en las cuales el patrón puede ser clasificado. Supóngase N clases Ci, i=1, 2, …, N,

personalizadas por N representantes: Zi, i=1, 2, …, N, un patrón de entrada x = {x1, x2, …, xn}T

será clasificado en la clase Ci, i = 1, 2, …, N cuando se cumpla la condición que:

argmin i d(x, Zi)

La distancia “d(x, Zi)” se calcula como se muestra en la siguiente tabla:

DISTANCIA FÓRMULA

Euclidiana

( ) [∑( )

]

Minkowski

( ) [∑( )

]

Dominante ( ) {| |} Tabla 2: distancias para clasificador

Donde “d(x, Zi)” es la distancia entre el vector de entrada “x” y cada uno de los representantes Zi,

i=1, 2, …, N de cada clase Ci, i=1, 2, …, N.

2.1.4.1.2. Clasificador de Bayes

18

El clasificador de Bayes, es de tipo probabilístico, solamente calcula la probabilidad de cada

hipótesis dados los datos, es decir, se realizan predicciones ponderadas en sus probabilidades, por

lo que el aprendizaje se reduce a las inferencias probabilísticas.

2.1.4.1.3. Árbol de decisión

Los árboles de decisión son una de las técnicas más usadas para la resolución de problemas en

inteligencia artificial, ya que son fáciles de comprender.

Un árbol de decisión es un modelo predictivo, el cual tiene como objetivo principal el aprendizaje

inductivo a partir de observaciones y construcciones lógicas. Un árbol se representa gráficamente

usando un conjunto de nodos, hojas y ramas. Existe un nodo principal o raíz, en ella se inicia el

proceso de clasificación.

Por ejemplo: ¿administrar fármaco “F”?

Ilustración 2: ejemplo de un árbol de decisión

Los nodos internos corresponden a las preguntas acerca del atributo en particular del problema.

Las ramas que salen de los nodos se etiquetan con los posibles valores que puede tomar el

atributo.

Los nodos finales o también llamados nodos hoja corresponden a una decisión.

2.1.4.1.4. K-NN

No

No

Bajo Bajo Alto

¿Presión arterial?

¿Azúcar en la sangre? ¿Índice de colesterol?

¿Alergia a antibióticos?

¿Otras alergias?

Alta

Alto

Si

Mediana

Si

Si No Si

Si

No Si

Si

Baja

19

Es un algoritmo de clasificación de aprendizaje supervisado, es decir aprende a partir de un

conjunto de clases conocidas. La notación utilizada por este algoritmo se puede observar en la

siguiente tabla:

X1 … Xj … Xn C

(x1,c1) 1 x11 … x1j … x1n c1

⁞ ⁞ ⁞ ⁞ ⁞

(xi,ci) i xi1 … xij … xin ci

⁞ ⁞ ⁞ ⁞ ⁞

(xN,cN) N xN1 … xNj … xNn cN

x N+1 xN+1,1 … xN+1,j … xN+1,n ?

Tabla 3: algoritmo K-NN

Donde N es el número de casos de entrada. Estos casos se caracterizan por n variables

predictoras, x1,…,xn y C una variable a predecir.

El algoritmo consiste en calcular distancias entre los casos ya clasificados y donde x sea el nuevo

caso a clasificar, se ordenan las distancias y se seleccionan los k casos más cercanos al nuevo

caso, asignándolo a la clase más frecuente entre los k objetos.

2.2. Tratamiento digital de imágenes

Las etapas del tratamiento digital de imágenes consiste principalmente en dos áreas: el

mejoramiento de la calidad de las imágenes digitales y el procesamiento de la información de la

imagen, de manera que puedan ser utilizados por la computadora para un objetivo específico.

El sistema a desarrollar está enfocado al tratamiento digital de la imagen, la cual se concentra en

las técnicas y procedimientos para extraer la información de la imagen de tal forma que pueda ser

interpretada por la computadora, de manera que pueda analizarla de manera sencilla.

Etapas principales del procesamiento digital de imágenes:

Procesos de bajo nivel: utilizan las operaciones como el pre-procesamiento de imagen

para reducir el ruido del contraste, y los filtros de enfoque.

Procesos de nivel medio: se aplican operaciones como segmentación, clasificación y

etiquetado de objetos, se extraen atributos como contornos, bordes e identidad de objetos

individuales.

Procesos de alto nivel: se obtiene un conjunto de objetos reconocidos, análisis de

imágenes y se realizan funciones cognitivas asociadas a los resultados [13].

20

2.2.1. Segmentación de imágenes

La segmentación es una de las etapas cruciales de cualquier sistema de análisis de imágenes,

tanto por las dificultades que conlleva como por la importancia de sus resultados. Básicamente, la

segmentación puede considerarse como la partición de una imagen, digamos f (x,y) en un

conjunto de regiones R no completa. En otras palabras, el objetivo fundamental de la

segmentación, en el proceso del análisis de imágenes, es el de separar los objetos de interés del

resto no relevante el cual es considerado como fondo.

En ocasiones la segmentación suele considerarse como un proceso de clasificación de los objetos

presentes en una imagen y también, en cierta medida, equivale a su reconocimiento puesto que

como consecuencia de la segmentación los diferentes objetos (entendidos como realizaciones

físicas de clases o patrones abstractos) se encuentran perfectamente ubicados dentro de la imagen

digital. El realizar dicha clasificación no es una tarea trivial. El nivel al que se lleva a cabo esta

subdivisión depende del problema a resolver y, por supuesto, de la imagen de entrada. Es por ello

que se han originado diferentes técnicas de segmentación. Hasta el presente no se tiene

conocimiento de una técnica única que pueda ser utilizada para segmentar cualquier tipo de

imagen. La segmentación termina cuando se satisfacen los intereses u objetivos de la aplicación.

De manera gráfica en la siguiente figura se representa el proceso de segmentación de una imagen

simple.

Ilustración 3: esquema que representa el proceso de segmentación

De dicha figura se aprecia que en virtud de la segmentación se ha pasado de una imagen digital

bruta, con toda su información en forma de los niveles de intensidad luminosa, a una imagen

mucho más simplificada en lo que deben de estar nítidamente distinguidos entre sí los diferentes

objetos existentes.

Segmentación

1

3

21

En general, los métodos clásicos de segmentación se pueden categorizar como se indica a

continuación:

Métodos basados en el umbralado a partir del histograma de la imagen: En este caso,

a partir del histograma de una imagen es posible obtener un umbral de comparación para

el agrupamiento de los píxeles.

Métodos basados en la detección de discontinuidades: En este caso, la imagen en

cuestión es dividida a partir de cambios bruscos de los niveles de grises.

Métodos basados en la propiedad de similitud de los valores de los niveles de grises:

En este caso se usan criterios de homogeneidad para la agrupación de los píxeles.

Métodos heurísticos de segmentación: Basan su operación en el conocimiento previo de

la imagen a segmentar y en la experiencia del observador, e incluyen en muchas ocasiones

los métodos supervisados de segmentación.

2.2.1.1. Métodos basados en el umbralado del histograma

El umbralado es uno de los métodos más antiguos para la segmentación de una imagen. Se puede

ver que una operación implica realizar comprobaciones frente a una función τ de la forma:

( ( ) ( ))

Donde f (x,y) es el nivel de gris en el punto (x,y) y p (x,y) representa alguna propiedad local de

este punto (por ejemplo, la media de los niveles de gris, la desviación estándar, en entropía, etc).

Definición de umbralado: Dado un conjunto N de números naturales sean (x,y) las coordenadas

espaciales de una imagen digitalizada, y sea G = {0,1,…,2B} un conjunto de números positivos

que representan los niveles de grises, donde B es el número de bits. Entonces se puede definir una

función de imagen como f: N x N G. La brillantez (nivel de gris) de un pixel con coordenadas

(x,y) se denota como f (x,y). Sea τ Є G un umbral y sea C = {c0, c1} un par de niveles de gris

binarios (c0, c1 Є G). El resultado de segmentar una función de imagen f (x,y) respecto al umbral

τ es la función binaria f τ: N x N C, tal que:

( ) { ( )

( )

Así los píxeles marcados con c0 podrían corresponder al fondo mientras que los marcados con c1

corresponden a los objetos. En este caso se dice que la imagen ha quedado binarizada.

2.2.1.1.1. El método de OTSU

El método de OTSU es una de las técnicas más utilizadas para la obtención automática del

umbral para la segmentación de una imagen. Este método se fundamenta en el llamado análisis

discriminante. En este caso, el umbral es considerado como el valor que permite la partición de la

22

imagen en dos clases C0 y C1 (es decir, el objeto y el fondo) por medio del nivel de gris u. O sea,

C0 = {0, 1,…, u} y C1 = {u+1, u+2,…, L-1}, donde L es el número de niveles de grises. Sean σw2,

σb2 y σT

2 la varianza dentro de la clase, la varianza entre clases y la varianza total

respectivamente. El umbral óptimo puede ser obtenido al maximizar cualquiera de las siguientes

funciones con respecto a u:

El umbral es seleccionado al maximizar la separación entre las clases a partir del histograma

resultante de la composición de los histogramas de las dos clases implicadas. En otras palabras,

en el caso de la primera medida, el objetivo consiste en maximizar el cociente entre la varianza

entre clases: σb2 con respecto a la varianza dentro de las clases: σw

2. Mientras mayor sea la

varianza entre las clases y menor la varianza dentro de ellas, mejor será la discriminación entre

los grupos presentes. Es lógico pensar que si dentro de los dos grupos, la varianza es pequeña

habrá mayor similitud dentro de ellos lo cual es lo deseado para la existencia de dichos grupos.

Antes de llevar a cabo un proceso de segmentación es recomendable disminuir o atenuar el ruido

existente en la imagen original, lo cual se logra a través de un preprocesamiento mediante el filtro

promedio o Gaussiano, al aplicar una de las propuestas descritas anteriormente.

2.2.1.2. Métodos basados en la formación de regiones

La segmentación de imágenes en regiones se basa en el agrupamiento de píxeles en zonas con

características similares. Para una región dada, en general, los píxeles pertenecen a un objeto

simple. A este conjunto de puntos conectados que pertenecen al mismo objeto se le llama región.

Los métodos de segmentación que pertenecen a esta categoría se pueden dividir en supervisados

y no supervisados. En el primer caso el observador determina el número de clases o regiones de

la imagen a segmentar. En el segundo caso, el método de segmentación adoptado debe ser capaz

de determinar, dado algún criterio, el número de regiones en las cuales la imagen debe ser

segmentada.

Estos últimos métodos, en general, son más complejos desde el punto de vista algorítmico y

computacional. Una definición importante de segmentación de una imagen en regiones es la que

aparece a continuación:

Sea R la representación en una región completa de una imagen. Se puede contemplar la

segmentación como un proceso que divide a R en n subregiones, R1, R2,…, Rm tal que:

) ⋃

23

)

)

) ( )

) ( )

Donde P(Ri) es una propiedad de los puntos del conjunto Ri y es el conjunto vacío.

La condición a) indica que la segmentación deber ser completa, o sea cada píxel debe pertenecer

a una región. La condición b) indica que los puntos de una región deben ser conexos. La

condición c) se refiere al hecho de que las regiones obtenidas son disjuntas. La condición d)

determina que todos los puntos que conforman una región satisfacen una misma propiedad.

Finalmente, la condición e) establece que las regiones Ri y Rj formarían una misma región.

2.2.1.2.1. Crecimiento de regiones por agrupamiento de píxeles

El crecimiento de regiones es un procedimiento que, acorde a algún criterio de similitud

seleccionado, agrupa a los píxeles dentro de regiones más grandes. El algoritmo comienza con un

conjunto de puntos generadores o semillas a partir de los cuales las regiones se irán creciendo. La

semilla no es más que un nivel de gris de un píxel en la imagen. Los píxeles semilla son

usualmente seleccionados por el usuario en forma supervisada. Se parte del hecho que al menos

una semilla debe existir para cada región. A estas semillas se les suele llamar también marcas. La

selección de las semillas o marcas se puede realizar también de forma automática a partir de los

picos del histograma de la imagen; sin embargo, esto no es una tarea fácil para el caso de

imágenes con bajo contraste y alto nivel de ruido.

Durante la ejecución de un algoritmo para el crecimiento de regiones, éstas se van formando bajo

ciertas propiedades de los píxeles, las cuales pueden ser: el color, el valor del nivel de gris, la

textura, la estadística, entre otras. Para ilustrar el procedimiento descrito obsérvese las figuras (a),

(b) y (c) de la siguiente ilustración.

24

Ilustración 4: ejemplo de crecimiento de regiones por agrupamiento de píxeles

En la figura (a) los números en el interior de las celdas representan los niveles de grises. Los

puntos con coordenadas (3,2), (3,4) y (3,6) son usados como semillas. Usando estos tres puntos

se generan tres regiones: la región R1 con semilla en el píxel (3,2), la región R2 con semilla en el

píxel (3,4) y la región R3 con semilla en el píxel (3,6). Las figuras (b) y (c) muestran los

resultados obtenidos para u=3 y u=7 (u=umbral) respectivamente.

Obsérvese en la figura (b) como para u=3 se generaron tres regiones. Sin embargo, para este

umbral hubo un punto que no quedó clasificado en ninguna región (el pixel con coordenadas

(6,6)) y, por tanto dicho pixel se considerará como ruido. Para un umbral con valor = 7 se

generan dos regiones y el punto con coordenadas (6,6) se incluye en una de ellas. Es por ello que

la selección adecuada del umbral es de suma importancia y depende del objetivo del observador.

2.2.1.3. Métodos de segmentación basados en la detección de discontinuidades

En esta sección se discuten los métodos más representativos para la segmentación de una imagen,

tomando como base las fronteras de las regiones en la imagen. Primero se hablará de puntos,

bordes y líneas. Enseguida se tratarán los métodos basados en el cálculo del gradiente para la

detección de estos elementos.

2.2.1.3.1. Detección de puntos, bordes y líneas

Un borde puede definirse como un cambio significativo en el valor de la intensidad de los píxeles

en una región de la imagen. En esta obra se consideran dos tipos de bordes: tipo escalón y tipo

rampa, en la siguiente figura se muestran los tipos de borde.

25

Ilustración 5: tipos de bordes

Se puede ver que el cambio en las características de la imagen, dentro de una región, permite

obtener una estructura semejante a la de un paso o escalón. Sin embargo, en el caso de imágenes

reales los bordes aparecen suavizados en dependencia de las condiciones de captación de la

escena. El proceso de detección de bordes o contorneado de una imagen consiste en determinar

cuáles píxeles deben ser considerados como elementos pertenecientes a bordes suaves y cuáles

no. El conocimiento de estos puntos permite la construcción de los bordes y por tanto la

delimitación de las fronteras de las diferentes regiones en una imagen. Durante el proceso de

detección de bordes se puede obtener la siguiente información:

Orientación local de los elementos del borde.

Intensidad de los elementos del borde, es decir, contraste en la brillantez entre regiones

vecinas.

Ancho de los elementos del borde (puesto que los bordes no son pasos ideales, estos en

general varían considerablemente en su ancho).

Colocación de la representación del borde (puesto que pueden tener más de un píxel de

ancho, es importante determinar dónde poner el punto del borde).

Polaridad del elemento del borde (cuál de las regiones es la más brillante).

Valor de gris del elemento del borde.

Valor de gris de las regiones del entorno.

2.2.1.3.2. Detección de bordes mediante el cálculo del gradiente

Es conocido que en forma analógica el operador del gradiente tiene la siguiente expresión:

( ) (

)

En el caso de trabajar con imágenes, esta expresión se toma de la siguiente forma:

(a) (b) (c)

26

( )

El gradiente de un vector indica la dirección de máxima variación de f en el punto (x,y).

En forma discreta este método es derivado de la diferencia horizontal y vertical entre los valores

de los píxeles. Esta diferencia se realiza entre las pendientes a lo largo de una línea en la imagen

acorde a las siguientes ecuaciones:

( ) ( ) ( )

( ) ( ) ( )

f (i-1,j-1) f (i-1,j) f (i-1,j+1)

f (i,j-1) f (i,j) f (i,j+1)

f (i+1,j-1) f (i+1,j) f (i+1,j+1) Tabla 4: entorno de un píxel

Por simplicidad computacional en el cálculo de la magnitud del gradiente digital, en lugar de

computar la raíz cuadrada de la suma de sus cuadrados de los gradientes parciales, se pueden usar

las siguientes aproximaciones:

( ) | ( )| | ( )| ( )

( ) (| ( )| | ( )|) ( )

Como se observa las formulaciones dadas por las expresiones (1) y (2) no producen un

aislamiento evidente de los bordes de las regiones, sino un acentuado de los mismos. Esto es útil

en muchas aplicaciones donde sea necesario resaltar los contornos de una o varias estructuras.

Para evidenciar los bordes normalmente se fija un umbral u. En este caso, aquellos píxeles cuya

magnitud sea superior al valor del umbral, son marcados como los píxeles tipo borde en la

imagen. La expresión que permite realizar esta operación es la siguiente:

( ) { ( )

( )

Donde L es el número de niveles de grises.

El valor de u se toma, en general, de forma “had hoc”, es decir, de acuerdo al objetivo de la

aplicación. Cómo fue puntualizado, si el valor del umbral u es muy grande, los bordes obtenidos

pueden resultar muy finos con algunas rupturas. Si por el contrario el valor de u se toma muy

pequeño, los bordes resultantes resultan ser gruesos, pudiéndose unir incluso entre ellos. Una

forma de evitar la obtención “had hoc” del umbral u, aunque consuma más tiempo

27

computacional, es combinando el método del gradiente con las técnicas estadísticas. Así por

ejemplo, el umbral podría ser calculado acorde a la siguiente expresión:

( ) ( ) ( )

Donde el parámetro k es un factor de atenuación o ganancia y son respectivamente la

varianza y la media en las zonas de análisis.

Para una imagen muy ruidosa, la varianza tiene un valor elevado y por tanto debe ser atenuada.

En esta situación al parámetro k se le debe asignar un valor menor que 1.0 para que pondere, en

la expresión (3), al primer término con respecto al segundo. Esto hace que el umbral sea menos

sensible al ruido. En el caso extremo, al parámetro k se le puede asignar el valor igual a cero del

cual resulta un método muy eficiente para la segmentación estricta (umbralado) de imágenes con

histograma bimodal. Si el valor del píxel central es mayor que la media se coloca una etiqueta en

la imagen de salida, digamos 255, si es menor o igual al de la media se pondrá otra, por ejemplo

0. Este algoritmo ofrece muy buenos resultados al trabajar con tamaños de ventanas grandes por

arriba de 9x9.

Otra forma de aislar los bordes es compararlos con dos umbrales, digamos u1 y u2. Para ello se

puede representar el histograma de la imagen del gradiente y obtener dos valores de umbral para

los cuales se asigne al borde: un valor dado, cuando el valor del gradiente sea inferior a los dos

umbrales y, el mismo valor del píxel, sí el valor del umbral se encuentre en el rango de los dos

umbrales [17].

2.3. Reconocimiento automático de número de placas

Hay cinco algoritmos que el software necesita para identificar una placa vehicular:

Algoritmo responsable de encontrar y aislar la matrícula en la imagen.

Algoritmo que compensa los ángulos que hacen que la matrícula parezca "torcida" y

ajusta las dimensiones al tamaño requerido.

Algoritmo que ajusta el brillo y el contraste de la imagen.

Algoritmo que encuentra los distintos caracteres presentes en la matrícula.

Algoritmo que hace reconocimiento óptico de caracteres [14].

2.4. Reconocimiento óptico de caracteres (OCR)

2.4.1. ¿Qué es el reconocimiento óptico de caracteres?

Digamos que usted quiere digitalizar un artículo de una revista como un contrato imprimido.

Usted puede pasar horas reescribiendo y después corrigiendo los errores. O puede convertir todos

28

materiales requeridos en formato digital en pocos minutos usando un escáner (o cámara digital) y

un software de Reconocimiento Óptico de Caracteres para manipular el texto del documento. Es

una tecnología que le permite convertir diferentes tipos de documentos, tales como documentos

en papel escaneados, PDF archivos o imágenes captadas por una cámara digital en datos con

opción de búsqueda y funcionalidad de editar [15].

2.4.2. ¿Qué hay detrás de la tecnología OCR?

Resolución: los archivos de alta resolución funcionan mejor. Por norma general, se recomienda

que cada línea de texto de los documentos tenga una altura de al menos 10 píxeles.

Orientación: solo se reconocen los documentos orientados con la cara correcta hacia arriba.

Calidad de imagen: las imágenes nítidas con iluminación regular y contraste claro funcionarán

mejor. Los borrones por el movimiento o por un enfoque incorrecto de la cámara reducirán la

calidad de la detección de texto [16].

29

3. Metodología

La metodología a implementar es Scrum ya que se tiene la idea general del sistema pero no se ha

determinado cómo hará el procesamiento digital de imágenes, por lo que es un proyecto

cambiante.

Scrum mantiene una revisión constante por parte de todo el equipo manteniendo a cada uno de

los integrantes informados sobre los cambios o actualizaciones del proyecto. En la ilustración se

puede observar las fases que sigue dicha metodología.

Debido a que el desarrollo de metodologías ágiles emplean entornos de incertidumbre e

inestabilidad de requisitos, no es conveniente predecir en las fases iniciales la arquitectura y el

diseño del sistema ya que las circunstancias obligan a remodelarlo con mucha frecuencia, en este

sentido Scrum permite la evolución sin degradar la calidad de la arquitectura que se generará

durante el desarrollo.

Scrum denomina “sprint” a cada iteración, cada sprint es planificado determinando los objetivos

y el trabajo a realizarse, al final de cada iteración se revisa mediante reuniones para así analizar y

revisar el incremento generado.

Básicamente Scrum requiere de una planificación inicial marcando los objetivos esperados y

priorizando los requisitos del sistema [11].

Idea Pila de

producto

Reunión de planeación Pila de sprint

Reunión diaria

Reunión de revisión

Reunión de retrospectiva

Incremento del producto

Ilustración 6: diagrama de la metodología SCRUM

30

3.1. SCRUM aplicado al sistema

En la ilustración 1 se pueden ver las fases que tiene un proyecto al usar la metodología SCRUM,

para este sistema sus fases son las siguientes:

3.1.1. Idea del sistema

Se realizará un sistema que sea capaz de controlar el acceso a un fraccionamiento mediante la

verificación de placas del automóvil.

3.1.2. Pila del producto

En la siguiente tabla se describen las “historias” o “actividades” que debe tener el sistema para

que sea funcional; se describe la idea pero no se detalla cómo se hará. La importancia nos dice la

prioridad de las actividades pero si la historia “1” tiene valor de 15 y la historia “3” un valor de

30, no quiere decir que sea el doble de importante, solo nos dice que la historia “3” es más

importante.

ID NOMBRE IMPORTANCIA

(10 A 150)

ESTIMACIÓN

INICIAL

(PUNTOS DE

HISTORIA)

CÓMO COMPROBARLO NOTAS

1 Visualizar la imagen

que muestra la cámara 15 10

Abrir la aplicación, ingresar IP de la cámara, oprimir el botón conectar y

visualizar lo que la cámara emite.

Necesita diagrama UML y una cámara conectada a una

red local

2

Agregar placa, para

que el vehículo del

inquilino este autorizado a entrar

50 5

En la aplicación, escoger la pestaña "administrador", escribir la contraseña

de administrador, llenar los campos que

solicita la aplicación, oprimir el botón agregar. El sistema indica si la placa se

agregó correctamente

Requiere diagrama de caso de uso y descripción del caso

de uso

3

Eliminar placa, para

que el vehículo del

inquilino no esté autorizado a entrar

30 5


de administrador, llenar los campos que

solicita la aplicación, oprimir el botón eliminar. El sistema indica si la placa

fue eliminada.


de uso

4 Modificar placas por si el inquilino cambia de

auto

40 5

En la aplicación, escoger la pestaña

"administrador", escribir la contraseña

de administrador, llenar los campos que solicita la aplicación, oprimir el botón

modificar. Seleccionar la forma de

modificar y el sistema indicará si la placa fue modificada.


de uso

31

5 Agregar placa para permitir visita de los

inquilinos

20 5


de administrador, llenar los campos que solicita la aplicación, oprimir el botón

agregar visita. El sistema indica si la

placa fue agregada.


de uso

6 Buscar placa 17 5

En la aplicación, escoger la pestaña

"administrador", oprimir el botón buscar y el sistema muestra las placas

que existen en la base de datos.

Requiere diagrama de caso

de uso y descripción del caso

de uso

7

Permitir la entrada al

vehículo del inquilino

cuando este frente a la entrada de la unidad

habitacional

100 90

Colocar el vehículo de un inquilino

frente a la puerta; si la puerta se abre, el sistema permitió la entrada

Necesita hardware de

comunicación con la

computadora, requiere algoritmo para el

reconocimiento de placas

vehiculares y requiere hardware para la apertura de

la puerta

7 a Ubicar la placa en la imagen

20 15 La subimagen solo debe contener la placa del vehículo

Necesita diagrama de flujo

7b Ajustar brillo y

contraste de la imagen 10 10

En la imagen resultante se ve

claramente las letras de la placa Necesita diagrama de flujo

7c

Programar algoritmo

que separa los

caracteres de la imagen

20 15 En cada subimagen se verá una carácter de la placa


7d Definir los “rasgos” de

la placa 10 10 No aplica No aplica

7e Programar algoritmo

de “Hu” 10 10

Al ingresar una imagen se obtiene el

vector característico de la imagen Necesita diagrama de flujo

7f

“Entrenar” el programa

para reconocer

caracteres

10 10 El programa muestra los valores de ajuste en la pestaña “Valores”


32

7g

Programar algoritmo

que determina si la

placa pertenece al

fraccionamiento

10 10

Antes de ingresar la imagen, buscar la

placa en la base de datos; y si existe el

programa dirá si la placa pertenece al

fraccionamiento.


7h Programar algoritmo que activa la puerta de

entrada

10 10

Cuando el programa verifica que la

placa pertenece al fraccionamiento,

emite la señal al microcontrolador y abre la puerta


8

Desarrollar una

alternativa por si el

sistema no reconoce la placa

10 30 --- ---

Tabla 5: pila de producto

En la tabla anterior se plantea la solución a la idea general del problema y la importancia que

tiene cada actividad.

3.1.3. Pila de sprint 1

Una “pila de sprint” aísla una pequeña parte de la pila de producto y al finalizar el sprint se

espera un incremento del sistema, el sprint se ejecuta cada 2 a 4 semanas. En la siguiente tabla se

muestra la pila de sprint 1:

Objetivo de sprint:

* Visualizar la imagen que muestra la

cámara

Pila de sprint:

* Diseñar interfaz gráfica

* Conectar cámara a través de Java

Media Framework (JMF)

Velocidad estimada:

* 10

Calendario:

* Periodo de sprint: 23/03/2015 a 06/04/2015

* Scrum diario: 8:30 a 9:00 en cubículo de oficina

* Demo de sprint: 06/04/2015, 22:30 en cuarto de

tareas

Tabla 6: pila de sprint 1

En este sprint se avanzará 10 puntos de historia.

33


En la siguiente tabla se muestran las siguientes actividades que se tomarán de la pila del producto

y puedan realizarse en 2 semanas.

Objetivo de sprint:

* Agregar y eliminar placas en el

sistema

Pila de sprint:

* Desarrollar algoritmo que permita

agregar placa de inquilino


eliminar placa de inquilino

Velocidad estimada:

* 10

Calendario:


* Scrum diario: 8:30 a 9:00 en cubículo de oficina


tareas






Objetivo de sprint:

* Agregar placa de visita y

modificar placas en el sistema

Pila de sprint:


agregar placa de visita del inquilino


modificar placa de inquilino

Velocidad estimada:

* 10

Calendario:


* Scrum diario: 8:30 a 9:00 en cubículo de

oficina


tareas



34




Objetivo de sprint:

* Buscar placa en el sistema

Pila de sprint:

* Desarrollar Algoritmo que

permita buscar una placa en el

sistema

Velocidad estimada:

* 5

Calendario:



oficina


tareas





y puedan realizarse en 1 semana.

Objetivo de sprint:

* Visualizar la imagen que muestra

la cámara

Pila de sprint:

* Diseñar interfaz gráfica

* Conectar cámara a través de Red

Local

Velocidad estimada:

* 10

Calendario:



oficina

* Demo de sprint: 24/09/2015, 20:30 en sala de TT



35




Objetivo de sprint:

* Ubicar la placa en la imagen

Pila de sprint:

* Realizar diagrama de flujo

* Programar el diagrama de flujo

Velocidad estimada:

* 15

Calendario:



oficina

* Demo de sprint: 02/10/2015, 20:30 en sala de TT






Objetivo de sprint:

* Ajustar brillo y contraste de la

imagen.

Pila de sprint:



Velocidad estimada:

* 10

Calendario:



oficina

* Demo de sprint: 10/10/2015, 20:30 en sala de

tareas



36




Objetivo de sprint:

*Separar los caracteres de la

imagen tomada a la placa vehicular

Pila de sprint:



Velocidad estimada:

* 15

Calendario:



oficina


tareas






Objetivo de sprint:

*Programar algoritmo de los

momentos invariantes de Hu

Pila de sprint:



Velocidad estimada:

* 10

Calendario:



oficina


tareas



37




Objetivo de sprint:

*Programar algoritmo de

entrenamiento

Pila de sprint:

* Programar algoritmo que

determine los representantes de

clase

* Programar algoritmo clasificador

Velocidad estimada:

* 10

Calendario:



oficina


tareas






Objetivo de sprint:

*Programar algoritmo de

comparación

Pila de sprint:

* Programar algoritmo que compara

la matrícula obtenida por el sistema

y la base de datos

Velocidad estimada:

* 10

Calendario:



oficina


tareas



38




Objetivo de sprint:

*Programar algoritmo que activa la

puerta de entrada

Pila de sprint:

* Programar algoritmo que manda

una señal de apertura al circuito

electrónico

Velocidad estimada:

* 10

Calendario:



oficina


tareas



39

4. Análisis del sistema

4.1. Estudio de factibilidad

Para el desarrollo de este trabajo es necesario realizar un estudio de factibilidad de programación

que se adapte a nuestras necesidades.

Para el estudio de factibilidad operativo se consideraron los siguientes aspectos:

CARACTERÍSTICAS JAVA C++ C#

PARADIGMA Orientado a objetos Orientado a objetos Orientado a objetos

MULTIMEDIA Java Media Framework

Simple and Fast

Multimedia Library

“SFML”

ActiveX Control

DISEÑADOR DE GUI Si No Si

CONOCIMIENTO 9 2 5 Tabla 18: estudio de factibilidad [software]

En la tabla 8 se muestra una comparación entre los posibles lenguajes a utilizar. Los lenguajes

propuestos manejan el paradigma orientado a objetos, esto nos ayuda a realizar una mejor

planeación de la programación usando patrones de diseño y las ventajas del paradigma.

Se consideró la experiencia del programador con cada uno de los lenguajes, ya que si no se tiene

conocimiento suficiente del lenguaje implica costos en tiempo para aprenderlo. Se tomó una

escala del 0 al 10 donde 0 implica un conocimiento nulo del lenguaje y 10 un conocimiento

bastante bueno.

CARACTERÍSTICAS ATMEGA PIC

IDE Orientado a objetos Orientado a objetos

LENGUAJE Ensamblador / C Ensamblador / C

8-PIN

COSTO 28-PIN

40-PIN

ATtiny13 ($32)

ATmega48 ($74)

ATmega32 ($129)

PIC12F629 ($38)

PIC16F628 ($92)

PIC18F452 ($130)

CONOCIMIENTO 9 7 Tabla 19: estudio de factibilidad [microcontrolador]

En la tabla 9 se muestra una comparación entre los microcontroladores a utilizar para la

comunicación de la computadora y el circuito electrónico. Se consideró elegir un

microcontrolador ATMEGA debido a que el precio con respecto al PIC es menor.

40

4.2. Análisis de costos

La siguiente tabla muestra el costo de los aspectos que se necesitan para desarrollar el sistema

ASPECTO COSTO TOTAL (1 AÑO)

Energía eléctrica $ 2,100.00

Transporte $ 5,760.00

Sueldo programador nivel Junior $ 60,000.00

IDE $ 0.00

Equipo de cómputo $ 7,000.00

1 Fototransistor $ 6.00

1 Fotodiodo $ 13.00

1 Compuerta NAND 74LS00 $ 7.00

1 Led $ 4.00

2 resistencias de 220 Ohms $ 5.00

1 resistencia de 4.7 KOhms $ 5.00

1 ATMEGA48 $ 67.00

1 cámara infrarroja $ 1,300.00

TOTAL $ 76,267.00 Tabla 20: análisis de costos

A pesar de que el sistema será gratis, el costo estimado del desarrollo es alto porque en los

sistemas similares se describió la barra de acceso LiftPRO y la Barrera Vehicular CAME

GARD4 que están por debajo del costo del proyecto.

4.3. Requerimientos no funcionales

Los requerimientos no funcionales determinan los aspectos que debe cumplir el sistema, pero no

son necesarios para que el sistema funcione. En la siguiente tabla se detallan los requerimientos

no funcionales del sistema.

No. Atributo de

calidad

Requerimiento no funcional

RNF1 Exactitud El sistema tardará a lo más 6 segundos para reconocer una placa.

RNF2 Interoperabilidad El sistema se conectará con un circuito externo para dar acceso al

vehículo, la conexión será con un microcontrolador ATMEGA.

RNF3 Interoperabilidad El sistema se conectará con una cámara de video para obtener la

imagen a procesar.

RNF4 Eficiencia La base de datos se desarrollará en archivos XML.

RNF5 Usabilidad El sistema será una aplicación de escritorio. Tabla 21: requerimientos no funcionales

Los requerimientos no funcionales son de gran importancia ya que hacen que el inquilino esté

satisfecho con el sistema, por ejemplo si el RNF1 no se cumpliera y el sistema tardará 10 minutos

en reconocer una placa vehicular, el inquilino diría que el sistema no sirve a pesar de hacer el

reconocimiento.

41

4.4. Requerimientos funcionales

Los requerimientos funcionales son los aspectos que forman la parte operativa del sistema, es

decir, son los aspectos que hacen que el sistema funcione. En la siguiente tabla se enlistan los

requerimientos funcionales del sistema.

No. Requerimiento Funcional

RF1 El sistema debe eliminar ruido de la imagen

RF2 El sistema debe ajustar el brillo de la imagen

RF3 El sistema debe obtener la ubicación de los caracteres de la imagen

RF4 El sistema hará un reconocimiento de los caracteres de la imagen

RF5 El sistema se conectará con una base de datos para comprobar la validez de la placa vehicular

RF6 El sistema determinará si una placa pertenece al fraccionamiento

RF7 El sistema mandará una señal al circuito externo indicando si debe permitir el acceso

RF8 El sistema verificará la autenticidad del administrador

RF9 El sistema podrá dar de alta una placa vehicular en la base de datos

RF10 El sistema podrá modificar una placa vehicular en la base de datos

RF11 El sistema podrá dar de baja una placa vehicular en la base de datos

RF12 El sistema agregará a lo más 2 placas por inquilino Tabla 22: requerimientos funcionales

Estos requerimientos son de vital importancia ya que si alguno de ellos falla, el sistema falla.

4.5. Análisis de riesgos

El riesgo es un evento a futuro que puede ocasionar un perjuicio generando pérdidas indeseables;

pueden afectar la calendarización o los recursos del proyecto.

El análisis y la gestión del riesgo son una serie de pasos que ayudan a un equipo de software a

comprender y manejar la incertidumbre. Un riesgo es un problema potencial: puede ocurrir o no.

Pero sin importar el resultado, en realidad es una buena idea identificarlo, evaluar la probabilidad

de que ocurra, estimar su impacto y establecer un plan de contingencia en caso de que el

problema se presente.

Para empezar a crear una gestión de riesgos se necesita reconocer que puede salir mal (Listado de

riesgos potenciales). A continuación se analiza cada riesgo para determinar la probabilidad de

que ocurrirá y el daño que causará si en efecto ocurre (listado de priorización de riesgos). Una

vez establecida esta información, se desarrolla un plan para gestionar aquellos riesgos con gran

probabilidad e impacto (planes de prevención y contingencia). Al final se realiza la supervisión

de riesgos (valoración de riesgos). Obteniendo estos datos se produce un plan de reducción,

supervisión y gestión del riesgo (RSGR).

42

4.5.1. Listado de riesgos potenciales

Para el proyecto descrito en el documento las cosas que pueden salir mal son las siguientes:

El hardware no es el adecuado para realizar las funciones que el sistema requiere.

Cambio excesivo de requerimientos.

El algoritmo de reconocimiento de patrones tiene un porcentaje de eficacia bajo.

El cable que conecta la cámara con la computadora se rompe.

La lluvia afecta en el reconocimiento de la imagen.

La oscuridad afecta la calidad de imagen.

En vez de una placa se utiliza un papel con una placa impresa.

4.5.2. Listado de priorización de riesgos

Al listado de riegos potenciales se les debe asignar una probabilidad de ocurrencia percibida; en

mi caso se estableció como escala los siguientes rangos:

“Muy bajo” es menor o igual que 10%

“Bajo” es de 10% a 25%

“Moderado” es de 25% a 50%

“Alto” es de 50% a 75%

“Muy alto es mayor a 75%

El listado de riesgos queda de la siguiente manera:

RIESGO PROBABILIDAD COSTO

El hardware no es el adecuado para

realizar las funciones que el

sistema requiere.

Muy bajo

Comprar una cámara de mejor resolución

$2,000

Comprar la electrónica adecuada $1,000.

Cambio excesivo de

requerimientos Bajo

El tiempo para terminar el proyecto se

prolongaría con cada cambio de

requerimientos.

El algoritmo de reconocimiento de

patrones tiene un porcentaje de

eficacia bajo

Moderado

De 3 a 4 semanas más en la entrega del

proyecto

El cable que conecta la cámara con

la computadora se rompe Muy bajo

Comprar un cable Ethernet $50

La lluvia afecta el reconocimiento

de la imagen Alto

El sistema no sería funcional cuando llueve

La oscuridad afecta la calidad de la

imagen Muy alto

El sistema solo funcionaría de noche

En vez de una placa se utiliza un

papel con una placa impresa Muy alto

El sistema no sería funcional

Tabla 23: listado de priorización de riesgos

43

4.5.3. Planes de prevención y contingencia

Los riesgos que se valoran son los que van de Moderado a Muy alto por lo que los dos primeros

riesgos no generan grandes repercusiones sobre el proyecto, estableciendo únicamente para los

demás riesgos el plan de contingencia:

RIESGO PLAN DE PREVENCIÓN

La oscuridad afecta la calidad de la

imagen

Se usará una cámara infrarroja y así obtener una visión nocturna.

En vez de una placa se utiliza un

papel con una placa impresa

La cámara infrarroja al emitir señales infrarrojas capta los bordes

de los objetos y los dibuja en la imagen, por lo que no se debe ver

ningún carácter impreso.

La lluvia afecta el reconocimiento

de la imagen

Se programará un filtro de ruido blanco que limpiará el ruido que

genera la lluvia en la imagen.

El algoritmo de reconocimiento de

patrones tiene un porcentaje de

eficacia bajo

Se estudiará la eficacia de al menos 3 algoritmos y su eficacia en

distintos proyectos, para usar el más efectivo en un proyecto

similar a éste. Tabla 24: plan de prevención y contingencia

4.6. Diagramas de casos de uso Los diagramas de casos de uso nos muestran gráficamente la interacción que tienen los distintos

actores con el sistema.

4.6.1. Actores

Administrador: persona encargada de gestionar las placas de los habitantes en la unidad

Inquilino: persona que vive en la unidad habitacional.

4.6.2. Diagramas

En la siguiente ilustración se muestra cómo interactúa el administrador con el sistema.

Ilustración 7: diagrama de casos de uso del administrador

Cada ovalo nos dice la operación que el sistema realiza para interactuar con el administrador.

Administrador

Agregar placa

Eliminar placa

Modificar placa

Buscar placa

44

En la siguiente ilustración se muestra cómo interactúa el inquilino con el sistema.

Ilustración 8: diagrama de casos de uso del inquilino

La etiqueta “include” nos indica que una vez terminado un proceso se hará inmediatamente el

proceso siguiente y “extends” indica que es opcional que se haga el siguiente proceso.

4.7. Casos de uso Un caso de uso es un proceso que llevará a cabo el sistema, en el diagrama de casos de uso se

identifican fácilmente ya que son los óvalos dentro del sistema.

A continuación se detallan los casos de uso del sistema.

4.7.1. CU-01 Iniciar sesión como administrador

En la siguiente tabla se definen los atributos para el caso de uso “iniciar sesión como

administrador”

Nombre de caso de uso CU-01 Iniciar sesión como administrador

Actores Administrador

Tipo Primario

Referencias Ninguno

Precondición Ninguno

Postcondición Mostrar interfaz gráfica para altas, bajas y modificaciones de placas.

Propósito Verificar que la persona tiene los permisos para hacer cambios en la base de datos

Resumen El administrador ingresa el password. Aprieta el botón de aceptar y si existe en la base de datos,

se le permitirá el acceso al sistema

Tabla 25: caso de uso CU-01

Inquilino

Reconocer placa

Decidir acceso

Abrir puerta

<<include>>

<<extends>>

45

Una vez definido el caso de uso, se traza la trayectoria que debe de llevar para su

ejecución, esta trayectoria es la ideal pero aun así se contemplan los errores o

trayectorias alternas que pueda tener el caso de uso.

4.7.1.1. Trayectorias de caso de uso

Trayectoria principal

1. El administrador selecciona la pestaña “administrador” en la pantalla principal IG-01.

2. El sistema muestra un cuadro de dialogo solicitando la contraseña.

3. El administrador ingresa la contraseña y oprime el botón (aceptar) [Trayectoria

A][Trayectoria B]

4. El sistema muestra la pantalla IG-02

Trayectoria alternativa A: El inquilino ingreso contraseña incorrecta

1. El sistema redirige a la pantalla principal IG-01

Trayectoria alternativa B: El inquilino oprimió el botón (cancelar)


4.7.2. CU-02 Agregar placa

En la siguiente tabla se define el caso de uso “Agregar placa”

Nombre de caso de uso CU-02 Agregar placa


Tipo Secundario

Referencias CU-01

Precondición El administrador solicitó dar de alta una placa

Postcondición La placa ingresada se guarda en la base de datos

Propósito Agregar registro de placa nueva en la base de datos

Resumen El administrador ingresar el número de placa nueva, oprime botón de agregar y el sistema le

informa si la operación fue exitosa o no


En este caso de uso se hace referencia al CU-01ya que para agregar una placa se tuvo que iniciar

sesión como administrador.

46



1. El administrador llena los campos con la información solicitada y oprime el botón

(agregar)

2. El sistema le indica al administrador si la placa fue agregada [Trayectoria C]


Trayectoria alternativa C: campos vacíos

1. El sistema le indica al administrador que algún campo está vacío y no agrega la placa.

4.7.3. CU-03 Eliminar placa

En la siguiente tabla se define el caso de uso “Eliminar placa”

Nombre de caso de uso CU-03 Eliminar placa


Tipo Secundario

Referencias CU-01

Precondición El administrador solicitó dar de baja una placa

Postcondición La placa ingresada se borra de la base de datos

Propósito Eliminar registro de placa en la base de datos

Resumen El administrador ingresar el número de placa a eliminar, oprime botón de eliminar y el sistema le

informa si la operación fue exitosa o no


En este caso de uso se hace referencia al CU-01ya que para eliminar una placa se tuvo que iniciar

sesión como administrador.




(eliminar)

2. El sistema le indica al administrador si la placa fue eliminada [Trayectoria D]


47

Trayectoria alternativa D: placa no encontrada

1. El sistema le indica al administrador que el número de placa no se encontró en el sistema.

4.7.4. CU-04 Modificar placa

En la siguiente tabla se define el caso de uso “Modificar placa”

Nombre de caso de uso CU-04 Modificar placa


Tipo Secundario

Referencias CU-01

Precondición El administrador solicitó modificar una placa, La placa se encontró en la base de datos

Postcondición Se guardan los nuevos valores de la placa ingresada en la base de datos

Propósito Modificar registro de una placa existente en la base de datos

Resumen El administrador ingresar el número de placa a modificar, el sistema despliega los campos con los

valores actuales, el administrador cambia los valores de los campos necesarios, oprime botón de

modificar y el sistema le informa si la operación fue exitosa o no


En este caso de uso se hace referencia al CU-01ya que para modificar una placa se tuvo que

iniciar sesión como administrador.




(modificar)

2. El sistema le indica al administrador si la placa fue modificada [Trayectoria E]


Trayectoria alternativa E: campos vacíos

1. El sistema le indica al administrador que algún campo está vacío y no modifica la placa.

48

4.7.5. CU-05 Reconocer placa

En la siguiente tabla se define el caso de uso “Reconocer placa”

Nombre de caso de uso CU-05 Reconocer placa

Actores Inquilino

Tipo Primario

Referencias Ninguna

Precondición El inquilino coloca su auto en la entrada de la unidad habitacional y detona la captura de la placa

Postcondición Decidir acceso del vehículo

Propósito Obtener cadena alfanumérica de la placa vehicular

Resumen El inquilino llega a la unidad habitacional, detonando la captura de la placa vehicular a través de

la cámara digital.


El nombre de este caso de uso hace referencia al proceso que se lleva a cabo mediante

programación para reconocer una placa.



1. El sistema obtiene imagen de la placa vehicular

2. El sistema obtiene la cadena de texto que representa la placa vehicular [Trayectoria F]

Trayectoria alternativa F: no se obtiene cadena de texto

1. El sistema obtiene una nueva imagen y hace de nuevo el punto 2 de la trayectoria

principal.

49

4.7.6. CU-06 Decidir acceso

En la siguiente tabla se define el caso de uso “Decidir acceso”

Nombre de caso de uso CU-06 Decidir acceso

Actores Inquilino

Tipo Secundario

Referencias CU-05

Precondición El sistema obtuvo la cadena de texto que representa la placa vehicular

Postcondición Abrir puerta

Propósito Obtener señal que determina si un vehículo entra a la unidad habitacional

Resumen El sistema verifica si la placa existe en la base de datos y notifica el resultado.


Una vez que se obtuvo la representación alfanumérica de la placa, se compara esa matricula con

la base de datos y en caso de existir permite el acceso, en caso contrario no lo deja entrar.



1. El sistema consulta si existe la placa en la base de datos

2. El sistema abre la puerta [Trayectoria G]

Trayectoria alternativa G: la placa no fue encontrada

1. El sistema notifica al inquilino que el acceso es denegado.

4.8. Reglas del negocio

Las reglas del negocio describen las políticas, reglas, normas y restricciones presentes en un

proyecto, siendo de vital importancia para alcanzar los objetivos del proyecto.

Se establecieron 5 reglas de negocio para el proyecto:

El sistema tardará a lo más 1.5 segundos para reconocer una placa.

El administrador es la única persona autorizada a gestionar las placas vehiculares.

El sistema solo agregará a lo más 2 placas vehiculares por inquilino.

El sistema guardará la información de sus inquilinos en archivos XML.

El sistema solo reconocerá la placa si está en el centro del paragolpes delantero.

Estas reglas se trasladan a programación dentro de un proceso en el sistema, haciendo notar que

la variable del número de placas por inquilino puede ser modificada dentro del programa.

50

4.8.1. Composición de una placa vehicular

Las placas para automóviles, autobuses, camiones, midibuses, remolques, convertidores (dolly) y

semirremolques, deben ser rectangulares con las siguientes dimensiones [12]:

Largo 300 mm

Ancho 150 mm

Tabla 31: composición de una placa vehicular

51

5. Diseño del sistema

5.1. Diagrama entidad-relación Un diagrama o modelo entidad-relación es una herramienta para el modelado de datos que

permite representar las entidades relevantes de un sistema de información así como sus

interrelaciones y propiedades. En la ilustración 6 se detalla el diagrama entidad-relación del

sistema.

Ilustración 9: diagrama entidad – relación

A simple vista podría decirse que el inquilino puede tener los carros que el quiera pero

recordando una de las reglas del negocio dice: “El sistema solo agregará a lo más 2 placas

vehiculares por inquilino”, por lo que la restricción estará en la programación.

5.2. Diagrama de base de datos En el diagrama de base de datos se muestra el diagrama entidad-relación con la diferencia de que

se detallan los tipos de datos de los atributos de cada entidad.

Ilustración 10: diagrama de base de datos

Ya que la relación es uno a muchos no se tiene que hacer la tabla “TIENE” solo se pasa la llave

primaria del inquilino como llave foránea.

INQUILINO

Placa varchar(10)

Nombre_s VARCHAR(85)

ApellidoPaterno VARCHAR(85)

ApellidoMaterno VARCHAR(85)

Edificio VARCHAR(5)

Departamento(5)

VISITA

Placa VARCHAR(10)

Nombre_s VARCHAR(85)

ApellidoPaterno VARCHAR(85)

ApellidoMaterno VARCHAR(85)

PlacaInquilino VARCHAR(10)

INQUILINO VISITA TIENE

Placa Placa

Edificio

Departamento

Nombre

Nombre_s Apellido

Paterno Apellido Materno

Nombre

Nombre_s Apellido

Paterno Apellido Materno

1 m

52

5.2. Diagrama de clases

Los elementos que componen un diagrama de clases son:

Clase.- Unidad básica que encapsula los atributos y métodos de un objeto.

Atributo.- Valor que toma un objeto, como color, cantidad, material, dimensión, etc.

Método.- Actividad que hace el objeto, como abrir, cerrar, buscar, cancelar, imprimir, etc.

El diagrama de clases muestra las clases del sistema y sus interrelaciones.

Ilustración 11: diagrama de clases

53

5.3. Interfaz gráfica

A continuación se muestra la pantalla principal del sistema.

Ilustración 12: pantalla principal IG-01

La pantalla principal del sistema muestra lo que la cámara capta que es el objetivo del sprint 1.

Al cambiar a la pestaña “administrador” el sistema solicita la contraseña de autenticación.

Ilustración 13: iniciar sesión como administrador

En caso de no saber la contraseña el sistema regresará a la pantalla principal.

Pero en caso de ser el administrador, el sistema permitirá ver la pantalla de gestión de placas.

54

Ilustración 14: gestión de placas vehiculares

En la ilustración 10 vemos todas las acciones que puede realizar el administrador (agregar,

modificar, buscar, eliminar y agregar invitado).

5.4. Diagrama de flujo del sistema El diagrama de flujo muestra paso a paso lo que el sistema hace desde el principio hasta el final

para reconocer una placa vehicular.

Ilustración 15: diagrama de flujo del sistema

En la ilustración 11 observamos de manera general las etapas que realiza el sistema.

5.5. Diseño de circuitos electrónicos

Para que el sistema funcione se requiere una conexión con un circuito externo el cual consta de 3

partes esenciales, la primera es el sensor de presencia para saber cuándo un coche está en la

Inicio

El inquilino sitúa

su auto frente a

la entrada

El sensor de

presencia captura

la imagen de la

placa del coche

El sistema procesa la

imagen obteniendo la

combinación alfanumérica

que representa la matrícula

del vehículo

El sistema compara la

matricula con la base de

datos de los inquilinos

La matrícula

está en la

base?

El sistema abre la puerta

El sistema indica

que no se

permite el

acceso

Fin

Si

No

55

entrada de la unidad habitacional y así llevar a cabo la captura de la imagen de las placas; la

segunda es la señal “verificación de placa” la cual está representada con un led, si el led enciende

indica que el sistema reconoció la placa vehicular y permite el acceso del vehículo a la unidad

habitacional; y la tercer parte es la comunicación serial con el software mediante un micro-

controlador.

Ilustración 16: diseño de circuito electrónico

Con el circuito mostrado en la ilustración 12 se podrá llevar a cabo la comunicación bidireccional

con el software, tanto para indicarle al sistema que debe hacer una captura de las placas como

para que el sistema le indique al circuito la apertura de la puerta al vehículo.

56

6. Implementación y pruebas

6.1. Conectividad con la cámara

La implementación del sistema se hizo basándose en la pila del producto. Desarrollando la

actividad uno de la pila del producto la interfaz gráfica queda de la siguiente manera:

Ilustración 17: conexión con cámara web

Pero cuando no hay luz, la imagen es muy oscura, haciendo que la toma entregue un patrón de

malas condiciones imposibilitando el análisis de la imagen.

Ilustración 18: conexión con cámara web sin luz

57

Para corregir el problema de la oscuridad se hace uso de una cámara infrarroja y se cambia la

interfaz, quedando cómo se muestra en la siguiente figura:

Ilustración 19: captura de cámara infrarroja

El código de la interfaz gráfica es el siguiente:

import javax.imageio.ImageIO;

import javax.swing.*;

import javax.swing.border.TitledBorder;

import javax.swing.event.ChangeEvent;

import javax.swing.event.ChangeListener;

import java.awt.event.*;

import java.awt.image.BufferedImage;

import java.awt.*;

import java.io.File;

public class GUI extends JFrame implements ActionListener, ChangeListener

{

private static final long serialVersionUID = 1L;

private JTabbedPane fichas;

private BufferedImage bufferImagen;

private JLabel vacio, textoIP, textoPlaca, textoNombreInquilino,

textoApellidoPaternoInquilino, textoApellidoMaternoInquilino, textoDepartamento,

textoEdificio, textoPlacaVisita, textoNombreVisita, textoApellidoPaternoVisita,

textoApellidoMaternoVisita, textoPlacaInquilino;

private JTextField ip, placa, nomInquilino, apPatInquilino, apMatInquilino, departamento,

edificio, placaVisita, nombreVisita, apPatVisita, apMatVisita, placaInquilino;

58

private JButton borrar,capturar, agregar, modificar, buscar, eliminar, agregarInvitado,

inicia, buscarVisita;

private JPanel panelGestion, panelGestionPlaca, panelAgregarInvitado, panelOpcVideo;

public JPanel panelContenedorVideo, panelVideo;

private XML gestionPlacas;

private ComCtoExt comunicacion;

private String IP;

PanelIm pan;

public GUI()

{

super("Reconocimiento de placas vehiculares");

this.setSize(700, 620);

this.setLocationRelativeTo(null);

iniciaComponentes();

this.setVisible(true);

this.setResizable(false);

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

}

public void iniciaComponentes()

{

fichas = new JTabbedPane();

vacio = new JLabel(" ");

textoIP = new JLabel("IP de la camara: ");

textoPlaca = new JLabel("Placa del inquilino: ");

textoNombreInquilino = new JLabel("Nombre (s) del inquilino: ");

textoApellidoPaternoInquilino = new JLabel("Apellido paterno: ");

textoApellidoMaternoInquilino = new JLabel("Apellido materno: ");

textoDepartamento = new JLabel("Departamento: ");

textoEdificio = new JLabel("Edificio: ");

textoPlacaVisita = new JLabel("Placa de visita: ");

textoNombreVisita = new JLabel("Nombre (s) de la visita: ");

textoApellidoPaternoVisita = new JLabel("Apellido paterno: ");

textoApellidoMaternoVisita = new JLabel("Apellido Materno: ");

textoPlacaInquilino = new JLabel("Placa del inquilino: ");

ip = new JTextField(10);

placa = new JTextField(5);

nomInquilino = new JTextField(15);

apPatInquilino = new JTextField(15);

apMatInquilino = new JTextField(15);

departamento = new JTextField(5);

edificio = new JTextField(5);

59

placaVisita = new JTextField(5);

nombreVisita = new JTextField(15);

apPatVisita = new JTextField(15);

apMatVisita = new JTextField(15);

placaInquilino = new JTextField(5);

capturar = new JButton("Capturar");

agregar = new JButton("Agregar");

modificar = new JButton("Modificar");

buscar = new JButton("Buscar");

eliminar = new JButton("Eliminar");

agregarInvitado = new JButton("Agregar");

inicia = new JButton("Iniciar");

buscarVisita = new JButton("Buscar");

borrar = new JButton("Recibir");

panelGestionPlaca = new JPanel();

panelAgregarInvitado = new JPanel();

panelVideo = new JPanel();

panelGestion = new JPanel();

panelOpcVideo = new JPanel();

panelGestionPlaca.setLayout(new GridLayout(4,4,10,50));

panelGestionPlaca.setBorder(BorderFactory.createTitledBorder(null, "Gestión de

placas", TitledBorder.DEFAULT_JUSTIFICATION, TitledBorder.DEFAULT_POSITION, new

Font("Dialogo", Font.BOLD, 16), new Color(0, 0, 200)));

panelGestionPlaca.add(textoPlaca);

panelGestionPlaca.add(placa);

panelGestionPlaca.add(textoNombreInquilino);

panelGestionPlaca.add(nomInquilino);

panelGestionPlaca.add(textoApellidoPaternoInquilino);

panelGestionPlaca.add(apPatInquilino);

panelGestionPlaca.add(textoApellidoMaternoInquilino);

panelGestionPlaca.add(apMatInquilino);

panelGestionPlaca.add(textoDepartamento);

panelGestionPlaca.add(departamento);

panelGestionPlaca.add(textoEdificio);

panelGestionPlaca.add(edificio);

panelGestionPlaca.add(agregar);

panelGestionPlaca.add(modificar);

panelGestionPlaca.add(buscar);

panelGestionPlaca.add(eliminar);

panelAgregarInvitado.setLayout(new GridLayout(3,4,10,80));

60

panelAgregarInvitado.setBorder(BorderFactory.createTitledBorder(null, "Agregar

invitado", TitledBorder.DEFAULT_JUSTIFICATION, TitledBorder.DEFAULT_POSITION,

new Font("Dialogo", Font.BOLD, 16), new Color(0, 0, 200)));

panelAgregarInvitado.add(textoPlacaVisita);

panelAgregarInvitado.add(placaVisita);

panelAgregarInvitado.add(textoNombreVisita);

panelAgregarInvitado.add(nombreVisita);

panelAgregarInvitado.add(textoApellidoPaternoVisita);

panelAgregarInvitado.add(apPatVisita);

panelAgregarInvitado.add(textoApellidoMaternoVisita);

panelAgregarInvitado.add(apMatVisita);

panelAgregarInvitado.add(textoPlacaInquilino);

panelAgregarInvitado.add(placaInquilino);

panelAgregarInvitado.add(agregarInvitado);

panelAgregarInvitado.add(buscarVisita);

panelOpcVideo.setLayout(new FlowLayout());

panelOpcVideo.add(textoIP);

panelOpcVideo.add(ip);

panelOpcVideo.add(inicia);

panelOpcVideo.add(capturar);

panelContenedorVideo = new JPanel();

panelVideo.setLayout(new BorderLayout());

panelVideo.setSize(new Dimension(400,400));

panelVideo.add(panelOpcVideo,BorderLayout.NORTH);

panelVideo.add(vacio,BorderLayout.WEST);

panelVideo.add(panelContenedorVideo,BorderLayout.CENTER);

panelGestion.setLayout(new GridLayout(2,1));

panelGestion.add(panelGestionPlaca);

panelGestion.add(panelAgregarInvitado);

fichas.addTab("Camara", panelVideo);

fichas.addTab("Administrador", panelGestion);

fichas.addChangeListener(this);

this.add(fichas);

gestionPlacas = new XML();

comunicacion = new ComCtoExt();

inicia.addActionListener(this);

capturar.addActionListener(this);

agregar.addActionListener(this);

modificar.addActionListener(this);

buscar.addActionListener(this);

eliminar.addActionListener(this);

61

agregarInvitado.addActionListener(this);

buscarVisita.addActionListener(this);

borrar.addActionListener(this);

}

public void botonIniciar()

{

String fi,co;

int fil,col;

IP = ip.getText();

String[] comIP=IP.split("\\.");

if(comIP.length==4)

{

if(Comunes.esNumero(comIP[0]) && Comunes.esNumero(comIP[1]) &&

Comunes.esNumero(comIP[2]) && Comunes.esNumero(comIP[3]))

{

pan = new PanelIm(IP,this);

Thread hilo = new Thread(pan);

hilo.start();

inicia.setEnabled(false);

}

else

{

JOptionPane.showMessageDialog(null, "Los componentes de la

direccion IP no son numeros");

}

}

else

{

JOptionPane.showMessageDialog(null, "No es una direccion IP");

}

}

public void botonCapturar()

{

BufferedImage b1 = new

BufferedImage(pan.getImage().getWidth(this),pan.getImage().getHeight(this),BufferedIm

age.TYPE_INT_RGB);

Graphics2D gra = b1.createGraphics();

gra.drawImage(pan.getImage(), 0, 0, b1.getWidth(), b1.getHeight(), this);

print(gra);

gra.dispose();

try

{

62

ImageIO.write(b1, "jpg", new File("Recursos/foto.jpg"));

}

catch(Exception e)

{

JOptionPane.showMessageDialog(null, "No se pudo crear la imagen");

}

}

public void botonAgregar()

{

String placaI,nomI,apPatI,apMatI,deptoI,edifI,msg;

placaI = placa.getText().toString();

nomI = nomInquilino.getText().toString();

apPatI = apPatInquilino.getText().toString();

apMatI = apMatInquilino.getText().toString();

deptoI = departamento.getText().toString();

edifI = edificio.getText().toString();

if(placaI.equals("")||nomI.equals("")||apPatI.equals("")||apMatI.equals("")||deptoI.equals("

")||edifI.equals(""))

{

JOptionPane.showMessageDialog(null, "Todos los campos deben estar

llenos");

}

else

{

msg = gestionPlacas.agregarPlaca(placaI, nomI, apPatI, apMatI, deptoI,

edifI);

JOptionPane.showMessageDialog(null, msg);

limpiarFormulario();

}

}

public void botonModificar()

{

String placaI,nomI,apPatI,apMatI,deptoI,edifI,msg,opc,placaN;

int op;


nomI = nomInquilino.getText().toString();

apPatI = apPatInquilino.getText().toString();

apMatI = apMatInquilino.getText().toString();

63

deptoI = departamento.getText().toString();

edifI = edificio.getText().toString();

if(placaI.equals("")||nomI.equals("")||apPatI.equals("")||apMatI.equals("")||deptoI.equals("

")||edifI.equals(""))

{


llenos");

}

else

{

opc = JOptionPane.showInputDialog("1.- Cambiar placa del inquilino\n2.-

Cambiar datos del inquilino conservando la placa\n3.- Salir\n\nIngresa numero");

op = Integer.parseInt(opc);

try

{

if(op==1)

{

placaN = JOptionPane.showInputDialog("Ingresa placa

nueva");//Validar

msg = gestionPlacas.modificarPlaca(placaI, placaN);


}

else if(op==2)

{

msg = gestionPlacas.modificarPlaca(placaI, nomI, apPatI,

apMatI, deptoI, edifI);


}

}

catch(Exception e)

{

JOptionPane.showMessageDialog(null, "Error: Dato ingresado no

es numero entero");

}


}

}

public void inquilinoEncontrado(NodoInquilino encontrado, JFrame GUIBusqueda)

{

GUIBusqueda.setVisible(false);

placa.setText(encontrado.getPlaca());

64

nomInquilino.setText(encontrado.getNombres());

apPatInquilino.setText(encontrado.getApellidoPaterno());

apMatInquilino.setText(encontrado.getApellidoMaterno());

departamento.setText(encontrado.getDepartamento());

edificio.setText(encontrado.getEdificio());

}

public void visitaEncontrada(NodoVisita encontrado, JFrame GUIBusqueda)

{

GUIBusqueda.setVisible(false);

placaVisita.setText(encontrado.getPlaca());

nombreVisita.setText(encontrado.getNombres());

apPatVisita.setText(encontrado.getApellidoPaterno());

apMatVisita.setText(encontrado.getApellidoMaterno());

placaInquilino.setText(encontrado.getPlacaInquilino());

}

public void botonBuscar()

{

InterfazBuscar datosBusqueda = new InterfazBuscar(this);

}

public void botonEliminar()

{

String placaI,msg;


if(placaI.equals(""))

{

JOptionPane.showMessageDialog(null, "El campo de la placa debe estar

lleno");

}

else

{

msg = gestionPlacas.eliminarPlaca(placaI);



}

}

public void botonAgregarInvitado()

{

String placaI,nomV,apPatV,apMatV,msg,placaV;

65

placaV = placaVisita.getText().toString();

placaI = placaInquilino.getText().toString();

nomV = nombreVisita.getText().toString();

apPatV = apPatVisita.getText().toString();

apMatV = apMatVisita.getText().toString();

if(placaV.equals("")||placaI.equals("")||nomV.equals("")||apPatV.equals("")||apMatV.equal

s(""))

{


llenos");

}

else

{

msg = gestionPlacas.agregarPlaca(placaV, nomV, apPatV, apMatV,

placaI);



}

}

public void limpiarFormulario()

{

placa.setText("");

nomInquilino.setText("");

apPatInquilino.setText("");

apMatInquilino.setText("");

departamento.setText("");

edificio.setText("");

placaVisita.setText("");

nombreVisita.setText("");

apPatVisita.setText("");

apMatVisita.setText("");

placaInquilino.setText("");

}

public void botonBuscarVisita()

{

@SuppressWarnings("unused")

66

InterfazBuscar datosBusqueda = new InterfazBuscar(this,1);

}

public void botonBorrarRS232()

{

comunicacion.recibir_enviar();

}

public void actionPerformed(ActionEvent click)

{

if(click.getSource()==inicia)

botonIniciar();

else if(click.getSource()==capturar)

botonCapturar();

else if(click.getSource()==agregar)

botonAgregar();

else if(click.getSource()==modificar)

botonModificar();

else if(click.getSource()==buscar)

botonBuscar();

else if(click.getSource()==eliminar)

botonEliminar();

else if(click.getSource()==agregarInvitado)

botonAgregarInvitado();

else if(click.getSource()==buscarVisita)

botonBuscarVisita();

else if(click.getSource()==borrar)

botonBorrarRS232();

}

public void stateChanged(ChangeEvent arg0)

{

int seleccion = fichas.getSelectedIndex();

if(seleccion == 1)

{

try

{

String contra = JOptionPane.showInputDialog("Contraseña");

if(!contra.equals("1234"))

fichas.setSelectedIndex(0);

}

catch(Exception e2)

{

67

fichas.setSelectedIndex(0);

}

}

}

public static class Comunes

{

@SuppressWarnings("unused")

private static boolean esNumero(String cadena)

{

try

{

Integer.parseInt(cadena);

return true;

}

catch(NumberFormatException e)

{

return false;

}

}

}

}

En este punto se puede ver la placa pero se presenta un nuevo problema, los rayos infrarrojos de

la cámara rebotan en la placa haciendo que no se puedan ver los caracteres de la imagen; para

solucionar este conflicto se arma un filtro casero con papel celofán rojo, éste filtro se coloca

encima del lente de la cámara esperando que los rayos infrarrojos se atenúen permitiéndonos ver

los caracteres de la placa; el resultado fue el siguiente:

Ilustración 20: captura de cámara infrarroja con celofán rojo

68

La imagen mejora bastante con el filtro de celofán rojo, por lo que se toman medidas de

diferentes automóviles incluyendo camionetas para observar el comportamiento de la cámara a

distancias reales.

Ilustración 21: medidas del auto más bajo

Ilustración 22: medidas del auto más alto

69

Ilustración 23: medidas de la camioneta más baja

Ilustración 24: medidas de la camioneta más alta

Se presentó un problema al probar la cámara con el infrarrojo activado, por las medidas, ángulos

y el material propio de la placa vuelve a brillar de manera que no permite el análisis de la imagen.

Ilustración 25: cámara infrarroja con medidas reales

Al colocar un objeto entre la cámara y la placa hacemos que los rayos infrarrojos se reflejen de

tal forma que no todos los rayos infrarrojos llegan a la placa y su luminosidad disminuye

considerablemente, cómo se muestra en las siguientes imágenes:

70

Ilustración 26: cámara infrarroja con obstáculo

Ilustración 27: cámara infrarroja con obstáculo 2

Ilustración 28: cámara infrarroja con obstáculo 3

Está es solución para visualizar la placa en la noche pero genera un gran inconveniente; qué al

obstaculizar la imagen se reduce la visión de la cámara a la mitad, por tal motivo los vehículos

que sus placas rebasen la mitad del campo de visión no podrán ser reconocidos, por lo que se

tomó la medida del suelo a la placa del vehículo de los autos más vendidos en México (2015),

siendo estos coches los que se muestran en la tabla siguiente:

71

Lugar Modelo Unidades Distancia (cm)

1 Chevrolet Aveo 23,090.00 45.5

2 Nissan Versa 19,122.00 45.5

3 Volkswagen Vento 18,305.00 50

4 Nissan Tsuru 16,451.00 45.5

5 Chevrolet Spark 15,367.00 45.5

6 Nissan March 14,222.00 46

7 Volkswagen Jetta 10,727.00 45.5

8 Nissan Sentra 10,137.00 40

9 Nissan Chasis Largo 9,010.00 50.5

10 Chevrolet Matiz 8,806.00 40 Tabla 32: vehículos más vendidos en Abril 2015

En la tabla anterior podemos ver que la distancia con mayor frecuencia es la de 45.5 cm, siendo

ésta medida la que el proyecto podrá identificar, cubriendo el 58.35% de los 10 autos más

vendidos en Abril 2015. Cómo trabajo a futuro se deberá contemplar el desarrollo de un

mecanismo capaz de determinar la altura de la placa colocando la cámara a esa altura.

6.2. Segmentación de imagen

Para encontrar las regiones de interés se hacen divisiones de cuadricula a la imagen, de tal forma

que solo algunos cuadros contengan la información a tratar. Los demás cuadros se despreciaran

ya que no contienen información útil.

La cantidad de filas y columnas en la cuadrícula se variaron desde 2 hasta que se encontró el

número que satisface la necesidad de contener la información útil.

Colocando la cámara a una distancia de la placa de 120 cm, 110 cm, 100 cm y 90 cm, se varió el

número de columnas hasta que se concluyó por medio de pruebas el número buscado.

Para una distancia de 120 cm entre la cámara y la placa se concluyó que el número de columnas

son 17 cómo se muestra en la siguiente figura:

72

Ilustración 29: división de columnas a 120 cm









73


Se toma como elección la distancia que mejor divide la placa siendo ésta la de 100 cm. Y se

procede a hacer lo mismo que las columnas pero ahora con las filas de tal manera que se obtenga

una subimagen en la cual se visualice únicamente la placa del vehículo; se concluyó que el

número de filas es 6.

Ilustración 33: división de filas a 100 cm

Está acción a parte de encontrar la región útil, nos segmenta los caracteres de la

placa vehicular, sin necesidad de un algoritmo de separación de caracteres,

simplemente se tomarían los 6 cuadros en donde se aloja cada carácter. Para el

ejemplo de la imagen anterior la región de interés queda de la siguiente manera:

Ilustración 34: Placa segmentada

En la ilustración 31 podemos ver la fila 3 de la columna 7 a la columna 12 de la

Ilustración 30, notando que es la región que necesitamos para el sistema.

74

El código que ayuda a segmentar la imagen es el siguiente:

public void paint(Graphics g)

{

super.paint(g);

int i, j, ofset = 50, fil=7, col=15, alto=imagen.getHeight(this),

ancho=imagen.getWidth(this);

g.drawImage(imagen, ofset, ofset, this);

g.setColor(new Color(0,0,255));

int columnas = ancho/col;

int filas = alto/fil;

for(i = 0; i <= fil; i++)

g.drawLine(ofset,i*filas+ofset, ancho+ofset, i*filas+ofset);

for(j = 0; j <= col; j++)

g.drawLine(j*columnas+ofset, ofset, j*columnas+ofset, alto+ofset);

}

6.3. Umbralizado

Haciendo uso del umbralizado OTSU en la placa obtenemos las siguientes imágenes:

76

Al finalizar el proceso del método OTSU la imagen ingresada queda binarizada y lista para la

extracción de características.

La clase OTSU se encarga de binarizar la imagen, su código es el siguiente:

import java.awt.Color;


import java.util.ArrayList;

public class OTSU

{

//Nivel gris es un valor entre 0 y 255

private static float[] probabilidad(BufferedImage imagen)

{

float probabilidades[] = new float[256];

int i,j,N,pixel;

Color c;

N = imagen.getHeight()*imagen.getWidth();

for(i=0; i<256; i++)

probabilidades[i]=0;

77

for(i=0; i<imagen.getHeight(); i++)

{

for(j=0; j<imagen.getWidth(); j++)

{

//convierto el valor del pixel a un valor entre 0 y 255

pixel = imagen.getRGB(j, i);

c = new Color(pixel);

//Como es una imagen en escala de grises no importa si el componente es

rojo, verde o azul

probabilidades[c.getGreen()] = probabilidades[c.getGreen()]+1;

}

}

for(i=0; i<256; i++)

probabilidades[i]=probabilidades[i]/N;

return probabilidades;

}

private static float omegaUno(float probabilidades[], int limiteNivelGris)

{

float suma=0;

int i;

//De 0 a t niveles de gris

for(i=0; i<=limiteNivelGris; i++)

suma = suma + probabilidades[i];

return suma;

}

private static float omegaDos(float probabilidades[], int limiteNivelGris)

{

float suma=0;

int i;

for(i=limiteNivelGris+1; i<256; i++)

suma = suma + probabilidades[i];

return suma;

}

private static ArrayList<Float> ClaseUno(float probabilidades[], int nivelGris, float omega1)

{

ArrayList<Float> clase1 = new ArrayList<Float>();

int i;

float aux;

for(i=0; i<=nivelGris; i++)

{

aux = probabilidades[i]/omega1;

clase1.add(aux);

}

78

return clase1;

}

private static ArrayList<Float> ClaseDos(float probabilidades[], int nivelGris, float omega2)

{

ArrayList<Float> clase2 = new ArrayList<Float>();

int i;

float aux;

for(i=nivelGris+1; i<256; i++)

{

aux = probabilidades[i]/omega2;

clase2.add(aux);

}

return clase2;

}

private static float mediaUno(float probabilidades[], int nivelGris, float omega1)

{

float media1=0;

int i;

if(omega1!=0)

{

for(i=0; i<=nivelGris; i++)

media1 = media1 + (i*probabilidades[i]/omega1);

}

return media1;

}

private static float mediaDos(float probabilidades[], int nivelGris, float omega2)

{

float media2=0;

int i;

if(omega2!=0)

{

for(i=nivelGris+1; i<256; i++)

media2 = media2 + (i*probabilidades[i]/omega2);

}

return media2;

}

private static float mediaTotal(int nivelGris, float omega1, float omega2, float media1, float

media2)

{

return (omega1*media1)+(omega2*media2);

}

79

private static float varianza(float probabilidades[], int nivelGris)

{

float omega1 = omegaUno(probabilidades,nivelGris);

float omega2 = omegaDos(probabilidades,nivelGris);

float media1 = mediaUno(probabilidades,nivelGris,omega1);

float media2 = mediaDos(probabilidades,nivelGris,omega2);

float mediaT = mediaTotal(nivelGris,omega1,omega2,media1,media2);

float pot1 = (float) Math.pow(media1-mediaT,2);

float pot2 = (float) Math.pow(media2-mediaT,2);

return (omega1*pot1)+(omega2*pot2);

}

public static int otsu(BufferedImage imagen)

{

float probabilidades[] = probabilidad(imagen);

float varianzas[] = new float[256];

float maximo;

int i,t;

varianzas[0] = varianza(probabilidades,0);

maximo = varianzas[0];

t=0;

for(i=1; i<256; i++)

{

varianzas[i] = varianza(probabilidades,i);

if(varianzas[i]>=maximo)

{

maximo = varianzas[i];

t=i;

}

}

for(i=0; i<256; i++)

System.out.println("var["+i+"]:"+varianzas[i]);

return t;

}

}

6.4. Extracción de características

Lo que se busca es tener un vector característico el cual determine de manera eficaz el valor de

una letra o número, por lo que se hace uso de los 7 momentos invariantes de Hu; y cómo

resultado de una placa se obtuvieron los siguientes resultados:

80

Placa vehicular a analizar

Momentos

de Hu

Momentos

de Hu

Momentos

de Hu

Momentos

de Hu

Momentos

de Hu

81

Una vez obtenidos los momentos invariantes de Hu se hace un listado de las letras con los valores

de Hu para determinar los rasgos que representaran a cada carácter.

El listado será con los 33 diferentes caracteres alfanuméricos normados por la Secretaría de

Economía en su NOM-131-SCFI-2004, números 3.2, 3.2.1, 3.2.2, en donde se especifica que el

número de identificación vehicular NIV (Placa) debe estar integrado por diecisiete caracteres,

seleccionados por el fabricante de los siguientes:

Alfanuméricos: A B C D E F G H J K L M N P R S T U V W X Y Z

Numéricos: 0 1 2 3 4 5 6 7 8 9

Por lo que el sistema será entrenado con 33 distintos caracteres.

La clase “MomentosDeHu” es la encargada de obtener el vector característico de la imagen

ingresada. Esta imagen ingresada tiene la peculiaridad de que el objeto a reconocer son “0” y el

fondo es uno “255”; el código es el siguiente:

import java.awt.Color;



public class MomentosDeHu

{

private static float m(int p, int q, int[][] imagen)

{

int i,j;

double m=0;

for(i=0; i<imagen.length; i++)

{

for(j=0; j<imagen[0].length; j++)

{

m = m + (Math.pow(i, p) * Math.pow(j, q) * imagen[i][j]);

}

}

return (float) m;

}

private static float mu(int p, int q, float x, float y, int[][] imagen)

Momentos

de Hu

82

{

int i,j;

double mu=0;

for(i=0; i<imagen.length; i++)

{

for(j=0; j<imagen[0].length; j++)

{

mu = mu + (Math.pow(i-x, p) * Math.pow(j-y, q) * imagen[i][j]);

}

}

return (float) mu;

}

private static int[][] convierteAUnos(BufferedImage imagen)

{

int im[][] = new int[imagen.getHeight()][imagen.getWidth()];

int i,j;

Color aux;

for(i=0; i<imagen.getHeight(); i++)

{

for(j=0; j<imagen.getWidth(); j++)

{

aux = new Color(imagen.getRGB(j, i));

if(aux.getBlue()==255)

im[i][j] = 0;

else im[i][j] = 1;

}

}

return im;

}

public static ArrayList<Float> vectorCaracteristico(BufferedImage imagen)

{

ArrayList<Float> vector = new ArrayList<Float>();

float x,y,phiActual;

int im[][];

float mu00, mu20, mu02, mu11, mu30, mu12, mu21, mu03;

float nu00, nu20, nu02, nu11, nu30, nu12, nu21, nu03;

im = convierteAUnos(imagen);

x = m(1,0,im)/m(0,0,im);

y = m(0,1,im)/m(0,0,im);

83

mu00 = mu(0,0,x,y,im);

mu20 = mu(2,0,x,y,im);

mu02 = mu(0,2,x,y,im);

mu11 = mu(1,1,x,y,im);

mu30 = mu(3,0,x,y,im);

mu12 = mu(1,2,x,y,im);

mu21 = mu(2,1,x,y,im);

mu03 = mu(0,3,x,y,im);

nu00 = (float) (mu00/Math.pow(mu00,((0+0)/2)+1));








//Phi1

phiActual = nu20+nu02;

vector.add(phiActual);

//Phi2

phiActual = (float)(Math.pow(nu20-nu02, 2) + (4 * Math.pow(nu11, 2)));


//Phi3

phiActual = (float)(Math.pow(nu30-(3*nu12), 2) + (3 * Math.pow(nu21-nu03,

2)));


//Phi4

phiActual = (float)(Math.pow(nu30+nu12, 2) + Math.pow(nu21+nu03, 2));


//Phi5

phiActual = (float)((nu30-3*nu12) * (nu30+nu12) * (Math.pow(nu30+nu12, 2) - 3

* Math.pow(nu21+nu03, 2)) + (3*nu21-nu03) * (nu21+nu03) * (3 * Math.pow(nu30+nu12,

2) - Math.pow(nu21+nu03, 2)));


//Phi6

phiActual = (float)((nu20-nu02) * (Math.pow(nu30+nu12, 2) - (nu21+nu03)) + 4

* nu11 * (nu30+nu12) * (nu21+nu03));


//Phi7

84

phiActual = (float)((3*nu21-nu30) * (nu30+nu12) * (Math.pow(nu30+nu12, 2) - 3

* Math.pow(nu21+nu03, 2)) + (3*nu12-nu30) * (nu21+nu03) * (3 * Math.pow(nu30+nu12, 2) -

Math.pow(nu21+nu03, 2)));


return vector;

}

}

El listado debe ser muy parecido a como se muestra en la siguiente tabla:

Carácter Hu[0] Hu[1] Hu[2] Hu[3] Hu[4] Hu[5] Hu[6]

0 0.50087184 0.08338678 1.3953158 0.22291896 0.028536 -0.0225 -0.12101

1 0.6374464 0.35811114 3.1058395 1.0753286 1.946938 0.63923 -0.26711

2 0.5730092 0.1937591 2.7764597 2.991378 8.62083 1.28248 -0.03493

3 0.49795482 0.06730094 1.356645 2.6469855 4.039336 -0.467 2.973947

4 0.31934872 0.028446164 2.9411118 0.1271784 0.024273 -0.0068 -0.0739

5 0.6664881 0.23523621 1.9689263 1.3001914 2.072467 0.61433 -0.18034

6 0.3374156 0.03692153 1.9891704 0.29729438 0.084852 0.01966 0.212292

7 0.85578287 0.36719176 6.917794 25.63998 340.2705 11.6674 28.66936

8 0.3356613 0.0411801 3.5632517 3.0622268 9.906353 0.52429 -2.04541

9 0.3329018 0.038919766 1.9313223 0.2808322 0.132723 0.03226 0.158619

A 0.35445648 0.062675685 1.3177928 0.008762863 -7.74E-04 0.00206 -5.37E-04

B 0.3612862 0.055391427 0.37371305 0.42128906 0.165958 0.07545 0.020035

C 0.6892669 0.19304295 3.4495971 2.8310578 -7.45897 -0.9998 -4.75787

D 0.4746565 0.091795884 1.1364069 0.2725987 0.136746 0.04498 0.065732

F 0.6141951 0.264926 22.98991 4.948064 35.43237 1.47339 -39.1109

G 0.491167 0.108664535 4.915788 2.6929152 8.887837 0.59242 4.123606

H 0.3928454 0.030924933 0.006743655 0.10312833 0.002023 0.01811 0.001818

J 0.5950386 0.25404927 16.920773 2.293323 -3.6767 -0.2701 -13.8047

L 0.77583313 0.4169833 70.69413 18.203732 552.4641 9.04685 348.1812

M 0.26397172 0.016384855 0.03575832 0.057538036 1.49E-05 0.00735 -0.00261

N 0.27176225 0.019738225 0.013929789 0.003044901 -2.77E-06 1.80E-04 -1.96E-05

P 0.38612068 0.048150267 7.8942976 1.3838526 4.505151 0.29623 0.790344

R 0.58331966 0.118546434 1.0301155 1.5312951 1.699097 0.25804 0.901046

S 0.65309745 0.2610224 17.587933 10.805343 148.9572 5.50726 0.61494

T 0.8643054 0.4026193 133.62584 19.988672 -41.8841 2.01457 1032.2

U 0.5397741 0.11237686 2.0339537 1.954244 3.776235 0.59382 -0.95929

V 0.34312153 0.052090097 4.849162 0.11611578 0.083881 0.0252 0.023573

X 0.43612242 0.102056086 0.003951191 0.26530197 0.008522 0.08204 0.001077

Y 0.6321448 0.2527956 9.644733 0.8059883 -1.3232 0.36512 -1.8163

Z 0.67994905 0.31456044 0.43046156 0.66164935 0.346175 0.37107 -0.06964 Tabla 33: momentos de Hu de los caracteres

Con la tabla anterior podemos determinar los 3 momentos de Hu que nos ayudaran a la

separabilidad de los caracteres.

85

6.3. Entrenamiento

Se guardó en un archivo de texto los momentos de Hu (0,1 y 6) de cada carácter y poniendo la

letra en un principio para identificar a que carácter nos referimos, por ejemplo:

0 0.50087184 0.08338678 -0.12101

1 0.6374464 0.35811114 -0.26711

1 0.6434364 0.35815414 -0.26711

1 0.6214574 0.35811784 -0.26711

2 0.5730092 0.1937591 -0.03493

3 0.49795482 0.06730094 2.973947 Tabla 34: archivo "entrenamiento.txt"

El entrenamiento se hace obteniendo los representantes de cada clase (carácter) de la siguiente

manera:

[(

)] (

)

[(

) (

) (

)] (

)

[(

)] (

)

Archivo “representantes.txt”

Con cada clase se hace un promedio para obtener el representante y a la hora de evaluar un

carácter nuevo recurrimos a la distancia Euclidiana, obteniendo la distancia del carácter nuevo

con todos los representantes de clase.

( ) [∑( )

]

La idea es que al obtener todas las distancias el carácter se asignara a la clase con la menor

distancia entre su representante.

86

6.4. Conectividad con el circuito

Una vez obtenida la cadena alfanumérica de la placa y compararla con la base de datos,

determinando que la placa del inquilino existe, el código que envía la señal de acceso al circuito

es el siguiente:

import java.util.List;

import javax.swing.JOptionPane;

import giovynet.nativelink.SerialPort;

import giovynet.permissions.Info;

import giovynet.serial.Baud;

import giovynet.serial.Com;

import giovynet.serial.Parameters;

public class ComCtoExt

{

public ComCtoExt()

{

}

public void recibir_enviar()

{

try

{

SerialPort serialPort = new SerialPort();

List<String> puertosLibres = serialPort.getFreeSerialPort();

if(puertosLibres.size()>0)

{

//Si hay puertos libres

Parameters parameters = new Parameters(); //Creo

un objeto de parametros

parameters.setPort("COM3");

//asigno el puerto COM5

parameters.setBaudRate(Baud._9600);

//asigno el baud rate

parameters.setByteSize("8");

//asigno bits de comunicacion

parameters.setParity("N");

//asigno paridad

Com com = new Com(parameters);

//creo la comunicacion con los parametros

//Recibo y envio datos

int datoRecibido = com.receiveSingleCharAsInteger();

System.out.println("Dato: "+datoRecibido);

87

if(datoRecibido==103)

//103 = $67

{

JOptionPane.showMessageDialog(null,"Dato recibido: "+datoRecibido);

Thread.sleep(200);

//com.sendSingleData(240);

//240 = $F0

//JOptionPane.showMessageDialog(null,"Enviando $F0");

//Thread.sleep(200);

}

else

{

System.out.println("Termina transmision");

}

com.sendSingleData(240);

//240 = $F0

JOptionPane.showMessageDialog(null,"Enviando $F0");

Thread.sleep(200);

com.close();

}

else

{

System.out.println("No hay puertos libres");

}

for(String free: puertosLibres)

{

System.out.println(free);

}

}

catch(Exception e)

{

System.out.println("Error al cargar");

}

}

}

88

6.5. Gestión de placas vehiculares

Por su simplicidad la base de datos se guardó en un archivo XML, teniendo como necesidad un

gestor del archivo, este mecanismo se programa en la clase XML de la siguiente manera:

import java.io.File;

import java.io.FileWriter;

import java.io.IOException;


import java.util.List;

import org.jdom2.Document;

import org.jdom2.Element;

import org.jdom2.JDOMException;

import org.jdom2.input.SAXBuilder;

import org.jdom2.output.Format;

import org.jdom2.output.XMLOutputter;

public class XML

{

public XML()

{

}

public String modificarPlaca(String matricula, String nom, String apPaterno, String

apMaterno, String depto, String edif)

{

String msg="";

List<Element> listaInquilinos=null;

if(!buscarPlaca(matricula).isEmpty())

{

try {

int i,bandera=0;

Element elementoSistema = ((Document) (new

SAXBuilder()).build(new File("Recursos/inquilinos.xml"))).getRootElement();

listaInquilinos =

elementoSistema.getChildren().get(0).getChildren();

if(!(listaInquilinos==null))

{

for(i=0; i<listaInquilinos.size(); i++)

89

{

if(matricula.equals(listaInquilinos.get(i).getChildren().get(0).getText()))

{

listaInquilinos.get(i).getChildren().get(1).removeContent(0);

listaInquilinos.get(i).getChildren().get(1).addContent(nom);


listaInquilinos.get(i).getChildren().get(2).addContent(apPaterno);


listaInquilinos.get(i).getChildren().get(3).addContent(apMaterno);


listaInquilinos.get(i).getChildren().get(4).addContent(depto);


listaInquilinos.get(i).getChildren().get(5).addContent(edif);

bandera=1;

break;

}

}

if(bandera==1)

{

String primerNodo = (new

XMLOutputter(Format.getPrettyFormat())).outputString(elementoSistema.getDocument());

try {

FileWriter fichero = new FileWriter("Recursos/inquilinos.xml");

fichero.write(primerNodo);

fichero.close();

msg = "La placa se modifico";

}

catch(Exception g)

{

msg = "Error al escribir el archivo: modificarPlaca()";

}

}

else {

msg = "La placa no se modifico";

}}

}

catch(JDOMException e)

{

msg = "Error en la estructura del archivo: buscarPlaca()";

}

catch(IOException f)

{

90

msg = "Error al leer archivo: buscarPlaca()";

}}

else {

msg = "No se pudo modificar la matricula";

}

return msg;

}

public String modificarPlaca(String matriculaVieja, String matriculaNueva)

{


String msg = "";

if(!buscarPlaca(matriculaVieja).isEmpty())

{

try {

int i,bandera=0;



listaInquilinos =



{


{

if(matriculaVieja.equals(listaInquilinos.get(i).getChildren().get(0).getText()))

{


listaInquilinos.get(i).getChildren().get(0).addContent(matriculaNueva);

bandera=1;

break;

}

}

if(bandera==1)

{



try

91

{

FileWriter fichero = new

FileWriter("Recursos/inquilinos.xml");


fichero.close();

msg = "La placa se modifico";

}

catch(Exception g)

{

msg = "Error al escribir el archivo:

modificarPlaca()";

}

}

else {

msg = "La placa no se modifico";

}

}

}


{

msg = "Error en la estructura del archivo: buscarPlaca()";

}


{

msg = "Error al leer archivo: buscarPlaca()";

}

}

else {

msg = "No se pudo modificar la matricula";

}

return msg;

}

public String agregarPlaca(String sPlaca,String sNombre_s,String sApPat,String

sApMat,String sPlacaInquilino)

{

String msg = "";

if(!buscarPlaca(sPlacaInquilino).isEmpty())

{

File archivo = new File("Recursos/inquilinos.xml");

if(archivo.exists())

{

try

92

{


SAXBuilder()).build(archivo)).getRootElement();

Element visita = new Element("visita");

Element placa = new Element("placa");

placa.addContent(sPlaca);

visita.addContent(placa);

Element nombres = new Element("nombre_s");

nombres.addContent(sNombre_s);

visita.addContent(nombres);

Element apPat = new Element("apellido_paterno");

apPat.addContent(sApPat);

visita.addContent(apPat);

Element apMat = new Element("apellido_materno");

apMat.addContent(sApMat);

visita.addContent(apMat);

Element placaInquilino = new Element("placa_inquilino");

placaInquilino.addContent(sPlacaInquilino);

visita.addContent(placaInquilino);

elementoSistema.getChildren().get(1).addContent(visita);



try {




fichero.close();

msg = "Placa agregada";

}

catch(Exception g)

{

msg = "Error al escribir el archivo: agregarPlaca()";

}

}


{

msg = "Error en la estructura del archivo: agregarPlaca()";

}

93


{

msg = "\n\nError al leer el archivo: agregarPlaca()";

}

}

else {

Document doc = new Document();

Element sistema = new Element("sistema");

doc.setRootElement(sistema);

Element inquilinos = new Element("inquilinos");

sistema.addContent(inquilinos);

Element visitas = new Element("visitas");

sistema.addContent(visitas);

Element visita = new Element("visita");

visitas.addContent(visita);



visita.addContent(placa);



visita.addContent(nombres);



visita.addContent(apPat);



visita.addContent(apMat);

Element placaInquilino = new Element("placa_inquilino");

placaInquilino.addContent(sPlacaInquilino);

visita.addContent(placaInquilino);


XMLOutputter(Format.getPrettyFormat())).outputString(doc);

try {



94


fichero.close();


}

catch(Exception g)

{


}

}

}

else {

msg = "La placa del inquilino no existe";

}

return msg;

}

public String agregarPlaca(String sPlaca,String sNombre_s,String sApPat,String

sApMat,String sDepto, String sEdif)

{

File archivo = new File("Recursos/inquilinos.xml");

String msg = "";

if(buscarPlaca(sPlaca).isEmpty())

{

if(archivo.exists())

{

try {


SAXBuilder()).build(archivo)).getRootElement();

Element inquilino = new Element("inquilino");



inquilino.addContent(placa);



inquilino.addContent(nombres);



inquilino.addContent(apPat);

95



inquilino.addContent(apMat);

Element depto = new Element("departamento");

depto.addContent(sDepto);

inquilino.addContent(depto);

Element edif = new Element("edificio");

edif.addContent(sEdif);

inquilino.addContent(edif);

elementoSistema.getChildren().get(0).addContent(inquilino);



try {




fichero.close();


}

catch(Exception g)

{


}

}


{

msg = "Error en la estructura del archivo: agregarPlaca()";

}


{

msg = "Error al leer el archivo: agregarPlaca()";

}

}

else {

Document doc = new Document();

Element sistema = new Element("sistema");

doc.setRootElement(sistema);

96

Element inquilinos = new Element("inquilinos");

sistema.addContent(inquilinos);

Element visitas = new Element("visitas");

sistema.addContent(visitas);

Element inquilino = new Element("inquilino");

inquilinos.addContent(inquilino);



inquilino.addContent(placa);



inquilino.addContent(nombres);



inquilino.addContent(apPat);



inquilino.addContent(apMat);

Element depto = new Element("departamento");

depto.addContent(sDepto);

inquilino.addContent(depto);

Element edif = new Element("edificio");

edif.addContent(sEdif);

inquilino.addContent(edif);


XMLOutputter(Format.getPrettyFormat())).outputString(doc);

try {




fichero.close();


}

catch(Exception g)

{


}

97

}

}

else {

msg = "La placa ya existe";

}

return msg;

}

public List<String> buscarPlaca(String matricula)

{

List<String> elementos = new ArrayList<String>();

List<Element> listaInquilinos = null;

try {

int i,bandera=0;

Element elementoSistema = ((Document) (new SAXBuilder()).build(new

File("Recursos/inquilinos.xml"))).getRootElement();

listaInquilinos = elementoSistema.getChildren().get(0).getChildren();


{


{


{

elementos.add(listaInquilinos.get(i).getChildren().get(0).getText());






bandera=1;

break;

}

}

if(bandera==1)

{

98

System.out.println("La placa si existe");

}

}

}


{

System.out.println("Error en la estructura del archivo: buscarPlaca()");

}


{

System.out.println("Error al leer archivo: buscarPlaca()");

}

if(elementos.isEmpty())

System.out.println("No se encontro la placa");

return elementos;

}

public List<NodoInquilino> buscarPlacaInquilino()

{

List<NodoInquilino> elementos = new ArrayList<NodoInquilino>();

List<Element> listaInquilinos = null;

NodoInquilino actual = new NodoInquilino();

try {

int i;



listaInquilinos = elementoSistema.getChildren().get(0).getChildren();


{


{

actual = new NodoInquilino();

actual.setPlaca(listaInquilinos.get(i).getChildren().get(0).getText());

actual.setNombres(listaInquilinos.get(i).getChildren().get(1).getText());

actual.setApellidoPaterno(listaInquilinos.get(i).getChildren().get(2).getText());

actual.setApellidoMaterno(listaInquilinos.get(i).getChildren().get(3).getText());

99

actual.setDepartamento(listaInquilinos.get(i).getChildren().get(4).getText());

actual.setEdificio(listaInquilinos.get(i).getChildren().get(5).getText());

elementos.add(actual);

}

}

}


{

System.out.println("Error en la estructura del archivo: XML-

buscarPlacaInquilino()");

}


{

System.out.println("Error al leer archivo: XML-buscarPlacaInquilino()");

}


System.out.println("No hay informacion para mostrar");

return elementos;

}

public List<NodoVisita> buscarPlacaVisita()

{

List<NodoVisita> elementos = new ArrayList<NodoVisita>();

List<Element> listaVisitas = null;

NodoVisita actual = new NodoVisita();

try {

int i, nodosDelSistema;



nodosDelSistema = elementoSistema.getChildren().size();

if(nodosDelSistema==2)

{

listaVisitas = elementoSistema.getChildren().get(1).getChildren();

}

if(!(listaVisitas==null))

{

for(i=0; i<listaVisitas.size(); i++)

{

actual = new NodoVisita();

100

actual.setPlaca(listaVisitas.get(i).getChildren().get(0).getText());

actual.setNombres(listaVisitas.get(i).getChildren().get(1).getText());

actual.setApellidoPaterno(listaVisitas.get(i).getChildren().get(2).getText());

actual.setApellidoMaterno(listaVisitas.get(i).getChildren().get(3).getText());

actual.setPlacaInquilino(listaVisitas.get(i).getChildren().get(4).getText());

elementos.add(actual);

}

}

}


{

System.out.println("Error en la estructura del archivo: XML-

buscarPlacaVisita()");

}


{

System.out.println("Error al leer archivo: XML-buscarPlacaVisita()");

}


System.out.println("No se encontro la placa: XML-buscarPlacaVisita()");

return elementos;

}

public String eliminarPlaca(String matricula)

{

List<String> elementoDePlaca = buscarPlaca(matricula);

String mensaje = "";

int i;

if(elementoDePlaca.isEmpty())

{

mensaje = "La placa no existe en la base de datos";

}

else {

try {




101

List<Element> listaVisitas=null;

int nodosDelSistema=0,bandera=0;

nodosDelSistema = elementoSistema.getChildren().size();

if(nodosDelSistema == 2)

{

listaInquilinos =


listaVisitas =


}

else if(nodosDelSistema == 1)

{

listaInquilinos =


}


{


{


{

listaInquilinos.remove(i);

bandera=1;

break;

}

}

if(bandera==1)

{



try {




fichero.close();

mensaje = "Placa borrada";

}

catch(Exception g)

{

mensaje = "Error al escribir el archivo:

eliminarPlaca()";

102

}

}

}

if(!(listaVisitas==null))

{

for(i=0; i<listaVisitas.size(); i++)

{

if(matricula.equals(listaVisitas.get(i).getChildren().get(0).getText()))

{

listaVisitas.remove(i);

bandera=1;

break;

}

}

if(bandera==1)

{



try {




fichero.close();

mensaje = "Placa borrada";

}

catch(Exception g)

{

mensaje = "Error al escribir el archivo:

eliminarPlaca()";

}

}

}

}


{

mensaje = "Error en la estructura del archivo: eliminarPlaca()";

}


{

mensaje = "Error al leer archivo: eliminarPlaca()";

}

}

return mensaje;}}

103

Conclusiones

El proyecto ha solucionado parcialmente el problema principal debido a que se restringió el

reconocimiento de placas de algunos coches que no cumplieron con los requerimientos como

altura o placas en buen estado.

Trabajo a futuro

El sistema requiere de un mecanismo, el cual situé la cámara a la altura de la placa, para

reconocer el 100% de las placas en buen estado.

Referencias

[1] CyJMéxico (7/8/2013). Estudio sobre el robo de autos en México 2013 [online]. Disponible:

http://crimyjustmexico.com/estudio-sobre-el-robo-de-autos-en-mexico-2013/

[2] Juan Carlos González Islas (25/10/2013). Prototipo de Control de acceso vehicular empleando

un sistema de visión artificial con Labview [online]. Disponible:

https://www.youtube.com/watch?v=tcN_jGon4Dc

[3] Morfín Montes Francisco Jesús. “SRACC: Sistema de Reconocimiento de Automóviles en

Centros Comerciales” M.S. thesis (TT 13-02-2007). Escuela Superior de Cómputo, Distrito

Federal, 2007.

[4] Jesica Azucena Juárez García Alberto Robles arenas y Alma Verónica Villamil Salazar.

“Sistema de control de acceso vehicular mediante Identificación por Radiofrecuencia” M.S.

thesis (TT-20060046). Escuela Superior de Cómputo, Distrito Federal, 2006.

[5] Convergencia digital. Paquete control de acceso vehicular con reconocimiento de placas

[online]. Disponible: http://convergenciadigital.com/eshop/product_info.php?products_id=1228

[6] LIFTPROXPL. Barrera Vehicular Serie X de Alta Velocidad Iluminada y Sensor de Impacto

[online]. Disponible: http://www.syscom.mx/producto/LIFTPROXPL-LiftPRO-69049.html

[7] IBIX. Control de Acceso Barrera Vehicular CAME GARD4 [online]. Disponible:

http://www.ibix.com/came-gard4

[8] Canny, J., A Computational Approach To Edge Detection, IEEE Trans. Pattern Analysis and

Machine Intelligence, 8(6):679–698, 1986

[9] ORACLE. Características y ventajas [online]. Disponible:

http://www.oracle.com/es/technologies/java/features/index.html

104

[10] Asamblea Legislativa del Distrito Federal. VI Legislatura, Ley de Seguridad

Pública del Distrito Federal [online]. Disponible: http://www.aldf.gob.mx/archivo-

b5e52c7654d985d94885ed2faae74291.pdf

[11] Juan Palacios (2006). El modelo Scrum [online]. Disponible:

http://www.navegapolis.net/files/s/NST-010_01.pdf

[12] SEGOB. PROYECTO DE NORMA OFICIAL MEXICANA PROY-NOM-001-SCT-2-2012

[online]. Disponible:

http://www.dof.gob.mx/nota_detalle.php?codigo=5293069&fecha=21/03/2013

[13] Bravo Chávez Erick Iván, “Herramienta de ayuda para la detección temprana de la

osteoporosis mediante imágenes de rayos x”. M.S. thesis (2013-B086). Escuela Superior de

Cómputo, Distrito Federal, 2015

[14] Lourdes Jiménez Zozaya, “ANPR Automatic Number Plate Recognition”, Ph.D. dissertation

univ. California, Berkeley (2010).

[15] ABBYY (2015). Acerca de OCR [online]. Disponible:

http://latam.abbyy.com/finereader/ocr/

[16] GOOGLE (2015). Acerca del reconocimiento óptico de caracteres en Google Drive [online].

Disponible: https://support.google.com/drive/answer/176692?hl=es

[17] Roberto Rodríguez Morales y Juan Humberto Sossa Azuela “Segmentación de imágenes” en

Procesamiento y análisis digital de imágenes, Ed. Alfaomega Ra-Ma.

sistema de control de acceso vehicular mediante

Documents