Lasagna Fields

Stream, download and load

Every field made here is also in the public bucket SharpMeow/lasagna-fields, so any tool that reads zarr over HTTPS opens it with no download and no account. Pick one of the first ten fields made here, with the villa lasagna model, to see its field, its numbers and the commands to get it; for any other field, Copy URL in the list gives its folder.

Model output: cos left, surface normals as color right

The bucket is laid out like the Vesuvius Challenge open data (SCAN/representations/predictions/lasagna/RUN/). villa's fields in the open data stream the same way from their run folder.

Anonymous HTTPS, CORS open, missing chunks read as empty

Install the Hugging Face client and zarr.

pip install -U "huggingface_hub[cli]" "zarr<3" numpy

Download, check, unpack. sha256sum -c SHA256SUMS checks every file. Unpack the fix tar last (the meta tar, for a Lasagnetta field): it holds the joined manifest, so it must overwrite the per-part ones.
Load it. The Load in Python tab reads a point; each dataset's load_example.py runs as is.

Click the map, or type a point in full-resolution scan voxels. The first command copies from the bucket only the chunks that cover your z range. The second downloads whole parts from the dataset: each scan was computed in boxes called parts, one tar each, and a region needs only the parts it touches plus one small tar with the joined manifest. Parts you skip read as empty; add --ignore-missing to the checksum check after a partial download.

Half size (voxels)

The Load in Python tab reads this point.

Open the arrays with zarr, tensorstore or any OME-Zarr viewer. Coordinates are the scan's own voxels, divided by 2 for cos and by 4 for the other channels. Normals are stored as uint8 as v × 127 + 128; nz is not stored, so take sqrt(1 - nx² - ny²). This reads a local copy at the point of the Only a region tab; Connect your tool reads straight from the bucket.

The same layout as the lasagna fields in the open data. Replace SCAN with the scan's name.

File	Read at	Scale	Stored as
`SCAN_cos.ome.zarr`	Level `1`	Every 2nd scan voxel	uint8; peaks on papyrus sheets and dips between them
`SCAN_grad_mag.ome.zarr`	Level `2`	Every 4th scan voxel	uint8 gradient magnitude, encoded as the manifest says (`grad_mag_encode_scale`)
`SCAN_nx.ome.zarr`, `SCAN_ny.ome.zarr`	Level `2`	Every 4th scan voxel	uint8 surface normal components, `v × 127 + 128`; `nz` not stored
`SCAN.lasagna.json`	The manifest the lasagna tools read: groups, their zarr paths (relative, to the four channels) and scale-downs, `base_shape_zyx` and the boxes computed
Every array	zarr v2, chunks 64 × 64 × 64, Blosc zstd level 3, fill value 0, axes z, y, x, each with coarser levels down to 4

Lasagnetta fields keep the same layout and channels. A field read at level 2 or 3 of a fine scan is on that level's grid: its levels are counted from that level, as its manifest's base_shape_zyx says, so multiply its coordinates by 4 or 8 for full resolution.

About these fields

A lasagna field is the input that the lasagna surface fit in villa reads. These are public so that nobody has to spend a GPU day before trying an idea on these scrolls: use them, compare against them, and tell us if you find a problem.

Limits. This is raw model output, and nobody has checked it by eye. Regions the masked scan leaves empty are absent (read as 0). The scan's ends include the mount, and the model produces values there too.

The scans are Vesuvius Challenge open data under CC BY-NC 4.0, and these derived fields are shared under the same terms. Model and code are ScrollPrize/villa's lasagna; credit to its authors. The fields listed from the open data are villa's own, published there by the Vesuvius Challenge; this page only links them. The other fields were computed and shared by Chase Hendrick, some with Lasagnetta, which was trained here to copy villa's lasagna.

How it was made every step ran on Hugging Face Jobs from scripts, with each part's record kept; nothing was edited by hand

Same settings as the published fields

The lasagna code in villa at commit db3dbea2, lasagna-preprocess predict3d --tile-size 192 with default chunks and levels, and the scrollprize/lasagna model model_current.pt at revision de45f011. On a test crop of PHerc0343 these settings reproduce the published lasagna field to within 2 of 255 at every voxel compared. Bigger tiles and torch.compile ran faster in testing but changed the output, so they were not used.

Split into parts that never share a chunk

Each scan was cut into boxes whose edges sit on multiples of 1,024 scan voxels, each small enough to finish in one Job. Because of that alignment, every chunk of every pyramid level is written by exactly one part, so the parts join without blending. PHerc0175A, the first scan, used an earlier layout whose coarsest level was rebuilt across tile edges; its card gives the details.

Predict on GPUs

One Job per part on an NVIDIA RTX PRO 6000, at the scan's native resolution with no resampling: parts in all.

Join and check

The parts were joined into one store, with a check that no chunk appears twice. A seam check then compares the step across each part edge with the steps beside it (1.0 means no step; the limit is 1.5). Finally the card's own load snippet was run on two real parts before upload.

One flag, checked properly

PHerc0841 flagged one edge: cos at z 1,024 stepped 1.62 times its neighbors. A single run straight across that edge gave the same field as the joined parts, byte for byte, in all 1,084 level-1 cos chunks and all 760 level-2 chunks of the four channels there. So that step is in the scan itself, not a seam.

Seven more scrolls, 29 October 2026

PHercMANBp and PHerc0343P got villa fields the same way from their 2.4 and 2.2 µm scans read at level 2, one 1,024-slice slab per part, with no step at any part edge (worst seam ratios 1.203 and 1.101). PHerc0009B, PHerc0172, PHerc0500P2, PHercMAN5 and PHercMANB got Lasagnetta 0.1.1 fields: three students averaged, cos blur 0.5, cos offset 0.04, part edges on multiples of 512 scan voxels, values kept only where the masked scan holds CT. Each card gives that scan's agreement with villa's net and what the release's self-check said there.

Publish with checksums, and unpacked for streaming

Each dataset carries SHA256SUMS, an index.json with every part's box and hash, the previews and the tested load example. The same parts were then unpacked into the public bucket, with the joined manifest written last, so tools can read chunks by URL.

Cite

Chase Hendrick (2026). Lasagna Fields: lasagna fields for Herculaneum scrolls.
Hugging Face. https://huggingface.co/spaces/SharpMeow/lasagna-fields
Computed with ScrollPrize/villa lasagna (db3dbea2) and scrollprize/lasagna (de45f011),
and with Lasagnetta 0.1.1 (SharpMeow/lasagnetta), on Vesuvius Challenge open data (CC BY-NC 4.0).

Lasagna fields for 24 Herculaneum scrolls

Every field, by scroll

Stream, download and load

About these fields