autumnplot-gl 4.0.0-beta → 4.1.0

package/lib/grids/LambertGrid.d.ts

@@ -0,0 +1,73 @@
+import { StructuredGrid } from "./StructuredGrid";
+declare const LambertGrid_base: import("./Grid").AbstractConstructor<import("./AutoZoom").AutoZoomGridIntf> & import("./Grid").AbstractConstructor<import("./GridCoordinates").GridCoordinateIntf> & typeof StructuredGrid;
+/**
+ * A Lambert conformal conic grid with uniform grid spacing
+ *
+ * ## Plot Component Compatibility
+ * - :white_check_mark: `Fill`
+ * - :white_check_mark: `Raster`
+ * - :white_check_mark: `Contour`
+ * - :white_check_mark: `Paintball`
+ * - :white_check_mark: `Barbs`
+ * - :white_check_mark: `Hodographs`
+ * - :white_check_mark: `StationPlot`
+ */
+declare class LambertGrid extends LambertGrid_base {
+    readonly lon_0: number;
+    readonly lat_0: number;
+    readonly lat_std: [number, number];
+    readonly ll_x: number;
+    readonly ll_y: number;
+    readonly ur_x: number;
+    readonly ur_y: number;
+    readonly a: number;
+    readonly b: number;
+    private readonly lcc;
+    /**
+     * Create a Lambert conformal conic grid from the lower-left and upper-right corner x/y values.
+     * @param ni      - The number of grid points in the i (longitude) direction
+     * @param nj      - The number of grid points in the j (latitude) direction
+     * @param lon_0   - The standard longitude for the projection; this is also the center longitude for the projection
+     * @param lat_0   - The center latitude for the projection
+     * @param lat_std - The standard latitudes for the projection
+     * @param ll_x    - The x coordinate in projection space of the lower-left corner of the grid
+     * @param ll_y    - The y coordinate in projection space of the lower-left corner of the grid
+     * @param ur_x    - The x coordinate in projection space of the upper-right corner of the grid
+     * @param ur_y    - The y coordinate in projection space of the upper-right corner of the grid
+     * @param a       - The semimajor axis of the assumed shape of Earth in meters
+     * @param b       - The semiminor axis of the assumed shape of Earth in meters
+     */
+    constructor(ni: number, nj: number, lon_0: number, lat_0: number, lat_std: [number, number], ll_x: number, ll_y: number, ur_x: number, ur_y: number, a?: number, b?: number, thin_x?: number, thin_y?: number);
+    /**
+     * Create a Lambert conformal conic grid from the lower-left grid point coordinate and a dx and dy.
+     * @param ni      - The number of grid points in the i (longitude) direction
+     * @param nj      - The number of grid points in the j (latitude) direction
+     * @param lon_0   - The standard longitude for the projection; this is also the center longitude for the projection
+     * @param lat_0   - The center latitude for the projection
+     * @param lat_std - The standard latitudes for the projection
+     * @param ll_lon  - The longitude of the lower-left corner of the grid
+     * @param ll_lat  - The latitude of the lower-left corner of the grid
+     * @param dx      - The grid dx in meters
+     * @param dy      - The grid dy in meters
+     * @param a       - The semimajor axis of the assumed shape of Earth in meters
+     * @param b       - The semiminor axis of the assumed shape of Earth in meters
+     * @returns
+     */
+    static fromLLCornerLonLat(ni: number, nj: number, lon_0: number, lat_0: number, lat_std: [number, number], ll_lon: number, ll_lat: number, dx: number, dy: number, a?: number, b?: number): LambertGrid;
+    /** @internal */
+    copy(opts?: {
+        ni?: number;
+        nj?: number;
+        ll_x?: number;
+        ll_y?: number;
+        ur_x?: number;
+        ur_y?: number;
+    }): LambertGrid;
+    /** @internal */
+    transform(x: number, y: number, opts?: {
+        inverse?: boolean;
+    }): [number, number];
+    /** @internal */
+    getThinnedGrid(thin_fac: number, map_max_zoom: number): this;
+}
+export { LambertGrid };

package/lib/grids/LambertGrid.js

