Beruflich Dokumente
Kultur Dokumente
AUTOR:
-1-
MEMORIA
-2-
ndice de contenido
1.- Prlogo..................................................................................................5 2.- Introduccin..........................................................................................7 1 Estudio de los trabajos y tecnologas existentes....................................7 2 Motivacin del proyecto........................................................................9 3 Objetivos.............................................................................................10 4 Metodologa y solucin desarrollada..................................................10 5 Recursos y herramientas empleadas....................................................12 3.- Anlisis de la placa MipScale............................................................14 1 Configuracin de la mquina base......................................................14 2 Desarrollo de una pequea aplicacin.................................................16 3 Prueba de la unidad de coma flotante.................................................18 4.- Formato utilizado para las imgenes................................................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 caractersticas......................................25 6.- Algoritmo de obtencin de caractersticas.......................................27 1 Lectura del fichero..............................................................................29 2 Atenuacin y ajuste de tonalidades.....................................................31 3 Ajuste de negros y blancos fijos por direcciones................................33 4 Bsqueda de direcciones.....................................................................36 5 Binarizado de la imagen o paso a blanco y negro...............................38 6 Proceso de apertura y erosin..............................................................40 7 Proceso de apertura y dilatacin..........................................................42 8 Proceso de cerrado y dilatacin...........................................................44 9 Proceso de cerrado y erosin...............................................................46 10 Obtencin de esqueletos....................................................................48 11 Perfeccionamiento de los esqueletos.................................................50
-3-
12 Superposicin de los esqueletos sobre la imagen original................52 13 Obtencin de caractersticas..............................................................54 7.- Experimentos y Resultados...............................................................58 8.- Conclusiones.......................................................................................67 9.- Futuros desarrollos............................................................................69 10.- Bibliografa.......................................................................................72 11.- Anlisis del mercado........................................................................75 12.- Posibilidades del algoritmo desarrollado.......................................77 13.- Ejecucin del algoritmo...................................................................79 14.- Configuracin de los parmetros del proceso................................81
-4-
1.- Prlogo
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 aos con xito, pero no de una forma demasiado fiable. En los procesos que se estn efectuando a da de hoy, existen dos vertientes: en un caso es necesario una imagen de muy buena calidad y un entorno muy potente que permita un anlisis riguroso de la imagen, mientras que en la otra vertiente nos encontramos con pequeos dispositivos, dotados de sensores de baja calidad, que consiguen identificar a cada individuo mediante la comparacin de los datos obtenidos con el propio sensor con los ya almacenados en una base de datos propia, realizada tambin con el mismo sensor. La primera opcin tiene como ventaja que los resultados son realmente fiables e independientes de la forma de obtencin de la imagen, pero esto es a cambio de una costosa y elevada infraestructura, que los convierte en equipos difcilmente transportables y al alcance de pocos usuarios. La segunda opcin, sin embargo, soluciona el elitismo existente en el mbito de reconocimiento de huellas dactilares, pero tiene muy poca diversidad, ya que slo 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 solucin intermedia a los dos casos presentados. Lo que pretendemos es alcanzar un algoritmo de fcil implantacin que maneje cualquier imagen y detecte algunas de las caractersticas importantes de una huella dactilar, las suficientes como para identificar a un individuo en el
-5-
menor tiempo posible. En busca de una fcil y, sobre todo, verstil implantacin 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 ms los pequeos dispositivos que llevan GNU/Linux embebido y que, al ser un sistema libre, existen multitud de desarrolladores asegurando un prspero futuro. Adems, 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 Investigacin Tecnolgica (IIT), pero ste estaba optimizado para su uso con un potente software de clculo y se alejaba de nuestro propsito de alcanzar un algoritmo sencillo y verstil. 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 gustara agradecer la colaboracin de la empresa MicroPowerSoft (MIPSA) que ha cedido una pequea 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 pequeo tamao.
-6-
2.- Introduccin
A lo largo de esta memoria vamos a explicar en qu consiste el algoritmo desarrollado para la obtencin de caractersticas 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 captulo, el tercero, se analiza la placa que se va a utilizar a modo de banco de pruebas como dispositivo de bolsillo. En el cuarto captulo, se presenta el formato utilizado para manejar las imgenes, de forma que ste manejo sea lo ms sencillo posible, y en el quinto captulo se muestra qu es una huella dactilar y cules son las caractersticas ms importantes. El sexto captulo es el ms extenso y en el que se explica con el mximo detalle posible en qu consiste el algoritmo, realizando todos los procesos implementados de forma consecutiva y viendo el resultado que se obtiene despus de realizar cada proceso. A continuacin, en el captulo sptimo, se van a realizar una serie de ensayos y experimentos en los que vemos cmo podemos mejorar los resultados optimizando el algoritmo para un tipo concreto de huellas dactilares. En los dos siguientes captulos, se obtienen las conclusiones objetivas del algoritmo y se analizan los futuros desarrollos que podran mejorar nuestro algoritmo desarrollado.
-7-
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 ms 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 obtencin de caractersticas. Anlisis de las direcciones fundamentales: No todos los procesos estudiados realizan un anlisis acerca de las direcciones fundamentales, pero s es comn en un gran nmero de ellos, de forma que se puede obtener informacin adicional para el proceso de reconocimiento. Obtencin de contornos o esqueletos: En ste punto es dnde existe la posibilidad de elegir entre una opcin u otra ya que cada una posee sus ventajas e inconvenientes, siendo ambas vlidas para poder encontrar las caractersticas fundamentales de una huella dactilar. En la obtencin de contornos buscaramos los bordes de las crestas de la huella, mientras que en la obtencin de esqueletos estaramos buscando la parte central de la cresta de la huella. Obtencin de caractersticas: Es el proceso final y comn a todos los estudiados. En l se averiguan las posiciones de las caractersticas para poder as llegar a completar el proceso de reconocimiento. Comparacin de caractersticas 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
-8-
ste proyecto, ya que implica la bsqueda del centro de la huella, as como la translacin, rotacin y desplazamiento de las caractersticas hasta poder asegurar si dos huellas son exactas, aunque slo se tenga una parte de ellas. Los proyectos estudiados han sido incluidos en la bibliografa, que se encuentra en el ltimo apartado de sta memoria.
-9-
3 Objetivos
La idea de llevar a cabo este proyecto surge del deseo de llevar a cabo un proceso de clculo sobre un sistema embebido con GNU/Linux. El proceso elegido es la obtencin de caractersticas de una huella dactilar, pero ste no es el nico objetivo, sino que existen varios objetivos: Utilizar dispositivos de pequeo tamao con GNU/Linux embebidos y desarrollar aplicaciones que puedan ser ejecutadas de forma autnoma en el dispositivo. Realizar un proceso digital de una imagen utilizando el lenguaje de programacin C, uno de los ms extendidos y de gran versatilidad. Programar un algoritmo que obtenga las caractersticas 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.
- 10 -
ajustan los valores de la imagen, de forma que el mximo y mnimo, coincidan con 255 y 0 respectivamente. Determinacin de direcciones y ajuste de tonalidades: El siguiente proceso evala los pxeles cercanos de cada pxel de forma que si existe una clara mayora de pxeles cercanos negros o blancos, el pxel se fija a blanco o negro, a no ser que no exista una clara mayora, en cuyo caso se deja el pxel con el mismo valor que tiene. Adems, en ste proceso conseguimos una matriz que nos indica la direccin en la que existe un dominio claro de una determinada tonalidad o, si por el contrario, no existe ninguna direccin dominante. Binarizacin de la imagen: Una vez que hemos obtenido la matriz de direcciones con la mayor informacin posible, pasamos la imagen a blanco y negro puros, es decir una imagen binaria, compuesta por ceros y unos. Si buscramos las direcciones dominantes con la imagen binarizada, la matriz obtenida no sera tan precisa. Procesos de apertura y cierre: Tambin 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 binarizacin, suavizando los bordes y eliminado el ruido que pueda aparecer. Obtencin de esqueletos: En este paso hemos tomado un camino divergente a los procesos estudiados que se han realizado hasta ahora en el IIT, pero comn a muchos procesos de reconocimiento de huellas dactilares obtenidos de la bibliografa. Este proceso es ms complejo que la bsqueda 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 clculo para obtener los mismos
- 11 -
resultados que se pueden obtener con los esqueletos. Como parte adicional a este proceso, el algoritmo superpone los esqueletos obtenidos sobre la imagen original. Obtencin de las caractersticas: Una vez que tenemos los esqueletos, se analizan para descubrir dnde se dividen en dos, punto que ser marcado como pxel en el que existe una bifurcacin. Todos estos procesos se analizarn ms concretamente en el captulo 6, en el que mostraremos las imgenes que el algoritmo va grabando al finalizar cada uno de los procesos.
Placa MipScale
- 12 -
La placa MipScale posee unas caractersticas idneas para el desarrollo del proyecto, tales como un bajo consumo (170mA a 5V), un reducido tamao (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 realizacin de clculos matemticos. The Gimp, para el retoque y conversin de las imgenes. Bluefish, como editor de texto para el cdigo en C del algoritmo. GCC, compilador libre utilizado sobre el PC y cruzado para la compilacin del algoritmo de forma que pueda ser implantado en la placa MipScale. gThumb, para poder ver las imgenes obtenidas. OpenOffice.org, para la redaccin de ste documento. Distribucin 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.
- 13 -
- 14 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX Welcome to minicom 2.1 OPCIONES: History Buffer, F-key Macros, Search History Buffer, I18n Compilado en Mar 29 2005, 09:39:09. Presione CTRL-A Z para obtener ayuda sobre teclas especiales
El siguiente paso sera configurar el minicom para que se pueda entender con la placa, para lo cual, y segn las especificaciones del fabricante, es necesario configurar los siguientes parmetros: - Bits por segundo: 115.200 - Bits de datos: 8 - Paridad: ninguna Para configurar estos parmetros es necesario pulsar simultneamente las teclas Control y A, para despus pulsar la tecla P (tambin se puede pulsar la tecla Z y consultar la ayuda del programa). Veremos una pantalla parecida a esto: - Bits de parada: 1 - Control de flujo: ninguno
- 15 -
Si seleccionamos la opcin de Configuracin de la puerta serial, podremos configurar estos parmetros en una pantalla parecida esta:
Pulsamos la tecla Enter para salir, seleccionamos la opcin de salir y volvemos a la interfaz del minicom en la que, si reiniciamos la placa con el botn de Reset, podemos ver los mensajes de arranque del sistema operativo que lleva implementado y se pueden apreciar en Apndice B.
- 16 -
de los posibles sitios, en la web de LART (http://www.lart.tudelft.nl/). Aqu elegimos el compilador gcc, versin 2.95.3, por ser la ms apropiada para nuestra mquina base y nuestra placa, segn 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 cdigo 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 cdigo lo guardamos como un fichero de texto llamado prueba.c y lo compilamos. Para llevar a cabo la compilacin 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 mquina GNU/Linux, con el siguiente comando:
./prueba.arm
Este proceso de ejecucin de nuestro programa de prueba, as como la transferencia del archivo a la placa, ha sido realizado a travs del programa
- 17 -
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 apndice.
Por este motivo, hemos credo oportuno probar cmo funcionan stas libreras 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 necesitaran el correspondiente coprocesador matemtico). Para llevar a cabo una prueba fiel, hemos decidido programar un sencillo filtro FIR (Finite Impulse Response, Respuesta Finita de Impulsos) sobre una seal sinusoidal, a la que le hemos introducido ruido, para que nuestro filtro lo elimine. ste filtro consiste en sustituir el valor de la seal para un instante dado por la media de los instantes anteriores. El nmero de instantes a tener en cuenta para realizar el clculo es variable, por lo que cuanto mayor sea el nmero de instantes considerados, mayor ser el proceso de filtrado y mejor ser uniformidad y periodicidad de la seal. Sin embargo, parece obvio que cuanto mayor sea el nmero de instantes considerados, mayor ser la carga de clculo del proceso, siendo ste unos de los objetivos de nuestra prueba.
- 18 -
Este grfico muestra los resultados obtenidos con el filtro, al que le hemos introducido la seal que vemos en color magenta y hemos ido aumentando el tamao de la ventana de los datos, es decir el nmero de instantes que se utilizan al aplicar el filtro. Para una ventana de datos pequea (del orden de 10 datos) obtenemos la seal en verde, para una ventana mediana (100 datos) la seal roja y para una venta grande (1.000 datos) obtenemos la seal azul, perfectamente filtrada, pero de menor amplitud. El cdigo 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++)
- 19 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX 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 continuacin, el cdigo 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;
- 20 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX suma=0; printf("%f\n",fir[i]); } return 0; }
La conclusin 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 ms rpido 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 implantacin en coma fija, que tenga en cuenta los problemas de codificacin y escalado adecuados para que la precisin se mantenga dentro de unos lmites razonables. Adems, de esta forma se elimina un grado de libertad a la hora de marcar el estilo a seguir en la programacin del algoritmo. Por ste motivo hemos decidido utilizar variables de tipo short int, de tal forma que no superemos en ningn momento los 32 bits de los que dispone la placa MipScale, disminuyendo as el uso de la memoria y aumentando la velocidad del algoritmo.
- 21 -
- 22 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX P1 # Ejemplo 3x3 de PBM 3 3 # Ancho y alto 0 0 1 0 1 1 1 1 0
Ejemplo de PBM
Este ser el formato elegido (P1) para el desarrollo del proyecto cuando utilicemos imgenes binarizadas o en blanco y negro.
Ejemplo de PGM
- 23 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX P3 # Ejemplo 3x3 de PPM 3 3 # Ancho y alto 255 # Valor mximo 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 imgenes de gran resolucin (por encima de 300x300). Esto podra ser mejorando utilizando algn formato que permita la compresin, pero sin prdida de informacin como podra ser el formato PNG. Sin embargo, esta solucin complicara el proceso de lectura y escritura, alejndose de uno de los intereses del proyecto, que consiste, precisamente, en obtener un algoritmo sencillo.
- 24 -
Sin embargo, este tipo de huella, que se ve a simple vista es, complicado de identificar por parte de una mquina, sobre todo porque no siempre se dispone de la huella completa, por lo que cuando se busca identificar una huella en un
- 25 -
proceso automtico 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 tpicas en las crestas de una huella dactilar, tal y como podemos apreciar en la siguiente figura:
Estas formaciones singulares que se crean con las crestas de una huella dactilar, es lo que podemos llamar caractersticas de la huella, y son propiedades que s se pueden localizar de forma independiente al resto de la huella, al contrario de lo que ocurra con el tipo de la huella, para el que necesitamos la huella completa.
- 26 -
Imagen recortada
Adems, para una mayor claridad, vamos a seleccionar una pequea seccin en la que podremos ver los efectos del procesamiento digital de la imagen. En esta seccin elegida, podemos ver claramente una caracterstica importante de la huella: una bifurcacin o separacin de una cresta en dos, dentro de la huella. Si el algoritmo funciona correctamente, debera detectarla.
- 27 -
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 despus de cada proceso. Por esta razn, para cada uno de los procesos que realizamos, mostraremos el resultado obtenido con la imagen original y con el pequeo fragmento de la misma que hemos obtenido.
- 28 -
Para poder leer esta imagen tiene que estar en el formato PPM y ASCII, es decir, tal y como hemos comentado en el captulo cuatro, la cabecera de la imagen debe comenzar por P3, que de esta forma para cada pxel lee tres nmeros y en el caso en el que estos sean distintos (lo cual significara que la imagen es a color) realiza la media de estos nmeros, obteniendo as la imagen en escala de grises que estbamos buscando, ya que para la obtencin de caractersticas no es necesaria la informacin que aporta el color. Por lo tanto, tras realizar la lectura de la imagen, el algoritmo genera un vector de dimensin variable y de tantos campos como pxeles tiene la imagen. El nmero de pxeles se obtiene multiplicando el ancho por el alto de la imagen,
- 29 -
datos que obtenemos de la cabecera de la imagen, segn es habitual en todos los formatos PNM, teniendo en cuenta que los datos se encuentran en ASCII.
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 pxeles de la imagen queda, entonces, representado por un valor numrico comprendido entre 0 (negro) y 255 (blanco).
- 30 -
Para obtener esta imagen ha sido necesario averiguar cul es el valor mximo y cul el mnimo, lo que indica que si el valor mximo de todos los pxeles es 255 y el valor mnimo es 0, no se realiza ningn cambio. Sin embargo, si el valor mximo es inferior a 255, tal y como ocurre en esta imagen en la que el pxel ms claro posee el valor de 241, se ajusta de forma que el valor mximo sea 255. Esto se consigue restando a todos los valores de la imagen el valor del mnimo, siempre y cuando este sea mayor que cero, para despus, multiplicar el valor de cada pxel por 255 y dividirlo por la diferencia entre el valor mximo y el valor mnimo. Con este proceso lo que buscamos es que en las sucesivas operaciones que realicemos sobre la imagen se pierda la mnima informacin posible ya que
- 31 -
nicamente utilizamos nmeros enteros porque al realizar operaciones con decimales, perderamos valores decimales que podran llegar a ser importantes.
En esta imagen vemos cmo influye este proceso en la imagen completa, viendo cmo realmente parece una imagen ms clara.
- 32 -
Para este proceso hacemos uso de mscaras direccionales, es decir, una especie de filtros que nos permiten observar los pxeles que hay alrededor de un pxel concreto, segn una direccin en concreto. Esto lo conseguimos gracias doce imgenes creadas para la ocasin y que nos encargaremos de cargar dentro del propio algoritmo. stas mscaras 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 mscara porque sera informacin repetida, ya que la mscara de 180 sera exactamente igual a la mscara de 0. Tampoco sera til utilizar un mayor nmero de mscaras, debido a que aumentara mucho el tiempo del proceso y no as los resultados obtenidos.
- 33 -
Las mscaras que el algoritmo carga provienen de doce archivos de imagen con el formato PBM, que mostramos a continuacin:
Mscara de 0
Mscara de 60
Mscara de 120
Mscara de 15
Mscara de 75
Mscara de 135
Mscara de 30
Mscara de 90
Mscara de 150
Mscara de 45
Mscara de 105
Mscara de 165
De esta forma, el proceso que realizamos ahora es ir comprobando pxel a pxel si existe alguna direccin en la que se observe que predomina el blanco o el negro sobre todos los dems. En el caso en el que se detecte una direccin con un tono (negro o blanco) dominante, ese pxel se convierte en blanco puro (255) o
- 34 -
negro (0), de forma que no haya ninguna duda en el siguiente proceso de binarizacin y, en el caso en el que no haya una ninguna direccin con un tono dominate, el pxel correspondiente se deja con el valor original.
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 pxeles dudosos en los bordes de las crestas.
- 35 -
4 Bsqueda de direcciones
En el tercer proceso, ya comentado, se va evaluando si existe alguna direccin en la que se pueda afirmar que existe alguna tonalidad dominante y, si esto ocurre, se graba esta direccin dentro de un vector de la misma dimensin y caractersticas, a partir del cual se obtiene esta imagen, a modo de matriz de direcciones:
En esta imagen se puede ver la direccin dominante, segn el color que posea cada pxel, que se corresponde con la escala que vemos a la derecha de la imagen. En el caso en el que no exista una direccin 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 mscaras, de forma que no se produzcan errores en los clculos. El ancho de ste margen se corresponde con la mitad menos uno del ancho de las mscaras. En nuestro caso, las mscaras poseen un ancho fijo de 13 pxeles, por lo que el margen necesario debe tener un ancho de 7 pxeles. 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
- 36 -
color amarillo. Esto puede provocar una prdida de informacin importante en imgenes pequeas (como es el caso del recorte), pero no as en imgenes grandes, como la que vemos a continuacin:
Como podemos ver en esta imagen, el resultado queda mucho ms claro cuando la imagen es ms grande y hace pensar que los puntos han sido clasificados de forma correcta.
- 37 -
El proceso utilizado para la binarizacin es un proceso reiterativo y muy utilizado para imgenes 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 cul significar que es el valor mnimo de blanco, es decir, cualquier pxel por debajo de ese valor ser negro y cualquier pxel 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 mnimo de blanco, segn la siguiente ecuacin:
- 38 -
1 ' = 12 2
Este proceso lo repetimos hasta que el valor de mnimo blanco no vare o hasta que alcancemos la reiteracin nmero 13. El resultado sobre la imagen completa los vemos a continuacin:
En sta imagen podemos ver cmo todos los pxeles ya han sido definidos como negros o como blancos, no existiendo ningn pxel gris.
- 39 -
En este proceso de la erosin, solamente se mantiene un pxel negro si est rodeado por pxeles negros en su totalidad, es decir, cada pxel est rodeado por otros ocho pxeles, por lo que si un pxel negro, est rodeado por ocho pxeles negros, el pxel seguir siendo negro despus del proceso de erosin, pero pasar a ser blanco si no est rodeado es su totalidad por pxeles negros. Con este proceso, al que se suele conocer como opening y del que la erosin es el primer paso, lo que estamos buscando es una apertura de la imagen, de forma que aumente el nmero de espacios en blanco y slo queden los espacios negros que sean ms densos o completos. As es posible filtrar pequeos pxeles negros aislado que puedan aparecer debido a ruido y se pueden limar los
- 40 -
apndices que puedan existir, quedando una imagen ms limpia, como podemos ver a continuacin en la imagen completa:
En esta imagen observamos algo importante, que no es otra cosa que la prdida de informacin 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.
- 41 -
En este proceso de dilatacin realizamos justo la operacin inversa que en el proceso anterior, ya que nicamente conservamos como pxel blanco, aquel que est completamente rodeado de pxeles blancos, consiguiendo as volver ms densas las zonas negras cerrando los huecos que se han podido formar. La dilatacin es un procesos tal til como necesario, ya que es fundamental volver a recuperar todos los pxeles que se han perdidos durante el proceso de erosin porque, si las crestas de las huellas quedan demasiado delgadas, podran fallar los procesos posteriores de obtencin de caractersticas. Es por esto, por lo que cuando hablamos del proceso de apertura (o de opening
- 42 -
como se suele conocer) estamos hablando de una erosin y su posterior dilatacin. Este proceso tambin lo podemos ver en la imagen completa:
Tras el proceso de dilatacin vemos cmo hemos recuperado el grosor de las crestas de la huella, pero han aparecido nuevos problemas, como son pxeles blancos rodeados de pxeles negro que solucionaremos en prximos procesos.
- 43 -
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, tambin conocido como closing funciona de forma anloga al proceso de apertura, ya que en este caso lo que vamos a realizar es una primera dilatacin, para una posterior erosin, de forma que consigamos el efecto contrario al proceso de apertura
- 44 -
Este primer proceso de dilatacin lo podemos apreciar en la siguiente imagen, en la que observamos cmo, efectivamente, se van cerrando los espacios en blanco:
Aparentemente, se han perdido muchas crestas, pero no debemos olvidar que todava nos queda el posterior proceso de erosin, que sin duda liberar crestas, aunque no se descarta el haber perdido ciertas crestas dudosas.
- 45 -
En el caso de la imagen recortada, vemos cmo, 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 pxeles 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 prdidas de determinadas crestas, que luego pueden ser fundamentales a la hora de encontrar ciertas
- 46 -
Efectivamente, vemos que en la imagen completa hemos perdido crestas que han quedado ocultas, pero no debemos olvidar que buscamos caractersticas y de esta forma estamos filtrando las que pueden ser dudosas y aclarando las ms obvias.
- 47 -
10 Obtencin 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 mximo posible su grosor, hasta que sea de aproximadamente un pxel, tal y como se puede ver en la siguiente imagen:
Nuestro fin es llegar a encontrar las caractersticas importantes de la huellas y, en especial, las bifurcaciones, por lo que no nos aporta ninguna informacin el grosor de las crestas, sino sus direcciones principales, las cuales ya hemos buscado al realizar la binarizacin. Al conseguir adelgazar al mximo 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 erosin se han podido provocar terminaciones que no existen realmente en la huella
- 48 -
original. El resultado de la obtencin de esqueletos se puede observar a continuacin sobre la imagen completa:
Al realizar el proceso de bsqueda de esqueletos sobre la imagen completa, vemos que los resultados no son los esperados debido, posiblemente, al proceso de dilatacin que ha anulado una parte importante de la huella, por lo que resulta necesario el siguiente proceso.
- 49 -
Sin embargo en la imagen completa si resulta necesario perfeccionarlos de la mejor manera posible. Al repetir el proceso de obtencin de esqueletos, no se consigue mejorar la calidad de estos, por lo que la decisin tomada ha sido limitarnos a obtener los contornos de los esqueletos obtenidos. Con esta solucin, 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
- 50 -
quedado claras en los nuevos esqueletos tal y como podemos apreciar en la siguiente imagen, resultado de haber perfeccionado los esqueletos anteriores:
En esta imagen vemos como hemos eliminado las zonas en las que no se distingua nada y hemos conservado los esqueletos claros, para no eliminar ninguna posible bifurcacin.
- 51 -
Merece la pena destacar que los esqueletos se han superpuesto sobre la imagen leda original, pero variando su color para conseguir una imagen ms clara, asignando a cada pxel del esqueleto, el color que le corresponde segn 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 lgicos y aceptables. Tambin se puede observar cmo se han perdido los datos que se encuentran dentro del margen de 7 pxeles que se cre al realizar la bsqueda de
- 52 -
direcciones. sta es una perdida necesaria para mantener la resolucin original de la imagen y que en un principio no supone una prdida importante, tal y como se puede apreciar cuando la imgen es ms grande como es el siguiente caso:
Aqu podemos ver cmo los esqueletos de la imagen completa, quedan correctamente superpuestos sobre la imagen completa original.
- 53 -
13 Obtencin de caractersticas
Tras la binarizacin, los procesos de apertura y cierre y la obtencin de los esqueletos, llega el momento de alcanzar el objetivo fundamental de ste algoritmo: Obtener las caractersticas y, en concreto las bifurcaciones, tal y como se puede ver en la siguiente imagen:
Con ayuda del programa de clculo matemtico, octave, vamos a explicar en qu consiste el proceso de bsqueda de caractersticas. Al igual que en caso de la binarizacin, se va evaluando pxel a pxel del esqueleto de la imagen, solo que en este caso nos centraremos nicamente en los pxeles de color negro. A estos pxeles negros les aplicamos las mscaras ya comentadas en el proceso de binarizacin y analizamos los valores mnimos del histograma obtenido, segn el resultado de multiplicar los pxeles del esqueletos por los valores de la mscara, obtenindose valores bajos si los pxeles de la mscara coinciden con el esqueleto y obtenindose valores altos si esto no ocurre.
- 54 -
- 55 -
El mtodo para encontrar caractersticas consiste en analizar los histogramas de forma que entre el valor mximo del histograma y el valor mnimo exista una diferencia mayor de 130 unidades, un valor lgico, teniendo en cuenta que el valor mximo puede ser hasta 255 y el valor mnimo ms pequeo puede ser 0. Una vez que nos hemos asegurado la diferencia mnima, se debe cumplir que los mnimos estn separados y no sean consecutivos, ni tampoco estn demasiado dispersos. El resultado de ste ltimo proceso sobre la imagen completa, sera el siguiente:
- 56 -
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 mtodo efectivo de forma clara y cuya depuracin escapa ya de este proyecto, pero queda abierta a nuevas pruebas y futuros desarrollos.
- 57 -
- 58 -
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 continuacin, el resultado de los esqueletos obtenidos mejora considerablemente:
En este caso vemos cmo los esqueletos han salido realmente ms fieles que los que salieron en el captulo anterior, pero ha sido a cosa de la existencia de
- 59 -
ruido. Este ruido queda traducido en los pxeles rojos que se ven entre los esqueletos, los cuales implican que son pxeles cuya direccin es elevada (a partir de 135). siempre y cuando esta tonalidad roja sea aislada, ya que los que no se encuentran aislados sern pxeles cuya direccin es realmente elevada. A esta imagen le aplicaremos el proceso en el que descubrimos las bifurcaciones:
Aqu vemos cmo seis bifurcaciones han sido localizadas de forma clara, aunque tambin se han detectado puntos como bifurcaciones que no lo son, pero
- 60 -
esto puede ser mejorado aumentando la resolucin de la imagen o introduciendo slo un fragmento de la huella. A continuacin, vamos a utilizar otra imagen en la que veremos que a pesar de ser de caractersticas completamente diferentes, se obtienen resultados incluso mejores a los ya comentados. La imagen de partida es la siguiente:
Como podemos ver en esta nueva imagen, las caractersticas son diferentes, ya que existe una menor diferencia de contraste en la huella y, adems, se puede observar como la parte central o ncleo de la misma, se encuentra peor diferenciada que la parte perifrica. Esto va a provocar que al tratar la imagen como un todo, sta parte perifrica se desvanezca dentro del fondo, siendo filtrada a costa de ganar mayor claridad en la parte central. ste hecho puede
- 61 -
anular bifurcaciones importantes del permetro dndonos 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 perifrica las crestas estn ms separadas, vindose con ms claridad los valles y, por lo tanto, obtenindose las bifurcaciones de una forma ms 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 cmo el proceso de atenuacin ha destacado, como era de esperar la parte central de la huella, es decir, su ncleo:
Merece la pena destacar que en este caso hemos anulado el proceso de asignacin de tonalidades por direcciones, ya que al existir tanta diferencia entre
- 62 -
entre la parte del permetro de la huella y su parte central, emborronara este ncleo de la huella, dejando slo 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:
En esta matriz podemos observar cmo se han detectado direcciones de manera incorrecta en los valles, de forma que si realizsemos la asignacin de tonalidades por direcciones, en el ncleo de la huella los valles sera convertidos a crestas y las crestas mantendran su condicin de cresta. El resultado sera que la parte central se hara completamente oscura y borde completamente claro.
- 63 -
Es por esto por lo que dejamos el paso a una imagen de blanco y negro al proceso de binarizacin, en el que los resultados obtenidos son ms 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:
Viendo esta imagen binarizada, nos hace esperar una correcta obtencin 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 erosin de la imagen, pero sin la posterior dilatacin, que completara el proceso de apertura.
- 64 -
Al prescindir del proceso de dilatacin, la siguiente imagen ser la empleada para obtener los esqueletos, y podemos ver que el resultado puede ser considerado como correcto:
Para una mayor claridad, mostramos directamente la imagen en la que vemos los esqueletos superpuestos sobre la imagen original, viendo cmo, efectivamente, la parte de la periferia de la huella ha pasado al anonimato, perdindose, tal vez, informacin importante. Sin embargo, es importante apreciar cmo 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 ncleo de la huella.
- 65 -
Por lo tanto, en el ltimo proceso se obtienen unos puntos crticos donde se seala la existencia de bifurcaciones, tal y como se puede apreciar en la siguiente imagen:
En esta ltima imagen, tal vez deberamos evaluar la posibilidad de que la caracterstica encontrada sea real si la concentracin de los utilizados puntos verdes es mayor y su distancia relativa muy pequea.
- 66 -
8.- Conclusiones
Como conclusin general del proyecto podemos afirmar que se ha cubierto el objetivo fundamental que consiste en obtener caractersticas de una huella dactilar. Decimos que hemos obtenido caractersticas de una huella dactilar porque, aunque el algoritmo busca bifurcaciones, el proceso seguido puede ser empleado para detectar otras caractersticas concretas como cruces,
terminaciones, islas o cualquier otra caracterstica que pueda ser interesante. Este proyecto ha servido como recopilacin actual de las ltimas tcnicas desarrolladas en Instituto de Investigacin Tecnolgica (IIT) dentro del campo de reconocimiento de huellas dactilares. ste es un campo en el que el IIT lleva investigado desde hace varios aos, pero que durante los dos ltimos aos no ha recibido ninguna nueva aportacin. Adems, todos los desarrollos realizados hasta ahora, siempre se haban usado grandes infraestructuras, mquinas potentes y software propietario. ste proyecto es, por lo tanto, un intento de realizar una fusin y mejora de los proyectos actuales, as como ampliar el campo de investigacin, abriendo nuevos horizontes, como el software libre y la realizacin de reconocimiento de huellas dactilares en pequeos 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 aadido, en este proyecto se realiza una introduccin al procesamiento digital de una imagen. Con las tecnologas actuales, cada vez ms potentes, los dispositivos de bolsillo ya son perfectamente capaces de realizar
- 67 -
complejos procesos, que hace un par de aos no se podan ni imaginar o, simplemente, parecan utpicos. 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 algn que otro archivo, sin llegar a exprimir ni siquiera una cuarta parte de sus posibilidades.
- 68 -
- 69 -
mejorado, junto con el proceso de deteccin de caractersticas. Adems, el resultado de estos dos procesos depende de la conveniencia de realizar los procesos de apertura y cierre. En la versin actual del algoritmo, estos procesos se realizan a juicio del usuario, pero podra darse el caso de que fuera el propio algoritmo el que decidiera si se deben realizar o no estos procesos, ya que segn hemos visto en nuestros experimentos estos procesos pueden mejorar o empeorar los resultados finales. Dentro del proceso de obtencin de caractersticas, hemos utilizado un formato para las imgenes que no lleva integrado ningn algoritmo de compresin. La razn por la que se ha tomado sta decisin es que uno de los objetivos del proyecto busca, sobre todo, la sencillez en el algoritmo. Sin embargo, es posible que el uso de algn algoritmo de compresin 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 obtencin de caractersticas de huellas dactilares. Como parte final del proceso de reconocimiento de huellas dactilares, sera interesante disponer de una base de datos con huellas dactilares del mayor nmero posible de individuos. Sin embargo, esto ya escapa del uso de dispositivos pequeos, ya que sera necesario una alta capacidad, la cual es el taln de alquiles de los dispositivos de bolsillo debido, fundamentalmente, al alto precio que las unidades de almacenamiento porttiles poseen. Sera, por tanto necesario, realizar algn tipo de comunicacin del pequeo dispositivo con un gran servidor de datos donde se almacenarn las huellas dactilares, clasificadas siempre que sea posible. De esta forma se podra utilizar el pequeo dispositivo para recopilar la huella dactilar y analizarla, obteniendo las caractersticas y envindolas al servidor de huellas dactilares, obteniendo a cambio la posible identidad del dueo de la huella analizada. Extrapolando los procesos utilizados en este proyecto, podemos romper los lmites impuestos y utilizarlos para otras aplicaciones centradas en el
- 70 -
procesamiento digital de una imagen, como pueden ser el reconocimiento de caracteres o la deteccin de movimiento, investigando diferencias entre imgenes o detectando objetos definidos previamente.
- 71 -
10.- Bibliografa
[1] Rafael C. Gonzlez, Richard E. Woods. Digital Image Procesing. PEARSON, Prentice Hall. 2001. [2] Rafael C. Gonzlez, Richard E. Woods, Steven L. Eddins. Digital Image Procesing Using MATLAB. PEARSON, Prentice Hall. 2004. [3] Mnica Arias Parra. Desarrollo de Algoritmos de Filtrado de Imgenes de Huellas Dactilares. Proyecto Fin de Carrera, IIT. 2001. [4] Ismael Corrales Toribio. Extraccin de Caractersticas Descriptivas de Huellas Dactilares. Proyecto Fin de Carrera, IIT. 2001. [5] Daniel Gutirrez Rodrguez. Algoritmo de Comparacin de
Caractersticas para el Reconocimiento de Huellas Dactilares. Proyecto Fin de Carrera, IIT. 2001. [6] Brbara Carln Sainz. Extraccin de Caractersticas Singulares de Huellas Dactilares. Proyecto Fin de Carrera, IIT. 2002. [7] Vctor Manuel Sombra Rodrguez. Identificacin y Clasificacin de Huellas Dactilares. Proyecto Fin de Carrera, IIT. 2003. [8] Pgina web de LART (http://www.lart.tudelft.nl/): Herramientas de compilacin. [9] Pgina web de MicroPowerSoft (http://www.micropowersoft.com/): Empresa fabricante de la placa MipScale.
- 72 -
[10]
Pgina web de FVC (Fingerprint Verification Competition Competicin de verificacin de huellas dactilares, http://bias.csr.unibo.it/fvc2004/): Web del laboratorio de sistemas biomtricos de la universidad de Bolonia, que organiza una competicin de reconocimiento de huellas dactilares.
[11]
[12]
Pgina
web
de
VeriFinger
(http://www.ex-cle.com/ESSdkVf.htm):
Aplicacin 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] Pgina web de GNU/Linux (http://www.linux.org/): Abundante
informacin y manuales sobre GNU/Linux. [14] Pgina web oficial de GNU/Linux Debian (http://www.debian.org/): Distribucin GNU/Linux Debian e instrucciones de instalacin.
- 73 -
ESTUDIO ECONMICO
- 74 -
- 75 -
pequeos 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 pequeos, cuyo precio oscila entre los 100 y los 300, es que son demasiados permisivos, dndose el caso de que acceda un usuario no autorizado, o que son demasiado estrictos, denegando el acceso a un usuario vlido porque no ha colocado la huella con la misma orientacin, o porque su huella ha sufrido alguna herida leve.
- 76 -
- 77 -
MANUAL DE USUARIO
- 78 -
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
cmo
van
apareciendo
mensajes
informndonos de los procesos que el algoritmo va siguiendo, los valores mximo y mnimo, el valor de blanco y el nmero de iteraciones que realiza hasta depuerar los esqueletos:
ALGORITMO DE RECONOCIMIENTO DE HUELLAS DACTILARES (v1.05) Leyendo fichero... ...fichero leido (300x300, 90000 pxeles)
Calculando Maximo y Minimo... ... Maximo: 255 y Minimo: 71 Atenuando la imagen... ...imagen atenuada... ...fichero grabado Calculando Maximo y Minimo... ... Maximo: 255 y Minimo: 0 Buscando direcciones... ... direcciones calculadas ......fichero grabado Calculando Maximo y Minimo... ... Maximo: 255 y Minimo: 0 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
- 79 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX Propuesta n4 de NUEVO blanco: 110 Propuesta n5 de NUEVO blanco: 110... Valor blanco: 110 Generando imagen binarizada... ...imagen binarizada... ...fichero grabado 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... ...fichero grabado Buscando caracteristicas... ...caracteristicas encontradas... ... fichero grabado Fin del programa... ... y memoria liberada
- 80 -
Con esta primera opcin anulamos la definicin de la tonalidad de un pxel en funcin de los pxeles que posea a su alrededor y dejamos el proceso de binarizacin nicamente al clculo del valor de blanco.
#define OPEN_ERO 0 de opening */ /* Poner a 1 si se erosionar en el proceso
Con esta quinta y ltima opcin anulamos el proceso de erosin 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 slo alguien que sepa realmente lo que est haciendo pueda modificarlos. Se podran haber configurado de forma
- 81 -
que estos parmetros los leyera de una archivo, pero se ha descartado esta opcin debido a que puede llegar a provocar confusin y problemas en la ejecucin del algoritmo, siendo ms fiable el mtodo elegido, tratndose de un algoritmo todava en desarrollo.
- 82 -
- 83 -
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 botn 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
- 84 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX 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: Make DRAM section cacheable: Make DRAM section cacheable: Make DRAM section cacheable: Make DRAM section cacheable: Make DRAM section cacheable: Make DRAM section cacheable: Make DRAM section cacheable: Make DRAM section cacheable: Make DRAM section cacheable: Make DRAM section cacheable: Make DRAM section cacheable:
A0400000 A0500000 A0600000 A0700000 A0800000 A0900000 A0A000 A0B00000 A0C00000 A0D00000 A0E00000 A0F00000
- 85 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX Make DRAM section cacheable: A1000000 Make DRAM section cacheable: A1100000 Make DRAM section cacheable: A1200000 Make DRAM section cacheable: A1300000 Make DRAM section cacheable: A1400000 Make DRAM section cacheable: A1500000 Make DRAM section cacheable: A1600000 Make DRAM section cacheable: A1700000 Make DRAM section cacheab Make DRAM section cacheable: A1900000 Make DRAM section cacheable: A1A00000 Make DRAM section cacheable: A1B00000 Make DRAM section cacheable: A1C00000 Make DRAM section cacheable: A1D00000 Make DRAM section cacheable: A1E00000 Make DRAM section cacheable: A1F00000 Map Flash virtual section to DRAM at: A1E00000 00000000 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 0x00000001 verify 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
- 86 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX 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: bootldr@handhelds.org Cpu company: INTEL Cpu Architecture: XScale Cpu Part: PXA250 (Cotulla) >> ARM Processor Rev=00050000 >> (c) 2000-2001 Compaq Computer Corporation, provided with NO WARRANTY under th e terms of the GNU General Public License. >> See http://www.handhelds.org/bootldr/ for full license and sourcesPress Retur n 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-12 seconds! build_list: max = 01F7FFBC . dir entries = 00000310 frag entries = 0000096F +4 increments = 00000000 +file_offset increments = 00000CBF loaded file of size = 0x0007F000 at location 0xA0008000 kernel partition base A0008000 kernel_magic=E1A00000 kernel_region_words[9]=016F2818 Linux ELF flash_imgstart=50040000 size=01F80000 dest=A0000000 offset=00008000 MMU 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
- 87 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX A0008024: 016F2818 root_filesystem_name=ramdisk Grabbed linuxargs, argc = 00000001 Using mach_type 000000CB setting boot parameters to noinitrd root=/dev/mtdblock1 init=/linuxrc console=ttySA0 Making core tag at A0000100 Making cmdline tag at A0000114 Making mem32 tag at A00001D4 command line is: mtdparts=ipaq:0x00040000@0x00000000(bootldr) ro,0x01F80000@0x000 40000(root),0x00040000@0x01FC0000(asset) noinitrd root=/dev/mtdblock1 init=/lin uxrc console=ttySA0 rootfstype=jffs2 linuxEntryPoint=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 kern el. Linux version 2.4.19-rmk2-pxa2 (tomas@viento) (gcc version 2.95.3 20010315 (rele ase)) #5 Mon Nov 11 16:43:20 CET 2002 CPU: Intel XScale-PXA250 revision 3 Machine: Intel DBPXA250 Development Platform Ignoring unrecognised tag 0x00000000 Memory 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/mtdblock1 console=ttyS0,115200n8 Calibrating delay loop... 99.32 BogoMIPS Memory: 32MB = 32MB total
- 88 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX 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 UNIFIX Linux NET4.0 for Linux 2.4 Based upon Swansea University Computer Society NET3.039 Initializing RT netlink socket Starting kswapd JFFS2 version 2.1. (C) 2001 Red Hat, Inc., designed by Axis Communications AB. Keyboard interface test failed[1]: 5fffbff7 Keyboard interface test failed[2]: 08 Keyboard interface test failed[3]: 0a initialize_kbd: Keyboard reset failed, no ACK pty: 256 Unix98 ptys configured Serial driver version 5.05c (2001-07-08) with no serial options enabled Keyboard 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 UART ttyS01 at 0x0000 (irq = 13) is a PXA UART ttyS02 at 0x0000 (irq = 12) is a PXA UART SA1100 Real Time Clock driver v1.00 Probing Lubbock flash at physical address 0x00000000 Using 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 asset NET4: Linux TCP/IP 1.0 for NET4.0 IP Protocols: ICMP, UDP, TCP IP: routing cache hash table of 512 buckets, 4Kbytes TCP: Hash tables configured (established 2048 bind 2048) NetWinder Floating Point Emulator V0.95 (c) 1998-1999 Rebel.com VFS: Mounted root (jffs2 filesystem). Freeing init memory: 44K INIT: version 2.78 booting Mounting local filesystems... Setting the System Clock using the Hardware Clock as reference...
- 89 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX INIT: Entering runlevel: 2 Configuring network interfaces: done. Not recalculating module dependencies Loading 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 segn viene explicado por el fabricante de la placa, el nombre de usuario por defecto, segn viene de fbrica, 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 slo queda indicar que con el comando rz, la placa se queda a la espera de archivos que podemos transferir a travs del programa minicom, utilizando el protocolo zmodem, as como que con el comando sz <nombredelarchivo>, recibimos el archivo que se encuentra en la placa.
- 90 -
- 91 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX #include <stdio.h> #include <string.h> #include <stdlib.h> #define MINIMO_ESQUELETO 169 #define MAXIMO_ESQUELETO 169 #define FILTRADO_DIRECCION las direcciones */ #define OPEN_ERO 0 /* de opening */ #define OPEN_DIL 0 /* opening */ #define CLOSE_DIL 0 /* closing */ #define CLOSE_ERO 0 /* de closing */ 0 /* Poner a 1 si se quiere filtrar por Poner a 1 si se erosionar en el proceso Poner a 1 si se dilatar en el proceso de Poner a 1 si se dilatar en el proceso de Poner a 1 si se erosionar en el proceso
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 en ASCII */ if(a!=10) {
- 92 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX printf("\nError en el formato de la imagen (debe empezar por P3, mas un salto de linea)\n\n"); exit(0); } a=getchar(); /* Tenemos que leer una almohadilla (#), 35 en ASCII */ if(a!=35) { printf("\nError en el formato de la imagen (la segunda linea debe ser un comentario)\n\n"); exit(0); } do comentada */ { /* Lectura de la cabecera PPM, segunda linea
a=getchar(); i++; } while(a!=10); scanf("%d %d",&ancho,&alto); la imagen */ n=ancho*alto; el numero de elementos del archivo */ /* Leemos dimensiones de /* Calculamos
imagen=(short int *)calloc(n,sizeof(short int)); Reservamos memoria para leer la imagen */ if(!imagen) { printf("\nError al reservar la memoria para imagen\n\n"); exit(0); } imagenOriginal=(short int *)calloc(n,sizeof(short /* Reservamos memoria para leer la imagen */ if(!imagen) { printf("\nError al reservar la memoria para la imagen original\n\n"); exit(0); } scanf("%d",&elemento); /* Leemos un 255 que principio */
/*
abrir la
int));
almacenar
hay al
- 93 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX { 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++) /* Inicializacin de la imagen temporal a valor 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;
- 94 -
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; /* */ 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-----------------------------------------fprintf(fhist," TABLA RESUMEN: Valores mayores que cero\n"); fprintf(fhist,"-----------------------------------------for(i=minimo;i<=maximo;i++) if(valores[i]>0) { contador=contador+valores[i]; maximo=255; minimo=0;
\n");
\n");
- 95 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX 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 representacin en Octave\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];
- 96 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX 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 que se 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 mscara\n\n"); exit(0); }
- 97 -
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 la 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, 51
mscara");
en 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 de linea, 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 una almohadilla (#), 35 en ASCII */
- 98 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX if(letra!=35) { printf("\nError en el formato de la imagen (la segunda linea debe ser un comentario)\n\n"); exit(0); } do { letra=fgetc(mascaras); } while(letra!=10); fscanf(mascaras,"%d",&mancho); /* Leemos dimensiones de la mascara */ fscanf(mascaras,"%d",&malto); /* Leemos dimensiones 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]); /* Lectura de la cabecera PPM, segunda linea
comentada */
/* Valor de
- 99 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX indicemax=i; } if(valores[2*i-1]<=minimo) { minimo=valores[2*i-1]; 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: El resto 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 && (indiceminindicemin2)<9) return 20; /* Hay una caracterstica */ else { if((indicemin2-indicemin)>3 && (indicemin2-indicemin)<9) return 20; /* Hay una caracterstica */
negro */
/* Valor de
- 100 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX else caracterstica */ } } else return 240; /* No hay una caracterstica */ 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) { return 240; /* No hay una
//
- 101 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX case 1: cercano=(long int *)calloc(8,sizeof(long int)); if(!cercano) { printf("\nError al reservar la memoria para crear el alrededor del pxel\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 pxel\n\n"); exit(0); } for(i=1;i<=13;i++) for(j=1;j<=13;j++) cercano[13*(i-1)+j-1]=Coordenadas(x7+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 *fpxel; imagenTMP=(short int *)calloc(n,sizeof(short int)); Reservamos memoria para leer la imagen */ if(!imagen) { /*
- 102 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX printf("\nError al reservar la memoria para crear la imagen temporal\n\n"); exit(0); } for(i=0;i<n;i++) /* Inicializacin de la imagen temporal a valor de blanco */ imagenTMP[i]=255; switch(opcion) { case 1: /* Proceso de erosin */ 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]]/ if(suma>0) imagenTMP[coordenada]=255; else imagenTMP[coordenada]=0; free(cercano); } break; case 2: /* Proceso de dilatacin */ 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]]/ if(suma>7) imagenTMP[coordenada]=255; else imagenTMP[coordenada]=0; free(cercano); } break; case 3: /* Bsqueda de direcciones */ mascara=CargaMascara(); for(y=7;y<(alto-7);y++)
255;
255;
- 103 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX for(x=7;x<(ancho-7);x++) { 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;
- 104 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX do { i=0; j++; for(y=1;y<(alto-1);y++) for(x=1;x<(ancho-1);x++) { coordenada=Coordenadas(x,y); cercano=Alrededor if(imagen[coordenada]==0) { suma=0; for(i=0;i<8;i++) suma=suma+imagen if(suma<1) { i++; imagenTMP } else [coordenada]=0; } else =imagen[coordenada]; } 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++) imagenTMP[coordenada] free(cercano); imagenTMP
(coordenada,1);
[cercano[i]]/255;
[coordenada]=255;
- 105 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX { coordenada=Coordenadas(x,y); cercano=Alrededor if(imagen[coordenada]==0) { suma=0; for(i=0;i<8;i++) if(imagen[cercano suma=suma+1; switch(suma) { case 8: imagenTMP break; case 7: imagenTMP break; case 6: imagenTMP
(coordenada,1);
[i]]==0)
[coordenada]=imagen[coordenada];
[coordenada]=imagen[coordenada];
[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) imagenTMP[coordenada]=255; else if(imagen [cercano[3]]==255&&imagen[cercano[5]]==255&&imagen[cercano[6]] ==255) imagenTMP[coordenada]=255; else if(imagen [cercano[4]]==255&&imagen[cercano[6]]==255&&imagen[cercano[7]] ==255) imagenTMP[coordenada]=255; else imagenTMP[coordenada]=imagen[coordenada]; break; case 4:
- 106 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX if(imagen [cercano[0]]==0&&imagen[cercano[2]]==0&&imagen[cercano[5]] ==0&&imagen[cercano[7]]==0) imagenTMP[coordenada]=imagen[coordenada]; [cercano[1]]==0&&imagen[cercano[6]]==0) imagenTMP[coordenada]=imagen[coordenada]; [cercano[3]]==0&&imagen[cercano[4]]==0) imagenTMP[coordenada]=imagen[coordenada]; else if(imagen [cercano[0]]==0&&imagen[cercano[1]]==0&&imagen[cercano[4]] ==0&&imagen[cercano[7]]==0) imagenTMP[coordenada]=imagen[coordenada]; else if(imagen [cercano[1]]==0&&imagen[cercano[2]]==0&&imagen[cercano[3]] ==0&&imagen[cercano[5]]==0) imagenTMP[coordenada]=imagen[coordenada]; else if(imagen [cercano[2]]==0&&imagen[cercano[4]]==0&&imagen[cercano[6]] ==0&&imagen[cercano[5]]==0) imagenTMP[coordenada]=imagen[coordenada]; else if(imagen [cercano[0]]==0&&imagen[cercano[3]]==0&&imagen[cercano[6]] ==0&&imagen[cercano[7]]==0) imagenTMP[coordenada]=imagen[coordenada]; else imagenTMP[coordenada]=255; break; case 3: if(imagen [cercano[0]]==0&&imagen[cercano[5]]==0&&imagen[cercano[7]]==0) imagenTMP[coordenada]=imagen[coordenada]; else if(imagen [cercano[2]]==0&&imagen[cercano[5]]==0&&imagen[cercano[7]]==0) imagenTMP[coordenada]=imagen[coordenada]; else if(imagen [cercano[0]]==0&&imagen[cercano[2]]==0&&imagen[cercano[5]]==0) imagenTMP[coordenada]=imagen[coordenada]; else if(imagen [cercano[0]]==0&&imagen[cercano[2]]==0&&imagen[cercano[7]]==0) imagenTMP[coordenada]=imagen[coordenada]; else if(imagen else if(imagen
- 107 -
else if(imagen [cercano[0]]==0&&imagen[cercano[1]]==0&&imagen[cercano[2]]==0) imagenTMP[coordenada]=imagen[coordenada]; else if(imagen [cercano[5]]==0&&imagen[cercano[6]]==0&&imagen[cercano[7]]==0) imagenTMP[coordenada]=imagen[coordenada]; else if(imagen [cercano[0]]==0&&imagen[cercano[3]]==0&&imagen[cercano[5]]==0) imagenTMP[coordenada]=imagen[coordenada]; else if(imagen [cercano[2]]==0&&imagen[cercano[4]]==0&&imagen[cercano[7]]==0) imagenTMP[coordenada]=imagen[coordenada]; else if(imagen [cercano[0]]==0&&imagen[cercano[1]]==0&&imagen[cercano[6]]==0) imagenTMP[coordenada]=imagen[coordenada]; else if(imagen [cercano[1]]==0&&imagen[cercano[2]]==0&&imagen[cercano[6]]==0) imagenTMP[coordenada]=imagen[coordenada]; else if(imagen [cercano[1]]==0&&imagen[cercano[5]]==0&&imagen[cercano[6]]==0) imagenTMP[coordenada]=imagen[coordenada]; else if(imagen [cercano[1]]==0&&imagen[cercano[6]]==0&&imagen[cercano[7]]==0) imagenTMP[coordenada]=imagen[coordenada]; else if(imagen [cercano[2]]==0&&imagen[cercano[3]]==0&&imagen[cercano[4]]==0) imagenTMP[coordenada]=imagen[coordenada]; else if(imagen [cercano[0]]==0&&imagen[cercano[3]]==0&&imagen[cercano[4]]==0) imagenTMP[coordenada]=imagen[coordenada]; else if(imagen [cercano[3]]==0&&imagen[cercano[4]]==0&&imagen[cercano[7]]==0) imagenTMP[coordenada]=imagen[coordenada]; else if(imagen [cercano[3]]==0&&imagen[cercano[4]]==0&&imagen[cercano[5]]==0) imagenTMP[coordenada]=imagen[coordenada]; else if(imagen [cercano[0]]==0&&imagen[cercano[3]]==0&&imagen[cercano[6]]==0)
- 108 -
imagenTMP[coordenada]=imagen[coordenada]; else if(imagen [cercano[1]]==0&&imagen[cercano[3]]==0&&imagen[cercano[5]]==0) imagenTMP[coordenada]=imagen[coordenada]; else if(imagen [cercano[2]]==0&&imagen[cercano[4]]==0&&imagen[cercano[6]]==0) imagenTMP[coordenada]=imagen[coordenada]; else if(imagen [cercano[1]]==0&&imagen[cercano[4]]==0&&imagen[cercano[7]]==0) imagenTMP[coordenada]=imagen[coordenada]; else if(imagen [cercano[1]]==0&&imagen[cercano[2]]==0&&imagen[cercano[3]]==0) imagenTMP[coordenada]=imagen[coordenada]; else if(imagen [cercano[0]]==0&&imagen[cercano[1]]==0&&imagen[cercano[4]]==0) imagenTMP[coordenada]=imagen[coordenada]; else if(imagen [cercano[3]]==0&&imagen[cercano[6]]==0&&imagen[cercano[7]]==0) imagenTMP[coordenada]=imagen[coordenada]; else if(imagen [cercano[4]]==0&&imagen[cercano[5]]==0&&imagen[cercano[6]]==0) imagenTMP[coordenada]=imagen[coordenada]; else imagenTMP[coordenada]=255; break; case 2: if(imagen
else if(imagen
else if(imagen
else if(imagen
else if(imagen
- 109 -
imagenTMP[coordenada]=imagen[coordenada]; [cercano[3]]==0&&imagen[cercano[4]]==0) imagenTMP[coordenada]=imagen[coordenada]; [cercano[0]]==0&&imagen[cercano[7]]==0) imagenTMP[coordenada]=imagen[coordenada]; [cercano[2]]==0&&imagen[cercano[5]]==0) imagenTMP[coordenada]=imagen[coordenada]; else imagenTMP[coordenada]=255; case 1: imagenTMP break; case 0: imagenTMP break; } if(imagenTMP[coordenada] valor++; } else =imagen[coordenada]; imagenTMP[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) { else if(imagen else if(imagen else if(imagen
[coordenada]=imagen[coordenada];
[coordenada]=255;
==255&&suma!=1)
- 110 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX cercano=Alrededor suma=0; for(i=0;i<8;i++) if(imagen[cercano
(coordenada,1);
[i]]==0)
suma=suma+1; switch(suma) { case 3: if(imagen [cercano[0]]==0&&imagen[cercano[3]]==0&&imagen[cercano[7]]==0) imagenTMP[cercano[4]]=0; else if(imagen [cercano[2]]==0&&imagen[cercano[4]]==0&&imagen[cercano[5]]==0) imagenTMP[cercano[3]]=0; else if(imagen [cercano[0]]==0&&imagen[cercano[4]]==0&&imagen[cercano[7]]==0) imagenTMP[cercano[3]]=0; else if(imagen [cercano[2]]==0&&imagen[cercano[3]]==0&&imagen[cercano[5]]==0) imagenTMP[cercano[4]]=0; else if(imagen [cercano[2]]==0&&imagen[cercano[5]]==0&&imagen[cercano[6]]==0) imagenTMP[cercano[4]]=0; else if(imagen [cercano[0]]==0&&imagen[cercano[6]]==0&&imagen[cercano[7]]==0) imagenTMP[cercano[3]]=0; else if(imagen [cercano[0]]==0&&imagen[cercano[1]]==0&&imagen[cercano[7]]==0) imagenTMP[cercano[6]]=0; else if(imagen [cercano[1]]==0&&imagen[cercano[2]]==0&&imagen[cercano[5]]==0) imagenTMP[cercano[6]]=0; break; case 2: if(imagen
else if(imagen
- 111 -
else if(imagen
else if(imagen
else if(imagen
else if(imagen
else if(imagen
else if(imagen
[cercano[0]]==0&&imagen[cercano[7]]==0)
else if(imagen {
imagenTMP[cercano[3]]=0; imagenTMP[cercano[4]]=0; } else if(imagen { imagenTMP[cercano[3]]=0; imagenTMP[cercano[4]]=0; } break; } free(cercano); } } for(i=0;i<n;i++) imagen[i]=imagenTMP[i];
[cercano[2]]==0&&imagen[cercano[5]]==0)
- 112 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX if(valor==valorNUEVO) valorN++; else valorN=0; }while(valorN<3&&j<MAXIMO_ESQUELETO); break; case 6: /* Bsqueda de Caractersticas */ 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*i1]=valores[2*i-1]+valor; valores[2*i2]++; } } 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*i1]); printf("])"); */ direcciones[coordenada] =BuscaDirecciones(valores,2);
- 113 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX 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 "); }
- 114 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX } 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 en el 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\n 255\n",ancho,alto); for(i=0;i<n;i++) { angulo=direcciones[i]/10; switch (angulo) { case 1: fprintf(fhuella," 64 192 break; case 2: fprintf(fhuella," 0 255 break; case 3: fprintf(fhuella," 0 192 break;
0\n");
0\n");
64\n");
- 115 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX 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; } } if(fclose(fhuella)==EOF) /* Cerramos el archivo en el que se almacena la matriz */ { printf("\nError al cerrar el archivo para las direcciones\n\n"); exit(0); } } void GeneraFicheroCaracteristica(char nombre[13])
- 116 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX { 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\n 255\n",ancho,alto); for(i=0;i<n;i++) { switch (imagen[i]) { case 13: fprintf(fhuella," break; case 169: fprintf(fhuella," break; case 69: fprintf(fhuella," break; default: fprintf(fhuella," imagen[i],imagen[i]); break; } }
0 255 0\n");
255 0 0\n");
0 0 255\n");
%d %d %d\n",imagen[i],
if(fclose(fhuella)==EOF) /* Cerramos el archivo en el que se almacena la matriz */ { printf("\nError al cerrar el archivo para las direcciones\n\n"); exit(0); } } void GeneraMatriz(void) { FILE *fmatriz; if(!(fmatriz=fopen("matriz.txt","w+"))) archivo para almacenar la matriz */ { /* Abrimos el
- 117 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX 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 en el 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 pxeles) \n",ancho,alto,n); printf("\n Calculando Maximo y Minimo... "); maximo=CalculaMaximo(); printf("... Maximo: %d",maximo); minimo=CalculaMinimo();
- 118 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX 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); /* Erosin */ printf("...imagen erosionada... "); GeneraFichero("06openero.pnm","P3","Imagen erosionada (OPENING)"); printf("...fichero grabado");
- 119 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX printf("\n Dilatando imagen... "); if(OPEN_DIL==1) ProcesaImagen(2); /* Dilatacin */ 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); /* Dilatacin */ printf("...imagen dilatada... "); GeneraFichero("08closdil.pnm","P3","Imagen dilatada (CLOSING)"); printf("...fichero grabado"); printf("\n Erosionando imagen... "); if(CLOSE_ERO==1) ProcesaImagen(1); /* Erosin */ printf("...imagen erosionada... "); GeneraFichero("09closero.pnm","P3","Imagen erosionada (CLOSING)"); printf("...fichero grabado \n"); printf(" FIN DEL CLOSING \n"); // SobrescribeOriginal(); original con la actual */ /* Sobrescrimos la imagen
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 caractersticas */ printf("...caracteristicas encontradas... "); GeneraFicheroDireccion("13caractr.pnm");
- 120 -
ALGORITMO DE OBTENCIN DE CARACTERSTICAS EN HUELLAS DACTILARES PARA SISTEMAS EMBEBIDOS GNU/LINUX 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; }
- 121 -