arrayview 0.6.0__tar.gz → 0.8.0__tar.gz

{arrayview-0.6.0 → arrayview-0.8.0}/.claude/skills/ui-consistency-audit/SKILL.md

@@ -222,6 +222,13 @@ These rules are codified as DOM assertions in `tests/ui_audit.py`. When a new in
 | R26 | Shared colorbar width capped in compare mode | `#slim-cb-wrap` width ≤ 500px in compare mode |
 | R27 | Mode eggs hidden during loading | `#mode-eggs` empty/hidden until at least one frame has been received |
 | R28 | Compare+multiview crosshair fade works | Crosshair lines in compare+multiview fade in/out on hover, scoped to the hovered array's panes |
+| R29 | Dimbar/colorbar height sync | `#info` and `#slim-cb-wrap` offsetHeight within 4px when both visible. Enforced by `_validateUIState()` (runtime) and `run_invariant_assertions()` (Playwright) |
+| R30 | Drag positions cleared on immersive exit | `_infoDragPos`, `_cbDragPos`, `_islandDragPos` all null when `!_fullscreenActive`. Enforced by `_validateUIState()` and `run_immersive_exit_assertions()` |
+| R31 | No .fs-overlay outside immersive | Zero `.fs-overlay` elements when `!_fullscreenActive && !_immersiveAnimating`. Enforced by `_validateUIState()` and `run_immersive_exit_assertions()` |
+| R32 | Per-pane cbs only in immersive+center | `.compare-pane-cb-island.fs-overlay` count > 0 only when `_fullscreenActive && centerMode`. Enforced by `_validateUIState()` |
+| R33 | Colorbar flex-direction always row | All visible `.cb-island` computed `flex-direction === 'row'`. Enforced by CSS (`!important`) and `_validateUIState()` and `run_invariant_assertions()` |
+| R34 | Shared colorbar visible in compare non-center | `#slim-cb-wrap` not `display:none` when `compareActive && !centerMode`. Enforced by `_validateUIState()` |
+| R35 | Islands fully inside or outside pane | Dynamic islands must be fully inside pane bounds (immersive) or fully outside in normal flow (non-immersive) — never partially overlapping |
 
 ---
 
