improved report and region measurement

app.py

@@ -206,7 +206,7 @@ with st.sidebar:
             st.markdown('<p style="font-size: 0.95rem; font-weight: 500; margin-bottom: 0.5rem;">Conditions</p>', unsafe_allow_html=True)
             conditions_source = st.radio(
                 "Conditions",
-                ["Manually", "From config"],
+                ["From config", "Manually"],
                 horizontal=True,
                 label_visibility="collapsed",
             )
@@ -245,7 +245,7 @@ with st.sidebar:
 
     auto_cell_boundary = st.checkbox(
         "Auto boundary",
-        value=True,
+        value=False,
         help="When on: estimate cell region from force map and use it for metrics (red contour). When off: use entire map.",
     )
 

ui/components.py

@@ -1,5 +1,6 @@
 """UI components for S2F App."""
 import csv
+import html
 import io
 import os
 
@@ -17,7 +18,13 @@ from config.constants import (
     TOOL_LABELS,
 )
 from utils.display import apply_display_scale, cv_colormap_to_plotly_colorscale
-from utils.report import heatmap_to_rgb, heatmap_to_rgb_with_contour, heatmap_to_png_bytes, create_pdf_report
+from utils.report import (
+    heatmap_to_rgb,
+    heatmap_to_rgb_with_contour,
+    heatmap_to_png_bytes,
+    create_pdf_report,
+    create_measure_pdf_report,
+)
 from utils.segmentation import estimate_cell_mask
 
 try:
@@ -30,6 +37,19 @@ except (ImportError, AttributeError):
 ST_DIALOG = getattr(st, "dialog", None) or getattr(st, "experimental_dialog", None)
 
 
+# Distinct colors for each region (RGB - heatmap_rgb is RGB)
+_REGION_COLORS = [
+    (255, 102, 0),   # orange
+    (255, 165, 0),   # orange-red
+    (255, 255, 0),   # yellow
+    (255, 0, 255),   # magenta
+    (0, 255, 127),   # spring green
+    (0, 128, 255),   # blue
+    (203, 192, 255), # lavender
+    (255, 215, 0),   # gold
+]
+
+
 def make_annotated_heatmap(heatmap_rgb, mask, fill_alpha=0.3, stroke_color=(255, 102, 0), stroke_width=2):
     """Composite heatmap with drawn region overlay."""
     annotated = heatmap_rgb.copy()
