VISIONSHIELD / app.py
maxni94's picture
add test route
639f1e0 verified
Raw History Blame
8.35 kB
## 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."""