Update app.py

app.py

@@ -59,13 +59,13 @@ def _text_size(draw, text, font):
     return bbox[2] - bbox[0], bbox[3] - bbox[1]
 
 
-# ─── Visual polygon helpers ────────────────────────────────────────────────────
+# ─── Visual polygon helpers ───────────────────────────────────────────────────
 
 def _smooth_polygon(pts_xy, window=11):
     """
     Hanning-weighted circular sliding-window average on polygon vertices.
     pts_xy  : numpy (N, 2) float — already in original image coordinates
-              from results.masks.xy, so NO resize drift whatsoever.
+              from results.masks.xy (no resize, no drift).
     Returns : int32 array (N, 1, 2) for cv2.polylines / fillPoly.
     VISUAL ONLY — backend mask uses raw polygon via _polygon_to_mask().
     """
@@ -74,10 +74,8 @@ def _smooth_polygon(pts_xy, window=11):
     if n < 6:
         return pts.astype(np.int32).reshape(-1, 1, 2)
 
-    # Window must be odd and fit inside the polygon
-    window = min(window | 1, (n - 1) | 1)
-    half   = window // 2
-
+    window  = min(window | 1, (n - 1) | 1)
+    half    = window // 2
     padded  = np.vstack([pts[-half:], pts, pts[:half]])
     weights = np.hanning(window).astype(np.float32)
     weights /= weights.sum()
@@ -90,10 +88,7 @@ def _smooth_polygon(pts_xy, window=11):
 
 
 def _polygon_to_mask(pts_xy, h, w):
-    """
-    Rasterise raw polygon to binary uint8 mask.
-    Used ONLY for backend measurements — never for visuals.
-    """
+    """Rasterise raw polygon → binary uint8 mask. BACKEND / measurements only."""
     mask = np.zeros((h, w), dtype=np.uint8)
     if len(pts_xy) >= 3:
         cv2.fillPoly(mask, [pts_xy.astype(np.int32)], 1)
@@ -103,13 +98,9 @@ def _polygon_to_mask(pts_xy, h, w):
 # ─────────────────────────────────────────────────────────────────────────────
 # STEP 1 — Segmentation + visual output
 #
-# ROOT-CAUSE FIX FOR MISALIGNMENT:
-#   Previously used results.masks.data (low-res tensor) + cv2.resize
-#   which introduces sub-pixel drift at every grain boundary.
-#
-#   Now uses results.masks.xy — ultralytics already maps each polygon
-#   to ORIGINAL image pixel coordinates, so alignment is exact.
-#   No resize, no drift, no displacement.
+# Uses results.masks.xy (polygon in original-image px coords) instead of
+# results.masks.data (low-res tensor + resize) → zero resize drift,
+# pixel-perfect mask alignment.
 # ─────────────────────────────────────────────────────────────────────────────
 def run_segmentation(img_np):
     h, w    = img_np.shape[:2]
@@ -123,7 +114,7 @@ def run_segmentation(img_np):
     all_x1, all_y1, all_x2, all_y2 = w, h, 0, 0
 
     if results.masks is not None:
-        xy_list = results.masks.xy          # list of (N_i, 2) arrays, original coords
+        xy_list = results.masks.xy      # list of (N_i, 2) float arrays, orig coords
 
         for poly_xy, box in zip(xy_list, results.boxes):
             if len(poly_xy) < 3:
@@ -134,13 +125,13 @@ def run_segmentation(img_np):
             color    = CLASS_COLORS.get(cls_id, (200, 200, 200))
             counts[cls_name] += 1
 
-            # Backend mask: raw polygon fill — for measurements only
-            mask_np = _polygon_to_mask(poly_xy, h, w)
+            # Backend mask: raw polygon fill (measurements only)
+            mask_np  = _polygon_to_mask(poly_xy, h, w)
 
-            # Visual polygon: Hanning-smoothed — for display only
+            # Visual polygon: Hanning-smoothed (display only)
             vis_poly = _smooth_polygon(poly_xy, window=11)
 
-            # Update zoom bounding box from backend mask
+            # Bounding box from backend mask for zoom crop
             ys, xs = np.where(mask_np == 1)
             if len(xs) > 0:
                 all_x1 = min(all_x1, int(xs.min()))
@@ -148,7 +139,6 @@ def run_segmentation(img_np):
                 all_x2 = max(all_x2, int(xs.max()))
                 all_y2 = max(all_y2, int(ys.max()))
 
