Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Nota: Cabe resaltar que algunos términos de esta explicación fueron sacados del blog de monillo que me sirvió de inquietud para el
desarrollo de este programa en vista de los problemas que presentaban muchos de sus seguidores.
Se ejecuta el setup.exe
Por ultimo presionamos instalar y esperamos que a que se instale el sdk respectivo en
nuestro SO, y configure automaticamente los drivers para lector de huella compatible
con este sdk…
• DigitalPersona U.are.U 4000B/4500 or later fingerprint readers and modules
• DigitalPersona U.are.U Fingerprint Keyboard
Le damos finalizar… y nos aparecera la opcion de reiniciar el pc o no, es prefereible
reiniciarlo para que el sistema tome los cambios…
----------------------------------------------------------------------------------------------------------
--
Preparación de las librerías : Una vez que se tiene todo lo anterior correctamente instalado
y configurado se deben de preparar las librerías colocándolos en los directorios que deben
de estar, para ello se realiza lo siguiente:
1. Luego que hallamos reiniciado la pc, el siguiente paso es ubicar el directorio en el cual
se intalo DigitalPersona, que para este caso seria: C:\Program Files\DigitalPersona
2. Y procederemos a ubicar dentro del directorio Bin la carpeta Java y copiar los 4
archivos .jar que se encuentra en ella hacia hacia las carpetas C:\Archivos de
programa\Java\ jdk*\jre\lib\ext (donde jdk* es la versión que tienes instalada, si tienes
varias se puede colocar en todas) y en la carpeta C:\Archivos de programa\Java\
jre*\lib\ext (donde jre* es la versión más reciente).
Preparación de la base de datos:: Ya realizados los pasos anteriores únicamente nos falta
crear una base de datos que almacene los registros de las huellas, en este caso
prepararemos dentro de dicha base una tabla sencilla que contenga únicamente 3 datos,
un ID, el nombre de la persona y la huella registrada. Para efectos de este ejemplo
usaremos una base de datos de nombre huellas y una tabla dentro de dicha base de nombre
somhue que contendrá los datos descritos a continuación:
1. Nombre de campo: ID , tipo: INT
2. Nombre de campo: huenombre , tipo: VARCHAR(100)
3. Nombre de campo: huehuella , tipo: BLOB
Ya tenemos todo para comenzar a programar nuestra aplicación de reconocimiento de
huella digital en nuestra proxima sesion.
Cualquiera duda espero la comenten
Tambien les dejos un documento pdf con el desarrollo de esta primera parte del Tutorial.
Aqui
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.
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.
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.
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;
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:
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 ");
}
Prescionamos Clic derecho sobre una area de en blanco de espacio de Fuente del JFrame asi;
return template;
this.template = template;
this.template = 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.
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
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.
• 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.
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;
}
}
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.
/*
* 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;
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í;
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();
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.
/**
* 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();
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.
-------------------------------------------------------------------------------------------------------------
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