Check against this Space's own fields where the open data has none; normals on the strong half; larger picture labels

app.py

@@ -200,8 +200,12 @@ def volume_text(vid):
     shape = v.get("shape_zyx") or ["?"] * 3
     f = 2 ** v["level"]
     pub = L.published_field(v)
-    pub_line = ("The open data has villa's field for this scan, so each box is checked against it." if pub
-                else "The open data has no lasagna field for this scan, so there is nothing to check against.")
+    if pub and pub.get("source") == "lasagna-fields":
+        pub_line = "This Space has a whole-scan field for this scan, so each box is checked against it."
+    elif pub:
+        pub_line = "The open data has villa's field for this scan, so each box is checked against it."
+    else:
+        pub_line = "No lasagna field has been published for this scan, so there is nothing to check against."
     return (f"{' × '.join(map(str, shape))} voxels (z × y × x) at {v['voxel_um']:g} um. The model reads level "
             f"{v['level']} ({v['voxel_um'] * f:.2f} um), nearest to the 9.4 um it was trained at. {pub_line}")
 
@@ -233,12 +237,17 @@ def result_text(r):
 
         def fmt(v, unit=""):
             return "n/a" if v is None else f"{v}{unit}"
+        where = ("this Space's whole-scan field" if a.get("published_source") == "lasagna-fields"
+                 else "the open data's field")
         lines.append(
-            "\n**Check against the published field** (`" + a["published"] + "`): "
-            f"cos r = {fmt(same['cos_r'])}, grad_mag r = {fmt(same['grad_mag_r'])}, normals {fmt(same['normal_median_deg'], '°')} "
-            f"apart (median). Control, the published field {L.CONTROL_SHIFT} voxels away: cos r = "
-            f"{fmt(ctl.get('cos_r'))}, normals {fmt(ctl.get('normal_median_deg'), '°')}. The same box should agree "
-            "far better than the control.")
+            f"\n**Check against {where}** (`" + a["published"] + "`): "
+            f"cos r = {fmt(same['cos_r'])}, grad_mag r = {fmt(same['grad_mag_r'])}, normals "
+            f"{fmt(same.get('normal_median_deg_strong'), '°')} apart where the layer signal is strong "
+            f"({fmt(same['normal_median_deg'], '°')} over every voxel; medians). Control, the same field "
+            f"{L.CONTROL_SHIFT} voxels away: cos r = {fmt(ctl.get('cos_r'))}, normals "
+            f"{fmt(ctl.get('normal_median_deg_strong'), '°')}. The same box should agree far better than the control.")
+        if a.get("normals_note"):
+            lines.append(f"\n{a['normals_note']}.")
     elif a.get("note") or a.get("error"):
         lines.append(f"\nCheck: {a.get('note') or a.get('error')}")
     lines.append("\nThe download holds villa's own output folder (open `villa/*.lasagna.json` with lasagna's fit), "
@@ -444,7 +453,7 @@ CSS = """
 .lf-est p { font-size:13.5px; color: var(--body-text-color-subdued); }
 .lf-point { flex-wrap: nowrap !important; }
 .lf-credit { text-align:center; font-size:13px; color: var(--body-text-color-subdued); padding:18px 0 6px; }
-.lf-credit a { color: var(--lf-accent); }
+.lf-credit a { color: var(--lf-accent) !important; padding:0 !important; margin:0 !important; }
 .lf-howto img { border-radius:10px; border:1px solid var(--border-color-primary); max-width:100%; }
 @media (max-width: 640px) {
   .lf-head h1 { font-size:24px; }
@@ -573,11 +582,11 @@ def build_demo():
                         example = MEDIA / "example-result.png"
                         pic = gr.Image(str(example) if example.is_file() else None,
                                        label="Middle slices along z, y, x: CT · cos · grad_mag · normal",
-                                       type="numpy", format="png", interactive=False)
+                                       type="numpy", format="png", interactive=False, show_label=False)
                         summary = gr.Markdown("Above: what a result looks like (the first example point). Your "
                                               "field replaces it. The first run after the Space wakes up also loads "
                                               "the model (about a minute).")
-                        dl = gr.File(label="Download: villa output folder, field.npz, receipt.json")
+                        dl = gr.File(label="Download: villa output folder, field.npz, receipt.json", height=88)
                         with gr.Accordion("Receipt", open=False):
                             receipt = gr.JSON()
                         with gr.Accordion("About the model", open=False):

lasfield.py

@@ -155,6 +155,21 @@ def zarray(v, level):
 
 
 _PUBLISHED = {}
+# the ten whole-scan fields this Space hosts, made with the same villa commit and checkpoint as Make a field: volume id
+# to (sample, run folder) in the public bucket; the check uses them where the open data has no field
+OWN_BUCKET = "https://huggingface.co/buckets/SharpMeow/lasagna-fields/resolve"
+OWN_FIELDS = {
+    "20250521115057": ("PHerc0175A", "20250521115057-lasagna-de45f011"),
+    "20250521125822": ("PHerc0175B", "20250521125822-lasagna-de45f011"),
+    "20250521133212": ("PHerc0306B", "20250521133212-lasagna-de45f011"),
+    "20250521140913": ("PHerc0483A", "20250521140913-lasagna-de45f011"),
+    "20251124083638": ("PHerc0483B", "20251124083638-lasagna-de45f011"),
+    "20250521151210": ("PHerc0490A", "20250521151210-lasagna-de45f011"),
+    "20250521151215": ("PHerc0490B", "20250521151215-lasagna-de45f011"),
+    "20250821151531": ("PHerc0841", "20250821151531-lasagna-de45f011"),
+    "20250728152254": ("PHerc0846A", "20250728152254-lasagna-de45f011"),
+    "20250804142305": ("PHerc0846B", "20250804142305-lasagna-de45f011"),
+}
 
 
 def published_field(v):
@@ -174,10 +189,25 @@ def published_field(v):
                     found = dict(found, note=f"published for {old['volume']}, which this volume replaces in the "
                                              "same voxel frame")
                     break
+    if found is None and key in OWN_FIELDS and v["level"] == 0:
+        found = _own_run(*OWN_FIELDS[key])
     _PUBLISHED[key] = found
     return found
 
 
+def _own_run(sample, run):
+    """One of this Space's ten whole-scan fields, described like an open-data run."""
+    url = f"{OWN_BUCKET}/{sample}/representations/predictions/lasagna/{run}/"
+    try:
+        manifest = get_json(f"{url}{sample}.lasagna.json")
+    except FieldError as exc:
+        log(f"own field lookup for {sample} failed: {exc}")
+        return None
+    return {"run": run, "url": url, "manifest": f"{url}{sample}.lasagna.json", "groups": manifest.get("groups"),
+            "base_shape_zyx": manifest.get("base_shape_zyx"), "source": "lasagna-fields",
+            "note": "this Space's own whole-scan field, made with the same villa commit and checkpoint"}
+
+
 def _published_run(v):
     found = None
     try:
@@ -195,7 +225,8 @@ def _published_run(v):
             if js:
                 manifest = get_json(f"{BUCKET}/{js[0]}")
                 found = {"run": name, "url": f"{BUCKET}/{run}", "manifest": f"{BUCKET}/{js[0]}",
-                         "groups": manifest.get("groups"), "base_shape_zyx": manifest.get("base_shape_zyx")}
+                         "groups": manifest.get("groups"), "base_shape_zyx": manifest.get("base_shape_zyx"),
+                         "source": "open-data"}
     except FieldError as exc:
         log(f"published field lookup for {v['volume']} failed: {exc}")
     return found
