@loaders.gl/geotiff 4.0.0-alpha.1 → 4.0.0-alpha.11

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.d.ts

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

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAC,OAAO,IAAI,eAAe,EAAC,MAAM,yBAAyB,CAAC"}

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.d.ts

@@ -0,0 +1,28 @@
+import { GeoTIFF } from 'geotiff';
+import type TiffPixelSource from './tiff-pixel-source';
+/** Options for initializing a tiff pixel source. */
+interface GeoTIFFOptions {
+    /** Headers passed to each underlying request. */
+    headers?: Record<string, unknown>;
+    /** Performance enhancment to index the remote tiff source using pre-computed byte-offsets. Generated via https://github.com/ilan-gold/generate-tiff-offsets */
+    offsets?: number[];
+    /** Indicates whether a multi-threaded pool of image decoders should be used to decode tiles. */
+    pool?: boolean;
+}
+interface GeoTIFFData {
+    data: TiffPixelSource<string[]>[];
+    metadata: Record<string, unknown>;
+}
+/**
+ * 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.
+ */
+export declare function loadGeoTiff(source: string | Blob | GeoTIFF, opts?: GeoTIFFOptions): Promise<GeoTIFFData>;
+export {};
+//# sourceMappingURL=load-geotiff.d.ts.map

package/dist/lib/load-geotiff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-geotiff.d.ts","sourceRoot":"","sources":["../../src/lib/load-geotiff.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,OAAO,EAAC,MAAM,SAAS,CAAC;AAUnD,OAAO,KAAK,eAAe,MAAM,qBAAqB,CAAC;AAEvD,oDAAoD;AACpD,UAAU,cAAc;IACtB,iDAAiD;IACjD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,+JAA+J;IAC/J,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,gGAAgG;IAChG,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,UAAU,WAAW;IACnB,IAAI,EAAE,eAAe,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC;IAClC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,EAC/B,IAAI,GAAE,cAAmB,GACxB,OAAO,CAAC,WAAW,CAAC,CA2CtB"}

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';
+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.d.ts

@@ -0,0 +1,50 @@
+import type { GeoTIFF, GeoTIFFImage } from 'geotiff';
+import TiffPixelSource from '../tiff-pixel-source';
+export declare const isOmeTiff: (img: GeoTIFFImage) => boolean;
+export declare function loadOmeTiff(tiff: GeoTIFF, firstImage: GeoTIFFImage): Promise<{
+    data: TiffPixelSource<["t", "c", "z"] | ["c", "t", "z"] | ["z", "t", "c"] | ["t", "z", "c"] | ["z", "c", "t"] | ["c", "z", "t"]>[];
+    metadata: {
+        format(): {
+            'Acquisition Date': string;
+            'Dimensions (XY)': string;
+            'Pixels Type': "uint8" | "uint16" | "uint32" | "float" | "double" | "int8" | "int16" | "int32" | "bit" | "complex" | "double-complex";
+            'Pixels Size (XYZ)': string;
+            'Z-sections/Timepoints': string;
+            Channels: number;
+        };
+        AquisitionDate: string;
+        Description: string;
+        Pixels: {
+            Channels: ({
+                Color: [number, number, number, number];
+                ID: string;
+                SamplesPerPixel: number;
+                Name?: string | undefined;
+            } | {
+                ID: string;
+                SamplesPerPixel: number;
+                Name?: string | undefined;
+            })[];
+            PhysicalSizeX: number;
+            PhysicalSizeY: number;
+            PhysicalSizeZ: number;
+            SignificantBits: number;
+            SizeX: number;
+            SizeY: number;
+            SizeZ: number;
+            SizeT: number;
+            SizeC: number;
+            PhysicalSizeXUnit: import("./omexml").UnitsLength;
+            PhysicalSizeYUnit: import("./omexml").UnitsLength;
+            PhysicalSizeZUnit: import("./omexml").UnitsLength;
+            BigEndian: boolean;
+            Interleaved: boolean;
+            ID: string;
+            DimensionOrder: import("./omexml").DimensionOrder;
+            Type: "uint8" | "uint16" | "uint32" | "float" | "double" | "int8" | "int16" | "int32" | "bit" | "complex" | "double-complex";
+        };
+        ID: string;
+        Name: string;
+    };
+}>;
+//# sourceMappingURL=load-ome-tiff.d.ts.map

package/dist/lib/ome/load-ome-tiff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-ome-tiff.d.ts","sourceRoot":"","sources":["../../../src/lib/ome/load-ome-tiff.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,OAAO,EAAE,YAAY,EAAC,MAAM,SAAS,CAAC;AAEnD,OAAO,eAAe,MAAM,sBAAsB,CAAC;AAMnD,eAAO,MAAM,SAAS,QAAS,YAAY,YAAwD,CAAC;AAEpG,wBAAsB,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCxE"}

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

@@ -0,0 +1,11 @@
+import type { GeoTIFFImage, GeoTIFF } from 'geotiff';
+import type { OMEXML } from '../ome/omexml';
+export type OmeTiffSelection = {
+    t: number;
+    c: number;
+    z: number;
+};
+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

@@ -0,0 +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,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.d.ts

@@ -0,0 +1,28 @@
+import type { OMEXML, UnitsLength } from './omexml';
+export declare const DTYPE_LOOKUP: {
+    readonly uint8: "Uint8";
+    readonly uint16: "Uint16";
+    readonly uint32: "Uint32";
+    readonly float: "Float32";
+    readonly double: "Float64";
+    readonly int8: "Int8";
+    readonly int16: "Int16";
+    readonly int32: "Int32";
+};
+export declare function getOmePixelSourceMeta({ Pixels }: OMEXML[0]): {
+    labels: import("../../types").Labels<["t", "c", "z"] | ["c", "t", "z"] | ["z", "t", "c"] | ["t", "z", "c"] | ["z", "c", "t"] | ["c", "z", "t"]>;
+    getShape: (level: number) => number[];
+    physicalSizes: {
+        [k: string]: {
+            size: number;
+            unit: UnitsLength;
+        };
+    };
+    dtype: "Uint8" | "Uint16" | "Uint32" | "Float32" | "Float64" | "Int8" | "Int16" | "Int32";
+} | {
+    labels: import("../../types").Labels<["t", "c", "z"] | ["c", "t", "z"] | ["z", "t", "c"] | ["t", "z", "c"] | ["z", "c", "t"] | ["c", "z", "t"]>;
+    getShape: (level: number) => number[];
+    dtype: "Uint8" | "Uint16" | "Uint32" | "Float32" | "Float64" | "Int8" | "Int16" | "Int32";
+    physicalSizes?: undefined;
+};
+//# sourceMappingURL=ome-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ome-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/ome/ome-utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,MAAM,EAAE,WAAW,EAAC,MAAM,UAAU,CAAC;AAElD,eAAO,MAAM,YAAY;;;;;;;;;CASf,CAAC;AAEX,wBAAgB,qBAAqB,CAAC,EAAC,MAAM,EAAC,EAAE,MAAM,CAAC,CAAC,CAAC;;sBAoB9B,MAAM;;;kBAcP,MAAM;kBAAQ,WAAW;;;;;;sBAdxB,MAAM;;;EAmChC"}