​​​​                                RAPPORT TECHNHIQUE

I. INTRODUCTION

Dans le cadre de l'UE (Unité d'Enseignement) Internet des objets, il nous a été demandé de réaliser un système de surveillance d'examens. Il s'agit de créer une application qui communique avec un ordinateur selon le protocole client-serveur afin d'analyser le comportement d'un candidat pendant un examen.

En effet, l'ordinateur qui joue le rôle de serveur doit pouvoir analyser les données envoyées par l'application qui simule le client afin de déterminer les suspicions de fraude que nous énumérons plus tard. Pour ce faire, l'application possède deux modes principaux.

1. Un mode tête qui signifie que l'application est placée sur la tête du candidat. Dans ce cas, elle va:
   • prendre une photo toutes les deux secondes pour les envoyer au serveur afin de lui montrer ce que le candidat voit pendant la réunion,
   • envoyer au serveur les coordonnées x y et z de l'accéléromètre placé dans l'appareil contenant l'application pour qu'il puisse déterminer les mouvements de la tête pendant la réunion.
2. Un mode main lorsque l'application est placée sur la main. Ainsi :
   • comme pour l'application, elle enverra au serveur les valeurs de l'accéléromètre,
   • elle affichera sur son écran un chronomètre montrant le temps écoulé depuis le début de la réunion.

Ce projet a ainsi pour objectif de proposer un prototype d'outil d'aide à la prise de décision. Il retranscrit les suspiscions de fraude dans des fichiers Excel qui seront consultés par l'examinateur pour qu'il puisse en déduire s'il y a réellement eu au moins une fraude. Mais pour mieux comprendre la démarche entamée, nous avons rédigé ce rapport technique afin d'y décrire les fonctionnalités du système ainsi que les détails d'implémentation.

II. gRPC : Remote Procedure Call

gRPC est une technologie de communication open source développée par Google. Elle consiste en la création d'un service (avec ses méthodes, entrées et sorties) compatible avec de nombreux langages de programmation comme Java, Kotlin, Python, etc. Il permet ainsi de construire des liaisons client/serveur avec une très bonne prise en charge de la diffusion bidirectionnelle:

• Le serveur implémente une interface et exécute un serveur gRPC pour gérer les clients,
• Le client dispose d'un stub qui fournit les mêmes méthodes que le seveur pour qu'il puisse communiquer avec lui.

C'est pour ces raisons que nous avons utilisé le protocole gRPC. Pour qu'il puisse effectuer des communications entre notre programme Kotlin (application mobile) et notre serveur Python (ordinateur portable). Voici une représentation simplifiée de notre protocole client-Serveur:

Pour mettre en place un tel protocole, il faut dans un premier temps créer un IDL (Interface Definition Language) qui n'est rien de plus qu'un contrat de service rédigé sous la forme d'un fichier texte .proto. Ainsi, grâce à ce dernier, le compilateur Protobuf protoc va pouvoir générer du code pour le client et le serveur.

Dans le cas de notre système de surveillance d'examen, nous avons créé le fichier envoie.proto qui est composé :

• de deux blocs identiques qu'on appelle des messages et qui sont composés d'une série de paires (type, nom de la variable) appelées champs.

// Bloc pour créer des messages
message Envoie {
    // > Membres de la reunion
    string nomReunion = 1;
    string mailEtudiant = 2;
    // > Option
    string teteOuMain = 3;
    // > true pour reunion termine sinon false
    string etatReunion = 4;
    // > CameraX
    string image = 5;
    // > Accéléromètre
    float x = 6;
    float y = 7;
    float z = 8;   
    // > Tentative de connexion
    string tentaConnec = 9;  
}

https://hackmd.io/S18oxuh6Tc6fCS1Hrfc1ZA?both#:~:text=variable)%20appel%C3%A9es%20champs.-,//%20Bloc%20pour%20cr%C3%A9er%20des%20messages,-message%20Envoie%20%7B%0A%20%20%20%20//%20%3E%20Membres

• d'un bloc qui définit le service gRPC et qui va être utilisé pour la communication client-serveur

// Bloc pour créer un service
service EnvoieService {
    rpc GetEnvoie (GetEnvoieRequest) returns (Envoie);
}

https://hackmd.io/S18oxuh6Tc6fCS1Hrfc1ZA?both#:~:text=communication client-serveur-,// Bloc pour créer un service,-service EnvoieService { rpc

