Porteuses du projet: Aïseta DEMBELE (contact : aiseta.dembele@live.fr)
Et Annie KASSONGO (contact : anniekassongo@hotmail.com),

• Date de début de projet: Janvier 2019

• But du projet: Créer un objet qui permet de percevoir autrui.

• Date de fin de projet estimé: Mai 2019

<fc #f4d03f>Cahier des charges fonctionnel</fc>

cahier des charges en pdf: cdcf_i.s.y.pdf

<fc #f4d03f>Descriptif du projet et questionnement</fc>

Le dispositif I See You I.S.Y est un dispositif de détection du regard, il va nous permettre de percevoir les gens et leurs montrer qu’on les perçoit. Le but est la perception d’autrui, voir qu’elles sont les réactions d’autrui une fois qu’ils se savent perçu. Pour cela nous avons décidé de créer un capteur de regard, qui nous permettrai de voir les réactions d’autrui une fois qu’ils se savent filmé et aussi compté le nombre de regard porté sur nous lorsque notre dispositif est visible. On ce demandait qu'elles sont les réactions d'autrui lorsqu'il ce sait perçu et est ce que nous sommes remarquables ? Les expériences que nous réaliseront avec le dispositif nous permettront de répondre à ces questionnement.

<fc #f4d03f>Objectif</fc>

<fc #f4d03f>Moyens</fc>

<fc #f4d03f>Veille de l'existant</fc>

voici le format pdf: veille_google.pdf

<fc #f4d03f>Avancement du projet</fc>

<fc #088A4B>10/04/2019</fc>

Nous sommes aller au FabLab afin de nous renseigner sur les matériaux que l'ont devrait utiliser pour notre dispositif ainsi que les logiciels de programmation que l'on aurait à utiliser. Du coup nous savons maintenant que nous devons utiliser une raspberry pi, la nôtre sera une raspberry pi 3 b+, nous devrons utiliser le langage python, nous programmons en software et sous Linux.

<fc #088A4B>12/04/2019</fc>

Nous avons tout d'abord installé la Raspberry pi, nous avons vu qu'il fallait installer un logiciel (Raspbian) qui sera notre système d'exploitation, pour cela nous devions télécharger NOOBS qui nous permettrait ensuite de télécharger Raspbian. Du coup nous avons formaté notre carte micro SD de 4Giga, et installer, télécharger NOOBS dessus via ce lien : https://www.raspberrypi.org/downloads/noobs/. Nous avions pris la version Lite, la version normal étant trop grosse pour notre carte mémoire du coup nous allons acheter une carte mémoire de 8 ou 16giga.

<fc #088A4B>12/04/2019</fc>

Nous avons cette fois installé NOOBS sur une carte mémoire de 16 giga. Nous voulions commencer à essayer de programmer notre programme de reconnaissance de regard mais, nous avons fait face à quelques problèmes, le réseau wi-fi ne fonctionnait pas bien, et impossible de changer le réseau. Nous voulions installer python mais nous sommes tombé sur des messages d'erreurs. Nous avons aussi fait un petit modèle du cartel du titre que nous voulions, une maquette si on peut dire. La Raspberry Pi est un vrai ordinateur avec, une interface, un bureau, internet. Nous devions juste lui “fournir” un système d'exploitation ainsi que certaines donnés.

<fc #088A4B>Quelques images</fc>

Voici la Raspberry Pi 3 B+ que nous utilisons

C'est l'interface que nous donne la Raspberry, une fois branchée et connecter par HDMI à un ecran.

<fc #088A4B>23/04/2019</fc>

Aujourd'hui,nous avons commencer à voir comment installer une bibliothèque OpenCv sur notre Raspberry, étant donné que nous n'avons aucune connaissance en code nous effectuons des recherches afin de voir à quoi ressemblerai un code sur python et voir les différents code de reconnaissance existant.

<fc #088A4B>30/04/2019</fc>

Nous avons essayé d'installer OpenCV sur notre raspberry, de plus nous avons installé une webcam et regarder sur notre raspberry si nous avions une application qui nous permettait d'avoir une image en temps réelle produite par la camera et qui nous confirme que notre raspberry reconnais la caméra et sais ce qu'est une caméra. Nous avons ensuite voulu testé un code de reconnaissance d'objet pris sur ce lien : https://www.framboise314.fr/i-a-realisez-un-systeme-de-reconnaissance-dobjets-avec-raspberry-pi/ mais sans succès.

<fc #088A4B>6/05/2019</fc>

Nous avons poussé les recherches sur l'installation d'OpenCV et Python sur raspberry,nous sommes tombé sur ce site: https://www.pyimagesearch.com/2017/09/04/raspbian-stretch-install-opencv-3-python-on-your-raspberry-pi/

