@loaders.gl/geotiff 4.0.0-alpha.5 → 4.0.0-alpha.6

package/dist/esm/typings/geotiff.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=geotiff.js.map

package/dist/esm/typings/geotiff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geotiff.js","names":[],"sources":["../../../src/typings/geotiff.ts"],"sourcesContent":["declare type TypedArray = import('../types').TypedArray;\n\ndeclare module 'geotiff' {\n  function fromUrl(url: string, headers?: Record<string, unknown>): Promise<GeoTIFF>;\n  function fromBlob(blob: Blob): Promise<GeoTIFF>;\n  function fromFile(path: string): Promise<GeoTIFF>;\n\n  class GeoTIFF {\n    readRasters(options?: RasterOptions): Promise<TypedArray>;\n    getImage(index: number): Promise<GeoTIFFImage>;\n    parseFileDirectoryAt(offset: number): Promise<ImageFileDirectory>;\n    ifdRequests: {[key: number]: Promise<ImageFileDirectory>};\n    dataView: DataView;\n    littleEndian: boolean;\n    cache: any;\n    source: any;\n  }\n\n  interface Pool {\n    decode(fileDirectory: FileDirectory, buffer: ArrayBuffer): Promise<ArrayBuffer>;\n  }\n\n  interface RasterOptions {\n    window?: number[];\n    bbox?: number[];\n    samples?: number[];\n    interleave?: boolean;\n    pool?: Pool;\n    width?: number;\n    height?: number;\n    resampleMethod?: string;\n    enableAlpha?: boolean;\n    signal?: AbortSignal;\n  }\n\n  type RasterData = (TypedArray | TypedArray[]) & {\n    width: number;\n    height: number;\n  };\n  class GeoTIFFImage {\n    constructor(\n      fileDirectory: FileDirectory,\n      geoKeyDirectory: any,\n      dataView: DataView,\n      littleEndian: boolean,\n      cache: any,\n      source: any\n    );\n    fileDirectory: FileDirectory;\n    getBoundingBox(): number[];\n    getFileDirectory(): FileDirectory;\n    getBytesPerPixel(): number;\n    getHeight(): number;\n    getSamplesPerPixel(): number;\n    getTileHeight(): number;\n    getTileWidth(): number;\n    getWidth(): number;\n    readRasters(options?: RasterOptions): Promise<RasterData>;\n  }\n\n  interface FileDirectory {\n    ImageDescription: string;\n    SubIFDs?: number[];\n    PhotometricInterpretation?: number;\n  }\n\n  interface ImageFileDirectory {\n    fileDirectory: FileDirectory;\n    geoKeyDirectory: any;\n  }\n}\n"],"mappings":""}

package/dist/index.js

@@ -1,3 +1,10 @@
-export { loadGeoTiff } from './lib/load-geotiff';
-export { default as TiffPixelSource } from './lib/tiff-pixel-source';
-//# sourceMappingURL=index.js.map
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TiffPixelSource = exports.loadGeoTiff = void 0;
+var load_geotiff_1 = require("./lib/load-geotiff");
+Object.defineProperty(exports, "loadGeoTiff", { enumerable: true, get: function () { return load_geotiff_1.loadGeoTiff; } });
+var tiff_pixel_source_1 = require("./lib/tiff-pixel-source");
+Object.defineProperty(exports, "TiffPixelSource", { enumerable: true, get: function () { return __importDefault(tiff_pixel_source_1).default; } });

package/dist/lib/load-geotiff.js

