@vitessce/spatial-utils 3.6.11 → 3.6.13

package/dist/{deflate-CBbIkiez.js → deflate-TxuAgoYJ.js}

@@ -1,5 +1,5 @@
 import { i as inflate_1 } from "./pako.esm-SxljTded.js";
-import { B as BaseDecoder } from "./index-SrBFQLfa.js";
+import { B as BaseDecoder } from "./index-B7UQn9SL.js";
 class DeflateDecoder extends BaseDecoder {
   decodeBlock(buffer) {
     return inflate_1(new Uint8Array(buffer)).buffer;

package/dist/{index-SrBFQLfa.js → index-B7UQn9SL.js}

@@ -120366,22 +120366,22 @@ function addDecoder(cases, importFn) {
   }
   cases.forEach((c) => registry$2.set(c, importFn));
 }
-addDecoder([void 0, 1], () => import("./raw-C8msAWCy.js").then((m) => m.default));
-addDecoder(5, () => import("./lzw-m-7_MlEr.js").then((m) => m.default));
+addDecoder([void 0, 1], () => import("./raw-NP8gx4mT.js").then((m) => m.default));
+addDecoder(5, () => import("./lzw-CEZtZPvs.js").then((m) => m.default));
 addDecoder(6, () => {
   throw new Error("old style JPEG compression is not supported.");
 });
-addDecoder(7, () => import("./jpeg-CPDP-GQ7.js").then((m) => m.default));
-addDecoder([8, 32946], () => import("./deflate-CBbIkiez.js").then((m) => m.default));
-addDecoder(32773, () => import("./packbits-D2Yz8IY3.js").then((m) => m.default));
+addDecoder(7, () => import("./jpeg-C55SiNtf.js").then((m) => m.default));
+addDecoder([8, 32946], () => import("./deflate-TxuAgoYJ.js").then((m) => m.default));
+addDecoder(32773, () => import("./packbits-BDxIgeb9.js").then((m) => m.default));
 addDecoder(
   34887,
-  () => import("./lerc-DqLmboAn.js").then(async (m) => {
+  () => import("./lerc-cC8m0WBJ.js").then(async (m) => {
     await m.zstd.init();
     return m;
   }).then((m) => m.default)
 );
-addDecoder(50001, () => import("./webimage-CBuzuQEe.js").then((m) => m.default));
+addDecoder(50001, () => import("./webimage-BMtq3qgy.js").then((m) => m.default));
 function decodeRowAcc(row, stride) {
   let length2 = row.length - stride;
   let offset = 0;
@@ -137721,6 +137721,101 @@ function abbreviateNumber(value) {
   if (naive.length <= maxLength) return naive;
   return value.toExponential(0);
 }
+class InternMap extends Map {
+  constructor(entries, key = keyof) {
+    super();
+    Object.defineProperties(this, { _intern: { value: /* @__PURE__ */ new Map() }, _key: { value: key } });
+    if (entries != null) for (const [key2, value] of entries) this.set(key2, value);
+  }
+  get(key) {
+    return super.get(intern_get(this, key));
+  }
+  has(key) {
+    return super.has(intern_get(this, key));
+  }
+  set(key, value) {
+    return super.set(intern_set(this, key), value);
+  }
+  delete(key) {
+    return super.delete(intern_delete(this, key));
+  }
+}
+function intern_get({ _intern, _key }, value) {
+  const key = _key(value);
+  return _intern.has(key) ? _intern.get(key) : value;
+}
+function intern_set({ _intern, _key }, value) {
+  const key = _key(value);
+  if (_intern.has(key)) return _intern.get(key);
+  _intern.set(key, value);
+  return value;
+}
+function intern_delete({ _intern, _key }, value) {
+  const key = _key(value);
+  if (_intern.has(key)) {
+    value = _intern.get(key);
+    _intern.delete(key);
+  }
+  return value;
+}
+function keyof(value) {
+  return value !== null && typeof value === "object" ? value.valueOf() : value;
+}
+class DAG {
+  /**
+     * DAG constructor.
+     * @param {{ from: string, to: string, attributes: any}[]} edges
+     */
+  constructor(edges) {
+    this.graph = /* @__PURE__ */ new Map();
+    this.edgeData = new InternMap([], JSON.stringify);
+    edges.forEach((edge) => {
+      const { from, to } = edge;
+      if (!this.graph.has(from)) {
+        this.graph.set(from, []);
+      }
+      this.graph.get(from).push(to);
+      this.edgeData.set([from, to], edge.attributes);
+    });
+  }
+  /**
+   * Find a path from start to end using DFS.
+   * @param {string} start
+   * @param {string} end
+   * @returns {{ from: string, to: string, attributes: any }[] | null} Returns
+   * the path as an array of edges or null if no path exists.
+   */
+  findPath(start, end) {
+    const path = [];
+    const visited = /* @__PURE__ */ new Set();
+    const dfs = (node2) => {
+      if (node2 === end) {
+        return true;
+      }
+      visited.add(node2);
+      const neighbors = this.graph.get(node2) || [];
+      for (const neighbor of neighbors) {
+        if (!visited.has(neighbor)) {
+          path.push([node2, neighbor]);
+          if (dfs(neighbor)) {
+            return true;
+          }
+          path.pop();
+        }
+      }
+      return false;
+    };
+    const found = dfs(start);
+    if (found) {
+      return path.map(([from, to]) => ({
+        from,
+        to,
+        attributes: this.edgeData.get([from, to])
+      }));
+    }
+    return null;
+  }
+}
 function getSourceFromLoader(loader, level) {
   const { data } = loader;
   const source = Array.isArray(data) ? data[level || data.length - 1] : data;
@@ -138049,8 +138144,14 @@ function coordinateTransformationsToMatrix(coordinateTransformations, axes) {
           }
         } else if (spatialOutputAxes.length === 2) {
           const nextMat = new Matrix4().fromArray([
-            ...filteredAffine[0],
-            ...filteredAffine[1],
+            filteredAffine[0][0],
+            filteredAffine[0][1],
+            0,
+            filteredAffine[0][2],
+            filteredAffine[1][0],
+            filteredAffine[1][1],
+            0,
+            filteredAffine[1][2],
             0,
             0,
             1,
@@ -138066,6 +138167,7 @@ function coordinateTransformationsToMatrix(coordinateTransformations, axes) {
             const swapMat = new Matrix4().fromArray(swapMatNested.flat());
             mat = mat.multiplyLeft(swapMat);
           }
+          mat = mat.transpose();
         } else {
           throw new Error("Affine transformation must have 2 or 3 rows.");
         }
@@ -138092,6 +138194,9 @@ function coordinateTransformationsToMatrix(coordinateTransformations, axes) {
       }
     });
   }
+  if (mat.some((value) => Number.isNaN(value))) {
+    throw new Error("Matrix contains NaN values");
+  }
   return mat;
 }
 function hexToRgb(hex) {
@@ -138110,6 +138215,9 @@ function normalizeAxes(axes) {
     return axisInfo;
   });
 }
+function getIntrinsicCoordinateSystem(normAxes) {
+  return normAxes.map((axis) => axis.name).join("");
+}
 function normalizeCoordinateTransformations(coordinateTransformations, datasets) {
   var _a3;
   let result = [];
@@ -138117,35 +138225,13 @@ function normalizeCoordinateTransformations(coordinateTransformations, datasets)
     result = coordinateTransformations.flatMap((transform2) => {
       if (transform2.input && transform2.output) {
         const { type } = transform2;
-        if (type === "translation") {
-          return {
-            type,
-            translation: transform2.translation
-          };
-        }
-        if (type === "scale") {
-          return {
-            type,
-            scale: transform2.scale
-          };
-        }
-        if (type === "affine") {
-          return {
-            type,
-            affine: transform2.affine,
-            // Affine transformations can potentially swap axes,
-            // so we need to include the input and output axes.
-            input: transform2.input,
-            output: transform2.output
-          };
-        }
-        if (type === "identity") {
-          return { type };
-        }
         if (type === "sequence") {
-          return normalizeCoordinateTransformations(transform2.transformations, datasets);
+          return normalizeCoordinateTransformations(transform2.transformations, null);
         }
-        log$5.warn(`Coordinate transformation type "${type}" is not supported.`);
+        if (type === "affine" || type === "translation" || type === "scale" || type === "identity") {
+          return transform2;
+        }
+        log$5.error(`Coordinate transformation type "${type}" is not supported.`);
       }
       return transform2;
     });
@@ -138158,6 +138244,36 @@ function normalizeCoordinateTransformations(coordinateTransformations, datasets)
   }
   return result;
 }
