docs(README): add HAADF npy workshop flow + acquisition params table

README.md

@@ -15,11 +15,11 @@ Reference electron-microscopy datasets for browsing and learning. Open them in y
 Two buckets, that's it:
 
 - **`4dstem/`** — 4D-STEM acquisitions. `_npy_bin*` variants are pre-binned NumPy files for fast workshop / Colab demos; the originals are full Arina h5 bundles.
-- **`haadf/`** — HAADF survey images.
+- **`haadf/`** — HAADF survey images. `_npy` variants are pre-cooked NumPy + a `meta.json` sidecar carrying sampling + optics; the originals are full Velox EMD files.
 
-## Quick start — Show4DSTEM in Google Colab (or any Jupyter)
+## Workshop quick start — Show4DSTEM (Google Colab or any Jupyter)
 
-Workshop path: just `quantem.widget` from TestPyPI + `huggingface_hub`. No CUDA, no h5, no quantem.live.
+Just `quantem.widget` from TestPyPI + `huggingface_hub`. No CUDA, no h5, no quantem.live.
 
 ```python
 !pip install -q --pre --extra-index-url https://test.pypi.org/simple/ quantem.widget huggingface_hub
@@ -28,50 +28,85 @@ import os, json, numpy as np, torch
 from huggingface_hub import snapshot_download
 from quantem.widget import Show4DSTEM
 
-# Pre-binned NumPy bundle — fast download, no decompression needed.
 folder = snapshot_download(
     "bobleesj/quantem-data",
     repo_type="dataset",
     allow_patterns=["4dstem/gold_512_npy_bin8/*"],
 )
 asset = os.path.join(folder, "4dstem", "gold_512_npy_bin8")
-data = np.load(os.path.join(asset, "data.npy"))          # (512, 512, 24, 24) uint16, ~300 MB
-meta = json.load(open(os.path.join(asset, "meta.json"))) # sampling + units
+data = np.load(os.path.join(asset, "data.npy"))            # (512, 512, 24, 24) uint16, ~300 MB
+meta = json.load(open(os.path.join(asset, "meta.json")))
 
 Show4DSTEM(torch.from_numpy(data), sampling=meta["sampling"], units=meta["units"])
 ```
 
 Drag the scan cursor in the real-space image; the CBED updates in real time. Chrome works best (WebGPU).
 
-For HAADF use `Show2D` with `quantem.live.io.read_image` (or load the `.emd` directly with `hyperspy`).
+## Workshop quick start — Show2D for HAADF
 
-## Datasets
+Same pattern; no Velox parser needed (the EMD has been pre-decoded to NumPy + a sampling sidecar).
+
+```python
+import os, json, numpy as np, torch
+from huggingface_hub import snapshot_download
+from quantem.widget import Show2D
+
+folder = snapshot_download(
+    "bobleesj/quantem-data",
+    repo_type="dataset",
+    allow_patterns=["haadf/gold_haadf_npy/*"],
+)
+asset = os.path.join(folder, "haadf", "gold_haadf_npy")
+img  = np.load(os.path.join(asset, "data.npy"))            # (4096, 4096) uint16
+meta = json.load(open(os.path.join(asset, "meta.json")))
+
+Show2D(torch.from_numpy(img), sampling=meta["sampling"], units=meta["units"])
+```
+
+## Acquisition parameters
+
+| dataset | voltage | probe | scan | scan sampling | det pitch | mag | format |
+|---|---|---|---|---|---|---|---|
+| `haadf/gold_haadf_npy` | 300 kV | 30 mrad | 4096² image | 0.0186 nm/px | n/a | FOV 76.2 nm | Velox EMD → NumPy |
+| `4dstem/gold_512_npy_bin8` | 200 kV | 30 mrad (op) | 512² | 0.5 Å (op) | 3.68 mrad/px | (unknown) | NumPy bundle |
+| `4dstem/gold_512_npy_bin4` | 200 kV | 30 mrad (op) | 512² | 0.5 Å (op) | 1.84 mrad/px | (unknown) | NumPy bundle |
+| `4dstem/gold_512` | 200 kV | 30 mrad (op) | 512² | 0.5 Å (op) | 0.46 mrad/px | (unknown) | Arina h5 |
+| `4dstem/gold_30mrad1.3mx04` … `09` | 200 kV | 30 mrad | smaller | (session yaml) | 0.46 mrad/px | 1.3 Mx | Arina h5 |
+| `haadf/gold_haadf.emd` | 300 kV | 30 mrad | 4096² image | 0.0186 nm/px | n/a | FOV 76.2 nm | Velox EMD |
+
+`(op)` = operator-supplied, not stored in the file. Arina h5 records detector + scan count but no optics; the optics live in the operator's session yaml. EMD carries full optics (BeamConvergence, CameraLength, AccelerationVoltage, pixel sizes).
+
+## Datasets at a glance
 
 | name | kind | shape | dtype | size | use |
 |---|---|---|---|---|---|
 | `4dstem/gold_512_npy_bin8/` | NumPy bundle | (512, 512, 24, 24) | uint16 | ~302 MB | workshop / Colab demo |
