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

package/esm2022/lib/implementations/napari-js/napari-volume-slice-planes.mjs

@@ -0,0 +1,103 @@
+import { parseColor } from 'napari-js';
+import { SlicePlanesWidget } from 'napari-js/overlays';
+/** Each plane's colour: its axis's, as the axes gizmo draws them. */
+export const SLICE_PLANE_COLORS = {
+    x: '#ff5c5c',
+    y: '#4cd964',
+    z: '#668cff',
+};
+/** A plane's opacity: enough to read where it is, not to hide the volume behind it … */
+export const SLICE_PLANE_OPACITY = 0.22;
+/** … and while it is dragged. */
+export const SLICE_PLANE_DRAG_OPACITY = 0.4;
+const AXES = ['x', 'y', 'z'];
+/**
+ * The planes of the sections shown beside a volume view: napari-js's {@link SlicePlanesWidget}
+ * (translucent quads in their axis's colour, each with a grip that drags it along its axis) over
+ * the stack's frame. It works in the frame's image px and slices: the widget's box is the image,
+ * one voxel per px, so a px position is the widget's shifted by half a pixel (pixel i spans
+ * [i, i + 1) here, is centred on i there); a slice is the same in both.
+ */
+export class VolumeSlicePlanes {
+    constructor(viewer, host, opts) {
+        this.viewer = viewer;
+        this.host = host;
+        this.opts = opts;
+        this.widget = null;
+        this.frame = null;
+        this.planes = { x: null, y: null, z: null };
+        /** Set while the planes are moved from here, so the widget's echo is not reported as a drag. */
+        this.applying = false;
+    }
+    /** Follow the volume's frame (it opened, or its Z was stretched). */
+    setFrame(frame) {
+        this.frame = frame;
+        this.rebuild();
+    }
+    /** Show the planes where they are now (null: hide one). */
+    set(planes) {
+        this.planes = { ...planes };
+        if (this.widget)
+            this.apply();
+        else
+            this.rebuild();
+    }
+    clear() {
+        this.widget?.dispose();
+        this.widget = null;
+        this.planes = { x: null, y: null, z: null };
+    }
+    destroy() {
+        this.clear();
+    }
+    /** The widget over the current frame, made when there is one and a plane to show. */
+    rebuild() {
+        this.widget?.dispose();
+        this.widget = null;
+        const frame = this.frame;
+        if (!frame || AXES.every((a) => this.planes[a] === null))
+            return;
+        const [w, h, d] = frame.size;
+        const [ww, wh, wd] = frame.world;
+        const widget = new SlicePlanesWidget(this.host, this.viewer, {
+            volume: { shape: [w, h, d], voxelSize: [ww / w, wh / h, wd / d] },
+            colors: { x: rgb(SLICE_PLANE_COLORS.x), y: rgb(SLICE_PLANE_COLORS.y), z: rgb(SLICE_PLANE_COLORS.z) },
+            opacity: SLICE_PLANE_OPACITY,
+            dragOpacity: SLICE_PLANE_DRAG_OPACITY,
+        });
+        widget.changed.connect(({ axis, value }) => {
+            if (!this.applying)
+                this.opts.onMove(axis, fromWidget(axis, value));
+        });
+        this.widget = widget;
+        this.apply();
+    }
+    apply() {
+        const widget = this.widget;
+        this.applying = true;
+        try {
+            for (const axis of AXES) {
+                const at = this.planes[axis];
+                widget.setVisible(axis, at !== null);
+                if (at !== null)
+                    widget.setPosition(axis, toWidget(axis, at));
+            }
+        }
+        finally {
+            this.applying = false;
+        }
+    }
+}
+/** Image px (pixel i spanning [i, i + 1)) → the widget's data coordinates (centred on i); slices as is. */
+function toWidget(axis, v) {
+    return axis === 'z' ? v : v - 0.5;
+}
+function fromWidget(axis, v) {
+    return axis === 'z' ? v : v + 0.5;
+}
+/** `#rrggbb` → 0..1 RGB. */
+function rgb(css) {
+    const [r, g, b] = parseColor(css) ?? [1, 1, 1, 1];
+    return [r, g, b];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-volume-slice-planes.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-volume-slice-planes.ts"],"names":[],"mappings":"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","sourcesContent":["import { parseColor } from 'napari-js';\nimport type { Viewer } from 'napari-js';\nimport { SlicePlanesWidget } from 'napari-js/overlays';\n\nimport type { VolumeFrame } from './napari-volume-region-meshes';\n\n/** A plane across the volume: x = const, y = const (image px) or z = const (a slice). */\nexport type PlaneAxis = 'x' | 'y' | 'z';\n\n/** Where each plane is (image px for x and y, the slice for z); null: not shown. */\nexport type SlicePlanes = Record<PlaneAxis, number | null>;\n\n/** Each plane's colour: its axis's, as the axes gizmo draws them. */\nexport const SLICE_PLANE_COLORS: Readonly<Record<PlaneAxis, string>> = {\n  x: '#ff5c5c',\n  y: '#4cd964',\n  z: '#668cff',\n};\n/** A plane's opacity: enough to read where it is, not to hide the volume behind it … */\nexport const SLICE_PLANE_OPACITY = 0.22;\n/** … and while it is dragged. */\nexport const SLICE_PLANE_DRAG_OPACITY = 0.4;\n\nconst AXES: readonly PlaneAxis[] = ['x', 'y', 'z'];\n\nexport interface SlicePlanesOptions {\n  /** A plane dragged to `value` along its axis (image px, or a fractional slice). */\n  onMove(axis: PlaneAxis, value: number): void;\n}\n\n/**\n * The planes of the sections shown beside a volume view: napari-js's {@link SlicePlanesWidget}\n * (translucent quads in their axis's colour, each with a grip that drags it along its axis) over\n * the stack's frame. It works in the frame's image px and slices: the widget's box is the image,\n * one voxel per px, so a px position is the widget's shifted by half a pixel (pixel i spans\n * [i, i + 1) here, is centred on i there); a slice is the same in both.\n */\nexport class VolumeSlicePlanes {\n  private widget: SlicePlanesWidget | null = null;\n  private frame: VolumeFrame | null = null;\n  private planes: SlicePlanes = { x: null, y: null, z: null };\n  /** Set while the planes are moved from here, so the widget's echo is not reported as a drag. */\n  private applying = false;\n\n  constructor(\n    private readonly viewer: Viewer,\n    private readonly host: HTMLElement,\n    private readonly opts: SlicePlanesOptions,\n  ) {}\n\n  /** Follow the volume's frame (it opened, or its Z was stretched). */\n  setFrame(frame: VolumeFrame): void {\n    this.frame = frame;\n    this.rebuild();\n  }\n\n  /** Show the planes where they are now (null: hide one). */\n  set(planes: SlicePlanes): void {\n    this.planes = { ...planes };\n    if (this.widget) this.apply();\n    else this.rebuild();\n  }\n\n  clear(): void {\n    this.widget?.dispose();\n    this.widget = null;\n    this.planes = { x: null, y: null, z: null };\n  }\n\n  destroy(): void {\n    this.clear();\n  }\n\n  /** The widget over the current frame, made when there is one and a plane to show. */\n  private rebuild(): void {\n    this.widget?.dispose();\n    this.widget = null;\n    const frame = this.frame;\n    if (!frame || AXES.every((a) => this.planes[a] === null)) return;\n    const [w, h, d] = frame.size;\n    const [ww, wh, wd] = frame.world;\n    const widget = new SlicePlanesWidget(this.host, this.viewer, {\n      volume: { shape: [w, h, d], voxelSize: [ww / w, wh / h, wd / d] },\n      colors: { x: rgb(SLICE_PLANE_COLORS.x), y: rgb(SLICE_PLANE_COLORS.y), z: rgb(SLICE_PLANE_COLORS.z) },\n      opacity: SLICE_PLANE_OPACITY,\n      dragOpacity: SLICE_PLANE_DRAG_OPACITY,\n    });\n    widget.changed.connect(({ axis, value }) => {\n      if (!this.applying) this.opts.onMove(axis, fromWidget(axis, value));\n    });\n    this.widget = widget;\n    this.apply();\n  }\n\n  private apply(): void {\n    const widget = this.widget as SlicePlanesWidget;\n    this.applying = true;\n    try {\n      for (const axis of AXES) {\n        const at = this.planes[axis];\n        widget.setVisible(axis, at !== null);\n        if (at !== null) widget.setPosition(axis, toWidget(axis, at));\n      }\n    } finally {\n      this.applying = false;\n    }\n  }\n}\n\n/** Image px (pixel i spanning [i, i + 1)) → the widget's data coordinates (centred on i); slices as is. */\nfunction toWidget(axis: PlaneAxis, v: number): number {\n  return axis === 'z' ? v : v - 0.5;\n}\n\nfunction fromWidget(axis: PlaneAxis, v: number): number {\n  return axis === 'z' ? v : v + 0.5;\n}\n\n/** `#rrggbb` → 0..1 RGB. */\nfunction rgb(css: string): [number, number, number] {\n  const [r, g, b] = parseColor(css) ?? [1, 1, 1, 1];\n  return [r, g, b];\n}\n"]}

package/esm2022/lib/implementations/napari-js/napari-volume-z-handle.mjs

@@ -1,14 +1,14 @@
 /**
  * Draggable Z-height handle for the napari-js WebGPU volume (jit-ui#102). A small DOM grip is drawn
- * over the 3D canvas at the projected top-face centre of the volume box (reusing the axes-label
- * {@link projectPoint} projection, so it tracks the box as the volume orbits). Dragging it up makes
+ * over the 3D canvas at the projected top-face centre of the volume box (projected with napari-js's
+ * {@link projectPoint}, as the axes labels are, so it tracks the box as the volume orbits). Dragging it up makes
  * the volume taller, down makes it flatter — the host maps the drag to a Z-scale factor and
  * restretches the volume + axes live (only the model matrix changes; the voxel texture is untouched).
  *
- * Direct-manipulation counterpart of {@link NapariAxesLabels}: both are absolute-positioned overlays
- * updated on every `camera3d.changed`, but this one accepts pointer input.
+ * Direct-manipulation counterpart of napari-js's `AxesLabelsOverlay`: both are absolute-positioned
+ * overlays updated on every `camera3d.changed`, but this one accepts pointer input.
  */
-import { projectPoint } from './napari-axes-labels';
+import { projectPoint } from 'napari-js';
 const DEFAULTS = { pixelsPerDouble: 180, minScale: 0.1, maxScale: 10 };
 export class NapariVolumeZHandle {
     constructor(host, camera3d, opts) {
@@ -123,4 +123,4 @@ export class NapariVolumeZHandle {
         this.el.parentNode?.removeChild(this.el);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-volume-z-handle.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-volume-z-handle.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Draggable Z-height handle for the napari-js WebGPU volume (jit-ui#102). A small DOM grip is drawn\n * over the 3D canvas at the projected top-face centre of the volume box (reusing the axes-label\n * {@link projectPoint} projection, so it tracks the box as the volume orbits). Dragging it up makes\n * the volume taller, down makes it flatter — the host maps the drag to a Z-scale factor and\n * restretches the volume + axes live (only the model matrix changes; the voxel texture is untouched).\n *\n * Direct-manipulation counterpart of {@link NapariAxesLabels}: both are absolute-positioned overlays\n * updated on every `camera3d.changed`, but this one accepts pointer input.\n */\nimport { AxesLabelCamera3D, projectPoint } from './napari-axes-labels';\n\nexport interface VolumeZHandleOptions {\n  /** Current top-face-centre world point (the box is centred at the origin, so `[0, 0, +halfZ]`). */\n  topAnchor: () => [number, number, number];\n  /** The current Z-scale factor (1 = the volume's default proportions). */\n  getScale: () => number;\n  /** Apply a new Z-scale factor — the host restretches the volume + axes and repositions overlays. */\n  setScale: (scale: number) => void;\n  /** Vertical drag (px) for one doubling/halving of the Z height. Larger = less sensitive. */\n  pixelsPerDouble?: number;\n  /** Clamp for the Z-scale factor. */\n  minScale?: number;\n  maxScale?: number;\n}\n\nconst DEFAULTS = { pixelsPerDouble: 180, minScale: 0.1, maxScale: 10 };\n\nexport class NapariVolumeZHandle {\n  private readonly el: HTMLDivElement;\n  private readonly disconnectCamera: () => void;\n  private readonly resizeObserver?: ResizeObserver;\n  private readonly opts: Required<VolumeZHandleOptions>;\n  private visible = true;\n  private dragging = false;\n  private startY = 0;\n  private startScale = 1;\n\n  constructor(\n    private readonly host: HTMLElement,\n    private readonly camera3d: AxesLabelCamera3D,\n    opts: VolumeZHandleOptions,\n  ) {\n    this.opts = { ...DEFAULTS, ...opts };\n    if (getComputedStyle(host).position === 'static') host.style.position = 'relative';\n\n    this.el = document.createElement('div');\n    Object.assign(this.el.style, {\n      position: 'absolute',\n      zIndex: '31',\n      width: '22px',\n      height: '22px',\n      marginLeft: '-11px',\n      marginTop: '-11px',\n      borderRadius: '50%',\n      background: 'rgba(102,140,255,0.85)', // matches the Z axis colour (#668cff)\n      border: '1.5px solid #fff',\n      boxShadow: '0 0 4px rgba(0,0,0,0.6)',\n      color: '#fff',\n      font: '13px sans-serif',\n      lineHeight: '20px',\n      textAlign: 'center',\n      cursor: 'ns-resize',\n      touchAction: 'none',\n      userSelect: 'none',\n    } as Partial<CSSStyleDeclaration>);\n    this.el.textContent = '↕';\n    this.el.title = 'Drag to change the volume height (Z). Double-click to reset.';\n    this.host.appendChild(this.el);\n\n    this.el.addEventListener('pointerdown', this.onPointerDown);\n    this.el.addEventListener('pointermove', this.onPointerMove);\n    this.el.addEventListener('pointerup', this.onPointerUp);\n    this.el.addEventListener('pointercancel', this.onPointerUp);\n    this.el.addEventListener('dblclick', this.onDoubleClick);\n\n    this.disconnectCamera = this.camera3d.changed.connect(() => this.reposition());\n    if (typeof ResizeObserver !== 'undefined') {\n      this.resizeObserver = new ResizeObserver(() => this.reposition());\n      this.resizeObserver.observe(this.host);\n    }\n    this.reposition();\n  }\n\n  setVisible(visible: boolean): void {\n    this.visible = visible;\n    this.reposition();\n  }\n\n  /** Reproject the handle to the current top-face anchor. Called on camera move, resize, and after\n   *  the host applies a new scale (so the grip follows the growing/shrinking box). */\n  reposition(): void {\n    const vw = this.host.clientWidth;\n    const vh = this.host.clientHeight;\n    if (!this.visible || vw <= 0 || vh <= 0) {\n      this.el.style.display = 'none';\n      return;\n    }\n    const mvp = this.camera3d.viewProjection(vw, vh);\n    const s = projectPoint(mvp, this.opts.topAnchor(), vw, vh);\n    if (!s.visible) {\n      this.el.style.display = 'none';\n      return;\n    }\n    this.el.style.display = '';\n    this.el.style.left = `${s.x}px`;\n    this.el.style.top = `${s.y}px`;\n  }\n\n  private readonly onPointerDown = (e: PointerEvent): void => {\n    e.preventDefault();\n    e.stopPropagation();\n    this.dragging = true;\n    this.startY = e.clientY;\n    this.startScale = this.opts.getScale();\n    this.el.setPointerCapture?.(e.pointerId);\n  };\n\n  private readonly onPointerMove = (e: PointerEvent): void => {\n    if (!this.dragging) return;\n    e.preventDefault();\n    e.stopPropagation();\n    // Up (negative dy) → taller. Exponential so each `pixelsPerDouble` px doubles/halves the height.\n    const dy = e.clientY - this.startY;\n    const factor = Math.pow(2, -dy / this.opts.pixelsPerDouble);\n    const next = Math.min(\n      this.opts.maxScale,\n      Math.max(this.opts.minScale, this.startScale * factor),\n    );\n    this.opts.setScale(next);\n    this.reposition();\n  };\n\n  private readonly onPointerUp = (e: PointerEvent): void => {\n    if (!this.dragging) return;\n    this.dragging = false;\n    if (this.el.hasPointerCapture?.(e.pointerId)) this.el.releasePointerCapture?.(e.pointerId);\n  };\n\n  private readonly onDoubleClick = (e: MouseEvent): void => {\n    e.preventDefault();\n    e.stopPropagation();\n    this.opts.setScale(1);\n    this.reposition();\n  };\n\n  destroy(): void {\n    this.disconnectCamera();\n    this.resizeObserver?.disconnect();\n    this.el.removeEventListener('pointerdown', this.onPointerDown);\n    this.el.removeEventListener('pointermove', this.onPointerMove);\n    this.el.removeEventListener('pointerup', this.onPointerUp);\n    this.el.removeEventListener('pointercancel', this.onPointerUp);\n    this.el.removeEventListener('dblclick', this.onDoubleClick);\n    this.el.parentNode?.removeChild(this.el);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-volume-z-handle.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-volume-z-handle.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Draggable Z-height handle for the napari-js WebGPU volume (jit-ui#102). A small DOM grip is drawn\n * over the 3D canvas at the projected top-face centre of the volume box (projected with napari-js's\n * {@link projectPoint}, as the axes labels are, so it tracks the box as the volume orbits). Dragging it up makes\n * the volume taller, down makes it flatter — the host maps the drag to a Z-scale factor and\n * restretches the volume + axes live (only the model matrix changes; the voxel texture is untouched).\n *\n * Direct-manipulation counterpart of napari-js's `AxesLabelsOverlay`: both are absolute-positioned\n * overlays updated on every `camera3d.changed`, but this one accepts pointer input.\n */\nimport { projectPoint } from 'napari-js';\n\n/** The slice of napari's Camera3D the handle reads. `viewProjection` is column-major (gl-matrix). */\nexport interface ZHandleCamera3D {\n  viewProjection(vw: number, vh: number): ArrayLike<number>;\n  readonly changed: { connect(listener: () => void): () => void };\n}\n\nexport interface VolumeZHandleOptions {\n  /** Current top-face-centre world point (the box is centred at the origin, so `[0, 0, +halfZ]`). */\n  topAnchor: () => [number, number, number];\n  /** The current Z-scale factor (1 = the volume's default proportions). */\n  getScale: () => number;\n  /** Apply a new Z-scale factor — the host restretches the volume + axes and repositions overlays. */\n  setScale: (scale: number) => void;\n  /** Vertical drag (px) for one doubling/halving of the Z height. Larger = less sensitive. */\n  pixelsPerDouble?: number;\n  /** Clamp for the Z-scale factor. */\n  minScale?: number;\n  maxScale?: number;\n}\n\nconst DEFAULTS = { pixelsPerDouble: 180, minScale: 0.1, maxScale: 10 };\n\nexport class NapariVolumeZHandle {\n  private readonly el: HTMLDivElement;\n  private readonly disconnectCamera: () => void;\n  private readonly resizeObserver?: ResizeObserver;\n  private readonly opts: Required<VolumeZHandleOptions>;\n  private visible = true;\n  private dragging = false;\n  private startY = 0;\n  private startScale = 1;\n\n  constructor(\n    private readonly host: HTMLElement,\n    private readonly camera3d: ZHandleCamera3D,\n    opts: VolumeZHandleOptions,\n  ) {\n    this.opts = { ...DEFAULTS, ...opts };\n    if (getComputedStyle(host).position === 'static') host.style.position = 'relative';\n\n    this.el = document.createElement('div');\n    Object.assign(this.el.style, {\n      position: 'absolute',\n      zIndex: '31',\n      width: '22px',\n      height: '22px',\n      marginLeft: '-11px',\n      marginTop: '-11px',\n      borderRadius: '50%',\n      background: 'rgba(102,140,255,0.85)', // matches the Z axis colour (#668cff)\n      border: '1.5px solid #fff',\n      boxShadow: '0 0 4px rgba(0,0,0,0.6)',\n      color: '#fff',\n      font: '13px sans-serif',\n      lineHeight: '20px',\n      textAlign: 'center',\n      cursor: 'ns-resize',\n      touchAction: 'none',\n      userSelect: 'none',\n    } as Partial<CSSStyleDeclaration>);\n    this.el.textContent = '↕';\n    this.el.title = 'Drag to change the volume height (Z). Double-click to reset.';\n    this.host.appendChild(this.el);\n\n    this.el.addEventListener('pointerdown', this.onPointerDown);\n    this.el.addEventListener('pointermove', this.onPointerMove);\n    this.el.addEventListener('pointerup', this.onPointerUp);\n    this.el.addEventListener('pointercancel', this.onPointerUp);\n    this.el.addEventListener('dblclick', this.onDoubleClick);\n\n    this.disconnectCamera = this.camera3d.changed.connect(() => this.reposition());\n    if (typeof ResizeObserver !== 'undefined') {\n      this.resizeObserver = new ResizeObserver(() => this.reposition());\n      this.resizeObserver.observe(this.host);\n    }\n    this.reposition();\n  }\n\n  setVisible(visible: boolean): void {\n    this.visible = visible;\n    this.reposition();\n  }\n\n  /** Reproject the handle to the current top-face anchor. Called on camera move, resize, and after\n   *  the host applies a new scale (so the grip follows the growing/shrinking box). */\n  reposition(): void {\n    const vw = this.host.clientWidth;\n    const vh = this.host.clientHeight;\n    if (!this.visible || vw <= 0 || vh <= 0) {\n      this.el.style.display = 'none';\n      return;\n    }\n    const mvp = this.camera3d.viewProjection(vw, vh);\n    const s = projectPoint(mvp, this.opts.topAnchor(), vw, vh);\n    if (!s.visible) {\n      this.el.style.display = 'none';\n      return;\n    }\n    this.el.style.display = '';\n    this.el.style.left = `${s.x}px`;\n    this.el.style.top = `${s.y}px`;\n  }\n\n  private readonly onPointerDown = (e: PointerEvent): void => {\n    e.preventDefault();\n    e.stopPropagation();\n    this.dragging = true;\n    this.startY = e.clientY;\n    this.startScale = this.opts.getScale();\n    this.el.setPointerCapture?.(e.pointerId);\n  };\n\n  private readonly onPointerMove = (e: PointerEvent): void => {\n    if (!this.dragging) return;\n    e.preventDefault();\n    e.stopPropagation();\n    // Up (negative dy) → taller. Exponential so each `pixelsPerDouble` px doubles/halves the height.\n    const dy = e.clientY - this.startY;\n    const factor = Math.pow(2, -dy / this.opts.pixelsPerDouble);\n    const next = Math.min(this.opts.maxScale, Math.max(this.opts.minScale, this.startScale * factor));\n    this.opts.setScale(next);\n    this.reposition();\n  };\n\n  private readonly onPointerUp = (e: PointerEvent): void => {\n    if (!this.dragging) return;\n    this.dragging = false;\n    if (this.el.hasPointerCapture?.(e.pointerId)) this.el.releasePointerCapture?.(e.pointerId);\n  };\n\n  private readonly onDoubleClick = (e: MouseEvent): void => {\n    e.preventDefault();\n    e.stopPropagation();\n    this.opts.setScale(1);\n    this.reposition();\n  };\n\n  destroy(): void {\n    this.disconnectCamera();\n    this.resizeObserver?.disconnect();\n    this.el.removeEventListener('pointerdown', this.onPointerDown);\n    this.el.removeEventListener('pointermove', this.onPointerMove);\n    this.el.removeEventListener('pointerup', this.onPointerUp);\n    this.el.removeEventListener('pointercancel', this.onPointerUp);\n    this.el.removeEventListener('dblclick', this.onDoubleClick);\n    this.el.parentNode?.removeChild(this.el);\n  }\n}\n"]}

package/esm2022/lib/implementations/napari-js/region-overlay/overlay-projection.mjs

@@ -0,0 +1,96 @@
+import { PIXEL_WORLD_QUANTUM, snapToWorldGrid } from '../../../spatial/world-grid';
+import { applyAffine } from '../../../region-overlay/svg-region-renderer';
+/**
+ * The region overlay's coordinate spaces: pointer CLIENT pixels, svg-LOCAL pixels and WORLD
+ * units, through the viewer's own transforms (see {@link OverlayViewer}).
+ *
+ * World → svg-local is the viewer's camera affine (`canvasTransform`), which reads no layout, so
+ * drawing and following the camera read none. Only a pointer, in client pixels, needs the svg's
+ * client origin: read once per {@link withOrigin} block (a gesture event), as an uncached read
+ * per vertex — interleaved with the elements a redraw appends — forced a synchronous layout per
+ * vertex (review NAPARI-BOUNDARY-10).
+ */
+export class OverlayProjection {
+    constructor(svg, viewer) {
+        this.svg = svg;
+        this.viewer = viewer;
+        /**
+         * How finely a drawn vertex may be placed, in world units.
+         *
+         * One by default, because for an image the world IS pixels and a region should align to
+         * them. A dataset whose coordinates are not pixels sets it finer — seqFISH's whole
+         * sample spans about 5 x 7 units, where whole-unit vertices leave roughly six by eight
+         * placeable positions and no ROI can be drawn at all.
+         */
+        this.worldQuantum = PIXEL_WORLD_QUANTUM;
+        /** The svg's client origin and the camera affine, cached while a {@link withOrigin} block runs. */
+        this.origin = null;
+        this.camera = null;
+        /** {@link toLocal} as the shared region geometry takes it. */
+        this.toScreen = (x, y) => this.toLocal(x, y);
+    }
+    setWorldQuantum(quantum) {
+        this.worldQuantum = Number.isFinite(quantum) && quantum > 0 ? quantum : PIXEL_WORLD_QUANTUM;
+    }
+    /** Pointer client coords → world coords, snapped to the world quantum (for placing vertices). */
+    toImage(clientX, clientY) {
+        const [wx, wy] = this.viewer.canvasToWorld(clientX, clientY);
+        return [snapToWorldGrid(wx, this.worldQuantum), snapToWorldGrid(wy, this.worldQuantum)];
+    }
+    /** Pointer client coords → world coords, exact (for picking: snapping is for placing). */
+    toWorld(clientX, clientY) {
+        return this.viewer.canvasToWorld(clientX, clientY);
+    }
+    /**
+     * World units spanned by one screen pixel, measured through the viewer's own transform.
+     *
+     * Read from the transform rather than from the camera, so it holds for both the 2D and
+     * the 3D screen-space adapters without either having to expose a zoom. Falls back to 1
+     * if the transform gives nothing usable, which keeps the established pixel behaviour
+     * rather than collapsing the threshold to zero and recording a point per event.
+     */
+    worldPerCanvasPixel() {
+        const [x0] = this.viewer.canvasToWorld(0, 0);
+        const [x1] = this.viewer.canvasToWorld(1, 0);
+        const per = Math.abs(x1 - x0);
+        return Number.isFinite(per) && per > 0 ? per : 1;
+    }
+    /** Run `fn` with the svg's client origin and the camera affine read once (nested calls reuse them). */
+    withOrigin(fn) {
+        if (this.origin)
+            return fn();
+        const r = this.svg.getBoundingClientRect();
+        this.origin = { left: r.left, top: r.top };
+        this.camera = this.viewer.canvasTransform();
+        try {
+            return fn();
+        }
+        finally {
+            this.origin = null;
+            this.camera = null;
+        }
+    }
+    /** Client px → SVG-local px. */
+    clientToLocal(clientX, clientY) {
+        const o = this.origin ?? this.svg.getBoundingClientRect();
+        return [clientX - o.left, clientY - o.top];
+    }
+    /** World coords → SVG-local px, through the camera affine: no layout read. */
+    toLocal(imgX, imgY) {
+        return applyAffine(this.affine(), imgX, imgY);
+    }
+    /** Screen distance (px) between a client point and a world point. */
+    screenDist(clientX, clientY, imgX, imgY) {
+        const [lx, ly] = this.toLocal(imgX, imgY);
+        const [px, py] = this.clientToLocal(clientX, clientY);
+        return Math.hypot(px - lx, py - ly);
+    }
+    /**
+     * The world → svg-local affine for the current camera: the viewer's `canvasTransform`, which
+     * reads no layout. The svg and the canvas share an origin (see {@link OverlayViewer}).
+     */
+    affine() {
+        return this.camera ?? this.viewer.canvasTransform();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overlay-projection.js","sourceRoot":"","sources":["../../../../../../src/lib/implementations/napari-js/region-overlay/overlay-projection.ts"],"names":[],"mappings":"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","sourcesContent":["import { PIXEL_WORLD_QUANTUM, snapToWorldGrid } from '../../../spatial/world-grid';\nimport type { ToScreen } from '../../../region-overlay/region-geometry';\nimport { Affine, applyAffine } from '../../../region-overlay/svg-region-renderer';\nimport type { OverlayViewer } from '../napari-region-overlay';\n\n/**\n * The region overlay's coordinate spaces: pointer CLIENT pixels, svg-LOCAL pixels and WORLD\n * units, through the viewer's own transforms (see {@link OverlayViewer}).\n *\n * World → svg-local is the viewer's camera affine (`canvasTransform`), which reads no layout, so\n * drawing and following the camera read none. Only a pointer, in client pixels, needs the svg's\n * client origin: read once per {@link withOrigin} block (a gesture event), as an uncached read\n * per vertex — interleaved with the elements a redraw appends — forced a synchronous layout per\n * vertex (review NAPARI-BOUNDARY-10).\n */\nexport class OverlayProjection {\n  /**\n   * How finely a drawn vertex may be placed, in world units.\n   *\n   * One by default, because for an image the world IS pixels and a region should align to\n   * them. A dataset whose coordinates are not pixels sets it finer — seqFISH's whole\n   * sample spans about 5 x 7 units, where whole-unit vertices leave roughly six by eight\n   * placeable positions and no ROI can be drawn at all.\n   */\n  private worldQuantum = PIXEL_WORLD_QUANTUM;\n  /** The svg's client origin and the camera affine, cached while a {@link withOrigin} block runs. */\n  private origin: { left: number; top: number } | null = null;\n  private camera: Affine | null = null;\n\n  constructor(\n    private readonly svg: SVGSVGElement,\n    private readonly viewer: OverlayViewer,\n  ) {}\n\n  setWorldQuantum(quantum: number): void {\n    this.worldQuantum = Number.isFinite(quantum) && quantum > 0 ? quantum : PIXEL_WORLD_QUANTUM;\n  }\n\n  /** Pointer client coords → world coords, snapped to the world quantum (for placing vertices). */\n  toImage(clientX: number, clientY: number): [number, number] {\n    const [wx, wy] = this.viewer.canvasToWorld(clientX, clientY);\n    return [snapToWorldGrid(wx, this.worldQuantum), snapToWorldGrid(wy, this.worldQuantum)];\n  }\n\n  /** Pointer client coords → world coords, exact (for picking: snapping is for placing). */\n  toWorld(clientX: number, clientY: number): [number, number] {\n    return this.viewer.canvasToWorld(clientX, clientY);\n  }\n\n  /**\n   * World units spanned by one screen pixel, measured through the viewer's own transform.\n   *\n   * Read from the transform rather than from the camera, so it holds for both the 2D and\n   * the 3D screen-space adapters without either having to expose a zoom. Falls back to 1\n   * if the transform gives nothing usable, which keeps the established pixel behaviour\n   * rather than collapsing the threshold to zero and recording a point per event.\n   */\n  worldPerCanvasPixel(): number {\n    const [x0] = this.viewer.canvasToWorld(0, 0);\n    const [x1] = this.viewer.canvasToWorld(1, 0);\n    const per = Math.abs(x1 - x0);\n    return Number.isFinite(per) && per > 0 ? per : 1;\n  }\n\n  /** Run `fn` with the svg's client origin and the camera affine read once (nested calls reuse them). */\n  withOrigin<T>(fn: () => T): T {\n    if (this.origin) return fn();\n    const r = this.svg.getBoundingClientRect();\n    this.origin = { left: r.left, top: r.top };\n    this.camera = this.viewer.canvasTransform();\n    try {\n      return fn();\n    } finally {\n      this.origin = null;\n      this.camera = null;\n    }\n  }\n\n  /** Client px → SVG-local px. */\n  clientToLocal(clientX: number, clientY: number): [number, number] {\n    const o = this.origin ?? this.svg.getBoundingClientRect();\n    return [clientX - o.left, clientY - o.top];\n  }\n\n  /** World coords → SVG-local px, through the camera affine: no layout read. */\n  toLocal(imgX: number, imgY: number): [number, number] {\n    return applyAffine(this.affine(), imgX, imgY);\n  }\n\n  /** {@link toLocal} as the shared region geometry takes it. */\n  readonly toScreen: ToScreen = (x, y) => this.toLocal(x, y);\n\n  /** Screen distance (px) between a client point and a world point. */\n  screenDist(clientX: number, clientY: number, imgX: number, imgY: number): number {\n    const [lx, ly] = this.toLocal(imgX, imgY);\n    const [px, py] = this.clientToLocal(clientX, clientY);\n    return Math.hypot(px - lx, py - ly);\n  }\n\n  /**\n   * The world → svg-local affine for the current camera: the viewer's `canvasTransform`, which\n   * reads no layout. The svg and the canvas share an origin (see {@link OverlayViewer}).\n   */\n  affine(): Affine {\n    return this.camera ?? this.viewer.canvasTransform();\n  }\n}\n"]}

package/esm2022/lib/implementations/napari-js/region-overlay/region-edit.mjs

@@ -0,0 +1,35 @@
+import { Rectangle } from '../../../models/region';
+/** Apply the drag of `edit` to the pointer at world point `(x, y)`, through the store's edit ops. */
+export function applyRegionEdit(store, edit, x, y) {
+    switch (edit.kind) {
+        case 'body': {
+            const [lx, ly] = edit.last;
+            store.moveRegion(edit.id, x - lx, y - ly);
+            edit.last = [x, y];
+            return;
+        }
+        case 'corner': {
+            const [ax, ay] = edit.anchor;
+            const rect = new Rectangle();
+            rect.x = Math.min(ax, x);
+            rect.y = Math.min(ay, y);
+            rect.width = Math.abs(x - ax);
+            rect.height = Math.abs(y - ay);
+            store.updateBounds(edit.id, rect);
+            return;
+        }
+        case 'vertex':
+            if (edit.ring < 0)
+                store.moveVertex(edit.id, edit.index, x, y);
+            else
+                store.moveHoleVertex(edit.id, edit.ring, edit.index, x, y);
+            return;
+        case 'bezier':
+            if (edit.ring < 0)
+                store.moveBezierHandle(edit.id, edit.index, edit.side, x, y);
+            else
+                store.moveHoleBezierHandle(edit.id, edit.ring, edit.index, edit.side, x, y);
+            return;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/implementations/napari-js/region-overlay/region-svg-renderer.mjs

@@ -0,0 +1,194 @@
+import { Polygon, Rectangle } from '../../../models/region';
+import { regionBBox, ringHandles, ringOf } from '../../../region-overlay/region-geometry';
+import { SvgRegionRenderer, svgEl } from '../../../region-overlay/svg-region-renderer';
+import { applyPaint, isFilled, placeInsideLabel, regionLabelSpots, shapePaint, } from '../../../region-overlay/region-style';
+const SVG_NS = 'http://www.w3.org/2000/svg';
+/** Rendered handle size (screen px). */
+export const HANDLE_SIZE = 7;
+/**
+ * What the napari region overlay draws, over the shared {@link SvgRegionRenderer}: the regions
+ * in world coordinates (styled from the store's colours, labelled when labels are on), and in
+ * screen space the selected regions' grab handles (corners, vertices, bézier control points),
+ * the draft being drawn and the rubber-band marquee.
+ */
+export class NapariRegionSvgRenderer {
+    constructor(svg, store) {
+        this.svg = svg;
+        this.store = store;
+        /** Dedicated marquee rect element, updated directly during the drag (no full region redraw). */
+        this.marqueeEl = null;
+        this.renderer = new SvgRegionRenderer(svg, {
+            rectElement: 'rect',
+            styleShape: (el, region, selected) => this.style(el, this.strokeOf(region), selected),
+            decorate: (region, _i, _selected, layer) => this.drawLabel(region, layer),
+            skip: (region) => !!region.isProfile?.() || store.isClassHidden(region.label),
+        });
+    }
+    /** Follow the camera: one transform attribute plus the screen-space elements. */
+    setCamera(affine) {
+        this.renderer.setCamera(affine);
+    }
+    /** Rebuild the regions (world space) and their labels. */
+    render(regions, selected) {
+        this.renderer.render(regions, selected);
+    }
+    /** Rebuild the screen-space overlay only: the selected regions' handles and the draft. */
+    renderOverlay(regions, selected, draft) {
+        this.renderer.renderOverlay((layer) => {
+            for (const i of selected) {
+                const region = regions[i];
+                if (region && !region.isProfile?.())
+                    this.drawHandles(region, layer);
+            }
+            this.drawDraft(draft, layer);
+        });
+    }
+    /** Show the marquee over svg-local corners `(lx, ly)`–`(rx, ry)`, creating it on first use. */
+    showMarquee(lx, ly, rx, ry) {
+        if (!this.marqueeEl || !this.marqueeEl.parentNode) {
+            this.marqueeEl = document.createElementNS(SVG_NS, 'rect');
+            this.marqueeEl.setAttribute('stroke', '#4da3ff');
+            this.marqueeEl.setAttribute('stroke-width', '1');
+            this.marqueeEl.setAttribute('stroke-dasharray', '4 3');
+            this.marqueeEl.setAttribute('fill', '#4da3ff');
+            this.marqueeEl.setAttribute('fill-opacity', '0.12');
+            this.marqueeEl.setAttribute('vector-effect', 'non-scaling-stroke');
+            this.svg.appendChild(this.marqueeEl);
+        }
+        this.marqueeEl.setAttribute('x', `${lx}`);
+        this.marqueeEl.setAttribute('y', `${ly}`);
+        this.marqueeEl.setAttribute('width', `${Math.abs(rx - lx)}`);
+        this.marqueeEl.setAttribute('height', `${Math.abs(ry - ly)}`);
+    }
+    /** Remove the marquee element from the SVG. */
+    clearMarquee() {
+        if (this.marqueeEl?.parentNode)
+            this.marqueeEl.parentNode.removeChild(this.marqueeEl);
+        this.marqueeEl = null;
+    }
+    /** A region's outline colour. */
+    strokeOf(region) {
+        return region.color || this.store.getShapeColor() || '#00ffff';
+    }
+    /** Draw a region's classification label at its top-left, when labels are enabled (matches OSD). */
+    drawLabel(region, layer) {
+        if (!this.store.getShowShapeLabel() || region.isProfile?.() || this.store.isLabelCovered(region.label))
+            return;
+        const label = region.label;
+        // The filled (atlas) look labels each part inside it, where it fits.
+        if (label && isFilled(this.store.getRegionStyle())) {
+            for (const spot of regionLabelSpots(region))
+                placeInsideLabel(layer, label, spot);
+            return;
+        }
+        const bb = label ? regionBBox(region) : null;
+        if (!label || !bb)
+            return;
+        const text = svgEl('text');
+        text.setAttribute('fill', '#fff');
+        text.setAttribute('stroke', '#000');
+        text.setAttribute('stroke-width', '3');
+        text.setAttribute('paint-order', 'stroke');
+        text.setAttribute('font', '12px sans-serif');
+        text.setAttribute('pointer-events', 'none');
+        text.textContent = label;
+        layer.at(text, bb.x0, bb.y0, { dy: -4 });
+    }
+    /** Draw grab handles for a selected region: rectangle corners or polygon vertices. */
+    drawHandles(region, layer) {
+        const b = region.bounds;
+        if (!b)
+            return;
+        const stroke = this.strokeOf(region);
+        const handle = (imgX, imgY) => {
+            const el = svgEl('rect');
+            el.setAttribute('width', `${HANDLE_SIZE}`);
+            el.setAttribute('height', `${HANDLE_SIZE}`);
+            el.setAttribute('fill', '#fff');
+            el.setAttribute('stroke', stroke);
+            el.setAttribute('stroke-width', '1.5');
+            layer.at(el, imgX, imgY, { dx: -HANDLE_SIZE / 2, dy: -HANDLE_SIZE / 2 });
+        };
+        if (b instanceof Rectangle) {
+            handle(b.x, b.y);
+            handle(b.x + b.width, b.y);
+            handle(b.x, b.y + b.height);
+            handle(b.x + b.width, b.y + b.height);
+        }
+        else if (b instanceof Polygon) {
+            for (let i = 0; i < b.npoints; i++)
+                handle(b.xpoints[i], b.ypoints[i]);
+            for (const ring of b.holes ?? [])
+                for (const [hx, hy] of ring)
+                    handle(hx, hy);
+            // Bezier regions also expose their tangent control points (circles) joined to the anchor
+            // by a thin line, matching the OSD overlay's editable bezier handles. Stored handles when
+            // present, else the Catmull-Rom default the curve is drawn with.
+            if (b.bezier) {
+                for (let ring = -1; ring < (b.holes?.length ?? 0); ring++) {
+                    const { xs, ys } = ringOf(b, ring);
+                    ringHandles(b, ring).forEach((h, i) => {
+                        if (h.hasOut)
+                            this.drawBezierHandle(xs[i], ys[i], h.out, stroke, layer);
+                        if (h.hasIn)
+                            this.drawBezierHandle(xs[i], ys[i], h.in, stroke, layer);
+                    });
+                }
+            }
+        }
+    }
+    /** Draw one bezier control point as a small circle connected to its anchor by a tangent line.
+     *  `handle` is the control point's absolute position in image space. */
+    drawBezierHandle(ax, ay, handle, stroke, layer) {
+        if (handle[0] === ax && handle[1] === ay)
+            return;
+        const line = layer.line(ax, ay, handle[0], handle[1]);
+        line.setAttribute('stroke', stroke);
+        line.setAttribute('stroke-width', '1');
+        line.setAttribute('stroke-opacity', '0.7');
+        const dot = svgEl('circle');
+        dot.setAttribute('r', `${HANDLE_SIZE / 2}`);
+        dot.setAttribute('fill', stroke);
+        dot.setAttribute('stroke', '#fff');
+        dot.setAttribute('stroke-width', '1');
+        layer.at(dot, handle[0], handle[1], { x: 'cx', y: 'cy' });
+    }
+    style(el, stroke, isSelected) {
+        const style = this.store.getRegionStyle();
+        if (isFilled(style)) {
+            applyPaint(el, shapePaint(stroke, isSelected, style));
+            return;
+        }
+        el.setAttribute('stroke', stroke);
+        el.setAttribute('stroke-width', isSelected ? '4' : '2');
+        el.setAttribute('fill', isSelected ? stroke : 'none');
+        el.setAttribute('fill-opacity', isSelected ? '0.35' : '0');
+    }
+    /** Draw the in-progress rectangle / path preview. */
+    drawDraft(draft, layer) {
+        if (draft.rect) {
+            const { x0, y0, x1, y1 } = draft.rect;
+            const el = svgEl('rect');
+            layer.place(el, (e, project) => {
+                const [lx, ly] = project(Math.min(x0, x1), Math.min(y0, y1));
+                const [rx, ry] = project(Math.max(x0, x1), Math.max(y0, y1));
+                e.setAttribute('x', `${lx}`);
+                e.setAttribute('y', `${ly}`);
+                e.setAttribute('width', `${Math.abs(rx - lx)}`);
+                e.setAttribute('height', `${Math.abs(ry - ly)}`);
+            });
+            this.styleDraft(el);
+        }
+        if (draft.path && draft.path.length) {
+            this.styleDraft(layer.poly('polyline', draft.path.map(([x, y]) => ({ x, y }))));
+        }
+    }
+    styleDraft(el) {
+        el.setAttribute('stroke', this.store.getShapeColor() || '#00ffff');
+        el.setAttribute('stroke-width', '2');
+        el.setAttribute('stroke-dasharray', '4 3');
+        el.setAttribute('fill', 'none');
+        el.setAttribute('vector-effect', 'non-scaling-stroke');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"region-svg-renderer.js","sourceRoot":"","sources":["../../../../../../src/lib/implementations/napari-js/region-overlay/region-svg-renderer.ts"],"names":[],"mappings":"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","sourcesContent":["import { Polygon, Rectangle, Region } from '../../../models/region';\nimport type { RegionStore } from '../../../store/region-store.service';\nimport { regionBBox, ringHandles, ringOf } from '../../../region-overlay/region-geometry';\nimport { Affine, ScreenLayer, SvgRegionRenderer, svgEl } from '../../../region-overlay/svg-region-renderer';\nimport {\n  applyPaint,\n  isFilled,\n  placeInsideLabel,\n  regionLabelSpots,\n  shapePaint,\n} from '../../../region-overlay/region-style';\n\nconst SVG_NS = 'http://www.w3.org/2000/svg';\n/** Rendered handle size (screen px). */\nexport const HANDLE_SIZE = 7;\n\n/** An axis-aligned box from a drag's start to its current point (any order). */\nexport interface DragBox {\n  x0: number;\n  y0: number;\n  x1: number;\n  y1: number;\n}\n\n/** A region being drawn: a rectangle drag, or a freehand / click-placed path. */\nexport interface RegionDraft {\n  rect: DragBox | null;\n  path: Array<[number, number]> | null;\n}\n\n/**\n * What the napari region overlay draws, over the shared {@link SvgRegionRenderer}: the regions\n * in world coordinates (styled from the store's colours, labelled when labels are on), and in\n * screen space the selected regions' grab handles (corners, vertices, bézier control points),\n * the draft being drawn and the rubber-band marquee.\n */\nexport class NapariRegionSvgRenderer {\n  private readonly renderer: SvgRegionRenderer;\n  /** Dedicated marquee rect element, updated directly during the drag (no full region redraw). */\n  private marqueeEl: SVGRectElement | null = null;\n\n  constructor(\n    private readonly svg: SVGSVGElement,\n    private readonly store: RegionStore,\n  ) {\n    this.renderer = new SvgRegionRenderer(svg, {\n      rectElement: 'rect',\n      styleShape: (el, region, selected) => this.style(el, this.strokeOf(region), selected),\n      decorate: (region, _i, _selected, layer) => this.drawLabel(region, layer),\n      skip: (region) => !!region.isProfile?.() || store.isClassHidden(region.label),\n    });\n  }\n\n  /** Follow the camera: one transform attribute plus the screen-space elements. */\n  setCamera(affine: Affine): void {\n    this.renderer.setCamera(affine);\n  }\n\n  /** Rebuild the regions (world space) and their labels. */\n  render(regions: readonly Region[], selected: readonly number[]): void {\n    this.renderer.render(regions, selected);\n  }\n\n  /** Rebuild the screen-space overlay only: the selected regions' handles and the draft. */\n  renderOverlay(regions: readonly Region[], selected: readonly number[], draft: RegionDraft): void {\n    this.renderer.renderOverlay((layer) => {\n      for (const i of selected) {\n        const region = regions[i];\n        if (region && !region.isProfile?.()) this.drawHandles(region, layer);\n      }\n      this.drawDraft(draft, layer);\n    });\n  }\n\n  /** Show the marquee over svg-local corners `(lx, ly)`–`(rx, ry)`, creating it on first use. */\n  showMarquee(lx: number, ly: number, rx: number, ry: number): void {\n    if (!this.marqueeEl || !this.marqueeEl.parentNode) {\n      this.marqueeEl = document.createElementNS(SVG_NS, 'rect');\n      this.marqueeEl.setAttribute('stroke', '#4da3ff');\n      this.marqueeEl.setAttribute('stroke-width', '1');\n      this.marqueeEl.setAttribute('stroke-dasharray', '4 3');\n      this.marqueeEl.setAttribute('fill', '#4da3ff');\n      this.marqueeEl.setAttribute('fill-opacity', '0.12');\n      this.marqueeEl.setAttribute('vector-effect', 'non-scaling-stroke');\n      this.svg.appendChild(this.marqueeEl);\n    }\n    this.marqueeEl.setAttribute('x', `${lx}`);\n    this.marqueeEl.setAttribute('y', `${ly}`);\n    this.marqueeEl.setAttribute('width', `${Math.abs(rx - lx)}`);\n    this.marqueeEl.setAttribute('height', `${Math.abs(ry - ly)}`);\n  }\n\n  /** Remove the marquee element from the SVG. */\n  clearMarquee(): void {\n    if (this.marqueeEl?.parentNode) this.marqueeEl.parentNode.removeChild(this.marqueeEl);\n    this.marqueeEl = null;\n  }\n\n  /** A region's outline colour. */\n  private strokeOf(region: Region): string {\n    return region.color || this.store.getShapeColor() || '#00ffff';\n  }\n\n  /** Draw a region's classification label at its top-left, when labels are enabled (matches OSD). */\n  private drawLabel(region: Region, layer: ScreenLayer): void {\n    if (!this.store.getShowShapeLabel() || region.isProfile?.() || this.store.isLabelCovered(region.label)) return;\n    const label = region.label;\n    // The filled (atlas) look labels each part inside it, where it fits.\n    if (label && isFilled(this.store.getRegionStyle())) {\n      for (const spot of regionLabelSpots(region)) placeInsideLabel(layer, label, spot);\n      return;\n    }\n    const bb = label ? regionBBox(region) : null;\n    if (!label || !bb) return;\n    const text = svgEl('text');\n    text.setAttribute('fill', '#fff');\n    text.setAttribute('stroke', '#000');\n    text.setAttribute('stroke-width', '3');\n    text.setAttribute('paint-order', 'stroke');\n    text.setAttribute('font', '12px sans-serif');\n    text.setAttribute('pointer-events', 'none');\n    text.textContent = label;\n    layer.at(text, bb.x0, bb.y0, { dy: -4 });\n  }\n\n  /** Draw grab handles for a selected region: rectangle corners or polygon vertices. */\n  private drawHandles(region: Region, layer: ScreenLayer): void {\n    const b = region.bounds;\n    if (!b) return;\n    const stroke = this.strokeOf(region);\n    const handle = (imgX: number, imgY: number): void => {\n      const el = svgEl('rect');\n      el.setAttribute('width', `${HANDLE_SIZE}`);\n      el.setAttribute('height', `${HANDLE_SIZE}`);\n      el.setAttribute('fill', '#fff');\n      el.setAttribute('stroke', stroke);\n      el.setAttribute('stroke-width', '1.5');\n      layer.at(el, imgX, imgY, { dx: -HANDLE_SIZE / 2, dy: -HANDLE_SIZE / 2 });\n    };\n    if (b instanceof Rectangle) {\n      handle(b.x, b.y);\n      handle(b.x + b.width, b.y);\n      handle(b.x, b.y + b.height);\n      handle(b.x + b.width, b.y + b.height);\n    } else if (b instanceof Polygon) {\n      for (let i = 0; i < b.npoints; i++) handle(b.xpoints[i], b.ypoints[i]);\n      for (const ring of b.holes ?? []) for (const [hx, hy] of ring) handle(hx, hy);\n      // Bezier regions also expose their tangent control points (circles) joined to the anchor\n      // by a thin line, matching the OSD overlay's editable bezier handles. Stored handles when\n      // present, else the Catmull-Rom default the curve is drawn with.\n      if (b.bezier) {\n        for (let ring = -1; ring < (b.holes?.length ?? 0); ring++) {\n          const { xs, ys } = ringOf(b, ring);\n          ringHandles(b, ring).forEach((h, i) => {\n            if (h.hasOut) this.drawBezierHandle(xs[i], ys[i], h.out, stroke, layer);\n            if (h.hasIn) this.drawBezierHandle(xs[i], ys[i], h.in, stroke, layer);\n          });\n        }\n      }\n    }\n  }\n\n  /** Draw one bezier control point as a small circle connected to its anchor by a tangent line.\n   *  `handle` is the control point's absolute position in image space. */\n  private drawBezierHandle(\n    ax: number,\n    ay: number,\n    handle: [number, number],\n    stroke: string,\n    layer: ScreenLayer,\n  ): void {\n    if (handle[0] === ax && handle[1] === ay) return;\n    const line = layer.line(ax, ay, handle[0], handle[1]);\n    line.setAttribute('stroke', stroke);\n    line.setAttribute('stroke-width', '1');\n    line.setAttribute('stroke-opacity', '0.7');\n    const dot = svgEl('circle');\n    dot.setAttribute('r', `${HANDLE_SIZE / 2}`);\n    dot.setAttribute('fill', stroke);\n    dot.setAttribute('stroke', '#fff');\n    dot.setAttribute('stroke-width', '1');\n    layer.at(dot, handle[0], handle[1], { x: 'cx', y: 'cy' });\n  }\n\n  private style(el: SVGElement, stroke: string, isSelected: boolean): void {\n    const style = this.store.getRegionStyle();\n    if (isFilled(style)) {\n      applyPaint(el, shapePaint(stroke, isSelected, style));\n      return;\n    }\n    el.setAttribute('stroke', stroke);\n    el.setAttribute('stroke-width', isSelected ? '4' : '2');\n    el.setAttribute('fill', isSelected ? stroke : 'none');\n    el.setAttribute('fill-opacity', isSelected ? '0.35' : '0');\n  }\n\n  /** Draw the in-progress rectangle / path preview. */\n  private drawDraft(draft: RegionDraft, layer: ScreenLayer): void {\n    if (draft.rect) {\n      const { x0, y0, x1, y1 } = draft.rect;\n      const el = svgEl('rect');\n      layer.place(el, (e, project) => {\n        const [lx, ly] = project(Math.min(x0, x1), Math.min(y0, y1));\n        const [rx, ry] = project(Math.max(x0, x1), Math.max(y0, y1));\n        e.setAttribute('x', `${lx}`);\n        e.setAttribute('y', `${ly}`);\n        e.setAttribute('width', `${Math.abs(rx - lx)}`);\n        e.setAttribute('height', `${Math.abs(ry - ly)}`);\n      });\n      this.styleDraft(el);\n    }\n    if (draft.path && draft.path.length) {\n      this.styleDraft(\n        layer.poly(\n          'polyline',\n          draft.path.map(([x, y]) => ({ x, y })),\n        ),\n      );\n    }\n  }\n\n  private styleDraft(el: SVGElement): void {\n    el.setAttribute('stroke', this.store.getShapeColor() || '#00ffff');\n    el.setAttribute('stroke-width', '2');\n    el.setAttribute('stroke-dasharray', '4 3');\n    el.setAttribute('fill', 'none');\n    el.setAttribute('vector-effect', 'non-scaling-stroke');\n  }\n}\n"]}