Dans un second temps, il faut mettre à jour le code gRPC (utilisé par notre serveur python) pour qu'il puisse utiliser notre service. Pour ce faire, on se place sur le répertoire où se trouve notre fichier proto (ici SpyCheat) et on exécute les commandes suivantes :

# Installer
python -m pip install --upgrade pip
python -m pip install grpcio
python -m pip install grpcio-tools
# Générer les fichiers
python -m grpc_tools.protoc -I../SpyCheat --python_out=. --grpc_python_out=. ../SpyCheat/envoie.proto

https://hackmd.io/S18oxuh6Tc6fCS1Hrfc1ZA?both#:~:text=les commandes suivantes %3A-,%23 Installer,-python -m pip

Les fichiers envoie_pb2.py et envoie_pb2_grpc.py sont alors générés et seront utilisés pour implémenter les fonctions de notre serveur pour qu'il puisse communiquer avec notre application.

III. SpyCheat : Application android

1. Objectif

L'application SpyCheat joue le rôle de client dans notre système de surveillance d'examens. Elle se découpe en 3 parties principales où la première sert à créer des réunions en donnant la liste des utilisateurs qui auront le droit d'y accéder. La seconde est utilisée pour lancer une réunion quand l'application est posée sur la main. Et pour finir, la troisième partie permet de participer à une réunion en ayant mis l'application sur la tête. Finalement, ces trois parties sont utilisées pour de détecter les tentatives de fraudes en s'assurant que uniquement les personnes inscrites peuvent se connecter à la réunion et en analysant des photos et les mouvements d'un candidat.

2. Prérequis

Pour y parvenir, l'application à été crée sur Android Studio. Elle est composée de plusieurs fichiers dont :

• envoie.proto : le même fichier que nous avons présenté dans la première partie et qui est stocké dans un répertoire nommé proto (lui même placé dans le répertoire main).

• build.gradle : un fichier qui permet d'utiliser le compilateur protobuf (gRPC) et d'ajouter la caméra (caméraX) à notre code. Pour cela, il faut ajouter les lignes suivantes :

  • Dans le bloc des plugins :
    id "com.google.protobuf" version "0.8.12"
id 'distribution'
    https://hackmd.io/S18oxuh6Tc6fCS1Hrfc1ZA?both#:~:text=Dans le bloc des plugins
  • Dans le bloc android :
    buildFeatures { viewBinding true }
    https://hackmd.io/S18oxuh6Tc6fCS1Hrfc1ZA?both#:~:text=Dans le bloc android
  • Dans le bloc des dependences:

  ​​​​//CAMERAX
  ​​​​implementation "androidx.camera:camera-camera2:1.1.0-beta01"
  ​​​​implementation "androidx.camera:camera-lifecycle:1.1.0-beta01"
  ​​​​implementation "androidx.camera:camera-view:1.1.0-beta01"
  
  ​​​​//GRPC
  ​​​​implementation 'com.google.protobuf:protobuf-lite:3.0.1'
  ​​​​implementation 'io.grpc:grpc-okhttp:1.25.0' // CURRENT_GRPC_VERSION
  ​​​​implementation 'io.grpc:grpc-protobuf-lite:1.25.0' // CURRENT_GRPC_VERSION
  ​​​​implementation 'io.grpc:grpc-stub:1.25.0' //
  ​​​​implementation 'javax.annotation:javax.annotation-api:1.3.2
  

  https://hackmd.io/S18oxuh6Tc6fCS1Hrfc1ZA?both#:~:text=Dans le bloc des dependences

  • Pour finir, on ajoute à la fin du fichier ce nouveau bloc:

  ​​​​protobuf {
  ​​​​    protoc { artifact = 'com.google.protobuf:protoc:3.10.0' }
  ​​​​    plugins {
  ​​​​        javalite { artifact = "com.google.protobuf:protoc-gen-javalite:3.0.0" }
  ​​​​        grpc { artifact = 'io.grpc:protoc-gen-grpc-java:1.25.0' // CURRENT_GRPC_VERSION
  ​​​​        }
  ​​​​    }
  
  ​​​​    generateProtoTasks {
  ​​​​        all().each { task ->
  ​​​​            task.builtins{
  ​​​​                remove java
  ​​​​            }
  ​​​​            task.plugins {
  ​​​​                javalite {}
  ​​​​                grpc { // Options added to --grpc_out
  ​​​​                    option 'lite' }
  ​​​​            }
  ​​​​        }
  ​​​​    }
  ​​​​}
  

  https://hackmd.io/S18oxuh6Tc6fCS1Hrfc1ZA?both#:~:text=bloc des dependences-,Pour finir%2C on ajoute à la fin du fichier ce nouveau bloc%3A,-protobuf { protoc { artifact

