ALGORITMO DE OBTENCIÓN DE CARACTERÍSTICAS EN HUELLAS ... · obtienen, con el propio dispositivo y con una base de datos muy reducida, es decir, capaz de identificar a un escaso

ALGORITMO DE OBTENCIÓN DE CARACTERÍSTICAS EN HUELLAS DACTILARES PARASISTEMAS EMBEBIDOS GNU/LINUX

PROYECTO FIN DE CARRERA

ALGORITMO DE OBTENCIÓN DECARACTERÍSTICAS EN HUELLAS

DACTILARES PARA SISTEMASEMBEBIDOS GNU/LINUX

AUTOR: JOAQUÍN DIEGO REYES GONZÁLEZ

MADRID, Septiembre 2005

JOAQUÍN DIEGO REYES GONZÁLEZ - 1 -

UNIVERSIDAD PONTIFICIA COMILLASESCUELA TÉCNICA SUPERIOR DE INGENIERÍA (ICAI)

INGENIERO INDUSTRIAL


MMEMORIAEMORIA



Índice de contenidoÍndice de contenido

1.- Prólogo..................................................................................................5

2.- Introducción..........................................................................................7

1 Estudio de los trabajos y tecnologías existentes....................................7

2 Motivación del proyecto........................................................................9

3 Objetivos.............................................................................................10

4 Metodología y solución desarrollada..................................................10

5 Recursos y herramientas empleadas....................................................12

3.- Análisis de la placa MipScale............................................................14

1 Configuración de la máquina base......................................................14

2 Desarrollo de una pequeña aplicación.................................................16

3 Prueba de la unidad de coma flotante.................................................18

4.- Formato utilizado para las imágenes................................................22

1 El formato PBM (Portable BitMap)....................................................22

2 El formato PGM (Portable GrayMap).................................................23

3 El formato PPM (Portable PixMap)....................................................23

5.- Las huellas dactilares y sus características......................................25

6.- Algoritmo de obtención de características.......................................27

1 Lectura del fichero..............................................................................29

2 Atenuación y ajuste de tonalidades.....................................................31

3 Ajuste de negros y blancos fijos por direcciones................................33

4 Búsqueda de direcciones.....................................................................36

5 Binarizado de la imagen o paso a blanco y negro...............................38

6 Proceso de apertura y erosión..............................................................40

7 Proceso de apertura y dilatación..........................................................42

8 Proceso de cerrado y dilatación...........................................................44

9 Proceso de cerrado y erosión...............................................................46

10 Obtención de esqueletos....................................................................48

11 Perfeccionamiento de los esqueletos.................................................50



12 Superposición de los esqueletos sobre la imagen original................52

13 Obtención de características..............................................................54

7.- Experimentos y Resultados...............................................................58

8.- Conclusiones.......................................................................................67

9.- Futuros desarrollos............................................................................69

10.- Bibliografía.......................................................................................72

11.- Análisis del mercado........................................................................75

12.- Posibilidades del algoritmo desarrollado.......................................77

13.- Ejecución del algoritmo...................................................................79

14.- Configuración de los parámetros del proceso................................81



1.- 1.- PrólogoPrólogo

En la memoria de este proyecto se recogen los trabajos realizados

investigando un nuevo proceso de reconocimiento de huellas dactilares. Todo ser

humano posee varios rasgos propios y únicos, pero no es sencillo obtener un

esquema en el que se muestren todos estos rasgos, de forma que se puedan

comparar entre varios individuos y así poder asegurar la identidad de cada uno.

Sin embargo, el reconocimiento de huellas dactilares no es nuevo, sino que se

lleva usando varios años con éxito, pero no de una forma demasiado fiable. En

los procesos que se están efectuando a día de hoy, existen dos vertientes: en un

caso es necesario una imagen de muy buena calidad y un entorno muy potente

que permita un análisis riguroso de la imagen, mientras que en la otra vertiente

nos encontramos con pequeños dispositivos, dotados de sensores de baja calidad,

que consiguen identificar a cada individuo mediante la comparación de los datos

obtenidos con el propio sensor con los ya almacenados en una base de datos

propia, realizada también con el mismo sensor. La primera opción tiene como

ventaja que los resultados son realmente fiables e independientes de la forma de

obtención de la imagen, pero esto es a cambio de una costosa y elevada

infraestructura, que los convierte en equipos difícilmente transportables y al

alcance de pocos usuarios. La segunda opción, sin embargo, soluciona el elitismo

existente en el ámbito de reconocimiento de huellas dactilares, pero tiene muy

poca diversidad, ya que sólo es posible utilizar los pobres resultados que se

obtienen, con el propio dispositivo y con una base de datos muy reducida, es

decir, capaz de identificar a un escaso abanico de individuos.

En este proyecto, se busca una solución intermedia a los dos casos

presentados. Lo que pretendemos es alcanzar un algoritmo de fácil implantación

que maneje cualquier imagen y detecte algunas de las características importantes

de una huella dactilar, las suficientes como para identificar a un individuo en el



menor tiempo posible. En busca de una fácil y, sobre todo, versátil implantación

buscamos un algoritmo que funcione en sistemas embebidos GNU/Linux. Si

utilizamos un sistema operativo libre, como GNU/Linux, los beneficios son

innumerables pero podemos destacar que cada vez son más los pequeños

dispositivos que llevan GNU/Linux embebido y que, al ser un sistema libre,

existen multitud de desarrolladores asegurando un próspero futuro. Además,

utilizando una base estable y probada, nos podemos dedicar a desarrollar

únicamente el algoritmo, sin tener en cuenta la arquitectura sobre la que se va

implantar.

Como punto de inicio del proyecto se pensaba implantar un algoritmo ya

desarrollado en el Instituto de Investigación Tecnológica (IIT), pero éste estaba

optimizado para su uso con un potente software de cálculo y se alejaba de nuestro

propósito de alcanzar un algoritmo sencillo y versátil. Este motivo ha disminuido

las aspiraciones iniciales del proyecto y, aunque los resultados pueden ser

considerados aceptables, podemos decir que éste proyecto puede ser el principio

de un desarrollo largo y siempre mejorable, de un sistema de reconocimiento de

huellas dactilares para sistemas de corta infraestructura.

Finalmente, nos gustaría agradecer la colaboración de la empresa

MicroPowerSoft (MIPSA) que ha cedido una pequeña placa MipScale, con

GNU/Linux embebido, para poder llevar a cabo ciertas pruebas del algoritmo

desarrollado y comprobar la utilidad de éste en dispositivos de pequeño tamaño.



2.- 2.- IntroducciónIntroducción

A lo largo de esta memoria vamos a explicar en qué consiste el algoritmo

desarrollado para la obtención de características de una huella dactilar, así como

los trabajos desarrollados para llevar a cabo el desarrollo de éste algoritmo así

como sus pruebas en un sistema con GNU/Linux embebido. En el siguiente

capítulo, el tercero, se analiza la placa que se va a utilizar a modo de banco de

pruebas como dispositivo de bolsillo. En el cuarto capítulo, se presenta el formato

utilizado para manejar las imágenes, de forma que éste manejo sea lo más

sencillo posible, y en el quinto capítulo se muestra qué es una huella dactilar y

cuáles son las características más importantes. El sexto capítulo es el más extenso

y en el que se explica con el máximo detalle posible en qué consiste el algoritmo,

realizando todos los procesos implementados de forma consecutiva y viendo el

resultado que se obtiene después de realizar cada proceso. A continuación, en el

capítulo séptimo, se van a realizar una serie de ensayos y experimentos en los que

vemos cómo podemos mejorar los resultados optimizando el algoritmo para un

tipo concreto de huellas dactilares. En los dos siguientes capítulos, se obtienen las

conclusiones objetivas del algoritmo y se analizan los futuros desarrollos que

podrían mejorar nuestro algoritmo desarrollado.

11 Estudio de los trabajos y tecnologías existentesEstudio de los trabajos y tecnologías existentes

Hasta ahora todos los trabajos desarrollados por el Instituto de

Investigación Tecnológica (IIT) necesitaban el uso de grandes máquinas y

software propietario para poder llevar a cabo el análisis de una huella dactilar. El

proceso seguido para llevar a cabo éste análisis, siempre ha seguido el mismo

patrón, cuya utilidad ha sido ampliamente comprobada en la multitud de

proyectos que se han llevado a cabo ya que, aunque existen ciertas diferencias

entre los proyectos, si que existe un esquema general que siguen todos los



proyectos, el cual incluye los siguientes procesos que son siempre realizados de

forma secuencial:

✗ Filtrado de la imagen: En todos los procesos se lleva a cabo un filtrado

de la imagen, buscando siempre utilizar la mejor imagen posible para

asegurar los resultados más fieles a nuestro alcance.

✗ Binarizado de la imagen: La imagen en color o con escala de grises no

mejora los resultados y sí aumenta la carga del proceso, por lo que es

fundamental obtener una imagen en blanco y negro, a partir de la

imagen original, con la que poder llevar a cabo la obtención de

características.

✗ Análisis de las direcciones fundamentales: No todos los procesos

estudiados realizan un análisis acerca de las direcciones fundamentales,

pero sí es común en un gran número de ellos, de forma que se puede

obtener información adicional para el proceso de reconocimiento.

✗ Obtención de contornos o esqueletos: En éste punto es dónde existe la

posibilidad de elegir entre una opción u otra ya que cada una posee sus

ventajas e inconvenientes, siendo ambas válidas para poder encontrar

las características fundamentales de una huella dactilar. En la obtención

de contornos buscaríamos los bordes de las crestas de la huella, mientras

que en la obtención de esqueletos estaríamos buscando la parte central

de la cresta de la huella.

✗ Obtención de características: Es el proceso final y común a todos los

estudiados. En él se averiguan las posiciones de las características para

poder así llegar a completar el proceso de reconocimiento.

✗ Comparación de características entre dos huellas: Éste es el proceso

necesario para asegurar la identidad de un individuo por medio de su

huella dactilar. Sin embargo, éste proceso ya se escapa a los objetivos de



éste proyecto, ya que implica la búsqueda del centro de la huella, así

como la translación, rotación y desplazamiento de las características

hasta poder asegurar si dos huellas son exactas, aunque sólo se tenga

una parte de ellas.

Los proyectos estudiados han sido incluidos en la bibliografía, que se

encuentra en el último apartado de ésta memoria.

22 Motivación del proyectoMotivación del proyecto

Éste proyecto pretende mejorar y fusionar varios de los proyectos

desarrollados por el IIT a lo largo de los últimos años. La mejora consiste en

disminuir el tiempo de proceso y la fusión va a analizar los procesos ya utilizados

en otros proyectos y elegir aquéllos que puedan proporcionar el mejor

rendimiento. Una vez analizado el proyecto de Bárbara Carlón Sainz (referencia

[6] en la bibliografía) observamos que el tiempo de proceso que necesita el

algoritmo ronda los 30 minutos en una máquina gobernada por un

microprocesador Intel Pentium IV a 1'6GHz y 521MB de RAM, mientras que

nuestro algoritmo tan sólo necesita 20 segundos en la misma máquina. A la hora

de implantar éste algoritmo en la placa MipScale el tiempo aumenta, como es

lógico, hasta los 6 minutos, siendo todavía un tiempo razonable, sobre todo

teniendo en cuenta que se trata de un dispositivo de bolsillo.

Además, nuestro algoritmo se puede implantar en cualquier máquina que

posea el Sistema Operativo GNU/Linux embebido, tal y como puede ser un

ordenador PC o Macintosh doméstico o cualquier otro dispositivo cuya

arquitectura sea menor, no cerrando las puertas a máquinas más potentes. De esta

forma resulta sencillo, por lo tanto, centrarse en la implantación del algoritmo y

olvidarse del sistema operativo, el cual se encargará de gestionar los recursos del

hardware.



33 ObjetivosObjetivos

La idea de llevar a cabo este proyecto surge del deseo de llevar a cabo un

proceso de cálculo sobre un sistema embebido con GNU/Linux. El proceso

elegido es la obtención de características de una huella dactilar, pero éste no es el

único objetivo, sino que existen varios objetivos:

✗ Utilizar dispositivos de pequeño tamaño con GNU/Linux embebidos y

desarrollar aplicaciones que puedan ser ejecutadas de forma autónoma

en el dispositivo.

✗ Realizar un proceso digital de una imagen utilizando el lenguaje de

programación C, uno de los más extendidos y de gran versatilidad.

✗ Programar un algoritmo que obtenga las características de una huella

dactilar en el menor tiempo posible, de forma que sea factible identificar

a un individuo.

✗ Utilizar exclusivamente software libre para el completo desarrollo del

proyecto.

44 Metodología y solución desarrolladaMetodología y solución desarrollada

Para poder llevar a cabo la obtención de características de una huella

dactilar, nuestro algoritmo debe realizar los siguientes procesos:

✗ Lectura de la imagen: El primer proceso es obtener la imagen y, si ésta

se encuentra a color es pasada a escala de grises.

✗ Atenuación: El rango de valores que pueden tener los píxeles de la

imagen va desde el valor 0 (negro) hasta el valor 255 (blanco). Ahora

bien, no todas las imágenes tienen estos valores máximos y mínimos,

por lo que para aprovechar al máximo la información de la imagen, se



ajustan los valores de la imagen, de forma que el máximo y mínimo,

coincidan con 255 y 0 respectivamente.

✗ Determinación de direcciones y ajuste de tonalidades: El siguiente

proceso evalúa los píxeles cercanos de cada píxel de forma que si existe

una clara mayoría de píxeles cercanos negros o blancos, el píxel se fija a

blanco o negro, a no ser que no exista una clara mayoría, en cuyo caso

se deja el píxel con el mismo valor que tiene. Además, en éste proceso

conseguimos una matriz que nos indica la dirección en la que existe un

dominio claro de una determinada tonalidad o, si por el contrario, no

existe ninguna dirección dominante.

✗ Binarización de la imagen: Una vez que hemos obtenido la matriz de

direcciones con la mayor información posible, pasamos la imagen a

blanco y negro puros, es decir una imagen binaria, compuesta por ceros

y unos. Si buscáramos las direcciones dominantes con la imagen

binarizada, la matriz obtenida no sería tan precisa.

✗ Procesos de apertura y cierre: También conocidos como opening y

closing, se trata de dos procesos que filtran la imagen y evitan la

permanencia de puntos negros sobre fondo blanco y viceversa, puntos

blancos sobre fondo negro. Estos procesos son necesarios para mejorar

la calidad de la imagen tras la binarización, suavizando los bordes y

eliminado el ruido que pueda aparecer.

✗ Obtención de esqueletos: En este paso hemos tomado un camino

divergente a los procesos estudiados que se han realizado hasta ahora en

el IIT, pero común a muchos procesos de reconocimiento de huellas

