PROGRAMACION DE 4500 FINGERPRINT READER DIGITAL PERSONA EN

JAVA CON WINDOWS 7-PARTE 2

Continuando con el desarrollo de este articulo, en esta parte nos encargaremos quizás de
la parte más importante en el desarrollo del artículo, el cual hace referencia a la creación
de los métodos abstractos que se implementan para el correcto funcionamiento de la
previas captura de las huellas digitales por medio del lector, y nuestra tercera parte
estaremos desarrollando las parte de cómo guardar, autentificar y verificar huellas desde
la base de datos creadas en la primera parte, entonces sin más aquí vamos:
• Creamos un nuevo proyecto el IDE Netbeans 6.9.1

• Creamos un nuevo directorio o carpeta, que podremos llamar Formularios.

• Creamos un JFrame, que llamaremos CapturaHuella

En este punto no es necesario, dar ningún toque de apariencia a nuestro formulario, ya
que nos vamos a dedicar a desarrollar los métodos abstractos con las respectivas variables,
y además todo lo vamos a realizar en el espacio de Fuente del formulario, sin usar ninguna
clase, aunque para muchos no sea uno forma modulada de programar, pero con el fin de
explicar es mas q suficiente, y pues de ahí cada quien adapta su aplicación a como lo
requieran.

1. Verficamos que los .jar, que copiamos a los jre de java están correctamente instalados
y aceptados por el IDE de Netbeans para luego programarl IDE de Digital Persona.
Realizamos un pequeño import para darnos cuenta ha sido aceptado el IDE de
DigitalPersona.

Al aparecernos import com.digitalpersona…. quiere decir que está bien y podremos

continuar…

2. En el constructor del JFrame, antes de initComponents(); insertamos el siguiente

código con el fin de cambiarle el estilo visual a la aplicación.
try {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
} catch (Exception e) {
JOptionPane.showMessageDialog(null, "Imposible modificar el tema visual",
"Lookandfeel inválido.",
 JOptionPane.ERROR_MESSAGE);
}
En este momentos nos sales una cantidad de errors y es porque no se han hecho los
imports correspondientes, asi que simplemente hacemos clic sobre el icono que denota el
error y se agregan los imports necesarios.

3. Ahora declaramos 5 variables principales para la captura, verificación, inserción y

template de la huella digital que se pretende capturar y también importamos los imports
que necesiten esas variables.
private DPFPCapture Lector = DPFPGlobal.getCaptureFactory().createCapture();
private DPFPEnrollment Reclutador =
DPFPGlobal.getEnrollmentFactory().createEnrollment();
private DPFPVerification Verificador =
DPFPGlobal.getVerificationFactory().createVerification();
private DPFPTemplate template;
public static String TEMPLATE_PROPERTY = "template";

4. Creamos los métodos abstractos, para la variable Lector, creando un Nuevo método
que podemos llamar Iniciar, en el cual vamos a colocar los distintos métodos programable
del lector, bien sea cuando ocurre la captura de la huella, cuando el lector se conecta o
desconecta, cuando se coloca el dedo o se retira y cuando se presenta algún error, estos
suelen ser los más importantes pero puede existir uno o dos más que para este ejemplo no
los tocaremos.