@@ -1,32 +1,57 @@
-import { fromUrl, fromBlob, GeoTIFF } from 'geotiff';
-import { createOffsetsProxy, checkProxies } from './utils/proxies';
-import { loadOmeTiff, isOmeTiff } from './ome/load-ome-tiff';
-export async function loadGeoTiff(source, opts = {}) {
-  const {
-    headers,
-    offsets
-  } = opts;
-  let tiff;
-
-  if (source instanceof GeoTIFF) {
-    tiff = source;
-  } else if (typeof source === 'string') {
-    tiff = await fromUrl(source, headers);
-  } else {
-    tiff = await 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.');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadGeoTiff = void 0;
+const geotiff_1 = require("geotiff");
+const proxies_1 = require("./utils/proxies");
+// import Pool from './lib/Pool.js';
+const load_ome_tiff_1 = require("./ome/load-ome-tiff");
+/**
+ * Opens an OME-TIFF via URL and returns data source and associated metadata for first image.
+ *
+ * @param source url string, File/Blob object, or GeoTIFF object
+ * @param opts options for initializing a tiff pixel source.
+ *  - `opts.headers` are passed to each underlying fetch request.
+ *  - `opts.offsets` are a performance enhancment to index the remote tiff source using pre-computed byte-offsets.
+ *  - `opts.pool` indicates whether a multi-threaded pool of image decoders should be used to decode tiles (default = true).
+ * @return data source and associated OME-Zarr metadata.
+ */
+async function loadGeoTiff(source, opts = {}) {
+    const { headers, offsets } = opts;
+    // Create tiff source
+    let tiff;
+    if (source instanceof geotiff_1.GeoTIFF) {
+        tiff = source;
+    }
+    else if (typeof source === 'string') {
+        tiff = await (0, geotiff_1.fromUrl)(source, headers);
+    }
+    else {
+        tiff = await (0, geotiff_1.fromBlob)(source);
+    }
+    // if (pool) {
+    /*
+     * Creates a worker pool to decode tiff tiles. Wraps tiff
+     * in a Proxy that injects 'pool' into `tiff.readRasters`.
+     */
+    // tiff = createPoolProxy(tiff, new Pool());
+    // }
+    if (offsets) {
+        /*
+         * Performance enhancement. If offsets are provided, we
+         * create a proxy that intercepts calls to `tiff.getImage`
+         * and injects the pre-computed offsets.
+         */
+        tiff = (0, proxies_1.createOffsetsProxy)(tiff, offsets);
+    }
+    /*
+     * Inspect tiff source for our performance enhancing proxies.
+     * Prints warnings to console if `offsets` or `pool` are missing.
+     */
+    (0, proxies_1.checkProxies)(tiff);
+    const firstImage = await tiff.getImage(0);
+    if ((0, load_ome_tiff_1.isOmeTiff)(firstImage)) {
+        return (0, load_ome_tiff_1.loadOmeTiff)(tiff, firstImage);
+    }
+    throw new Error('GeoTIFF not recognized.');
 }
-//# sourceMappingURL=load-geotiff.js.map
+exports.loadGeoTiff = loadGeoTiff;

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

@@ -1,51 +1,46 @@
-import TiffPixelSource from '../tiff-pixel-source';
-import { getOmeLegacyIndexer, getOmeSubIFDIndexer } from './ome-indexers';
-import { getOmePixelSourceMeta } from './ome-utils';
-import { fromString } from './omexml';
-export const isOmeTiff = img => img.fileDirectory.ImageDescription.includes('<OME');
-export 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 TiffPixelSource(indexer, dtype, tileSize, shape, labels, meta);
-    return source;
-  });
-  return {
-    data,
-    metadata: imgMeta
-  };
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadOmeTiff = exports.isOmeTiff = void 0;
+const tiff_pixel_source_1 = __importDefault(require("../tiff-pixel-source"));
+const ome_indexers_1 = require("./ome-indexers");
+const ome_utils_1 = require("./ome-utils");
+const omexml_1 = require("./omexml");
+const isOmeTiff = (img) => img.fileDirectory.ImageDescription.includes('<OME');
+exports.isOmeTiff = isOmeTiff;
+async function loadOmeTiff(tiff, firstImage) {
+    // Get first image from tiff and inspect OME-XML metadata
+    const { ImageDescription, SubIFDs, PhotometricInterpretation: photometricInterpretation } = firstImage.fileDirectory;
+    const omexml = (0, omexml_1.fromString)(ImageDescription);
+    /*
+     * Image pyramids are stored differently between versions of Bioformats.
+     * Thus we need a different indexer depending on which format we have.
+     */
+    let levels;
+    let pyramidIndexer;
+    if (SubIFDs) {
+        // Image is >= Bioformats 6.0 and resolutions are stored using SubIFDs.
+        levels = SubIFDs.length + 1;
+        pyramidIndexer = (0, ome_indexers_1.getOmeSubIFDIndexer)(tiff, omexml);
+    }
+    else {
+        // Image is legacy format; resolutions are stored as separate images.
+        levels = omexml.length;
+        pyramidIndexer = (0, ome_indexers_1.getOmeLegacyIndexer)(tiff, omexml);
+    }
+    // TODO: The OmeTIFF loader only works for the _first_ image in the metadata.
+    const imgMeta = omexml[0];
+    const { labels, getShape, physicalSizes, dtype } = (0, ome_utils_1.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_1.default(indexer, dtype, tileSize, shape, labels, meta);
+        return source;
+    });
+    return { data, metadata: imgMeta };
 }
