autumnplot-gl 4.0.0 → 4.1.0

package/lib/grids/UnstructuredGrid.js

@@ -0,0 +1,102 @@
+import { kdTree } from "kd-tree-javascript";
+import { Cache, argMin, getArrayConstructor } from "../utils";
+import { autoZoomGridMixin } from "./AutoZoom";
+import { Grid } from "./Grid";
+import { LngLat } from "../Map";
+/**
+ * An unstructured grid defined by a list of latitudes and longitudes
+ *
+ * ## Plot Component Compatibility
+ * - :x:                `Fill`
+ * - :x:                `Raster`
+ * - :x:                `Contour`
+ * - :x:                `Paintball`
+ * - :white_check_mark: `Barbs`
+ * - :white_check_mark: `Hodographs`
+ * - :white_check_mark: `StationPlot`
+ */
+class UnstructuredGrid extends autoZoomGridMixin(Grid) {
+    /**
+     * Create an unstructured grid
+     * @param coords - The lat/lon coordinates of the grid points
+     */
+    constructor(coords, zoom) {
+        const MAX_DIM = 4096;
+        super('unstructured', true, Math.min(coords.length, MAX_DIM), Math.floor(coords.length / MAX_DIM) + 1);
+        this.coords = coords;
+        this.zoom_arg = zoom === undefined ? null : zoom;
+        this.zoom_cache = new Cache((thin_fac) => {
+            const MAP_MAX_ZOOM = 24;
+            const offset = Math.log2(thin_fac);
+            const kd_nodes = this.coords.map(c => ({ ...new LngLat(c.lon, c.lat).toMercatorCoord(), min_zoom: MAP_MAX_ZOOM }));
+            const tree = new kdTree([...kd_nodes], (a, b) => Math.max(Math.abs(a.x - b.x), Math.abs(a.y - b.y)), ['x', 'y']);
+            const recursiveThin = (x, y, depth) => {
+                const size = Math.pow(0.5, depth + 1);
+                const nodes = tree.nearest({ x: x, y: y, min_zoom: 0 }, 2, size);
+                if (nodes.length > 0) {
+                    const [node, dist] = nodes.sort((a, b) => a[1] - b[1])[0];
+                    if (node.min_zoom == MAP_MAX_ZOOM) {
+                        node.min_zoom = Math.max(depth - offset, 0);
+                    }
+                }
+                if (nodes.length > 1 && depth < MAP_MAX_ZOOM + offset) {
+                    recursiveThin(x - size / 2, y - size / 2, depth + 1);
+                    recursiveThin(x + size / 2, y - size / 2, depth + 1);
+                    recursiveThin(x - size / 2, y + size / 2, depth + 1);
+                    recursiveThin(x + size / 2, y + size / 2, depth + 1);
+                }
+            };
+            // Start at -1 zoom depth, which should handle longitudes > 180 degrees.
+            recursiveThin(0.5, 0.5, -1);
+            return new Uint8Array(kd_nodes.map(n => n.min_zoom));
+        });
+    }
+    /** @internal */
+    copy() {
+        return new UnstructuredGrid(this.coords);
+    }
+    /** @internal */
+    getEarthCoords() {
+        return { lons: new Float32Array(this.coords.map(c => c.lon)), lats: new Float32Array(this.coords.map(c => c.lat)) };
+    }
+    /** @internal */
+    getGridCoords() {
+        const { lons, lats } = this.getEarthCoords();
+        return { x: lons, y: lats };
+    }
+    /** @internal */
+    transform(x, y, opts) {
+        return [x, y];
+    }
+    /** @internal */
+    getMinVisibleZoom(thin_fac) {
+        if (this.zoom_arg !== null)
+            return this.zoom_arg;
+        return this.zoom_cache.getValue(thin_fac);
+    }
+    /** @internal */
+    getThinnedGrid(thin_fac, map_max_zoom) {
+        const min_zoom = this.getMinVisibleZoom(thin_fac);
+        return new UnstructuredGrid(this.coords.filter((ll, ill) => min_zoom[ill] <= map_max_zoom), min_zoom.filter(ll => ll <= map_max_zoom));
+    }
+    /** @internal */
+    thinDataArray(original_grid, ary) {
+        let i_new = 0;
+        const arrayType = getArrayConstructor(ary);
+        const new_data = new arrayType(this.ni * this.nj);
+        for (let i = 0; i < original_grid.coords.length; i++) {
+            if (this.coords[i_new].lat == original_grid.coords[i].lat && this.coords[i_new].lon == original_grid.coords[i].lon) {
+                new_data[i_new++] = ary[i];
+                if (i_new >= this.coords.length)
+                    break;
+            }
+        }
+        return new_data;
+    }
+    sampleNearestGridPoint(lon, lat, ary) {
+        // TAS: This is gonna be slow. Need to think about using the kdTree here.
+        const idx = argMin(this.coords.map(c => (c.lon - lon) * (c.lon - lon) + (c.lat - lat) * (c.lat - lat)));
+        return { sample: ary[idx], sample_lon: this.coords[idx].lon, sample_lat: this.coords[idx].lat };
+    }
+}
+export { UnstructuredGrid };

