File size: 8,353 Bytes
ba103a1
 
1eb9eea
 
 
 
b82df62
 
 
 
ba103a1
b82df62
 
 
 
e038407
4c42c3b
ba103a1
 
 
48cd77f
1eb9eea
 
 
 
 
48cd77f
e038407
 
 
 
 
 
 
 
 
 
 
 
42adcdf
 
 
 
 
 
 
 
e038407
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
42adcdf
e038407
42adcdf
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ba103a1
 
 
42adcdf
 
ba103a1
42adcdf
 
ba103a1
42adcdf
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ba103a1
 
 
 
42adcdf
 
b649895
ba103a1
 
 
 
 
 
 
 
 
 
 
 
42adcdf
 
ba103a1
 
 
 
 
 
 
 
 
42adcdf
 
 
ba103a1
 
42adcdf
e038407
ba103a1
e038407
 
 
 
ba103a1
e038407
639f1e0
 
 
 
 
b82df62
 
42adcdf
48cd77f
 
 
 
 
 
 
42adcdf
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
## on déclare notre serveur web avec FastAPI:
# on définit les routes que l'application mobile va appeler.
# c'est app.py qui va lancer le main main quand l'on recoit une info de l'app avec la vidéo en temps réels
# c'est app.py qui va aussi envoyer des infos à notre application pour lui dire si la vérification est ok etc.

#on importe FastAPI
#File et UploadFile ==> pour recevoir des fichier via request POST
from fastapi import FastAPI, File, UploadFile, HTTPException
#pour retourner une réponse structurée au format JSON à l'app
from fastapi.responses import JSONResponse
#from modeles.template_generator import generate_template_from_image # pour générer nos embedding de nos images récupérer grâce à l'application
#on importe notre fonction analyze_frame de notre pipeline (programme principal)
from pipeline import analyze_frame
#pour manipuler le template facial (emmbedding) au format .npy
import numpy as np
# pour générer un template de notre frame pour la reconnaissance faciale
from modeles.insightface_template_utils import create_insightface_template
import shutil
import os
import uuid


#on crée notre serveur API
app = FastAPI()

#on définit les routes

#----------------------
#route pour recevoir l'empreinte faciale de l'utilisateur et son nom/prénom
@app.post("/register-template/{username}")
#on recoit le nom/prénom de l'utilisateur et la photo de son empreinte
async def register_template(username: str, file: UploadFile = File(...)):
    # Nettoyer et normaliser le nom de l'utilisateur
    username_clean = username.strip().replace(" ", "_").lower()
    #on créer le chemin du dossier de l'utilisateur
    user_folder = f"registered_users/{username_clean}"
    #on crée le chemin du template du dossier de l'utilisateur
    template_path = os.path.join(user_folder, "template.npy")

    #on vérifie que le fichier reçu est bien une image
    if not file.filename.lower().endswith((".jpg", ".jpeg", ".png")):
        #sinon on envoie une erreur
        raise HTTPException(
            status_code=400,
            detail="Le fichier doit être une image (.jpg, .jpeg ou .png)."
        )
    
    # on vérifie si le template existe déjà
    if os.path.exists(template_path): # on envoie une erreur si l'utilisateur à déjà son template de fait
        raise HTTPException(status_code=400, detail="Un template existe déjà pour cet utilisateur.")

    # Créer le dossier si nécessaire
    os.makedirs(user_folder, exist_ok=True)

    # on enregistre l'image reçue dans le dossier de notre utilisateur
    img_path = os.path.join(user_folder, file.filename)
    with open(img_path, "wb") as f:
        shutil.copyfileobj(file.file, f)

    try:
        # on crée et on enregistre le template
        create_insightface_template(user_folder, template_path)

        # on prévient que tout ce passe bien
        return JSONResponse(content={"message": f"Template enregistré avec succès pour {username_clean}"})
    
    except Exception as e:
        #on prévient qu'une erreur est survenue
        return JSONResponse(content={"error": str(e)}, status_code=500)

#----------------------

