@vitessce/spatial-utils 3.1.1 → 3.1.3

package/dist/{deflate-e1882774.js → deflate-e2811f40.js}

@@ -1,5 +1,5 @@
 import { i as inflate_1 } from "./pako.esm-68f84e2a.js";
-import { B as BaseDecoder } from "./index-50f2f2d8.js";
+import { B as BaseDecoder } from "./index-e86d2626.js";
 import "react";
 class DeflateDecoder extends BaseDecoder {
   decodeBlock(buffer) {

package/dist/{index-50f2f2d8.js → index-e86d2626.js}

@@ -19770,6 +19770,363 @@ var unit = /* @__PURE__ */ createUnitFunction({
   Unit,
   typed
 });
+function commonjsRequire(path) {
+  throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+}
+var pluralize = { exports: {} };
+(function(module2, exports2) {
+  (function(root2, pluralize2) {
+    if (typeof commonjsRequire === "function" && true && true) {
+      module2.exports = pluralize2();
+    } else {
+      root2.pluralize = pluralize2();
+    }
+  })(commonjsGlobal, function() {
+    var pluralRules = [];
+    var singularRules = [];
+    var uncountables = {};
+    var irregularPlurals = {};
+    var irregularSingles = {};
+    function sanitizeRule(rule) {
+      if (typeof rule === "string") {
+        return new RegExp("^" + rule + "$", "i");
+      }
+      return rule;
+    }
+    function restoreCase(word, token) {
+      if (word === token)
+        return token;
+      if (word === word.toLowerCase())
+        return token.toLowerCase();
+      if (word === word.toUpperCase())
+        return token.toUpperCase();
+      if (word[0] === word[0].toUpperCase()) {
+        return token.charAt(0).toUpperCase() + token.substr(1).toLowerCase();
+      }
+      return token.toLowerCase();
+    }
+    function interpolate2(str, args) {
+      return str.replace(/\$(\d{1,2})/g, function(match, index2) {
+        return args[index2] || "";
+      });
+    }
+    function replace(word, rule) {
+      return word.replace(rule[0], function(match, index2) {
+        var result = interpolate2(rule[1], arguments);
+        if (match === "") {
+          return restoreCase(word[index2 - 1], result);
+        }
+        return restoreCase(match, result);
+      });
+    }
+    function sanitizeWord(token, word, rules) {
+      if (!token.length || uncountables.hasOwnProperty(token)) {
+        return word;
+      }
+      var len2 = rules.length;
+      while (len2--) {
+        var rule = rules[len2];
+        if (rule[0].test(word))
+          return replace(word, rule);
+      }
+      return word;
+    }
+    function replaceWord(replaceMap, keepMap, rules) {
+      return function(word) {
+        var token = word.toLowerCase();
+        if (keepMap.hasOwnProperty(token)) {
+          return restoreCase(word, token);
+        }
+        if (replaceMap.hasOwnProperty(token)) {
+          return restoreCase(word, replaceMap[token]);
+        }
+        return sanitizeWord(token, word, rules);
+      };
+    }
+    function checkWord(replaceMap, keepMap, rules, bool) {
+      return function(word) {
+        var token = word.toLowerCase();
+        if (keepMap.hasOwnProperty(token))
+          return true;
+        if (replaceMap.hasOwnProperty(token))
+          return false;
+        return sanitizeWord(token, token, rules) === token;
+      };
+    }
+    function pluralize2(word, count2, inclusive) {
+      var pluralized = count2 === 1 ? pluralize2.singular(word) : pluralize2.plural(word);
+      return (inclusive ? count2 + " " : "") + pluralized;
+    }
+    pluralize2.plural = replaceWord(
+      irregularSingles,
+      irregularPlurals,
+      pluralRules
+    );
+    pluralize2.isPlural = checkWord(
+      irregularSingles,
+      irregularPlurals,
+      pluralRules
+    );
+    pluralize2.singular = replaceWord(
+      irregularPlurals,
+      irregularSingles,
+      singularRules
+    );
+    pluralize2.isSingular = checkWord(
+      irregularPlurals,
+      irregularSingles,
+      singularRules
+    );
+    pluralize2.addPluralRule = function(rule, replacement) {
+      pluralRules.push([sanitizeRule(rule), replacement]);
+    };
+    pluralize2.addSingularRule = function(rule, replacement) {
+      singularRules.push([sanitizeRule(rule), replacement]);
+    };
+    pluralize2.addUncountableRule = function(word) {
+      if (typeof word === "string") {
+        uncountables[word.toLowerCase()] = true;
+        return;
+      }
+      pluralize2.addPluralRule(word, "$0");
+      pluralize2.addSingularRule(word, "$0");
+    };
+    pluralize2.addIrregularRule = function(single, plural) {
+      plural = plural.toLowerCase();
+      single = single.toLowerCase();
+      irregularSingles[single] = plural;
+      irregularPlurals[plural] = single;
+    };
+    [
+      // Pronouns.
+      ["I", "we"],
+      ["me", "us"],
+      ["he", "they"],
+      ["she", "they"],
+      ["them", "them"],
+      ["myself", "ourselves"],
+      ["yourself", "yourselves"],
+      ["itself", "themselves"],
+      ["herself", "themselves"],
+      ["himself", "themselves"],
+      ["themself", "themselves"],
+      ["is", "are"],
+      ["was", "were"],
+      ["has", "have"],
+      ["this", "these"],
+      ["that", "those"],
+      // Words ending in with a consonant and `o`.
+      ["echo", "echoes"],
+      ["dingo", "dingoes"],
+      ["volcano", "volcanoes"],
+      ["tornado", "tornadoes"],
+      ["torpedo", "torpedoes"],
+      // Ends with `us`.
+      ["genus", "genera"],
+      ["viscus", "viscera"],
+      // Ends with `ma`.
+      ["stigma", "stigmata"],
+      ["stoma", "stomata"],
+      ["dogma", "dogmata"],
+      ["lemma", "lemmata"],
+      ["schema", "schemata"],
+      ["anathema", "anathemata"],
+      // Other irregular rules.
+      ["ox", "oxen"],
+      ["axe", "axes"],
+      ["die", "dice"],
+      ["yes", "yeses"],
+      ["foot", "feet"],
+      ["eave", "eaves"],
+      ["goose", "geese"],
+      ["tooth", "teeth"],
+      ["quiz", "quizzes"],
+      ["human", "humans"],
+      ["proof", "proofs"],
+      ["carve", "carves"],
+      ["valve", "valves"],
+      ["looey", "looies"],
+      ["thief", "thieves"],
+      ["groove", "grooves"],
+      ["pickaxe", "pickaxes"],
+      ["passerby", "passersby"]
+    ].forEach(function(rule) {
+      return pluralize2.addIrregularRule(rule[0], rule[1]);
+    });
+    [
+      [/s?$/i, "s"],
+      [/[^\u0000-\u007F]$/i, "$0"],
+      [/([^aeiou]ese)$/i, "$1"],
+      [/(ax|test)is$/i, "$1es"],
+      [/(alias|[^aou]us|t[lm]as|gas|ris)$/i, "$1es"],
+      [/(e[mn]u)s?$/i, "$1s"],
+      [/([^l]ias|[aeiou]las|[ejzr]as|[iu]am)$/i, "$1"],
+      [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1i"],
+      [/(alumn|alg|vertebr)(?:a|ae)$/i, "$1ae"],
+      [/(seraph|cherub)(?:im)?$/i, "$1im"],
+      [/(her|at|gr)o$/i, "$1oes"],
+      [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|automat|quor)(?:a|um)$/i, "$1a"],
+      [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)(?:a|on)$/i, "$1a"],
+      [/sis$/i, "ses"],
+      [/(?:(kni|wi|li)fe|(ar|l|ea|eo|oa|hoo)f)$/i, "$1$2ves"],
+      [/([^aeiouy]|qu)y$/i, "$1ies"],
+      [/([^ch][ieo][ln])ey$/i, "$1ies"],
+      [/(x|ch|ss|sh|zz)$/i, "$1es"],
+      [/(matr|cod|mur|sil|vert|ind|append)(?:ix|ex)$/i, "$1ices"],
+      [/\b((?:tit)?m|l)(?:ice|ouse)$/i, "$1ice"],
+      [/(pe)(?:rson|ople)$/i, "$1ople"],
+      [/(child)(?:ren)?$/i, "$1ren"],
+      [/eaux$/i, "$0"],
+      [/m[ae]n$/i, "men"],
+      ["thou", "you"]
+    ].forEach(function(rule) {
+      return pluralize2.addPluralRule(rule[0], rule[1]);
+    });
+    [
+      [/s$/i, ""],
+      [/(ss)$/i, "$1"],
+      [/(wi|kni|(?:after|half|high|low|mid|non|night|[^\w]|^)li)ves$/i, "$1fe"],
+      [/(ar|(?:wo|[ae])l|[eo][ao])ves$/i, "$1f"],
+      [/ies$/i, "y"],
+      [/\b([pl]|zomb|(?:neck|cross)?t|coll|faer|food|gen|goon|group|lass|talk|goal|cut)ies$/i, "$1ie"],
+      [/\b(mon|smil)ies$/i, "$1ey"],
+      [/\b((?:tit)?m|l)ice$/i, "$1ouse"],
+      [/(seraph|cherub)im$/i, "$1"],
+      [/(x|ch|ss|sh|zz|tto|go|cho|alias|[^aou]us|t[lm]as|gas|(?:her|at|gr)o|[aeiou]ris)(?:es)?$/i, "$1"],
+      [/(analy|diagno|parenthe|progno|synop|the|empha|cri|ne)(?:sis|ses)$/i, "$1sis"],
+      [/(movie|twelve|abuse|e[mn]u)s$/i, "$1"],
+      [/(test)(?:is|es)$/i, "$1is"],
+      [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1us"],
+      [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|quor)a$/i, "$1um"],
+      [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)a$/i, "$1on"],
+      [/(alumn|alg|vertebr)ae$/i, "$1a"],
+      [/(cod|mur|sil|vert|ind)ices$/i, "$1ex"],
+      [/(matr|append)ices$/i, "$1ix"],
+      [/(pe)(rson|ople)$/i, "$1rson"],
+      [/(child)ren$/i, "$1"],
+      [/(eau)x?$/i, "$1"],
+      [/men$/i, "man"]
+    ].forEach(function(rule) {
+      return pluralize2.addSingularRule(rule[0], rule[1]);
+    });
+    [
+      // Singular words with no plurals.
+      "adulthood",
+      "advice",
+      "agenda",
+      "aid",
+      "aircraft",
+      "alcohol",
+      "ammo",
+      "analytics",
+      "anime",
+      "athletics",
+      "audio",
+      "bison",
+      "blood",
+      "bream",
+      "buffalo",
+      "butter",
+      "carp",
+      "cash",
+      "chassis",
+      "chess",
+      "clothing",
+      "cod",
+      "commerce",
+      "cooperation",
+      "corps",
+      "debris",
+      "diabetes",
+      "digestion",
+      "elk",
+      "energy",
+      "equipment",
+      "excretion",
+      "expertise",
+      "firmware",
+      "flounder",
+      "fun",
+      "gallows",
+      "garbage",
+      "graffiti",
+      "hardware",
+      "headquarters",
+      "health",
+      "herpes",
+      "highjinks",
+      "homework",
+      "housework",
+      "information",
+      "jeans",
+      "justice",
+      "kudos",
+      "labour",
+      "literature",
+      "machinery",
+      "mackerel",
+      "mail",
+      "media",
+      "mews",
+      "moose",
+      "music",
+      "mud",
+      "manga",
+      "news",
+      "only",
+      "personnel",
+      "pike",
+      "plankton",
+      "pliers",
+      "police",
+      "pollution",
+      "premises",
+      "rain",
+      "research",
+      "rice",
+      "salmon",
+      "scissors",
+      "series",
+      "sewage",
+      "shambles",
+      "shrimp",
+      "software",
+      "species",
+      "staff",
+      "swine",
+      "tennis",
+      "traffic",
+      "transportation",
+      "trout",
+      "tuna",
+      "wealth",
+      "welfare",
+      "whiting",
+      "wildebeest",
+      "wildlife",
+      "you",
+      /pok[eé]mon$/i,
+      // Regexes.
+      /[^aeiou]ese$/i,
+      // "chinese", "japanese"
+      /deer$/i,
+      // "deer", "reindeer"
+      /fish$/i,
+      // "fish", "blowfish", "angelfish"
+      /measles$/i,
+      /o[iu]s$/i,
+      // "carnivorous"
+      /pox$/i,
+      // "chickpox", "smallpox"
+      /sheep$/i
+    ].forEach(pluralize2.addUncountableRule);
+    return pluralize2;
+  });
+})(pluralize);
+var pluralizeExports = pluralize.exports;
+const plur = /* @__PURE__ */ getDefaultExportFromCjs(pluralizeExports);
+plur.addPluralRule("glomerulus", "glomeruli");
+plur.addPluralRule("interstitium", "interstitia");
 function fromEntries(iterable) {
   return [...iterable].reduce((obj, { 0: key, 1: val }) => Object.assign(obj, { [key]: val }), {});
 }
