Cómo desarrollé un sistema de reconocimiento facial para control de acceso utilizando Java, OpenCV e Inteligencia Artificial

Una experiencia construyendo una solución completa de visión por computador, desde la arquitectura del software hasta la implementación de reconocimiento facial en tiempo real.

Introducción

Hace algunos meses decidí embarcarme en un reto que combinara varias de las áreas que más disfruto del desarrollo de software: inteligencia artificial, visión por computador, arquitectura de aplicaciones y desarrollo en Java.

El objetivo era claro:

Desarrollar un sistema de control de acceso capaz de identificar automáticamente a los residentes de un conjunto residencial mediante reconocimiento facial en tiempo real.

Lo que comenzó como un ejercicio académico terminó convirtiéndose en una aplicación bastante completa, capaz de detectar múltiples personas simultáneamente, reconocerlas, autorizar o denegar el acceso y registrar cada evento de manera automática.

Durante este proyecto descubrí que el verdadero desafío no era entrenar un modelo de reconocimiento facial, sino integrar todos los componentes necesarios para construir un sistema estable, rápido y preparado para operar en un entorno real.

El problema que quería resolver

En muchos edificios y conjuntos residenciales, el proceso de ingreso continúa dependiendo de la memoria del portero.

Esto genera varios inconvenientes:

• demoras en el ingreso de residentes;
• posibilidad de errores humanos;
• dificultad para mantener un historial confiable de accesos;
• ausencia de evidencia visual de cada ingreso.

Pensé que la inteligencia artificial podía ayudar a automatizar buena parte de ese proceso.

Así nació Portería Facial.

Tecnologías utilizadas

El proyecto fue desarrollado completamente en Java.

Las principales tecnologías fueron:

• Java 17
• Java Swing
• JavaCV
• OpenCV
• SQLite
• Maven

Para el reconocimiento facial utilicé el algoritmo LBPH (Local Binary Patterns Histograms), ampliamente utilizado cuando se requiere un modelo ligero, rápido y que pueda ejecutarse sin necesidad de GPU.

Arquitectura del sistema

Desde el inicio quise evitar crear una aplicación monolítica.

Por ello dividí el sistema en varios módulos independientes.

La arquitectura quedó organizada en componentes como:

• Gestión de usuarios
• Gestión de residentes
• Captura de cámara
• Detección facial
• Seguimiento de personas
• Reconocimiento facial
• Control de acceso
• Registro histórico
• Administración de evidencias
• Base de datos SQLite

Esta separación facilitó mucho la evolución del proyecto.

Detección facial

El primer paso consiste en localizar los rostros presentes en la imagen capturada por la cámara.

Cada cuadro del video es analizado utilizando OpenCV para identificar todas las caras visibles.

Una vez detectadas, se dibuja un recuadro sobre cada rostro.

Hasta aquí parece sencillo.

Sin embargo, aparece el primer problema importante.

El problema del “parpadeo”

Cuando una persona permanece frente a la cámara, OpenCV detecta el rostro nuevamente en cada fotograma.

Eso significa que el sistema cree que cada detección corresponde a una persona distinta.

El resultado era algo como:

Persona 1

Persona 2

Persona 3

Persona 4

…aunque en realidad siempre era la misma persona.

La solución: seguimiento mediante CSRT

Para resolver este problema implementé un sistema de seguimiento utilizando CSRT Tracker.

En lugar de volver a detectar el rostro continuamente, el sistema mantiene un seguimiento del mismo objeto durante varios cuadros consecutivos.

Esto permitió asignar un identificador estable:

P1

P2

P3

aunque las personas estuvieran moviéndose.

El rendimiento mejoró considerablemente.

Reconocimiento facial

Con el rostro ya localizado, comienza el verdadero proceso de identificación.

Cada imagen pasa por varias etapas:

• conversión a escala de grises;
• normalización;
• redimensionamiento;
• extracción de características mediante LBPH;
• comparación contra la base de datos de residentes.