protected void Iniciar(){

Lector.addDataListener(new DPFPDataAdapter() {
@Override public void dataAcquired(final DPFPDataEvent e) {
SwingUtilities.invokeLater(new Runnable() { public void run() {
EnviarTexto("La Huella Digital ha sido Capturada");
ProcesarCaptura(e.getSample());
}});}
});

Lector.addReaderStatusListener(new DPFPReaderStatusAdapter() {
@Override public void readerConnected(final DPFPReaderStatusEvent e) {
SwingUtilities.invokeLater(new Runnable() { public void run() {
EnviarTexto("El Sensor de Huella Digital esta Activado o Conectado");
}});}
@Override public void readerDisconnected(final DPFPReaderStatusEvent e) {
 SwingUtilities.invokeLater(new Runnable() { public void run() {
EnviarTexto("El Sensor de Huella Digital esta Desactivado o no Conecatado");
}});}
});

Lector.addSensorListener(new DPFPSensorAdapter() {
@Override public void fingerTouched(final DPFPSensorEvent e) {
SwingUtilities.invokeLater(new Runnable() { public void run() {
EnviarTexto("El dedo ha sido colocado sobre el Lector de Huella");
}});}
@Override public void fingerGone(final DPFPSensorEvent e) {
SwingUtilities.invokeLater(new Runnable() { public void run() {
EnviarTexto("El dedo ha sido quitado del Lector de Huella");
}});}
});

Lector.addErrorListener(new DPFPErrorAdapter(){
public void errorReader(final DPFPErrorEvent e){
SwingUtilities.invokeLater(new Runnable() { public void run() {
EnviarTexto("Error: "+e.getError());
}});}
});
}
Lector.addErrorListener(new DPFPErrorAdapter(){
public void errorReader(final DPFPErrorEvent e){
SwingUtilities.invokeLater(new Runnable() { public void run() {
enviarTexto("Error: "+e.getError());
}});}
});
}
Para este punto existen dos métodos que aun no hemos creado y aun después de
importar todos los imports necesarios que son:
import com.digitalpersona.onetouch.DPFPGlobal;
import com.digitalpersona.onetouch.DPFPTemplate;
import com.digitalpersona.onetouch.capture.DPFPCapture;
import com.digitalpersona.onetouch.capture.event.DPFPDataAdapter;
import com.digitalpersona.onetouch.capture.event.DPFPDataEvent;
import com.digitalpersona.onetouch.capture.event.DPFPErrorAdapter;
import com.digitalpersona.onetouch.capture.event.DPFPErrorEvent;
import com.digitalpersona.onetouch.capture.event.DPFPReaderStatusAdapter;
import com.digitalpersona.onetouch.capture.event.DPFPSensorAdapter;
import com.digitalpersona.onetouch.processing.DPFPEnrollment;
import com.digitalpersona.onetouch.verification.DPFPVerification;

Marcara errores en los metodos:

EnviarTexto();
ProcesarCaptura();
No importa porque ahora desarrollaremos estos métodos.
5. Antes de comenzar a crear el método EnviarTexto(), declararemos dos variable que
son las mas importante en el proyecto, y sirven para procesar las características de la
huella capturada, bien sea para verificarla o para crear una nueva e importamos los
imports necesarios para estas variables.

public DPFPFeatureSet featuresinscripcion;

public DPFPFeatureSet featuresverificacion;

6. Creamos el metodo ProcesarCaptura(); y para cada item donde presente error no se

les olvide importar los imports correspondientes.
Pero antes declararemos una serie de métodos que son llamados dentro de este método de
ProcesarCaptura.
public DPFPFeatureSet extraerCaracteristicas(DPFPSample sample, DPFPDataPurpose
purpose){
DPFPFeatureExtraction extractor =
DPFPGlobal.getFeatureExtractionFactory().createFeatureExtraction();
try {
return extractor.createFeatureSet(sample, purpose);
} catch (DPFPImageQualityException e) {
return null;
}
}

public Image CrearImagenHuella(DPFPSample sample) {

return DPFPGlobal.getSampleConversionFactory().createImage(sample);
}
public void DibujarHuella(Image image) {
 lblImagenHuella.setIcon(new ImageIcon(
image.getScaledInstance(lblImagenHuella.getWidth(),
lblImagenHuella.getHeight(), Image.SCALE_DEFAULT)));
repaint();
}

Aquí, nos daremos cuenta que marcara error y es por aun no hemos agregado un objeto a
JFrame creado, después nos encargaremos de esto.
public void EstadoHuellas(){
EnviarTexto("Muestra de Huellas Necesarias para Guardar Template "+
Reclutador.getFeaturesNeeded());
}

Aquí tambien nos aparece un error porque no hemos creado el método EnviarTexto();
Ahora lo creamos:

public void EnviarTexto(String string) {

txtArea.append(string + "\n");
}

