autumnplot-gl 3.2.0 → 4.0.0

package/lib/RawField.js

@@ -1,8 +1,16 @@
 import { Float16Array } from "@petamoriken/float16";
+import { isStormRelativeWindProfile } from "./AutumnTypes";
 import { contourCreator } from "./ContourCreator";
-import { Cache, zip } from "./utils";
-function getArrayConstructor(ary) {
-    return ary.constructor;
+import { Cache, getArrayConstructor, zip } from "./utils";
+import { getGLFormatTypeAlignment } from "./PlotComponent";
+function getArrayDType(ary) {
+    if (ary instanceof Float32Array) {
+        return 'float32';
+    }
+    else if (ary instanceof Uint8Array) {
+        return 'uint8';
+    }
+    return 'float16';
 }
 /** A class representing a raw 2D field of gridded data, such as height or u wind. */
 class RawScalarField {
@@ -25,15 +33,23 @@ class RawScalarField {
     getTextureData() {
         // Need to give float16 data as uint16s to make WebGL happy: https://github.com/petamoriken/float16/issues/105
         const raw_data = this.data;
-        let data;
-        if (raw_data instanceof Float32Array) {
-            data = raw_data;
-        }
-        else {
-            data = new Uint16Array(raw_data.buffer);
-        }
+        const raw_data_type = getArrayDType(raw_data);
+        const data = (raw_data_type == 'float32' || raw_data_type == 'uint8') ? raw_data : new Uint16Array(raw_data.buffer);
         return data;
     }
+    getWGLTextureSpec(gl, image_mag_filter) {
+        const tex_data = this.getTextureData();
+        const { format, type, row_alignment } = getGLFormatTypeAlignment(gl, getArrayDType(this.data));
+        return { 'format': format, 'type': type,
+            'width': this.grid.ni, 'height': this.grid.nj, 'image': tex_data,
+            'mag_filter': image_mag_filter, 'row_alignment': row_alignment,
+        };
+    }
+    /**
+     * Get contour data as an object with each contour level being a separate property.
+     * @param opts - Options for doing the contouring
+     * @returns contour data as an object
+     */
     async getContours(opts) {
         return await this.contour_cache.getValue(opts);
     }
@@ -57,6 +73,9 @@ class RawScalarField {
         const agg_data = new arrayType(mapGenerator(zipped_args, (a) => func(...a)));
         return new RawScalarField(args[0].grid, agg_data);
     }
+    sampleField(lon, lat) {
+        return this.grid.sampleNearestGridPoint(lon, lat, this.data).sample;
+    }
 }
 /** A class representing a 2D gridded field of vectors */
 class RawVectorField {
@@ -73,35 +92,53 @@ class RawVectorField {
         this.v = new RawScalarField(grid, v);
         this.relative_to = opts.relative_to === undefined ? 'grid' : opts.relative_to;
     }
+    /** @internal */
     getTextureData() {
         // Need to give float16 data as uint16s to make WebGL happy: https://github.com/petamoriken/float16/issues/105
         const raw_u = this.u.data;
         const raw_v = this.v.data;
-        const u = raw_u instanceof Float32Array ? raw_u : new Uint16Array(raw_u.buffer);
-        const v = raw_v instanceof Float32Array ? raw_v : new Uint16Array(raw_v.buffer);
+        const u_raw_data_type = getArrayDType(raw_u);
+        const v_raw_data_type = getArrayDType(raw_u);
+        const u = (u_raw_data_type == 'float32' || u_raw_data_type == 'uint8') ? raw_u : new Uint16Array(raw_u.buffer);
+        const v = (v_raw_data_type == 'float32' || v_raw_data_type == 'uint8') ? raw_v : new Uint16Array(raw_v.buffer);
         return { u: u, v: v };
     }
-    getThinnedField(thin_x, thin_y) {
-        const new_grid = this.grid.getThinnedGrid(thin_x, thin_y);
-        const thinGrid = (data) => {
-            const arrayType = getArrayConstructor(data);
-            const new_data = new arrayType(new_grid.ni * new_grid.nj);
-            for (let i = 0; i < new_grid.ni; i++) {
-                for (let j = 0; j < new_grid.nj; j++) {
-                    const idx_old = i * thin_x + this.grid.ni * j * thin_y;
-                    const idx = i + new_grid.ni * j;
-                    new_data[idx] = data[idx_old];
-                }
-            }
-            return new_data;
+    getWGLTextureSpecs(gl, mag_filter) {
+        const { u: u_thin, v: v_thin } = this.getTextureData();
+        const { format, type, row_alignment } = getGLFormatTypeAlignment(gl, getArrayDType(this.u.data));
+        const u_image = { 'format': format, 'type': type,
+            'width': this.grid.ni, 'height': this.grid.nj, 'image': u_thin,
+            'mag_filter': mag_filter, 'row_alignment': row_alignment,
         };
-        const thin_u = thinGrid(this.u.data);
-        const thin_v = thinGrid(this.v.data);
+        const v_image = { 'format': format, 'type': type,
+            'width': this.grid.ni, 'height': this.grid.nj, 'image': v_thin,
+            'mag_filter': mag_filter, 'row_alignment': row_alignment,
+        };
+        return { u: u_image, v: v_image };
+    }
+    /** @internal */
+    getThinnedField(thin_fac, map_max_zoom) {
+        const new_grid = this.grid.getThinnedGrid(thin_fac, map_max_zoom);
+        const thin_u = new_grid.thinDataArray(this.grid, this.u.data);
+        const thin_v = new_grid.thinDataArray(this.grid, this.v.data);
         return new RawVectorField(new_grid, thin_u, thin_v, { relative_to: this.relative_to });
     }
+    /** @internal */
     get grid() {
         return this.u.grid;
     }
+    sampleField(lon, lat) {
+        const u_sample = this.grid.sampleNearestGridPoint(lon, lat, this.u.data);
+        const v_sample = this.grid.sampleNearestGridPoint(lon, lat, this.v.data);
+        const rot = this.relative_to == 'earth' ? 0 : this.grid.getVectorRotationAtPoint(u_sample.sample_lon, u_sample.sample_lat);
+        const mag = Math.hypot(u_sample.sample, v_sample.sample);
+        let brg = (Math.PI / 2 - Math.atan2(-v_sample.sample, -u_sample.sample) + rot) * 180 / Math.PI;
+        if (brg > 360)
+            brg -= 360;
+        if (brg < 0)
+            brg += 360;
+        return [brg, mag];
+    }
 }
 /** A class grid of wind profiles */
 class RawProfileField {
@@ -114,17 +151,96 @@ class RawProfileField {
         this.profiles = profiles;
         this.grid = grid;
     }
-    /** Get the gridded storm motion vector field (internal method) */
+    /**
+     * @internal
+     * Get the gridded storm motion vector field
+     */
     getStormMotionGrid() {
         const profiles = this.profiles;
         const u = new Float16Array(this.grid.ni * this.grid.nj).fill(parseFloat('nan'));
         const v = new Float16Array(this.grid.ni * this.grid.nj).fill(parseFloat('nan'));
         profiles.forEach(prof => {
             const idx = prof.ilon + this.grid.ni * prof.jlat;
-            u[idx] = prof.smu;
-            v[idx] = prof.smv;
+            if (isStormRelativeWindProfile(prof)) {
+                u[idx] = prof.smu;
+                v[idx] = prof.smv;
+            }
+            else {
+                u[idx] = 0;
+                v[idx] = 0;
+            }
         });
         return new RawVectorField(this.grid, u, v, { relative_to: 'grid' });
     }
+    /** @internal */
+    getProfileCoords() {
+        const { lats, lons } = this.grid.getEarthCoords();
+        const prof_lats = new Float32Array(this.profiles.length);
+        const prof_lons = new Float32Array(this.profiles.length);
+        this.profiles.forEach((prof, iprof) => {
+            const idx = prof.ilon + prof.jlat * this.grid.ni;
+            prof_lats[iprof] = lats[idx];
+            prof_lons[iprof] = lons[idx];
+        });
+        return { lats: prof_lats, lons: prof_lons };
+    }
+}
+/** Raw observation data, given as a list of objects */
+class RawObsField {
+    /**
+     * Create a field of observations
+     * @param grid - The grid on which the obs are defined (can be either a structured or unstructured grid)
+     * @param data - The observation data. Conceptually, obs are given as a list of individual observations.
+     */
+    constructor(grid, data) {
+        this.grid = grid;
+        this.data = data;
+    }
+    /**
+     * @internal
+     * Get observation element as a list of scalar numbers
+     */
+    getScalar(key) {
+        const field_data = this.data.map(d => d[key]);
+        if (!field_data.map(d => typeof d == 'number' || d === null).reduce((a, b) => a && b, true))
+            throw `It doesn't look like ${key} contains scalar numerical data`;
+        return field_data;
+    }
+    /**
+     * @internal
+     * Get observed element as a list of strings (internal method)
+     */
+    getStrings(key) {
+        const field_data = this.data.map(d => d[key]);
+        if (!field_data.map(d => typeof d == 'string' || d === null).reduce((a, b) => a && b, true))
+            throw `It doesn't look like ${key} contains string data`;
+        return field_data;
+    }
+    /**
+     * @internal
+     * Get observed element as a list of vectors (internal method)
+     */
+    getVector(key) {
+        const field_data = this.data.map(d => d[key]);
+        if (!field_data.map(d => Array.isArray(d)).reduce((a, b) => a && b, true))
+            throw `It doesn't look like ${key} contains vector data`;
+        const vector_field_data = field_data;
+        const vec2comp = (wspd, wdir) => {
+            const u = -wspd * Math.sin(wdir * Math.PI / 180);
+            const v = -wspd * Math.cos(wdir * Math.PI / 180);
+            return [u, v];
+        };
+        const u_data = new Float16Array(this.grid.ni * this.grid.nj).fill(parseFloat('nan'));
+        const v_data = new Float16Array(this.grid.ni * this.grid.nj).fill(parseFloat('nan'));
+        vector_field_data.forEach(([wspd, wdir], idat) => {
+            if (wspd === null || wdir === null) {
+                return;
+            }
+            const [u, v] = vec2comp(wspd, wdir);
+            u_data[idat] = u;
+            v_data[idat] = v;
+        });
+        return new RawVectorField(this.grid, u_data, v_data, { relative_to: 'earth' });
+    }
 }
-export { RawScalarField, RawVectorField, RawProfileField };
+export { RawScalarField, RawVectorField, RawProfileField, RawObsField };

package/lib/ShaderManager.d.ts

@@ -0,0 +1,12 @@
+import { WGLProgram } from "autumn-wgl";
+import { RenderShaderData, RendererData, WebGLAnyRenderingContext } from "./AutumnTypes";
+declare class ShaderProgramManager {
+    readonly vertex_shader_src: string;
+    readonly fragment_shader_src: string;
+    readonly shader_defines: string[];
+    private readonly program_map;
+    constructor(vertex_shader_src: string, fragment_shader_src: string, shader_defines: string[]);
+    getShaderProgram(gl: WebGLAnyRenderingContext, shader_data: RenderShaderData | null): WGLProgram;
+    getShaderUniforms(render_data: RendererData): Record<string, number | number[]>;
+}
+export { ShaderProgramManager };

package/lib/ShaderManager.js

@@ -0,0 +1,58 @@
+import { WGLProgram } from "autumn-wgl";
+import { mergeShaderCode } from "./utils";
+class ShaderProgramManager {
+    constructor(vertex_shader_src, fragment_shader_src, shader_defines) {
+        this.vertex_shader_src = vertex_shader_src;
+        this.fragment_shader_src = fragment_shader_src;
+        this.shader_defines = shader_defines;
+        this.program_map = new Map();
+    }
+    getShaderProgram(gl, shader_data) {
+        const shader_key = shader_data === null ? 'default' : shader_data.variantName;
+        const cached_program = this.program_map.get(shader_key);
+        if (cached_program !== undefined) {
+            return cached_program;
+        }
+        let vertex_src = this.vertex_shader_src;
+        if (shader_data !== null) {
+            vertex_src = mergeShaderCode(shader_data.vertexShaderPrelude + '\n' + shader_data.define, vertex_src);
+        }
+        else {
+            const prelude = `
+            uniform mat4 u_projection_matrix;
+
+            vec4 projectTile(vec2 p) {
+                vec4 result = u_projection_matrix * vec4(p, 0.0, 1.0);
+                return result;
+            }`;
+            vertex_src = mergeShaderCode(prelude, vertex_src);
+        }
+        const program = new WGLProgram(gl, vertex_src, this.fragment_shader_src, { define: this.shader_defines });
+        this.program_map.set(shader_key, program);
+        return program;
+    }
+    getShaderUniforms(render_data) {
+        if (render_data.type == 'maplibre') {
+            if (render_data.shaderData.define.includes('GLOBE')) {
+                return {
+                    'u_projection_matrix': render_data.defaultProjectionData.mainMatrix,
+                    'u_projection_fallback_matrix': render_data.defaultProjectionData.fallbackMatrix,
+                    'u_projection_tile_mercator_coords': render_data.defaultProjectionData.tileMercatorCoords,
+                    'u_projection_clipping_plane': render_data.defaultProjectionData.clippingPlane,
+                    'u_projection_transition': render_data.defaultProjectionData.projectionTransition
+                };
+            }
+            else {
+                return {
+                    'u_projection_matrix': render_data.defaultProjectionData.mainMatrix,
+                };
+            }
+        }
+        else {
+            return {
+                'u_projection_matrix': render_data.mainMatrix,
+            };
+        }
+    }
+}
+export { ShaderProgramManager };

package/lib/StationPlot.d.ts

@@ -1,34 +1,196 @@
-import { WebGLAnyRenderingContext } from "./AutumnTypes";
+import { RenderMethodArg, WebGLAnyRenderingContext } from "./AutumnTypes";
 import { MapLikeType } from "./Map";
 import { PlotComponent } from "./PlotComponent";
-interface EarthCoord {
-    lon: number;
-    lat: number;
+import { Grid } from "./Grid";
+import { RawObsField } from "./RawField";
+/**
+ * Positions around the station plot at which to draw the various elements
+ *
+ *  | Value   | Position     |
+ *  | --------|--------------|
+ *  | `'cl'`  | center-left  |
+ *  | `'ll'`  | lower-left   |
+ *  | `'lc'`  | lower-center |
+ *  | `'lr'`  | lower-right  |
+ *  | `'cr'`  | center-right |
+ *  | `'ur'`  | upper-right  |
+ *  | `'uc'`  | upper-center |
+ *  | `'ul'`  | upper-left   |
+ *  | `'c'`   | center       |
+ */
+type SPPosition = 'cl' | 'll' | 'lc' | 'lr' | 'cr' | 'ur' | 'uc' | 'ul' | 'c';
+/** Configuration for numerical values on station plots */
+interface SPNumberConfig {
+    type: 'number';
+    /**
+     * The position on the station plot at which to place the number
+     */
+    pos: SPPosition;
+    /**
+     * The color to use to draw the number
+     * @default '#000000'
+     */
+    color?: string;
+    /**
+     * Whether to draw a halo (outline) around the number
+     * @default true;
+     */
+    halo?: boolean;
+    /**
+     * The color to use for the halo (outline)
+     * @default '#ffffff'
+     */
+    halo_color?: string;
+    /**
+     * A function that properly formats the number for display
+     * @example (val) => val === null ? '' : val.toFixed(0)
+     * @param val - The number to format
+     * @returns A string containing the formatted nubmer
+     */
+    formatter?: (val: number | null) => string;
 }
-interface ObsRawData<ObsFieldName extends string> {
-    coord: EarthCoord;
-    data: Record<ObsFieldName, number>;
+/** Configuration for strings on station plots */
+interface SPStringConfig {
+    type: 'string';
+    /**
+     * The position on the station plot at which to place the string
+     */
+    pos: SPPosition;
+    /**
+     * The color to use to draw the string
+     * @default '#000000'
+     */
+    color?: string;
+    /**
+     * Whether to draw a halo (outline) around the string
+     * @default true;
+     */
+    halo?: boolean;
+    /**
+     * The color to use for the halo (outline)
+     * @default '#ffffff'
+     */
+    halo_color?: string;
 }
-type SPPositions = 'cl' | 'll' | 'lc' | 'lr' | 'cr' | 'ur' | 'uc' | 'ul';
-type SPDataPosition<ObsFieldName extends string> = Record<ObsFieldName, SPPositions>;
-declare class UnstructuredGrid {
-    readonly coords: EarthCoord[];
-    constructor(coords: EarthCoord[]);
-    getZoomThinning(thin_fac: number, map_max_zoom: number): number[];
+/** Configuration for wind barbs on station plots */
+interface SPBarbConfig {
+    type: 'barb';
+    /**
+     * The color to use to draw the barb
+     * @default '#000000'
+     */
+    color?: string;
+    /**
+     * A multiplier for the barb size
+     * @default 1
+     */
+    barb_size_multipler?: number;
 }
-declare class ObsField<ObsFieldName extends string> {
-    readonly grid: UnstructuredGrid;
-    readonly data: ObsRawData<ObsFieldName>[];
-    constructor(data: ObsRawData<ObsFieldName>[]);
+/**
+ * Accepted symbol codes for sky cover and present weather symbols
+ */
+type SPSymbol = ('0/8' | '1/8' | '2/8' | '3/8' | '4/8' | '5/8' | '6/8' | '7/8' | '8/8' | 'clr' | 'few' | 'sct' | 'bkn' | 'ovc' | 'obsc' | 'va' | 'fu' | 'hz' | 'du' | 'bldu' | 'sa' | 'blsa' | 'vcblsa' | 'vcbldu' | 'blpy' | 'po' | 'vcpo' | 'vcds' | 'vcss' | 'br' | 'bcbr' | 'bc' | 'mifg' | 'vcts' | 'virga' | 'vcsh' | 'ts' | 'thdr' | 'vctshz' | 'tsfzfg' | 'tsbr' | 'tsdz' | 'vctsup' | '-tsup' | 'tsup' | '+tsup' | 'sq' | 'fc' | '+fc' | 'ds' | 'ss' | 'drsa' | 'drdu' | '+ds' | '+ss' | 'drsn' | '+drsn' | '-blsn' | 'blsn' | '+blsn' | 'vcblsn' | 'vcfg' | 'bcfg' | 'prfg' | 'fg' | 'fzfg' | '-vctsdz' | '-dz' | '-dzbr' | 'vctsdz' | 'dz' | '+vctsdz' | '+dz' | '-fzdz' | '-fzdzsn' | 'fzdz' | '+fzdz' | 'fzdzsn' | '-dzra' | 'dzra' | '+dzra' | '-ra' | '-rabr' | 'ra' | 'rabr' | 'rafg' | 'vcra' | '+ra' | '-fzra' | '-fzrasn' | '-fzrabr' | '-fzrapl' | '-fzrasnpl' | 'tsfzrapl' | '-tsfzra' | 'fzra' | '+fzra' | 'fzrasn' | 'tsfzra' | '-dzsn' | '-rasn' | '-snra' | '-sndz' | 'rasn' | '+rasn' | 'snra' | 'dzsn' | 'sndz' | '+dzsn' | '+sndz' | '-sn' | '-snbr' | 'sn' | '+sn' | '-snsg' | 'sg' | '-sg' | 'ic' | '-fzdzpl' | '-fzdzplsn' | 'fzdzpl' | '-fzraplsn' | 'fzrapl' | '+fzrapl' | '-rapl' | '-rasnpl' | '-raplsn' | '+rapl' | 'rapl' | '-snpl' | 'snpl' | '-pl' | 'pl' | '-plsn' | '-plra' | 'plra' | '-pldz' | '+pl' | 'plsn' | 'plup' | '+plsn' | '-sh' | '-shra' | 'sh' | 'shra' | '+sh' | '+shra' | '-shrasn' | '-shsnra' | '+shrabr' | 'shrasn' | '+shrasn' | 'shsnra' | '+shsnra' | '-shsn' | 'shsn' | '+shsn' | '-gs' | '-shgs' | 'fzraplgs' | '-sngs' | 'gsplsn' | 'gspl' | 'plgssn' | 'gs' | 'shgs' | '+gs' | '+shgs' | '-gr' | '-shgr' | '-sngr' | 'gr' | 'shgr' | '+gr' | '+shgr' | '-tsrasn' | 'tsrasn' | '-tssnra' | 'tssnra' | '-vctsra' | '-tsra' | 'tsra' | '-tsdz' | 'vctsra' | 'tspl' | '-tssn' | '-tspl' | 'tssn' | '-vctssn' | 'vctssn' | 'tsplsn' | 'tssnpl' | '-tssnpl' | '-tsragr' | 'tsrags' | 'tsragr' | 'tsgs' | 'tsgr' | '+tsfzrapl' | '+vctsra' | '+tsra' | '+tsfzra' | '+tssn' | '+tspl' | '+tsplsn' | '+vctssn' | 'tssa' | 'tsds' | 'tsdu' | '+tsgs' | '+tsgr' | '+tsrags' | '+tsragr' | 'in' | '-up' | 'up' | '+up' | '-fzup' | 'fzup' | '+fzup');
+/** Configuration for symbols on station plots */
+interface SPSymbolConfig {
+    type: 'symbol';
+    /**
+     * The position on the station plot at which to place the symbol
+     */
+    pos: SPPosition;
+    /**
+     * The color to use to draw the symbol
+     * @default '#000000'
+     */
+    color?: string;
+    /**
+ * Whether to draw a halo (outline) around the string
+ * @default true;
+ */
+    halo?: boolean;
+    /**
+     * The color to use for the halo (outline)
+     * @default '#ffffff'
+     */
+    halo_color?: string;
 }
-interface StationPlotOpts {
+/** Configuration for station plot sub-elements */
+type SPConfig = SPNumberConfig | SPStringConfig | SPBarbConfig | SPSymbolConfig;
+/**
+ * Configuration for station data plots
+ * @example
+ * spconfig : SPDataConfig<'id' | 'tmpf' | 'wind' | 'skyc'> = {
+ *      // Add a string to the station plot (like the station ID)
+ *      id:   {type: 'string', pos: 'lr'},
+ *
+ *      // Add a number to the station plot (like the temperature)
+ *      tmpf: {type: 'number', pos: 'ul', color: '#cc0000', formatter: val => val === null ? '' : val.toFixed(0)},
+ *
+ *      // Add a barb to the station plot
+ *      wind: {type: 'barb', pos: 'c'},
+ *
+ *      // Add a symbol to the station plot
+ *      skyc: {type: 'symbol', pos: 'c'},
+ * }
+ */
+type SPDataConfig<ObsFieldName extends string> = Record<ObsFieldName, SPConfig>;
+/** Options for {@link StationPlot} components */
+interface StationPlotOptions<ObsFieldName extends string> {
+    config: SPDataConfig<ObsFieldName>;
+    /**
+     * Thin factor at zoom level 1 for the station plots. Should be a power of 2.
+     * @default 1
+     */
+    thin_fac?: number;
+    /**
+     * Font face to use for plotting text
+     * @default 'Trebuchet MS'
+     */
+    font_face?: string;
+    /**
+     * Size of the font to use for the text
+     * @default 12
+     */
+    font_size?: number;
+    /**
+     * URL template to use in retrieving the font data for the text. The default is to use the template from the map style.
+     */
+    font_url_template?: string;
 }
-declare class StationPlot<ObsFieldName extends string, MapType extends MapLikeType> extends PlotComponent<MapType> {
-    readonly field: ObsField<ObsFieldName>;
-    readonly data_positions: SPDataPosition<ObsFieldName>;
-    readonly opts: Required<StationPlotOpts>;
-    constructor(field: ObsField<ObsFieldName>, data_positions: SPDataPosition<ObsFieldName>, opts: StationPlotOpts);
+/**
+ * Station model plots for observed data
+ * @example
+ * // Specify how to set up the station plot
+ * const station_plot_locs = {
+ *     tmpf: {type: 'number', pos: 'ul', color: '#cc0000', formatter: val => val === null ? '' : val.toFixed(0)},
+ *     dwpf: {type: 'number', pos: 'll', color: '#00aa00', formatter: val => val === null ? '' : val.toFixed(0)},
+ *     wind: {type: 'barb', pos: 'c'},
+ *     preswx: {type: 'symbol', pos: 'cl', color: '#ff00ff'},
+ *     skyc: {type: 'symbol', pos: 'c'},
+ * };
+ *
+ * // Create the station plot
+ * const station_plot = new StationPlot(obs_field, {config: station_plot_locs, thin_fac: 8, font_size: 14});
+ */
+declare class StationPlot<GridType extends Grid, MapType extends MapLikeType, ObsFieldName extends string> extends PlotComponent<MapType> {
+    private field;
+    readonly opts: Required<StationPlotOptions<ObsFieldName>>;
+    private gl_elems;
+    private text_components;
+    /**
+     * Create station plots
+     * @param field - A field containing the observed data
+     * @param opts  - Various options for the station plots
+     */
+    constructor(field: RawObsField<GridType, ObsFieldName>, opts: StationPlotOptions<ObsFieldName>);
+    /**
+     * Update the data displayed as station plots
+     * @param field - The new field to display as station plots
+     */
+    updateField(field: RawObsField<GridType, ObsFieldName>): Promise<void>;
+    /** @internal */
     onAdd(map: MapType, gl: WebGLAnyRenderingContext): Promise<void>;
-    render(gl: WebGLAnyRenderingContext, matrix: Float32Array | number[]): void;
+    /** @internal */
+    render(gl: WebGLAnyRenderingContext, arg: RenderMethodArg): void;
 }
-export { StationPlot };
+export default StationPlot;
+export type { StationPlotOptions, SPPosition, SPNumberConfig, SPStringConfig, SPBarbConfig, SPSymbolConfig, SPConfig, SPDataConfig, SPSymbol };