du coup nous avons commencé l'installation de OpenCv et Python en suivant les étapes.

<fc #088A4B>7/05/2019</fc>

Nous avons essayé d'installer openCV mais sans succès, nous avons fait face à des bugs, des soucis de téléchargement, du coup il nous a fallu tout recommencer.

Nous avons aussi penser à l'aspect du dispositif, ou sera placé notre dispositif, de quel manière etc.

<fc #088A4B>8/05/2019</fc>

Aujourd'hui nous avons suivi un autre tutoriel d'installation de bibliothèque OpenCv et Python, mais toujours le même problème pas de moyen d'installer les bibliothèque.

<fc #088A4B>16/05/2019</fc>

Nous avons décidé de rebooté notre carte et réessayé d'installer les installations toujours le même soucis du coup nous avons tout supprimé de la carte mémoire, repartitionné la carte car une fois qu'elle est insérée dans la raspberry, elle ce partitionne. Du coup nous avons réinstallé Noobs sur la carte et réinstallé notre système d'exploitation Raspbian.

<fc #088A4B>17/05/2019</fc>

Nous avons commencé l'installation d'openCv 4 et de python 3 sur notre raspberry, ça à fonctionné avec succès,non sans quelques problème notamment la compilation d'OpenCV qui a durée 3h à peu près. Notre erreur à sûrement été d'avoir suivi 2 tutoriel différents pour leur installation, du coup nous avons suivi celle ci : https://www.pyimagesearch.com/2018/09/26/install-opencv-4-on-your-raspberry-pi/

voilà une image de la fin de compilation d'OpenCV

<fc #088A4B>20/05/2019</fc>

Nous nous sommes du coup cette fois ci attaqué à notre code de reconnaissance faciale, nous avons encore une fois rencontré des problèmes avec l'installation du package dlib, il n'as pas voulu s'installer du coup nous avons du essayé plusieurs méthodes, tapé l'erreur sur l'internet afin de trouver des solutions car taper “pip install dlib” sur notre environnement python ne nous permettais pas de l'installer, en cherchant nous avons découvert que dlib demandait beaucoup de place et construisait beaucoup d'extension C++ ce qui demande beaucoup de temps du coup pour palier au problème nous avons installer le module face_ recognition en tapant “pip install face_recognition –vv” Du coup nous avons réussi a installer tout nos modules après quelques heures sans oublier l'installation d'imutils. Nous avons commencer par enregistré 12 photos sur notre jeu de donnés d'images, les nôtres, du coup le programme a été capable de nous reconnaitre toute les deux.

<fc #088A4B>21/05/2019</fc>

Cette fois nous avons ajouté des photos à notre jeu de donnés au final nous nous retrouvons avec 21 photos, 5 dossiers photos, dont 2 de nos camarades. Nous avons aussi imprimé en 3D un boitier pour notre Raspberry afin de respecter le critère de sécurité de notre cahier des charges et bien entendu aussi pour l’esthétique. Il nous faut juste tout monté ensemble afin d'avoir un dispositif fonctionnel. Notre Raspberry sera alimenté avec une batterie externe. Et connecté à un ordinateur par le biais d'une connexion de bureau à distance. Il est possible de le faire car nous avons gardé l'adresse ip de notre Raspberry.

on peut voir ici la création de nos images faciales, le début de notre reconnaissance faciale.

<fc #088A4B>22/05/2019</fc>

ici on peut voir la fonctionnalité de notre reconnaissance faciale, je mettrai en bas les codes en python de notre programme.

<fc #f4d03f>Quelques Images</fc>

Boitier de la Raspberry pi imprimé en 3D

Le dispositif porté lors de la phase de test

<fc #088A4B>Le Programme Python 1 encode_faces.py </fc>

ce programme nous permet de décrire les chemins d'accès aux fichiers images de notre emsemble de données, et nous permettra de passer en boucle sur chaque face de l'ensemble de données et ensuite exporter les encodages faciaux sur notre disque pour pouvoir les utiliser dans notre script de reconnaissance faciale.

# importer les packages nécessaires
from imutils import paths
import face_recognition
import argparse
import pickle
import cv2
import os
 
# construit l'analyseur d'argument et analyse l'arguments
ap = argparse.ArgumentParser()
ap.add_argument("-i", "--dataset", required=True,
    help="path to input directory of faces + images")
ap.add_argument("-e", "--encodings", required=True,
    help="path to serialized db of facial encodings")
ap.add_argument("-d", "--detection-method", type=str, default="cnn",
    help="face detection model to use: either `hog` or `cnn`")
args = vars(ap.parse_args())