@@ -240,6 +247,31 @@ All colorbars across ALL modes follow the same structure: `[vmin span] [gradient
 
 ---
 
+## Section 5d: Enforcement Layers
+
+Rules are enforced through multiple layers. When adding new rules, add enforcement at the appropriate layer(s):
+
+| Layer | Mechanism | Where | When it runs |
+|-------|-----------|-------|--------------|
+| **CSS** | `!important` structural constraints | `_viewer.html` CSS (line ~156) | Always — structurally impossible to violate |
+| **Runtime JS** | `_validateUIState()` | `_viewer.html` JS (after `_positionFullscreenChrome`) | After every layout change, gated behind `?debug_ui=1` |
+| **Playwright** | `run_invariant_assertions()` + `run_immersive_exit_assertions()` | `tests/ui_audit.py` | During `ui_audit.py` runs (all tiers) |
+| **Skill** | This document (Section 5b) | `.claude/skills/ui-consistency-audit/SKILL.md` | When AI agent invokes the skill |
+
+**Cross-reference:**
+
+| Rule | CSS | Runtime JS | Playwright | Notes |
+|------|-----|-----------|------------|-------|
+| R29 (height sync) | — | ✓ | ✓ | |
+| R30 (drag cleanup) | — | ✓ | ✓ | Only after immersive exit |
+| R31 (fs-overlay cleanup) | — | ✓ | ✓ | Only after immersive exit |
+| R32 (per-pane cb visibility) | — | ✓ | — | |
+| R33 (flex-direction row) | ✓ | ✓ | ✓ | CSS makes violation impossible |
+| R34 (shared cb in compare) | — | ✓ | — | |
+| R35 (island containment) | — | — | — | Design principle, enforced by code review |
+
+---
+
 ## Section 6: Common Feature Categories
 
 ### Zoom / Canvas Sizing

arrayview-0.8.0/.claude/skills/visual-bug-fixing/SKILL.md

@@ -0,0 +1,153 @@
+---
+name: visual-bug-fixing
+description: Use when fixing any visual bug, layout glitch, rendering artifact, or UI regression in arrayview. Triggered by symptoms like overlapping elements, wrong positioning, missing components, flickering, or incorrect sizing in any view mode.
+---
+
+# Visual Bug Fixing
+
+## Overview
+
+**Fix visual bugs with screenshot evidence, not guesswork.** Capture before-state, diagnose root cause, fix, capture after-state, verify no regressions across all view modes. Never commit a visual fix without photographic proof it works and doesn't break anything else.
+
+## When to Use
+
+- User reports a visual bug (overlap, misalignment, wrong size, missing element, rendering artifact)
+- You notice a visual inconsistency during other work
+- A UI change causes unexpected layout shifts
+- Screenshot diff failures in `ui_audit.py`
+
+**When NOT to use:**
+- Pure logic bugs with no visual impact — use superpowers:systematic-debugging
+- Adding new UI features — use ui-consistency-audit + frontend-designer
+- Updating test coverage — use viewer-ui-checklist
+
+## Workflow
+
+```dot
+digraph visual_bug_fix {
+  rankdir=TB;
+  "Bug reported" -> "Capture baseline screenshots";
+  "Capture baseline screenshots" -> "Diagnose root cause";
+  "Diagnose root cause" -> "Implement fix";
+  "Implement fix" -> "Capture post-fix screenshots";
+  "Capture post-fix screenshots" -> "Compare before/after";
+  "Compare before/after" -> "Run full regression check";
+  "Run full regression check" -> "Regressions found?" [shape=diamond];
+  "Regressions found?" -> "Implement fix" [label="yes — iterate"];
+  "Regressions found?" -> "Show evidence & commit" [label="no"];
+}
+```
+
+### Step 1: Capture Baseline Screenshots
+
+Before touching any code, capture the current broken state. Use the Playwright MCP tools:
+
+1. **Navigate** to the affected view using `browser_navigate` to the arrayview URL
+2. **Set up the bug conditions** — press keys to enter the right mode, load the right array
+3. **Screenshot the broken state** with `browser_take_screenshot` — save as `baseline_bug.png`
+4. **Screenshot ALL other modes** that could be affected:
+   - Normal view (default)
+   - Immersive mode (`Shift+K`)
+   - Compare mode (navigate to compare URL)
+   - Diff modes (`Shift+X` to cycle)
+   - Multiview (`v`)
+   - Zen mode (`Shift+F`)
+   - Zoomed state (`+` keys)
+
+**Key selectors to inspect** (via `browser_snapshot` or `browser_evaluate`):
+- `#canvas-wrap` — main canvas container
+- `#slim-cb-wrap` — colorbar wrapper
+- `#info` — info bar
+- `.mode-egg` — mode indicator badges
+- `#miniview` — minimap overlay
+- `#dimbar` — dimension navigation bar
+
+### Step 2: Diagnose Root Cause
+
+Read the relevant source files. The UI lives in:
+
+| Layer | File |
+|-------|------|
+| HTML structure | `arrayview/_viewer.html` |
+| Inline CSS | `<style>` blocks in `_viewer.html` |
+| Canvas rendering | JavaScript in `_viewer.html` (search for `scaleCanvas`, `mvScaleAllCanvases`, `compareScaleCanvases`) |
+| Python server | `arrayview/_app.py` |
+| Colorbar logic | `ColorBar` class in `_viewer.html` |
+
+**Diagnosis checklist:**
+- Is this a CSS issue (positioning, overflow, z-index, flexbox)?
+- Is this a JS layout calculation issue (wrong width/height, missing mode branch)?
+- Does the bug only appear in certain modes? Which scale function is involved?
+- Does zoom level matter? Check the zoom-related code paths.
+- Is this a race condition (element rendered before data arrives)?
+
+**Check hard rules:** Before implementing a fix, check if the bug is a violation of a hard UI rule (R1-R35 in `ui-consistency-audit` Section 5b). If so, the fix should restore the invariant rather than work around it. Enable `?debug_ui=1` to see runtime invariant warnings in the browser console — they may pinpoint the exact rule being violated.
+
+**Use `browser_evaluate` to inspect live DOM state:**
+```javascript
+// Get bounding boxes of key elements
+JSON.stringify({
+  canvas: document.querySelector('#canvas-wrap')?.getBoundingClientRect(),
+  colorbar: document.querySelector('#slim-cb-wrap')?.getBoundingClientRect(),
+  info: document.querySelector('#info')?.getBoundingClientRect(),
+  viewport: { width: window.innerWidth, height: window.innerHeight }
+})
+```
+
+### Step 3: Implement the Fix
+
+Apply the minimal fix. Reference the ui-consistency-audit design rules (R1-R35) to ensure the fix doesn't violate any existing constraints.
+
+**Common fix patterns:**
+- **Overlap bugs**: Check z-index hierarchy, adjust `position`/`top`/`left`/`right`
+- **Sizing bugs**: Trace the calculation chain in the relevant scale function
+- **Mode-specific bugs**: Ensure all mode branches handle the element (check `isCompare`, `isMultiview`, `isImmersive`, `isZen` flags)
+- **Zoom bugs**: Check `zoomLevel` interactions with element positioning
+
+### Step 4: Capture Post-Fix Screenshots
+
+Repeat the exact same navigation and key presses from Step 1. Screenshot every view that was captured in the baseline.
+
+### Step 5: Compare Before/After
+
+Present the before and after screenshots to the user. Explain:
+- What was broken (with baseline screenshot)
+- What changed in the code
+- What it looks like now (with post-fix screenshot)
+
+### Step 6: Full Regression Check
+
+Run the automated visual audit:
+
+```bash
+uv run python tests/ui_audit.py --tier 1
+```
+
+This checks 14 core scenarios with DOM assertions and pixel diffs. If any fail:
+- Read the failure output to identify which scenario regressed
+- Screenshot that specific scenario manually to understand the regression
+- Go back to Step 3 and iterate
+
+For thorough validation (before committing):
+```bash
+uv run python tests/ui_audit.py --tier 2
+```
+
+**Only commit when Tier 1 passes clean.** Tier 2 failures should be investigated but may be pre-existing.
+
+## Red Flags — STOP and Investigate
+
+| Symptom | Likely Cause |
+|---------|-------------|
+| Fix works in normal mode but breaks compare | Missing branch in `compareScaleCanvases` |
+| Element disappears on zoom | Absolute positioning without zoom-aware offsets |
+| Fix works at 1440x900 but breaks at other sizes | Hardcoded pixel values instead of relative/calc |
+| Colorbar overlaps canvas after fix | Forgot to account for colorbar width in canvas sizing |
+| Mode eggs shift position | Changed a parent container's layout without updating egg anchoring |
+
+## Common Mistakes
+
+- **Fixing the symptom, not the cause** — A `display:none` hack hides the bug. Find why the element is in the wrong place.
+- **Testing only the affected mode** — Visual bugs often have cross-mode impact. Always check at minimum: normal, immersive, compare, multiview.
+- **Skipping the baseline screenshot** — Without before/after evidence, you can't prove the fix worked or detect subtle regressions.
+- **Committing without running ui_audit.py** — DOM assertions catch things screenshots miss (off-by-1px overlaps, viewport overflow).