El algoritmo devuelve la persona más parecida junto con una medida de distancia.

Esa distancia determina la confianza del reconocimiento.

Evitando falsos positivos

Uno de los mayores retos fue evitar que el sistema cambiara constantemente de identidad cuando la confianza variaba ligeramente.

Para solucionarlo implementé un mecanismo de estabilización.

Antes de aceptar un reconocimiento, el sistema necesita obtener varias coincidencias consecutivas.

Solo entonces considera que la identidad es válida.

Con ello desaparecieron prácticamente todos los cambios erráticos de nombre.

Control inteligente de acceso

Una vez reconocida una persona, el sistema consulta automáticamente la base de datos.

Dependiendo de la información almacenada puede determinar si:

• el residente está autorizado;
• existe alguna restricción;
• se trata de una persona desconocida.

Posteriormente registra:

• fecha;
• hora;
• apartamento;
• fotografía;
• resultado del acceso.

Todo ocurre de manera automática.

Interfaz gráfica

Uno de los aspectos a los que dediqué más tiempo fue la experiencia del usuario.

Quería que el sistema pudiera ser utilizado fácilmente por un portero sin conocimientos técnicos.

La interfaz muestra:

• video en tiempo real;
• personas detectadas;
• fotografía congelada del reconocimiento;
• calidad de coincidencia;
• contador de personas;
• accesos permitidos;
• accesos denegados;
• personas desconocidas;
• estado del modelo;
• estado de la cámara;
• historial de accesos.

El objetivo era que toda la información importante estuviera visible en una sola pantalla.

Persistencia de información

Para evitar depender de un servidor instalé una base de datos SQLite.

Esto hace que el sistema sea completamente autónomo.

Cada instalación mantiene su propia información:

• residentes;
• usuarios;
• accesos;
• evidencias;
• configuraciones.

Esto facilita enormemente el despliegue.

El reto del despliegue

Una aplicación que funciona únicamente en el computador del desarrollador no está terminada.

Uno de los últimos desafíos consistió en convertir el proyecto en una aplicación instalable.

Para ello utilicé:

• Maven
• jpackage
• Runtime propio de Java

Con esto fue posible generar un ejecutable que incluye el entorno de ejecución necesario.

El usuario final no necesita instalar Java manualmente.

Lecciones aprendidas

Este proyecto me recordó algo muy importante.

La inteligencia artificial representa únicamente una pequeña parte del sistema.

Gran parte del esfuerzo estuvo en resolver problemas relacionados con:

• arquitectura;
• concurrencia;
• rendimiento;
• integración entre librerías;
• manejo de cámaras;
• persistencia;
• experiencia de usuario;
• distribución de la aplicación.

En un proyecto real, estos aspectos suelen consumir mucho más tiempo que el propio modelo de IA.

Lo que viene

Aunque el sistema ya funciona correctamente, todavía existen muchas posibilidades de evolución.

Entre ellas:

• reconocimiento con redes neuronales profundas;
• integración con torniquetes y puertas automáticas;
• notificaciones móviles;
• panel web para administración;
• acceso remoto;
• autenticación multifactor;
• analítica de accesos;
• reportes en tiempo real;
• integración con sistemas de videovigilancia.

Reflexión final

Desarrollar este sistema fue mucho más que implementar un algoritmo de reconocimiento facial.

Fue la oportunidad de construir una solución completa, donde convergen ingeniería de software, visión por computador, inteligencia artificial y diseño de sistemas para resolver un problema real.

Más allá del resultado técnico, este proyecto reafirmó una idea que considero fundamental: la tecnología alcanza su verdadero valor cuando se transforma en herramientas útiles para las personas.

Y esa es precisamente la dirección en la que quiero seguir desarrollando soluciones.

Si te interesa conversar sobre inteligencia artificial, visión por computador, desarrollo en Java o sistemas inteligentes aplicados a problemas del mundo real, estaré encantado de intercambiar ideas. La innovación nace cuando compartimos conocimiento y aprendemos de las experiencias de otros.