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

package/esm2022/lib/implementations/osd/osd-coordinate-transform.mjs

@@ -0,0 +1,25 @@
+import { elementToImage, imageToElement } from './osd-coords';
+/**
+ * OpenSeadragon implementation of {@link ICoordinateTransform}. "Data coords"
+ * here are image-pixel coordinates (OSD's native shape space), obtained from the
+ * viewport API. This is the reason the tools can run over OSD at all: the
+ * viewport gives a clean screen<->image mapping that holds across pan/zoom.
+ */
+export class OsdCoordinateTransform {
+    constructor(viewer) {
+        this.viewer = viewer;
+    }
+    isReady() {
+        return !!this.viewer?.viewport && this.viewer.world?.getItemCount() > 0;
+    }
+    clientToData(clientX, clientY) {
+        const rect = this.viewer.canvas.getBoundingClientRect();
+        return elementToImage(this.viewer, clientX - rect.left, clientY - rect.top);
+    }
+    dataLengthToScreen(dataLength) {
+        const a = imageToElement(this.viewer, 0, 0);
+        const b = imageToElement(this.viewer, dataLength, 0);
+        return Math.abs(b.x - a.x);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/implementations/osd/osd-coords.mjs

@@ -0,0 +1,53 @@
+import { OSD } from './osd-lib';
+/**
+ * Coordinate conversions between screen (viewer-element) pixels, the OSD viewport,
+ * and image (data) pixels.
+ *
+ * With the stack-slice cache the world holds several tiled images at once, which
+ * makes the `Viewport.*` image conversions ambiguous — OpenSeadragon logs
+ * "not accurate with multi-image; use TiledImage.* instead". All slices share the
+ * same dimensions and placement, so we route the image<->viewport step through a
+ * single reference tiled image (world item 0) and keep the viewport<->element
+ * step on the viewport (which is unambiguous). Falls back to the viewport methods
+ * when the world is empty.
+ */
+const osd = OSD;
+/** Reference tiled image for image<->viewport conversions (any slice works since
+ *  they share geometry). */
+function refItem(viewer) {
+    return viewer?.world?.getItemCount?.() > 0 ? viewer.world.getItemAt(0) : null;
+}
+/** Viewer-element pixel -> image (data) coordinates. */
+export function elementToImage(viewer, x, y) {
+    const vp = viewer.viewport;
+    const pt = new osd.Point(x, y);
+    const item = refItem(viewer);
+    const img = item
+        ? item.viewportToImageCoordinates(vp.viewerElementToViewportCoordinates(pt))
+        : vp.viewerElementToImageCoordinates(pt);
+    return { x: img.x, y: img.y };
+}
+/** Image (data) coordinates -> viewer-element pixel point. */
+export function imageToElement(viewer, x, y) {
+    const vp = viewer.viewport;
+    const pt = new osd.Point(x, y);
+    const item = refItem(viewer);
+    const p = item
+        ? vp.viewportToViewerElementCoordinates(item.imageToViewportCoordinates(pt))
+        : vp.imageToViewerElementCoordinates(pt);
+    return { x: p.x, y: p.y };
+}
+/** Image-space rectangle -> viewport rectangle (for fitBounds). */
+export function imageRectToViewport(viewer, x, y, w, h) {
+    const rect = new osd.Rect(x, y, w, h);
+    const item = refItem(viewer);
+    return item ? item.imageToViewportRectangle(rect) : viewer.viewport.imageToViewportRectangle(rect);
+}
+/** Viewport rectangle -> image (data) rectangle. Routes through world item 0 so
+ *  it stays accurate when the world holds multiple images (stack slices /
+ *  per-channel layers); falls back to the viewport when the world is empty. */
+export function viewportRectToImage(viewer, vpRect) {
+    const item = refItem(viewer);
+    return item ? item.viewportToImageRectangle(vpRect) : viewer.viewport.viewportToImageRectangle(vpRect);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/implementations/osd/osd-lib.mjs

@@ -0,0 +1,20 @@
+import * as OpenSeadragon from 'openseadragon';
+/**
+ * The real OpenSeadragon object, normalized for the packaged (FESM) build.
+ *
+ * OpenSeadragon ships as plain CommonJS (`module.exports = OpenSeadragon`, no
+ * `__esModule` flag). Bundled into this library's FESM and re-bundled by a
+ * consuming app, `import * as OpenSeadragon` resolves to a synthesized ES
+ * namespace whose only reliable slot is `.default` (the real `module.exports`).
+ * The factory itself and every static member (Viewer, Point, Rect, TileSource, …)
+ * live on that object, NOT on the namespace — so `OpenSeadragon(...)` or
+ * `new OpenSeadragon.Point()` against the namespace fail once packaged
+ * ("is not a function" / "not a constructor"). Normalize ONCE here and import
+ * { OSD } wherever a runtime VALUE is needed; import the `openseadragon` namespace
+ * directly only for its TYPES (e.g. `OpenSeadragon.Viewer`).
+ *
+ * (plotly.js-dist-min needs no equivalent: it sets `__esModule`, so webpack gives
+ * it real named exports and plain member access works.)
+ */
+export const OSD = OpenSeadragon.default ?? OpenSeadragon;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3NkLWxpYi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9saWIvaW1wbGVtZW50YXRpb25zL29zZC9vc2QtbGliLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxhQUFhLE1BQU0sZUFBZSxDQUFDO0FBRS9DOzs7Ozs7Ozs7Ozs7Ozs7O0dBZ0JHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sR0FBRyxHQUNiLGFBQXFCLENBQUMsT0FBTyxJQUFJLGFBQWEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIE9wZW5TZWFkcmFnb24gZnJvbSAnb3BlbnNlYWRyYWdvbic7XG5cbi8qKlxuICogVGhlIHJlYWwgT3BlblNlYWRyYWdvbiBvYmplY3QsIG5vcm1hbGl6ZWQgZm9yIHRoZSBwYWNrYWdlZCAoRkVTTSkgYnVpbGQuXG4gKlxuICogT3BlblNlYWRyYWdvbiBzaGlwcyBhcyBwbGFpbiBDb21tb25KUyAoYG1vZHVsZS5leHBvcnRzID0gT3BlblNlYWRyYWdvbmAsIG5vXG4gKiBgX19lc01vZHVsZWAgZmxhZykuIEJ1bmRsZWQgaW50byB0aGlzIGxpYnJhcnkncyBGRVNNIGFuZCByZS1idW5kbGVkIGJ5IGFcbiAqIGNvbnN1bWluZyBhcHAsIGBpbXBvcnQgKiBhcyBPcGVuU2VhZHJhZ29uYCByZXNvbHZlcyB0byBhIHN5bnRoZXNpemVkIEVTXG4gKiBuYW1lc3BhY2Ugd2hvc2Ugb25seSByZWxpYWJsZSBzbG90IGlzIGAuZGVmYXVsdGAgKHRoZSByZWFsIGBtb2R1bGUuZXhwb3J0c2ApLlxuICogVGhlIGZhY3RvcnkgaXRzZWxmIGFuZCBldmVyeSBzdGF0aWMgbWVtYmVyIChWaWV3ZXIsIFBvaW50LCBSZWN0LCBUaWxlU291cmNlLCDigKYpXG4gKiBsaXZlIG9uIHRoYXQgb2JqZWN0LCBOT1Qgb24gdGhlIG5hbWVzcGFjZSDigJQgc28gYE9wZW5TZWFkcmFnb24oLi4uKWAgb3JcbiAqIGBuZXcgT3BlblNlYWRyYWdvbi5Qb2ludCgpYCBhZ2FpbnN0IHRoZSBuYW1lc3BhY2UgZmFpbCBvbmNlIHBhY2thZ2VkXG4gKiAoXCJpcyBub3QgYSBmdW5jdGlvblwiIC8gXCJub3QgYSBjb25zdHJ1Y3RvclwiKS4gTm9ybWFsaXplIE9OQ0UgaGVyZSBhbmQgaW1wb3J0XG4gKiB7IE9TRCB9IHdoZXJldmVyIGEgcnVudGltZSBWQUxVRSBpcyBuZWVkZWQ7IGltcG9ydCB0aGUgYG9wZW5zZWFkcmFnb25gIG5hbWVzcGFjZVxuICogZGlyZWN0bHkgb25seSBmb3IgaXRzIFRZUEVTIChlLmcuIGBPcGVuU2VhZHJhZ29uLlZpZXdlcmApLlxuICpcbiAqIChwbG90bHkuanMtZGlzdC1taW4gbmVlZHMgbm8gZXF1aXZhbGVudDogaXQgc2V0cyBgX19lc01vZHVsZWAsIHNvIHdlYnBhY2sgZ2l2ZXNcbiAqIGl0IHJlYWwgbmFtZWQgZXhwb3J0cyBhbmQgcGxhaW4gbWVtYmVyIGFjY2VzcyB3b3Jrcy4pXG4gKi9cbmV4cG9ydCBjb25zdCBPU0Q6IHR5cGVvZiBPcGVuU2VhZHJhZ29uID1cbiAgKE9wZW5TZWFkcmFnb24gYXMgYW55KS5kZWZhdWx0ID8/IE9wZW5TZWFkcmFnb247XG4iXX0=