cog-tiler-wasm 0.2.3 → 0.2.5

package/cog-tiler.d.ts

@@ -124,8 +124,8 @@ export declare function init(): Promise<unknown>;
 
 /**
  * Open a COG and return a {@link CogSource} ready to render XYZ tiles. Pass a URL
- * string (read via HTTP range) or in-memory bytes / a Blob / a File for a local
- * raster.
+ * string (read via HTTP range), a Blob / File (read via ranged slices, so
+ * multi-GB local rasters never load whole), or in-memory bytes.
  */
 export declare function openCog(source: string | ArrayBuffer | Uint8Array | Blob): Promise<CogSource>;
 

package/cog-tiler.js

@@ -165,6 +165,43 @@ async function readTiffTag(img, name) {
   return undefined;
 }
 
+// Root keyword of a projected WKT (OGC `PROJCS`/`PROJCRS`, including the ESRI PE
+// string flavour ArcGIS writes). Matching the keyword lets us slice off any
+// `ESRI PE String = ` prefix.
+const PROJECTED_WKT_ROOT = /\b(?:PROJCS|PROJCRS)\s*\[/i;
+
+/** Pull a projected WKT/ESRI-PE-string definition out of a GeoTIFF citation geo
+ * key, if one is present. Returns the WKT from the `PROJCS`/`PROJCRS` keyword
+ * onward, or `null`. */
+function projectedWktFromGeoKeys(geoKeys) {
+  for (const citation of [geoKeys.PCSCitationGeoKey, geoKeys.GTCitationGeoKey]) {
+    if (typeof citation !== "string") continue;
+    const match = PROJECTED_WKT_ROOT.exec(citation);
+    if (match) return citation.slice(match.index);
+  }
+  return null;
+}
+
+/**
+ * Resolve the source CRS as a proj4 definition (a `+proj=...` string or a WKT).
+ *
+ * `geotiff-geokeys-to-proj4` builds the def from the numeric geo keys, but for a
+ * projection it cannot express (no `ProjCoordTransGeoKey`, e.g. ESRI world
+ * projections such as Mollweide/54009 written only as an `ESRI PE String`) it
+ * silently falls back to the bare geographic CRS (`+proj=longlat`, `isGCS`).
+ * That would place a projected raster at lon/lat where its metre coordinates
+ * are, so it never draws. When the keys carry a projected WKT, prefer it; proj4
+ * parses the ESRI/OGC WKT directly.
+ */
+function sourceCrsDef(geoKeys) {
+  const result = geokeysToProj4.toProj4(geoKeys);
+  if (result.isGCS) {
+    const wkt = projectedWktFromGeoKeys(geoKeys);
+    if (wkt) return wkt;
+  }
+  return result.proj4;
+}
+
 /** Build a 256-entry RGBA palette from a TIFF ColorMap (16-bit R,G,B blocks). */
 function buildPalette(colorMap) {
   if (!colorMap) return null;
@@ -203,18 +240,29 @@ function sampleWindowBilinear(buf, w, h, fc, fr) {
   return top + (bot - top) * ty;
 }
 
-// Build a byte reader from a URL string or an in-memory source (ArrayBuffer,
-// Uint8Array, or Blob/File). `range(a,b)` yields bytes [a..b]; `openTiff()`
+// 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.
 async function makeReader(source) {
   if (typeof source === "string") {
     return { label: source, range: rangeFetcher(source), openTiff: () => GeoTIFF.fromUrl(source) };
   }
+  // Blob / File: read on demand via ranged slices, mirroring the URL path.
+  // Slurping the whole file (blob.arrayBuffer()) throws NotReadableError in
+  // Chromium for multi-GB rasters (e.g. the 7 GB GEBCO GeoTIFF) — and only the
+  // header prefix and the requested tiles are ever needed.
+  if (typeof Blob !== "undefined" && source instanceof Blob) {
+    return {
+      label: source.name || "(local file)",
+      range: async (a, b) => new Uint8Array(await source.slice(a, b + 1).arrayBuffer()),
+      openTiff: () => GeoTIFF.fromBlob(source),
+    };
+  }
   let bytes;
   if (source instanceof Uint8Array) bytes = source;
   else if (source instanceof ArrayBuffer) bytes = new Uint8Array(source);
   else if (source && typeof source.arrayBuffer === "function") {
-    bytes = new Uint8Array(await source.arrayBuffer()); // Blob / File
+    bytes = new Uint8Array(await source.arrayBuffer()); // exotic Blob-likes
   } else {
     throw new Error("openCog: expected a URL string, ArrayBuffer, Uint8Array, or Blob");
   }
@@ -233,10 +281,11 @@ async function makeReader(source) {
 
 /**
  * Open a COG and return a {@link CogSource} ready to render XYZ tiles. `source`
- * is a URL string (read via HTTP range) or in-memory bytes / a Blob / a File for
- * a local raster. Detects EPSG:3857 (fast path) vs. any other CRS (warp path),
- * reading the source projection + color table from the GeoTIFF header (which
- * whitebox-wasm 0.4.0 does not expose).
+ * is a URL string (read via HTTP range), a Blob / File (read via ranged slices,
+ * so multi-GB local rasters never load whole), or in-memory bytes. Detects
+ * EPSG:3857 (fast path) vs. any other CRS (warp path), reading the source
+ * projection + color table from the GeoTIFF header (which whitebox-wasm 0.4.0
+ * does not expose).
  */
 export async function openCog(source) {
   await init();
@@ -282,7 +331,7 @@ export async function openCog(source) {
   }
 
   // Warp path: read the real source CRS + optional palette from the header.
-  const srcDef = geokeysToProj4.toProj4(img.getGeoKeys()).proj4;
+  const srcDef = sourceCrsDef(img.getGeoKeys());
   if (!srcDef) throw new Error("could not derive source CRS from GeoTIFF geokeys");
   const toSource = proj4("EPSG:3857", srcDef); // forward: mercator -> source
   const toLonLat = proj4(srcDef, "EPSG:4326"); // forward: source -> lon/lat
@@ -304,10 +353,20 @@ export async function openCog(source) {
     toSource,
     palette,
     boundsLonLat: [Math.min(...lons), Math.min(...lats), Math.max(...lons), Math.max(...lats)],
-    crsLabel: "warped from " + (srcDef.match(/\+proj=\w+/) || ["custom CRS"])[0],
+    crsLabel: "warped from " + crsLabelForDef(srcDef),
   });
 }
 
+/** A short label for a proj4 def: the `+proj=...` token, or the WKT's CRS name,
+ * falling back to "custom CRS". */
+function crsLabelForDef(srcDef) {
+  const projTag = srcDef.match(/\+proj=\w+/);
+  if (projTag) return projTag[0];
+  const wktName = srcDef.match(/\b(?:PROJCS|PROJCRS)\s*\[\s*"([^"]+)"/i);
+  if (wktName) return wktName[1];
+  return "custom CRS";
+}
+
 /** A single opened COG. Renders XYZ tiles via {@link CogSource#renderTileRGBA}. */
 export class CogSource {
   constructor(fields) {

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.3",
+  "version": "0.2.5",
   "license": "MIT",
   "repository": {
     "type": "git",