autumnplot-gl 3.0.0 → 3.1.0

package/lib/Barbs.d.ts

@@ -26,8 +26,8 @@ interface BarbsOptions {
 declare class Barbs<ArrayType extends TypedArray, MapType extends MapLikeType> extends PlotComponent<MapType> {
     /** The vector field */
     private fields;
-    readonly color: [number, number, number];
-    readonly thin_fac: number;
+    readonly opts: Required<BarbsOptions>;
+    private readonly color_rgb;
     private gl_elems;
     /**
      * Create a field of wind barbs

package/lib/Barbs.js

@@ -1,6 +1,6 @@
 import { PlotComponent } from "./PlotComponent";
 import { BillboardCollection } from './BillboardCollection';
-import { hex2rgba } from './utils';
+import { hex2rgb, normalizeOptions } from './utils';
 const BARB_DIMS = {
     BB_WIDTH: 85,
     BB_HEIGHT: 256,
@@ -97,6 +97,10 @@ function _createBarbTexture() {
     return canvas;
 }
 let BARB_TEXTURE = null;
+const barb_opt_defaults = {
+    color: '#000000',
+    thin_fac: 1
+};
 /**
  * A class representing a field of wind barbs. The barbs are automatically thinned based on the zoom level on the map; the user only has to provide a
  * thinning factor at zoom level 1.
@@ -114,9 +118,9 @@ class Barbs extends PlotComponent {
     constructor(fields, opts) {
         super();
         this.fields = fields;
-        const color = hex2rgba(opts.color || '#000000');
-        this.color = [color[0], color[1], color[2]];
-        this.thin_fac = opts.thin_fac || 1;
+        this.opts = normalizeOptions(opts, barb_opt_defaults);
+        const color_rgb = hex2rgb(this.opts.color);
+        this.color_rgb = [color_rgb[0], color_rgb[1], color_rgb[2]];
         this.gl_elems = null;
     }
     /**
@@ -142,7 +146,7 @@ class Barbs extends PlotComponent {
             BARB_TEXTURE = _createBarbTexture();
         }
         const barb_image = { format: gl.RGBA, type: gl.UNSIGNED_BYTE, image: BARB_TEXTURE, mag_filter: gl.NEAREST };
-        const barb_billboards = new BillboardCollection(this.fields, this.thin_fac, map_max_zoom, barb_image, BARB_DIMS, this.color, 0.1);
+        const barb_billboards = new BillboardCollection(this.fields, this.opts.thin_fac, map_max_zoom, barb_image, BARB_DIMS, this.color_rgb, 0.1);
         await barb_billboards.setup(gl);
         this.gl_elems = {
             map: map, barb_billboards: barb_billboards

package/lib/Contour.d.ts

@@ -28,9 +28,7 @@ interface ContourOptions {
  */
 declare class Contour<ArrayType extends TypedArray, MapType extends MapLikeType> extends PlotComponent<MapType> {
     private field;
-    readonly color: string;
-    readonly interval: number;
-    readonly levels: number[];
+    readonly opts: Required<ContourOptions>;
     private gl_elems;
     private contours;
     /**

package/lib/Contour.js

@@ -4,6 +4,11 @@ import { PolylineCollection } from './PolylineCollection';
 import { TextCollection } from './TextCollection';
 import { hex2rgb, normalizeOptions } from './utils';
 import { kdTree } from 'kd-tree-javascript';
+const contour_opt_defaults = {
+    color: '#000000',
+    interval: 1,
+    levels: undefined
+};
 /**
  * A field of contoured data.
  * @example
@@ -20,9 +25,7 @@ class Contour extends PlotComponent {
     constructor(field, opts) {
         super();
         this.field = field;
-        this.interval = opts.interval || 1;
-        this.levels = opts.levels || [];
-        this.color = opts.color || '#000000';
+        this.opts = normalizeOptions(opts, contour_opt_defaults);
         this.gl_elems = null;
         this.contours = null;
     }
@@ -39,11 +42,11 @@ class Contour extends PlotComponent {
         const line_data = Object.values(contour_data).flat().map(c => {
             return { vertices: c };
         });
-        this.contours = await PolylineCollection.make(gl, line_data, { line_width: 2, color: this.color });
+        this.contours = await PolylineCollection.make(gl, line_data, { line_width: 2, color: this.opts.color });
         this.gl_elems.map.triggerRepaint();
     }
     async getContours() {
-        return await this.field.getContours({ interval: this.interval, levels: this.levels });
+        return await this.field.getContours({ interval: this.opts.interval, levels: this.opts.levels });
     }
     /**
      * @internal

package/lib/ContourCreator.js

@@ -12,48 +12,12 @@ async function contourCreator(data, grid, opts) {
         throw "Must supply either an interval or levels to contourCreator()";
     }
     const interval = opts.interval === undefined ? 0 : opts.interval;
-    const levels = opts.levels === undefined ? [] : [...opts.levels];
     const msm = await initMSModule();
     const grid_coords = grid.getGridCoords();
-    const grid_data = new msm.FloatList();
-    grid_data.resize(grid.ni * grid.nj, 0);
-    const tex_data = data;
-    tex_data.forEach((v, i) => grid_data.set(i, v));
-    const grid_x = new msm.FloatList();
-    grid_x.resize(grid.ni, 0);
-    grid_coords.x.forEach((v, i) => grid_x.set(i, v));
-    const grid_y = new msm.FloatList();
-    grid_y.resize(grid.nj, 0);
-    grid_coords.y.forEach((v, i) => grid_y.set(i, v));
-    if (levels.length == 0) {
-        const levels_cpp = msm.getContourLevelsFloat32(grid_data, grid.ni, grid.nj, interval);
-        for (let ilvl = 0; ilvl < levels_cpp.size(); ilvl++) {
-            levels.push(levels_cpp.get(ilvl));
-        }
-        levels_cpp.delete();
-    }
-    const contours = {};
-    levels.forEach(v => {
-        const contours_ = msm.makeContoursFloat32(grid_data, grid_x, grid_y, v);
-        contours[v] = [];
-        for (let icntr = 0; icntr < contours_.size(); icntr++) {
-            const contour = contours_.get(icntr);
-            const contour_point_list = contour.point_list;
-            contours[v].push([]);
-            for (let ipt = 0; ipt < contour_point_list.size(); ipt++) {
-                const pt = contour_point_list.get(ipt);
-                const [lon, lat] = grid.transform(pt.x, pt.y, { inverse: true });
-                contours[v][icntr].push([lon, lat]);
-                pt.delete();
-            }
-            contour_point_list.delete();
-            contour.delete();
-        }
-        contours_.delete();
-    });
-    grid_data.delete();
-    grid_x.delete();
-    grid_y.delete();
+    const getContourLevels = data instanceof Float32Array ? msm.getContourLevelsFloat32 : msm.getContourLevelsFloat16;
+    const makeContours = data instanceof Float32Array ? msm.makeContoursFloat32 : msm.makeContoursFloat16;
+    const levels = opts.levels === undefined ? getContourLevels(data, grid.ni, grid.nj, interval) : opts.levels;
+    const contours = makeContours(data, grid_coords.x, grid_coords.y, levels, (x, y) => grid.transform(x, y, { inverse: true }));
     return contours;
 }
 export { contourCreator, initMSModule };

package/lib/Fill.d.ts

@@ -23,8 +23,7 @@ interface RasterOptions {
 }
 declare class PlotComponentFill<ArrayType extends TypedArray, MapType extends MapLikeType> extends PlotComponent<MapType> {
     private field;
-    readonly cmap: ColorMap;
-    readonly opacity: number;
+    readonly opts: Required<ContourFillOptions>;
     private readonly cmap_image;
     private readonly index_map;
     private gl_elems;

package/lib/Fill.js

@@ -1,7 +1,7 @@
 import { PlotComponent, getGLFormatTypeAlignment } from './PlotComponent';
-import { makeIndexMap, makeTextureImage } from './Colormap';
+import { ColorMap, makeIndexMap, makeTextureImage } from './Colormap';
 import { WGLProgram, WGLTexture } from 'autumn-wgl';
-import { hex2rgb } from './utils';
+import { hex2rgb, normalizeOptions } from './utils';
 const contourfill_vertex_shader_src = `uniform mat4 u_matrix;
 uniform int u_offset;
 
@@ -50,14 +50,22 @@ void main() {
     color.a = color.a * u_opacity;
     gl_FragColor = color;
 }`
+const default_cmap = new ColorMap([0, 1], ['#000000'], { overflow_color: '#000000', underflow_color: '#000000' });
+const contour_fill_opt_defaults = {
+    cmap: default_cmap,
+    opacity: 1,
+};
+const raster_opt_defaults = {
+    cmap: default_cmap,
+    opacity: 1,
+};
 class PlotComponentFill extends PlotComponent {
     constructor(field, opts) {
         super();
         this.field = field;
-        this.cmap = opts.cmap;
-        this.opacity = opts.opacity || 1.;
-        this.cmap_image = makeTextureImage(this.cmap);
-        this.index_map = makeIndexMap(this.cmap);
+        this.opts = normalizeOptions(opts, contour_fill_opt_defaults);
+        this.cmap_image = makeTextureImage(this.opts.cmap);
+        this.index_map = makeIndexMap(this.opts.cmap);
         this.gl_elems = null;
         this.fill_texture = null;
         this.image_mag_filter = null;
@@ -113,9 +121,10 @@ class PlotComponentFill extends PlotComponent {
         const gl_elems = this.gl_elems;
         if (matrix instanceof Float32Array)
             matrix = [...matrix];
-        const underflow_color = this.cmap.underflow_color === null ? [0, 0, 0, 0] : hex2rgb(this.cmap.underflow_color.color).concat(this.cmap.underflow_color.opacity);
-        const overflow_color = this.cmap.overflow_color === null ? [0, 0, 0, 0] : hex2rgb(this.cmap.overflow_color.color).concat(this.cmap.overflow_color.opacity);
-        gl_elems.program.use({ 'a_pos': gl_elems.vertices, 'a_tex_coord': gl_elems.texcoords }, { 'u_cmap_min': this.cmap.levels[0], 'u_cmap_max': this.cmap.levels[this.cmap.levels.length - 1], 'u_matrix': matrix, 'u_opacity': this.opacity,
+        const cmap = this.opts.cmap;
+        const underflow_color = cmap.underflow_color === null ? [0, 0, 0, 0] : hex2rgb(cmap.underflow_color.color).concat(cmap.underflow_color.opacity);
+        const overflow_color = cmap.overflow_color === null ? [0, 0, 0, 0] : hex2rgb(cmap.overflow_color.color).concat(cmap.overflow_color.opacity);
+        gl_elems.program.use({ 'a_pos': gl_elems.vertices, 'a_tex_coord': gl_elems.texcoords }, { 'u_cmap_min': cmap.levels[0], 'u_cmap_max': cmap.levels[cmap.levels.length - 1], 'u_matrix': matrix, 'u_opacity': this.opts.opacity,
             'u_n_index': this.index_map.length, 'u_underflow_color': underflow_color, 'u_overflow_color': overflow_color, 'u_offset': 0 }, { 'u_fill_sampler': this.fill_texture, 'u_cmap_sampler': gl_elems.cmap_texture, 'u_cmap_nonlin_sampler': gl_elems.cmap_nonlin_texture });
         gl.enable(gl.BLEND);
         gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);

package/lib/Hodographs.d.ts

@@ -17,8 +17,7 @@ interface HodographOptions {
 /** A class representing a a field of hodograph plots */
 declare class Hodographs<MapType extends MapLikeType> extends PlotComponent<MapType> {
     private profile_field;
-    readonly bgcolor: string;
-    readonly thin_fac: number;
+    readonly opts: Required<HodographOptions>;
     private gl_elems;
     private line_elems;
     private readonly hodo_scale;

package/lib/Hodographs.js

@@ -1,7 +1,7 @@
 import { PlotComponent } from "./PlotComponent";
 import { PolylineCollection } from "./PolylineCollection";
 import { BillboardCollection } from "./BillboardCollection";
-import { getMinZoom, hex2rgb } from './utils';
+import { getMinZoom, hex2rgb, normalizeOptions } from './utils';
 import { ColorMap } from "./Colormap";
 const LINE_WIDTH = 4;
 const BG_MAX_RING_MAG = 40;
@@ -41,6 +41,10 @@ function _createHodoBackgroundTexture() {
 ;
 let HODO_BG_TEXTURE = null;
 const HODO_CMAP = new ColorMap([0, 1, 3, 6, 9], ['#ffffcc', '#a1dab4', '#41b6c4', '#225ea8']);
+const hodograph_opt_defaults = {
+    bgcolor: '#000000',
+    thin_fac: 1
+};
 /** A class representing a a field of hodograph plots */
 class Hodographs extends PlotComponent {
     /**
@@ -50,10 +54,8 @@ class Hodographs extends PlotComponent {
      */
     constructor(profile_field, opts) {
         super();
-        opts = opts || {};
         this.profile_field = profile_field;
-        this.bgcolor = opts.bgcolor || '#000000';
-        this.thin_fac = opts.thin_fac || 1;
+        this.opts = normalizeOptions(opts, hodograph_opt_defaults);
         this.hodo_scale = (HODO_BG_DIMS.BB_TEX_WIDTH - LINE_WIDTH / 2) / (HODO_BG_DIMS.BB_TEX_WIDTH * BG_MAX_RING_MAG);
         this.bg_size = 140;
         this.gl_elems = null;
@@ -72,7 +74,7 @@ class Hodographs extends PlotComponent {
         this.gl_elems.bg_billboard.updateField(field.getStormMotionGrid());
         const profiles = this.profile_field.profiles;
         const hodo_polyline = profiles.map(prof => {
-            const zoom = getMinZoom(prof['jlat'], prof['ilon'], this.thin_fac);
+            const zoom = getMinZoom(prof['jlat'], prof['ilon'], this.opts.thin_fac);
             return {
                 'offsets': [...prof['u']].map((u, ipt) => [u - prof['smu'], prof['v'][ipt] - prof['smv']]),
                 'vertices': [...prof['u']].map(u => [prof['lon'], prof['lat']]),
@@ -82,7 +84,7 @@ class Hodographs extends PlotComponent {
         });
         const hodo_line = await PolylineCollection.make(gl, hodo_polyline, { line_width: 2.5, cmap: HODO_CMAP, offset_scale: this.hodo_scale * this.bg_size });
         const sm_polyline = profiles.map(prof => {
-            const zoom = getMinZoom(prof['jlat'], prof['ilon'], this.thin_fac);
+            const zoom = getMinZoom(prof['jlat'], prof['ilon'], this.opts.thin_fac);
             const sm_mag = Math.hypot(prof['smu'], prof['smv']);
             const sm_ang = Math.PI / 2 - Math.atan2(-prof['smv'], -prof['smu']);
             const buffer = 2;
@@ -93,7 +95,7 @@ class Hodographs extends PlotComponent {
                 'zoom': zoom
             };
         });
-        const sm_line = await PolylineCollection.make(gl, sm_polyline, { line_width: 1.5, color: this.bgcolor, offset_scale: this.hodo_scale * this.bg_size });
+        const sm_line = await PolylineCollection.make(gl, sm_polyline, { line_width: 1.5, color: this.opts.bgcolor, offset_scale: this.hodo_scale * this.bg_size });
         this.line_elems = {
             hodo_line: hodo_line, sm_line: sm_line
         };
@@ -108,7 +110,7 @@ class Hodographs extends PlotComponent {
         }
         const bg_image = { 'format': gl.RGBA, 'type': gl.UNSIGNED_BYTE, 'image': HODO_BG_TEXTURE, 'mag_filter': gl.NEAREST };
         const max_zoom = map.getMaxZoom();
-        const bg_billboard = new BillboardCollection(this.profile_field.getStormMotionGrid(), this.thin_fac, max_zoom, bg_image, HODO_BG_DIMS, hex2rgb(this.bgcolor), this.bg_size * 0.004);
+        const bg_billboard = new BillboardCollection(this.profile_field.getStormMotionGrid(), this.opts.thin_fac, max_zoom, bg_image, HODO_BG_DIMS, hex2rgb(this.opts.bgcolor), this.bg_size * 0.004);
         await bg_billboard.setup(gl);
         this.gl_elems = {
             gl: gl, map: map, bg_billboard: bg_billboard

package/lib/Paintball.d.ts

@@ -22,8 +22,8 @@ interface PaintballOptions {
  */
 declare class Paintball<ArrayType extends TypedArray, MapType extends MapLikeType> extends PlotComponent<MapType> {
     private field;
-    readonly colors: number[];
-    readonly opacity: number;
+    readonly opts: Required<PaintballOptions>;
+    private readonly color_components;
     private gl_elems;
     private fill_texture;
     /**

package/lib/Paintball.js

@@ -1,5 +1,5 @@
 import { PlotComponent, getGLFormatTypeAlignment } from "./PlotComponent";
-import { hex2rgba } from "./utils";
+import { hex2rgba, normalizeOptions } from "./utils";
 import { WGLProgram, WGLTexture } from "autumn-wgl";
 const paintball_vertex_shader_src = `uniform mat4 u_matrix;
 uniform int u_offset;
@@ -45,6 +45,10 @@ void main() {
     color.a = color.a * u_opacity;
     gl_FragColor = color;
 }`
+const paintball_opt_defaults = {
+    colors: ['#000000'],
+    opacity: 1
+};
 /**
  * A class representing a paintball plot, which is a plot of objects in every member of an ensemble. Objects are usually defined by a single threshold on
  * a field (such as simulated reflectivity greater than 40 dBZ), but could in theory be defined by any arbitrarily complicated method. In autumnplot-gl,
@@ -63,10 +67,8 @@ class Paintball extends PlotComponent {
     constructor(field, opts) {
         super();
         this.field = field;
-        opts = opts !== undefined ? opts : {};
-        const colors = opts.colors !== undefined ? [...opts.colors] : ['#000000'];
-        this.colors = colors.reverse().map(color => hex2rgba(color)).flat();
-        this.opacity = opts.opacity !== undefined ? opts.opacity : 1.;
+        this.opts = normalizeOptions(opts, paintball_opt_defaults);
+        this.color_components = [...this.opts.colors].reverse().map(color => hex2rgba(color)).flat();
         this.gl_elems = null;
         this.fill_texture = null;
     }
@@ -119,7 +121,7 @@ class Paintball extends PlotComponent {
         if (matrix instanceof Float32Array)
             matrix = [...matrix];
         // Render to framebuffer
-        gl_elems.program.use({ 'a_pos': gl_elems.vertices, 'a_tex_coord': gl_elems.texcoords }, { 'u_matrix': matrix, 'u_opacity': this.opacity, 'u_colors': this.colors, 'u_num_colors': this.colors.length / 4, 'u_offset': 0 }, { 'u_fill_sampler': this.fill_texture });
+        gl_elems.program.use({ 'a_pos': gl_elems.vertices, 'a_tex_coord': gl_elems.texcoords }, { 'u_matrix': matrix, 'u_opacity': this.opts.opacity, 'u_colors': this.color_components, 'u_num_colors': this.opts.colors.length, 'u_offset': 0 }, { 'u_fill_sampler': this.fill_texture });
         gl.enable(gl.BLEND);
         gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
         gl_elems.program.draw();

package/lib/PlotLayer.worker.js

@@ -239,6 +239,9 @@ function makePolylinesMiter(lines) {
 }
 */
 function makePolylines(lines) {
+    if (lines.length == 0) {
+        return { vertices: new Float32Array([]), extrusion: new Float32Array([]) };
+    }
     const n_points_per_vert = Object.fromEntries(Object.entries(lines[0]).map(([k, v]) => {
         let n_verts;
         if (typeof v === 'number') {