geolibre-wasm 0.5.2 → 0.6.0

package/README.md

@@ -65,10 +65,87 @@ const { exitCode, stdout, files } = await runTool("slope", {
 const slopeCog = files["slope.tif"]; // Uint8Array (Cloud Optimized GeoTIFF)
 ```
 
+COG subsets can be extracted from a local file or an HTTP source. HTTP sources
+use byte-range requests and do not download the full object:
+
+```js
+const { files } = await runTool("extract_cog_subset", {
+  args: [
+    "--url=https://example.com/scene.cog.tif",
+    "--bbox=-122.55,37.70,-122.35,37.84",
+    "--bbox_crs=4326",
+    "--output_crs=3857",
+    "--resolution=10",
+    "--nodata=-9999",
+    "--output=/work/subset.tif",
+  ],
+});
+const subsetCog = files["subset.tif"];
+```
+
+WMS subsets can be requested from a GetMap endpoint that supports GeoTIFF
+responses:
+
+```js
+const { files } = await runTool("extract_wms_subset", {
+  args: [
+    "--url=https://example.com/geoserver/wms",
+    "--layers=workspace:layer",
+    "--bbox=-122.55,37.70,-122.35,37.84",
+    "--bbox_crs=4326",
+    "--resolution=0.0001",
+    "--format=image/geotiff",
+    "--output=/work/wms_subset.tif",
+  ],
+});
+```
+
+XYZ tile subsets can be mosaicked from raster tiles and written as an RGB COG:
+
+```js
+const { files } = await runTool("extract_xyz_tile_subset", {
+  args: [
+    "--url=https://tile.openstreetmap.org/{z}/{x}/{y}.png",
+    "--zoom=10",
+    "--bbox=-122.55,37.70,-122.35,37.84",
+    "--bbox_crs=4326",
+    "--width=512",
+    "--height=512",
+    "--output=/work/xyz_subset.tif",
+  ],
+});
+```
+
+For a local COG, upload/provide bytes through `input` and point `--input` at
+the `/work` path:
+
+```js
+const { files } = await runTool("extract_cog_subset", {
+  args: [
+    "--input=/work/local.cog.tif",
+    "--bbox=-122.55,37.70,-122.35,37.84",
+    "--bbox_crs=4326",
+    "--output=/work/subset.tif",
+  ],
+  input: { "local.cog.tif": localCogBytes },
+});
+```
+
 Inputs are placed under `/work` (keyed by filename); any file a tool writes is
 returned in `files`. Raster outputs are Cloud Optimized GeoTIFFs; vector outputs
 are GeoJSON.
 
+When `output_crs` is set, `resolution` is interpreted in output CRS units and
+the subset is reprojected with nearest-neighbor resampling. Without
+`output_crs`, the output usually stays on the source COG grid. Sources with
+user-defined projection strings that cannot be written as EPSG metadata, such as
+the NLCD sample, default to `bbox_crs` output so GIS viewers can place the
+result. Outputs are Deflate-compressed by default. `nodata` overrides the output
+nodata metadata and is used to fill pixels introduced during reprojection.
+The subset writer preserves the source sample type for supported COG types
+(`uint8`, `float32`, and `float64`); palette-indexed `uint8` rasters retain
+their source ColorMap.
+
 ## API
 
 | Export | Description |
@@ -77,6 +154,9 @@ are GeoJSON.
 | `listTools(): Promise<string[]>` | Every available tool id. |
 | `listManifests(): Promise<ToolManifest[]>` | All tool manifests (parameter schemas), for building UIs offline. |
 | `runTool(tool, { args?, input? }): Promise<ToolResult>` | Run one tool over the in-memory filesystem. |
+| `extractCogSubset(source, opts): Promise<Uint8Array>` | Extract a local or HTTP COG subset directly. |
+| `extractWmsSubset(url, opts): Promise<Uint8Array>` | Request a WMS GeoTIFF subset and encode it as a COG. |
+| `extractXyzTileSubset(url, opts): Promise<Uint8Array>` | Mosaic XYZ raster tiles and encode them as an RGB COG. |
 
 `ToolResult` is `{ exitCode: number, stdout: string[], files: Record<string, Uint8Array> }`.
 

package/geolibre_wasm.d.ts

@@ -79,6 +79,14 @@ export class CogBuilder {
 export class CogStream {
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * Reproject a bbox from `bbox_epsg` into this COG's dataset CRS.
+     *
+     * The COG projection string is preferred over its EPSG tag when available,
+     * because some user-defined projected GeoTIFFs expose only their geographic
+     * base EPSG code.
+     */
+    bbox_to_dataset_crs(bbox_epsg: number, bbox: Float64Array): Float64Array;
     /**
      * Bounding box `[min_x, min_y, max_x, max_y]` in the dataset CRS, or empty.
      */
@@ -115,6 +123,14 @@ export class CogStream {
      * Parse a COG's tile layout from front-of-file header bytes.
      */
     constructor(header_bytes: Uint8Array);
+    /**
+     * Reproject x,y coordinate pairs from this COG's dataset CRS to an EPSG CRS.
+     */
+    points_from_dataset_crs(dst_epsg: number, xy: Float64Array): Float64Array;
+    /**
+     * Reproject x,y coordinate pairs from an EPSG CRS into this COG's dataset CRS.
+     */
+    points_to_dataset_crs(src_epsg: number, xy: Float64Array): Float64Array;
     /**
      * `[offset, length]` byte range of the tile at `(col, row)` on `level`.
      */
@@ -128,6 +144,10 @@ export class CogStream {
      * EPSG code of the full-resolution level, if any.
      */
     readonly epsg: number | undefined;
+    /**
+     * True when the COG CRS is represented by a user-defined projection string.
+     */
+    readonly has_projection_string: boolean;
     /**
      * No-data sentinel, if declared.
      */
@@ -319,6 +339,20 @@ export function lidar_read_xyz(data: Uint8Array, format: string): Float64Array;
  */
 export function morans_i(points_xy: Float64Array, values: Float64Array, distance_threshold: number): string;
 
+/**
+ * Reproject a bbox between two EPSG CRSs.
+ *
+ * Input and output order is `[min_x, min_y, max_x, max_y]`. The bbox edges are
+ * densified so projected extrema that fall along an edge are preserved better
+ * than a corner-only transform.
+ */
+export function transform_bbox_epsg(src_epsg: number, dst_epsg: number, bbox: Float64Array): Float64Array;
+
+/**
+ * Reproject x,y coordinate pairs between two EPSG CRSs.
+ */
+export function transform_points_epsg(src_epsg: number, dst_epsg: number, xy: Float64Array): Float64Array;
+
 /**
  * Vector formats this build can read from memory (comma-separated).
  */
@@ -370,6 +404,7 @@ export interface InitOutput {
     readonly cogbuilder_write_f32: (a: number, b: number, c: number, d: number) => void;
     readonly cogbuilder_write_f64: (a: number, b: number, c: number, d: number) => void;
     readonly cogbuilder_write_u8: (a: number, b: number, c: number, d: number) => void;
+    readonly cogstream_bbox_to_dataset_crs: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly cogstream_bounding_box: (a: number, b: number) => void;
     readonly cogstream_bounds_lonlat: (a: number, b: number) => void;
     readonly cogstream_center: (a: number, b: number) => void;
@@ -377,10 +412,13 @@ export interface InitOutput {
     readonly cogstream_decode_tile_f64: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly cogstream_epsg: (a: number) => number;
     readonly cogstream_geo_transform: (a: number, b: number) => void;
+    readonly cogstream_has_projection_string: (a: number) => number;
     readonly cogstream_levels_json: (a: number, b: number) => void;
     readonly cogstream_new: (a: number, b: number, c: number) => void;
     readonly cogstream_nodata: (a: number, b: number) => void;
     readonly cogstream_num_levels: (a: number) => number;
+    readonly cogstream_points_from_dataset_crs: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly cogstream_points_to_dataset_crs: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly cogstream_tile_range: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly cogstream_tiles_for_window: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly convex_hull: (a: number, b: number, c: number) => void;
@@ -421,6 +459,8 @@ export interface InitOutput {
     readonly lidar_read_intensity: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly lidar_read_xyz: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly morans_i: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly transform_bbox_epsg: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly transform_points_epsg: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly vector_formats: (a: number) => void;
     readonly vector_info: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly vector_to_geojson: (a: number, b: number, c: number, d: number, e: number) => void;

package/geolibre_wasm.js

@@ -218,6 +218,36 @@ export class CogStream {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_cogstream_free(ptr, 0);
     }
+    /**
+     * Reproject a bbox from `bbox_epsg` into this COG's dataset CRS.
+     *
+     * The COG projection string is preferred over its EPSG tag when available,
+     * because some user-defined projected GeoTIFFs expose only their geographic
+     * base EPSG code.
+     * @param {number} bbox_epsg
+     * @param {Float64Array} bbox
+     * @returns {Float64Array}
+     */
+    bbox_to_dataset_crs(bbox_epsg, bbox) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(bbox, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.cogstream_bbox_to_dataset_crs(retptr, this.__wbg_ptr, bbox_epsg, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v2 = getArrayF64FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export(r0, r1 * 8, 8);
+            return v2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Bounding box `[min_x, min_y, max_x, max_y]` in the dataset CRS, or empty.
      * @returns {Float64Array}
@@ -340,6 +370,14 @@ export class CogStream {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * True when the COG CRS is represented by a user-defined projection string.
+     * @returns {boolean}
+     */
+    get has_projection_string() {
+        const ret = wasm.cogstream_has_projection_string(this.__wbg_ptr);
+        return ret !== 0;
+    }
     /**
      * JSON array describing every level: `[{level,width,height,tile_width,
      * tile_height,tiles_x,tiles_y,bands,bits_per_sample,sample_format,compression}]`.
@@ -407,6 +445,58 @@ export class CogStream {
         const ret = wasm.cogstream_num_levels(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Reproject x,y coordinate pairs from this COG's dataset CRS to an EPSG CRS.
+     * @param {number} dst_epsg
+     * @param {Float64Array} xy
+     * @returns {Float64Array}
+     */
+    points_from_dataset_crs(dst_epsg, xy) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(xy, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.cogstream_points_from_dataset_crs(retptr, this.__wbg_ptr, dst_epsg, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v2 = getArrayF64FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export(r0, r1 * 8, 8);
+            return v2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Reproject x,y coordinate pairs from an EPSG CRS into this COG's dataset CRS.
+     * @param {number} src_epsg
+     * @param {Float64Array} xy
+     * @returns {Float64Array}
+     */
+    points_to_dataset_crs(src_epsg, xy) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(xy, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.cogstream_points_to_dataset_crs(retptr, this.__wbg_ptr, src_epsg, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v2 = getArrayF64FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export(r0, r1 * 8, 8);
+            return v2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * `[offset, length]` byte range of the tile at `(col, row)` on `level`.
      * @param {number} level
@@ -1290,6 +1380,66 @@ export function morans_i(points_xy, values, distance_threshold) {
     }
 }
 
+/**
+ * Reproject a bbox between two EPSG CRSs.
+ *
+ * Input and output order is `[min_x, min_y, max_x, max_y]`. The bbox edges are
+ * densified so projected extrema that fall along an edge are preserved better
+ * than a corner-only transform.
+ * @param {number} src_epsg
+ * @param {number} dst_epsg
+ * @param {Float64Array} bbox
+ * @returns {Float64Array}
+ */
+export function transform_bbox_epsg(src_epsg, dst_epsg, bbox) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArrayF64ToWasm0(bbox, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.transform_bbox_epsg(retptr, src_epsg, dst_epsg, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v2 = getArrayF64FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export(r0, r1 * 8, 8);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Reproject x,y coordinate pairs between two EPSG CRSs.
+ * @param {number} src_epsg
+ * @param {number} dst_epsg
+ * @param {Float64Array} xy
+ * @returns {Float64Array}
+ */
+export function transform_points_epsg(src_epsg, dst_epsg, xy) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArrayF64ToWasm0(xy, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.transform_points_epsg(retptr, src_epsg, dst_epsg, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v2 = getArrayF64FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export(r0, r1 * 8, 8);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
 /**
  * Vector formats this build can read from memory (comma-separated).
  * @returns {string}

package/geolibre_wasm_bg.wasm.d.ts

@@ -17,6 +17,7 @@ export const cogbuilder_set_tile_size: (a: number, b: number) => void;
 export const cogbuilder_write_f32: (a: number, b: number, c: number, d: number) => void;
 export const cogbuilder_write_f64: (a: number, b: number, c: number, d: number) => void;
 export const cogbuilder_write_u8: (a: number, b: number, c: number, d: number) => void;
+export const cogstream_bbox_to_dataset_crs: (a: number, b: number, c: number, d: number, e: number) => void;
 export const cogstream_bounding_box: (a: number, b: number) => void;
 export const cogstream_bounds_lonlat: (a: number, b: number) => void;
 export const cogstream_center: (a: number, b: number) => void;
@@ -24,10 +25,13 @@ export const cogstream_center_lonlat: (a: number, b: number) => void;
 export const cogstream_decode_tile_f64: (a: number, b: number, c: number, d: number, e: number) => void;
 export const cogstream_epsg: (a: number) => number;
 export const cogstream_geo_transform: (a: number, b: number) => void;
+export const cogstream_has_projection_string: (a: number) => number;
 export const cogstream_levels_json: (a: number, b: number) => void;
 export const cogstream_new: (a: number, b: number, c: number) => void;
 export const cogstream_nodata: (a: number, b: number) => void;
 export const cogstream_num_levels: (a: number) => number;
+export const cogstream_points_from_dataset_crs: (a: number, b: number, c: number, d: number, e: number) => void;
+export const cogstream_points_to_dataset_crs: (a: number, b: number, c: number, d: number, e: number) => void;
 export const cogstream_tile_range: (a: number, b: number, c: number, d: number, e: number) => void;
 export const cogstream_tiles_for_window: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
 export const convex_hull: (a: number, b: number, c: number) => void;
@@ -68,6 +72,8 @@ export const lidar_read_classification: (a: number, b: number, c: number, d: num
 export const lidar_read_intensity: (a: number, b: number, c: number, d: number, e: number) => void;
 export const lidar_read_xyz: (a: number, b: number, c: number, d: number, e: number) => void;
 export const morans_i: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const transform_bbox_epsg: (a: number, b: number, c: number, d: number, e: number) => void;
+export const transform_points_epsg: (a: number, b: number, c: number, d: number, e: number) => void;
 export const vector_formats: (a: number) => void;
 export const vector_info: (a: number, b: number, c: number, d: number, e: number) => void;
 export const vector_to_geojson: (a: number, b: number, c: number, d: number, e: number) => void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "geolibre-wasm",
   "type": "module",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "Pure-Rust geospatial toolkit (whitebox_next_gen) compiled to WebAssembly (WASI) for GeoLibre's in-browser tool execution",
   "license": "MIT",
   "repository": {

package/tools.d.ts

@@ -19,6 +19,79 @@ export interface RunToolOptions {
   input?: Record<string, Uint8Array | ArrayBuffer | string>;
 }
 
+export interface ExtractCogSubsetOptions {
+  /** Bounding box as [minX, minY, maxX, maxY]. */
+  bbox: [number, number, number, number];
+  /** EPSG code of bbox coordinates. */
+  bboxCrs: number;
+  /** COG overview level to read. Level 0 is full resolution. */
+  level?: number;
+  /** Target output pixel size in outputCrs units when outputCrs is set; otherwise bboxCrs units. */
+  resolution?: number;
+  /** Optional output EPSG code. User-defined source CRSs default to bboxCrs output when omitted. */
+  outputCrs?: number;
+  /** Optional output nodata value. Used as reprojection fill and output nodata metadata. */
+  nodata?: number;
+  /** Extra fetch options used for header and tile range requests. */
+  fetchOptions?: RequestInit;
+  /** Initial COG header prefix size in bytes. Default 262144. */
+  initialHeaderBytes?: number;
+  /** Maximum COG header prefix size in bytes. Default 8388608. */
+  maxHeaderBytes?: number;
+}
+
+export interface ExtractWmsSubsetOptions {
+  /** WMS layer name(s), comma-separated. */
+  layers: string;
+  /** WMS style name(s), comma-separated. */
+  styles?: string;
+  /** Bounding box as [minX, minY, maxX, maxY]. */
+  bbox: [number, number, number, number];
+  /** EPSG code of bbox coordinates. */
+  bboxCrs: number;
+  /** Target output pixel size in output CRS units. */
+  resolution?: number;
+  /** Request width in pixels; used when resolution is omitted. */
+  width?: number;
+  /** Request height in pixels; used when resolution is omitted. */
+  height?: number;
+  /** Optional output/request EPSG code. Defaults to bboxCrs. */
+  outputCrs?: number;
+  /** WMS image format. Defaults to image/geotiff. */
+  format?: string;
+  /** WMS version. Defaults to 1.1.1. */
+  version?: string;
+  /** Optional output nodata value. */
+  nodata?: number;
+  /** Extra fetch options used for the GetMap request. */
+  fetchOptions?: RequestInit;
+}
+
+export interface ExtractXyzTileSubsetOptions {
+  /** XYZ zoom level. */
+  zoom: number;
+  /** Bounding box as [minX, minY, maxX, maxY]. */
+  bbox: [number, number, number, number];
+  /** EPSG code of bbox coordinates. */
+  bboxCrs: number;
+  /** Target output pixel size in output CRS units. */
+  resolution?: number;
+  /** Output width in pixels; used when resolution is omitted. */
+  width?: number;
+  /** Output height in pixels; used when resolution is omitted. */
+  height?: number;
+  /** Optional output EPSG code. Defaults to bboxCrs. */
+  outputCrs?: number;
+  /** Tile size in pixels. Defaults to 256. */
+  tileSize?: number;
+  /** Optional subdomain letters for {s}. */
+  subdomains?: string;
+  /** Optional output nodata/fill value. */
+  nodata?: number;
+  /** Extra fetch options used for tile requests. */
+  fetchOptions?: RequestInit;
+}
+
 /** A single parameter in a tool manifest. */
 export interface ToolParam {
   name: string;
@@ -46,3 +119,21 @@ export function listManifests(): Promise<ToolManifest[]>;
 
 /** Run one tool over an in-memory filesystem. */
 export function runTool(tool: string, opts?: RunToolOptions): Promise<ToolResult>;
+
+/** Extract a bbox subset from a local COG or HTTP COG. HTTP sources use byte-range requests. */
+export function extractCogSubset(
+  source: string | Uint8Array | ArrayBuffer,
+  opts: ExtractCogSubsetOptions,
+): Promise<Uint8Array>;
+
+/** Request a bbox subset from a WMS GetMap endpoint and write it as a Deflate COG. */
+export function extractWmsSubset(
+  url: string,
+  opts: ExtractWmsSubsetOptions,
+): Promise<Uint8Array>;
+
+/** Fetch XYZ raster tiles for a bbox, mosaic them, and write a Deflate RGB COG. */
+export function extractXyzTileSubset(
+  url: string,
+  opts: ExtractXyzTileSubsetOptions,
+): Promise<Uint8Array>;