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

package/dist/bundle.js

@@ -1,26 +1,4 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const moduleExports = __importStar(require("./index"));
-// @ts-ignore
+import * as moduleExports from './index';
 globalThis.loaders = globalThis.loaders || {};
-// @ts-ignore
 module.exports = Object.assign(globalThis.loaders, moduleExports);
+//# sourceMappingURL=bundle.js.map

package/dist/bundle.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/bundle.ts"],"names":["moduleExports","globalThis","loaders","module","exports","Object","assign"],"mappings":"AAAA,OAAO,KAAKA,aAAZ,MAA+B,SAA/B;AAEAC,UAAU,CAACC,OAAX,GAAqBD,UAAU,CAACC,OAAX,IAAsB,EAA3C;AAEAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,OAAzB,EAAkCF,aAAlC,CAAjB","sourcesContent":["import * as moduleExports from './index';\n// @ts-ignore\nglobalThis.loaders = globalThis.loaders || {};\n// @ts-ignore\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"file":"bundle.js"}

package/dist/index.js

@@ -1,10 +1,3 @@
-"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; } });
+export { loadGeoTiff } from './lib/load-geotiff';
+export { default as TiffPixelSource } from './lib/tiff-pixel-source';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

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

package/dist/lib/load-geotiff.js

@@ -1,57 +1,32 @@
-"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.');
+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.');
 }
-exports.loadGeoTiff = loadGeoTiff;
+//# sourceMappingURL=load-geotiff.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/load-geotiff.ts"],"names":["fromUrl","fromBlob","GeoTIFF","createOffsetsProxy","checkProxies","loadOmeTiff","isOmeTiff","loadGeoTiff","source","opts","headers","offsets","tiff","firstImage","getImage","Error"],"mappings":"AAAA,SAAQA,OAAR,EAAiBC,QAAjB,EAA2BC,OAA3B,QAAyC,SAAzC;AAEA,SAEEC,kBAFF,EAGEC,YAHF,QAIO,iBAJP;AAOA,SAAQC,WAAR,EAAqBC,SAArB,QAAqC,qBAArC;AA4BA,OAAO,eAAeC,WAAf,CACLC,MADK,EAELC,IAAoB,GAAG,EAFlB,EAGiB;AACtB,QAAM;AAACC,IAAAA,OAAD;AAAUC,IAAAA;AAAV,MAAqBF,IAA3B;AAGA,MAAIG,IAAJ;;AACA,MAAIJ,MAAM,YAAYN,OAAtB,EAA+B;AAC7BU,IAAAA,IAAI,GAAGJ,MAAP;AACD,GAFD,MAEO,IAAI,OAAOA,MAAP,KAAkB,QAAtB,EAAgC;AACrCI,IAAAA,IAAI,GAAG,MAAMZ,OAAO,CAACQ,MAAD,EAASE,OAAT,CAApB;AACD,GAFM,MAEA;AACLE,IAAAA,IAAI,GAAG,MAAMX,QAAQ,CAACO,MAAD,CAArB;AACD;;AAUD,MAAIG,OAAJ,EAAa;AAMXC,IAAAA,IAAI,GAAGT,kBAAkB,CAACS,IAAD,EAAOD,OAAP,CAAzB;AACD;;AAMDP,EAAAA,YAAY,CAACQ,IAAD,CAAZ;AAEA,QAAMC,UAAU,GAAG,MAAMD,IAAI,CAACE,QAAL,CAAc,CAAd,CAAzB;;AAEA,MAAIR,SAAS,CAACO,UAAD,CAAb,EAA2B;AACzB,WAAOR,WAAW,CAACO,IAAD,EAAOC,UAAP,CAAlB;AACD;;AAED,QAAM,IAAIE,KAAJ,CAAU,yBAAV,CAAN;AACD","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"],"file":"load-geotiff.js"}

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

@@ -1,46 +1,51 @@
-"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 };
+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
+  };
 }