# saisir les chemins d'accès aux images d'entrée dans notre jeu de données
print("[INFO] quantifying faces...")
imagePaths = list(paths.list_images(args["dataset"]))
 
# initialise la liste des encodages et noms connus
knownEncodings = []
knownNames = []

# boucle sur les chemins de l'image
for (i, imagePath) in enumerate(imagePaths):
    # extraire le nom de la personne du chemin de l'image
    print("[INFO] processing image {}/{}".format(i + 1,
        len(imagePaths)))
    name = imagePath.split(os.path.sep)[-2]
 
   # charge l'image d'entrée et la convertit à partir de BGR (commande OpenCV)
    # à la commande dlib (RVB)
    image = cv2.imread(imagePath)
    rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
 
   # détecter les coordonnées (x, y) des boîtes englobantes
    # correspondant à chaque visage dans l'image d'entrée
    boxes = face_recognition.face_locations(rgb,
        model=args["detection_method"])
 
   # calcule l'incrustation du visage pour le visage
    encodings = face_recognition.face_encodings(rgb, boxes)
 
    # boucle sur les encodages
    for encoding in encodings:
        # ajouter chaque encodage + nom à notre ensemble de noms connus et
        #encodages
        knownEncodings.append(encoding)
        knownNames.append(name)
        
 # décharge les encodages faciaux + les noms sur le disque
print("[INFO] serializing encodings...")
data = {"encodings": knownEncodings, "names": knownNames}
f = open(args["encodings"], "wb")
f.write(pickle.dumps(data))
f.close()

