Update app.py

app.py

@@ -48,43 +48,33 @@ DEMO_INPUTS = {
 }
 
 # ----------------------------
-# Model loading (kept placeholder)
+# Model stub (kept)
 # ----------------------------
 _model = None
 def load_model(model_path: str = DEFAULT_MODEL_PATH):
     global _model
     if _model is not None:
         return _model
-
-    class DummyModel:
-        pass
-
-    _model = DummyModel()
+    class Dummy: ...
+    _model = Dummy()
     return _model
 
-
 # ----------------------------
 # Helpers
 # ----------------------------
 def _norm_mae(a: np.ndarray, b: np.ndarray) -> float:
-    """Normalized mean absolute error in [0,1] for matching demo images."""
     if a.shape != b.shape:
         b = cv2.resize(b, (a.shape[1], a.shape[0]), interpolation=cv2.INTER_AREA)
-    a = cv2.cvtColor(a, cv2.COLOR_BGR2GRAY) if a.ndim == 3 else a
-    b = cv2.cvtColor(b, cv2.COLOR_BGR2GRAY) if b.ndim == 3 else b
+    if a.ndim == 3: a = cv2.cvtColor(a, cv2.COLOR_BGR2GRAY)
+    if b.ndim == 3: b = cv2.cvtColor(b, cv2.COLOR_BGR2GRAY)
     a = a.astype(np.float32) / 255.0
     b = b.astype(np.float32) / 255.0
     return float(np.mean(np.abs(a - b)))
 
-
 def match_demo_image(upload_bgr: np.ndarray) -> str | None:
-    """
-    Return 'input_1.png' or 'input_2.png' if the uploaded image matches,
-    else None. Uses simple normalized MAE with resizing.
-    """
     best_name, best_score = None, 1.0
     for fname in DEMO_INPUTS.keys():
-        if not os.path.exists(fname):
+        if not os.path.exists(fname): 
             continue
         ref = cv2.imread(fname, cv2.IMREAD_COLOR)
         if ref is None:
@@ -92,11 +82,8 @@ def match_demo_image(upload_bgr: np.ndarray) -> str | None:
         score = _norm_mae(upload_bgr, ref)
         if score < best_score:
             best_score, best_name = score, fname
-
-    # Loose threshold to cope with minor metadata/encoding differences
     return best_name if best_score < 0.01 else None  # ~99% similar
 
-
 def draw_boxes_with_x(image_bgr: np.ndarray, boxes, thickness: int = 3):
     img = image_bgr.copy()
     color = (0, 0, 255)
@@ -105,32 +92,15 @@ def draw_boxes_with_x(image_bgr: np.ndarray, boxes, thickness: int = 3):
         cv2.rectangle(img, (x1, y1), (x2, y2), color, thickness)
         cv2.line(img, (x1, y1), (x2, y2), color, thickness)
         cv2.line(img, (x1, y2), (x2, y1), color, thickness)
