result dict

app.py

@@ -9,7 +9,7 @@ from src.detection import load_detector, detect
 from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse
 
-import requests
+# import requests
 
 DETECTOR_MODEL = "models/detector_quantized.onnx"
 LIVENESS_MODEL = "models/best_model_quantized.onnx"
@@ -50,34 +50,101 @@ FIXED_THRESHOLD = 0.4
 FIXED_MARGIN = 5
 FIXED_BBOX_EXPANSION = 1.5
 
+# def predict_liveness(image_in, threshold=FIXED_THRESHOLD, margin=FIXED_MARGIN, bbox_expansion_factor=FIXED_BBOX_EXPANSION):
+#     # image_bgr is a numpy array from gr.Image(type="numpy")
+
+#     # image_in is RGB from Gradio [web:122]
+#     image_bgr = cv2.cvtColor(image_in, cv2.COLOR_RGB2BGR)
+#     if image_bgr is None:
+#         return {"faces": [], "result": spoof_default_result(), "error": "No image provided"}
+
+#     if face_detector is None or liveness_session is None:
+#         return {"faces": [], "result": spoof_default_result(), "error": "Models not loaded"}
+
+#     # threshold -> logit threshold (same as demo.py)
+#     p = max(1e-6, min(1 - 1e-6, float(threshold)))
+#     logit_threshold = float(np.log(p / (1 - p)))
+
+#     # detect on resized
+#     det_bgr, scale = resize_for_detection(image_bgr, max_side=1280)
+#     det_rgb = cv2.cvtColor(det_bgr, cv2.COLOR_BGR2RGB)
+#     faces = detect(det_rgb, face_detector, margin=int(margin))
+
+#     if not faces:
+#         return {"faces": [], "result": spoof_default_result()}
+
+#     inv_scale = 1.0 / scale if scale != 0 else 1.0
+#     image_rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB)
+
+#     face_crops = []
+#     meta = []
+#     for face in faces:
+#         det_conf = face.get("confidence", None)
+#         det_conf = round(float(det_conf), 2) if det_conf is not None else None
+
+#         bbox_orig = scale_bbox_to_original(face["bbox"], inv_scale)
+#         x, y, w, h = bbox_orig["x"], bbox_orig["y"], bbox_orig["width"], bbox_orig["height"]
+
+#         try:
+#             face_crop = crop(image_rgb, (x, y, x + w, y + h), float(bbox_expansion_factor))
+#         except Exception:
+#             continue
+
+#         face_crops.append(face_crop)
+#         meta.append({
+#             "bbox": {"x": int(x), "y": int(y), "width": int(w), "height": int(h)},
+#             "det_confidence": det_conf
+#         })
+
+#     if not face_crops:
+#         return {"faces": [], "result": spoof_default_result()}
+
+#     predictions = infer(face_crops, liveness_session, input_name, model_img_size=128)
+#     if not predictions:
+#         return {"faces": [], "result": spoof_default_result()}
+
+#     out_faces = []
+#     for m, pred in zip(meta, predictions):
+#         r = process_with_logits(pred, logit_threshold)  # already rounded (your change)
+#         out_faces.append({**m, "liveness": r})
+
+#     best = max(out_faces, key=lambda d: (d["det_confidence"] or 0.0))
+#     return best["liveness"]
+
+
 def predict_liveness(image_in, threshold=FIXED_THRESHOLD, margin=FIXED_MARGIN, bbox_expansion_factor=FIXED_BBOX_EXPANSION):
-    # image_bgr is a numpy array from gr.Image(type="numpy")
+    """Return only the liveness result dict under all conditions."""
+    
+    # Convert RGB to BGR
+    if image_in is None:
+        return spoof_default_result()
 
-    # image_in is RGB from Gradio [web:122]
     image_bgr = cv2.cvtColor(image_in, cv2.COLOR_RGB2BGR)
     if image_bgr is None:
-        return {"faces": [], "result": spoof_default_result(), "error": "No image provided"}
+        return spoof_default_result()
 
+    # Ensure models are loaded
     if face_detector is None or liveness_session is None:
-        return {"faces": [], "result": spoof_default_result(), "error": "Models not loaded"}
+        return spoof_default_result()
 
-    # threshold -> logit threshold (same as demo.py)
+    # Convert threshold to logit
     p = max(1e-6, min(1 - 1e-6, float(threshold)))
     logit_threshold = float(np.log(p / (1 - p)))
 
-    # detect on resized
+    # Detect faces
     det_bgr, scale = resize_for_detection(image_bgr, max_side=1280)
     det_rgb = cv2.cvtColor(det_bgr, cv2.COLOR_BGR2RGB)
     faces = detect(det_rgb, face_detector, margin=int(margin))
 
     if not faces:
-        return {"faces": [], "result": spoof_default_result()}
+        return spoof_default_result()
 
     inv_scale = 1.0 / scale if scale != 0 else 1.0
     image_rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB)
 
     face_crops = []
     meta = []
+
     for face in faces:
         det_conf = face.get("confidence", None)
         det_conf = round(float(det_conf), 2) if det_conf is not None else None
@@ -97,19 +164,20 @@ def predict_liveness(image_in, threshold=FIXED_THRESHOLD, margin=FIXED_MARGIN, b
         })
 
     if not face_crops:
-        return {"faces": [], "result": spoof_default_result()}
+        return spoof_default_result()
 
     predictions = infer(face_crops, liveness_session, input_name, model_img_size=128)
     if not predictions:
-        return {"faces": [], "result": spoof_default_result()}
+        return spoof_default_result()
 
     out_faces = []
     for m, pred in zip(meta, predictions):
-        r = process_with_logits(pred, logit_threshold)  # already rounded (your change)
+        r = process_with_logits(pred, logit_threshold)
         out_faces.append({**m, "liveness": r})
 
+    # Return only the liveness dict of the best face
     best = max(out_faces, key=lambda d: (d["det_confidence"] or 0.0))
-    return {"faces": out_faces, "result": best["liveness"]}
+    return best["liveness"]
 
 demo = gr.Interface(
     fn=predict_liveness,
@@ -125,31 +193,5 @@ demo = gr.Interface(
 
 
 
-app: FastAPI = demo.app  # Gradio's FastAPI app
-
-@app.post("/api/predict_liveness_json")
-async def predict_liveness_json(req: Request):
-    payload = await req.json()
-
-    # Expect a public URL (simplest for Postman). Example:
-    # {"image_url": "https://....jpg"}
-    image_url = payload.get("image_url")
-    if not image_url:
-        return JSONResponse(status_code=400, content={"error": "image_url is required"})
-
-    # download -> decode to image -> run predict_liveness
-    
-    r = requests.get(image_url, timeout=20)
-    img_arr = np.frombuffer(r.content, dtype=np.uint8)
-    bgr = cv2.imdecode(img_arr, cv2.IMREAD_COLOR)
-    if bgr is None:
-        return JSONResponse(status_code=400, content={"error": "invalid image_url"})
-
-    # convert BGR->RGB because your predict_liveness expects Gradio-style RGB input
-    rgb = cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB)
-
-    result = predict_liveness(rgb)  # returns dict
-    return JSONResponse(content=result)
-
 if __name__ == "__main__":
     demo.launch()