Update app.py

app.py

@@ -1,116 +1,116 @@
 from flask import Flask, request, jsonify
 from flask_cors import CORS
-import cv2
-import mediapipe as mp
-import numpy as np
-from PIL import Image
-import base64
-import io
+import threading
+import time
 import traceback
+import cv2, mediapipe as mp, numpy as np, base64, io
+from PIL import Image
 
-# Initialize Flask
 app = Flask(__name__)
-CORS(app)  # Allow cross-origin requests (for Flutter or frontend)
+CORS(app)
+
+pose = None
+mp_drawing = None
+mp_pose = mp.solutions.pose
+
+print("🚀 Flask app starting...")
+
+@app.route("/", methods=["GET"])
+def home():
+    return "<h1>✅ Virtual Try-On API is Running (Health OK)</h1>", 200
+
+@app.route("/health", methods=["GET"])
+def health():
+    return jsonify({"status": "ok"}), 200
+
+
+def init_mediapipe():
+    """Load MediaPipe Pose in a background thread."""
+    global pose, mp_drawing
+    try:
+        print("🧠 Initializing MediaPipe Pose (CPU)...")
+        start = time.time()
+        pose = mp_pose.Pose(static_image_mode=False, min_detection_confidence=0.5)
+        mp_drawing = mp.solutions.drawing_utils
+        print("✅ MediaPipe initialized in", round(time.time() - start, 2), "seconds")
+    except Exception as e:
+        print("❌ MediaPipe init error:", e)
+        traceback.print_exc()
+
 
-print("✅ Flask app starting...")
+# Start loading MediaPipe asynchronously
+threading.Thread(target=init_mediapipe, daemon=True).start()
 
-try:
-    # Initialize MediaPipe Pose
-    mp_pose = mp.solutions.pose
-    pose = mp_pose.Pose(static_image_mode=False, min_detection_confidence=0.5)
-    mp_drawing = mp.solutions.drawing_utils
-    print("✅ MediaPipe initialized successfully")
-except Exception as e:
-    print("❌ Error initializing MediaPipe:", e)
-    traceback.print_exc()
 
-# ---------- Helper function ----------
 def overlay_dress(frame, dress, landmarks):
-    """Overlay a dress image on the user's frame based on pose landmarks."""
     if landmarks is not None:
         h, w, _ = frame.shape
 
-        def to_pixel(lm):
-            return int(lm.x * w), int(lm.y * h)
+        def to_pixel(lm): return int(lm.x * w), int(lm.y * h)
 
         left_shoulder = to_pixel(landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value])
         right_shoulder = to_pixel(landmarks[mp_pose.PoseLandmark.RIGHT_SHOULDER.value])
         left_hip = to_pixel(landmarks[mp_pose.PoseLandmark.LEFT_HIP.value])
         right_hip = to_pixel(landmarks[mp_pose.PoseLandmark.RIGHT_HIP.value])
 
-        # Estimate size and position of the dress
         dress_width = int(np.linalg.norm(np.array(left_shoulder) - np.array(right_shoulder)) * 1.8)
-        top_shoulder_y = min(left_shoulder[1], right_shoulder[1])
-        bottom_hip_y = max(left_hip[1], right_hip[1])
-        dress_height = int((bottom_hip_y - top_shoulder_y) * 1.2)
+        top_y = min(left_shoulder[1], right_shoulder[1])
+        bottom_y = max(left_hip[1], right_hip[1])
+        dress_height = int((bottom_y - top_y) * 1.2)
 
         center_x = (left_shoulder[0] + right_shoulder[0]) // 2
         x1 = max(center_x - dress_width // 2, 0)
-        y1 = max(top_shoulder_y - 30, 0)
+        y1 = max(top_y - 30, 0)
         x2 = min(x1 + dress_width, w)
         y2 = min(y1 + dress_height, h)
 
-        # Resize and overlay
         dress_resized = cv2.resize(dress, (x2 - x1, y2 - y1), interpolation=cv2.INTER_AREA)
-        if dress_resized.shape[2] == 4:  # if dress has alpha channel
+        if dress_resized.shape[2] == 4:
             alpha_s = dress_resized[:, :, 3] / 255.0
             alpha_l = 1.0 - alpha_s
             for c in range(3):
                 frame[y1:y2, x1:x2, c] = (
                     alpha_s * dress_resized[:, :, c] + alpha_l * frame[y1:y2, x1:x2, c]
                 )
-
     return frame
 
 
-# ---------- Routes ----------
-@app.route("/", methods=["GET"])
-def home():
-    return "<h1>✅ Flask Virtual Try-On API is Running!</h1>"
-
-
 @app.route("/tryon", methods=["POST"])
 def tryon():
     try:
-        data = request.json.get("image")   # User webcam image in base64
-        dress_data = request.json.get("dress")  # Dress image in base64
+        global pose
+        if pose is None:
+            return jsonify({"error": "Model still loading, please retry in 1–2 minutes"}), 503
+
+        data = request.json.get("image")
+        dress_data = request.json.get("dress")
 
         if not data or not dress_data:
             return jsonify({"error": "Missing image or dress data"}), 400
 
-        # Decode user image
         img_bytes = base64.b64decode(data.split(",")[1])
         img = Image.open(io.BytesIO(img_bytes)).convert("RGB")
         frame = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
 
-        # Decode dress image
         dress_bytes = base64.b64decode(dress_data.split(",")[1])
         dress_img = cv2.imdecode(np.frombuffer(dress_bytes, np.uint8), cv2.IMREAD_UNCHANGED)
 
-        # Pose detection
         results = pose.process(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
         landmarks = results.pose_landmarks.landmark if results.pose_landmarks else None
 
-        # Overlay dress
         frame = overlay_dress(frame, dress_img, landmarks)
-
-        # Draw pose landmarks (optional for debugging)
         if results.pose_landmarks:
             mp_drawing.draw_landmarks(frame, results.pose_landmarks, mp_pose.POSE_CONNECTIONS)
 
-        # Encode output to base64
         _, buffer = cv2.imencode(".jpg", frame)
         img_base64 = "data:image/jpeg;base64," + base64.b64encode(buffer).decode()
 
         return jsonify({"image": img_base64})
-
     except Exception as e:
-        print("❌ Error during /tryon:", e)
+        print("❌ /tryon error:", e)
         traceback.print_exc()
         return jsonify({"error": str(e)}), 500
 
 
-# ---------- Local Debug Mode ----------
 if __name__ == "__main__":
-    # Only for local testing (Gunicorn will handle production)
     app.run(debug=True, host="0.0.0.0", port=5000)