@@ -69458,9 +69815,6 @@ class GeoCellLayer extends CompositeLayer {
 }
 _defineProperty$e(GeoCellLayer, "layerName", "GeoCellLayer");
 _defineProperty$e(GeoCellLayer, "defaultProps", defaultProps$t);
-function commonjsRequire(path) {
-  throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
-}
 var long = { exports: {} };
 (function(module2) {
   /**
@@ -132943,16 +133297,16 @@ function addDecoder(cases, importFn) {
   }
   cases.forEach((c) => registry$1.set(c, importFn));
 }
-addDecoder([void 0, 1], () => import("./raw-51c1d779.js").then((m) => m.default));
-addDecoder(5, () => import("./lzw-183b6431.js").then((m) => m.default));
+addDecoder([void 0, 1], () => import("./raw-01deac62.js").then((m) => m.default));
+addDecoder(5, () => import("./lzw-61ae68b2.js").then((m) => m.default));
 addDecoder(6, () => {
   throw new Error("old style JPEG compression is not supported.");
 });
-addDecoder(7, () => import("./jpeg-c95516fd.js").then((m) => m.default));
-addDecoder([8, 32946], () => import("./deflate-e1882774.js").then((m) => m.default));
-addDecoder(32773, () => import("./packbits-b1c7f20d.js").then((m) => m.default));
-addDecoder(34887, () => import("./lerc-c8eb24c6.js").then((m) => m.default));
-addDecoder(50001, () => import("./webimage-54b36ce2.js").then((m) => m.default));
+addDecoder(7, () => import("./jpeg-03b93228.js").then((m) => m.default));
+addDecoder([8, 32946], () => import("./deflate-e2811f40.js").then((m) => m.default));
+addDecoder(32773, () => import("./packbits-b1d8eca2.js").then((m) => m.default));
+addDecoder(34887, () => import("./lerc-d5a641c1.js").then((m) => m.default));
+addDecoder(50001, () => import("./webimage-f6e6dcb0.js").then((m) => m.default));
 function decodeRowAcc(row, stride) {
   let length2 = row.length - stride;
   let offset = 0;
@@ -144121,6 +144475,41 @@ function coordinateTransformationsToMatrix(coordinateTransformations, axes) {
   }
   return mat;
 }
+function normalizeCoordinateTransformations(coordinateTransformations, datasets) {
+  var _a2;
+  let result = [];
+  if (Array.isArray(coordinateTransformations)) {
+    result = coordinateTransformations.map((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 === "identity") {
+          return { type };
+        }
+        console.warn(`Coordinate transformation type "${type}" is not supported.`);
+      }
+      return transform2;
+    });
+  }
+  if (Array.isArray((_a2 = datasets == null ? void 0 : datasets[0]) == null ? void 0 : _a2.coordinateTransformations)) {
+    result = [
+      ...datasets[0].coordinateTransformations,
+      ...result
+    ];
+  }
+  return result;
+}
 export {
   BaseDecoder as B,
   DEFAULT_CELLS_LAYER as D,
@@ -144139,5 +144528,6 @@ export {
   getNgffAxes as l,
   getNgffAxesForTiff as m,
   coordinateTransformationsToMatrix as n,
+  normalizeCoordinateTransformations as o,
   square as s
 };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { D, e, a, b, c, d, G, n, l, m, h, i, f, j, k, s } from "./index-50f2f2d8.js";
+import { D, e, a, b, c, d, G, n, l, m, h, i, f, j, k, o, s } from "./index-e86d2626.js";
 import "react";
 export {
   D as DEFAULT_CELLS_LAYER,
@@ -16,5 +16,6 @@ export {
   f as initializeRasterLayersAndChannels,
   j as isInterleaved,
   k as isRgb,
+  o as normalizeCoordinateTransformations,
   s as square
 };

package/dist/{jpeg-c95516fd.js → jpeg-03b93228.js}

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

package/dist/{lerc-c8eb24c6.js → lerc-d5a641c1.js}

@@ -1,5 +1,5 @@
 import { i as inflate_1 } from "./pako.esm-68f84e2a.js";
-import { g as getDefaultExportFromCjs, B as BaseDecoder } from "./index-50f2f2d8.js";
+import { g as getDefaultExportFromCjs, B as BaseDecoder } from "./index-e86d2626.js";
 import "react";
 const LercParameters = {
   Version: 0,

package/dist/{lzw-183b6431.js → lzw-61ae68b2.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index-50f2f2d8.js";
+import { B as BaseDecoder } from "./index-e86d2626.js";
 import "react";
 const MIN_BITS = 9;
 const CLEAR_CODE = 256;

package/dist/{packbits-b1c7f20d.js → packbits-b1d8eca2.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index-50f2f2d8.js";
+import { B as BaseDecoder } from "./index-e86d2626.js";
 import "react";
 class PackbitsDecoder extends BaseDecoder {
   decodeBlock(buffer) {

package/dist/{raw-51c1d779.js → raw-01deac62.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index-50f2f2d8.js";
+import { B as BaseDecoder } from "./index-e86d2626.js";
 import "react";
 class RawDecoder extends BaseDecoder {
   decodeBlock(buffer) {

package/dist/{webimage-54b36ce2.js → webimage-f6e6dcb0.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index-50f2f2d8.js";
+import { B as BaseDecoder } from "./index-e86d2626.js";
 import "react";
 class WebImageDecoder extends BaseDecoder {
   constructor() {

package/dist-tsc/index.d.ts

@@ -1,2 +1,2 @@
-export { GLOBAL_LABELS, DEFAULT_CELLS_LAYER, DEFAULT_MOLECULES_LAYER, DEFAULT_NEIGHBORHOODS_LAYER, DEFAULT_RASTER_DOMAIN_TYPE, DEFAULT_RASTER_LAYER_PROPS, DEFAULT_LAYER_TYPE_ORDERING, square, initializeLayerChannels, initializeRasterLayersAndChannels, getSourceFromLoader, isInterleaved, isRgb, getNgffAxes, getNgffAxesForTiff, coordinateTransformationsToMatrix } from "./spatial.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, square, initializeLayerChannels, initializeRasterLayersAndChannels, getSourceFromLoader, isInterleaved, isRgb, getNgffAxes, getNgffAxesForTiff, coordinateTransformationsToMatrix, normalizeCoordinateTransformations } from "./spatial.js";
 //# sourceMappingURL=index.d.ts.map

package/dist-tsc/index.js

@@ -1 +1 @@
-export { GLOBAL_LABELS, DEFAULT_CELLS_LAYER, DEFAULT_MOLECULES_LAYER, DEFAULT_NEIGHBORHOODS_LAYER, DEFAULT_RASTER_DOMAIN_TYPE, DEFAULT_RASTER_LAYER_PROPS, DEFAULT_LAYER_TYPE_ORDERING, square, initializeLayerChannels, initializeRasterLayersAndChannels, getSourceFromLoader, isInterleaved, isRgb, getNgffAxes, getNgffAxesForTiff, coordinateTransformationsToMatrix, } from './spatial.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, square, initializeLayerChannels, initializeRasterLayersAndChannels, getSourceFromLoader, isInterleaved, isRgb, getNgffAxes, getNgffAxesForTiff, coordinateTransformationsToMatrix, normalizeCoordinateTransformations, } from './spatial.js';

package/dist-tsc/spatial.d.ts

@@ -51,6 +51,17 @@ export function getNgffAxesForTiff(dimOrder: any): any;
  * @returns {Array<number>} Array of 16 numbers representing the Matrix4.
  */
 export function coordinateTransformationsToMatrix(coordinateTransformations: object[], axes: object[]): Array<number>;
+/**
+ * Normalize coordinate transformations to the OME-NGFF v0.4 format,
+ * despite potentially being in the new format proposed in
+ * https://github.com/ome/ngff/pull/138 (As of 2023-09-02).
+ * @param {object[]|undefined} coordinateTransformations Value of
+ * multiscales[0].coordinateTransformations in either OME-NGFF v0.4 format
+ * or that proposed in https://github.com/ome/ngff/pull/138.
+ * @param {object[]} datasets Value of multiscales[0].datasets in OME-NGFF v0.4 format.
+ * @returns {object[]} Array of coordinateTransformations in OME-NGFF v0.4 format.
+ */
+export function normalizeCoordinateTransformations(coordinateTransformations: object[] | undefined, datasets: object[]): object[];
 export const GLOBAL_LABELS: string[];
 export const DEFAULT_RASTER_DOMAIN_TYPE: "Min/Max";
 export namespace DEFAULT_RASTER_LAYER_PROPS {

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

@@ -1 +1 @@
-{"version":3,"file":"spatial.d.ts","sourceRoot":"","sources":["../src/spatial.js"],"names":[],"mappings":"AAOA,wDAEC;AAiCD;;;;;;GAMG;AACH,4CAJW,MAAM,UACN,MAAM,eACJ,MAAM,CAMlB;AAED;;;;GAIG;AACH,8BAHW,MAAM,YACN,QAAM,IAAI,WAiBpB;AAmHD;;GAEG;AACH,qCAFW,MAAO,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;;;;;;;;GAQG;AACH,6EANW,MAAM,EAAE,QAER,MAAM,EAAE,GAEN,MAAM,MAAM,CAAC,CA4CzB;AAtZD,qCAAwC;AAExC,mDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsBpD,mDAKE"}
+{"version":3,"file":"spatial.d.ts","sourceRoot":"","sources":["../src/spatial.js"],"names":[],"mappings":"AAOA,wDAEC;AAiCD;;;;;;GAMG;AACH,4CAJW,MAAM,UACN,MAAM,eACJ,MAAM,CAMlB;AAED;;;;GAIG;AACH,8BAHW,MAAM,YACN,QAAM,IAAI,WAiBpB;AAmHD;;GAEG;AACH,qCAFW,MAAO,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;;;;;;;;GAQG;AACH,6EANW,MAAM,EAAE,QAER,MAAM,EAAE,GAEN,MAAM,MAAM,CAAC,CA4CzB;AAED;;;;;;;;;GASG;AACH,8EANW,MAAM,EAAE,GAAC,SAAS,YAGlB,MAAM,EAAE,GACN,MAAM,EAAE,CAiDpB;AAjdD,qCAAwC;AAExC,mDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsBpD,mDAKE"}

package/dist-tsc/spatial.js

@@ -373,3 +373,58 @@ export function coordinateTransformationsToMatrix(coordinateTransformations, axe
     }
     return mat;
 }
+/**
+ * Normalize coordinate transformations to the OME-NGFF v0.4 format,
+ * despite potentially being in the new format proposed in
+ * https://github.com/ome/ngff/pull/138 (As of 2023-09-02).
+ * @param {object[]|undefined} coordinateTransformations Value of
+ * multiscales[0].coordinateTransformations in either OME-NGFF v0.4 format
+ * or that proposed in https://github.com/ome/ngff/pull/138.
+ * @param {object[]} datasets Value of multiscales[0].datasets in OME-NGFF v0.4 format.
+ * @returns {object[]} Array of coordinateTransformations in OME-NGFF v0.4 format.
+ */
+export function normalizeCoordinateTransformations(coordinateTransformations, datasets) {
+    // "The transformations in the list are applied sequentially and in order."
+    // Reference: https://ngff.openmicroscopy.org/0.4/index.html#trafo-md
+    let result = [];
+    if (Array.isArray(coordinateTransformations)) {
+        result = coordinateTransformations.map((transform) => {
+            if (transform.input && transform.output) {
+                // 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 === 'identity') {
+                    return { type };
+                }
+                console.warn(`Coordinate transformation type "${type}" is not supported.`);
+            }
+            // Assume it was already an old-style (NGFF v0.4) coordinate transformation.
+            return transform;
+        });
+    }
+    if (Array.isArray(datasets?.[0]?.coordinateTransformations)) {
+        // "Datasets SHOULD define a transformation from array space
+        // to their "native physical space."
+        // This transformation SHOULD describe physical pixel spacing
+        // and origin only, and therefore SHOULD consist of
+        // `scale` and/or `translation` types only.""
+        // Reference: https://github.com/ome/ngff/blob/b92f540dc95440f2d6b7012185b09c2b862aa744/latest/transform-details.bs#L99
+        result = [
+            ...datasets[0].coordinateTransformations,
+            ...result,
+        ];
+    }
+    return result;
+}

package/dist-tsc/spatial.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { square, coordinateTransformationsToMatrix } from './spatial.js';
+import { square, coordinateTransformationsToMatrix, normalizeCoordinateTransformations, } from './spatial.js';
 const defaultAxes = [
     { type: 'time', name: 't' },
     { type: 'channel', name: 'c' },
@@ -41,4 +41,159 @@ describe('Spatial.js', () => {
             ]);
         });
     });