@@ -0,0 +1,92 @@
+import { lambertConformalConic } from "../Map";
+import { autoZoomGridMixin } from "./AutoZoom";
+import { WGS84_SEMIMAJOR, WGS84_SEMIMINOR } from "./Grid";
+import { gridCoordinateMixin } from "./GridCoordinates";
+import { StructuredGrid } from "./StructuredGrid";
+/**
+ * A Lambert conformal conic grid with uniform grid spacing
+ *
+ * ## Plot Component Compatibility
+ * - :white_check_mark: `Fill`
+ * - :white_check_mark: `Raster`
+ * - :white_check_mark: `Contour`
+ * - :white_check_mark: `Paintball`
+ * - :white_check_mark: `Barbs`
+ * - :white_check_mark: `Hodographs`
+ * - :white_check_mark: `StationPlot`
+ */
+class LambertGrid extends autoZoomGridMixin(gridCoordinateMixin(StructuredGrid)) {
+    /**
+     * Create a Lambert conformal conic grid from the lower-left and upper-right corner x/y values.
+     * @param ni      - The number of grid points in the i (longitude) direction
+     * @param nj      - The number of grid points in the j (latitude) direction
+     * @param lon_0   - The standard longitude for the projection; this is also the center longitude for the projection
+     * @param lat_0   - The center latitude for the projection
+     * @param lat_std - The standard latitudes for the projection
+     * @param ll_x    - The x coordinate in projection space of the lower-left corner of the grid
+     * @param ll_y    - The y coordinate in projection space of the lower-left corner of the grid
+     * @param ur_x    - The x coordinate in projection space of the upper-right corner of the grid
+     * @param ur_y    - The y coordinate in projection space of the upper-right corner of the grid
+     * @param a       - The semimajor axis of the assumed shape of Earth in meters
+     * @param b       - The semiminor axis of the assumed shape of Earth in meters
+     */
+    constructor(ni, nj, lon_0, lat_0, lat_std, ll_x, ll_y, ur_x, ur_y, a, b, thin_x, thin_y) {
+        super('lcc', true, ni, nj, thin_x, thin_y);
+        this.lon_0 = lon_0;
+        this.lat_0 = lat_0;
+        this.lat_std = lat_std;
+        this.ll_x = ll_x;
+        this.ll_y = ll_y;
+        this.ur_x = ur_x;
+        this.ur_y = ur_y;
+        this.a = a === undefined ? WGS84_SEMIMAJOR : a;
+        this.b = b === undefined ? WGS84_SEMIMINOR : b;
+        this.lcc = lambertConformalConic({ lon_0: lon_0, lat_0: lat_0, lat_std: lat_std, a: this.a, b: this.b });
+        this.setupCoordinateCaches(ll_x, ur_x, ll_y, ur_y);
+    }
+    /**
+     * Create a Lambert conformal conic grid from the lower-left grid point coordinate and a dx and dy.
+     * @param ni      - The number of grid points in the i (longitude) direction
+     * @param nj      - The number of grid points in the j (latitude) direction
+     * @param lon_0   - The standard longitude for the projection; this is also the center longitude for the projection
+     * @param lat_0   - The center latitude for the projection
+     * @param lat_std - The standard latitudes for the projection
+     * @param ll_lon  - The longitude of the lower-left corner of the grid
+     * @param ll_lat  - The latitude of the lower-left corner of the grid
+     * @param dx      - The grid dx in meters
+     * @param dy      - The grid dy in meters
+     * @param a       - The semimajor axis of the assumed shape of Earth in meters
+     * @param b       - The semiminor axis of the assumed shape of Earth in meters
+     * @returns
+     */
+    static fromLLCornerLonLat(ni, nj, lon_0, lat_0, lat_std, ll_lon, ll_lat, dx, dy, a, b) {
+        a = a === undefined ? WGS84_SEMIMAJOR : a;
+        b = b === undefined ? WGS84_SEMIMINOR : b;
+        const lcc = lambertConformalConic({ lon_0: lon_0, lat_0: lat_0, lat_std: lat_std, a: a, b: b });
+        const [ll_x, ll_y] = lcc(ll_lon, ll_lat);
+        return new LambertGrid(ni, nj, lon_0, lat_0, lat_std, ll_x, ll_y, ll_x + ni * dx, ll_y + nj * dy, a, b);
+    }
+    /** @internal */
+    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_x = opts.ll_x !== undefined ? opts.ll_x : this.ll_x;
+        const ll_y = opts.ll_y !== undefined ? opts.ll_y : this.ll_y;
+        const ur_x = opts.ur_x !== undefined ? opts.ur_x : this.ur_x;
+        const ur_y = opts.ur_y !== undefined ? opts.ur_y : this.ur_y;
+        return new LambertGrid(ni, nj, this.lon_0, this.lat_0, this.lat_std, ll_x, ll_y, ur_x, ur_y, this.a, this.b);
+    }
+    /** @internal */
+    transform(x, y, opts) {
+        opts = opts === undefined ? {} : opts;
+        const inverse = opts.inverse === undefined ? false : opts.inverse;
+        return this.lcc(x, y, { inverse: inverse });
+    }
+    /** @internal */
+    getThinnedGrid(thin_fac, map_max_zoom) {
+        const { ni, nj, thin_x, thin_y, ll_x, ll_y, ur_x, ur_y } = this.thinnedGridParameters(thin_fac, map_max_zoom, this.ll_x, this.ll_y, this.ur_x, this.ur_y);
+        return new LambertGrid(ni, nj, this.lon_0, this.lat_0, this.lat_std, ll_x, ll_y, ur_x, ur_y, this.a, this.b, this.thin_x * thin_x, this.thin_y * thin_y);
+    }
+}
+export { LambertGrid };

