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

package/dist/bundle.d.ts

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=bundle.d.ts.map

package/dist/bundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../src/bundle.ts"],"names":[],"mappings":""}

package/dist/bundle.js

@@ -0,0 +1,26 @@
+"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
+globalThis.loaders = globalThis.loaders || {};
+// @ts-ignore
+module.exports = Object.assign(globalThis.loaders, moduleExports);

package/dist/index.d.ts

@@ -1,2 +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

@@ -0,0 +1,10 @@
+"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

@@ -25,3 +25,4 @@ interface GeoTIFFData {
  */
 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

@@ -0,0 +1,57 @@
+"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.');
+}
+exports.loadGeoTiff = loadGeoTiff;

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

@@ -47,3 +47,4 @@ export declare function loadOmeTiff(tiff: GeoTIFF, firstImage: GeoTIFFImage): Pr
         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

@@ -0,0 +1,46 @@
+"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 };
+}
+exports.loadOmeTiff = loadOmeTiff;

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

@@ -8,3 +8,4 @@ export declare type OmeTiffSelection = {
 export declare 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,oBAAY,gBAAgB,GAAG;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC,CAAC;AACjE,oBAAY,cAAc,GAAG,CAAC,GAAG,EAAE,gBAAgB,EAAE,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;AAqBzF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,cAAc,CAanF;AAgBD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,cAAc,CAuCnF"}

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

@@ -0,0 +1,108 @@
+"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);
+    };
+}
+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 ${DimensionOrder}.`);
+        }
+    }
+}

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

@@ -25,3 +25,4 @@ export declare function getOmePixelSourceMeta({ Pixels }: OMEXML[0]): {
     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"}

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

@@ -0,0 +1,63 @@
+"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'
+};
+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;
+    };
+    if (!(Pixels.Type in exports.DTYPE_LOOKUP)) {
+        throw Error(`Pixel type ${Pixels.Type} not supported.`);
+    }
+    const dtype = exports.DTYPE_LOOKUP[Pixels.Type];
+    if (Pixels.PhysicalSizeX && Pixels.PhysicalSizeY) {
+        const physicalSizes = {
+            x: {
+                size: Pixels.PhysicalSizeX,
+                unit: Pixels.PhysicalSizeXUnit
+            },
+            y: {
+                size: Pixels.PhysicalSizeY,
+                unit: Pixels.PhysicalSizeYUnit
+            }
+        };
+        if (Pixels.PhysicalSizeZ) {
+            physicalSizes.z = {
+                size: Pixels.PhysicalSizeZ,
+                unit: Pixels.PhysicalSizeZUnit
+            };
+        }
+        return { labels, getShape, physicalSizes, dtype };
+    }
+    return { labels, getShape, dtype };
+}
+exports.getOmePixelSourceMeta = getOmePixelSourceMeta;

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

@@ -46,3 +46,4 @@ export declare type DimensionOrder = 'XYZCT' | 'XYZTC' | 'XYCTZ' | 'XYCZT' | 'XY
 declare type PixelType = 'int8' | 'int16' | 'int32' | 'uint8' | 'uint16' | 'uint32' | 'float' | 'bit' | 'double' | 'complex' | 'double-complex';
 export declare type UnitsLength = 'Ym' | 'Zm' | 'Em' | 'Pm' | 'Tm' | 'Gm' | 'Mm' | 'km' | 'hm' | 'dam' | 'm' | 'dm' | 'cm' | 'mm' | 'µm' | 'nm' | 'pm' | 'fm' | 'am' | 'zm' | 'ym' | 'Å' | 'thou' | 'li' | 'in' | 'ft' | 'yd' | 'mi' | 'ua' | 'ly' | 'pc' | 'pt' | 'pixel' | 'reference frame';
 export {};
+//# sourceMappingURL=omexml.d.ts.map

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

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

package/dist/lib/ome/omexml.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromString = void 0;
+const fast_xml_parser_1 = __importDefault(require("fast-xml-parser"));
+const tiff_utils_1 = require("../utils/tiff-utils");
+// WARNING: Changes to the parser options _will_ effect the types in types/omexml.d.ts.
+const PARSER_OPTIONS = {
+    // Nests attributes withtout prefix under 'attr' key for each node
+    attributeNamePrefix: '',
+    attrNodeName: 'attr',
+    // Parses numbers for both attributes and nodes
+    parseNodeValue: true,
+    parseAttributeValue: true,
+    // Forces attributes to be parsed
+    ignoreAttributes: false
+};
+const parse = (str) => fast_xml_parser_1.default.parse(str, PARSER_OPTIONS);
+function fromString(str) {
+    const res = parse(str);
+    if (!res.OME) {
+        throw Error('Failed to parse OME-XML metadata.');
+    }
+    return (0, tiff_utils_1.ensureArray)(res.OME.Image).map((img) => {
+        const Channels = (0, tiff_utils_1.ensureArray)(img.Pixels.Channel).map((c) => {
+            if ('Color' in c.attr) {
+                return { ...c.attr, Color: (0, tiff_utils_1.intToRgba)(c.attr.Color) };
+            }
+            return { ...c.attr };
+        });
+        const { AquisitionDate = '', Description = '' } = img;
+        const image = {
+            ...img.attr,
+            AquisitionDate,
+            Description,
+            Pixels: {
+                ...img.Pixels.attr,
+                Channels
+            }
+        };
+        return {
+            ...image,
+            format() {
+                const { Pixels } = image;
+                const sizes = ['X', 'Y', 'Z']
+                    .map((name) => {
+                    const size = Pixels[`PhysicalSize${name}`];
+                    const unit = Pixels[`PhysicalSize${name}Unit`];
+                    return size && unit ? `${size} ${unit}` : '-';
+                })
+                    .join(' x ');
+                return {
+                    'Acquisition Date': image.AquisitionDate,
+                    'Dimensions (XY)': `${Pixels.SizeX} x ${Pixels.SizeY}`,
+                    'Pixels Type': Pixels.Type,
+                    'Pixels Size (XYZ)': sizes,
+                    'Z-sections/Timepoints': `${Pixels.SizeZ} x ${Pixels.SizeT}`,
+                    Channels: Pixels.SizeC
+                };
+            }
+        };
+    });
+}
+exports.fromString = fromString;

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

@@ -2,3 +2,4 @@ import type { OMEXML } from '../ome/omexml';
 import type { Labels } from '../../types';
 export declare function getLabels(dimOrder: OMEXML[0]['Pixels']['DimensionOrder']): Labels<["t", "c", "z"] | ["c", "t", "z"] | ["z", "t", "c"] | ["t", "z", "c"] | ["z", "c", "t"] | ["c", "z", "t"]>;
 export declare function getDims<S extends string>(labels: S[]): (name: S) => number;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/ome/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAYxC,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,gBAAgB,CAAC,qHAExE;AAWD,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,UAKrC,CAAC,YAOhB"}

package/dist/lib/ome/utils.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDims = exports.getLabels = void 0;
+function getLabels(dimOrder) {
+    return dimOrder.toLowerCase().split('').reverse();
+}
+exports.getLabels = getLabels;
+/*
+ * Creates an ES6 map of 'label' -> index
+ * > const labels = ['a', 'b', 'c', 'd'];
+ * > const dims = getDims(labels);
+ * > dims('a') === 0;
+ * > dims('b') === 1;
+ * > dims('c') === 2;
+ * > dims('hi!'); // throws
+ */
+function getDims(labels) {
+    const lookup = new Map(labels.map((name, i) => [name, i]));
+    if (lookup.size !== labels.length) {
+        throw Error('Labels must be unique, found duplicated label.');
+    }
+    return (name) => {
+        const index = lookup.get(name);
+        if (index === undefined) {
+            throw Error('Invalid dimension.');
+        }
+        return index;
+    };
+}
+exports.getDims = getDims;

package/dist/lib/tiff-pixel-source.d.ts

@@ -15,3 +15,4 @@ declare class TiffPixelSource<S extends string[]> implements PixelSource<S> {
     onTileError(err: Error): void;
 }
 export default TiffPixelSource;
+//# sourceMappingURL=tiff-pixel-source.d.ts.map

package/dist/lib/tiff-pixel-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiff-pixel-source.d.ts","sourceRoot":"","sources":["../../src/lib/tiff-pixel-source.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAgB,MAAM,SAAS,CAAC;AAGzD,OAAO,KAAK,EACV,WAAW,EACX,oBAAoB,EACpB,eAAe,EACf,KAAK,EACL,MAAM,EACN,eAAe,EACf,aAAa,EACb,SAAS,EAEV,MAAM,UAAU,CAAC;AAElB,cAAM,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,CAAE,YAAW,WAAW,CAAC,CAAC,CAAC;IAC1D,KAAK,EAAE,KAAK,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;IAClB,IAAI,EAAE,eAAe,GAAG,SAAS,CAAC;IACzC,OAAO,CAAC,QAAQ,CAA0D;gBAIxE,OAAO,EAAE,CAAC,GAAG,EAAE,oBAAoB,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,YAAY,CAAC,EAChE,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EAAE,EACf,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EACjB,IAAI,CAAC,EAAE,eAAe;IAUlB,SAAS,CAAC,EAAC,SAAS,EAAE,MAAM,EAAC,EAAE,eAAe,CAAC,CAAC,CAAC;IAKjD,OAAO,CAAC,EAAC,CAAC,EAAE,CAAC,EAAE,SAAS,EAAE,MAAM,EAAC,EAAE,aAAa,CAAC,CAAC,CAAC;YAU3C,YAAY;IAuB1B,OAAO,CAAC,cAAc;IAetB,WAAW,CAAC,GAAG,EAAE,KAAK;CAGvB;AAED,eAAe,eAAe,CAAC"}

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tiff_utils_1 = require("./utils/tiff-utils");
+class TiffPixelSource {
+    // eslint-disable-next-line max-params
+    constructor(indexer, dtype, tileSize, shape, labels, meta) {
+        this._indexer = indexer;
+        this.dtype = dtype;
+        this.tileSize = tileSize;
+        this.shape = shape;
+        this.labels = labels;
+        this.meta = meta;
+    }
+    async getRaster({ selection, signal }) {
+        const image = await this._indexer(selection);
+        return this._readRasters(image, { signal });
+    }
+    async getTile({ x, y, selection, signal }) {
+        const { height, width } = this._getTileExtent(x, y);
+        const x0 = x * this.tileSize;
+        const y0 = y * this.tileSize;
+        const window = [x0, y0, x0 + width, y0 + height];
+        const image = await this._indexer(selection);
+        return this._readRasters(image, { window, width, height, signal });
+    }
+    async _readRasters(image, props) {
+        const interleave = (0, tiff_utils_1.isInterleaved)(this.shape);
+        const raster = await image.readRasters({ interleave, ...props });
+        if (props?.signal?.aborted) {
+            throw tiff_utils_1.SIGNAL_ABORTED;
+        }
+        /*
+         * geotiff.js returns objects with different structure
+         * depending on `interleave`. It's weird, but this seems to work.
+         */
+        const data = (interleave ? raster : raster[0]);
+        return {
+            data,
+            width: raster.width,
+            height: raster.height
+        };
+    }
+    /*
+     * Computes tile size given x, y coord.
+     */
+    _getTileExtent(x, y) {
+        const { height: zoomLevelHeight, width: zoomLevelWidth } = (0, tiff_utils_1.getImageSize)(this);
+        let height = this.tileSize;
+        let width = this.tileSize;
+        const maxXTileCoord = Math.floor(zoomLevelWidth / this.tileSize);
+        const maxYTileCoord = Math.floor(zoomLevelHeight / this.tileSize);
+        if (x === maxXTileCoord) {
+            width = zoomLevelWidth % this.tileSize;
+        }
+        if (y === maxYTileCoord) {
+            height = zoomLevelHeight % this.tileSize;
+        }
+        return { height, width };
+    }
+    onTileError(err) {
+        console.error(err); // eslint-disable-line no-console
+    }
+}
+exports.default = TiffPixelSource;

package/dist/lib/utils/Pool.d.ts

@@ -26,3 +26,4 @@ export default class Pool {
     finishTask(currentWorker: Worker): Promise<void>;
     destroy(): void;
 }
+//# sourceMappingURL=Pool.d.ts.map

package/dist/lib/utils/Pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Pool.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/Pool.ts"],"names":[],"mappings":"AAAA,qBAAqB;AACrB,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,SAAS,CAAC;AAU3C;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,IAAI;IACvB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,SAAS,EAAE,GAAG,EAAE,CAAC;IACjB,OAAO,EAAE,IAAI,CAAC;IAEd;;;;;OAKG;gBACS,IAAI,SAAkB;IAclC;;;;OAIG;IACG,MAAM,CAAC,aAAa,EAAE,aAAa,EAAE,MAAM,EAAE,WAAW;IAmBxD,aAAa;IAcb,UAAU,CAAC,aAAa,EAAE,MAAM;IAStC,OAAO;CAMR"}