+    describe('normalizeCoordinateTransformations', () => {
+        it('does nothing for OME-NGFF v0.4 input', () => {
+            const datasets = [
+                {
+                    coordinateTransformations: [
+                        {
+                            scale: [
+                                1,
+                                0.5002025531914894,
+                                0.3603981534640209,
+                                0.3603981534640209,
+                            ],
+                            type: 'scale',
+                        },
+                    ],
+                    path: '0',
+                },
+                {
+                    coordinateTransformations: [
+                        {
+                            scale: [
+                                1,
+                                0.5002025531914894,
+                                0.7207963069280418,
+                                0.7207963069280418,
+                            ],
+                            type: 'scale',
+                        },
+                    ],
+                    path: '1',
+                },
+                {
+                    coordinateTransformations: [
+                        {
+                            scale: [
+                                1,
+                                0.5002025531914894,
+                                1.4415926138560835,
+                                1.4415926138560835,
+                            ],
+                            type: 'scale',
+                        },
+                    ],
+                    path: '2',
+                },
+            ];
+            expect(normalizeCoordinateTransformations(undefined, datasets)).toEqual([
+                // Here, we expect only the first dataset to be used.
+                // However, we should eventually support transforms
+                // specified for each dataset individually,
+                // since there could in theory be irregular ways of downsampling.
+                {
+                    scale: [
+                        1,
+                        0.5002025531914894,
+                        0.3603981534640209,
+                        0.3603981534640209,
+                    ],
+                    type: 'scale',
+                },
+            ]);
+        });
+        it('transforms SpatialData input', () => {
+            const newCoordinateTransformations = [
+                {
+                    input: {
+                        axes: [
+                            {
+                                name: 'c',
+                                type: 'channel',
+                            },
+                            {
+                                name: 'y',
+                                type: 'space',
+                                unit: 'unit',
+                            },
+                            {
+                                name: 'x',
+                                type: 'space',
+                                unit: 'unit',
+                            },
+                        ],
+                        name: 'cyx',
+                    },
+                    output: {
+                        axes: [
+                            {
+                                name: 'c',
+                                type: 'channel',
+                            },
+                            {
+                                name: 'y',
+                                type: 'space',
+                                unit: 'unit',
+                            },
+                            {
+                                name: 'x',
+                                type: 'space',
+                                unit: 'unit',
+                            },
+                        ],
+                        name: 'ST8059048',
+                    },
+                    scale: [
+                        1.0,
+                        8.670500183814605,
+                        8.670500183814605,
+                    ],
+                    type: 'scale',
+                },
+            ];
+            const datasets = [
+                {
+                    coordinateTransformations: [
+                        {
+                            scale: [
+                                1.0,
+                                1.0,
+                                1.0,
+                            ],
+                            type: 'scale',
+                        },
+                    ],
+                    path: '0',
+                },
+            ];
+            expect(normalizeCoordinateTransformations(newCoordinateTransformations, datasets)).toEqual([
+                // Here, we expect only the first dataset to be used.
+                // However, we should eventually support transforms
+                // specified for each dataset individually,
+                // since there could in theory be irregular ways of downsampling.
+                {
+                    scale: [
+                        1.0,
+                        1.0,
+                        1.0,
+                    ],
+                    type: 'scale',
+                },
+                // We expect the dataset transform to be prepended
+                // to the newCoordinateTransformations items.
+                // We do not check the input/output coordinate systems, but we should eventually allow
+                // the user to specify this somehow and use that information to filter which transforms
+                // are included here.
+                {
+                    scale: [
+                        1.0,
+                        8.670500183814605,
+                        8.670500183814605,
+                    ],
+                    type: 'scale',
+                },
+            ]);
+        });
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vitessce/spatial-utils",
-  "version": "3.1.1",
+  "version": "3.1.3",
   "author": "Gehlenborg Lab",
   "homepage": "http://vitessce.io",
   "repository": {
@@ -19,8 +19,8 @@
     "lodash-es": "^4.17.21",
     "math.gl": "^3.5.6",
     "mathjs": "^9.2.0",
-    "@vitessce/gl": "3.1.1",
-    "@vitessce/utils": "3.1.1"
+    "@vitessce/gl": "3.1.3",
+    "@vitessce/utils": "3.1.3"
   },
   "scripts": {
     "bundle": "pnpm exec vite build -c ../../../scripts/vite.config.js",

package/src/index.js

@@ -15,4 +15,5 @@ export {
   getNgffAxes,
   getNgffAxesForTiff,
   coordinateTransformationsToMatrix,
+  normalizeCoordinateTransformations,
 } from './spatial.js';

package/src/spatial.js

@@ -416,3 +416,62 @@ export function coordinateTransformationsToMatrix(coordinateTransformations, axe
   }
   return mat;
 }
+
+/**
+ * Normalize coordinate transformations to the OME-NGFF v0.4 format,
+ * despite potentially being in the new format proposed in
+ * https://github.com/ome/ngff/pull/138 (As of 2023-09-02).
+ * @param {object[]|undefined} coordinateTransformations Value of
+ * multiscales[0].coordinateTransformations in either OME-NGFF v0.4 format
+ * or that proposed in https://github.com/ome/ngff/pull/138.
+ * @param {object[]} datasets Value of multiscales[0].datasets in OME-NGFF v0.4 format.
+ * @returns {object[]} Array of coordinateTransformations in OME-NGFF v0.4 format.
+ */
+export function normalizeCoordinateTransformations(coordinateTransformations, datasets) {
+  // "The transformations in the list are applied sequentially and in order."
+  // Reference: https://ngff.openmicroscopy.org/0.4/index.html#trafo-md
+  let result = [];
+
+  if (Array.isArray(coordinateTransformations)) {
+    result = coordinateTransformations.map((transform) => {
+      if (transform.input && transform.output) {
+        // 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 === 'identity') {
+          return { type };
+        }
+        console.warn(`Coordinate transformation type "${type}" is not supported.`);
+      }
+      // Assume it was already an old-style (NGFF v0.4) coordinate transformation.
+      return transform;
+    });
+  }
+
+  if (Array.isArray(datasets?.[0]?.coordinateTransformations)) {
+    // "Datasets SHOULD define a transformation from array space
+    // to their "native physical space."
+    // This transformation SHOULD describe physical pixel spacing
+    // and origin only, and therefore SHOULD consist of
+    // `scale` and/or `translation` types only.""
+    // Reference: https://github.com/ome/ngff/blob/b92f540dc95440f2d6b7012185b09c2b862aa744/latest/transform-details.bs#L99
+
+    result = [
+      ...datasets[0].coordinateTransformations,
+      ...result,
+    ];
+  }
+  return result;
+}

package/src/spatial.test.js

@@ -1,5 +1,9 @@
 import { describe, it, expect } from 'vitest';
-import { square, coordinateTransformationsToMatrix } from './spatial.js';
+import {
+  square,
+  coordinateTransformationsToMatrix,
+  normalizeCoordinateTransformations,
+} from './spatial.js';
 
 const defaultAxes = [
   { type: 'time', name: 't' },
@@ -43,4 +47,159 @@ describe('Spatial.js', () => {
       ]);
     });
   });
