The center lines of thirty-three scans

The Herculaneum scrolls are rolls of papyrus that the eruption of Vesuvius in 79 AD carbonized. They are too fragile to unroll, so the Vesuvius Challenge scans them with X-ray CT, and people and programs trace the wound sheet in 3D to unwrap it virtually. A scroll is wound around a center. The center line, or umbilicus, follows that center from the bottom of the scan to the top. Tracing tools start from it, so a good line for every scan saves everyone time.

This page draws every public center line we know of for the 22 scans on the prize page (the 21 First Letters volumes and PHerc1447, read 23 October 2026) and for 13 other public scans that are not on the prize page (listed last, under NOT ON THE PRIZE PAGE; 11 since 1.8.0, PHerc1667 and PHerc0172 since 1.10.0): 35 scans, 57 lines from 6 sources.

How to look around

1. Array stands every scan's lines side by side at true height. Drag to orbit, scroll or pinch to zoom, hover for names. The front rows hold the prize scans (lines made by people behind, the Center Finder's in front); the back row holds the scans not on the prize page.
2. Click a scan (in the 3D view or the list) to open its X-ray: a radiograph your browser builds from CT it streams from the open data, with the lines inside. The list steps aside there; the menu next to the scan's name on its card opens another scan.
3. The square at the bottom right is one horizontal slice through the scan. Drag its slider or scroll over it to move up and down. Rings mark where each line crosses that slice; a good line sits in the middle of the innermost turns.
4. Lasagna shows villa's sheet model on PHerc0175A: where it thinks papyrus is, and which way each sheet faces.
5. Data opens every number on this page as tables you can sort and download.
6. Hide a line: click a maker in the key under the list to hide all of its lines, or untick one line on a scan card. The link you copy keeps what you hid.

Colors and grades

Each maker has its own color: Vesuvius Challenge, Alexey Drobkov, Abd Elilah, Iyan Dopico, all made by people. Amber lines are model output from Chase Hendrick's Center Finder, made for the nine 1.2 m prize scans nobody had traced and for nine scans not on the prize page (seven since 1.8.0, PHerc1667 and PHerc0172 since 1.10.0); no person has checked their ends on CT. Lime lines are the Center Finder lines after the coverage polish (Scrolls kit axispolish), marked NEWEST: the twelve on 1.2 m scans since 1.9.0, and since 1.10.0 three on 2.4 µm scans (PHerc1299, PHercMAN5, PHercMANB), where the polish ran on level 2 and is untested. The originals stay on the page, faded and marked SUPERSEDED, so a later polish can replace a line without losing the one before: on all ten scans of a frozen test the 1.2 m polished lines sat deeper in villa's traced sheet than the line before the polish, and kit takes them first, but they are jumpier and their ends were not re-checked, so the grades below are the original line's. An automatic CT end check graded each end of each Center Finder line (release v2.2, 23 Oct 2026). It compares the end with the scroll center the CT itself shows there, estimated from the scan alone (sheet orientations in three slices, never the line), 0, 1 and 2 mm inside the end, with a 4 mm bar. A planted fake tilt is caught at all 18 ends. 14 of the 18 ends pass and 4 are flagged. The same check on the seven newer lines (24 Oct 2026) passes all 14 ends, 2 after a CT recap, but four of those scans are 2.4 µm scans the check was never tuned on, so their grades are marked untested and no end there is usable. Of the two lines added in release v2.6 (25 Oct 2026), PHerc1667's (a 2.4 µm scan) passes both ends, untested, and PHerc0172's (a 7.91 µm scan) is flagged at both ends, so treat its ends with care.

Scan names and grades use a traffic light: green when both ends passed, yellow for caution (a pass that rests on a CT recap, an end the check could not judge, or an untested scan), red when an end was flagged.

• PASS both ends passed.
• VOID the planted tilt was not caught at an end, so the check cannot judge it (none here).
• FLAG one end sits more than 4 mm from the center the CT shows there; the card names which end.
• PASSCT recap marks a passing end whose last 10 mm was replaced by a straight fit to the CT at heights the check doesn't judge, so the pass says the CT supports that end, not that a separate check confirmed it.

The grades come from an automatic check only. Model output: no end has been checked on CT by a person. Each line's card says which of its ends are usable. A faded line is one its author withdrew from recommended use.

A center line is geometry. Nothing here is a reading of any text.

Every line is a JSON file in SharpMeow/vesuvius-center-lines: a list control_points of {"x", "y", "z"} in the level-0 voxels of the scan the file names, plus a metadata block in most files. Each scan card has a download link per line, a copy URL for its raw file, the scan's OME-Zarr URL, and copy x,y,z for the crossing on the slice you are looking at. copy kit command gives a line for the Scrolls kit (python -m kit centerline get SCROLL --source NAME --into FOLDER) that downloads the line, checks its sha256 against the dataset's index and writes it as FOLDER/umbilicus.json; it will not overwrite an existing umbilicus.json without --force, and it refuses a folder that holds estimated_umbilicus.json, because VC3D stops at two umbilicus files unless the project's "umbilicus" field names one.

VC3D

VC3D (volume-cartographer in villa) reads an umbilicus JSON that is a bare array of points, or an object with points or control_points; every point needs x, y and z. It also reads an optional metadata block: voxelsize_um, volume, and the grid volume_width, volume_height, volume_slices, all three or none. 22 of the files here carry that stamp, matching their scan's level-0 grid; the others are bare points. Between control points VC3D interpolates linearly; past the last point it holds that point's x and y.

Source: villa main, volume-cartographer/core/src/Umbilicus.cpp, read 23 Oct 2026.

