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

![Published label (orange) and snapped label (blue) on PHerc0139 CT, segment w054](preview-0139.png)

On fresh test sites, scored against the recto face seen in an independent 1.129 µm scan:

![Vertices within 1 voxel of the recto face: published labels against the two snaps](accuracy.png)

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

![Distance gained toward the recto face over the published label, 71 fresh sites pooled: labelsnap +2.15 voxels, seven community snaps from +0.26 to -0.41 and vc_objrefine with its shipped thresholds off the scale](community.png)

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

![Four stops along PHerc0139 w054 at z 8048: published, snapped, both](snapped-0139.gif)

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

![Model output: PHerc0139 w033 at z 7600, published label (orange) moving onto the snapped label (blue) and back](snap-pherc0139-w033-z7600.gif)

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.