dactilares obtenidos de la bibliografía. Este proceso es más complejo

que la búsqueda de contornos, el cual ha sido utilizado por los procesos

desarrollados en el IIT, pero el rendimiento es superior, ya que es

necesario una menor carga de cálculo para obtener los mismos



resultados que se pueden obtener con los esqueletos. Como parte

adicional a este proceso, el algoritmo superpone los esqueletos

obtenidos sobre la imagen original.

✗ Obtención de las características: Una vez que tenemos los esqueletos,

se analizan para descubrir dónde se dividen en dos, punto que será

marcado como píxel en el que existe una bifurcación.

Todos estos procesos se analizarán más concretamente en el capítulo 6, en

el que mostraremos las imágenes que el algoritmo va grabando al finalizar cada

uno de los procesos.

55 Recursos y herramientas empleadasRecursos y herramientas empleadas

Como ya hemos mencionado, el proyecto se ha desarrollado en un PC

doméstico, gobernado por un microprocesador Intel Pentium IV a 1'6 GHz con

512 MB de RAM y con la distribución GNU/Linux Debian Sid instalada. Sin

embargo, a la hora de manejar la placa hemos necesitado otra máquina, también

PC, que disponga de puerto serie. Esta máquina se encuentra gobernada por un

microprocesador Intel Pentium III a 450 MHz y con 384 MB de RAM, la cual se

encarga de compilar el código fuente y transferir el ejecutable a nuestra placa

MipScale, gobernada por el microprocesador Intel Xscale PXA255 a 400MHz y

con 32 MB, que podemos ver a continuación:

Placa MipScale



La placa MipScale posee unas características idóneas para el desarrollo

del proyecto, tales como un bajo consumo (170mA a 5V), un reducido tamaño

(80x60mm), arquitectura de 32 bits, 32 MB de memoria STRATA Flash, un

puerto USB (slave), un puerto serie (RS-232) y dispone del kernel de GNU/Linux

2.4.19 embebido.

En el apartado del software, se ha utilizado Software Libre para el

completo desarrollo del proyecto, ya que las herramientas utilizadas han sido las

siguientes:

✗ Octave, para la realización de cálculos matemáticos.

✗ The Gimp, para el retoque y conversión de las imágenes.

✗ Bluefish, como editor de texto para el código en C del algoritmo.

✗ GCC, compilador libre utilizado sobre el PC y cruzado para la

compilación del algoritmo de forma que pueda ser implantado en la

placa MipScale.

✗ gThumb, para poder ver las imágenes obtenidas.

✗ OpenOffice.org, para la redacción de éste documento.

✗ Distribución GNU/Linux Debian Sid, instalada en los ordenadores PC

utilizados.

Actuando de esta forma, únicamente se pretende apoyar al desarrollo del

Software Libre y darlo a conocer dentro del ambiente universitario.



3.- 3.- Análisis de la placa MipScaleAnálisis de la placa MipScale

La placa con la que se desarrolla el Proyecto posee un puerto serie como

única forma de transmitir información de manera bidireccional, ya que aunque

también dispone de un conector USB, éste sólo funciona en modo esclavo. Por lo

tanto, necesitamos conectar la placa a un ordenador mediante un clave de puerto

serie, 9 hilos, cruzado. Esto es necesario porque la placa no posee ningún tipo de

pantalla ni ningún dispositivo en el que se muestre información acerca de lo que

está ocurriendo, por lo tanto al ordenador al que conectamos la placa será

conocido como máquina base y servirá para controlar los procesos y aplicaciones

que se ejecuten en la placa. Normalmente hemos utilizado conexiones de red,

mediante ssh, para conectarnos a la máquina base y así poder desarrollar el

algoritmo en cualquier máquina.

11 Configuración de la máquina baseConfiguración de la máquina base

Una vez que tenemos conectada la placa al ordenador mediante el cable de

puerto serie, y alimentada con tensión (bien mediante adaptador a la red eléctrica,

bien mediante baterías), necesitamos configurar la máquina para que se

comunique con nuestra placa. Para ello necesitamos una aplicación que sea capaz

de enviar y recibir información a través del puerto serie y, como el sistema

operativo que estamos usando en la máquina base es GNU/Linux Debian, la

elección se llama minicom. Se trata de un programa de uso sencillo a través de

un terminal y para instalarlo bastaría con ejecutar, como superusuario, apt-get

install minicom lrzsz (instalamos el paquete lrzsz para poder utilizar

el protocolo de comunicación zmodem y transmitir archivos a la placa). Si todo

el proceso de instalación ha sido llevado a cabo sin ningún tipo de contratiempo,

al teclear en un terminal o en una consola el comando minicom, deberíamos leer

algo parecido a lo que muestra a continuación:



Welcome to minicom 2.1

OPCIONES: History Buffer, F-key Macros, Search History Buffer, I18nCompilado en Mar 29 2005, 09:39:09.

Presione CTRL-A Z para obtener ayuda sobre teclas especiales

El siguiente paso sería configurar el minicom para que se pueda entender

con la placa, para lo cual, y según las especificaciones del fabricante, es necesario

configurar los siguientes parámetros:

- Bits por segundo: 115.200

- Bits de datos: 8

- Paridad: ninguna

- Bits de parada: 1

- Control de flujo: ninguno

Para configurar estos parámetros es necesario pulsar simultáneamente las

teclas Control y A, para después pulsar la tecla P (también se puede pulsar la

tecla Z y consultar la ayuda del programa). Veremos una pantalla parecida a esto:

Pantalla de configuración del programa minicom



Si seleccionamos la opción de Configuración de la puerta serial, podremos

configurar estos parámetros en una pantalla parecida esta:

Configuración necesaria para el correcto funcionamiento del minicom

Pulsamos la tecla Enter para salir, seleccionamos la opción de salir y

volvemos a la interfaz del minicom en la que, si reiniciamos la placa con el

botón de Reset, podemos ver los mensajes de arranque del sistema operativo

que lleva implementado y se pueden apreciar en Apéndice B.

22 Desarrollo de una pequeña aplicaciónDesarrollo de una pequeña aplicación

Para llevar a cabo el desarrollo de una aplicación, lo primero de todo es

elegir un lenguaje apropiado. Nuestra elección ha sido el lenguaje C, debido a

que es de uso común, sencillo y suficientemente extendido. Además de elegir el

lenguaje, es necesario obtener un compilador apropiado para la máquina en la que

se va a implementar la aplicación. En nuestro caso estamos trabajando con una

placa que lleva un procesador Intel XSCALE PXA250 de 400MHz, por lo que

necesitamos un compilador, denominado cruzado, que nos permita compilar el

código deseado de manera apropiada. Este compilador lo conseguimos, entre uno