package/lib/grids/PlateCarreeGrid.d.ts

@@ -0,0 +1,46 @@
+import { StructuredGrid } from "./StructuredGrid";
+declare const PlateCarreeGrid_base: import("./Grid").AbstractConstructor<import("./AutoZoom").AutoZoomGridIntf> & import("./Grid").AbstractConstructor<import("./GridCoordinates").GridCoordinateIntf> & typeof StructuredGrid;
+/**
+ * A plate carree (a.k.a. lat/lon) grid with uniform grid spacing
+ *
+ * ## Plot Component Compatibility
+ * - :white_check_mark: `Fill`
+ * - :white_check_mark: `Raster`
+ * - :white_check_mark: `Contour`
+ * - :white_check_mark: `Paintball`
+ * - :white_check_mark: `Barbs`
+ * - :white_check_mark: `Hodographs`
+ * - :white_check_mark: `StationPlot`
+ */
+declare class PlateCarreeGrid extends PlateCarreeGrid_base {
+    readonly ll_lon: number;
+    readonly ll_lat: number;
+    readonly ur_lon: number;
+    readonly ur_lat: number;
+    /**
+     * Create a plate carree grid
+     * @param ni     - The number of grid points in the i (longitude) direction
+     * @param nj     - The number of grid points in the j (latitude) direction
+     * @param ll_lon - The longitude of the lower left corner of the grid
+     * @param ll_lat - The latitude of the lower left corner of the grid
+     * @param ur_lon - The longitude of the upper right corner of the grid
+     * @param ur_lat - The latitude of the upper right corner of the grid
+     */
+    constructor(ni: number, nj: number, ll_lon: number, ll_lat: number, ur_lon: number, ur_lat: number, thin_x?: number, thin_y?: number);
+    /** @internal */
+    copy(opts?: {
+        ni?: number;
+        nj?: number;
+        ll_lon?: number;
+        ll_lat?: number;
+        ur_lon?: number;
+        ur_lat?: number;
+    }): PlateCarreeGrid;
+    /** @internal */
+    transform(x: number, y: number, opts?: {
+        inverse?: boolean;
+    }): [number, number];
+    /** @internal */
+    getThinnedGrid(thin_fac: number, map_max_zoom: number): this;
+}
+export { PlateCarreeGrid };

package/lib/grids/PlateCarreeGrid.js

