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

package/dist/lib/ome/omexml.js

@@ -1,66 +1,66 @@
-import parser from 'fast-xml-parser';
-import { ensureArray, intToRgba } from '../utils/tiff-utils';
+"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 = {
-  attributeNamePrefix: '',
-  attrNodeName: 'attr',
-  parseNodeValue: true,
-  parseAttributeValue: true,
-  ignoreAttributes: false
+    // 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 => parser.parse(str, PARSER_OPTIONS);
-
-export function fromString(str) {
-  const res = parse(str);
-
-  if (!res.OME) {
-    throw Error('Failed to parse OME-XML metadata.');
-  }
-
-  return ensureArray(res.OME.Image).map(img => {
-    const Channels = ensureArray(img.Pixels.Channel).map(c => {
-      if ('Color' in c.attr) {
-        return { ...c.attr,
-          Color: intToRgba(c.attr.Color)
+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 { ...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".concat(name)];
-          const unit = Pixels["PhysicalSize".concat(name, "Unit")];
-          return size && unit ? "".concat(size, " ").concat(unit) : '-';
-        }).join(' x ');
         return {
-          'Acquisition Date': image.AquisitionDate,
-          'Dimensions (XY)': "".concat(Pixels.SizeX, " x ").concat(Pixels.SizeY),
-          'Pixels Type': Pixels.Type,
-          'Pixels Size (XYZ)': sizes,
-          'Z-sections/Timepoints': "".concat(Pixels.SizeZ, " x ").concat(Pixels.SizeT),
-          Channels: Pixels.SizeC
+            ...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
+                };
+            }
         };
-      }
-
-    };
-  });
+    });
 }
-//# sourceMappingURL=omexml.js.map
+exports.fromString = fromString;

package/dist/lib/ome/utils.js

@@ -1,21 +1,30 @@
-export function getLabels(dimOrder) {
-  return dimOrder.toLowerCase().split('').reverse();
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDims = exports.getLabels = void 0;
+function getLabels(dimOrder) {
+    return dimOrder.toLowerCase().split('').reverse();
 }
-export 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.');
+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 index;
-  };
+    return (name) => {
+        const index = lookup.get(name);
+        if (index === undefined) {
+            throw Error('Invalid dimension.');
+        }
+        return index;
+    };
 }
-//# sourceMappingURL=utils.js.map
+exports.getDims = getDims;

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

@@ -1,111 +1,64 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { getImageSize, isInterleaved, SIGNAL_ABORTED } from './utils/tiff-utils';
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tiff_utils_1 = require("./utils/tiff-utils");
 class TiffPixelSource {
-  constructor(indexer, dtype, tileSize, shape, labels, meta) {
-    _defineProperty(this, "dtype", void 0);
-
-    _defineProperty(this, "tileSize", void 0);
-
-    _defineProperty(this, "shape", void 0);
-
-    _defineProperty(this, "labels", void 0);
-
-    _defineProperty(this, "meta", void 0);
-
-    _defineProperty(this, "_indexer", void 0);
-
-    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) {
-    var _props$signal;
-
-    const interleave = isInterleaved(this.shape);
-    const raster = await image.readRasters({
-      interleave,
-      ...props
-    });
-
-    if (props !== null && props !== void 0 && (_props$signal = props.signal) !== null && _props$signal !== void 0 && _props$signal.aborted) {
-      throw SIGNAL_ABORTED;
+    // 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;
     }
-
-    const data = interleave ? raster : raster[0];
-    return {
-      data,
-      width: raster.width,
-      height: raster.height
-    };
-  }
-
-  _getTileExtent(x, y) {
-    const {
-      height: zoomLevelHeight,
-      width: zoomLevelWidth
-    } = 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;
+    async getRaster({ selection, signal }) {
+        const image = await this._indexer(selection);
+        return this._readRasters(image, { signal });
     }
-
-    if (y === maxYTileCoord) {
-      height = zoomLevelHeight % this.tileSize;
+    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
     }
-
-    return {
-      height,
-      width
-    };
-  }
-
-  onTileError(err) {
-    console.error(err);
-  }
-
 }
-
-export default TiffPixelSource;
-//# sourceMappingURL=tiff-pixel-source.js.map
+exports.default = TiffPixelSource;

package/dist/lib/utils/Pool.js

