@developmentseed/deck.gl-raster 0.1.0-beta.1

package/dist/index.js

@@ -0,0 +1,723 @@
+import proj4 from '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(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
+  ];
+}
+
+export { reprojection_exports as reprojection };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map