de los posibles sitios, en la web de LART (http://www.lart.tudelft.nl/). Aquí

elegimos el compilador gcc, versión 2.95.3, por ser la más apropiada para nuestra

máquina base y nuestra placa, según las especificaciones de los fabricantes. Las

instrucciones para instalar el compilador vienen detalladas en la propia web.

Por lo tanto, lo siguiente que nos queda por hacer es escribir un código en

C sumamente sencillo, como por ejemplo:

#include <stdio.h>

void main (void){printf("\n Muy Buenas:\n\n");printf("\n Éste es el primer programa que compilo\n\n");printf("\n (d\"_\"b jreyes13)\n\n");}

Éste código lo guardamos como un fichero de texto llamado prueba.c y

lo compilamos. Para llevar a cabo la compilación es necesario usar el compilador

cruzado, ejecutando el siguiente comando:

arm-linux-gcc -o prueba.arm prueba.c

Tras ejecutar este comando, obtenemos el archivo ejecutable,

prueba.arm, el cual podremos llevar a la placa MipScale y ejecutar como

cualquier otro ejecutable, en un máquina GNU/Linux, con el siguiente comando:

./prueba.arm

Como consecuencia de ésta ejecución, podremos ver:

Muy Buenas:

Éste es el primer programa que compilo

(d"_"b jreyes13)

Este proceso de ejecución de nuestro programa de prueba, así como la

transferencia del archivo a la placa, ha sido realizado a través del programa



minicom. Con éste programa, lo que hemos tenido que hacer antes de transferir

el archivo ejecutable, es arrancar el sistema operativo GNU/Linux que lleva

integrado la placa MipScale, tal y como viene explicado en el primer apéndice.

33 Prueba de la unidad de coma flotantePrueba de la unidad de coma flotante

Tal y como podemos ver en los mensajes de arranque del sistema

operativo GNU/Linux embebido en la placa MipScale, esta placa no lleva

integrada una unidad de coma flotante, sino que las operaciones en coma flotante

se resuelven mediante rutinas de software, librerías de coma flotante, cuyo

rendimiento puede ser puesto en duda. A esta conclusión hemos llegado tras

apreciar el siguiente mensaje en el arranque del sistema:

NetWinder Floating Point Emulator V0.95 (c) 1998-1999 Rebel.com

Por este motivo, hemos creído oportuno probar cómo funcionan éstas

librerías de coma flotante y, para evaluar el rendimiento que estas pueden aportar

al algoritmo, compararemos la diferencia del tiempo de proceso de un algoritmo

utilizando variables int (variables de coma fija) y utilizando variables de tipo

float (variables de coma flotante, que necesitarían el correspondiente

coprocesador matemático).

Para llevar a cabo una prueba fiel, hemos decidido programar un sencillo

filtro FIR (Finite Impulse Response, Respuesta Finita de Impulsos) sobre una

señal sinusoidal, a la que le hemos introducido ruido, para que nuestro filtro lo

elimine. Éste filtro consiste en sustituir el valor de la señal para un instante dado

por la media de los instantes anteriores. El número de instantes a tener en cuenta

para realizar el cálculo es variable, por lo que cuanto mayor sea el número de

instantes considerados, mayor será el proceso de filtrado y mejor será

uniformidad y periodicidad de la señal. Sin embargo, parece obvio que cuanto

mayor sea el número de instantes considerados, mayor será la carga de cálculo del

proceso, siendo éste unos de los objetivos de nuestra prueba.



El resultado obtenido con el filtro lo podemos observar a continuación:

0 1 2 3 4 5 6 7 8 9 10 11 12 13-2

-1,75

-1,5

-1,25

-1

-0,75

-0,5

-0,25

0

0,25

0,5

0,75

1

1,25

1,5

1,75

2

Señales obtenidas en el filtro de la señal sinusoidal

Este gráfico muestra los resultados obtenidos con el filtro, al que le hemos

introducido la señal que vemos en color magenta y hemos ido aumentando el

tamaño de la ventana de los datos, es decir el número de instantes que se utilizan

al aplicar el filtro. Para una ventana de datos pequeña (del orden de 10 datos)

obtenemos la señal en verde, para una ventana mediana (100 datos) la señal roja y

para una venta grande (1.000 datos) obtenemos la señal azul, perfectamente

filtrada, pero de menor amplitud.

El código del algoritmo utilizando para la prueba en coma fija es:

#include <stdio.h>#define DATOS 13000#define VENTANA 13

main(void) { int i,j,n; int d[DATOS],fir[DATOS],suma; for(i=0;i<DATOS;i++)



n=scanf("%d",&d[i]); for(i=0;i<DATOS;i++)

{ suma=0; for(j=0;j<VENTANA;j++) { if((i+j)<(DATOS)) suma+=d[i+j]; else suma+=0; } fir[i]=suma/VENTANA; suma=0; printf("%d\n",fir[i]);}

return 0; }

Y como podemos ver a continuación, el código del mismo algoritmo en

coma flotante, es muy similar:

#include <stdio.h>#define DATOS 13000#define VENTANA 13

main(void) { int i,j,n; float d[DATOS],fir[DATOS],suma; for(i=0;i<DATOS;i++) n=scanf("%f",&d[i]); for(i=0;i<DATOS;i++) { suma=0; for(j=0;j<VENTANA;j++) { if((i+j)<(DATOS)) suma+=d[i+j]; else suma+=0; } fir[i]=suma/VENTANA;



suma=0; printf("%f\n",fir[i]); }

return 0; }

La conclusión directa de este experimento es que hay una diferencia

considerable entre utilizar variables de tipo int o tipo float. Concretamente,

si utilizamos variables de tipo int, conseguimos que el mismo algoritmo se

llegue a ejecutar hasta treinta veces más rápido que si utilizamos variables de tipo

float.

Por lo tanto, este experimento ha marcado una premisa a la hora de

implantar el algoritmo desarrollado en este proyecto: se deben utilizar únicamente

variables de tipo int. Esta premisa implica realizar un estudio de la implantación

en coma fija, que tenga en cuenta los problemas de codificación y escalado

adecuados para que la precisión se mantenga dentro de unos límites razonables.

Además, de esta forma se elimina un grado de libertad a la hora de marcar el

estilo a seguir en la programación del algoritmo. Por éste motivo hemos decidido

utilizar variables de tipo short int, de tal forma que no superemos en ningún

momento los 32 bits de los que dispone la placa MipScale, disminuyendo así el

uso de la memoria y aumentando la velocidad del algoritmo.



4.- 4.- Formato utilizado para las imágenesFormato utilizado para las imágenes

La primera decisión importante que se ha tomado para el correcto

desarrollo del Proyecto es la elección del formato de las imágenes. Existen

multitud de formatos válidos, pero se busca un formato sencillo y que no lleve

ningún tipo de algoritmo de compresión, por lo que después de investigar acerca

de los posibles formatos se decide utilizar el formato PNM.

Este formato incluye los formatos de imagen PPM, PGM y PBM, los

cuales se utilizan para almacenar imágenes en color, imágenes en escala de grises

e imágenes en blanco y negro respectivamente. Para cada uno de los tres formatos

hay una versión binaria y otra ASCII. En el primer caso, la imagen se codifica

como una secuencia de bits y, en el segundo caso, se codifica en un archivo de

texto donde se listan los valores numéricos de cada píxel, o unidad de

información gráfica. Los archivos de PNM pueden ser identificados

automáticamente por un “código mágico” (P[1-6]) en la cabecera de fichero o

primera línea.

A lo largo del desarrollo del Proyecto se utilizará siempre la versión

ASCII, ya que suele ser la más intuitiva y más sencilla de editar e interpretar, para

el tipo de programación que estamos utilizando, tanto a la hora de leer, como a la

hora escribir imágenes.

11 El formato PBM (Portable BitMap)El formato PBM (Portable BitMap)

Este formato almacena imágenes monocromáticas. En el formato binario

se usa un bit para cada píxel y en el ASCII cada píxel se representa con un 0 ó

con un 1. Podemos ver un ejemplo a continuación en el que si escribimos lo

siguiente en un archivo de texto plano se podría ver la imagen correspondiente de

dimensión 3x3 en la que se aprecia una escalera:



P1# Ejemplo 3x3 de PBM3 3 # Ancho y alto0 0 10 1 11 1 0

Ejemplo de PBM

Este será el formato elegido (P1) para el desarrollo del proyecto cuando

utilicemos imágenes binarizadas o en blanco y negro.

22 El formato PGM El formato PGM (Portable GrayMap)(Portable GrayMap)

Este formato, a diferencia del anterior, soporta imágenes en escala de

grises (y no solamente blanco y negro) y cada píxel se representa con un byte (P5)

o con su valor en ASCII (P2). Un ejemplo de este formato podría ser:

P2# Ejemplo 3x3 de PGM3 3 # Ancho y alto15 # Valor máximo 0 3 9 3 9 12 9 12 15 Ejemplo de PGM

33 El formato PPM (Portable PixMap)El formato PPM (Portable PixMap)

Éste último formato almacena imágenes en color según el código RGB. Se

puede usar un número (cabecera P3) o un byte (cabecera P6), para el valor de

cada componente (rojo, verde, azul) de cada píxel. Los valores de cada píxel se

codifican intercalando las tres componentes. Este formato tiene como principal

ventaja su sencillez ya que cada píxel viene representado por tres números. Por

esto, para definir un píxel de color verde, utilizando este código RGB y como

valor máximo el 255 y 0 como valor mínimo, tendremos que escribir: 0 255 0. De

forma análoga definiremos un píxel rojo como 255 0 0 y uno azul como 0 0 255.

Para el caso de lo colores extremos, el negro sería 0 0 0 (ausencia de cualquier

color) y el blanco sería el valor máximo de las tres componentes: 255 255 255.

Comprobaremos esto en el siguiente ejemplo:



P3# Ejemplo 3x3 de PPM3 3 # Ancho y alto255 # Valor máximo 0 0 0 0 0 0 255 0 0 0 0 0 0 255 0 255 255 255 0 0 255 255 255 255 255 255 255 Ejemplo de PPM

Como inconveniente general de estos formatos, merece la pena destacar

que aumentan el tiempo de lectura y escritura cuando se utilizan imágenes de

gran resolución (por encima de 300x300). Esto podría ser mejorando utilizando

algún formato que permita la compresión, pero sin pérdida de información como

podría ser el formato PNG. Sin embargo, esta solución complicaría el proceso de

lectura y escritura, alejándose de uno de los intereses del proyecto, que consiste,

precisamente, en obtener un algoritmo sencillo.



5.- 5.- Las huellas dactilares y sus característicasLas huellas dactilares y sus características

Las huellas dactilares son una propiedad física propia de cada persona, de

tal forma que es posible identificar a un individuo por sus huellas dactilares. Para

llegar a una identificación exacta, se requiere el uso de métodos sofisticados, pero

es posible identificar el tipo de huella que tenemos cada uno de nosotros a simple

vista, ya que las huellas dactilares de todas las personas se pueden clasificar en

cuatro tipos: espiral, arco, lazo y compuesta. En las siguientes imágenes podemos

ver un ejemplo de cada tipo:

Huella de tipo espiral

Huella de tipo arco

Huella de tipo lazo

Huella de tipo compuesta

Sin embargo, este tipo de huella, que se ve a simple vista es, complicado

de identificar por parte de una máquina, sobre todo porque no siempre se dispone

de la huella completa, por lo que cuando se busca identificar una huella en un



proceso automático se descarta, en un principio, averiguar el tipo de la huella, y

nos centramos en algo a menor escala: las crestas y los valles. La cresta de una

huella dactilar es la parte que queda marcada (normalmente la parte que queda

marcada en negro), mientras que el valle es la parte de la huella situada entre dos

crestas. Existen formas típicas en las crestas de una huella dactilar, tal y como

podemos apreciar en la siguiente figura:

Características de una huella según la forma de sus crestas

Estas formaciones singulares que se crean con las crestas de una huella

dactilar, es lo que podemos llamar características de la huella, y son propiedades

que sí se pueden localizar de forma independiente al resto de la huella, al

contrario de lo que ocurría con el tipo de la huella, para el que necesitamos la

huella completa.



6.- 6.- Algoritmo de obtención de característicasAlgoritmo de obtención de características

La realización del algoritmo, así como su explicación, implica la

necesidad de tener una imagen con la que probarlo. Para la explicación del

proceso completo que sigue el algoritmo, vamos a elegir una imagen cualquiera

de una recopilación de huellas dactilares, como la siguiente:

Imagen completa a utilizar en la prueba del algoritmo

Imagen recortada

Además, para una mayor claridad, vamos a seleccionar una pequeña

sección en la que podremos ver los efectos del procesamiento digital de la

imagen. En esta sección elegida, podemos ver claramente una característica

importante de la huella: una bifurcación o separación de una cresta en dos, dentro

de la huella. Si el algoritmo funciona correctamente, debería detectarla.



El algoritmo desarrollado lleva a cabo una serie de procesos consecutivos

que van variando la apariencia de la imagen y, para poder analizarlos, el

algoritmo va guardando la imagen después de cada proceso. Por esta razón, para

cada uno de los procesos que realizamos, mostraremos el resultado obtenido con

la imagen original y con el pequeño fragmento de la misma que hemos obtenido.



11 Lectura del ficheroLectura del fichero

El primer paso es leer la imagen y el algoritmo escribe la primera imagen,

mostrando lo que ha leído. En el caso en el que la imagen sea con color el

algoritmo la transforma en escala de grises.

Imagen recortada leída por el algoritmo

Para poder leer esta imagen tiene que estar en el formato PPM y ASCII, es

decir, tal y como hemos comentado en el capítulo cuatro, la cabecera de la

imagen debe comenzar por P3, que de esta forma para cada píxel lee tres números

y en el caso en el que estos sean distintos (lo cual significaría que la imagen es a

color) realiza la media de estos números, obteniendo así la imagen en escala de

grises que estábamos buscando, ya que para la obtención de características no es

necesaria la información que aporta el color.

Por lo tanto, tras realizar la lectura de la imagen, el algoritmo genera un

vector de dimensión variable y de tantos campos como píxeles tiene la imagen. El

número de píxeles se obtiene multiplicando el ancho por el alto de la imagen,



datos que obtenemos de la cabecera de la imagen, según es habitual en todos los

formatos PNM, teniendo en cuenta que los datos se encuentran en ASCII.

Imagen completa leída por el algoritmo

Como vemos en esta imagen, si cogemos la imagen completa, se observa

que el proceso de lectura se ha realizado correctamente ya que la imagen obtenida

es la misma que la original, debido a que la imagen original no tiene color. Cada

uno de los píxeles de la imagen queda, entonces, representado por un valor

numérico comprendido entre 0 (negro) y 255 (blanco).



22 Atenuación y ajuste de tonalidadesAtenuación y ajuste de tonalidades

El siguiente paso es variar la intensidad de los píxeles de forma que se

pueda obtener una información más fiable a la hora de realizar los siguientes

procesos. Después de este ajuste, la imagen obtenida es la siguiente:

Imagen recortada tras ajustar tonalidades

Para obtener esta imagen ha sido necesario averiguar cuál es el valor

máximo y cuál el mínimo, lo que indica que si el valor máximo de todos los

píxeles es 255 y el valor mínimo es 0, no se realiza ningún cambio. Sin embargo,

si el valor máximo es inferior a 255, tal y como ocurre en esta imagen en la que el

píxel más claro posee el valor de 241, se ajusta de forma que el valor máximo sea

255. Esto se consigue restando a todos los valores de la imagen el valor del

mínimo, siempre y cuando este sea mayor que cero, para después, multiplicar el

valor de cada píxel por 255 y dividirlo por la diferencia entre el valor máximo y

el valor mínimo.

Con este proceso lo que buscamos es que en las sucesivas operaciones que

realicemos sobre la imagen se pierda la mínima información posible ya que



únicamente utilizamos números enteros porque al realizar operaciones con

decimales, perderíamos valores decimales que podrían llegar a ser importantes.

Imagen completa tras ajustar tonalidades

En esta imagen vemos cómo influye este proceso en la imagen completa,

viendo cómo realmente parece una imagen más clara.



33 Ajuste de negros y blancos fijos por direccionesAjuste de negros y blancos fijos por direcciones

El tercer proceso consiste en buscar los píxeles que son seguro negro o

que son seguro blanco, de forma que un posterior proceso de binarización o paso

a blanco y negro, éste sea más efectivo, obteniendo lo que vemos a continuación:

Imagen recortada tras buscar blancos y negros por direcciones

Para este proceso hacemos uso de máscaras direccionales, es decir, una

especie de filtros que nos permiten observar los píxeles que hay alrededor de un

píxel concreto, según una dirección en concreto. Esto lo conseguimos gracias

doce imágenes creadas para la ocasión y que nos encargaremos de cargar dentro

del propio algoritmo. Éstas máscaras son doce porque vamos a utilizar los

siguientes ángulos: 0º, 15º, 30º, 45º, 60º, 75º, 90º, 105º, 120º, 135º, 150º y 165º.

A partir de 165º ya no tiene sentido utilizar una máscara porque sería información

repetida, ya que la máscara de 180º sería exactamente igual a la máscara de 0º.

Tampoco sería útil utilizar un mayor número de máscaras, debido a que

aumentaría mucho el tiempo del proceso y no así los resultados obtenidos.



Las máscaras que el algoritmo carga provienen de doce archivos de

imagen con el formato PBM, que mostramos a continuación:

Máscara de 0º

Máscara de 15º

Máscara de 30º

Máscara de 45º

Máscara de 60º

Máscara de 75º

Máscara de 90º

Máscara de 105º

Máscara de 120º

Máscara de 135º

Máscara de 150º

Máscara de 165º

De esta forma, el proceso que realizamos ahora es ir comprobando píxel a

píxel si existe alguna dirección en la que se observe que predomina el blanco o el

negro sobre todos los demás. En el caso en el que se detecte una dirección con un

tono (negro o blanco) dominante, ese píxel se convierte en blanco puro (255) o



negro (0), de forma que no haya ninguna duda en el siguiente proceso de

binarización y, en el caso en el que no haya una ninguna dirección con un tono

dominate, el píxel correspondiente se deja con el valor original.

Imagen completa tras buscar blancos y negros por direcciones

Como se puede ver en esta imagen, la parte central de las crestas de la

huella queda definida como negro, mientras los valles quedan como blancos,

existiendo píxeles dudosos en los bordes de las crestas.



44 Búsqueda de direccionesBúsqueda de direcciones

En el tercer proceso, ya comentado, se va evaluando si existe alguna

dirección en la que se pueda afirmar que existe alguna tonalidad dominante y, si

esto ocurre, se graba esta dirección dentro de un vector de la misma dimensión y

características, a partir del cual se obtiene esta imagen, a modo de matriz de

direcciones:

Imagen obtenida de la matriz direcciones de la imagen recortada

En esta imagen se puede ver la dirección dominante, según el color que

posea cada píxel, que se corresponde con la escala que vemos a la derecha de la

imagen. En el caso en el que no exista una dirección dominante, el color elegido

es el amarillo. Como se puede ver en esta imagen, se ha creado un margen en la

misma, necesario para poder aplicar las máscaras, de forma que no se produzcan

errores en los cálculos. El ancho de éste margen se corresponde con la mitad

menos uno del ancho de las máscaras. En nuestro caso, las máscaras poseen un

ancho fijo de 13 píxeles, por lo que el margen necesario debe tener un ancho de 7

píxeles. Como puede quedar claro, a lo largo del margen de la imagen, las

direcciones no van a quedar definidas, por lo que el margen quedará siempre de


0º15º30º45º60º75º90º105º120º135º150º165º


color amarillo. Esto puede provocar una pérdida de información importante en

imágenes pequeñas (como es el caso del recorte), pero no así en imágenes

grandes, como la que vemos a continuación:

Imagen obtenida de la matriz direcciones de la imagen completa

Como podemos ver en esta imagen, el resultado queda mucho más claro

cuando la imagen es más grande y hace pensar que los puntos han sido

clasificados de forma correcta.


0º15º30º45º60º75º90º105º120º135º150º165º


55 Binarizado de la imagen o paso a blanco y negroBinarizado de la imagen o paso a blanco y negro

Una vez que se han fijado píxeles negros y blancos, según las direcciones

y la información de los píxeles cercanos, llega la hora de definir todos los píxeles,

a negro o blanco, lo cual es necesario para simplificar los siguientes procesos, ya

que no mejoran los resultados utilizando escala de grises y sí aumenta

considerablemente el tiempo de proceso. El resultado de este proceso lo podemos

ver en la siguiente imagen:

Imagen recortada pasada a blanco y negro (binarizada)

El proceso utilizado para la binarización es un proceso reiterativo y muy

utilizado para imágenes en escala de grises. El proceso consiste en realizar un

histograma con la cantidad de valores repetidos en cada franja y estimar un valor

medio (µ), el cuál significará que es el valor mínimo de blanco, es decir,

cualquier píxel por debajo de ese valor será negro y cualquier píxel de un valor

mayor o igual, será blanco. Una vez calculado este valor, realizaremos la media

de los valores blancos (µ1) y la media de los valores negros (µ2), obteniendo un

nuevo valor de mínimo de blanco, según la siguiente ecuación:



µ'=12·µ1µ2

Este proceso lo repetimos hasta que el valor de mínimo blanco no varíe o

hasta que alcancemos la reiteración número 13. El resultado sobre la imagen

completa los vemos a continuación:

Imagen completa pasada a blanco y negro (binarizada)

En ésta imagen podemos ver cómo todos los píxeles ya han sido definidos

como negros o como blancos, no existiendo ningún píxel gris.



66 Proceso de apertura y erosiónProceso de apertura y erosión

Los siguientes cuatro procesos están relacionados entre sí, ya que el son

muy similares y basados en el mismo principio: contar y estudiar los píxeles de

alrededor. Estos procesos son conocidos como erosión y dilatación. En la

siguiente imagen, vemos el efecto de la erosión:

Imagen recortada erosionada, buscando la apertura

En este proceso de la erosión, solamente se mantiene un píxel negro si está

rodeado por píxeles negros en su totalidad, es decir, cada píxel está rodeado por

otros ocho píxeles, por lo que si un píxel negro, está rodeado por ocho píxeles

negros, el píxel seguirá siendo negro después del proceso de erosión, pero pasará

a ser blanco si no está rodeado es su totalidad por píxeles negros.

Con este proceso, al que se suele conocer como “opening” y del que la

erosión es el primer paso, lo que estamos buscando es una apertura de la imagen,

de forma que aumente el número de espacios en blanco y sólo queden los

espacios negros que sean más densos o completos. Así es posible filtrar pequeños

píxeles negros aislado que puedan aparecer debido a ruido y se pueden limar los



apéndices que puedan existir, quedando una imagen más limpia, como podemos

ver a continuación en la imagen completa:

Imagen completa erosionada, buscando la apertura

En esta imagen observamos algo importante, que no es otra cosa que la

pérdida de información que hemos sufrido, especialmente en la parte del recorte

que estamos usando, por lo que no vamos a poder comprobar esa zona, pero sí

vamos a poder apreciar el resultado final y las consecuencias del proceso

completo.



77 Proceso de apertura y dilataciónProceso de apertura y dilatación

Tras el proceso de erosión en busca de la apertura de la imagen, le toca el

turno a la dilatación de la imagen, proceso que contrarresta la erosión anterior,

llevando a cabo una cierta reconstrucción de la imagen, tal y como se puede

observar en la siguiente imagen:

Imagen recortada dilatada en el proceso de apertura

En este proceso de dilatación realizamos justo la operación inversa que en

el proceso anterior, ya que únicamente conservamos como píxel blanco, aquel

que está completamente rodeado de píxeles blancos, consiguiendo así volver más

densas las zonas negras cerrando los huecos que se han podido formar.

La dilatación es un procesos tal útil como necesario, ya que es

fundamental volver a recuperar todos los píxeles que se han perdidos durante el

proceso de erosión porque, si las crestas de las huellas quedan demasiado

delgadas, podrían fallar los procesos posteriores de obtención de características.

Es por esto, por lo que cuando hablamos del proceso de apertura (o de “opening”



como se suele conocer) estamos hablando de una erosión y su posterior

dilatación. Este proceso también lo podemos ver en la imagen completa:

Imagen completa dilatada en el proceso de apertura

Tras el proceso de dilatación vemos cómo hemos recuperado el grosor de

las crestas de la huella, pero han aparecido nuevos problemas, como son píxeles

blancos rodeados de píxeles negro que solucionaremos en próximos procesos.



88 Proceso de cerrado y dilataciónProceso de cerrado y dilatación

Tras el proceso de apertura nos espera un proceso que ayudará a cerrar

aquellos huecos que puedan ser descriptivos y, por lo tanto, necesarios para poder

obtener correctamente las características que estamos buscando. Esto lo

conseguimos repitiendo el proceso de dilatación, como podemos ver la imagen

siguiente:

Imagen recortada dilatada en el proceso de cerrado

En éste proceso estamos completando el binomio apertura-cerrado, de

forma que podamos unir ciertas crestas que pueden haber sido separadas en el

proceso de apertura anterior.

Como cabe esperar, este proceso de cierre, también conocido como

“closing” funciona de forma análoga al proceso de apertura, ya que en este caso

lo que vamos a realizar es una primera dilatación, para una posterior erosión, de

forma que consigamos el efecto contrario al proceso de apertura



Este primer proceso de dilatación lo podemos apreciar en la siguiente

imagen, en la que observamos cómo, efectivamente, se van cerrando los espacios

en blanco:

Imagen completa dilatada en el proceso de cerrado

Aparentemente, se han perdido muchas crestas, pero no debemos olvidar

que todavía nos queda el posterior proceso de erosión, que sin duda liberará

crestas, aunque no se descarta el haber perdido ciertas crestas dudosas.



99 Proceso de cerrado y erosiónProceso de cerrado y erosión

Como noveno proceso del algoritmo, llega el turno de finalizar el binomio

apertura-cierre (“opening-closing”) y, por lo tanto, llega el turno de la segunda

erosión, en que, como podemos ver en la siguiente imagen, se consiguen otra vez

las crestas estilizadas del principio, pero considerablemente mejor perfiladas:

Imagen recortada erosionada en el proceso de cierre

En el caso de la imagen recortada, vemos cómo, efectivamente, las crestas

quedan de forma perfilada y clara y de un ancho aceptable.

Tras observar los resultados de los cuatro últimos procesos se comprende

la necesidad de estos para conseguir eliminar posibles ruidos que pueda tener la

imagen así como para cerrar los huecos o píxeles blancos que puedan aparecer

dentro de las huellas.

Como inconvenientes de estos procesos hemos podido observar que al

dilatar la imagen o al erosionarla, se pueden producir pérdidas de determinadas

crestas, que luego pueden ser fundamentales a la hora de encontrar ciertas



características, tal y como podemos ver a continuación en la imagen completa

dilatada:

Imagen completa erosionada en el proceso de cierre

Efectivamente, vemos que en la imagen completa hemos perdido crestas

que han quedado ocultas, pero no debemos olvidar que buscamos características y

de esta forma estamos filtrando las que pueden ser dudosas y aclarando las más

obvias.



1010 Obtención de esqueletosObtención de esqueletos

Una vez que tenemos las crestas de la huella lo suficientemente perfiladas,

llega el momento de obtener los esqueletos de las crestas o, lo que es lo mismo,

reducir al máximo posible su grosor, hasta que sea de aproximadamente un píxel,

tal y como se puede ver en la siguiente imagen:

Esqueletos obtenidos de la imagen recortada

Nuestro fin es llegar a encontrar las características importantes de la

huellas y, en especial, las bifurcaciones, por lo que no nos aporta ninguna

información el grosor de las crestas, sino sus direcciones principales, las cuales

ya hemos buscado al realizar la binarización.

Al conseguir adelgazar al máximo las crestas, podemos ver las

bifurcaciones cuando los esqueletos de la imagen se dividan en tres. En un

principio y vistos los resultados que hemos obtenido, no nos centraremos en

encontrar la terminaciones de las huellas, ya que durante el proceso de erosión se

han podido provocar terminaciones que no existen realmente en la huella



original. El resultado de la obtención de esqueletos se puede observar a

continuación sobre la imagen completa:

Esqueletos obtenidos de la imagen completa

Al realizar el proceso de búsqueda de esqueletos sobre la imagen

completa, vemos que los resultados no son los esperados debido, posiblemente, al

proceso de dilatación que ha anulado una parte importante de la huella, por lo que

resulta necesario el siguiente proceso.



1111 Perfeccionamiento de los esqueletosPerfeccionamiento de los esqueletos

Aunque en la imagen recortada hemos visto que el proceso de obtención

de esqueletos ha sido suficientemente bueno, en la imagen completa no ha sido

así, por lo que se ha visto que resulta necesario perfeccionar los esqueletos, o por

lo menos perfilarlos. Éste proceso no se puede apreciar en la siguiente imagen,

igual a la anterior, debido a que estos esqueletos se encuentran perfectamente

perfilados:

Esqueletos de la imagen recortada, perfeccionados

Sin embargo en la imagen completa si resulta necesario perfeccionarlos de

la mejor manera posible. Al repetir el proceso de obtención de esqueletos, no se

consigue mejorar la calidad de estos, por lo que la decisión tomada ha sido

limitarnos a obtener los contornos de los esqueletos obtenidos.

Con esta solución, no podemos obtener las bifurcaciones interiores, pero sí

podemos aplicar el posterior proceso que buscará puntos en los que se unan tres

ramas de un esqueleto, pudiendo así encontrar ciertas bifurcaciones que han



quedado claras en los nuevos esqueletos tal y como podemos apreciar en la

siguiente imagen, resultado de haber perfeccionado los esqueletos anteriores:

Esqueletos de la imagen completa, perfeccionados

En esta imagen vemos como hemos eliminado las zonas en las que no se

distinguía nada y hemos conservado los esqueletos claros, para no eliminar

ninguna posible bifurcación.



1212 Superposición de los esqueletos sobre la imagen originalSuperposición de los esqueletos sobre la imagen original

Este proceso, no busca mejorar el algoritmo de reconocimiento, pero sí

busca aclarar un poco cuál ha sido el resultado de la obtención de los esqueletos.

Para lograr esto y demostrar que los esqueletos obtenidos se corresponden con la

imagen de una manera fiel, el algoritmo superpone los esqueletos sobre la imagen

original, tal y como se puede ver en la siguiente imagen:

Esqueletos superpuestos sobre la imagen recortada original

Merece la pena destacar que los esqueletos se han superpuesto sobre la

imagen leída original, pero variando su color para conseguir una imagen más

clara, asignando a cada píxel del esqueleto, el color que le corresponde según la

matriz de direcciones calculada cuando se binarizó la imagen. El valor que le

corresponde a cada color se puede ver en la escala que hemos situado a la derecha

de la imagen y vemos que realmente los resultados conseguidos son lógicos y

aceptables.

También se puede observar cómo se han perdido los datos que se

encuentran dentro del margen de 7 píxeles que se creó al realizar la búsqueda de


0º15º30º45º60º75º90º105º120º135º150º165º


direcciones. Ésta es una perdida necesaria para mantener la resolución original de

la imagen y que en un principio no supone una pérdida importante, tal y como se

puede apreciar cuando la imgen es más grande como es el siguiente caso:

Esqueletos superpuestos sobre la imagen completa original

Aquí podemos ver cómo los esqueletos de la imagen completa, quedan

correctamente superpuestos sobre la imagen completa original.



1313 Obtención de característicasObtención de características

Tras la binarización, los procesos de apertura y cierre y la obtención de los

esqueletos, llega el momento de alcanzar el objetivo fundamental de éste

algoritmo: Obtener las características y, en concreto las bifurcaciones, tal y como

se puede ver en la siguiente imagen:

Característica encontrada (bifurcación) en la imagen recortada.

Con ayuda del programa de cálculo matemático, octave, vamos a explicar

en qué consiste el proceso de búsqueda de características. Al igual que en caso de

la binarización, se va evaluando píxel a píxel del esqueleto de la imagen, solo que

en este caso nos centraremos únicamente en los píxeles de color negro.

A estos píxeles negros les aplicamos las máscaras ya comentadas en el

proceso de binarización y analizamos los valores mínimos del histograma

obtenido, según el resultado de multiplicar los píxeles del esqueletos por los

valores de la máscara, obteniéndose valores bajos si los píxeles de la máscara

coinciden con el esqueleto y obteniéndose valores altos si esto no ocurre.



Aquí podemos ver el histograma del píxel con la característica:

Histograma de direcciones en un píxel con una bifurcación

Y en este otro histograma, vemos que no existe ninguna característica:

Histograma de direcciones en un píxel sin ninguna característica



El método para encontrar características consiste en analizar los

histogramas de forma que entre el valor máximo del histograma y el valor

mínimo exista una diferencia mayor de 130 unidades, un valor lógico, teniendo

en cuenta que el valor máximo puede ser hasta 255 y el valor mínimo más

pequeño puede ser 0. Una vez que nos hemos asegurado la diferencia mínima, se

debe cumplir que los mínimos estén separados y no sean consecutivos, ni

tampoco estén demasiado dispersos.

El resultado de éste último proceso sobre la imagen completa, sería el

siguiente:

Características encontradas en la imagen completa.



En vista de los resultados obtenidos sobre la imagen completa, no queda

ninguna duda que este algoritmo es el primer paso de un largo camino hacia el

reconocimiento de huellas dactilares, pero un paso importante en el que se ha

fijado un método efectivo de forma clara y cuya depuración escapa ya de este

proyecto, pero queda abierta a nuevas pruebas y futuros desarrollos.



7.- 7.- Experimentos y ResultadosExperimentos y Resultados

A lo largo del capítulo anterior hemos visto el funcionamiento del

algoritmo, así como los procesos que se llevan a cabo sobre la imagen, pero cabe

destacar que no es necesario realizar todos estos procesos, ya que podemos

mejorar el resultado si no se realizan los procesos de apertura o cierre, o si

evitamos el filtro de tonalidades por direcciones. Volvamos a utilizar la imagen

anterior:



Huella dactilar binarizada

Si comenzamos a procesar ésta imagen, sin realizar los procesos de

apertura y cierre, podemos ver que no filtraremos los puntos de ruidos que

aparecen alrededor, ni rellenaremos los poros que hay dentro de las huellas, pero,

como podemos ver a continuación, el resultado de los esqueletos obtenidos

mejora considerablemente:

Esqueletos obtenidos de la huellas dactilar

En este caso vemos cómo los esqueletos han salido realmente más fieles

que los que salieron en el capítulo anterior, pero ha sido a cosa de la existencia de



ruido. Este ruido queda traducido en los píxeles rojos que se ven entre los

esqueletos, los cuales implican que son píxeles cuya dirección es elevada (a partir

de 135º). siempre y cuando esta tonalidad roja sea aislada, ya que los que no se

encuentran aislados serán píxeles cuya dirección es realmente elevada. A esta

imagen le aplicaremos el proceso en el que descubrimos las bifurcaciones:

Características encontradas en la huella dactilar

Aquí vemos cómo seis bifurcaciones han sido localizadas de forma clara,

aunque también se han detectado puntos como bifurcaciones que no lo son, pero



esto puede ser mejorado aumentando la resolución de la imagen o introduciendo

sólo un fragmento de la huella.

A continuación, vamos a utilizar otra imagen en la que veremos que a

pesar de ser de características completamente diferentes, se obtienen resultados

incluso mejores a los ya comentados. La imagen de partida es la siguiente:

Imagen original de la huella dactilar

Como podemos ver en esta nueva imagen, las características son

diferentes, ya que existe una menor diferencia de contraste en la huella y, además,

se puede observar como la parte central o núcleo de la misma, se encuentra peor

diferenciada que la parte periférica. Esto va a provocar que al tratar la imagen

como un todo, ésta parte periférica se desvanezca dentro del fondo, siendo

filtrada a costa de ganar mayor claridad en la parte central. Éste hecho puede



anular bifurcaciones importantes del perímetro dándonos lugar a las bifurcaciones

de la parte central, la cual nunca obtiene los mejores resultados, por que la

densidad de las crestas es mayor, es decir, en la parte periférica las crestas están

más separadas, viéndose con más claridad los valles y, por lo tanto, obteniéndose

las bifurcaciones de una forma más fiel y verdadera, mientras que en la parte

interior se detectan algunas bifurcaciones que no son reales y dan, por lo tanto un

resultado incorrecto.

En la siguiente imagen vemos cómo el proceso de atenuación ha

destacado, como era de esperar la parte central de la huella, es decir, su núcleo:

Imagen original atenuada, destacando el núcleo de la huella

Merece la pena destacar que en este caso hemos anulado el proceso de

asignación de tonalidades por direcciones, ya que al existir tanta diferencia entre



entre la parte del perímetro de la huella y su parte central, emborronaría este

núcleo de la huella, dejando sólo legible la parte externa de la huella.

Sin embargo, sí puede ser útil obtener la matriz de direcciones de la huella

ya que puede dar lugar a ciertas comprobaciones posteriores, así como ser

necesaria para el proceso de perfeccionamiento de los esqueletos. Esta matriz la

podemos ver reflejada por colores en la siguiente imagen:

Matriz de direcciones obtenida de la huella dactilar

En esta matriz podemos observar cómo se han detectado direcciones de

manera incorrecta en los valles, de forma que si realizásemos la asignación de

tonalidades por direcciones, en el núcleo de la huella los valles sería convertidos

a crestas y las crestas mantendrían su condición de cresta. El resultado sería que

la parte central se haría completamente oscura y borde completamente claro.


0º15º30º45º60º75º90º105º120º135º150º165º


Es por esto por lo que dejamos el paso a una imagen de blanco y negro al

proceso de binarización, en el que los resultados obtenidos son más aceptables

para estos casos. De esta forma podemos conseguir la siguiente imagen en la que

vemos como las crestas y los vales han sido correctamente diferenciadas:

Huella binarizada de forma independiente a las direcciones

Viendo esta imagen binarizada, nos hace esperar una correcta obtención

de los esqueletos aceptable aunque la presencia de abundantes puntos negros,

deben ser interpretados como ruido y, por lo tanto, deben se filtrados. Para

realizar un correcto proceso de filtrado lo que vamos a realizar es el primer

proceso de la apertura de la imagen, esto es, vamos a llevar a cabo una erosión de

la imagen, pero sin la posterior dilatación, que completaría el proceso de apertura.



Al prescindir del proceso de dilatación, la siguiente imagen será la

empleada para obtener los esqueletos, y podemos ver que el resultado puede ser

considerado como correcto:

Esqueletos obtenidos superpuestos en la imagen original

Para una mayor claridad, mostramos directamente la imagen en la que

vemos los esqueletos superpuestos sobre la imagen original, viendo cómo,

efectivamente, la parte de la periferia de la huella ha pasado al anonimato,

perdiéndose, tal vez, información importante.

Sin embargo, es importante apreciar cómo la parte central de la huella ha

quedado clara y sin las excesivas zonas rellenas completamente, que ocultan las

bifurcaciones que se pueden encontrar en el núcleo de la huella.



Por lo tanto, en el último proceso se obtienen unos puntos críticos donde

se señala la existencia de bifurcaciones, tal y como se puede apreciar en la

siguiente imagen:

Características encontradas en la huella dactilar

En esta última imagen, tal vez deberíamos evaluar la posibilidad de que la

característica encontrada sea real si la concentración de los utilizados puntos

verdes es mayor y su distancia relativa muy pequeña.



8.- 8.- ConclusionesConclusiones

Como conclusión general del proyecto podemos afirmar que se ha cubierto

el objetivo fundamental que consiste en obtener características de una huella

dactilar. Decimos que hemos obtenido características de una huella dactilar

porque, aunque el algoritmo busca bifurcaciones, el proceso seguido puede ser

empleado para detectar otras características concretas como cruces,

terminaciones, islas o cualquier otra característica que pueda ser interesante.

Este proyecto ha servido como recopilación actual de las últimas técnicas

desarrolladas en Instituto de Investigación Tecnológica (IIT) dentro del campo de

reconocimiento de huellas dactilares. Éste es un campo en el que el IIT lleva

investigado desde hace varios años, pero que durante los dos últimos años no ha

recibido ninguna nueva aportación. Además, todos los desarrollos realizados

hasta ahora, siempre se habían usado grandes infraestructuras, máquinas potentes

y software propietario. Éste proyecto es, por lo tanto, un intento de realizar una

fusión y mejora de los proyectos actuales, así como ampliar el campo de

investigación, abriendo nuevos horizontes, como el software libre y la realización

de reconocimiento de huellas dactilares en pequeños dispositivos. Sin embargo,

está claro que éste proyecto no ha podido abarcar todos los proyectos realizados

hasta ahora en el IIT, pero estos sí han sido un pilar importante en el que apoyar

el algoritmo desarrollado, dando claras orientaciones sobre los procesos a

realizar, así como esclarecer los posibles problemas que puedan surgir, cuando

alguien comienza a estudiar el apasionante campo del reconocimiento de

individuos mediante su huella dactilar.

Como valor añadido, en este proyecto se realiza una introducción al

procesamiento digital de una imagen. Con las tecnologías actuales, cada vez más

potentes, los dispositivos de bolsillo ya son perfectamente capaces de realizar



complejos procesos, que hace un par de años no se podían ni imaginar o,

simplemente, parecían utópicos.

Por otra parte, se ha comprobado que el algoritmo puede ser

implementado de forma realmente sencilla en una placa actual, similar a la que

utilizan los ordenadores de bolsillo que muchas veces quedan relegados a ser

utilizados como simples dispositivos en los que apuntar datos y leer algún que

otro archivo, sin llegar a exprimir ni siquiera una cuarta parte de sus

posibilidades.



9.- 9.- Futuros desarrollosFuturos desarrollos

La necesidad de desarrollar un nuevo algoritmo, menos dependiente del

uso de grandes dispositivos, así como de cierto software propietario ha diezmado

los objetivos originales del proyecto dejando, por tanto, muchas posibilidades

abiertas.

Hemos comprobado que los resultados obtenidos pueden ser claramente

mejorados, ya que no son realmente fiables al cien por cien, aunque sí pueden ser

útiles si se utilizan con precaución. Por lo tanto, éste proyecto es, como ya se ha

comentado, el primer escalón de una larga escalera en constante construcción.

Esto es debido a que hemos comenzado un proceso de reconocimiento de huellas

dactilares, pero nos hemos quedado en la obtención de características. Si

observamos la bibliografía, vemos cómo todavía quedan procesos por

implementar dentro del algoritmo, o consecutivos a éste, en los que, una vez

obtenidas las características de la huella, es necesario rotar, trasladar y comparar

dichas características para poder indicar si la huella analizada corresponde o no a

un determinado individuo.

Por lo tanto, además de ampliar el algoritmo con nuevos procesos que

permitan completar el reconocimiento de una huella dactilar, hay varios procesos

ya programados que podrían ser mejorados, para así obtener resultados más

fiables. El primer proceso que debería ser mejorado, sería el proceso de filtrado

de tonalidades por direcciones, en el que se decide si un píxel es negro o blanco

en función de las direcciones dominantes de los píxeles de su alrededor.

Hablando del proceso de determinación de direcciones, éste también podría ser

mejorado drásticamente, de forma que pudiera cargar mascaras de dimensión

variable o que incluso genere y cargue la máscaras más apropiadas para el tipo de

huella que se esté analizando. También hemos observado cómo el proceso de

obtención de esqueletos no es del todo satisfactorio, por lo que podría ser



mejorado, junto con el proceso de detección de características. Además, el

resultado de estos dos procesos depende de la conveniencia de realizar los

procesos de apertura y cierre. En la versión actual del algoritmo, estos procesos

se realizan a juicio del usuario, pero podría darse el caso de que fuera el propio

algoritmo el que decidiera si se deben realizar o no estos procesos, ya que según

hemos visto en nuestros experimentos estos procesos pueden mejorar o empeorar

los resultados finales.

Dentro del proceso de obtención de características, hemos utilizado un

formato para las imágenes que no lleva integrado ningún algoritmo de

compresión. La razón por la que se ha tomado ésta decisión es que uno de los

objetivos del proyecto busca, sobre todo, la sencillez en el algoritmo. Sin

embargo, es posible que el uso de algún algoritmo de compresión pueda aminorar

el tiempo que el algoritmo invierte en la lectura del fichero, a costa de tiempo de

proceso, algo que puede reducir el tiempo total del proceso de obtención de

características de huellas dactilares.

Como parte final del proceso de reconocimiento de huellas dactilares,

sería interesante disponer de una base de datos con huellas dactilares del mayor

número posible de individuos. Sin embargo, esto ya escapa del uso de

dispositivos pequeños, ya que sería necesario una alta capacidad, la cual es el

talón de alquiles de los dispositivos de bolsillo debido, fundamentalmente, al alto

precio que las unidades de almacenamiento portátiles poseen. Sería, por tanto

necesario, realizar algún tipo de comunicación del pequeño dispositivo con un

gran servidor de datos donde se almacenarán las huellas dactilares, clasificadas

siempre que sea posible. De esta forma se podría utilizar el pequeño dispositivo

para recopilar la huella dactilar y analizarla, obteniendo las características y

enviándolas al servidor de huellas dactilares, obteniendo a cambio la posible

identidad del dueño de la huella analizada.

Extrapolando los procesos utilizados en este proyecto, podemos romper

los límites impuestos y utilizarlos para otras aplicaciones centradas en el



procesamiento digital de una imagen, como pueden ser el reconocimiento de

caracteres o la detección de movimiento, investigando diferencias entre imágenes

o detectando objetos definidos previamente.



10.- 10.- BibliografíaBibliografía

[1] Rafael C. González, Richard E. Woods. Digital Image Procesing.

PEARSON, Prentice Hall. 2001.

[2] Rafael C. González, Richard E. Woods, Steven L. Eddins. Digital Image

Procesing Using MATLAB. PEARSON, Prentice Hall. 2004.

[3] Mónica Arias Parra. Desarrollo de Algoritmos de Filtrado de Imágenes de

Huellas Dactilares. Proyecto Fin de Carrera, IIT. 2001.

[4] Ismael Corrales Toribio. Extracción de Características Descriptivas de


[5] Daniel Gutiérrez Rodríguez. Algoritmo de Comparación de

Características para el Reconocimiento de Huellas Dactilares. Proyecto

Fin de Carrera, IIT. 2001.

[6] Bárbara Carlón Sainz. Extracción de Características Singulares de


[7] Víctor Manuel Sombría Rodríguez. Identificación y Clasificación de


[8] Página web de LART (http://www.lart.tudelft.nl/): Herramientas de

compilación.

[9] Página web de MicroPowerSoft (http://www.micropowersoft.com/):

Empresa fabricante de la placa MipScale.



[10] Página web de FVC (Fingerprint Verification Competition ó Competición

de verificación de huellas dactilares, http://bias.csr.unibo.it/fvc2004/):

Web del laboratorio de sistemas biométricos de la universidad de Bolonia,

que organiza una competición de reconocimiento de huellas dactilares.

[11] Página web de la Interpol sobre el reconocimiento de huellas dactilares:

http://www.interpol.int/public/Forensic/fingerprints/WorkingParties/IEEG

FI/ieegfiEs.asp

[12] Página web de VeriFinger (http://www.ex-cle.com/ESSdkVf.htm):

Aplicación comercial para realizar el reconocimiento de huellas dactilares.

Merece la pena destacar el listado de precios de las licencias de cada

programa: http://www.ex-cle.com/ESVFPrecios.htm

[13] Página web de GNU/Linux (http://www.linux.org/): Abundante

información y manuales sobre GNU/Linux.

[14] Página web oficial de GNU/Linux Debian (http://www.debian.org/):

Distribución GNU/Linux Debian e instrucciones de instalación.



EESTUDIOSTUDIO ECONÓMICOECONÓMICO



11.- 11.- Análisis del mercadoAnálisis del mercado

Hemos buscado algún tipo de software que realice reconocimiento de

huellas dactilares, pero los resultados obtenidos no han sido muy alentadores. En

mundo del software libre y código abierto, no hemos encontrado nada destacable,

mientras que en el ambiente comercial se encuentran programas complejos de

utilizar y todavía en pleno desarrollo. El precio de los programas comerciales de

desarrollo oscilan alrededor de los 500€ por una licencia y para uso no comercial.

Si queremos tener ánimo de lucro con el uso del software, el precio de una

licencia profesional asciende a unos 1.000 ó 1.500 €. En estos casos lo que

recibimos es un conjunto de archivos ejecutables que llevan a cabo el proceso de

reconocimiento de huellas dactilares, sin que el usuario pueda llegar a

comprender cómo funciona éste software ni cuáles son los procesos que sigue la

acción del reconocimiento.

Sin embargo, si queremos disponer del código fuente de algún programa

comercial, hay ciertas empresas que lo ofrecen a cambio de elevadas cantidades

de dinero (por encima de los 3.000€) y siempre y cuando no haya el más mínimo

ánimo de lucro con los posibles beneficios o conocimientos que se puedan

adquirir a partir del código de fuente suministrado, por lo que sólo se admite su

uso para fines educativos y docentes, tal y como figura en el contrato que

usualmente es necesario aceptar al recibir el código fuente.

En otro ambiente completamente distinto, se encuentra los dispositivos

con sensores de huellas dactilares integrados. Estos dispositivos usan su propio

lector integrado y almacenan una serie de estampaciones de un mismo usuario.

Lo normal es que le pidan al usuario una media de diez estampas de un mismo

dedo, para que éstas sean almacenadas en el propio dispositivo, y hasta un

máximo de diez dedos, pudiendo ser así ser compartido por hasta diez usuarios,

siempre y cuando cada usuario utilice únicamente un dedo. Por lo tanto, estos



pequeños dispositivos se limitan a aceptar o denegar el acceso a un usuario al

dispositivo si este posee o no posee, respectivamente, su huella grabada dentro

del dispositivo. La consecuencia de estos procesos utilizados por los dispositivos

pequeños, cuyo precio oscila entre los 100 y los 300€, es que son demasiados

permisivos, dándose el caso de que acceda un usuario no autorizado, o que son

demasiado estrictos, denegando el acceso a un usuario válido porque no ha

colocado la huella con la misma orientación, o porque su huella ha sufrido alguna

herida leve.



12.- 12.- Posibilidades del algoritmo desarrolladoPosibilidades del algoritmo desarrollado

Las posibilidades que puede tener un algoritmo de reconocimiento de

huellas dactilares son muy elevadas, sobre todo si disponemos del código fuente.

Dado que las tecnologías aumentan de manera exponencial, ya estamos en un

momento en el que se puede implantar el reconocimiento de huellas dactilares en

casi cualquier dispositivo, como por ejemplo una simple lavadora (recientemente

ha aparecido un modelo que se asegura que varios miembros de la familia la

pongan en funcionamiento de forma alternada, para que no sea siempre la misma

persona la que pone a lavar la colada).

Sin embargo, no solo se puede utilizar la huella dactilar para acceder o no

acceder a un dispositivo, sino que una posible utilidad puede ser asegurar la

identidad de un usuario a la hora de realizar una compra a través de Internet,

acceder al mercado de la banca electrónica o para hacer realidad de una vez por

todas el popular y siempre lejano DNI electrónico. Incluso puede llegar a sustituir

a la ineficaz firma gráfica, la cual carece de validez al utilizar tarjetas de crédito o

de débito, ya que nunca suele ser comprobada de manera fiable.

Por lo tanto, estamos en un momento en el que los pequeños dispositivos

con sensores para huellas dactilares se están abriendo mercado de manera real y

esto está provocando que la sociedad lo empiece a ver como algo útil y natural,

algo que siempre ha estado a nuestro servicio y que hasta ahora la técnica no nos

ha permitido disfrutar.

En resumen, este proyecto puede tener múltiples usos con ánimo de lucro

siempre y cuando sea apoyado y desarrollado, ahora que la tecnología actual

permite su uso de forma eficaz.



MMANUALANUAL DEDE USUARIOUSUARIO



13.- 13.- Ejecución del algoritmoEjecución del algoritmo

Para ejecutar el algoritmo es necesario compilarlo primero, utilizando el

compilador apropiado para la arquitectura que se va a utilizar. Para el caso de un

equipo con GNU/Linux Debian instalado, el comando es sencillo (suponiendo

que el código del algoritmo se encuentra en el archivo img.c):

gcc -o img img.c

Una vez que tenemos el ejecutable, basta con indicarle qué archivo es el

que queremos que analice, mediante el siguiente comando:

./img < nombredelarchivo.ppm

Como consecuencia veremos cómo van apareciendo mensajes

informándonos de los procesos que el algoritmo va siguiendo, los valores

máximo y mínimo, el valor de blanco y el número de iteraciones que realiza hasta

depuerar los esqueletos:

ALGORITMO DE RECONOCIMIENTO DE HUELLAS DACTILARES (v1.05)

Leyendo fichero... ...fichero leido (300x300, 90000 píxeles)

Calculando Maximo y Minimo... ... Maximo: 255 y Minimo: 71

Atenuando la imagen... ...imagen atenuada... ...fichero grabado


Buscando direcciones... ... direcciones calculadas ......ficherograbado


Calculando el valor de minimo blanco... Propuesta inicial de blanco: 139 Propuesta n1 de NUEVO blanco: 119 Propuesta n2 de NUEVO blanco: 113 Propuesta n3 de NUEVO blanco: 111



Propuesta n4 de NUEVO blanco: 110 Propuesta n5 de NUEVO blanco: 110... Valor blanco: 110

Generando imagen binarizada... ...imagen binarizada... ...ficherograbado

INICIO DEL OPENING Erosionando imagen... ...imagen erosionada... ...fichero grabado Dilatando imagen... ...imagen dilatada... ...fichero grabado FIN DEL OPENING

INICIO DEL CLOSING Dilatando imagen... ...imagen dilatada... ...fichero grabado Erosionando imagen... ...imagen erosionada... ...fichero grabado FIN DEL CLOSING

Buscando esqueletos... 1-> 2429: 0 2-> 1803: 2429 3-> 1305: 1803 4-> 1027: 1305 5-> 843: 1027 6-> 744: 843 7-> 664: 744 8-> 610: 664 9-> 569: 610 10-> 539: 569 11-> 520: 539 12-> 501: 520 13-> 489: 501 14-> 471: 489 15-> 464: 471 16-> 453: 464 17-> 444: 453 18-> 442: 444 19-> 441: 442 20-> 436: 441 21-> 435: 436 22-> 434: 435 23-> 430: 434 24-> 426: 430 25-> 424: 426 26-> 422: 424 27-> 419: 422 28-> 418: 419 29-> 417: 418 30-> 416: 417 31-> 416: 416 32-> 414: 416 33-> 414: 414 34-> 415: 414 35-> 416: 415 36-> 414: 416 37-> 412: 414 38-> 412: 412 39-> 412: 412 40-> 411: 412 41-> 411: 411 42-> 411: 411 43-> 410: 411 44-> 410: 410 45-> 410: 410 46-> 410: 410 ...esqueletos encontrados... ...fichero grabado

Perfilando esqueletos... ...esqueletos perfilados... ...ficherograbado

Buscando caracteristicas... ...caracteristicas encontradas... ...fichero grabado

Fin del programa... ... y memoria liberada



14.- 14.- Configuración de los parámetros del procesoConfiguración de los parámetros del proceso

En la cabecera del algoritmo se definen una serie de parámetros que

permiten modificar el algoritmo anulando procesos, que hemos podido ver que

mejoran, en cierta medida, los resultados obtenidos:

#define FILTRADO_DIRECCION 0 /* Poner a 1 si se quiere filtrar porlas direcciones */

Con esta primera opción anulamos la definición de la tonalidad de un

píxel en función de los píxeles que posea a su alrededor y dejamos el proceso de

binarización únicamente al cálculo del valor de blanco.

#define OPEN_ERO 0 /* Poner a 1 si se erosionar en el procesode opening */

Con esta segunda opción anulamos la erosión del proceso de apertura.

#define OPEN_DIL 0 /* Poner a 1 si se dilatar en el proceso deopening */

Con esta tercera opción la dilatación del proceso de apertura.

#define CLOSE_DIL 0 /* Poner a 1 si se dilatar en el proceso declosing */

Con esta cuarta opción anulamos la dilatación en el proceso de cierre.

#define CLOSE_ERO 0 /* Poner a 1 si se erosionar en el procesode closing */

Con esta quinta y última opción anulamos el proceso de erosión en el

proceso de cierre.

Sabemos que esta no es la mejor manera de modificar los procesos, pero

afectan los suficiente al resultado, como para que sólo alguien que sepa realmente

lo que está haciendo pueda modificarlos. Se podrían haber configurado de forma



que estos parámetros los leyera de una archivo, pero se ha descartado esta opción

debido a que puede llegar a provocar confusión y problemas en la ejecución del

algoritmo, siendo más fiable el método elegido, tratándose de un algoritmo

todavía en desarrollo.



AAPÉNDICEPÉNDICE A: U A: USOSO DEDE LALA PLACAPLACA M MIPIPSSCALECALE



Para arrancar el sistema operativo GNU/Linux que lleva embebido la

placa MipScale es necesario teclear el comando boot en el sencillo interfaz de

comandos que aparece al resetear la placa con el botón que ésta posee, algo que

no siempre es necesario, pero si recomendable si no vemos nada en la pantalla del

minicom. Al arrancar la placa, podemos ver los siguientes mensajes:

UFF

F

0STP

1STP

2STP 3STP 4STP 5STP 6STP MTST 00000001 00000002 00000004 00000008 00000010 00000020 00000040 00000080 00000100 00000200 00000400 00000800 00001000 00002000 00004000 00008000 00010000



00020000 00040000 00080000 00100000 00200000 00400000 00800000 01000000 02000000 04000000 08000000 10000000 20000000 40000000 80000000 A0000000 DEADBEEF 48000000 000009A9 48000004 0005B018 48000008 7FF07FF0 4800000C 7FF07FF0 48000010 7FF07FF0 ENDM DUCK STKP A19F3FF0 &_start=00000000 FLASH_BASE=00000000 boot_flags_ptr=A19F3FFC *boot_flags_ptr= Make DRAM section cacheable: A0400000Make DRAM section cacheable: A0500000Make DRAM section cacheable: A0600000Make DRAM section cacheable: A0700000Make DRAM section cacheable: A0800000Make DRAM section cacheable: A0900000Make DRAM section cacheable: A0A000Make DRAM section cacheable: A0B00000Make DRAM section cacheable: A0C00000Make DRAM section cacheable: A0D00000Make DRAM section cacheable: A0E00000Make DRAM section cacheable: A0F00000



Make DRAM section cacheable: A1000000Make DRAM section cacheable: A1100000Make DRAM section cacheable: A1200000Make DRAM section cacheable: A1300000Make DRAM section cacheable: A1400000Make DRAM section cacheable: A1500000Make DRAM section cacheable: A1600000Make DRAM section cacheable: A1700000Make DRAM section cacheab Make DRAM section cacheable: A1900000Make DRAM section cacheable: A1A00000Make DRAM section cacheable: A1B00000Make DRAM section cacheable: A1C00000Make DRAM section cacheable: A1D00000Make DRAM section cacheable: A1E00000Make DRAM section cacheable: A1F00000Map Flash virtual section to DRAM at: A1E0000000000000 A1E00C0A 00000040 04000C02 00000080 08000C02 00000100 10000C02 00000140 14000C02 00000000 A1E00C0A 00000500 00000C02 00000A00 A0000C0E 00000A40 A4000C02 00000E00 E0000C02 Flash style = 2x16 queryFlash(0x13) returns 0x00000001verify flash size... btflash_init: mfrid=00890089 devid=00180018 walking flash descriptors (2x16) btflash_init: found flash 28F128J3A flashDescriptor=00020DE4 flashSectors=00020BC4 nsectors=00000080 flash_size=02000000 flash_address_mask=01FFFFFF Machine type--> iPAQ 3900 mach_type ->000000CB allocated partition_table defining partition: bootldr defining partition: root defining partition: asset Probing bank0 memory size... bank0 memory size=02000000



SDRAM size: 0x020 in megs: 32M >> Compaq OHH BootLoader, Rev 2-19-40 [BIG_KERNEL] [MD5] [MONO]>> 02-11-06_12:09 >> Last link date: Wed Nov 6 12:09:17 CET 2002>> Contact: [email protected]

Cpu company: INTEL Cpu Architecture: XScale Cpu Part: PXA250 (Cotulla) >> ARM Processor Rev=00050000 >> (c) 2000-2001 Compaq Computer Corporation, provided with NOWARRANTY under the terms of the GNU General Public License.>> See http://www.handhelds.org/bootldr/ for full license andsourcesPress Return to start the OS now, any other k DEBUG BOOT: not evaluating params DEBUG BOOT: use `params eval' to evaluate parameters.boot> boot booting jffs2... booting boot/zImage from partition >root<Scanning all of flash for your JFFS2 convenience. Est Time: 6-12seconds!build_list: max = 01F7FFBC . dir entries = 00000310 frag entries = 0000096F +4 increments = 00000000 +file_offset increments = 00000CBFloaded file of size = 0x0007F000 at location 0xA0008000kernel partition base A0008000 kernel_magic=E1A00000 kernel_region_words[9]=016F2818 Linux ELF flash_imgstart=50040000 size=01F80000 dest=A0000000offset=00008000MMU Control=00000079 MMU PIDVAM=00000000 Skipping kernel copy by request. A0008000: E1A00000 A0008004: E1A00000 A0008008: E1A00000 A000800C: E1A00000 A0008010: E1A00000 A0008014: E1A00000 A0008018: E1A00000 A000801C: E1A00000 A0008020: EA000002



A0008024: 016F2818 root_filesystem_name=ramdisk Grabbed linuxargs, argc = 00000001Using mach_type 000000CB setting boot parameters to noinitrd root=/dev/mtdblock1 init=/linuxrc console=ttySA0Making core tag at A0000100 Making cmdline tag at A0000114 Making mem32 tag at A00001D4 command line is: mtdparts=ipaq:0x00040000@0x00000000(bootldr)ro,0x01F80000@0x00040000(root),0x00040000@0x01FC0000(asset) noinitrdroot=/dev/mtdblock1 init=/linuxrc console=ttySA0 rootfstype=jffs2linuxEntryPoint=A0008000 Booting Linux image CP15 r0=69052903 CP15 r1=00000079 CP15 r2=A19F4000 CP15 r3=FFFFFFFF CP15 r5=0000040C CP15 r6=F533FFFF CP15 r7=FFFFFFFF CP15 r8=FFFFFFFF CP15 r9=FFFFFFFF CP15 r10=FFFFFFFF CP15 r13=00000000 CP15 r14=7DF7FF9F CP15 r15=FFFFFFFF Uncompressing Linux...................................... done,booting the kernel. Linux version 2.4.19-rmk2-pxa2 (tomas@viento) (gcc version 2.95.320010315 (release)) #5 Mon Nov 11 16:43:20 CET 2002CPU: Intel XScale-PXA250 revision 3Machine: Intel DBPXA250 Development PlatformIgnoring unrecognised tag 0x00000000Memory clock: 99.53MHz (*27) Run Mode clock: 199.07MHz (*2) Turbo Mode clock: 398.13MHz (*2.0, inactive)On node 0 totalpages: 8192 zone(0): 8192 pages. zone(1): 0 pages. zone(2): 0 pages. Kernel command line: mem=32M rw root=/dev/mtdblock1console=ttyS0,115200n8Calibrating delay loop... 99.32 BogoMIPSMemory: 32MB = 32MB total



Memory: 31128KB available (966K code, 245K data, 44K init)Dentry cache hash table entries: 4096 (order: 3, 32768 bytes)Inode cache hash table entries: 2048 (order: 2, 16384 bytes)Mount-cache hash table entries: 512 (order: 0, 4096 bytes)Buffer-cache hash table entries: 1024 (order: 0, 4096 bytes)Page-cache hash table entries: 8192 (POSIX conformance testing by UNIFIXLinux NET4.0 for Linux 2.4 Based upon Swansea University Computer Society NET3.039Initializing RT netlink socket Starting kswapd JFFS2 version 2.1. (C) 2001 Red Hat, Inc., designed by AxisCommunications AB.Keyboard interface test failed[1]: 5fffbff7Keyboard interface test failed[2]: 08Keyboard interface test failed[3]: 0ainitialize_kbd: Keyboard reset failed, no ACKpty: 256 Unix98 ptys configured Serial driver version 5.05c (2001-07-08) with no serial optionsenabledKeyboard timed out[1] keyboard: Timeout - AT keyboard not present?Keyboard timed out[1] keyboard: Timeout - AT keyboard not present?ttyS00 at 0x0000 (irq = 14) is a PXA UARTttyS01 at 0x0000 (irq = 13) is a PXA UARTttyS02 at 0x0000 (irq = 12) is a PXA UARTSA1100 Real Time Clock driver v1.00Probing Lubbock flash at physical address 0x00000000Using buffer write method Using static partition definition Creating 3 MTD partitions on "Lubbock flash":0x00000000-0x00040000 : "bootldr" mtd: Giving out device 0 to bo 0x00040000-0x01fc0000 : "root" mtd: Giving out device 1 to root 0x01fc0000-0x02000000 : "asset"mtd: Giving out device 2 to assetNET4: Linux TCP/IP 1.0 for NET4.0IP Protocols: ICMP, UDP, TCPIP: routing cache hash table of 512 buckets, 4KbytesTCP: Hash tables configured (established 2048 bind 2048)NetWinder Floating Point Emulator V0.95 (c) 1998-1999 Rebel.comVFS: Mounted root (jffs2 filesystem).Freeing init memory: 44KINIT: version 2.78 bootingMounting local filesystems...Setting the System Clock using the Hardware Clock as reference...



INIT: Entering runlevel: 2Configuring network interfaces: done.Not recalculating module dependenciesLoading modules:Starting OpenBSD Secure Shell server: sshd.Starting syslogd/klogd: done

thechangers login:

Al llegar a éste punto, nos pide un nombre de usuario y una

password, que según viene explicado por el fabricante de la placa, el nombre

de usuario por defecto, según viene de fábrica, es root y el password rootme.

Si accedemos al sistema, podremos ver lo siguiente:

login[108]: root login on `ttyS0'

~ #

Una vez que hemos alcanzado la shell de la placa sólo queda indicar

que con el comando rz, la placa se queda a la espera de archivos que podemos

transferir a través del programa minicom, utilizando el protocolo zmodem, así

como que con el comando sz <nombredelarchivo>, recibimos el archivo

que se encuentra en la placa.



AAPÉNDICEPÉNDICE B: C B: CÓDIGOÓDIGO DELDEL PROGRAMAPROGRAMA



#include <stdio.h>#include <string.h>#include <stdlib.h>

#define MINIMO_ESQUELETO 169#define MAXIMO_ESQUELETO 169

#define FILTRADO_DIRECCION 0 /* Poner a 1 si se quiere filtrar porlas direcciones */#define OPEN_ERO 0 /* Poner a 1 si se erosionar en el procesode opening */#define OPEN_DIL 0 /* Poner a 1 si se dilatar en el proceso deopening */#define CLOSE_DIL 0 /* Poner a 1 si se dilatar en el proceso declosing */#define CLOSE_ERO 0 /* Poner a 1 si se erosionar en el procesode closing */

short int *imagen,*direcciones,*imagenOriginal;int i=0,j=0,ancho,alto,mancho,malto,mn,melemento;long int n;

void LeerFichero(void){ char a; short int elemento; int elementos; i=0;

a=getchar(); /* Tenemos que leer una P, 80 en ASCII */ if(a!=80)

{ printf("\nError en el formato de la imagen (debe

empezar por P)\n\n"); exit(0); }

a=getchar(); /* Tenemos que leer una 3, 51 en ASCII */ if(a!=51) { printf("\nError en el formato de la imagen (debe

empezar por P3)\n\n"); exit(0); }

a=getchar(); /* Tenemos que leer un salto de linea, 10 enASCII */

if(a!=10) {



printf("\nError en el formato de la imagen (debeempezar por P3, mas un salto de linea)\n\n");

exit(0); }

a=getchar(); /* Tenemos que leer una almohadilla (#), 35 enASCII */

if(a!=35) { printf("\nError en el formato de la imagen (la segunda

linea debe ser un comentario)\n\n"); exit(0); }

do /* Lectura de la cabecera PPM, segunda lineacomentada */

{ a=getchar();

i++; } while(a!=10);

scanf("%d %d",&ancho,&alto); /* Leemos dimensiones dela imagen */

n=ancho*alto; /* Calculamosel numero de elementos del archivo */

imagen=(short int *)calloc(n,sizeof(short int)); /*

Reservamos memoria para leer la imagen */ if(!imagen) { printf("\nError al reservar la memoria para abrir la

imagen\n\n"); exit(0); } imagenOriginal=(short int *)calloc(n,sizeof(short int));/* Reservamos memoria para leer la imagen */ if(!imagen) { printf("\nError al reservar la memoria para almacenar

la imagen original\n\n"); exit(0); } scanf("%d",&elemento); /* Leemos un 255 que hay al

principio */

for(i=0;i<n;i++) /* Leemos los elementos de la imagen,almacenandolos en un puntero */

{ elementos=0; for(j=0;j<3;j++)



{ scanf("%d",&elemento); elementos+=elemento; }

elemento=elementos/3; imagen[i]=elemento; imagenOriginal[i]=elemento;}

direcciones=(short int *)calloc(n,sizeof(short int)); /*Reservamos memoria para leer la matriz de direciones */

if(!direcciones) { printf("\nError al reservar la memoria para crear la

matriz de direciones\n\n"); exit(0); }

for(i=0;i<n;i++) /* Inicialización de la imagen temporal avalor de blanco */

direcciones[i]=255;

}

short int CalculaMaximo(void){ short int valor=0; for(i=0;i<n;i++) if(imagen[i]>valor) valor=imagen[i]; if(valor>255)

valor=255; return valor;}

short int CalculaMinimo(void){ short int valor=255; for(i=0;i<n;i++) if(imagen[i]<valor) valor=imagen[i];

if(valor<0)valor=0;



return valor;}

short int Histograma(short int maximo,short int minimo){ short int

blanco=0,blancoNUEVO=0,blancoABAJO=0,blancoARRIBA=0; long int contador=0,sumatorio=0; long int *valores; FILE *fhist;

/* maximo=255; minimo=0;

*/ valores=(long int *)calloc(256,sizeof(long int)); if(!valores) { printf("\nError al reservar la memoria para crear los

valores del histograma\n\n"); exit(0); } if(!(fhist=fopen("hisblanc.txt","w+"))) /* Abrimos el

archivo para almacenar el histograma */ { printf("\nError al abrir el archivo para el

histograma\n\n"); exit(0); }

for(i=minimo;i<=maximo;i++) {

for(j=0;j<=n;j++) if(imagen[j]==i) valores[i]++;

fprintf(fhist,"Valor %3d: %d\n",i,valores[i]);}

fprintf(fhist,"\n------------------------------------------\n"); fprintf(fhist," TABLA RESUMEN: Valores mayores que cero\n");

fprintf(fhist,"------------------------------------------\n");

for(i=minimo;i<=maximo;i++) if(valores[i]>0) {

contador=contador+valores[i];



fprintf(fhist,"Valor %3d: %8d, %8d de %d\n",i,valores[i],contador,n);

if(contador>n/2 && blanco==0) {

fprintf(fhist,"------------------------------------------\n");

blanco=i; }

} fprintf(fhist,"------------------------------------------\n");

fprintf(fhist,"\n------------------------------------------\n"); fprintf(fhist," Comando para la representación enOctave\n");

fprintf(fhist,"------------------------------------------\n");

fprintf(fhist,"bar(["); for(i=minimo;i<=maximo;i++)

if(valores[i]>0) fprintf(fhist," %d ",i);

fprintf(fhist,"],["); for(i=minimo;i<=maximo;i++)

if(valores[i]>0) fprintf(fhist," %d ",valores[i]);

fprintf(fhist,"])\n"); fprintf(fhist,"------------------------------------------

\n");

blancoNUEVO=blanco;

printf("\n\t Propuesta inicial de blanco: %d",blancoNUEVO); j=1; do { blanco=blancoNUEVO; contador=0; sumatorio=0;

for(i=minimo;i<blanco;i++) { contador=contador+valores[i]; sumatorio=sumatorio+i*valores[i]; } blancoABAJO=sumatorio/contador;

for(i=blanco;i<=maximo;i++) { contador=contador+valores[i];



sumatorio=sumatorio+i*valores[i]; } blancoARRIBA=sumatorio/contador;

blancoNUEVO=(blancoABAJO+blancoARRIBA)/2; printf("\n\t Propuesta n%d de NUEVO blanco: %d",j,blancoNUEVO); j++;

} while (blancoNUEVO!=blanco && j<13);

if(fclose(fhist)==EOF) /* Cerramos el archivo en el quese almacena el histograma */

{ printf("\nError al cerrar el archivo para el

histograma\n\n"); exit(0); } free(valores); return blanco;}

void Atenuacion(short int maximo,short int minimo){ int elemento; if(minimo>0) for(i=0;i<=n;i++) imagen[i]=imagen[i]-minimo;

if((maximo-minimo)<255) for(i=0;i<=n;i++) imagen[i]=imagen[i]*255/(maximo-minimo);}

short int *CargaMascara(void){ short int *mascara, nmascara; FILE *mascaras; char letra; char nombre[9]="m01.ppm";

mascara=(short int *)calloc(169*12,sizeof(short int));/* Reservamos memoria para las direcciones de la imagen */ if(!imagen)

{ printf("\nError al reservar la memoria para la

máscara\n\n"); exit(0);}



for(nmascara=1;nmascara<13;nmascara++) { if(nmascara<10) nombre[2]=48+nmascara; else if(nmascara<13) { nombre[1]=49; nombre[2]=48+nmascara-10; }

mascaras=fopen(nombre,"r"); if (!mascaras) {

printf("Error al abrir el archivo de lamáscara");

exit(0); }

letra=fgetc(mascaras); /* Tenemos que leer una P,80 en ASCII */ if(letra!=80)

{ printf("\nError en el formato de la imagen (debe

empezar por P)\n\n"); exit(0); }

letra=fgetc(mascaras); /* Tenemos que leer una 1, 51en ASCII */

if(letra!=49) { printf("\nError en el formato de la imagen (debe

empezar por P3)\n\n"); exit(0); }

letra=fgetc(mascaras); /* Tenemos que leer un salto delinea, 10 en ASCII */

if(letra!=10) { printf("\nError en el formato de la imagen (debe

empezar por P1, mas un salto de linea)\n\n"); exit(0); }

letra=fgetc(mascaras); /* Tenemos que leer unaalmohadilla (#), 35 en ASCII */



if(letra!=35) { printf("\nError en el formato de la imagen (la

segunda linea debe ser un comentario)\n\n"); exit(0); }

do /* Lectura de la cabecera PPM, segunda lineacomentada */

{ letra=fgetc(mascaras); } while(letra!=10);

fscanf(mascaras,"%d",&mancho); /* Leemosdimensiones de la mascara */

fscanf(mascaras,"%d",&malto); /* Leemosdimensiones de la mascara */

mn=mancho*malto;// printf("\n %2d || Ancho: %d, Alto: %d, Total: %d",nmascara,mancho,malto,mn);

for(i=0;i<mn;i++) { fscanf(mascaras,"%d",&melemento); mascara[(nmascara-1)*mn+i]=melemento; } } return mascara;}

short int BuscaDirecciones(long int valores[24],short int opcion){ int

maximo=0,minimo=255,minimo2=255,indicemin=0,indicemin2=0,indicemax=0;

/* printf("\n");

for(i=0;i<24;i++) printf("%d:%d ",i,valores[i]);

*/ for(i=1;i<13;i++) { if(valores[2*i-2]==13) {

if(valores[2*i-1]>=maximo) { maximo=valores[2*i-1]; /* Valor de

blanco */



indicemax=i; }

if(valores[2*i-1]<=minimo) { minimo=valores[2*i-1]; /* Valor de

negro */ indicemin=i; } }}

switch(opcion) { case 1:

if(maximo>169 || minimo<130) { if(((255*7)/10-maximo)<(minimo-(255*3)/10)) return indicemax*10+3; /* BLANCO: El

resto entero de 10 es 1 */ else

return indicemin*10+1; /* NEGRO: Elresto entero de 10 es 3 */

} break; case 2: if((maximo-minimo)>130) {

for(i=1;i<13;i++) { if(valores[2*i-2]==13) {

if(valores[2*i-1]<=minimo2 &&i!=indicemin)

{ minimo2=valores[2*i-1];

/* Valor de negro */ indicemin2=i;

} }}

if((indicemin-indicemin2)>3 && (indicemin-indicemin2)<9)

return 20; /* Hay una característica*/

else {

if((indicemin2-indicemin)>3 &&(indicemin2-indicemin)<9)

return 20; /* Hay unacaracterística */



else return 240; /* No hay una

característica */}

} else return 240; /* No hay una característica */ break;

default: if(minimo<MINIMO_ESQUELETO) return indicemin*10+1; /* NEGRO: El resto

entero de 10 es 3 */ break;

} return 255;}

void BinarizaImagen(int blanco){ for(i=0;i<n;i++) /* Filtro blanco y negro */ { if(imagen[i]>blanco) imagen[i]=255; else imagen[i]=0;

}}

long int Coordenadas(int x,int y){ long int coordenada; coordenada=y*ancho+x; return coordenada;}

long int *Alrededor(long int coordenada,short int campo){ long int *cercano; int x,y;

y=coordenada/ancho; x=coordenada%ancho;

// printf("\n (%d,%d)=%d",x,y,coordenada);

switch(campo) {



case 1: cercano=(long int *)calloc(8,sizeof(long int));

if(!cercano){ printf("\nError al reservar la memoria para

crear el alrededor del píxel\n\n"); exit(0);

} cercano[0]=Coordenadas(x-1,y-1); cercano[1]=Coordenadas( x ,y-1); cercano[2]=Coordenadas(x+1,y-1); cercano[3]=Coordenadas(x-1, y ); cercano[4]=Coordenadas(x+1, y ); cercano[5]=Coordenadas(x-1,y+1); cercano[6]=Coordenadas( x ,y+1); cercano[7]=Coordenadas(x+1,y+1); break; case 6: cercano=(long int *)calloc(2*campo+1,sizeof(long

int));if(!cercano)

{ printf("\nError al reservar la memoria para

crear el alrededor del píxel\n\n"); exit(0);

}for(i=1;i<=13;i++)

for(j=1;j<=13;j++)cercano[13*(i-1)+j-1]=Coordenadas(x-

7+j,y-7+i); break;

}

return cercano;}

void ProcesaImagen(short int opcion){ long int *cercano,coordenada,valor,valorNUEVO,valorN,valores

[24]; int x,y; short int *mascara,*imagenTMP,suma; FILE *fpíxel;

imagenTMP=(short int *)calloc(n,sizeof(short int)); /*Reservamos memoria para leer la imagen */

if(!imagen) {



printf("\nError al reservar la memoria para crear laimagen temporal\n\n");

exit(0); }

for(i=0;i<n;i++) /* Inicialización de la imagen temporal avalor de blanco */

imagenTMP[i]=255;

switch(opcion) { case 1: /* Proceso de erosión */ for(y=1;y<(alto-1);y++)

for(x=1;x<(ancho-1);x++){

coordenada=Coordenadas(x,y); cercano=Alrededor(coordenada,1); suma=0; for(i=0;i<8;i++) suma=suma+imagen[cercano[i]]/

255; if(suma>0) imagenTMP[coordenada]=255; else imagenTMP[coordenada]=0;

free(cercano); }

break; case 2: /* Proceso de dilatación */ for(y=1;y<(alto-1);y++)


coordenada=Coordenadas(x,y); cercano=Alrededor(coordenada,1); suma=0; for(i=0;i<8;i++) suma=suma+imagen[cercano[i]]/

255; if(suma>7) imagenTMP[coordenada]=255; else imagenTMP[coordenada]=0;

free(cercano); }

break; case 3: /* Búsqueda de direcciones */ mascara=CargaMascara(); for(y=7;y<(alto-7);y++)




coordenada=Coordenadas(x,y); cercano=Alrededor(coordenada,6); for(i=1;i<13;i++) { valores[2*i-2]=0; valores[2*i-1]=0; for(j=0;j<169;j++) { valor=mascara[(i-1)

*169+j]*imagen[cercano[j]]; if(mascara[(i-1)*169+j]!

=0) { valores[2*i-1]

=valores[2*i-1]+valor; valores[2*i-2]++; } }

valores[2*i-1]=valores[2*i-1]/valores[2*i-2];

} direcciones[coordenada]

=BuscaDirecciones(valores,1); if(FILTRADO_DIRECCION==1) { if(direcciones[coordenada]%

10==1) imagenTMP[coordenada]=0; else { if(direcciones

[coordenada]%10==3) imagenTMP

[coordenada]=255; else imagenTMP

[coordenada]=imagen[coordenada]; }}

else imagenTMP[coordenada]=imagen

[coordenada]; free(cercano);

}free(mascara);

break; case 4: /* Contornos al descubierto */ j=0;



do { i=0; j++;

for(y=1;y<(alto-1);y++)for(x=1;x<(ancho-1);x++)

{ coordenada=Coordenadas(x,y); cercano=Alrededor

(coordenada,1); if(imagen[coordenada]==0) { suma=0; for(i=0;i<8;i++) suma=suma+imagen

[cercano[i]]/255; if(suma<1) { i++; imagenTMP

[coordenada]=255; } else imagenTMP

[coordenada]=0; } else imagenTMP[coordenada]

=imagen[coordenada]; free(cercano);

} suma=i;

for(i=0;i<n;i++)imagen[i]=imagenTMP[i];

}while(suma!=8&&j<169); break; case 5: /* Esqueletos al descubierto */ j=0; valor=0; valorNUEVO=0; valorN=0; printf("\n"); do { valorNUEVO=valor; valor=0; j++;

for(y=1;y<(alto-1);y++)for(x=1;x<(ancho-1);x++)



{ coordenada=Coordenadas(x,y); cercano=Alrededor

(coordenada,1); if(imagen[coordenada]==0) { suma=0; for(i=0;i<8;i++) if(imagen[cercano

[i]]==0) suma=suma+1; switch(suma) { case 8: imagenTMP

[coordenada]=imagen[coordenada]; break; case 7: imagenTMP

[coordenada]=imagen[coordenada]; break; case 6: imagenTMP

[coordenada]=imagen[coordenada]; break; case 5: if(imagen

[cercano[0]]==255&&imagen[cercano[1]]==255&&imagen[cercano[3]]==255)

imagenTMP[coordenada]=255;

else if(imagen[cercano[1]]==255&&imagen[cercano[2]]==255&&imagen[cercano[4]]==255)






else

imagenTMP[coordenada]=imagen[coordenada]; break; case 4:



if(imagen[cercano[0]]==0&&imagen[cercano[2]]==0&&imagen[cercano[5]]==0&&imagen[cercano[7]]==0)

imagenTMP[coordenada]=imagen[coordenada];

else if(imagen[cercano[1]]==0&&imagen[cercano[6]]==0)




else if(imagen[cercano[0]]==0&&imagen[cercano[1]]==0&&imagen[cercano[4]]==0&&imagen[cercano[7]]==0)








else

imagenTMP[coordenada]=255; break; case 3: if(imagen


imagenTMP[coordenada]=imagen[coordenada];else if(imagen



















































else

imagenTMP[coordenada]=255; break; case 2: if(imagen

[cercano[1]]==0&&imagen[cercano[3]]==0)

imagenTMP[coordenada]=imagen[coordenada]; else if(imagen

















else

imagenTMP[coordenada]=255; case 1:


break; case 0: imagenTMP

[coordenada]=255; break; }

if(imagenTMP[coordenada]==255&&suma!=1)

valor++;}

else imagenTMP[coordenada]

=imagen[coordenada]; free(cercano);

} for(i=0;i<n;i++)

imagen[i]=imagenTMP[i]; printf("%3d->%5d:%5d ",j,valor,valorNUEVO); if(j%5==0) printf("\n");

for(i=0;i<n;i++) imagenTMP[i]=imagen[i];

for(y=7;y<(alto-7);y++) for(x=7;x<(ancho-7);x++)

{ coordenada=Coordenadas(x,y);

if(imagen[coordenada]==0) {



cercano=Alrededor(coordenada,1);

suma=0; for(i=0;i<8;i++)

if(imagen[cercano[i]]==0)

suma=suma+1; switch(suma) {

case 3: if(imagen


imagenTMP[cercano[4]]=0; else if(imagen[cercano[2]]==0&&imagen[cercano[4]]==0&&imagen[cercano[5]]==0)



imagenTMP[cercano[4]]=0;






break; case 2: if(imagen


imagenTMP[cercano[3]]=0; else if(imagen[cercano[2]]==0&&imagen[cercano[6]]==0)













else if(imagen[cercano[0]]==0&&imagen[cercano[7]]==0) {



} else if(imagen[cercano[2]]==0&&imagen[cercano[5]]==0) {



}

break; } free(cercano);

} }

for(i=0;i<n;i++) imagen[i]=imagenTMP[i];



if(valor==valorNUEVO) valorN++; else valorN=0; }while(valorN<3&&j<MAXIMO_ESQUELETO);

break; case 6: /* Búsqueda de Características */ mascara=CargaMascara(); for(y=7;y<(alto-7);y++)

{ for(x=7;x<(ancho-7);x++)

{ coordenada=Coordenadas(x,y); if(imagen[coordenada]==0) { cercano=Alrededor

(coordenada,6); for(i=1;i<13;i++) { valores[2*i-2]=0; valores[2*i-1]=0; for(j=0;j<169;j++) { valor=mascara[(i-1)

*169+j]*imagen[cercano[j]]; if(mascara[(i-1)

*169+j]!=0) { valores[2*i-

1]=valores[2*i-1]+valor; valores[2*i-

2]++; } }

valores[2*i-1]=valores[2*i-1]/valores[2*i-2];

}

/* printf("\n (%3d,%3d):%3d=%3d >bar([" ,x,y,coordenada,imagen[coordenada]); for(i=1;i<13;i++)

printf("%d ",i); printf("],["); for(i=1;i<13;i++) printf("%d ",valores[2*i-

1]); printf("])");

*/ direcciones[coordenada]

=BuscaDirecciones(valores,2);



free(cercano); } else direcciones[coordenada]=240; } }

free(mascara); break; case 7: /* Perfilado de esqueletos */ for(i=0;i<n;i++) { if(imagen[i]==255) direcciones[i]=240; imagenTMP[i]=imagen[i]; } break;

} for(i=0;i<n;i++)

imagen[i]=imagenTMP[i];

free(imagenTMP);}

void GeneraFichero(char nombre[13],char px[2],char comentario[39]){ FILE *fhuella; if(!(fhuella=fopen(nombre,"w+"))) /* Abrimos el

archivo para almacenar la matriz */ { printf("\nError al abrir el archivo para la

imagen\n\n"); exit(0); }

fprintf(fhuella,"%s\n# %s\n%d %d\n",px,comentario,ancho,alto);

if(px[1]==49) /* Formato P1 de PPM */ { for(i=0;i<n;i++) { if(imagen[i]>0) fprintf(fhuella,"0 "); else fprintf(fhuella,"1 "); }



}

if(px[1]==51) /* Formato P3 de PPM */ { fprintf(fhuella,"255\n"); for(i=0;i<n;i++) for(j=0;j<3;j++) fprintf(fhuella,"%d\n",imagen[i]); }

if(fclose(fhuella)==EOF) /* Cerramos el archivo enel que se almacena la matriz */

{ printf("\nError al cerrar el archivo para la

matriz\n\n"); exit(0); }}

void GeneraFicheroDireccion(char nombre[13]){ FILE *fhuella; short int angulo; if(!(fhuella=fopen(nombre,"w+"))) { printf("\nError al abrir el archivo para las

direcciones\n\n"); exit(0); }

fprintf(fhuella,"P3\n# Imagen de direcciones\n%d %d\n255\n",ancho,alto);

for(i=0;i<n;i++) { angulo=direcciones[i]/10; switch (angulo) { case 1: fprintf(fhuella," 64 192 0\n"); break; case 2: fprintf(fhuella," 0 255 0\n"); break; case 3: fprintf(fhuella," 0 192 64\n"); break;



case 4: fprintf(fhuella," 0 128 128\n"); break; case 5: fprintf(fhuella," 0 64 192\n"); break; case 6: fprintf(fhuella," 0 0 255\n"); break; case 7: fprintf(fhuella," 64 0 192\n"); break; case 8: fprintf(fhuella,"128 0 128\n"); break; case 9: fprintf(fhuella,"192 0 64\n"); break; case 10: fprintf(fhuella,"255 0 0\n"); break; case 11: fprintf(fhuella,"192 64 0\n"); break; case 12: fprintf(fhuella,"128 128 0\n"); break; case 24: fprintf(fhuella,"%d %d %d\n",imagenOriginal

[i],imagenOriginal[i],imagenOriginal[i]);// fprintf(fhuella,"255 0 255\n");

break; default: fprintf(fhuella,"255 255 0\n"); break; } }


{ printf("\nError al cerrar el archivo para las

direcciones\n\n"); exit(0); }}

void GeneraFicheroCaracteristica(char nombre[13])



{ FILE *fhuella; if(!(fhuella=fopen(nombre,"w+"))) { printf("\nError al abrir el archivo para las

caracteristicas\n\n"); exit(0); }

fprintf(fhuella,"P3\n# Imagen con caracteristicas\n%d %d\n255\n",ancho,alto);

for(i=0;i<n;i++) { switch (imagen[i]) { case 13: fprintf(fhuella," 0 255 0\n"); break; case 169: fprintf(fhuella," 255 0 0\n"); break; case 69: fprintf(fhuella," 0 0 255\n"); break; default: fprintf(fhuella," %d %d %d\n",imagen[i],

imagen[i],imagen[i]); break; } }


{ printf("\nError al cerrar el archivo para las

direcciones\n\n"); exit(0); }}

void GeneraMatriz(void){ FILE *fmatriz;

if(!(fmatriz=fopen("matriz.txt","w+"))) /* Abrimos elarchivo para almacenar la matriz */

{



printf("\nError al abrir el archivo para la matriz"); exit(0); }

j=0; for(i=0;i<n;i++) /* Grabamos los datos de la matriz en

el archivo matriz.txt */ { if(j==ancho) { fprintf(fmatriz,"\n"); j=0; } j++;

fprintf(fmatriz,"%2d:%3d ",i,imagen[i]); }

if(fclose(fmatriz)==EOF) /* Cerramos el archivo enel que se almacena la matriz */

{ printf("\nError al cerrar el archivo para la matriz");

exit(0); }}

void SobrescribeOriginal(void){ for(i=0;i<n;i++) imagenOriginal[i]=imagen[i]; }

int main (void){ short int maximo,minimo,blanco;

printf("\n ALGORITMO DE RECONOCIMIENTO DE HUELLAS DACTILARES(v1.05)\n");

printf("\n Leyendo fichero... "); LeerFichero(); /* Leemos la imgen que nos entra al programa

*/ GeneraFichero("01leidosd.pnm","P3","Imagen original"); printf("...fichero leido (%dx%d, %d píxeles)

\n",ancho,alto,n);

printf("\n Calculando Maximo y Minimo... "); maximo=CalculaMaximo(); printf("... Maximo: %d",maximo); minimo=CalculaMinimo();



printf(" y Minimo: %d\n",minimo); printf("\n Atenuando la imagen... "); Atenuacion(maximo,minimo); printf("...imagen atenuada... "); GeneraFichero("02atenuad.pnm","P3","Imagen atenuada"); printf("...fichero grabado \n");

printf("\n Calculando Maximo y Minimo... "); maximo=CalculaMaximo(); printf("... Maximo: %d",maximo); minimo=CalculaMinimo(); printf(" y Minimo: %d\n",minimo);

printf("\n Buscando direcciones... "); ProcesaImagen(3); /* Buscar direcciones */ printf("... direcciones calculadas ..."); GeneraFichero("03direccn.pnm","P3","Imagen de direcciones"); printf("...fichero grabado \n",direcciones[13],direcciones

[169]); GeneraFicheroDireccion("04colodir.pnm");

printf("\n Calculando Maximo y Minimo... "); maximo=CalculaMaximo(); printf("... Maximo: %d",maximo); minimo=CalculaMinimo(); printf(" y Minimo: %d\n",minimo);

printf("\n Calculando el valor de minimo blanco... "); blanco=Histograma(maximo,minimo); printf("... Valor blanco: %d\n",blanco);

printf("\n Generando imagen binarizada... "); BinarizaImagen(blanco); printf("...imagen binarizada... "); GeneraFichero("05binary.pnm","P3","Imagen binarizada");

// GeneraMatriz(); printf("...fichero grabado \n");

printf("\n INICIO DEL OPENING"); printf("\n Erosionando imagen... "); if(OPEN_ERO==1)

ProcesaImagen(1); /* Erosión */ printf("...imagen erosionada... "); GeneraFichero("06openero.pnm","P3","Imagen erosionada

(OPENING)"); printf("...fichero grabado");



printf("\n Dilatando imagen... "); if(OPEN_DIL==1)

ProcesaImagen(2); /* Dilatación */ printf("...imagen dilatada... "); GeneraFichero("07opendil.pnm","P3","Imagen dilatada

(OPENING)"); printf("...fichero grabado \n"); printf(" FIN DEL OPENING \n");

printf("\n INICIO DEL CLOSING"); printf("\n Dilatando imagen... "); if(CLOSE_DIL==1)

ProcesaImagen(2); /* Dilatación */ printf("...imagen dilatada... "); GeneraFichero("08closdil.pnm","P3","Imagen dilatada

(CLOSING)"); printf("...fichero grabado");

printf("\n Erosionando imagen... "); if(CLOSE_ERO==1)

ProcesaImagen(1); /* Erosión */ printf("...imagen erosionada... "); GeneraFichero("09closero.pnm","P3","Imagen erosionada

(CLOSING)"); printf("...fichero grabado \n"); printf(" FIN DEL CLOSING \n");

// SobrescribeOriginal(); /* Sobrescrimos la imagenoriginal con la actual */

printf("\n Buscando esqueletos... "); ProcesaImagen(5); /* Descubrimos los esqueletos */ printf("...esqueletos encontrados... "); GeneraFichero("10esqelet.pnm","P3","Imagen con esqueletos"); printf("...fichero grabado \n");

printf("\n Perfilando esqueletos... "); ProcesaImagen(4); /* Buscamos los contornos */ ProcesaImagen(7); /* Perfilamos los esqueletos */ printf("...esqueletos perfilados... "); GeneraFichero("11esqperf.pnm","P3","Imagen con esqueletos

perfilados"); GeneraFicheroDireccion("12colodir.pnm"); printf("...fichero grabado \n");

printf("\n Buscando caracteristicas... "); ProcesaImagen(6); /* Descubrimos las características */ printf("...caracteristicas encontradas... "); GeneraFicheroDireccion("13caractr.pnm");



printf("...fichero grabado \n");

printf("\n Fin del programa..."); free(imagen); /* Liberamos la memoria de

la imagen */ free(imagenOriginal); /* Liberamos la memoria de la imagen

original */ free(direcciones); /* Liberamos la memoria de las

direcciones */ printf(" ... y memoria liberada\n\n");

return 0;}


Documents

ALGORITMO DE OBTENCIÓN DE CARACTERÍSTICAS EN HUELLAS ... · obtienen, con el propio dispositivo y con una base de datos muy reducida, es decir, capaz de identificar a un escaso