autumnplot-gl 3.1.0 → 4.0.0-beta

package/lib/RawField.js

@@ -1,8 +1,15 @@
 import { Float16Array } from "@petamoriken/float16";
 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 +32,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 +72,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 +91,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 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,
         };
-        const thin_u = thinGrid(this.u.data);
-        const thin_v = thinGrid(this.v.data);
+        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,7 +150,10 @@ 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'));
@@ -126,5 +165,75 @@ class RawProfileField {
         });
         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

@@ -0,0 +1,145 @@
+import { RenderMethodArg, WebGLAnyRenderingContext } from "./AutumnTypes";
+import { MapLikeType } from "./Map";
+import { PlotComponent } from "./PlotComponent";
+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';
+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;
+    /**
+     * 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 SPStringConfig {
+    type: 'string';
+    /**
+     * 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;
+}
+interface SPBarbConfig {
+    type: 'barb';
+    /**
+     * The color to use to draw the number
+     * @default '#000000'
+     */
+    color?: string;
+    /**
+     * A multiplier for the barb size
+     * @default 1
+     */
+    barb_size_multipler?: number;
+}
+/**
+ * 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');
+interface SPSymbolConfig {
+    type: 'symbol';
+    /**
+     * 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;
+}
+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>;
+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<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;
+    /**
+     *
+     * @param field
+     * @param opts
+     */
+    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>;
+    /** @internal */
+    render(gl: WebGLAnyRenderingContext, arg: RenderMethodArg): void;
+}
+export default StationPlot;
+export type { StationPlotOptions, SPPosition, SPNumberConfig, SPStringConfig, SPBarbConfig, SPSymbolConfig, SPConfig, SPDataConfig, SPSymbol };

package/lib/StationPlot.js