@@ -0,0 +1,55 @@
+import { autoZoomGridMixin } from "./AutoZoom";
+import { gridCoordinateMixin } from "./GridCoordinates";
+import { StructuredGrid } from "./StructuredGrid";
+/**
+ * A plate carree (a.k.a. lat/lon) grid with uniform grid spacing
+ *
+ * ## Plot Component Compatibility
+ * - :white_check_mark: `Fill`
+ * - :white_check_mark: `Raster`
+ * - :white_check_mark: `Contour`
+ * - :white_check_mark: `Paintball`
+ * - :white_check_mark: `Barbs`
+ * - :white_check_mark: `Hodographs`
+ * - :white_check_mark: `StationPlot`
+ */
+class PlateCarreeGrid extends autoZoomGridMixin(gridCoordinateMixin(StructuredGrid)) {
+    /**
+     * Create a plate carree grid
+     * @param ni     - The number of grid points in the i (longitude) direction
+     * @param nj     - The number of grid points in the j (latitude) direction
+     * @param ll_lon - The longitude of the lower left corner of the grid
+     * @param ll_lat - The latitude of the lower left corner of the grid
+     * @param ur_lon - The longitude of the upper right corner of the grid
+     * @param ur_lat - The latitude of the upper right corner of the grid
+     */
+    constructor(ni, nj, ll_lon, ll_lat, ur_lon, ur_lat, thin_x, thin_y) {
+        super('latlon', true, ni, nj, thin_x, thin_y);
+        this.ll_lon = ll_lon;
+        this.ll_lat = ll_lat;
+        this.ur_lon = ur_lon;
+        this.ur_lat = ur_lat;
+        this.setupCoordinateCaches(ll_lon, ur_lon, ll_lat, ur_lat);
+    }
+    /** @internal */
+    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 PlateCarreeGrid(ni, nj, ll_lon, ll_lat, ur_lon, ur_lat);
+    }
+    /** @internal */
+    transform(x, y, opts) {
+        return [x, y];
+    }
+    /** @internal */
+    getThinnedGrid(thin_fac, map_max_zoom) {
+        const { ni, nj, thin_x, thin_y, ll_x: ll_lon, ll_y: ll_lat, ur_x: ur_lon, ur_y: ur_lat } = this.thinnedGridParameters(thin_fac, map_max_zoom, this.ll_lon, this.ll_lat, this.ur_lon, this.ur_lat);
+        return new PlateCarreeGrid(ni, nj, ll_lon, ll_lat, ur_lon, ur_lat, this.thin_x * thin_x, this.thin_y * thin_y);
+    }
+}
+export { PlateCarreeGrid };

package/lib/grids/PlateCarreeRotatedGrid.d.ts

@@ -0,0 +1,53 @@
+import { StructuredGrid } from "./StructuredGrid";
+declare const PlateCarreeRotatedGrid_base: import("./Grid").AbstractConstructor<import("./AutoZoom").AutoZoomGridIntf> & import("./Grid").AbstractConstructor<import("./GridCoordinates").GridCoordinateIntf> & typeof StructuredGrid;
+/**
+ * A rotated lat-lon (plate carree) grid with uniform grid spacing
+ *
+ * ## Plot Component Compatibility
+ * - :white_check_mark: `Fill`
+ * - :white_check_mark: `Raster`
+ * - :white_check_mark: `Contour`
+ * - :white_check_mark: `Paintball`
+ * - :white_check_mark: `Barbs`
+ * - :white_check_mark: `Hodographs`
+ * - :white_check_mark: `StationPlot`
+ */
+declare class PlateCarreeRotatedGrid extends PlateCarreeRotatedGrid_base {
+    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;
+    /**
+     * Create a Lambert conformal conic grid
+     * @param ni        - The number of grid points in the i (longitude) direction
+     * @param nj        - The number of grid points in the j (latitude) direction
+     * @param np_lon    - The longitude of the north pole for the rotated grid
+     * @param np_lat    - The latitude of the north pole for the rotated grid
+     * @param lon_shift - The angle around the rotated north pole to shift the central meridian
+     * @param ll_lon    - The longitude of the lower left corner of the grid (on the rotated earth)
+     * @param ll_lat    - The latitude of the lower left corner of the grid (on the rotated earth)
+     * @param ur_lon    - The longitude of the upper right corner of the grid (on the rotated earth)
+     * @param ur_lat    - The latitude of the upper right corner of the grid (on the rotated earth)
+     */
+    constructor(ni: number, nj: number, np_lon: number, np_lat: number, lon_shift: number, ll_lon: number, ll_lat: number, ur_lon: number, ur_lat: number, thin_x?: number, thin_y?: number);
+    /** @internal */
+    copy(opts?: {
+        ni?: number;
+        nj?: number;
+        ll_lon?: number;
+        ll_lat?: number;
+        ur_lon?: number;
+        ur_lat?: number;
+    }): PlateCarreeRotatedGrid;
+    /** @internal */
+    transform(x: number, y: number, opts?: {
+        inverse?: boolean;
+    }): [number, number];
+    /** @internal */
+    getThinnedGrid(thin_fac: number, map_max_zoom: number): this;
+}
+export { PlateCarreeRotatedGrid };

