@jax-data-science/sci-image-visualizer 0.8.3 → 0.10.0

package/esm2022/lib/implementations/napari-js/napari-tool-bridge.mjs

@@ -0,0 +1,347 @@
+import { IDENTITY_AFFINE } from '../../region-overlay/svg-region-renderer';
+import { createCanvasToolManager } from '../../toolbar/canvas-tools';
+import { packedFrame } from '../../toolbar/tool-kit/frame-pixels';
+import { NapariRegionOverlay } from './napari-region-overlay';
+import { READBACK_DEBOUNCE_MS } from './napari-helpers';
+/** ICoordinateTransform over the napari camera: pointer client coords ↔ image/world coords. */
+export class NapariCoordinateTransform {
+    constructor(viewer, ready) {
+        this.viewer = viewer;
+        this.ready = ready;
+    }
+    clientToData(clientX, clientY) {
+        const [x, y] = this.viewer.canvasToWorld(clientX, clientY);
+        return { x, y };
+    }
+    dataLengthToScreen(dataLength) {
+        return dataLength * this.viewer.camera.zoom; // CSS px per world unit
+    }
+    isReady() {
+        return this.ready();
+    }
+}
+/**
+ * The napari backend's side of the shared canvas tools (review Appendix B, step 4): the region
+ * overlay, the {@link CanvasToolManager} and its host, the coordinate transform, and the
+ * displayed-pixel readback the wand, brush, eraser and SAM/cellpose read — kept current as the
+ * camera moves, but only paid for while a pixel tool needs it (NAPARI-SVC-26).
+ *
+ * One per service; {@link teardown} ends a scene's interaction (overlay, camera hook, timers,
+ * pixels) and an `install…Interaction` starts the next one's.
+ */
+export class NapariToolBridge {
+    constructor(host, deps) {
+        this.host = host;
+        this.deps = deps;
+        /** SVG region-drawing overlay (null until a 2D/3D interaction is installed). */
+        this.regionOverlay = null;
+        /** The pixel tools' pointer ↔ world transform for the current viewer. */
+        this.coordTransform = null;
+        /** The last readback of the displayed composite (the pixel tools' source). */
+        this.lastPixels = null;
+        /** Visible world rect captured AT the last readback — must pair with `lastPixels` so the pixel
+         *  tools' ratios/origin match the matrix's camera (using the live rect after a pan/zoom would
+         *  mis-scale the region). */
+        this.lastPixelsRect = null;
+        /** Active tools that read the displayed pixels; a pan/zoom re-reads them only while non-empty. */
+        this.pixelTools = new Set();
+        /** The camera moved since {@link lastPixels} was read. */
+        this.pixelsStale = false;
+        /** Cached CachedImageData built from the last readback (rebuilt when lastPixels changes). */
+        this.cachedImage = null;
+        this.cachedImageSource = null;
+        /** Debounced readback timer + camera-change unsubscribe (keep lastPixels current for tools). */
+        this.readbackTimer = null;
+        /** Debounced viewport emission for a camera change that needs no pixels. */
+        this.viewportTimer = null;
+        this.cameraOff = null;
+        const { regionStore } = deps;
+        // The pixel tools read displayed pixels synchronously from the last readback and convert
+        // pointer coords via the napari camera, mirroring the OSD host. This backend owns its own tool
+        // instances (RT-21); the host reads live state, so it is built once.
+        this.toolHost = {
+            getRegions: () => regionStore.getRegions(),
+            setRegions: (r) => regionStore.setRegions(r),
+            getCachedImageData: () => this.cachedImageData(),
+            getActiveFrameIndex: () => host.frameIndex(),
+            getOverlayContainer: () => host.host(),
+            getCoordinateTransform: () => this.coordTransform,
+            getFileName: () => host.fileName(),
+            getShapeColor: () => regionStore.getShapeColor(),
+            pixelToData: (px, py) => {
+                const rect = host.host()?.getBoundingClientRect();
+                const viewer = host.viewer();
+                if (!viewer || !rect)
+                    return { x: 0, y: 0 };
+                const [x, y] = viewer.canvasToWorld(rect.left + px, rect.top + py);
+                return { x, y };
+            },
+            applyZoomToBox: (coords) => this.applyZoomToBox(coords),
+        };
+        this.canvasTools = createCanvasToolManager(this.toolHost, {
+            wandService: deps.wandService,
+            regionStore,
+            samPoint: deps.samPointTool,
+        });
+    }
+    /**
+     * The interaction stack every 2D mode needs: the region overlay (draw/select/edit), the pixel
+     * tools that read back displayed pixels (wand, brush, vertex eraser, zoom-to-box, SAM/cellpose),
+     * and a camera hook that keeps that readback current as the view pans/zooms and tiled levels
+     * load.
+     *
+     * One call for all of it because forgetting it is invisible: the toolbar gates its region buttons
+     * on 2D-vs-3D rather than on plot type, so a 2D mode that skips this shows every tool and silently
+     * does nothing. That is exactly what happened to the spatial and region-centroid scatter modes.
+     */
+    install2dInteraction(viewer, host) {
+        this.regionOverlay = new NapariRegionOverlay(host, viewer, this.deps.regionStore);
+        this.buildCoordinateTransform();
+        this.cameraOff = viewer.camera.changed.connect(() => this.onViewChanged());
+    }
+    /**
+     * Region drawing for the 3D cloud.
+     *
+     * Reuses {@link NapariRegionOverlay} verbatim by handing it a SCREEN-SPACE viewer: the drawn
+     * shape is a lasso in canvas pixels, so "world" is the canvas and both transforms are identity
+     * (bar the client→canvas offset). Every existing tool — rectangle, polygon, freehand — therefore
+     * works in 3D with no new drawing code.
+     *
+     * A screen-space shape stops meaning anything the moment the camera moves, so an orbit clears
+     * the regions drawn in this view (and only those). The SELECTION they produced is kept: that is
+     * the durable artefact, and the highlighted points stay highlighted from every angle.
+     */
+    install3dInteraction(viewer, host) {
+        const { regionStore } = this.deps;
+        // World here is the canvas, not the image: no region source to draw.
+        this.regionOverlay = new NapariRegionOverlay(host, this.screenSpaceViewer(viewer), regionStore, {
+            regionSource: false,
+        });
+        this.buildCoordinateTransform();
+        // Regions already in the shared store when the 3D view mounted (the image's own, say) are
+        // not screen-space shapes and must survive an orbit; only those drawn here are cleared.
+        // (No mid-gesture case to guard: the overlay disables the camera controls while drawing.)
+        const foreign = new Set(regionStore.getRegions().map((r) => r.id));
+        this.cameraOff = viewer.camera3d.changed.connect(() => {
+            const drawn = regionStore
+                .getRegions()
+                .filter((r) => !foreign.has(r.id))
+                .map((r) => r.id);
+            // Not an edit of the user's: no undo step (NAPARI-SVC-11).
+            if (drawn.length)
+                this.host.inZone(() => regionStore.removeRegions(drawn, { recordUndo: false }));
+        });
+    }
+    /**
+     * The {@link OverlayViewer} the 3D region overlay draws through: "world" is the canvas, in
+     * canvas-local CSS pixels. A pointer arrives in CLIENT pixels, so `canvasToWorld` subtracts the
+     * canvas's client offset (without it the lasso was drawn offset from the cursor whenever the
+     * canvas was not at the page origin); drawing is then the identity, with no layout read.
+     */
+    screenSpaceViewer(viewer) {
+        return {
+            canvasToWorld: (clientX, clientY) => {
+                const r = this.host.canvas()?.getBoundingClientRect();
+                return r ? [clientX - r.left, clientY - r.top] : [clientX, clientY];
+            },
+            canvasTransform: () => IDENTITY_AFFINE,
+            setControlsEnabled: (enabled) => viewer.setControlsEnabled(enabled),
+            camera: viewer.camera3d,
+        };
+    }
+    /** End the scene's interaction: the overlay, the camera hook, the pending timers and the
+     *  pixels read from the old canvas. The armed tool and the pixel-tool set persist. */
+    teardown() {
+        this.regionOverlay?.destroy();
+        this.regionOverlay = null;
+        this.cachedImage = null;
+        this.cachedImageSource = null;
+        this.lastPixelsRect = null;
+        if (this.readbackTimer != null) {
+            clearTimeout(this.readbackTimer);
+            this.readbackTimer = null;
+        }
+        if (this.viewportTimer != null) {
+            clearTimeout(this.viewportTimer);
+            this.viewportTimer = null;
+        }
+        this.pixelsStale = false;
+        this.cameraOff?.();
+        this.cameraOff = null;
+        this.lastPixels = null;
+    }
+    /** Read the displayed composite into `lastPixels` (the pixel-tools' source) + emit the clamped
+     *  visible region. A fresh PixelData object means cachedImageData() rebuilds automatically. */
+    async runReadback() {
+        const v = this.host.viewer();
+        if (!v)
+            return;
+        try {
+            const px = await v.readDisplayedPixels();
+            if (this.host.viewer() !== v)
+                return;
+            const rect = v.visibleWorldRect(); // capture WITH the pixels (same camera)
+            this.lastPixels = px;
+            this.lastPixelsRect = rect;
+            this.pixelsStale = false;
+            this.emitViewport(rect);
+        }
+        catch {
+            /* readback unavailable (no device yet, or it was lost): the tools keep the last pixels */
+        }
+    }
+    /** A readback on the next frame — after a plot or a scene change drew something new. */
+    scheduleReadback() {
+        if (!this.host.viewer())
+            return;
+        this.host.outsideZone(() => {
+            if (typeof requestAnimationFrame === 'function')
+                requestAnimationFrame(() => void this.runReadback());
+            else
+                setTimeout(() => void this.runReadback(), 0);
+        });
+    }
+    /** Debounced readback — armed on camera changes while a pixel tool is active, so `lastPixels`
+     *  tracks the current view after a pan/zoom settles, which the on-canvas pixel tools
+     *  (wand/brush/SAM) read synchronously. Coalesces rapid changes. */
+    armReadback(delayMs = READBACK_DEBOUNCE_MS) {
+        if (this.readbackTimer != null)
+            clearTimeout(this.readbackTimer);
+        this.readbackTimer = this.host.outsideZone(() => setTimeout(() => {
+            this.readbackTimer = null;
+            void this.runReadback();
+        }, delayMs));
+    }
+    /** Emit the visible region, clamped to the image. */
+    emitViewport(rect) {
+        const size = this.host.imageSize();
+        if (!size || !rect)
+            return;
+        const x = Math.max(0, Math.min(size.width, rect.x));
+        const y = Math.max(0, Math.min(size.height, rect.y));
+        const width = Math.max(1, Math.min(size.width - x, rect.width));
+        const height = Math.max(1, Math.min(size.height - y, rect.height));
+        this.host.viewportChanged({ x, y, width, height });
+    }
+    /**
+     * A 2D pan/zoom. The full-canvas GPU readback is paid for only while a pixel tool reads it
+     * ({@link pixelTools}); otherwise only the viewport rect is emitted (debounced), and the pixels
+     * are marked stale for whoever next needs them (a tool arms a fresh readback as it activates).
+     */
+    onViewChanged() {
+        this.pixelsStale = true;
+        if (this.pixelTools.size > 0) {
+            this.armReadback(); // emits the viewport with the pixels
+            return;
+        }
+        if (this.viewportTimer != null)
+            clearTimeout(this.viewportTimer);
+        this.viewportTimer = this.host.outsideZone(() => setTimeout(() => {
+            this.viewportTimer = null;
+            const viewer = this.host.viewer();
+            if (viewer)
+                this.emitViewport(viewer.visibleWorldRect());
+        }, READBACK_DEBOUNCE_MS));
+    }
+    /** Build the pixel tools' coordinate transform for the current viewer. */
+    buildCoordinateTransform() {
+        const viewer = this.host.viewer();
+        if (!viewer)
+            return;
+        this.coordTransform = new NapariCoordinateTransform(viewer, () => !!this.host.viewer() && (this.host.imageSize()?.width ?? 0) > 0);
+    }
+    /** Zoom/pan the camera to fit a data-space rectangle `[xMin, xMax, yMax, yMin]`. */
+    applyZoomToBox(coordinates) {
+        const v = this.host.viewer();
+        const canvas = this.host.canvas();
+        if (!v || !canvas || coordinates.length < 4)
+            return;
+        const [xMin, xMax, yA, yB] = coordinates;
+        const x0 = Math.min(xMin, xMax);
+        const x1 = Math.max(xMin, xMax);
+        const y0 = Math.min(yA, yB);
+        const y1 = Math.max(yA, yB);
+        const w = Math.max(1, x1 - x0);
+        const h = Math.max(1, y1 - y0);
+        const vw = canvas.clientWidth || w;
+        const vh = canvas.clientHeight || h;
+        v.camera.center = [(x0 + x1) / 2, (y0 + y1) / 2];
+        v.camera.zoom = Math.min(vw / w, vh / h);
+        v.requestRender();
+    }
+    /** Build CachedImageData from the most recent readback — its RGBA device pixels are the frame
+     *  as-is (packed, no per-pixel arrays: NAPARI-SVC-23) — with ratios/origin mapping image coords
+     *  ↔ readback pixels. Cached until the readback changes. */
+    cachedImageData() {
+        const px = this.lastPixels;
+        const viewer = this.host.viewer();
+        if (!px || !viewer)
+            return null;
+        if (this.cachedImage && this.cachedImageSource === px)
+            return this.cachedImage;
+        const w = px.width;
+        const h = px.height;
+        // Use the rect captured WITH this readback (not the live one) so ratios/origin match the
+        // matrix's camera — otherwise a pan/zoom since the readback mis-scales the traced region.
+        const rect = this.lastPixelsRect ?? viewer.visibleWorldRect();
+        this.cachedImage = {
+            frames: [packedFrame(px.data, w, h)],
+            width: w,
+            height: h,
+            ratios: [rect.width / w, rect.height / h],
+            isGrayscale: false,
+            originX: rect.x,
+            originY: rect.y,
+        };
+        this.cachedImageSource = px;
+        return this.cachedImage;
+    }
+    /**
+     * The service's `beforeToolChange`: track the pixel-reading tool (see {@link onViewChanged}),
+     * gate the camera, and arm a fresh readback for a pixel tool. Nothing is armed without a
+     * viewer, nor a pixel tool before a plot built its coordinate transform.
+     *
+     * Control gating: a tool that ACTIVATES disables the camera controls; deactivation is a no-op
+     * because the host always calls the region overlay's setMode FIRST in each toggle (which sets
+     * the baseline enabled/disabled), so re-enabling here would fight a freshly-activated draw mode.
+     */
+    beforeToolChange(next) {
+        this.pixelTools.clear();
+        if (next !== null && next !== 'zoomToBox')
+            this.pixelTools.add(next);
+        const viewer = this.host.viewer();
+        if (!viewer)
+            return false; // no plot yet → nothing to drive
+        if (next === null)
+            return true;
+        if (next !== 'zoomToBox' && !this.coordTransform)
+            return false;
+        viewer.setControlsEnabled(false);
+        if (next === 'zoomToBox')
+            return true;
+        this.cachedImageSource = null;
+        // The eraser only converts coordinates with the readback, so a current one will do.
+        if (next !== 'eraseVertex' || this.pixelsStale)
+            this.armReadback(0);
+        return true;
+    }
+    /** SAM over the drawn rectangles — a server round-trip that reads the rectangles from the
+     *  RegionStore and the image from a fresh readback. Returns the regions added. */
+    async segmentRectangles() {
+        if (!this.host.viewer() || !this.coordTransform)
+            return 0;
+        await this.runReadback(); // the SAM embedding samples the currently-displayed image
+        this.cachedImageSource = null;
+        return this.deps.samTool.segmentBoxes(this.toolHost);
+    }
+    /** Cellpose over the drawn rectangles (see {@link segmentRectangles}). */
+    async segmentRectanglesCellpose() {
+        const segmenter = this.deps.cellSegmenter;
+        if (!this.host.viewer() || !this.coordTransform || !segmenter)
+            return 0;
+        await this.runReadback();
+        this.cachedImageSource = null;
+        return this.deps.cellSegmentTool.segmentBoxes(this.toolHost, segmenter);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-tool-bridge.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-tool-bridge.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Viewer } from 'napari-js';\n\nimport { CanvasToolId } from '../../contracts/display-types';\nimport { ICoordinateTransform } from '../../contracts/coordinate-transform.contract';\nimport { PixelData } from '../../contracts/visualizer.contract';\nimport { ICellSegmenter } from '../../contracts/cell-segmenter.contract';\nimport { RegionStore } from '../../store/region-store.service';\nimport { IDENTITY_AFFINE } from '../../region-overlay/svg-region-renderer';\nimport { CachedImageData, CanvasToolHost } from '../../toolbar/tool-kit/canvas-tool';\nimport { CanvasToolManager } from '../../toolbar/tool-kit/canvas-tool-manager';\nimport { createCanvasToolManager } from '../../toolbar/canvas-tools';\nimport { packedFrame } from '../../toolbar/tool-kit/frame-pixels';\nimport { WandService } from '../../toolbar/wand/wand.service';\nimport { SamToolService } from '../../toolbar/segmentation/sam-tool.service';\nimport { SamPointToolService } from '../../toolbar/segmentation/sam-point-tool.service';\nimport { CellSegmentToolService } from '../../toolbar/segmentation/cell-segment-tool.service';\nimport { NapariRegionOverlay, OverlayViewer } from './napari-region-overlay';\nimport { READBACK_DEBOUNCE_MS } from './napari-helpers';\n\n/** A world-space rectangle (x, y = top-left). */\nexport interface WorldRect {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/** ICoordinateTransform over the napari camera: pointer client coords ↔ image/world coords. */\nexport class NapariCoordinateTransform implements ICoordinateTransform {\n  constructor(\n    private readonly viewer: {\n      canvasToWorld(clientX: number, clientY: number): [number, number];\n      readonly camera: { zoom: number };\n    },\n    private readonly ready: () => boolean,\n  ) {}\n  clientToData(clientX: number, clientY: number): { x: number; y: number } {\n    const [x, y] = this.viewer.canvasToWorld(clientX, clientY);\n    return { x, y };\n  }\n  dataLengthToScreen(dataLength: number): number {\n    return dataLength * this.viewer.camera.zoom; // CSS px per world unit\n  }\n  isReady(): boolean {\n    return this.ready();\n  }\n}\n\n/** What the bridge reads from the service: the live viewer and its DOM, the image on screen, and\n *  where the viewport and zone-crossing output go. */\nexport interface ToolBridgeHost {\n  viewer(): Viewer | null;\n  host(): HTMLElement | null;\n  canvas(): HTMLCanvasElement | null;\n  /** The image's full-resolution size, or null before one is drawn. */\n  imageSize(): { width: number; height: number } | null;\n  frameIndex(): number;\n  fileName(): string | undefined;\n  /** The visible region changed (clamped to the image); called outside the Angular zone. */\n  viewportChanged(rect: WorldRect): void;\n  /** Run `fn` outside / inside the Angular zone. */\n  outsideZone<T>(fn: () => T): T;\n  inZone<T>(fn: () => T): T;\n}\n\n/** The services the pixel tools and segmentation runs need. */\nexport interface ToolBridgeDeps {\n  regionStore: RegionStore;\n  wandService: WandService;\n  samTool: SamToolService;\n  samPointTool: SamPointToolService;\n  cellSegmentTool: CellSegmentToolService;\n  cellSegmenter: ICellSegmenter | null;\n}\n\n/**\n * The napari backend's side of the shared canvas tools (review Appendix B, step 4): the region\n * overlay, the {@link CanvasToolManager} and its host, the coordinate transform, and the\n * displayed-pixel readback the wand, brush, eraser and SAM/cellpose read — kept current as the\n * camera moves, but only paid for while a pixel tool needs it (NAPARI-SVC-26).\n *\n * One per service; {@link teardown} ends a scene's interaction (overlay, camera hook, timers,\n * pixels) and an `install…Interaction` starts the next one's.\n */\nexport class NapariToolBridge {\n  /** What this backend's canvas tools read and write (one host for every tool). */\n  readonly toolHost: CanvasToolHost;\n  /** This backend's own wand, brush, eraser, zoom-to-box and SAM point tools. */\n  readonly canvasTools: CanvasToolManager;\n  /** SVG region-drawing overlay (null until a 2D/3D interaction is installed). */\n  regionOverlay: NapariRegionOverlay | null = null;\n  /** The pixel tools' pointer ↔ world transform for the current viewer. */\n  coordTransform: ICoordinateTransform | null = null;\n  /** The last readback of the displayed composite (the pixel tools' source). */\n  lastPixels: PixelData | null = null;\n  /** Visible world rect captured AT the last readback — must pair with `lastPixels` so the pixel\n   *  tools' ratios/origin match the matrix's camera (using the live rect after a pan/zoom would\n   *  mis-scale the region). */\n  lastPixelsRect: WorldRect | null = null;\n  /** Active tools that read the displayed pixels; a pan/zoom re-reads them only while non-empty. */\n  readonly pixelTools = new Set<CanvasToolId>();\n  /** The camera moved since {@link lastPixels} was read. */\n  pixelsStale = false;\n  /** Cached CachedImageData built from the last readback (rebuilt when lastPixels changes). */\n  private cachedImage: CachedImageData | null = null;\n  private cachedImageSource: PixelData | null = null;\n  /** Debounced readback timer + camera-change unsubscribe (keep lastPixels current for tools). */\n  private readbackTimer: ReturnType<typeof setTimeout> | null = null;\n  /** Debounced viewport emission for a camera change that needs no pixels. */\n  private viewportTimer: ReturnType<typeof setTimeout> | null = null;\n  private cameraOff: (() => void) | null = null;\n\n  constructor(\n    private readonly host: ToolBridgeHost,\n    private readonly deps: ToolBridgeDeps,\n  ) {\n    const { regionStore } = deps;\n    // The pixel tools read displayed pixels synchronously from the last readback and convert\n    // pointer coords via the napari camera, mirroring the OSD host. This backend owns its own tool\n    // instances (RT-21); the host reads live state, so it is built once.\n    this.toolHost = {\n      getRegions: () => regionStore.getRegions(),\n      setRegions: (r) => regionStore.setRegions(r),\n      getCachedImageData: () => this.cachedImageData(),\n      getActiveFrameIndex: () => host.frameIndex(),\n      getOverlayContainer: () => host.host(),\n      getCoordinateTransform: () => this.coordTransform as ICoordinateTransform,\n      getFileName: () => host.fileName(),\n      getShapeColor: () => regionStore.getShapeColor(),\n      pixelToData: (px, py) => {\n        const rect = host.host()?.getBoundingClientRect();\n        const viewer = host.viewer();\n        if (!viewer || !rect) return { x: 0, y: 0 };\n        const [x, y] = viewer.canvasToWorld(rect.left + px, rect.top + py);\n        return { x, y };\n      },\n      applyZoomToBox: (coords) => this.applyZoomToBox(coords),\n    };\n    this.canvasTools = createCanvasToolManager(this.toolHost, {\n      wandService: deps.wandService,\n      regionStore,\n      samPoint: deps.samPointTool,\n    });\n  }\n\n  /**\n   * The interaction stack every 2D mode needs: the region overlay (draw/select/edit), the pixel\n   * tools that read back displayed pixels (wand, brush, vertex eraser, zoom-to-box, SAM/cellpose),\n   * and a camera hook that keeps that readback current as the view pans/zooms and tiled levels\n   * load.\n   *\n   * One call for all of it because forgetting it is invisible: the toolbar gates its region buttons\n   * on 2D-vs-3D rather than on plot type, so a 2D mode that skips this shows every tool and silently\n   * does nothing. That is exactly what happened to the spatial and region-centroid scatter modes.\n   */\n  install2dInteraction(viewer: Viewer, host: HTMLElement): void {\n    this.regionOverlay = new NapariRegionOverlay(host, viewer, this.deps.regionStore);\n    this.buildCoordinateTransform();\n    this.cameraOff = viewer.camera.changed.connect(() => this.onViewChanged());\n  }\n\n  /**\n   * Region drawing for the 3D cloud.\n   *\n   * Reuses {@link NapariRegionOverlay} verbatim by handing it a SCREEN-SPACE viewer: the drawn\n   * shape is a lasso in canvas pixels, so \"world\" is the canvas and both transforms are identity\n   * (bar the client→canvas offset). Every existing tool — rectangle, polygon, freehand — therefore\n   * works in 3D with no new drawing code.\n   *\n   * A screen-space shape stops meaning anything the moment the camera moves, so an orbit clears\n   * the regions drawn in this view (and only those). The SELECTION they produced is kept: that is\n   * the durable artefact, and the highlighted points stay highlighted from every angle.\n   */\n  install3dInteraction(viewer: Viewer, host: HTMLElement): void {\n    const { regionStore } = this.deps;\n    // World here is the canvas, not the image: no region source to draw.\n    this.regionOverlay = new NapariRegionOverlay(host, this.screenSpaceViewer(viewer), regionStore, {\n      regionSource: false,\n    });\n    this.buildCoordinateTransform();\n    // Regions already in the shared store when the 3D view mounted (the image's own, say) are\n    // not screen-space shapes and must survive an orbit; only those drawn here are cleared.\n    // (No mid-gesture case to guard: the overlay disables the camera controls while drawing.)\n    const foreign = new Set(regionStore.getRegions().map((r) => r.id));\n    this.cameraOff = viewer.camera3d.changed.connect(() => {\n      const drawn = regionStore\n        .getRegions()\n        .filter((r) => !foreign.has(r.id))\n        .map((r) => r.id);\n      // Not an edit of the user's: no undo step (NAPARI-SVC-11).\n      if (drawn.length) this.host.inZone(() => regionStore.removeRegions(drawn, { recordUndo: false }));\n    });\n  }\n\n  /**\n   * The {@link OverlayViewer} the 3D region overlay draws through: \"world\" is the canvas, in\n   * canvas-local CSS pixels. A pointer arrives in CLIENT pixels, so `canvasToWorld` subtracts the\n   * canvas's client offset (without it the lasso was drawn offset from the cursor whenever the\n   * canvas was not at the page origin); drawing is then the identity, with no layout read.\n   */\n  screenSpaceViewer(viewer: Viewer): OverlayViewer {\n    return {\n      canvasToWorld: (clientX: number, clientY: number) => {\n        const r = this.host.canvas()?.getBoundingClientRect();\n        return r ? [clientX - r.left, clientY - r.top] : [clientX, clientY];\n      },\n      canvasTransform: () => IDENTITY_AFFINE,\n      setControlsEnabled: (enabled: boolean) => viewer.setControlsEnabled(enabled),\n      camera: viewer.camera3d,\n    };\n  }\n\n  /** End the scene's interaction: the overlay, the camera hook, the pending timers and the\n   *  pixels read from the old canvas. The armed tool and the pixel-tool set persist. */\n  teardown(): void {\n    this.regionOverlay?.destroy();\n    this.regionOverlay = null;\n    this.cachedImage = null;\n    this.cachedImageSource = null;\n    this.lastPixelsRect = null;\n    if (this.readbackTimer != null) {\n      clearTimeout(this.readbackTimer);\n      this.readbackTimer = null;\n    }\n    if (this.viewportTimer != null) {\n      clearTimeout(this.viewportTimer);\n      this.viewportTimer = null;\n    }\n    this.pixelsStale = false;\n    this.cameraOff?.();\n    this.cameraOff = null;\n    this.lastPixels = null;\n  }\n\n  /** Read the displayed composite into `lastPixels` (the pixel-tools' source) + emit the clamped\n   *  visible region. A fresh PixelData object means cachedImageData() rebuilds automatically. */\n  async runReadback(): Promise<void> {\n    const v = this.host.viewer();\n    if (!v) return;\n    try {\n      const px = await v.readDisplayedPixels();\n      if (this.host.viewer() !== v) return;\n      const rect = v.visibleWorldRect(); // capture WITH the pixels (same camera)\n      this.lastPixels = px;\n      this.lastPixelsRect = rect;\n      this.pixelsStale = false;\n      this.emitViewport(rect);\n    } catch {\n      /* readback unavailable (no device yet, or it was lost): the tools keep the last pixels */\n    }\n  }\n\n  /** A readback on the next frame — after a plot or a scene change drew something new. */\n  scheduleReadback(): void {\n    if (!this.host.viewer()) return;\n    this.host.outsideZone(() => {\n      if (typeof requestAnimationFrame === 'function') requestAnimationFrame(() => void this.runReadback());\n      else setTimeout(() => void this.runReadback(), 0);\n    });\n  }\n\n  /** Debounced readback — armed on camera changes while a pixel tool is active, so `lastPixels`\n   *  tracks the current view after a pan/zoom settles, which the on-canvas pixel tools\n   *  (wand/brush/SAM) read synchronously. Coalesces rapid changes. */\n  armReadback(delayMs = READBACK_DEBOUNCE_MS): void {\n    if (this.readbackTimer != null) clearTimeout(this.readbackTimer);\n    this.readbackTimer = this.host.outsideZone(() =>\n      setTimeout(() => {\n        this.readbackTimer = null;\n        void this.runReadback();\n      }, delayMs),\n    );\n  }\n\n  /** Emit the visible region, clamped to the image. */\n  private emitViewport(rect: WorldRect): void {\n    const size = this.host.imageSize();\n    if (!size || !rect) return;\n    const x = Math.max(0, Math.min(size.width, rect.x));\n    const y = Math.max(0, Math.min(size.height, rect.y));\n    const width = Math.max(1, Math.min(size.width - x, rect.width));\n    const height = Math.max(1, Math.min(size.height - y, rect.height));\n    this.host.viewportChanged({ x, y, width, height });\n  }\n\n  /**\n   * A 2D pan/zoom. The full-canvas GPU readback is paid for only while a pixel tool reads it\n   * ({@link pixelTools}); otherwise only the viewport rect is emitted (debounced), and the pixels\n   * are marked stale for whoever next needs them (a tool arms a fresh readback as it activates).\n   */\n  private onViewChanged(): void {\n    this.pixelsStale = true;\n    if (this.pixelTools.size > 0) {\n      this.armReadback(); // emits the viewport with the pixels\n      return;\n    }\n    if (this.viewportTimer != null) clearTimeout(this.viewportTimer);\n    this.viewportTimer = this.host.outsideZone(() =>\n      setTimeout(() => {\n        this.viewportTimer = null;\n        const viewer = this.host.viewer();\n        if (viewer) this.emitViewport(viewer.visibleWorldRect());\n      }, READBACK_DEBOUNCE_MS),\n    );\n  }\n\n  /** Build the pixel tools' coordinate transform for the current viewer. */\n  private buildCoordinateTransform(): void {\n    const viewer = this.host.viewer();\n    if (!viewer) return;\n    this.coordTransform = new NapariCoordinateTransform(\n      viewer,\n      () => !!this.host.viewer() && (this.host.imageSize()?.width ?? 0) > 0,\n    );\n  }\n\n  /** Zoom/pan the camera to fit a data-space rectangle `[xMin, xMax, yMax, yMin]`. */\n  private applyZoomToBox(coordinates: number[]): void {\n    const v = this.host.viewer();\n    const canvas = this.host.canvas();\n    if (!v || !canvas || coordinates.length < 4) return;\n    const [xMin, xMax, yA, yB] = coordinates;\n    const x0 = Math.min(xMin, xMax);\n    const x1 = Math.max(xMin, xMax);\n    const y0 = Math.min(yA, yB);\n    const y1 = Math.max(yA, yB);\n    const w = Math.max(1, x1 - x0);\n    const h = Math.max(1, y1 - y0);\n    const vw = canvas.clientWidth || w;\n    const vh = canvas.clientHeight || h;\n    v.camera.center = [(x0 + x1) / 2, (y0 + y1) / 2];\n    v.camera.zoom = Math.min(vw / w, vh / h);\n    v.requestRender();\n  }\n\n  /** Build CachedImageData from the most recent readback — its RGBA device pixels are the frame\n   *  as-is (packed, no per-pixel arrays: NAPARI-SVC-23) — with ratios/origin mapping image coords\n   *  ↔ readback pixels. Cached until the readback changes. */\n  cachedImageData(): CachedImageData | null {\n    const px = this.lastPixels;\n    const viewer = this.host.viewer();\n    if (!px || !viewer) return null;\n    if (this.cachedImage && this.cachedImageSource === px) return this.cachedImage;\n    const w = px.width;\n    const h = px.height;\n    // Use the rect captured WITH this readback (not the live one) so ratios/origin match the\n    // matrix's camera — otherwise a pan/zoom since the readback mis-scales the traced region.\n    const rect = this.lastPixelsRect ?? viewer.visibleWorldRect();\n    this.cachedImage = {\n      frames: [packedFrame(px.data, w, h)],\n      width: w,\n      height: h,\n      ratios: [rect.width / w, rect.height / h],\n      isGrayscale: false,\n      originX: rect.x,\n      originY: rect.y,\n    };\n    this.cachedImageSource = px;\n    return this.cachedImage;\n  }\n\n  /**\n   * The service's `beforeToolChange`: track the pixel-reading tool (see {@link onViewChanged}),\n   * gate the camera, and arm a fresh readback for a pixel tool. Nothing is armed without a\n   * viewer, nor a pixel tool before a plot built its coordinate transform.\n   *\n   * Control gating: a tool that ACTIVATES disables the camera controls; deactivation is a no-op\n   * because the host always calls the region overlay's setMode FIRST in each toggle (which sets\n   * the baseline enabled/disabled), so re-enabling here would fight a freshly-activated draw mode.\n   */\n  beforeToolChange(next: CanvasToolId | null): boolean {\n    this.pixelTools.clear();\n    if (next !== null && next !== 'zoomToBox') this.pixelTools.add(next);\n    const viewer = this.host.viewer();\n    if (!viewer) return false; // no plot yet → nothing to drive\n    if (next === null) return true;\n    if (next !== 'zoomToBox' && !this.coordTransform) return false;\n    viewer.setControlsEnabled(false);\n    if (next === 'zoomToBox') return true;\n    this.cachedImageSource = null;\n    // The eraser only converts coordinates with the readback, so a current one will do.\n    if (next !== 'eraseVertex' || this.pixelsStale) this.armReadback(0);\n    return true;\n  }\n\n  /** SAM over the drawn rectangles — a server round-trip that reads the rectangles from the\n   *  RegionStore and the image from a fresh readback. Returns the regions added. */\n  async segmentRectangles(): Promise<number> {\n    if (!this.host.viewer() || !this.coordTransform) return 0;\n    await this.runReadback(); // the SAM embedding samples the currently-displayed image\n    this.cachedImageSource = null;\n    return this.deps.samTool.segmentBoxes(this.toolHost);\n  }\n\n  /** Cellpose over the drawn rectangles (see {@link segmentRectangles}). */\n  async segmentRectanglesCellpose(): Promise<number> {\n    const segmenter = this.deps.cellSegmenter;\n    if (!this.host.viewer() || !this.coordTransform || !segmenter) return 0;\n    await this.runReadback();\n    this.cachedImageSource = null;\n    return this.deps.cellSegmentTool.segmentBoxes(this.toolHost, segmenter);\n  }\n}\n"]}