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

package/esm2022/lib/intensity-inset/intensity-inset.component.mjs

@@ -0,0 +1,133 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, DestroyRef, Inject, Input, NgZone, signal, } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { CommonModule } from '@angular/common';
+import { VISUALIZER } from '../contracts/visualizer.contract';
+import { FloatingDragDirective } from '../visualizer/floating-drag.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * The floating, draggable intensity-profile inset: shown while any intensity line
+ * exists, charting one trace per line as lines are added, moved or removed.
+ *
+ * Owns the profile and viewport-change subscriptions, the window-resize reflow, the
+ * drag and the per-instance chart div id it is given. The chart itself is drawn by the
+ * backend (`IVisualizer.renderIntensityInset`) so this never reaches a charting
+ * library. Fixed to the viewport, outside the plot div, so it is not clipped to the
+ * canvas.
+ *
+ * OnPush, with its view state in signals: the profile stream may fire outside the zone.
+ */
+export class IntensityInsetComponent {
+    constructor(visualizer, cdr, zone, destroyRef) {
+        this.visualizer = visualizer;
+        this.cdr = cdr;
+        this.zone = zone;
+        this.destroyRef = destroyRef;
+        /** Id of the chart div — unique per viewer: the backend resolves it by id. */
+        this.divId = '';
+        /** Id of the viewer's plot div: the inset parks near its top-right corner. */
+        this.plotDivName = '';
+        /** The displayed slice, re-sampled at when the view settles. */
+        this.zIndex = 0;
+        /** The Image view (OSD), whose line sampling is fed from preview frames. */
+        this.imageView = false;
+        /** True whenever any intensity-profile line exists (whatever the plot type). */
+        this.hasProfiles = signal(false);
+        this.pos = signal({ x: 20, y: 70 });
+        /** Where a header drag starts from. */
+        this.dragOrigin = () => this.pos();
+        this.profiles = [];
+        this.onResize = () => {
+            // Reflow to the (fixed) panel size once layout has settled: a mid-reflow resize
+            // can leave the chart at a stale or zero size.
+            if (this.hasProfiles())
+                requestAnimationFrame(() => this.render());
+        };
+    }
+    ngOnInit() {
+        this.visualizer
+            .getIntensityProfile$()
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((profiles) => {
+            this.profiles = profiles;
+            this.hasProfiles.set(profiles.length > 0);
+            // The panel is behind *ngIf. detectChanges() materializes it synchronously (the
+            // stream may fire outside the zone, e.g. from an OSD drag). Render on the next
+            // frame, AFTER layout: drawn synchronously, Plotly sizes a fresh chart to a zero
+            // box and keeps it, so the inset stays blank.
+            this.cdr.detectChanges();
+            requestAnimationFrame(() => this.render());
+        });
+        // When the OSD view settles at a new zoom/pan, re-sample from a crop of the
+        // visible region so the inset reflects the zoom-level resolution (Plotly's own
+        // high-def zoom updates the sampling cache inline).
+        this.visualizer
+            .getViewportChange$()
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((roi) => {
+            if (this.hasProfiles() && this.imageView) {
+                this.visualizer.refreshIntensitySamplingForRoi(roi.x, roi.y, roi.width, roi.height, this.zIndex);
+            }
+        });
+        this.zone.runOutsideAngular(() => window.addEventListener('resize', this.onResize));
+    }
+    /** Removes the window resize listener; the streams end through `takeUntilDestroyed`. */
+    ngOnDestroy() {
+        window.removeEventListener('resize', this.onResize);
+    }
+    /** The canvas was resized: reflow the chart a tick later, once the panel has settled. */
+    reflow() {
+        if (this.hasProfiles())
+            setTimeout(() => this.render(), 0);
+    }
+    /** A slice was committed: keep the lines sampled from it (Image view). */
+    sliceCommitted(z) {
+        if (this.hasProfiles() && this.imageView && this.imageInfo) {
+            void this.visualizer.ensureIntensitySampling(this.imageInfo, z);
+        }
+    }
+    /**
+     * Add another line ROI (next bright colour) and select it on the active backend so
+     * it is ready to move or delete. The first line parks the inset near the plot's
+     * top-right. Resolves the new line, or null when no image extent is known yet.
+     */
+    async addProfileLine() {
+        if (!this.hasProfiles()) {
+            const rect = document.getElementById(this.plotDivName)?.getBoundingClientRect();
+            this.pos.set(rect ? { x: Math.max(10, rect.right - 300), y: rect.top + 10 } : { x: 20, y: 70 });
+        }
+        // Image (OSD) view: Plotly never rendered, so it has no pixel cache / extent. Load
+        // the current slice's frames for sampling + line placement first.
+        if (this.imageView && this.imageInfo) {
+            await this.visualizer.ensureIntensitySampling(this.imageInfo, this.zIndex);
+        }
+        const region = this.visualizer.getIntensityControls()?.addProfileLine() ?? null;
+        if (region)
+            this.visualizer.selectRegion(region);
+        return region;
+    }
+    render() {
+        if (this.hasProfiles())
+            this.visualizer.renderIntensityInset(this.divId, this.profiles);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: IntensityInsetComponent, deps: [{ token: VISUALIZER }, { token: i0.ChangeDetectorRef }, { token: i0.NgZone }, { token: i0.DestroyRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.9", type: IntensityInsetComponent, isStandalone: true, selector: "viz-intensity-inset", inputs: { divId: "divId", plotDivName: "plotDivName", zIndex: "zIndex", imageView: "imageView", imageInfo: "imageInfo" }, ngImport: i0, template: "<div *ngIf=\"hasProfiles()\" class=\"intensity-panel\" [style.left.px]=\"pos().x\" [style.top.px]=\"pos().y\">\n  <div class=\"intensity-panel-header\" [vizFloatingDrag]=\"dragOrigin\" (vizFloatingDragMove)=\"pos.set($event)\">\n    <span>Intensity profile</span>\n    <i class=\"pi pi-arrows-alt\"></i>\n  </div>\n  <div [id]=\"divId\" class=\"intensity-panel-plot\"></div>\n</div>\n", styles: [".intensity-panel{position:fixed;z-index:1100;width:280px;height:180px;background:#191919e6;border:1px solid var(--primary-color, #3399ff);border-radius:6px;box-shadow:0 4px 14px #00000073;display:flex;flex-direction:column;overflow:hidden}.intensity-panel-header{display:flex;align-items:center;justify-content:space-between;padding:.25rem .5rem;cursor:move;-webkit-user-select:none;user-select:none;background:#ffffff14;color:#eee;font-size:.75rem;font-weight:600}.intensity-panel-header i{opacity:.6;font-size:.7rem}.intensity-panel-plot{flex:1 1 auto;width:100%}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: FloatingDragDirective, selector: "[vizFloatingDrag]", inputs: ["vizFloatingDrag"], outputs: ["vizFloatingDragMove"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: IntensityInsetComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'viz-intensity-inset', standalone: true, imports: [CommonModule, FloatingDragDirective], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div *ngIf=\"hasProfiles()\" class=\"intensity-panel\" [style.left.px]=\"pos().x\" [style.top.px]=\"pos().y\">\n  <div class=\"intensity-panel-header\" [vizFloatingDrag]=\"dragOrigin\" (vizFloatingDragMove)=\"pos.set($event)\">\n    <span>Intensity profile</span>\n    <i class=\"pi pi-arrows-alt\"></i>\n  </div>\n  <div [id]=\"divId\" class=\"intensity-panel-plot\"></div>\n</div>\n", styles: [".intensity-panel{position:fixed;z-index:1100;width:280px;height:180px;background:#191919e6;border:1px solid var(--primary-color, #3399ff);border-radius:6px;box-shadow:0 4px 14px #00000073;display:flex;flex-direction:column;overflow:hidden}.intensity-panel-header{display:flex;align-items:center;justify-content:space-between;padding:.25rem .5rem;cursor:move;-webkit-user-select:none;user-select:none;background:#ffffff14;color:#eee;font-size:.75rem;font-weight:600}.intensity-panel-header i{opacity:.6;font-size:.7rem}.intensity-panel-plot{flex:1 1 auto;width:100%}\n"] }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [VISUALIZER]
+                }] }, { type: i0.ChangeDetectorRef }, { type: i0.NgZone }, { type: i0.DestroyRef }], propDecorators: { divId: [{
+                type: Input
+            }], plotDivName: [{
+                type: Input
+            }], zIndex: [{
+                type: Input
+            }], imageView: [{
+                type: Input
+            }], imageInfo: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"intensity-inset.component.js","sourceRoot":"","sources":["../../../../src/lib/intensity-inset/intensity-inset.component.ts","../../../../src/lib/intensity-inset/intensity-inset.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  DestroyRef,\n  Inject,\n  Input,\n  NgZone,\n  OnDestroy,\n  OnInit,\n  signal,\n} from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { CommonModule } from '@angular/common';\n\nimport { IImageInfo } from '../contracts/image.contract';\nimport { IntensityProfile, IVisualizer, VISUALIZER } from '../contracts/visualizer.contract';\nimport { Region } from '../models/region';\nimport { FloatingDragDirective, FloatingPos } from '../visualizer/floating-drag.directive';\n\n/**\n * The floating, draggable intensity-profile inset: shown while any intensity line\n * exists, charting one trace per line as lines are added, moved or removed.\n *\n * Owns the profile and viewport-change subscriptions, the window-resize reflow, the\n * drag and the per-instance chart div id it is given. The chart itself is drawn by the\n * backend (`IVisualizer.renderIntensityInset`) so this never reaches a charting\n * library. Fixed to the viewport, outside the plot div, so it is not clipped to the\n * canvas.\n *\n * OnPush, with its view state in signals: the profile stream may fire outside the zone.\n */\n@Component({\n  selector: 'viz-intensity-inset',\n  standalone: true,\n  imports: [CommonModule, FloatingDragDirective],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  templateUrl: './intensity-inset.component.html',\n  styleUrls: ['./intensity-inset.component.scss'],\n})\nexport class IntensityInsetComponent implements OnInit, OnDestroy {\n  /** Id of the chart div — unique per viewer: the backend resolves it by id. */\n  @Input() divId = '';\n  /** Id of the viewer's plot div: the inset parks near its top-right corner. */\n  @Input() plotDivName = '';\n  /** The displayed slice, re-sampled at when the view settles. */\n  @Input() zIndex = 0;\n  /** The Image view (OSD), whose line sampling is fed from preview frames. */\n  @Input() imageView = false;\n  /** The image shown (the Image view samples its lines from it). */\n  @Input() imageInfo: IImageInfo | undefined;\n\n  /** True whenever any intensity-profile line exists (whatever the plot type). */\n  protected readonly hasProfiles = signal(false);\n  protected readonly pos = signal<FloatingPos>({ x: 20, y: 70 });\n  /** Where a header drag starts from. */\n  protected readonly dragOrigin = (): FloatingPos => this.pos();\n\n  private profiles: IntensityProfile[] = [];\n  private readonly onResize = () => {\n    // Reflow to the (fixed) panel size once layout has settled: a mid-reflow resize\n    // can leave the chart at a stale or zero size.\n    if (this.hasProfiles()) requestAnimationFrame(() => this.render());\n  };\n\n  constructor(\n    @Inject(VISUALIZER) private readonly visualizer: IVisualizer,\n    private readonly cdr: ChangeDetectorRef,\n    private readonly zone: NgZone,\n    private readonly destroyRef: DestroyRef,\n  ) {}\n\n  ngOnInit(): void {\n    this.visualizer\n      .getIntensityProfile$()\n      .pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe((profiles) => {\n        this.profiles = profiles;\n        this.hasProfiles.set(profiles.length > 0);\n        // The panel is behind *ngIf. detectChanges() materializes it synchronously (the\n        // stream may fire outside the zone, e.g. from an OSD drag). Render on the next\n        // frame, AFTER layout: drawn synchronously, Plotly sizes a fresh chart to a zero\n        // box and keeps it, so the inset stays blank.\n        this.cdr.detectChanges();\n        requestAnimationFrame(() => this.render());\n      });\n    // When the OSD view settles at a new zoom/pan, re-sample from a crop of the\n    // visible region so the inset reflects the zoom-level resolution (Plotly's own\n    // high-def zoom updates the sampling cache inline).\n    this.visualizer\n      .getViewportChange$()\n      .pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe((roi) => {\n        if (this.hasProfiles() && this.imageView) {\n          this.visualizer.refreshIntensitySamplingForRoi(roi.x, roi.y, roi.width, roi.height, this.zIndex);\n        }\n      });\n    this.zone.runOutsideAngular(() => window.addEventListener('resize', this.onResize));\n  }\n\n  /** Removes the window resize listener; the streams end through `takeUntilDestroyed`. */\n  ngOnDestroy(): void {\n    window.removeEventListener('resize', this.onResize);\n  }\n\n  /** The canvas was resized: reflow the chart a tick later, once the panel has settled. */\n  reflow(): void {\n    if (this.hasProfiles()) setTimeout(() => this.render(), 0);\n  }\n\n  /** A slice was committed: keep the lines sampled from it (Image view). */\n  sliceCommitted(z: number): void {\n    if (this.hasProfiles() && this.imageView && this.imageInfo) {\n      void this.visualizer.ensureIntensitySampling(this.imageInfo, z);\n    }\n  }\n\n  /**\n   * Add another line ROI (next bright colour) and select it on the active backend so\n   * it is ready to move or delete. The first line parks the inset near the plot's\n   * top-right. Resolves the new line, or null when no image extent is known yet.\n   */\n  async addProfileLine(): Promise<Region | null> {\n    if (!this.hasProfiles()) {\n      const rect = document.getElementById(this.plotDivName)?.getBoundingClientRect();\n      this.pos.set(rect ? { x: Math.max(10, rect.right - 300), y: rect.top + 10 } : { x: 20, y: 70 });\n    }\n    // Image (OSD) view: Plotly never rendered, so it has no pixel cache / extent. Load\n    // the current slice's frames for sampling + line placement first.\n    if (this.imageView && this.imageInfo) {\n      await this.visualizer.ensureIntensitySampling(this.imageInfo, this.zIndex);\n    }\n    const region = this.visualizer.getIntensityControls()?.addProfileLine() ?? null;\n    if (region) this.visualizer.selectRegion(region);\n    return region;\n  }\n\n  private render(): void {\n    if (this.hasProfiles()) this.visualizer.renderIntensityInset(this.divId, this.profiles);\n  }\n}\n","<div *ngIf=\"hasProfiles()\" class=\"intensity-panel\" [style.left.px]=\"pos().x\" [style.top.px]=\"pos().y\">\n  <div class=\"intensity-panel-header\" [vizFloatingDrag]=\"dragOrigin\" (vizFloatingDragMove)=\"pos.set($event)\">\n    <span>Intensity profile</span>\n    <i class=\"pi pi-arrows-alt\"></i>\n  </div>\n  <div [id]=\"divId\" class=\"intensity-panel-plot\"></div>\n</div>\n"]}