• A cela s'ajoute un troisième et dernier fichier appelé AndroidManifest.xml. Il va servir à implémenter les permissions pour utiliser la caméra et la wifi :

  ​​​​<uses-permission android:name="android.permission.INTERNET" />
  ​​​​<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
  ​​​​<uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
  ​​​​<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
  ​​​​<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" /> 
  
  ​​​​<uses-feature android:name="android.hardware.camera.any" />
  ​​​​<uses-permission android:name="android.permission.CAMERA" />
  

https://hackmd.io/S18oxuh6Tc6fCS1Hrfc1ZA?both#:~:text=xml. Il va servir à implémenter les-,permissions pour utiliser la caméra et la wifi,-%3A

Une fois que c'est trois fichiers sont modifiés, il faut exécuter la commande gradlew build sur le terminal d'android studio pour que les fichiers contenant les fonctions gRPC soit générés.

3. Fonctionnement

Une fois que la liste des prérequis ait été respéctée, nous pouvons nous intéresser aux fonctionnalités de l'application. En effet, cette dernière est composée de :

• une page MainActivity.kt : l'utilisateur doit d'abord donner son authorisation pour que l'application puisse utiliser la caméra. Ensuite, il saisit l'adresse IP du réseau ainsi que le port pour que l'application puisse faire appel à la méthode suivante :

​   // Connexion au seveur
​   val channel: ManagedChannel
​   val newport = if (TextUtils.isEmpty(port)) 50051 else Integer.valueOf(port)
​   channel = ManagedChannelBuilder
​           .forAddress(host, newport)
​           .usePlaintext()
​           .build()

https://hackmd.io/S18oxuh6Tc6fCS1Hrfc1ZA?both#:~:text=la méthode suivante %3A-,// Connexion au seveur,-val channel%3A ManagedChannel
Si la connexion a échouée un message rouge s'affichera sur l'écran sinon l'utilisateur sera redirigé vers la page suivante.

• une page d'accueil (AcceuilActivity.kt) : l'utilisateur à le choix entre créer une réunion ou se connecter à une réunion.
• une page de création de réunion (InscriptionActivity.kt) : lorsque l'utilisateur arrive sur cette page, il doit remplir un formulaire en saisissant le nom d'une réunion et l'adresse mail d'un candidat. Pour valider l'inscription, il doit cliquer sur le bouton envoyer. La méthode suivante est alors exécutée pour que l'information soit envoyée au serveur :

    // Si la connexion est un succès, on envoie nos données au serveur
    val stub: EnvoieServiceGrpc.EnvoieServiceBlockingStub = EnvoieServiceGrpc.newBlockingStub(channel).withDeadlineAfter(2,TimeUnit.SECONDS)
    val request: GetEnvoieRequest = GetEnvoieRequest.newBuilder()
            .setNomReunion(nomReu)            //nom de la Réunion
            .setMailEtudiant(mailEtud)        // mail de l'étudiant
            .setTeteOuMain(optionTeteOuMain)
            .setEtatReunion(etatReu)
            .setImage(imageForGRPC)
            .setX(x)
            .setY(y)
            .setZ(z)
            .setTentaConnec(tenteConnexion)  //false car c'est un inscription et non une connexion
            .build()

https://hackmd.io/S18oxuh6Tc6fCS1Hrfc1ZA?both#:~:text=envoyée au serveur %3A-,// Si la connexion est un succès%2C on envoie nos données au serveur,-val stub%3A EnvoieServiceGrpc