-            # Fill overlay with smooth visual polygon
             cv2.fillPoly(overlay, [vis_poly], color)
 
             grain_boxes.append({
@@ -161,22 +151,19 @@ def run_segmentation(img_np):
     # Blend fill
     annotated = cv2.addWeighted(annotated, 0.72, overlay, 0.28, 0)
 
-    # Draw smooth anti-aliased outlines on top
+    # Anti-aliased contour lines
     for g in grain_boxes:
-        color = CLASS_COLORS[g["cls_id"]]
         cv2.polylines(
             annotated, [g["vis_poly"]],
-            isClosed=True, color=color, thickness=2,
+            isClosed=True, color=CLASS_COLORS[g["cls_id"]], thickness=2,
             lineType=cv2.LINE_AA,
         )
 
-    # Zoom to grain region
+    # Zoom
     if all_x2 > all_x1 and all_y2 > all_y1:
         pad  = max(30, int(max(all_x2 - all_x1, all_y2 - all_y1) * 0.08))
-        cx1  = max(0, all_x1 - pad)
-        cy1  = max(0, all_y1 - pad)
-        cx2  = min(w, all_x2 + pad)
-        cy2  = min(h, all_y2 + pad)
+        cx1, cy1 = max(0, all_x1 - pad), max(0, all_y1 - pad)
+        cx2, cy2 = min(w, all_x2 + pad), min(h, all_y2 + pad)
         zoomed_pil = Image.fromarray(annotated[cy1:cy2, cx1:cx2])
     else:
         zoomed_pil = Image.fromarray(annotated)
@@ -185,7 +172,7 @@ def run_segmentation(img_np):
 
 
 # ─────────────────────────────────────────────────────────────────────────────
-# STEP 2 — Measure grains (unchanged — uses backend mask_np only)
+# STEP 2 — Measure grains (backend mask_np only — unaffected by visual changes)
 # ─────────────────────────────────────────────────────────────────────────────
 def measure_grains_from_boxes(grain_boxes, img_shape, paper_dims):
     paper_px = (paper_dims[0] + paper_dims[1]) / 2.0 if paper_dims else None
@@ -235,10 +222,10 @@ def build_table_data(measurements, paper_px, counts):
         w_val    = round(g["w_mm"],    2) if (has_mm and g["w_mm"])    else round(g["w_px"], 1)
         area_val = round(g["area_mm2"], 2) if g["area_mm2"] else None
         rows.append({
-            "#":                                 g["label"],
-            "Class":                             g["cls_name"],
-            f"Height ({unit})":                  h_val,
-            f"Width ({unit})":                   w_val,
+            "#":                                     g["label"],
+            "Class":                                 g["cls_name"],
+            f"Height ({unit})":                      h_val,
+            f"Width ({unit})":                       w_val,
             "Area (mm\u00b2)" if has_mm else "Area": area_val,
         })
     grain_df = pd.DataFrame(rows)
@@ -326,7 +313,9 @@ def predict_stage2(image: Image.Image):
 
 
 # ─────────────────────────────────────────────────────────────────────────────
-# UI
+# UI  — Gradio 6 compatible
+#   • theme / css → moved to demo.launch()
+#   • gr.DataFrame has no height param → use CSS to expand tables
 # ─────────────────────────────────────────────────────────────────────────────
 THEME = gr.themes.Soft(
     primary_hue="violet",
@@ -335,13 +324,27 @@ THEME = gr.themes.Soft(
     font=gr.themes.GoogleFont("Inter"),
 )
 
+# In Gradio 6 the CSS string is passed to launch(), not Blocks()
 CSS = """
-#run-btn { margin-top: 6px; }
+#run-btn  { margin-top: 6px; }
 #status-box textarea { font-size: 0.92rem; }
 #count-box { font-size: 0.95rem; }
+
+/* Make both measurement tables tall enough to show all rows */
+#grain-table   .table-wrap,
+#grain-table   .svelte-table,
+#summary-table .table-wrap,
+#summary-table .svelte-table {
+    max-height: none !important;
+    overflow-y: visible !important;
+}
+#grain-table,
+#summary-table {
+    overflow: visible !important;
+}
 """
 
-with gr.Blocks(theme=THEME, title="GrainVision", css=CSS) as demo:
+with gr.Blocks(title="GrainVision") as demo:
 
     gr.HTML("""
     <div style="padding:18px 12px 10px 12px; background-color:#0F172A;
@@ -361,7 +364,8 @@ with gr.Blocks(theme=THEME, title="GrainVision", css=CSS) as demo:
             inp_image = gr.Image(type="pil", label="Upload Rice Image", height=280)
             run_btn   = gr.Button("🔍  Analyse Grains",
                                   variant="primary", size="lg", elem_id="run-btn")
-            gr.Markdown("_Upload an image then press **Analyse**. Segmentation appears first, measurements follow._")
+            gr.Markdown("_Upload an image then press **Analyse**. "
+                        "Segmentation appears first, measurements follow._")
             status_box = gr.Textbox(
                 label="Status", value="", interactive=False,
                 visible=True, max_lines=3, elem_id="status-box",
@@ -387,7 +391,8 @@ with gr.Blocks(theme=THEME, title="GrainVision", css=CSS) as demo:
         with gr.Column(scale=1):
             gr.Markdown("#### Grain Count")
             count_md = gr.Markdown(
-                value="| | Count |\n|---|---|\n| 🌾 Total | — |\n| 🟢 Full | — |\n| 🔴 Broken | — |",
+                value="| | Count |\n|---|---|\n"
+                      "| 🌾 Total | — |\n| 🟢 Full | — |\n| 🔴 Broken | — |",
                 elem_id="count-box",
             )
 
@@ -397,18 +402,14 @@ with gr.Blocks(theme=THEME, title="GrainVision", css=CSS) as demo:
         with gr.Column(scale=2):
             gr.Markdown("#### Per-Grain Measurements")
             grain_table_out = gr.DataFrame(
-                label="",
-                interactive=False,
-                wrap=False,
-                height=500,          # shows all rows; scrollable if > 500px
+                label="", interactive=False, wrap=False,
+                elem_id="grain-table",
             )
         with gr.Column(scale=1):
             gr.Markdown("#### Summary Statistics")
             summary_table_out = gr.DataFrame(
-                label="",
-                interactive=False,
-                wrap=False,
-                height=420,          # fits all 11 summary rows without scroll
+                label="", interactive=False, wrap=False,
+                elem_id="summary-table",
             )
 
     OUTPUTS = [seg_out, summary_box, count_md, grain_table_out, summary_table_out]
@@ -421,4 +422,5 @@ with gr.Blocks(theme=THEME, title="GrainVision", css=CSS) as demo:
 
 
 if __name__ == "__main__":
-    demo.launch()
+    # Gradio 6: theme and css passed here, not in gr.Blocks()
+    demo.launch(theme=THEME, css=CSS)