autumnplot-gl 2.1.0 → 2.2.1

package/lib/RawField.d.ts

@@ -1,36 +1,29 @@
-import { WebGLAnyRenderingContext, WindProfile } from "./AutumnTypes";
+import { Float16Array } from "@petamoriken/float16";
+import { TypedArray, WebGLAnyRenderingContext, WindProfile } from "./AutumnTypes";
 import { WGLBuffer } from "autumn-wgl";
-declare class Cache<A extends unknown[], R> {
-    cached_value: R | null;
-    compute_value: (...args: A) => R;
-    constructor(compute_value: (...args: A) => R);
-    getValue(...args: A): R;
-}
-interface Coords {
+interface EarthCoords {
     lons: Float32Array;
     lats: Float32Array;
 }
-type GridType = 'latlon' | 'lcc';
+interface GridCoords {
+    x: Float32Array;
+    y: Float32Array;
+}
+type GridType = 'latlon' | 'latlonrot' | 'lcc';
 declare abstract class Grid {
     readonly type: GridType;
     readonly ni: number;
     readonly nj: number;
     readonly is_conformal: boolean;
-    readonly _buffer_cache: Cache<[WebGLAnyRenderingContext], Promise<{
-        'vertices': WGLBuffer;
-        'texcoords': WGLBuffer;
-        'cellsize': WGLBuffer;
-    }>>;
-    readonly _billboard_buffer_cache: Cache<[WebGLAnyRenderingContext, number, number], Promise<{
-        'vertices': WGLBuffer;
-        'texcoords': WGLBuffer;
-    }>>;
+    private readonly buffer_cache;
+    private readonly billboard_buffer_cache;
     constructor(type: GridType, is_conformal: boolean, ni: number, nj: number);
     abstract copy(opts?: {
         ni?: number;
         nj?: number;
     }): Grid;
-    abstract getCoords(): Coords;
+    abstract getEarthCoords(): EarthCoords;
+    abstract getGridCoords(): GridCoords;
     abstract transform(x: number, y: number, opts?: {
         inverse?: boolean;
     }): [number, number];
@@ -51,8 +44,8 @@ declare class PlateCarreeGrid extends Grid {
     readonly ll_lat: number;
     readonly ur_lon: number;
     readonly ur_lat: number;
-    /** @private */
-    readonly _ll_cache: Cache<[], Coords>;
+    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
@@ -74,12 +67,56 @@ declare class PlateCarreeGrid extends Grid {
     /**
      * Get a list of longitudes and latitudes on the grid (internal method)
      */
-    getCoords(): Coords;
+    getEarthCoords(): EarthCoords;
+    getGridCoords(): GridCoords;
     transform(x: number, y: number, opts?: {
         inverse?: boolean;
     }): [number, number];
     getThinnedGrid(thin_x: number, thin_y: number): PlateCarreeGrid;
 }
+/** A rotated lat-lon (plate carree) grid with uniform grid spacing */
+declare class PlateCarreeRotatedGrid extends Grid {
+    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);
+    copy(opts?: {
+        ni?: number;
+        nj?: number;
+        ll_lon?: number;
+        ll_lat?: number;
+        ur_lon?: number;
+        ur_lat?: number;
+    }): PlateCarreeRotatedGrid;
+    /**
+     * Get a list of longitudes and latitudes on the grid (internal method)
+     */
+    getEarthCoords(): EarthCoords;
+    getGridCoords(): GridCoords;
+    transform(x: number, y: number, opts?: {
+        inverse?: boolean;
+    }): [number, number];
+    getThinnedGrid(thin_x: number, thin_y: number): PlateCarreeRotatedGrid;
+}
 /** A Lambert conformal conic grid with uniform grid spacing */
 declare class LambertGrid extends Grid {
     readonly lon_0: number;
@@ -89,12 +126,9 @@ declare class LambertGrid extends Grid {
     readonly ll_y: number;
     readonly ur_x: number;
     readonly ur_y: number;
-    /** @private */
-    readonly lcc: (a: number, b: number, opts?: {
-        inverse: boolean;
-    }) => [number, number];
-    /** @private */
-    readonly _ll_cache: Cache<[], Coords>;
+    private readonly lcc;
+    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
@@ -119,23 +153,28 @@ declare class LambertGrid extends Grid {
     /**
      * Get a list of longitudes and latitudes on the grid (internal method)
      */
-    getCoords(): Coords;
+    getEarthCoords(): EarthCoords;
+    getGridCoords(): GridCoords;
     transform(x: number, y: number, opts?: {
         inverse?: boolean;
     }): [number, number];
     getThinnedGrid(thin_x: number, thin_y: number): LambertGrid;
 }
+type TextureDataType<ArrayType> = ArrayType extends Float32Array ? Float32Array : Uint16Array;
 /** A class representing a raw 2D field of gridded data, such as height or u wind. */
-declare class RawScalarField {
+declare class RawScalarField<ArrayType extends TypedArray> {
     readonly grid: Grid;
-    readonly data: Float32Array;
+    readonly data: ArrayType;
     /**
      * 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: Grid, data: Float32Array);
-    getThinnedField(thin_x: number, thin_y: number): RawScalarField;
+    constructor(grid: Grid, data: ArrayType);
+    /** @internal */
+    getTextureData(): TextureDataType<ArrayType>;
+    isFloat16(): boolean;
+    getThinnedField(thin_x: number, thin_y: number): RawScalarField<ArrayType>;
     /**
      * Create a new field by aggregating a number of fields using a specific function
      * @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.
@@ -145,7 +184,7 @@ declare class RawScalarField {
      * // Compute wind speed from u and v
      * wind_speed_field = RawScalarField.aggreateFields(Math.hypot, u_field, v_field);
      */
-    static aggregateFields(func: (...args: number[]) => number, ...args: RawScalarField[]): RawScalarField;
+    static aggregateFields<ArrayType extends TypedArray>(func: (...args: number[]) => number, ...args: RawScalarField<ArrayType>[]): RawScalarField<ArrayType>;
 }
 type VectorRelativeTo = 'earth' | 'grid';
 interface RawVectorFieldOptions {
@@ -156,15 +195,11 @@ interface RawVectorFieldOptions {
     relative_to?: VectorRelativeTo;
 }
 /** A class representing a 2D gridded field of vectors */
-declare class RawVectorField {
-    readonly u: RawScalarField;
-    readonly v: RawScalarField;
+declare class RawVectorField<ArrayType extends TypedArray> {
+    readonly u: RawScalarField<ArrayType>;
+    readonly v: RawScalarField<ArrayType>;
     readonly relative_to: VectorRelativeTo;
-    /** @private */
-    readonly _rotate_cache: Cache<[], {
-        u: RawScalarField;
-        v: RawScalarField;
-    }>;
+    private readonly rotate_cache;
     /**
      * Create a vector field.
      * @param grid - The grid on which the vector components are defined
@@ -172,10 +207,10 @@ declare class RawVectorField {
      * @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.
      */
-    constructor(grid: Grid, u: Float32Array, v: Float32Array, opts?: RawVectorFieldOptions);
-    getThinnedField(thin_x: number, thin_y: number): RawVectorField;
+    constructor(grid: Grid, u: ArrayType, v: ArrayType, opts?: RawVectorFieldOptions);
+    getThinnedField(thin_x: number, thin_y: number): RawVectorField<ArrayType>;
     get grid(): Grid;
-    toEarthRelative(): RawVectorField;
+    toEarthRelative(): RawVectorField<ArrayType>;
 }
 /** A class grid of wind profiles */
 declare class RawProfileField {
@@ -188,7 +223,7 @@ declare class RawProfileField {
      */
     constructor(grid: Grid, profiles: WindProfile[]);
     /** Get the gridded storm motion vector field (internal method) */
-    getStormMotionGrid(): RawVectorField;
+    getStormMotionGrid(): RawVectorField<Float16Array>;
 }
-export { RawScalarField, RawVectorField, RawProfileField, PlateCarreeGrid, LambertGrid, Grid };
-export type { GridType, RawVectorFieldOptions, VectorRelativeTo };
+export { RawScalarField, RawVectorField, RawProfileField, PlateCarreeGrid, PlateCarreeRotatedGrid, LambertGrid, Grid };
+export type { GridType, RawVectorFieldOptions, VectorRelativeTo, TextureDataType };

package/lib/RawField.js

@@ -1,25 +1,14 @@
-import { lambertConformalConic } from "./Map";
+import { Float16Array } from "@petamoriken/float16";
+import { lambertConformalConic, rotateSphere } from "./Map";
 import { layer_worker } from "./PlotComponent";
-import { zip } from "./utils";
+import { Cache, zip } from "./utils";
 import { WGLBuffer } from "autumn-wgl";
-class Cache {
-    constructor(compute_value) {
-        this.cached_value = null;
-        this.compute_value = compute_value;
-    }
-    getValue(...args) {
-        if (this.cached_value === null) {
-            this.cached_value = this.compute_value(...args);
-        }
-        return this.cached_value;
-    }
-}
 async function makeWGLDomainBuffers(gl, grid, native_grid) {
     native_grid = native_grid !== undefined ? native_grid : grid;
     const texcoord_margin_r = 1 / (2 * native_grid.ni);
     const texcoord_margin_s = 1 / (2 * native_grid.nj);
     const grid_cell_size_multiplier = (grid.ni * grid.nj) / (native_grid.ni * native_grid.nj);
-    const { lats: field_lats, lons: field_lons } = grid.getCoords();
+    const { lats: field_lats, lons: field_lons } = grid.getEarthCoords();
     const domain_coords = await layer_worker.makeDomainVerticesAndTexCoords(field_lats, field_lons, grid.ni, grid.nj, texcoord_margin_r, texcoord_margin_s);
     for (let icd = 0; icd < domain_coords['grid_cell_size'].length; icd++) {
         domain_coords['grid_cell_size'][icd] *= grid_cell_size_multiplier;
@@ -30,7 +19,7 @@ async function makeWGLDomainBuffers(gl, grid, native_grid) {
     return { 'vertices': vertices, 'texcoords': texcoords, 'cellsize': grid_cell_size };
 }
 async function makeWGLBillboardBuffers(gl, grid, thin_fac, max_zoom) {
-    const { lats: field_lats, lons: field_lons } = grid.getCoords();
+    const { lats: field_lats, lons: field_lons } = grid.getEarthCoords();
     const bb_elements = await layer_worker.makeBBElements(field_lats, field_lons, grid.ni, grid.nj, thin_fac, max_zoom);
     const vertices = new WGLBuffer(gl, bb_elements['pts'], 3, gl.TRIANGLE_STRIP);
     const texcoords = new WGLBuffer(gl, bb_elements['tex_coords'], 2, gl.TRIANGLE_STRIP);
@@ -42,20 +31,20 @@ class Grid {
         this.is_conformal = is_conformal;
         this.ni = ni;
         this.nj = nj;
-        this._buffer_cache = new Cache((gl) => {
+        this.buffer_cache = new Cache((gl) => {
             const new_ni = Math.max(Math.floor(this.ni / 50), 20);
             const new_nj = Math.max(Math.floor(this.nj / 50), 20);
             return makeWGLDomainBuffers(gl, this.copy({ ni: new_ni, nj: new_nj }), this);
         });
-        this._billboard_buffer_cache = new Cache((gl, thin_fac, max_zoom) => {
+        this.billboard_buffer_cache = new Cache((gl, thin_fac, max_zoom) => {
             return makeWGLBillboardBuffers(gl, this, thin_fac, max_zoom);
         });
     }
     async getWGLBuffers(gl) {
-        return await this._buffer_cache.getValue(gl);
+        return await this.buffer_cache.getValue(gl);
     }
     async getWGLBillboardBuffers(gl, thin_fac, max_zoom) {
-        return await this._billboard_buffer_cache.getValue(gl, thin_fac, max_zoom);
+        return await this.billboard_buffer_cache.getValue(gl, thin_fac, max_zoom);
     }
 }
 /** A plate carree (a.k.a. lat/lon) grid with uniform grid spacing */
@@ -75,9 +64,9 @@ class PlateCarreeGrid extends Grid {
         this.ll_lat = ll_lat;
         this.ur_lon = ur_lon;
         this.ur_lat = ur_lat;
-        this._ll_cache = new Cache(() => {
-            const dlon = (this.ur_lon - this.ll_lon) / (this.ni - 1);
-            const dlat = (this.ur_lat - this.ll_lat) / (this.nj - 1);
+        const dlon = (this.ur_lon - this.ll_lon) / (this.ni - 1);
+        const dlat = (this.ur_lat - this.ll_lat) / (this.nj - 1);
+        this.ll_cache = new Cache(() => {
             const lons = new Float32Array(this.ni * this.nj);
             const lats = new Float32Array(this.ni * this.nj);
             for (let i = 0; i < this.ni; i++) {
@@ -89,6 +78,17 @@ class PlateCarreeGrid extends Grid {
             }
             return { 'lons': lons, 'lats': lats };
         });
+        this.gc_cache = new Cache(() => {
+            const x = new Float32Array(this.ni);
+            const y = new Float32Array(this.nj);
+            for (let i = 0; i < this.ni; i++) {
+                x[i] = this.ll_lon + i * dlon;
+            }
+            for (let j = 0; j < this.nj; j++) {
+                y[j] = this.ll_lat + j * dlat;
+            }
+            return { x: x, y: y };
+        });
     }
     copy(opts) {
         opts = opts !== undefined ? opts : {};
@@ -103,8 +103,11 @@ class PlateCarreeGrid extends Grid {
     /**
      * Get a list of longitudes and latitudes on the grid (internal method)
      */
-    getCoords() {
-        return this._ll_cache.getValue();
+    getEarthCoords() {
+        return this.ll_cache.getValue();
+    }
+    getGridCoords() {
+        return this.gc_cache.getValue();
     }
     transform(x, y, opts) {
         return [x, y];
@@ -123,6 +126,97 @@ class PlateCarreeGrid extends Grid {
         return new PlateCarreeGrid(ni, nj, ll_lon, ll_lat, ur_lon, ur_lat);
     }
 }
+/** A rotated lat-lon (plate carree) grid with uniform grid spacing */
+class PlateCarreeRotatedGrid extends Grid {
+    /**
+     * 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, nj, np_lon, np_lat, lon_shift, ll_lon, ll_lat, ur_lon, ur_lat) {
+        super('latlonrot', true, ni, nj);
+        this.np_lon = np_lon;
+        this.np_lat = np_lat;
+        this.lon_shift = lon_shift;
+        this.ll_lon = ll_lon;
+        this.ll_lat = ll_lat;
+        this.ur_lon = ur_lon;
+        this.ur_lat = ur_lat;
+        this.llrot = rotateSphere({ np_lon: np_lon, np_lat: np_lat, lon_shift: lon_shift });
+        const dlon = (this.ur_lon - this.ll_lon) / (this.ni - 1);
+        const dlat = (this.ur_lat - this.ll_lat) / (this.nj - 1);
+        this.ll_cache = new Cache(() => {
+            const lons = new Float32Array(this.ni * this.nj);
+            const lats = new Float32Array(this.ni * this.nj);
+            for (let i = 0; i < this.ni; i++) {
+                const lon_p = this.ll_lon + i * dlon;
+                for (let j = 0; j < this.nj; j++) {
+                    const lat_p = this.ll_lat + j * dlat;
+                    const [lon, lat] = this.llrot(lon_p, lat_p);
+                    const idx = i + j * this.ni;
+                    lons[idx] = lon;
+                    lats[idx] = lat;
+                }
+            }
+            return { lons: lons, lats: lats };
+        });
+        this.gc_cache = new Cache(() => {
+            const x = new Float32Array(this.ni);
+            const y = new Float32Array(this.nj);
+            for (let i = 0; i < this.ni; i++) {
+                x[i] = this.ll_lon + i * dlon;
+            }
+            for (let j = 0; j < this.nj; j++) {
+                y[j] = this.ll_lat + j * dlat;
+            }
+            return { x: x, y: y };
+        });
+    }
+    copy(opts) {
+        opts = opts !== undefined ? opts : {};
+        const ni = opts.ni !== undefined ? opts.ni : this.ni;
+        const nj = opts.nj !== undefined ? opts.nj : this.nj;
+        const ll_lon = opts.ll_lon !== undefined ? opts.ll_lon : this.ll_lon;
+        const ll_lat = opts.ll_lat !== undefined ? opts.ll_lat : this.ll_lat;
+        const ur_lon = opts.ur_lon !== undefined ? opts.ur_lon : this.ur_lon;
+        const ur_lat = opts.ur_lat !== undefined ? opts.ur_lat : this.ur_lat;
+        return new PlateCarreeRotatedGrid(ni, nj, this.np_lon, this.np_lat, this.lon_shift, ll_lon, ll_lat, ur_lon, ur_lat);
+    }
+    /**
+     * Get a list of longitudes and latitudes on the grid (internal method)
+     */
+    getEarthCoords() {
+        return this.ll_cache.getValue();
+    }
+    getGridCoords() {
+        return this.gc_cache.getValue();
+    }
+    transform(x, y, opts) {
+        opts = opts === undefined ? {} : opts;
+        const inverse = 'inverse' in opts ? opts.inverse : false;
+        return this.llrot(x, y, { inverse: !inverse });
+    }
+    getThinnedGrid(thin_x, thin_y) {
+        const dlon = (this.ur_lon - this.ll_lon) / this.ni;
+        const dlat = (this.ur_lat - this.ll_lat) / this.nj;
+        const ni = Math.ceil(this.ni / thin_x);
+        const nj = Math.ceil(this.nj / thin_y);
+        const ni_remove = (this.ni - 1) % thin_x;
+        const nj_remove = (this.nj - 1) % thin_y;
+        const ll_lon = this.ll_lon;
+        const ll_lat = this.ll_lat;
+        const ur_lon = this.ur_lon - ni_remove * dlon;
+        const ur_lat = this.ur_lat - nj_remove * dlat;
+        return new PlateCarreeRotatedGrid(ni, nj, this.np_lon, this.np_lat, this.lon_shift, ll_lon, ll_lat, ur_lon, ur_lat);
+    }
+}
 /** A Lambert conformal conic grid with uniform grid spacing */
 class LambertGrid extends Grid {
     /**
@@ -147,13 +241,15 @@ class LambertGrid extends Grid {
         this.ur_x = ur_x;
         this.ur_y = ur_y;
         this.lcc = lambertConformalConic({ lon_0: lon_0, lat_0: lat_0, lat_std: lat_std });
-        this._ll_cache = new Cache(() => {
+        const dx = (this.ur_x - this.ll_x) / (this.ni - 1);
+        const dy = (this.ur_y - this.ll_y) / (this.nj - 1);
+        this.ll_cache = new Cache(() => {
             const lons = new Float32Array(this.ni * this.nj);
             const lats = new Float32Array(this.ni * this.nj);
             for (let i = 0; i < this.ni; i++) {
-                const x = this.ll_x + (this.ur_x - this.ll_x) * i / (this.ni - 1);
+                const x = this.ll_x + i * dx;
                 for (let j = 0; j < this.nj; j++) {
-                    const y = this.ll_y + (this.ur_y - this.ll_y) * j / (this.nj - 1);
+                    const y = this.ll_y + j * dy;
                     const [lon, lat] = this.lcc(x, y, { inverse: true });
                     const idx = i + j * this.ni;
                     lons[idx] = lon;
@@ -162,6 +258,17 @@ class LambertGrid extends Grid {
             }
             return { lons: lons, lats: lats };
         });
+        this.gc_cache = new Cache(() => {
+            const x = new Float32Array(this.ni);
+            const y = new Float32Array(this.nj);
+            for (let i = 0; i < this.ni; i++) {
+                x[i] = this.ll_x + i * dx;
+            }
+            for (let j = 0; j < this.nj; j++) {
+                y[j] = this.ll_y + j * dy;
+            }
+            return { x: x, y: y };
+        });
     }
     copy(opts) {
         opts = opts !== undefined ? opts : {};
@@ -176,8 +283,11 @@ class LambertGrid extends Grid {
     /**
      * Get a list of longitudes and latitudes on the grid (internal method)
      */
-    getCoords() {
-        return this._ll_cache.getValue();
+    getEarthCoords() {
+        return this.ll_cache.getValue();
+    }
+    getGridCoords() {
+        return this.gc_cache.getValue();
     }
     transform(x, y, opts) {
         opts = opts === undefined ? {} : opts;
@@ -198,6 +308,9 @@ class LambertGrid extends Grid {
         return new LambertGrid(ni, nj, this.lon_0, this.lat_0, this.lat_std, ll_x, ll_y, ur_x, ur_y);
     }
 }
+function getArrayConstructor(ary) {
+    return ary.constructor;
+}
 /** A class representing a raw 2D field of gridded data, such as height or u wind. */
 class RawScalarField {
     /**
@@ -212,9 +325,25 @@ class RawScalarField {
             throw `Data size (${data.length}) doesn't match the grid dimensions (${grid.ni} x ${grid.nj}; expected ${grid.ni * grid.nj} points)`;
         }
     }
+    /** @internal */
+    getTextureData() {
+        // Need to give float16 data as uint16s to make WebGL happy: https://github.com/petamoriken/float16/issues/105
+        let data;
+        if (this.data instanceof Float32Array) {
+            data = this.data;
+        }
+        else {
+            data = new Uint16Array(this.data.buffer);
+        }
+        return data;
+    }
+    isFloat16() {
+        return !(this.data instanceof Float32Array);
+    }
     getThinnedField(thin_x, thin_y) {
+        const arrayType = getArrayConstructor(this.data);
         const new_grid = this.grid.getThinnedGrid(thin_x, thin_y);
-        const new_data = new Float32Array(new_grid.ni * new_grid.nj);
+        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;
@@ -239,8 +368,9 @@ class RawScalarField {
                 yield func(elem);
             }
         }
+        const arrayType = getArrayConstructor(args[0].data);
         const zipped_args = zip(...args.map(a => a.data));
-        const agg_data = new Float32Array(mapGenerator(zipped_args, (a) => func(...a)));
+        const agg_data = new arrayType(mapGenerator(zipped_args, (a) => func(...a)));
         return new RawScalarField(args[0].grid, agg_data);
     }
 }
@@ -255,19 +385,25 @@ class RawVectorField {
      */
     constructor(grid, u, v, opts) {
         opts = opts === undefined ? {} : opts;
+        const arrayType = getArrayConstructor(u);
         this.u = new RawScalarField(grid, u);
         this.v = new RawScalarField(grid, v);
         this.relative_to = opts.relative_to === undefined ? 'grid' : opts.relative_to;
-        this._rotate_cache = new Cache(() => {
+        this.rotate_cache = new Cache(() => {
             const grid = this.u.grid;
-            const coords = grid.getCoords();
-            const u_rot = new Float32Array(coords.lats.length);
-            const v_rot = new Float32Array(coords.lats.length);
+            const coords = grid.getEarthCoords();
+            const u_rot = new arrayType(coords.lats.length);
+            const v_rot = new arrayType(coords.lats.length);
             for (let icd = 0; icd < coords.lats.length; icd++) {
                 const lon = coords.lons[icd];
                 const lat = coords.lats[icd];
                 const u = this.u.data[icd];
                 const v = this.v.data[icd];
+                if (Math.abs(u) < 1e-6 && Math.abs(v) < 1e-6) {
+                    u_rot[icd] = 0;
+                    v_rot[icd] = 0;
+                    continue;
+                }
                 const [x, y] = grid.transform(lon, lat);
                 const [x_pertlon, y_pertlon] = grid.transform(lon + 0.01, lat);
                 const mag_pertlon = Math.hypot(x - x_pertlon, y - y_pertlon);
@@ -307,7 +443,7 @@ class RawVectorField {
             v = this.v;
         }
         else {
-            const { u: u_, v: v_ } = this._rotate_cache.getValue();
+            const { u: u_, v: v_ } = this.rotate_cache.getValue();
             u = u_;
             v = v_;
         }
@@ -327,8 +463,8 @@ class RawProfileField {
     }
     /** Get the gridded storm motion vector field (internal method) */
     getStormMotionGrid() {
-        const u = new Float32Array(this.grid.ni * this.grid.nj);
-        const v = new Float32Array(this.grid.ni * this.grid.nj);
+        const u = new Float16Array(this.grid.ni * this.grid.nj);
+        const v = new Float16Array(this.grid.ni * this.grid.nj);
         this.profiles.forEach(prof => {
             const idx = prof.ilon + this.grid.ni * prof.jlat;
             u[idx] = prof.smu;
@@ -337,4 +473,4 @@ class RawProfileField {
         return new RawVectorField(this.grid, u, v, { relative_to: 'grid' });
     }
 }
-export { RawScalarField, RawVectorField, RawProfileField, PlateCarreeGrid, LambertGrid, Grid };
+export { RawScalarField, RawVectorField, RawProfileField, PlateCarreeGrid, PlateCarreeRotatedGrid, LambertGrid, Grid };

package/lib/index.d.ts

@@ -5,11 +5,11 @@ import Barbs, { BarbsOptions } from "./Barbs";
 import Paintball, { PaintballOptions } from "./Paintball";
 import Hodographs, { HodographOptions } from './Hodographs';
 import { PlotLayer, MultiPlotLayer } from './PlotLayer';
-import { WindProfile, WebGLAnyRenderingContext } from "./AutumnTypes";
+import { WindProfile, WebGLAnyRenderingContext, TypedArray } from "./AutumnTypes";
 import { MapType } from "./Map";
 import { ColorMap, Color } from './Colormap';
 import { makeColorBar, makePaintballKey, ColorbarOrientation, ColorbarTickDirection, ColorBarOptions, PaintballKeyOptions } from "./ColorBar";
-import { RawScalarField, RawVectorField, RawProfileField, Grid, GridType, VectorRelativeTo, RawVectorFieldOptions, PlateCarreeGrid, LambertGrid } from "./RawField";
+import { RawScalarField, RawVectorField, RawProfileField, Grid, GridType, VectorRelativeTo, RawVectorFieldOptions, PlateCarreeGrid, PlateCarreeRotatedGrid, LambertGrid } from "./RawField";
 declare const colormaps: {
     bluered: (level_min: number, level_max: number, n_colors: number) => ColorMap;
     redblue: (level_min: number, level_max: number, n_colors: number) => ColorMap;
@@ -20,4 +20,4 @@ declare const colormaps: {
     pw_td2m: ColorMap;
     nws_storm_clear_refl: ColorMap;
 };
-export { PlotComponent, Barbs, BarbsOptions, Contour, ContourOptions, ContourFill, Raster, ContourFillOptions, RasterOptions, Paintball, PaintballOptions, Hodographs, HodographOptions, WindProfile, PlotLayer, MultiPlotLayer, MapType, ColorMap, colormaps, makeColorBar, makePaintballKey, Color, ColorbarOrientation, ColorbarTickDirection, ColorBarOptions, PaintballKeyOptions, RawScalarField, RawVectorField, RawProfileField, Grid, GridType, VectorRelativeTo, RawVectorFieldOptions, PlateCarreeGrid, LambertGrid, WebGLAnyRenderingContext };
+export { PlotComponent, Barbs, BarbsOptions, Contour, ContourOptions, ContourFill, Raster, ContourFillOptions, RasterOptions, Paintball, PaintballOptions, Hodographs, HodographOptions, WindProfile, PlotLayer, MultiPlotLayer, MapType, ColorMap, colormaps, makeColorBar, makePaintballKey, Color, ColorbarOrientation, ColorbarTickDirection, ColorBarOptions, PaintballKeyOptions, RawScalarField, RawVectorField, RawProfileField, Grid, GridType, VectorRelativeTo, RawVectorFieldOptions, PlateCarreeGrid, PlateCarreeRotatedGrid, LambertGrid, WebGLAnyRenderingContext, TypedArray };

package/lib/index.js

@@ -7,7 +7,7 @@ import Hodographs from './Hodographs';
 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 { makeColorBar, makePaintballKey } from "./ColorBar";
-import { RawScalarField, RawVectorField, RawProfileField, Grid, PlateCarreeGrid, LambertGrid } from "./RawField";
+import { RawScalarField, RawVectorField, RawProfileField, Grid, PlateCarreeGrid, PlateCarreeRotatedGrid, LambertGrid } from "./RawField";
 const colormaps = {
     bluered: bluered,
     redblue: redblue,
@@ -18,4 +18,4 @@ const colormaps = {
     pw_td2m: pw_td2m,
     nws_storm_clear_refl: nws_storm_clear_refl,
 };
-export { PlotComponent, Barbs, Contour, ContourFill, Raster, Paintball, Hodographs, PlotLayer, MultiPlotLayer, ColorMap, colormaps, makeColorBar, makePaintballKey, RawScalarField, RawVectorField, RawProfileField, Grid, PlateCarreeGrid, LambertGrid };
+export { PlotComponent, Barbs, Contour, ContourFill, Raster, Paintball, Hodographs, PlotLayer, MultiPlotLayer, ColorMap, colormaps, makeColorBar, makePaintballKey, RawScalarField, RawVectorField, RawProfileField, Grid, PlateCarreeGrid, PlateCarreeRotatedGrid, LambertGrid };

package/lib/utils.d.ts

@@ -6,4 +6,11 @@ declare const rgb2hsv: (rgb: [number, number, number]) => [number, number, numbe
 declare const hsv2rgb: (hsv: [number, number, number]) => [number, number, number];
 declare function getMinZoom(jlat: number, ilon: number, thin_fac_base: number): number;
 declare function zip(...args: any[]): Generator<any[], void, unknown>;
-export { hex2rgba, rgba2hex, hex2rgb, rgb2hex, rgb2hsv, hsv2rgb, zip, getMinZoom };
+declare function getOS(): string;
+declare class Cache<A extends unknown[], R> {
+    private cached_value;
+    private readonly compute_value;
+    constructor(compute_value: (...args: A) => R);
+    getValue(...args: A): R;
+}
+export { hex2rgba, rgba2hex, hex2rgb, rgb2hex, rgb2hsv, hsv2rgb, zip, getMinZoom, getOS, Cache };

package/lib/utils.js

@@ -100,4 +100,36 @@ function* zip(...args) {
         yield current.map(x => x.value);
     }
 }
-export { hex2rgba, rgba2hex, hex2rgb, rgb2hex, rgb2hsv, hsv2rgb, zip, getMinZoom };
+function getOS() {
+    const userAgent = window.navigator.userAgent, platform = window.navigator.platform, macosPlatforms = ['Macintosh', 'MacIntel', 'MacPPC', 'Mac68K'], windowsPlatforms = ['Win32', 'Win64', 'Windows', 'WinCE'], iosPlatforms = ['iPhone', 'iPad', 'iPod'];
+    let os = null;
+    if (macosPlatforms.indexOf(platform) !== -1 && navigator.maxTouchPoints <= 1) {
+        os = 'Mac OS';
+    }
+    else if (iosPlatforms.indexOf(platform) !== -1 || (macosPlatforms.indexOf(platform) !== -1 && navigator.maxTouchPoints > 1)) {
+        os = 'iOS';
+    }
+    else if (windowsPlatforms.indexOf(platform) !== -1) {
+        os = 'Windows';
+    }
+    else if (/Android/.test(userAgent)) {
+        os = 'Android';
+    }
+    else if (/Linux/.test(platform)) {
+        os = 'Linux';
+    }
+    return os;
+}
+class Cache {
+    constructor(compute_value) {
+        this.cached_value = null;
+        this.compute_value = compute_value;
+    }
+    getValue(...args) {
+        if (this.cached_value === null) {
+            this.cached_value = this.compute_value(...args);
+        }
+        return this.cached_value;
+    }
+}
+export { hex2rgba, rgba2hex, hex2rgb, rgb2hex, rgb2hsv, hsv2rgb, zip, getMinZoom, getOS, Cache };