-//# sourceMappingURL=load-ome-tiff.js.map
+exports.loadOmeTiff = loadOmeTiff;

package/dist/lib/ome/ome-indexers.d.ts

@@ -1,11 +1,11 @@
 import type { GeoTIFFImage, GeoTIFF } from 'geotiff';
 import type { OMEXML } from '../ome/omexml';
-export declare type OmeTiffSelection = {
+export type OmeTiffSelection = {
     t: number;
     c: number;
     z: number;
 };
-export declare type OmeTiffIndexer = (sel: OmeTiffSelection, z: number) => Promise<GeoTIFFImage>;
+export type OmeTiffIndexer = (sel: OmeTiffSelection, z: number) => Promise<GeoTIFFImage>;
 export declare function getOmeLegacyIndexer(tiff: GeoTIFF, rootMeta: OMEXML): OmeTiffIndexer;
 export declare function getOmeSubIFDIndexer(tiff: GeoTIFF, rootMeta: OMEXML): OmeTiffIndexer;
 //# sourceMappingURL=ome-indexers.d.ts.map

package/dist/lib/ome/ome-indexers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ome-indexers.d.ts","sourceRoot":"","sources":["../../../src/lib/ome/ome-indexers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAE,OAAO,EAAqB,MAAM,SAAS,CAAC;AACvE,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,eAAe,CAAC;AAE1C,oBAAY,gBAAgB,GAAG;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC,CAAC;AACjE,oBAAY,cAAc,GAAG,CAAC,GAAG,EAAE,gBAAgB,EAAE,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;AAqBzF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,cAAc,CAanF;AAgBD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,cAAc,CAuCnF"}
+{"version":3,"file":"ome-indexers.d.ts","sourceRoot":"","sources":["../../../src/lib/ome/ome-indexers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAE,OAAO,EAAqB,MAAM,SAAS,CAAC;AACvE,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,eAAe,CAAC;AAE1C,MAAM,MAAM,gBAAgB,GAAG;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC,CAAC;AACjE,MAAM,MAAM,cAAc,GAAG,CAAC,GAAG,EAAE,gBAAgB,EAAE,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;AAqBzF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,cAAc,CAanF;AAgBD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,cAAc,CAuCnF"}

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

@@ -1,116 +1,108 @@
-export 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);
-  };
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOmeSubIFDIndexer = exports.getOmeLegacyIndexer = void 0;
+/*
+ * An "indexer" for a GeoTIFF-based source is a function that takes a
+ * "selection" (e.g. { z, t, c }) and returns a Promise for the GeoTIFFImage
+ * object corresponding to that selection.
+ *
+ * For OME-TIFF images, the "selection" object is the same regardless of
+ * the format version. However, modern version of Bioformats have a different
+ * memory layout for pyramidal resolutions. Thus, we have two different "indexers"
+ * depending on which format version is detected.
+ *
+ * TODO: We currently only support indexing the first image in the OME-TIFF with
+ * our indexers. There can be multiple images in an OME-TIFF, so supporting these
+ * images will require extending these indexers or creating new methods.
+ */
+/*
+ * Returns an indexer for legacy Bioformats images. This assumes that
+ * downsampled resolutions are stored sequentially in the OME-TIFF.
+ */
+function getOmeLegacyIndexer(tiff, rootMeta) {
+    const imgMeta = rootMeta[0];
+    const { SizeT, SizeC, SizeZ } = imgMeta.Pixels;
+    const ifdIndexer = getOmeIFDIndexer(imgMeta);
+    return (sel, pyramidLevel) => {
+        // Get IFD index at base pyramid level
+        const index = ifdIndexer(sel);
+        // Get index of first image at pyramidal level
+        const pyramidIndex = pyramidLevel * SizeZ * SizeT * SizeC;
+        // Return image at IFD index for pyramidal level
+        return tiff.getImage(index + pyramidIndex);
+    };
 }
