cog-tiler-wasm 0.3.0 → 0.3.2

package/cog-tiler.js

@@ -25,6 +25,7 @@ import initTiler, { colorize, colormap_names } from "./cog_tiler_wasm.js";
 import proj4 from "proj4";
 import * as GeoTIFF from "geotiff";
 import geokeysToProj4 from "geotiff-geokeys-to-proj4";
+import { sampleWindowBilinear } from "./sampling.js";
 
 const OS = 20037508.342789244; // Web Mercator half-extent (m)
 const TILE = 256; // output tile size (px)
@@ -224,22 +225,6 @@ function bilin(v00, v10, v01, v11, tx, ty) {
   return top + (bot - top) * ty;
 }
 
-// Bilinear sample of a row-major window at fractional (fc,fr). Returns NaN when
-// the cell center is outside the window so out-of-raster pixels stay transparent
-// (no edge smear); falls back to nearest at the window edge / next to nodata.
-function sampleWindowBilinear(buf, w, h, fc, fr) {
-  const c0 = Math.floor(fc), r0 = Math.floor(fr);
-  if (c0 < 0 || c0 >= w || r0 < 0 || r0 >= h) return NaN;
-  const c1 = Math.min(c0 + 1, w - 1), r1 = Math.min(r0 + 1, h - 1);
-  const v00 = buf[r0 * w + c0];
-  if (Number.isNaN(v00)) return NaN;
-  const v10 = buf[r0 * w + c1], v01 = buf[r1 * w + c0], v11 = buf[r1 * w + c1];
-  if (Number.isNaN(v10) || Number.isNaN(v01) || Number.isNaN(v11)) return v00; // edge/nodata
-  const tx = fc - c0, ty = fr - r0;
-  const top = v00 + (v10 - v00) * tx, bot = v01 + (v11 - v01) * tx;
-  return top + (bot - top) * ty;
-}
-
 // Build a byte reader from a URL string, a Blob/File, or an in-memory source
 // (ArrayBuffer, Uint8Array). `range(a,b)` yields bytes [a..b]; `openTiff()`
 // returns a geotiff.js GeoTIFF for reading the CRS / color table from the header.
