@loaders.gl/geotiff 4.0.0-beta.2 → 4.0.0-beta.3

package/dist/index.cjs

@@ -0,0 +1,398 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  TiffPixelSource: () => tiff_pixel_source_default,
+  loadGeoTiff: () => loadGeoTiff
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/lib/load-geotiff.ts
+var import_geotiff = require("geotiff");
+
+// src/lib/utils/proxies.ts
+var VIV_PROXY_KEY = "__viv";
+var OFFSETS_PROXY_KEY = `${VIV_PROXY_KEY}-offsets`;
+var POOL_PROXY_KEY = `${VIV_PROXY_KEY}-decoder-pool`;
+function checkProxies(tiff) {
+  if (!isProxy(tiff, OFFSETS_PROXY_KEY)) {
+    console.warn("GeoTIFF source is missing offsets proxy.");
+  }
+  if (!isProxy(tiff, POOL_PROXY_KEY)) {
+    console.warn("GeoTIFF source is missing decoder-pool proxy.");
+  }
+}
+function isProxy(tiff, proxyFlag) {
+  return tiff[proxyFlag];
+}
+function createOffsetsProxy(tiff, offsets) {
+  const get = (target, key) => {
+    if (key === "getImage") {
+      return (index) => {
+        if (!(index in target.ifdRequests) && index in offsets) {
+          const offset = offsets[index];
+          target.ifdRequests[index] = target.parseFileDirectoryAt(offset);
+        }
+        return target.getImage(index);
+      };
+    }
+    if (key === OFFSETS_PROXY_KEY) {
+      return true;
+    }
+    return Reflect.get(target, key);
+  };
+  return new Proxy(tiff, { get });
+}
+
+// src/lib/utils/tiff-utils.ts
+function ensureArray(x) {
+  return Array.isArray(x) ? x : [x];
+}
+function intToRgba(int) {
+  if (!Number.isInteger(int)) {
+    throw Error("Not an integer.");
+  }
+  const buffer = new ArrayBuffer(4);
+  const view = new DataView(buffer);
+  view.setInt32(0, int, false);
+  const bytes = new Uint8Array(buffer);
+  return Array.from(bytes);
+}
+function isInterleaved(shape) {
+  const lastDimSize = shape[shape.length - 1];
+  return lastDimSize === 3 || lastDimSize === 4;
+}
+function getImageSize(source) {
+  const interleaved = isInterleaved(source.shape);
+  const [height, width] = source.shape.slice(interleaved ? -3 : -2);
+  return { height, width };
+}
+var SIGNAL_ABORTED = "__vivSignalAborted";
+
+// src/lib/tiff-pixel-source.ts
+var TiffPixelSource = class {
+  // eslint-disable-next-line max-params
+  constructor(indexer, dtype, tileSize, shape, labels, meta) {
+    this._indexer = indexer;
+    this.dtype = dtype;
+    this.tileSize = tileSize;
+    this.shape = shape;
+    this.labels = labels;
+    this.meta = meta;
+  }
+  async getRaster({ selection, signal }) {
+    const image = await this._indexer(selection);
+    return this._readRasters(image, { signal });
+  }
+  async getTile({ x, y, selection, signal }) {
+    const { height, width } = this._getTileExtent(x, y);
+    const x0 = x * this.tileSize;
+    const y0 = y * this.tileSize;
+    const window = [x0, y0, x0 + width, y0 + height];
+    const image = await this._indexer(selection);
+    return this._readRasters(image, { window, width, height, signal });
+  }
+  async _readRasters(image, props) {
+    var _a;
+    const interleave = isInterleaved(this.shape);
+    const raster = await image.readRasters({ interleave, ...props });
+    if ((_a = props == null ? void 0 : props.signal) == null ? void 0 : _a.aborted) {
+      throw SIGNAL_ABORTED;
+    }
+    const data = interleave ? raster : raster[0];
+    return {
+      data,
+      width: raster.width,
+      height: raster.height
+    };
+  }
+  /*
+   * Computes tile size given x, y coord.
+   */
+  _getTileExtent(x, y) {
+    const { height: zoomLevelHeight, width: zoomLevelWidth } = getImageSize(this);
+    let height = this.tileSize;
+    let width = this.tileSize;
+    const maxXTileCoord = Math.floor(zoomLevelWidth / this.tileSize);
+    const maxYTileCoord = Math.floor(zoomLevelHeight / this.tileSize);
+    if (x === maxXTileCoord) {
+      width = zoomLevelWidth % this.tileSize;
+    }
+    if (y === maxYTileCoord) {
+      height = zoomLevelHeight % this.tileSize;
+    }
+    return { height, width };
+  }
+  onTileError(err) {
+    console.error(err);
+  }
+};
+var tiff_pixel_source_default = TiffPixelSource;
+
+// src/lib/ome/ome-indexers.ts
+function getOmeLegacyIndexer(tiff, rootMeta) {
+  const imgMeta = rootMeta[0];
+  const { SizeT, SizeC, SizeZ } = imgMeta.Pixels;
+  const ifdIndexer = getOmeIFDIndexer(imgMeta);
+  return (sel, pyramidLevel) => {
+    const index = ifdIndexer(sel);
+    const pyramidIndex = pyramidLevel * SizeZ * SizeT * SizeC;
+    return tiff.getImage(index + pyramidIndex);
+  };
+}
+function getOmeSubIFDIndexer(tiff, rootMeta) {
+  const imgMeta = rootMeta[0];
+  const ifdIndexer = getOmeIFDIndexer(imgMeta);
+  const ifdCache = /* @__PURE__ */ new Map();
+  return async (sel, pyramidLevel) => {
+    const index = ifdIndexer(sel);
+    const baseImage = await tiff.getImage(index);
+    if (pyramidLevel === 0) {
+      return baseImage;
+    }
+    const { SubIFDs } = baseImage.fileDirectory;
+    if (!SubIFDs) {
+      throw Error("Indexing Error: OME-TIFF is missing SubIFDs.");
+    }
+    const key = `${sel.t}-${sel.c}-${sel.z}-${pyramidLevel}`;
+    if (!ifdCache.has(key)) {
+      const subIfdOffset = SubIFDs[pyramidLevel - 1];
+      ifdCache.set(key, tiff.parseFileDirectoryAt(subIfdOffset));
+    }
+    const ifd = await ifdCache.get(key);
+    return new baseImage.constructor(
+      ifd.fileDirectory,
+      ifd.geoKeyDirectory,
+      tiff.dataView,
+      tiff.littleEndian,
+      tiff.cache,
+      tiff.source
+    );
+  };
+}
+function getOmeIFDIndexer(imgMeta) {
+  const { SizeC, SizeZ, SizeT, DimensionOrder } = imgMeta.Pixels;
+  switch (DimensionOrder) {
+    case "XYZCT": {
+      return ({ t, c, z }) => t * SizeZ * SizeC + c * SizeZ + z;
+    }
+    case "XYZTC": {
+      return ({ t, c, z }) => c * SizeZ * SizeT + t * SizeZ + z;
+    }
+    case "XYCTZ": {
+      return ({ t, c, z }) => z * SizeC * SizeT + t * SizeC + c;
+    }
+    case "XYCZT": {
+      return ({ t, c, z }) => t * SizeC * SizeZ + z * SizeC + c;
+    }
+    case "XYTCZ": {
+      return ({ t, c, z }) => z * SizeT * SizeC + c * SizeT + t;
+    }
+    case "XYTZC": {
+      return ({ t, c, z }) => c * SizeT * SizeZ + z * SizeT + t;
+    }
+    default: {
+      throw new Error(`Invalid OME-XML DimensionOrder, got ${DimensionOrder}.`);
+    }
+  }
+}
+
+// src/lib/ome/utils.ts
+function getLabels(dimOrder) {
+  return dimOrder.toLowerCase().split("").reverse();
+}
+function getDims(labels) {
+  const lookup = new Map(labels.map((name, i) => [name, i]));
+  if (lookup.size !== labels.length) {
+    throw Error("Labels must be unique, found duplicated label.");
+  }
+  return (name) => {
+    const index = lookup.get(name);
+    if (index === void 0) {
+      throw Error("Invalid dimension.");
+    }
+    return index;
+  };
+}
+
+// src/lib/ome/ome-utils.ts
+var DTYPE_LOOKUP = {
+  uint8: "Uint8",
+  uint16: "Uint16",
+  uint32: "Uint32",
+  float: "Float32",
+  double: "Float64",
+  int8: "Int8",
+  int16: "Int16",
+  int32: "Int32"
+};
+function getOmePixelSourceMeta({ Pixels }) {
+  const labels = getLabels(Pixels.DimensionOrder);
+  const dims = getDims(labels);
+  const shape = Array(labels.length).fill(0);
+  shape[dims("t")] = Pixels.SizeT;
+  shape[dims("c")] = Pixels.SizeC;
+  shape[dims("z")] = Pixels.SizeZ;
+  if (Pixels.Interleaved) {
+    labels.push("_c");
+    shape.push(3);
+  }
+  const getShape = (level) => {
+    const s = [...shape];
+    s[dims("x")] = Pixels.SizeX >> level;
+    s[dims("y")] = Pixels.SizeY >> level;
+    return s;
+  };
+  if (!(Pixels.Type in DTYPE_LOOKUP)) {
+    throw Error(`Pixel type ${Pixels.Type} not supported.`);
+  }
+  const dtype = DTYPE_LOOKUP[Pixels.Type];
+  if (Pixels.PhysicalSizeX && Pixels.PhysicalSizeY) {
+    const physicalSizes = {
+      x: {
+        size: Pixels.PhysicalSizeX,
+        unit: Pixels.PhysicalSizeXUnit
+      },
+      y: {
+        size: Pixels.PhysicalSizeY,
+        unit: Pixels.PhysicalSizeYUnit
+      }
+    };
+    if (Pixels.PhysicalSizeZ) {
+      physicalSizes.z = {
+        size: Pixels.PhysicalSizeZ,
+        unit: Pixels.PhysicalSizeZUnit
+      };
+    }
+    return { labels, getShape, physicalSizes, dtype };
+  }
+  return { labels, getShape, dtype };
+}
+
+// src/lib/ome/omexml.ts
+var import_fast_xml_parser = require("fast-xml-parser");
+var xmlParser = new import_fast_xml_parser.XMLParser({
+  // Nests attributes withtout prefix under 'attr' key for each node
+  attributeNamePrefix: "",
+  attributesGroupName: "attr",
+  // Parses numbers for both attributes and nodes
+  parseTagValue: true,
+  parseAttributeValue: true,
+  // Forces attributes to be parsed
+  ignoreAttributes: false
+});
+var parse = (str) => xmlParser.parse(str);
+function fromString(str) {
+  const res = parse(str);
+  if (!res.OME) {
+    throw Error("Failed to parse OME-XML metadata.");
+  }
+  return ensureArray(res.OME.Image).map((img) => {
+    const Channels = ensureArray(img.Pixels.Channel).map((c) => {
+      if ("Color" in c.attr) {
+        return { ...c.attr, Color: intToRgba(c.attr.Color) };
+      }
+      return { ...c.attr };
+    });
+    const { AquisitionDate = "", Description = "" } = img;
+    const image = {
+      ...img.attr,
+      AquisitionDate,
+      Description,
+      Pixels: {
+        ...img.Pixels.attr,
+        Channels
+      }
+    };
+    return {
+      ...image,
+      format() {
+        const { Pixels } = image;
+        const sizes = ["X", "Y", "Z"].map((name) => {
+          const size = Pixels[`PhysicalSize${name}`];
+          const unit = Pixels[`PhysicalSize${name}Unit`];
+          return size && unit ? `${size} ${unit}` : "-";
+        }).join(" x ");
+        return {
+          "Acquisition Date": image.AquisitionDate,
+          "Dimensions (XY)": `${Pixels.SizeX} x ${Pixels.SizeY}`,
+          "Pixels Type": Pixels.Type,
+          "Pixels Size (XYZ)": sizes,
+          "Z-sections/Timepoints": `${Pixels.SizeZ} x ${Pixels.SizeT}`,
+          Channels: Pixels.SizeC
+        };
+      }
+    };
+  });
+}
+
+// src/lib/ome/load-ome-tiff.ts
+var isOmeTiff = (img) => img.fileDirectory.ImageDescription.includes("<OME");
+async function loadOmeTiff(tiff, firstImage) {
+  const {
+    ImageDescription,
+    SubIFDs,
+    PhotometricInterpretation: photometricInterpretation
+  } = firstImage.fileDirectory;
+  const omexml = fromString(ImageDescription);
+  let levels;
+  let pyramidIndexer;
+  if (SubIFDs) {
+    levels = SubIFDs.length + 1;
+    pyramidIndexer = getOmeSubIFDIndexer(tiff, omexml);
+  } else {
+    levels = omexml.length;
+    pyramidIndexer = getOmeLegacyIndexer(tiff, omexml);
+  }
+  const imgMeta = omexml[0];
+  const { labels, getShape, physicalSizes, dtype } = getOmePixelSourceMeta(imgMeta);
+  const tileSize = firstImage.getTileWidth();
+  const meta = { photometricInterpretation, physicalSizes };
+  const data = Array.from({ length: levels }).map((_, resolution) => {
+    const shape = getShape(resolution);
+    const indexer = (sel) => pyramidIndexer(sel, resolution);
+    const source = new tiff_pixel_source_default(indexer, dtype, tileSize, shape, labels, meta);
+    return source;
+  });
+  return { data, metadata: imgMeta };
+}
+
+// src/lib/load-geotiff.ts
+async function loadGeoTiff(source, opts = {}) {
+  const { headers, offsets } = opts;
+  let tiff;
+  if (source instanceof import_geotiff.GeoTIFF) {
+    tiff = source;
+  } else if (typeof source === "string") {
+    tiff = await (0, import_geotiff.fromUrl)(source, headers);
+  } else {
+    tiff = await (0, import_geotiff.fromBlob)(source);
+  }
+  if (offsets) {
+    tiff = createOffsetsProxy(tiff, offsets);
+  }
+  checkProxies(tiff);
+  const firstImage = await tiff.getImage(0);
+  if (isOmeTiff(firstImage)) {
+    return loadOmeTiff(tiff, firstImage);
+  }
+  throw new Error("GeoTIFF not recognized.");
+}