• une page de connexion (ConnexionActivity/kt) : le candidat doit saisir le nom de la réunion et son adresse mail. En cliquant sur le bouton valider, la méthode précédente est éxécutée en précisant cette fois qu'il y a une tentative de connexion (tenteConnexion = true). Si le candidat n'est pas inscrit, un message d'erreur s'affichera sinon il sera redirigé vers la page suivante.
• une page OptionActivity.kt : le candidat a alors le choix entre deux options:
  • participer à la réunion en mode tete. Il sera alors redirigé vers la page de HeadActivity.kt et devra placer l'application sur sa tête. Lorsque la réunion débutera, la caméra se lancera ainsi que l'accéléromètre et leur données seront envoyées toutes les 2 secondes au serveur (toujours grâce à la méthode précédente).
  • participer à la réunion en mode main. Il sera donc redirigé vers la page HandActivity.kt et devra placer l'application sur sa main. Cette fois-ci c'est l'accéléromètre et le chronomètre qui sont lancé lorsque la réunion débutera.

IV. Serveur : code python

1. Objectifs

Placé sur un ordinateur portable, le serveur python se découpe en plusieurs parties. La première consiste à gérér les inscriptions et les connexions des utilisateurs. La seconde partie intervient lorsqu'une réunion a débuté en analysant les données (photos et accéléromètre) envoyées par l'application. Et pour finir, une troisième partie dédiée à l'enregistrement vocal.

2. Prérequis

Pour lancer le serveur, il faut installer et importer un certain nombre de paquets :

• Pour gRPC il faut importer :

from concurrent import futures
import logging
import grpc
import envoie_pb2
import envoie_pb2_grpc

https://hackmd.io/S18oxuh6Tc6fCS1Hrfc1ZA?both#:~:text=nombre de paquets %3A-,Pour gRPC il faut importer,-%3A

• Pour convertir en .jpg une image envoyée par l'application sous forme de chaîne de caractères :

# Installer
pip install base64
# Importer
import base64

https://hackmd.io/S18oxuh6Tc6fCS1Hrfc1ZA?both#:~:text=faut importer%2C-%253A-,Pour convertir,-en .jpg une

• Pour écrire et lire des fichiers CSV :

# Installer
pip install csv
pip install os
pip install pandas
# Importer
import csv
import os
import pandas as pd

https://hackmd.io/S18oxuh6Tc6fCS1Hrfc1ZA?both#:~:text=en .jpg une-,Pour écrire et lire des fichiers CSV,-%3A

• Pour analyser les coordonnées de l'accéléromètre :

# Installer
pip install numpy
# Importer
import numpy as np

https://hackmd.io/S18oxuh6Tc6fCS1Hrfc1ZA?both#:~:text=fichiers CSV%2C-%253A-,Pour analyser les coordonnées de l’accéléromètre,-%3A

• Pour l'enregistrement vocal il faut installer et importer :

# Installer
pip install sounddevice
pip install wavio
pip install wave
# Importer
import sounddevice as sd
import wavio as wv
import wave

https://hackmd.io/S18oxuh6Tc6fCS1Hrfc1ZA?both#:~:text=de l’accéléromètre%2C-%253A-,Pour l’enregistrement vocal,-il faut installer

• Pour la reconnaissance de personne et d'objets sur les photos envoyé par l'application :

# Installer
pip install argparse
pip install opencv-python
pip install datetime
# Importer
import argparse
import cv2
import datetime

https://hackmd.io/S18oxuh6Tc6fCS1Hrfc1ZA?both#:~:text=de l’accéléromètre%2C-%253A-,Pour l’enregistrement vocal il faut installer et importer,-%3A

3. Fonctionnement

Une fois que la liste des prérequis ait été respecté, nous pouvons nous intéresser aux fonctionnalités du serveur. En effet, ce dernier est composé d'une fonction server() qui attend que des clients (maximum 10) se connectent sur son réseau. Dans ce cas là, il exécute la classe Greeter() à chaque fois que le client (application) lui envoie des données:

# code server()
def serve():
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
    envoie_pb2_grpc.add_EnvoieServiceServicer_to_server(Greeter(), server)
    server.add_insecure_port('[::]:50051')
    server.start()
    
    server.wait_for_termination()

https://hackmd.io/S18oxuh6Tc6fCS1Hrfc1ZA?both#:~:text=envoie des données%3A-,%23 code server(),-def serve()%3A server

Les données subissent alors une série de traitement que nous allons énumérer. Mais pour mieux comprendre les phases de traitement, nous allons nous baser sur des scénarios :

