autumnplot-gl 4.0.0 → 4.1.0

package/lib/RawField.js

@@ -1,8 +1,8 @@
 import { Float16Array } from "@petamoriken/float16";
-import { isStormRelativeWindProfile } from "./AutumnTypes";
-import { contourCreator } from "./ContourCreator";
+import { isContourable, isStormRelativeWindProfile } from "./AutumnTypes";
 import { Cache, getArrayConstructor, zip } from "./utils";
-import { getGLFormatTypeAlignment } from "./PlotComponent";
+import { WGLTexture } from "autumn-wgl";
+import { getContourWorkerPool, getGLFormatTypeAlignment } from "./PlotComponent";
 function getArrayDType(ary) {
     if (ary instanceof Float32Array) {
         return 'float32';
@@ -10,40 +10,157 @@ function getArrayDType(ary) {
     else if (ary instanceof Uint8Array) {
         return 'uint8';
     }
+    else if (ary instanceof Uint16Array) {
+        return 'uint16';
+    }
+    else if (ary instanceof Uint32Array) {
+        return 'uint32';
+    }
+    else if (ary instanceof Int16Array) {
+        return 'int16';
+    }
+    else if (ary instanceof Int32Array) {
+        return 'int32';
+    }
     return 'float16';
 }
+class ExpressionScalarField {
+    operand(other, operand) {
+        const FUNCS = {
+            '+': (a, b) => a + b,
+            '-': (a, b) => a - b,
+            '*': (a, b) => a * b,
+            '/': (a, b) => a / b,
+        };
+        if (typeof other === 'number') {
+            return new ComputedScalarField([this], `{0} ${operand} ${other.toFixed(100)}`, v => FUNCS[operand](v, other));
+        }
+        return new ComputedScalarField([this, other], `{0} ${operand} {1}`, FUNCS[operand]);
+    }
+    /**
+     * Multiply this field by another scalar. The computation occurs on the GPU if the resulting field is used in a plot component or on the CPU if
+     *  {@link ComputedScalarField.renderCPU | renderCPU()} is called on the resulting field.
+     * @param other - Scalar to multiply this field by
+     * @returns A `ComputedScalarField` representing the multiplied field
+     */
+    multiply(other) {
+        return this.operand(other, '*');
+    }
+    /**
+     * Divide this field by another scalar. The computation occurs on the GPU if the resulting field is used in a plot component or on the CPU if
+     * {@link ComputedScalarField.renderCPU | renderCPU()} is called on the resulting field.
+     * @param other - Scalar to divide this field by
+     * @returns A `ComputedScalarField` representing the divided field
+     */
+    divide(other) {
+        return this.operand(other, '/');
+    }
+    /**
+     * Add this field to another scalar. The computation occurs on the GPU if the resulting field is used in a plot component or on the CPU if
+     *  {@link ComputedScalarField.renderCPU | renderCPU()} is called on the resulting field.
+     * @param other - Scalar to add to this field
+     * @returns A `ComputedScalarField` representing the added field
+     */
+    add(other) {
+        return this.operand(other, '+');
+    }
+    /**
+     * Subtract another scalar from this field. The computation occurs on the GPU if the resulting field is used in a plot component or on the CPU if
+     *  {@link ComputedScalarField.renderCPU | renderCPU()} is called on the resulting field.
+     * @param other - Scalar to subtract from this field
+     * @returns A `ComputedScalarField` representing the subtracted field
+     */
+    subtract(other) {
+        return this.operand(other, '-');
+    }
+}
 /** A class representing a raw 2D field of gridded data, such as height or u wind. */
-class RawScalarField {
+class RawScalarField extends ExpressionScalarField {
     /**
      * Create a data field.
      * @param grid - The grid on which the data are defined
      * @param data - The data, which should be given as a 1D array in row-major order, with the first element being at the lower-left corner of the grid.
      */
     constructor(grid, data) {
+        super();
         this.grid = grid;
         this.data = data;
         if (grid.ni * grid.nj != data.length) {
             throw `Data size (${data.length}) doesn't match the grid dimensions (${grid.ni} x ${grid.nj}; expected ${grid.ni * grid.nj} points)`;
         }
         this.contour_cache = new Cache(async (opts) => {
-            return await contourCreator(this.data, this.grid, opts);
+            if (getArrayDType(this.data) != 'float16' && getArrayDType(this.data) != 'float32')
+                throw `Grid is of type ${getArrayDType(this.data)}, which is not contourable (should be either float16 or float32)`;
+            const tex_data = this.getTextureData();
+            if (!isContourable(tex_data))
+                throw `Type check for contourable array failed`;
+            const pool = getContourWorkerPool(undefined, 1); // 1 worker is the default; if the user requests more, the pool will be pre-created with the correct number of workers
+            const contour_data = await pool.contourCreator(tex_data, grid.getGridCoords(), opts);
+            for (const v in contour_data) {
+                for (let ic = 0; ic < contour_data[v].length; ic++) {
+                    for (let ip = 0; ip < contour_data[v][ic].length; ip++) {
+                        const [x, y] = contour_data[v][ic][ip];
+                        contour_data[v][ic][ip] = grid.transform(x, y, { inverse: true });
+                    }
+                }
+            }
+            return contour_data;
         });
     }
     /** @internal */
+    get aryConstructor() {
+        return getArrayConstructor(this.data);
+    }
+    /** @internal */
+    get dtypes() {
+        return [getArrayDType(this.data)];
+    }
+    /** @internal */
     getTextureData() {
         // Need to give float16 data as uint16s to make WebGL happy: https://github.com/petamoriken/float16/issues/105
         const raw_data = this.data;
         const raw_data_type = getArrayDType(raw_data);
-        const data = (raw_data_type == 'float32' || raw_data_type == 'uint8') ? raw_data : new Uint16Array(raw_data.buffer);
+        const data = ['float32', 'uint8', 'uint32', 'uint16', 'int32', 'int16'].includes(raw_data_type) ? 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,
-        };
+        return new Map([['_0', { 'format': format, 'type': type,
+                    'width': this.grid.ni, 'height': this.grid.nj, 'image': tex_data,
+                    'mag_filter': image_mag_filter, 'min_filter': image_mag_filter, 'row_alignment': row_alignment,
+                }]]);
+    }
+    updateTexImageData(gl, image_mag_filter, fill_textures) {
+        const fill_texture_specs = this.getWGLTextureSpec(gl, image_mag_filter);
+        if (fill_textures === null) {
+            fill_textures = new Map(this.getSamplerIds().map(key => {
+                const key_fill_image = fill_texture_specs.get(key);
+                if (key_fill_image === undefined)
+                    throw `Missing key '${key}' in fill_texture_specs`;
+                return [key, new WGLTexture(gl, key_fill_image)];
+            }));
+        }
+        else {
+            this.getSamplerIds().forEach(key => {
+                const key_fill_image = fill_texture_specs.get(key);
+                if (key_fill_image === undefined)
+                    throw `Missing key '${key}' in fill_texture_specs`;
+                const tex = fill_textures?.get(key);
+                if (tex === undefined)
+                    throw `Missing key '${key}' in fill_textures`;
+                tex.setImageData(key_fill_image);
+            });
+        }
+        return fill_textures;
+    }
+    /** @internal */
+    getSamplerIds() {
+        return ['_0'];
+    }
+    /** @internal */
+    getExpression() {
+        return '_0';
     }
     /**
      * Get contour data as an object with each contour level being a separate property.
@@ -54,7 +171,7 @@ class RawScalarField {
         return await this.contour_cache.getValue(opts);
     }
     /**
-     * Create a new field by aggregating a number of fields using a specific function
+     * Create a new field by aggregating a number of fields using a specific function. This computation occurs on the CPU.
      * @param func - A function that will be applied each element of the field. It should take the same number of arguments as fields you have and return a single number.
      * @param args - The RawScalarFields to aggregate
      * @returns a new gridded field
@@ -63,73 +180,255 @@ class RawScalarField {
      * wind_speed_field = RawScalarField.aggreateFields(Math.hypot, u_field, v_field);
      */
     static aggregateFields(func, ...args) {
-        function* mapGenerator(gen, func) {
-            for (const elem of gen) {
-                yield func(elem);
-            }
+        return (new ComputedScalarField(args, '', func)).renderCPU();
+    }
+    /**
+     * Run computations on a scalar field on the CPU (for a `RawScalarField`, this is a no-op). The function blocks the main thread, so avoid calling it if possible.
+     * @returns The computed grid in a `RawScalarField`
+     */
+    renderCPU() {
+        return this;
+    }
+    /** @internal */
+    *iterateCPU() {
+        for (let i = 0; i < this.data.length; i++) {
+            yield this.data[i];
         }
-        const arrayType = getArrayConstructor(args[0].data);
-        const zipped_args = zip(...args.map(a => a.data));
-        const agg_data = new arrayType(mapGenerator(zipped_args, (a) => func(...a)));
-        return new RawScalarField(args[0].grid, agg_data);
     }
+    /** @internal */
+    getThinnedField(thin_fac, map_max_zoom) {
+        const new_grid = this.grid.getThinnedGrid(thin_fac, map_max_zoom);
+        const thin_data = new_grid.thinDataArray(this.grid, this.data);
+        return new RawScalarField(new_grid, thin_data);
+    }
+    /**
+     * Sample this field at a given latitude and longitude.
+     * @param lon - Longitude of the sample in degrees east
+     * @param lat - Latitude of the sample in degrees north
+     * @returns The value of the nearest grid point along with the grid point latitude and longitude, or NaNs if the point is outside the grid.
+     */
+    sampleFieldWithCoord(lon, lat) {
+        return this.grid.sampleNearestGridPoint(lon, lat, this.data);
+    }
+    /**
+     * Sample this field at a given latitude and longitude.
+     * @param lon - Longitude of the sample in degrees east
+     * @param lat - Latitude of the sample in degrees north
+     * @returns The value of the nearest grid point, or NaN if the point is outside the grid.
+     */
     sampleField(lon, lat) {
-        return this.grid.sampleNearestGridPoint(lon, lat, this.data).sample;
+        return this.sampleFieldWithCoord(lon, lat).sample;
     }
 }
-/** A class representing a 2D gridded field of vectors */
-class RawVectorField {
+const chars = 'abcdefghijklmnopqrstuvwxyz';
+class ComputedScalarField extends ExpressionScalarField {
+    constructor(raw_fields, expression, cpu_func) {
+        super();
+        this.raw_fields = raw_fields;
+        this.expression = expression;
+        this.cpu_func = cpu_func;
+    }
+    /** @internal */
+    get grid() {
+        return this.raw_fields[0].grid;
+    }
+    /** @internal */
+    get aryConstructor() {
+        return this.raw_fields[0].aryConstructor;
+    }
+    /** @internal */
+    get dtypes() {
+        return this.raw_fields.map(f => f.dtypes).flat();
+    }
+    /** @internal */
+    updateTexImageData(gl, image_mag_filter, fill_textures) {
+        const fill_textures_ret = new Map();
+        this.raw_fields.forEach((field, idx) => {
+            let fill_textures_pre_field = null;
+            if (fill_textures !== null) {
+                fill_textures_pre_field = new Map();
+                for (let [key, val] of fill_textures) {
+                    if (key[key.length - 1] == chars[idx])
+                        fill_textures_pre_field.set(key.slice(0, -1), val);
+                }
+            }
+            const fill_textures_field = field.updateTexImageData(gl, image_mag_filter, fill_textures_pre_field);
+            for (let [key, val] of fill_textures_field) {
+                fill_textures_ret.set(`${key}${chars[idx]}`, val);
+            }
+        });
+        return fill_textures_ret;
+    }
+    /** @internal */
+    getSamplerIds() {
+        return this.raw_fields.map((f, i) => f.getSamplerIds().map(id => `${id}${chars[i]}`)).flat();
+    }
+    /** @internal */
+    getExpression() {
+        let expression = this.expression;
+        this.raw_fields.forEach((field, idx) => {
+            let field_expr = field.getExpression();
+            const matches = field_expr.match(/_0[a-z]*/g);
+            if (matches === null)
+                throw `Field expression not found`;
+            matches.forEach(m => field_expr = field_expr.replace(m, `${m}${chars[idx]}`));
+            expression = expression.replace(`{${idx}}`, field_expr);
+        });
+        return `(${expression})`;
+    }
+    /** @internal */
+    getThinnedField(thin_fac, map_max_zoom) {
+        return new ComputedScalarField(this.raw_fields.map(f => f.getThinnedField(thin_fac, map_max_zoom)), this.expression, this.cpu_func);
+    }
     /**
-     * Create a vector field.
-     * @param grid - The grid on which the vector components are defined
-     * @param u    - The u (east/west) component of the vectors, which should be given as a 1D array in row-major order, with the first element being at the lower-left corner of the grid
-     * @param v    - The v (north/south) component of the vectors, which should be given as a 1D array in row-major order, with the first element being at the lower-left corner of the grid
-     * @param opts - Options for creating the vector field.
+     * Sample this field at a given latitude and longitude.
+     * @param lon - Longitude of the sample in degrees east
+     * @param lat - Latitude of the sample in degrees north
+     * @returns The value of the nearest grid point along with the grid point latitude and longitude, or NaNs if the point is outside the grid.
+     */
+    sampleFieldWithCoord(lon, lat) {
+        const field_samples = this.raw_fields.map(f => f.sampleFieldWithCoord(lon, lat));
+        return { sample: this.cpu_func(...field_samples.map(s => s.sample)), sample_lon: field_samples[0].sample_lon, sample_lat: field_samples[0].sample_lat };
+    }
+    /**
+     * Sample this field at a given latitude and longitude.
+     * @param lon - Longitude of the sample in degrees east
+     * @param lat - Latitude of the sample in degrees north
+     * @returns The value of the nearest grid point, or NaN if the point is outside the grid.
+     */
+    sampleField(lon, lat) {
+        return this.sampleFieldWithCoord(lon, lat).sample;
+    }
+    /**
+     * Run computations on a scalar field on the CPU. The function blocks the main thread, so avoid calling it if possible.
+     * @returns The computed grid in a `RawScalarField`
      */
-    constructor(grid, u, v, opts) {
+    renderCPU() {
+        const ary = new this.aryConstructor([...this.iterateCPU()]);
+        return new RawScalarField(this.grid, ary);
+    }
+    /** @internal */
+    *iterateCPU() {
+        function* mapGenerator(gen, func) {
+            for (const elem of gen) {
+                yield func(...elem);
+            }
+        }
+        const zipped_args = zip(...this.raw_fields.map(a => a.iterateCPU()));
+        for (const elem of mapGenerator(zipped_args, this.cpu_func)) {
+            yield elem;
+        }
+    }
+}
+function scalarIdToVectorComponentId(id, component) {
+    return `_${component}${id.slice(1)}`;
+}
+function vectorComponentIdToScalarId(id) {
+    return `_${id.slice(2)}`;
+}
+class ExpressionVectorField {
+    constructor(u, v, opts) {
+        this.u = u;
+        this.v = v;
         opts = opts === undefined ? {} : opts;
-        this.u = new RawScalarField(grid, u);
-        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_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 };
-    }
-    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,
+    operandScalar(other, operand) {
+        const FUNCS = {
+            '*': (a, b) => a * b,
+            '/': (a, b) => a / b,
         };
-        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,
+        if (typeof other === 'number') {
+            const u = new ComputedScalarField([this.u], `{0} ${operand} ${other.toFixed(100)}`, v => FUNCS[operand](v, other));
+            const v = new ComputedScalarField([this.v], `{0} ${operand} ${other.toFixed(100)}`, v => FUNCS[operand](v, other));
+            return new ComputedVectorField(u, v, { relative_to: this.relative_to });
+        }
+        const u = new ComputedScalarField([this.u, other], `{0} ${operand} {1}`, FUNCS[operand]);
+        const v = new ComputedScalarField([this.v, other], `{0} ${operand} {1}`, FUNCS[operand]);
+        return new ComputedVectorField(u, v, { relative_to: this.relative_to });
+    }
+    operandVector(other, operand) {
+        const FUNCS = {
+            '+': (a, b) => a + b,
+            '-': (a, b) => a - b,
         };
-        return { u: u_image, v: v_image };
+        const u = new ComputedScalarField([this.u, other.u], `{0} ${operand} {1}`, FUNCS[operand]);
+        const v = new ComputedScalarField([this.v, other.v], `{0} ${operand} {1}`, FUNCS[operand]);
+        return new ComputedVectorField(u, v, { relative_to: this.relative_to });
+    }
+    /**
+     * Multiply this vector field by a scalar. The multiplication occurs on the GPU if the resulting field is used in a plot component.
+     * @param other - Scalar to multiply by. Can be either a number or a scalar field.
+     * @returns A `ComputedVectorField` representing the multiplied vector field
+     */
+    multiply(other) {
+        return this.operandScalar(other, '*');
+    }
+    /**
+     * Divide this vector field by a scalar. The division occurs on the GPU if the resulting field is used in a plot component.
+     * @param other - Scalar to divide by. Can be either a number or a scalar field.
+     * @returns A `ComputedVectorField` representing the divided vector field
+     */
+    divide(other) {
+        return this.operandScalar(other, '/');
+    }
+    /**
+     * Add this vector field to another vector field. The addition occurs on the GPU if the resulting field is used in a plot component.
+     * @param other Vector field to add.
+     * @returns A `ComputedVectorField` representing the added vector field
+     */
+    add(other) {
+        return this.operandVector(other, '+');
+    }
+    /**
+     * Subtract another vector field from this vector field. The subtraction occurs on the GPU if the resulting field is used in a plot component.
+     * @param other Vector field to subtract.
+     * @returns A `ComputedVectorField` representing the subtracted vector field
+     */
+    subtract(other) {
+        return this.operandVector(other, '-');
+    }
+    /** @internal */
+    updateTexImageData(gl, image_mag_filter, fill_textures) {
+        const translateKeys = (map, component, reverse) => {
+            const map_trans = new Map();
+            const translator = reverse ? vectorComponentIdToScalarId : scalarIdToVectorComponentId;
+            map.forEach((value, key) => {
+                map_trans.set(translator(key, component), value);
+            });
+            return map_trans;
+        };
+        const tex_u = this.u.updateTexImageData(gl, image_mag_filter, fill_textures === null ? null : translateKeys(fill_textures.u, 'u', true));
+        const tex_v = this.v.updateTexImageData(gl, image_mag_filter, fill_textures === null ? null : translateKeys(fill_textures.v, 'v', true));
+        return { u: translateKeys(tex_u, 'u', false), v: translateKeys(tex_v, 'v', false) };
+    }
+    /**
+     * Get the magnitude of the vector field as a scalar field. The magnitude calculation occurs on the GPU if this field is used in a plot component.
+     * @returns A `ComputedScalarField` representing the subtracted vector field
+     */
+    magnitude() {
+        return new ComputedScalarField([this.u, this.v], 'length(vec2({0}, {1}))', Math.hypot);
     }
     /** @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 });
+        const thin_u = this.u.getThinnedField(thin_fac, map_max_zoom);
+        const thin_v = this.v.getThinnedField(thin_fac, map_max_zoom);
+        return new ComputedVectorField(thin_u, thin_v, { relative_to: this.relative_to });
     }
     /** @internal */
     get grid() {
         return this.u.grid;
     }
+    /**
+     * Sample this field at a given latitude and longitude.
+     * @param lon - Longitude of the sample in degrees east
+     * @param lat - Latitude of the sample in degrees north
+     * @returns A tuple containing the [`bearing`, `magnitude`] of the vector field at the nearest grid point. The bearing is given as degrees from north, increasing clockwise.
+     *  If the point is outside the grid, it returns [NaN, NaN] instead.
+     */
     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 u_sample = this.u.sampleFieldWithCoord(lon, lat);
+        const v_sample = this.v.sampleFieldWithCoord(lon, lat);
         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;
@@ -139,6 +438,54 @@ class RawVectorField {
             brg += 360;
         return [brg, mag];
     }
+    /** @internal */
+    getSamplerIds() {
+        return {
+            u: this.u.getSamplerIds().map(id => scalarIdToVectorComponentId(id, 'u')),
+            v: this.v.getSamplerIds().map(id => scalarIdToVectorComponentId(id, 'v')),
+        };
+    }
+    /** @internal */
+    getExpressions() {
+        const translateVariables = (expr, component) => {
+            const matches = expr.match(/_0[a-z]*/g);
+            if (matches === null)
+                throw `Field expression not found`;
+            matches.forEach(m => expr = expr.replace(m, scalarIdToVectorComponentId(m, component)));
+            return expr;
+        };
+        return {
+            u: translateVariables(this.u.getExpression(), 'u'),
+            v: translateVariables(this.v.getExpression(), 'v'),
+        };
+    }
+}
+/** A class representing a 2D gridded field of vectors */
+class RawVectorField extends ExpressionVectorField {
+    /**
+     * Create a vector field.
+     * @param grid - The grid on which the vector components are defined
+     * @param u_ary - The u (east/west) component of the vectors, which should be given as a 1D array in row-major order, with the first element being at the lower-left corner of the grid
+     * @param v_ary - The v (north/south) component of the vectors, which should be given as a 1D array in row-major order, with the first element being at the lower-left corner of the grid
+     * @param opts - Options for creating the vector field.
+     */
+    constructor(grid, u_ary, v_ary, opts) {
+        const u = new RawScalarField(grid, u_ary);
+        const v = new RawScalarField(grid, v_ary);
+        super(u, v, opts);
+        this.u_ary = u_ary;
+        this.v_ary = v_ary;
+    }
+    /** @internal */
+    getSamplerIds() {
+        return { u: ['_u0'], v: ['_v0'] };
+    }
+    /** @internal */
+    getExpressions() {
+        return { u: '_u0', v: '_v0' };
+    }
+}
+class ComputedVectorField extends ExpressionVectorField {
 }
 /** A class grid of wind profiles */
 class RawProfileField {
@@ -243,4 +590,4 @@ class RawObsField {
         return new RawVectorField(this.grid, u_data, v_data, { relative_to: 'earth' });
     }
 }
-export { RawScalarField, RawVectorField, RawProfileField, RawObsField };
+export { RawScalarField, ComputedScalarField, RawVectorField, ComputedVectorField, RawProfileField, RawObsField };

package/lib/StationPlot.d.ts

@@ -1,8 +1,9 @@
 import { RenderMethodArg, WebGLAnyRenderingContext } from "./AutumnTypes";
 import { MapLikeType } from "./Map";
 import { PlotComponent } from "./PlotComponent";
-import { Grid } from "./Grid";
+import { AutoZoomGrid } from "./grids/AutoZoom";
 import { RawObsField } from "./RawField";
+import { ColorMap } from "./Colormap";
 /**
  * Positions around the station plot at which to draw the various elements
  *
@@ -31,6 +32,11 @@ interface SPNumberConfig {
      * @default '#000000'
      */
     color?: string;
+    /**
+     * A colormap to use for coloring numeric values
+     * @default null
+     */
+    cmap?: ColorMap | null;
     /**
      * Whether to draw a halo (outline) around the number
      * @default true;
@@ -101,11 +107,11 @@ interface SPSymbolConfig {
      * The color to use to draw the symbol
      * @default '#000000'
      */
-    color?: string;
+    color?: string | ((symbol: SPSymbol | null, category: SPSymbolCategory) => string);
     /**
- * Whether to draw a halo (outline) around the string
- * @default true;
- */
+     * Whether to draw a halo (outline) around the string
+     * @default true;
+     */
     halo?: boolean;
     /**
      * The color to use for the halo (outline)
@@ -156,8 +162,18 @@ interface StationPlotOptions<ObsFieldName extends string> {
      */
     font_url_template?: string;
 }
+type SPSymbolCategory = 'freezing_rain' | 'sleet' | 'snow' | 'rain' | 'blowing_dust' | 'thunder' | 'fog' | 'none';
 /**
  * Station model plots for observed data
+ *
+ * ## Grid Compatibility
+ * - :white_check_mark: `PlateCarreeGrid`
+ * - :white_check_mark: `PlateCarreeRotatedGrid`
+ * - :white_check_mark: `LambertGrid`
+ * - :white_check_mark: `UnstructuredGrid`
+ * - :x:                `RadarSweepGrid`
+ * - :x:                `Geostationary`
+ *
  * @example
  * // Specify how to set up the station plot
  * const station_plot_locs = {
@@ -171,7 +187,7 @@ interface StationPlotOptions<ObsFieldName extends string> {
  * // 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> {
+declare class StationPlot<GridType extends AutoZoomGrid, MapType extends MapLikeType, ObsFieldName extends string> extends PlotComponent<MapType> {
     private field;
     readonly opts: Required<StationPlotOptions<ObsFieldName>>;
     private gl_elems;