@@ -290,6 +275,11 @@ async function makeReader(source) {
 export async function openCog(source) {
   await init();
   const { range, openTiff, label } = await makeReader(source);
+  // whitebox-wasm's streaming decoder currently materializes numeric tile
+  // samples as little-endian. Detect Motorola TIFFs up front so their pixels
+  // can be decoded by geotiff.js, which honors the header byte order.
+  const byteOrder = await range(0, 1);
+  const bigEndian = byteOrder[0] === 0x4d && byteOrder[1] === 0x4d;
   // Parse the COG header; grow the prefix and retry for large COGs whose IFDs
   // exceed 64 KB (many overviews / huge tile-offset arrays).
   let stream;
@@ -301,7 +291,7 @@ export async function openCog(source) {
       if (len >= 1 << 25) throw e; // give up past ~32 MB
     }
   }
-  const gt = stream.geo_transform(); // [x0, px_w, rot, y0, rot, px_h]
+  let gt = stream.geo_transform(); // [x0, px_w, rot, y0, rot, px_h]
   const levels = JSON.parse(stream.levels_json());
   if (!Array.isArray(levels) || levels.length === 0) {
     throw new Error("levels_json() returned no levels");
@@ -312,12 +302,27 @@ export async function openCog(source) {
   // through geotiff.js instead (see _assembleWindow / point).
   const multiBand = levels[0].bands > 1;
   let tiff = null, img = null, planar = false;
-  if (stream.epsg !== 3857 || multiBand) {
+  if (stream.epsg !== 3857 || multiBand || bigEndian) {
     tiff = await openTiff();
     img = await tiff.getImage();
     planar = multiBand && (await readTiffTag(img, "PlanarConfiguration")) === 2;
+    if (bigEndian && gt.length !== 6) {
+      const [x, y] = img.getOrigin();
+      const [pixelWidth, pixelHeight] = img.getResolution();
+      gt = [x, pixelWidth, 0, y, 0, -pixelHeight];
+    }
   }
-  const base = { url: label, range, stream, levels, gt, nodata: stream.nodata, tiff, planar };
+  const base = {
+    url: label,
+    range,
+    stream,
+    levels,
+    gt,
+    nodata: stream.nodata,
+    tiff,
+    planar,
+    bigEndian,
+  };
 
   if (stream.epsg === 3857) {
     return new CogSource({
@@ -425,10 +430,11 @@ export class CogSource {
 
   // Fetch + decode band `band` (0-based) over a level pixel window into a
   // row-major buffer. Chunky COGs go through whitebox (cached, NaN for gaps);
-  // planar (INTERLEAVE=BAND) COGs are read per-band via geotiff.js, which
-  // whitebox's chunky-only streaming decoder can't address.
+  // Planar (INTERLEAVE=BAND) and big-endian COGs are read per-band via
+  // geotiff.js. Whitebox's streaming decoder cannot address planar tiles and
+  // currently interprets multi-byte tile samples as little-endian.
   async _assembleWindow(level, x, y, w, h, band = 0) {
-    if (this.planar) {
+    if (this.planar || this.bigEndian) {
       const img = await this._tiffImage(level);
       const rasters = await img.readRasters({ window: [x, y, x + w, y + h], samples: [band] });
       return rasters[0]; // typed array, length w*h, row-major
@@ -569,7 +575,7 @@ export class CogSource {
           // RGB composite: bilinear-sample each band, rescale -> curve -> gamma.
           let ok = true;
           for (let k = 0; k < 3; k++) {
-            const v = sampleWindowBilinear(bufs[k], ww, hh, fcol, frow);
+            const v = sampleWindowBilinear(bufs[k], ww, hh, fcol, frow, ndSet ? nodata : undefined);
             if (!isFinite(v) || (ndSet && v === nodata)) { ok = false; break; }
             const [mn, mx] = rescales[k] || rescales[0];
             const t = transferCurve(Math.max(0, Math.min(1, (v - mn) / ((mx - mn) || 1))), stretch, gamma);
@@ -579,7 +585,7 @@ export class CogSource {
           else { out[o] = out[o + 1] = out[o + 2] = 0; }
         } else {
           // Continuous single band: bilinear; colormap applied below.
-          const v = sampleWindowBilinear(bufs[0], ww, hh, fcol, frow);
+          const v = sampleWindowBilinear(bufs[0], ww, hh, fcol, frow, ndSet ? nodata : undefined);
           if (!isFinite(v) || (ndSet && v === nodata)) continue;
           grid[py * outW + px] = v;
         }

package/package.json

@@ -5,7 +5,7 @@
     "Qiusheng Wu <giswqs@gmail.com>"
   ],
   "description": "Serverless Cloud Optimized GeoTIFF (COG) dynamic tiling in WebAssembly. TiTiler-style XYZ tiles, no backend.",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -16,6 +16,7 @@
     "cog_tiler_wasm.js",
     "cog_tiler_wasm.d.ts",
     "cog-tiler.js",
+    "sampling.js",
     "cog-tiler.d.ts",
     "README.md",
     "LICENSE"

package/sampling.js

@@ -0,0 +1,33 @@
+/**
+ * Pure resampling helpers, kept dependency-free so they can be unit-tested
+ * without loading the wasm/geotiff stack that `cog-tiler.js` pulls in.
+ */
+
+// Bilinear sample of a row-major window at fractional (fc,fr). Returns NaN when
+// the cell center is outside the window so out-of-raster pixels stay transparent
+// (no edge smear); falls back to nearest at the window edge / next to nodata.
+//
+// `nodata` is the declared sentinel, when the dataset has one. It must be tested
+// here rather than only on the result: interpolating across the boundary blends
+// the sentinel into the value, and the product matches neither the sentinel nor
+// NaN, so a caller's `v === nodata` check cannot recognize it. With a large
+// negative sentinel (-9999 is the GDAL convention) the blend lands far below the
+// rescale window, clamps to its low end, and paints a ring of the colormap's
+// first color around every nodata boundary -- e.g. a blue border along a swath
+// edge under `jet`. Treating a sentinel neighbor exactly like a NaN one keeps
+// the boundary pixel at its own valid value instead.
+export function sampleWindowBilinear(buf, w, h, fc, fr, nodata) {
+  const c0 = Math.floor(fc), r0 = Math.floor(fr);
+  if (c0 < 0 || c0 >= w || r0 < 0 || r0 >= h) return NaN;
+  const c1 = Math.min(c0 + 1, w - 1), r1 = Math.min(r0 + 1, h - 1);
+  // `nodata` is undefined when the dataset declares none; `v === undefined` is
+  // false for every numeric sample, so the test costs nothing in that case.
+  const isVoid = (v) => Number.isNaN(v) || v === nodata;
+  const v00 = buf[r0 * w + c0];
+  if (isVoid(v00)) return NaN;
+  const v10 = buf[r0 * w + c1], v01 = buf[r1 * w + c0], v11 = buf[r1 * w + c1];
+  if (isVoid(v10) || isVoid(v01) || isVoid(v11)) return v00; // edge/nodata
+  const tx = fc - c0, ty = fr - r0;
+  const top = v00 + (v10 - v00) * tx, bot = v01 + (v11 - v01) * tx;
+  return top + (bot - top) * ty;
+}