Si no carga la presentación, aqui esta el link directo --> Presentación
Código:
Las funciones más importantes son donde se ejecuta la detección facial y el recononcimiento, todo lo incluido en estas funciones se complementa con otras creadas para la manipulación de los botones y la búsqueda en la base de datos.
Ejecutando solamente el código en la primera imágen, el programa corre hasta la versión mostrada en clase.
Si ejecuta el código de la segunda imágen además del código de la primera imágen, debería de ejecutar la versión completa del programa donde se reconoce a las personas, pero esta es la parte que nos dio problemas y no pudimos completar.
Algunas caps de la version final:
Mejoras futuras:
Después de terminar y que realice todas las funciones deseadas (detección y reconocimiento) una idea muy tentadora sería la de programar una función que realice el entrenamiento en tiempo real desde la webcam para que el anexo de usuarios posteriores resulte mucho más facil y se necesite menos tiempo.
JADE (Java Agent Development Framework) es un software totalmente implementado en lenguaje Java. Se simplifica la implementación de sistemas multi-agente a través de un middleware que cumple con las especificaciones FIPA ya través de un conjunto de herramientas gráficas que soporta la depuración y las fases de implementación. La plataforma de agentes puede ser distribuido entre todas las máquinas (que ni siquiera necesidad de compartir el mismo sistema operativo) y la configuración pueden ser controlados a través de una interfaz gráfica de usuario remota . La configuración se puede cambiar, incluso en tiempo de ejecución moviendo agentes de una máquina a otra, cuando sea necesario. JADE es completamente implementado en el lenguaje Java y la exigencia mínima del sistema es la versión 1.4 de Java (el entorno de tiempo de ejecución o JDK).
Ejecución de agentes completamente asíncrona
Comunicación entre agentes en la misma o diferentes plataforma/s JADE/LEAP/JADEX
Programación de agentes mediante un conjunto de paquetes Java (JDK 1.4 o superior).
Validación de la ejecución mediante seguimiento mensajes y estado interno del agente.
JADE esta compuesta de:
Una plataforma FIPA para la ejecucion de agentes
Un conjunto de paquetes para la programación de agentes FIPA
SPADE
Del inglés "Smart Python multi-Agent Development Environment", SPADE es una plataforma de sistemas multi-agente desarrollada en 2005 en la Universidad Politécnica de Valencia. La plataforma nació como una prueba de concepto para probar la tecnología de la mensajería instantánea como protocolo de transporte para los agentes inteligentes. Desde ese momento el proyecto ha seguido creciendo y añadiendo nuevas características aprovechando la flexibilidad del protocolo de mensajería instantánea basado en XML y la cantidad de extensiones desarrolladas para el mismo que son aprovechables dentro del marco de los sistemas multi-agente. La plataforma SPADE está basada en un conjunto de estándares, siendo los más destacables FIPA y XMPP/Jabber.
Las principales características de la plataforma SPADE son:
Soporte del estándar FIPA mediante el protocolo de mensajería instantánea XMPP (Agentes AMS y DF incluídos)
Notificación de presencia entre agentes.
Organizaciones Virtuales basadas en el protocolo de multi-conferencia MUC.
Comunicación P2P entre agentes.
Invocación remota de servicios entre agentes usando el estándar XML-RPC.
Procesadores de lenguajes de contenido en SL0 y RDF.
Modelo de agente BDI basado en Conocimiento, Deseos e Intenciones.
Modelo de comportamientos: Cíclicos, Periódicos, Timeout, una ejecución, máquina de estados finita y basado en eventos.
Soporte de comunicación con otras plataformas mediante diversos protocolos de transporte: JADE (via HTTP o XMPP) y SIMBA.
Publicación y subscripción de eventos mediante el estándar PubSub.
Interfaz gráfica basada en web.
MadKit
MadKit es una plataforma para la implementación de Sistemas
Multi-Agentes. Esta basada sobre el modelo AGR de Ferber y Gutknecht.
AGR en un modelo organizacional basado sobre los principios de Agente,
Grupo y Rol. Esta escrita puramente en JAVA.
Este documento no intenta ser una introducción a AGR, ni a los
modelos organizacionales para los SMA. Pero vamos a describir solamente
las bases para poder comprender el funcionamiento del SMA que vamos a
desarrollar y el porque de ciertas elecciones.
El modelo AGR
El modelo AGR esta basado en las nociones de Agente, Grupo y Rol.
Estructura general de la Plataforma
La arquitectura general de la plataforma puede ser representada de la forma siguiente (imagen del MadKit Development Guide)
El componente principal es el Kernel (o micro-kernel). El kernel provee soporte para:
Control de grupos y roles locales
Manejo del ciclo de vida de los Agentes
Despacho de Mensajes locales
Ciclo de vida de un agente
El ciclo de vida de un agente (usando
la clase ), requiere la implementación de tres metodos. El primero es
el método activate() que es llamado en el momento de la inicialización
del agente. El segundo es live() donde se define el comportamiento del
agente. El tercero es end() llamado a la finalización del agente.
De estos tres metodos, solo live() es obligatorio (si queremos que
nuestro agente haga algo). Los otros dos (activate y end) tienen una
implementación (vacía) por “default” en AbstractAgent.
RoboCup es un proyecto internacional fundado en 1997 para promover, a través de competencias integradas por robots autónomos, la investigación y educación sobre inteligencia artificial.
Las 3 variantes para participar en este tipo de torneo:
Simulación 2D: Basado en la creación de sistemas multi-agentes, en el que todos cooperan para ganar un partido de soccer entre dos equipo, obviamente la simulación y la programación del sistema debe de ser en 2 dimensiones.
Simulación 3D:: Basicamente es lo mismo que el anterior, con la única diferencia que este tipo de competencias se realizan en entornos 3D.
Otra muy interesante es la de la competencia en un juego de soccer entre dos equipos pero con la misión de dejar de lado las simulaciones, es decir, ahora los partidos los juegan robots reales (tangibles), previamente entrenados (programados como sistemas multi-agentes para cooperar entre todos y ganar) para la ocasión.
La iniciativa está dividida en cuatro grandes competencias:
RoboCupSoccer: RoboCupSoccer es una competencia de fútbol con robots autónomos.
El objetivo oficial del proyecto es conseguir para mediados del siglo XXI un equipo capaz de vencer al ganador de la Copa Mundial de la FIFA siguiendo sus propias reglas.
RoboCupRescue: Se trata de poner a prueba a los robots para tareas de búsqueda y
salvamento de víctimas en terreno desfavorable. Los robots pueden ser
tanto autónomos como guíados por control remoto.
En cada prueba, un equipo de robots debe ser capaz de encontrar el
camino adecuado en la zona designada y hacer un mapa con la posición de
los diferentes obstáculos del térreno y de las víctimas.
RoboCupJunior: Intenta acercar las metas y objetivos de Robocup a estudiantes de educación primaria y secundaria.
Hay diferentes formatos:
Fútbol, en equipos de 2 contra 2.
Rescate, las reglas son similares al concurso global,4 pero el escenario es más básico y sencillo.
Baile, en el que los participantes deben escoger una canción y robots autónomo que bailen a su son.
RoboCup@Home: Competencia añadida en la edición del 2006 celebrada en Bremen (Alemania) que se centra en la aplicación de robots autónomos en la vida diaria y en las relaciones hombre-robot derivadas.7
El escenario suele ser de la vida real y es ahí donde hay que demostrar las capacidades del robot.
Cada una de ellas tiene varias ligas internas dependiendo de la modalidad.
En México se celebrará en los diás 18-24 de Junio un torneo de RoboCup pueden checar bases y todo lo que se le ocurra (con respecto al torneo) en la pagina RoboCup México 2012.
Reconocimiento de imágenes: Al
momento de que el sistema realice el reconocimiento facial, verifica si hay
coincidencias con los datos en la base y muestra información.
Búsqueda del usuario en la base de
datos.
Deja acceder al usuario al dominio
seleccionado y muestra el rango que tiene dicho usuario, para así saber a que áreas
tiene permitido entrar.
Reconocimiento
de patrones
El sistema reconocerá
patrones faciales de los diferentes usuarios identificando si son parte de la
base de datos o no.
Herramientas
Librería de
reconocimiento de patrones OpenCV (2.1.0) para Phyton(2.6.6)
Imagen binarizada
Se reconocen los objetos de
interés de las imágenes que se capturan.
Con una imagen binarizada
obtenemos las características relevantes de la misma.
Una ves binarizada, se agrupan
los puntos de interés formando blobs.
Con los blobs podemos
seleccionar los objetos que se encuentran en la imagen binarizada. Tiene
funciones para filtrar, obtener el número de blobs, y encerrar los blobs en
cuadriláteros con las medidas definidas.
Conforme a las actividades
que teníamos pensadas (ya que no contábamos
con un calendario riguroso) para ir avanzando en el proyecto todas se han ido
cumpliendo, por lo que se puede decir que no tenemos contratiempos, todo marcha
como lo teníamos pensado y contamos con el suficiente tiempo para terminar
nuestro proyecto.
Ya que las últimas
actividades necesarias para concluir nuestro proyecto son las más importantes,
propusimos un pequeño calendario de actividades para así tratar de evitar
contratiempos y/o retrasos.
Algunos
problemas con los que
hemos tenido que lidiar son más que nada en la obtención e instalación de los
paquetes necesarios para nuestro proyecto; actualmente estamos trabajando bajo
Windows, el primer obstáculo que tuvimos fue la ejecución de los fragmentos de
código para realizar pruebas que lo solucionamos editando las variables de
entorno de Windows (PATH) para poder así poder ejecutar código python desde la
terminal.
Posteriormente cuando
comenzamos a trabajar con la librería de OpenCV, continuaron las
complicaciones, ya que no todas las versiones de OpenCV son compatibles con
todas las versiones de Python, por lo que nos dimos a la tarea de buscar que
versiones trabajaban con cuales de cada paquete; llegamos hasta la instalación
de Python 2.7 y OpenCV 2.2 ya que aparentemente eran compatibles, después de
las instalaciones procedimos a linkear
la librería a python para poder trabajar (ya que esto no se realizaba por
default) editando nuevamente las variables de entorno de Windows.
Después de esto nos
dimos a la tarea de realizar una pequeña prueba para validar si se encontraban
asociadas o no, superando la prueba, pero posteriormente al tratar de cargar
imágenes o lanzar la cámara, no lo realizaba correctamente o simplemente no lo
realizaba. Buscando, encontramos que esas versiones, al menos en Windows, no
funcionan del todo bien, por lo que tuvimos que volver a buscar hasta encontrar
las últimas versiones estables de los dos paquetes a utilizar; llegando hasta
la conclusión de debíamos usar la versión 2.6.6 de Python y la versión 2.1.0 de
OpenCV.
Realizamos todas las
pruebas necesarias para validar su funcionalidad y hasta el momento, no hemos
tenido errores y esperemos que en un futuro no surjan.
Actividades
pendientes:
Son básicamente todas
las listadas en el calendario anterior, pero la de mayor importancia es la de entrenamiento de nuestro programa para
que sea capaz de reconocer rostro, ya que involucra mucho esfuerzo en cuanto a la
recolección de contenido (imágenes) y también una buena cantidad de tiempo para
finalizar el entrenamiento.
En el proceso de
búsqueda, salió a relucir que para realizar un buen entrenamiento y que nuestro
programa sea de buen nivel, tendremos que darle aproximadamente 5000 imágenes
negativas y 1500 positivas (con sus respectivos datos) por lo que consideramos
que es la parte más importante de nuestro proyecto.
También encontramos que
para realizar pruebas, con alrededor de 1000 imágenes negativas y 200 positivas,
sería más que suficiente.
Código
realizado hasta el momento
-Compilación, prueba de
errores y funcionalidad y base de datos.
En
cuanto al código, hasta
el momento no tenemos código muy espectacular o tan funcional(versión final),
solo pruebas, ya que seguimos aprendiendo Python, pero contamos con algunas
fracciones (pruebas) de código importantes, como el lanzamiento del visor de la
cámara por medio de la implementación de la librería de OpenCV y las pruebas
para el uso de la base de datos.
Básicamente esta fracción
de código sería la que nos permitirá establecer una conexión con la base de
datos para poder mostrar información acerca del usuario que está intentando
entrar al complejo.
Solo faltaría crear
unas cuantas líneas más de código para poder ir tomando lo valores requeridos
de la base de datos, almacenarlos temporalmente y procesarlos, para
posteriormente mostrar con mensajes en pantalla.
El siguiente fragmento
de código realiza la función de cargar el croquis y ubicar en una puerta el botón
que lanzara el visor de la cámara para le ejecución del reconocimiento fácil y
así permitir o no, la entrada (para simular la entrada se lanzara un mensaje
para avisar si se abrió o no la puerta y además los botones siguientes se
activaran o desactivaran según sea el caso).
El código es muy
simple, en la primera parte tenemos una función que es la que se encarga de
lanzar el visor de la cámara (que después se usara para el reconocimiento facial)
haciendo uso de algunas opciones de la librería de OpenCV:
cv.NamedWindow('visor')
-> Se usa para crear una venta con el título visor
cv.CaptureFromCAM(1)
-> Usado para activar la cámara y poder usarla
cv.QueryFrame(capture)->Se
usa para tomar las fotografías usando la cámara ya activada anteriormente
cv.ShowImage('visor',
img) -> Usado para mostrar las imágenes tomadas anteriormente y las muestra
en la ventana ‘visor’
if cv.WaitKey(30) ==
27: Esta opción se utiliza para esperar a que se presione la tecla ESC y así
poder salir de la aplicación.
Las siguientes líneas de
código son aún más sencillas, pues solo son una ventana que contiene 2 frames
para poder ubicar mejor las cosas dentro de ellos utilizando el método grid()
en vez de pack() para organizar y facilitar más la ubicación de los widgets(botones,
label, frames, etc.), se utiliza un label para cargar la imagen del croquis y
un botón que es el encargado del lanzar el visor de la cámara por medio de la
opción ‘command’, al final solo se agrupan todos los widgets contenidos en
ventana mediante el método ‘mainlopp()’ para poder asi mostrar la ventana al
ejecutar el programa.
Pra finalizar la entrada, dejamos un video, del codigo anterior (demo.py) ejecutandose:
