autumnplot-gl 4.0.0-beta → 4.1.0

package/lib/WorkerPool.js

@@ -0,0 +1,77 @@
+import * as Comlink from 'comlink';
+class WorkerPool_ {
+    constructor(workers, init) {
+        this.workers = workers.map(wkr => ({ worker: Comlink.wrap(wkr), is_busy: false }));
+        if (init) {
+            this.workers.forEach(wkr => init(wkr.worker));
+        }
+        this.queue = new Map();
+    }
+    call(path, args, callback) {
+        const worker_idx = this.workers.map(((w, iw) => [w, iw])).filter(([w, iw]) => !w.is_busy)[0];
+        if (worker_idx === undefined) {
+            this.enqueue(path, args, callback);
+        }
+        else {
+            const [worker, iw] = worker_idx;
+            const dequeueAndStart = () => {
+                if (this.queueSize(path) > 0) {
+                    const queue_data = this.dequeue(path);
+                    if (queue_data === undefined)
+                        return;
+                    this.startRun(worker, path, queue_data.args).then(queue_data.callback).then(dequeueAndStart);
+                }
+            };
+            this.startRun(worker, path, args).then(callback).then(dequeueAndStart);
+        }
+    }
+    enqueue(path, args, callback) {
+        const path_str = path.join(".");
+        const old_queue = this.queue.get(path_str);
+        const new_queue = old_queue ? old_queue : [];
+        new_queue.push({ args: args, callback: callback });
+        this.queue.set(path_str, new_queue);
+    }
+    dequeue(path) {
+        const path_str = path.join(".");
+        const queue = this.queue.get(path_str);
+        if (!queue) {
+            return undefined;
+        }
+        const elem = queue.shift();
+        this.queue.set(path_str, queue);
+        return elem;
+    }
+    queueSize(path) {
+        const path_str = path.join(".");
+        const queue = this.queue.get(path_str);
+        if (!queue) {
+            return 0;
+        }
+        return queue.length;
+    }
+    async startRun(worker, path, args) {
+        let rem = worker.worker;
+        path.forEach(p => rem = rem[p]);
+        worker.is_busy = true;
+        const ret = await rem(...args);
+        worker.is_busy = false;
+        return ret;
+    }
+}
+function createProxy(pool, path, target) {
+    const proxy = new Proxy(target, {
+        get(tgt, prop) {
+            return createProxy(pool, [...path, prop], () => { });
+        },
+        apply(tgt, this_arg, func_args) {
+            return new Promise((resolve, reject) => pool.call(path, func_args, resolve));
+        }
+    });
+    return proxy;
+}
+function createWorkerPool(workers, init) {
+    const pool = new WorkerPool_(workers, init);
+    return createProxy(pool, [], () => { });
+}
+export { createWorkerPool };

package/lib/cpp/marchingsquares.js