arrayview-0.8.0/.github/workflows/docs.yml

@@ -0,0 +1,20 @@
+name: Deploy docs
+
+on:
+  push:
+    branches: [main]
+    paths: [docs/**, mkdocs.yml]
+
+permissions:
+  contents: write
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+      - run: pip install mkdocs-material
+      - run: mkdocs gh-deploy --force

{arrayview-0.6.0 → arrayview-0.8.0}/.gitignore

@@ -11,6 +11,7 @@ wheels/
 
 *.npy
 .claude/
+.worktrees/
 !.claude/skills/
 !.claude/skills/**
 CLAUDE.md
@@ -24,7 +25,10 @@ tests/smoke_output/
 dev/
 *.png
 !src/arrayview/_icon.png
+!docs/logo.png
 
 benchmarks/data
 .superpowers/brainstorm
-site/
+site/
+van_gogh/
+docs/superpowers

arrayview-0.8.0/AGENTS.md

@@ -0,0 +1,52 @@
+# ArrayView
+
+Interactive viewer for multi-dimensional arrays and medical/scientific volumes. FastAPI server + single-file HTML/JS frontend (`_viewer.html`), displayed via native window, browser, VS Code Simple Browser, or Jupyter iframe.
+
+## Core Files
+
+| File | Role |
+|------|------|
+| `_launcher.py` | Entry points, process management, display routing |
+| `_server.py` | FastAPI app, REST/WebSocket, HTML templates |
+| `_session.py` | Sessions, state, caches, render thread |
+| `_render.py` | Colormaps, LUTs, slice extraction, RGBA |
+| `_viewer.html` | All frontend (JS/CSS embedded, single file) |
+| `_vscode.py` | Extension management, signal-file IPC |
+| `_stdio_server.py` | Stdio transport for direct webview mode |
+| `_segmentation.py` | nnInteractive segmentation client |
+
+## Skills
+
+Load the relevant skill before touching the corresponding area.
+
+| Skill | When |
+|-------|------|
+| `ui-consistency-audit` | Any visual/UI change |
+| `frontend-designer` | Styling/layout changes to `_viewer.html` |
+| `vscode-simplebrowser` | Extension, signal-file IPC, `_VSCODE_EXT_VERSION` |
+| `invocation-consistency` | Server startup, display-opening, env detection |
+| `docs-style` | README, help overlay, docstrings |
+
+## Non-Negotiables
+
+- Always use `localhost` (not `127.0.0.1`) -- required for VS Code port forwarding
+- Never `--force` reinstall the extension if correct version is on disk
+- Do not add logic to `_app.py` -- compat shim only
+- Avoid orphan processes; shutdown must be automatic
+- Do not regress working display paths when fixing another
+- For visual/animation features, propose 2-3 options BEFORE implementing
+- UI visibility changes go through reconcilers (`_reconcileUI`/`_reconcileLayout`/`_reconcileCompareState`/`_reconcileCbVisibility`), not inline `style.display` or `classList` toggles in mode functions
+
+## Execution
+
+Always use **subagent-driven development** for implementation. Commit completed work automatically.
+
+## Testing
+
+```bash
+uv run pytest tests/test_api.py -v       # HTTP API
+uv run pytest tests/test_browser.py -v   # Playwright
+uv run python tests/visual_smoke.py      # screenshots
+```
+
+After any UI change, use `/ui-consistency-audit` to verify across all modes.

arrayview-0.8.0/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: arrayview
+Version: 0.8.0
+Summary: Fast multi-dimensional array viewer
+Project-URL: Home, https://github.com/oscarvanderheide/arrayview
+Project-URL: Source, https://github.com/oscarvanderheide/arrayview
+Author-email: Oscar <oscarvanderheide@example.com>
+License: MIT
+License-File: LICENSE
+Keywords: array,mri,npy,viewer,visualization
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.12
+Requires-Dist: fastapi>=0.129.0
+Requires-Dist: h5py>=3.0
+Requires-Dist: matplotlib>=3.9.0
+Requires-Dist: nibabel>=5.3.3
+Requires-Dist: numpy>=2.4.2
+Requires-Dist: pillow>=12.1.1
+Requires-Dist: pyqt5>=5.15; sys_platform == 'linux'
+Requires-Dist: pyqtwebengine>=5.15; sys_platform == 'linux'
+Requires-Dist: python-multipart>=0.0.22
+Requires-Dist: pywebview>=6.1
+Requires-Dist: qmricolors>=0.1.2
+Requires-Dist: qtpy>=2.0; sys_platform == 'linux'
+Requires-Dist: scipy>=1.10
+Requires-Dist: tifffile>=2023.1.1
+Requires-Dist: uvicorn>=0.41.0
+Requires-Dist: websockets>=14.0
+Requires-Dist: zarr>=2.17
+Description-Content-Type: text/markdown
+
+# arrayview
+
+A viewer for multi-dimensional arrays.
+
+- CLI and Python
+- Jupyter / VS Code
+- Browser / native
+- SSH / tunnels
+
+## CLI
+
+```bash
+uvx arrayview scan.nii.gz
+uvx arrayview --window browser scan.npy
+uvx arrayview                            # demo
+```
+
+## Python
+
+```python
+from arrayview import view
+view(arr)
+```
+
+## MATLAB
+
+Add the `matlab/` directory to your MATLAB path, then:
+
+```matlab
+addpath('/path/to/arrayview/matlab')
+
+A = rand(100, 200, 10);
+arrayview(A)
+```
+
+Requires arrayview installed in [MATLAB's Python environment](https://www.mathworks.com/help/matlab/matlab_external/install-supported-python-implementation.html):
+
+```bash
+pip install arrayview
+```
+
+Arrays are passed zero-copy via the buffer protocol (in-process Python). `arrayview()` enables this automatically — just call it before any other `py.*` call in your MATLAB session.
+
+## PyTorch / Deep Learning
+
+```python
+from arrayview import view_batch, TrainingMonitor
+
+# Browse a DataLoader batch
+view_batch(train_loader)
+view_batch(train_loader, overlay='label')
+
+# Live training monitor — updates every N epochs
+monitor = TrainingMonitor(every=5, samples=3)
+for epoch in range(100):
+    for batch in val_loader:
+        pred = model(batch['image'])
+        monitor.step(input=batch['image'], target=batch['label'],
+                     prediction=pred, epoch=epoch)
+```
+
+`view_batch()` accepts DataLoaders, Datasets, dicts, tuples, or raw tensors. `TrainingMonitor` opens a compare window and calls `handle.update()` automatically. PyTorch is not required at import time.
+
+
+## Formats
+
+`.npy` `.npz` `.nii` `.nii.gz` `.zarr` `.pt` `.h5` `.tif` `.mat`
+
+## Once open
+
+`c` colormaps · `d` dynamic range · `v` 3-plane · `z` mosaic · `Shift+O` overlay toggle · `?` help · colorbar dblclick histogram
+
+
+## nnInteractive Segmentation
+
+`S` starts AI-assisted 3D segmentation (requires CUDA). Click/draw to segment, `Enter` to accept.
+
+```toml
+[nninteractive]
+url = "http://gpu-server:1527"   # skip auto-launch, use running server
+```
+
+Or: `ARRAYVIEW_NNINTERACTIVE_URL=http://gpu-server:1527`
+
+
+## Config
+
+`~/.arrayview/config.toml`:
+
+```toml
+[viewer]
+colormaps = ["gray", "viridis", "plasma"]   # colormaps cycled by 'c'
+
+[window]
+default = "browser"                         # browser | native | vscode | inline
+```
+
+[Full documentation →](https://oscarvanderheide.github.io/arrayview/)

arrayview-0.8.0/README.md

@@ -0,0 +1,98 @@
+# arrayview
+
+A viewer for multi-dimensional arrays.
+
+- CLI and Python
+- Jupyter / VS Code
+- Browser / native
+- SSH / tunnels
+
+## CLI
+
+```bash
+uvx arrayview scan.nii.gz
+uvx arrayview --window browser scan.npy
+uvx arrayview                            # demo
+```
+
+## Python
+
+```python
+from arrayview import view
+view(arr)
+```
+
+## MATLAB
+
+Add the `matlab/` directory to your MATLAB path, then:
+
+```matlab
+addpath('/path/to/arrayview/matlab')
+
+A = rand(100, 200, 10);
+arrayview(A)
+```
+
+Requires arrayview installed in [MATLAB's Python environment](https://www.mathworks.com/help/matlab/matlab_external/install-supported-python-implementation.html):
+
+```bash
+pip install arrayview
+```
+
+Arrays are passed zero-copy via the buffer protocol (in-process Python). `arrayview()` enables this automatically — just call it before any other `py.*` call in your MATLAB session.
+
+## PyTorch / Deep Learning
+
+```python
+from arrayview import view_batch, TrainingMonitor
+
+# Browse a DataLoader batch
+view_batch(train_loader)
+view_batch(train_loader, overlay='label')
+
+# Live training monitor — updates every N epochs
+monitor = TrainingMonitor(every=5, samples=3)
+for epoch in range(100):
+    for batch in val_loader:
+        pred = model(batch['image'])
+        monitor.step(input=batch['image'], target=batch['label'],
+                     prediction=pred, epoch=epoch)
+```
+
+`view_batch()` accepts DataLoaders, Datasets, dicts, tuples, or raw tensors. `TrainingMonitor` opens a compare window and calls `handle.update()` automatically. PyTorch is not required at import time.
+
+
+## Formats
+
+`.npy` `.npz` `.nii` `.nii.gz` `.zarr` `.pt` `.h5` `.tif` `.mat`
+
+## Once open
+
+`c` colormaps · `d` dynamic range · `v` 3-plane · `z` mosaic · `Shift+O` overlay toggle · `?` help · colorbar dblclick histogram
+
+
+## nnInteractive Segmentation
+
+`S` starts AI-assisted 3D segmentation (requires CUDA). Click/draw to segment, `Enter` to accept.
+
+```toml
+[nninteractive]
+url = "http://gpu-server:1527"   # skip auto-launch, use running server
+```
+
+Or: `ARRAYVIEW_NNINTERACTIVE_URL=http://gpu-server:1527`
+
+
+## Config
+
+`~/.arrayview/config.toml`:
+
+```toml
+[viewer]
+colormaps = ["gray", "viridis", "plasma"]   # colormaps cycled by 'c'
+
+[window]
+default = "browser"                         # browser | native | vscode | inline
+```
+
+[Full documentation →](https://oscarvanderheide.github.io/arrayview/)

{arrayview-0.6.0 → arrayview-0.8.0}/docs/remote.md

@@ -16,19 +16,40 @@ Auto-detects VS Code terminals and opens in Simple Browser. Works automatically.
 
 ## VS Code tunnel
 
-For remote development through a VS Code tunnel, start the server on the remote machine:
+The VS Code extension uses a **direct webview** transport: the viewer runs
+inside a VS Code webview panel and communicates with a Python subprocess via
+the extension host.  No port forwarding or public ports are needed — everything
+stays inside the tunnel.
 
 ```bash
-# on the remote machine
-arrayview --serve
+arrayview volume.nii.gz     # opens in a webview tab automatically
+```
+
+### How it works
+
+```
+Viewer (webview) ←postMessage→ Extension Host ←stdin/stdout→ Python
 ```
 
-Set port 8000 to Public in the VS Code Ports tab. Load arrays normally — each opens in Simple Browser:
+Instead of a WebSocket connection to a running server, the extension spawns a
+dedicated Python process per array.  Slice requests travel through VS Code's
+`postMessage` IPC and the extension relays them to Python's stdin as JSON.
+Binary RGBA responses flow back through stdout with a length prefix.
+
+This avoids the main limitation of the WebSocket approach: VS Code tunnels
+don't expose arbitrary ports, so the old method required manually setting
+port 8000 to "Public" in the Ports tab.
+
+### Fallback: WebSocket mode
+
+If you prefer the traditional WebSocket server (e.g. for multi-hop setups or
+when sharing the viewer URL), you can still use it:
 
 ```bash
-arrayview volume.nii.gz
+arrayview --serve
 ```
 
+Set port 8000 to Public in the VS Code Ports tab, then load arrays normally.
 The server persists across invocations. Kill it with `arrayview --kill`.
 
 ## Multi-hop

arrayview-0.8.0/matlab/arrayview.m

@@ -0,0 +1,74 @@
+function arrayview(A, varargin)
+% ARRAYVIEW  View a numeric array in the ArrayView browser viewer.
+%
+%   arrayview(A)                      view array, name taken from variable name
+%   arrayview(A, 'name', 'MyName')    use custom display name
+%   arrayview(A, 'port', 8200)        use custom port (default 8123)
+%
+%   Requires arrayview installed in MATLAB's Python environment:
+%       % In your system Python or conda env:
+%       pip install arrayview
+%       % Then configure MATLAB to use it:
+%       pyenv('Version', '/path/to/python')
+%
+%   For zero-copy (recommended for large arrays), arrayview() auto-enables
+%   in-process Python. Call arrayview() before any other py.* call in your
+%   session, or set it manually:
+%       pyenv('ExecutionMode', 'InProcess')
+
+    % --- Version guard ---
+    if verLessThan('matlab', '9.11')  % 9.11 = R2021b
+        error('arrayview:unsupportedVersion', ...
+            'arrayview() requires MATLAB R2021b (9.11) or later.');
+    end
+
+    % --- Auto-configure in-process Python for zero-copy ---
+    % Must happen before Python is first loaded in this session.
+    pe = pyenv();
+    if strcmp(pe.Status, 'NotLoaded')
+        pyenv('ExecutionMode', 'InProcess');
+    elseif strcmp(pe.ExecutionMode, 'OutOfProcess')
+        warning('arrayview:outOfProcess', '%s', ...
+            ['ArrayView: Python is running out-of-process — the array will be ' ...
+             'copied (doubles memory).' newline 'To avoid this, restart MATLAB and call ' ...
+             'arrayview() before any other py.* call.']);
+    end
+
+    % --- Parse arguments ---
+    defname = inputname(1);
+    if isempty(defname)
+        defname = 'Array';
+    end
+    p = inputParser;
+    addParameter(p, 'name', defname);
+    addParameter(p, 'port', 8123);
+    parse(p, varargin{:});
+
+    % --- Input validation ---
+    validateattributes(A, {'numeric', 'logical'}, {}, 'arrayview', 'A');
+
+    % --- Wrap array (zero-copy in in-process mode via buffer protocol) ---
+    try
+        np = py.importlib.import_module('numpy');
+    catch ME
+        error('arrayview:numpyNotFound', ...
+            ['NumPy not found in MATLAB''s Python environment.' newline ...
+             'Install it with:' newline ...
+             '    pip install numpy' newline ...
+             'Then restart MATLAB. (Error: %s)'], ME.message);
+    end
+    arr = np.asarray(A);
+
+    % --- Call arrayview.view() ---
+    try
+        av = py.importlib.import_module('arrayview');
+    catch ME
+        error('arrayview:notInstalled', ...
+            ['ArrayView Python package not found.' newline ...
+             'Install it in MATLAB''s Python environment:' newline ...
+             '    pip install arrayview' newline ...
+             'Then restart MATLAB. (Error: %s)'], ME.message);
+    end
+
+    av.view(arr, name=p.Results.name, port=int32(p.Results.port));
+end

{arrayview-0.6.0 → arrayview-0.8.0}/mkdocs.yml

@@ -4,6 +4,8 @@ repo_url: https://github.com/oscarvanderheide/arrayview
 
 theme:
   name: material
+  logo: logo.png
+  favicon: logo.png
   palette:
     scheme: slate
     primary: black