-exports.loadOmeTiff = loadOmeTiff;
+//# sourceMappingURL=load-ome-tiff.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/ome/load-ome-tiff.ts"],"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"],"mappings":"AAEA,OAAOA,eAAP,MAA4B,sBAA5B;AACA,SAAQC,mBAAR,EAA6BC,mBAA7B,QAAuE,gBAAvE;AACA,SAAQC,qBAAR,QAAoC,aAApC;AACA,SAAQC,UAAR,QAAyB,UAAzB;AAGA,OAAO,MAAMC,SAAS,GAAIC,GAAD,IAAuBA,GAAG,CAACC,aAAJ,CAAkBC,gBAAlB,CAAmCC,QAAnC,CAA4C,MAA5C,CAAzC;AAEP,OAAO,eAAeC,WAAf,CAA2BC,IAA3B,EAA0CC,UAA1C,EAAoE;AAEzE,QAAM;AACJJ,IAAAA,gBADI;AAEJK,IAAAA,OAFI;AAGJC,IAAAA,yBAAyB,EAAEC;AAHvB,MAIFH,UAAU,CAACL,aAJf;AAKA,QAAMS,MAAM,GAAGZ,UAAU,CAACI,gBAAD,CAAzB;AAMA,MAAIS,MAAJ;AACA,MAAIC,cAAJ;;AAEA,MAAIL,OAAJ,EAAa;AAEXI,IAAAA,MAAM,GAAGJ,OAAO,CAACM,MAAR,GAAiB,CAA1B;AACAD,IAAAA,cAAc,GAAGhB,mBAAmB,CAACS,IAAD,EAAOK,MAAP,CAApC;AACD,GAJD,MAIO;AAELC,IAAAA,MAAM,GAAGD,MAAM,CAACG,MAAhB;AACAD,IAAAA,cAAc,GAAGjB,mBAAmB,CAACU,IAAD,EAAOK,MAAP,CAApC;AACD;;AAGD,QAAMI,OAAO,GAAGJ,MAAM,CAAC,CAAD,CAAtB;AACA,QAAM;AAACK,IAAAA,MAAD;AAASC,IAAAA,QAAT;AAAmBC,IAAAA,aAAnB;AAAkCC,IAAAA;AAAlC,MAA2CrB,qBAAqB,CAACiB,OAAD,CAAtE;AACA,QAAMK,QAAQ,GAAGb,UAAU,CAACc,YAAX,EAAjB;AACA,QAAMC,IAAI,GAAG;AAACZ,IAAAA,yBAAD;AAA4BQ,IAAAA;AAA5B,GAAb;AAEA,QAAMK,IAAI,GAAGC,KAAK,CAACC,IAAN,CAAW;AAACX,IAAAA,MAAM,EAAEF;AAAT,GAAX,EAA6Bc,GAA7B,CAAiC,CAACC,CAAD,EAAIC,UAAJ,KAAmB;AAC/D,UAAMC,KAAK,GAAGZ,QAAQ,CAACW,UAAD,CAAtB;;AACA,UAAME,OAAO,GAAIC,GAAD,IAA2BlB,cAAc,CAACkB,GAAD,EAAMH,UAAN,CAAzD;;AACA,UAAMI,MAAM,GAAG,IAAIrC,eAAJ,CAAoBmC,OAApB,EAA6BX,KAA7B,EAAoCC,QAApC,EAA8CS,KAA9C,EAAqDb,MAArD,EAA6DM,IAA7D,CAAf;AACA,WAAOU,MAAP;AACD,GALY,CAAb;AAOA,SAAO;AAACT,IAAAA,IAAD;AAAOU,IAAAA,QAAQ,EAAElB;AAAjB,GAAP;AACD","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"],"file":"load-ome-tiff.js"}

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

@@ -1,108 +1,116 @@
-"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 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);
+  };
 }
-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);
-    };
+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.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 ${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 ".concat(DimensionOrder, "."));
+      }
+  }
 }
+//# sourceMappingURL=ome-indexers.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/ome/ome-indexers.ts"],"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"],"mappings":"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","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"],"file":"ome-indexers.js"}

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

@@ -1,63 +1,73 @@
-"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'
+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'
 };
-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);
-    }
-    // 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;
+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.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 };
+
+    if (Pixels.PhysicalSizeZ) {
+      physicalSizes.z = {
+        size: Pixels.PhysicalSizeZ,
+        unit: Pixels.PhysicalSizeZUnit
+      };
     }
-    return { labels, getShape, dtype };
+
+    return {
+      labels,
+      getShape,
+      physicalSizes,
+      dtype
+    };
+  }
+
+  return {
+    labels,
+    getShape,
+    dtype
+  };
 }
-exports.getOmePixelSourceMeta = getOmePixelSourceMeta;
+//# sourceMappingURL=ome-utils.js.map