Update app.py

app.py

@@ -27,7 +27,6 @@ models = {name: YOLO(path) for name, path in model_paths.items()}
 mp_face_mesh = mp.solutions.face_mesh
 face_mesh = mp_face_mesh.FaceMesh(static_image_mode=True)
 
-
 # -------------------- SKIN TYPE DETECTOR --------------------
 def detect_skin_type_from_image(img):
     img = cv2.resize(img, (400, 400))
@@ -77,7 +76,6 @@ def detect_skin_type_from_image(img):
 
     return percentages, f"{final_type} ({final_value}%)"
 
-
 # -------------------- HELPERS --------------------
 def run_model(model_name, model, img, face_polygon, face_area):
     if model_name == "pores2":
@@ -119,7 +117,6 @@ def run_model(model_name, model, img, face_polygon, face_area):
 
     return skin_percentages
 
-
 def normalize_and_merge(percentages):
     normalized = {}
     for cls_name, value in percentages.items():
@@ -142,98 +139,72 @@ def normalize_and_merge(percentages):
 
     return normalized
 
-
 # -------------------- ROUTES --------------------
 @app.route("/", methods=["GET"])
 def home():
     return jsonify({
         "message": "✅ Skin API is running",
-        "usage": "POST exactly 3 images (form-data key 'file') to /analyze"
+        "usage": "POST one image (form-data key 'file') to /analyze"
     })
 
-
 @app.route("/analyze", methods=["POST"])
 def analyze():
     try:
         files = request.files.getlist("file")
-        if not files or len(files) != 3:
+        if not files or len(files) != 1:
             return jsonify({
                 "success": False,
                 "analysis": [],
-                "error": "You must upload exactly 3 images."
+                "error": "You must upload exactly 1 image."
             }), 400
 
-        all_model_results = []
-        all_skin_types = []
-
-        for file in files:
-            file_bytes = np.frombuffer(file.read(), np.uint8)
-            img = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)
-            if img is None:
-                return jsonify({"success": False, "analysis": [], "error": "Invalid image."}), 400
-
-            img_h, img_w = img.shape[:2]
-
-            rgb_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-            result = face_mesh.process(rgb_img)
-
-            face_polygon = None
-            face_area = 0
-            if result.multi_face_landmarks:
-                for landmarks in result.multi_face_landmarks:
-                    points = np.array([[int(lm.x * img_w), int(lm.y * img_h)] for lm in landmarks.landmark])
-                    hull = cv2.convexHull(points)
-                    face_area = cv2.contourArea(hull)
-                    face_polygon = Polygon(hull.reshape(-1, 2))
-                    break
-            else:
-                return jsonify({"success": False, "analysis": [], "error": "No face detected."}), 400
-
-            combined_percentages = {}
-            with ThreadPoolExecutor() as executor:
-                futures = {
-                    executor.submit(run_model, model_name, model, img, face_polygon, face_area): model_name
-                    for model_name, model in models.items()
-                }
-                for future in as_completed(futures):
-                    skin_percentages = future.result()
-                    combined_percentages.update(skin_percentages)
-
-            final_percentages = normalize_and_merge(combined_percentages)
-
-            # MERGE WRINKLES + FOREHEAD
-            wrinkle_value = final_percentages.get("wrinkles", 0.0) + final_percentages.get("forehead", 0.0)
-            final_percentages["wrinkles"] = round(wrinkle_value, 2)
-            if "forehead" in final_percentages:
-                final_percentages.pop("forehead")
-
-            all_model_results.append(final_percentages)
-
-            # Skin type percentages
-            skin_type_percentages, _ = detect_skin_type_from_image(img)
-            all_skin_types.append(skin_type_percentages)
-
-        # -------------------- AVERAGE RESULTS --------------------
-        avg_results = defaultdict(float)
-        for res in all_model_results:
-            for k, v in res.items():
-                avg_results[k] += v
-        for k in avg_results:
-            avg_results[k] = round(avg_results[k] / 3, 2)
-
-        # -------------------- AVERAGE SKIN TYPE --------------------
-        avg_skin_type_percentages = defaultdict(float)
-        for st in all_skin_types:
-            for k, v in st.items():
-                avg_skin_type_percentages[k] += v
-        for k in avg_skin_type_percentages:
-            avg_skin_type_percentages[k] = round(avg_skin_type_percentages[k] / 3, 2)
-
-        final_skin_type = max(avg_skin_type_percentages, key=avg_skin_type_percentages.get)
-        final_skin_type_str = f"{final_skin_type} ({avg_skin_type_percentages[final_skin_type]}%)"
-
-        # -------------------- FORMAT RESPONSE --------------------
-        analysis_list = [f"{cls_name.upper()}: {value}%" for cls_name, value in avg_results.items()]
+        file = files[0]
+        file_bytes = np.frombuffer(file.read(), np.uint8)
+        img = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)
+        if img is None:
+            return jsonify({"success": False, "analysis": [], "error": "Invalid image."}), 400
+
+        img_h, img_w = img.shape[:2]
+        rgb_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+        result = face_mesh.process(rgb_img)
+
+        if not result.multi_face_landmarks:
+            return jsonify({"success": False, "analysis": [], "error": "No face detected."}), 400
+
+        # Face polygon
+        for landmarks in result.multi_face_landmarks:
+            points = np.array([[int(lm.x * img_w), int(lm.y * img_h)] for lm in landmarks.landmark])
+            hull = cv2.convexHull(points)
+            face_area = cv2.contourArea(hull)
+            face_polygon = Polygon(hull.reshape(-1, 2))
+            break
+
+        # Run YOLO models in parallel
+        combined_percentages = {}
+        with ThreadPoolExecutor() as executor:
+            futures = {
+                executor.submit(run_model, model_name, model, img, face_polygon, face_area): model_name
+                for model_name, model in models.items()
+            }
+            for future in as_completed(futures):
+                skin_percentages = future.result()
+                combined_percentages.update(skin_percentages)
+
+        final_percentages = normalize_and_merge(combined_percentages)
+
+        # Merge wrinkles + forehead
+        wrinkle_value = final_percentages.get("wrinkles", 0.0) + final_percentages.get("forehead", 0.0)
+        final_percentages["wrinkles"] = round(wrinkle_value, 2)
+        if "forehead" in final_percentages:
+            final_percentages.pop("forehead")
+
+        # Skin type
+        skin_type_percentages, _ = detect_skin_type_from_image(img)
+        final_skin_type = max(skin_type_percentages, key=skin_type_percentages.get)
+        final_skin_type_str = f"{final_skin_type} ({skin_type_percentages[final_skin_type]}%)"
+
+        # Format response
+        analysis_list = [f"{cls_name.upper()}: {value}%" for cls_name, value in final_percentages.items()]
         analysis_list.append(f"SKIN TYPE: {final_skin_type_str}")
 
         return jsonify({"success": True, "analysis": ["\n".join(analysis_list)]})
@@ -241,7 +212,6 @@ def analyze():
     except Exception as e:
         return jsonify({"success": False, "analysis": [], "error": str(e)}), 500
 
-
 # -------------------- RUN --------------------
 if __name__ == "__main__":
     app.run(host="0.0.0.0", port=7860)