-| `4dstem/gold_512_npy_bin4/` | NumPy bundle | (512, 512, 48, 48) | uint16 | ~1.2 GB | sharper version |
-| `4dstem/gold_512/` | Arina h5 (full) | (512, 512, 192, 192) | uint16 | ~5 GB | power user, full data |
-| `4dstem/gold_30mrad1.3mx04` …`09` | Arina h5 (full) | smaller scans | uint16 | ~5 GB each | series demo |
-| `haadf/gold_haadf.emd` | Velox EMD | (4096, 4096) | float32 | a few MB | Show2D |
+| `4dstem/gold_512_npy_bin4/` | NumPy bundle | (512, 512, 48, 48) | uint16 | ~1.2 GB | sharper workshop version |
+| `4dstem/gold_512/` | Arina h5 (full) | (512, 512, 192, 192) | uint16 | ~5 GB | power user |
+| `4dstem/gold_30mrad1.3mx04` … `09` | Arina h5 (full) | varies | uint16 | ~5 GB each | series demo |
+| `haadf/gold_haadf_npy/` | NumPy bundle | (4096, 4096) | uint16 | ~34 MB | workshop / Colab Show2D |
+| `haadf/gold_haadf.emd` | Velox EMD | (4096, 4096) | uint16 | a few MB | full optics carrier |
 
-Each `_npy_*` bundle ships a `meta.json` next to `data.npy`: `shape`, `dtype`, `sampling`, `units`, `bin_factor`, original source.
+Each `_npy*` bundle ships a `meta.json` next to `data.npy`: shape, dtype, sampling, units, plus voltage / probe / camera length / FOV when known.
 
 ## Power-user path (full data, GPU decompression)
 
-If you have an NVIDIA GPU and want the full uncooked h5 path, install `quantem.live` (private):
+Have an NVIDIA GPU and want the full uncooked h5 / EMD? Install [`quantem.live`](https://github.com/bobleesj/quantem.live) — it carries a sampling-aware loader (`io.read_image` → `Dataset2d` → `Show2D` for HAADF; `io.load` for 4D-STEM):
 
 ```python
 from quantem.live import io
-from quantem.widget import Show4DSTEM
+from quantem.widget import Show4DSTEM, Show2D
 import torch
 
-folder = io.download("gold_512")                              # → 4dstem/gold_512/
-result = io.load(io.discover_masters(folder)[0], det_bin=2)   # GPU decompression
+# 4D-STEM, full Arina h5 → GPU
+folder = io.download("gold_512")
+result = io.load(io.discover_masters(folder)[0], det_bin=2)
 Show4DSTEM(torch.from_dlpack(result.data))
-```
 
-Same data, full Arina h5, decompressed on the GPU. Faster + full resolution.
+# HAADF, full Velox EMD with sampling carried through
+ds = io.read_image(io.download("gold_haadf"))                 # → Dataset2d
+Show2D(ds)                                                    # sampling auto-picked
+```
 
 ## Memory (VRAM) for the full h5