package/lib/grids/PlateCarreeRotatedGrid.js

@@ -0,0 +1,65 @@
+import { rotateSphere } from "../Map";
+import { autoZoomGridMixin } from "./AutoZoom";
+import { gridCoordinateMixin } from "./GridCoordinates";
+import { StructuredGrid } from "./StructuredGrid";
+/**
+ * A rotated lat-lon (plate carree) grid with uniform grid spacing
+ *
+ * ## Plot Component Compatibility
+ * - :white_check_mark: `Fill`
+ * - :white_check_mark: `Raster`
+ * - :white_check_mark: `Contour`
+ * - :white_check_mark: `Paintball`
+ * - :white_check_mark: `Barbs`
+ * - :white_check_mark: `Hodographs`
+ * - :white_check_mark: `StationPlot`
+ */
+class PlateCarreeRotatedGrid extends autoZoomGridMixin(gridCoordinateMixin(StructuredGrid)) {
+    /**
+     * 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, thin_x, thin_y) {
+        super('latlonrot', true, ni, nj, thin_x, thin_y);
+        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 });
+        this.setupCoordinateCaches(ll_lon, ur_lon, ll_lat, ur_lat);
+    }
+    /** @internal */
+    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);
+    }
+    /** @internal */
+    transform(x, y, opts) {
+        opts = opts === undefined ? {} : opts;
+        const inverse = 'inverse' in opts ? opts.inverse : false;
+        return this.llrot(x, y, { inverse: !inverse });
+    }
+    /** @internal */
+    getThinnedGrid(thin_fac, map_max_zoom) {
+        const { ni, nj, thin_x, thin_y, ll_x: ll_lon, ll_y: ll_lat, ur_x: ur_lon, ur_y: ur_lat } = this.thinnedGridParameters(thin_fac, map_max_zoom, this.ll_lon, this.ll_lat, this.ur_lon, 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, this.thin_x * thin_x, this.thin_y * thin_y);
+    }
+}
+export { PlateCarreeRotatedGrid };

package/lib/grids/RadarSweepGrid.d.ts

@@ -0,0 +1,46 @@
+import { GeodesicClass } from "geographiclib-geodesic";
+import { StructuredGrid } from "./StructuredGrid";
+import { WebGLAnyRenderingContext } from "../AutumnTypes";
+declare const RadarSweepGrid_base: import("./Grid").AbstractConstructor<import("./GridCoordinates").GridCoordinateIntf> & typeof StructuredGrid;
+/**
+ * A grid for a radar sweep centered at a certain latitude and longitude.
+ *
+ * ## Plot Component Compatibility
+ * - :white_check_mark: `Fill`
+ * - :white_check_mark: `Raster`
+ * - :white_check_mark: `Contour`
+ * - :white_check_mark: `Paintball`
+ * - :x:                `Barbs`
+ * - :x:                `Hodographs`
+ * - :x:                `StationPlot`
+ */
+declare class RadarSweepGrid extends RadarSweepGrid_base {
+    readonly longitude: number;
+    readonly latitude: number;
+    readonly start_rn: number;
+    readonly end_rn: number;
+    readonly start_az: number;
+    readonly end_az: number;
+    readonly geod: GeodesicClass;
+    constructor(nr: number, nt: number, start_rn: number, end_rn: number, start_az: number, end_az: number, longitude: number, latitude: number, thin_x?: number, thin_y?: number);
+    copy(opts?: {
+        ni?: number;
+        nj?: number;
+        start_rn?: number;
+        end_rn?: number;
+        start_az?: number;
+        end_az?: number;
+        longitude?: number;
+        latitude?: number;
+    }): RadarSweepGrid;
+    protected makeDomainBuffers(gl: WebGLAnyRenderingContext): Promise<{
+        vertices: import("autumn-wgl").WGLBuffer;
+        texcoords: import("autumn-wgl").WGLBuffer;
+    }>;
+    transform(a: number, b: number, opts?: {
+        inverse?: boolean | undefined;
+    } | undefined): [number, number];
+    /** @internal */
+    getThinnedGrid(thin_fac: number, map_max_zoom: number): this;
+}
+export { RadarSweepGrid };

package/lib/grids/RadarSweepGrid.js

