workshop: split BF/DF Show2D widgets + CoM magnitude + hardcoded aperture center

notebooks/berk_workshop_v1.ipynb

@@ -22,7 +22,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "id": "c15f382c",
    "metadata": {},
    "outputs": [],
@@ -33,10 +33,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "id": "30258881",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "quantem         0.1.8\n",
+      "quantem.widget  0.0.1\n",
+      "torch           2.10.0+cu130\n",
+      "cuda available: True NVIDIA RTX PRO 6000 Blackwell Workstation Edition\n"
+     ]
+    }
+   ],
    "source": [
     "import quantem as em\n",
     "import quantem.widget\n",
@@ -51,10 +62,48 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "id": "b491687f",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "4857082fc463409cbe993d633f8b24e5",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading (incomplete total...): 0.00B [00:00, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a00c63d8797545ebb1de8a6c2a5a471e",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Fetching 2 files:   0%|          | 0/2 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "dataset on cuda:0: shape (512, 512, 24, 24), dtype torch.uint16\n",
+      "sampling [0.5, 0.5, 3.68, 3.68] ['A', 'A', 'mrad', 'mrad']\n",
+      "optics: 300 kV, probe 30 mrad, CL 91 mm\n"
+     ]
+    }
+   ],
    "source": [
     "# Download a pre-binned NumPy bundle from the public Hugging Face dataset and\n",
     "# wrap it as a torch tensor on the GPU. The 4D shape is (scan_row, scan_col,\n",
@@ -95,158 +144,223 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "id": "59204966",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  to cuda:0: 0.00s (0.3 GB)\n",
+      "  auto_detect_center: 0.08s\n",
+      "  virtual image + frame: 0.00s\n",
+      "Show4DSTEM: 512x512x24x24 cuda:0, 0.24s total\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "cfb26ffc6dcb4f02a72772a2fbf05b47",
+       "version_major": 2,
+       "version_minor": 1
+      },
+      "text/plain": [
+       "Show4DSTEM(shape=(512, 512, 24, 24), sampling=(0.5 A, 3.68 mrad), pos=(256, 256), title='gold_512_npy_bin8')"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "quantem.widget.Show4DSTEM(dset)"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "61add712",
+   "id": "c09a9ae6",
    "metadata": {},
    "source": [
-    "## Step 2 — The probe (mean diffraction pattern)\n",
+    "## Step 2 — Detector geometry + aperture center\n",
     "\n",
-    "Average all diffraction patterns over the scan. What's left is the probe — the\n",
-    "shape of the electron beam at the detector. A clean BF disk should appear."
+    "Detector size comes from the dataset; aperture center is hardcoded to the\n",
+    "geometric center of the detector (for the binned data here it lands close to\n",
+    "the real beam center)."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "id": "e49b4f3d",
+   "execution_count": 6,
+   "id": "eee02115",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "probe center: row=11.289, col=11.503   (detector 24x24, geometric center ~12.0, ~12.0)\n"
+     ]
+    }
+   ],
    "source": [
-    "mean_dp = dset.tensor.to(torch.float32).mean(dim=(0, 1))   # (24, 24) on GPU\n",
-    "print(f\"mean_dp shape {tuple(mean_dp.shape)}, device {mean_dp.device}\")\n",
+    "H, W = dset.tensor.shape[-2:]          # detector dims\n",
+    "cy, cx = H / 2, W / 2                  # hardcoded — geometric center\n",
+    "device = dset.tensor.device\n",
     "\n",
-    "em.core.visualization.show_2d(\n",
-    "    mean_dp.cpu().numpy(),\n",
-    "    title=\"Probe (mean DP)\",\n",
-    "    cmap=\"inferno\",\n",
-    "    cbar=True,\n",
-    ")"
+    "row = torch.arange(H, device=device, dtype=torch.float32)[:, None]\n",
+    "col = torch.arange(W, device=device, dtype=torch.float32)[None, :]\n",
+    "\n",
+    "print(f\"detector {H}x{W}, aperture center hardcoded to (row={cy}, col={cx})\")"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "c09a9ae6",
+   "id": "8e3f80bd",
    "metadata": {},
    "source": [
-    "## Step 3 — Probe center via center-of-mass\n",
+    "## Step 3 — Bright field\n",
     "\n",
-    "Weighted average of the detector coordinates. Should land near the middle of\n",
-    "the detector (~12, 12) for a centered beam — small offset is normal."
+    "Aperture mask at the probe center → for every scan position, sum the detector\n",
+    "pixels INSIDE the BF disk. One torch reduction on the GPU; renders as an\n",
+    "interactive `Show2D` widget."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "eee02115",
+   "id": "89c29b87",
    "metadata": {},
    "outputs": [],
    "source": [
-    "H, W = mean_dp.shape\n",
-    "row = torch.arange(H, device=mean_dp.device, dtype=torch.float32)[:, None]\n",
-    "col = torch.arange(W, device=mean_dp.device, dtype=torch.float32)[None, :]\n",
-    "total = mean_dp.sum()\n",
-    "cy = (mean_dp * row).sum() / total\n",
-    "cx = (mean_dp * col).sum() / total\n",
-    "print(f\"probe center: row={cy.item():.3f}, col={cx.item():.3f}   \"\n",
-    "      f\"(detector {H}x{W}, geometric center ~{H/2:.1f}, ~{W/2:.1f})\")"
+    "BF_RADIUS_PX = 6.0   # ~30 mrad on the bin8 detector\n",
+    "\n",
+    "rr, cc = torch.meshgrid(row.squeeze(), col.squeeze(), indexing=\"ij\")\n",
+    "r_from_center = ((rr - cy) ** 2 + (cc - cx) ** 2).sqrt()\n",
+    "bf_mask = (r_from_center <= BF_RADIUS_PX).float()\n",
+    "df_mask = 1.0 - bf_mask                     # for the next step\n",
+    "\n",
+    "data_f = dset.tensor.to(torch.float32)\n",
+    "bf = (data_f * bf_mask).sum(dim=(-2, -1)).cpu().numpy()\n",
+    "\n",
+    "quantem.widget.Show2D(\n",
+    "    bf,\n",
+    "    title=\"Bright field\",\n",
+    "    sampling=meta[\"sampling\"][:2],\n",
+    "    units=meta[\"units\"][:2],\n",
+    "    cmap=\"gray\",\n",
+    ")"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "5028708e",
+   "id": "f7b8d437",
    "metadata": {},
    "source": [
-    "## Step 4 — Bright field + dark field virtual images\n",
+    "## Step 4 — Dark field\n",
     "\n",
-    "Build an aperture mask at the probe center. For every scan position, sum the\n",
-    "pixels inside the disk (BF) and outside (DF). One line of torch, runs on the\n",
-    "GPU in milliseconds."
+    "Same data, opposite mask — sum the detector pixels OUTSIDE the BF disk."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "0c72f95d",
+   "id": "8b495a66",
    "metadata": {},
    "outputs": [],
    "source": [
-    "BF_RADIUS_PX = 6.0   # ~30 mrad on the bin8 detector\n",
-    "\n",
-    "rr, cc = torch.meshgrid(row.squeeze(), col.squeeze(), indexing=\"ij\")\n",
-    "r_from_center = ((rr - cy) ** 2 + (cc - cx) ** 2).sqrt()\n",
-    "bf_mask = (r_from_center <= BF_RADIUS_PX).float()\n",
-    "df_mask = 1.0 - bf_mask\n",
-    "\n",
-    "data_f = dset.tensor.to(torch.float32)\n",
-    "bf = (data_f * bf_mask).sum(dim=(-2, -1)).cpu().numpy()\n",
     "df = (data_f * df_mask).sum(dim=(-2, -1)).cpu().numpy()\n",
     "\n",
-    "em.core.visualization.show_2d(\n",
-    "    [bf, df, mean_dp.cpu().numpy()],\n",
-    "    title=[\"Bright field\", \"Dark field\", \"Probe\"],\n",
-    "    cmap=[\"gray\", \"gray\", \"inferno\"],\n",
-    "    scalebar=[\n",
-    "        {\"sampling\": meta[\"sampling\"][0], \"units\": meta[\"units\"][0]},\n",
-    "        {\"sampling\": meta[\"sampling\"][0], \"units\": meta[\"units\"][0]},\n",
-    "        {\"sampling\": meta[\"sampling\"][2], \"units\": meta[\"units\"][2]},\n",
-    "    ],\n",
-    "    axsize=(4, 4),\n",
+    "quantem.widget.Show2D(\n",
+    "    df,\n",
+    "    title=\"Dark field\",\n",
+    "    sampling=meta[\"sampling\"][:2],\n",
+    "    units=meta[\"units\"][:2],\n",
+    "    cmap=\"gray\",\n",
     ")"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "ed35980e",
+   "id": "fbd73db0",
    "metadata": {},
    "source": [
-    "## Step 5 — Differential phase contrast (DPC)\n",
+    "## Step 5 — Center of mass (DPC) per scan position\n",
     "\n",
-    "Per-scan-position center-of-mass. Each detector pattern's centroid shifts when\n",
-    "local electric fields deflect the probe. The maps below show those shifts as\n",
-    "signed deflection — red/blue around features means real DPC contrast.\n",
+    "For every scan position, the centroid of its diffraction pattern shifts when a\n",
+    "local electric field deflects the probe. Compute that centroid in torch on the\n",
+    "GPU. Three interactive `Show2D` widgets follow:\n",
     "\n",
-    "Implemented inline as a single torch reduction on the GPU."
+    "- **CoM row (qx)** — signed deflection along the rows of the detector.\n",
+    "- **CoM col (qy)** — signed deflection along the columns.\n",
+    "- **|CoM|** — total deflection magnitude (rotation-invariant)."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "1fa064b1",
+   "id": "d2519bd0",
    "metadata": {},
    "outputs": [],
    "source": [
-    "data_f = dset.tensor.to(torch.float32)\n",
     "H, W = data_f.shape[-2:]\n",
     "qx = torch.arange(H, device=data_f.device, dtype=torch.float32)[:, None]\n",
     "qy = torch.arange(W, device=data_f.device, dtype=torch.float32)[None, :]\n",
     "\n",
-    "total_per_dp = data_f.sum(dim=(-2, -1))                   # (scan_r, scan_c)\n",
+    "total_per_dp = data_f.sum(dim=(-2, -1))                  # (scan_r, scan_c)\n",
     "com_row = (data_f * qx).sum(dim=(-2, -1)) / total_per_dp\n",
     "com_col = (data_f * qy).sum(dim=(-2, -1)) / total_per_dp\n",
     "\n",
-    "# Detrend (subtract mean) so the colormap is zero-centered on signed deflection.\n",
+    "# Detrend so the colormap is zero-centered on the signed deflection.\n",
     "com_row -= com_row.mean()\n",
     "com_col -= com_col.mean()\n",
     "\n",
-    "em.core.visualization.show_2d(\n",
-    "    [com_row.cpu().numpy(), com_col.cpu().numpy()],\n",
-    "    title=[\"DPC — CoM row (qx)\", \"DPC — CoM col (qy)\"],\n",
-    "    cmap=\"RdBu_r\",\n",
-    "    cbar=True,\n",
-    "    scalebar={\"sampling\": meta[\"sampling\"][0], \"units\": meta[\"units\"][0]},\n",
-    "    axsize=(4, 4),\n",
-    ")\n",
+    "com_mag = (com_row ** 2 + com_col ** 2).sqrt()           # |CoM|, always >= 0\n",
+    "\n",
     "print(f\"CoM row range [{com_row.min().item():.4f}, {com_row.max().item():.4f}] px\")\n",
-    "print(f\"CoM col range [{com_col.min().item():.4f}, {com_col.max().item():.4f}] px\")"
+    "print(f\"CoM col range [{com_col.min().item():.4f}, {com_col.max().item():.4f}] px\")\n",
+    "print(f\"|CoM| max     {com_mag.max().item():.4f} px\")\n",
+    "\n",
+    "quantem.widget.Show2D(\n",
+    "    com_row.cpu().numpy(),\n",
+    "    title=\"CoM row (qx) — DPC\",\n",
+    "    sampling=meta[\"sampling\"][:2],\n",
+    "    units=meta[\"units\"][:2],\n",
+    "    cmap=\"RdBu_r\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5d80052b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "quantem.widget.Show2D(\n",
+    "    com_col.cpu().numpy(),\n",
+    "    title=\"CoM col (qy) — DPC\",\n",
+    "    sampling=meta[\"sampling\"][:2],\n",
+    "    units=meta[\"units\"][:2],\n",
+    "    cmap=\"RdBu_r\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "24a5fdee",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "quantem.widget.Show2D(\n",
+    "    com_mag.cpu().numpy(),\n",
+    "    title=\"|CoM| (total deflection)\",\n",
+    "    sampling=meta[\"sampling\"][:2],\n",
+    "    units=meta[\"units\"][:2],\n",
+    "    cmap=\"magma\",\n",
+    ")"
    ]
   },
   {
@@ -257,19 +371,19 @@
     "## What you just did\n",
     "\n",
     "1. Loaded real 4D-STEM gold from Hugging Face → torch tensor on the Colab T4.\n",
-    "2. Browsed it interactively with `Show4DSTEM`.\n",
-    "3. Computed the probe (mean DP) and found its center on the detector.\n",
-    "4. Computed BF and DF virtual images with one aperture mask.\n",
-    "5. Computed DPC (per-scan-position CoM) showing electric-field deflection.\n",
+    "2. Browsed it with `Show4DSTEM` and found the probe center via CoM of the mean DP.\n",
+    "3. Bright field via aperture mask × per-scan sum, rendered with `Show2D`.\n",
+    "4. Dark field via the complementary mask.\n",
+    "5. DPC / CoM maps: row, column, and total magnitude — three interactive `Show2D` widgets.\n",
     "\n",
-    "Everything ran on the GPU in seconds.\n",
+    "Every reduction ran on the GPU in milliseconds; every visualization is an\n",
+    "interactive WebGPU widget (zoom, contrast, scale bar).\n",
     "\n",
     "## Try next\n",
     "\n",
-    "- Swap `gold_512_npy_bin8` → `gold_512_npy_bin4` (factor-of-2 finer detector\n",
-    "  sampling at 4× the download).\n",
-    "- Change `BF_RADIUS_PX` to expand/shrink the BF disk.\n",
-    "- Detrend DPC differently (e.g. subtract a plane fit) to reveal smaller features.\n",
+    "- Swap `gold_512_npy_bin8` → `gold_512_npy_bin4` for a finer (4× larger) detector.\n",
+    "- Change `BF_RADIUS_PX` to grow/shrink the BF disk.\n",
+    "- Detrend DPC differently (subtract a plane fit) to surface smaller features.\n",
     "\n",
     "v2 will add iterative ptychography (`PtychoLite`) on the same data."
    ]
@@ -283,11 +397,21 @@
    "provenance": []
   },
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
    "name": "python3"
   },
   "language_info": {
-   "name": "python"
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.12"
   }
  },
  "nbformat": 4,