También nos aparece un error y es porque no hemos añadido el objeto TextArea al

JFrame.
Pero todos esos errores de objetos, los resolveremos cuando dediquemos el tiempo de
organizar el espacio de captura de huella en el JFrame.
Continuamos declarando los métodos y en este caso continuamos con los métodos que
nos permiten que el lector de huella dactilar inicie para las capturas y/o para que pare.
public void start(){
Lector.startCapture();
EnviarTexto("Utilizando el Lector de Huella Dactilar ");
}

public void stop(){

Lector.stopCapture();
EnviarTexto("No se está usando el Lector de Huella Dactilar ");
}

Por ultimo creamos los insertamos los códigos de getter() y setter() de la variable que
declaramos al inicio; private DPFPTemplate template;
Prescionamos Clic derecho sobre una area de en blanco de espacio de Fuente del JFrame
asi;

Lo cual nos creara los siguiente métodos:

public DPFPTemplate getTemplate() {
return template;
}

public void setTemplate(DPFPTemplate template) {

this.template = template;
}

Pero este ultimo lo modificamos, quedando asi:

public void setTemplate(DPFPTemplate template) {

DPFPTemplate old = this.template;
this.template = template;
firePropertyChange(TEMPLATE_PROPERTY, old, template);
}
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------
Finalmente hemos terminado la creación del código de los métodos abstractos que vamos
a usar en esta segunda fase del artículos, pues ahora nos concentraremos en desarrollar la
interfaz del JFrame:
Volvemos a la vista de Diseño del JFrame, y desarrollaremos una interfaz similar a esta:
Agregamos Dos JPanel, uno panHuellas con dirección Norte, y otro panBtns con
dirección Sur.
 Al panel de Huella Digital Capturada, le activamos el gestor de distribución
BorderLayout y agregamos otro JPanel, no interesa el nombre y también activamos un
gestor de distribución BordeLayout con una caracterictica de hundido y añadimos un
JLabel que llamaremos lblImagenHuella la cual se ajustara automáticamente al
contendor del panel, y le borramos el nombre:

Hasta este punto si volvemos a la vista de fuente nos daremos cuenta que ya se han
corregido los errores del método DibujarHuella();.

Para el panel de Acciones también activamos el gestor BorderLayout y agregaremos dos

paneles mas, aquí no interesan como se llamen.

En el primero añadiremos cuatros botones que se llamaran; btnSalir, btnGuardar,

btnIdentificicar, btnVerificar, esto tres últimos no serán usados en esta fase pero se
necestitan para que no se presente error en el fuente:
 En el segundo JPanel, que agreguemos activamos también el gestor BorderLayout y
agregamos un JScrollPane que llamaremos txtArea.

Por ultimo podemos darnos cuenta que en la vista de fuente, ya se han corregido todos
los errores presentados, ahora solo nos queda programar simplemente en botón de Salir,
System.exit(0);

Ahora simplemente nos toca llamar a los métodos correspondientes en los eventos en
los que se abra o se cierre el JFrame:
Y tambien en el constructor del JFrame agregar después de initComponents();,
txtArea.setEditable(false);

NOTA: Recuerden que los otros botones por lo pronto no serán usados, mas sin embargo
se comportaran como si tuvieran alguna acción.

Eso es todo, espero le sirva y no olviden en comentar, nos vemos después con la parte de
Gurdar, Verificar e Identificar desde una BD.., SALUDOS JARC..!

Tambien les dejos un documento pdf con el desarrollo de esta segunda parte del Tutorial.
Aqui

Y lo que todos esperan, el codigo fuente, pues aqui se los dejo y espero por lo menos
comenten si de algo le ha servido. Aqui

DEDICADO A TODOS AQUELLOS QUE CON PACIENCIA ESPERARON AL

DESARROLLO DE ESTA SEGUNDA PARTE, ESPERO PODER TENER LA
ULTIMA PARTE LO ANTES POSIBLE, SALUDOS...
 !EL CONOCIMIENTO AUMENTA CUANDO SE COMPARTE¡
