Update app.py

app.py

@@ -1,5 +1,4 @@
-from fastapi import FastAPI, UploadFile, File, HTTPException
-from fastapi.responses import JSONResponse
+from flask import Flask, request, jsonify
 from ultralytics import YOLO
 import cv2
 import numpy as np
@@ -8,57 +7,67 @@ from shapely.ops import unary_union
 import mediapipe as mp
 from collections import defaultdict
 
-app = FastAPI(title="Face Skin Percentage API")
+# -------------------- CONFIG --------------------
+skin_model_path = "pores.pt"  # replace with your model in HF Space
+conf_threshold = 0.05
+imgsz = 1024
 
-# -------------------- LOAD MODELS --------------------
-skin_model_path = "pores.pt"  # Your YOLO model path
+# -------------------- INIT --------------------
+app = Flask(__name__)
 skin_model = YOLO(skin_model_path)
-mp_face_mesh = mp.solutions.face_mesh.FaceMesh(static_image_mode=True)
+mp_face_mesh = mp.solutions.face_mesh
+face_mesh = mp_face_mesh.FaceMesh(static_image_mode=True)
 
-# -------------------- HOME ROUTE --------------------
-@app.get("/")
+# -------------------- ROUTES --------------------
+@app.route("/", methods=["GET"])
 def home():
-    return {"message": "✅ Skin API is running", 
-            "usage": "POST an image (form-data key 'file') to /analyze"}
+    return jsonify({
+        "message": "✅ Skin API is running",
+        "usage": "POST an image (form-data key 'file') to /analyze"
+    })
 
-# -------------------- ANALYZE ROUTE --------------------
-@app.post("/analyze")
-async def analyze(file: UploadFile = File(...)):
-    if not file:
-        raise HTTPException(status_code=400, detail="No file uploaded")
+@app.route("/analyze", methods=["POST"])
+def analyze():
+    if "file" not in request.files:
+        return jsonify({"success": False, "analysis": []}), 400
 
-    # Read image bytes and convert to OpenCV image
-    contents = await file.read()
-    np_arr = np.frombuffer(contents, np.uint8)
-    img = cv2.imdecode(np_arr, cv2.IMREAD_COLOR)
+    file = request.files["file"]
+    file_bytes = np.frombuffer(file.read(), np.uint8)
+    img = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)
     if img is None:
-        raise HTTPException(status_code=400, detail="Invalid image file")
+        return jsonify({"success": False, "error": "Invalid image"}), 400
 
     img_h, img_w = img.shape[:2]
 
-    # -------------------- STEP 1: Detect face --------------------
+    # -------------------- FACE DETECTION --------------------
     rgb_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-    result = mp_face_mesh.process(rgb_img)
+    result = face_mesh.process(rgb_img)
 
-    face_area = 0
     face_polygon = None
+    face_area = 0
+
     if result.multi_face_landmarks:
-        for facial_landmarks in result.multi_face_landmarks:
-            points = [[int(lm.x * img_w), int(lm.y * img_h)] for lm in facial_landmarks.landmark]
-            hull = cv2.convexHull(np.array(points, dtype=np.int32))
+        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  # only first face
     else:
-        return JSONResponse({"success": False, "message": "No face detected", "percentages": {}})
+        return jsonify({"success": False, "error": "No face detected"}), 400
 
-    # -------------------- STEP 2: Run YOLO skin detection --------------------
-    skin_results = skin_model(img)
-    boxes_xy = skin_results[0].boxes.xyxy.cpu().numpy()
-    boxes_cls = skin_results[0].boxes.cls.cpu().numpy().astype(int)
+    # -------------------- SKIN DETECTION --------------------
+    results = skin_model(img, conf=conf_threshold, imgsz=imgsz)
+    boxes_xy = results[0].boxes.xyxy.cpu().numpy()
+    boxes_conf = results[0].boxes.conf.cpu().numpy()
+    boxes_cls = results[0].boxes.cls.cpu().numpy().astype(int)
 
     class_polygons = defaultdict(list)
-    for xy, cls_id in zip(boxes_xy, boxes_cls):
+
+    for i, (xy, cls_id) in enumerate(zip(boxes_xy, boxes_cls)):
         x1, y1, x2, y2 = xy.astype(int)
         det_poly = shapely_box(x1, y1, x2, y2)
         if face_polygon.intersects(det_poly):
@@ -66,15 +75,16 @@ async def analyze(file: UploadFile = File(...)):
             if intersection.area > 0:
                 class_polygons[cls_id].append(intersection)
 
-    # -------------------- STEP 3: Calculate percentages --------------------
+    # -------------------- CALCULATE PERCENTAGES --------------------
     skin_percentages = {}
-    for cls_id, class_name in skin_model.names.items():
-        polys = class_polygons.get(cls_id, [])
-        if polys:
-            union_poly = unary_union(polys)
-            percentage = (union_poly.area / face_area) * 100 if face_area > 0 else 0.0
-        else:
-            percentage = 0.0
-        skin_percentages[class_name] = round(percentage, 2)
+    for cls_id, polys in class_polygons.items():
+        union_poly = unary_union(polys)
+        pixels = union_poly.area
+        percentage = (pixels / face_area) * 100 if face_area > 0 else 0.0
+        skin_percentages[skin_model.names.get(cls_id, str(cls_id))] = round(percentage, 2)
+
+    return jsonify({"success": True, "percentages": skin_percentages})
 
-    return {"success": True, "percentages": skin_percentages}
+# -------------------- RUN --------------------
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=7860)