| --- |
| license: cc-by-nc-4.0 |
| pretty_name: Vesuvius snapped surface labels |
| tags: [vesuvius-challenge, herculaneum, ct, tifxyz, surface, segmentation] |
| size_categories: [1K<n<10K] |
| --- |
| |
| # Vesuvius snapped surface labels |
|
|
| Published surface labels of four Herculaneum scrolls from the Vesuvius Challenge open data, each vertex moved along |
| its mesh normal onto the papyrus recto face that the CT shows. Every segment is a tifxyz mesh on the same grid and in |
| the same voxel frame as the published label it came from, so it drops into VC3D, villa or any tifxyz reader, and |
| lines up with the original vertex for vertex. |
|
|
|  |
|
|
| On fresh test sites, scored against the recto face seen in an independent 1.129 µm scan: |
|
|
|  |
|
|
| | | Within 1 voxel of the face | |
| | --- | ---: | |
| | PHerc0139, published labels | 23.7% | |
| | PHerc0139, snapped (finesnap) | **91.2%** | |
| | PHerc0814, published labels | 24.2% | |
| | PHerc0814, snapped (single-scan snap) | **71.0%** | |
|
|
| A 3D surface model trained on snapped PHerc0139 labels placed the surface 0.61 voxels closer on PHerc0814 than the |
| same model trained on the published labels (95% interval 0.39 to 0.84; all 9 seed pairings agree). |
|
|
| Against seven community snaps, on 71 fresh PHerc0814 and PHerc0841 test sites (29 October 2026, rule fixed before |
| the run, truth from a finer scan of the same scroll registered per site), the single-scan snap used here for PHerc0172 |
| moved labels 2.15 voxels closer to the recto face than the published labels (95% interval 1.82 to 2.51) and 1.89 |
| closer than VC3D's vc_objrefine with thresholds tuned on PHerc0139 (1.48 to 2.35). It was also closer than |
| vc_objrefine as shipped, recto-offset r2 with and without its gate, surface_placement_audit, RectoRefine's midline and |
| a snap onto a surface prediction, on each scroll and pooled; every control held. Scored against a finer scan's face found with labelsnap's own band rule; with a face rule sharing neither, the lead held at about half the size (+1.04, +1.23 voxels). |
|
|
|  |
|
|
| What that test does not show: every vertex within 1 voxel (within 1 voxel it reached 55% on PHerc0814 and 66% on |
| PHerc0841, against 19% for the published labels); a label displaced toward the verso coming back; anything beyond |
| these sites (PHerc0814 is held out by site, not by scroll). Where a finer scan exists, finesnap did better than |
| labelsnap on PHerc0814 by 0.93 voxels. The released PHerc0841 meshes were not scored there, because their finesnap |
| read the same 2.403 µm scan the test used as truth. |
|
|
| See any segment on its CT in the [Snapped Labels viewer](https://huggingface.co/spaces/SharpMeow/snapped-labels). |
|
|
|  |
|
|
| **Model output.** A slow loop on PHerc0139 segment w033 at z 7600 (scan `20250728140407`, 9.362 µm): the published |
| label (orange) moves along its normals onto the snapped label (blue), holds, and moves back. The lines are the snap's |
| geometry drawn on the CT; they say nothing about ink or text. |
|
|
|  |
|
|
| Vesuvius Challenge open data, CC BY-NC 4.0. Its sidecar `snap-pherc0139-w033-z7600.json` names the scan, the voxel |
| size, the labels drawn, the credit and the command that made it (`scripts/media/snap_media.py real`). |
|
|
| ## What is in it |
|
|
| | Scroll | Method | Segments | Vertices released | Snapped | Filled | Held back | |
| | --- | --- | ---: | ---: | ---: | ---: | ---: | |
| | PHerc0139 | finesnap | 34 | 3,147,195 | 87.7% | 11.9% | 872,310 | |
| | PHerc0814 | finesnap | 19 | 1,143,812 | 83.6% | 15.7% | 226,239 | |
| | PHerc0841 | finesnap | 2 | 73,856 | 79.3% | 20.5% | 0 | |
| | PHerc0172 | labelsnap | 53 | 28,579,231 | 62.8% | 36.1% | 0 | |
| | **All** | | **108** | **32,944,094** | **66.0%** | **33.0%** | **1,098,549** | |
|
|
| Snapped: the recto face was measured at the vertex. Filled: no face was measured there, and the vertex moved by the |
| offset filled in from its measured neighbors (median move 2.7 voxels); nothing at the vertex vouches for it. |
| The rest of the released vertices (about 1%) keep their published position. |
|
|
| Each segment folder `SCROLL/SEGMENT/` holds: |
|
|
| - `snapped.tifxyz/` (`x.tif`, `y.tif`, `z.tif`, `meta.json`): the moved mesh, float32 level-0 voxels of the label |
| scan; `-1` where there is no vertex or it was held back. |
| - `abstain.tif`: 0 snapped (face measured at the vertex), 1 not measured and left at its published position, 2 not |
| measured and moved by the offset filled in from measured neighbors (filled), 255 no vertex or held back. To keep |
| measured vertices only, use `abstain.tif == 0`. |
| - `confidence.tif` (0 to 1) and `reason.tif` (why no face was measured at a vertex). |
| - `source.tif` (finesnap only): 1 placed in the 2.4 µm scan, 2 in the label scan. |
| - `release_mask.tif`: 0 released, 1 held back for evaluation, 255 not in the source mesh. |
| - `release.json`: the source mesh URL and the sha256 of its files, the scans used, the summary, and the sha256 of |
| every file in the folder. |
|
|
| `index.json` lists every segment with its summary. `viewer/` holds the cross sections the viewer draws (float32 line |
| pieces per z plane; the `.json` beside each `.bin` indexes them). `SHA256SUMS` covers every file. |
|
|
| ## Get it |
|
|
| ```bash |
| hf download SharpMeow/vesuvius-snapped-labels --repo-type dataset --local-dir snapped-labels |
| cd snapped-labels && sha256sum -c SHA256SUMS |
| ``` |
|
|
| One segment only: add `--include "PHerc0139/20250108000000-w025_2025010863/*"` (any path from `index.json`). |
|
|
| ## Load it |
|
|
| ```python |
| import io, json, urllib.request |
| import numpy as np, tifffile |
| from huggingface_hub import hf_hub_download |
| |
| seg = "PHerc0841/20260220213127-w00" |
| get = lambda p: hf_hub_download("SharpMeow/vesuvius-snapped-labels", f"{seg}/{p}", repo_type="dataset") |
| snapped = np.stack([tifffile.imread(get(f"snapped.tifxyz/{c}.tif")) for c in "xyz"], -1) |
| rec = json.load(open(get("release.json"))) |
| src = rec["source_mesh"] # the published mesh, on the open data |
| published = np.stack([tifffile.imread(io.BytesIO(urllib.request.urlopen(f"{src}/{c}.tif").read())) for c in "xyz"], -1) |
| ok = snapped[..., 0] != -1 |
| print("median move, voxels:", np.median(np.linalg.norm(snapped[ok] - published[ok], axis=1))) |
| ``` |
|
|
| `load_example.py` is a runnable version (it also reads a local copy with `--root`); it was run on this release |
| before upload. |
|
|
| ## How it was made |
|
|
| - **finesnap** (PHerc0139, PHerc0814, PHerc0841): each vertex's neighborhood in the label scan is registered to a |
| 2.4 µm scan of the same scroll, and the recto face is found there, as the edge of the bright papyrus band on the side |
| toward the scroll's center line. Where that fails, the face in the label scan is used (`source.tif` says which). |
| - **labelsnap** (PHerc0172): the face is found in the label scan itself. |
| - A vertex moves only along its normal. Where no face is measured at a vertex, it takes a Gaussian-weighted average |
| of its measured neighbors' offsets when one lies within two grid cells (`abstain.tif` = 2), and otherwise keeps |
| its published position (`abstain.tif` = 1). Filled vertices are not counted as snapped. The accuracy figures above |
| count every vertex of the tested snaps, filled ones included; the fill was not scored on its own. |
| - Segments were cut into overlapping row bands and run on CPU; the bands were stitched back and checked against |
| a whole-mesh run (identical for finesnap; for labelsnap 0.79% of vertices differ slightly, because its contrast floor |
| is set from each run's own profiles). |
|
|
| Scans and center lines: PHerc0139: 9.362 µm label scan `20250728140407`, finer scan 2.4 µm `20260102150214`; PHerc0814: 9.362 µm label scan `20250804134230`, finer scan 2.4 µm `20260309142202`; PHerc0841: 9.366 µm label scan `20250821151531`, finer scan 2.4 µm `20260319124803`; PHerc0172: 7.910 µm label scan `20241024131838` (the viewer shows its uncompressed twin `20241024131839`) |
|
|
| ## Notes |
|
|
| - A snap moves a vertex along its normal; it does not move a label that follows the wrong wrap onto the right one. |
| Where two sheets touch, the face it finds can belong to the neighbor. |
| - Some regions are held back for evaluation (`release_mask.tif` = 1), and 6 segments of the source sets |
| are not included. |
| - These are geometry: they say nothing about ink or text. |
|
|
| ## Changes |
|
|
| - **4 November 2026**: Scored against a finer scan's face found with labelsnap's own band rule; with a face rule sharing neither, the lead held at about half the size (+1.04, +1.23 voxels). No data file changed. |
| - **30 October 2026**: added the placement test against seven community snaps and its chart `community.png` (Model |
| output). No data file changed. |
| - **28 October 2026**: added the w033 snap loop and its sidecar (Model output). No data file changed. |
| - **1.0.1** (27 October 2026): `abstain.tif` now tells the two kinds of unmeasured vertex apart: 1 kept its |
| published position, 2 moved by the neighbor fill. In 1.0.0 both were 1, and this card said they all kept their |
| published position; in fact 97% of them had moved. The coordinates and every other grid are |
| unchanged; each mesh's `meta.json` note, `release.json` (new counts `filled` and `left_in_place`) and `index.json` |
| are updated. |
| - **1.0.0** (27 October 2026): first release. |
|
|
| ## Credit and terms |
|
|
| The scans and the published meshes are Vesuvius Challenge open data, CC BY-NC 4.0, credit to the people who traced |
| them; these derived meshes are shared under the same terms. Made by Chase Hendrick. |
|
|