+  describe('normalizeCoordinateTransformations', () => {
+    it('does nothing for OME-NGFF v0.4 input', () => {
+      const datasets = [
+        {
+          coordinateTransformations: [
+            {
+              scale: [
+                1,
+                0.5002025531914894,
+                0.3603981534640209,
+                0.3603981534640209,
+              ],
+              type: 'scale',
+            },
+          ],
+          path: '0',
+        },
+        {
+          coordinateTransformations: [
+            {
+              scale: [
+                1,
+                0.5002025531914894,
+                0.7207963069280418,
+                0.7207963069280418,
+              ],
+              type: 'scale',
+            },
+          ],
+          path: '1',
+        },
+        {
+          coordinateTransformations: [
+            {
+              scale: [
+                1,
+                0.5002025531914894,
+                1.4415926138560835,
+                1.4415926138560835,
+              ],
+              type: 'scale',
+            },
+          ],
+          path: '2',
+        },
+      ];
+      expect(normalizeCoordinateTransformations(undefined, datasets)).toEqual([
+        // Here, we expect only the first dataset to be used.
+        // However, we should eventually support transforms
+        // specified for each dataset individually,
+        // since there could in theory be irregular ways of downsampling.
+        {
+          scale: [
+            1,
+            0.5002025531914894,
+            0.3603981534640209,
+            0.3603981534640209,
+          ],
+          type: 'scale',
+        },
+      ]);
+    });
+    it('transforms SpatialData input', () => {
+      const newCoordinateTransformations = [
+        {
+          input: {
+            axes: [
+              {
+                name: 'c',
+                type: 'channel',
+              },
+              {
+                name: 'y',
+                type: 'space',
+                unit: 'unit',
+              },
+              {
+                name: 'x',
+                type: 'space',
+                unit: 'unit',
+              },
+            ],
+            name: 'cyx',
+          },
+          output: {
+            axes: [
+              {
+                name: 'c',
+                type: 'channel',
+              },
+              {
+                name: 'y',
+                type: 'space',
+                unit: 'unit',
+              },
+              {
+                name: 'x',
+                type: 'space',
+                unit: 'unit',
+              },
+            ],
+            name: 'ST8059048',
+          },
+          scale: [
+            1.0,
+            8.670500183814605,
+            8.670500183814605,
+          ],
+          type: 'scale',
+        },
+      ];
+      const datasets = [
+        {
+          coordinateTransformations: [
+            {
+              scale: [
+                1.0,
+                1.0,
+                1.0,
+              ],
+              type: 'scale',
+            },
+          ],
+          path: '0',
+        },
+      ];
+      expect(normalizeCoordinateTransformations(newCoordinateTransformations, datasets)).toEqual([
+        // Here, we expect only the first dataset to be used.
+        // However, we should eventually support transforms
+        // specified for each dataset individually,
+        // since there could in theory be irregular ways of downsampling.
+        {
+          scale: [
+            1.0,
+            1.0,
+            1.0,
+          ],
+          type: 'scale',
+        },
+        // We expect the dataset transform to be prepended
+        // to the newCoordinateTransformations items.
+        // We do not check the input/output coordinate systems, but we should eventually allow
+        // the user to specify this somehow and use that information to filter which transforms
+        // are included here.
+        {
+          scale: [
+            1.0,
+            8.670500183814605,
+            8.670500183814605,
+          ],
+          type: 'scale',
+        },
+      ]);
+    });
+  });
 });