@@ -0,0 +1,74 @@
+import { Geodesic } from "geographiclib-geodesic";
+import { gridCoordinateMixin } from "./GridCoordinates";
+import { StructuredGrid, makeCartesianDomainBuffers } from "./StructuredGrid";
+/**
+ * A grid for a radar sweep centered at a certain latitude and longitude.
+ *
+ * ## Plot Component Compatibility
+ * - :white_check_mark: `Fill`
+ * - :white_check_mark: `Raster`
+ * - :white_check_mark: `Contour`
+ * - :white_check_mark: `Paintball`
+ * - :x:                `Barbs`
+ * - :x:                `Hodographs`
+ * - :x:                `StationPlot`
+ */
+class RadarSweepGrid extends gridCoordinateMixin(StructuredGrid) {
+    constructor(nr, nt, start_rn, end_rn, start_az, end_az, longitude, latitude, thin_x, thin_y) {
+        super('radar', true, nr, nt, thin_x, thin_y);
+        this.longitude = longitude;
+        this.latitude = latitude;
+        this.start_rn = start_rn;
+        this.end_rn = end_rn;
+        this.start_az = start_az;
+        this.end_az = end_az;
+        this.geod = Geodesic.WGS84;
+        this.setupCoordinateCaches(start_rn, end_rn, start_az, end_az);
+    }
+    copy(opts) {
+        opts = opts === undefined ? {} : opts;
+        const nr = opts.ni === undefined ? this.ni : opts.ni;
+        const nt = opts.nj === undefined ? this.nj : opts.nj;
+        const longitude = opts.longitude === undefined ? this.longitude : opts.longitude;
+        const latitude = opts.latitude === undefined ? this.latitude : opts.latitude;
+        const start_rn = opts.start_rn === undefined ? this.start_rn : opts.start_rn;
+        const end_rn = opts.end_rn === undefined ? this.end_rn : opts.end_rn;
+        const start_az = opts.start_az === undefined ? this.start_az : opts.start_az;
+        const end_az = opts.end_az === undefined ? this.end_az : opts.end_az;
+        return new RadarSweepGrid(nr, nt, start_rn, end_rn, start_az, end_az, longitude, latitude);
+    }
+    async makeDomainBuffers(gl) {
+        return await makeCartesianDomainBuffers(gl, this, 16, this.nj, { margin_r: false, margin_s: false });
+    }
+    transform(a, b, opts) {
+        opts = opts === undefined ? {} : opts;
+        const inverse = opts.inverse === undefined ? false : opts.inverse;
+        // geographiclib calls the "forward" transformation what the rest of my code calls the "inverse" transformation and vice versa
+        if (inverse) {
+            const ret = this.geod.Direct(this.latitude, this.longitude, b, a);
+            if (ret.lon2 === undefined || ret.lat2 === undefined)
+                throw "Why are lon2 and lat2 not in the return value?";
+            return [ret.lon2, ret.lat2];
+        }
+        else {
+            const ret = this.geod.Inverse(this.latitude, this.longitude, b, a);
+            if (ret.azi1 === undefined || ret.s12 === undefined)
+                throw "Why are azi1 and s12 not in the return value?";
+            if (!Number.isFinite(ret.azi1) || !Number.isFinite(ret.s12))
+                return [NaN, NaN];
+            const half_dt = 0.5 * (this.end_az - this.start_az) / this.ni;
+            let az1 = ret.azi1;
+            while (az1 < this.start_az - half_dt)
+                az1 += 360;
+            while (az1 >= this.end_az + half_dt)
+                az1 -= 360;
+            return [ret.s12, az1];
+        }
+    }
+    /** @internal */
+    getThinnedGrid(thin_fac, map_max_zoom) {
+        const { ni: nr, nj: nt, thin_x, thin_y, ll_x: start_az, ll_y: start_rn, ur_x: end_az, ur_y: end_rn } = this.thinnedGridParameters(thin_fac, map_max_zoom, this.end_az, this.end_rn, this.start_az, this.start_rn);
+        return new RadarSweepGrid(nr, nt, start_rn, end_rn, start_az, end_az, this.longitude, this.latitude, thin_x * this.thin_x, thin_y * this.thin_y);
+    }
+}
+export { RadarSweepGrid };

package/lib/grids/StructuredGrid.d.ts

