Spaces:
Sleeping
Sleeping
File size: 8,995 Bytes
ba103a1 1eb9eea b82df62 ba103a1 b82df62 e038407 4c42c3b ba103a1 48cd77f 1eb9eea 48cd77f e038407 46c21ad e038407 46c21ad 192dc84 e038407 46c21ad e038407 46c21ad 42adcdf e038407 46c21ad e038407 46c21ad e038407 46c21ad e038407 46c21ad e038407 46c21ad 42adcdf e038407 42adcdf 46c21ad 42adcdf b00508c 42adcdf ba103a1 42adcdf ba103a1 42adcdf ba103a1 42adcdf b00508c 42adcdf 2afccc6 ba103a1 42adcdf b649895 ba103a1 58872ce ba103a1 42adcdf ba103a1 42adcdf ba103a1 42adcdf e038407 ba103a1 e038407 ba103a1 e038407 e88bf0a 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 187 188 189 190 191 192 193 194 | ## 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
print("Nettoyer et normaliser le nom de l'utilisateur")
username_clean = username.strip().replace(" ", "_").lower()
#on créer le chemin du dossier de l'utilisateur
print("on créer le chemin du dossier de l'utilisateur")
user_folder = f"/tmp/registered_users/{username_clean}"
#on crée le chemin du template du dossier de l'utilisateur
print("on crée le chemin du template du dossier de l'utilisateur")
template_path = os.path.join(user_folder, "template.npy")
print("on vérifie que le fichier reçu est bien une image")
#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à
print("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
print("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
print("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:
print(" on crée et on enregistre le template")
# on crée et on enregistre le template
create_insightface_template(user_folder, template_path)
print("on prévient que tout ce passe bien")
# 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
print("erreur : ",e)
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"/tmp/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"/tmp/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"/tmp/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) #donner le path de template pour verify_liveness
# 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.""" |