+function coordinateTransformationsToMatrixForSpatialData(ngffMetadata, targetCoordinateSystem) {
+  const {
+    datasets,
+    coordinateTransformations,
+    axes
+  } = ngffMetadata;
+  const normAxes = normalizeAxes(axes);
+  const intrinsicCoordinateSystem = getIntrinsicCoordinateSystem(normAxes);
+  const edges = coordinateTransformations.map((ct) => ({
+    from: ct.input.name,
+    to: ct.output.name,
+    attributes: ct
+  }));
+  const dag = new DAG(edges);
+  const ctPath = dag.findPath(intrinsicCoordinateSystem, targetCoordinateSystem);
+  if (!ctPath) {
+    if (!coordinateTransformations.find(
+      (ct) => ct.output.name === targetCoordinateSystem
+    )) {
+      throw new Error(`No coordinate transformation found with output.name "${targetCoordinateSystem}".`);
+    }
+    throw new Error(`No path found from "${intrinsicCoordinateSystem}" to "${targetCoordinateSystem}".`);
+  }
+  const filteredTransformations = ctPath.map((ctEdge) => ctEdge.attributes);
+  const normalizedTransformations = normalizeCoordinateTransformations(
+    filteredTransformations,
+    datasets
+  );
+  return coordinateTransformationsToMatrix(normalizedTransformations, normAxes);
+}
 class NodeNotFoundError extends Error {
   constructor(context, options = {}) {
     super(`Node not found: ${context}`, options);
@@ -139741,13 +139857,14 @@ function getDomains() {
 }
 const DOMAINS = getDomains();
 export {
-  getBoundingCube as A,
+  getPhysicalSizeScalingMatrix as A,
   BaseDecoder as B,
-  abbreviateNumber as C,
+  getBoundingCube as C,
   DEFAULT_CELLS_LAYER as D,
-  filterSelection as E,
-  DOMAINS as F,
+  abbreviateNumber as E,
+  filterSelection as F,
   GLOBAL_LABELS as G,
+  DOMAINS as H,
   ZarritaPixelSource as Z,
   DEFAULT_MOLECULES_LAYER as a,
   DEFAULT_NEIGHBORHOODS_LAYER as b,
@@ -139763,16 +139880,16 @@ export {
   getNgffAxes as l,
   getNgffAxesForTiff as m,
   coordinateTransformationsToMatrix as n,
-  hexToRgb as o,
+  coordinateTransformationsToMatrixForSpatialData as o,
   physicalSizeToMatrix as p,
-  getStatsForResolution as q,
-  canLoadResolution as r,
-  normalizeCoordinateTransformations as s,
-  normalizeAxes as t,
-  loadOmeZarr as u,
-  guessTileSize as v,
-  toRgbUIString as w,
-  getSingleSelectionStats as x,
-  getMultiSelectionStats as y,
-  getPhysicalSizeScalingMatrix as z
+  hexToRgb as q,
+  getStatsForResolution as r,
+  canLoadResolution as s,
+  normalizeCoordinateTransformations as t,
+  normalizeAxes as u,
+  loadOmeZarr as v,
+  guessTileSize as w,
+  toRgbUIString as x,
+  getSingleSelectionStats as y,
+  getMultiSelectionStats as z
 };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { D, e, a, b, c, d, F, G, Z, C, r, n, E, A, y, l, m, z, x, h, q, v, o, i, f, j, k, u, t, s, p, w } from "./index-SrBFQLfa.js";
+import { D, e, a, b, c, d, H, G, Z, E, s, n, o, F, C, z, l, m, A, y, h, r, w, q, i, f, j, k, v, u, t, p, x } from "./index-B7UQn9SL.js";
 export {
   D as DEFAULT_CELLS_LAYER,
   e as DEFAULT_LAYER_TYPE_ORDERING,
@@ -6,30 +6,31 @@ export {
   b as DEFAULT_NEIGHBORHOODS_LAYER,
   c as DEFAULT_RASTER_DOMAIN_TYPE,
   d as DEFAULT_RASTER_LAYER_PROPS,
-  F as DOMAINS,
+  H as DOMAINS,
   G as GLOBAL_LABELS,
   Z as ZarritaPixelSource,
-  C as abbreviateNumber,
-  r as canLoadResolution,
+  E as abbreviateNumber,
+  s as canLoadResolution,
   n as coordinateTransformationsToMatrix,
-  E as filterSelection,
-  A as getBoundingCube,
-  y as getMultiSelectionStats,
+  o as coordinateTransformationsToMatrixForSpatialData,
+  F as filterSelection,
+  C as getBoundingCube,
+  z as getMultiSelectionStats,
   l as getNgffAxes,
   m as getNgffAxesForTiff,
-  z as getPhysicalSizeScalingMatrix,
-  x as getSingleSelectionStats,
+  A as getPhysicalSizeScalingMatrix,
+  y as getSingleSelectionStats,
   h as getSourceFromLoader,
-  q as getStatsForResolution,
-  v as guessTileSize,
-  o as hexToRgb,
+  r as getStatsForResolution,
+  w as guessTileSize,
+  q as hexToRgb,
   i as initializeLayerChannels,
   f as initializeRasterLayersAndChannels,
   j as isInterleaved,
   k as isRgb,
-  u as loadOmeZarr,
-  t as normalizeAxes,
-  s as normalizeCoordinateTransformations,
+  v as loadOmeZarr,
+  u as normalizeAxes,
+  t as normalizeCoordinateTransformations,
   p as physicalSizeToMatrix,
-  w as toRgbUIString
+  x as toRgbUIString
 };

package/dist/{jpeg-CPDP-GQ7.js → jpeg-C55SiNtf.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index-SrBFQLfa.js";
+import { B as BaseDecoder } from "./index-B7UQn9SL.js";
 const dctZigZag = new Int32Array([
   0,
   1,

package/dist/{lerc-DqLmboAn.js → lerc-cC8m0WBJ.js}

@@ -1,5 +1,5 @@
 import { i as inflate_1 } from "./pako.esm-SxljTded.js";
-import { g as getDefaultExportFromCjs, B as BaseDecoder } from "./index-SrBFQLfa.js";
+import { g as getDefaultExportFromCjs, B as BaseDecoder } from "./index-B7UQn9SL.js";
 const LercParameters = {
   AddCompression: 1
 };

package/dist/{lzw-m-7_MlEr.js → lzw-CEZtZPvs.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index-SrBFQLfa.js";
+import { B as BaseDecoder } from "./index-B7UQn9SL.js";
 const MIN_BITS = 9;
 const CLEAR_CODE = 256;
 const EOI_CODE = 257;

package/dist/{packbits-D2Yz8IY3.js → packbits-BDxIgeb9.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index-SrBFQLfa.js";
+import { B as BaseDecoder } from "./index-B7UQn9SL.js";
 class PackbitsDecoder extends BaseDecoder {
   decodeBlock(buffer) {
     const dataView = new DataView(buffer);

package/dist/{raw-C8msAWCy.js → raw-NP8gx4mT.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index-SrBFQLfa.js";
+import { B as BaseDecoder } from "./index-B7UQn9SL.js";
 class RawDecoder extends BaseDecoder {
   decodeBlock(buffer) {
     return buffer;

package/dist/{webimage-CBuzuQEe.js → webimage-BMtq3qgy.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index-SrBFQLfa.js";
+import { B as BaseDecoder } from "./index-B7UQn9SL.js";
 class WebImageDecoder extends BaseDecoder {
   constructor() {
     super();

package/dist-tsc/dag.d.ts

@@ -0,0 +1,35 @@
+export class DAG {
+    /**
+       * DAG constructor.
+       * @param {{ from: string, to: string, attributes: any}[]} edges
+       */
+    constructor(edges: {
+        from: string;
+        to: string;
+        attributes: any;
+    }[]);
+    /**
+     * Adjacency list representation of the DAG.
+     * Maps each input to an array of outputs.
+     * @type {Map<string, string[]>}
+     */
+    graph: Map<string, string[]>;
+    /**
+     * Mapping from [from, to] pairs to edge data.
+     * @type {InternMap<[string, string], any>}
+     */
+    edgeData: InternMap<[string, string], any>;
+    /**
+     * Find a path from start to end using DFS.
+     * @param {string} start
+     * @param {string} end
+     * @returns {{ from: string, to: string, attributes: any }[] | null} Returns
+     * the path as an array of edges or null if no path exists.
+     */
+    findPath(start: string, end: string): {
+        from: string;
+        to: string;
+        attributes: any;
+    }[] | null;
+}
+//# sourceMappingURL=dag.d.ts.map

package/dist-tsc/dag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dag.d.ts","sourceRoot":"","sources":["../src/dag.js"],"names":[],"mappings":"AAMA;IACE;;;SAGK;IACL,mBAFa;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,GAAG,CAAA;KAAC,EAAE,EAwB1D;IArBC;;;;OAIG;IACH,OAFU,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAET;IACtB;;;OAGG;IACH,UAFU,SAAS,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,CAAC,CAEO;IAanD;;;;;;OAMG;IACH,gBALW,MAAM,OACN,MAAM,GACJ;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,GAAG,CAAA;KAAE,EAAE,GAAG,IAAI,CA0ClE;CACF"}

package/dist-tsc/dag.js

@@ -0,0 +1,75 @@
+import { InternMap } from 'internmap';
+// Simple DAG class, with minimum functionality:
+// to find a path from targetInput-to-targetOutput.
+// Edges can have arbitrary attributes.
+export class DAG {
+    /**
+       * DAG constructor.
+       * @param {{ from: string, to: string, attributes: any}[]} edges
+       */
+    constructor(edges) {
+        /**
+         * Adjacency list representation of the DAG.
+         * Maps each input to an array of outputs.
+         * @type {Map<string, string[]>}
+         */
+        this.graph = new Map();
+        /**
+         * Mapping from [from, to] pairs to edge data.
+         * @type {InternMap<[string, string], any>}
+         */
+        this.edgeData = new InternMap([], JSON.stringify);
+        // Build adjacency list
+        edges.forEach((edge) => {
+            const { from, to } = edge;
+            if (!this.graph.has(from)) {
+                this.graph.set(from, []);
+            }
+            this.graph.get(from).push(to);
+            this.edgeData.set([from, to], edge.attributes);
+        });
+    }
+    /**
+     * Find a path from start to end using DFS.
+     * @param {string} start
+     * @param {string} end
+     * @returns {{ from: string, to: string, attributes: any }[] | null} Returns
+     * the path as an array of edges or null if no path exists.
+     */
+    findPath(start, end) {
+        const path = [];
+        const visited = new Set();
+        // Depth-first search (DFS) to find a path from start to end.
+        const dfs = (node) => {
+            if (node === end) {
+                return true;
+            }
+            visited.add(node);
+            const neighbors = this.graph.get(node) || [];
+            // Do not use forEach to allow early exit (returning).
+            // eslint-disable-next-line no-restricted-syntax
+            for (const neighbor of neighbors) {
+                if (!visited.has(neighbor)) {
+                    path.push([node, neighbor]);
+                    if (dfs(neighbor)) {
+                        return true;
+                    }
+                    path.pop(); // backtrack
+                }
+            }
+            return false;
+        };
+        // Start DFS from the start node.
+        const found = dfs(start);
+        if (found) {
+            // Convert path to a list of edge objects with info
+            return path.map(([from, to]) => ({
+                from,
+                to,
+                attributes: this.edgeData.get([from, to]),
+            }));
+        }
+        // If no path is found, return null.
+        return null;
+    }
+}

package/dist-tsc/dag.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dag.test.d.ts.map

package/dist-tsc/dag.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dag.test.d.ts","sourceRoot":"","sources":["../src/dag.test.js"],"names":[],"mappings":""}

package/dist-tsc/dag.test.js

@@ -0,0 +1,29 @@
+import { describe, it, expect } from 'vitest';
+import { DAG } from './dag.js';
+describe('DAG', () => {
+    describe('findPath', () => {
+        it('Can find a path from start to end.', () => {
+            // Example usage:
+            const edges = [
+                { from: 'A', to: 'B', attributes: { some_key: 'a_to_b' } },
+                { from: 'B', to: 'C', attributes: { some_key: 'b_to_c', hello: 'world' } },
+                { from: 'A', to: 'D', attributes: { some_key: 'a_to_d' } },
+                { from: 'D', to: 'E', attributes: { some_key: 'd_to_e' } },
+                { from: 'E', to: 'C', attributes: { some_key: 'e_to_c' } },
+            ];
+            const dag = new DAG(edges);
+            const path = dag.findPath('A', 'C');
+            expect(path).toEqual([
+                { from: 'A', to: 'B', attributes: { some_key: 'a_to_b' } },
+                { from: 'B', to: 'C', attributes: { some_key: 'b_to_c', hello: 'world' } },
+            ]);
+            const path2 = dag.findPath('D', 'C');
+            expect(path2).toEqual([
+                { from: 'D', to: 'E', attributes: { some_key: 'd_to_e' } },
+                { from: 'E', to: 'C', attributes: { some_key: 'e_to_c' } },
+            ]);
+            const path3 = dag.findPath('D', 'B');
+            expect(path3).toEqual(null);
+        });
+    });
+});

package/dist-tsc/index.d.ts

@@ -1,6 +1,6 @@
 export { DOMAINS } from "./constants.js";
 export { GLOBAL_LABELS, DEFAULT_CELLS_LAYER, DEFAULT_MOLECULES_LAYER, DEFAULT_NEIGHBORHOODS_LAYER, DEFAULT_RASTER_DOMAIN_TYPE, DEFAULT_RASTER_LAYER_PROPS, DEFAULT_LAYER_TYPE_ORDERING } from "@vitessce/constants-internal";
-export { initializeLayerChannels, initializeRasterLayersAndChannels, getSourceFromLoader, isInterleaved, isRgb, getNgffAxes, getNgffAxesForTiff, coordinateTransformationsToMatrix, physicalSizeToMatrix, hexToRgb, getStatsForResolution, canLoadResolution, normalizeCoordinateTransformations, normalizeAxes } from "./spatial.js";
+export { initializeLayerChannels, initializeRasterLayersAndChannels, getSourceFromLoader, isInterleaved, isRgb, getNgffAxes, getNgffAxesForTiff, coordinateTransformationsToMatrix, coordinateTransformationsToMatrixForSpatialData, physicalSizeToMatrix, hexToRgb, getStatsForResolution, canLoadResolution, normalizeCoordinateTransformations, normalizeAxes } from "./spatial.js";
 export { loadOmeZarr, guessTileSize, ZarritaPixelSource } from "./load-ome-zarr.js";
 export { toRgbUIString, getSingleSelectionStats, getMultiSelectionStats, getPhysicalSizeScalingMatrix, getBoundingCube, abbreviateNumber, filterSelection } from "./layer-controller.js";
 //# sourceMappingURL=index.d.ts.map

package/dist-tsc/index.js

@@ -1,5 +1,5 @@
 export { GLOBAL_LABELS, DEFAULT_CELLS_LAYER, DEFAULT_MOLECULES_LAYER, DEFAULT_NEIGHBORHOODS_LAYER, DEFAULT_RASTER_DOMAIN_TYPE, DEFAULT_RASTER_LAYER_PROPS, DEFAULT_LAYER_TYPE_ORDERING, } from '@vitessce/constants-internal';
-export { initializeLayerChannels, initializeRasterLayersAndChannels, getSourceFromLoader, isInterleaved, isRgb, getNgffAxes, getNgffAxesForTiff, coordinateTransformationsToMatrix, physicalSizeToMatrix, hexToRgb, getStatsForResolution, canLoadResolution, normalizeCoordinateTransformations, normalizeAxes, } from './spatial.js';
+export { initializeLayerChannels, initializeRasterLayersAndChannels, getSourceFromLoader, isInterleaved, isRgb, getNgffAxes, getNgffAxesForTiff, coordinateTransformationsToMatrix, coordinateTransformationsToMatrixForSpatialData, physicalSizeToMatrix, hexToRgb, getStatsForResolution, canLoadResolution, normalizeCoordinateTransformations, normalizeAxes, } from './spatial.js';
 export { loadOmeZarr, guessTileSize, ZarritaPixelSource, } from './load-ome-zarr.js';
 export { toRgbUIString, getSingleSelectionStats, getMultiSelectionStats, getPhysicalSizeScalingMatrix, getBoundingCube, abbreviateNumber, filterSelection, } from './layer-controller.js';
 export { DOMAINS, } from './constants.js';

package/dist-tsc/spatial.d.ts

@@ -61,6 +61,7 @@ export function getSwapAxesMatrix(inputAxes: ("x" | "y" | "z")[], outputAxes: ("
 export function coordinateTransformationsToMatrix(coordinateTransformations: object[] | undefined, axes: object[] | undefined): Matrix4;
 export function hexToRgb(hex: any): number[];
 export function normalizeAxes(axes: any): any;
+export function getIntrinsicCoordinateSystem(normAxes: any): any;
 /**
  * Normalize coordinate transformations to the OME-NGFF v0.4 format,
  * despite potentially being in the new format proposed in
@@ -72,6 +73,30 @@ export function normalizeAxes(axes: any): any;
  * @returns {object[]} Array of coordinateTransformations in OME-NGFF v0.4 format.
  */
 export function normalizeCoordinateTransformations(coordinateTransformations: object[] | undefined, datasets: object[]): object[];
+/**
+ * Convert coordinate transformations to a 4x4 matrix for SpatialData
+ * spatial elements. This function is intended to be used with SpatialData
+ * objects which have named coordinate systems. This function should
+ * be compatible with any SpatialElement (shapes, points, labels, images).
+ * @param {{
+ *  axe?: (string[]|{ name: string, type?: string, unit?: string }[]),
+ *  coordinateTransformations?: object[],
+ *  datasets?: object[]
+ * }} ngffMetadata For images/labels, this is multiscales[0] from .zattrs.
+ * For shapes/points, this is { axes, coordinateTransformations } from .zattrs.
+ * @param {string} targetCoordinateSystem A target coordinate system name.
+ * @returns {Matrix4} A 4x4 transformation matrix.
+ * This can later be multiplied with other matrices if needed.
+ */
+export function coordinateTransformationsToMatrixForSpatialData(ngffMetadata: {
+    axe?: (string[] | {
+        name: string;
+        type?: string;
+        unit?: string;
+    }[]);
+    coordinateTransformations?: object[];
+    datasets?: object[];
+}, targetCoordinateSystem: string): Matrix4;
 export function getStatsForResolution(loader: any, resolution: any): {
     height: any;
     width: any;

package/dist-tsc/spatial.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spatial.d.ts","sourceRoot":"","sources":["../src/spatial.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,4CAJW,MAAM,SACN,MAAM,GAAG,SAAS,GAChB,MAAM,CAMlB;AAoCD;;;;GAIG;AACH,8BAHW,MAAM,YACN,KAAK,GAAC,IAAI,WAiBpB;AAID,sHAmCC;AAiHD;;GAEG;AACH,qCAFW,KAAK,CAAE,MAAM,CAAC,WAKxB;AAED;;;;;;GAMG;AACH,gDALW,MAAM,eAEJ,MAAM,EAAE,CAuCpB;AAED;;;;;;;;;GASG;AACH,gEAJW,MAAM,EAAE,sBAER,CAAC,MAAM,EAAE,GAAC,IAAI,CAAC,+CAuEzB;AASD;;;IAuBC;AAED,uDAQC;AAED;;;;;;GAMG;AACH,6CAJW,CAAC,GAAG,GAAC,GAAG,GAAC,GAAG,CAAC,EAAE,cACf,CAAC,GAAG,GAAC,GAAG,GAAC,GAAG,CAAC,EAAE,GACd,MAAM,EAAE,EAAE,CA6BrB;AAED;;;;;;;;GAQG;AACH,6EANW,MAAM,EAAE,GAAC,SAAS,QAElB,MAAM,EAAE,GAAC,SAAS,GAEhB,OAAO,CA0GnB;AAED,6CAOC;AAMD,8CASC;AAED;;;;;;;;;GASG;AACH,8EANW,MAAM,EAAE,GAAC,SAAS,YAGlB,MAAM,EAAE,GACN,MAAM,EAAE,CA+DpB;AApnBM;;;;;EAYN;AAEM,yEAkBN;wBAnDuB,SAAS"}
+{"version":3,"file":"spatial.d.ts","sourceRoot":"","sources":["../src/spatial.js"],"names":[],"mappings":"AASA;;;;;;GAMG;AACH,4CAJW,MAAM,SACN,MAAM,GAAG,SAAS,GAChB,MAAM,CAMlB;AAoCD;;;;GAIG;AACH,8BAHW,MAAM,YACN,KAAK,GAAC,IAAI,WAiBpB;AAID,sHAmCC;AAiHD;;GAEG;AACH,qCAFW,KAAK,CAAE,MAAM,CAAC,WAKxB;AAED;;;;;;GAMG;AACH,gDALW,MAAM,eAEJ,MAAM,EAAE,CAuCpB;AAED;;;;;;;;;GASG;AACH,gEAJW,MAAM,EAAE,sBAER,CAAC,MAAM,EAAE,GAAC,IAAI,CAAC,+CAuEzB;AASD;;;IAuBC;AAED,uDAQC;AAED;;;;;;GAMG;AACH,6CAJW,CAAC,GAAG,GAAC,GAAG,GAAC,GAAG,CAAC,EAAE,cACf,CAAC,GAAG,GAAC,GAAG,GAAC,GAAG,CAAC,EAAE,GACd,MAAM,EAAE,EAAE,CA6BrB;AAED;;;;;;;;GAQG;AACH,6EANW,MAAM,EAAE,GAAC,SAAS,QAElB,MAAM,EAAE,GAAC,SAAS,GAEhB,OAAO,CAiHnB;AAED,6CAOC;AAMD,8CASC;AAED,iEAKC;AAGD;;;;;;;;;GASG;AACH,8EANW,MAAM,EAAE,GAAC,SAAS,YAGlB,MAAM,EAAE,GACN,MAAM,EAAE,CA4CpB;AAED;;;;;;;;;;;;;;GAcG;AACH,8EAVW;IACV,GAAM,CAAC,EAAE,CAAC,MAAM,EAAE,GAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC,CAAC;IACrE,yBAA4B,CAAC,EAAE,MAAM,EAAE,CAAC;IACxC,QAAW,CAAC,EAAE,MAAM,EAAE,CAAA;CACnB,0BAEO,MAAM,GACJ,OAAO,CA2CnB;AAzqBM;;;;;EAYN;AAEM,yEAkBN;wBArDuB,SAAS"}