SharpMeow/vesuvius-snapped-labels

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.

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.

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

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

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

• 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.