@@ -40,10 +40,13 @@ var readyPromise = new Promise((resolve, reject) => {
 // Determine the runtime environment we are in. You can customize this by
 // setting the ENVIRONMENT setting at compile time (see settings.js).
 
-var ENVIRONMENT_IS_WEB = true;
-var ENVIRONMENT_IS_WORKER = false;
-var ENVIRONMENT_IS_NODE = false;
-var ENVIRONMENT_IS_SHELL = false;
+// Attempt to auto-detect the environment
+var ENVIRONMENT_IS_WEB = typeof window == 'object';
+var ENVIRONMENT_IS_WORKER = typeof importScripts == 'function';
+// N.b. Electron.js environment is simultaneously a NODE-environment, but
+// also a web environment.
+var ENVIRONMENT_IS_NODE = typeof process == 'object' && typeof process.versions == 'object' && typeof process.versions.node == 'string';
+var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
 
 if (Module['ENVIRONMENT']) {
   throw new Error('Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)');
@@ -114,7 +117,17 @@ if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
 
   {
 // include: web_or_worker_shell_read.js
-readAsync = (url) => {
+if (ENVIRONMENT_IS_WORKER) {
+    readBinary = (url) => {
+      var xhr = new XMLHttpRequest();
+      xhr.open('GET', url, false);
+      xhr.responseType = 'arraybuffer';
+      xhr.send(null);
+      return new Uint8Array(/** @type{!ArrayBuffer} */(xhr.response));
+    };
+  }
+
+  readAsync = (url) => {
     assert(!isFileURI(url), "readAsync does not work with file:// URLs");
     return fetch(url, { credentials: 'same-origin' })
       .then((response) => {
@@ -177,8 +190,6 @@ var OPFS = 'OPFS is no longer included by default; build with -lopfs.js';
 
 var NODEFS = 'NODEFS is no longer included by default; build with -lnodefs.js';
 
-assert(!ENVIRONMENT_IS_WORKER, 'worker environment detected but not enabled at build time.  Add `worker` to `-sENVIRONMENT` to enable.');
-
 assert(!ENVIRONMENT_IS_NODE, 'node environment detected but not enabled at build time.  Add `node` to `-sENVIRONMENT` to enable.');
 
 assert(!ENVIRONMENT_IS_SHELL, 'shell environment detected but not enabled at build time.  Add `shell` to `-sENVIRONMENT` to enable.');
@@ -2386,6 +2397,14 @@ function dbg(...args) {
 
   var __emval_new_array = () => Emval.toHandle([]);
 
+  var __emval_new_array_from_memory_view = (view) => {
+      view = Emval.toValue(view);
+      // using for..loop is faster than Array.from
+      var a = new Array(view.length);
+      for (var i = 0; i < view.length; i++) a[i] = view[i];
+      return Emval.toHandle(a);
+    };
+
   
   var __emval_new_cstring = (v) => Emval.toHandle(getStringOrSymbol(v));
 
@@ -2560,6 +2579,100 @@ function dbg(...args) {
     };
 
 
+  var getCFunc = (ident) => {
+      var func = Module['_' + ident]; // closure exported function
+      assert(func, 'Cannot call unknown function ' + ident + ', make sure it is exported');
+      return func;
+    };
+  
+  var writeArrayToMemory = (array, buffer) => {
+      assert(array.length >= 0, 'writeArrayToMemory array must have a length (should be an array or typed array)')
+      HEAP8.set(array, buffer);
+    };
+  
+  
+  
+  var stackAlloc = (sz) => __emscripten_stack_alloc(sz);
+  var stringToUTF8OnStack = (str) => {
+      var size = lengthBytesUTF8(str) + 1;
+      var ret = stackAlloc(size);
+      stringToUTF8(str, ret, size);
+      return ret;
+    };
+  
+  
+  
+  
+  
+    /**
+     * @param {string|null=} returnType
+     * @param {Array=} argTypes
+     * @param {Arguments|Array=} args
+     * @param {Object=} opts
+     */
+  var ccall = (ident, returnType, argTypes, args, opts) => {
+      // For fast lookup of conversion functions
+      var toC = {
+        'string': (str) => {
+          var ret = 0;
+          if (str !== null && str !== undefined && str !== 0) { // null string
+            // at most 4 bytes per UTF-8 code point, +1 for the trailing '\0'
+            ret = stringToUTF8OnStack(str);
+          }
+          return ret;
+        },
+        'array': (arr) => {
+          var ret = stackAlloc(arr.length);
+          writeArrayToMemory(arr, ret);
+          return ret;
+        }
+      };
+  
+      function convertReturnValue(ret) {
+        if (returnType === 'string') {
+          
+          return UTF8ToString(ret);
+        }
+        if (returnType === 'boolean') return Boolean(ret);
+        return ret;
+      }
+  
+      var func = getCFunc(ident);
+      var cArgs = [];
+      var stack = 0;
+      assert(returnType !== 'array', 'Return type should not be "array".');
+      if (args) {
+        for (var i = 0; i < args.length; i++) {
+          var converter = toC[argTypes[i]];
+          if (converter) {
+            if (stack === 0) stack = stackSave();
+            cArgs[i] = converter(args[i]);
+          } else {
+            cArgs[i] = args[i];
+          }
+        }
+      }
+      var ret = func(...cArgs);
+      function onDone(ret) {
+        if (stack !== 0) stackRestore(stack);
+        return convertReturnValue(ret);
+      }
+  
+      ret = onDone(ret);
+      return ret;
+    };
+
+  
+  
+    /**
+     * @param {string=} returnType
+     * @param {Array=} argTypes
+     * @param {Object=} opts
+     */
+  var cwrap = (ident, returnType, argTypes, opts) => {
+      return (...args) => ccall(ident, returnType, argTypes, args, opts);
+    };
+
   var incrementExceptionRefcount = (ptr) => ___cxa_increment_exception_refcount(ptr);
   Module['incrementExceptionRefcount'] = incrementExceptionRefcount;
 
@@ -2570,7 +2683,6 @@ function dbg(...args) {
   
   
   
-  var stackAlloc = (sz) => __emscripten_stack_alloc(sz);
   
   var getExceptionMessageCommon = (ptr) => {
       var sp = stackSave();
@@ -2657,6 +2769,8 @@ var wasmImports = {
   /** @export */
   _emval_new_array: __emval_new_array,
   /** @export */
+  _emval_new_array_from_memory_view: __emval_new_array_from_memory_view,
+  /** @export */
   _emval_new_cstring: __emval_new_cstring,
   /** @export */
   _emval_new_object: __emval_new_object,
@@ -2825,6 +2939,8 @@ function invoke_j(index) {
 // include: postamble.js
 // === Auto-generated postamble setup entry stuff ===
 
+Module['ccall'] = ccall;
+Module['cwrap'] = cwrap;
 var missingLibrarySymbols = [
   'writeI53ToI64',
   'writeI53ToI64Clamped',
@@ -2873,9 +2989,6 @@ var missingLibrarySymbols = [
   'STACK_ALIGN',
   'POINTER_SIZE',
   'ASSERTIONS',
-  'getCFunc',
-  'ccall',
-  'cwrap',
   'uleb128Encode',
   'sigToWasmTypes',
   'generateFuncType',
@@ -2895,8 +3008,6 @@ var missingLibrarySymbols = [
   'AsciiToString',
   'stringToAscii',
   'stringToNewUTF8',
-  'stringToUTF8OnStack',
-  'writeArrayToMemory',
   'registerKeyEventCallback',
   'maybeCStringToJsString',
   'findEventTarget',
@@ -3074,6 +3185,7 @@ var unexportedSymbols = [
   'dynCall',
   'wasmTable',
   'noExitRuntime',
+  'getCFunc',
   'freeTableIndexes',
   'functionsInTableMap',
   'setValue',
@@ -3093,6 +3205,8 @@ var unexportedSymbols = [
   'UTF32ToString',
   'stringToUTF32',
   'lengthBytesUTF32',
+  'stringToUTF8OnStack',
+  'writeArrayToMemory',
   'JSEvents',
   'specialHTMLTargets',
   'findCanvasEventTarget',

package/lib/cpp/marchingsquares_embind.d.ts

@@ -1,10 +1,23 @@
 // TypeScript bindings for emscripten-generated code.  Automatically generated at compile time.
 declare namespace RuntimeExports {
+    let HEAPU8: any;
     let HEAPF32: any;
     let HEAPF64: any;
+    /**
+     * @param {string|null=} returnType
+     * @param {Array=} argTypes
+     * @param {Arguments|Array=} args
+     * @param {Object=} opts
+     */
+    function ccall(ident: any, returnType?: (string | null) | undefined, argTypes?: any[] | undefined, args?: (IArguments | any[]) | undefined, opts?: any | undefined): any;
+    /**
+     * @param {string=} returnType
+     * @param {Array=} argTypes
+     * @param {Object=} opts
+     */
+    function cwrap(ident: any, returnType?: string | undefined, argTypes?: any[] | undefined, opts?: any | undefined): (...args: any[]) => any;
     let HEAP_DATA_VIEW: any;
     let HEAP8: any;
-    let HEAPU8: any;
     let HEAP16: any;
     let HEAPU16: any;
     let HEAP32: any;
@@ -16,8 +29,8 @@ interface WasmModule {
 }
 
 interface EmbindModule {
-  makeContoursFloat32(_0: any, _1: any, _2: any, _3: any, _4: any, _5: any): any;
-  makeContoursFloat16(_0: any, _1: any, _2: any, _3: any, _4: any, _5: any): any;
+  makeContoursFloat32(_0: any, _1: any, _2: any, _3: any, _4: any): any;
+  makeContoursFloat16(_0: any, _1: any, _2: any, _3: any, _4: any): any;
   getContourLevelsFloat32(_0: any, _1: number, _2: number, _3: number): any;
   getContourLevelsFloat16(_0: any, _1: number, _2: number, _3: number): any;
 }

package/lib/grids/AutoZoom.d.ts

@@ -0,0 +1,21 @@
+import { WGLBuffer, WGLTexture } from "autumn-wgl";
+import { WebGLAnyRenderingContext } from "../AutumnTypes";
+import { AbstractConstructor, Grid } from "./Grid";
+interface AutoZoomGridIntf {
+    getWGLBillboardBuffers(gl: WebGLAnyRenderingContext, thin_fac: number, max_zoom: number): Promise<{
+        'vertices': WGLBuffer;
+        'texcoords': WGLBuffer;
+    }>;
+    getVectorRotationTexture(gl: WebGLAnyRenderingContext, data_are_earth_relative: boolean): {
+        'rotation': WGLTexture;
+    };
+    getVectorRotationAtPoint(lon: number, lat: number): number;
+    getMinVisibleZoom(thin_fac: number): Uint8Array;
+}
+declare function autoZoomGridMixin<G extends AbstractConstructor<Grid>>(base: G): AbstractConstructor<AutoZoomGridIntf> & G;
+/**
+ * Grids of this type can be used with wind barbs, observations, and anything that needs automatic thinning.
+ */
+type AutoZoomGrid<T extends Grid = Grid> = InstanceType<ReturnType<typeof autoZoomGridMixin<AbstractConstructor<T>>>>;
+export { autoZoomGridMixin };
+export type { AutoZoomGrid, AutoZoomGridIntf };

package/lib/grids/AutoZoom.js

@@ -0,0 +1,63 @@
+import { WGLBuffer, WGLTexture } from "autumn-wgl";
+import { Cache } from "../utils";
+import { getGLFormatTypeAlignment, layer_worker } from "../PlotComponent";
+import { Float16Array } from "@petamoriken/float16";
+async function makeWGLBillboardBuffers(gl, grid, thin_fac, map_max_zoom) {
+    const { lats: field_lats, lons: field_lons } = grid.getEarthCoords();
+    const min_zoom = grid.getMinVisibleZoom(thin_fac);
+    const bb_elements = await layer_worker.makeBBElements(field_lats, field_lons, min_zoom, grid.ni, grid.nj, map_max_zoom);
+    const vertices = new WGLBuffer(gl, bb_elements['pts'], 2, gl.POINTS, { per_instance: true });
+    const texcoords = new WGLBuffer(gl, bb_elements['tex_coords'], 2, gl.POINTS, { per_instance: true });
+    return { 'vertices': vertices, 'texcoords': texcoords };
+}
+function makeVectorRotationTexture(gl, grid, data_are_earth_relative) {
+    const coords = grid.getEarthCoords();
+    const rot_vals = new Float16Array(grid.ni * grid.nj).fill(parseFloat('nan'));
+    if (data_are_earth_relative) {
+        rot_vals.fill(0);
+    }
+    else {
+        if (!grid.is_conformal) {
+            // If the grid is non-conformal, we need a fully general change of basis from grid coordinates to earth coordinates. This is not supported for now, so warn about it.
+            console.warn('Vector rotations for non-conformal projections are not supported. The output may look incorrect.');
+        }
+        for (let icd = 0; icd < coords.lats.length; icd++) {
+            const lon = coords.lons[icd];
+            const lat = coords.lats[icd];
+            rot_vals[icd] = grid.getVectorRotationAtPoint(lon, lat);
+        }
+    }
+    const { format, type, row_alignment } = getGLFormatTypeAlignment(gl, 'float16');
+    const rot_img = {
+        format: format, type: type, row_alignment: row_alignment, image: new Uint16Array(rot_vals.buffer),
+        width: grid.ni, height: grid.nj, mag_filter: gl.LINEAR
+    };
+    const rot_tex = new WGLTexture(gl, rot_img);
+    return { 'rotation': rot_tex };
+}
+function autoZoomGridMixin(base) {
+    class AutoZoomGrid extends base {
+        constructor(...args) {
+            super(...args);
+            this.billboard_buffer_cache = new Cache((gl, thin_fac, max_zoom) => {
+                return makeWGLBillboardBuffers(gl, this, thin_fac, max_zoom);
+            });
+            this.vector_rotation_cache = new Cache((gl, data_are_earth_relative) => {
+                return makeVectorRotationTexture(gl, this, data_are_earth_relative);
+            });
+        }
+        async getWGLBillboardBuffers(gl, thin_fac, max_zoom) {
+            return await this.billboard_buffer_cache.getValue(gl, thin_fac, max_zoom);
+        }
+        getVectorRotationTexture(gl, data_are_earth_relative) {
+            return this.vector_rotation_cache.getValue(gl, data_are_earth_relative);
+        }
+        getVectorRotationAtPoint(lon, lat) {
+            const [x, y] = this.transform(lon, lat);
+            const [x_pertlon, y_pertlon] = this.transform(lon + 0.01, lat);
+            return Math.atan2(y_pertlon - y, x_pertlon - x);
+        }
+    }
+    return AutoZoomGrid;
+}
+export { autoZoomGridMixin };

package/lib/grids/DomainBuffer.d.ts

@@ -0,0 +1,14 @@
+import { WGLBuffer } from "autumn-wgl";
+import { WebGLAnyRenderingContext } from "../AutumnTypes";
+import { AbstractConstructor, Grid } from "./Grid";
+type DomainBuffers = {
+    vertices: WGLBuffer;
+    texcoords: WGLBuffer;
+};
+interface DomainBufferIntf {
+    getDomainBuffers(gl: WebGLAnyRenderingContext): Promise<DomainBuffers>;
+}
+declare function domainBufferMixin<G extends AbstractConstructor<Grid>>(base: G): AbstractConstructor<DomainBufferIntf> & G;
+type DomainBufferGrid<T extends Grid = Grid> = InstanceType<ReturnType<typeof domainBufferMixin<AbstractConstructor<T>>>>;
+export { domainBufferMixin };
+export type { DomainBuffers, DomainBufferGrid, DomainBufferIntf };

package/lib/grids/DomainBuffer.js

@@ -0,0 +1,16 @@
+import { Cache } from "../utils";
+function domainBufferMixin(base) {
+    class DomainBufferMixin extends base {
+        constructor(...args) {
+            super(...args);
+            this.buffer_cache = new Cache((gl) => {
+                return this.makeDomainBuffers(gl);
+            });
+        }
+        async getDomainBuffers(gl) {
+            return await this.buffer_cache.getValue(gl);
+        }
+    }
+    return DomainBufferMixin;
+}
+export { domainBufferMixin };

package/lib/grids/Geostationary.d.ts

@@ -0,0 +1,35 @@
+import { WebGLAnyRenderingContext } from "../AutumnTypes";
+import { StructuredGrid } from "./StructuredGrid";
+declare const GeostationaryImage_base: import("./Grid").AbstractConstructor<import("./GridCoordinates").GridCoordinateIntf> & typeof StructuredGrid;
+/**
+ * Grid for geostationary satellite images
+ *
+ * ## 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 GeostationaryImage extends GeostationaryImage_base {
+    readonly satellite_lon: number;
+    readonly ll_x: number;
+    readonly ll_y: number;
+    readonly ur_x: number;
+    readonly ur_y: number;
+    private readonly vpp;
+    constructor(ni: number, nj: number, ll_x: number, ll_y: number, ur_x: number, ur_y: number, satellite_lon: number, thin_x?: number, thin_y?: number);
+    protected makeDomainBuffers(gl: WebGLAnyRenderingContext): Promise<{
+        vertices: import("autumn-wgl").WGLBuffer;
+        texcoords: import("autumn-wgl").WGLBuffer;
+    }>;
+    transform(x: number, y: number, opts?: {
+        inverse?: boolean;
+    }): [number, number];
+    copy(): GeostationaryImage;
+    /** @internal */
+    getThinnedGrid(thin_fac: number, map_max_zoom: number): this;
+}
+export { GeostationaryImage };

package/lib/grids/Geostationary.js

@@ -0,0 +1,47 @@
+import { geostationaryProjection } from "../Map";
+import { gridCoordinateMixin } from "./GridCoordinates";
+import { StructuredGrid, makeCartesianDomainBuffers } from "./StructuredGrid";
+/**
+ * Grid for geostationary satellite images
+ *
+ * ## 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 GeostationaryImage extends gridCoordinateMixin(StructuredGrid) {
+    constructor(ni, nj, ll_x, ll_y, ur_x, ur_y, satellite_lon, thin_x, thin_y) {
+        super('geostationary', false, ni, nj, thin_x, thin_y);
+        this.satellite_lon = satellite_lon;
+        this.ll_x = ll_x;
+        this.ll_y = ll_y;
+        this.ur_x = ur_x;
+        this.ur_y = ur_y;
+        //this.vpp = verticalPerspective({lon_0: satellite_lon, lat_0: 0, alt: 35786023.0, a: 6378137.0, b: 6356752.31414});
+        this.vpp = geostationaryProjection({ lon_0: satellite_lon, alt: 35786023.0 + 6378137.0, a: 6378137.0, b: 6356752.31414 });
+        this.setupCoordinateCaches(ll_x, ur_x, ll_y, ur_y);
+    }
+    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 await makeCartesianDomainBuffers(gl, this, simplify_ni, simplify_nj, { margin_r: false, margin_s: false });
+    }
+    transform(x, y, opts) {
+        opts = opts === undefined ? {} : opts;
+        const inverse = opts.inverse === undefined ? false : opts.inverse;
+        return this.vpp(x, y, { inverse: inverse });
+    }
+    copy() {
+        return new GeostationaryImage(this.ni, this.nj, this.ll_x, this.ll_y, this.ur_x, this.ur_y, this.satellite_lon);
+    }
+    /** @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 GeostationaryImage(ni, nj, ll_x, ll_y, ur_x, ur_y, this.satellite_lon, this.thin_x * thin_x, this.thin_y * thin_y);
+    }
+}
+export { GeostationaryImage };

package/lib/grids/Grid.d.ts

@@ -0,0 +1,36 @@
+import { TypedArray } from "../AutumnTypes";
+interface EarthCoords {
+    lons: Float32Array;
+    lats: Float32Array;
+}
+interface GridCoords {
+    x: Float32Array;
+    y: Float32Array;
+}
+type GridType = 'latlon' | 'latlonrot' | 'lcc' | 'unstructured' | 'radar' | 'geostationary';
+declare const WGS84_SEMIMAJOR = 6378137;
+declare const WGS84_SEMIMINOR = 6356752.314245;
+/** The base class for grid types */
+declare abstract class Grid {
+    readonly type: GridType;
+    readonly ni: number;
+    readonly nj: number;
+    readonly is_conformal: boolean;
+    constructor(type: GridType, is_conformal: boolean, ni: number, nj: number);
+    abstract getEarthCoords(): EarthCoords;
+    abstract getGridCoords(): GridCoords;
+    abstract transform(x: number, y: number, opts?: {
+        inverse?: boolean;
+    }): [number, number];
+    abstract sampleNearestGridPoint(lon: number, lat: number, ary: TypedArray): {
+        sample: number;
+        sample_lon: number;
+        sample_lat: number;
+    };
+    abstract getThinnedGrid(thin_fac: number, map_max_zoom: number): this;
+    abstract thinDataArray<ArrayType extends TypedArray>(original_grid: Grid, ary: ArrayType): ArrayType;
+    abstract copy(): Grid;
+}
+type AbstractConstructor<T> = abstract new (...args: any[]) => T;
+export { Grid, WGS84_SEMIMAJOR, WGS84_SEMIMINOR };
+export type { AbstractConstructor, EarthCoords, GridCoords, GridType };

package/lib/grids/Grid.js

@@ -0,0 +1,12 @@
+const WGS84_SEMIMAJOR = 6378137.0;
+const WGS84_SEMIMINOR = 6356752.314245;
+/** The base class for grid types */
+class Grid {
+    constructor(type, is_conformal, ni, nj) {
+        this.type = type;
+        this.is_conformal = is_conformal;
+        this.ni = ni;
+        this.nj = nj;
+    }
+}
+export { Grid, WGS84_SEMIMAJOR, WGS84_SEMIMINOR };

package/lib/grids/GridCoordinates.d.ts

@@ -0,0 +1,10 @@
+import { AbstractConstructor, EarthCoords, Grid, GridCoords } from "./Grid";
+type GridElement = 'center' | 'edge';
+interface GridCoordinateIntf {
+    setupCoordinateCaches(start_i: number, end_i: number, start_j: number, end_j: number): void;
+    getEarthCoords(ni?: number, nj?: number, which_i?: GridElement, which_j?: GridElement): EarthCoords;
+    getGridCoords(): GridCoords;
+}
+declare function gridCoordinateMixin<G extends AbstractConstructor<Grid>>(base: G): AbstractConstructor<GridCoordinateIntf> & G;
+export { gridCoordinateMixin };
+export type { GridElement, GridCoordinateIntf };

package/lib/grids/GridCoordinates.js

@@ -0,0 +1,64 @@
+import { Cache } from "../utils";
+function gridCoordinateMixin(base) {
+    class GridCoordinates extends base {
+        constructor() {
+            super(...arguments);
+            this.ll_cache = null;
+            this.gc_cache = null;
+        }
+        setupCoordinateCaches(start_i, end_i, start_j, end_j) {
+            const di = (end_i - start_i) / (this.ni - 1);
+            const dj = (end_j - start_j) / (this.nj - 1);
+            this.ll_cache = new Cache((ni, nj, which_i, which_j) => {
+                const ni_grid = which_i == 'center' ? ni : ni + 1;
+                const nj_grid = which_j == 'center' ? nj : nj + 1;
+                const ni_grid_full = which_i == 'center' ? this.ni : this.ni + 1;
+                const nj_grid_full = which_j == 'center' ? this.nj : this.nj + 1;
+                const ni_offset = which_i == 'center' ? 0 : -di / 2;
+                const nj_offset = which_j == 'center' ? 0 : -dj / 2;
+                const lons = new Float32Array(ni_grid * nj_grid);
+                const lats = new Float32Array(ni_grid * nj_grid);
+                const di_req = (ni_grid_full - 1) / (ni_grid - 1) * di;
+                const dj_req = (nj_grid_full - 1) / (nj_grid - 1) * dj;
+                for (let i = 0; i < ni_grid; i++) {
+                    const x = start_i + i * di_req + ni_offset;
+                    for (let j = 0; j < nj_grid; j++) {
+                        const y = start_j + j * dj_req + nj_offset;
+                        const [lon, lat] = this.transform(x, y, { inverse: true });
+                        const idx = i + j * ni_grid;
+                        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] = start_i + i * di;
+                }
+                for (let j = 0; j < this.nj; j++) {
+                    y[j] = start_j + j * dj;
+                }
+                return { x: x, y: y };
+            });
+        }
+        getEarthCoords(ni, nj, which_i, which_j) {
+            if (this.ll_cache === null)
+                throw "Need to set up coordinate caches first";
+            ni = ni === undefined ? this.ni : ni;
+            nj = nj === undefined ? this.nj : nj;
+            which_i = which_i === undefined ? 'center' : which_i;
+            which_j = which_j === undefined ? 'center' : which_j;
+            return this.ll_cache.getValue(ni, nj, which_i, which_j);
+        }
+        getGridCoords() {
+            if (this.gc_cache === null)
+                throw "Need to set up coordinate caches first";
+            return this.gc_cache.getValue();
+        }
+    }
+    return GridCoordinates;
+}
+export { gridCoordinateMixin };