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

package/esm2022/lib/toolbar/zoom-to-box/zoom-to-box-tool.service.mjs

@@ -0,0 +1,157 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Custom canvas overlay for click-and-drag rectangular zoom. Plotly's
+ * built-in `dragmode: 'zoom'` works on heatmap/image traces too, but it
+ * doesn't drive the high-def zoom pipeline — this overlay does, by handing
+ * the selected coordinates back to the host.
+ */
+export class ZoomToBoxToolService {
+    constructor() {
+        this.overlay = null;
+        this.startPx = null;
+        this.boundMouseDown = (e) => this.onMouseDown(e);
+        this.boundMouseMove = (e) => this.onMouseMove(e);
+        this.boundMouseUp = (e) => this.onMouseUp(e);
+    }
+    bindHost(host) {
+        this.host = host;
+    }
+    setMode(active) {
+        if (active) {
+            this.createOverlay();
+        }
+        else {
+            this.destroyOverlay();
+        }
+    }
+    // ── Overlay lifecycle ───────────────────────────────────────────────
+    createOverlay() {
+        const plotEl = document.getElementById(this.host.getPlotDiv());
+        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.startPx = null;
+    }
+    // ── Mouse handlers ──────────────────────────────────────────────────
+    onMouseDown(e) {
+        const rect = this.overlay.getBoundingClientRect();
+        this.startPx = { x: e.clientX - rect.left, y: e.clientY - rect.top };
+    }
+    onMouseMove(e) {
+        if (!this.startPx || !this.overlay)
+            return;
+        const rect = this.overlay.getBoundingClientRect();
+        this.drawSelection(this.startPx.x, this.startPx.y, e.clientX - rect.left, e.clientY - rect.top);
+    }
+    onMouseUp(e) {
+        if (!this.startPx || !this.overlay)
+            return;
+        const rect = this.overlay.getBoundingClientRect();
+        const endX = e.clientX - rect.left;
+        const endY = e.clientY - rect.top;
+        // Ignore tiny drags (accidental clicks).
+        if (Math.abs(endX - this.startPx.x) < 5 || Math.abs(endY - this.startPx.y) < 5) {
+            this.startPx = null;
+            this.clearCanvas();
+            return;
+        }
+        // Convert overlay-pixel → data coordinates via the active backend's host.
+        const d0 = this.host.pixelToData(this.startPx.x, this.startPx.y);
+        const d1 = this.host.pixelToData(endX, endY);
+        const coordinates = [
+            Math.min(d0.x, d1.x), Math.max(d0.x, d1.x),
+            Math.max(d0.y, d1.y), Math.min(d0.y, d1.y),
+        ];
+        this.startPx = null;
+        this.clearCanvas();
+        this.host.applyZoomToBox(coordinates);
+    }
+    // ── Selection rectangle drawing ─────────────────────────────────────
+    drawSelection(x0, y0, x1, y1) {
+        const canvas = this.overlay;
+        const ctx = canvas.getContext('2d');
+        const left = Math.min(x0, x1);
+        const top = Math.min(y0, y1);
+        const w = Math.abs(x1 - x0);
+        const h = Math.abs(y1 - y0);
+        ctx.clearRect(0, 0, canvas.width, canvas.height);
+        // Semi-transparent overlay covering everything outside the selection.
+        ctx.save();
+        ctx.fillStyle = 'rgba(0, 0, 0, 0.35)';
+        ctx.beginPath();
+        // Outer rectangle (full canvas).
+        ctx.rect(0, 0, canvas.width, canvas.height);
+        // Inner rectangle (selection cutout) — wound counter-clockwise to create a hole.
+        ctx.moveTo(left, top);
+        ctx.lineTo(left, top + h);
+        ctx.lineTo(left + w, top + h);
+        ctx.lineTo(left + w, top);
+        ctx.closePath();
+        ctx.fill('evenodd');
+        ctx.restore();
+        // Corner notches.
+        const notchLen = Math.min(16, w / 4, h / 4);
+        ctx.save();
+        ctx.strokeStyle = 'rgba(255, 255, 255, 0.9)';
+        ctx.lineWidth = 2;
+        ctx.beginPath();
+        // Top-left.
+        ctx.moveTo(left, top + notchLen);
+        ctx.lineTo(left, top);
+        ctx.lineTo(left + notchLen, top);
+        // Top-right.
+        ctx.moveTo(left + w - notchLen, top);
+        ctx.lineTo(left + w, top);
+        ctx.lineTo(left + w, top + notchLen);
+        // Bottom-right.
+        ctx.moveTo(left + w, top + h - notchLen);
+        ctx.lineTo(left + w, top + h);
+        ctx.lineTo(left + w - notchLen, top + h);
+        // Bottom-left.
+        ctx.moveTo(left + notchLen, top + h);
+        ctx.lineTo(left, top + h);
+        ctx.lineTo(left, top + h - notchLen);
+        ctx.stroke();
+        ctx.restore();
+    }
+    clearCanvas() {
+        if (!this.overlay)
+            return;
+        const ctx = this.overlay.getContext('2d');
+        if (ctx)
+            ctx.clearRect(0, 0, this.overlay.width, this.overlay.height);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: ZoomToBoxToolService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: ZoomToBoxToolService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: ZoomToBoxToolService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"zoom-to-box-tool.service.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/zoom-to-box/zoom-to-box-tool.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAsB3C;;;;;GAKG;AAEH,MAAM,OAAO,oBAAoB;IAU/B;QAPQ,YAAO,GAA6B,IAAI,CAAC;QACzC,YAAO,GAAoC,IAAI,CAAC;QAOtD,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,IAAuB;QAC9B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;IAED,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,uEAAuE;IAE/D,aAAa;QACnB,MAAM,MAAM,GAAG,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;QAC/D,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,OAAO,GAAG,IAAI,CAAC;IACtB,CAAC;IAED,uEAAuE;IAE/D,WAAW,CAAC,CAAa;QAC/B,MAAM,IAAI,GAAG,IAAI,CAAC,OAAQ,CAAC,qBAAqB,EAAE,CAAC;QACnD,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IACvE,CAAC;IAEO,WAAW,CAAC,CAAa;QAC/B,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,OAAO;QAC3C,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,qBAAqB,EAAE,CAAC;QAClD,IAAI,CAAC,aAAa,CAChB,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,EAC9B,CAAC,CAAC,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,CAC5C,CAAC;IACJ,CAAC;IAEO,SAAS,CAAC,CAAa;QAC7B,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,OAAO;QAC3C,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,qBAAqB,EAAE,CAAC;QAClD,MAAM,IAAI,GAAG,CAAC,CAAC,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC;QACnC,MAAM,IAAI,GAAG,CAAC,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC;QAElC,yCAAyC;QACzC,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC;YAC/E,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;YACpB,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,OAAO;QACT,CAAC;QAED,0EAA0E;QAC1E,MAAM,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QACjE,MAAM,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAE7C,MAAM,WAAW,GAAG;YAClB,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;YAC1C,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;SAC3C,CAAC;QAEF,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,IAAI,CAAC,WAAW,EAAE,CAAC;QAEnB,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;IACxC,CAAC;IAED,uEAAuE;IAE/D,aAAa,CAAC,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU;QAClE,MAAM,MAAM,GAAG,IAAI,CAAC,OAAQ,CAAC;QAC7B,MAAM,GAAG,GAAG,MAAM,CAAC,UAAU,CAAC,IAAI,CAAE,CAAC;QAErC,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;QAC9B,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;QAC7B,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC;QAC5B,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC;QAE5B,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;QAEjD,sEAAsE;QACtE,GAAG,CAAC,IAAI,EAAE,CAAC;QACX,GAAG,CAAC,SAAS,GAAG,qBAAqB,CAAC;QACtC,GAAG,CAAC,SAAS,EAAE,CAAC;QAChB,iCAAiC;QACjC,GAAG,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;QAC5C,iFAAiF;QACjF,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QACtB,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC;QAC1B,GAAG,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC;QAC9B,GAAG,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;QAC1B,GAAG,CAAC,SAAS,EAAE,CAAC;QAChB,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACpB,GAAG,CAAC,OAAO,EAAE,CAAC;QAEd,kBAAkB;QAClB,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;QAC5C,GAAG,CAAC,IAAI,EAAE,CAAC;QACX,GAAG,CAAC,WAAW,GAAG,0BAA0B,CAAC;QAC7C,GAAG,CAAC,SAAS,GAAG,CAAC,CAAC;QAClB,GAAG,CAAC,SAAS,EAAE,CAAC;QAChB,YAAY;QACZ,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,GAAG,QAAQ,CAAC,CAAC;QACjC,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QACtB,GAAG,CAAC,MAAM,CAAC,IAAI,GAAG,QAAQ,EAAE,GAAG,CAAC,CAAC;QACjC,aAAa;QACb,GAAG,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC,GAAG,QAAQ,EAAE,GAAG,CAAC,CAAC;QACrC,GAAG,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;QAC1B,GAAG,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC,EAAE,GAAG,GAAG,QAAQ,CAAC,CAAC;QACrC,gBAAgB;QAChB,GAAG,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,GAAG,QAAQ,CAAC,CAAC;QACzC,GAAG,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC;QAC9B,GAAG,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC,GAAG,QAAQ,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC;QACzC,eAAe;QACf,GAAG,CAAC,MAAM,CAAC,IAAI,GAAG,QAAQ,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC;QACrC,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC;QAC1B,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,GAAG,CAAC,GAAG,QAAQ,CAAC,CAAC;QACrC,GAAG,CAAC,MAAM,EAAE,CAAC;QACb,GAAG,CAAC,OAAO,EAAE,CAAC;IAChB,CAAC;IAEO,WAAW;QACjB,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,OAAO;QAC1B,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QAC1C,IAAI,GAAG;YAAE,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACxE,CAAC;8GAvKU,oBAAoB;kHAApB,oBAAoB,cADP,MAAM;;2FACnB,oBAAoB;kBADhC,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE","sourcesContent":["import { Injectable } from '@angular/core';\n\n/**\n * Collaboration interface the zoom-to-box tool needs from PlotlyService.\n */\nexport interface ZoomToBoxToolHost {\n  /** DOM id of the plot element the overlay canvas attaches to. */\n  getPlotDiv(): string;\n  /**\n   * Convert an overlay-pixel point (relative to the plot element's top-left)\n   * into the backend's data coordinates — Plotly axis data for Plotly,\n   * image-pixel coords for OpenSeadragon. Keeps the tool backend-agnostic.\n   */\n  pixelToData(px: number, py: number): { x: number; y: number };\n  /**\n   * Apply the user-selected zoom rectangle, ordered `[xMin, xMax, yMax, yMin]`.\n   * The host decides what that means: Plotly does a high-def re-fetch / axis\n   * relayout, OpenSeadragon fits the viewport to the image rectangle.\n   */\n  applyZoomToBox(coordinates: number[]): void;\n}\n\n/**\n * Custom canvas overlay for click-and-drag rectangular zoom. Plotly's\n * built-in `dragmode: 'zoom'` works on heatmap/image traces too, but it\n * doesn't drive the high-def zoom pipeline — this overlay does, by handing\n * the selected coordinates back to the host.\n */\n@Injectable({ providedIn: 'root' })\nexport class ZoomToBoxToolService {\n\n  private host!: ZoomToBoxToolHost;\n  private overlay: HTMLCanvasElement | null = null;\n  private startPx: { 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() {\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: ZoomToBoxToolHost) {\n    this.host = host;\n  }\n\n  setMode(active: boolean) {\n    if (active) {\n      this.createOverlay();\n    } else {\n      this.destroyOverlay();\n    }\n  }\n\n  // ── Overlay lifecycle ───────────────────────────────────────────────\n\n  private createOverlay() {\n    const plotEl = document.getElementById(this.host.getPlotDiv());\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.startPx = null;\n  }\n\n  // ── Mouse handlers ──────────────────────────────────────────────────\n\n  private onMouseDown(e: MouseEvent) {\n    const rect = this.overlay!.getBoundingClientRect();\n    this.startPx = { x: e.clientX - rect.left, y: e.clientY - rect.top };\n  }\n\n  private onMouseMove(e: MouseEvent) {\n    if (!this.startPx || !this.overlay) return;\n    const rect = this.overlay.getBoundingClientRect();\n    this.drawSelection(\n      this.startPx.x, this.startPx.y,\n      e.clientX - rect.left, e.clientY - rect.top\n    );\n  }\n\n  private onMouseUp(e: MouseEvent) {\n    if (!this.startPx || !this.overlay) return;\n    const rect = this.overlay.getBoundingClientRect();\n    const endX = e.clientX - rect.left;\n    const endY = e.clientY - rect.top;\n\n    // Ignore tiny drags (accidental clicks).\n    if (Math.abs(endX - this.startPx.x) < 5 || Math.abs(endY - this.startPx.y) < 5) {\n      this.startPx = null;\n      this.clearCanvas();\n      return;\n    }\n\n    // Convert overlay-pixel → data coordinates via the active backend's host.\n    const d0 = this.host.pixelToData(this.startPx.x, this.startPx.y);\n    const d1 = this.host.pixelToData(endX, endY);\n\n    const coordinates = [\n      Math.min(d0.x, d1.x), Math.max(d0.x, d1.x),\n      Math.max(d0.y, d1.y), Math.min(d0.y, d1.y),\n    ];\n\n    this.startPx = null;\n    this.clearCanvas();\n\n    this.host.applyZoomToBox(coordinates);\n  }\n\n  // ── Selection rectangle drawing ─────────────────────────────────────\n\n  private drawSelection(x0: number, y0: number, x1: number, y1: number) {\n    const canvas = this.overlay!;\n    const ctx = canvas.getContext('2d')!;\n\n    const left = Math.min(x0, x1);\n    const top = Math.min(y0, y1);\n    const w = Math.abs(x1 - x0);\n    const h = Math.abs(y1 - y0);\n\n    ctx.clearRect(0, 0, canvas.width, canvas.height);\n\n    // Semi-transparent overlay covering everything outside the selection.\n    ctx.save();\n    ctx.fillStyle = 'rgba(0, 0, 0, 0.35)';\n    ctx.beginPath();\n    // Outer rectangle (full canvas).\n    ctx.rect(0, 0, canvas.width, canvas.height);\n    // Inner rectangle (selection cutout) — wound counter-clockwise to create a hole.\n    ctx.moveTo(left, top);\n    ctx.lineTo(left, top + h);\n    ctx.lineTo(left + w, top + h);\n    ctx.lineTo(left + w, top);\n    ctx.closePath();\n    ctx.fill('evenodd');\n    ctx.restore();\n\n    // Corner notches.\n    const notchLen = Math.min(16, w / 4, h / 4);\n    ctx.save();\n    ctx.strokeStyle = 'rgba(255, 255, 255, 0.9)';\n    ctx.lineWidth = 2;\n    ctx.beginPath();\n    // Top-left.\n    ctx.moveTo(left, top + notchLen);\n    ctx.lineTo(left, top);\n    ctx.lineTo(left + notchLen, top);\n    // Top-right.\n    ctx.moveTo(left + w - notchLen, top);\n    ctx.lineTo(left + w, top);\n    ctx.lineTo(left + w, top + notchLen);\n    // Bottom-right.\n    ctx.moveTo(left + w, top + h - notchLen);\n    ctx.lineTo(left + w, top + h);\n    ctx.lineTo(left + w - notchLen, top + h);\n    // Bottom-left.\n    ctx.moveTo(left + notchLen, top + h);\n    ctx.lineTo(left, top + h);\n    ctx.lineTo(left, top + h - notchLen);\n    ctx.stroke();\n    ctx.restore();\n  }\n\n  private clearCanvas() {\n    if (!this.overlay) return;\n    const ctx = this.overlay.getContext('2d');\n    if (ctx) ctx.clearRect(0, 0, this.overlay.width, this.overlay.height);\n  }\n}\n"]}

package/esm2022/lib/visualization.module.mjs

@@ -0,0 +1,162 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { ToolbarModule } from 'primeng/toolbar';
+import { ButtonModule } from 'primeng/button';
+import { MenuModule } from 'primeng/menu';
+import { DropdownModule } from 'primeng/dropdown';
+import { SliderModule } from 'primeng/slider';
+import { TreeSelectModule } from 'primeng/treeselect';
+import { InputNumberModule } from 'primeng/inputnumber';
+import { DialogModule } from 'primeng/dialog';
+import { ContextMenuModule } from 'primeng/contextmenu';
+import { ProgressBarModule } from 'primeng/progressbar';
+import { ToastModule } from 'primeng/toast';
+import { TooltipModule } from 'primeng/tooltip';
+import { RippleModule } from 'primeng/ripple';
+import { TableModule } from 'primeng/table';
+import { PaginatorModule } from 'primeng/paginator';
+import { OverlayPanelModule } from 'primeng/overlaypanel';
+import { ConfirmDialogModule } from 'primeng/confirmdialog';
+import { InputTextModule } from 'primeng/inputtext';
+import { CheckboxModule } from 'primeng/checkbox';
+import { RadioButtonModule } from 'primeng/radiobutton';
+import { SelectButtonModule } from 'primeng/selectbutton';
+import { VisualizerComponent } from './visualizer.component';
+import { ToolbarComponent } from './toolbar/toolbar.component';
+import { RegionEditorComponent } from './region-editor/region-editor.component';
+import { HexColorPickerComponent } from './hex-color-picker/hex-color-picker.component';
+import { ChannelHistogramComponent } from './channel-histogram/channel-histogram.component';
+import { RoutingVisualizerService } from './routing-visualizer.service';
+import { VISUALIZER } from './contracts/visualizer.contract';
+import { REGION_EDITOR_API } from './contracts/region-editor-api.contract';
+import { CHANNEL_HISTOGRAM_API } from './contracts/channel-histogram-api.contract';
+import * as i0 from "@angular/core";
+/**
+ * Self-contained plotting UI: the {@link VisualizerComponent} (plot surface
+ * + render orchestration), its {@link ToolbarComponent}, and the
+ * {@link RegionEditorComponent} (the Regions tab table/editor). Consumers embed
+ * `<visualizer>` / `<region-editor>` and need know nothing about the toolbar,
+ * the rendering backends, or region file I/O (supplied via the REGION_IO_PORT).
+ *
+ * Also exports {@link HexColorPickerComponent} (`<hex-color-picker>`) as a
+ * standalone reusable picker (`[color]` in, `(colorChange)` out) so consuming
+ * apps can use it on its own, the same way as the visualizer and region editor.
+ */
+export class VisualizationModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: VisualizationModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.9", ngImport: i0, type: VisualizationModule, declarations: [VisualizerComponent,
+            ToolbarComponent,
+            RegionEditorComponent,
+            HexColorPickerComponent,
+            ChannelHistogramComponent], imports: [CommonModule,
+            FormsModule,
+            ToolbarModule,
+            ButtonModule,
+            MenuModule,
+            DropdownModule,
+            SliderModule,
+            TreeSelectModule,
+            InputNumberModule,
+            DialogModule,
+            ContextMenuModule,
+            ProgressBarModule,
+            ToastModule,
+            TooltipModule,
+            RippleModule,
+            TableModule,
+            PaginatorModule,
+            OverlayPanelModule,
+            ConfirmDialogModule,
+            InputTextModule,
+            CheckboxModule,
+            RadioButtonModule,
+            SelectButtonModule], exports: [VisualizerComponent, RegionEditorComponent, HexColorPickerComponent, ChannelHistogramComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: VisualizationModule, providers: [
+            // Internal backend wiring. All three host-facing contracts are served by the
+            // RoutingVisualizerService (the Plotly/OpenSeadragon selector), so consumers
+            // depend only on the tokens and never the concrete router. Owned by the
+            // library so importing VisualizationModule is enough — the host supplies only
+            // the *ports* (IMAGE_STATE_PORT / TILE_ACCESS_PORT / REGION_IO_PORT) and
+            // VIZ_CONFIG, which are app-specific. A consumer needing an isolated instance
+            // (e.g. a modal that mustn't share region/image state) re-provides this same
+            // set at component scope, which shadows these defaults for its subtree.
+            { provide: VISUALIZER, useExisting: RoutingVisualizerService },
+            { provide: REGION_EDITOR_API, useExisting: RoutingVisualizerService },
+            { provide: CHANNEL_HISTOGRAM_API, useExisting: RoutingVisualizerService },
+        ], imports: [CommonModule,
+            FormsModule,
+            ToolbarModule,
+            ButtonModule,
+            MenuModule,
+            DropdownModule,
+            SliderModule,
+            TreeSelectModule,
+            InputNumberModule,
+            DialogModule,
+            ContextMenuModule,
+            ProgressBarModule,
+            ToastModule,
+            TooltipModule,
+            RippleModule,
+            TableModule,
+            PaginatorModule,
+            OverlayPanelModule,
+            ConfirmDialogModule,
+            InputTextModule,
+            CheckboxModule,
+            RadioButtonModule,
+            SelectButtonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: VisualizationModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        VisualizerComponent,
+                        ToolbarComponent,
+                        RegionEditorComponent,
+                        HexColorPickerComponent,
+                        ChannelHistogramComponent,
+                    ],
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        ToolbarModule,
+                        ButtonModule,
+                        MenuModule,
+                        DropdownModule,
+                        SliderModule,
+                        TreeSelectModule,
+                        InputNumberModule,
+                        DialogModule,
+                        ContextMenuModule,
+                        ProgressBarModule,
+                        ToastModule,
+                        TooltipModule,
+                        RippleModule,
+                        TableModule,
+                        PaginatorModule,
+                        OverlayPanelModule,
+                        ConfirmDialogModule,
+                        InputTextModule,
+                        CheckboxModule,
+                        RadioButtonModule,
+                        SelectButtonModule,
+                    ],
+                    exports: [VisualizerComponent, RegionEditorComponent, HexColorPickerComponent, ChannelHistogramComponent],
+                    providers: [
+                        // Internal backend wiring. All three host-facing contracts are served by the
+                        // RoutingVisualizerService (the Plotly/OpenSeadragon selector), so consumers
+                        // depend only on the tokens and never the concrete router. Owned by the
+                        // library so importing VisualizationModule is enough — the host supplies only
+                        // the *ports* (IMAGE_STATE_PORT / TILE_ACCESS_PORT / REGION_IO_PORT) and
+                        // VIZ_CONFIG, which are app-specific. A consumer needing an isolated instance
+                        // (e.g. a modal that mustn't share region/image state) re-provides this same
+                        // set at component scope, which shadows these defaults for its subtree.
+                        { provide: VISUALIZER, useExisting: RoutingVisualizerService },
+                        { provide: REGION_EDITOR_API, useExisting: RoutingVisualizerService },
+                        { provide: CHANNEL_HISTOGRAM_API, useExisting: RoutingVisualizerService },
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"visualization.module.js","sourceRoot":"","sources":["../../../src/lib/visualization.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgModule } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { FormsModule } from '@angular/forms';\n\nimport { ToolbarModule } from 'primeng/toolbar';\nimport { ButtonModule } from 'primeng/button';\nimport { MenuModule } from 'primeng/menu';\nimport { DropdownModule } from 'primeng/dropdown';\nimport { SliderModule } from 'primeng/slider';\nimport { TreeSelectModule } from 'primeng/treeselect';\nimport { InputNumberModule } from 'primeng/inputnumber';\nimport { DialogModule } from 'primeng/dialog';\nimport { ContextMenuModule } from 'primeng/contextmenu';\nimport { ProgressBarModule } from 'primeng/progressbar';\nimport { ToastModule } from 'primeng/toast';\nimport { TooltipModule } from 'primeng/tooltip';\nimport { RippleModule } from 'primeng/ripple';\nimport { TableModule } from 'primeng/table';\nimport { PaginatorModule } from 'primeng/paginator';\nimport { OverlayPanelModule } from 'primeng/overlaypanel';\nimport { ConfirmDialogModule } from 'primeng/confirmdialog';\nimport { InputTextModule } from 'primeng/inputtext';\nimport { CheckboxModule } from 'primeng/checkbox';\nimport { RadioButtonModule } from 'primeng/radiobutton';\nimport { SelectButtonModule } from 'primeng/selectbutton';\n\nimport { VisualizerComponent } from './visualizer.component';\nimport { ToolbarComponent } from './toolbar/toolbar.component';\nimport { RegionEditorComponent } from './region-editor/region-editor.component';\nimport { HexColorPickerComponent } from './hex-color-picker/hex-color-picker.component';\nimport { ChannelHistogramComponent } from './channel-histogram/channel-histogram.component';\nimport { RoutingVisualizerService } from './routing-visualizer.service';\nimport { VISUALIZER } from './contracts/visualizer.contract';\nimport { REGION_EDITOR_API } from './contracts/region-editor-api.contract';\nimport { CHANNEL_HISTOGRAM_API } from './contracts/channel-histogram-api.contract';\n\n/**\n * Self-contained plotting UI: the {@link VisualizerComponent} (plot surface\n * + render orchestration), its {@link ToolbarComponent}, and the\n * {@link RegionEditorComponent} (the Regions tab table/editor). Consumers embed\n * `<visualizer>` / `<region-editor>` and need know nothing about the toolbar,\n * the rendering backends, or region file I/O (supplied via the REGION_IO_PORT).\n *\n * Also exports {@link HexColorPickerComponent} (`<hex-color-picker>`) as a\n * standalone reusable picker (`[color]` in, `(colorChange)` out) so consuming\n * apps can use it on its own, the same way as the visualizer and region editor.\n */\n@NgModule({\n  declarations: [\n    VisualizerComponent,\n    ToolbarComponent,\n    RegionEditorComponent,\n    HexColorPickerComponent,\n    ChannelHistogramComponent,\n  ],\n  imports: [\n    CommonModule,\n    FormsModule,\n    ToolbarModule,\n    ButtonModule,\n    MenuModule,\n    DropdownModule,\n    SliderModule,\n    TreeSelectModule,\n    InputNumberModule,\n    DialogModule,\n    ContextMenuModule,\n    ProgressBarModule,\n    ToastModule,\n    TooltipModule,\n    RippleModule,\n    TableModule,\n    PaginatorModule,\n    OverlayPanelModule,\n    ConfirmDialogModule,\n    InputTextModule,\n    CheckboxModule,\n    RadioButtonModule,\n    SelectButtonModule,\n  ],\n  exports: [VisualizerComponent, RegionEditorComponent, HexColorPickerComponent, ChannelHistogramComponent],\n  providers: [\n    // Internal backend wiring. All three host-facing contracts are served by the\n    // RoutingVisualizerService (the Plotly/OpenSeadragon selector), so consumers\n    // depend only on the tokens and never the concrete router. Owned by the\n    // library so importing VisualizationModule is enough — the host supplies only\n    // the *ports* (IMAGE_STATE_PORT / TILE_ACCESS_PORT / REGION_IO_PORT) and\n    // VIZ_CONFIG, which are app-specific. A consumer needing an isolated instance\n    // (e.g. a modal that mustn't share region/image state) re-provides this same\n    // set at component scope, which shadows these defaults for its subtree.\n    { provide: VISUALIZER, useExisting: RoutingVisualizerService },\n    { provide: REGION_EDITOR_API, useExisting: RoutingVisualizerService },\n    { provide: CHANNEL_HISTOGRAM_API, useExisting: RoutingVisualizerService },\n  ],\n})\nexport class VisualizationModule {}\n"]}