package/esm2022/lib/models/bezier.mjs

@@ -107,14 +107,4 @@ export function bezierCurveFromHandles(xs, ys, handles, closed) {
     }
     return { xs: outX, ys: outY };
 }
-/**
- * Flatten the smooth Catmull-Rom bezier through the anchors (no custom handles).
- * Falls back to the anchors when there are too few to form a curve.
- */
-export function bezierCurve(xs, ys, closed) {
-    const n = Math.min(xs.length, ys.length);
-    if (n < 3)
-        return { xs: xs.slice(), ys: ys.slice() };
-    return bezierCurveFromHandles(xs, ys, bezierAnchorHandles(xs, ys, closed), closed);
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bezier.js","sourceRoot":"","sources":["../../../../src/lib/models/bezier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAgBH,8EAA8E;AAC9E,MAAM,mBAAmB,GAAG,EAAE,CAAC;AAE/B;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CAAC,EAAY,EAAE,EAAY,EAAE,MAAe;IAC7E,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC;IACzC,MAAM,GAAG,GAAmB,EAAE,CAAC;IAC/B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3B,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;QAC3D,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;QAC3D,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QACrC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QACrC,GAAG,CAAC,IAAI,CAAC;YACP,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;YAC7B,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;YAC5B,MAAM,EAAE,MAAM,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;YAC3B,KAAK,EAAE,MAAM,IAAI,CAAC,GAAG,CAAC;SACvB,CAAC,CAAC;IACL,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;0EAC0E;AAC1E,MAAM,UAAU,oBAAoB,CAAC,EAAY,EAAE,EAAY,EAAE,MAAe;IAE9E,MAAM,CAAC,GAAG,mBAAmB,CAAC,EAAE,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC;IAC9C,OAAO;QACL,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QACvD,GAAG,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;KAC3D,CAAC;AACJ,CAAC;AAED,uEAAuE;AACvE,MAAM,UAAU,kBAAkB,CAAC,EAAY,EAAE,EAAY,EAC1B,KAAiB,EAAE,MAAkB,EAAE,MAAe;IACvF,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC;IACzC,MAAM,GAAG,GAAmB,EAAE,CAAC;IAC/B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3B,GAAG,CAAC,IAAI,CAAC;YACP,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;YAChE,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;YACnE,MAAM,EAAE,MAAM,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;YAC3B,KAAK,EAAE,MAAM,IAAI,CAAC,GAAG,CAAC;SACvB,CAAC,CAAC;IACL,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;qFACqF;AACrF,MAAM,UAAU,cAAc,CAAC,EAAY,EAAE,EAAY,EAAE,MAAe,EAC3C,KAAkB,EAAE,MAAmB;IACpE,IAAI,KAAK,IAAI,MAAM,IAAI,KAAK,CAAC,MAAM,KAAK,EAAE,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,EAAE,CAAC,MAAM,EAAE,CAAC;QACjF,OAAO,kBAAkB,CAAC,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3D,CAAC;IACD,OAAO,mBAAmB,CAAC,EAAE,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC;AAC7C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,sBAAsB,CAAC,EAAY,EAAE,EAAY,EAC1B,OAAuB,EAAE,MAAe;IAC7E,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC;IACzC,IAAI,CAAC,GAAG,CAAC;QAAE,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC;IAErD,MAAM,IAAI,GAAa,EAAE,CAAC;IAC1B,MAAM,IAAI,GAAa,EAAE,CAAC;IAC1B,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IAChC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC;QAC9B,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;QACtB,MAAM,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;QAC/B,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAC9C,MAAM,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;QAC/B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,mBAAmB,EAAE,CAAC,EAAE,EAAE,CAAC;YAC7C,MAAM,CAAC,GAAG,CAAC,GAAG,mBAAmB,CAAC;YAClC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAChB,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAC7E,IAAI,CAAC,IAAI,CAAC,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,GAAG,CAAC,CAAC;YACzD,IAAI,CAAC,IAAI,CAAC,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,GAAG,CAAC,CAAC;QAC3D,CAAC;IACH,CAAC;IACD,IAAI,MAAM,EAAE,CAAC;QACX,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IACrC,CAAC;SAAM,CAAC;QACN,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAC7C,CAAC;IACD,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC;AAChC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,WAAW,CAAC,EAAY,EAAE,EAAY,EAAE,MAAe;IACrE,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC;IACzC,IAAI,CAAC,GAAG,CAAC;QAAE,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC;IACrD,OAAO,sBAAsB,CAAC,EAAE,EAAE,EAAE,EAAE,mBAAmB,CAAC,EAAE,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC;AACrF,CAAC","sourcesContent":["/**\n * Bezier-curve helpers (no external dependency).\n *\n * JIT supports true bezier regions: a polygon's vertices are the editable\n * *anchors*, and the smooth curve through them is derived here with the\n * Catmull-Rom construction — the same algorithm paper.js uses in\n * `path.smooth()`. The curve interpolates every anchor and\n * each anchor's two handles are colinear (a smooth tangent).\n *\n * The OSD overlay renders the curve as a true cubic SVG path + draggable handles\n * (see {@link bezierAnchorHandles}); GeoJSON export flattens the *same* cubics\n * into a dense point list (see {@link bezierCurve}) so a viewer without bezier\n * support (e.g. QuPath, which just draws the coordinate list) still shows the\n * smooth shape. Using one algorithm for both keeps what JIT draws identical to\n * what it exports.\n *\n * Pure functions: no DOM, no service state. Coordinates are image pixels.\n */\n\nexport interface CurvePoints {\n  xs: number[];\n  ys: number[];\n}\n\n/** A vertex's two cubic-bezier control points (absolute coords) plus whether\n *  each side has a handle (open-path endpoints have only one). */\nexport interface AnchorHandle {\n  in: [number, number];\n  out: [number, number];\n  hasIn: boolean;\n  hasOut: boolean;\n}\n\n/** How many points to sample per cubic segment when flattening for export. */\nconst SAMPLES_PER_SEGMENT = 16;\n\n/**\n * Per-anchor cubic-bezier control points using the Catmull-Rom construction\n * (tension 1: control = anchor ± (next − prev) / 6). Matches paper.js\n * `path.smooth()`: the resulting cubic interpolates every anchor and the two\n * handles of each anchor are colinear. Coordinates are in the input space.\n */\nexport function bezierAnchorHandles(xs: number[], ys: number[], closed: boolean): AnchorHandle[] {\n  const n = Math.min(xs.length, ys.length);\n  const out: AnchorHandle[] = [];\n  for (let i = 0; i < n; i++) {\n    const prev = closed ? (i - 1 + n) % n : Math.max(0, i - 1);\n    const next = closed ? (i + 1) % n : Math.min(n - 1, i + 1);\n    const tx = (xs[next] - xs[prev]) / 6;\n    const ty = (ys[next] - ys[prev]) / 6;\n    out.push({\n      out: [xs[i] + tx, ys[i] + ty],\n      in: [xs[i] - tx, ys[i] - ty],\n      hasOut: closed || i < n - 1,\n      hasIn: closed || i > 0,\n    });\n  }\n  return out;\n}\n\n/** The Catmull-Rom handles as **relative** offsets `[dx, dy]` per anchor — used\n *  to initialise a region's editable handles when bezier is turned on. */\nexport function defaultHandleOffsets(xs: number[], ys: number[], closed: boolean):\n  { in: number[][]; out: number[][] } {\n  const h = bezierAnchorHandles(xs, ys, closed);\n  return {\n    in: h.map((a, i) => [a.in[0] - xs[i], a.in[1] - ys[i]]),\n    out: h.map((a, i) => [a.out[0] - xs[i], a.out[1] - ys[i]]),\n  };\n}\n\n/** Absolute handles from stored relative offsets (anchor + offset). */\nexport function handlesFromOffsets(xs: number[], ys: number[],\n                                   inOff: number[][], outOff: number[][], closed: boolean): AnchorHandle[] {\n  const n = Math.min(xs.length, ys.length);\n  const out: AnchorHandle[] = [];\n  for (let i = 0; i < n; i++) {\n    out.push({\n      in: [xs[i] + (inOff[i]?.[0] ?? 0), ys[i] + (inOff[i]?.[1] ?? 0)],\n      out: [xs[i] + (outOff[i]?.[0] ?? 0), ys[i] + (outOff[i]?.[1] ?? 0)],\n      hasOut: closed || i < n - 1,\n      hasIn: closed || i > 0,\n    });\n  }\n  return out;\n}\n\n/** A region's handles: from its stored (editable) offsets when present, else the\n *  Catmull-Rom default. The single source of truth for both rendering and export. */\nexport function resolveHandles(xs: number[], ys: number[], closed: boolean,\n                               inOff?: number[][], outOff?: number[][]): AnchorHandle[] {\n  if (inOff && outOff && inOff.length === xs.length && outOff.length === xs.length) {\n    return handlesFromOffsets(xs, ys, inOff, outOff, closed);\n  }\n  return bezierAnchorHandles(xs, ys, closed);\n}\n\n/**\n * Flatten a cubic bezier (defined by explicit per-anchor handles) into a dense\n * point list by sampling each segment. The curve passes through every anchor; a\n * closed ring returns to its first point.\n */\nexport function bezierCurveFromHandles(xs: number[], ys: number[],\n                                       handles: AnchorHandle[], closed: boolean): CurvePoints {\n  const n = Math.min(xs.length, ys.length);\n  if (n < 3) return { xs: xs.slice(), ys: ys.slice() };\n\n  const outX: number[] = [];\n  const outY: number[] = [];\n  const segs = closed ? n : n - 1;\n  for (let i = 0; i < segs; i++) {\n    const j = (i + 1) % n;\n    const p0x = xs[i], p0y = ys[i];\n    const c1 = handles[i].out, c2 = handles[j].in;\n    const p3x = xs[j], p3y = ys[j];\n    for (let s = 0; s < SAMPLES_PER_SEGMENT; s++) {\n      const t = s / SAMPLES_PER_SEGMENT;\n      const u = 1 - t;\n      const w0 = u * u * u, w1 = 3 * u * u * t, w2 = 3 * u * t * t, w3 = t * t * t;\n      outX.push(w0 * p0x + w1 * c1[0] + w2 * c2[0] + w3 * p3x);\n      outY.push(w0 * p0y + w1 * c1[1] + w2 * c2[1] + w3 * p3y);\n    }\n  }\n  if (closed) {\n    outX.push(xs[0]); outY.push(ys[0]);\n  } else {\n    outX.push(xs[n - 1]); outY.push(ys[n - 1]);\n  }\n  return { xs: outX, ys: outY };\n}\n\n/**\n * Flatten the smooth Catmull-Rom bezier through the anchors (no custom handles).\n * Falls back to the anchors when there are too few to form a curve.\n */\nexport function bezierCurve(xs: number[], ys: number[], closed: boolean): CurvePoints {\n  const n = Math.min(xs.length, ys.length);\n  if (n < 3) return { xs: xs.slice(), ys: ys.slice() };\n  return bezierCurveFromHandles(xs, ys, bezierAnchorHandles(xs, ys, closed), closed);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bezier.js","sourceRoot":"","sources":["../../../../src/lib/models/bezier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAgBH,8EAA8E;AAC9E,MAAM,mBAAmB,GAAG,EAAE,CAAC;AAE/B;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CAAC,EAAY,EAAE,EAAY,EAAE,MAAe;IAC7E,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC;IACzC,MAAM,GAAG,GAAmB,EAAE,CAAC;IAC/B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3B,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;QAC3D,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;QAC3D,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QACrC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QACrC,GAAG,CAAC,IAAI,CAAC;YACP,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;YAC7B,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;YAC5B,MAAM,EAAE,MAAM,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;YAC3B,KAAK,EAAE,MAAM,IAAI,CAAC,GAAG,CAAC;SACvB,CAAC,CAAC;IACL,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;0EAC0E;AAC1E,MAAM,UAAU,oBAAoB,CAClC,EAAY,EACZ,EAAY,EACZ,MAAe;IAEf,MAAM,CAAC,GAAG,mBAAmB,CAAC,EAAE,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC;IAC9C,OAAO;QACL,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QACvD,GAAG,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;KAC3D,CAAC;AACJ,CAAC;AAED,uEAAuE;AACvE,MAAM,UAAU,kBAAkB,CAChC,EAAY,EACZ,EAAY,EACZ,KAAiB,EACjB,MAAkB,EAClB,MAAe;IAEf,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC;IACzC,MAAM,GAAG,GAAmB,EAAE,CAAC;IAC/B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3B,GAAG,CAAC,IAAI,CAAC;YACP,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;YAChE,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;YACnE,MAAM,EAAE,MAAM,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;YAC3B,KAAK,EAAE,MAAM,IAAI,CAAC,GAAG,CAAC;SACvB,CAAC,CAAC;IACL,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;qFACqF;AACrF,MAAM,UAAU,cAAc,CAC5B,EAAY,EACZ,EAAY,EACZ,MAAe,EACf,KAAkB,EAClB,MAAmB;IAEnB,IAAI,KAAK,IAAI,MAAM,IAAI,KAAK,CAAC,MAAM,KAAK,EAAE,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,EAAE,CAAC,MAAM,EAAE,CAAC;QACjF,OAAO,kBAAkB,CAAC,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3D,CAAC;IACD,OAAO,mBAAmB,CAAC,EAAE,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC;AAC7C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,sBAAsB,CACpC,EAAY,EACZ,EAAY,EACZ,OAAuB,EACvB,MAAe;IAEf,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC;IACzC,IAAI,CAAC,GAAG,CAAC;QAAE,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC;IAErD,MAAM,IAAI,GAAa,EAAE,CAAC;IAC1B,MAAM,IAAI,GAAa,EAAE,CAAC;IAC1B,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IAChC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC;QAC9B,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;QACtB,MAAM,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC,EACf,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;QACd,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,EACvB,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QACrB,MAAM,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC,EACf,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;QACd,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,mBAAmB,EAAE,CAAC,EAAE,EAAE,CAAC;YAC7C,MAAM,CAAC,GAAG,CAAC,GAAG,mBAAmB,CAAC;YAClC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAChB,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAClB,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAClB,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAClB,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACjB,IAAI,CAAC,IAAI,CAAC,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,GAAG,CAAC,CAAC;YACzD,IAAI,CAAC,IAAI,CAAC,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,GAAG,CAAC,CAAC;QAC3D,CAAC;IACH,CAAC;IACD,IAAI,MAAM,EAAE,CAAC;QACX,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QACjB,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IACnB,CAAC;SAAM,CAAC;QACN,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACrB,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IACvB,CAAC;IACD,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC;AAChC,CAAC","sourcesContent":["/**\n * Bezier-curve helpers (no external dependency).\n *\n * JIT supports true bezier regions: a polygon's vertices are the editable\n * *anchors*, and the smooth curve through them is derived here with the\n * Catmull-Rom construction — the same algorithm paper.js uses in\n * `path.smooth()`. The curve interpolates every anchor and\n * each anchor's two handles are colinear (a smooth tangent).\n *\n * The OSD overlay renders the curve as a true cubic SVG path + draggable handles\n * (see {@link bezierAnchorHandles}); GeoJSON export flattens the *same* cubics\n * into a dense point list (see {@link bezierCurve}) so a viewer without bezier\n * support (e.g. QuPath, which just draws the coordinate list) still shows the\n * smooth shape. Using one algorithm for both keeps what JIT draws identical to\n * what it exports.\n *\n * Pure functions: no DOM, no service state. Coordinates are image pixels.\n */\n\nexport interface CurvePoints {\n  xs: number[];\n  ys: number[];\n}\n\n/** A vertex's two cubic-bezier control points (absolute coords) plus whether\n *  each side has a handle (open-path endpoints have only one). */\nexport interface AnchorHandle {\n  in: [number, number];\n  out: [number, number];\n  hasIn: boolean;\n  hasOut: boolean;\n}\n\n/** How many points to sample per cubic segment when flattening for export. */\nconst SAMPLES_PER_SEGMENT = 16;\n\n/**\n * Per-anchor cubic-bezier control points using the Catmull-Rom construction\n * (tension 1: control = anchor ± (next − prev) / 6). Matches paper.js\n * `path.smooth()`: the resulting cubic interpolates every anchor and the two\n * handles of each anchor are colinear. Coordinates are in the input space.\n */\nexport function bezierAnchorHandles(xs: number[], ys: number[], closed: boolean): AnchorHandle[] {\n  const n = Math.min(xs.length, ys.length);\n  const out: AnchorHandle[] = [];\n  for (let i = 0; i < n; i++) {\n    const prev = closed ? (i - 1 + n) % n : Math.max(0, i - 1);\n    const next = closed ? (i + 1) % n : Math.min(n - 1, i + 1);\n    const tx = (xs[next] - xs[prev]) / 6;\n    const ty = (ys[next] - ys[prev]) / 6;\n    out.push({\n      out: [xs[i] + tx, ys[i] + ty],\n      in: [xs[i] - tx, ys[i] - ty],\n      hasOut: closed || i < n - 1,\n      hasIn: closed || i > 0,\n    });\n  }\n  return out;\n}\n\n/** The Catmull-Rom handles as **relative** offsets `[dx, dy]` per anchor — used\n *  to initialise a region's editable handles when bezier is turned on. */\nexport function defaultHandleOffsets(\n  xs: number[],\n  ys: number[],\n  closed: boolean,\n): { in: number[][]; out: number[][] } {\n  const h = bezierAnchorHandles(xs, ys, closed);\n  return {\n    in: h.map((a, i) => [a.in[0] - xs[i], a.in[1] - ys[i]]),\n    out: h.map((a, i) => [a.out[0] - xs[i], a.out[1] - ys[i]]),\n  };\n}\n\n/** Absolute handles from stored relative offsets (anchor + offset). */\nexport function handlesFromOffsets(\n  xs: number[],\n  ys: number[],\n  inOff: number[][],\n  outOff: number[][],\n  closed: boolean,\n): AnchorHandle[] {\n  const n = Math.min(xs.length, ys.length);\n  const out: AnchorHandle[] = [];\n  for (let i = 0; i < n; i++) {\n    out.push({\n      in: [xs[i] + (inOff[i]?.[0] ?? 0), ys[i] + (inOff[i]?.[1] ?? 0)],\n      out: [xs[i] + (outOff[i]?.[0] ?? 0), ys[i] + (outOff[i]?.[1] ?? 0)],\n      hasOut: closed || i < n - 1,\n      hasIn: closed || i > 0,\n    });\n  }\n  return out;\n}\n\n/** A region's handles: from its stored (editable) offsets when present, else the\n *  Catmull-Rom default. The single source of truth for both rendering and export. */\nexport function resolveHandles(\n  xs: number[],\n  ys: number[],\n  closed: boolean,\n  inOff?: number[][],\n  outOff?: number[][],\n): AnchorHandle[] {\n  if (inOff && outOff && inOff.length === xs.length && outOff.length === xs.length) {\n    return handlesFromOffsets(xs, ys, inOff, outOff, closed);\n  }\n  return bezierAnchorHandles(xs, ys, closed);\n}\n\n/**\n * Flatten a cubic bezier (defined by explicit per-anchor handles) into a dense\n * point list by sampling each segment. The curve passes through every anchor; a\n * closed ring returns to its first point.\n */\nexport function bezierCurveFromHandles(\n  xs: number[],\n  ys: number[],\n  handles: AnchorHandle[],\n  closed: boolean,\n): CurvePoints {\n  const n = Math.min(xs.length, ys.length);\n  if (n < 3) return { xs: xs.slice(), ys: ys.slice() };\n\n  const outX: number[] = [];\n  const outY: number[] = [];\n  const segs = closed ? n : n - 1;\n  for (let i = 0; i < segs; i++) {\n    const j = (i + 1) % n;\n    const p0x = xs[i],\n      p0y = ys[i];\n    const c1 = handles[i].out,\n      c2 = handles[j].in;\n    const p3x = xs[j],\n      p3y = ys[j];\n    for (let s = 0; s < SAMPLES_PER_SEGMENT; s++) {\n      const t = s / SAMPLES_PER_SEGMENT;\n      const u = 1 - t;\n      const w0 = u * u * u,\n        w1 = 3 * u * u * t,\n        w2 = 3 * u * t * t,\n        w3 = t * t * t;\n      outX.push(w0 * p0x + w1 * c1[0] + w2 * c2[0] + w3 * p3x);\n      outY.push(w0 * p0y + w1 * c1[1] + w2 * c2[1] + w3 * p3y);\n    }\n  }\n  if (closed) {\n    outX.push(xs[0]);\n    outY.push(ys[0]);\n  } else {\n    outX.push(xs[n - 1]);\n    outY.push(ys[n - 1]);\n  }\n  return { xs: outX, ys: outY };\n}\n"]}

package/esm2022/lib/models/class-preset.mjs

@@ -11,8 +11,16 @@
  * gets the same colour with no stored state.
  */
 export const DEFAULT_FALLBACK_PALETTE = [
-    '#6C8EBF', '#82B366', '#B85450', '#9673A6', '#D79B00',
-    '#3C948B', '#A64CA6', '#CC6677', '#4477AA', '#228833',
+    '#6C8EBF',
+    '#82B366',
+    '#B85450',
+    '#9673A6',
+    '#D79B00',
+    '#3C948B',
+    '#A64CA6',
+    '#CC6677',
+    '#4477AA',
+    '#228833',
 ];
 /** Seed classes — mirrors the historical hard-coded `classificationColors` map. */
 const DEFAULT_CLASSES = [
@@ -43,4 +51,34 @@ export function defaultPresetSet() {
 export function isEmptyPresetSet(set) {
     return !set || !Array.isArray(set.classes) || set.classes.length === 0;
 }
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Validate an untrusted value (e.g. an imported JSON file) as a preset set.
+ * Returns a clean copy — only well-formed `{ name, color }` classes, defaults
+ * for missing optional fields — or null when it has no usable classes.
+ */
+export function parsePresetSet(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const raw = value;
+    if (!Array.isArray(raw.classes))
+        return null;
+    const classes = [];
+    for (const c of raw.classes) {
+        const entry = c;
+        if (!entry || typeof entry.name !== 'string' || typeof entry.color !== 'string')
+            continue;
+        classes.push({ ...entry, name: entry.name, color: entry.color });
+    }
+    if (classes.length === 0)
+        return null;
+    const palette = Array.isArray(raw.fallbackPalette)
+        ? raw.fallbackPalette.filter((c) => typeof c === 'string')
+        : [];
+    return {
+        classes,
+        fallbackPalette: palette.length ? palette : [...DEFAULT_FALLBACK_PALETTE],
+        autoPromote: raw.autoPromote === true,
+        matchMode: raw.matchMode === 'normalized' ? 'normalized' : 'exact',
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"class-preset.js","sourceRoot":"","sources":["../../../../src/lib/models/class-preset.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Preset annotation classes (jit-ui#70).\n *\n * A class is a flat `{ name, color }` pair (v1: no hierarchy, no special-class semantics).\n * The `PresetSet` is the per-user, server-persisted source of truth for region colours;\n * see `class-color.util.ts` for the deterministic colour-resolution engine.\n */\n\n/** Where a preset class came from: added by the user, one of the built-in\n *  defaults, or auto-promoted from an unknown region label. */\nexport type PresetSource = 'user' | 'default' | 'auto';\n\n/** One annotation class and its colour: regions whose `label` matches\n *  `name` (per the set's {@link MatchMode}) draw in `color` unless their colour\n *  was overridden by hand. */\nexport interface ClassPreset {\n  /** The class name — matched against `Region.label`. */\n  name: string;\n  /** Hex colour, `#RRGGBB`. */\n  color: string;\n  /** Reserved for a future per-class overlay-visibility toggle. */\n  visible?: boolean;\n  /** Provenance; `'auto'` = added by opt-in fallback promotion. */\n  source?: PresetSource;\n}\n\n/** How a region label is matched to a preset name: `'exact'` compares the\n *  strings as is; `'normalized'` trims and lower-cases both first. */\nexport type MatchMode = 'exact' | 'normalized';\n\n/**\n * The per-user class-colour configuration (server-persisted through the\n * preferences port): the preset classes, the palette for labels outside them,\n * and the matching rules. Resolved into region colours by `class-color.util.ts`.\n */\nexport interface PresetSet {\n  /** Ordered list of preset classes. */\n  classes: ClassPreset[];\n  /** Colours used for classes not in `classes` (assigned deterministically). */\n  fallbackPalette: string[];\n  /** Opt-in (default false): add an unknown class to `classes` the first time it is seen. */\n  autoPromote: boolean;\n  /** Label matching against `Region.label` (default `'exact'`). */\n  matchMode: MatchMode;\n  /**\n   * Class colours that imported GeoJSON carried for classes with no preset, keyed by the\n   * match mode's key (see `presetKey`). They come before the fallback palette, so an imported\n   * file keeps its own colours. Session-only: never persisted, and absent from a set a caller\n   * saves or exports.\n   */\n  importedColors?: Readonly<Record<string, string>>;\n}\n\n/**\n * Fallback palette for classes not present in the preset set — reasonably distinct hues.\n * Colours are assigned by a stable hash of the class name, so the same unknown class always\n * gets the same colour with no stored state.\n */\nexport const DEFAULT_FALLBACK_PALETTE: string[] = [\n  '#6C8EBF',\n  '#82B366',\n  '#B85450',\n  '#9673A6',\n  '#D79B00',\n  '#3C948B',\n  '#A64CA6',\n  '#CC6677',\n  '#4477AA',\n  '#228833',\n];\n\n/** Seed classes — mirrors the historical hard-coded `classificationColors` map. */\nconst DEFAULT_CLASSES: ClassPreset[] = [\n  { name: 'Fragmented-embryo', color: '#FF8C00', source: 'default' },\n  { name: 'Dying-embryo', color: '#FF3333', source: 'default' },\n  { name: 'Two-cell-embryo', color: '#33CC66', source: 'default' },\n  { name: 'One-cell-embryo', color: '#3399FF', source: 'default' },\n  { name: 'Unknown', color: '#888888', source: 'default' },\n  { name: 'Tumor', color: '#FF4444', source: 'default' },\n  { name: 'Stroma', color: '#44AAFF', source: 'default' },\n  { name: 'Immune cells', color: '#FFDD00', source: 'default' },\n  { name: 'Necrosis', color: '#AA6633', source: 'default' },\n  { name: 'Region', color: '#00FFFF', source: 'default' },\n  { name: 'Ignore', color: '#AAAAAA', source: 'default' },\n  { name: 'Positive', color: '#00CC44', source: 'default' },\n  { name: 'Negative', color: '#CC0000', source: 'default' },\n];\n\n/** A fresh default preset set (deep-copied so callers can mutate safely). */\nexport function defaultPresetSet(): PresetSet {\n  return {\n    classes: DEFAULT_CLASSES.map((c) => ({ ...c })),\n    fallbackPalette: [...DEFAULT_FALLBACK_PALETTE],\n    autoPromote: false,\n    matchMode: 'exact',\n  };\n}\n\n/** True when the set has no usable classes (e.g. the server returned an empty/blank record). */\nexport function isEmptyPresetSet(set: PresetSet | null | undefined): boolean {\n  return !set || !Array.isArray(set.classes) || set.classes.length === 0;\n}\n\n/**\n * Validate an untrusted value (e.g. an imported JSON file) as a preset set.\n * Returns a clean copy — only well-formed `{ name, color }` classes, defaults\n * for missing optional fields — or null when it has no usable classes.\n */\nexport function parsePresetSet(value: unknown): PresetSet | null {\n  if (!value || typeof value !== 'object') return null;\n  const raw = value as Partial<Record<keyof PresetSet, unknown>>;\n  if (!Array.isArray(raw.classes)) return null;\n  const classes: ClassPreset[] = [];\n  for (const c of raw.classes as unknown[]) {\n    const entry = c as Partial<ClassPreset> | null;\n    if (!entry || typeof entry.name !== 'string' || typeof entry.color !== 'string') continue;\n    classes.push({ ...entry, name: entry.name, color: entry.color });\n  }\n  if (classes.length === 0) return null;\n  const palette = Array.isArray(raw.fallbackPalette)\n    ? (raw.fallbackPalette as unknown[]).filter((c): c is string => typeof c === 'string')\n    : [];\n  return {\n    classes,\n    fallbackPalette: palette.length ? palette : [...DEFAULT_FALLBACK_PALETTE],\n    autoPromote: raw.autoPromote === true,\n    matchMode: raw.matchMode === 'normalized' ? 'normalized' : 'exact',\n  };\n}\n"]}

package/esm2022/lib/models/geometry.mjs

@@ -1,56 +1,46 @@
 /**
- * Pure geometry helpers extracted from PlotlyService.
+ * Pure SVG-path helpers (build and parse a vertex ring as a Plotly path).
  *
- * No DOM access, no service state, no `this` — every function is testable
- * in isolation. Keep it that way: this module is the dumping ground for
- * shape/mask/SVG-path utilities the wand, vertex eraser, and region editor
- * share. If a helper grows a `this.shapes` reference, it doesn't belong here.
+ * No DOM access, no service state, no `this`. Mask and ring geometry (the
+ * rasterizer, mask set operations, point-in-ring, simplification, contour
+ * tracing) lives in `src/lib/geometry/`.
  */
 // ── SVG path parsing / building ──────────────────────────────────────
 /**
- * Parse a single-subpath `M x,y L x,y ... Z` path into vertex arrays.
+ * Split a single-subpath `M x,y L x,y ... [Z]` path into vertex arrays, plus
+ * whether it is closed (ends in `Z`). No validation: a coordinate that doesn't
+ * parse comes back as NaN. See {@link parseSvgPathPolygon} for the checked form.
+ */
+export function parseSvgPath(path) {
+    const closed = path.endsWith('Z');
+    const body = closed ? path.slice(1, -1) : path.slice(1); // drop M and optionally Z
+    const xpoints = [];
+    const ypoints = [];
+    for (const seg of body.split('L')) {
+        const [sx, sy] = seg.split(',');
+        xpoints.push(parseFloat(sx));
+        ypoints.push(parseFloat(sy));
+    }
+    return { xpoints, ypoints, closed };
+}
+/**
+ * Parse a single-subpath `M x,y L x,y ... [Z]` path into vertex arrays.
  *
  * Returns null for paths we can't safely round-trip (multi-subpath, curves,
- * fewer than three vertices). The wand only adopts shapes it produced or
- * that Plotly's drawclosedpath produces, both of which are single-subpath
- * polygons.
+ * non-numeric coordinates, fewer than three vertices).
  */
 export function parseSvgPathPolygon(path) {
     if (!path || path[0] !== 'M')
         return null;
     if (path.indexOf('M', 1) !== -1)
         return null; // multi-subpath
-    const trimmed = path.endsWith('Z') ? path.slice(1, -1) : path.slice(1);
-    const segs = trimmed.split('L');
-    const xpoints = [];
-    const ypoints = [];
-    for (const seg of segs) {
-        const [sx, sy] = seg.split(',');
-        const x = parseFloat(sx);
-        const y = parseFloat(sy);
-        if (!Number.isFinite(x) || !Number.isFinite(y))
-            return null;
-        xpoints.push(x);
-        ypoints.push(y);
-    }
+    const { xpoints, ypoints } = parseSvgPath(path);
+    if (xpoints.some((x, i) => !Number.isFinite(x) || !Number.isFinite(ypoints[i])))
+        return null;
     if (xpoints.length < 3)
         return null;
     return { xpoints, ypoints };
 }
-/**
- * Build a closed SVG path string `M x,y L x,y L ... Z` from vertex arrays.
- * Returns '' for fewer than three vertices (degenerate).
- */
-export function polygonToSvgPath(xpoints, ypoints) {
-    if (xpoints.length < 3)
-        return '';
-    let path = 'M';
-    for (let i = 0; i < xpoints.length; i++) {
-        path += `${xpoints[i]},${ypoints[i]}`;
-        path += i < xpoints.length - 1 ? 'L' : 'Z';
-    }
-    return path;
-}
 /**
  * Build an SVG path string from vertex arrays. Closed polygons end with `Z`,
  * open polylines do not. Returns '' for fewer than two vertices (degenerate).
@@ -68,131 +58,4 @@ export function verticesToSvgPath(xs, ys, closed) {
         path += 'Z';
     return path;
 }
-// ── Region equality ──────────────────────────────────────────────────
-/**
- * Compare two Plotly shape objects for "same region" — used by the wand to
- * avoid appending duplicates when the user pushes the same find result more
- * than once. Polygons compare by SVG path string, rectangles compare by
- * (x0, y0, x1, y1).
- */
-export function shapesEqual(a, b) {
-    if (a.path && b.path) {
-        return a.path === b.path;
-    }
-    if (a.x0 !== undefined && a.y0 !== undefined &&
-        a.x1 !== undefined && a.y1 !== undefined &&
-        b.x0 !== undefined && b.y0 !== undefined &&
-        b.x1 !== undefined && b.y1 !== undefined) {
-        return a.x0 === b.x0 &&
-            a.y0 === b.y0 &&
-            a.x1 === b.x1 &&
-            a.y1 === b.y1;
-    }
-    return false;
-}
-// ── BBox-mask operations (used by the wand stroke accumulator) ───────
-/** Returns true if the two bbox-relative masks share at least one set pixel. */
-export function masksOverlap(a, b) {
-    const ix0 = Math.max(a.bx, b.bx);
-    const iy0 = Math.max(a.by, b.by);
-    const ix1 = Math.min(a.bx + a.bw, b.bx + b.bw);
-    const iy1 = Math.min(a.by + a.bh, b.by + b.bh);
-    if (ix0 >= ix1 || iy0 >= iy1)
-        return false;
-    for (let y = iy0; y < iy1; y++) {
-        const ar = (y - a.by) * a.bw;
-        const br = (y - b.by) * b.bw;
-        for (let x = ix0; x < ix1; x++) {
-            if (a.mask[ar + (x - a.bx)] && b.mask[br + (x - b.bx)])
-                return true;
-        }
-    }
-    return false;
-}
-/**
- * Allocate a fresh accumulator covering both masks and OR them in. The
- * resulting mask's bbox is the smallest rectangle containing both inputs.
- */
-export function unionMasks(a, b) {
-    const ux0 = Math.min(a.bx, b.bx);
-    const uy0 = Math.min(a.by, b.by);
-    const ux1 = Math.max(a.bx + a.bw, b.bx + b.bw);
-    const uy1 = Math.max(a.by + a.bh, b.by + b.bh);
-    const ubw = ux1 - ux0;
-    const ubh = uy1 - uy0;
-    const umask = new Uint8Array(ubw * ubh);
-    const dax = a.bx - ux0;
-    const day = a.by - uy0;
-    for (let row = 0; row < a.bh; row++) {
-        const src = row * a.bw;
-        const dst = (row + day) * ubw + dax;
-        umask.set(a.mask.subarray(src, src + a.bw), dst);
-    }
-    const dbx = b.bx - ux0;
-    const dby = b.by - uy0;
-    for (let row = 0; row < b.bh; row++) {
-        const srcRow = row * b.bw;
-        const dstRow = (row + dby) * ubw;
-        for (let col = 0; col < b.bw; col++) {
-            if (b.mask[srcRow + col])
-                umask[dstRow + (dbx + col)] = 1;
-        }
-    }
-    return { bx: ux0, by: uy0, bw: ubw, bh: ubh, mask: umask };
-}
-// ── Ring simplification (Douglas–Peucker) ───────────────────────────────
-/** Perpendicular distance from (px,py) to the segment (ax,ay)–(bx,by). */
-function perpDistance(px, py, ax, ay, bx, by) {
-    const dx = bx - ax, dy = by - ay;
-    const len2 = dx * dx + dy * dy;
-    if (len2 === 0)
-        return Math.hypot(px - ax, py - ay);
-    let t = ((px - ax) * dx + (py - ay) * dy) / len2;
-    t = Math.max(0, Math.min(1, t));
-    return Math.hypot(px - (ax + t * dx), py - (ay + t * dy));
-}
-/**
- * Simplify a closed ring with the Douglas–Peucker algorithm (jit-ui#85):
- * drop every vertex that lies within `epsilon` pixels (the "altitude
- * threshold") of the line between its kept neighbours. Anchored at vertex 0
- * (the ring is closed by appending it). Rings of ≤ 3 vertices, or a
- * non-positive epsilon, are returned unchanged. Output keeps the closed-ring
- * convention (no repeated closing point).
- */
-export function simplifyRing(xs, ys, epsilon) {
-    const n = xs.length;
-    if (n <= 3 || !(epsilon > 0))
-        return { xs: xs.slice(), ys: ys.slice() };
-    // Close the ring so both endpoints of the DP run are vertex 0.
-    const px = [...xs, xs[0]];
-    const py = [...ys, ys[0]];
-    const m = px.length;
-    const keep = new Array(m).fill(false);
-    keep[0] = true;
-    keep[m - 1] = true;
-    const stack = [[0, m - 1]];
-    while (stack.length) {
-        const [a, b] = stack.pop();
-        let maxD = -1, idx = -1;
-        for (let i = a + 1; i < b; i++) {
-            const d = perpDistance(px[i], py[i], px[a], py[a], px[b], py[b]);
-            if (d > maxD) {
-                maxD = d;
-                idx = i;
-            }
-        }
-        if (maxD > epsilon && idx > a) {
-            keep[idx] = true;
-            stack.push([a, idx], [idx, b]);
-        }
-    }
-    const outX = [], outY = [];
-    for (let i = 0; i < m - 1; i++) { // drop the duplicated closing vertex
-        if (keep[i]) {
-            outX.push(px[i]);
-            outY.push(py[i]);
-        }
-    }
-    return { xs: outX, ys: outY };
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"geometry.js","sourceRoot":"","sources":["../../../../src/lib/models/geometry.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Pure geometry helpers extracted from PlotlyService.\n *\n * No DOM access, no service state, no `this` — every function is testable\n * in isolation. Keep it that way: this module is the dumping ground for\n * shape/mask/SVG-path utilities the wand, vertex eraser, and region editor\n * share. If a helper grows a `this.shapes` reference, it doesn't belong here.\n */\n\n/** A bbox-relative binary mask (1 = filled, 0 = empty). */\nexport interface BBoxMask {\n  bx: number;\n  by: number;\n  bw: number;\n  bh: number;\n  mask: Uint8Array;\n}\n\n/** Parsed single-subpath polygon vertices. */\nexport interface PolygonVertices {\n  xpoints: number[];\n  ypoints: number[];\n}\n\n// ── SVG path parsing / building ──────────────────────────────────────\n\n/**\n * Parse a single-subpath `M x,y L x,y ... Z` path into vertex arrays.\n *\n * Returns null for paths we can't safely round-trip (multi-subpath, curves,\n * fewer than three vertices). The wand only adopts shapes it produced or\n * that Plotly's drawclosedpath produces, both of which are single-subpath\n * polygons.\n */\nexport function parseSvgPathPolygon(path: string): PolygonVertices | null {\n  if (!path || path[0] !== 'M') return null;\n  if (path.indexOf('M', 1) !== -1) return null; // multi-subpath\n  const trimmed = path.endsWith('Z') ? path.slice(1, -1) : path.slice(1);\n  const segs = trimmed.split('L');\n  const xpoints: number[] = [];\n  const ypoints: number[] = [];\n  for (const seg of segs) {\n    const [sx, sy] = seg.split(',');\n    const x = parseFloat(sx);\n    const y = parseFloat(sy);\n    if (!Number.isFinite(x) || !Number.isFinite(y)) return null;\n    xpoints.push(x);\n    ypoints.push(y);\n  }\n  if (xpoints.length < 3) return null;\n  return { xpoints, ypoints };\n}\n\n/**\n * Build a closed SVG path string `M x,y L x,y L ... Z` from vertex arrays.\n * Returns '' for fewer than three vertices (degenerate).\n */\nexport function polygonToSvgPath(xpoints: number[], ypoints: number[]): string {\n  if (xpoints.length < 3) return '';\n  let path = 'M';\n  for (let i = 0; i < xpoints.length; i++) {\n    path += `${xpoints[i]},${ypoints[i]}`;\n    path += i < xpoints.length - 1 ? 'L' : 'Z';\n  }\n  return path;\n}\n\n/**\n * Build an SVG path string from vertex arrays. Closed polygons end with `Z`,\n * open polylines do not. Returns '' for fewer than two vertices (degenerate).\n */\nexport function verticesToSvgPath(xs: number[], ys: number[], closed: boolean): string {\n  if (xs.length < 2) return '';\n  let path = 'M';\n  for (let i = 0; i < xs.length; i++) {\n    path += `${xs[i]},${ys[i]}`;\n    if (i < xs.length - 1) path += 'L';\n  }\n  if (closed) path += 'Z';\n  return path;\n}\n\n// ── Region equality ──────────────────────────────────────────────────\n\n/**\n * Compare two Plotly shape objects for \"same region\" — used by the wand to\n * avoid appending duplicates when the user pushes the same find result more\n * than once. Polygons compare by SVG path string, rectangles compare by\n * (x0, y0, x1, y1).\n */\nexport function shapesEqual(a: any, b: any): boolean {\n  if (a.path && b.path) {\n    return a.path === b.path;\n  }\n  if (\n    a.x0 !== undefined && a.y0 !== undefined &&\n    a.x1 !== undefined && a.y1 !== undefined &&\n    b.x0 !== undefined && b.y0 !== undefined &&\n    b.x1 !== undefined && b.y1 !== undefined\n  ) {\n    return a.x0 === b.x0 &&\n           a.y0 === b.y0 &&\n           a.x1 === b.x1 &&\n           a.y1 === b.y1;\n  }\n  return false;\n}\n\n// ── BBox-mask operations (used by the wand stroke accumulator) ───────\n\n/** Returns true if the two bbox-relative masks share at least one set pixel. */\nexport function masksOverlap(a: BBoxMask, b: BBoxMask): boolean {\n  const ix0 = Math.max(a.bx, b.bx);\n  const iy0 = Math.max(a.by, b.by);\n  const ix1 = Math.min(a.bx + a.bw, b.bx + b.bw);\n  const iy1 = Math.min(a.by + a.bh, b.by + b.bh);\n  if (ix0 >= ix1 || iy0 >= iy1) return false;\n  for (let y = iy0; y < iy1; y++) {\n    const ar = (y - a.by) * a.bw;\n    const br = (y - b.by) * b.bw;\n    for (let x = ix0; x < ix1; x++) {\n      if (a.mask[ar + (x - a.bx)] && b.mask[br + (x - b.bx)]) return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Allocate a fresh accumulator covering both masks and OR them in. The\n * resulting mask's bbox is the smallest rectangle containing both inputs.\n */\nexport function unionMasks(a: BBoxMask, b: BBoxMask): BBoxMask {\n  const ux0 = Math.min(a.bx, b.bx);\n  const uy0 = Math.min(a.by, b.by);\n  const ux1 = Math.max(a.bx + a.bw, b.bx + b.bw);\n  const uy1 = Math.max(a.by + a.bh, b.by + b.bh);\n  const ubw = ux1 - ux0;\n  const ubh = uy1 - uy0;\n  const umask = new Uint8Array(ubw * ubh);\n\n  const dax = a.bx - ux0;\n  const day = a.by - uy0;\n  for (let row = 0; row < a.bh; row++) {\n    const src = row * a.bw;\n    const dst = (row + day) * ubw + dax;\n    umask.set(a.mask.subarray(src, src + a.bw), dst);\n  }\n  const dbx = b.bx - ux0;\n  const dby = b.by - uy0;\n  for (let row = 0; row < b.bh; row++) {\n    const srcRow = row * b.bw;\n    const dstRow = (row + dby) * ubw;\n    for (let col = 0; col < b.bw; col++) {\n      if (b.mask[srcRow + col]) umask[dstRow + (dbx + col)] = 1;\n    }\n  }\n  return { bx: ux0, by: uy0, bw: ubw, bh: ubh, mask: umask };\n}\n\n// ── Ring simplification (Douglas–Peucker) ───────────────────────────────\n\n/** Perpendicular distance from (px,py) to the segment (ax,ay)–(bx,by). */\nfunction perpDistance(px: number, py: number,\n                      ax: number, ay: number, bx: number, by: number): number {\n  const dx = bx - ax, dy = by - ay;\n  const len2 = dx * dx + dy * dy;\n  if (len2 === 0) return Math.hypot(px - ax, py - ay);\n  let t = ((px - ax) * dx + (py - ay) * dy) / len2;\n  t = Math.max(0, Math.min(1, t));\n  return Math.hypot(px - (ax + t * dx), py - (ay + t * dy));\n}\n\n/**\n * Simplify a closed ring with the Douglas–Peucker algorithm (jit-ui#85):\n * drop every vertex that lies within `epsilon` pixels (the \"altitude\n * threshold\") of the line between its kept neighbours. Anchored at vertex 0\n * (the ring is closed by appending it). Rings of ≤ 3 vertices, or a\n * non-positive epsilon, are returned unchanged. Output keeps the closed-ring\n * convention (no repeated closing point).\n */\nexport function simplifyRing(xs: number[], ys: number[], epsilon: number)\n  : { xs: number[]; ys: number[] } {\n  const n = xs.length;\n  if (n <= 3 || !(epsilon > 0)) return { xs: xs.slice(), ys: ys.slice() };\n\n  // Close the ring so both endpoints of the DP run are vertex 0.\n  const px = [...xs, xs[0]];\n  const py = [...ys, ys[0]];\n  const m = px.length;\n  const keep = new Array<boolean>(m).fill(false);\n  keep[0] = true;\n  keep[m - 1] = true;\n\n  const stack: Array<[number, number]> = [[0, m - 1]];\n  while (stack.length) {\n    const [a, b] = stack.pop() as [number, number];\n    let maxD = -1, idx = -1;\n    for (let i = a + 1; i < b; i++) {\n      const d = perpDistance(px[i], py[i], px[a], py[a], px[b], py[b]);\n      if (d > maxD) { maxD = d; idx = i; }\n    }\n    if (maxD > epsilon && idx > a) {\n      keep[idx] = true;\n      stack.push([a, idx], [idx, b]);\n    }\n  }\n\n  const outX: number[] = [], outY: number[] = [];\n  for (let i = 0; i < m - 1; i++) {      // drop the duplicated closing vertex\n    if (keep[i]) { outX.push(px[i]); outY.push(py[i]); }\n  }\n  return { xs: outX, ys: outY };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,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