@loaders.gl/geotiff 3.1.0-alpha.3 → 3.1.0-alpha.4

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/ome/ome-utils.ts"],"names":["DTYPE_LOOKUP","uint8","uint16","uint32","float","double","int8","int16","int32","getOmePixelSourceMeta","Pixels","labels","DimensionOrder","dims","shape","Array","length","fill","SizeT","SizeC","SizeZ","Interleaved","push","getShape","level","s","SizeX","SizeY","Type","Error","dtype","PhysicalSizeX","PhysicalSizeY","physicalSizes","x","size","unit","PhysicalSizeXUnit","y","PhysicalSizeYUnit","PhysicalSizeZ","z","PhysicalSizeZUnit"],"mappings":"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","sourcesContent":["import {getDims, getLabels} from './utils';\nimport type {OMEXML, UnitsLength} from './omexml';\n\nexport const DTYPE_LOOKUP = {\n  uint8: 'Uint8',\n  uint16: 'Uint16',\n  uint32: 'Uint32',\n  float: 'Float32',\n  double: 'Float64',\n  int8: 'Int8',\n  int16: 'Int16',\n  int32: 'Int32'\n} as const;\n\nexport function getOmePixelSourceMeta({Pixels}: OMEXML[0]) {\n  // e.g. 'XYZCT' -> ['t', 'c', 'z', 'y', 'x']\n  const labels = getLabels(Pixels.DimensionOrder);\n\n  // Compute \"shape\" of image\n  const dims = getDims(labels);\n  const shape: number[] = Array(labels.length).fill(0);\n  shape[dims('t')] = Pixels.SizeT;\n  shape[dims('c')] = Pixels.SizeC;\n  shape[dims('z')] = Pixels.SizeZ;\n\n  // Push extra dimension if data are interleaved.\n  if (Pixels.Interleaved) {\n    // @ts-ignore\n    labels.push('_c');\n    shape.push(3);\n  }\n\n  // Creates a new shape for different level of pyramid.\n  // Assumes factor-of-two downsampling.\n  const getShape = (level: number) => {\n    const s = [...shape];\n    s[dims('x')] = Pixels.SizeX >> level;\n    s[dims('y')] = Pixels.SizeY >> level;\n    return s;\n  };\n\n  if (!(Pixels.Type in DTYPE_LOOKUP)) {\n    throw Error(`Pixel type ${Pixels.Type} not supported.`);\n  }\n\n  const dtype = DTYPE_LOOKUP[Pixels.Type as keyof typeof DTYPE_LOOKUP];\n  if (Pixels.PhysicalSizeX && Pixels.PhysicalSizeY) {\n    const physicalSizes: {\n      [k: string]: {size: number; unit: UnitsLength};\n    } = {\n      x: {\n        size: Pixels.PhysicalSizeX,\n        unit: Pixels.PhysicalSizeXUnit\n      },\n      y: {\n        size: Pixels.PhysicalSizeY,\n        unit: Pixels.PhysicalSizeYUnit\n      }\n    };\n    if (Pixels.PhysicalSizeZ) {\n      physicalSizes.z = {\n        size: Pixels.PhysicalSizeZ,\n        unit: Pixels.PhysicalSizeZUnit\n      };\n    }\n    return {labels, getShape, physicalSizes, dtype};\n  }\n\n  return {labels, getShape, dtype};\n}\n"],"file":"ome-utils.js"}

package/dist/es5/lib/ome/omexml.js

@@ -0,0 +1,82 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fromString = fromString;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _fastXmlParser = _interopRequireDefault(require("fast-xml-parser"));
+
+var _tiffUtils = require("../utils/tiff-utils");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var PARSER_OPTIONS = {
+  attributeNamePrefix: '',
+  attrNodeName: 'attr',
+  parseNodeValue: true,
+  parseAttributeValue: true,
+  ignoreAttributes: false
+};
+
+var parse = function parse(str) {
+  return _fastXmlParser.default.parse(str, PARSER_OPTIONS);
+};
+
+function fromString(str) {
+  var res = parse(str);
+
+  if (!res.OME) {
+    throw Error('Failed to parse OME-XML metadata.');
+  }
+
+  return (0, _tiffUtils.ensureArray)(res.OME.Image).map(function (img) {
+    var Channels = (0, _tiffUtils.ensureArray)(img.Pixels.Channel).map(function (c) {
+      if ('Color' in c.attr) {
+        return _objectSpread(_objectSpread({}, c.attr), {}, {
+          Color: (0, _tiffUtils.intToRgba)(c.attr.Color)
+        });
+      }
+
+      return _objectSpread({}, c.attr);
+    });
+    var _img$AquisitionDate = img.AquisitionDate,
+        AquisitionDate = _img$AquisitionDate === void 0 ? '' : _img$AquisitionDate,
+        _img$Description = img.Description,
+        Description = _img$Description === void 0 ? '' : _img$Description;
+
+    var image = _objectSpread(_objectSpread({}, img.attr), {}, {
+      AquisitionDate: AquisitionDate,
+      Description: Description,
+      Pixels: _objectSpread(_objectSpread({}, img.Pixels.attr), {}, {
+        Channels: Channels
+      })
+    });
+
+    return _objectSpread(_objectSpread({}, image), {}, {
+      format: function format() {
+        var Pixels = image.Pixels;
+        var sizes = ['X', 'Y', 'Z'].map(function (name) {
+          var size = Pixels["PhysicalSize".concat(name)];
+          var 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
+        };
+      }
+    });
+  });
+}
+//# sourceMappingURL=omexml.js.map

package/dist/es5/lib/ome/omexml.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/ome/omexml.ts"],"names":["PARSER_OPTIONS","attributeNamePrefix","attrNodeName","parseNodeValue","parseAttributeValue","ignoreAttributes","parse","str","parser","fromString","res","OME","Error","Image","map","img","Channels","Pixels","Channel","c","attr","Color","AquisitionDate","Description","image","format","sizes","name","size","unit","join","SizeX","SizeY","Type","SizeZ","SizeT","SizeC"],"mappings":";;;;;;;;;;;AAAA;;AACA;;;;;;AAGA,IAAMA,cAAc,GAAG;AAErBC,EAAAA,mBAAmB,EAAE,EAFA;AAGrBC,EAAAA,YAAY,EAAE,MAHO;AAMrBC,EAAAA,cAAc,EAAE,IANK;AAOrBC,EAAAA,mBAAmB,EAAE,IAPA;AAUrBC,EAAAA,gBAAgB,EAAE;AAVG,CAAvB;;AAaA,IAAMC,KAAK,GAAG,SAARA,KAAQ,CAACC,GAAD;AAAA,SAAuBC,uBAAOF,KAAP,CAAaC,GAAb,EAAkBP,cAAlB,CAAvB;AAAA,CAAd;;AAEO,SAASS,UAAT,CAAoBF,GAApB,EAAiC;AACtC,MAAMG,GAAG,GAAGJ,KAAK,CAACC,GAAD,CAAjB;;AACA,MAAI,CAACG,GAAG,CAACC,GAAT,EAAc;AACZ,UAAMC,KAAK,CAAC,mCAAD,CAAX;AACD;;AACD,SAAO,4BAAYF,GAAG,CAACC,GAAJ,CAAQE,KAApB,EAA2BC,GAA3B,CAA+B,UAACC,GAAD,EAAS;AAC7C,QAAMC,QAAQ,GAAG,4BAAYD,GAAG,CAACE,MAAJ,CAAWC,OAAvB,EAAgCJ,GAAhC,CAAoC,UAACK,CAAD,EAAO;AAC1D,UAAI,WAAWA,CAAC,CAACC,IAAjB,EAAuB;AACrB,+CAAWD,CAAC,CAACC,IAAb;AAAmBC,UAAAA,KAAK,EAAE,0BAAUF,CAAC,CAACC,IAAF,CAAOC,KAAjB;AAA1B;AACD;;AACD,+BAAWF,CAAC,CAACC,IAAb;AACD,KALgB,CAAjB;AAMA,8BAAgDL,GAAhD,CAAOO,cAAP;AAAA,QAAOA,cAAP,oCAAwB,EAAxB;AAAA,2BAAgDP,GAAhD,CAA4BQ,WAA5B;AAAA,QAA4BA,WAA5B,iCAA0C,EAA1C;;AACA,QAAMC,KAAK,mCACNT,GAAG,CAACK,IADE;AAETE,MAAAA,cAAc,EAAdA,cAFS;AAGTC,MAAAA,WAAW,EAAXA,WAHS;AAITN,MAAAA,MAAM,kCACDF,GAAG,CAACE,MAAJ,CAAWG,IADV;AAEJJ,QAAAA,QAAQ,EAARA;AAFI;AAJG,MAAX;;AASA,2CACKQ,KADL;AAEEC,MAAAA,MAFF,oBAEW;AACP,YAAOR,MAAP,GAAiBO,KAAjB,CAAOP,MAAP;AAEA,YAAMS,KAAK,GAAI,CAAC,GAAD,EAAM,GAAN,EAAW,GAAX,CAAD,CACXZ,GADW,CACP,UAACa,IAAD,EAAU;AACb,cAAMC,IAAI,GAAGX,MAAM,uBAAgBU,IAAhB,EAAnB;AACA,cAAME,IAAI,GAAGZ,MAAM,uBAAgBU,IAAhB,UAAnB;AACA,iBAAOC,IAAI,IAAIC,IAAR,aAAkBD,IAAlB,cAA0BC,IAA1B,IAAmC,GAA1C;AACD,SALW,EAMXC,IANW,CAMN,KANM,CAAd;AAQA,eAAO;AACL,8BAAoBN,KAAK,CAACF,cADrB;AAEL,uCAAsBL,MAAM,CAACc,KAA7B,gBAAwCd,MAAM,CAACe,KAA/C,CAFK;AAGL,yBAAef,MAAM,CAACgB,IAHjB;AAIL,+BAAqBP,KAJhB;AAKL,6CAA4BT,MAAM,CAACiB,KAAnC,gBAA8CjB,MAAM,CAACkB,KAArD,CALK;AAMLnB,UAAAA,QAAQ,EAAEC,MAAM,CAACmB;AANZ,SAAP;AAQD;AArBH;AAuBD,GAxCM,CAAP;AAyCD","sourcesContent":["import parser from 'fast-xml-parser';\nimport {ensureArray, intToRgba} from '../utils/tiff-utils';\n\n// WARNING: Changes to the parser options _will_ effect the types in types/omexml.d.ts.\nconst PARSER_OPTIONS = {\n  // Nests attributes withtout prefix under 'attr' key for each node\n  attributeNamePrefix: '',\n  attrNodeName: 'attr',\n\n  // Parses numbers for both attributes and nodes\n  parseNodeValue: true,\n  parseAttributeValue: true,\n\n  // Forces attributes to be parsed\n  ignoreAttributes: false\n};\n\nconst parse = (str: string): Root => parser.parse(str, PARSER_OPTIONS);\n\nexport function fromString(str: string) {\n  const res = parse(str);\n  if (!res.OME) {\n    throw Error('Failed to parse OME-XML metadata.');\n  }\n  return ensureArray(res.OME.Image).map((img) => {\n    const Channels = ensureArray(img.Pixels.Channel).map((c) => {\n      if ('Color' in c.attr) {\n        return {...c.attr, Color: intToRgba(c.attr.Color)};\n      }\n      return {...c.attr};\n    });\n    const {AquisitionDate = '', Description = ''} = img;\n    const image = {\n      ...img.attr,\n      AquisitionDate,\n      Description,\n      Pixels: {\n        ...img.Pixels.attr,\n        Channels\n      }\n    };\n    return {\n      ...image,\n      format() {\n        const {Pixels} = image;\n\n        const sizes = (['X', 'Y', 'Z'] as const)\n          .map((name) => {\n            const size = Pixels[`PhysicalSize${name}` as const];\n            const unit = Pixels[`PhysicalSize${name}Unit` as const];\n            return size && unit ? `${size} ${unit}` : '-';\n          })\n          .join(' x ');\n\n        return {\n          'Acquisition Date': image.AquisitionDate,\n          'Dimensions (XY)': `${Pixels.SizeX} x ${Pixels.SizeY}`,\n          'Pixels Type': Pixels.Type,\n          'Pixels Size (XYZ)': sizes,\n          'Z-sections/Timepoints': `${Pixels.SizeZ} x ${Pixels.SizeT}`,\n          Channels: Pixels.SizeC\n        };\n      }\n    };\n  });\n}\n\nexport type OMEXML = ReturnType<typeof fromString>;\nexport type DimensionOrder = 'XYZCT' | 'XYZTC' | 'XYCTZ' | 'XYCZT' | 'XYTCZ' | 'XYTZC';\n\n// Structure of node is determined by the PARSER_OPTIONS.\ntype Node<T, A> = T & {attr: A};\ntype Attrs<Fields extends string, T = string> = {[K in Fields]: T};\n\ntype OMEAttrs = Attrs<'xmlns' | 'xmlns:xsi' | 'xsi:schemaLocation'>;\ntype OME = Node<{Insturment: Insturment; Image: Image | Image[]}, OMEAttrs>;\n\ntype Insturment = Node<\n  {Objective: Node<{}, Attrs<'ID' | 'Model' | 'NominalMagnification'>>},\n  Attrs<'ID'>\n>;\n\ninterface ImageNodes {\n  AquisitionDate?: string;\n  Description?: string;\n  Pixels: Pixels;\n  InstrumentRef: Node<{}, {ID: string}>;\n  ObjectiveSettings: Node<{}, {ID: string}>;\n}\ntype Image = Node<ImageNodes, Attrs<'ID' | 'Name'>>;\n\ntype PixelType =\n  | 'int8'\n  | 'int16'\n  | 'int32'\n  | 'uint8'\n  | 'uint16'\n  | 'uint32'\n  | 'float'\n  | 'bit'\n  | 'double'\n  | 'complex'\n  | 'double-complex';\n\nexport type UnitsLength =\n  | 'Ym'\n  | 'Zm'\n  | 'Em'\n  | 'Pm'\n  | 'Tm'\n  | 'Gm'\n  | 'Mm'\n  | 'km'\n  | 'hm'\n  | 'dam'\n  | 'm'\n  | 'dm'\n  | 'cm'\n  | 'mm'\n  | 'µm'\n  | 'nm'\n  | 'pm'\n  | 'fm'\n  | 'am'\n  | 'zm'\n  | 'ym'\n  | 'Å'\n  | 'thou'\n  | 'li'\n  | 'in'\n  | 'ft'\n  | 'yd'\n  | 'mi'\n  | 'ua'\n  | 'ly'\n  | 'pc'\n  | 'pt'\n  | 'pixel'\n  | 'reference frame';\n\ntype PhysicalSize<Name extends string> = `PhysicalSize${Name}`;\ntype PhysicalSizeUnit<Name extends string> = `PhysicalSize${Name}Unit`;\ntype Size<Names extends string> = `Size${Names}`;\n\ntype PixelAttrs = Attrs<\n  PhysicalSize<'X' | 'Y' | 'Z'> | 'SignificantBits' | Size<'T' | 'C' | 'Z' | 'Y' | 'X'>,\n  number\n> &\n  Attrs<PhysicalSizeUnit<'X' | 'Y' | 'Z'>, UnitsLength> &\n  Attrs<'BigEndian' | 'Interleaved', boolean> & {\n    ID: string;\n    DimensionOrder: DimensionOrder;\n    Type: PixelType;\n  };\n\ntype Pixels = Node<\n  {\n    Channel: Channel | Channel[];\n    TiffData: Node<{}, Attrs<'IFD' | 'PlaneCount'>>;\n  },\n  PixelAttrs\n>;\n\ntype ChannelAttrs =\n  | {\n      ID: string;\n      SamplesPerPixel: number;\n      Name?: string;\n    }\n  | {\n      ID: string;\n      SamplesPerPixel: number;\n      Name?: string;\n      Color: number;\n    };\n\ntype Channel = Node<{}, ChannelAttrs>;\n\ntype Root = {OME: OME};\n"],"file":"omexml.js"}

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

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getLabels = getLabels;
+exports.getDims = getDims;
+
+function getLabels(dimOrder) {
+  return dimOrder.toLowerCase().split('').reverse();
+}
+
+function getDims(labels) {
+  var lookup = new Map(labels.map(function (name, i) {
+    return [name, i];
+  }));
+
+  if (lookup.size !== labels.length) {
+    throw Error('Labels must be unique, found duplicated label.');
+  }
+
+  return function (name) {
+    var index = lookup.get(name);
+
+    if (index === undefined) {
+      throw Error('Invalid dimension.');
+    }
+
+    return index;
+  };
+}
+//# sourceMappingURL=utils.js.map

package/dist/es5/lib/ome/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/ome/utils.ts"],"names":["getLabels","dimOrder","toLowerCase","split","reverse","getDims","labels","lookup","Map","map","name","i","size","length","Error","index","get","undefined"],"mappings":";;;;;;;;AAaO,SAASA,SAAT,CAAmBC,QAAnB,EAAoE;AACzE,SAAOA,QAAQ,CAACC,WAAT,GAAuBC,KAAvB,CAA6B,EAA7B,EAAiCC,OAAjC,EAAP;AACD;;AAWM,SAASC,OAAT,CAAmCC,MAAnC,EAAgD;AACrD,MAAMC,MAAM,GAAG,IAAIC,GAAJ,CAAQF,MAAM,CAACG,GAAP,CAAW,UAACC,IAAD,EAAOC,CAAP;AAAA,WAAa,CAACD,IAAD,EAAOC,CAAP,CAAb;AAAA,GAAX,CAAR,CAAf;;AACA,MAAIJ,MAAM,CAACK,IAAP,KAAgBN,MAAM,CAACO,MAA3B,EAAmC;AACjC,UAAMC,KAAK,CAAC,gDAAD,CAAX;AACD;;AACD,SAAO,UAACJ,IAAD,EAAa;AAClB,QAAMK,KAAK,GAAGR,MAAM,CAACS,GAAP,CAAWN,IAAX,CAAd;;AACA,QAAIK,KAAK,KAAKE,SAAd,EAAyB;AACvB,YAAMH,KAAK,CAAC,oBAAD,CAAX;AACD;;AACD,WAAOC,KAAP;AACD,GAND;AAOD","sourcesContent":["import type {OMEXML} from '../ome/omexml';\nimport type {Labels} from '../../types';\n\n/*\n * Creates typed labels from DimensionOrder.\n * > imgMeta.Pixels.DimensionOrder === 'XYCZT'\n * > getLabels(imgMeta.Pixels) === ['t', 'z', 'c', 'y', 'x']\n */\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\ntype Sel<Dim extends string> = Dim extends `${infer Z}${infer X}${infer A}${infer B}${infer C}`\n  ? [C, B, A]\n  : 'error';\nexport function getLabels(dimOrder: OMEXML[0]['Pixels']['DimensionOrder']) {\n  return dimOrder.toLowerCase().split('').reverse() as Labels<Sel<Lowercase<typeof dimOrder>>>;\n}\n\n/*\n * Creates an ES6 map of 'label' -> index\n * > const labels = ['a', 'b', 'c', 'd'];\n * > const dims = getDims(labels);\n * > dims('a') === 0;\n * > dims('b') === 1;\n * > dims('c') === 2;\n * > dims('hi!'); // throws\n */\nexport function getDims<S extends string>(labels: S[]) {\n  const lookup = new Map(labels.map((name, i) => [name, i]));\n  if (lookup.size !== labels.length) {\n    throw Error('Labels must be unique, found duplicated label.');\n  }\n  return (name: S) => {\n    const index = lookup.get(name);\n    if (index === undefined) {\n      throw Error('Invalid dimension.');\n    }\n    return index;\n  };\n}\n"],"file":"utils.js"}

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

@@ -0,0 +1,202 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _tiffUtils = require("./utils/tiff-utils");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var TiffPixelSource = function () {
+  function TiffPixelSource(indexer, dtype, tileSize, shape, labels, meta) {
+    (0, _classCallCheck2.default)(this, TiffPixelSource);
+    (0, _defineProperty2.default)(this, "dtype", void 0);
+    (0, _defineProperty2.default)(this, "tileSize", void 0);
+    (0, _defineProperty2.default)(this, "shape", void 0);
+    (0, _defineProperty2.default)(this, "labels", void 0);
+    (0, _defineProperty2.default)(this, "meta", void 0);
+    (0, _defineProperty2.default)(this, "_indexer", void 0);
+    this._indexer = indexer;
+    this.dtype = dtype;
+    this.tileSize = tileSize;
+    this.shape = shape;
+    this.labels = labels;
+    this.meta = meta;
+  }
+
+  (0, _createClass2.default)(TiffPixelSource, [{
+    key: "getRaster",
+    value: function () {
+      var _getRaster = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(_ref) {
+        var selection, signal, image;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                selection = _ref.selection, signal = _ref.signal;
+                _context.next = 3;
+                return this._indexer(selection);
+
+              case 3:
+                image = _context.sent;
+                return _context.abrupt("return", this._readRasters(image, {
+                  signal: signal
+                }));
+
+              case 5:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function getRaster(_x) {
+        return _getRaster.apply(this, arguments);
+      }
+
+      return getRaster;
+    }()
+  }, {
+    key: "getTile",
+    value: function () {
+      var _getTile = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2(_ref2) {
+        var x, y, selection, signal, _this$_getTileExtent, height, width, x0, y0, window, image;
+
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                x = _ref2.x, y = _ref2.y, selection = _ref2.selection, signal = _ref2.signal;
+                _this$_getTileExtent = this._getTileExtent(x, y), height = _this$_getTileExtent.height, width = _this$_getTileExtent.width;
+                x0 = x * this.tileSize;
+                y0 = y * this.tileSize;
+                window = [x0, y0, x0 + width, y0 + height];
+                _context2.next = 7;
+                return this._indexer(selection);
+
+              case 7:
+                image = _context2.sent;
+                return _context2.abrupt("return", this._readRasters(image, {
+                  window: window,
+                  width: width,
+                  height: height,
+                  signal: signal
+                }));
+
+              case 9:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function getTile(_x2) {
+        return _getTile.apply(this, arguments);
+      }
+
+      return getTile;
+    }()
+  }, {
+    key: "_readRasters",
+    value: function () {
+      var _readRasters2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee3(image, props) {
+        var _props$signal;
+
+        var interleave, raster, data;
+        return _regenerator.default.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                interleave = (0, _tiffUtils.isInterleaved)(this.shape);
+                _context3.next = 3;
+                return image.readRasters(_objectSpread({
+                  interleave: interleave
+                }, props));
+
+              case 3:
+                raster = _context3.sent;
+
+                if (!(props !== null && props !== void 0 && (_props$signal = props.signal) !== null && _props$signal !== void 0 && _props$signal.aborted)) {
+                  _context3.next = 6;
+                  break;
+                }
+
+                throw _tiffUtils.SIGNAL_ABORTED;
+
+              case 6:
+                data = interleave ? raster : raster[0];
+                return _context3.abrupt("return", {
+                  data: data,
+                  width: raster.width,
+                  height: raster.height
+                });
+
+              case 8:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+
+      function _readRasters(_x3, _x4) {
+        return _readRasters2.apply(this, arguments);
+      }
+
+      return _readRasters;
+    }()
+  }, {
+    key: "_getTileExtent",
+    value: function _getTileExtent(x, y) {
+      var _getImageSize = (0, _tiffUtils.getImageSize)(this),
+          zoomLevelHeight = _getImageSize.height,
+          zoomLevelWidth = _getImageSize.width;
+
+      var height = this.tileSize;
+      var width = this.tileSize;
+      var maxXTileCoord = Math.floor(zoomLevelWidth / this.tileSize);
+      var maxYTileCoord = Math.floor(zoomLevelHeight / this.tileSize);
+
+      if (x === maxXTileCoord) {
+        width = zoomLevelWidth % this.tileSize;
+      }
+
+      if (y === maxYTileCoord) {
+        height = zoomLevelHeight % this.tileSize;
+      }
+
+      return {
+        height: height,
+        width: width
+      };
+    }
+  }, {
+    key: "onTileError",
+    value: function onTileError(err) {
+      console.error(err);
+    }
+  }]);
+  return TiffPixelSource;
+}();
+
+var _default = TiffPixelSource;
+exports.default = _default;
+//# sourceMappingURL=tiff-pixel-source.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/tiff-pixel-source.ts"],"names":["TiffPixelSource","indexer","dtype","tileSize","shape","labels","meta","_indexer","selection","signal","image","_readRasters","x","y","_getTileExtent","height","width","x0","y0","window","props","interleave","readRasters","raster","aborted","SIGNAL_ABORTED","data","zoomLevelHeight","zoomLevelWidth","maxXTileCoord","Math","floor","maxYTileCoord","err","console","error"],"mappings":"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","sourcesContent":["import type {GeoTIFFImage, RasterOptions} from 'geotiff';\nimport {getImageSize, isInterleaved, SIGNAL_ABORTED} from './utils/tiff-utils';\n\nimport type {\n  PixelSource,\n  PixelSourceSelection,\n  PixelSourceMeta,\n  Dtype,\n  Labels,\n  RasterSelection,\n  TileSelection,\n  PixelData,\n  TypedArray\n} from '../types';\n\nclass TiffPixelSource<S extends string[]> implements PixelSource<S> {\n  public dtype: Dtype;\n  public tileSize: number;\n  public shape: number[];\n  public labels: Labels<S>;\n  public meta: PixelSourceMeta | undefined;\n  private _indexer: (sel: PixelSourceSelection<S>) => Promise<GeoTIFFImage>;\n\n  // eslint-disable-next-line max-params\n  constructor(\n    indexer: (sel: PixelSourceSelection<S>) => Promise<GeoTIFFImage>,\n    dtype: Dtype,\n    tileSize: number,\n    shape: number[],\n    labels: Labels<S>,\n    meta?: PixelSourceMeta\n  ) {\n    this._indexer = indexer;\n    this.dtype = dtype;\n    this.tileSize = tileSize;\n    this.shape = shape;\n    this.labels = labels;\n    this.meta = meta;\n  }\n\n  async getRaster({selection, signal}: RasterSelection<S>) {\n    const image = await this._indexer(selection);\n    return this._readRasters(image, {signal});\n  }\n\n  async getTile({x, y, selection, signal}: TileSelection<S>) {\n    const {height, width} = this._getTileExtent(x, y);\n    const x0 = x * this.tileSize;\n    const y0 = y * this.tileSize;\n    const window = [x0, y0, x0 + width, y0 + height];\n\n    const image = await this._indexer(selection);\n    return this._readRasters(image, {window, width, height, signal});\n  }\n\n  private async _readRasters(image: GeoTIFFImage, props?: RasterOptions) {\n    const interleave = isInterleaved(this.shape);\n    const raster = await image.readRasters({interleave, ...props});\n\n    if (props?.signal?.aborted) {\n      throw SIGNAL_ABORTED;\n    }\n\n    /*\n     * geotiff.js returns objects with different structure\n     * depending on `interleave`. It's weird, but this seems to work.\n     */\n    const data = (interleave ? raster : raster[0]) as TypedArray;\n    return {\n      data,\n      width: raster.width,\n      height: raster.height\n    } as PixelData;\n  }\n\n  /*\n   * Computes tile size given x, y coord.\n   */\n  private _getTileExtent(x: number, y: number) {\n    const {height: zoomLevelHeight, width: zoomLevelWidth} = getImageSize(this);\n    let height = this.tileSize;\n    let width = this.tileSize;\n    const maxXTileCoord = Math.floor(zoomLevelWidth / this.tileSize);\n    const maxYTileCoord = Math.floor(zoomLevelHeight / this.tileSize);\n    if (x === maxXTileCoord) {\n      width = zoomLevelWidth % this.tileSize;\n    }\n    if (y === maxYTileCoord) {\n      height = zoomLevelHeight % this.tileSize;\n    }\n    return {height, width};\n  }\n\n  onTileError(err: Error) {\n    console.error(err); // eslint-disable-line no-console\n  }\n}\n\nexport default TiffPixelSource;\n"],"file":"tiff-pixel-source.js"}

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

@@ -0,0 +1,173 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _globalThis$navigator, _globalThis$navigator2;
+
+var 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;
+
+var Pool = function () {
+  function Pool() {
+    var size = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultPoolSize;
+    (0, _classCallCheck2.default)(this, Pool);
+    (0, _defineProperty2.default)(this, "workers", void 0);
+    (0, _defineProperty2.default)(this, "idleWorkers", void 0);
+    (0, _defineProperty2.default)(this, "waitQueue", void 0);
+    (0, _defineProperty2.default)(this, "decoder", void 0);
+    this.workers = [];
+    this.idleWorkers = [];
+    this.waitQueue = [];
+    this.decoder = null;
+
+    for (var i = 0; i < size; ++i) {
+      var w = new Worker('./decoder.worker');
+      this.workers.push(w);
+      this.idleWorkers.push(w);
+    }
+  }
+
+  (0, _createClass2.default)(Pool, [{
+    key: "decode",
+    value: function () {
+      var _decode = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(fileDirectory, buffer) {
+        var _this = this;
+
+        var currentWorker;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _context.next = 2;
+                return this.waitForWorker();
+
+              case 2:
+                currentWorker = _context.sent;
+                return _context.abrupt("return", new Promise(function (resolve, reject) {
+                  currentWorker.onmessage = function (event) {
+                    _this.finishTask(currentWorker);
+
+                    resolve(event.data[0]);
+                  };
+
+                  currentWorker.onerror = function (error) {
+                    _this.finishTask(currentWorker);
+
+                    reject(error);
+                  };
+
+                  currentWorker.postMessage(['decode', fileDirectory, buffer], [buffer]);
+                }));
+
+              case 4:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function decode(_x, _x2) {
+        return _decode.apply(this, arguments);
+      }
+
+      return decode;
+    }()
+  }, {
+    key: "waitForWorker",
+    value: function () {
+      var _waitForWorker = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2() {
+        var idleWorker, waiter, promise;
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                idleWorker = this.idleWorkers.pop();
+
+                if (!idleWorker) {
+                  _context2.next = 3;
+                  break;
+                }
+
+                return _context2.abrupt("return", idleWorker);
+
+              case 3:
+                waiter = {};
+                promise = new Promise(function (resolve) {
+                  waiter.resolve = resolve;
+                });
+                this.waitQueue.push(waiter);
+                return _context2.abrupt("return", promise);
+
+              case 7:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function waitForWorker() {
+        return _waitForWorker.apply(this, arguments);
+      }
+
+      return waitForWorker;
+    }()
+  }, {
+    key: "finishTask",
+    value: function () {
+      var _finishTask = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee3(currentWorker) {
+        var waiter;
+        return _regenerator.default.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                waiter = this.waitQueue.pop();
+
+                if (waiter) {
+                  waiter.resolve(currentWorker);
+                } else {
+                  this.idleWorkers.push(currentWorker);
+                }
+
+              case 2:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+
+      function finishTask(_x3) {
+        return _finishTask.apply(this, arguments);
+      }
+
+      return finishTask;
+    }()
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      for (var i = 0; i < this.workers.length; ++i) {
+        this.workers[i].terminate();
+      }
+    }
+  }]);
+  return Pool;
+}();
+
+exports.default = Pool;
+//# sourceMappingURL=Pool.js.map