UNIVERSIDAD NACIONAL DANIEL ALCIDES CARRION
PROYECTO: LECTOR DE HUELLA DIGITAL EN JAVA
INTELIGENCIA ARTIFICIAL
DOCENTE:
Ing. HUAROC SUAREZ, Jhonny A.
SEMESTRE: VI
INTEGRANTES:
ESPINOZA CONDOR, Iván
CALLUPE SEGURA, Cristian
E.F.P
SISTEMAS Y COMPUTACION
Cerro de Pasco, Octubre de 2013
LECTOR DE HUELLA DIGITAL EN JAVA
Actualmente estamos trabajando en este proyecto que pretende realizar la autentificación de
personas en base a su huella digital, lo que este sistema realizará a grandes rasgos es
primeramente registrar una cantidad definida de huellas de una persona para que posteriormente al
tratar de realizar algún procedimiento le sea requerido colocar alguno de los dedos previamente
registrados para poder proceder.
Existen diversas ventajas y desventajas al implementar un sistema de este tipo ya que la correcta
lectura de la huella digital depende de varios factores ajenos a la programación del sistema, sin
embargo, este tipo de autentificación es sumamente segura y resulta realmente cómodo para las
personas el no tener que portar ningún tipo de documento para poder realizar transacciones
previamente definidas.
En un principio sinceramente no encontrábamos por dónde comenzar ya que nunca habíamos
desarrollado ningún proyecto de este tipo pero poco a poco fuimos detectando y obteniendo todo lo
necesario para poder realizar este trabajo.
Navegando por la web encontramos algunos foros en los cuales se hablaba de diversos SDK's para
programar un lector de huellas, desde el propietario de Digital Persona hasta algunos otros más
flexibles como el de Griaule, cada uno de ellos con sus respectivas descargas de prueba. Al final
decidí utilizar el Fingerprint SDK Java 2007 de Griaule ya que provee de diversas funcionalidades
y facilidades de implementación, además de que la licencia de uso es relativamente barata ($36 USD
para un cliente) y al descargarlo obtienes también diversas aplicaciones de ejemplo para poder
entender mejor su funcionamiento.
Además de Java, Griaule provee SDK's para otros lenguajes de programación como Delphi, Visual
Basic, C++, .NET, FoxPro, etc, soporta 19 modelos de lectores diferentes (incluyendo el de
Microsoft) ya que viene también con un controlador genérico tanto para Windows como Linux que
te reconoce cualquiera de estos dispositivos al momento de conectarlo ;), puede comparar hasta
35,000 huellas por segundo y soporta perfectamente un ambiente de cliente - servidor (actualmente
yo tengo mi servidor de aplicaciones y bases de datos en Ubuntu Linux 8.04 y nuestros clientes en
Windows).
Para realizar la descarga del software de prueba es necesario registrarse previamente (no tiene costo
alguno). Ahora hablaremos sobre la implementación y la programación de este SDK.
Programando el lector de huella digital en Java Parte 1.
En la actualidad la seguridad en las transacciones electrónicas se ha vuelto una parte indispensable
para los programadores de sistemas, la identificación para el acceso a los registros y demás
cuestiones relacionadas deben de ser tomadas en cuenta para poder validar que alguna persona está
accediendo realmente a lo que debe acceder, es esencial hacer que (en medida de lo posible) nadie
pueda hacerse pasar por alguien que no es al momento de identificarse en un sistema. Aquí es donde
la biometría juega un papel sumamente interesante (más información sobre la biometría en éste
artículo) así que dedicaremos una serie de artículos a tratar de explicar cómo programar un lector de
huella digital en Java utilizando algunas herramientas y API's que nos permitirán realizar todos los
procedimientos sin ningún problema.
Primeramente hablaré de lo que necesitamos para poder empezar a programar un sistema completo
de registro y verificación de identidades por medio de la huella digital:
El JRE (Java Runtime Environment) más reciente, al momento de la publicación de este
artículo es la 1.6.7.
IDE de programación NetBeans en su versión más reciente, al momento de publicar este
artículo es la 6.1. Cabe mencionar que el vínculo que indico contiene varias versiones, se
puede descargar cualquiera que cuente con el Base IDE y Java SE.
Un lector de huella digital de cualquiera de estos modelos.
El API de programación de lectores de huella digital de Griaule para Java.
Un servidor de bases de datos en MySQL.
Una vez que tenemos todo lo anterior procedemos con la instalación del API de programación de
Griaule (asumo que el NetBeans y el servidor MySQL ya están instalados y funcionando sin
problemas). Instalación del API de programación de Griaule: Una vez que hemos descargado el
API tendremos un archivo llamadoFingerprint_SDK_Java_2007_Installer.jar, para comenzar la
instalación se realiza lo siguiente:
1. Doble clic sobre el archivo, aparecerá una ventana que nos pide elegir el idioma, selecciona
el que desees.
2. Posteriormente aparece la pantalla de bienvenida y si se da clic en Siguiente aparecen los
términos de la licencia, los cuales se debe aceptar para poder continuar.
3. Una vez hecho lo anterior se selecciona la ruta donde se instalará, aquí se dejan los valores
por defecto.
4. Después de la ruta de instalación se debe elegir los elementos que se instalarán, de igual
manera se deja todo marcado y se da clic en Siguiente.
5. Posteriormente se instalan los elementos seleccionados, dejando al final la instalación del
controlador. NOTA: Es de suma importancia tomar en cuenta que antes de la instalación del
lector de huella digital, este se debe de tener desconectado y de preferencia desinstalar el
software y controladores que venían con él de fábrica para evitar conflictos durante
la actual instalación.
6. Ahora aparece una pantalla para seleccionar el idioma de la instalación del controlador, de
igual manera se elige el que más convenga.
7. Después aparece la pantalla de bienvenida...
... aquí se da clic en Siguiente o Next.
8. Se aceptan los términos de la licencia y se da clic en Siguiente un par de veces.
9. Posteriormente presionamos el botón de Instalar o Install para que se realice la instalación
de los controladores del lector.
10. Al terminar el proceso se da clic en el botón de Siguiente y posteriormente en Finalizar para
terminar la instalación del controlador.
11. Una vez hecho esto se sigue con la pantalla del proceso de instalación general...
... y se da clic en Siguiente o Next.
12. Al final se da clic en el botón Done para culminar.
Una vez terminada la instalación del API se puede conectar el lector para terminar su
instalación. Conectar el lector de huella digital: Ahora continuemos con lo siguiente:
1. Se conecta el lector de huella digital.
2. Aparece el Asistente para Nuevo Hardware de Windows.
3. Se selecciona No por el momento y se da clic en Siguiente.
4. Después se elige Instalar automáticamente el software recomendado y se da clic en
siguiente.
5. Se espera a que termine la instalación, el asistente debe de reconocerlo e instalar los
controladores que previamente hemos agregado junto con el API.
6. Se da clic en Finalizar para terminar la instalación.
Programando el lector de huella digital en Java Parte 2.
Continuando con la programación de un lector de huella digital en Java procederemos en este caso
ya directamente con el código, la entrega anterior se refirió meramente a la preparación del entorno
para el desarrollo, si no la has leído te recomiendo verificarla, entenderla y realizarla primero antes
de proceder con esto ya que de lo contrario no funcionará la aplicación.
Comenzando con las indicaciones, haremos lo siguiente:
1. Creamos un proyecto en NetBeans con el nombre EjemploLectorHuellas.
2. Dentro del proyecto crear un paquete de nombre procedimientos y otro de nombre interfaz.
3. Dentro de procedimientos crear una clase (Java Class) llamada Util.
4. En la definición de la clase util agregar implements IStatusEventListener, IImageEventListener,
IFingerEventListener y sus correspondientes imports...
import com.griaule.grfingerjava.FingerprintImage;
import com.griaule.grfingerjava.IFingerEventListener;
import com.griaule.grfingerjava.IImageEventListener;
import com.griaule.grfingerjava.IStatusEventListener;
public class Util implements IStatusEventListener,
IImageEventListener, IFingerEventListener{
5. Al implementar dichas interfaces nos pedirán implementar todos sus métodos abstractos, lo
hacemos dando un clic en el foco que aparece del lado izquierdo y seleccionando "Implement all
abstract methods" lo cual generará la implementación de 5 métodos (modifica el nombre de los
argumentos para mejor referencia):
public void onSensorPlug(String idSensor) // evento que se genera
al conectar el lector de huella
public void onSensorUnplug(String idSensor) // evento que se genera
al desconectar el lector de huella
public void onImageAcquired(String idSensor, FingerprintImage
huellaDigital) // evento que se genera al obtener una imagen de la
huella
public void onFingerDown(String idSensor) // evento que se genera
al colocar un dedo en el lector
public void onFingerUp(String idSensor) // evento que se genera
al levantar el dedo del lector
Cabe mencionar que no utilizaremos todos los eventos en este ejemplo pero se deben de
implementar para que el compilador no marque errores ya que provienen de una interface.
6. Modificamos los métodos onSensorPlug y onSensorUnplug para que queden de la siguiente
manera:
public void onSensorPlug(String idSensor) {
try {
GrFingerJava.startCapture(idSensor, this, this);
} catch (GrFingerJavaException e) {
e.printStackTrace();
}
}
public void onSensorUnplug(String idSensor) {
try {
GrFingerJava.stopCapture(idSensor);
} catch (GrFingerJavaException e) {
e.printStackTrace();
}
}
Lo anterior es para evitar problemas en la captura al momento de conectar y desconectar el lector,
para que el compilador no marque errores debemos importar las
clases GrFingerJavay GrFingerJavaException...
import com.griaule.grfingerjava.GrFingerJava;
import com.griaule.grfingerjava.GrFingerJavaException;
Los demás métodos que se implementaron deben de quedar vacíos (por el momento).
7. Ahora creamos un método estático que nos permita establecer el directorio de las
librerías del SDK
/**
* Establece el directorio donde se ubican las librerías nativas
del SDK
*/
public static void setFingerprintSDKNativeDirectory(String
directorio) {
File directory = new File(directorio);
try {
GrFingerJava.setNativeLibrariesDirectory(directory);
GrFingerJava.setLicenseDirectory(directory);
} catch (GrFingerJavaException e) {
e.printStackTrace();
}
}
y el import de la clase File correspondiente:
import java.io.File;
8. Posteriormente agregamos los siguientes objetos y variables inmediatamente después
de la definición de la clase:
/**Contexto utilizado para la captura, extracción y coincidencia
de huellas digitales */
private MatchingContext fingerprintSDK;
/**Interfaz de usuario donde se muestra la imagen de la huella*/
private PantallaPrincipal ui;
/** Indica si la plantilla o template debe ser extraída
automáticamente*/
private boolean autoExtract = true;
/** Contiene localmente los datos de la huella capturada */
private ByteArrayInputStream fingerprintData;
/**Contiene la longitud del dato de la huella*/
private int fingerprintDataLength;
/** La imagen de la última huella digital capturada. */
private FingerprintImage fingerprint;
/** La plantilla de la última imagen de huella capturada */
public Template template;
... con sus correspondientes imports ...
import com.griaule.grfingerjava.MatchingContext;
import interfaz.PantallaPrincipal;
import java.io.ByteArrayInputStream;
Nota: se debe agregar 'import interfaz.PantallaPrincipal;' aún cuando no existe actualmente ya que
se creará en los pasos siguientes.
9. Ahora crearemos la interfaz de usuario, para ello damos clic derecho en el paquete interfaz y
seleccionamos New -> JFrame Form, le damos por nombre 'PantallaPrincipal'.
10. Agregamos dos paneles (Huella Digital y Acciones, como se muestra en la imagen) y 4 botones
(Verificar, Identificar, Guardar y Salir) de manera que queden parecido a lo siguiente:
11. Nombramos los botones tal cual su etiqueta pero anteponiendo las letras btn, es
decirbtnVerificar, btnIdentificar y así sucesivamente, el panel de Huella Digital lo nombramos
'panelContenedor'.
12. Establecemos el panelContenedor con un BorderLayout dando un clic derecho sobre él -> Set
Layout -> Border Layout
12. Ya que tenemos lo anterior nos vamos a la vista de código y agregamos los siguientes
objetos...
//objeto usado para realizar todas las operaciones relacionadas
al Fingerprint-SDK
private Util procedimientosSDK;
//Panel para mostrar la huella digital
private JPanel fingerprintViewPanel = null;
//Imagen de la huella actual
private BufferedImage fingerprintImage = null;
... con sus correspondientes imports ...
import java.awt.image.BufferedImage;
import javax.swing.JPanel;
import procedimientos.Util;
... los objetos deben ir dentro de la clase pero fuera de cualquier método.
13. Nuevamente modificamos la clase Util agregando un constructor sobrecargado que
reciba un objeto de tipo PantallaPrincipal de la siguiente manera:
public Util(PantallaPrincipal ui) {
this.ui = ui;
}
14. Por último en la clase Util (por el momento) agregamos un método que nos permita
inicializar la captura de las huellas, deberá de quedar así:
/**
* Inicializa el Fingerprint SDK y habilita la captura de
huellas.
*/
public void inicializarCaptura() {
try {
fingerprintSDK = new MatchingContext();
//Inicializa la captura de huella digital.
GrFingerJava.initializeCapture(this);
} catch (Exception e) {
//Si ocurre un error se cierra la aplicación.
e.printStackTrace();
System.exit(1);
}
}
15. Ahora trabajaremos con la clase PantallaPrincipal, lo que haremos es crear un método para
inicializar la forma, estableciendo el estilo visual y creando una instancia de la clase Util. Deberá
quedar de la siguiente manera:
/**
* Se establece el estilo visual de la aplicación y se realiza
la inicialización de la clase
* que contiene los procedimientos principales.
**/
public void inicializar() {
try {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName())
;
} catch (Exception e) {
System.err.println("No se pudo aplicar el estilo
visual");
}
//Crea una instancia de Util
this.procedimientosSDK = new Util(this);
}
... y su import correspondiente:
import javax.swing.UIManager;
16. Agregamos una llamada al método inicializar() dentro del constructor de la clase y
antes del método initComponents() de tal manera que quede así:
/* Crea una nueva forma de PantallaPrincipal */
public PantallaPrincipal() {
inicializar();
initComponents();
}
17. Ahora hacemos un método para crear el contenedor de la imagen de la huella digital,
en los comentarios se va explicando las funciones de cada línea...
/**
* Crea el panel que contendrá la imagen de la huella digital
*/
private JComponent crearPanelHuella() {
//Crea un panel nuevo para mostrar la huella
fingerprintViewPanel = new JPanel(){
//Se sobreescribe el método paintComponent
//para habilitar la muestra de la imagen de la huella
public void paintComponent(Graphics g) {
super.paintComponent(g);
//Si hay una imagen para ser mostrada
if (fingerprintImage!=null) {
//Calcula el tamaño y posición de la imagen para
ser pintada
//el tamaño es ajustado para que ocupe todo el
tamaño del panel
Insets insets = getInsets();
int transX = insets.left;
int transY = insets.top;
int width = getWidth() - getInsets().right -
getInsets().left;
int height = getHeight() - getInsets().bottom -
getInsets().top;
//Se dibuja la imagen
g.drawImage(fingerprintImage, transX, transY,
width, height, null);
}
}
};
//Se agrega un borde alrededor del panel
fingerprintViewPanel.setBorder(new CompoundBorder (
new EmptyBorder (2,2,2,2),
new BevelBorder(BevelBorder.LOWERED)));
//si no hay existe el panel de la huella no devuelve nada...
if(fingerprintViewPanel==null)
{
return null;
}else{ // de lo contrario devuelve el panel mismo
return fingerprintViewPanel;
}
}
... y se agregan los imports correspondientes para evitar errores ...
import java.awt.Graphics;
import java.awt.Insets;
import javax.swing.JComponent;
import javax.swing.border.BevelBorder;
import javax.swing.border.CompoundBorder;
import javax.swing.border.EmptyBorder;
18. Una vez hecho esto nos vamos a la vista de diseño de la clase PantallaPrincipal, sin
seleccionar ningún elemento damos clic derecho sobre el JFrame y posteriormente
seleccionamos Events -> Window -> WindowActivated ...
... lo cual nos llevará a la vista de código de la clase, dentro del método form Window
Activated, ahí agregamos el código de manera que quede de la siguiente forma:
private void formWindowActivated(java.awt.event.WindowEvent evt) {
this.panelContenedor.add(crearPanelHuella());
}
19. Ahora creamos el método showImage que nos permitirá mostrar la imagen capturada
por el lector en el panel correspondiente. El método debe quedar de la siguiente manera:
/**
* Método utilizado para mostrar la imagen de la huella
* en el panel correspondiente.
*/
public void showImage(BufferedImage image) {
//Utiliza el imageProducer para crear una imagen de la
huella digital
fingerprintImage = image;
//Se dibuja la nueva imagen
repaint();
}
20. Una vez hecho esto vamos a la clase Util y agregamos el código correspondiente al
método onImageAcquired que se ha creado al implementar las interfaces, el método
debe quedar así:
/**
* Este método es llamado cada vez que la imagen de una huella
ha sido capturada.
*/
public void onImageAcquired(String idSensor, FingerprintImage
huellaDigital) {
//Almacena la imagen de la huella
this.fingerprint=huellaDigital;
//Muestra la imagen obtenida
ui.showImage(huellaDigital);
}
21. Ahora en el constructor de la clase Pantalla Principal agregamos las siguientes 3
líneas:
/*Inicializa la captura de huellas*/
procedimientosSDK.inicializarCaptura();
/*centra la ventana en la pantalla*/
setLocationRelativeTo(null);
/*hace visible la ventana*/
setVisible(true);
22. Agregamos el evento Action Performed del botón 'Salir' dando clic derecho sobre él
en vista de diseño y seleccionando Events -> Action -> ActionPerformed y dentro del
código generado agregamos el método dispose();
23. Para que nuestro programa pueda ejecutarse necesitamos mandarlo llamar desde la
clase main, en este caso además de llamar a la ventana se necesita establecer el
directorio de las librerías, en conjunto, el método main de la clase main debe quedar así:
public static void main(String[] args) {
String grFingerNativeDirectory = new
File(".").getAbsolutePath();
Util.setFingerprintSDKNativeDirectory(grFingerNativeDirectory);
PantallaPrincipal p = new PantallaPrincipal();
}
Una vez hecho esto podemos correr la aplicación con F6 y verificar que realmente
funcione, si has realizado los pasos tal cual podrás, hasta este momento, activar el lector
de huellas y obtener la lectura de la huella que se ha colocado en el lector, aún nos falta
especificar cómo verificar, identificar y guardar las huellas pero eso lo dejaremos para la
próxima entrega.
¿Alguna duda o algo qué decir? Deja tu comentario. Saludox.
Programando el lector de huella digital en Java. Parte 3.
Siguiendo con el proyecto para la programación de un lector de huellas en Java (si no has leído la parte 1 y parte 2 te recomiendo hacerlo antes de proceder) en este caso explicaré cómo almacenar los registros de las huellas en una base de datos en MySQL, anteriormente en la parte 1 hemos creado la base de datos con 3 columnas (el id, los datos de la huella y el nombre de la persona que la registró) ahora pasemos al código.
Recapitulando...
Se tienen únicamente 3 clases en el proyecto: la clase ejemplolectorhuellas.Main, interfaz.PantallaPrincipal y procedimientos.Util, donde Main es a través de la cual se arranca el programa, Pantalla Principal es la interfaz y Util es la clase que contiene los procedimientos.
Al realizar todos los procedimientos de la parte 2 del tutorial y ejecutar el programa se debe de enceder el lector de huellas, al colocar el dedo sobre el lector debe de aparecer la imagen de la huella capturada.
¿Hasta aquí todo bien? Si tu respuesta es afirmativa continúa con los siguientes pasos, de lo contrario regresa a las partes anteriores y verifíca que no tengas errores en la codificación.
Agregar los objetos para las consultas en procedimientos.Util::
Abrimos la clase Procedimientos.Util y agregamos al inicio de la misma los siguientes objetos:
/**Conexión a la base de datos*/ private Connection dbConnection; /**Consultas preparadas**/ private PreparedStatement guardarStmt; private PreparedStatement identificarStmt; private PreparedStatement verificarStmt;
Los objetos anteriores se utilizarán para crear la conexión a la base de datos y realizar consultas en la misma, para poder realizar lo anterior debemos de crear un par de métodos como se muestran a continuación:
/** * Inicializa la conexión a la base de datos y prepara las operaciones para insertar, * eliminar y modificar los datos */ private void initDB() { try { //Carga el driver ODBC Class.forName("com.mysql.jdbc.Driver");
//Se conecta a la bd dbConnection = DriverManager.getConnection("jdbc:mysql://servidor:3306/huellas","usuario", "contrasena");
Statement stm = dbConnection.createStatement(); //Prepara las consultas/sentencias que se utilizarán guardarStmt = dbConnection.prepareStatement("INSERT INTO somhue(id, huenombre, huehuella) values(?,?,?)"); identificarStmt = dbConnection.prepareStatement("SELECT huehuella FROM somhue"); verificarStmt = dbConnection.prepareStatement("SELECT huehuella FROM somhue WHERE huenombre=?"); } catch (Exception e) { e.printStackTrace(); } } /** * Cierra la conexión a la base de datos y libera los recursos empleados.
*/ private void destroyDB() { try { //Se cierran todas las sentencias guardarStmt.close(); identificarStmt.close(); //Cierra la conexión a la base dbConnection.close(); } catch (Exception e) { e.printStackTrace(); } }
Las partes en rojo deben ser remplazadas por aquellas que correspondan a tu configuración del servidor MySQL. Una vez que tenemos la conexión a la base de datos debemos hacer que el programa se conecte al inicializar la clase procedimientos.Util, para ello debemos de agregar una llamada al método initDB() dentro del constructor de la misma para que al final quede de la siguiente manera:
public Util(PantallaPrincipal ui) { this.ui = ui; //Inicializa la conexión a la BD. initDB(); }
Antes de poder guardar la huella (o la información de la huella) en la base de datos debemos de extraer el llamado Template o plantilla de la huella que es una representación matemática de un mapa de la huella, es importante aclarar que no vamos a guardar la imagen de la huella sino este mapa a partir del cual se pueden comparar varias huellas o verificar a quién pertenece, existe la manera de guardar la imagen pero no se realizará dicho proceso en este tutorial debido a las siguiente razones:
1. No es seguro tener la imagen de una huella capturada.2. Una imagen ocupa muchísimo más espacio en la base de datos, si se plantea utilizar para
corroborar una considerable cantidad de huellas el proceso se vuelve inoperable.3. No es necesario tener la imagen de la huella para compararla con otra, basta con la plantilla
que se extraerá.
Una vez aclarado el punto anterior procedamos a extraer la plantilla de la huella capturada agregando el método extract() a la clase procedimientos.Util de la manera siguiente:
/** * Extrae la plantilla de la imagen de la huella actual. */ public void extract() { try { //Extrae la plantilla de la imagen. template = fingerprintSDK.extract(fingerprint); //Muestra la plantilla en la imagen
ui.showImage(GrFingerJava.getBiometricImage(template,fingerprint)); } catch (GrFingerJavaException e) { e.printStackTrace(); } }
Ya que hemos creado el método extract() basta con mandarlo llamar desde el método onImageAcquired() para que este último quede de la siguiente manera:
public void onImageAcquired(String idSensor, FingerprintImage huellaDigital) { //Almacena la imagen de la huella this.fingerprint=huellaDigital;
//Muestra la imagen obtenida ui.showImage(huellaDigital); //Muestra la plantilla en la imagen actual extract();}
Una vez hecho lo anterior podemos correr el programa y capturar una huella, notaremos que se dibujan algunas líneas verdes sobre la misma, dichas líneas son la representación de la plantilla que hemos extraído.
Ahora viene la parte donde guardamos la plantilla de la huella en la base de datos. Lo primero que hacemos es agregar el método guardarHuella() a procedimientos.Util de tal forma que quede de la siguiente manera:
/* * Guarda los datos de la huella digital actual en la base de datos */ public void guardarHuella(){
//Obtiene los datos del template de la huella actual fingerprintData = new ByteArrayInputStream(template.getData()); fingerprintDataLength = template.getData().length; //Pregunta el nombre de la persona a la cual corresponde dicha huella String nombre = JOptionPane.showInputDialog("Nombre:"); try { //Establece los valores para la sentencia SQL guardarStmt.setString(1,"default"); guardarStmt.setString(2,nombre); guardarStmt.setBinaryStream(3, fingerprintData, fingerprintDataLength); //Ejecuta la sentencia guardarStmt.execute();
} catch (SQLException ex) { //Si ocurre un error lo indica en la consola System.err.println("Error al guardar los datos de la huella."); ex.printStackTrace(); } }
Tras realizar lo anterior debemos de realizar import correspondiente a la clase JOptionPane: import javax.swing.JOptionPane
Lo único que resta por hacer es mandar llamar el método guardarHuella() por medio del botón Guardar que aparece en la pantalla principal, para ello nos situamos en la pantalla principal y damos doble clic sobre el botón Guardar lo cual automáticamente nos crea el método que se efectúa al presionar el botón, ahora solo basta mandar llamar el método de la siguiente manera:
private void btnGuardarActionPerformed(java.awt.event.ActionEvent evt) { procedimientosSDK.guardarHuella();}
Tras realizar lo anterior, al ejecutar el programa, capturar una huella y presionar el botón Guardar podremos almacenar los datos de la huella digital en la base de datos y, posteriormente, podremos realizar operaciones de comparación y verificación de identidades, pero esto lo dejaremos para la siguiente entrega.
¿Alguna duda o algo qué decir? Deja tu comentario. Saludox.
Programando el lector de huella digital en Java. Parte 4.
Anteriormente hemos visto cómo capturar y guardar huellas digitales en una base de datos en MySQL (si no sabes a lo que me refiero lee las partes Uno, Dos y Tres de este tutorial) ahora toca el turno a la verificación de una identidad por medio de la huella e identificación de una persona.
Antes de continuar cabe aclarar(y diferenciar) a lo que me refiero con verificación e identificación:
Verificación: Es el corroborar la identidad de una persona por medio de un dato previamente dado (como el nombre, una credencial, CURP, etc) y su huella digital, por ejemplo: yo digo que soy Juan Pérez y lo confirmo con mi huella digital.
Identificación: Es el corroborar la identidad de una persona utilizando solamente su huella digital, por ejemplo: coloco mi huella digital y el sistema automáticamente sabe que soy Juan Pérez.
Una vez aclarado lo anterior, procedamos pues a analizarlo en base al código que hemos agregado para las consultas en la parte 3 del tutorial.
Anteriormente agregamos un método de nombre initDB() que es por medio del cual se inicializa la conexión y se preparan las consultas a la base de datos, dicho método tiene, entre otras cosas, las siguientes líneas:
identificarStmt = dbConnection.prepareStatement("SELECT * FROM somhue"); verificarStmt = dbConnection.prepareStatement("SELECT huehuella FROM somhue WHERE huenombre=?");
Nota: anteriormente en la sentencia identificarStmt se tenía huella en lugar de *, para fines de esta aplicación debemos de cambiarlo para que quede tal cual se muestra en las líneas anteriores.
Aquí diferenciamos claramente que al momento de identificar una huella seleccionamos todas las huellas de la base de datos (que posteriormente compararemos una por una con la que tenemos actualmente para identificar a quién pertenece dicha huella), pero al momento de verificar solamente tomamos un registro de huella filtrando con el nombre de la persona a quien pertenece.
¿Todo perfectamente claro? Ok. Sigamos con el código que va a realizar la primera función: Verificar.
/** * Verifica la huella digital actual contra otra en la base de datos */ public void verify(String nom) { try { //Obtiene la plantilla correspondiente a la persona indicada verificarStmt.setString(1,nom); ResultSet rs = verificarStmt.executeQuery(); //Si se encuentra el nombre en la base de datos if (rs.next()){ //Lee la plantilla de la base de datos byte templateBuffer[] = rs.getBytes("huehuella"); //Crea una nueva plantilla Template referenceTemplate = new Template(templateBuffer); //compara las plantilas (actual vs bd) boolean coinciden = fingerprintSDK.verify(template,referenceTemplate); //Si corresponden, dibuja el mapa de correspondencia y lo indica con un mensaje if (coinciden){ ui.showImage(GrFingerJava.getBiometricImage(template, fingerprint, fingerprintSDK)); JOptionPane.showMessageDialog(ui, "Las huellas sí coinciden"); } else { //De no ser así lo indica con un mensaje JOptionPane.showMessageDialog(ui, "No corresponde la huella con "+nom, "Error", JOptionPane.ERROR_MESSAGE); }
//Si no encuentra alguna huella correspondiente //al nombre lo indica con un mensaje } else { JOptionPane.showMessageDialog(ui, "No existe el registro de "+nom, "Error", JOptionPane.ERROR_MESSAGE); } } catch (SQLException e) { e.printStackTrace(); } catch (GrFingerJavaException e) { e.printStackTrace(); } }
Al realizar lo anterior es posible que necesites importar algunas clases como java.sql.ResultSet para que todo funcione correctamente.
Ahora solo se debe de agregar una llamada al método verificar() desde el botón de Verificar en la clase interfaz.PantallaPrincipal, para realizarlo correctamente se debe dar doble clic sobre el botón y posteriormente agregar el código dentro del método creado de tal manera que quede así...
private void btnVerificarActionPerformed(java.awt.event.ActionEvent evt) { String nombre = JOptionPane.showInputDialog("Nombre a verificar:"); procedimientosSDK.verify(nombre);}
Si corremos la aplicación tras realizar lo anterior podremos verificar la huella capturada actualmente contra otra en la base de datos y el sistema nos indicará si la huella coincide o no...
Hasta aquí le dejamos en esta parte, si le has entendido correctamente a la lógica del código no te será difícil crear el método de identificar(), si lo deseas, puedes esperar a la próxima entrega en la cual lo explicaré paso a paso.
Programando el lector de huella digital en Java. Parte 5.
Después de una larga espera seguimos con el tutorial en su quinta parte (si no has leído las partes uno, dos, tres y cuatro te recomiendo que lo hagas antes de continuar). En este caso toca el turno a la identificación de personas por medio de su huella digital. Hasta el momento ya tenemos resueltas las funciones para guardar y verificar así que falta poco para culminar con las funciones básicas.
Recordemos que todos los procedimientos los estamos realizando en la clase procedimientos.Util así que vayamos a dicha clase y creamos un método de nombre identificarPersona() que no recibe argumentos de ningún tipo, en un principo quedará de la siguiente manera:
?
1 /**
23456
* Identifica a una persona registrada por medio de su huella digital */ public void identificarPersona(){
}
Ya que tenemos la definición del método debemos de brindarle un comportamiento pero
para decirle qué hacer primero debemos entenderlo. Para identificar una persona se
necesita tomar una muestra de la huella digital y posteriormente compararla con todas
aquellas entre las cuales se encuentra la persona, en este caso, entre todas las huellas
registradas, si encontramos un registro que coincida entonces tenemos a la persona que
buscamos.
En código se traduce a lo siguiente:
Primero obtenemos todas las huellas de la base de datos...
?
1 ResultSet rsIdentificar = identificarStmt.executeQuery();
...posteriormente iteramos a través de todos los resultados...
?
1 while(rsIdentificar.next()){
...en cada iteración obtenemos la plantilla de la huella almacenada...
?
1 byte templateBuffer[] = rsIdentificar.getBytes("huehuella");
...y la creamos para posteriormente utilizarla...
?
1 Template referenceTemplate = new Template(templateBuffer);
...ya que tenemos la plantilla de la base de datos la comparamos con
la actual almacenando el resultado de la comparación en una variable...
?
1 boolean coinciden = fingerprintSDK.verify(template,referenceTemplate);
...si coinciden hacemos lo pertinente y rompemos el ciclo de iteración y lo cerramos...
1234567
if (coinciden){ ui.showImage(GrFingerJava.getBiometricImage(template, fingerprint, fingerprintSDK)); JOptionPane.showMessageDialog(ui, "La huella es de "+rsIdentificar.getString("huenombre")); return;}
}
?
...si hemos buscado en todas las huellas y no se encuentra se lo indicamos al usuario...
?
1 JOptionPane.showMessageDialog(ui, "No existe ningún registro que coincida con la huella.");
...y listo!
Al finalizar debemos de encerrar el código entre algunos try-catch para evitar errores al
momento de compilar, el método completo queda así:
?
123456789101112131415161718192021222324
/** * verifica la huella digital actual contra otra en la base de datos */ public void identificarPersona() { try { //Obtiene todas las huellas de la bd ResultSet rsIdentificar = identificarStmt.executeQuery();
//Si se encuentra el nombre en la base de datos while(rsIdentificar.next()){ //Lee la plantilla de la base de datos byte templateBuffer[] = rsIdentificar.getBytes("huehuella"); //Crea una nueva plantilla Template referenceTemplate = new Template(templateBuffer);
//compara las plantilas (actual vs bd) boolean coinciden = fingerprintSDK.verify(template,referenceTemplate);
//Si encuentra correspondencia dibuja el mapa //e indica el nombre de la persona que coincidió. if (coinciden){ ui.showImage(GrFingerJava.getBiometricImage(template, fingerprint, fingerprintSDK)); JOptionPane.showMessageDialog(ui, "La huella es de "+rsIdentificar.getString("huenombre")); return; }
}
//Si no encuentra alguna huella que coincida lo indica con un mensaje
25262728293031323334353637
JOptionPane.showMessageDialog(ui, "No existe ningún registro que coincida con la huella.");
} catch (SQLException e) { e.printStackTrace(); } catch (GrFingerJavaException e) { e.printStackTrace(); } }
Posteriormente lo único que debemos hacer es mandarlo llamar desde el botón de 'Identificar' y listo! hemos terminado con las 3 funciones principales de un sistema de identificación de huellas digitales, solo necesitas adaptar estos métodos a tu aplicación y tendrás funcionalidad total.
Este proyecto se seguirá implementando en el transcurso de los días y también bajo la supervisión del docente encargado del curso.
Gracias
