Update app.py

app.py

@@ -5,98 +5,105 @@ import json
 import urllib.request
 import os
 from PIL import Image
+import tensorflow as tf
 
-# ── Download face landmark TFLite model ──
-MODEL_PATH = "/tmp/face_landmark.tflite"
-DETECTOR_PATH = "/tmp/face_detection.tflite"
+print("TensorFlow version:", tf.__version__)
 
-MODEL_URL    = "https://storage.googleapis.com/mediapipe-assets/face_landmark.tflite"
-DETECTOR_URL = "https://storage.googleapis.com/mediapipe-assets/face_detection_short_range.tflite"
+# ── Download face landmark model ──
+MODEL_PATH = "/tmp/face_landmark.tflite"
+MODEL_URL  = "https://storage.googleapis.com/mediapipe-assets/face_landmark.tflite"
 
-for path, url in [(MODEL_PATH, MODEL_URL), (DETECTOR_PATH, DETECTOR_URL)]:
-    if not os.path.exists(path):
-        print(f"Downloading {url}...")
-        urllib.request.urlretrieve(url, path)
-        print(f"Downloaded to {path}")
+if not os.path.exists(MODEL_PATH):
+    print("Downloading face landmark model...")
+    urllib.request.urlretrieve(MODEL_URL, MODEL_PATH)
+    print("Downloaded.")
 
-# ── Load TFLite interpreter (no OpenGL needed) ──
-import tensorflow as tf
-tflite = tf.lite
-print("Using tensorflow.lite, TF version:", tf.__version__)
-
-detector_interp = tflite.Interpreter(model_path=DETECTOR_PATH)
-detector_interp.allocate_tensors()
-landmark_interp = tflite.Interpreter(model_path=MODEL_PATH)
+landmark_interp = tf.lite.Interpreter(model_path=MODEL_PATH)
 landmark_interp.allocate_tensors()
+lm_in  = landmark_interp.get_input_details()
+lm_out = landmark_interp.get_output_details()
+LM_SIZE = (lm_in[0]['shape'][2], lm_in[0]['shape'][1])  # (W, H)
+print(f"Landmark model input: {lm_in[0]['shape']} → size {LM_SIZE}")
+print(f"Landmark model outputs: {[o['shape'] for o in lm_out]}")
+print("Model ready.")
+
+
+def detect_face_crop(image_pil):
+    """
+    Use OpenCV-based face detection to crop the face region.
+    Falls back to centre-crop if no face found.
+    """
+    try:
+        import cv2
+        img = np.array(image_pil.convert("RGB"))
+        gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
+        h, w = img.shape[:2]
+
+        cascade_path = cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
+        detector = cv2.CascadeClassifier(cascade_path)
+        faces = detector.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=4, minSize=(60,60))
+
+        if len(faces) > 0:
+            # Take largest face
+            faces = sorted(faces, key=lambda f: f[2]*f[3], reverse=True)
+            x, y, fw, fh = faces[0]
+            pad = int(max(fw, fh) * 0.30)
+            x1 = max(0, x - pad)
+            y1 = max(0, y - pad)
+            x2 = min(w, x + fw + pad)
+            y2 = min(h, y + fh + pad)
+            return image_pil.crop((x1, y1, x2, y2)), x1/w, y1/h, x2/w, y2/h
 
-det_in  = detector_interp.get_input_details()
-det_out = detector_interp.get_output_details()
-lm_in   = landmark_interp.get_input_details()
-lm_out  = landmark_interp.get_output_details()
-
-print(f"Detector input shape:  {det_in[0]['shape']}")
-print(f"Landmark input shape:  {lm_in[0]['shape']}")
-print("Models ready.")
-
+    except Exception as e:
+        print(f"CV2 detection failed: {e}")
 
