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.
__________________
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 30: división de columnas a 110 cm ............................................................................. 72
Ilustración 31: división de columnas a 100 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 7: pila de sprint 2 ................................................................................................................. 33
Tabla 8: pila de sprint 3 ................................................................................................................. 33
Tabla 9: pila de sprint 4 ................................................................................................................. 34
Tabla 10: pila de sprint 5 ............................................................................................................... 34
Tabla 11: pila de sprint 6 ............................................................................................................... 35
Tabla 12: pila de sprint 7 ............................................................................................................... 35
Tabla 13: pila de sprint 8 ............................................................................................................... 36
Tabla 14: pila de sprint 9 ............................................................................................................... 36
Tabla 15: pila de sprint 10 ............................................................................................................. 37
Tabla 16: pila de sprint 11 ............................................................................................................. 37
Tabla 17: pila de sprint 12 ............................................................................................................. 38
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
Tabla 26: caso de uso CU-02 ......................................................................................................... 45
Tabla 27: caso de uso CU-03 ......................................................................................................... 46
9
Tabla 28: caso de uso CU-04 ......................................................................................................... 47
Tabla 29: caso de uso CU-05 ......................................................................................................... 48
Tabla 30: caso de uso CU-06 ......................................................................................................... 49
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
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 eliminar. El sistema indica si la placa
fue eliminada.
Requiere diagrama de caso de uso y descripción del caso
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.
Requiere diagrama de caso de uso y descripción del caso
de uso
31
5 Agregar placa para permitir visita de los
inquilinos
20 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 visita. El sistema indica si la
placa fue agregada.
Requiere diagrama de caso de uso y descripción del caso
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
Necesita diagrama de flujo
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”
Necesita diagrama de flujo
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.
Necesita diagrama de flujo
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
Necesita diagrama de flujo
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
3.1.4. Pila de sprint 2
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
* Desarrollar algoritmo que permita
eliminar placa de inquilino
Velocidad estimada:
* 10
Calendario:
* Periodo de sprint: 07/04/2015 a 21/04/2015
* Scrum diario: 8:30 a 9:00 en cubículo de oficina
* Demo de sprint: 21/04/2015, 22:30 en cuarto de
tareas
Tabla 7: pila de sprint 2
En este sprint se avanzará 10 puntos de historia.
3.1.5. Pila de sprint 3
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 placa de visita y
modificar placas en el sistema
Pila de sprint:
* Desarrollar algoritmo que permita
agregar placa de visita del inquilino
* Desarrollar algoritmo que permita
modificar placa de inquilino
Velocidad estimada:
* 10
Calendario:
* Periodo de sprint: 22/04/2015 a 06/05/2015
* Scrum diario: 8:30 a 9:00 en cubículo de
oficina
* Demo de sprint: 06/05/2015, 22:30 en cuarto de
tareas
Tabla 8: pila de sprint 3
En este sprint se avanzará 10 puntos de historia.
34
3.1.6. Pila de sprint 4
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:
* Buscar placa en el sistema
Pila de sprint:
* Desarrollar Algoritmo que
permita buscar una placa en el
sistema
Velocidad estimada:
* 5
Calendario:
* Periodo de sprint: 07/05/2015 a 21/05/2015
* Scrum diario: 8:30 a 9:00 en cubículo de
oficina
* Demo de sprint: 21/05/2015, 22:30 en cuarto de
tareas
Tabla 9: pila de sprint 4
En este sprint se avanzará 5 puntos de historia.
3.1.7. Pila de sprint 5
En la siguiente tabla se muestran las siguientes actividades que se tomarán de la pila del producto
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:
* Periodo de sprint: 17/09/2015 a 24/09/2015
* Scrum diario: 9:00 a 9:30 en cubículo de
oficina
* Demo de sprint: 24/09/2015, 20:30 en sala de TT
Tabla 10: pila de sprint 5
En este sprint se avanzará 10 puntos de historia.
35
3.1.8. Pila de sprint 6
En la siguiente tabla se muestran las siguientes actividades que se tomarán de la pila del producto
y puedan realizarse en 1 semana.
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:
* Periodo de sprint: 25/09/2015 a 02/10/2015
* Scrum diario: 9:00 a 9:30 en cubículo de
oficina
* Demo de sprint: 02/10/2015, 20:30 en sala de TT
Tabla 11: pila de sprint 6
En este sprint se avanzará 10 puntos de historia.
3.1.9. Pila de sprint 7
En la siguiente tabla se muestran las siguientes actividades que se tomarán de la pila del producto
y puedan realizarse en 1 semana.
Objetivo de sprint:
* Ajustar brillo y contraste de la
imagen.
Pila de sprint:
* Realizar diagrama de flujo
* Programar el diagrama de flujo
Velocidad estimada:
* 10
Calendario:
* Periodo de sprint: 03/10/2015 a 10/10/2015
* Scrum diario: 9:00 a 9:30 en cubículo de
oficina
* Demo de sprint: 10/10/2015, 20:30 en sala de
tareas
Tabla 12: pila de sprint 7
En este sprint se avanzará 10 puntos de historia.
36
3.1.10. Pila de sprint 8
En la siguiente tabla se muestran las siguientes actividades que se tomarán de la pila del producto
y puedan realizarse en 1 semana.
Objetivo de sprint:
*Separar los caracteres de la
imagen tomada a la placa vehicular
Pila de sprint:
* Realizar diagrama de flujo
* Programar el diagrama de flujo
Velocidad estimada:
* 15
Calendario:
* Periodo de sprint: 11/10/2015 a 18/10/2015
* Scrum diario: 9:00 a 9:30 en cubículo de
oficina
* Demo de sprint: 18/10/2015, 20:30 en sala de
tareas
Tabla 13: pila de sprint 8
En este sprint se avanzará 10 puntos de historia.
3.1.11. Pila de sprint 9
En la siguiente tabla se muestran las siguientes actividades que se tomarán de la pila del producto
y puedan realizarse en 1 semana.
Objetivo de sprint:
*Programar algoritmo de los
momentos invariantes de Hu
Pila de sprint:
* Realizar diagrama de flujo
* Programar el diagrama de flujo
Velocidad estimada:
* 10
Calendario:
* Periodo de sprint: 19/10/2015 a 26/10/2015
* Scrum diario: 9:00 a 9:30 en cubículo de
oficina
* Demo de sprint: 26/10/2015, 20:30 en sala de
tareas
Tabla 14: pila de sprint 9
En este sprint se avanzará 10 puntos de historia.
37
3.1.12. Pila de sprint 10
En la siguiente tabla se muestran las siguientes actividades que se tomarán de la pila del producto
y puedan realizarse en 1 semana.
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:
* Periodo de sprint: 27/10/2015 a 04/11/2015
* Scrum diario: 9:00 a 9:30 en cubículo de
oficina
* Demo de sprint: 04/11/2015, 20:30 en sala de
tareas
Tabla 15: pila de sprint 10
En este sprint se avanzará 10 puntos de historia.
3.1.13. Pila de sprint 11
En la siguiente tabla se muestran las siguientes actividades que se tomarán de la pila del producto
y puedan realizarse en 1 semana.
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:
* Periodo de sprint: 04/11/2015 a 11/11/2015
* Scrum diario: 9:00 a 9:30 en cubículo de
oficina
* Demo de sprint: 11/11/2015, 20:30 en sala de
tareas
Tabla 16: pila de sprint 11
En este sprint se avanzará 10 puntos de historia.
38
3.1.14. Pila de sprint 12
En la siguiente tabla se muestran las siguientes actividades que se tomarán de la pila del producto
y puedan realizarse en 1 semana.
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:
* Periodo de sprint: 11/11/2015 a 18/11/2015
* Scrum diario: 9:00 a 9:30 en cubículo de
oficina
* Demo de sprint: 18/11/2015, 20:30 en sala de
tareas
Tabla 17: pila de sprint 12
En este sprint se avanzará 10 puntos de historia.
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)
1. El sistema redirige a la pantalla principal IG-01
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
Actores Administrador
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
Tabla 26: caso de uso CU-02
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
4.7.2.1. Trayectorias de caso de uso
Trayectoria principal
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]
3. El sistema redirige a la pantalla principal IG-01
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
Actores Administrador
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
Tabla 27: caso de uso CU-03
En este caso de uso se hace referencia al CU-01ya que para eliminar una placa se tuvo que iniciar
sesión como administrador.
4.7.3.1. Trayectorias de caso de uso
Trayectoria principal
1. El administrador llena los campos con la información solicitada y oprime el botón
(eliminar)
2. El sistema le indica al administrador si la placa fue eliminada [Trayectoria D]
3. El sistema redirige a la pantalla principal IG-01
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
Actores Administrador
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
Tabla 28: caso de uso CU-04
En este caso de uso se hace referencia al CU-01ya que para modificar una placa se tuvo que
iniciar sesión como administrador.
4.7.4.1. Trayectorias de caso de uso
Trayectoria principal
1. El administrador llena los campos con la información solicitada y oprime el botón
(modificar)
2. El sistema le indica al administrador si la placa fue modificada [Trayectoria E]
3. El sistema redirige a la pantalla principal IG-01
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.
Tabla 29: caso de uso CU-05
El nombre de este caso de uso hace referencia al proceso que se lleva a cabo mediante
programación para reconocer una placa.
4.7.5.1. Trayectorias de caso de uso
Trayectoria principal
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.
Tabla 30: caso de uso CU-06
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.
4.7.6.1. Trayectorias de caso de uso
Trayectoria principal
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;
placaI = placa.getText().toString();
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(""))
{
JOptionPane.showMessageDialog(null, "Todos los campos deben estar
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);
JOptionPane.showMessageDialog(null, msg);
}
else if(op==2)
{
msg = gestionPlacas.modificarPlaca(placaI, nomI, apPatI,
apMatI, deptoI, edifI);
JOptionPane.showMessageDialog(null, msg);
}
}
catch(Exception e)
{
JOptionPane.showMessageDialog(null, "Error: Dato ingresado no
es numero entero");
}
limpiarFormulario();
}
}
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;
placaI = placa.getText().toString();
if(placaI.equals(""))
{
JOptionPane.showMessageDialog(null, "El campo de la placa debe estar
lleno");
}
else
{
msg = gestionPlacas.eliminarPlaca(placaI);
JOptionPane.showMessageDialog(null, msg);
limpiarFormulario();
}
}
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(""))
{
JOptionPane.showMessageDialog(null, "Todos los campos deben estar
llenos");
}
else
{
msg = gestionPlacas.agregarPlaca(placaV, nomV, apPatV, apMatV,
placaI);
JOptionPane.showMessageDialog(null, msg);
limpiarFormulario();
}
}
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
Para una distancia de 110 cm entre la cámara y la placa se concluyó que el número de columnas
son 20 cómo se muestra en la siguiente figura:
Ilustración 30: división de columnas a 110 cm
Para una distancia de 100 cm entre la cámara y la placa se concluyó que el número de columnas
son 20 cómo se muestra en la siguiente figura:
Ilustración 31: división de columnas a 100 cm
Para una distancia de 90 cm entre la cámara y la placa se concluyó que el número de columnas
son 20 cómo se muestra en la siguiente figura:
73
Ilustración 32: división de columnas a 90 cm
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.awt.image.BufferedImage;
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;
import java.awt.image.BufferedImage;
import java.util.ArrayList;
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));
nu20 = (float) (mu20/Math.pow(mu00,((2+0)/2)+1));
nu02 = (float) (mu02/Math.pow(mu00,((0+2)/2)+1));
nu11 = (float) (mu11/Math.pow(mu00,((1+1)/2)+1));
nu30 = (float) (mu30/Math.pow(mu00,((3+0)/2)+1));
nu12 = (float) (mu12/Math.pow(mu00,((1+2)/2)+1));
nu21 = (float) (mu21/Math.pow(mu00,((2+1)/2)+1));
nu03 = (float) (mu03/Math.pow(mu00,((0+3)/2)+1));
//Phi1
phiActual = nu20+nu02;
vector.add(phiActual);
//Phi2
phiActual = (float)(Math.pow(nu20-nu02, 2) + (4 * Math.pow(nu11, 2)));
vector.add(phiActual);
//Phi3
phiActual = (float)(Math.pow(nu30-(3*nu12), 2) + (3 * Math.pow(nu21-nu03,
2)));
vector.add(phiActual);
//Phi4
phiActual = (float)(Math.pow(nu30+nu12, 2) + Math.pow(nu21+nu03, 2));
vector.add(phiActual);
//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)));
vector.add(phiActual);
//Phi6
phiActual = (float)((nu20-nu02) * (Math.pow(nu30+nu12, 2) - (nu21+nu03)) + 4
* nu11 * (nu30+nu12) * (nu21+nu03));
vector.add(phiActual);
//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)));
vector.add(phiActual);
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.ArrayList;
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).removeContent(0);
listaInquilinos.get(i).getChildren().get(2).addContent(apPaterno);
listaInquilinos.get(i).getChildren().get(3).removeContent(0);
listaInquilinos.get(i).getChildren().get(3).addContent(apMaterno);
listaInquilinos.get(i).getChildren().get(4).removeContent(0);
listaInquilinos.get(i).getChildren().get(4).addContent(depto);
listaInquilinos.get(i).getChildren().get(5).removeContent(0);
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)
{
List<Element> listaInquilinos=null;
String msg = "";
if(!buscarPlaca(matriculaVieja).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++)
{
if(matriculaVieja.equals(listaInquilinos.get(i).getChildren().get(0).getText()))
{
listaInquilinos.get(i).getChildren().get(0).removeContent(0);
listaInquilinos.get(i).getChildren().get(0).addContent(matriculaNueva);
bandera=1;
break;
}
}
if(bandera==1)
{
String primerNodo = (new
XMLOutputter(Format.getPrettyFormat())).outputString(elementoSistema.getDocument());
try
91
{
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)
{
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
{
Element elementoSistema = ((Document) (new
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);
String primerNodo = (new
XMLOutputter(Format.getPrettyFormat())).outputString(elementoSistema.getDocument());
try {
FileWriter fichero = new
FileWriter("Recursos/inquilinos.xml");
fichero.write(primerNodo);
fichero.close();
msg = "Placa agregada";
}
catch(Exception g)
{
msg = "Error al escribir el archivo: agregarPlaca()";
}
}
catch(JDOMException e)
{
msg = "Error en la estructura del archivo: agregarPlaca()";
}
93
catch(IOException f)
{
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);
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);
String primerNodo = (new
XMLOutputter(Format.getPrettyFormat())).outputString(doc);
try {
FileWriter fichero = new
FileWriter("Recursos/inquilinos.xml");
94
fichero.write(primerNodo);
fichero.close();
msg = "Placa agregada";
}
catch(Exception g)
{
msg = "Error al escribir el archivo: agregarPlaca()";
}
}
}
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 {
Element elementoSistema = ((Document) (new
SAXBuilder()).build(archivo)).getRootElement();
Element inquilino = new Element("inquilino");
Element placa = new Element("placa");
placa.addContent(sPlaca);
inquilino.addContent(placa);
Element nombres = new Element("nombre_s");
nombres.addContent(sNombre_s);
inquilino.addContent(nombres);
Element apPat = new Element("apellido_paterno");
apPat.addContent(sApPat);
inquilino.addContent(apPat);
95
Element apMat = new Element("apellido_materno");
apMat.addContent(sApMat);
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);
String primerNodo = (new
XMLOutputter(Format.getPrettyFormat())).outputString(elementoSistema.getDocument());
try {
FileWriter fichero = new
FileWriter("Recursos/inquilinos.xml");
fichero.write(primerNodo);
fichero.close();
msg = "Placa agregada";
}
catch(Exception g)
{
msg = "Error al escribir el archivo: agregarPlaca()";
}
}
catch(JDOMException e)
{
msg = "Error en la estructura del archivo: agregarPlaca()";
}
catch(IOException f)
{
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);
Element placa = new Element("placa");
placa.addContent(sPlaca);
inquilino.addContent(placa);
Element nombres = new Element("nombre_s");
nombres.addContent(sNombre_s);
inquilino.addContent(nombres);
Element apPat = new Element("apellido_paterno");
apPat.addContent(sApPat);
inquilino.addContent(apPat);
Element apMat = new Element("apellido_materno");
apMat.addContent(sApMat);
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);
String primerNodo = (new
XMLOutputter(Format.getPrettyFormat())).outputString(doc);
try {
FileWriter fichero = new
FileWriter("Recursos/inquilinos.xml");
fichero.write(primerNodo);
fichero.close();
msg = "Placa agregada";
}
catch(Exception g)
{
msg = "Error al escribir el archivo: agregarPlaca()";
}
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();
if(!(listaInquilinos==null))
{
for(i=0; i<listaInquilinos.size(); i++)
{
if(matricula.equals(listaInquilinos.get(i).getChildren().get(0).getText()))
{
elementos.add(listaInquilinos.get(i).getChildren().get(0).getText());
elementos.add(listaInquilinos.get(i).getChildren().get(1).getText());
elementos.add(listaInquilinos.get(i).getChildren().get(2).getText());
elementos.add(listaInquilinos.get(i).getChildren().get(3).getText());
elementos.add(listaInquilinos.get(i).getChildren().get(4).getText());
elementos.add(listaInquilinos.get(i).getChildren().get(5).getText());
bandera=1;
break;
}
}
if(bandera==1)
{
98
System.out.println("La placa si existe");
}
}
}
catch(JDOMException e)
{
System.out.println("Error en la estructura del archivo: buscarPlaca()");
}
catch(IOException f)
{
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;
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++)
{
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);
}
}
}
catch(JDOMException e)
{
System.out.println("Error en la estructura del archivo: XML-
buscarPlacaInquilino()");
}
catch(IOException f)
{
System.out.println("Error al leer archivo: XML-buscarPlacaInquilino()");
}
if(elementos.isEmpty())
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;
Element elementoSistema = ((Document) (new SAXBuilder()).build(new
File("Recursos/inquilinos.xml"))).getRootElement();
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);
}
}
}
catch(JDOMException e)
{
System.out.println("Error en la estructura del archivo: XML-
buscarPlacaVisita()");
}
catch(IOException f)
{
System.out.println("Error al leer archivo: XML-buscarPlacaVisita()");
}
if(elementos.isEmpty())
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 {
Element elementoSistema = ((Document) (new
SAXBuilder()).build(new File("Recursos/inquilinos.xml"))).getRootElement();
List<Element> listaInquilinos=null;
101
List<Element> listaVisitas=null;
int nodosDelSistema=0,bandera=0;
nodosDelSistema = elementoSistema.getChildren().size();
if(nodosDelSistema == 2)
{
listaInquilinos =
elementoSistema.getChildren().get(0).getChildren();
listaVisitas =
elementoSistema.getChildren().get(1).getChildren();
}
else if(nodosDelSistema == 1)
{
listaInquilinos =
elementoSistema.getChildren().get(0).getChildren();
}
if(!(listaInquilinos==null))
{
for(i=0; i<listaInquilinos.size(); i++)
{
if(matricula.equals(listaInquilinos.get(i).getChildren().get(0).getText()))
{
listaInquilinos.remove(i);
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();
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)
{
String primerNodo = (new
XMLOutputter(Format.getPrettyFormat())).outputString(elementoSistema.getDocument());
try {
FileWriter fichero = new
FileWriter("Recursos/inquilinos.xml");
fichero.write(primerNodo);
fichero.close();
mensaje = "Placa borrada";
}
catch(Exception g)
{
mensaje = "Error al escribir el archivo:
eliminarPlaca()";
}
}
}
}
catch(JDOMException e)
{
mensaje = "Error en la estructura del archivo: eliminarPlaca()";
}
catch(IOException f)
{
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.