Upload 2 files

app.py

@@ -0,0 +1,244 @@
+import gradio as gr
+import numpy as np
+import cv2
+import pandas as pd
+from skimage import measure, morphology
+import tempfile
+
+MAX_SIDE = 2048
+
+def downscale_bgr(img):
+    h, w = img.shape[:2]
+    scale = min(1.0, MAX_SIDE / max(h, w))
+    if scale < 1.0:
+        img = cv2.resize(img, (int(w * scale), int(h * scale)), interpolation=cv2.INTER_AREA)
+    return img, scale
+
+def normalize_angle(angle, size_w, size_h):
+    a = angle
+    if size_w < size_h:
+        a += 90.0
+    a = ((a % 180.0) + 180.0) % 180.0
+    return a
+
+def detect_reference(img_bgr, mode, ref_size_mm):
+    h, w = img_bgr.shape[:2]
+    roi_w = int(w * 0.25)
+    roi_h = int(h * 0.25)
+    roi = img_bgr[0:roi_h, 0:roi_w]
+    gray = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY)
+    gray = cv2.medianBlur(gray, 5)
+    px_per_mm = None
+    center = None
+    ref_type = None
+    if mode in ["auto", "coin"]:
+        circles = cv2.HoughCircles(gray, cv2.HOUGH_GRADIENT, dp=1.2, minDist=20, param1=120, param2=35, minRadius=8, maxRadius=min(roi_w, roi_h) // 2)
+        if circles is not None and len(circles) > 0:
+            c = circles[0][0]
+            r = float(c[2])
+            d_px = 2.0 * r
+            d_mm = ref_size_mm if ref_size_mm and ref_size_mm > 0 else 25.0
+            px_per_mm = d_px / d_mm
+            center = (int(c[0]), int(c[1]))
+            ref_type = "coin"
+    if px_per_mm is None and mode in ["auto", "square"]:
+        edges = cv2.Canny(gray, 80, 160)
+        cnts, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        best = None
+        best_score = 0.0
+        for cnt in cnts:
+            x, y, ww, hh = cv2.boundingRect(cnt)
+            area = ww * hh
+            if area < 225:
+                continue
+            score = min(ww, hh) / max(ww, hh)
+            if score > best_score:
+                best_score = score
+                best = (x, y, ww, hh)
+        if best is not None and best_score > 0.6:
+            ww, hh = best[2], best[3]
+            s_px = float(max(ww, hh))
+            s_mm = ref_size_mm if ref_size_mm and ref_size_mm > 0 else 20.0
+            px_per_mm = s_px / s_mm
+            center = (best[0] + ww // 2, best[1] + hh // 2)
+            ref_type = "square"
+    if px_per_mm is None:
+        px_per_mm = 5.0 if ref_size_mm and ref_size_mm < 10 else 3.0
+    return px_per_mm, center, ref_type
+
+def build_mask_hsv(img_bgr, sample_type, hsv_low_h, hsv_high_h, color_tol):
+    hsv = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2HSV)
+    h = hsv[:, :, 0]
+    s = hsv[:, :, 1]
+    v = hsv[:, :, 2]
+    if sample_type == "leaves":
+        low_h = int(max(0, hsv_low_h))
+        high_h = int(min(179, hsv_high_h))
+        mask_h = cv2.inRange(h, low_h, high_h)
+        mask_s = cv2.inRange(s, 30, 255)
+        mask_v = cv2.inRange(v, 30, 255)
+        mask = cv2.bitwise_and(mask_h, cv2.bitwise_and(mask_s, mask_v))
+    else:
+        mask_s = cv2.inRange(s, 20, 255)
+        mask_v = cv2.inRange(v, 20, 255)
+        mask = cv2.bitwise_and(mask_s, mask_v)
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
+    mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
+    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
+    return mask
+
+def segment(img_bgr, sample_type, hsv_low_h, hsv_high_h, color_tol, min_area_px, max_area_px):
+    mask = build_mask_hsv(img_bgr, sample_type, hsv_low_h, hsv_high_h, color_tol)
+    cnts, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    comps = []
+    for cnt in cnts:
+        area_px = cv2.contourArea(cnt)
+        if area_px < float(min_area_px) or area_px > float(max_area_px):
+            continue
+        rect = cv2.minAreaRect(cnt)
+        box = cv2.boxPoints(rect)
+        box = np.int0(box)
+        m = cv2.moments(cnt)
+        if m["m00"] == 0:
+            cx, cy = 0, 0
+        else:
+            cx = int(m["m10"] / m["m00"])
+            cy = int(m["m01"] / m["m00"])
+        peri = cv2.arcLength(cnt, True)
+        circ = (4.0 * np.pi * area_px) / (peri * peri + 1e-6)
+        hull = cv2.convexHull(cnt)
+        hull_area = cv2.contourArea(hull)
+        solidity = area_px / (hull_area + 1e-6)
+        angle = normalize_angle(rect[2], rect[1][0], rect[1][1])
+        comps.append({
+            "contour": cnt,
+            "rect": rect,
+            "box": box,
+            "area_px": area_px,
+            "peri_px": peri,
+            "center": (cx, cy),
+            "angle": angle,
+            "solidity": solidity
+        })
+    return comps
+
+def compute_color_metrics(img_bgr, mask):
+    mean_bgr = cv2.mean(img_bgr, mask=mask)
+    mean_b, mean_g, mean_r = mean_bgr[0], mean_bgr[1], mean_bgr[2]
+    rgb = np.array([[[mean_r, mean_g, mean_b]]], dtype=np.uint8)
+    hsv = cv2.cvtColor(rgb, cv2.COLOR_RGB2HSV)[0, 0]
+    h, s, v = int(hsv[0]), int(hsv[1]), int(hsv[2])
+    denom = (mean_r + mean_g + mean_b + 1e-6)
+    green_index = (2.0 * mean_g - mean_r - mean_b) / denom
+    brown_index = (mean_r - mean_b) / denom
+    return mean_r, mean_g, mean_b, h, s, v, green_index, brown_index
+
+def compute_metrics(img_bgr, comps, px_per_mm):
+    rows = []
+    for i, c in enumerate(comps, start=1):
+        w_px = max(c["rect"][1][0], c["rect"][1][1])
+        h_px = min(c["rect"][1][0], c["rect"][1][1])
+        length_mm = w_px / px_per_mm
+        width_mm = h_px / px_per_mm
+        area_mm2 = c["area_px"] / (px_per_mm * px_per_mm)
+        perimeter_mm = c["peri_px"] / px_per_mm
+        aspect_ratio = length_mm / (width_mm + 1e-6)
+        circularity = (4.0 * np.pi * area_mm2) / (perimeter_mm * perimeter_mm + 1e-6)
+        mask_single = np.zeros(img_bgr.shape[:2], dtype=np.uint8)
+        cv2.drawContours(mask_single, [c["contour"]], -1, 255, thickness=-1)
+        mean_r, mean_g, mean_b, h, s, v, gi, bi = compute_color_metrics(img_bgr, mask_single)
+        rows.append({
+            "label": f"s{i}",
+            "centerX_px": int(c["center"][0]),
+            "centerY_px": int(c["center"][1]),
+            "length_mm": round(length_mm, 2),
+            "width_mm": round(width_mm, 2),
+            "area_mm2": round(area_mm2, 2),
+            "perimeter_mm": round(perimeter_mm, 2),
+            "aspect_ratio": round(aspect_ratio, 2),
+            "circularity": round(circularity, 3),
+            "angle_deg": round(float(c["angle"]), 1),
+            "meanR": int(round(mean_r)),
+            "meanG": int(round(mean_g)),
+            "meanB": int(round(mean_b)),
+            "hue": h,
+            "saturation": s,
+            "value": v,
+            "greenIndex": round(float(gi), 3),
+            "brownIndex": round(float(bi), 3)
+        })
+    return pd.DataFrame(rows)
+
+def render_overlay(img_bgr, px_per_mm, ref, comps, df):
+    out = img_bgr.copy()
+    if ref and ref[0] is not None:
+        cx, cy = ref[0]
+        cv2.circle(out, (int(cx), int(cy)), 16, (0, 0, 0), -1)
+        cv2.putText(out, "s0", (int(cx) + 20, int(cy) - 6), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)
+    for i, c in enumerate(comps, start=1):
+        box = c["box"]
+        cv2.drawContours(out, [box], 0, (0, 0, 0), 2)
+        cv2.drawContours(out, [c["contour"]], -1, (0, 0, 0), 1)
+        cx, cy = c["center"][0], c["center"][1]
+        cv2.circle(out, (int(cx), int(cy)), 14, (0, 0, 0), -1)
+        cv2.putText(out, f"s{i}", (int(cx) - 8, int(cy) + 5), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA)
+        row = df.iloc[i - 1]
+        tx = int(cx) + 22
+        ty = int(cy) - 12
+        cv2.putText(out, f"L:{row['length_mm']}mm", (tx, ty), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)
+        cv2.putText(out, f"W:{row['width_mm']}mm", (tx, ty + 12), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)
+        cv2.putText(out, f"A:{row['area_mm2']}mm2", (tx, ty + 24), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)
+        cv2.putText(out, f"θ:{row['angle_deg']}°", (tx, ty + 36), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)
+    return cv2.cvtColor(out, cv2.COLOR_BGR2RGB)
+
+def analyze(image, sample_type, expected_count, ref_mode, ref_size_mm, min_area_px, max_area_px, color_tol, hsv_low_h, hsv_high_h):
+    if image is None:
+        return None, pd.DataFrame(), None, []
+    img_rgb = np.array(image)
+    img_bgr = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2BGR)
+    img_bgr, scale = downscale_bgr(img_bgr)
+    px_per_mm, ref_center, ref_type = detect_reference(img_bgr, ref_mode, ref_size_mm)
+    comps = segment(img_bgr, sample_type, hsv_low_h, hsv_high_h, color_tol, min_area_px, max_area_px)
+    if sample_type == "leaves":
+        comps.sort(key=lambda c: c["center"][0])
+    else:
+        comps.sort(key=lambda c: c["center"][1] * 0.3 + c["center"][0] * 0.7)
+    if expected_count and expected_count > 0:
+        comps = comps[:int(expected_count)]
+    df = compute_metrics(img_bgr, comps, px_per_mm)
+    overlay = render_overlay(img_bgr.copy(), px_per_mm, (ref_center, ref_type), comps, df)
+    csv = df.to_csv(index=False)
+    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".csv")
+    tmp.write(csv.encode("utf-8"))
+    tmp.close()
+    js = df.to_dict(orient="records")
+    return overlay, df, tmp.name, js
+
+with gr.Blocks(theme=gr.themes.Default()) as demo:
+    gr.Markdown("# Biological Sample Quantifier (Leaves / Seeds)")
+    with gr.Row():
+        with gr.Column(scale=1):
+            image = gr.Image(type="numpy", label="Upload image")
+            sample_type = gr.Radio(["leaves", "seeds-grains"], value="leaves", label="Sample type")
+            expected = gr.Slider(1, 500, value=5, step=1, label="Expected count")
+            ref_mode = gr.Radio(["auto", "coin", "square"], value="auto", label="Reference mode")
+            ref_size = gr.Slider(1, 100, value=25.0, step=0.1, label="Reference size (mm)")
+            min_area = gr.Slider(10, 5000, value=500, step=10, label="Min area (px²)")
+            max_area = gr.Slider(1000, 200000, value=50000, step=1000, label="Max area (px²)")
+            color_tol = gr.Slider(5, 100, value=40, step=1, label="Color tolerance")
+            hsv_low = gr.Slider(0, 179, value=35, step=1, label="HSV H lower (leaves)")
+            hsv_high = gr.Slider(0, 179, value=85, step=1, label="HSV H upper (leaves)")
+            run = gr.Button("Analyze")
+            reset = gr.Button("Reset")
+        with gr.Column(scale=2):
+            overlay = gr.Image(label="Annotated")
+            table = gr.Dataframe(label="Metrics", wrap=True)
+            csv_out = gr.File(label="CSV export")
+            json_out = gr.JSON(label="JSON preview")
+    def _analyze(image, sample_type, expected, ref_mode, ref_size, min_area, max_area, color_tol, hsv_low, hsv_high):
+        return analyze(image, sample_type, expected, ref_mode, ref_size, min_area, max_area, color_tol, hsv_low, hsv_high)
+    run.click(_analyze, [image, sample_type, expected, ref_mode, ref_size, min_area, max_area, color_tol, hsv_low, hsv_high], [overlay, table, csv_out, json_out])
+    reset.click(lambda: (None, pd.DataFrame(), None, []), None, [overlay, table, csv_out, json_out])
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,6 @@
+gradio>=4.34.0
+opencv-python-headless>=4.10.0.84
+numpy>=1.26.4
+pillow>=10.4.0
+scikit-image>=0.24.0
+pandas>=2.2.2