villa spiral fitting

villa's spiral tutorial (last updated 16 Sep 2026) calls the umbilicus required: fit_spiral.py takes a --dataset root and reads umbilicus.json from it, beside lasagna_inputs/*.ome.zarr and the other inputs, and infer_winding_volume.py takes --umbilicus (or finds it from the checkpoint's dataset). Every input has to be in the fit's own voxel frame.

spiral-fitting's JSON reader sorts control_points by z, multiplies x, y and z by coordinate_scale (or 1/downsample_factor), ignores metadata, and extrapolates linearly past both ends. The files here are level 0, so a fit on pyramid level L needs a scale of 1/2^L. Because VC3D holds the ends and the fit extrapolates them, the same file can behave differently above and below its last points: check the line's usable ends first.

Sources: the tutorial above; villa main, spiral-fitting/umbilicus.py, read 23 Oct 2026.

villa lasagna

villa's lasagna predict3d is, in its README's words, "the Lasagna cos/normal wrapper around the shared 3D tiled inference code". The PHerc0175A field in the Lasagna view is its output on the whole scan, in villa's own OME-Zarr layout: SharpMeow/pherc0175a-lasagna.

In Python

Read a line and find its center at any height, the way both readers do between points:

Read the CT voxel under it straight from the open data (levels here are raw uint8 in 128-voxel chunks, so one HTTP range read is one axial row of a chunk; a 404 is a masked, empty chunk; on PHerc0172, whose chunks are Blosc-compressed, the snippet reads and decodes a whole chunk instead):

Both snippets were run against the live dataset and bucket on 23 Oct 2026, and the Blosc variant on PHerc0172 on 27 Oct 2026. They use the selected scan when one is open.

Every statistic below is in the Data tables and the downloads, computed in your browser from the control points (rounded to whole level-0 voxels; the downloaded files keep full precision). Millimeters use each scan's voxel size.

How to read them

• Where a scan has two lines, the gap shows how far two independent tracings disagree. It does not say which one is closer to the true center.
• A line's own spread (stray, wiggle) is not an error. Scrolls are crushed and bent, so the center can wander; a straight line through a bent scroll would be wrong.
• The end check grade applies only to Center Finder lines. Person-made lines have no grade here; that is not a pass.
• The radiograph is a view, not a measurement: it uses scan level 5 (32 times coarser than level 0), with a z stride, and a display curve.

For agents

Everything is scriptable through window.umbilici in a browser or headless Chromium: scans(), lines(scroll), at(scroll, z), stats(scroll), table(), csv('lines' | 'scans' | 'points'), select(scroll, mode), mode(m), setZ(z), state(), image(), slice(). URL parameters: ?mode=scan&scan=PHerc0191&z=10400, ?guide=vc3d, ?data=lines.

Lines

• Dataset SharpMeow/vesuvius-center-lines, release . Frame: . Each file's sha256 is in the dataset's index.json and SHA256SUMS, and in the Data table.
• This page's copy is data/lines.json, built by tools/build_lines.py: control points (sorted by z, rounded to whole voxels), the public index fields, each file's frame stamp, and each scan's OME-Zarr pyramid read from the bucket. Nothing else from the files' metadata is copied.
• Scan ids are the 14-digit time stamps in the volume names. A line belongs to one scan; moving it to another scan of the same scroll needs a registration.

CT

• Read live from vesuvius-challenge-open-data.s3.us-east-1.amazonaws.com, OME-Zarr v2, never stored on this Space. The bucket allows cross-origin range reads.
• All 210 pyramid levels of the 35 scans (6 each) are uint8 in 128 x 128 x 128 chunks, checked when lines.json was built. All but one scan's have no compressor. PHerc0172's 7.91 µm scan (added in 1.10.0) is stored with Blosc (zstd), so a chunk cannot be read one plane at a time: the page draws its line without CT, and its card says so. Level L has voxels 2^L times the level-0 size. Each scan card's "CT pyramid" lists its shapes.
• The page reads one axial plane of a chunk per request (16,384 bytes). Masked chunks outside the scroll are absent and read as empty. The 3D view uses level 5 with a z stride (at most 120 heights, 72 on touch screens; every fourth height first). A 2.4 µm scan's level-5 plane is up to 1,326 px across, so it keeps every second or third pixel (at most 640 across) and reads fewer heights (at least 24, about 2,400 range reads a scan). The slice uses level 4, then level 3, with a 1st to 99.5th percentile window; on a 2.4 µm scan it uses level 5 (77 µm pixels, close to a 1.2 m scan's level 3), the coarsest its pyramid has.

Lasagna field, PHerc0175A

• Source: villa lasagna predict3d over the whole scan (ScrollPrize/villa db3dbea2, model scrollprize/lasagna de45f011), in SharpMeow/pherc0175a-lasagna: cos at OME-Zarr level 1 (2x down), grad_mag, nx and ny at level 2 (4x down), each with its pyramid. Normals are stored as uint8, v x 127 + 128; nz is not stored.
• This page's derivative (data/lasagna/, by tools/build_lasagna.py):
• Raw model output; nobody has checked it by eye.

Lines and their makers

Data and code

• CT scans: Vesuvius Challenge open data, CC BY-NC 4.0.
• Lasagna: ScrollPrize/villa and scrollprize/lasagna; the field dataset is CC BY-NC 4.0.
• The lines bundle is non-commercial because some files are; each file keeps its own license (above).
• This page: Apache 2.0, by Chase Hendrick, a sibling of Unroll. three.js is MIT.

A center line is geometry. Nothing here is a reading of any text.