Spaces:
Sleeping
Sleeping
Download app.py from VisionShield/VISIONSHIELD: direct link, hf CLI and curl.
- Browser
- Download file 9 kB
-
https://huggingface.co/spaces/VisionShield/VISIONSHIELD/resolve/main/app.py
- Command line
-
hf download hf://spaces/VisionShield/VISIONSHIELD/app.py
-
curl -L -o app.py https://huggingface.co/spaces/VisionShield/VISIONSHIELD/resolve/main/app.py
9 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 | |
| #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 | |
| #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 | |
| # 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) | |
| #---------------------- | |
| 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.""" |