@vitessce/spatial-utils 3.6.11 → 3.6.12

package/src/dag.test.js

@@ -0,0 +1,34 @@
+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/src/index.js

@@ -16,6 +16,7 @@ export {
   getNgffAxes,
   getNgffAxesForTiff,
   coordinateTransformationsToMatrix,
+  coordinateTransformationsToMatrixForSpatialData,
   physicalSizeToMatrix,
   hexToRgb,
   getStatsForResolution,

package/src/spatial.js

@@ -5,6 +5,8 @@ import { VIEWER_PALETTE } from '@vitessce/utils';
 import { GLOBAL_LABELS, DEFAULT_RASTER_LAYER_PROPS } from '@vitessce/constants-internal';
 import { log } from '@vitessce/globals';
 import { getMultiSelectionStats } from './layer-controller.js';
+import { DAG } from './dag.js';
+
 /**
  * Get a representative PixelSource from a loader object returned from
  * the Vitessce imaging loaders
@@ -494,8 +496,8 @@ export function coordinateTransformationsToMatrix(coordinateTransformations, axe
           }
         } else if (spatialOutputAxes.length === 2) { // 2D case
           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, 0,
             0, 0, 0, 1,
           ]);
@@ -507,6 +509,10 @@ export function coordinateTransformationsToMatrix(coordinateTransformations, axe
             const swapMat = (new Matrix4()).fromArray(swapMatNested.flat());
             mat = mat.multiplyLeft(swapMat);
           }
+          // TODO: is the transpose needed? why?
+          // TODO: is transpose only needed when axis-swapping?
+          // TODO: is it also needed in the 3D case? Why was it not needed before?
+          mat = mat.transpose();
         } else {
           throw new Error('Affine transformation must have 2 or 3 rows.');
         }
@@ -548,6 +554,9 @@ export function coordinateTransformationsToMatrix(coordinateTransformations, axe
       }
     });
   }
+  if (mat.some(value => Number.isNaN(value))) {
+    throw new Error('Matrix contains NaN values');
+  }
   return mat;
 }
 
@@ -575,6 +584,14 @@ export function normalizeAxes(axes) {
   });
 }
 
+export function getIntrinsicCoordinateSystem(normAxes) {
+  // Get the intrinsic coordinate system from the axes.
+  // TODO: is this correct?
+  // See https://github.com/scverse/spatialdata/pull/963
+  return normAxes.map(axis => axis.name).join('');
+}
+
+
 /**
  * Normalize coordinate transformations to the OME-NGFF v0.4 format,
  * despite potentially being in the new format proposed in
@@ -596,36 +613,17 @@ export function normalizeCoordinateTransformations(coordinateTransformations, da
         // This is a new-style coordinate transformation.
         // (As proposed in https://github.com/ome/ngff/pull/138)
         const { type } = transform;
-        if (type === 'translation') {
-          return {
-            type,
-            translation: transform.translation,
-          };
-        }
-        if (type === 'scale') {
-          return {
-            type,
-            scale: transform.scale,
-          };
-        }
-        if (type === 'affine') {
-          return {
-            type,
-            affine: transform.affine,
-            // Affine transformations can potentially swap axes,
-            // so we need to include the input and output axes.
-            input: transform.input,
-            output: transform.output,
-          };
-        }
-        if (type === 'identity') {
-          return { type };
-        }
         if (type === 'sequence') {
-          return normalizeCoordinateTransformations(transform.transformations, datasets);
+          // Recursion to flatten the sequence of transformations.
+          return normalizeCoordinateTransformations(transform.transformations, null);
+        } if (type === 'affine' || type === 'translation' || type === 'scale' || type === 'identity') {
+          // TODO: normalize the transform.input/transform.output if they are missing?
+          // Old transformations did not specify them for translation/scale/identity.
+          // But we are currently only using them for affine.
+          return transform;
         }
-
-        log.warn(`Coordinate transformation type "${type}" is not supported.`);
+        // If the type is not recognized, log an error.
+        log.error(`Coordinate transformation type "${type}" is not supported.`);
       }
       // Assume it was already an old-style (NGFF v0.4) coordinate transformation.
       return transform;
@@ -647,3 +645,60 @@ export function normalizeCoordinateTransformations(coordinateTransformations, da
   }
   return result;
 }
+
+/**
+ * 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, targetCoordinateSystem,
+) {
+  const {
+    datasets,
+    coordinateTransformations,
+    axes,
+  } = ngffMetadata; // In the image/labels case, this is multiscales[0].
+
+  // In case axes is an array of strings like ['x', 'y', 'z'],
+  // we convert them to a consistent object format.
+  const normAxes = normalizeAxes(axes);
+  // We know the target coordinate system, but not yet the starting (intrinsic) one.
+  const intrinsicCoordinateSystem = getIntrinsicCoordinateSystem(normAxes);
+  // Create a DAG of coordinate transformations.
+  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) {
+    // For example, this can be the case if the targetCoordinateSystem
+    // is "global" but the set of coordinate transformations does not
+    // include one with output.name "global".
+    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);
+  // Normalize the coordinate transformations to OME-NGFF v0.4 format.
+  const normalizedTransformations = normalizeCoordinateTransformations(
+    filteredTransformations, datasets,
+  );
+  // Convert the coordinate transformations to a 4x4 matrix.
+  return coordinateTransformationsToMatrix(normalizedTransformations, normAxes);
+}