#route pour recevoir le frame du flux vidéo en temps réel
@app.post("/upload-frame-temp/")
#on télécharge l'image
async def upload_temp_frame(file: UploadFile = File(...)):
    #on vérifie que le fichier est bien une image
    if not file.filename.lower().endswith((".jpg", ".jpeg", ".png")):
        return JSONResponse(content={"error": "Le fichier doit être une image"}, status_code=400)

    #on crée un dossier temporaire unique
    frame_id = str(uuid.uuid4()) #on crée un id pour le dossier
    #on crée le chemin du dossier
    temp_folder = f"temp_frames/{frame_id}"
    os.makedirs(temp_folder, exist_ok=True) # pour éviter une erreur si le dossier déjà

    #le chemin complet de notre frame envoyé par l'application
    img_path = os.path.join(temp_folder, file.filename)
    with open(img_path, "wb") as f: #on ouvre le fichier en écriture binaire
        shutil.copyfileobj(file.file, f) # on copie le contenu du fichier reçu dans ce fichier local

    # on prévient que le frame a bie été stocké = on confirme à l'application que tout s'est bien passé
    return JSONResponse(content={
        "message": "Frame reçu et stocké temporairement.",
        "frame_id": frame_id,
        "image_path": img_path  # utile côté débug, mais à cacher en prod
    })

#----------------------


#on définit une route pour analyser les frames 

@app.get("/analyze_uploaded_frame/{frame_id}/{username}")
# on crée une nouvelle fonction pour appliquer notre système de vérification sur notre frame
# on a besoin du frame et du nom de l'utilisateur pour chercher le template de son empreinte faciale
async def analyze_uploaded_frame(frame_id: str, username: str):
    # Chemin du dossier temporaire contenant le frame à analyser
    temp_folder = f"temp_frames/{frame_id}"
    if not os.path.exists(temp_folder): 
        # on alerte si on ne retrouve pas le dossier
        return JSONResponse(content={"error": "Frame introuvable"}, status_code=404)

    # on retrouve le fichier image dans le dossier de notre frame
    image_files = [f for f in os.listdir(temp_folder) if f.lower().endswith((".jpg", ".jpeg", ".png"))]
    if not image_files:
        # si on ne retrouve aucune image, on envoit une erreur
        return JSONResponse(content={"error": "Aucune image trouvée"}, status_code=400)

    #on crée notre chemin d'acces à notre image
    img_path = os.path.join(temp_folder, image_files[0])

    # on récupère le chemin du template utilisateur grace à son nom 
    username_clean = username.strip().replace(" ", "_").lower()
    #on crée le chemin d'accès à notre template utilisateur
    template_path = f"registered_users/{username_clean}/template.npy"
    
    if not os.path.exists(template_path):
        # on s'assure que le template a bien été trouvé
        return JSONResponse(content={"error": "Template non trouvé pour cet utilisateur"}, status_code=404)


    try:
        # on charge le template facial pour l'avoir en mémoire
        template_array = np.load(template_path)

        # on ouvre l'image sous forme de bytes
        with open(img_path, "rb") as f:
            image_bytes = f.read()

        # on appel notre fonction qui va nous permettre de vérifier que l'utilisateur 
        # ne transgresse pas les règles de l'utilisation : que la personne autorisée, pas d'objet interdits, et la bonne personne devant le doc
        result_code = analyze_frame(image_bytes, template_array)

        # on nettoie le dossier temporaire
        shutil.rmtree(temp_folder)

        # on crée un dictionnaire des codes de retour à l'application
        messages = {
            0: "Vérification réussie",
            1: "Erreur : plusieurs personnes détectées",
            2: "Erreur : objet suspect détecté",
            3: "Erreur : visage non reconnu",
            4: "Erreur : deepfake ou attaque par photo détectée"
        }
        # on renvoie une réponse à l'application pour qu'elle sache le résultat de l'analyse du frame
        return JSONResponse(content={
            "frame_id": frame_id,
            "username": username_clean,
            "result_code": result_code,
            "message": messages.get(result_code, "Code inconnu")
        })

    #on renvoie une erreur si nous n'avons pas réussi à analyser notre frame
    except Exception as e:
        return JSONResponse(content={"error": str(e)}, status_code=500)


#----------------------

@app.get("/test")
async def test():
    return JSONResponse(content={
                "test" : "vision_shield"
    })


"""# on définit notre route pour le fichier embedding
@app.post("/generate_template/")
#on recoit notre images ==> utiliser pas l'app mobile pour nous envoyer l'image de l'utilisateur à vérifier
async def generate_template(image: UploadFile = File(...)): 
#on attend un fichier nommé image, ficheir = obligatoire : mention ...
    image_bytes = await image.read()
    #on lit le contenu de l'image
    return generate_template_from_image(image_bytes) 
    # crée un dossier temporaire et enregister notre image dedans et génère un template faciale (embedding) et nous retourne un template json à utiliser ensuite."""