-def preprocess(image_pil, target_size):
-    img = image_pil.convert("RGB").resize(target_size, Image.LANCZOS)
-    arr = np.array(img, dtype=np.float32) / 255.0
-    return arr[np.newaxis, ...]  # (1, H, W, 3)
+    # Fallback: use centre 80% of image
+    img_w, img_h = image_pil.size
+    margin = 0.10
+    return (image_pil.crop((int(img_w*margin), int(img_h*margin),
+                             int(img_w*(1-margin)), int(img_h*(1-margin)))),
+            margin, margin, 1-margin, 1-margin)
 
 
 def analyse_face(image):
     try:
         orig_w, orig_h = image.size
 
-        # ── Step 1: Detect face bounding box ──
-        det_size = (det_in[0]['shape'][2], det_in[0]['shape'][1])  # (W, H)
-        det_input = preprocess(image, det_size)
-        detector_interp.set_tensor(det_in[0]['index'], det_input)
-        detector_interp.invoke()
-
-        # Get detection output — boxes are [y_min, x_min, y_max, x_max] normalised
-        boxes   = detector_interp.get_tensor(det_out[0]['index'])[0]  # (N, 4)
-        scores  = detector_interp.get_tensor(det_out[1]['index'])[0]  # (N,)
-
-        best_idx = int(np.argmax(scores))
-        if scores[best_idx] < 0.4:
-            return json.dumps({"error": "No face detected. Please upload a clear, front-facing photo."})
-
-        y1, x1, y2, x2 = boxes[best_idx]
-        # Add 20% padding
-        pad = 0.20
-        bw  = x2 - x1
-        bh  = y2 - y1
-        x1  = max(0.0, x1 - bw * pad)
-        y1  = max(0.0, y1 - bh * pad)
-        x2  = min(1.0, x2 + bw * pad)
-        y2  = min(1.0, y2 + bh * pad)
-
-        crop = image.crop((int(x1 * orig_w), int(y1 * orig_h),
-                           int(x2 * orig_w), int(y2 * orig_h)))
-        crop_w, crop_h = crop.size
-
-        # ── Step 2: Run landmark model on cropped face ──
-        lm_size   = (lm_in[0]['shape'][2], lm_in[0]['shape'][1])
-        lm_input  = preprocess(crop, lm_size)
-        landmark_interp.set_tensor(lm_in[0]['index'], lm_input)
+        # Step 1: Detect and crop face
+        crop, cx1, cy1, cx2, cy2 = detect_face_crop(image)
+
+        # Step 2: Resize crop to landmark model input size
+        crop_resized = crop.convert("RGB").resize(LM_SIZE, Image.LANCZOS)
+        inp = np.array(crop_resized, dtype=np.float32) / 255.0
+        inp = inp[np.newaxis, ...]  # (1, H, W, 3)
+
+        # Step 3: Run landmark model
+        landmark_interp.set_tensor(lm_in[0]['index'], inp)
         landmark_interp.invoke()
 
-        raw_lm = landmark_interp.get_tensor(lm_out[0]['index'])  # shape varies
-        raw_lm = raw_lm.reshape(-1, 3)  # (468, 3) — x, y, z all in [0, lm_size]
+        # Output 0: landmarks, shape (1, 1404) = 468 points * 3 (x,y,z)
+        raw = landmark_interp.get_tensor(lm_out[0]['index'])
+        raw = raw.reshape(-1, 3)  # (468, 3)
+
+        # Check if face was actually detected (confidence output if available)
+        if len(lm_out) > 1:
+            conf = float(landmark_interp.get_tensor(lm_out[1]['index']).flatten()[0])
+            print(f"Landmark confidence: {conf:.3f}")
+            if conf < 0.3:
+                return json.dumps({"error": "No face detected. Please upload a clear, front-facing photo."})
+
+        lm_w, lm_h = LM_SIZE
 
-        lm_w, lm_h = lm_size
-        # Normalise to [0,1] relative to original image
+        # Denormalise: landmark coords are in pixel space of the crop input
+        # Map back to original image normalised coords
         landmarks = []