-export function getOmeSubIFDIndexer(tiff, rootMeta) {
-  const imgMeta = rootMeta[0];
-  const ifdIndexer = getOmeIFDIndexer(imgMeta);
-  const ifdCache = 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 = "".concat(sel.t, "-").concat(sel.c, "-").concat(sel.z, "-").concat(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);
-  };
+exports.getOmeLegacyIndexer = getOmeLegacyIndexer;
+/*
+ * Returns an indexer for modern Bioforamts images that store multiscale
+ * resolutions using SubIFDs.
+ *
+ * The ifdIndexer returns the 'index' to the base resolution for a
+ * particular 'selection'. The SubIFDs to the downsampled resolutions
+ * of the 'selection' are stored within the `baseImage.fileDirectory`.
+ * We use the SubIFDs to get the IFD for the corresponding sub-resolution.
+ *
+ * NOTE: This function create a custom IFD cache rather than mutating
+ * `GeoTIFF.ifdRequests` with a random offset. The IFDs are cached in
+ * an ES6 Map that maps a string key that identifies the selection uniquely
+ * to the corresponding IFD.
+ */
+function getOmeSubIFDIndexer(tiff, rootMeta) {
+    const imgMeta = rootMeta[0];
+    const ifdIndexer = getOmeIFDIndexer(imgMeta);
+    const ifdCache = new Map();
+    return async (sel, pyramidLevel) => {
+        const index = ifdIndexer(sel);
+        const baseImage = await tiff.getImage(index);
+        // It's the highest resolution, no need to look up SubIFDs.
+        if (pyramidLevel === 0) {
+            return baseImage;
+        }
+        const { SubIFDs } = baseImage.fileDirectory;
+        if (!SubIFDs) {
+            throw Error('Indexing Error: OME-TIFF is missing SubIFDs.');
+        }
+        // Get IFD for the selection at the pyramidal level
+        const key = `${sel.t}-${sel.c}-${sel.z}-${pyramidLevel}`;
+        if (!ifdCache.has(key)) {
+            // Only create a new request if we don't have the key.
+            const subIfdOffset = SubIFDs[pyramidLevel - 1];
+            ifdCache.set(key, tiff.parseFileDirectoryAt(subIfdOffset));
+        }
+        const ifd = (await ifdCache.get(key));
+        // Create a new image object manually from IFD
+        // https://github.com/geotiffjs/geotiff.js/blob/8ef472f41b51d18074aece2300b6a8ad91a21ae1/src/geotiff.js#L447-L453
+        return new baseImage.constructor(ifd.fileDirectory, ifd.geoKeyDirectory, tiff.dataView, tiff.littleEndian, tiff.cache, tiff.source);
+    };
 }
-
+exports.getOmeSubIFDIndexer = getOmeSubIFDIndexer;
+/*
+ * Returns a function that computes the image index based on the dimension
+ * order and dimension sizes.
+ */
 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 ".concat(DimensionOrder, "."));
