@loaders.gl/geotiff 3.1.0-beta.4 → 3.1.0

package/dist/es5/bundle.js

@@ -1,10 +1,12 @@
 "use strict";
 
+var _typeof = require("@babel/runtime/helpers/typeof");
+
 var moduleExports = _interopRequireWildcard(require("./index"));
 
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
 globalThis.loaders = globalThis.loaders || {};
 module.exports = Object.assign(globalThis.loaders, moduleExports);

package/dist/es5/bundle.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/bundle.ts"],"names":["globalThis","loaders","module","exports","Object","assign","moduleExports"],"mappings":";;AAAA;;;;;;AAEAA,UAAU,CAACC,OAAX,GAAqBD,UAAU,CAACC,OAAX,IAAsB,EAA3C;AAEAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,OAAzB,EAAkCK,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"}
+{"version":3,"sources":["../../src/bundle.ts"],"names":["globalThis","loaders","module","exports","Object","assign","moduleExports"],"mappings":";;;;AAAA;;;;;;AAEAA,UAAU,CAACC,OAAX,GAAqBD,UAAU,CAACC,OAAX,IAAsB,EAA3C;AAEAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,OAAzB,EAAkCK,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/es5/index.js

@@ -7,13 +7,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "loadGeoTiff", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _loadGeotiff.loadGeoTiff;
   }
 });
 Object.defineProperty(exports, "TiffPixelSource", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _tiffPixelSource.default;
   }
 });

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

@@ -1,42 +1,100 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.loadGeoTiff = loadGeoTiff;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
 var _geotiff = require("geotiff");
 
 var _proxies = require("./utils/proxies");
 
 var _loadOmeTiff = require("./ome/load-ome-tiff");
 
