{ "cells": [ { "cell_type": "markdown", "id": "0b54050c3b95", "metadata": {}, "source": [ "# MxN multi-widget editor: layout as code\n", "\n", "The MxN multi-widget editor lets you build arbitrary grids of synchronised\n", "render windows. This notebook walks through a multimodal storyline (CT next\n", "to MR), and along the way demonstrates the GET-modify-PUT pattern for\n", "*layout-as-code*: the same Python DSL builds layouts from scratch, parses\n", "the workbench's live layout, and validates documents before they cross the\n", "network.\n", "\n", "You will learn how to:\n", "\n", "- Open the MxN editor and inspect its current layout\n", "- Build a typed `MxNLayoutDocument` and apply it via `set_layout`\n", "- Use semantic window ids that encode modality and anatomical plane\n", "- Drive per-cell node visibility so each cell shows only what it should\n", "- Move the crosshair and observe synchronised updates across cells\n", "\n", "**Prerequisites**\n", "\n", "- A running MITK Workbench at `http://localhost:8080`.\n", "- The **MxN multi-widget editor** must be open in the workbench before\n", " you run the notebook. Open it via *Window > New Editor > MxN*\n", " (or switch to a perspective that includes it). `wb.show()` does\n", " not open MxN -- the StdMultiWidget gets shown instead.\n", "- The optional `mitk` Python package (provides `mitk.mxn.layout`). This\n", " package ships with a local MITK build's Python wrapping; it is not\n", " available from public PyPI. Without it, the typed DSL paths\n", " (`get_layout`, `set_layout(doc)`, `update_layout`, ...) raise\n", " `ImportError`. The raw-dict path (`get_layout_json`,\n", " `set_layout(dict)`) is always available -- see the callout near the\n", " end of this notebook.\n", "- Install the library with the layout extra:\n", " `pip install -e \".[layout]\"` from the repo root.\n" ] }, { "cell_type": "markdown", "id": "3a0b6e81eb76", "metadata": {}, "source": [ "## 1. Connect and import the DSL\n", "\n", "The DSL is gated on the optional `mitk` package. We fail loudly with an\n", "actionable message if it is missing -- the raw-dict path remains usable\n", "without it, but every cell below uses the typed builders.\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "98d888085c2d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Connected to MITK Workbench REST API; mitk.mxn.layout DSL loaded.\n" ] } ], "source": [ "import mitk_workbench_remote as mw\n", "from mitk_workbench_remote.examples import phantoms\n", "\n", "wb = mw.connect(\"http://localhost:8080\")\n", "if not wb.ping():\n", " raise SystemExit(\"Workbench unreachable at http://localhost:8080. Start it and re-run.\")\n", "\n", "try:\n", " from mitk.mxn.layout import (\n", " LayoutWindow,\n", " MxNLayoutDocument,\n", " Split,\n", " ViewDirection,\n", " )\n", "except ImportError as exc:\n", " raise SystemExit(\n", " \"This notebook requires the optional 'mitk' package. \"\n", " \"Build it from a local MITK CMake build (Wrapping/Python) and install the wheel.\"\n", " ) from exc\n", "\n", "print(f\"Connected to {wb.info.name}; mitk.mxn.layout DSL loaded.\")\n", "\n", "if not wb.mxn.get_info().active:\n", " raise SystemExit(\n", " \"The MxN multi-widget editor is not open in the workbench. \"\n", " \"Open it via 'Window > New Editor > MxN' and re-run.\"\n", " )\n" ] }, { "cell_type": "markdown", "id": "7a54dc34dd6e", "metadata": {}, "source": [ "## 2. Two modalities -- one body, two textures\n", "\n", "We use a deliberately simplified phantom: the body and a small offset\n", "tumor. The shape primitives differ by modality so the two volumes are\n", "visually distinct -- spheres for MR, cubes for CT -- but they share the\n", "same geometry so they overlay cleanly.\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "91ffb43d983d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Loaded and .\n" ] } ], "source": [ "mr_image = phantoms.make_body_with_tumor(\"mr\")\n", "ct_image = phantoms.make_body_with_tumor(\"ct\")\n", "\n", "mr_node = wb.show(mr_image, name=\"MR\", color=(0.95, 0.30, 0.30))\n", "ct_node = wb.show(ct_image, name=\"CT\", color=(0.30, 0.55, 0.95))\n", "print(f\"Loaded {mr_node} and {ct_node}.\")\n" ] }, { "cell_type": "markdown", "id": "af815a8b9156", "metadata": {}, "source": [ "## 3. Open the MxN editor with the default layout\n", "\n", "`wb.mxn` returns a stateless handle to the MxN editor. Out of the box the\n", "editor opens with a single cell, so both modalities currently render in the\n", "same window. To see them overlaid, we put MR on top and dial its opacity\n", "down to 0.5.\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "faa25c9a3d5d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "alias=mxn active=True cells=('mxn__ct_axial', 'mxn__ct_coronal', 'mxn__ct_sagittal', 'mxn__mr_axial', 'mxn__mr_coronal', 'mxn__mr_sagittal')\n", "MR is on top at 50% opacity.\n" ] } ], "source": [ "mxn = wb.mxn\n", "info = mxn.get_info()\n", "print(f\"alias={info.alias} active={info.active} cells={info.windows}\")\n", "\n", "# Stack MR above CT and make MR semi-transparent so both modalities are visible.\n", "for cell in mxn.list_windows():\n", " cell.set_node_layer(ct_node, 0)\n", " cell.set_node_layer(mr_node, 1)\n", "mr_node.opacity = 0.5\n", "wb.update()\n", "print(\"MR is on top at 50% opacity.\")\n" ] }, { "cell_type": "markdown", "id": "1640df208c50", "metadata": {}, "source": [ "**Try this:** open the workbench's data inspector for the active cell.\n", "Both `MR` and `CT` are listed -- in this default single-cell layout, every\n", "visible node renders in every window.\n" ] }, { "cell_type": "markdown", "id": "5143445408dc", "metadata": {}, "source": [ "## 4. Layout as code: GET the current document\n", "\n", "`mxn.get_layout()` parses the live workbench layout into a typed\n", "`MxNLayoutDocument`. Repr is human-readable; `to_json()` shows the wire\n", "form.\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "4c52ee49318a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "MxNLayoutDocument(name='modality grid', version='2.0', windows=6, groups=2)\n" ] } ], "source": [ "current = mxn.get_layout()\n", "print(current)" ] }, { "cell_type": "markdown", "source": [ "Layouts also support pretty html print/representation." ], "metadata": { "collapsed": false }, "id": "341178fbe2fc" }, { "cell_type": "code", "execution_count": 5, "outputs": [ { "data": { "text/plain": "MxNLayoutDocument(name='modality grid', version='2.0', windows=6, groups=2)", "text/html": "
modality grid
version 2.0 · groups: ct (select-all), mr (select-all)
CT axial
mxn__ct_axial
view: axial
selection: ct
CT coronal
mxn__ct_coronal
view: coronal
selection: ct
CT sagittal
mxn__ct_sagittal
view: sagittal
selection: ct
MR axial
mxn__mr_axial
view: axial
selection: mr
MR coronal
mxn__mr_coronal
view: coronal
selection: mr
MR sagittal
mxn__mr_sagittal
view: sagittal
selection: mr
" }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "current" ], "metadata": { "collapsed": false }, "id": "291a8a050f0b" }, { "cell_type": "markdown", "id": "e3a47b4fe521", "metadata": {}, "source": [ "### Build a one-row, three-plane layout\n", "\n", "A common quick-look layout is a single row of three cells, one per\n", "anatomical plane, all linked to the same selection group. We construct\n", "the windows manually so the cell ids encode the plane (`mxn__row_axial`\n", "etc.) -- semantic ids make the next steps easier to read.\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "c8dbd6a74edc", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Cells now: ['mxn__row_axial', 'mxn__row_coronal', 'mxn__row_sagittal']\n" ] }, { "data": { "text/plain": "MxNLayoutDocument(name='multimodal row', version='2.0', windows=3, groups=1)", "text/html": "
multimodal row
version 2.0 · groups: main (select-all)
Axial
mxn__row_axial
view: axial
selection: main
Coronal
mxn__row_coronal
view: coronal
selection: main
Sagittal
mxn__row_sagittal
view: sagittal
selection: main
" }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "row_doc = MxNLayoutDocument.create(\n", " root=Split.horizontal(\n", " LayoutWindow.create(\n", " id=\"mxn__row_axial\",\n", " view_direction=ViewDirection.AXIAL,\n", " selection=\"main\",\n", " name=\"Axial\",\n", " ),\n", " LayoutWindow.create(\n", " id=\"mxn__row_coronal\",\n", " view_direction=ViewDirection.CORONAL,\n", " selection=\"main\",\n", " name=\"Coronal\",\n", " ),\n", " LayoutWindow.create(\n", " id=\"mxn__row_sagittal\",\n", " view_direction=ViewDirection.SAGITTAL,\n", " selection=\"main\",\n", " name=\"Sagittal\",\n", " ),\n", " ),\n", " name=\"multimodal row\",\n", ")\n", "mxn.set_layout(row_doc)\n", "print(f\"Cells now: {[c.id for c in mxn.list_windows()]}\")\n", "row_doc" ] }, { "cell_type": "markdown", "id": "ab91878a26fd", "metadata": {}, "source": [ "**Try this:** look at the workbench. Three cells, one per plane, all\n", "showing both modalities. Because every cell is in the same `main`\n", "selection group, selecting a node in one cell selects it in the others.\n", "MR is still at 50% opacity from step 3 -- both modalities are visible\n", "as a coregistered overlay in every cell.\n" ] }, { "cell_type": "markdown", "id": "6d16cf9503ee", "metadata": {}, "source": [ "## 5. A 2x3 modality grid with per-row groups\n", "\n", "To put each modality in its own row we build a 2x3 grid. Two synchronisation\n", "groups (`ct` and `mr`) keep the rows independent -- selection state in the\n", "CT row does not leak into MR. Window ids encode both modality and plane\n", "(e.g. `mxn__ct_axial`).\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "ec8626b4cf1b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Cells now: ['mxn__ct_axial', 'mxn__ct_coronal', 'mxn__ct_sagittal', 'mxn__mr_axial', 'mxn__mr_coronal', 'mxn__mr_sagittal']\n", "Groups: ['ct', 'mr']\n" ] }, { "data": { "text/plain": "MxNLayoutDocument(name='modality grid', version='2.0', windows=6, groups=2)", "text/html": "
modality grid
version 2.0 · groups: ct (select-all), mr (select-all)
CT axial
mxn__ct_axial
view: axial
selection: ct
CT coronal
mxn__ct_coronal
view: coronal
selection: ct
CT sagittal
mxn__ct_sagittal
view: sagittal
selection: ct
MR axial
mxn__mr_axial
view: axial
selection: mr
MR coronal
mxn__mr_coronal
view: coronal
selection: mr
MR sagittal
mxn__mr_sagittal
view: sagittal
selection: mr
" }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def make_row(modality: str) -> Split:\n", " label = modality.upper()\n", " return Split.horizontal(\n", " LayoutWindow.create(\n", " id=f\"mxn__{modality}_axial\",\n", " view_direction=ViewDirection.AXIAL,\n", " selection=modality,\n", " name=f\"{label} axial\",\n", " ),\n", " LayoutWindow.create(\n", " id=f\"mxn__{modality}_coronal\",\n", " view_direction=ViewDirection.CORONAL,\n", " selection=modality,\n", " name=f\"{label} coronal\",\n", " ),\n", " LayoutWindow.create(\n", " id=f\"mxn__{modality}_sagittal\",\n", " view_direction=ViewDirection.SAGITTAL,\n", " selection=modality,\n", " name=f\"{label} sagittal\",\n", " ),\n", " )\n", "\n", "# Keep the rows as named locals: the per-cell visibility step in the\n", "# next cell iterates them directly, so it never has to recover the\n", "# row-to-cell mapping by pattern-matching cell ids.\n", "ct_row = make_row(\"ct\")\n", "mr_row = make_row(\"mr\")\n", "\n", "modality_doc = MxNLayoutDocument.create(\n", " root=Split.vertical(ct_row, mr_row),\n", " name=\"modality grid\",\n", ")\n", "mxn.set_layout(modality_doc)\n", "print(f\"Cells now: {[c.id for c in mxn.list_windows()]}\")\n", "print(f\"Groups: {sorted(modality_doc.groups)}\")\n", "modality_doc" ] }, { "cell_type": "markdown", "id": "156d053e35db", "metadata": {}, "source": [ "### Per-cell node visibility\n", "\n", "The layout determines *which cells exist*; node visibility per cell is a\n", "DataNode property scoped by the cell's render context. The library wraps\n", "this as `RenderWindow.set_node_visible(node, True/False)` -- the cell id is\n", "threaded through as the property's `context` query parameter.\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "70cc333d2801", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Per-cell visibility set; MR opacity restored to 1.0.\n" ] } ], "source": [ "# Iterate the cached row Splits from the previous cell rather than\n", "# recovering the mapping from cell-id prefixes. The DSL nodes you used\n", "# to build the layout are also the cleanest iteration source.\n", "for win in ct_row.windows():\n", " cell = mxn[win.id]\n", " cell.set_node_visible(ct_node, True)\n", " cell.set_node_visible(mr_node, False)\n", "\n", "for win in mr_row.windows():\n", " cell = mxn[win.id]\n", " cell.set_node_visible(ct_node, False)\n", " cell.set_node_visible(mr_node, True)\n", "\n", "# With each modality confined to its own row, the 50% MR overlay is no\n", "# longer needed.\n", "mr_node.opacity = 1.0\n", "wb.update()\n", "print(\"Per-cell visibility set; MR opacity restored to 1.0.\")\n" ] }, { "cell_type": "markdown", "id": "1d1d662b401e", "metadata": {}, "source": [ "**Try this:** the data inspector now shows only the relevant modality\n", "per cell. CT lives in the top row, MR in the bottom row, and the per-row\n", "selection groups keep navigation independent within each modality.\n" ] }, { "cell_type": "markdown", "id": "8cf6bb1dc65a", "metadata": {}, "source": [ "## 6. Snapshot the editor\n", "\n", "`mxn.screenshot()` grabs the entire MxN canvas (cell tree only -- no\n", "toolbars or side panels). It returns raw PNG bytes; we render inline via\n", "matplotlib.\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "6ebe9ac477e9", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": "" }, "execution_count": 9, "metadata": { "image/png": { "width": 300 } }, "output_type": "execute_result" } ], "source": [ "from IPython.display import Image as IPyImage\n", "\n", "IPyImage(data=mxn.screenshot(), format=\"png\", width=300)\n" ] }, { "cell_type": "markdown", "id": "8878fb4926fe", "metadata": {}, "source": [ "## JSON-only path (no `mitk` install)\n", "\n", "The same flow runs without the optional DSL by trading typed builders for\n", "raw dicts:\n", "\n", "- `mxn.get_layout_json()` returns the JSON body unchanged.\n", "- `mxn.set_layout(payload)` accepts a `dict` and PUTs it as-is. The\n", " server validates the schema and returns 400 `INVALID_REQUEST` on a\n", " malformed body.\n", "\n", "The dict shape mirrors the schema (`mxn-layout-v2.schema.json`) one-to-one\n", "and is byte-stable with what `get_layout_json` returns. Use this path in\n", "environments where a local MITK build is not available; lose only the\n", "client-side validation and the ergonomic builders.\n" ] }, { "cell_type": "markdown", "id": "dce08e8ac745", "metadata": {}, "source": [ "## Recap and clean up\n", "\n", "What you exercised:\n", "\n", "- `MxNEditor.get_info`, `get_layout`, `set_layout`, `screenshot`\n", "- `MxNRenderWindow.set_node_visible`, `set_node_layer`\n", "- `Workbench.set_position`\n", "- DSL building blocks: `LayoutWindow`, `Split`, `MxNLayoutDocument`,\n", " selection-linked groups via `selection=\"\"`\n", "- Semantic, plane-encoding cell ids that route end-to-end (URL,\n", " document, engine) without prefix translation\n", "\n", "Notebook 08 reuses these primitives in a cohort-processing script.\n" ] }, { "cell_type": "code", "execution_count": 10, "id": "c572a3acf6f4", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Removed CT and MR nodes.\n" ] } ], "source": [ "mr_node.remove()\n", "ct_node.remove()\n", "print(\"Removed CT and MR nodes.\")\n" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "name": "python", "version": "3.10.0" } }, "nbformat": 4, "nbformat_minor": 5 }