-      }
-  }
+    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}.`);
+        }
+    }
 }
-//# sourceMappingURL=ome-indexers.js.map

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

@@ -1,73 +1,63 @@
-import { getDims, getLabels } from './utils';
-export const DTYPE_LOOKUP = {
-  uint8: 'Uint8',
-  uint16: 'Uint16',
-  uint32: 'Uint32',
-  float: 'Float32',
-  double: 'Float64',
-  int8: 'Int8',
-  int16: 'Int16',
-  int32: 'Int32'
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOmePixelSourceMeta = exports.DTYPE_LOOKUP = void 0;
+const utils_1 = require("./utils");
+exports.DTYPE_LOOKUP = {
+    uint8: 'Uint8',
+    uint16: 'Uint16',
+    uint32: 'Uint32',
+    float: 'Float32',
+    double: 'Float64',
+    int8: 'Int8',
+    int16: 'Int16',
+    int32: 'Int32'
 };
-export 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 ".concat(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
-      };
+function getOmePixelSourceMeta({ Pixels }) {
+    // e.g. 'XYZCT' -> ['t', 'c', 'z', 'y', 'x']
+    const labels = (0, utils_1.getLabels)(Pixels.DimensionOrder);
+    // Compute "shape" of image
+    const dims = (0, utils_1.getDims)(labels);
+    const shape = Array(labels.length).fill(0);
+    shape[dims('t')] = Pixels.SizeT;
+    shape[dims('c')] = Pixels.SizeC;
+    shape[dims('z')] = Pixels.SizeZ;
+    // Push extra dimension if data are interleaved.
+    if (Pixels.Interleaved) {
+        // @ts-ignore
+        labels.push('_c');
+        shape.push(3);
     }
-
-    return {
-      labels,
-      getShape,
-      physicalSizes,
-      dtype
+    // Creates a new shape for different level of pyramid.
+    // Assumes factor-of-two downsampling.
+    const getShape = (level) => {
+        const s = [...shape];
+        s[dims('x')] = Pixels.SizeX >> level;
+        s[dims('y')] = Pixels.SizeY >> level;
+        return s;
     };
-  }
-
-  return {
-    labels,
-    getShape,
-    dtype
-  };
+    if (!(Pixels.Type in exports.DTYPE_LOOKUP)) {
+        throw Error(`Pixel type ${Pixels.Type} not supported.`);
+    }
+    const dtype = exports.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 };
 }
-//# sourceMappingURL=ome-utils.js.map
+exports.getOmePixelSourceMeta = getOmePixelSourceMeta;

package/dist/lib/ome/omexml.d.ts

@@ -41,9 +41,9 @@ export declare function fromString(str: string): {
     ID: string;
     Name: string;
 }[];
-export declare type OMEXML = ReturnType<typeof fromString>;
-export declare type DimensionOrder = 'XYZCT' | 'XYZTC' | 'XYCTZ' | 'XYCZT' | 'XYTCZ' | 'XYTZC';
-declare type PixelType = 'int8' | 'int16' | 'int32' | 'uint8' | 'uint16' | 'uint32' | 'float' | 'bit' | 'double' | 'complex' | 'double-complex';
-export declare type UnitsLength = 'Ym' | 'Zm' | 'Em' | 'Pm' | 'Tm' | 'Gm' | 'Mm' | 'km' | 'hm' | 'dam' | 'm' | 'dm' | 'cm' | 'mm' | 'µm' | 'nm' | 'pm' | 'fm' | 'am' | 'zm' | 'ym' | 'Å' | 'thou' | 'li' | 'in' | 'ft' | 'yd' | 'mi' | 'ua' | 'ly' | 'pc' | 'pt' | 'pixel' | 'reference frame';
+export type OMEXML = ReturnType<typeof fromString>;
+export type DimensionOrder = 'XYZCT' | 'XYZTC' | 'XYCTZ' | 'XYCZT' | 'XYTCZ' | 'XYTZC';
+type PixelType = 'int8' | 'int16' | 'int32' | 'uint8' | 'uint16' | 'uint32' | 'float' | 'bit' | 'double' | 'complex' | 'double-complex';
+export type UnitsLength = 'Ym' | 'Zm' | 'Em' | 'Pm' | 'Tm' | 'Gm' | 'Mm' | 'km' | 'hm' | 'dam' | 'm' | 'dm' | 'cm' | 'mm' | 'µm' | 'nm' | 'pm' | 'fm' | 'am' | 'zm' | 'ym' | 'Å' | 'thou' | 'li' | 'in' | 'ft' | 'yd' | 'mi' | 'ua' | 'ly' | 'pc' | 'pt' | 'pixel' | 'reference frame';
 export {};
 //# sourceMappingURL=omexml.d.ts.map

package/dist/lib/ome/omexml.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"omexml.d.ts","sourceRoot":"","sources":["../../../src/lib/ome/omexml.ts"],"names":[],"mappings":"AAmBA,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA8CrC;AAED,oBAAY,MAAM,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC;AACnD,oBAAY,cAAc,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;AAuBvF,aAAK,SAAS,GACV,MAAM,GACN,OAAO,GACP,OAAO,GACP,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,OAAO,GACP,KAAK,GACL,QAAQ,GACR,SAAS,GACT,gBAAgB,CAAC;AAErB,oBAAY,WAAW,GACnB,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,KAAK,GACL,GAAG,GACH,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,GAAG,GACH,MAAM,GACN,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,OAAO,GACP,iBAAiB,CAAC"}
+{"version":3,"file":"omexml.d.ts","sourceRoot":"","sources":["../../../src/lib/ome/omexml.ts"],"names":[],"mappings":"AAmBA,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA8CrC;AAED,MAAM,MAAM,MAAM,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC;AACnD,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;AAuBvF,KAAK,SAAS,GACV,MAAM,GACN,OAAO,GACP,OAAO,GACP,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,OAAO,GACP,KAAK,GACL,QAAQ,GACR,SAAS,GACT,gBAAgB,CAAC;AAErB,MAAM,MAAM,WAAW,GACnB,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,KAAK,GACL,GAAG,GACH,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,GAAG,GACH,MAAM,GACN,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,OAAO,GACP,iBAAiB,CAAC"}