• "Je suis un utilisateur et je souhaiterai créer des réunions". L'utilisateur est allé sur l'application SpyCheat et c'est dirigé vers la page des inscriptions. Lorsqu'il clique sur le bouton "envoyer" après avoir saisit le nom d'une réunion et l'adresse mail d'un candidat, le serveur va :
  • Si le fichier 'ReunionEtCandidats.csv' (stocke les réunions qui ont été créés) n'existe pas, le serveur le crée et écrit sur une ligne le nom de la réunion avec l'adresse mail du candidat inscrit à cette dernière
  • Si le fichier existe alors le serveur commence par vérifier si le candidat a déjà ou non été inscrit dans le fichier avec la fonction def verifCandidat(reunion, mail). Dans le cas échéant, il est ajouté au fichier grâce à la fonction def ajoutCandidat(reunion, mail) sinon l'inscription est ignorée.
• "Je suis un candidat et je souhaiterai me connecter à une réunion". Le candidat est allé sur l'application SpyCheat et c'est dirigé vers la page de connexion. Lorsqu'il a cliqué sur le bouton "valider" après avoir saisit le nom de sa réunion et son adresse mail, le serveur va :
  • Si les identifiants ne sont pas inscrits dans le fichier 'ReunionEtCandidats.csv' alors il envoie un message à l'application pour lui dire que le candidat ne peut pas se connecter à la réunion. Celle-ci reçoit l'information grâce à ces lignes de code :

  
  
  
  
  
  
  
  
  ​​​​// Réponse du serveur
  ​​​​var reply : Envoie = stub.getEnvoie(request)
  ​​​​// on veut savoir si le serveur a accépté ou refusé un demande de connexion
  ​​​​if(reply.tentaConnec == "accepte"){
  ​​​​    connectAuto = "accepte"
  ​​​​}
  ​​​​else if(reply.tentaConnec == "refuse"){
  ​​​​    connectAuto = "refuse"
  ​​​​}
  

  https://hackmd.io/S18oxuh6Tc6fCS1Hrfc1ZA?both#:~:text=lignes de code %3A-,// Réponse du serveur,-var reply %3A Envoie
  • Si les identifiants sont inscrits dans le fichier 'ReunionEtCandidats.csv' alors il envoie un message à l'application pour lui dire que le candidat a le droit de se connecter. Dans ce cas, il sera redirigé vers une page qui lui demandera de choisir entre l'option tête et l'option main.
• "Je suis un candidat est je souhaiterai participer à la réunion en mode tête (respectivement en mode main)". Dans ce cas, le serveur ce doit de vérifier si le candidat a déjà participé à cette réunion ET avec ce mode. Pour ce faire, le serveur reçoit un message en provenance de l'application l'informant que ce candidat veut participer à cette réunion. Il parcourt alors un fichier appelé 'InventaireTeteReunionEtCandidats.csv' (respectivement 'InventaireMainReunionEtCandidats.csv') grâce à la fonction def encours_ou_termine(fileName, reunion, mail, colonne, statut) : s'il y est marqué que le candidat a déjà terminé la réunion, alors il envoie un message à l'application pour donner son désaccord. En revanche, si rien n'est indiqué dans le fichier, alors le serveur donne son accord à l'application et le candidat sera redirigé vers la page de réunion en mode tête. Notons que l'application reçoit la réponse du serveur grâce à ces lignes de code :

var reply : Envoie = stub.getEnvoie(request)
if(reply.tentaConnec == "accepte"){
    connectAuto = "accepte"
}
else if(reply.tentaConnec == "refuse"){
    connectAuto = "refuse"
}
// c'est cette condition qui entre en jeu ! 
else if (reply.tentaConnec == "fini"){
    tenteConnexion = "fini"
}

https://hackmd.io/S18oxuh6Tc6fCS1Hrfc1ZA?both#:~:text=lignes de code %3A-,var reply,-%3A Envoie %3D stub.getEnvoie

