@jax-data-science/sci-image-visualizer 0.8.2 → 0.9.0

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,182 @@
+import { Polygon, Rectangle } from '../../../models/region';
+import { regionBBox, ringHandles, ringOf } from '../../../region-overlay/region-geometry';
+import { SvgRegionRenderer, svgEl } from '../../../region-overlay/svg-region-renderer';
+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?.(),
+        });
+    }
+    /** 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?.())
+            return;
+        const label = region.label;
+        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) {
+        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';\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?.(),\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?.()) return;\n    const label = region.label;\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    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"]}

package/esm2022/lib/implementations/napari-js/spatial-tiles/categorical-lookup.mjs

@@ -0,0 +1,30 @@
+import { isCategoricalColumn } from '../../../contracts/spatial-dataset.contract';
+import { cellTypeColumnFor } from '../../../spatial/lod';
+/**
+ * The categorical columns the cells, the transcripts and the hover all read: the cell-type
+ * column's codes, and which of its groups the user switched off. A failed request rejects;
+ * the caller decides whether that fails its group of the plan or degrades to "no types".
+ */
+export class CategoricalLookup {
+    constructor(port) {
+        this.port = port;
+    }
+    /** Codes of the column `name`, or null when it is not categorical. */
+    async codes(name) {
+        const column = await this.port.getColumn(name);
+        return isCategoricalColumn(column) ? { codes: column.codes, meta: column.meta } : null;
+    }
+    /** Codes of the group column that are switched off, or null when none are. */
+    async hiddenCodes(dataset, view) {
+        if (!view.hiddenGroups.length)
+            return null;
+        const name = cellTypeColumnFor(dataset, view);
+        const col = name ? await this.codes(name) : null;
+        if (!col || col.meta.kind !== 'categorical')
+            return null;
+        const off = new Set(view.hiddenGroups);
+        const hidden = Uint8Array.from(col.meta.categories, (c) => (off.has(c) ? 1 : 0));
+        return { codes: col.codes, hidden };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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