-        txt = f"{label}:{score:.2f}"
-        cv2.putText(img, txt, (x1, max(y1 - 6, 0)),
+        cv2.putText(img, f"{label}:{score:.2f}", (x1, max(y1-6,0)),
                     cv2.FONT_HERSHEY_SIMPLEX, 0.6, color, 2, cv2.LINE_AA)
     return img
 
-
-def boxes_from_mask(mask: np.ndarray, min_area: int = 50):
-    mask = (mask > 0).astype(np.uint8)
-    cnts, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    out = []
-    for c in cnts:
-        x, y, w, h = cv2.boundingRect(c)
-        if w * h >= min_area:
-            out.append([x, y, x + w, y + h, 1.0, "defect"])
-    return out
-
-
-def to_csv_file_from_df(df: pd.DataFrame, path="/tmp/defect_report.csv"):
+def to_csv(df: pd.DataFrame, path="/tmp/defect_report.csv"):
     df.to_csv(path, index=False)
     return path, df
 
-
-# ----------------------------
-# Placeholder inference for non-demo images
-# ----------------------------
-def infer_placeholder(image_bgr: np.ndarray, conf: float = 0.25):
+def placeholder_boxes(image_bgr: np.ndarray, conf: float = 0.25):
     gray = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2GRAY)
     e = cv2.Canny(gray, 50, 150)
     cnts, _ = cv2.findContours(e, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
@@ -138,55 +108,51 @@ def infer_placeholder(image_bgr: np.ndarray, conf: float = 0.25):
     h, w = gray.shape[:2]
     for c in cnts:
         x, y, bw, bh = cv2.boundingRect(c)
-        if bw * bh < max(0.0005 * w * h, 150):
+        if bw * bh < max(0.0005 * w * h, 150): 
             continue
-        boxes.append([x, y, x + bw, y + bh, 0.5, "defect"])
+        boxes.append([x, y, x+bw, y+bh, 0.5, "defect"])
         if len(boxes) >= 20:
             break
-    return boxes
-
+    return [b for b in boxes if b[4] >= conf]
 
 # ----------------------------
-# Gradio handler
+# Gradio handler (filepath input)
 # ----------------------------
-def process(image: Image.Image, conf: float, draw_x: bool, min_area: int):
-    if image is None:
-        return None, pd.DataFrame(), None, "Please upload an image."
-
-    # PIL -> BGR
-    img_rgb = np.array(image.convert("RGB"))
-    img_bgr = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2BGR)
-
-    # 1) Check if this is one of our demo images
-    match_name = match_demo_image(img_bgr)
-    if match_name is not None:
-        meta = DEMO_INPUTS[match_name]
-        # Use the pre-rendered annotated image
-        vis_pil = Image.open(meta["output_path"]).convert("RGB")
-        df = pd.DataFrame(meta["rows"], columns=["row", "cell", "defect"])
-        csv_path, df = to_csv_file_from_df(df)
-        return vis_pil, df, csv_path, meta["summary"]
-
-    # 2) Otherwise fall back to placeholder detection
-    boxes = infer_placeholder(img_bgr, conf=conf)
-    boxes = [b for b in boxes if b[4] >= conf]
-    vis = draw_boxes_with_x(img_bgr, boxes) if draw_x else img_bgr.copy()
-    vis_rgb = cv2.cvtColor(vis, cv2.COLOR_BGR2RGB)
-    vis_pil = Image.fromarray(vis_rgb)
-
-    # Build a simple table for non-demo case
-    if boxes:
-        df = pd.DataFrame(
-            [{"x1": b[0], "y1": b[1], "x2": b[2], "y2": b[3], "score": b[4], "label": b[5]} for b in boxes]
-        )
-        summary = f"Detected {len(boxes)} defect region(s)."
-    else:
-        df = pd.DataFrame(columns=["x1", "y1", "x2", "y2", "score", "label"])
-        summary = "No defects detected by placeholder."
-
-    csv_path, df = to_csv_file_from_df(df)
-    return vis_pil, df, csv_path, summary
-
+def process(image_path: str, conf: float, draw_x: bool, min_area: int):
+    try:
+        if not image_path or not os.path.exists(image_path):
+            return None, pd.DataFrame(), None, "Please upload an image."
+
+        # read as BGR
+        pil_img = Image.open(image_path).convert("RGB")
+        img_bgr = cv2.cvtColor(np.array(pil_img), cv2.COLOR_RGB2BGR)
+
+        # Demo match?
+        match_name = match_demo_image(img_bgr)
+        if match_name is not None:
+            meta = DEMO_INPUTS[match_name]
+            vis_pil = Image.open(meta["output_path"]).convert("RGB")
+            df = pd.DataFrame(meta["rows"], columns=["row", "cell", "defect"])
+            csv_path, df = to_csv(df)
+            return vis_pil, df, csv_path, meta["summary"]
+
+        # Fallback placeholder
+        boxes = placeholder_boxes(img_bgr, conf=conf)
+        vis = draw_boxes_with_x(img_bgr, boxes) if draw_x else img_bgr.copy()
+        vis_pil = Image.fromarray(cv2.cvtColor(vis, cv2.COLOR_BGR2RGB))
+        if boxes:
+            df = pd.DataFrame(
+                [{"x1": b[0], "y1": b[1], "x2": b[2], "y2": b[3], "score": b[4], "label": b[5]} for b in boxes]
+            )
+            summary = f"Detected {len(boxes)} region(s) by placeholder."
+        else:
+            df = pd.DataFrame(columns=["x1","y1","x2","y2","score","label"])
+            summary = "No defects detected by placeholder."
+        csv_path, df = to_csv(df)
+        return vis_pil, df, csv_path, summary
+    except Exception as e:
+        # surface errors to UI instead of crashing
+        return None, pd.DataFrame(), None, f"Error: {type(e).__name__}: {e}"
 
 # ----------------------------
 # UI
@@ -194,16 +160,16 @@ def process(image: Image.Image, conf: float, draw_x: bool, min_area: int):
 with gr.Blocks(title="AI-Driven EL Defect Recognition") as demo:
     gr.Markdown(
         "## AI-Driven Defect Recognition in EL Images\n"
-        "Upload an electroluminescence (EL) image. For the demo, uploading **input_1.png** "
-        "or **input_2.png** will return your predefined annotated results and a CSV.\n"
-        "For other images, a lightweight placeholder detector runs."
+        "Demo: uploading **input_1.png** or **input_2.png** returns predefined annotated results and CSV.\n"
+        "Other images run a lightweight placeholder."
     )
     with gr.Row():
         with gr.Column():
-            inp = gr.Image(type="pil", label="Upload EL image")
+            # Use filepath to avoid large base64 uploads
+            inp = gr.Image(type="filepath", label="Upload EL image")
             conf = gr.Slider(0.0, 1.0, value=0.25, step=0.01, label="Confidence threshold")
             draw_x = gr.Checkbox(True, label="Draw red box + X (non-demo only)")
-            min_area = gr.Slider(10, 5000, value=120, step=10, label="Min defect area (pixels, for masks)")
+            min_area = gr.Slider(10, 5000, value=120, step=10, label="Min defect area (for masks)")
             run_btn = gr.Button("Run inference", variant="primary")
         with gr.Column():
             out_img = gr.Image(type="pil", label="Annotated output")
@@ -216,4 +182,5 @@ with gr.Blocks(title="AI-Driven EL Defect Recognition") as demo:
 
 if __name__ == "__main__":
     load_model()
-    demo.launch()
+    # Disable SSR to avoid upload edge-cases
+    demo.launch(ssr_mode=False)