cog-tiler-wasm 0.2.6 → 0.3.1

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.
@@ -569,7 +554,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 +564,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.2.6",
+  "version": "0.3.1",
   "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;
+}