@@ -537,7 +568,9 @@ def _corr(a, b, mask):
 
 def compare(mine, theirs):
     """Agreement of two fields on the same grids: Pearson r of cos and grad_mag where either is non-zero, and the
-    median angle between normals (sign ignored) where both are."""
+    median angle between normals (sign ignored) where both are, over all those voxels and over the strong half (our
+    grad_mag at or above its median there). Where the layer signal is weak the normal is barely defined and tiny
+    numerical differences turn it, so the strong half is the fair test."""
     m_cos = (mine["cos"] > 0) | (theirs["cos"] > 0)
     m_oth = (mine["grad_mag"] > 0) | (theirs["grad_mag"] > 0)
     both = (mine["nx"] > 0) & (theirs["nx"] > 0)
@@ -546,8 +579,13 @@ def compare(mine, theirs):
            "voxels": int(m_cos.sum())}
     if both.sum() >= 100:
         a, b = decode_normal(mine["nx"], mine["ny"]), decode_normal(theirs["nx"], theirs["ny"])
-        dot = np.abs((a * b).sum(axis=0))[both]
-        out["normal_median_deg"] = round(float(np.degrees(np.arccos(np.clip(np.median(dot), 0, 1)))), 2)
+        dot = np.abs((a * b).sum(axis=0))
+        out["normal_median_deg"] = round(float(np.degrees(np.arccos(np.clip(np.median(dot[both]), 0, 1)))), 2)
+        g = mine["grad_mag"]
+        strong = both & (g >= np.median(g[both]))
+        if strong.sum() >= 100:
+            out["normal_median_deg_strong"] = round(
+                float(np.degrees(np.arccos(np.clip(np.median(dot[strong]), 0, 1)))), 2)
     return out
 
 
@@ -570,6 +608,12 @@ def read_published(pub, boxes, shift=(0, 0, 0)):
 CONTROL_SHIFT = 48           # input-level voxels: the control reads the published field this far away in y and x
 
 
+OPEN_DATA_NORMALS = ("cos and grad_mag should match the open data's field exactly. Its normals can differ in "
+                     "parts of a box: villa changed how lasagna estimates normals after the open data's fields "
+                     "were made (April 2026, by their run names), and Make a field runs the later code, the same "
+                     "as this Space's ten whole-scan fields, which it matches exactly")
+
+
 def agreement(p, arrays, boxes):
     """How close this field is to the open data's own lasagna field for the scan, where one exists, with a control
     that must score lower: the published field read CONTROL_SHIFT input voxels away along y and x (a few papyrus
@@ -592,7 +636,12 @@ def agreement(p, arrays, boxes):
         return {"published": pub["run"], "error": f"{type(exc).__name__}: {exc}"[:300]}
     if same is None:
         return {"published": pub["run"], "note": "the published field uses other grids; not compared"}
-    out = {"published": pub["run"], "published_url": pub["url"], "same_box": compare(arrays, same)}
+    out = {"published": pub["run"], "published_url": pub["url"], "published_source": pub.get("source"),
+           "same_box": compare(arrays, same)}
+    if pub.get("note"):
+        out["published_note"] = pub["note"]
+    if pub.get("source") == "open-data":
+        out["normals_note"] = OPEN_DATA_NORMALS
     if shifted is not None:
         out["control_shifted"] = compare(arrays, shifted)
         out["control_note"] = (f"the published field {CONTROL_SHIFT} input voxels away in y and x: "
@@ -646,26 +695,29 @@ PANELS = ("CT", "cos", "grad_mag", "normal (x red, y green, z blue)")
 
 def compose(pictures, title=""):
     """The three rows (z, y, x middle slices) under one header naming the panels, each row named on its left, on a
-    white card. Returns an RGB uint8 array."""
+    white card. Text is sized for the card to be shown about 700 px wide. Returns an RGB uint8 array."""
     from PIL import Image, ImageDraw, ImageFont
-    try:
-        font = ImageFont.load_default(size=14)
-    except TypeError:                      # Pillow before 10.1
-        font = ImageFont.load_default()
     rows = [_fit(r, pictures[0].shape[:2]) if r.shape != pictures[0].shape else r for r in pictures]
     h, w = rows[0].shape[:2]
+    k = max(1.0, w / 640)
+    try:
+        font = ImageFont.load_default(size=round(14 * k))
+        bold = ImageFont.load_default(size=round(16 * k))
+    except TypeError:                      # Pillow before 10.1
+        font = bold = ImageFont.load_default()
     pw = (w - 18) // 4
-    left, top, gap = 64, 30 + (26 if title else 0), 8
-    canvas = Image.new("RGB", (left + w + 8, top + 3 * h + 2 * gap + 8), (255, 255, 255))
+    left, gap = round(66 * k), round(8 * k)
+    top = round(26 * k) + (round(30 * k) if title else 0)
+    canvas = Image.new("RGB", (left + w + gap, top + 3 * h + 3 * gap), (255, 255, 255))
     d = ImageDraw.Draw(canvas)
     if title:
-        d.text((left, 6), title, fill=(35, 32, 28), font=font)
+        d.text((left, round(6 * k)), title, fill=(35, 32, 28), font=bold)
     for i, name in enumerate(PANELS):
-        d.text((left + i * (pw + 6) + 2, top - 20), name, fill=(93, 85, 75), font=font)
+        d.text((left + i * (pw + 6) + 2, top - round(21 * k)), name, fill=(93, 85, 75), font=font)
     for i, (r, name) in enumerate(zip(rows, ("z slice", "y slice", "x slice"))):
         y0 = top + i * (h + gap)
         canvas.paste(Image.fromarray(r), (left, y0))
-        d.text((6, y0 + h // 2 - 8), name, fill=(93, 85, 75), font=font)
+        d.text((round(6 * k), y0 + h // 2 - round(8 * k)), name, fill=(93, 85, 75), font=font)
     return np.asarray(canvas)