@@ -0,0 +1,205 @@
+import { PlotComponent } from "./PlotComponent";
+import { normalizeOptions } from "./utils";
+import { TextCollection } from "./TextCollection";
+import { Color } from "./Color";
+import Barbs from "./Barbs";
+const SYMBOLS = {
+    // Sky cover symbols
+    '0/8': 59658, '1/8': 59659, '2/8': 59660, '3/8': 59661, '4/8': 59662, '5/8': 59663, '6/8': 59664, '7/8': 59665, '8/8': 59666,
+    'clr': 59658, 'few': 59660, 'sct': 59662, 'bkn': 59664, 'ovc': 59666, 'obsc': 59667,
+    // Present weather symbols
+    'va': 59810, 'fu': 59810, 'hz': 59811, 'du': 59812, 'bldu': 59814, 'sa': 59814, 'blsa': 59814, 'vcblsa': 59814, 'vcbldu': 59814, 'blpy': 59814,
+    'po': 59816, 'vcpo': 59816, 'vcds': 59817, 'vcss': 59817,
+    'br': 59818, 'bcbr': 59818, 'bc': 59819, 'mifg': 59820,
+    'vcts': 59821, 'virga': 59822, 'vcsh': 59824, 'ts': 59825, 'thdr': 59825, 'vctshz': 59825,
+    'tsfzfg': 59825, 'tsbr': 59825, 'tsdz': 59825, 'vctsup': 59825,
+    '-tsup': 59825, 'tsup': 59825, '+tsup': 59825,
+    'sq': 59826, 'fc': 59827, '+fc': 59827,
+    'ds': 59839, 'ss': 59839, 'drsa': 59839, 'drdu': 59839, '+ds': 59842, '+ss': 59842,
+    'drsn': 59844, '+drsn': 59845, '-blsn': 59846, 'blsn': 59846, '+blsn': 59847, 'vcblsn': 59846,
+    'vcfg': 59848, 'bcfg': 59849, 'prfg': 59852, 'fg': 59853, 'fzfg': 59857,
+    '-vctsdz': 59859, '-dz': 59859, '-dzbr': 59859, 'vctsdz': 59861, 'dz': 59861, '+vctsdz': 59863, '+dz': 59863,
+    '-fzdz': 59864, '-fzdzsn': 59864, 'fzdz': 59865, '+fzdz': 59865, 'fzdzsn': 59865,
+    '-dzra': 59866, 'dzra': 59867, '+dzra': 59867, '-ra': 59869, '-rabr': 59869, 'ra': 59871, 'rabr': 59871, 'rafg': 59871, 'vcra': 59871, '+ra': 59873,
+    '-fzra': 59874, '-fzrasn': 59874, '-fzrabr': 59874, '-fzrapl': 59874, '-fzrasnpl': 59874, 'tsfzrapl': 59875, '-tsfzra': 59875,
+    'fzra': 59875, '+fzra': 59875, 'fzrasn': 59875, 'tsfzra': 59875,
+    '-dzsn': 59876, '-rasn': 59876, '-snra': 59876, '-sndz': 59876, 'rasn': 59877, '+rasn': 59877, 'snra': 59877, 'dzsn': 59877, 'sndz': 59877, '+dzsn': 59877, '+sndz': 59877,
+    '-sn': 59879, '-snbr': 59879, 'sn': 59881, '+sn': 59883, '-snsg': 59885, 'sg': 59885, '-sg': 59885, 'ic': 59886,
+    '-fzdzpl': 59887, '-fzdzplsn': 59887, 'fzdzpl': 59887, '-fzraplsn': 59887, 'fzrapl': 59887, '+fzrapl': 59887,
+    '-rapl': 59887, '-rasnpl': 59887, '-raplsn': 59887, '+rapl': 59887, 'rapl': 59887, '-snpl': 59887, 'snpl': 59887,
+    '-pl': 59887, 'pl': 59887, '-plsn': 59887, '-plra': 59887, 'plra': 59887, '-pldz': 59887, '+pl': 59887, 'plsn': 59887, 'plup': 59887, '+plsn': 59887,
+    '-sh': 59888, '-shra': 59888, 'sh': 59889, 'shra': 59889, '+sh': 59889, '+shra': 59889, '-shrasn': 59891, '-shsnra': 59891, '+shrabr': 59892,
+    'shrasn': 59892, '+shrasn': 59892, 'shsnra': 59892, '+shsnra': 59892, '-shsn': 59893, 'shsn': 59894, '+shsn': 59894,
+    '-gs': 59895, '-shgs': 59895, 'fzraplgs': 59896, '-sngs': 59896, 'gsplsn': 59896, 'gspl': 59896, 'plgssn': 59896, 'gs': 59896, 'shgs': 59896, '+gs': 59896, '+shgs': 59896,
+    '-gr': 59897, '-shgr': 59897, '-sngr': 59898, 'gr': 59898, 'shgr': 59898, '+gr': 59898, '+shgr': 59898,
+    '-tsrasn': 59907, 'tsrasn': 59907, '-tssnra': 59907, 'tssnra': 59907, '-vctsra': 59908, '-tsra': 59908, 'tsra': 59908, '-tsdz': 59908, 'vctsra': 59908,
+    'tspl': 59909, '-tssn': 59909, '-tspl': 59909, 'tssn': 59909, '-vctssn': 59909, 'vctssn': 59909, 'tsplsn': 59909, 'tssnpl': 59909, '-tssnpl': 59909, '-tsragr': 59910,
+    'tsrags': 59910, 'tsragr': 59910, 'tsgs': 59910, 'tsgr': 59910,
+    '+tsfzrapl': 59911, '+vctsra': 59912, '+tsra': 59912, '+tsfzra': 59912, '+tssn': 59913, '+tspl': 59913, '+tsplsn': 59913, '+vctssn': 59913,
+    'tssa': 59914, 'tsds': 59914, 'tsdu': 59914, '+tsgs': 59915, '+tsgr': 59915, '+tsrags': 59915, '+tsragr': 59915, 'in': 59750,
+    '-up': 59750, 'up': 59750, '+up': 59751, '-fzup': 59756, 'fzup': 59756, '+fzup': 59757,
+};
+const station_plot_opts_defaults = {
+    config: {},
+    thin_fac: 1,
+    font_face: 'Trebuchet MS',
+    font_size: 12,
+    font_url_template: '',
+};
+function positionToAlignmentAndOffset(pos, off_size) {
+    off_size = off_size === undefined ? 10 : off_size;
+    let ha, va;
+    let xoff, yoff;
+    if (pos == 'll' || pos == 'cl' || pos == 'ul') {
+        ha = 'right';
+        xoff = -off_size;
+    }
+    else if (pos == 'lc' || pos == 'c' || pos == 'uc') {
+        ha = 'center';
+        xoff = 0;
+    }
+    else {
+        ha = 'left';
+        xoff = off_size;
+    }
+    if (pos == 'll' || pos == 'lc' || pos == 'lr') {
+        va = 'top';
+        yoff = -off_size;
+    }
+    else if (pos == 'cl' || pos == 'c' || pos == 'cr') {
+        va = 'middle';
+        yoff = 0;
+    }
+    else {
+        va = 'baseline';
+        yoff = off_size;
+    }
+    return { horizontal_align: ha, vertical_align: va, offset_x: xoff, offset_y: yoff };
+}
+class StationPlot extends PlotComponent {
+    /**
+     *
+     * @param field
+     * @param opts
+     */
+    constructor(field, opts) {
+        super();
+        this.field = field;
+        this.opts = normalizeOptions(opts, station_plot_opts_defaults); // Is there a way to do this without invoking `as`?
+        this.gl_elems = null;
+        this.text_components = null;
+    }
+    /**
+     * Update the data displayed as station plots
+     * @param field - The new field to display as station plots
+     */
+    async updateField(field) {
+        this.field = field;
+        if (this.gl_elems === null)
+            return;
+        const map = this.gl_elems.map;
+        const gl = this.gl_elems.gl;
+        const barb_components = this.gl_elems.barb_components;
+        const map_style = map.getStyle();
+        const font_url_template = this.opts.font_url_template == '' ? map_style.glyphs : this.opts.font_url_template;
+        if (font_url_template === undefined)
+            throw "The map style doesn't have any glyph information. Please pass the font_url_template option to StationPlot";
+        const font_url = font_url_template.replace('{fontstack}', this.opts.font_face);
+        let ibarb = 0;
+        const sub_component_promises = Object.entries(this.opts.config).map(async ([k_, config]) => {
+            const k = k_;
+            if (config.type == 'number' || config.type == 'string') {
+                const pos = config.pos;
+                const color_opt = config.color;
+                const color = color_opt === undefined ? Color.fromHex('#000000') : Color.normalizeColor(color_opt);
+                const coords = this.field.grid.getEarthCoords();
+                const zoom = this.field.grid.getMinVisibleZoom(this.opts.thin_fac);
+                let text_specs;
+                if (config.type == 'number') {
+                    const comp = this.field.getScalar(k);
+                    const formatter = config.formatter === undefined ? (val) => val === null ? 'null' : val.toString() : config.formatter;
+                    text_specs = comp.map((v, i) => ({ text: formatter(v), lat: coords.lats[i], lon: coords.lons[i], min_zoom: zoom[i] }));
+                }
+                else {
+                    const comp = this.field.getStrings(k);
+                    text_specs = comp.map((v, i) => ({ text: v === null ? '' : v, lat: coords.lats[i], lon: coords.lons[i], min_zoom: zoom[i] }));
+                }
+                const tc_opts = {
+                    ...positionToAlignmentAndOffset(pos),
+                    font_size: this.opts.font_size, halo: true,
+                    text_color: color, halo_color: Color.fromHex('#ffffff'),
+                };
+                return await TextCollection.make(gl, text_specs, font_url, tc_opts);
+            }
+            else if (config.type == 'barb') {
+                const comp = this.field.getVector(k);
+                const barb_comp = barb_components[ibarb++];
+                barb_comp.updateField(comp);
+            }
+            else if (config.type == 'symbol') {
+                const pos = config.pos;
+                const color_opt = config.color;
+                const color = color_opt === undefined ? Color.fromHex('#000000') : Color.normalizeColor(color_opt);
+                const comp = this.field.getStrings(k);
+                const coords = this.field.grid.getEarthCoords();
+                const zoom = this.field.grid.getMinVisibleZoom(this.opts.thin_fac);
+                const wxsym_font_url = font_url_template.replace('{fontstack}', 'wx_symbols');
+                const text_specs = comp.map((v, i) => ({ text: v === null ? '' : String.fromCharCode(SYMBOLS[v]),
+                    lat: coords.lats[i], lon: coords.lons[i], min_zoom: zoom[i] }));
+                const tc_opts = {
+                    ...positionToAlignmentAndOffset(pos),
+                    font_size: this.opts.font_size, halo: true,
+                    text_color: color, halo_color: Color.fromHex('#ffffff'),
+                };
+                if (tc_opts.offset_x !== undefined)
+                    tc_opts.offset_x -= 3;
+                return await TextCollection.make(gl, text_specs, wxsym_font_url, tc_opts);
+            }
+            else {
+                throw `Unknown station plot configuration type ${config.type}`;
+            }
+        });
+        this.text_components = (await Promise.all(sub_component_promises)).filter((c) => c !== undefined);
+        map.triggerRepaint();
+    }
+    /** @internal */
+    async onAdd(map, gl) {
+        const barb_promises = Object.entries(this.opts.config).map(async ([k_, config]) => {
+            const k = k_;
+            if (config.type == 'barb') {
+                const comp = this.field.getVector(k);
+                const color = config.color === undefined ? '#000000' : config.color;
+                const barb_size = config.barb_size_multipler === undefined ? 1 : config.barb_size_multipler;
+                const barb_comp = new Barbs(comp, { thin_fac: this.opts.thin_fac, color: color, barb_size_multiplier: barb_size });
+                await barb_comp.onAdd(map, gl);
+                return barb_comp;
+            }
+        });
+        const barb_components = (await Promise.all(barb_promises)).filter((c) => c !== undefined);
+        this.gl_elems = {
+            map: map, gl: gl, barb_components: barb_components
+        };
+        this.updateField(this.field);
+    }
+    /** @internal */
+    render(gl, arg) {
+        if (this.gl_elems === null || this.text_components === null)
+            return;
+        const gl_elems = this.gl_elems;
+        const text_components = this.text_components;
+        const barb_components = this.gl_elems.barb_components;
+        const map_width = gl_elems.map.getCanvas().width;
+        const map_height = gl_elems.map.getCanvas().height;
+        const map_zoom = gl_elems.map.getZoom();
+        let itext = 0, ibarb = 0;
+        Object.values(this.opts.config).forEach(comp => {
+            if (comp.type == 'barb') {
+                barb_components[ibarb++].render(gl, arg);
+            }
+            else {
+                text_components[itext++].render(gl, arg, [map_width, map_height], map_zoom);
+            }
+        });
+    }
+}
+export default StationPlot;