@loaders.gl/geotiff 4.1.0-alpha.3 → 4.1.0-alpha.5

package/src/geotiff-loader.ts

@@ -0,0 +1,115 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {TypedArray} from '@loaders.gl/loader-utils';
+import type {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';
+import {fromArrayBuffer} from 'geotiff';
+
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+
+// Return type definition for GeoTIFF loader
+type GeoTIFFData = {
+  crs?: string;
+  bounds: number[];
+  metadata: Record<string, unknown>;
+
+  width: number;
+  height: number;
+  data: TypedArray;
+};
+
+/** GeoTIFF load options */
+export type GeoTIFFLoaderOptions = LoaderOptions & {
+  geotiff?: {
+    enableAlpha: boolean;
+  };
+};
+
+/** GeoTIFF loader */
+export const GeoTIFFLoader: LoaderWithParser<GeoTIFFData, never, GeoTIFFLoaderOptions> = {
+  id: 'geotiff',
+  name: 'GeoTIFF',
+  module: 'geotiff',
+  version: VERSION,
+  options: {
+    enableAlpha: true
+  },
+  mimeTypes: ['image/tiff', 'image/geotiff'],
+  extensions: ['geotiff', 'tiff', 'geotif', 'tif'],
+  parse: parseGeoTIFF
+};
+
+export function isTiff(arrayBuffer: ArrayBuffer): boolean {
+  const dataView = new DataView(arrayBuffer);
+  // Byte offset
+  const endianness = dataView.getUint16(0);
+  let littleEndian: boolean;
+  switch (endianness) {
+    case 0x4949:
+      littleEndian = true;
+      break;
+    case 0x4d4d:
+      littleEndian = false;
+      break;
+    default:
+      return false;
+    // throw new Error(`invalid byte order: 0x${endianness.toString(16)}`);
+  }
+
+  // Magic number
+  if (dataView.getUint16(2, littleEndian) !== 42) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Loads a GeoTIFF file containing a RGB image.
+ */
+async function parseGeoTIFF(
+  data: ArrayBuffer,
+  options?: GeoTIFFLoaderOptions
+): Promise<GeoTIFFData> {
+  // Load using Geotiff.js
+  const tiff = await fromArrayBuffer(data);
+
+  // Assumes we only have one image inside TIFF
+  const image = await tiff.getImage();
+
+  // Read image and size
+  // TODO: Add support for worker pools here.
+  // TODO: Add support for more image formats.
+  const rgbData = await image.readRGB({
+    enableAlpha: options?.geotiff?.enableAlpha
+  });
+
+  const width = image.getWidth();
+  const height = image.getHeight();
+
+  // Create a new ImageData object
+  const imageData = new Uint8ClampedArray(rgbData as unknown as Uint8Array);
+
+  // Get geo data
+  const bounds = image.getBoundingBox();
+  const metadata = image.getGeoKeys();
+
+  // ProjectedCSTypeGeoKey is the only key we support for now, we assume it is an EPSG code
+  let crs: string | undefined;
+  if (metadata?.ProjectedCSTypeGeoKey) {
+    crs = `EPSG:${metadata.ProjectedCSTypeGeoKey}`;
+  }
+
+  // Return GeoReferenced image data
+  return {
+    crs,
+    bounds,
+    width,
+    height,
+    data: imageData,
+    metadata
+  };
+}

package/src/index.ts

@@ -2,5 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
+export {GeoTIFFLoader} from './geotiff-loader';
+
 export {loadGeoTiff} from './lib/load-geotiff';
-export {default as TiffPixelSource} from './lib/tiff-pixel-source';
+export {TiffPixelSource} from './lib/tiff-pixel-source';

package/src/lib/load-geotiff.ts

@@ -4,15 +4,15 @@
 
 import {fromUrl, fromBlob, GeoTIFF} from 'geotiff';
 
-import {
-  // createPoolProxy,
-  createOffsetsProxy,
-  checkProxies
-} from './utils/proxies';
+// import {
+//   // createPoolProxy,
+//   createOffsetsProxy,
+//   checkProxies
+// } from './utils/proxies.ts.disabled';
 // import Pool from './lib/Pool';
 
 import {loadOmeTiff, isOmeTiff} from './ome/load-ome-tiff';
-import type TiffPixelSource from './tiff-pixel-source';
+import type {TiffPixelSource} from './tiff-pixel-source';
 
 /** Options for initializing a tiff pixel source. */
 interface GeoTIFFOptions {
@@ -69,14 +69,14 @@ export async function loadGeoTiff(
      * create a proxy that intercepts calls to `tiff.getImage`
      * and injects the pre-computed offsets.
      */
-    tiff = createOffsetsProxy(tiff, offsets);
+    // tiff = createOffsetsProxy(tiff, offsets);
   }
 
   /*
    * Inspect tiff source for our performance enhancing proxies.
    * Prints warnings to console if `offsets` or `pool` are missing.
    */
-  checkProxies(tiff);
+  // checkProxies(tiff);
 
   const firstImage = await tiff.getImage(0);
 

package/src/lib/ome/load-ome-tiff.ts

@@ -4,7 +4,7 @@
 
 import type {GeoTIFF, GeoTIFFImage} from 'geotiff';
 
-import TiffPixelSource from '../tiff-pixel-source';
+import {TiffPixelSource} from '../tiff-pixel-source';
 import {getOmeLegacyIndexer, getOmeSubIFDIndexer, OmeTiffIndexer} from './ome-indexers';
 import {getOmePixelSourceMeta} from './ome-utils';
 import {fromString} from './omexml';

package/src/lib/ome/ome-indexers.ts

@@ -2,9 +2,11 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {GeoTIFFImage, GeoTIFF, ImageFileDirectory} from 'geotiff';
+import type {GeoTIFFImage, GeoTIFF} from 'geotiff';
 import type {OMEXML} from '../ome/omexml';
 
+export type ImageFileDirectory = any;
+
 export type OmeTiffSelection = {t: number; c: number; z: number};
 export type OmeTiffIndexer = (sel: OmeTiffSelection, z: number) => Promise<GeoTIFFImage>;
 
@@ -82,13 +84,14 @@ export function getOmeSubIFDIndexer(tiff: GeoTIFF, rootMeta: OMEXML): OmeTiffInd
       const subIfdOffset = SubIFDs[pyramidLevel - 1];
       ifdCache.set(key, tiff.parseFileDirectoryAt(subIfdOffset));
     }
-    const ifd = (await ifdCache.get(key)) as ImageFileDirectory;
+    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 as any)(
       ifd.fileDirectory,
       ifd.geoKeyDirectory,
+      // @ts-expect-error
       tiff.dataView,
       tiff.littleEndian,
       tiff.cache,

package/src/lib/tiff-pixel-source.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {GeoTIFFImage, RasterOptions} from 'geotiff';
+import type {GeoTIFFImage} from 'geotiff';
 import {getImageSize, isInterleaved, SIGNAL_ABORTED} from './utils/tiff-utils';
 
 import type {
@@ -17,7 +17,9 @@ import type {
   TypedArray
 } from '../types';
 
-class TiffPixelSource<S extends string[]> implements PixelSource<S> {
+type ReadRasterOptions = Record<string, any>;
+
+export class TiffPixelSource<S extends string[]> implements PixelSource<S> {
   public dtype: Dtype;
   public tileSize: number;
   public shape: number[];
@@ -57,7 +59,7 @@ class TiffPixelSource<S extends string[]> implements PixelSource<S> {
     return this._readRasters(image, {window, width, height, signal});
   }
 
-  private async _readRasters(image: GeoTIFFImage, props?: RasterOptions) {
+  private async _readRasters(image: GeoTIFFImage, props?: ReadRasterOptions) {
     const interleave = isInterleaved(this.shape);
     const raster = await image.readRasters({interleave, ...props});
 
@@ -99,5 +101,3 @@ class TiffPixelSource<S extends string[]> implements PixelSource<S> {
     console.error(err); // eslint-disable-line no-console
   }
 }
-
-export default TiffPixelSource;

package/src/lib/utils/Pool.ts.disabled

@@ -0,0 +1,99 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/** eslint-disable */
+import {FileDirectory} from 'geotiff';
+
+// 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.8/src/pool.js
+ */
+export default class Pool {
+  workers: Worker[];
+  idleWorkers: Worker[];
+  waitQueue: any[];
+  decoder: null;
+
+  /**
+   * @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);
+    }
+  }
+
+  /**
+   * 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: FileDirectory, buffer: ArrayBuffer) {
+    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]);
+    });
+  }
+
+  async waitForWorker() {
+    const idleWorker = this.idleWorkers.pop();
+    if (idleWorker) {
+      return idleWorker;
+    }
+    const waiter: any = {};
+    const promise = new Promise((resolve) => {
+      waiter.resolve = resolve;
+    });
+
+    this.waitQueue.push(waiter);
+    return promise as Promise<Worker>;
+  }
+
+  async finishTask(currentWorker: Worker) {
+    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();
+    }
+  }
+}

package/src/lib/utils/proxies.ts.disabled

@@ -0,0 +1,96 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {GeoTIFF} from 'geotiff';
+import type Pool from './Pool';
+
+const VIV_PROXY_KEY = '__viv';
+const OFFSETS_PROXY_KEY = `${VIV_PROXY_KEY}-offsets` as const;
+const POOL_PROXY_KEY = `${VIV_PROXY_KEY}-decoder-pool` as const;
+
+/*
+ * Inspect if the GeoTIFF source is wrapped in our proxies,
+ * and warn if missing.
+ */
+export function checkProxies(tiff: GeoTIFF) {
+  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
+  }
+}
+
+/*
+ * > isProxy(tiff, POOL_PROXY_KEY) === true; // false
+ * > tiff = createPoolProxy(tiff, new Pool());
+ * > isProxy(tiff, POOL_PROXY_KEY) === true; // true
+ */
+function isProxy(tiff: GeoTIFF, proxyFlag: string) {
+  return (tiff as any)[proxyFlag] as boolean;
+}
+
+/*
+ * 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.
+ */
+export function createOffsetsProxy(tiff: GeoTIFF, offsets: number[]) {
+  const get = (target: GeoTIFF, key: any) => {
+    // Intercept `tiff.getImage`
+    if (key === 'getImage') {
+      return (index: number) => {
+        // 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);
+      };
+    }
+
+    // tiff['__viv-offsets'] === true
+    if (key === OFFSETS_PROXY_KEY) {
+      return true;
+    }
+
+    return Reflect.get(target, key);
+  };
+  return new Proxy(tiff, {get});
+}
+
+/*
+ * 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 });
+ */
+export function createPoolProxy(tiff: GeoTIFF, pool: Pool) {
+  const get = (target: GeoTIFF, key: any) => {
+    // Intercept calls to `image.readRasters`
+    if (key === 'readRasters') {
+      return (options: Parameters<typeof target.readRasters>) => {
+        // 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});
+}

package/src/loaders.ts

@@ -0,0 +1,68 @@
+import {fromArrayBuffer} from 'geotiff';
+import type {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';
+
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+
+// Type definitions
+type GeoTiffData = {
+  bounds: number[];
+  width: number;
+  height: number;
+  imageData: ImageData;
+};
+
+interface GeoTiffLoaderOptions extends LoaderOptions {
+  enableAlpha: boolean;
+}
+
+/**
+ * Loads a GeoTIFF file containing a RGB image.
+ */
+const loadGeoTiff = async (
+  data: ArrayBuffer,
+  options?: GeoTiffLoaderOptions
+): Promise<GeoTiffData> => {
+  // Load using Geotiff.js
+  const tiff = await fromArrayBuffer(data);
+
+  // Assumes we only have one image inside TIFF
+  const image = await tiff.getImage();
+
+  // Read image and size
+  // TODO: Add support for worker pools here.
+  // TODO: Add support for more image formats.
+  const rgbData = await image.readRGB({
+    enableAlpha: options?.enableAlpha
+  });
+  const width = image.getWidth();
+  const height = image.getHeight();
+
+  // Create a new ImageData object
+  const imageData = new ImageData(width, height);
+  imageData.data.set(new Uint8ClampedArray(rgbData as unknown as Uint8Array));
+
+  // Return GeoJSON data
+  return {
+    // TODO: Add bounds here
+    bounds: [],
+    imageData,
+    width,
+    height
+  };
+};
+
+// Export loader
+export const GeoTiffLoader: LoaderWithParser<GeoTiffData, never, GeoTiffLoaderOptions> = {
+  id: 'geotiff',
+  name: 'GeoTIFF',
+  module: 'geotiff',
+  version: VERSION,
+  options: {
+    enableAlpha: true
+  },
+  mimeTypes: ['image/tiff', 'image/geotiff'],
+  extensions: ['geotiff', 'tiff', 'geotif', 'tif'],
+  parse: loadGeoTiff
+};

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

@@ -1,29 +0,0 @@
-/** eslint-disable */
-import type { FileDirectory } from 'geotiff';
-/**
- * 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.8/src/pool.js
- */
-export default class Pool {
-    workers: Worker[];
-    idleWorkers: Worker[];
-    waitQueue: any[];
-    decoder: null;
-    /**
-     * @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?: number);
-    /**
-     * 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`
-     */
-    decode(fileDirectory: FileDirectory, buffer: ArrayBuffer): Promise<unknown>;
-    waitForWorker(): Promise<Worker>;
-    finishTask(currentWorker: Worker): Promise<void>;
-    destroy(): void;
-}
-//# sourceMappingURL=Pool.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Pool.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/Pool.ts"],"names":[],"mappings":"AAIA,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"}

package/dist/lib/utils/Pool.js

@@ -1,60 +0,0 @@
-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() {
-    let size = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultPoolSize;
-    this.workers = void 0;
-    this.idleWorkers = void 0;
-    this.waitQueue = void 0;
-    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);
-    }
-  }
-  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;
-    }
-    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);
-    }
-  }
-  destroy() {
-    for (let i = 0; i < this.workers.length; ++i) {
-      this.workers[i].terminate();
-    }
-  }
-}
-//# sourceMappingURL=Pool.js.map

package/dist/lib/utils/Pool.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Pool.js","names":["defaultPoolSize","_globalThis$navigator","globalThis","_globalThis$navigator2","navigator","hardwareConcurrency","Pool","constructor","size","arguments","length","undefined","workers","idleWorkers","waitQueue","decoder","i","w","Worker","push","decode","fileDirectory","buffer","currentWorker","waitForWorker","Promise","resolve","reject","onmessage","event","finishTask","data","onerror","error","postMessage","idleWorker","pop","waiter","promise","destroy","terminate"],"sources":["../../../src/lib/utils/Pool.ts"],"sourcesContent":["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\n/** eslint-disable */\nimport type {FileDirectory} from 'geotiff';\n\n// import Worker from 'web-worker:./decoder.worker.ts';\n\n// https://developer.mozilla.org/en-US/docs/Web/API/NavigatorConcurrentHardware/hardwareConcurrency\n// We need to give a different way of getting this for safari, so 4 is probably a safe bet\n// for parallel processing in the meantime.  More can't really hurt since they'll just block\n// each other and not the UI thread, which is the real benefit.\nconst defaultPoolSize = globalThis?.navigator?.hardwareConcurrency ?? 4;\n\n/**\n * Pool for workers to decode chunks of the images.\n * This is a line-for-line copy of GeoTIFFs old implementation: https://github.com/geotiffjs/geotiff.js/blob/v1.0.0-beta.8/src/pool.js\n */\nexport default class Pool {\n  workers: Worker[];\n  idleWorkers: Worker[];\n  waitQueue: any[];\n  decoder: null;\n\n  /**\n   * @constructor\n   * @param {Number} size The size of the pool. Defaults to the number of CPUs\n   *                      available. When this parameter is `null` or 0, then the\n   *                      decoding will be done in the main thread.\n   */\n  constructor(size = defaultPoolSize) {\n    this.workers = [];\n    this.idleWorkers = [];\n    this.waitQueue = [];\n    this.decoder = null;\n\n    // eslint-disable-next-line no-plusplus\n    for (let i = 0; i < size; ++i) {\n      const w = new Worker('./decoder.worker');\n      this.workers.push(w);\n      this.idleWorkers.push(w);\n    }\n  }\n\n  /**\n   * Decode the given block of bytes with the set compression method.\n   * @param {ArrayBuffer} buffer the array buffer of bytes to decode.\n   * @returns {Promise.<ArrayBuffer>} the decoded result as a `Promise`\n   */\n  async decode(fileDirectory: FileDirectory, buffer: ArrayBuffer) {\n    const currentWorker = await this.waitForWorker();\n    return new Promise((resolve, reject) => {\n      currentWorker.onmessage = (event) => {\n        // this.workers.push(currentWorker);\n        // eslint-disable-next-line\n        this.finishTask(currentWorker);\n        resolve(event.data[0]);\n      };\n      currentWorker.onerror = (error) => {\n        // this.workers.push(currentWorker);\n        // eslint-disable-next-line\n        this.finishTask(currentWorker);\n        reject(error);\n      };\n      currentWorker.postMessage(['decode', fileDirectory, buffer], [buffer]);\n    });\n  }\n\n  async waitForWorker() {\n    const idleWorker = this.idleWorkers.pop();\n    if (idleWorker) {\n      return idleWorker;\n    }\n    const waiter: any = {};\n    const promise = new Promise((resolve) => {\n      waiter.resolve = resolve;\n    });\n\n    this.waitQueue.push(waiter);\n    return promise as Promise<Worker>;\n  }\n\n  async finishTask(currentWorker: Worker) {\n    const waiter = this.waitQueue.pop();\n    if (waiter) {\n      waiter.resolve(currentWorker);\n    } else {\n      this.idleWorkers.push(currentWorker);\n    }\n  }\n\n  destroy() {\n    // eslint-disable-next-line no-plusplus\n    for (let i = 0; i < this.workers.length; ++i) {\n      this.workers[i].terminate();\n    }\n  }\n}\n"],"mappings":";AAaA,MAAMA,eAAe,IAAAC,qBAAA,GAAGC,UAAU,aAAVA,UAAU,wBAAAC,sBAAA,GAAVD,UAAU,CAAEE,SAAS,cAAAD,sBAAA,uBAArBA,sBAAA,CAAuBE,mBAAmB,cAAAJ,qBAAA,cAAAA,qBAAA,GAAI,CAAC;AAMvE,eAAe,MAAMK,IAAI,CAAC;EAYxBC,WAAWA,CAAA,EAAyB;IAAA,IAAxBC,IAAI,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAGT,eAAe;IAAA,KAXlCY,OAAO;IAAA,KACPC,WAAW;IAAA,KACXC,SAAS;IAAA,KACTC,OAAO;IASL,IAAI,CAACH,OAAO,GAAG,EAAE;IACjB,IAAI,CAACC,WAAW,GAAG,EAAE;IACrB,IAAI,CAACC,SAAS,GAAG,EAAE;IACnB,IAAI,CAACC,OAAO,GAAG,IAAI;IAGnB,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGR,IAAI,EAAE,EAAEQ,CAAC,EAAE;MAC7B,MAAMC,CAAC,GAAG,IAAIC,MAAM,CAAC,kBAAkB,CAAC;MACxC,IAAI,CAACN,OAAO,CAACO,IAAI,CAACF,CAAC,CAAC;MACpB,IAAI,CAACJ,WAAW,CAACM,IAAI,CAACF,CAAC,CAAC;IAC1B;EACF;EAOA,MAAMG,MAAMA,CAACC,aAA4B,EAAEC,MAAmB,EAAE;IAC9D,MAAMC,aAAa,GAAG,MAAM,IAAI,CAACC,aAAa,CAAC,CAAC;IAChD,OAAO,IAAIC,OAAO,CAAC,CAACC,OAAO,EAAEC,MAAM,KAAK;MACtCJ,aAAa,CAACK,SAAS,GAAIC,KAAK,IAAK;QAGnC,IAAI,CAACC,UAAU,CAACP,aAAa,CAAC;QAC9BG,OAAO,CAACG,KAAK,CAACE,IAAI,CAAC,CAAC,CAAC,CAAC;MACxB,CAAC;MACDR,aAAa,CAACS,OAAO,GAAIC,KAAK,IAAK;QAGjC,IAAI,CAACH,UAAU,CAACP,aAAa,CAAC;QAC9BI,MAAM,CAACM,KAAK,CAAC;MACf,CAAC;MACDV,aAAa,CAACW,WAAW,CAAC,CAAC,QAAQ,EAAEb,aAAa,EAAEC,MAAM,CAAC,EAAE,CAACA,MAAM,CAAC,CAAC;IACxE,CAAC,CAAC;EACJ;EAEA,MAAME,aAAaA,CAAA,EAAG;IACpB,MAAMW,UAAU,GAAG,IAAI,CAACtB,WAAW,CAACuB,GAAG,CAAC,CAAC;IACzC,IAAID,UAAU,EAAE;MACd,OAAOA,UAAU;IACnB;IACA,MAAME,MAAW,GAAG,CAAC,CAAC;IACtB,MAAMC,OAAO,GAAG,IAAIb,OAAO,CAAEC,OAAO,IAAK;MACvCW,MAAM,CAACX,OAAO,GAAGA,OAAO;IAC1B,CAAC,CAAC;IAEF,IAAI,CAACZ,SAAS,CAACK,IAAI,CAACkB,MAAM,CAAC;IAC3B,OAAOC,OAAO;EAChB;EAEA,MAAMR,UAAUA,CAACP,aAAqB,EAAE;IACtC,MAAMc,MAAM,GAAG,IAAI,CAACvB,SAAS,CAACsB,GAAG,CAAC,CAAC;IACnC,IAAIC,MAAM,EAAE;MACVA,MAAM,CAACX,OAAO,CAACH,aAAa,CAAC;IAC/B,CAAC,MAAM;MACL,IAAI,CAACV,WAAW,CAACM,IAAI,CAACI,aAAa,CAAC;IACtC;EACF;EAEAgB,OAAOA,CAAA,EAAG;IAER,KAAK,IAAIvB,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAG,IAAI,CAACJ,OAAO,CAACF,MAAM,EAAE,EAAEM,CAAC,EAAE;MAC5C,IAAI,CAACJ,OAAO,CAACI,CAAC,CAAC,CAACwB,SAAS,CAAC,CAAC;IAC7B;EACF;AACF"}

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

@@ -1,6 +0,0 @@
-import type { GeoTIFF } from 'geotiff';
-import type Pool from './Pool';
-export declare function checkProxies(tiff: GeoTIFF): void;
-export declare function createOffsetsProxy(tiff: GeoTIFF, offsets: number[]): GeoTIFF;
-export declare function createPoolProxy(tiff: GeoTIFF, pool: Pool): GeoTIFF;
-//# sourceMappingURL=proxies.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"proxies.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/proxies.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,SAAS,CAAC;AACrC,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAU/B,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,QAQzC;AAqBD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,WAsBlE;AAUD,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,WAmBxD"}

package/dist/lib/utils/proxies.js

@@ -1,54 +0,0 @@
-const VIV_PROXY_KEY = '__viv';
-const OFFSETS_PROXY_KEY = `${VIV_PROXY_KEY}-offsets`;
-const POOL_PROXY_KEY = `${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.');
-  }
-}
-function isProxy(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);
-        }
-        return target.getImage(index);
-      };
-    }
-    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
-  });
-}
-//# sourceMappingURL=proxies.js.map