@developmentseed/deck.gl-raster 0.1.0-beta.2 → 0.1.0-beta.4

package/dist/index.cjs

@@ -1,729 +1,4 @@
 'use strict';
 
-var proj4 = require('proj4');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var proj4__default = /*#__PURE__*/_interopDefault(proj4);
-
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/reprojection/index.ts
-var reprojection_exports = {};
-__export(reprojection_exports, {
-  RasterReprojector: () => RasterReprojector,
-  affine: () => affine_exports,
-  extractGeotiffReprojectors: () => extractGeotiffReprojectors,
-  fromGeoTransform: () => fromGeoTransform
-});
-
-// src/reprojection/delatin.ts
-var SAMPLE_POINTS = [
-  [1 / 3, 1 / 3, 1 / 3],
-  // centroid
-  [0.5, 0.5, 0],
-  // edge 0–1
-  [0.5, 0, 0.5],
-  // edge 0–2
-  [0, 0.5, 0.5]
-  // edge 1–2
-];
-var RasterReprojector = class {
-  reprojectors;
-  width;
-  height;
-  /**
-   * UV vertex coordinates (x, y), i.e.
-   * [x0, y0, x1, y1, ...]
-   *
-   * These coordinates are floats that range from [0, 1] in both X and Y.
-   */
-  uvs;
-  /**
-   * XY Positions in output CRS, computed via exact forward reprojection.
-   */
-  exactOutputPositions;
-  /**
-   * triangle vertex indices
-   */
-  triangles;
-  _halfedges;
-  /**
-   * The UV texture coordinates of candidates found from
-   * `findReprojectionCandidate`.
-   *
-   * Maybe in the future we'll want to store the barycentric coordinates instead
-   * of just the uv coordinates?
-   */
-  _candidatesUV;
-  _queueIndices;
-  _queue;
-  _errors;
-  _pending;
-  _pendingLen;
-  constructor(reprojectors, width, height = width) {
-    this.reprojectors = reprojectors;
-    this.width = width;
-    this.height = height;
-    this.uvs = [];
-    this.exactOutputPositions = [];
-    this.triangles = [];
-    this._halfedges = [];
-    this._candidatesUV = [];
-    this._queueIndices = [];
-    this._queue = [];
-    this._errors = [];
-    this._pending = [];
-    this._pendingLen = 0;
-    const u1 = 1;
-    const v1 = 1;
-    const p0 = this._addPoint(0, 0);
-    const p1 = this._addPoint(u1, 0);
-    const p2 = this._addPoint(0, v1);
-    const p3 = this._addPoint(u1, v1);
-    const t0 = this._addTriangle(p3, p0, p2, -1, -1, -1);
-    this._addTriangle(p0, p3, p1, t0, -1, -1);
-    this._flush();
-  }
-  // refine the mesh until its maximum error gets below the given one
-  run(maxError = 1) {
-    while (this.getMaxError() > maxError) {
-      this.refine();
-    }
-  }
-  // refine the mesh with a single point
-  refine() {
-    this._step();
-    this._flush();
-  }
-  // max error of the current mesh
-  getMaxError() {
-    return this._errors[0];
-  }
-  // rasterize and queue all triangles that got added or updated in _step
-  _flush() {
-    for (let i = 0; i < this._pendingLen; i++) {
-      const t = this._pending[i];
-      this._findReprojectionCandidate(t);
-    }
-    this._pendingLen = 0;
-  }
-  // Original, upstream implementation of FindCandidate:
-  // // rasterize a triangle, find its max error, and queue it for processing
-  // private _findCandidate(
-  //   p0x: number,
-  //   p0y: number,
-  //   p1x: number,
-  //   p1y: number,
-  //   p2x: number,
-  //   p2y: number,
-  //   t: number,
-  // ) {
-  //   // triangle bounding box
-  //   const minX = Math.min(p0x, p1x, p2x);
-  //   const minY = Math.min(p0y, p1y, p2y);
-  //   const maxX = Math.max(p0x, p1x, p2x);
-  //   const maxY = Math.max(p0y, p1y, p2y);
-  //   // forward differencing variables
-  //   let w00 = orient(p1x, p1y, p2x, p2y, minX, minY);
-  //   let w01 = orient(p2x, p2y, p0x, p0y, minX, minY);
-  //   let w02 = orient(p0x, p0y, p1x, p1y, minX, minY);
-  //   const a01 = p1y - p0y;
-  //   const b01 = p0x - p1x;
-  //   const a12 = p2y - p1y;
-  //   const b12 = p1x - p2x;
-  //   const a20 = p0y - p2y;
-  //   const b20 = p2x - p0x;
-  //   // pre-multiplied z values at vertices
-  //   const a = orient(p0x, p0y, p1x, p1y, p2x, p2y);
-  //   const z0 = this.heightAt(p0x, p0y) / a;
-  //   const z1 = this.heightAt(p1x, p1y) / a;
-  //   const z2 = this.heightAt(p2x, p2y) / a;
-  //   // iterate over pixels in bounding box
-  //   let maxError = 0;
-  //   let mx = 0;
-  //   let my = 0;
-  //   for (let y = minY; y <= maxY; y++) {
-  //     // compute starting offset
-  //     let dx = 0;
-  //     if (w00 < 0 && a12 !== 0) {
-  //       dx = Math.max(dx, Math.floor(-w00 / a12));
-  //     }
-  //     if (w01 < 0 && a20 !== 0) {
-  //       dx = Math.max(dx, Math.floor(-w01 / a20));
-  //     }
-  //     if (w02 < 0 && a01 !== 0) {
-  //       dx = Math.max(dx, Math.floor(-w02 / a01));
-  //     }
-  //     let w0 = w00 + a12 * dx;
-  //     let w1 = w01 + a20 * dx;
-  //     let w2 = w02 + a01 * dx;
-  //     let wasInside = false;
-  //     for (let x = minX + dx; x <= maxX; x++) {
-  //       // check if inside triangle
-  //       if (w0 >= 0 && w1 >= 0 && w2 >= 0) {
-  //         wasInside = true;
-  //         // compute z using barycentric coordinates
-  //         const z = z0 * w0 + z1 * w1 + z2 * w2;
-  //         const dz = Math.abs(z - this.heightAt(x, y));
-  //         if (dz > maxError) {
-  //           maxError = dz;
-  //           mx = x;
-  //           my = y;
-  //         }
-  //       } else if (wasInside) {
-  //         break;
-  //       }
-  //       w0 += a12;
-  //       w1 += a20;
-  //       w2 += a01;
-  //     }
-  //     w00 += b12;
-  //     w01 += b20;
-  //     w02 += b01;
-  //   }
-  //   if (
-  //     (mx === p0x && my === p0y) ||
-  //     (mx === p1x && my === p1y) ||
-  //     (mx === p2x && my === p2y)
-  //   ) {
-  //     maxError = 0;
-  //   }
-  //   // update triangle metadata
-  //   this._candidatesUV[2 * t] = mx;
-  //   this._candidatesUV[2 * t + 1] = my;
-  //   // add triangle to priority queue
-  //   this._queuePush(t, maxError);
-  // }
-  /**
-   * Conversion of upstream's `_findCandidate` for reprojection error handling.
-   *
-   * @param   {number}  t  The index (into `this.triangles`) of the pending triangle to process.
-   *
-   * @return  {void}    Doesn't return; instead modifies internal state.
-   */
-  _findReprojectionCandidate(t) {
-    const a2 = 2 * this.triangles[t * 3 + 0];
-    const b2 = 2 * this.triangles[t * 3 + 1];
-    const c = 2 * this.triangles[t * 3 + 2];
-    const p0u = this.uvs[a2];
-    const p0v = this.uvs[a2 + 1];
-    const p1u = this.uvs[b2];
-    const p1v = this.uvs[b2 + 1];
-    const p2u = this.uvs[c];
-    const p2v = this.uvs[c + 1];
-    const out0x = this.exactOutputPositions[a2];
-    const out0y = this.exactOutputPositions[a2 + 1];
-    const out1x = this.exactOutputPositions[b2];
-    const out1y = this.exactOutputPositions[b2 + 1];
-    const out2x = this.exactOutputPositions[c];
-    const out2y = this.exactOutputPositions[c + 1];
-    let maxError = 0;
-    let maxErrorU = 0;
-    let maxErrorV = 0;
-    for (const samplePoint of SAMPLE_POINTS) {
-      const uvSampleU = barycentricMix(
-        p0u,
-        p1u,
-        p2u,
-        samplePoint[0],
-        samplePoint[1],
-        samplePoint[2]
-      );
-      const uvSampleV = barycentricMix(
-        p0v,
-        p1v,
-        p2v,
-        samplePoint[0],
-        samplePoint[1],
-        samplePoint[2]
-      );
-      const outSampleX = barycentricMix(
-        out0x,
-        out1x,
-        out2x,
-        samplePoint[0],
-        samplePoint[1],
-        samplePoint[2]
-      );
-      const outSampleY = barycentricMix(
-        out0y,
-        out1y,
-        out2y,
-        samplePoint[0],
-        samplePoint[1],
-        samplePoint[2]
-      );
-      const pixelExactX = uvSampleU * (this.width - 1);
-      const pixelExactY = uvSampleV * (this.height - 1);
-      const inputCRSSampled = this.reprojectors.inverseReproject(
-        outSampleX,
-        outSampleY
-      );
-      const pixelSampled = this.reprojectors.inputCRSToPixel(
-        inputCRSSampled[0],
-        inputCRSSampled[1]
-      );
-      const dx = pixelExactX - pixelSampled[0];
-      const dy = pixelExactY - pixelSampled[1];
-      const err = Math.hypot(dx, dy);
-      if (err > maxError) {
-        maxError = err;
-        maxErrorU = uvSampleU;
-        maxErrorV = uvSampleV;
-      }
-    }
-    if (maxErrorU === p0u && maxErrorV === p0v || maxErrorU === p1u && maxErrorV === p1v || maxErrorU === p2u && maxErrorV === p2v) {
-      maxError = 0;
-    }
-    this._candidatesUV[2 * t] = maxErrorU;
-    this._candidatesUV[2 * t + 1] = maxErrorV;
-    this._queuePush(t, maxError);
-  }
-  // process the next triangle in the queue, splitting it with a new point
-  _step() {
-    const t = this._queuePop();
-    const e0 = t * 3 + 0;
-    const e1 = t * 3 + 1;
-    const e2 = t * 3 + 2;
-    const p0 = this.triangles[e0];
-    const p1 = this.triangles[e1];
-    const p2 = this.triangles[e2];
-    const au = this.uvs[2 * p0];
-    const av = this.uvs[2 * p0 + 1];
-    const bu = this.uvs[2 * p1];
-    const bv = this.uvs[2 * p1 + 1];
-    const cu = this.uvs[2 * p2];
-    const cv = this.uvs[2 * p2 + 1];
-    const pu = this._candidatesUV[2 * t];
-    const pv = this._candidatesUV[2 * t + 1];
-    const pn = this._addPoint(pu, pv);
-    if (orient(au, av, bu, bv, pu, pv) === 0) {
-      this._handleCollinear(pn, e0);
-    } else if (orient(bu, bv, cu, cv, pu, pv) === 0) {
-      this._handleCollinear(pn, e1);
-    } else if (orient(cu, cv, au, av, pu, pv) === 0) {
-      this._handleCollinear(pn, e2);
-    } else {
-      const h0 = this._halfedges[e0];
-      const h1 = this._halfedges[e1];
-      const h2 = this._halfedges[e2];
-      const t0 = this._addTriangle(p0, p1, pn, h0, -1, -1, e0);
-      const t1 = this._addTriangle(p1, p2, pn, h1, -1, t0 + 1);
-      const t2 = this._addTriangle(p2, p0, pn, h2, t0 + 2, t1 + 1);
-      this._legalize(t0);
-      this._legalize(t1);
-      this._legalize(t2);
-    }
-  }
-  // add coordinates for a new vertex
-  _addPoint(u, v) {
-    const i = this.uvs.length >> 1;
-    this.uvs.push(u, v);
-    const pixelX = u * (this.width - 1);
-    const pixelY = v * (this.height - 1);
-    const inputPosition = this.reprojectors.pixelToInputCRS(pixelX, pixelY);
-    const exactOutputPosition = this.reprojectors.forwardReproject(
-      inputPosition[0],
-      inputPosition[1]
-    );
-    this.exactOutputPositions.push(
-      exactOutputPosition[0],
-      exactOutputPosition[1]
-    );
-    return i;
-  }
-  // add or update a triangle in the mesh
-  _addTriangle(a2, b2, c, ab, bc, ca, e2 = this.triangles.length) {
-    const t = e2 / 3;
-    this.triangles[e2 + 0] = a2;
-    this.triangles[e2 + 1] = b2;
-    this.triangles[e2 + 2] = c;
-    this._halfedges[e2 + 0] = ab;
-    this._halfedges[e2 + 1] = bc;
-    this._halfedges[e2 + 2] = ca;
-    if (ab >= 0) {
-      this._halfedges[ab] = e2 + 0;
-    }
-    if (bc >= 0) {
-      this._halfedges[bc] = e2 + 1;
-    }
-    if (ca >= 0) {
-      this._halfedges[ca] = e2 + 2;
-    }
-    this._candidatesUV[2 * t + 0] = 0;
-    this._candidatesUV[2 * t + 1] = 0;
-    this._queueIndices[t] = -1;
-    this._pending[this._pendingLen++] = t;
-    return e2;
-  }
-  _legalize(a2) {
-    const b2 = this._halfedges[a2];
-    if (b2 < 0) {
-      return;
-    }
-    const a0 = a2 - a2 % 3;
-    const b0 = b2 - b2 % 3;
-    const al = a0 + (a2 + 1) % 3;
-    const ar = a0 + (a2 + 2) % 3;
-    const bl = b0 + (b2 + 2) % 3;
-    const br = b0 + (b2 + 1) % 3;
-    const p0 = this.triangles[ar];
-    const pr = this.triangles[a2];
-    const pl = this.triangles[al];
-    const p1 = this.triangles[bl];
-    const uvs = this.uvs;
-    if (!inCircle(
-      uvs[2 * p0],
-      uvs[2 * p0 + 1],
-      uvs[2 * pr],
-      uvs[2 * pr + 1],
-      uvs[2 * pl],
-      uvs[2 * pl + 1],
-      uvs[2 * p1],
-      uvs[2 * p1 + 1]
-    )) {
-      return;
-    }
-    const hal = this._halfedges[al];
-    const har = this._halfedges[ar];
-    const hbl = this._halfedges[bl];
-    const hbr = this._halfedges[br];
-    this._queueRemove(a0 / 3);
-    this._queueRemove(b0 / 3);
-    const t0 = this._addTriangle(p0, p1, pl, -1, hbl, hal, a0);
-    const t1 = this._addTriangle(p1, p0, pr, t0, har, hbr, b0);
-    this._legalize(t0 + 1);
-    this._legalize(t1 + 2);
-  }
-  // handle a case where new vertex is on the edge of a triangle
-  _handleCollinear(pn, a2) {
-    const a0 = a2 - a2 % 3;
-    const al = a0 + (a2 + 1) % 3;
-    const ar = a0 + (a2 + 2) % 3;
-    const p0 = this.triangles[ar];
-    const pr = this.triangles[a2];
-    const pl = this.triangles[al];
-    const hal = this._halfedges[al];
-    const har = this._halfedges[ar];
-    const b2 = this._halfedges[a2];
-    if (b2 < 0) {
-      const t02 = this._addTriangle(pn, p0, pr, -1, har, -1, a0);
-      const t12 = this._addTriangle(p0, pn, pl, t02, -1, hal);
-      this._legalize(t02 + 1);
-      this._legalize(t12 + 2);
-      return;
-    }
-    const b0 = b2 - b2 % 3;
-    const bl = b0 + (b2 + 2) % 3;
-    const br = b0 + (b2 + 1) % 3;
-    const p1 = this.triangles[bl];
-    const hbl = this._halfedges[bl];
-    const hbr = this._halfedges[br];
-    this._queueRemove(b0 / 3);
-    const t0 = this._addTriangle(p0, pr, pn, har, -1, -1, a0);
-    const t1 = this._addTriangle(pr, p1, pn, hbr, -1, t0 + 1, b0);
-    const t2 = this._addTriangle(p1, pl, pn, hbl, -1, t1 + 1);
-    const t3 = this._addTriangle(pl, p0, pn, hal, t0 + 2, t2 + 1);
-    this._legalize(t0);
-    this._legalize(t1);
-    this._legalize(t2);
-    this._legalize(t3);
-  }
-  // priority queue methods
-  _queuePush(t, error) {
-    const i = this._queue.length;
-    this._queueIndices[t] = i;
-    this._queue.push(t);
-    this._errors.push(error);
-    this._queueUp(i);
-  }
-  _queuePop() {
-    const n = this._queue.length - 1;
-    this._queueSwap(0, n);
-    this._queueDown(0, n);
-    return this._queuePopBack();
-  }
-  _queuePopBack() {
-    const t = this._queue.pop();
-    this._errors.pop();
-    this._queueIndices[t] = -1;
-    return t;
-  }
-  _queueRemove(t) {
-    const i = this._queueIndices[t];
-    if (i < 0) {
-      const it = this._pending.indexOf(t);
-      if (it !== -1) {
-        this._pending[it] = this._pending[--this._pendingLen];
-      } else {
-        throw new Error("Broken triangulation (something went wrong).");
-      }
-      return;
-    }
-    const n = this._queue.length - 1;
-    if (n !== i) {
-      this._queueSwap(i, n);
-      if (!this._queueDown(i, n)) {
-        this._queueUp(i);
-      }
-    }
-    this._queuePopBack();
-  }
-  _queueLess(i, j) {
-    return this._errors[i] > this._errors[j];
-  }
-  _queueSwap(i, j) {
-    const pi = this._queue[i];
-    const pj = this._queue[j];
-    this._queue[i] = pj;
-    this._queue[j] = pi;
-    this._queueIndices[pi] = j;
-    this._queueIndices[pj] = i;
-    const e2 = this._errors[i];
-    this._errors[i] = this._errors[j];
-    this._errors[j] = e2;
-  }
-  _queueUp(j0) {
-    let j = j0;
-    while (true) {
-      const i = j - 1 >> 1;
-      if (i === j || !this._queueLess(j, i)) {
-        break;
-      }
-      this._queueSwap(i, j);
-      j = i;
-    }
-  }
-  _queueDown(i0, n) {
-    let i = i0;
-    while (true) {
-      const j1 = 2 * i + 1;
-      if (j1 >= n || j1 < 0) {
-        break;
-      }
-      const j2 = j1 + 1;
-      let j = j1;
-      if (j2 < n && this._queueLess(j2, j1)) {
-        j = j2;
-      }
-      if (!this._queueLess(j, i)) {
-        break;
-      }
-      this._queueSwap(i, j);
-      i = j;
-    }
-    return i > i0;
-  }
-};
-function orient(ax, ay, bx, by, cx, cy) {
-  return (bx - cx) * (ay - cy) - (by - cy) * (ax - cx);
-}
-function inCircle(ax, ay, bx, by, cx, cy, px, py) {
-  const dx = ax - px;
-  const dy = ay - py;
-  const ex = bx - px;
-  const ey = by - py;
-  const fx = cx - px;
-  const fy = cy - py;
-  const ap = dx * dx + dy * dy;
-  const bp = ex * ex + ey * ey;
-  const cp = fx * fx + fy * fy;
-  return dx * (ey * cp - bp * fy) - dy * (ex * cp - bp * fx) + ap * (ex * fy - ey * fx) < 0;
-}
-function barycentricMix(a2, b2, c, t0, t1, t2) {
-  return t0 * a2 + t1 * b2 + t2 * c;
-}
-
-// src/reprojection/affine.ts
-var affine_exports = {};
-__export(affine_exports, {
-  applyAffine: () => applyAffine,
-  invertGeoTransform: () => invertGeoTransform
-});
-function invertGeoTransform(gt) {
-  if (isDegenerate(gt)) {
-    throw new Error("Cannot invert degenerate transform");
-  }
-  const idet = 1 / determinant(gt);
-  const [sa, sb, sc, sd, se, sf] = gt;
-  const ra = se * idet;
-  const rb = -sb * idet;
-  const rd = -sd * idet;
-  const re = sa * idet;
-  return [
-    ra,
-    rb,
-    -sc * ra - sf * rb,
-    rd,
-    re,
-    -sc * rd - sf * re
-  ];
-}
-function isDegenerate(gt) {
-  return determinant(gt) === 0;
-}
-function determinant(gt) {
-  return a(gt) * e(gt) - b(gt) * d(gt);
-}
-function a(gt) {
-  return gt[0];
-}
-function b(gt) {
-  return gt[1];
-}
-function d(gt) {
-  return gt[3];
-}
-function e(gt) {
-  return gt[4];
-}
-function applyAffine(x, y, gt) {
-  const [a2, b2, c, d2, e2, f] = gt;
-  return [a2 * x + b2 * y + c, d2 * x + e2 * y + f];
-}
-var OGC_84 = {
-  $schema: "https://proj.org/schemas/v0.7/projjson.schema.json",
-  type: "GeographicCRS",
-  name: "WGS 84 (CRS84)",
-  datum_ensemble: {
-    name: "World Geodetic System 1984 ensemble",
-    members: [
-      {
-        name: "World Geodetic System 1984 (Transit)",
-        id: { authority: "EPSG", code: 1166 }
-      },
-      {
-        name: "World Geodetic System 1984 (G730)",
-        id: { authority: "EPSG", code: 1152 }
-      },
-      {
-        name: "World Geodetic System 1984 (G873)",
-        id: { authority: "EPSG", code: 1153 }
-      },
-      {
-        name: "World Geodetic System 1984 (G1150)",
-        id: { authority: "EPSG", code: 1154 }
-      },
-      {
-        name: "World Geodetic System 1984 (G1674)",
-        id: { authority: "EPSG", code: 1155 }
-      },
-      {
-        name: "World Geodetic System 1984 (G1762)",
-        id: { authority: "EPSG", code: 1156 }
-      },
-      {
-        name: "World Geodetic System 1984 (G2139)",
-        id: { authority: "EPSG", code: 1309 }
-      }
-    ],
-    ellipsoid: {
-      name: "WGS 84",
-      semi_major_axis: 6378137,
-      inverse_flattening: 298.257223563
-    },
-    accuracy: "2.0",
-    id: { authority: "EPSG", code: 6326 }
-  },
-  coordinate_system: {
-    subtype: "ellipsoidal",
-    axis: [
-      {
-        name: "Geodetic longitude",
-        abbreviation: "Lon",
-        direction: "east",
-        unit: "degree"
-      },
-      {
-        name: "Geodetic latitude",
-        abbreviation: "Lat",
-        direction: "north",
-        unit: "degree"
-      }
-    ]
-  },
-  scope: "Not known.",
-  area: "World.",
-  bbox: {
-    south_latitude: -90,
-    west_longitude: -180,
-    north_latitude: 90,
-    east_longitude: 180
-  },
-  // @ts-expect-error - proj4 types are incomplete
-  id: { authority: "OGC", code: "CRS84" }
-};
-async function extractGeotiffReprojectors(tiff, outputCrs = OGC_84) {
-  const image = await tiff.getImage();
-  const geoKeys = image.getGeoKeys();
-  const projectionCode = geoKeys.ProjectedCSTypeGeoKey || geoKeys.GeographicTypeGeoKey || null;
-  const baseGeotransform = extractGeotransform(image);
-  const sourceProjection = await getProjjson(projectionCode);
-  if (sourceProjection === null) {
-    throw new Error(
-      "Could not determine source projection from GeoTIFF geo keys"
-    );
-  }
-  const converter = proj4__default.default(sourceProjection, outputCrs);
-  const { pixelToInputCRS, inputCRSToPixel } = fromGeoTransform(baseGeotransform);
-  return {
-    pixelToInputCRS,
-    inputCRSToPixel,
-    forwardReproject: (x, y) => converter.forward([x, y], false),
-    inverseReproject: (x, y) => converter.inverse([x, y], false)
-  };
-}
-function fromGeoTransform(geotransform) {
-  const inverseGeotransform = invertGeoTransform(geotransform);
-  return {
-    pixelToInputCRS: (x, y) => applyAffine(x, y, geotransform),
-    inputCRSToPixel: (x, y) => applyAffine(x, y, inverseGeotransform)
-  };
-}
-async function getProjjson(projectionCode) {
-  if (projectionCode === null) {
-    return null;
-  }
-  const url = `https://epsg.io/${projectionCode}.json`;
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new Error(`Failed to fetch projection data from ${url}`);
-  }
-  const data = await response.json();
-  return data;
-}
-function extractGeotransform(image) {
-  const origin = image.getOrigin();
-  const resolution = image.getResolution();
-  const fileDirectory = image.getFileDirectory();
-  const modelTransformation = fileDirectory.ModelTransformation;
-  let b2 = 0;
-  let d2 = 0;
-  if (modelTransformation && modelTransformation.length >= 16) {
-    b2 = modelTransformation[1];
-    d2 = modelTransformation[4];
-  }
-  return [
-    resolution[0],
-    // a: pixel width
-    b2,
-    // b: row rotation
-    origin[0],
-    // c: x origin
-    d2,
-    // d: column rotation
-    resolution[1],
-    // e: pixel height (often negative)
-    origin[1]
-    // f: y origin
-  ];
-}
-
-exports.reprojection = reprojection_exports;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map