Update app.py

app.py

@@ -1,85 +1,100 @@
-import cv2
-import numpy as np
-import math
 import os
-from flask import Flask, request, jsonify
-# 🔥 FORCE CPU MODE FOR MEDIAPIPE (REQUIRED IN CLOUD)
-os.environ["MEDIAPIPE_DISABLE_GPU"] = "1"
 os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
 os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
 
-from cvzone.HandTrackingModule import HandDetector
+import cv2
+import numpy as np
+import math
+from flask import Flask, request, jsonify
+import mediapipe as mp
 from cvzone.ClassificationModule import Classifier
 
-os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
+# ---------------- CONFIG ----------------
 
 MODEL_PATH = "Model_old/keras_model.h5"
 LABELS_PATH = "Model_old/labels.txt"
-
-CONFIDENCE_THRESHOLD = 0.5
 IMG_SIZE = 300
 OFFSET = 20
+CONFIDENCE_THRESHOLD = 0.5
 STABILITY_THRESHOLD = 3
 
+# ---------------- APP ----------------
+
 app = Flask(__name__)
 
-print("Loading hand detector...")
-detector = HandDetector(maxHands=1)
+# ---------------- MEDIAPIPE (CPU ONLY) ----------------
+
+mp_hands = mp.solutions.hands
+hands = mp_hands.Hands(
+    static_image_mode=True,   # 🔥 REQUIRED for cloud
+    max_num_hands=1,
+    model_complexity=0,       # 🔥 CPU-only
+    min_detection_confidence=0.6,
+    min_tracking_confidence=0.6
+)
+
+# ---------------- CLASSIFIER ----------------
 
-print("Loading classifier...")
 classifier = Classifier(MODEL_PATH, LABELS_PATH)
 
 with open(LABELS_PATH) as f:
     labels = [l.strip() for l in f.readlines()]
 
-last_gesture = None
 stable_gesture = None
 stable_count = 0
 
+# ---------------- API ----------------
 
 @app.route("/predict", methods=["POST"])
 def predict():
-    global last_gesture, stable_gesture, stable_count
+    global stable_gesture, stable_count
 
     if "frame" not in request.files:
         return jsonify({"gesture": None, "confidence": 0})
 
     file = request.files["frame"]
-    img_bytes = np.frombuffer(file.read(), np.uint8)
-    frame = cv2.imdecode(img_bytes, cv2.IMREAD_COLOR)
-
+    img = np.frombuffer(file.read(), np.uint8)
+    frame = cv2.imdecode(img, cv2.IMREAD_COLOR)
     frame = cv2.flip(frame, 1)
-    hands, _ = detector.findHands(frame)
 
-    if not hands:
-        stable_count = 0
+    rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+    result = hands.process(rgb)
+
+    if not result.multi_hand_landmarks:
         stable_gesture = None
+        stable_count = 0
         return jsonify({"gesture": None, "confidence": 0})
 
-    hand = hands[0]
-    x, y, w, h = hand["bbox"]
+    h, w, _ = frame.shape
+    lm = result.multi_hand_landmarks[0].landmark
+
+    x_vals = [int(p.x * w) for p in lm]
+    y_vals = [int(p.y * h) for p in lm]
+
+    x, y = min(x_vals), min(y_vals)
+    bw, bh = max(x_vals) - x, max(y_vals) - y
 
     imgWhite = np.ones((IMG_SIZE, IMG_SIZE, 3), np.uint8) * 255
-    imgCrop = frame[max(0, y - OFFSET):y + h + OFFSET,
-                    max(0, x - OFFSET):x + w + OFFSET]
+    imgCrop = frame[max(0, y - OFFSET):y + bh + OFFSET,
+                    max(0, x - OFFSET):x + bw + OFFSET]
 
     if imgCrop.size == 0:
         return jsonify({"gesture": None, "confidence": 0})
 
-    aspectRatio = h / w
+    aspectRatio = bh / bw
 
     if aspectRatio > 1:
-        k = IMG_SIZE / h
-        wCal = math.ceil(k * w)
+        k = IMG_SIZE / bh
+        wCal = math.ceil(k * bw)
         imgResize = cv2.resize(imgCrop, (wCal, IMG_SIZE))
-        wGap = math.ceil((IMG_SIZE - wCal) / 2)
-        imgWhite[:, wGap:wCal + wGap] = imgResize
+        wGap = (IMG_SIZE - wCal) // 2
+        imgWhite[:, wGap:wGap + wCal] = imgResize
     else:
-        k = IMG_SIZE / w
-        hCal = math.ceil(k * h)
+        k = IMG_SIZE / bw
+        hCal = math.ceil(k * bh)
         imgResize = cv2.resize(imgCrop, (IMG_SIZE, hCal))
-        hGap = math.ceil((IMG_SIZE - hCal) / 2)
-        imgWhite[hGap:hCal + hGap, :] = imgResize
+        hGap = (IMG_SIZE - hCal) // 2
+        imgWhite[hGap:hGap + hCal, :] = imgResize
 
     prediction, index = classifier.getPrediction(imgWhite, draw=False)
     confidence = float(prediction[index])
@@ -92,7 +107,6 @@ def predict():
         stable_count = 1
 
     if stable_count >= STABILITY_THRESHOLD and confidence >= CONFIDENCE_THRESHOLD:
-        last_gesture = gesture
         return jsonify({
             "gesture": gesture,
             "confidence": confidence