package/lib/index.d.ts

@@ -12,9 +12,17 @@ import { ColorMap, ColorMapOptions } from './Colormap';
 import { Color } from "./Color";
 import { makeColorBar, makePaintballKey, ColorbarOrientation, ColorbarTickDirection, ColorBarOptions, PaintballKeyOptions } from "./ColorBar";
 import { LineStyle } from "./PolylineCollection";
-import { RawScalarField, RawVectorField, RawProfileField, VectorRelativeTo, RawVectorFieldOptions, RawObsField, ObsRawData } from "./RawField";
-import { Grid, GridType, StructuredGrid, PlateCarreeGrid, PlateCarreeRotatedGrid, LambertGrid, UnstructuredGrid } from './Grid';
-import { FieldContourOpts } from './ContourCreator';
+import { RawScalarField, ComputedScalarField, ExpressionScalarField, RawVectorField, ComputedVectorField, ExpressionVectorField, RawProfileField, VectorRelativeTo, RawVectorFieldOptions, RawObsField, ObsRawData } from "./RawField";
+import { Grid, GridType } from "./grids/Grid";
+import { StructuredGrid } from "./grids/StructuredGrid";
+import { PlateCarreeGrid } from "./grids/PlateCarreeGrid";
+import { PlateCarreeRotatedGrid } from "./grids/PlateCarreeRotatedGrid";
+import { LambertGrid } from "./grids/LambertGrid";
+import { RadarSweepGrid } from "./grids/RadarSweepGrid";
+import { GeostationaryImage } from "./grids/Geostationary";
+import { UnstructuredGrid } from "./grids/UnstructuredGrid";
+import { AutoZoomGrid } from "./grids/AutoZoom";
+import { FieldContourOpts } from './ContourCreator.worker';
 /** All built-in colormaps */
 declare const colormaps: {
     bluered: (level_min: number, level_max: number, n_colors: number) => ColorMap;
@@ -25,15 +33,18 @@ declare const colormaps: {
     pw_t2m: ColorMap;
     pw_td2m: ColorMap;
     nws_storm_clear_refl: ColorMap;
+    wv_cimss: ColorMap;
 };
 /** Options for initializing the autumnplot-gl library */
 interface InitAutumnPlotOpts {
     /** Base URL at which to find the WASM module (change with caution!) */
     wasm_base_url?: string;
+    /** Number of worker threads to use for contouring */
+    contour_workers?: number;
 }
 /**
  * Initialize the WebAssembly module in autumnplot-gl. It's not strictly necessary to call it first, but if you call it
  * first, you can prevent races when you contour a bunch of fields at once.
  */
 declare function initAutumnPlot(opts?: InitAutumnPlotOpts): void;
-export { PlotComponent, Barbs, BarbsOptions, Contour, ContourOptions, ContourLabels, ContourLabelOptions, ContourFill, Raster, ContourFillOptions, RasterOptions, Paintball, PaintballOptions, Hodographs, HodographOptions, WindProfile, StormRelativeWindProfile, GroundRelativeWindProfile, StationPlot, StationPlotOptions, SPPosition, SPNumberConfig, SPStringConfig, SPBarbConfig, SPSymbolConfig, SPConfig, SPDataConfig, SPSymbol, PlotLayer, MultiPlotLayer, MapLikeType, LineStyle, ColorMap, ColorMapOptions, colormaps, makeColorBar, makePaintballKey, Color, ColorbarOrientation, ColorbarTickDirection, ColorBarOptions, PaintballKeyOptions, RawScalarField, RawVectorField, RawProfileField, RawObsField, ObsRawData, Grid, GridType, StructuredGrid, VectorRelativeTo, RawVectorFieldOptions, PlateCarreeGrid, PlateCarreeRotatedGrid, LambertGrid, UnstructuredGrid, WebGLAnyRenderingContext, TypedArray, ContourData, initAutumnPlot, InitAutumnPlotOpts, FieldContourOpts };
+export { PlotComponent, Barbs, BarbsOptions, Contour, ContourOptions, ContourLabels, ContourLabelOptions, ContourFill, Raster, ContourFillOptions, RasterOptions, Paintball, PaintballOptions, Hodographs, HodographOptions, WindProfile, StormRelativeWindProfile, GroundRelativeWindProfile, StationPlot, StationPlotOptions, SPPosition, SPNumberConfig, SPStringConfig, SPBarbConfig, SPSymbolConfig, SPConfig, SPDataConfig, SPSymbol, PlotLayer, MultiPlotLayer, MapLikeType, LineStyle, ColorMap, ColorMapOptions, colormaps, makeColorBar, makePaintballKey, Color, ColorbarOrientation, ColorbarTickDirection, ColorBarOptions, PaintballKeyOptions, RawScalarField, ComputedScalarField, ExpressionScalarField, RawVectorField, ComputedVectorField, ExpressionVectorField, RawProfileField, RawObsField, ObsRawData, Grid, GridType, StructuredGrid, VectorRelativeTo, RawVectorFieldOptions, PlateCarreeGrid, PlateCarreeRotatedGrid, LambertGrid, UnstructuredGrid, RadarSweepGrid, GeostationaryImage, AutoZoomGrid, WebGLAnyRenderingContext, TypedArray, ContourData, initAutumnPlot, InitAutumnPlotOpts, FieldContourOpts };

package/lib/index.js

@@ -1,4 +1,4 @@
-import { PlotComponent } from "./PlotComponent";
+import { PlotComponent, getContourWorkerPool } from "./PlotComponent";
 import Contour, { ContourLabels } from "./Contour";
 import { ContourFill, Raster } from "./Fill";
 import Barbs from "./Barbs";
@@ -6,12 +6,18 @@ import Paintball from "./Paintball";
 import Hodographs from './Hodographs';
 import StationPlot from "./StationPlot";
 import { PlotLayer, MultiPlotLayer } from './PlotLayer';
-import { ColorMap, bluered, redblue, pw_speed500mb, pw_speed850mb, pw_cape, pw_t2m, pw_td2m, nws_storm_clear_refl } from './Colormap';
+import { ColorMap, bluered, redblue, pw_speed500mb, pw_speed850mb, pw_cape, pw_t2m, pw_td2m, nws_storm_clear_refl, wv_cimss } from './Colormap';
 import { Color } from "./Color";
 import { makeColorBar, makePaintballKey } from "./ColorBar";
-import { RawScalarField, RawVectorField, RawProfileField, RawObsField } from "./RawField";
-import { Grid, StructuredGrid, PlateCarreeGrid, PlateCarreeRotatedGrid, LambertGrid, UnstructuredGrid } from './Grid';
-import { initMSModule } from './ContourCreator';
+import { RawScalarField, ComputedScalarField, RawVectorField, ComputedVectorField, RawProfileField, RawObsField } from "./RawField";
+import { Grid } from "./grids/Grid";
+import { StructuredGrid } from "./grids/StructuredGrid";
+import { PlateCarreeGrid } from "./grids/PlateCarreeGrid";
+import { PlateCarreeRotatedGrid } from "./grids/PlateCarreeRotatedGrid";
+import { LambertGrid } from "./grids/LambertGrid";
+import { RadarSweepGrid } from "./grids/RadarSweepGrid";
+import { GeostationaryImage } from "./grids/Geostationary";
+import { UnstructuredGrid } from "./grids/UnstructuredGrid";
 /** All built-in colormaps */
 const colormaps = {
     bluered: bluered,
@@ -22,6 +28,7 @@ const colormaps = {
     pw_t2m: pw_t2m,
     pw_td2m: pw_td2m,
     nws_storm_clear_refl: nws_storm_clear_refl,
+    wv_cimss: wv_cimss,
 };
 /**
  * Initialize the WebAssembly module in autumnplot-gl. It's not strictly necessary to call it first, but if you call it
@@ -29,6 +36,7 @@ const colormaps = {
  */
 function initAutumnPlot(opts) {
     opts = opts === undefined ? {} : opts;
-    initMSModule({ document_script: opts.wasm_base_url });
+    const contour_workers = opts.contour_workers === undefined ? 1 : opts.contour_workers;
+    getContourWorkerPool(opts.wasm_base_url, contour_workers);
 }
-export { PlotComponent, Barbs, Contour, ContourLabels, ContourFill, Raster, Paintball, Hodographs, StationPlot, PlotLayer, MultiPlotLayer, ColorMap, colormaps, makeColorBar, makePaintballKey, Color, RawScalarField, RawVectorField, RawProfileField, RawObsField, Grid, StructuredGrid, PlateCarreeGrid, PlateCarreeRotatedGrid, LambertGrid, UnstructuredGrid, initAutumnPlot };
+export { PlotComponent, Barbs, Contour, ContourLabels, ContourFill, Raster, Paintball, Hodographs, StationPlot, PlotLayer, MultiPlotLayer, ColorMap, colormaps, makeColorBar, makePaintballKey, Color, RawScalarField, ComputedScalarField, RawVectorField, ComputedVectorField, RawProfileField, RawObsField, Grid, StructuredGrid, PlateCarreeGrid, PlateCarreeRotatedGrid, LambertGrid, UnstructuredGrid, RadarSweepGrid, GeostationaryImage, initAutumnPlot };

package/lib/utils.d.ts

@@ -1,4 +1,4 @@
-import { TypedArray } from "./AutumnTypes";
+import { TypedArray, TypedArrayStr } from "./AutumnTypes";
 declare function getMinZoom(jlat: number, ilon: number, thin_fac_base: number): number;
 declare function zip(...args: any[]): Generator<any[], void, unknown>;
 declare function getOS(): string | null;
@@ -12,4 +12,13 @@ declare class Cache<A extends unknown[], R> {
 declare function normalizeOptions<Type extends Record<string, any>>(opts: Type | undefined, defaults: Required<Type>): Required<Type>;
 declare function getArrayConstructor<ArrayType extends TypedArray>(ary: ArrayType): new (...args: any[]) => ArrayType;
 declare function mergeShaderCode(snippet: string, main: string): string;
-export { zip, getMinZoom, getOS, Cache, normalizeOptions, getArrayConstructor, mergeShaderCode };
+declare function applySamplerCodeScalar(src: string, sampler_names: string[], sampler_expression: string, dtypes: TypedArrayStr[]): string;
+declare function applySamplerCodeVector(src: string, sampler_names: {
+    u: string[];
+    v: string[];
+}, sampler_expressions: {
+    u: string;
+    v: string;
+}): string;
+declare function argMin<T>(ary: T[] | TypedArray): number;
+export { zip, getMinZoom, getOS, Cache, normalizeOptions, getArrayConstructor, mergeShaderCode, applySamplerCodeScalar, applySamplerCodeVector, argMin };

package/lib/utils.js

@@ -72,4 +72,66 @@ function mergeShaderCode(snippet, main) {
     }
     return snippet + "\n" + main;
 }
-export { zip, getMinZoom, getOS, Cache, normalizeOptions, getArrayConstructor, mergeShaderCode };
+function applySamplerCodeScalar(src, sampler_names, sampler_expression, dtypes) {
+    // TAS: find a better place for this to live.
+    const SAMPLER_DTYPES = {
+        'float16': 'sampler2D', 'float32': 'sampler2D',
+        'uint8': 'lowp usampler2D', 'uint16': 'mediump usampler2D', 'uint32': 'highp usampler2D',
+        'int16': 'mediump isampler2D', 'int32': 'highp isampler2D',
+    };
+    const SHADER_DTYPES = {
+        'float16': 'highp float', 'float32': 'highp float',
+        'uint8': 'uint', 'uint16': 'uint', 'uint32': 'uint',
+        'int16': 'int', 'int32': 'int',
+    };
+    const samplers = sampler_names.map((v, i) => `uniform ${SAMPLER_DTYPES[dtypes[i]]} ${v};`).join("\n");
+    const sampler_get = sampler_names.map((v, i) => `    ${SHADER_DTYPES[dtypes[i]]} ${v}_val = texture(${v}, tex_coord).r;`).join("\n");
+    sampler_names.forEach(v => sampler_expression = sampler_expression.replaceAll(v, `${v}_val`));
+    // TAS: This assumes that the return type of the expression is the same as the type of the inputs. May need to revisit this later.
+    const sampler_code = `
+${samplers}
+
+${SHADER_DTYPES[dtypes[0]]} get_field_value(lowp vec2 tex_coord) {
+${sampler_get}
+    return ${sampler_expression};
+}`;
+    return mergeShaderCode(sampler_code, src);
+}
+function applySamplerCodeVector(src, sampler_names, sampler_expressions) {
+    const samplers = sampler_names.u.map(v => `uniform sampler2D ${v};`).join("\n") + "\n" +
+        sampler_names.v.map(v => `uniform sampler2D ${v};`).join("\n");
+    const sampler_u_get = sampler_names.u.map(v => `    highp float ${v}_val = texture(${v}, tex_coord).r;`).join("\n");
+    const sampler_v_get = sampler_names.v.map(v => `    highp float ${v}_val = texture(${v}, tex_coord).r;`).join("\n");
+    let sampler_expression_u = sampler_expressions.u;
+    sampler_names.u.forEach(v => sampler_expression_u = sampler_expression_u.replaceAll(v, `${v}_val`));
+    let sampler_expression_v = sampler_expressions.v;
+    sampler_names.v.forEach(v => sampler_expression_v = sampler_expression_v.replaceAll(v, `${v}_val`));
+    const sampler_code = `
+${samplers}
+
+highp float get_field_value_u(lowp vec2 tex_coord) {
+${sampler_u_get}
+    return ${sampler_expression_u};
+}
+
+highp float get_field_value_v(lowp vec2 tex_coord) {
+${sampler_v_get}
+    return ${sampler_expression_v};
+}`;
+    return mergeShaderCode(sampler_code, src);
+}
+function argMin(ary) {
+    if (ary.length === 0) {
+        return -1;
+    }
+    let min = ary[0];
+    let minIndex = 0;
+    for (let i = 1; i < ary.length; i++) {
+        if (ary[i] < min) {
+            minIndex = i;
+            min = ary[i];
+        }
+    }
+    return minIndex;
+}
+export { zip, getMinZoom, getOS, Cache, normalizeOptions, getArrayConstructor, mergeShaderCode, applySamplerCodeScalar, applySamplerCodeVector, argMin };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "autumnplot-gl",
-    "version": "4.0.0",
+    "version": "4.1.0",
     "description": "",
     "main": "lib/index.js",
     "types": "lib/index.d.ts",
@@ -34,8 +34,9 @@
     },
     "dependencies": {
         "@petamoriken/float16": "^3.8.4",
-        "autumn-wgl": "^1.5.3",
+        "autumn-wgl": "^1.5.5",
         "comlink": "^4.3.1",
+        "geographiclib-geodesic": "^2.2.0",
         "kd-tree-javascript": "^1.0.3",
         "pbf": "^3.2.1",
         "potpack": "^2.0.0"

package/lib/Grid.d.ts

@@ -1,270 +0,0 @@
-import { WGLBuffer, WGLTexture } from "autumn-wgl";
-import { TypedArray, WebGLAnyRenderingContext } from "./AutumnTypes";
-interface EarthCoords {
-    lons: Float32Array;
-    lats: Float32Array;
-}
-interface GridCoords {
-    x: Float32Array;
-    y: Float32Array;
-}
-type GridType = 'latlon' | 'latlonrot' | 'lcc' | 'unstructured';
-/** The base class for grid types */
-declare abstract class Grid {
-    readonly type: GridType;
-    readonly ni: number;
-    readonly nj: number;
-    readonly is_conformal: boolean;
-    private readonly billboard_buffer_cache;
-    private readonly vector_rotation_cache;
-    constructor(type: GridType, is_conformal: boolean, ni: number, nj: number);
-    abstract getEarthCoords(): EarthCoords;
-    abstract getGridCoords(): GridCoords;
-    abstract transform(x: number, y: number, opts?: {
-        inverse?: boolean;
-    }): [number, number];
-    abstract sampleNearestGridPoint(lon: number, lat: number, ary: TypedArray): {
-        sample: number;
-        sample_lon: number;
-        sample_lat: number;
-    };
-    abstract getThinnedGrid(thin_fac: number, map_max_zoom: number): Grid;
-    abstract thinDataArray<ArrayType extends TypedArray>(original_grid: Grid, ary: ArrayType): ArrayType;
-    abstract getMinVisibleZoom(thin_fac: number): Uint8Array;
-    getWGLBillboardBuffers(gl: WebGLAnyRenderingContext, thin_fac: number, max_zoom: number): Promise<{
-        vertices: WGLBuffer;
-        texcoords: WGLBuffer;
-    }>;
-    abstract copy(): Grid;
-    getVectorRotationAtPoint(lon: number, lat: number): number;
-    getVectorRotationTexture(gl: WebGLAnyRenderingContext, data_are_earth_relative: boolean): {
-        rotation: WGLTexture;
-    };
-}
-/** A structured grid (in this case meaning a cartesian grid with i and j coordinates) */
-declare abstract class StructuredGrid extends Grid {
-    private readonly buffer_cache;
-    protected readonly thin_x: number;
-    protected readonly thin_y: number;
-    constructor(type: GridType, is_conformal: boolean, ni: number, nj: number, thin_x?: number, thin_y?: number);
-    abstract getEarthCoords(ni?: number, nj?: number): EarthCoords;
-    /** @internal */
-    protected xyThinFromMaxZoom(thin_fac: number, map_max_zoom: number): [number, number];
-    /** @internal */
-    getMinVisibleZoom(thin_fac: number): Uint8Array;
-    /** @internal */
-    thinDataArray<ArrayType extends TypedArray>(original_grid: StructuredGrid, ary: ArrayType): ArrayType;
-    abstract copy(opts?: {
-        ni?: number;
-        nj?: number;
-    }): Grid;
-    getWGLBuffers(gl: WebGLAnyRenderingContext): Promise<{
-        vertices: WGLBuffer;
-        texcoords: WGLBuffer;
-    }>;
-    sampleNearestGridPoint(lon: number, lat: number, ary: TypedArray): {
-        sample: number;
-        sample_lon: number;
-        sample_lat: number;
-    };
-}
-/** A plate carree (a.k.a. lat/lon) grid with uniform grid spacing */
-declare class PlateCarreeGrid extends StructuredGrid {
-    readonly ll_lon: number;
-    readonly ll_lat: number;
-    readonly ur_lon: number;
-    readonly ur_lat: number;
-    private readonly ll_cache;
-    private readonly gc_cache;
-    /**
-     * Create a plate carree grid
-     * @param ni     - The number of grid points in the i (longitude) direction
-     * @param nj     - The number of grid points in the j (latitude) direction
-     * @param ll_lon - The longitude of the lower left corner of the grid
-     * @param ll_lat - The latitude of the lower left corner of the grid
-     * @param ur_lon - The longitude of the upper right corner of the grid
-     * @param ur_lat - The latitude of the upper right corner of the grid
-     */
-    constructor(ni: number, nj: number, ll_lon: number, ll_lat: number, ur_lon: number, ur_lat: number, thin_x?: number, thin_y?: number);
-    /** @internal */
-    copy(opts?: {
-        ni?: number;
-        nj?: number;
-        ll_lon?: number;
-        ll_lat?: number;
-        ur_lon?: number;
-        ur_lat?: number;
-    }): PlateCarreeGrid;
-    /**
-     * @internal
-     * Get a list of longitudes and latitudes on the grid (internal method)
-     */
-    getEarthCoords(ni?: number, nj?: number): EarthCoords;
-    /** @internal */
-    getGridCoords(): GridCoords;
-    /** @internal */
-    transform(x: number, y: number, opts?: {
-        inverse?: boolean;
-    }): [number, number];
-    /** @internal */
-    getThinnedGrid(thin_fac: number, map_max_zoom: number): PlateCarreeGrid;
-}
-/** A rotated lat-lon (plate carree) grid with uniform grid spacing */
-declare class PlateCarreeRotatedGrid extends StructuredGrid {
-    readonly np_lon: number;
-    readonly np_lat: number;
-    readonly lon_shift: number;
-    readonly ll_lon: number;
-    readonly ll_lat: number;
-    readonly ur_lon: number;
-    readonly ur_lat: number;
-    private readonly llrot;
-    private readonly ll_cache;
-    private readonly gc_cache;
-    /**
-     * Create a Lambert conformal conic grid
-     * @param ni        - The number of grid points in the i (longitude) direction
-     * @param nj        - The number of grid points in the j (latitude) direction
-     * @param np_lon    - The longitude of the north pole for the rotated grid
-     * @param np_lat    - The latitude of the north pole for the rotated grid
-     * @param lon_shift - The angle around the rotated north pole to shift the central meridian
-     * @param ll_lon    - The longitude of the lower left corner of the grid (on the rotated earth)
-     * @param ll_lat    - The latitude of the lower left corner of the grid (on the rotated earth)
-     * @param ur_lon    - The longitude of the upper right corner of the grid (on the rotated earth)
-     * @param ur_lat    - The latitude of the upper right corner of the grid (on the rotated earth)
-     */
-    constructor(ni: number, nj: number, np_lon: number, np_lat: number, lon_shift: number, ll_lon: number, ll_lat: number, ur_lon: number, ur_lat: number, thin_x?: number, thin_y?: number);
-    /** @internal */
-    copy(opts?: {
-        ni?: number;
-        nj?: number;
-        ll_lon?: number;
-        ll_lat?: number;
-        ur_lon?: number;
-        ur_lat?: number;
-    }): PlateCarreeRotatedGrid;
-    /**
-     * @internal
-     * Get a list of longitudes and latitudes on the grid
-     */
-    getEarthCoords(ni?: number, nj?: number): EarthCoords;
-    /** @internal */
-    getGridCoords(): GridCoords;
-    /** @internal */
-    transform(x: number, y: number, opts?: {
-        inverse?: boolean;
-    }): [number, number];
-    /** @internal */
-    getThinnedGrid(thin_fac: number, map_max_zoom: number): PlateCarreeRotatedGrid;
-}
-/** A Lambert conformal conic grid with uniform grid spacing */
-declare class LambertGrid extends StructuredGrid {
-    readonly lon_0: number;
-    readonly lat_0: number;
-    readonly lat_std: [number, number];
-    readonly ll_x: number;
-    readonly ll_y: number;
-    readonly ur_x: number;
-    readonly ur_y: number;
-    readonly a: number;
-    readonly b: number;
-    private readonly lcc;
-    private readonly ll_cache;
-    private readonly gc_cache;
-    /**
-     * Create a Lambert conformal conic grid from the lower-left and upper-right corner x/y values.
-     * @param ni      - The number of grid points in the i (longitude) direction
-     * @param nj      - The number of grid points in the j (latitude) direction
-     * @param lon_0   - The standard longitude for the projection; this is also the center longitude for the projection
-     * @param lat_0   - The center latitude for the projection
-     * @param lat_std - The standard latitudes for the projection
-     * @param ll_x    - The x coordinate in projection space of the lower-left corner of the grid
-     * @param ll_y    - The y coordinate in projection space of the lower-left corner of the grid
-     * @param ur_x    - The x coordinate in projection space of the upper-right corner of the grid
-     * @param ur_y    - The y coordinate in projection space of the upper-right corner of the grid
-     * @param a       - The semimajor axis of the assumed shape of Earth in meters
-     * @param b       - The semiminor axis of the assumed shape of Earth in meters
-     */
-    constructor(ni: number, nj: number, lon_0: number, lat_0: number, lat_std: [number, number], ll_x: number, ll_y: number, ur_x: number, ur_y: number, a?: number, b?: number, thin_x?: number, thin_y?: number);
-    /**
-     * Create a Lambert conformal conic grid from the lower-left grid point coordinate and a dx and dy.
-     * @param ni      - The number of grid points in the i (longitude) direction
-     * @param nj      - The number of grid points in the j (latitude) direction
-     * @param lon_0   - The standard longitude for the projection; this is also the center longitude for the projection
-     * @param lat_0   - The center latitude for the projection
-     * @param lat_std - The standard latitudes for the projection
-     * @param ll_lon  - The longitude of the lower-left corner of the grid
-     * @param ll_lat  - The latitude of the lower-left corner of the grid
-     * @param dx      - The grid dx in meters
-     * @param dy      - The grid dy in meters
-     * @param a       - The semimajor axis of the assumed shape of Earth in meters
-     * @param b       - The semiminor axis of the assumed shape of Earth in meters
-     * @returns
-     */
-    static fromLLCornerLonLat(ni: number, nj: number, lon_0: number, lat_0: number, lat_std: [number, number], ll_lon: number, ll_lat: number, dx: number, dy: number, a?: number, b?: number): LambertGrid;
-    /** @internal */
-    copy(opts?: {
-        ni?: number;
-        nj?: number;
-        ll_x?: number;
-        ll_y?: number;
-        ur_x?: number;
-        ur_y?: number;
-    }): LambertGrid;
-    /**
-     * @internal
-     * Get a list of longitudes and latitudes on the grid
-     */
-    getEarthCoords(ni?: number, nj?: number): EarthCoords;
-    /** @internal */
-    getGridCoords(): GridCoords;
-    /** @internal */
-    transform(x: number, y: number, opts?: {
-        inverse?: boolean;
-    }): [number, number];
-    /** @internal */
-    getThinnedGrid(thin_fac: number, map_max_zoom: number): LambertGrid;
-}
-/** An unstructured grid defined by a list of latitudes and longitudes */
-declare class UnstructuredGrid extends Grid {
-    readonly coords: {
-        lon: number;
-        lat: number;
-    }[];
-    private readonly zoom_cache;
-    private readonly zoom_arg;
-    /**
-     * Create an unstructured grid
-     * @param coords - The lat/lon coordinates of the grid points
-     */
-    constructor(coords: {
-        lon: number;
-        lat: number;
-    }[], zoom?: Uint8Array);
-    /** @internal */
-    copy(): UnstructuredGrid;
-    /** @internal */
-    getEarthCoords(): {
-        lons: Float32Array;
-        lats: Float32Array;
-    };
-    /** @internal */
-    getGridCoords(): GridCoords;
-    /** @internal */
-    transform(x: number, y: number, opts?: {
-        inverse?: boolean;
-    }): [number, number];
-    /** @internal */
-    getMinVisibleZoom(thin_fac: number): Uint8Array;
-    /** @internal */
-    getThinnedGrid(thin_fac: number, map_max_zoom: number): UnstructuredGrid;
-    /** @internal */
-    thinDataArray<ArrayType extends TypedArray>(original_grid: UnstructuredGrid, ary: ArrayType): ArrayType;
-    sampleNearestGridPoint(lon: number, lat: number, ary: TypedArray): {
-        sample: number;
-        sample_lon: number;
-        sample_lat: number;
-    };
-}
-export { Grid, StructuredGrid, PlateCarreeGrid, PlateCarreeRotatedGrid, LambertGrid, UnstructuredGrid };
-export type { GridType };