• "Je suis un candidat et je participe à la réunion en mode main". Lorsque le candidat clique sur le bouton "commencer", plusieurs évènements entrent en jeu :

  • Premièrement, le serveur écrit dans le fichier 'InventaireTeteReunionEtCandidats.csv' que la réunion est en cours grâce à la fonction def inventaire(fileName, reunion, mail, colonne, etatReu). Ce même fichier est mis à jour lorsque le candiat quitte la réunion en écrivant "terminé".
  • Deuxièmement, il lance l'enregistrement vocal grâce à la fonction def record(). Cette dernière lance un enregistrement toutes les 5 secondes et les concatènent au fur et à mesure pour ne former qu'un seul audio. Notons que l'enregistrement se termine lorsque le candidat a quitté la réunion.
  • Troisièment, il traite les valeurs de l'accéléromètre grâce à la fonction def calibrage(x, y ,z ,nb_ite). Cette dernière commence par faire une moyenne des 5 premières coordonnées envoyées par l'application. Ainsi si les nouveaux coordonnées s'éloigne de la moyenne (à partir d'un certains seuil), le serveur est en mesure de déterminer s'il y a eu un mouvement droite, gauche, haut ou bas de la tête.
  • Quatrièmement, il traite les images envoyées par l'application. Pour ce faire, grâce à la fonction def base64_to_image (img_data) la chaine de caractère est d'abord converti en image .jpg. Puis, un algorithme est alors appliqué à cette image de façon a reconnaître les objets et les personnes présent sur la photo et les écrits dans le fichier Objects_Detection.csv.

• "Je suis un candidat et je participe à la réunion en mode main". Lorsque le candidat clique sur le bouton "commencer", seules les valeurs de l'accéléromètre sont envoyées au serveur. Mais par manque de temps, ces dernières ne sont pas traitées.

V. Reconnaissance Faciale : script python

1. Objectif

Le but était d'implémenter une solution de reconnaissance faciale au niveau de la webcam de l'ordinateur. Cette dernière devait être capable de reconnaître la personne qui passait l'examen et d'enregistrer en cas de suspicion de fraude.

2. Prérequis

Il faut installer toutes les librairies suivantes dans votre environnement python pour permettre à l'utilisateur de lancer les scripts :
https://hackmd.io/S18oxuh6Tc6fCS1Hrfc1ZA?both#:~:text=suspicion de fraude.-,Prérequis,-Comment

# Installer
pip install opencv-python 
pip install dlib
pip install numpy
pip install imutils
pip install pillow
# Importer
import cv2
import dlib
import PIL.Image
import numpy as np
from imutils import face_utils
import argparse
from pathlib import Path
import os
import ntpath
import datetime
import glob
import time
from imutils.video import FPS

3. Fonctionnement

Une fois que nous avons les prérequis nécessaire nous pouvons lancer le script python pour nous prendre en photo avant l'examen :

#Une fois que nous sommes dans le répertoire easy_facial_recognition-master, nous lançons sur le terminal ceci : 
python 01_face_dataset.py

https://hackmd.io/S18oxuh6Tc6fCS1Hrfc1ZA?both#:~:text=%23-,Une fois que nous sommes dans le répertoire,-easy_facial_recognition-master%2C nous lançons sur le terminal ceci %3A python

Il faudra ensuite écrire votre nom puis appuyer sur entrée pour que la photo soit prise et enregistrée dans le dossier known_faces.

Ensuite, nous pouvons d'ores et déjà lancer la commande qui va nous permettre de lancer la webcam de l'ordinateur pour faire l'examen.
La commande est la suivante :
https://hackmd.io/S18oxuh6Tc6fCS1Hrfc1ZA?both#:~:text=pour faire l’examen.-,La commande est la suivante,-%3A

python easy_facial_recognition.py --i known_faces

Des informations sont communiquées sur le terminal pour voir l'avancé du chargement. Un message sera affiché pour pouvoir entrer le nom de la personne qui passera l'examen.

Voici les différents scénarios que nous avons traité :

Si la personne n'entre pas le bon nom, elle se verra être enregistrée puis on stockera la personne que nous verrons dans un fichier qui se nommera comme le nom qu'elle a entré pour se connecter.

Si la personne entre le bon nom puis au cours de l'examen se lève pour aller ailleurs, un enregistrement sera pris (dans le dossier recording) et pourra servir de preuve. De plus sur le fichier csv (dans le dossier Students puis dans le dossier de l'élève en question ) généré à son nom il y aura un intervalle de temps où la personne ne saura pas notée (nom de la personne et la date(jour,heure,seconde)).

Si la personne entre le bon nom puis au cours de l'examen un autre élève entre dans le champs de vision de la webcam, un enregistrement sera pris (dans le dossier recording) et pourra servir de preuve. De plus sur le fichier csv (Attendance.csv) généré il y aura écrit soit le nom de la seconde personne si l'algorithme le reconnait soit comme étant un inconnu (nom de la personne et la date(jour,heure,seconde)).

====================================================================

Ce que j'ai fais :

====================================================================

Sohayla
Ce que j'ai fais :