-async function loadGeoTiff(source, opts = {}) {
-  const {
-    headers,
-    offsets
-  } = opts;
-  let tiff;
-
-  if (source instanceof _geotiff.GeoTIFF) {
-    tiff = source;
-  } else if (typeof source === 'string') {
-    tiff = await (0, _geotiff.fromUrl)(source, headers);
-  } else {
-    tiff = await (0, _geotiff.fromBlob)(source);
-  }
-
-  if (offsets) {
-    tiff = (0, _proxies.createOffsetsProxy)(tiff, offsets);
-  }
-
-  (0, _proxies.checkProxies)(tiff);
-  const firstImage = await tiff.getImage(0);
-
-  if ((0, _loadOmeTiff.isOmeTiff)(firstImage)) {
-    return (0, _loadOmeTiff.loadOmeTiff)(tiff, firstImage);
-  }
-
-  throw new Error('GeoTIFF not recognized.');
+function loadGeoTiff(_x) {
+  return _loadGeoTiff.apply(this, arguments);
+}
+
+function _loadGeoTiff() {
+  _loadGeoTiff = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(source) {
+    var opts,
+        headers,
+        offsets,
+        tiff,
+        firstImage,
+        _args = arguments;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            opts = _args.length > 1 && _args[1] !== undefined ? _args[1] : {};
+            headers = opts.headers, offsets = opts.offsets;
+
+            if (!(source instanceof _geotiff.GeoTIFF)) {
+              _context.next = 6;
+              break;
+            }
+
+            tiff = source;
+            _context.next = 15;
+            break;
+
+          case 6:
+            if (!(typeof source === 'string')) {
+              _context.next = 12;
+              break;
+            }
+
+            _context.next = 9;
+            return (0, _geotiff.fromUrl)(source, headers);
+
+          case 9:
+            tiff = _context.sent;
+            _context.next = 15;
+            break;
+
+          case 12:
+            _context.next = 14;
+            return (0, _geotiff.fromBlob)(source);
+
+          case 14:
+            tiff = _context.sent;
+
+          case 15:
+            if (offsets) {
+              tiff = (0, _proxies.createOffsetsProxy)(tiff, offsets);
+            }
+
+            (0, _proxies.checkProxies)(tiff);
+            _context.next = 19;
+            return tiff.getImage(0);
+
+          case 19:
+            firstImage = _context.sent;
+
+            if (!(0, _loadOmeTiff.isOmeTiff)(firstImage)) {
+              _context.next = 22;
+              break;
+            }
+
+            return _context.abrupt("return", (0, _loadOmeTiff.loadOmeTiff)(tiff, firstImage));
+
+          case 22:
+            throw new Error('GeoTIFF not recognized.');
+
+          case 23:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _loadGeoTiff.apply(this, arguments);
 }
 //# sourceMappingURL=load-geotiff.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/load-geotiff.ts"],"names":["loadGeoTiff","source","opts","headers","offsets","tiff","GeoTIFF","firstImage","getImage","Error"],"mappings":";;;;;;;AAAA;;AAEA;;AAOA;;AA4BO,eAAeA,WAAf,CACLC,MADK,EAELC,IAAoB,GAAG,EAFlB,EAGiB;AACtB,QAAM;AAACC,IAAAA,OAAD;AAAUC,IAAAA;AAAV,MAAqBF,IAA3B;AAGA,MAAIG,IAAJ;;AACA,MAAIJ,MAAM,YAAYK,gBAAtB,EAA+B;AAC7BD,IAAAA,IAAI,GAAGJ,MAAP;AACD,GAFD,MAEO,IAAI,OAAOA,MAAP,KAAkB,QAAtB,EAAgC;AACrCI,IAAAA,IAAI,GAAG,MAAM,sBAAQJ,MAAR,EAAgBE,OAAhB,CAAb;AACD,GAFM,MAEA;AACLE,IAAAA,IAAI,GAAG,MAAM,uBAASJ,MAAT,CAAb;AACD;;AAUD,MAAIG,OAAJ,EAAa;AAMXC,IAAAA,IAAI,GAAG,iCAAmBA,IAAnB,EAAyBD,OAAzB,CAAP;AACD;;AAMD,6BAAaC,IAAb;AAEA,QAAME,UAAU,GAAG,MAAMF,IAAI,CAACG,QAAL,CAAc,CAAd,CAAzB;;AAEA,MAAI,4BAAUD,UAAV,CAAJ,EAA2B;AACzB,WAAO,8BAAYF,IAAZ,EAAkBE,UAAlB,CAAP;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"}
+{"version":3,"sources":["../../../src/lib/load-geotiff.ts"],"names":["loadGeoTiff","source","opts","headers","offsets","GeoTIFF","tiff","getImage","firstImage","Error"],"mappings":";;;;;;;;;;;;;AAAA;;AAEA;;AAOA;;SA4BsBA,W;;;;;2EAAf,iBACLC,MADK;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAELC,YAAAA,IAFK,2DAEkB,EAFlB;AAIEC,YAAAA,OAJF,GAIsBD,IAJtB,CAIEC,OAJF,EAIWC,OAJX,GAIsBF,IAJtB,CAIWE,OAJX;;AAAA,kBAQDH,MAAM,YAAYI,gBARjB;AAAA;AAAA;AAAA;;AASHC,YAAAA,IAAI,GAAGL,MAAP;AATG;AAAA;;AAAA;AAAA,kBAUM,OAAOA,MAAP,KAAkB,QAVxB;AAAA;AAAA;AAAA;;AAAA;AAAA,mBAWU,sBAAQA,MAAR,EAAgBE,OAAhB,CAXV;;AAAA;AAWHG,YAAAA,IAXG;AAAA;AAAA;;AAAA;AAAA;AAAA,mBAaU,uBAASL,MAAT,CAbV;;AAAA;AAaHK,YAAAA,IAbG;;AAAA;AAwBL,gBAAIF,OAAJ,EAAa;AAMXE,cAAAA,IAAI,GAAG,iCAAmBA,IAAnB,EAAyBF,OAAzB,CAAP;AACD;;AAMD,uCAAaE,IAAb;AArCK;AAAA,mBAuCoBA,IAAI,CAACC,QAAL,CAAc,CAAd,CAvCpB;;AAAA;AAuCCC,YAAAA,UAvCD;;AAAA,iBAyCD,4BAAUA,UAAV,CAzCC;AAAA;AAAA;AAAA;;AAAA,6CA0CI,8BAAYF,IAAZ,EAAkBE,UAAlB,CA1CJ;;AAAA;AAAA,kBA6CC,IAAIC,KAAJ,CAAU,yBAAV,CA7CD;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G","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/es5/lib/ome/load-ome-tiff.js

@@ -8,6 +8,10 @@ Object.defineProperty(exports, "__esModule", {
 exports.loadOmeTiff = loadOmeTiff;
 exports.isOmeTiff = void 0;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
 var _tiffPixelSource = _interopRequireDefault(require("../tiff-pixel-source"));
 
 var _omeIndexers = require("./ome-indexers");
@@ -16,53 +20,66 @@ var _omeUtils = require("./ome-utils");
 
 var _omexml = require("./omexml");
 
-const isOmeTiff = img => img.fileDirectory.ImageDescription.includes('<OME');
+var isOmeTiff = function isOmeTiff(img) {
+  return img.fileDirectory.ImageDescription.includes('<OME');
+};
 
 exports.isOmeTiff = isOmeTiff;
 
-async function loadOmeTiff(tiff, firstImage) {
-  const {
-    ImageDescription,
-    SubIFDs,
-    PhotometricInterpretation: photometricInterpretation
-  } = firstImage.fileDirectory;
-  const omexml = (0, _omexml.fromString)(ImageDescription);
-  let levels;
-  let pyramidIndexer;
-
-  if (SubIFDs) {
-    levels = SubIFDs.length + 1;
-    pyramidIndexer = (0, _omeIndexers.getOmeSubIFDIndexer)(tiff, omexml);
-  } else {
-    levels = omexml.length;
-    pyramidIndexer = (0, _omeIndexers.getOmeLegacyIndexer)(tiff, omexml);
-  }
-
-  const imgMeta = omexml[0];
-  const {
-    labels,
-    getShape,
-    physicalSizes,
-    dtype
-  } = (0, _omeUtils.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.default(indexer, dtype, tileSize, shape, labels, meta);
-    return source;
-  });
-  return {
-    data,
-    metadata: imgMeta
-  };
+function loadOmeTiff(_x, _x2) {
+  return _loadOmeTiff.apply(this, arguments);
+}
+
+function _loadOmeTiff() {
+  _loadOmeTiff = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(tiff, firstImage) {
+    var _firstImage$fileDirec, ImageDescription, SubIFDs, photometricInterpretation, omexml, levels, pyramidIndexer, imgMeta, _getOmePixelSourceMet, labels, getShape, physicalSizes, dtype, tileSize, meta, data;
+
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _firstImage$fileDirec = firstImage.fileDirectory, ImageDescription = _firstImage$fileDirec.ImageDescription, SubIFDs = _firstImage$fileDirec.SubIFDs, photometricInterpretation = _firstImage$fileDirec.PhotometricInterpretation;
+            omexml = (0, _omexml.fromString)(ImageDescription);
+
+            if (SubIFDs) {
+              levels = SubIFDs.length + 1;
+              pyramidIndexer = (0, _omeIndexers.getOmeSubIFDIndexer)(tiff, omexml);
+            } else {
+              levels = omexml.length;
+              pyramidIndexer = (0, _omeIndexers.getOmeLegacyIndexer)(tiff, omexml);
+            }
+
+            imgMeta = omexml[0];
+            _getOmePixelSourceMet = (0, _omeUtils.getOmePixelSourceMeta)(imgMeta), labels = _getOmePixelSourceMet.labels, getShape = _getOmePixelSourceMet.getShape, physicalSizes = _getOmePixelSourceMet.physicalSizes, dtype = _getOmePixelSourceMet.dtype;
+            tileSize = firstImage.getTileWidth();
+            meta = {
+              photometricInterpretation: photometricInterpretation,
+              physicalSizes: physicalSizes
+            };
+            data = Array.from({
+              length: levels
+            }).map(function (_, resolution) {
+              var shape = getShape(resolution);
+
+              var indexer = function indexer(sel) {
+                return pyramidIndexer(sel, resolution);
+              };
+
+              var source = new _tiffPixelSource.default(indexer, dtype, tileSize, shape, labels, meta);
+              return source;
+            });
+            return _context.abrupt("return", {
+              data: data,
+              metadata: imgMeta
+            });
+
+          case 9:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _loadOmeTiff.apply(this, arguments);
 }
 //# sourceMappingURL=load-ome-tiff.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/ome/load-ome-tiff.ts"],"names":["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","TiffPixelSource","metadata"],"mappings":";;;;;;;;;;AAEA;;AACA;;AACA;;AACA;;AAGO,MAAMA,SAAS,GAAIC,GAAD,IAAuBA,GAAG,CAACC,aAAJ,CAAkBC,gBAAlB,CAAmCC,QAAnC,CAA4C,MAA5C,CAAzC;;;;AAEA,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,GAAG,wBAAWR,gBAAX,CAAf;AAMA,MAAIS,MAAJ;AACA,MAAIC,cAAJ;;AAEA,MAAIL,OAAJ,EAAa;AAEXI,IAAAA,MAAM,GAAGJ,OAAO,CAACM,MAAR,GAAiB,CAA1B;AACAD,IAAAA,cAAc,GAAG,sCAAoBP,IAApB,EAA0BK,MAA1B,CAAjB;AACD,GAJD,MAIO;AAELC,IAAAA,MAAM,GAAGD,MAAM,CAACG,MAAhB;AACAD,IAAAA,cAAc,GAAG,sCAAoBP,IAApB,EAA0BK,MAA1B,CAAjB;AACD;;AAGD,QAAMI,OAAO,GAAGJ,MAAM,CAAC,CAAD,CAAtB;AACA,QAAM;AAACK,IAAAA,MAAD;AAASC,IAAAA,QAAT;AAAmBC,IAAAA,aAAnB;AAAkCC,IAAAA;AAAlC,MAA2C,qCAAsBJ,OAAtB,CAAjD;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,IAAIC,wBAAJ,CAAoBH,OAApB,EAA6BX,KAA7B,EAAoCC,QAApC,EAA8CS,KAA9C,EAAqDb,MAArD,EAA6DM,IAA7D,CAAf;AACA,WAAOU,MAAP;AACD,GALY,CAAb;AAOA,SAAO;AAACT,IAAAA,IAAD;AAAOW,IAAAA,QAAQ,EAAEnB;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"}
+{"version":3,"sources":["../../../../src/lib/ome/load-ome-tiff.ts"],"names":["isOmeTiff","img","fileDirectory","ImageDescription","includes","loadOmeTiff","tiff","firstImage","SubIFDs","photometricInterpretation","PhotometricInterpretation","omexml","levels","length","pyramidIndexer","imgMeta","labels","getShape","physicalSizes","dtype","tileSize","getTileWidth","meta","data","Array","from","map","_","resolution","shape","indexer","sel","source","TiffPixelSource","metadata"],"mappings":";;;;;;;;;;;;;;AAEA;;AACA;;AACA;;AACA;;AAGO,IAAMA,SAAS,GAAG,SAAZA,SAAY,CAACC,GAAD;AAAA,SAAuBA,GAAG,CAACC,aAAJ,CAAkBC,gBAAlB,CAAmCC,QAAnC,CAA4C,MAA5C,CAAvB;AAAA,CAAlB;;;;SAEeC,W;;;;;2EAAf,iBAA2BC,IAA3B,EAA0CC,UAA1C;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA,oCAMDA,UAAU,CAACL,aANV,EAGHC,gBAHG,yBAGHA,gBAHG,EAIHK,OAJG,yBAIHA,OAJG,EAKwBC,yBALxB,yBAKHC,yBALG;AAOCC,YAAAA,MAPD,GAOU,wBAAWR,gBAAX,CAPV;;AAgBL,gBAAIK,OAAJ,EAAa;AAEXI,cAAAA,MAAM,GAAGJ,OAAO,CAACK,MAAR,GAAiB,CAA1B;AACAC,cAAAA,cAAc,GAAG,sCAAoBR,IAApB,EAA0BK,MAA1B,CAAjB;AACD,aAJD,MAIO;AAELC,cAAAA,MAAM,GAAGD,MAAM,CAACE,MAAhB;AACAC,cAAAA,cAAc,GAAG,sCAAoBR,IAApB,EAA0BK,MAA1B,CAAjB;AACD;;AAGKI,YAAAA,OA3BD,GA2BWJ,MAAM,CAAC,CAAD,CA3BjB;AAAA,oCA4B4C,qCAAsBI,OAAtB,CA5B5C,EA4BEC,MA5BF,yBA4BEA,MA5BF,EA4BUC,QA5BV,yBA4BUA,QA5BV,EA4BoBC,aA5BpB,yBA4BoBA,aA5BpB,EA4BmCC,KA5BnC,yBA4BmCA,KA5BnC;AA6BCC,YAAAA,QA7BD,GA6BYb,UAAU,CAACc,YAAX,EA7BZ;AA8BCC,YAAAA,IA9BD,GA8BQ;AAACb,cAAAA,yBAAyB,EAAzBA,yBAAD;AAA4BS,cAAAA,aAAa,EAAbA;AAA5B,aA9BR;AAgCCK,YAAAA,IAhCD,GAgCQC,KAAK,CAACC,IAAN,CAAW;AAACZ,cAAAA,MAAM,EAAED;AAAT,aAAX,EAA6Bc,GAA7B,CAAiC,UAACC,CAAD,EAAIC,UAAJ,EAAmB;AAC/D,kBAAMC,KAAK,GAAGZ,QAAQ,CAACW,UAAD,CAAtB;;AACA,kBAAME,OAAO,GAAG,SAAVA,OAAU,CAACC,GAAD;AAAA,uBAA2BjB,cAAc,CAACiB,GAAD,EAAMH,UAAN,CAAzC;AAAA,eAAhB;;AACA,kBAAMI,MAAM,GAAG,IAAIC,wBAAJ,CAAoBH,OAApB,EAA6BX,KAA7B,EAAoCC,QAApC,EAA8CS,KAA9C,EAAqDb,MAArD,EAA6DM,IAA7D,CAAf;AACA,qBAAOU,MAAP;AACD,aALY,CAhCR;AAAA,6CAuCE;AAACT,cAAAA,IAAI,EAAJA,IAAD;AAAOW,cAAAA,QAAQ,EAAEnB;AAAjB,aAvCF;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G","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/es5/lib/ome/ome-indexers.js

@@ -1,119 +1,161 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getOmeLegacyIndexer = getOmeLegacyIndexer;
 exports.getOmeSubIFDIndexer = getOmeSubIFDIndexer;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
 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;
+  var imgMeta = rootMeta[0];
+  var _imgMeta$Pixels = imgMeta.Pixels,
+      SizeT = _imgMeta$Pixels.SizeT,
+      SizeC = _imgMeta$Pixels.SizeC,
+      SizeZ = _imgMeta$Pixels.SizeZ;
+  var ifdIndexer = getOmeIFDIndexer(imgMeta);
+  return function (sel, pyramidLevel) {
+    var index = ifdIndexer(sel);
+    var pyramidIndex = pyramidLevel * SizeZ * SizeT * SizeC;
     return tiff.getImage(index + pyramidIndex);
   };
 }
 
 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);
-  };
+  var imgMeta = rootMeta[0];
+  var ifdIndexer = getOmeIFDIndexer(imgMeta);
+  var ifdCache = new Map();
+  return function () {
+    var _ref = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(sel, pyramidLevel) {
+      var index, baseImage, SubIFDs, key, subIfdOffset, ifd;
+      return _regenerator.default.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              index = ifdIndexer(sel);
+              _context.next = 3;
+              return tiff.getImage(index);
+
+            case 3:
+              baseImage = _context.sent;
+
+              if (!(pyramidLevel === 0)) {
+                _context.next = 6;
+                break;
+              }
+
+              return _context.abrupt("return", baseImage);
+
+            case 6:
+              SubIFDs = baseImage.fileDirectory.SubIFDs;
+
+              if (SubIFDs) {
+                _context.next = 9;
+                break;
+              }
+
+              throw Error('Indexing Error: OME-TIFF is missing SubIFDs.');
+
+            case 9:
+              key = "".concat(sel.t, "-").concat(sel.c, "-").concat(sel.z, "-").concat(pyramidLevel);
+
+              if (!ifdCache.has(key)) {
+                subIfdOffset = SubIFDs[pyramidLevel - 1];
+                ifdCache.set(key, tiff.parseFileDirectoryAt(subIfdOffset));
+              }
+
+              _context.next = 13;
+              return ifdCache.get(key);
+
+            case 13:
+              ifd = _context.sent;
+              return _context.abrupt("return", new baseImage.constructor(ifd.fileDirectory, ifd.geoKeyDirectory, tiff.dataView, tiff.littleEndian, tiff.cache, tiff.source));
+
+            case 15:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+
+    return function (_x, _x2) {
+      return _ref.apply(this, arguments);
+    };
+  }();
 }
 
 function getOmeIFDIndexer(imgMeta) {
-  const {
-    SizeC,
-    SizeZ,
-    SizeT,
-    DimensionOrder
-  } = imgMeta.Pixels;
+  var _imgMeta$Pixels2 = imgMeta.Pixels,
+      SizeC = _imgMeta$Pixels2.SizeC,
+      SizeZ = _imgMeta$Pixels2.SizeZ,
+      SizeT = _imgMeta$Pixels2.SizeT,
+      DimensionOrder = _imgMeta$Pixels2.DimensionOrder;
 
   switch (DimensionOrder) {
     case 'XYZCT':
       {
-        return ({
-          t,
-          c,
-          z
-        }) => t * SizeZ * SizeC + c * SizeZ + z;
+        return function (_ref2) {
+          var t = _ref2.t,
+              c = _ref2.c,
+              z = _ref2.z;
+          return t * SizeZ * SizeC + c * SizeZ + z;
+        };
       }
 
     case 'XYZTC':
       {
-        return ({
-          t,
-          c,
-          z
-        }) => c * SizeZ * SizeT + t * SizeZ + z;
+        return function (_ref3) {
+          var t = _ref3.t,
+              c = _ref3.c,
+              z = _ref3.z;
+          return c * SizeZ * SizeT + t * SizeZ + z;
+        };
       }
 
     case 'XYCTZ':
       {
-        return ({
-          t,
-          c,
-          z
-        }) => z * SizeC * SizeT + t * SizeC + c;
+        return function (_ref4) {
+          var t = _ref4.t,
+              c = _ref4.c,
+              z = _ref4.z;
+          return z * SizeC * SizeT + t * SizeC + c;
+        };
       }
 
     case 'XYCZT':
       {
-        return ({
-          t,
-          c,
-          z
-        }) => t * SizeC * SizeZ + z * SizeC + c;
+        return function (_ref5) {
+          var t = _ref5.t,
+              c = _ref5.c,
+              z = _ref5.z;
+          return t * SizeC * SizeZ + z * SizeC + c;
+        };
       }
 
     case 'XYTCZ':
       {
-        return ({
-          t,
-          c,
-          z
-        }) => z * SizeT * SizeC + c * SizeT + t;
+        return function (_ref6) {
+          var t = _ref6.t,
+              c = _ref6.c,
+              z = _ref6.z;
+          return z * SizeT * SizeC + c * SizeT + t;
+        };
       }
 
     case 'XYTZC':
       {
-        return ({
-          t,
-          c,
-          z
-        }) => c * SizeT * SizeZ + z * SizeT + t;
+        return function (_ref7) {
+          var t = _ref7.t,
+              c = _ref7.c,
+              z = _ref7.z;
+          return c * SizeT * SizeZ + z * SizeT + t;
+        };
       }
 
     default:

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

@@ -1 +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"}
+{"version":3,"sources":["../../../../src/lib/ome/ome-indexers.ts"],"names":["getOmeLegacyIndexer","tiff","rootMeta","imgMeta","Pixels","SizeT","SizeC","SizeZ","ifdIndexer","getOmeIFDIndexer","sel","pyramidLevel","index","pyramidIndex","getImage","getOmeSubIFDIndexer","ifdCache","Map","baseImage","SubIFDs","fileDirectory","Error","key","t","c","z","has","subIfdOffset","set","parseFileDirectoryAt","get","ifd","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"}