from flask import Flask, request, jsonify from flask_cors import CORS import numpy as np import tensorflow.lite as tflite # REMARQUE: tf.lite.Interpreter sera supprimé dans TF 2.20, voir migration: https://ai.google.dev/edge/litert/migration import cv2 from PIL import Image import io import os from functools import wraps import requests from dotenv import load_dotenv app = Flask(__name__) # Configuration CORS spécifique pour le frontend déployé CORS(app, resources={r"/*": {"origins": ["https://app.glamflow.ma", "https://analysepeaux.vercel.app"]}}) # Middleware pour vérifier l'origine des requêtes def check_origin(f): @wraps(f) def decorated_function(*args, **kwargs): # Ignorer toutes les vérifications en mode debug if app.debug: return f(*args, **kwargs) origin = request.headers.get('Origin', '') referer = request.headers.get('Referer', '') # Autoriser les requêtes provenant des domaines autorisés if any(domain in origin or domain in referer for domain in ['https://app.glamflow.ma', 'https://analysepeaux.vercel.app']): return f(*args, **kwargs) else: return jsonify({'error': 'Unauthorized origin'}), 403 return decorated_function # Charger les variables d'environnement load_dotenv() GROQ_API_KEY = os.getenv('GROQ_API_KEY') # Image Size IMG_SIZE = (150, 150) # Load TFLite models globally models_dir = os.path.join(os.path.dirname(__file__), "saved_models") interpreter_type = tflite.Interpreter(model_path=os.path.join(models_dir, "skin_type_model.tflite")) interpreter_disease = tflite.Interpreter(model_path=os.path.join(models_dir, "skin_disease_model.tflite")) interpreter_type.allocate_tensors() interpreter_disease.allocate_tensors() # Label mappings skin_type_labels = {0: 'Sèche', 1: 'Normale', 2: 'Grasse'} skin_disease_labels = {0: 'Acné', 1: 'Mélanome', 2: 'Psoriasis', 3: 'Rosacée', 4: 'Vitiligo'} # Recommendations pour les différents types de peau skin_type_recommendations = { "Sèche": "💧 Hydratez bien, évitez les douches chaudes et utilisez une crème hydratante épaisse.", "Grasse": "🧴 Utilisez des soins légers et sans huile. Nettoyez deux fois par jour.", "Normale": "🌿 Maintenez une routine équilibrée, utilisez un écran solaire et hydratez bien." } # Recommendations pour les différentes maladies de peau disease_treatment = { "Acné": "🔬 Utilisez de l'acide salicylique, évitez de toucher votre visage et nettoyez bien.", "Mélanome": "🛀 Utilisez des crèmes sans parfum, évitez les allergènes et gérez votre stress.", "Psoriasis": "🩺 Hydratez souvent, utilisez des traitements médicamenteux et évitez les déclencheurs.", "Rosacée": "☀️ Évitez les aliments épicés, utilisez des soins doux et portez un écran solaire.", "Vitiligo": "🌞 Utilisez des sérums éclaircissants, évitez l'exposition au soleil et appliquez un SPF 50+." } # Charger le détecteur de visage Haar Cascade face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml') def detect_face(image_array): """Détecte si l'image contient un visage""" gray = cv2.cvtColor(image_array, cv2.COLOR_RGB2GRAY) faces = face_cascade.detectMultiScale(gray, 1.1, 4) return len(faces) > 0 def predict_skin_condition(image_array): img = cv2.resize(image_array, IMG_SIZE) img = img / 255.0 img = np.expand_dims(img, axis=0).astype(np.float32) # Skin Type Prediction input_tensor_index = interpreter_type.get_input_details()[0]['index'] interpreter_type.set_tensor(input_tensor_index, img) interpreter_type.invoke() output_tensor_index = interpreter_type.get_output_details()[0]['index'] type_pred = interpreter_type.get_tensor(output_tensor_index) # Skin Disease Prediction input_tensor_index = interpreter_disease.get_input_details()[0]['index'] interpreter_disease.set_tensor(input_tensor_index, img) interpreter_disease.invoke() output_tensor_index = interpreter_disease.get_output_details()[0]['index'] disease_pred = interpreter_disease.get_tensor(output_tensor_index) # Results processing skin_type = skin_type_labels[np.argmax(type_pred)] skin_disease = skin_disease_labels[np.argmax(disease_pred)] type_confidence = float(np.max(type_pred) * 100) disease_confidence = float(np.max(disease_pred) * 100) type_probabilities = {skin_type_labels[i]: float(prob * 100) for i, prob in enumerate(type_pred[0])} disease_probabilities = {skin_disease_labels[i]: float(prob * 100) for i, prob in enumerate(disease_pred[0])} return { 'skin_type': { 'prediction': skin_type, 'confidence': round(type_confidence, 2), 'probabilities': {k: round(v, 2) for k, v in type_probabilities.items()} }, 'skin_disease': { 'prediction': skin_disease, 'confidence': round(disease_confidence, 2), 'probabilities': {k: round(v, 2) for k, v in disease_probabilities.items()} }, 'recommendations': { 'skin_type': skin_type_recommendations[skin_type], 'skin_disease': disease_treatment[skin_disease] } } def get_ai_analysis(analysis_results): """Obtenir une analyse détaillée via Groq LLM""" headers = { "Content-Type": "application/json", "Authorization": f"Bearer {GROQ_API_KEY}" } prompt = f"""Analyse ces résultats dermatologiques et fournis une réponse structurée avec exactement les 3 sections suivantes, séparées par [SECTION]: Type de peau: {analysis_results['skin_type']['prediction']} (confiance: {analysis_results['skin_type']['confidence']}%) Condition détectée: {analysis_results['skin_disease']['prediction']} (confiance: {analysis_results['skin_disease']['confidence']}%) Distributions des probabilités: Types de peau: {analysis_results['skin_type']['probabilities']} Conditions: {analysis_results['skin_disease']['probabilities']} Réponds en utilisant exactement ce format: [SECTION] Interprétation détaillée des résultats dermatologiques [SECTION] Conseils supplémentaires personnalisés [SECTION] Recommandations pour une routine quotidienne""" try: response = requests.post( "https://api.groq.com/openai/v1/chat/completions", headers=headers, json={ "model": "llama-3.3-70b-versatile", "messages": [{ "role": "user", "content": prompt }] } ) if response.status_code == 200: content = response.json()["choices"][0]["message"]["content"] # Diviser la réponse en sections sections = content.split("[SECTION]") sections = [s.strip() for s in sections if s.strip()] # Nettoyer les sections # Structurer la réponse if len(sections) >= 3: return { "interpretation": sections[0], "conseils": sections[1], "routine": sections[2] } else: return { "interpretation": "Analyse non disponible", "conseils": "Conseils non disponibles", "routine": "Routine non disponible" } else: return { "interpretation": "Analyse non disponible", "conseils": "Conseils non disponibles", "routine": "Routine non disponible" } except Exception as e: print(f"Erreur lors de l'appel à Groq: {str(e)}") return { "interpretation": "Erreur lors de l'analyse", "conseils": "Conseils non disponibles", "routine": "Routine non disponible" } @app.route('/') @check_origin def home(): return jsonify({ "message": "GlamFlow AI API - Services disponibles:", "endpoints": [ "/predict - Analyse complète de la peau (type et maladie)", "/health - Vérification de l'état des modèles", "/preload - Préchargement des modèles" ] }), 200 @app.route('/predict', methods=['POST']) @check_origin def predict(): if 'file' not in request.files: return jsonify({'error': 'Aucun fichier fourni'}), 400 file = request.files['file'] if file.filename == '': return jsonify({'error': 'Aucun fichier sélectionné'}), 400 if file: try: # Lire l'image et la convertir en format compatible image_bytes = file.read() image = Image.open(io.BytesIO(image_bytes)).convert("RGB") image_array = np.array(image) # Vérifier la présence d'un visage if not detect_face(image_array): return jsonify({ 'error': 'Aucun visage n\'est détecté dans l\'image. Veuillez choisir une photo claire de votre visage pour effectuer l\'analyse.' }), 400 # Analyser l'image avec les deux modèles results = predict_skin_condition(image_array) # Obtenir l'analyse IA supplémentaire ai_analysis = get_ai_analysis(results) results['ai_analysis'] = ai_analysis return jsonify(results), 200 except Exception as e: return jsonify({'error': str(e)}), 500 @app.route('/preload', methods=['GET']) @check_origin def preload_models(): """Précharge les modèles pour éviter les délais lors de la première prédiction""" return jsonify({'status': 'Models preloaded successfully'}), 200 @app.route('/health', methods=['GET']) @check_origin def health_check(): models_loaded = { 'skin_type_model': True, 'skin_disease_model': True } return jsonify({ 'status': 'healthy', 'models': models_loaded }), 200 if __name__ == '__main__': app.run(host='0.0.0.0', port=5000, debug=True)