-        for pt in raw_lm:
-            # pt in landmark input coords → map to crop → map to original
-            nx = (pt[0] / lm_w) * (x2 - x1) + x1
-            ny = (pt[1] / lm_h) * (y2 - y1) + y1
+        for pt in raw:
+            nx = (pt[0] / lm_w) * (cx2 - cx1) + cx1
+            ny = (pt[1] / lm_h) * (cy2 - cy1) + cy1
             nz = float(pt[2]) / lm_w
             landmarks.append({"x": float(nx), "y": float(ny), "z": nz})
 
-        # ── Score calculation (same geometry as before) ──
+        # ── Score calculation from geometry ──
         h, w = orig_h, orig_w
 
         def dist(a, b):
@@ -105,7 +112,7 @@ def analyse_face(image):
                 ((landmarks[a]['y'] - landmarks[b]['y']) * h) ** 2
             )
 
-        lm = [type('L', (), {'x': p['x'], 'y': p['y'], 'z': p['z']})() for p in landmarks]
+        lm = landmarks
 
         face_ref = dist(33, 263)
         if face_ref < 1:
@@ -115,14 +122,14 @@ def analyse_face(image):
         lower_face_h = dist(168, 152)
         lower_ratio  = lower_face_h / face_height if face_height > 0 else 0.52
 
-        eye_drop_l   = (lm[33].y  - lm[234].y) * h
-        eye_drop_r   = (lm[263].y - lm[454].y) * h
+        eye_drop_l   = (lm[33]['y']  - lm[234]['y']) * h
+        eye_drop_r   = (lm[263]['y'] - lm[454]['y']) * h
         orbital_drop = ((eye_drop_l + eye_drop_r) / 2) / face_ref
 
         nasolabial = ((dist(50, 61) + dist(280, 291)) / 2) / face_ref
 
         forehead_idx = [10,109,67,103,54,21,162,127,234,338,297,332,284,251,389,356,454]
-        z_vals  = [lm[i].z for i in forehead_idx]
+        z_vals  = [lm[i]['z'] for i in forehead_idx]
         z_mean  = sum(z_vals) / len(z_vals)
         z_var   = sum((z - z_mean) ** 2 for z in z_vals) / len(z_vals)
         texture = math.sqrt(abs(z_var)) * 100
@@ -140,14 +147,15 @@ def analyse_face(image):
         cheek_sag  = ((dist(116, 61) + dist(345, 291)) / 2) / face_ref
         elasticity = round(max(1.0, min(9.9, 10 - (cheek_sag - 0.55) * 18 - (age_mid - 18) * 0.10)), 1)
 
-        jaw_pts = [234,93,132,58,172,136,150,149,176,148,152,377,400,378,379,365,397,288,361,323,454]
+        jaw_pts = [234,93,132,58,172,136,150,149,176,148,152,
+                   377,400,378,379,365,397,288,361,323,454]
         jaw_dev = 0.0
         for i in range(1, len(jaw_pts) - 1):
             p, c, n = jaw_pts[i-1], jaw_pts[i], jaw_pts[i+1]
-            ax = (lm[c].x - lm[p].x) * w
-            ay = (lm[c].y - lm[p].y) * h
-            bx = (lm[n].x - lm[c].x) * w
-            by = (lm[n].y - lm[c].y) * h
+            ax = (lm[c]['x'] - lm[p]['x']) * w
+            ay = (lm[c]['y'] - lm[p]['y']) * h
+            bx = (lm[n]['x'] - lm[c]['x']) * w
+            by = (lm[n]['y'] - lm[c]['y']) * h
             jaw_dev += abs(ax * by - ay * bx) / (face_ref ** 2)
         jaw_dev /= len(jaw_pts)
         jawline = round(max(1.0, min(9.9, 10 - jaw_dev * 0.8 - (age_mid - 18) * 0.09)), 1)