@@ -1,77 +1,83 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-
-var _globalThis$navigator, _globalThis$navigator2;
-
-const defaultPoolSize = (_globalThis$navigator = globalThis === null || globalThis === void 0 ? void 0 : (_globalThis$navigator2 = globalThis.navigator) === null || _globalThis$navigator2 === void 0 ? void 0 : _globalThis$navigator2.hardwareConcurrency) !== null && _globalThis$navigator !== void 0 ? _globalThis$navigator : 4;
-export default class Pool {
-  constructor(size = defaultPoolSize) {
-    _defineProperty(this, "workers", void 0);
-
-    _defineProperty(this, "idleWorkers", void 0);
-
-    _defineProperty(this, "waitQueue", void 0);
-
-    _defineProperty(this, "decoder", void 0);
-
-    this.workers = [];
-    this.idleWorkers = [];
-    this.waitQueue = [];
-    this.decoder = null;
-
-    for (let i = 0; i < size; ++i) {
-      const w = new Worker('./decoder.worker');
-      this.workers.push(w);
-      this.idleWorkers.push(w);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// import Worker from 'web-worker:./decoder.worker.ts';
+// https://developer.mozilla.org/en-US/docs/Web/API/NavigatorConcurrentHardware/hardwareConcurrency
+// We need to give a different way of getting this for safari, so 4 is probably a safe bet
+// for parallel processing in the meantime.  More can't really hurt since they'll just block
+// each other and not the UI thread, which is the real benefit.
+const defaultPoolSize = globalThis?.navigator?.hardwareConcurrency ?? 4;
+/**
+ * Pool for workers to decode chunks of the images.
+ * This is a line-for-line copy of GeoTIFFs old implementation: https://github.com/geotiffjs/geotiff.js/blob/v1.0.0-beta.6/src/pool.js
+ */
+class Pool {
+    /**
+     * @constructor
+     * @param {Number} size The size of the pool. Defaults to the number of CPUs
+     *                      available. When this parameter is `null` or 0, then the
+     *                      decoding will be done in the main thread.
+     */
+    constructor(size = defaultPoolSize) {
+        this.workers = [];
+        this.idleWorkers = [];
+        this.waitQueue = [];
+        this.decoder = null;
+        // eslint-disable-next-line no-plusplus
+        for (let i = 0; i < size; ++i) {
+            const w = new Worker('./decoder.worker');
+            this.workers.push(w);
+            this.idleWorkers.push(w);
+        }
     }
-  }
-
-  async decode(fileDirectory, buffer) {
-    const currentWorker = await this.waitForWorker();
-    return new Promise((resolve, reject) => {
-      currentWorker.onmessage = event => {
-        this.finishTask(currentWorker);
-        resolve(event.data[0]);
-      };
-
-      currentWorker.onerror = error => {
-        this.finishTask(currentWorker);
-        reject(error);
-      };
-
-      currentWorker.postMessage(['decode', fileDirectory, buffer], [buffer]);
-    });
-  }
-
-  async waitForWorker() {
-    const idleWorker = this.idleWorkers.pop();
-
-    if (idleWorker) {
-      return idleWorker;
+    /**
+     * Decode the given block of bytes with the set compression method.
+     * @param {ArrayBuffer} buffer the array buffer of bytes to decode.
+     * @returns {Promise.<ArrayBuffer>} the decoded result as a `Promise`
+     */
+    async decode(fileDirectory, buffer) {
+        const currentWorker = await this.waitForWorker();
+        return new Promise((resolve, reject) => {
+            currentWorker.onmessage = (event) => {
+                // this.workers.push(currentWorker);
+                // eslint-disable-next-line
+                this.finishTask(currentWorker);
+                resolve(event.data[0]);
+            };
+            currentWorker.onerror = (error) => {
+                // this.workers.push(currentWorker);
+                // eslint-disable-next-line
+                this.finishTask(currentWorker);
+                reject(error);
+            };
+            currentWorker.postMessage(['decode', fileDirectory, buffer], [buffer]);
+        });
     }
-
-    const waiter = {};
-    const promise = new Promise(resolve => {
-      waiter.resolve = resolve;
-    });
-    this.waitQueue.push(waiter);
-    return promise;
-  }
-
-  async finishTask(currentWorker) {
-    const waiter = this.waitQueue.pop();
-
-    if (waiter) {
-      waiter.resolve(currentWorker);
-    } else {
-      this.idleWorkers.push(currentWorker);
+    async waitForWorker() {
+        const idleWorker = this.idleWorkers.pop();
+        if (idleWorker) {
+            return idleWorker;
+        }
+        const waiter = {};
+        const promise = new Promise((resolve) => {
+            waiter.resolve = resolve;
+        });
+        this.waitQueue.push(waiter);
+        return promise;
     }
-  }
-
-  destroy() {
-    for (let i = 0; i < this.workers.length; ++i) {
-      this.workers[i].terminate();
+    async finishTask(currentWorker) {
+        const waiter = this.waitQueue.pop();
+        if (waiter) {
+            waiter.resolve(currentWorker);
+        }
+        else {
+            this.idleWorkers.push(currentWorker);
+        }
+    }
+    destroy() {
+        // eslint-disable-next-line no-plusplus
+        for (let i = 0; i < this.workers.length; ++i) {
+            this.workers[i].terminate();
+        }
     }
-  }
-
 }
-//# sourceMappingURL=Pool.js.map
+exports.default = Pool;

package/dist/lib/utils/proxies.js

@@ -1,63 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPoolProxy = exports.createOffsetsProxy = exports.checkProxies = void 0;
 const VIV_PROXY_KEY = '__viv';
-const OFFSETS_PROXY_KEY = "".concat(VIV_PROXY_KEY, "-offsets");
-const POOL_PROXY_KEY = "".concat(VIV_PROXY_KEY, "-decoder-pool");
-export function checkProxies(tiff) {
-  if (!isProxy(tiff, OFFSETS_PROXY_KEY)) {
-    console.warn('GeoTIFF source is missing offsets proxy.');
-  }
-
-  if (!isProxy(tiff, POOL_PROXY_KEY)) {
-    console.warn('GeoTIFF source is missing decoder-pool proxy.');
-  }
+const OFFSETS_PROXY_KEY = `${VIV_PROXY_KEY}-offsets`;
+const POOL_PROXY_KEY = `${VIV_PROXY_KEY}-decoder-pool`;
+/*
+ * Inspect if the GeoTIFF source is wrapped in our proxies,
+ * and warn if missing.
+ */
+function checkProxies(tiff) {
+    if (!isProxy(tiff, OFFSETS_PROXY_KEY)) {
+        console.warn('GeoTIFF source is missing offsets proxy.'); // eslint-disable-line no-console
+    }
+    if (!isProxy(tiff, POOL_PROXY_KEY)) {
+        console.warn('GeoTIFF source is missing decoder-pool proxy.'); // eslint-disable-line no-console
+    }
 }
-
+exports.checkProxies = checkProxies;
+/*
+ * > isProxy(tiff, POOL_PROXY_KEY) === true; // false
+ * > tiff = createPoolProxy(tiff, new Pool());
+ * > isProxy(tiff, POOL_PROXY_KEY) === true; // true
+ */
 function isProxy(tiff, proxyFlag) {
-  return tiff[proxyFlag];
+    return tiff[proxyFlag];
 }
-
-export function createOffsetsProxy(tiff, offsets) {
-  const get = (target, key) => {
-    if (key === 'getImage') {
-      return index => {
-        if (!(index in target.ifdRequests) && index in offsets) {
-          const offset = offsets[index];
-          target.ifdRequests[index] = target.parseFileDirectoryAt(offset);
+/*
+ * Creates an ES6 Proxy that wraps a GeoTIFF object. The proxy
+ * handler intercepts calls to `tiff.getImage` and uses our custom
+ * pre-computed offsets to pre-fetch the correct file directory.
+ *
+ * This is a bit of a hack. Internally GeoTIFF inspects `this.ifdRequests`
+ * to see which fileDirectories need to be traversed. By adding the
+ * ifdRequest for an 'index' manually, GeoTIFF will await that request
+ * rather than traversing the file system remotely.
+ */
+function createOffsetsProxy(tiff, offsets) {
+    const get = (target, key) => {
+        // Intercept `tiff.getImage`
+        if (key === 'getImage') {
+            return (index) => {
+                // Manually add ifdRequest to tiff if missing and we have an offset.
+                if (!(index in target.ifdRequests) && index in offsets) {
+                    const offset = offsets[index];
+                    target.ifdRequests[index] = target.parseFileDirectoryAt(offset);
+                }
+                return target.getImage(index);
+            };
         }
-
-        return target.getImage(index);
-      };
-    }
-
-    if (key === OFFSETS_PROXY_KEY) {
-      return true;
-    }
-
-    return Reflect.get(target, key);
-  };
-
-  return new Proxy(tiff, {
-    get
-  });
+        // tiff['__viv-offsets'] === true
+        if (key === OFFSETS_PROXY_KEY) {
+            return true;
+        }
+        return Reflect.get(target, key);
+    };
+    return new Proxy(tiff, { get });
 }
-export function createPoolProxy(tiff, pool) {
-  const get = (target, key) => {
-    if (key === 'readRasters') {
-      return options => {
-        return target.readRasters({ ...options,
-          pool
-        });
-      };
-    }
-
-    if (key === POOL_PROXY_KEY) {
-      return true;
-    }
-
-    return Reflect.get(target, key);
-  };
-
-  return new Proxy(tiff, {
-    get
-  });
+exports.createOffsetsProxy = createOffsetsProxy;
+/*
+ * Creates an ES6 Proxy that wraps a GeoTIFF object. The proxy
+ * handler intercepts calls to `tiff.readRasters` and injects
+ * a pool argument to every call. This means our TiffPixelSource
+ * doesn't need to be aware of whether a decoder pool is in use.
+ *
+ * > tiff.readRasters({ window }) -> tiff.readRasters({ window, pool });
+ */
+function createPoolProxy(tiff, pool) {
+    const get = (target, key) => {
+        // Intercept calls to `image.readRasters`
+        if (key === 'readRasters') {
+            return (options) => {
+                // Inject `pool` argument with other raster options.
+                // @ts-ignore
+                return target.readRasters({ ...options, pool });
+            };
+        }
+        // tiff['__viv-decoder-pool'] === true
+        if (key === POOL_PROXY_KEY) {
+            return true;
+        }
+        return Reflect.get(target, key);
+    };
+    return new Proxy(tiff, { get });
 }
-//# sourceMappingURL=proxies.js.map
+exports.createPoolProxy = createPoolProxy;