PROGRAMACION DE 4500 FINGERPRINT READER DIGITAL PERSONA EN
JAVA CON WINDOWS 7-PARTE3
FINAL

Para todos aquellos que con tanta paciencia estuvieron pendientes del blog y de esta
entrada, espero culminar el año entregándoles la parte final de la programación del lector
digital persona 4500, es por ello que en esta ultima parte, centraremos la atención de
programar las huellas capturada desde el lector hacia o dirigida a una base de datos; como
base proyecto que en los que necesitemos estos métodos de guardar, verificar y verificar.
Por otra parte recordamos que en la parte 2, habíamos quedado hasta como mostrar en el
en el panel de JFrame la huella dactilar capturada por el lector, como además una área
de texto que nos permitía visualizar los distintos eventos que habíamos declarado para
el lector, y también la cantidad de huellas dactilares necesarias para construir un
template de una huella con el fin de que en esta parte, podamos guardarla, verificarla e
identificarla.

Continuando con esta última parte lo que realizaremos será;

1. Crearemos un nuevo paquete, que llamaremos BD, y dentro de este creamos una clase
llamada ConexionBD.
2. Luego en la clase creada declararemos lo siguiente:
• Los imports necesarios para establecer la conexión respectiva con la BD, que hemos
creado en MySQL, en la primera parte de este tutorial.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import javax.swing.JOptionPane;

No importa que marque que los import aun no esten usados, ya que esto lógico porque
aun no hemos declarado ninguna sentecia o varible que use estos imports.
• Declaremos estas variables después de la clase principal, que nos permitaran contener
los valores de la conexión de la BD, el servidor, user, password, etc.
Hay que recordar que los valores de estas variables pueden cambiar según la lógica de
programación de cada uno, y además de cómo tengan configurado Mysql en su equipo.
Por defecto estos son los valores con lo que la mayoría intalan mysql como además el
nombre de la BD que habíamos creado en la primera parte.

public String puerto="3306";

public String nomservidor="localhost";
public String db="huellas";
public String user="root";
public String pass="root";
Connection conn=null;

• Crearemos una función o método llamado conectar y otro desconectar, el cual contendrá
los parámetros de conexión y desconexión con la BD, como además un try catch que
permitirá capturar las excepciones que puedan presentar a la hora de intentar conectar con
la BD.