@@ -45,6 +65,40 @@ def make_annotated_heatmap(heatmap_rgb, mask, fill_alpha=0.3, stroke_color=(255,
     return annotated
 
 
+def make_annotated_heatmap_multi_regions(heatmap_rgb, masks, labels, cell_mask=None, fill_alpha=0.3):
+    """Draw each region separately with distinct color and label (R1, R2, ...). No merging."""
+    annotated = heatmap_rgb.copy()
+    if cell_mask is not None and np.any(cell_mask > 0):
+        contours, _ = cv2.findContours(cell_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        cv2.drawContours(annotated, contours, -1, (255, 0, 0), 2)
+    for i, mask in enumerate(masks):
+        color = _REGION_COLORS[i % len(_REGION_COLORS)]
+        contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        overlay = annotated.copy()
+        cv2.fillPoly(overlay, contours, color)
+        mask_3d = np.stack([mask] * 3, axis=-1).astype(bool)
+        annotated[mask_3d] = (
+            (1 - fill_alpha) * annotated[mask_3d].astype(np.float32)
+            + fill_alpha * overlay[mask_3d].astype(np.float32)
+        ).astype(np.uint8)
+        cv2.drawContours(annotated, contours, -1, color, 2)
+        # Label at centroid
+        M = cv2.moments(mask)
+        if M["m00"] > 0:
+            cx = int(M["m10"] / M["m00"])
+            cy = int(M["m01"] / M["m00"])
+            label = labels[i] if i < len(labels) else f"R{i + 1}"
+            cv2.putText(
+                annotated, label, (cx - 12, cy + 5),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2, cv2.LINE_AA
+            )
+            cv2.putText(
+                annotated, label, (cx - 12, cy + 5),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 1, cv2.LINE_AA
+            )
+    return annotated
+
+
 def _obj_to_pts(obj, scale_x, scale_y, heatmap_w, heatmap_h):
     """Convert a single canvas object to polygon points in heatmap coords. Returns None if invalid."""
     obj_type = obj.get("type", "")
@@ -169,9 +223,13 @@ def compute_region_metrics(raw_heatmap, mask, original_vals=None):
     }
 
 
-def render_region_metrics_and_downloads(metrics_list, heatmap_rgb, combined_mask, input_filename, key_suffix, has_original_vals,
-                                        first_region_label=None):
-    """Render per-shape metrics table and download buttons. first_region_label: custom label for first row (e.g. 'Auto boundary')."""
+def render_region_metrics_and_downloads(metrics_list, masks, heatmap_rgb, input_filename, key_suffix, has_original_vals,
+                                        first_region_label=None, bf_img=None, cell_mask=None, colormap_name="Jet"):
+    """
+    Render per-shape metrics table and download buttons.
+    first_region_label: custom label for first row (e.g. 'Auto boundary').
+    masks: list of region masks (user-drawn only; used for labeled heatmap with R1, R2...).
+    """
     base_name = os.path.splitext(input_filename or "image")[0]
     st.markdown("**Regions (each selection = one row)**")
     if has_original_vals:
@@ -193,21 +251,56 @@ def render_region_metrics_and_downloads(metrics_list, heatmap_rgb, combined_mask
             csv_rows.append([base_name, region_label, metrics["area_px"], f"{metrics['force_sum']:.4f}",
                             f"{metrics['mean']:.6f}"])
         table_rows.append(row)
-    st.table(table_rows)
+    # Render as HTML table to avoid Streamlit's default row/column indices
+    header = table_rows[0]
+    body = table_rows[1:]
+    th_cells = "".join(
+        f'<th style="border: 1px solid #ddd; padding: 8px; text-align: left;">{html.escape(str(h))}</th>'
+        for h in header
+    )
+    rows_html = [
+        "<tr>"
+        + "".join(
+            f'<td style="border: 1px solid #ddd; padding: 8px;">{html.escape(str(c))}</td>'
+            for c in row
+        )
+        + "</tr>"
+        for row in body
+    ]
+    table_html = (
+        f'<table style="border-collapse: collapse; width: 100%;">'
+        f"<thead><tr>{th_cells}</tr></thead>"
+        f"<tbody>{''.join(rows_html)}</tbody></table>"
+    )
+    st.markdown(table_html, unsafe_allow_html=True)
     buf_csv = io.StringIO()
     csv.writer(buf_csv).writerows(csv_rows)
+    # Annotated heatmap: each region separate with R1, R2 labels (no merging)
+    # heatmap_rgb already has cell contour if applicable
+    region_labels = [f"R{i + 1}" for i in range(len(masks))]
+    heatmap_labeled = make_annotated_heatmap_multi_regions(heatmap_rgb.copy(), masks, region_labels, cell_mask=None)
     buf_img = io.BytesIO()
-    Image.fromarray(make_annotated_heatmap(heatmap_rgb, combined_mask)).save(buf_img, format="PNG")
+    Image.fromarray(heatmap_labeled).save(buf_img, format="PNG")
     buf_img.seek(0)
-    dl_col1, dl_col2 = st.columns(2)
-    with dl_col1:
+    # PDF report (requires bf_img)
+    pdf_bytes = None
+    if bf_img is not None:
+        pdf_bytes = create_measure_pdf_report(bf_img, heatmap_labeled, table_rows, base_name)
+    n_cols = 3 if pdf_bytes is not None else 2
+    dl_cols = st.columns(n_cols)
+    with dl_cols[0]:
         st.download_button("Download all regions", data=buf_csv.getvalue(),
             file_name=f"{base_name}_all_regions.csv", mime="text/csv",
             key=f"download_all_regions_{key_suffix}", icon=":material/download:")
-    with dl_col2:
-        st.download_button("Download annotated heatmap", data=buf_img.getvalue(),
+    with dl_cols[1]:
+        st.download_button("Download heatmap", data=buf_img.getvalue(),
             file_name=f"{base_name}_annotated_heatmap.png", mime="image/png",
             key=f"download_annotated_{key_suffix}", icon=":material/image:")
+    if pdf_bytes is not None:
+        with dl_cols[2]:
+            st.download_button("Download report", data=pdf_bytes,
+                file_name=f"{base_name}_measure_report.pdf", mime="application/pdf",
+                key=f"download_measure_pdf_{key_suffix}", icon=":material/picture_as_pdf:")
 
 
 def _draw_contour_on_image(img_rgb, mask, stroke_color=(255, 0, 0), stroke_width=2):
@@ -298,12 +391,10 @@ def render_region_canvas(display_heatmap, raw_heatmap=None, bf_img=None, origina
             if cell_mask is not None and np.any(cell_mask > 0):
                 cell_metrics = compute_region_metrics(raw_heatmap, cell_mask, original_vals)
                 metrics_list = [cell_metrics] + metrics_list
-            combined_mask = masks[0].copy()
-            for m in masks[1:]:
-                combined_mask = np.maximum(combined_mask, m)
             render_region_metrics_and_downloads(
-                metrics_list, heatmap_rgb, combined_mask, input_filename, key_suffix, original_vals is not None,
+                metrics_list, masks, heatmap_rgb, input_filename, key_suffix, original_vals is not None,
                 first_region_label="Auto boundary" if (cell_mask is not None and np.any(cell_mask > 0)) else None,
+                bf_img=bf_img, cell_mask=cell_mask, colormap_name=colormap_name,
             )
 
 
@@ -355,7 +446,7 @@ def render_result_display(img, raw_heatmap, display_heatmap, pixel_sum, force, k
     base_name = os.path.splitext(key_img or "image")[0]
     if use_cell_metrics:
         main_csv_rows = [
-            ["image", "Cell sum", "Cell force (scaled)", "Heatmap max", "Cell mean"],
+            ["image", "Cell sum", "Cell force (scaled)", "Heatmap max", "Heatmap mean"],
             [base_name, f"{cell_pixel_sum:.2f}", f"{cell_force:.2f}",
              f"{np.max(raw_heatmap):.4f}", f"{cell_mean:.4f}"],
         ]
@@ -401,7 +492,7 @@ def render_result_display(img, raw_heatmap, display_heatmap, pixel_sum, force, k
         with col3:
             st.metric("Heatmap max", f"{np.max(raw_heatmap):.4f}", help="Peak force intensity in the map")
         with col4:
-            st.metric("Cell mean", f"{cell_mean:.4f}", help="Mean force over estimated cell area")
+            st.metric("Heatmap mean", f"{cell_mean:.4f}", help="Mean force over estimated cell area")
     else:
         with col1:
             st.metric("Sum of all pixels", f"{pixel_sum:.2f}", help="Raw sum of all pixel values in the force map")
@@ -428,7 +519,7 @@ This is the raw image you provided—it shows cell shape but not forces.
 - **Cell sum:** Sum over estimated cell area (background excluded)
 - **Cell force (scaled):** Total traction force in physical units
 - **Heatmap max:** Peak force intensity in the map
-- **Cell mean:** Mean force over the estimated cell area
+- **Heatmap mean:** Mean force over the estimated cell area
             """)
         else:
             st.markdown("""

utils/report.py

@@ -47,50 +47,66 @@ def create_pdf_report(img, display_heatmap, raw_heatmap, pixel_sum, force, base_
     c = canvas.Canvas(buf, pagesize=A4)
     c.setTitle("Shape2Force")
     c.setAuthor("Angione-Lab")
-    h = A4[1]
-    img_w, img_h = 2.5 * inch, 2.5 * inch
+    page_w_pt = A4[0]
+    page_h_pt = A4[1]
+    margin = 72
+    img_w, img_h = 2.8 * inch, 2.8 * inch
+    img_gap = 20
+
+    # Center images
+    total_img_width = 2 * img_w + img_gap
+    img_left = margin + (page_w_pt - 2 * margin - total_img_width) / 2
+    bf_x = img_left
+    hm_x = img_left + img_w + img_gap
 
     footer_y = 40
     c.setFont("Helvetica", 8)
     c.setFillColorRGB(0.4, 0.4, 0.4)
     gen_date = datetime.now().strftime("%Y-%m-%d %H:%M")
-    c.drawString(72, footer_y, f"Generated by Shape2Force (S2F) on {gen_date}")
-    c.drawString(72, footer_y - 12, "Model: https://huggingface.co/Angione-Lab/Shape2Force")
-    c.drawString(72, footer_y - 24, "Web app: https://huggingface.co/spaces/Angione-Lab/Shape2force")
+    c.drawString(margin, footer_y, f"Generated by Shape2Force (S2F) on {gen_date}")
+    c.drawString(margin, footer_y - 12, "Model: https://huggingface.co/Angione-Lab/Shape2Force")
+    c.drawString(margin, footer_y - 24, "Web app: https://huggingface.co/spaces/Angione-Lab/Shape2force")
     c.setFillColorRGB(0, 0, 0)
 
-    img_top = h - 70
+    y_top = page_h_pt - 50
+    c.setFont("Helvetica-Bold", 16)
+    c.drawString(margin, y_top, "Shape2Force (S2F) - Prediction Report")
+    c.setFont("Helvetica", 10)
+    c.drawString(margin, y_top - 14, f"Image: {base_name}")
+    y_top -= 35
+
+    img_bottom = y_top - img_h
     img_pil = Image.fromarray(img) if img.ndim == 2 else Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
     img_buf = io.BytesIO()
     img_pil.save(img_buf, format="PNG")
     img_buf.seek(0)
-    c.drawImage(ImageReader(img_buf), 72, img_top - img_h, width=img_w, height=img_h, preserveAspectRatio=True)
+    c.drawImage(ImageReader(img_buf), bf_x, img_bottom, width=img_w, height=img_h, preserveAspectRatio=True)
     c.setFont("Helvetica", 9)
-    c.drawString(72, img_top - img_h - 12, "Input: Bright-field")
+    bf_label_w = c.stringWidth("Bright-field", "Helvetica", 9)
+    c.drawString(bf_x + (img_w - bf_label_w) / 2, img_bottom - 14, "Bright-field")
 
     heatmap_rgb = heatmap_to_rgb_with_contour(display_heatmap, colormap_name, cell_mask)
     hm_buf = io.BytesIO()
     Image.fromarray(heatmap_rgb).save(hm_buf, format="PNG")
     hm_buf.seek(0)
-    c.drawImage(ImageReader(hm_buf), 72 + img_w + 20, img_top - img_h, width=img_w, height=img_h, preserveAspectRatio=True)
-    c.drawString(72 + img_w + 20, img_top - img_h - 12, "Output: Force map (red = estimated cell)")
-
-    c.setFont("Helvetica-Bold", 16)
-    c.drawString(72, img_top + 25, "Shape2Force (S2F) - Prediction Report")
-    c.setFont("Helvetica", 10)
-    c.drawString(72, img_top + 8, f"Image: {base_name}")
-
-    y = img_top - img_h - 45
+    c.drawImage(ImageReader(hm_buf), hm_x, img_bottom, width=img_w, height=img_h, preserveAspectRatio=True)
+    hm_label = "Force map (red = estimated boundary)" if cell_mask is not None and np.any(cell_mask > 0) else "Force map"
+    hm_label_w = c.stringWidth(hm_label, "Helvetica", 9)
+    c.drawString(hm_x + (img_w - hm_label_w) / 2, img_bottom - 14, hm_label)
+
+    # Metrics section with spacing
+    row_height = 14
+    y = img_bottom - 14 - row_height
     c.setFont("Helvetica-Bold", 10)
-    c.drawString(72, y, "Metrics")
+    c.drawString(margin, y, "Metrics")
     c.setFont("Helvetica", 9)
     y -= 18
     if cell_pixel_sum is not None and cell_force is not None and cell_mean is not None:
         metrics = [
-            ("Cell sum (estimated cell area)", f"{cell_pixel_sum:.2f}"),
+            ("Cell sum (estimated boundary)", f"{cell_pixel_sum:.2f}"),
             ("Cell force (scaled)", f"{cell_force:.2f}"),
             ("Heatmap max", f"{np.max(raw_heatmap):.4f}"),
-            ("Cell mean (estimated cell area)", f"{cell_mean:.4f}"),
+            ("Heatmap mean (estimated boundary)", f"{cell_mean:.4f}"),
         ]
     else:
         metrics = [
@@ -100,9 +116,98 @@ def create_pdf_report(img, display_heatmap, raw_heatmap, pixel_sum, force, base_
             ("Heatmap mean", f"{np.mean(raw_heatmap):.4f}"),
         ]
     for label, val in metrics:
-        c.drawString(72, y, f"{label}: {val}")
+        c.drawString(margin, y, f"{label}: {val}")
         y -= 16
 
     c.save()
     buf.seek(0)
     return buf.getvalue()
+
+
+def create_measure_pdf_report(bf_img, heatmap_labeled_rgb, table_rows, base_name):
+    """
+    Create PDF report for measure tool.
+    Contents: bright-field, heatmap with region labels (R1, R2...), table.
+    """
+    buf = io.BytesIO()
+    c = canvas.Canvas(buf, pagesize=A4)
+    c.setTitle("Shape2Force - Region Measurement")
+    c.setAuthor("Angione-Lab")
+    page_w_pt = A4[0]
+    page_h_pt = A4[1]
+    margin = 72
+    img_w = 2.8 * inch
+    img_h = 2.8 * inch
+    img_gap = 20
+
+    # Center images: two images side by side
+    total_img_width = 2 * img_w + img_gap
+    img_left = margin + (page_w_pt - 2 * margin - total_img_width) / 2
+    bf_x = img_left
+    hm_x = img_left + img_w + img_gap
+
+    footer_y = 40
+    c.setFont("Helvetica", 8)
+    c.setFillColorRGB(0.4, 0.4, 0.4)
+    gen_date = datetime.now().strftime("%Y-%m-%d %H:%M")
+    c.drawString(margin, footer_y, f"Generated by Shape2Force (S2F) on {gen_date}")
+    c.drawString(margin, footer_y - 12, "Model: https://huggingface.co/Angione-Lab/Shape2Force")
+    c.setFillColorRGB(0, 0, 0)
+
+    y_top = page_h_pt - 50
+    c.setFont("Helvetica-Bold", 14)
+    c.drawString(margin, y_top, "Region Measurement Report")
+    c.setFont("Helvetica", 10)
+    c.drawString(margin, y_top - 14, f"Image: {base_name}")
+    y_top -= 35
+
+    # Images (centered)
+    img_bottom = y_top - img_h
+    bf_pil = Image.fromarray(bf_img) if bf_img.ndim == 2 else Image.fromarray(
+        cv2.cvtColor(bf_img, cv2.COLOR_BGR2RGB)
+    )
+    bf_buf = io.BytesIO()
+    bf_pil.save(bf_buf, format="PNG")
+    bf_buf.seek(0)
+    c.drawImage(ImageReader(bf_buf), bf_x, img_bottom, width=img_w, height=img_h, preserveAspectRatio=True)
+    c.setFont("Helvetica", 9)
+    bf_label_w = c.stringWidth("Bright-field", "Helvetica", 9)
+    c.drawString(bf_x + (img_w - bf_label_w) / 2, img_bottom - 14, "Bright-field")
+
+    hm_labeled_buf = io.BytesIO()
+    Image.fromarray(heatmap_labeled_rgb).save(hm_labeled_buf, format="PNG")
+    hm_labeled_buf.seek(0)
+    c.drawImage(ImageReader(hm_labeled_buf), hm_x, img_bottom, width=img_w, height=img_h, preserveAspectRatio=True)
+    hm_label_w = c.stringWidth("Force map", "Helvetica", 9)
+    c.drawString(hm_x + (img_w - hm_label_w) / 2, img_bottom - 14, "Force map")
+
+    # Spacing: one line between images/labels and measurements section
+    row_height = 14
+    y_table_top = img_bottom - 14 - row_height  # label + one line space
+
+    # Table with borders
+    n_cols = len(table_rows[0]) if table_rows else 0
+    table_width = page_w_pt - 2 * margin
+    col_w = table_width / n_cols if n_cols else 1
+    cell_pad = 4
+
+    c.setFont("Helvetica-Bold", 9)
+    c.drawString(margin, y_table_top, "Measurements")
+    y_table_top -= row_height + 8  # extra space before table
+
+    for ri, row in enumerate(table_rows):
+        y_cell_bottom = y_table_top - (ri + 1) * row_height
+        for ci, cell in enumerate(row):
+            x_left = margin + ci * col_w
+            # Draw cell border
+            c.rect(x_left, y_cell_bottom, col_w, row_height, stroke=1, fill=0)
+            # Draw text (with padding)
+            if ri == 0:
+                c.setFont("Helvetica-Bold", 8)
+            c.drawString(x_left + cell_pad, y_cell_bottom + 4, str(cell)[:22])
+            if ri == 0:
+                c.setFont("Helvetica", 8)
+
+    c.save()
+    buf.seek(0)
+    return buf.getvalue()