@vitessce/spatial-utils 3.6.11 → 3.6.13

package/dist-tsc/spatial.js

@@ -5,6 +5,7 @@ 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
@@ -440,8 +441,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,
                     ]);
@@ -452,6 +453,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.');
@@ -488,6 +493,9 @@ export function coordinateTransformationsToMatrix(coordinateTransformations, axe
             }
         });
     }
+    if (mat.some(value => Number.isNaN(value))) {
+        throw new Error('Matrix contains NaN values');
+    }
     return mat;
 }
 export function hexToRgb(hex) {
@@ -511,6 +519,12 @@ export function normalizeAxes(axes) {
         return axisInfo;
     });
 }
+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
@@ -531,35 +545,18 @@ 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);
                 }
-                log.warn(`Coordinate transformation type "${type}" is not supported.`);
+                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;
+                }
+                // 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;
@@ -579,3 +576,48 @@ 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);
+}