public Connection conectar(){

try{
String ruta="jdbc:mysql://";
 String servidor=nomservidor+":"+puerto+"/";
Class.forName("com.mysql.jdbc.Driver");
conn = DriverManager.getConnection(ruta+servidor+db,user,pass);

if (conn!=null){
System.out.println("Conección a base de datos listo...");
}
else if (conn==null)
{
throw new SQLException();
}
}catch(SQLException e){
JOptionPane.showMessageDialog(null, e.getMessage());
} catch (ClassNotFoundException e) {
JOptionPane.showMessageDialog(null, "Se produjo el siguiente error:
"+e.getMessage());
}catch (NullPointerException e){
JOptionPane.showMessageDialog(null, "Se produjo el siguiente error:
"+e.getMessage());
}finally{
return conn;
}
}

public void desconectar(){

conn = null;
System.out.println("Desconexion a base de datos listo...");
}

3. Luego de haber creado la clase de ConexionBD, volvemos a la vista fuente del jframe
principal, e importamos el import que me permitara ver los procedimientos de la clase
conexionBD.
 También declaramos un constructor que me permitirá llamar una nueva intancia de la
clase ConexionBD.

4. Ahora nos centraremos en crear cada método, para guardar, verificar e identificar la
huella dactilar capturada.
• Así que empezamos creando el método de guardarHuella.

/*
* 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
ByteArrayInputStream datosHuella = new
ByteArrayInputStream(template.serialize());
Integer tamañoHuella=template.serialize().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
Connection c=con.conectar();
PreparedStatement guardarStmt = c.prepareStatement("INSERT INTO
somhue(huenombre, huehuella) values(?,?)");
guardarStmt.setString(1,nombre);
guardarStmt.setBinaryStream(2, datosHuella,tamañoHuella);
//Ejecuta la sentencia
guardarStmt.execute();
guardarStmt.close();
JOptionPane.showMessageDialog(null,"Huella Guardada Correctamente");
con.desconectar();
btnGuardar.setEnabled(false);
btnVerificar.grabFocus();
} catch (SQLException ex) {
//Si ocurre un error lo indica en la consola
System.err.println("Error al guardar los datos de la huella.");
 }finally{
con.desconectar();
}
}
Luego de haber declarado este método se marcaran 4 errores sobre algunas líneas de
código, y esto es porque no se han importado los imports necesarios para cada línea así
que lo que haremos es con la ayuda de Netbeans, posicionamos el cursor sobre cada
símbolo que marca error, y presionamos clic izquierdo, y le daremos añadir import… así;

• Seguimos creando el método de verificarHuella.

Luego declararemos el método de verificarHuella, la cual funciona con la ayuda del
usuario, es decir este método se basa en que el usuario le pasa un parámetro especifico al
sistema de la BD, para que este filtre según este parámetro, que para este caso sería el
nombre con que se guardo la huella dactilar, pero cabe resaltar que puede ser usado con
cualquier otro tipo de parámetro con que se halla guardado la huella, puede ser con el ID,
si sabe y si también hay un campo en la tabla de CC o ID de usuario, en fin, la lógica con
que se use es variada.

/**
* Verifica la huella digital actual contra otra en la base de datos
*/
public void verificarHuella(String nom) {
try {
//Establece los valores para la sentencia SQL
Connection c=con.conectar();
//Obtiene la plantilla correspondiente a la persona indicada
PreparedStatement verificarStmt = c.prepareStatement("SELECT huehuella FROM
somhue WHERE huenombre=?");
verificarStmt.setString(1,nom);
ResultSet rs = verificarStmt.executeQuery();

//Si se encuentra el nombre en la basede datos

if (rs.next()){
//Lee la plantilla de la base de datos
byte templateBuffer[] = rs.getBytes("huehuella");
//Crea una nueva plantilla a partir de la guardada en la base de datos
DPFPTemplate referenceTemplate =
DPFPGlobal.getTemplateFactory().createTemplate(templateBuffer);
//Envia la plantilla creada al objeto contendor de Template del componente de huella
digital
setTemplate(referenceTemplate);
 // Compara las caracteriticas de la huella recientemente capturda con la
// plantilla guardada al usuario especifico en la base de datos
DPFPVerificationResult result = Verificador.verify(featuresverificacion,
getTemplate());

//compara las plantilas (actual vs bd)

if (result.isVerified())
JOptionPane.showMessageDialog(null, "Las huella capturada coinciden con la de
"+nom,"Verificacion de Huella", JOptionPane.INFORMATION_MESSAGE);
else
JOptionPane.showMessageDialog(null, "No corresponde la huella con "+nom,
"Verificacion de Huella", JOptionPane.ERROR_MESSAGE);

//Si no encuentra alguna huella correspondiente al nombre lo indica con un mensaje

} else {
JOptionPane.showMessageDialog(null, "No existe un registro de huella para "+nom,
"Verificacion de Huella", JOptionPane.ERROR_MESSAGE);
}
} catch (SQLException e) {
//Si ocurre un error lo indica en la consola
System.err.println("Error al verificar los datos de la huella.");
}finally{
con.desconectar();
}
}

Cuando se crea este método también veremos algunos errores, por lo que al igual que en
el método anterior, importaremos los imports necesarios para corregir estos errores.

• Finalmente creamos el método de identificarHuella.

Por ultimo declararemos el método de identificarHuella, el cual se basa en que al capturar
la huella dactilar, prescionando el botón de identificar, este se encarga de comparar cada
huella dactilar guardada en la BD con la capturada y decir a quien pertenece esta huella.

/**
* Identifica a una persona registrada por medio de su huella digital
 */
public void identificarHuella() throws IOException{
try {
//Establece los valores para la sentencia SQL
Connection c=con.conectar();

//Obtiene todas las huellas de la bd

PreparedStatement identificarStmt = c.prepareStatement("SELECT
huenombre,huehuella FROM somhue");
ResultSet rs = identificarStmt.executeQuery();

//Si se encuentra el nombre en la base de datos

while(rs.next()){
//Lee la plantilla de la base de datos
byte templateBuffer[] = rs.getBytes("huehuella");
String nombre=rs.getString("huenombre");
//Crea una nueva plantilla a partir de la guardada en la base de datos
DPFPTemplate referenceTemplate =
DPFPGlobal.getTemplateFactory().createTemplate(templateBuffer);
//Envia la plantilla creada al objeto contendor de Template del componente de huella
digital
setTemplate(referenceTemplate);

// Compara las caracteriticas de la huella recientemente capturda con la

// alguna plantilla guardada en la base de datos que coincide con ese tipo
DPFPVerificationResult result = Verificador.verify(featuresverificacion,
getTemplate());

//compara las plantilas (actual vs bd)

//Si encuentra correspondencia dibuja el mapa
//e indica el nombre de la persona que coincidió.
if (result.isVerified()){
//crea la imagen de los datos guardado de las huellas guardadas en la base de datos
JOptionPane.showMessageDialog(null, "Las huella capturada es de
"+nombre,"Verificacion de Huella", JOptionPane.INFORMATION_MESSAGE);
return;
}
}
//Si no encuentra alguna huella correspondiente al nombre lo indica con un mensaje
JOptionPane.showMessageDialog(null, "No existe ningún registro que coincida con
la huella", "Verificacion de Huella", JOptionPane.ERROR_MESSAGE);
setTemplate(null);
} catch (SQLException e) {
//Si ocurre un error lo indica en la consola
System.err.println("Error al identificar huella dactilar."+e.getMessage());
}finally{
con.desconectar();
}
}
Cuando se crea este método también veremos algunos errores, por lo que al igual que en
los método anteriores, importaremos los imports necesarios para corregir estos errores.

5. Finalmente, después de haber creado todo esto métodos, solo resta llamar los
respectivos métodos en los eventos cuando se presionen cada botón.
• Empezamos con el botón de Guardar.
guardarHuella();
Reclutador.clear();
lblImagenHuella.setIcon(null);
start();

• Seguimos con el botón de Verificar.

String nombre = JOptionPane.showInputDialog("Nombre a verificar:");
verificarHuella(nombre);
Reclutador.clear();

• Por último el botón Identificar.

try {
identificarHuella();
Reclutador.clear();
} catch (IOException ex) {
Logger.getLogger(CapturaHuella.class.getName()).log(Level.SEVERE, null, ex);
}
En este punto también, importaremos los import necesario que permitan corregir los
errores presentado.

----------------------------------------------------------------------------------------------------------
---
Eso es todo, espero le sirva y no olviden en comentar, nos vemos después cuando surja
una inquietud y podamos resolverla… SALUDOS JARC..!

QUE DIOS BENDIGA A TODOS LOS QUE ESTUVIERON PENDIENTES DE

ESTA ENTRADA Y LE HALLA SERVIDO DE ALGO, QUE PASEN UNA FELIZ
NAVIDAD Y UN PROSPERO AÑO NUEVO.

Tambien les dejos un documento pdf con el desarrollo de esta ultima parte del Tutorial.
Aqui

Y lo que todos esperan, el codigo fuente, pues aqui se los dejo y espero por lo menos
comenten si de algo le ha servido. Aqui

DEDICADO A TODOS AQUELLOS QUE CON PACIENCIA ESPERARON AL

DESARROLLO DE ESTE TUTORIAL Y OJALA HALLAMOS ENTENDIDO EL
TEMA, ESPERO ESTA ULTIMA PARTE SEA EL REGALO QUE MUCHOS
NECESISTABAN, SALUDOS...

!EL CONOCIMIENTO AUMENTA CUANDO SE COMPARTE¡

¡feliz navidad a todas las familias de colombia y en especial aquellas que han sido
asotadas por estos desastres naturales, que recuerden que Dios nunca nos olvida.!