suite à ça, on ouvre un terminale (ce qu'on voit sur les images précédentes) et on exécute la commande suivante :

$  python encode_faces.py --dataset dataset --encodings encodings.pickle \ 
 > --detection-method hog

celà va créer nos images faciales.

passons au second programme.

<fc #088A4B>Le Programme Python 2 pi_face_recognition.py </fc>

Ce code ci va nous permettre de faire la reconnaissance faciale à partir du programme précédent.

# importer les packages nécessaires
from imutils.video import VideoStream
from imutils.video import FPS
import face_recognition
import argparse
import imutils
import pickle
import time
import cv2
 
# construit l'analyseur d'arguments et analyse les arguments
ap = argparse.ArgumentParser()
ap.add_argument("-c", "--cascade", required=True,
    help = "path to where the face cascade resides")
ap.add_argument("-e", "--encodings", required=True,
    help="path to serialized db of facial encodings")
args = vars(ap.parse_args())
# charge les visages et les embeddings connus avec Haarcascade d'OpenCV
# pour la détection de visage
print("[INFO] loading encodings + face detector...")
data = pickle.loads(open(args["encodings"], "rb").read())
detector = cv2.CascadeClassifier(args["cascade"])
 
# initialise le flux vidéo et permet au capteur de la caméra de se réchauffer
print("[INFO] starting video stream...")
vs = VideoStream(src=0).start()
# vs = VideoStream(usePiCamera=True).start()
time.sleep(2.0)
 
# démarre le compteur FPS
fps = FPS().start()

# Boucle sur les images du flux de fichiers vidéo
while True:
    # récupère l'image du flux vidéo fileté et la redimensionne
    # à 500px (pour accélérer le traitement)
    frame = vs.read()
    frame = imutils.resize(frame, width=500)
    
   # convertit le cadre d’entrée de (1) BGR en niveaux de gris (pour la détection
    # faciale) et (2) de BGR à RGB (pour la reconnaissance faciale)
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
 
    # détecter les visages dans le cadre en niveaux de gris
    rects = detector.detectMultiScale(gray, scaleFactor=1.1, 
        minNeighbors=5, minSize=(30, 30))
 
    #OpenCV renvoie les coordonnées du cadre de sélection dans l'ordre (x, y, w, h)
    # mais nous en avons besoin dans l’ordre (en haut, à droite, en bas, à gauche), donc nous
    # avons besoin de faire un peu de réorganisation
    boxes = [(y, x + w, y + h, x) for (x, y, w, h) in rects]
 
    # calculez les imbrications faciales pour chaque boîte englobante
    encodings = face_recognition.face_encodings(rgb, boxes)
    names = []
    
    # faire une boucle sur les plis du visage
    for encoding in encodings:
        # essayer de faire correspondre chaque visage dans l'image d'entrée à notre connu
        # encodages
        matches = face_recognition.compare_faces(data["encodings"],
            encoding)
        name = "Unknown"
 
        # vérifier si nous avons trouvé une correspondance
        if True in matches:
            # trouver les index de tous les visages correspondants puis initialiser un
            # dictionnaire pour compter le nombre total de fois où chaque visage
            # a été jumelé
            matchedIdxs = [i for (i, b) in enumerate(matches) if b]
            counts = {}
 
            # boucle sur les index correspondants et maintenir un compte pour
            # chaque visage reconnu
            for i in matchedIdxs:
                name = data["names"][i]
                counts[name] = counts.get(name, 0) + 1
 
            # déterminer la face reconnue avec le plus grand nombre
            # des votes (note: en cas de lien improbable Python
            # sélectionnera la première entrée dans le dictionnaire)
            name = max(counts, key=counts.get)
        
        # mettre à jour la liste des noms
        names.append(name)
        
     # boucle sur les visages reconnus
    for ((top, right, bottom, left), name) in zip(boxes, names):
        # dessine le nom du visage prédit sur l'image
        cv2.rectangle(frame, (left, top), (right, bottom),
            (0, 255, 0), 2)
        y = top - 15 if top - 15 > 15 else top + 15
        cv2.putText(frame, name, (left, y), cv2.FONT_HERSHEY_SIMPLEX,
            0.75, (0, 255, 0), 2)
 
    # afficher l'image sur notre écran
    cv2.imshow("Frame", frame)
    key = cv2.waitKey(1) & 0xFF
 
    # si la touche `q` a été enfoncée, sortir de la boucle
    if key == ord("q"):
        break
 
    # mettre à jour le compteur FPS
    fps.update()
   
   
   # arrêter le chronomètre et afficher les informations FPS
fps.stop()
print("[INFO] elasped time: {:.2f}".format(fps.elapsed()))
print("[INFO] approx. FPS: {:.2f}".format(fps.fps()))
 
# faire un peu de nettoyage
cv2.destroyAllWindows()
vs.stop()

à la suite de celà, on execute une nouvelle commande:

$  python pi_face_recognition.py --cascade haarcascade_frontalface_default.xml \
 > --encodings encodings.pickle

à partir de la une fênetre va s'ouvrir et filmé avec la caméra connecté à notre Raspberry, à chaque fois qu'il reconnaitra un visage, un carré vert sera dessiné autour du visage avec le nom de la personne au dessus, seulement si la personne est inscrite sur notre base de données sinon il y aura écrit unknown.

<fc #f4d03f>Expérience vécue, donné à vivre.</fc>

L'expérience qu'on l'on souhaite faire vivre aux personnes qui utiliseront notre dispositif, est une expérience de perception d'autrui, une expérience qui leur permettraient de savoir s'ils sont remarquables aux yeux des gens mais aussi qui leur permettraient de savoir qu'elles sont les réactions qu'a autrui lorsqu'il se sait perçu.

<fc #000000> Un Petit Cours ?</fc>

Il existe différents types de perception en fonction de l'organe sensoriel sollicité : la perception tactile, la perception auditive, la perception olfactive, la perception gustative et enfin la perception visuelle. Pour l'objet de notre étude, nous nous focalisons plus particulièrement sur la perception visuelle ou l’œil et le cerveau, qui travaillent ensemble en duo pour nous permettre de voir. La vision fournit des informations sur notre environnement sans le besoin de proximité qui est nécessaire dans le cas du goût du toucher ou encore de l'odorat. La vision occupe une place importante, voir primordiale dans notre vie quotidienne.

Il y a différentes régions du cerveau mais aussi différents processus de perception qui sont impliqués dans la fonction visuelle mais aussi d'autres fonctions comme la perception du mouvement, de la couleur et de la profondeur. Il y a même des régions particulières du cerveau qui ne vont traiter que la fonction de reconnaissance faciale à la reconnaissance des objets et la reconnaissance des mouvements biologiques. L'information est envoyée au cerveau par le nerf optique. Par la suite, le cerveau transforme cette information en images visuelles que l'on peut voir. Cette perception nous permet d'identifier les visages que les individus rencontrent au jour le jour ou encore faire la différence entre les mouvements biologiques et non biologiques. En effet, le système visuel est particulièrement sensible aux mouvements « biologiques », c'est-à-dire produits par un organisme vivant. Ce processus de différenciation résulte-t-il d'un long processus ou l'on apprendrait dès l'enfance à distinguer ce qui est vivant de ce qui ne l'est pas, ou bien cette capacité est acquise dès la naissance ?

<fc #f4d03f>Cartels du dispositif</fc>

affiche_flip_1.pdf

affiche_flip_2.1.pdf

affiche_2.pdf

affiche_3.pdf

• Raspberry pi 3 B+

• Écran / Ordinateur

• Clavier

• Souris

• Câble HDMI

• Alimentation 5V 2.5A

• Ordinateur

• Casquette

• Imprimante 3D

• Caméra / Webcam