@@ -0,0 +1,49 @@
+import { WGLBuffer } from "autumn-wgl";
+import { TypedArray, WebGLAnyRenderingContext } from "../AutumnTypes";
+import { EarthCoords, Grid, GridType } from "./Grid";
+import { GridElement } from "./GridCoordinates";
+declare function makeCartesianDomainBuffers(gl: WebGLAnyRenderingContext, grid: StructuredGrid, simplify_ni: number, simplify_nj: number, opts?: {
+    margin_r?: boolean;
+    margin_s?: boolean;
+}): Promise<{
+    vertices: WGLBuffer;
+    texcoords: WGLBuffer;
+}>;
+declare const StructuredGrid_base: import("./Grid").AbstractConstructor<import("./DomainBuffer").DomainBufferIntf> & typeof Grid;
+/** A structured grid (in this case meaning a cartesian grid with i and j coordinates) */
+declare abstract class StructuredGrid extends StructuredGrid_base {
+    protected readonly thin_x: number;
+    protected readonly thin_y: number;
+    constructor(type: GridType, is_conformal: boolean, ni: number, nj: number, thin_x?: number, thin_y?: number);
+    abstract getEarthCoords(ni?: number, nj?: number, which_i?: GridElement, which_j?: GridElement): EarthCoords;
+    /** @internal */
+    protected xyThinFromMaxZoom(thin_fac: number, map_max_zoom: number): [number, number];
+    protected thinnedGridParameters(thin_fac: number, map_max_zoom: number, ll_x: number, ll_y: number, ur_x: number, ur_y: number): {
+        ni: number;
+        nj: number;
+        thin_x: number;
+        thin_y: number;
+        ll_x: number;
+        ll_y: number;
+        ur_x: number;
+        ur_y: number;
+    };
+    /** @internal */
+    getMinVisibleZoom(thin_fac: number): Uint8Array;
+    /** @internal */
+    thinDataArray<ArrayType extends TypedArray>(original_grid: StructuredGrid, ary: ArrayType): ArrayType;
+    abstract copy(opts?: {
+        ni?: number;
+        nj?: number;
+    }): Grid;
+    protected makeDomainBuffers(gl: WebGLAnyRenderingContext): Promise<{
+        vertices: WGLBuffer;
+        texcoords: WGLBuffer;
+    }>;
+    sampleNearestGridPoint(lon: number, lat: number, ary: TypedArray): {
+        sample: number;
+        sample_lon: number;
+        sample_lat: number;
+    };
+}
+export { StructuredGrid, makeCartesianDomainBuffers };

package/lib/grids/StructuredGrid.js

