@jax-data-science/sci-image-visualizer 0.1.0

package/esm2022/lib/toolbar/vertex-eraser/vertex-eraser-tool.service.mjs

@@ -0,0 +1,234 @@
+import { Injectable } from '@angular/core';
+import { WandService } from '../wand/wand.service';
+import { Region, Polygon } from '../../models/region';
+import * as i0 from "@angular/core";
+import * as i1 from "../wand/wand.service";
+/**
+ * Vertex eraser. A custom canvas overlay that, on click/drag, removes any
+ * polygon vertex within `radius` matrix-pixels of the cursor from every
+ * `type: 'path'` shape on the plot. Polygons that fall below 3 vertices
+ * (or polylines below 2) are removed entirely.
+ *
+ * The cursor is rendered as a dashed-red circle on the overlay so the user
+ * can see the active radius while moving.
+ */
+export class VertexEraserToolService {
+    constructor(wandService) {
+        this.wandService = wandService;
+        this.overlay = null;
+        this.dragging = false;
+        /** Eraser radius in image-pixel (matrix) coordinates. */
+        this.radius = 20;
+        this.cursor = null;
+        this.boundMouseDown = (e) => this.onMouseDown(e);
+        this.boundMouseMove = (e) => this.onMouseMove(e);
+        this.boundMouseUp = (e) => this.onMouseUp(e);
+    }
+    bindHost(host) {
+        this.host = host;
+    }
+    // ── Public API ──────────────────────────────────────────────────────
+    setMode(active) {
+        if (active) {
+            this.createOverlay();
+        }
+        else {
+            this.destroyOverlay();
+        }
+    }
+    /** Set eraser radius in matrix-pixel (image pixel) coordinates. */
+    setRadius(radius) {
+        if (!Number.isFinite(radius) || radius <= 0)
+            return;
+        this.radius = radius;
+        this.drawCursor();
+    }
+    // ── Overlay lifecycle ───────────────────────────────────────────────
+    createOverlay() {
+        const plotEl = this.host.getOverlayContainer();
+        if (!plotEl || this.overlay)
+            return;
+        const canvas = document.createElement('canvas');
+        canvas.style.position = 'absolute';
+        canvas.style.top = '0';
+        canvas.style.left = '0';
+        canvas.style.width = '100%';
+        canvas.style.height = '100%';
+        canvas.style.cursor = 'crosshair';
+        canvas.style.zIndex = '100';
+        canvas.width = plotEl.offsetWidth;
+        canvas.height = plotEl.offsetHeight;
+        plotEl.appendChild(canvas);
+        this.overlay = canvas;
+        canvas.addEventListener('mousedown', this.boundMouseDown);
+        canvas.addEventListener('mousemove', this.boundMouseMove);
+        canvas.addEventListener('mouseup', this.boundMouseUp);
+        canvas.addEventListener('mouseleave', this.boundMouseUp);
+    }
+    destroyOverlay() {
+        if (!this.overlay)
+            return;
+        this.overlay.removeEventListener('mousedown', this.boundMouseDown);
+        this.overlay.removeEventListener('mousemove', this.boundMouseMove);
+        this.overlay.removeEventListener('mouseup', this.boundMouseUp);
+        this.overlay.removeEventListener('mouseleave', this.boundMouseUp);
+        this.overlay.remove();
+        this.overlay = null;
+        this.dragging = false;
+        this.cursor = null;
+    }
+    // ── Mouse handlers ──────────────────────────────────────────────────
+    onMouseDown(e) {
+        if (e.button !== 0)
+            return;
+        this.dragging = true;
+        this.updateCursor(e);
+        this.applyAtClient(e);
+    }
+    onMouseMove(e) {
+        this.updateCursor(e);
+        if (!this.dragging) {
+            this.drawCursor();
+            return;
+        }
+        if ((e.buttons & 1) === 0) {
+            this.dragging = false;
+            this.drawCursor();
+            return;
+        }
+        this.applyAtClient(e);
+        this.drawCursor();
+    }
+    onMouseUp(_) {
+        this.dragging = false;
+    }
+    updateCursor(e) {
+        if (!this.overlay)
+            return;
+        const rect = this.overlay.getBoundingClientRect();
+        this.cursor = { x: e.clientX - rect.left, y: e.clientY - rect.top };
+    }
+    /** Draw the eraser radius circle at the current cursor position. */
+    drawCursor() {
+        if (!this.overlay)
+            return;
+        const ctx = this.overlay.getContext('2d');
+        if (!ctx)
+            return;
+        ctx.clearRect(0, 0, this.overlay.width, this.overlay.height);
+        if (!this.cursor)
+            return;
+        const transform = this.host.getCoordinateTransform();
+        if (!transform.isReady())
+            return;
+        // Convert matrix-pixel radius to screen-pixel radius via the data scale.
+        const rx = this.host.getCachedImageRatio();
+        const screenRadius = transform.dataLengthToScreen(this.radius * rx);
+        if (!Number.isFinite(screenRadius) || screenRadius <= 0)
+            return;
+        ctx.save();
+        ctx.strokeStyle = 'rgba(255, 80, 80, 0.9)';
+        ctx.lineWidth = 1.5;
+        ctx.setLineDash([4, 3]);
+        ctx.beginPath();
+        ctx.arc(this.cursor.x, this.cursor.y, screenRadius, 0, Math.PI * 2);
+        ctx.stroke();
+        ctx.restore();
+    }
+    // ── Per-tick erase logic ────────────────────────────────────────────
+    /**
+     * Drop every vertex of every path-shape that lies within the eraser's
+     * radius of the cursor. Polygons reduced below 3 vertices (or polylines
+     * below 2) are removed entirely.
+     */
+    applyAtClient(e) {
+        if (!this.overlay)
+            return;
+        const regions = this.host.getRegions();
+        if (!regions || regions.length === 0)
+            return;
+        const transform = this.host.getCoordinateTransform();
+        if (!transform.isReady())
+            return;
+        const { x: dataX, y: dataY } = transform.clientToData(e.clientX, e.clientY);
+        if (!Number.isFinite(dataX) || !Number.isFinite(dataY))
+            return;
+        const rx = this.host.getCachedImageRatio();
+        const cmx = dataX / rx;
+        const cmy = dataY / rx;
+        let anyChange = false;
+        for (let i = regions.length - 1; i >= 0; i--) {
+            const region = regions[i];
+            const b = region?.bounds;
+            if (!(b instanceof Polygon) || b.xpoints.length === 0)
+                continue;
+            const closed = b.closed !== false;
+            const xs = b.xpoints.map(x => x / rx);
+            const ys = b.ypoints.map(y => y / rx);
+            const result = this.wandService.dropVerticesWithinRadius(xs, ys, cmx, cmy, this.radius);
+            // Erase vertices on interior rings (a donut's inner outline) too, and drop
+            // a hole that degenerates below a triangle (jit-ui#85).
+            let holesChanged = false;
+            let newHoles;
+            if (b.holes) {
+                newHoles = [];
+                for (const ring of b.holes) {
+                    const hr = this.wandService.dropVerticesWithinRadius(ring.map(p => p[0] / rx), ring.map(p => p[1] / rx), cmx, cmy, this.radius);
+                    if (hr.removed === 0) {
+                        newHoles.push(ring); // untouched — keep as-is
+                    }
+                    else {
+                        holesChanged = true;
+                        if (hr.xpoints.length >= 3) {
+                            newHoles.push(hr.xpoints.map((x, k) => [x * rx, hr.ypoints[k] * rx]));
+                        } // else: hole collapsed — drop it
+                    }
+                }
+                if (newHoles.length === 0)
+                    newHoles = undefined;
+            }
+            if (result.removed === 0 && !holesChanged)
+                continue;
+            anyChange = true;
+            const minVerts = closed ? 3 : 2;
+            if (result.xpoints.length < minVerts) {
+                // Region became degenerate — remove it.
+                regions.splice(i, 1);
+                continue;
+            }
+            // Rebuild the polygon in image/data coords. Drop any stored bezier
+            // handles (the anchor count changed) — they re-derive from the new anchors.
+            const xPlot = result.xpoints.map(x => x * rx);
+            const yPlot = result.ypoints.map(y => y * rx);
+            const poly = new Polygon();
+            poly.npoints = xPlot.length;
+            poly.xpoints = xPlot;
+            poly.ypoints = yPlot;
+            poly.coordinates = xPlot.map((x, k) => [x, yPlot[k]]);
+            poly.closed = closed;
+            poly.bezier = b.bezier;
+            if (newHoles && newHoles.length)
+                poly.holes = newHoles;
+            const nr = new Region();
+            nr.id = region.id;
+            nr.name = region.name;
+            nr.label = region.label;
+            nr.color = region.color;
+            nr.bounds = poly;
+            regions[i] = nr;
+        }
+        if (!anyChange)
+            return;
+        // The wand's stroke mask becomes stale once we trim vertices off any
+        // region — drop it so the next wand interaction re-adopts or restarts.
+        this.host.invalidateWandRegion();
+        this.host.setRegions(regions);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: VertexEraserToolService, deps: [{ token: i1.WandService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: VertexEraserToolService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: VertexEraserToolService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.WandService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vertex-eraser-tool.service.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/vertex-eraser/vertex-eraser-tool.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEnD,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;;;AAsBtD;;;;;;;;GAQG;AAEH,MAAM,OAAO,uBAAuB;IAalC,YAAoB,WAAwB;QAAxB,gBAAW,GAAX,WAAW,CAAa;QAVpC,YAAO,GAA6B,IAAI,CAAC;QACzC,aAAQ,GAAG,KAAK,CAAC;QACzB,yDAAyD;QACjD,WAAM,GAAG,EAAE,CAAC;QACZ,WAAM,GAAoC,IAAI,CAAC;QAOrD,IAAI,CAAC,cAAc,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;QACjD,IAAI,CAAC,cAAc,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;QACjD,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IAC/C,CAAC;IAED,QAAQ,CAAC,IAA0B;QACjC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;IAED,uEAAuE;IAEvE,OAAO,CAAC,MAAe;QACrB,IAAI,MAAM,EAAE,CAAC;YACX,IAAI,CAAC,aAAa,EAAE,CAAC;QACvB,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,cAAc,EAAE,CAAC;QACxB,CAAC;IACH,CAAC;IAED,mEAAmE;IACnE,SAAS,CAAC,MAAc;QACtB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,MAAM,IAAI,CAAC;YAAE,OAAO;QACpD,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,UAAU,EAAE,CAAC;IACpB,CAAC;IAED,uEAAuE;IAE/D,aAAa;QACnB,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC/C,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,OAAO;YAAE,OAAO;QAEpC,MAAM,MAAM,GAAG,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;QAChD,MAAM,CAAC,KAAK,CAAC,QAAQ,GAAG,UAAU,CAAC;QACnC,MAAM,CAAC,KAAK,CAAC,GAAG,GAAG,GAAG,CAAC;QACvB,MAAM,CAAC,KAAK,CAAC,IAAI,GAAG,GAAG,CAAC;QACxB,MAAM,CAAC,KAAK,CAAC,KAAK,GAAG,MAAM,CAAC;QAC5B,MAAM,CAAC,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC;QAC7B,MAAM,CAAC,KAAK,CAAC,MAAM,GAAG,WAAW,CAAC;QAClC,MAAM,CAAC,KAAK,CAAC,MAAM,GAAG,KAAK,CAAC;QAC5B,MAAM,CAAC,KAAK,GAAG,MAAM,CAAC,WAAW,CAAC;QAClC,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,YAAY,CAAC;QAEpC,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;QAC3B,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QAEtB,MAAM,CAAC,gBAAgB,CAAC,WAAW,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;QAC1D,MAAM,CAAC,gBAAgB,CAAC,WAAW,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;QAC1D,MAAM,CAAC,gBAAgB,CAAC,SAAS,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;QACtD,MAAM,CAAC,gBAAgB,CAAC,YAAY,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;IAC3D,CAAC;IAEO,cAAc;QACpB,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,OAAO;QAC1B,IAAI,CAAC,OAAO,CAAC,mBAAmB,CAAC,WAAW,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;QACnE,IAAI,CAAC,OAAO,CAAC,mBAAmB,CAAC,WAAW,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;QACnE,IAAI,CAAC,OAAO,CAAC,mBAAmB,CAAC,SAAS,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;QAC/D,IAAI,CAAC,OAAO,CAAC,mBAAmB,CAAC,YAAY,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;QAClE,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;QACtB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QACtB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;IACrB,CAAC;IAED,uEAAuE;IAE/D,WAAW,CAAC,CAAa;QAC/B,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO;QAC3B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QACrB,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;IACxB,CAAC;IAEO,WAAW,CAAC,CAAa;QAC/B,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QACrB,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACnB,IAAI,CAAC,UAAU,EAAE,CAAC;YAClB,OAAO;QACT,CAAC;QACD,IAAI,CAAC,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;YACtB,IAAI,CAAC,UAAU,EAAE,CAAC;YAClB,OAAO;QACT,CAAC;QACD,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;QACtB,IAAI,CAAC,UAAU,EAAE,CAAC;IACpB,CAAC;IAEO,SAAS,CAAC,CAAa;QAC7B,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;IACxB,CAAC;IAEO,YAAY,CAAC,CAAa;QAChC,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,OAAO;QAC1B,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,qBAAqB,EAAE,CAAC;QAClD,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IACtE,CAAC;IAED,oEAAoE;IAC5D,UAAU;QAChB,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,OAAO;QAC1B,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QAC1C,IAAI,CAAC,GAAG;YAAE,OAAO;QACjB,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAC7D,IAAI,CAAC,IAAI,CAAC,MAAM;YAAE,OAAO;QACzB,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,sBAAsB,EAAE,CAAC;QACrD,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE;YAAE,OAAO;QACjC,yEAAyE;QACzE,MAAM,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3C,MAAM,YAAY,GAAG,SAAS,CAAC,kBAAkB,CAAC,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;QACpE,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,YAAY,IAAI,CAAC;YAAE,OAAO;QAChE,GAAG,CAAC,IAAI,EAAE,CAAC;QACX,GAAG,CAAC,WAAW,GAAG,wBAAwB,CAAC;QAC3C,GAAG,CAAC,SAAS,GAAG,GAAG,CAAC;QACpB,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QACxB,GAAG,CAAC,SAAS,EAAE,CAAC;QAChB,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;QACpE,GAAG,CAAC,MAAM,EAAE,CAAC;QACb,GAAG,CAAC,OAAO,EAAE,CAAC;IAChB,CAAC;IAED,uEAAuE;IAEvE;;;;OAIG;IACK,aAAa,CAAC,CAAa;QACjC,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,OAAO;QAC1B,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;QACvC,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO;QAE7C,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,sBAAsB,EAAE,CAAC;QACrD,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE;YAAE,OAAO;QACjC,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,GAAG,SAAS,CAAC,YAAY,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC;QAC5E,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;YAAE,OAAO;QAC/D,MAAM,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3C,MAAM,GAAG,GAAG,KAAK,GAAG,EAAE,CAAC;QACvB,MAAM,GAAG,GAAG,KAAK,GAAG,EAAE,CAAC;QAEvB,IAAI,SAAS,GAAG,KAAK,CAAC;QACtB,KAAK,IAAI,CAAC,GAAG,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC7C,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;YAC1B,MAAM,CAAC,GAAG,MAAM,EAAE,MAAM,CAAC;YACzB,IAAI,CAAC,CAAC,CAAC,YAAY,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC;gBAAE,SAAS;YAChE,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,KAAK,KAAK,CAAC;YAClC,MAAM,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC;YACtC,MAAM,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC;YAEtC,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,wBAAwB,CAAC,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;YAExF,2EAA2E;YAC3E,wDAAwD;YACxD,IAAI,YAAY,GAAG,KAAK,CAAC;YACzB,IAAI,QAAkC,CAAC;YACvC,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC;gBACZ,QAAQ,GAAG,EAAE,CAAC;gBACd,KAAK,MAAM,IAAI,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC;oBAC3B,MAAM,EAAE,GAAG,IAAI,CAAC,WAAW,CAAC,wBAAwB,CAClD,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;oBAC7E,IAAI,EAAE,CAAC,OAAO,KAAK,CAAC,EAAE,CAAC;wBACrB,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,yBAAyB;oBAChD,CAAC;yBAAM,CAAC;wBACN,YAAY,GAAG,IAAI,CAAC;wBACpB,IAAI,EAAE,CAAC,OAAO,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;4BAC3B,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;wBACxE,CAAC,CAAC,iCAAiC;oBACrC,CAAC;gBACH,CAAC;gBACD,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;oBAAE,QAAQ,GAAG,SAAS,CAAC;YAClD,CAAC;YAED,IAAI,MAAM,CAAC,OAAO,KAAK,CAAC,IAAI,CAAC,YAAY;gBAAE,SAAS;YAEpD,SAAS,GAAG,IAAI,CAAC;YACjB,MAAM,QAAQ,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAChC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,GAAG,QAAQ,EAAE,CAAC;gBACrC,wCAAwC;gBACxC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;gBACrB,SAAS;YACX,CAAC;YAED,mEAAmE;YACnE,4EAA4E;YAC5E,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC;YAC9C,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC;YAC9C,MAAM,IAAI,GAAG,IAAI,OAAO,EAAE,CAAC;YAC3B,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,MAAM,CAAC;YAC5B,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;YACrB,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;YACrB,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACtD,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;YACrB,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC;YACvB,IAAI,QAAQ,IAAI,QAAQ,CAAC,MAAM;gBAAE,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAC;YAEvD,MAAM,EAAE,GAAG,IAAI,MAAM,EAAE,CAAC;YACxB,EAAE,CAAC,EAAE,GAAG,MAAM,CAAC,EAAE,CAAC;YAClB,EAAE,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;YACtB,EAAE,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;YACxB,EAAE,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;YACxB,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC;YACjB,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;QAClB,CAAC;QAED,IAAI,CAAC,SAAS;YAAE,OAAO;QACvB,qEAAqE;QACrE,uEAAuE;QACvE,IAAI,CAAC,IAAI,CAAC,oBAAoB,EAAE,CAAC;QACjC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IAChC,CAAC;8GAhOU,uBAAuB;kHAAvB,uBAAuB,cADV,MAAM;;2FACnB,uBAAuB;kBADnC,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport { WandService } from '../wand/wand.service';\nimport { IViewportHost, IRegionDataHost } from '../../contracts/coordinate-transform.contract';\nimport { Region, Polygon } from '../../models/region';\n\n/**\n * Collaboration interface the vertex eraser needs from its host backend.\n *\n * Extends {@link IViewportHost} for coordinate conversion + overlay attachment,\n * so the eraser is backend-agnostic (Plotly and OpenSeadragon both satisfy it).\n */\nexport interface VertexEraserToolHost extends IViewportHost, IRegionDataHost {\n  /**\n   * Drop the wand's in-progress stroke. Called after the eraser modifies\n   * regions — the wand's accumulator may now reference stale vertices.\n   */\n  invalidateWandRegion(): void;\n  /**\n   * Data-coords-per-image-pixel ratio (== cachedImageRatios[0] || 1). Used to\n   * convert between matrix coordinates (the eraser's native space) and the\n   * backend's data coordinates.\n   */\n  getCachedImageRatio(): number;\n}\n\n/**\n * Vertex eraser. A custom canvas overlay that, on click/drag, removes any\n * polygon vertex within `radius` matrix-pixels of the cursor from every\n * `type: 'path'` shape on the plot. Polygons that fall below 3 vertices\n * (or polylines below 2) are removed entirely.\n *\n * The cursor is rendered as a dashed-red circle on the overlay so the user\n * can see the active radius while moving.\n */\n@Injectable({ providedIn: 'root' })\nexport class VertexEraserToolService {\n\n  private host!: VertexEraserToolHost;\n  private overlay: HTMLCanvasElement | null = null;\n  private dragging = false;\n  /** Eraser radius in image-pixel (matrix) coordinates. */\n  private radius = 20;\n  private cursor: { x: number; y: number } | null = null;\n\n  private readonly boundMouseDown: (e: MouseEvent) => void;\n  private readonly boundMouseMove: (e: MouseEvent) => void;\n  private readonly boundMouseUp: (e: MouseEvent) => void;\n\n  constructor(private wandService: WandService) {\n    this.boundMouseDown = (e) => this.onMouseDown(e);\n    this.boundMouseMove = (e) => this.onMouseMove(e);\n    this.boundMouseUp = (e) => this.onMouseUp(e);\n  }\n\n  bindHost(host: VertexEraserToolHost) {\n    this.host = host;\n  }\n\n  // ── Public API ──────────────────────────────────────────────────────\n\n  setMode(active: boolean) {\n    if (active) {\n      this.createOverlay();\n    } else {\n      this.destroyOverlay();\n    }\n  }\n\n  /** Set eraser radius in matrix-pixel (image pixel) coordinates. */\n  setRadius(radius: number) {\n    if (!Number.isFinite(radius) || radius <= 0) return;\n    this.radius = radius;\n    this.drawCursor();\n  }\n\n  // ── Overlay lifecycle ───────────────────────────────────────────────\n\n  private createOverlay() {\n    const plotEl = this.host.getOverlayContainer();\n    if (!plotEl || this.overlay) return;\n\n    const canvas = document.createElement('canvas');\n    canvas.style.position = 'absolute';\n    canvas.style.top = '0';\n    canvas.style.left = '0';\n    canvas.style.width = '100%';\n    canvas.style.height = '100%';\n    canvas.style.cursor = 'crosshair';\n    canvas.style.zIndex = '100';\n    canvas.width = plotEl.offsetWidth;\n    canvas.height = plotEl.offsetHeight;\n\n    plotEl.appendChild(canvas);\n    this.overlay = canvas;\n\n    canvas.addEventListener('mousedown', this.boundMouseDown);\n    canvas.addEventListener('mousemove', this.boundMouseMove);\n    canvas.addEventListener('mouseup', this.boundMouseUp);\n    canvas.addEventListener('mouseleave', this.boundMouseUp);\n  }\n\n  private destroyOverlay() {\n    if (!this.overlay) return;\n    this.overlay.removeEventListener('mousedown', this.boundMouseDown);\n    this.overlay.removeEventListener('mousemove', this.boundMouseMove);\n    this.overlay.removeEventListener('mouseup', this.boundMouseUp);\n    this.overlay.removeEventListener('mouseleave', this.boundMouseUp);\n    this.overlay.remove();\n    this.overlay = null;\n    this.dragging = false;\n    this.cursor = null;\n  }\n\n  // ── Mouse handlers ──────────────────────────────────────────────────\n\n  private onMouseDown(e: MouseEvent) {\n    if (e.button !== 0) return;\n    this.dragging = true;\n    this.updateCursor(e);\n    this.applyAtClient(e);\n  }\n\n  private onMouseMove(e: MouseEvent) {\n    this.updateCursor(e);\n    if (!this.dragging) {\n      this.drawCursor();\n      return;\n    }\n    if ((e.buttons & 1) === 0) {\n      this.dragging = false;\n      this.drawCursor();\n      return;\n    }\n    this.applyAtClient(e);\n    this.drawCursor();\n  }\n\n  private onMouseUp(_: MouseEvent) {\n    this.dragging = false;\n  }\n\n  private updateCursor(e: MouseEvent) {\n    if (!this.overlay) return;\n    const rect = this.overlay.getBoundingClientRect();\n    this.cursor = { x: e.clientX - rect.left, y: e.clientY - rect.top };\n  }\n\n  /** Draw the eraser radius circle at the current cursor position. */\n  private drawCursor() {\n    if (!this.overlay) return;\n    const ctx = this.overlay.getContext('2d');\n    if (!ctx) return;\n    ctx.clearRect(0, 0, this.overlay.width, this.overlay.height);\n    if (!this.cursor) return;\n    const transform = this.host.getCoordinateTransform();\n    if (!transform.isReady()) return;\n    // Convert matrix-pixel radius to screen-pixel radius via the data scale.\n    const rx = this.host.getCachedImageRatio();\n    const screenRadius = transform.dataLengthToScreen(this.radius * rx);\n    if (!Number.isFinite(screenRadius) || screenRadius <= 0) return;\n    ctx.save();\n    ctx.strokeStyle = 'rgba(255, 80, 80, 0.9)';\n    ctx.lineWidth = 1.5;\n    ctx.setLineDash([4, 3]);\n    ctx.beginPath();\n    ctx.arc(this.cursor.x, this.cursor.y, screenRadius, 0, Math.PI * 2);\n    ctx.stroke();\n    ctx.restore();\n  }\n\n  // ── Per-tick erase logic ────────────────────────────────────────────\n\n  /**\n   * Drop every vertex of every path-shape that lies within the eraser's\n   * radius of the cursor. Polygons reduced below 3 vertices (or polylines\n   * below 2) are removed entirely.\n   */\n  private applyAtClient(e: MouseEvent) {\n    if (!this.overlay) return;\n    const regions = this.host.getRegions();\n    if (!regions || regions.length === 0) return;\n\n    const transform = this.host.getCoordinateTransform();\n    if (!transform.isReady()) return;\n    const { x: dataX, y: dataY } = transform.clientToData(e.clientX, e.clientY);\n    if (!Number.isFinite(dataX) || !Number.isFinite(dataY)) return;\n    const rx = this.host.getCachedImageRatio();\n    const cmx = dataX / rx;\n    const cmy = dataY / rx;\n\n    let anyChange = false;\n    for (let i = regions.length - 1; i >= 0; i--) {\n      const region = regions[i];\n      const b = region?.bounds;\n      if (!(b instanceof Polygon) || b.xpoints.length === 0) continue;\n      const closed = b.closed !== false;\n      const xs = b.xpoints.map(x => x / rx);\n      const ys = b.ypoints.map(y => y / rx);\n\n      const result = this.wandService.dropVerticesWithinRadius(xs, ys, cmx, cmy, this.radius);\n\n      // Erase vertices on interior rings (a donut's inner outline) too, and drop\n      // a hole that degenerates below a triangle (jit-ui#85).\n      let holesChanged = false;\n      let newHoles: number[][][] | undefined;\n      if (b.holes) {\n        newHoles = [];\n        for (const ring of b.holes) {\n          const hr = this.wandService.dropVerticesWithinRadius(\n            ring.map(p => p[0] / rx), ring.map(p => p[1] / rx), cmx, cmy, this.radius);\n          if (hr.removed === 0) {\n            newHoles.push(ring); // untouched — keep as-is\n          } else {\n            holesChanged = true;\n            if (hr.xpoints.length >= 3) {\n              newHoles.push(hr.xpoints.map((x, k) => [x * rx, hr.ypoints[k] * rx]));\n            } // else: hole collapsed — drop it\n          }\n        }\n        if (newHoles.length === 0) newHoles = undefined;\n      }\n\n      if (result.removed === 0 && !holesChanged) continue;\n\n      anyChange = true;\n      const minVerts = closed ? 3 : 2;\n      if (result.xpoints.length < minVerts) {\n        // Region became degenerate — remove it.\n        regions.splice(i, 1);\n        continue;\n      }\n\n      // Rebuild the polygon in image/data coords. Drop any stored bezier\n      // handles (the anchor count changed) — they re-derive from the new anchors.\n      const xPlot = result.xpoints.map(x => x * rx);\n      const yPlot = result.ypoints.map(y => y * rx);\n      const poly = new Polygon();\n      poly.npoints = xPlot.length;\n      poly.xpoints = xPlot;\n      poly.ypoints = yPlot;\n      poly.coordinates = xPlot.map((x, k) => [x, yPlot[k]]);\n      poly.closed = closed;\n      poly.bezier = b.bezier;\n      if (newHoles && newHoles.length) poly.holes = newHoles;\n\n      const nr = new Region();\n      nr.id = region.id;\n      nr.name = region.name;\n      nr.label = region.label;\n      nr.color = region.color;\n      nr.bounds = poly;\n      regions[i] = nr;\n    }\n\n    if (!anyChange) return;\n    // The wand's stroke mask becomes stale once we trim vertices off any\n    // region — drop it so the next wand interaction re-adopts or restarts.\n    this.host.invalidateWandRegion();\n    this.host.setRegions(regions);\n  }\n}\n"]}