package/dist/index.js

@@ -0,0 +1,3 @@
+export { loadGeoTiff } from "./lib/load-geotiff.js";
+export { default as TiffPixelSource } from "./lib/tiff-pixel-source.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["loadGeoTiff","default","TiffPixelSource"],"sources":["../src/index.ts"],"sourcesContent":["export {loadGeoTiff} from './lib/load-geotiff';\nexport {default as TiffPixelSource} from './lib/tiff-pixel-source';\n"],"mappings":"SAAQA,WAAW;AAAA,SACXC,OAAO,IAAIC,eAAe"}

package/dist/{esm/lib → lib}/load-geotiff.js

@@ -1,6 +1,6 @@
 import { fromUrl, fromBlob, GeoTIFF } from 'geotiff';
-import { createOffsetsProxy, checkProxies } from './utils/proxies';
-import { loadOmeTiff, isOmeTiff } from './ome/load-ome-tiff';
+import { createOffsetsProxy, checkProxies } from "./utils/proxies.js";
+import { loadOmeTiff, isOmeTiff } from "./ome/load-ome-tiff.js";
 export async function loadGeoTiff(source) {
   let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   const {

package/dist/lib/load-geotiff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-geotiff.js","names":["fromUrl","fromBlob","GeoTIFF","createOffsetsProxy","checkProxies","loadOmeTiff","isOmeTiff","loadGeoTiff","source","opts","arguments","length","undefined","headers","offsets","tiff","firstImage","getImage","Error"],"sources":["../../src/lib/load-geotiff.ts"],"sourcesContent":["import {fromUrl, fromBlob, GeoTIFF} from 'geotiff';\n\nimport {\n  // createPoolProxy,\n  createOffsetsProxy,\n  checkProxies\n} from './utils/proxies';\n// import Pool from './lib/Pool';\n\nimport {loadOmeTiff, isOmeTiff} from './ome/load-ome-tiff';\nimport type TiffPixelSource from './tiff-pixel-source';\n\n/** Options for initializing a tiff pixel source. */\ninterface GeoTIFFOptions {\n  /** Headers passed to each underlying request. */\n  headers?: Record<string, unknown>;\n  /** Performance enhancment to index the remote tiff source using pre-computed byte-offsets. Generated via https://github.com/ilan-gold/generate-tiff-offsets */\n  offsets?: number[];\n  /** Indicates whether a multi-threaded pool of image decoders should be used to decode tiles. */\n  pool?: boolean;\n}\n\ninterface GeoTIFFData {\n  data: TiffPixelSource<string[]>[];\n  metadata: Record<string, unknown>;\n}\n\n/**\n * Opens an OME-TIFF via URL and returns data source and associated metadata for first image.\n *\n * @param source url string, File/Blob object, or GeoTIFF object\n * @param opts options for initializing a tiff pixel source.\n *  - `opts.headers` are passed to each underlying fetch request.\n *  - `opts.offsets` are a performance enhancment to index the remote tiff source using pre-computed byte-offsets.\n *  - `opts.pool` indicates whether a multi-threaded pool of image decoders should be used to decode tiles (default = true).\n * @return data source and associated OME-Zarr metadata.\n */\nexport async function loadGeoTiff(\n  source: string | Blob | GeoTIFF,\n  opts: GeoTIFFOptions = {}\n): Promise<GeoTIFFData> {\n  const {headers, offsets} = opts;\n\n  // Create tiff source\n  let tiff: GeoTIFF;\n  if (source instanceof GeoTIFF) {\n    tiff = source;\n  } else if (typeof source === 'string') {\n    tiff = await fromUrl(source, headers);\n  } else {\n    tiff = await fromBlob(source);\n  }\n\n  // if (pool) {\n  /*\n   * Creates a worker pool to decode tiff tiles. Wraps tiff\n   * in a Proxy that injects 'pool' into `tiff.readRasters`.\n   */\n  // tiff = createPoolProxy(tiff, new Pool());\n  // }\n\n  if (offsets) {\n    /*\n     * Performance enhancement. If offsets are provided, we\n     * create a proxy that intercepts calls to `tiff.getImage`\n     * and injects the pre-computed offsets.\n     */\n    tiff = createOffsetsProxy(tiff, offsets);\n  }\n\n  /*\n   * Inspect tiff source for our performance enhancing proxies.\n   * Prints warnings to console if `offsets` or `pool` are missing.\n   */\n  checkProxies(tiff);\n\n  const firstImage = await tiff.getImage(0);\n\n  if (isOmeTiff(firstImage)) {\n    return loadOmeTiff(tiff, firstImage);\n  }\n\n  throw new Error('GeoTIFF not recognized.');\n}\n"],"mappings":"AAAA,SAAQA,OAAO,EAAEC,QAAQ,EAAEC,OAAO,QAAO,SAAS;AAAC,SAIjDC,kBAAkB,EAClBC,YAAY;AAAA,SAINC,WAAW,EAAEC,SAAS;AA4B9B,OAAO,eAAeC,WAAWA,CAC/BC,MAA+B,EAET;EAAA,IADtBC,IAAoB,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC;EAEzB,MAAM;IAACG,OAAO;IAAEC;EAAO,CAAC,GAAGL,IAAI;EAG/B,IAAIM,IAAa;EACjB,IAAIP,MAAM,YAAYN,OAAO,EAAE;IAC7Ba,IAAI,GAAGP,MAAM;EACf,CAAC,MAAM,IAAI,OAAOA,MAAM,KAAK,QAAQ,EAAE;IACrCO,IAAI,GAAG,MAAMf,OAAO,CAACQ,MAAM,EAAEK,OAAO,CAAC;EACvC,CAAC,MAAM;IACLE,IAAI,GAAG,MAAMd,QAAQ,CAACO,MAAM,CAAC;EAC/B;EAUA,IAAIM,OAAO,EAAE;IAMXC,IAAI,GAAGZ,kBAAkB,CAACY,IAAI,EAAED,OAAO,CAAC;EAC1C;EAMAV,YAAY,CAACW,IAAI,CAAC;EAElB,MAAMC,UAAU,GAAG,MAAMD,IAAI,CAACE,QAAQ,CAAC,CAAC,CAAC;EAEzC,IAAIX,SAAS,CAACU,UAAU,CAAC,EAAE;IACzB,OAAOX,WAAW,CAACU,IAAI,EAAEC,UAAU,CAAC;EACtC;EAEA,MAAM,IAAIE,KAAK,CAAC,yBAAyB,CAAC;AAC5C"}

package/dist/{esm/lib → lib}/ome/load-ome-tiff.js

@@ -1,7 +1,7 @@
-import TiffPixelSource from '../tiff-pixel-source';
-import { getOmeLegacyIndexer, getOmeSubIFDIndexer } from './ome-indexers';
-import { getOmePixelSourceMeta } from './ome-utils';
-import { fromString } from './omexml';
+import TiffPixelSource from "../tiff-pixel-source.js";
+import { getOmeLegacyIndexer, getOmeSubIFDIndexer } from "./ome-indexers.js";
+import { getOmePixelSourceMeta } from "./ome-utils.js";
+import { fromString } from "./omexml.js";
 export const isOmeTiff = img => img.fileDirectory.ImageDescription.includes('<OME');
 export async function loadOmeTiff(tiff, firstImage) {
   const {

package/dist/lib/ome/load-ome-tiff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-ome-tiff.js","names":["TiffPixelSource","getOmeLegacyIndexer","getOmeSubIFDIndexer","getOmePixelSourceMeta","fromString","isOmeTiff","img","fileDirectory","ImageDescription","includes","loadOmeTiff","tiff","firstImage","SubIFDs","PhotometricInterpretation","photometricInterpretation","omexml","levels","pyramidIndexer","length","imgMeta","labels","getShape","physicalSizes","dtype","tileSize","getTileWidth","meta","data","Array","from","map","_","resolution","shape","indexer","sel","source","metadata"],"sources":["../../../src/lib/ome/load-ome-tiff.ts"],"sourcesContent":["import type {GeoTIFF, GeoTIFFImage} from 'geotiff';\n\nimport TiffPixelSource from '../tiff-pixel-source';\nimport {getOmeLegacyIndexer, getOmeSubIFDIndexer, OmeTiffIndexer} from './ome-indexers';\nimport {getOmePixelSourceMeta} from './ome-utils';\nimport {fromString} from './omexml';\nimport type {OmeTiffSelection} from './ome-indexers';\n\nexport const isOmeTiff = (img: GeoTIFFImage) => img.fileDirectory.ImageDescription.includes('<OME');\n\nexport async function loadOmeTiff(tiff: GeoTIFF, firstImage: GeoTIFFImage) {\n  // Get first image from tiff and inspect OME-XML metadata\n  const {\n    ImageDescription,\n    SubIFDs,\n    PhotometricInterpretation: photometricInterpretation\n  } = firstImage.fileDirectory;\n  const omexml = fromString(ImageDescription);\n\n  /*\n   * Image pyramids are stored differently between versions of Bioformats.\n   * Thus we need a different indexer depending on which format we have.\n   */\n  let levels: number;\n  let pyramidIndexer: OmeTiffIndexer;\n\n  if (SubIFDs) {\n    // Image is >= Bioformats 6.0 and resolutions are stored using SubIFDs.\n    levels = SubIFDs.length + 1;\n    pyramidIndexer = getOmeSubIFDIndexer(tiff, omexml);\n  } else {\n    // Image is legacy format; resolutions are stored as separate images.\n    levels = omexml.length;\n    pyramidIndexer = getOmeLegacyIndexer(tiff, omexml);\n  }\n\n  // TODO: The OmeTIFF loader only works for the _first_ image in the metadata.\n  const imgMeta = omexml[0];\n  const {labels, getShape, physicalSizes, dtype} = getOmePixelSourceMeta(imgMeta);\n  const tileSize = firstImage.getTileWidth();\n  const meta = {photometricInterpretation, physicalSizes};\n\n  const data = Array.from({length: levels}).map((_, resolution) => {\n    const shape = getShape(resolution);\n    const indexer = (sel: OmeTiffSelection) => pyramidIndexer(sel, resolution);\n    const source = new TiffPixelSource(indexer, dtype, tileSize, shape, labels, meta);\n    return source;\n  });\n\n  return {data, metadata: imgMeta};\n}\n"],"mappings":"OAEOA,eAAe;AAAA,SACdC,mBAAmB,EAAEC,mBAAmB;AAAA,SACxCC,qBAAqB;AAAA,SACrBC,UAAU;AAGlB,OAAO,MAAMC,SAAS,GAAIC,GAAiB,IAAKA,GAAG,CAACC,aAAa,CAACC,gBAAgB,CAACC,QAAQ,CAAC,MAAM,CAAC;AAEnG,OAAO,eAAeC,WAAWA,CAACC,IAAa,EAAEC,UAAwB,EAAE;EAEzE,MAAM;IACJJ,gBAAgB;IAChBK,OAAO;IACPC,yBAAyB,EAAEC;EAC7B,CAAC,GAAGH,UAAU,CAACL,aAAa;EAC5B,MAAMS,MAAM,GAAGZ,UAAU,CAACI,gBAAgB,CAAC;EAM3C,IAAIS,MAAc;EAClB,IAAIC,cAA8B;EAElC,IAAIL,OAAO,EAAE;IAEXI,MAAM,GAAGJ,OAAO,CAACM,MAAM,GAAG,CAAC;IAC3BD,cAAc,GAAGhB,mBAAmB,CAACS,IAAI,EAAEK,MAAM,CAAC;EACpD,CAAC,MAAM;IAELC,MAAM,GAAGD,MAAM,CAACG,MAAM;IACtBD,cAAc,GAAGjB,mBAAmB,CAACU,IAAI,EAAEK,MAAM,CAAC;EACpD;EAGA,MAAMI,OAAO,GAAGJ,MAAM,CAAC,CAAC,CAAC;EACzB,MAAM;IAACK,MAAM;IAAEC,QAAQ;IAAEC,aAAa;IAAEC;EAAK,CAAC,GAAGrB,qBAAqB,CAACiB,OAAO,CAAC;EAC/E,MAAMK,QAAQ,GAAGb,UAAU,CAACc,YAAY,CAAC,CAAC;EAC1C,MAAMC,IAAI,GAAG;IAACZ,yBAAyB;IAAEQ;EAAa,CAAC;EAEvD,MAAMK,IAAI,GAAGC,KAAK,CAACC,IAAI,CAAC;IAACX,MAAM,EAAEF;EAAM,CAAC,CAAC,CAACc,GAAG,CAAC,CAACC,CAAC,EAAEC,UAAU,KAAK;IAC/D,MAAMC,KAAK,GAAGZ,QAAQ,CAACW,UAAU,CAAC;IAClC,MAAME,OAAO,GAAIC,GAAqB,IAAKlB,cAAc,CAACkB,GAAG,EAAEH,UAAU,CAAC;IAC1E,MAAMI,MAAM,GAAG,IAAIrC,eAAe,CAACmC,OAAO,EAAEX,KAAK,EAAEC,QAAQ,EAAES,KAAK,EAAEb,MAAM,EAAEM,IAAI,CAAC;IACjF,OAAOU,MAAM;EACf,CAAC,CAAC;EAEF,OAAO;IAACT,IAAI;IAAEU,QAAQ,EAAElB;EAAO,CAAC;AAClC"}

package/dist/{esm/lib → lib}/ome/ome-indexers.js

@@ -28,7 +28,7 @@ export function getOmeSubIFDIndexer(tiff, rootMeta) {
     if (!SubIFDs) {
       throw Error('Indexing Error: OME-TIFF is missing SubIFDs.');
     }
-    const key = "".concat(sel.t, "-").concat(sel.c, "-").concat(sel.z, "-").concat(pyramidLevel);
+    const key = `${sel.t}-${sel.c}-${sel.z}-${pyramidLevel}`;
     if (!ifdCache.has(key)) {
       const subIfdOffset = SubIFDs[pyramidLevel - 1];
       ifdCache.set(key, tiff.parseFileDirectoryAt(subIfdOffset));
@@ -113,7 +113,7 @@ function getOmeIFDIndexer(imgMeta) {
       }
     default:
       {
-        throw new Error("Invalid OME-XML DimensionOrder, got ".concat(DimensionOrder, "."));
+        throw new Error(`Invalid OME-XML DimensionOrder, got ${DimensionOrder}.`);
       }
   }
 }

package/dist/lib/ome/ome-indexers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ome-indexers.js","names":["getOmeLegacyIndexer","tiff","rootMeta","imgMeta","SizeT","SizeC","SizeZ","Pixels","ifdIndexer","getOmeIFDIndexer","sel","pyramidLevel","index","pyramidIndex","getImage","getOmeSubIFDIndexer","ifdCache","Map","baseImage","SubIFDs","fileDirectory","Error","key","t","c","z","has","subIfdOffset","set","parseFileDirectoryAt","ifd","get","constructor","geoKeyDirectory","dataView","littleEndian","cache","source","DimensionOrder","_ref","_ref2","_ref3","_ref4","_ref5","_ref6"],"sources":["../../../src/lib/ome/ome-indexers.ts"],"sourcesContent":["import type {GeoTIFFImage, GeoTIFF, ImageFileDirectory} from 'geotiff';\nimport type {OMEXML} from '../ome/omexml';\n\nexport type OmeTiffSelection = {t: number; c: number; z: number};\nexport type OmeTiffIndexer = (sel: OmeTiffSelection, z: number) => Promise<GeoTIFFImage>;\n\n/*\n * An \"indexer\" for a GeoTIFF-based source is a function that takes a\n * \"selection\" (e.g. { z, t, c }) and returns a Promise for the GeoTIFFImage\n * object corresponding to that selection.\n *\n * For OME-TIFF images, the \"selection\" object is the same regardless of\n * the format version. However, modern version of Bioformats have a different\n * memory layout for pyramidal resolutions. Thus, we have two different \"indexers\"\n * depending on which format version is detected.\n *\n * TODO: We currently only support indexing the first image in the OME-TIFF with\n * our indexers. There can be multiple images in an OME-TIFF, so supporting these\n * images will require extending these indexers or creating new methods.\n */\n\n/*\n * Returns an indexer for legacy Bioformats images. This assumes that\n * downsampled resolutions are stored sequentially in the OME-TIFF.\n */\nexport function getOmeLegacyIndexer(tiff: GeoTIFF, rootMeta: OMEXML): OmeTiffIndexer {\n  const imgMeta = rootMeta[0];\n  const {SizeT, SizeC, SizeZ} = imgMeta.Pixels;\n  const ifdIndexer = getOmeIFDIndexer(imgMeta);\n\n  return (sel: OmeTiffSelection, pyramidLevel: number) => {\n    // Get IFD index at base pyramid level\n    const index = ifdIndexer(sel);\n    // Get index of first image at pyramidal level\n    const pyramidIndex = pyramidLevel * SizeZ * SizeT * SizeC;\n    // Return image at IFD index for pyramidal level\n    return tiff.getImage(index + pyramidIndex);\n  };\n}\n\n/*\n * Returns an indexer for modern Bioforamts images that store multiscale\n * resolutions using SubIFDs.\n *\n * The ifdIndexer returns the 'index' to the base resolution for a\n * particular 'selection'. The SubIFDs to the downsampled resolutions\n * of the 'selection' are stored within the `baseImage.fileDirectory`.\n * We use the SubIFDs to get the IFD for the corresponding sub-resolution.\n *\n * NOTE: This function create a custom IFD cache rather than mutating\n * `GeoTIFF.ifdRequests` with a random offset. The IFDs are cached in\n * an ES6 Map that maps a string key that identifies the selection uniquely\n * to the corresponding IFD.\n */\nexport function getOmeSubIFDIndexer(tiff: GeoTIFF, rootMeta: OMEXML): OmeTiffIndexer {\n  const imgMeta = rootMeta[0];\n  const ifdIndexer = getOmeIFDIndexer(imgMeta);\n  const ifdCache: Map<string, Promise<ImageFileDirectory>> = new Map();\n\n  return async (sel: OmeTiffSelection, pyramidLevel: number) => {\n    const index = ifdIndexer(sel);\n    const baseImage = await tiff.getImage(index);\n\n    // It's the highest resolution, no need to look up SubIFDs.\n    if (pyramidLevel === 0) {\n      return baseImage;\n    }\n\n    const {SubIFDs} = baseImage.fileDirectory;\n    if (!SubIFDs) {\n      throw Error('Indexing Error: OME-TIFF is missing SubIFDs.');\n    }\n\n    // Get IFD for the selection at the pyramidal level\n    const key = `${sel.t}-${sel.c}-${sel.z}-${pyramidLevel}`;\n    if (!ifdCache.has(key)) {\n      // Only create a new request if we don't have the key.\n      const subIfdOffset = SubIFDs[pyramidLevel - 1];\n      ifdCache.set(key, tiff.parseFileDirectoryAt(subIfdOffset));\n    }\n    const ifd = (await ifdCache.get(key)) as ImageFileDirectory;\n\n    // Create a new image object manually from IFD\n    // https://github.com/geotiffjs/geotiff.js/blob/8ef472f41b51d18074aece2300b6a8ad91a21ae1/src/geotiff.js#L447-L453\n    return new (baseImage.constructor as any)(\n      ifd.fileDirectory,\n      ifd.geoKeyDirectory,\n      tiff.dataView,\n      tiff.littleEndian,\n      tiff.cache,\n      tiff.source\n    ) as GeoTIFFImage;\n  };\n}\n\n/*\n * Returns a function that computes the image index based on the dimension\n * order and dimension sizes.\n */\nfunction getOmeIFDIndexer(imgMeta: OMEXML[0]): (sel: OmeTiffSelection) => number {\n  const {SizeC, SizeZ, SizeT, DimensionOrder} = imgMeta.Pixels;\n  switch (DimensionOrder) {\n    case 'XYZCT': {\n      return ({t, c, z}) => t * SizeZ * SizeC + c * SizeZ + z;\n    }\n    case 'XYZTC': {\n      return ({t, c, z}) => c * SizeZ * SizeT + t * SizeZ + z;\n    }\n    case 'XYCTZ': {\n      return ({t, c, z}) => z * SizeC * SizeT + t * SizeC + c;\n    }\n    case 'XYCZT': {\n      return ({t, c, z}) => t * SizeC * SizeZ + z * SizeC + c;\n    }\n    case 'XYTCZ': {\n      return ({t, c, z}) => z * SizeT * SizeC + c * SizeT + t;\n    }\n    case 'XYTZC': {\n      return ({t, c, z}) => c * SizeT * SizeZ + z * SizeT + t;\n    }\n    default: {\n      throw new Error(`Invalid OME-XML DimensionOrder, got ${DimensionOrder}.`);\n    }\n  }\n}\n"],"mappings":"AAyBA,OAAO,SAASA,mBAAmBA,CAACC,IAAa,EAAEC,QAAgB,EAAkB;EACnF,MAAMC,OAAO,GAAGD,QAAQ,CAAC,CAAC,CAAC;EAC3B,MAAM;IAACE,KAAK;IAAEC,KAAK;IAAEC;EAAK,CAAC,GAAGH,OAAO,CAACI,MAAM;EAC5C,MAAMC,UAAU,GAAGC,gBAAgB,CAACN,OAAO,CAAC;EAE5C,OAAO,CAACO,GAAqB,EAAEC,YAAoB,KAAK;IAEtD,MAAMC,KAAK,GAAGJ,UAAU,CAACE,GAAG,CAAC;IAE7B,MAAMG,YAAY,GAAGF,YAAY,GAAGL,KAAK,GAAGF,KAAK,GAAGC,KAAK;IAEzD,OAAOJ,IAAI,CAACa,QAAQ,CAACF,KAAK,GAAGC,YAAY,CAAC;EAC5C,CAAC;AACH;AAgBA,OAAO,SAASE,mBAAmBA,CAACd,IAAa,EAAEC,QAAgB,EAAkB;EACnF,MAAMC,OAAO,GAAGD,QAAQ,CAAC,CAAC,CAAC;EAC3B,MAAMM,UAAU,GAAGC,gBAAgB,CAACN,OAAO,CAAC;EAC5C,MAAMa,QAAkD,GAAG,IAAIC,GAAG,CAAC,CAAC;EAEpE,OAAO,OAAOP,GAAqB,EAAEC,YAAoB,KAAK;IAC5D,MAAMC,KAAK,GAAGJ,UAAU,CAACE,GAAG,CAAC;IAC7B,MAAMQ,SAAS,GAAG,MAAMjB,IAAI,CAACa,QAAQ,CAACF,KAAK,CAAC;IAG5C,IAAID,YAAY,KAAK,CAAC,EAAE;MACtB,OAAOO,SAAS;IAClB;IAEA,MAAM;MAACC;IAAO,CAAC,GAAGD,SAAS,CAACE,aAAa;IACzC,IAAI,CAACD,OAAO,EAAE;MACZ,MAAME,KAAK,CAAC,8CAA8C,CAAC;IAC7D;IAGA,MAAMC,GAAG,GAAI,GAAEZ,GAAG,CAACa,CAAE,IAAGb,GAAG,CAACc,CAAE,IAAGd,GAAG,CAACe,CAAE,IAAGd,YAAa,EAAC;IACxD,IAAI,CAACK,QAAQ,CAACU,GAAG,CAACJ,GAAG,CAAC,EAAE;MAEtB,MAAMK,YAAY,GAAGR,OAAO,CAACR,YAAY,GAAG,CAAC,CAAC;MAC9CK,QAAQ,CAACY,GAAG,CAACN,GAAG,EAAErB,IAAI,CAAC4B,oBAAoB,CAACF,YAAY,CAAC,CAAC;IAC5D;IACA,MAAMG,GAAG,GAAI,MAAMd,QAAQ,CAACe,GAAG,CAACT,GAAG,CAAwB;IAI3D,OAAO,IAAKJ,SAAS,CAACc,WAAW,CAC/BF,GAAG,CAACV,aAAa,EACjBU,GAAG,CAACG,eAAe,EACnBhC,IAAI,CAACiC,QAAQ,EACbjC,IAAI,CAACkC,YAAY,EACjBlC,IAAI,CAACmC,KAAK,EACVnC,IAAI,CAACoC,MACP,CAAC;EACH,CAAC;AACH;AAMA,SAAS5B,gBAAgBA,CAACN,OAAkB,EAAqC;EAC/E,MAAM;IAACE,KAAK;IAAEC,KAAK;IAAEF,KAAK;IAAEkC;EAAc,CAAC,GAAGnC,OAAO,CAACI,MAAM;EAC5D,QAAQ+B,cAAc;IACpB,KAAK,OAAO;MAAE;QACZ,OAAOC,IAAA;UAAA,IAAC;YAAChB,CAAC;YAAEC,CAAC;YAAEC;UAAC,CAAC,GAAAc,IAAA;UAAA,OAAKhB,CAAC,GAAGjB,KAAK,GAAGD,KAAK,GAAGmB,CAAC,GAAGlB,KAAK,GAAGmB,CAAC;QAAA;MACzD;IACA,KAAK,OAAO;MAAE;QACZ,OAAOe,KAAA;UAAA,IAAC;YAACjB,CAAC;YAAEC,CAAC;YAAEC;UAAC,CAAC,GAAAe,KAAA;UAAA,OAAKhB,CAAC,GAAGlB,KAAK,GAAGF,KAAK,GAAGmB,CAAC,GAAGjB,KAAK,GAAGmB,CAAC;QAAA;MACzD;IACA,KAAK,OAAO;MAAE;QACZ,OAAOgB,KAAA;UAAA,IAAC;YAAClB,CAAC;YAAEC,CAAC;YAAEC;UAAC,CAAC,GAAAgB,KAAA;UAAA,OAAKhB,CAAC,GAAGpB,KAAK,GAAGD,KAAK,GAAGmB,CAAC,GAAGlB,KAAK,GAAGmB,CAAC;QAAA;MACzD;IACA,KAAK,OAAO;MAAE;QACZ,OAAOkB,KAAA;UAAA,IAAC;YAACnB,CAAC;YAAEC,CAAC;YAAEC;UAAC,CAAC,GAAAiB,KAAA;UAAA,OAAKnB,CAAC,GAAGlB,KAAK,GAAGC,KAAK,GAAGmB,CAAC,GAAGpB,KAAK,GAAGmB,CAAC;QAAA;MACzD;IACA,KAAK,OAAO;MAAE;QACZ,OAAOmB,KAAA;UAAA,IAAC;YAACpB,CAAC;YAAEC,CAAC;YAAEC;UAAC,CAAC,GAAAkB,KAAA;UAAA,OAAKlB,CAAC,GAAGrB,KAAK,GAAGC,KAAK,GAAGmB,CAAC,GAAGpB,KAAK,GAAGmB,CAAC;QAAA;MACzD;IACA,KAAK,OAAO;MAAE;QACZ,OAAOqB,KAAA;UAAA,IAAC;YAACrB,CAAC;YAAEC,CAAC;YAAEC;UAAC,CAAC,GAAAmB,KAAA;UAAA,OAAKpB,CAAC,GAAGpB,KAAK,GAAGE,KAAK,GAAGmB,CAAC,GAAGrB,KAAK,GAAGmB,CAAC;QAAA;MACzD;IACA;MAAS;QACP,MAAM,IAAIF,KAAK,CAAE,uCAAsCiB,cAAe,GAAE,CAAC;MAC3E;EACF;AACF"}

package/dist/{esm/lib → lib}/ome/ome-utils.js

@@ -1,4 +1,4 @@
-import { getDims, getLabels } from './utils';
+import { getDims, getLabels } from "./utils.js";
 export const DTYPE_LOOKUP = {
   uint8: 'Uint8',
   uint16: 'Uint16',
@@ -30,7 +30,7 @@ export function getOmePixelSourceMeta(_ref) {
     return s;
   };
   if (!(Pixels.Type in DTYPE_LOOKUP)) {
-    throw Error("Pixel type ".concat(Pixels.Type, " not supported."));
+    throw Error(`Pixel type ${Pixels.Type} not supported.`);
   }
   const dtype = DTYPE_LOOKUP[Pixels.Type];
   if (Pixels.PhysicalSizeX && Pixels.PhysicalSizeY) {

package/dist/lib/ome/ome-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ome-utils.js","names":["getDims","getLabels","DTYPE_LOOKUP","uint8","uint16","uint32","float","double","int8","int16","int32","getOmePixelSourceMeta","_ref","Pixels","labels","DimensionOrder","dims","shape","Array","length","fill","SizeT","SizeC","SizeZ","Interleaved","push","getShape","level","s","SizeX","SizeY","Type","Error","dtype","PhysicalSizeX","PhysicalSizeY","physicalSizes","x","size","unit","PhysicalSizeXUnit","y","PhysicalSizeYUnit","PhysicalSizeZ","z","PhysicalSizeZUnit"],"sources":["../../../src/lib/ome/ome-utils.ts"],"sourcesContent":["import {getDims, getLabels} from './utils';\nimport type {OMEXML, UnitsLength} from './omexml';\n\nexport const DTYPE_LOOKUP = {\n  uint8: 'Uint8',\n  uint16: 'Uint16',\n  uint32: 'Uint32',\n  float: 'Float32',\n  double: 'Float64',\n  int8: 'Int8',\n  int16: 'Int16',\n  int32: 'Int32'\n} as const;\n\nexport function getOmePixelSourceMeta({Pixels}: OMEXML[0]) {\n  // e.g. 'XYZCT' -> ['t', 'c', 'z', 'y', 'x']\n  const labels = getLabels(Pixels.DimensionOrder);\n\n  // Compute \"shape\" of image\n  const dims = getDims(labels);\n  const shape: number[] = Array(labels.length).fill(0);\n  shape[dims('t')] = Pixels.SizeT;\n  shape[dims('c')] = Pixels.SizeC;\n  shape[dims('z')] = Pixels.SizeZ;\n\n  // Push extra dimension if data are interleaved.\n  if (Pixels.Interleaved) {\n    // @ts-ignore\n    labels.push('_c');\n    shape.push(3);\n  }\n\n  // Creates a new shape for different level of pyramid.\n  // Assumes factor-of-two downsampling.\n  const getShape = (level: number) => {\n    const s = [...shape];\n    s[dims('x')] = Pixels.SizeX >> level;\n    s[dims('y')] = Pixels.SizeY >> level;\n    return s;\n  };\n\n  if (!(Pixels.Type in DTYPE_LOOKUP)) {\n    throw Error(`Pixel type ${Pixels.Type} not supported.`);\n  }\n\n  const dtype = DTYPE_LOOKUP[Pixels.Type as keyof typeof DTYPE_LOOKUP];\n  if (Pixels.PhysicalSizeX && Pixels.PhysicalSizeY) {\n    const physicalSizes: {\n      [k: string]: {size: number; unit: UnitsLength};\n    } = {\n      x: {\n        size: Pixels.PhysicalSizeX,\n        unit: Pixels.PhysicalSizeXUnit\n      },\n      y: {\n        size: Pixels.PhysicalSizeY,\n        unit: Pixels.PhysicalSizeYUnit\n      }\n    };\n    if (Pixels.PhysicalSizeZ) {\n      physicalSizes.z = {\n        size: Pixels.PhysicalSizeZ,\n        unit: Pixels.PhysicalSizeZUnit\n      };\n    }\n    return {labels, getShape, physicalSizes, dtype};\n  }\n\n  return {labels, getShape, dtype};\n}\n"],"mappings":"SAAQA,OAAO,EAAEC,SAAS;AAG1B,OAAO,MAAMC,YAAY,GAAG;EAC1BC,KAAK,EAAE,OAAO;EACdC,MAAM,EAAE,QAAQ;EAChBC,MAAM,EAAE,QAAQ;EAChBC,KAAK,EAAE,SAAS;EAChBC,MAAM,EAAE,SAAS;EACjBC,IAAI,EAAE,MAAM;EACZC,KAAK,EAAE,OAAO;EACdC,KAAK,EAAE;AACT,CAAU;AAEV,OAAO,SAASC,qBAAqBA,CAAAC,IAAA,EAAsB;EAAA,IAArB;IAACC;EAAiB,CAAC,GAAAD,IAAA;EAEvD,MAAME,MAAM,GAAGb,SAAS,CAACY,MAAM,CAACE,cAAc,CAAC;EAG/C,MAAMC,IAAI,GAAGhB,OAAO,CAACc,MAAM,CAAC;EAC5B,MAAMG,KAAe,GAAGC,KAAK,CAACJ,MAAM,CAACK,MAAM,CAAC,CAACC,IAAI,CAAC,CAAC,CAAC;EACpDH,KAAK,CAACD,IAAI,CAAC,GAAG,CAAC,CAAC,GAAGH,MAAM,CAACQ,KAAK;EAC/BJ,KAAK,CAACD,IAAI,CAAC,GAAG,CAAC,CAAC,GAAGH,MAAM,CAACS,KAAK;EAC/BL,KAAK,CAACD,IAAI,CAAC,GAAG,CAAC,CAAC,GAAGH,MAAM,CAACU,KAAK;EAG/B,IAAIV,MAAM,CAACW,WAAW,EAAE;IAEtBV,MAAM,CAACW,IAAI,CAAC,IAAI,CAAC;IACjBR,KAAK,CAACQ,IAAI,CAAC,CAAC,CAAC;EACf;EAIA,MAAMC,QAAQ,GAAIC,KAAa,IAAK;IAClC,MAAMC,CAAC,GAAG,CAAC,GAAGX,KAAK,CAAC;IACpBW,CAAC,CAACZ,IAAI,CAAC,GAAG,CAAC,CAAC,GAAGH,MAAM,CAACgB,KAAK,IAAIF,KAAK;IACpCC,CAAC,CAACZ,IAAI,CAAC,GAAG,CAAC,CAAC,GAAGH,MAAM,CAACiB,KAAK,IAAIH,KAAK;IACpC,OAAOC,CAAC;EACV,CAAC;EAED,IAAI,EAAEf,MAAM,CAACkB,IAAI,IAAI7B,YAAY,CAAC,EAAE;IAClC,MAAM8B,KAAK,CAAE,cAAanB,MAAM,CAACkB,IAAK,iBAAgB,CAAC;EACzD;EAEA,MAAME,KAAK,GAAG/B,YAAY,CAACW,MAAM,CAACkB,IAAI,CAA8B;EACpE,IAAIlB,MAAM,CAACqB,aAAa,IAAIrB,MAAM,CAACsB,aAAa,EAAE;IAChD,MAAMC,aAEL,GAAG;MACFC,CAAC,EAAE;QACDC,IAAI,EAAEzB,MAAM,CAACqB,aAAa;QAC1BK,IAAI,EAAE1B,MAAM,CAAC2B;MACf,CAAC;MACDC,CAAC,EAAE;QACDH,IAAI,EAAEzB,MAAM,CAACsB,aAAa;QAC1BI,IAAI,EAAE1B,MAAM,CAAC6B;MACf;IACF,CAAC;IACD,IAAI7B,MAAM,CAAC8B,aAAa,EAAE;MACxBP,aAAa,CAACQ,CAAC,GAAG;QAChBN,IAAI,EAAEzB,MAAM,CAAC8B,aAAa;QAC1BJ,IAAI,EAAE1B,MAAM,CAACgC;MACf,CAAC;IACH;IACA,OAAO;MAAC/B,MAAM;MAAEY,QAAQ;MAAEU,aAAa;MAAEH;IAAK,CAAC;EACjD;EAEA,OAAO;IAACnB,MAAM;IAAEY,QAAQ;IAAEO;EAAK,CAAC;AAClC"}

package/dist/{esm/lib → lib}/ome/omexml.js

@@ -1,5 +1,5 @@
 import { XMLParser } from 'fast-xml-parser';
-import { ensureArray, intToRgba } from '../utils/tiff-utils';
+import { ensureArray, intToRgba } from "../utils/tiff-utils.js";
 const xmlParser = new XMLParser({
   attributeNamePrefix: '',
   attributesGroupName: 'attr',
@@ -45,16 +45,16 @@ export function fromString(str) {
           Pixels
         } = image;
         const sizes = ['X', 'Y', 'Z'].map(name => {
-          const size = Pixels["PhysicalSize".concat(name)];
-          const unit = Pixels["PhysicalSize".concat(name, "Unit")];
-          return size && unit ? "".concat(size, " ").concat(unit) : '-';
+          const size = Pixels[`PhysicalSize${name}`];
+          const unit = Pixels[`PhysicalSize${name}Unit`];
+          return size && unit ? `${size} ${unit}` : '-';
         }).join(' x ');
         return {
           'Acquisition Date': image.AquisitionDate,
-          'Dimensions (XY)': "".concat(Pixels.SizeX, " x ").concat(Pixels.SizeY),
+          'Dimensions (XY)': `${Pixels.SizeX} x ${Pixels.SizeY}`,
           'Pixels Type': Pixels.Type,
           'Pixels Size (XYZ)': sizes,
-          'Z-sections/Timepoints': "".concat(Pixels.SizeZ, " x ").concat(Pixels.SizeT),
+          'Z-sections/Timepoints': `${Pixels.SizeZ} x ${Pixels.SizeT}`,
           Channels: Pixels.SizeC
         };
       }

package/dist/lib/ome/omexml.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"omexml.js","names":["XMLParser","ensureArray","intToRgba","xmlParser","attributeNamePrefix","attributesGroupName","parseTagValue","parseAttributeValue","ignoreAttributes","parse","str","fromString","res","OME","Error","Image","map","img","Channels","Pixels","Channel","c","attr","Color","AquisitionDate","Description","image","format","sizes","name","size","unit","join","SizeX","SizeY","Type","SizeZ","SizeT","SizeC"],"sources":["../../../src/lib/ome/omexml.ts"],"sourcesContent":["import {XMLParser} from 'fast-xml-parser';\nimport {ensureArray, intToRgba} from '../utils/tiff-utils';\n\n// WARNING: Changes to the parser options _will_ effect the types in types/omexml.d.ts.\nconst xmlParser = new XMLParser({\n  // Nests attributes withtout prefix under 'attr' key for each node\n  attributeNamePrefix: '',\n  attributesGroupName: 'attr',\n\n  // Parses numbers for both attributes and nodes\n  parseTagValue: true,\n  parseAttributeValue: true,\n\n  // Forces attributes to be parsed\n  ignoreAttributes: false\n});\n\nconst parse = (str: string): Root => xmlParser.parse(str);\n\nexport function fromString(str: string) {\n  const res = parse(str);\n  if (!res.OME) {\n    throw Error('Failed to parse OME-XML metadata.');\n  }\n  return ensureArray(res.OME.Image).map((img) => {\n    const Channels = ensureArray(img.Pixels.Channel).map((c) => {\n      if ('Color' in c.attr) {\n        return {...c.attr, Color: intToRgba(c.attr.Color)};\n      }\n      return {...c.attr};\n    });\n    const {AquisitionDate = '', Description = ''} = img;\n    const image = {\n      ...img.attr,\n      AquisitionDate,\n      Description,\n      Pixels: {\n        ...img.Pixels.attr,\n        Channels\n      }\n    };\n    return {\n      ...image,\n      format() {\n        const {Pixels} = image;\n\n        const sizes = (['X', 'Y', 'Z'] as const)\n          .map((name) => {\n            const size = Pixels[`PhysicalSize${name}` as const];\n            const unit = Pixels[`PhysicalSize${name}Unit` as const];\n            return size && unit ? `${size} ${unit}` : '-';\n          })\n          .join(' x ');\n\n        return {\n          'Acquisition Date': image.AquisitionDate,\n          'Dimensions (XY)': `${Pixels.SizeX} x ${Pixels.SizeY}`,\n          'Pixels Type': Pixels.Type,\n          'Pixels Size (XYZ)': sizes,\n          'Z-sections/Timepoints': `${Pixels.SizeZ} x ${Pixels.SizeT}`,\n          Channels: Pixels.SizeC\n        };\n      }\n    };\n  });\n}\n\nexport type OMEXML = ReturnType<typeof fromString>;\nexport type DimensionOrder = 'XYZCT' | 'XYZTC' | 'XYCTZ' | 'XYCZT' | 'XYTCZ' | 'XYTZC';\n\n// Structure of node is determined by the PARSER_OPTIONS.\ntype Node<T, A> = T & {attr: A};\ntype Attrs<Fields extends string, T = string> = {[K in Fields]: T};\n\ntype OMEAttrs = Attrs<'xmlns' | 'xmlns:xsi' | 'xsi:schemaLocation'>;\ntype OME = Node<{Insturment: Insturment; Image: Image | Image[]}, OMEAttrs>;\n\ntype Insturment = Node<\n  {Objective: Node<{}, Attrs<'ID' | 'Model' | 'NominalMagnification'>>},\n  Attrs<'ID'>\n>;\n\ninterface ImageNodes {\n  AquisitionDate?: string;\n  Description?: string;\n  Pixels: Pixels;\n  InstrumentRef: Node<{}, {ID: string}>;\n  ObjectiveSettings: Node<{}, {ID: string}>;\n}\ntype Image = Node<ImageNodes, Attrs<'ID' | 'Name'>>;\n\ntype PixelType =\n  | 'int8'\n  | 'int16'\n  | 'int32'\n  | 'uint8'\n  | 'uint16'\n  | 'uint32'\n  | 'float'\n  | 'bit'\n  | 'double'\n  | 'complex'\n  | 'double-complex';\n\nexport type UnitsLength =\n  | 'Ym'\n  | 'Zm'\n  | 'Em'\n  | 'Pm'\n  | 'Tm'\n  | 'Gm'\n  | 'Mm'\n  | 'km'\n  | 'hm'\n  | 'dam'\n  | 'm'\n  | 'dm'\n  | 'cm'\n  | 'mm'\n  | 'µm'\n  | 'nm'\n  | 'pm'\n  | 'fm'\n  | 'am'\n  | 'zm'\n  | 'ym'\n  | 'Å'\n  | 'thou'\n  | 'li'\n  | 'in'\n  | 'ft'\n  | 'yd'\n  | 'mi'\n  | 'ua'\n  | 'ly'\n  | 'pc'\n  | 'pt'\n  | 'pixel'\n  | 'reference frame';\n\ntype PhysicalSize<Name extends string> = `PhysicalSize${Name}`;\ntype PhysicalSizeUnit<Name extends string> = `PhysicalSize${Name}Unit`;\ntype Size<Names extends string> = `Size${Names}`;\n\ntype PixelAttrs = Attrs<\n  PhysicalSize<'X' | 'Y' | 'Z'> | 'SignificantBits' | Size<'T' | 'C' | 'Z' | 'Y' | 'X'>,\n  number\n> &\n  Attrs<PhysicalSizeUnit<'X' | 'Y' | 'Z'>, UnitsLength> &\n  Attrs<'BigEndian' | 'Interleaved', boolean> & {\n    ID: string;\n    DimensionOrder: DimensionOrder;\n    Type: PixelType;\n  };\n\ntype Pixels = Node<\n  {\n    Channel: Channel | Channel[];\n    TiffData: Node<{}, Attrs<'IFD' | 'PlaneCount'>>;\n  },\n  PixelAttrs\n>;\n\ntype ChannelAttrs =\n  | {\n      ID: string;\n      SamplesPerPixel: number;\n      Name?: string;\n    }\n  | {\n      ID: string;\n      SamplesPerPixel: number;\n      Name?: string;\n      Color: number;\n    };\n\ntype Channel = Node<{}, ChannelAttrs>;\n\ntype Root = {OME: OME};\n"],"mappings":"AAAA,SAAQA,SAAS,QAAO,iBAAiB;AAAC,SAClCC,WAAW,EAAEC,SAAS;AAG9B,MAAMC,SAAS,GAAG,IAAIH,SAAS,CAAC;EAE9BI,mBAAmB,EAAE,EAAE;EACvBC,mBAAmB,EAAE,MAAM;EAG3BC,aAAa,EAAE,IAAI;EACnBC,mBAAmB,EAAE,IAAI;EAGzBC,gBAAgB,EAAE;AACpB,CAAC,CAAC;AAEF,MAAMC,KAAK,GAAIC,GAAW,IAAWP,SAAS,CAACM,KAAK,CAACC,GAAG,CAAC;AAEzD,OAAO,SAASC,UAAUA,CAACD,GAAW,EAAE;EACtC,MAAME,GAAG,GAAGH,KAAK,CAACC,GAAG,CAAC;EACtB,IAAI,CAACE,GAAG,CAACC,GAAG,EAAE;IACZ,MAAMC,KAAK,CAAC,mCAAmC,CAAC;EAClD;EACA,OAAOb,WAAW,CAACW,GAAG,CAACC,GAAG,CAACE,KAAK,CAAC,CAACC,GAAG,CAAEC,GAAG,IAAK;IAC7C,MAAMC,QAAQ,GAAGjB,WAAW,CAACgB,GAAG,CAACE,MAAM,CAACC,OAAO,CAAC,CAACJ,GAAG,CAAEK,CAAC,IAAK;MAC1D,IAAI,OAAO,IAAIA,CAAC,CAACC,IAAI,EAAE;QACrB,OAAO;UAAC,GAAGD,CAAC,CAACC,IAAI;UAAEC,KAAK,EAAErB,SAAS,CAACmB,CAAC,CAACC,IAAI,CAACC,KAAK;QAAC,CAAC;MACpD;MACA,OAAO;QAAC,GAAGF,CAAC,CAACC;MAAI,CAAC;IACpB,CAAC,CAAC;IACF,MAAM;MAACE,cAAc,GAAG,EAAE;MAAEC,WAAW,GAAG;IAAE,CAAC,GAAGR,GAAG;IACnD,MAAMS,KAAK,GAAG;MACZ,GAAGT,GAAG,CAACK,IAAI;MACXE,cAAc;MACdC,WAAW;MACXN,MAAM,EAAE;QACN,GAAGF,GAAG,CAACE,MAAM,CAACG,IAAI;QAClBJ;MACF;IACF,CAAC;IACD,OAAO;MACL,GAAGQ,KAAK;MACRC,MAAMA,CAAA,EAAG;QACP,MAAM;UAACR;QAAM,CAAC,GAAGO,KAAK;QAEtB,MAAME,KAAK,GAAI,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAC3BZ,GAAG,CAAEa,IAAI,IAAK;UACb,MAAMC,IAAI,GAAGX,MAAM,CAAE,eAAcU,IAAK,EAAC,CAAU;UACnD,MAAME,IAAI,GAAGZ,MAAM,CAAE,eAAcU,IAAK,MAAK,CAAU;UACvD,OAAOC,IAAI,IAAIC,IAAI,GAAI,GAAED,IAAK,IAAGC,IAAK,EAAC,GAAG,GAAG;QAC/C,CAAC,CAAC,CACDC,IAAI,CAAC,KAAK,CAAC;QAEd,OAAO;UACL,kBAAkB,EAAEN,KAAK,CAACF,cAAc;UACxC,iBAAiB,EAAG,GAAEL,MAAM,CAACc,KAAM,MAAKd,MAAM,CAACe,KAAM,EAAC;UACtD,aAAa,EAAEf,MAAM,CAACgB,IAAI;UAC1B,mBAAmB,EAAEP,KAAK;UAC1B,uBAAuB,EAAG,GAAET,MAAM,CAACiB,KAAM,MAAKjB,MAAM,CAACkB,KAAM,EAAC;UAC5DnB,QAAQ,EAAEC,MAAM,CAACmB;QACnB,CAAC;MACH;IACF,CAAC;EACH,CAAC,CAAC;AACJ"}

package/dist/lib/ome/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":["getLabels","dimOrder","toLowerCase","split","reverse","getDims","labels","lookup","Map","map","name","i","size","length","Error","index","get","undefined"],"sources":["../../../src/lib/ome/utils.ts"],"sourcesContent":["import type {OMEXML} from '../ome/omexml';\nimport type {Labels} from '../../types';\n\n/*\n * Creates typed labels from DimensionOrder.\n * > imgMeta.Pixels.DimensionOrder === 'XYCZT'\n * > getLabels(imgMeta.Pixels) === ['t', 'z', 'c', 'y', 'x']\n */\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\ntype Sel<Dim extends string> = Dim extends `${infer Z}${infer X}${infer A}${infer B}${infer C}`\n  ? [C, B, A]\n  : 'error';\nexport function getLabels(dimOrder: OMEXML[0]['Pixels']['DimensionOrder']) {\n  return dimOrder.toLowerCase().split('').reverse() as Labels<Sel<Lowercase<typeof dimOrder>>>;\n}\n\n/*\n * Creates an ES6 map of 'label' -> index\n * > const labels = ['a', 'b', 'c', 'd'];\n * > const dims = getDims(labels);\n * > dims('a') === 0;\n * > dims('b') === 1;\n * > dims('c') === 2;\n * > dims('hi!'); // throws\n */\nexport function getDims<S extends string>(labels: S[]) {\n  const lookup = new Map(labels.map((name, i) => [name, i]));\n  if (lookup.size !== labels.length) {\n    throw Error('Labels must be unique, found duplicated label.');\n  }\n  return (name: S) => {\n    const index = lookup.get(name);\n    if (index === undefined) {\n      throw Error('Invalid dimension.');\n    }\n    return index;\n  };\n}\n"],"mappings":"AAaA,OAAO,SAASA,SAASA,CAACC,QAA+C,EAAE;EACzE,OAAOA,QAAQ,CAACC,WAAW,CAAC,CAAC,CAACC,KAAK,CAAC,EAAE,CAAC,CAACC,OAAO,CAAC,CAAC;AACnD;AAWA,OAAO,SAASC,OAAOA,CAAmBC,MAAW,EAAE;EACrD,MAAMC,MAAM,GAAG,IAAIC,GAAG,CAACF,MAAM,CAACG,GAAG,CAAC,CAACC,IAAI,EAAEC,CAAC,KAAK,CAACD,IAAI,EAAEC,CAAC,CAAC,CAAC,CAAC;EAC1D,IAAIJ,MAAM,CAACK,IAAI,KAAKN,MAAM,CAACO,MAAM,EAAE;IACjC,MAAMC,KAAK,CAAC,gDAAgD,CAAC;EAC/D;EACA,OAAQJ,IAAO,IAAK;IAClB,MAAMK,KAAK,GAAGR,MAAM,CAACS,GAAG,CAACN,IAAI,CAAC;IAC9B,IAAIK,KAAK,KAAKE,SAAS,EAAE;MACvB,MAAMH,KAAK,CAAC,oBAAoB,CAAC;IACnC;IACA,OAAOC,KAAK;EACd,CAAC;AACH"}

package/dist/{esm/lib → lib}/tiff-pixel-source.js

@@ -1,13 +1,12 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { getImageSize, isInterleaved, SIGNAL_ABORTED } from './utils/tiff-utils';
+import { getImageSize, isInterleaved, SIGNAL_ABORTED } from "./utils/tiff-utils.js";
 class TiffPixelSource {
   constructor(indexer, dtype, tileSize, shape, labels, meta) {
-    _defineProperty(this, "dtype", void 0);
-    _defineProperty(this, "tileSize", void 0);
-    _defineProperty(this, "shape", void 0);
-    _defineProperty(this, "labels", void 0);
-    _defineProperty(this, "meta", void 0);
-    _defineProperty(this, "_indexer", void 0);
+    this.dtype = void 0;
+    this.tileSize = void 0;
+    this.shape = void 0;
+    this.labels = void 0;
+    this.meta = void 0;
+    this._indexer = void 0;
     this._indexer = indexer;
     this.dtype = dtype;
     this.tileSize = tileSize;

package/dist/lib/tiff-pixel-source.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiff-pixel-source.js","names":["getImageSize","isInterleaved","SIGNAL_ABORTED","TiffPixelSource","constructor","indexer","dtype","tileSize","shape","labels","meta","_indexer","getRaster","_ref","selection","signal","image","_readRasters","getTile","_ref2","x","y","height","width","_getTileExtent","x0","y0","window","props","_props$signal","interleave","raster","readRasters","aborted","data","zoomLevelHeight","zoomLevelWidth","maxXTileCoord","Math","floor","maxYTileCoord","onTileError","err","console","error"],"sources":["../../src/lib/tiff-pixel-source.ts"],"sourcesContent":["import type {GeoTIFFImage, RasterOptions} from 'geotiff';\nimport {getImageSize, isInterleaved, SIGNAL_ABORTED} from './utils/tiff-utils';\n\nimport type {\n  PixelSource,\n  PixelSourceSelection,\n  PixelSourceMeta,\n  Dtype,\n  Labels,\n  RasterSelection,\n  TileSelection,\n  PixelData,\n  TypedArray\n} from '../types';\n\nclass TiffPixelSource<S extends string[]> implements PixelSource<S> {\n  public dtype: Dtype;\n  public tileSize: number;\n  public shape: number[];\n  public labels: Labels<S>;\n  public meta: PixelSourceMeta | undefined;\n  private _indexer: (sel: PixelSourceSelection<S>) => Promise<GeoTIFFImage>;\n\n  // eslint-disable-next-line max-params\n  constructor(\n    indexer: (sel: PixelSourceSelection<S>) => Promise<GeoTIFFImage>,\n    dtype: Dtype,\n    tileSize: number,\n    shape: number[],\n    labels: Labels<S>,\n    meta?: PixelSourceMeta\n  ) {\n    this._indexer = indexer;\n    this.dtype = dtype;\n    this.tileSize = tileSize;\n    this.shape = shape;\n    this.labels = labels;\n    this.meta = meta;\n  }\n\n  async getRaster({selection, signal}: RasterSelection<S>) {\n    const image = await this._indexer(selection);\n    return this._readRasters(image, {signal});\n  }\n\n  async getTile({x, y, selection, signal}: TileSelection<S>) {\n    const {height, width} = this._getTileExtent(x, y);\n    const x0 = x * this.tileSize;\n    const y0 = y * this.tileSize;\n    const window = [x0, y0, x0 + width, y0 + height];\n\n    const image = await this._indexer(selection);\n    return this._readRasters(image, {window, width, height, signal});\n  }\n\n  private async _readRasters(image: GeoTIFFImage, props?: RasterOptions) {\n    const interleave = isInterleaved(this.shape);\n    const raster = await image.readRasters({interleave, ...props});\n\n    if (props?.signal?.aborted) {\n      throw SIGNAL_ABORTED;\n    }\n\n    /*\n     * geotiff.js returns objects with different structure\n     * depending on `interleave`. It's weird, but this seems to work.\n     */\n    const data = (interleave ? raster : raster[0]) as TypedArray;\n    return {\n      data,\n      width: raster.width,\n      height: raster.height\n    } as PixelData;\n  }\n\n  /*\n   * Computes tile size given x, y coord.\n   */\n  private _getTileExtent(x: number, y: number) {\n    const {height: zoomLevelHeight, width: zoomLevelWidth} = getImageSize(this);\n    let height = this.tileSize;\n    let width = this.tileSize;\n    const maxXTileCoord = Math.floor(zoomLevelWidth / this.tileSize);\n    const maxYTileCoord = Math.floor(zoomLevelHeight / this.tileSize);\n    if (x === maxXTileCoord) {\n      width = zoomLevelWidth % this.tileSize;\n    }\n    if (y === maxYTileCoord) {\n      height = zoomLevelHeight % this.tileSize;\n    }\n    return {height, width};\n  }\n\n  onTileError(err: Error) {\n    console.error(err); // eslint-disable-line no-console\n  }\n}\n\nexport default TiffPixelSource;\n"],"mappings":"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"}

package/dist/{esm/lib → lib}/utils/Pool.js

@@ -1,13 +1,12 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 var _globalThis$navigator, _globalThis$navigator2;
 const defaultPoolSize = (_globalThis$navigator = globalThis === null || globalThis === void 0 ? void 0 : (_globalThis$navigator2 = globalThis.navigator) === null || _globalThis$navigator2 === void 0 ? void 0 : _globalThis$navigator2.hardwareConcurrency) !== null && _globalThis$navigator !== void 0 ? _globalThis$navigator : 4;
 export default class Pool {
   constructor() {
     let size = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultPoolSize;
-    _defineProperty(this, "workers", void 0);
-    _defineProperty(this, "idleWorkers", void 0);
-    _defineProperty(this, "waitQueue", void 0);
-    _defineProperty(this, "decoder", void 0);
+    this.workers = void 0;
+    this.idleWorkers = void 0;
+    this.waitQueue = void 0;
+    this.decoder = void 0;
     this.workers = [];
     this.idleWorkers = [];
     this.waitQueue = [];