@@ -0,0 +1,103 @@
+import { WGLBuffer } from "autumn-wgl";
+import { argMin, getArrayConstructor, getMinZoom } from "../utils";
+import { Grid } from "./Grid";
+import { layer_worker } from "../PlotComponent";
+import { domainBufferMixin } from "./DomainBuffer";
+async function makeCartesianDomainBuffers(gl, grid, simplify_ni, simplify_nj, opts) {
+    opts = opts === undefined ? {} : opts;
+    const use_margin_r = opts.margin_r === undefined ? true : opts.margin_r;
+    const use_margin_s = opts.margin_s === undefined ? true : opts.margin_s;
+    const texcoord_margin_r = use_margin_r ? 1 / (2 * grid.ni) : 0;
+    const texcoord_margin_s = use_margin_s ? 1 / (2 * grid.nj) : 0;
+    const grid_element_i = use_margin_r ? 'center' : 'edge';
+    const grid_element_j = use_margin_s ? 'center' : 'edge';
+    const domain_ni = use_margin_r ? simplify_ni : simplify_ni + 1;
+    const domain_nj = use_margin_s ? simplify_nj : simplify_nj + 1;
+    const { lats: field_lats, lons: field_lons } = grid.getEarthCoords(simplify_ni, simplify_nj, grid_element_i, grid_element_j);
+    const domain_coords = await layer_worker.makeDomainVerticesAndTexCoords(field_lats, field_lons, domain_ni, domain_nj, texcoord_margin_r, texcoord_margin_s);
+    const vertices = new WGLBuffer(gl, domain_coords['vertices'], 2, gl.TRIANGLE_STRIP);
+    const texcoords = new WGLBuffer(gl, domain_coords['tex_coords'], 2, gl.TRIANGLE_STRIP);
+    return { 'vertices': vertices, 'texcoords': texcoords };
+}
+/** A structured grid (in this case meaning a cartesian grid with i and j coordinates) */
+class StructuredGrid extends domainBufferMixin(Grid) {
+    constructor(type, is_conformal, ni, nj, thin_x, thin_y) {
+        super(type, is_conformal, ni, nj);
+        this.thin_x = thin_x === undefined ? 1 : thin_x;
+        this.thin_y = thin_y === undefined ? 1 : thin_y;
+    }
+    /** @internal */
+    xyThinFromMaxZoom(thin_fac, map_max_zoom) {
+        const n_density_tiers = Math.log2(thin_fac);
+        const n_inaccessible_tiers = Math.max(n_density_tiers + 1 - map_max_zoom, 0);
+        const xy_thin = Math.pow(2, n_inaccessible_tiers);
+        return [xy_thin, xy_thin];
+    }
+    thinnedGridParameters(thin_fac, map_max_zoom, ll_x, ll_y, ur_x, ur_y) {
+        const [thin_x, thin_y] = this.xyThinFromMaxZoom(thin_fac, map_max_zoom);
+        const dx = (ur_x - ll_x) / this.ni;
+        const dy = (ur_y - ll_y) / 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 new_ll_x = ll_x;
+        const new_ll_y = ll_y;
+        const new_ur_x = ur_x - ni_remove * dx;
+        const new_ur_y = ur_y - nj_remove * dy;
+        return { ni, nj, thin_x, thin_y, ll_x: new_ll_x, ll_y: new_ll_y, ur_x: new_ur_x, ur_y: new_ur_y };
+    }
+    /** @internal */
+    getMinVisibleZoom(thin_fac) {
+        const min_zoom = new Uint8Array(this.ni * this.nj);
+        const zoom_thin_fac = thin_fac / Math.max(this.thin_x, this.thin_y);
+        for (let ilat = 0; ilat < this.nj * this.thin_y; ilat++) {
+            for (let ilon = 0; ilon < this.ni * this.thin_x; ilon++) {
+                const idx = ilat * this.ni + ilon;
+                min_zoom[idx] = getMinZoom(ilat, ilon, zoom_thin_fac);
+            }
+        }
+        return min_zoom;
+    }
+    /** @internal */
+    thinDataArray(original_grid, ary) {
+        const arrayType = getArrayConstructor(ary);
+        const new_data = new arrayType(this.ni * this.nj);
+        for (let i = 0; i < this.ni; i++) {
+            for (let j = 0; j < this.nj; j++) {
+                const idx_old = i * this.thin_x + original_grid.ni * j * this.thin_y;
+                const idx = i + this.ni * j;
+                new_data[idx] = ary[idx_old];
+            }
+        }
+        return new_data;
+    }
+    async makeDomainBuffers(gl) {
+        const simplify_ni = Math.max(Math.floor(this.ni / 20), 20);
+        const simplify_nj = Math.max(Math.floor(this.nj / 20), 20);
+        return makeCartesianDomainBuffers(gl, this, simplify_ni, simplify_nj);
+    }
+    sampleNearestGridPoint(lon, lat, ary) {
+        const [x, y] = this.transform(lon, lat);
+        const { x: xs, y: ys } = this.getGridCoords();
+        let ll_x = xs[0];
+        let ur_x = xs[xs.length - 1];
+        const dx = xs[1] - xs[0];
+        let ll_y = ys[0];
+        let ur_y = ys[ys.length - 1];
+        const dy = ys[1] - ys[0];
+        if (dx < 0)
+            [ll_x, ur_x] = [ur_x, ll_x];
+        if (dy < 0)
+            [ll_y, ur_y] = [ur_y, ll_y];
+        if (x < ll_x - 0.5 * dx || x > ur_x + 0.5 * dx || y < ll_y - 0.5 * dy || y > ur_y + 0.5 * dy) {
+            return { sample: NaN, sample_lon: NaN, sample_lat: NaN };
+        }
+        const i_min = argMin(xs.map(xv => Math.abs(xv - x)));
+        const j_min = argMin(ys.map(yv => Math.abs(yv - y)));
+        const idx = i_min + j_min * this.ni;
+        const [lon_min, lat_min] = this.transform(xs[i_min], ys[j_min], { inverse: true });
+        return { sample: ary[idx], sample_lon: lon_min, sample_lat: lat_min };
+    }
+}
+export { StructuredGrid, makeCartesianDomainBuffers };