autumnplot-gl 3.0.0 → 3.2.0

package/lib/StationPlot.js

@@ -0,0 +1,73 @@
+import { kdTree } from "kd-tree-javascript";
+import { LngLat } from "./Map";
+import { PlotComponent } from "./PlotComponent";
+import { getMinZoom, normalizeOptions } from "./utils";
+class UnstructuredGrid {
+    constructor(coords) {
+        this.coords = coords;
+    }
+    getZoomThinning(thin_fac, map_max_zoom) {
+        let min_label_lon = null, min_label_lat = null, max_label_lon = null, max_label_lat = null;
+        this.coords.forEach(coord => {
+            if (min_label_lon === null || coord.lon < min_label_lon)
+                min_label_lon = coord.lon;
+            if (max_label_lon === null || coord.lon > max_label_lon)
+                max_label_lon = coord.lon;
+            if (min_label_lat === null || coord.lat < min_label_lat)
+                min_label_lat = coord.lat;
+            if (max_label_lat === null || coord.lat > max_label_lat)
+                max_label_lat = coord.lat;
+        });
+        if (min_label_lon === null || min_label_lat === null || max_label_lon === null || max_label_lat === null)
+            return [];
+        const kd_nodes = this.coords.map(c => ({ lon: c.lon, lat: c.lat, min_zoom: map_max_zoom }));
+        const tree = new kdTree(kd_nodes, (a, b) => Math.hypot(a.lon - b.lon, a.lat - b.lat), ['lon', 'lat']);
+        const { x: min_label_x, y: max_label_y } = new LngLat(min_label_lon, min_label_lat).toMercatorCoord();
+        const { x: max_label_x, y: min_label_y } = new LngLat(max_label_lon, max_label_lat).toMercatorCoord();
+        const thin_grid_width = max_label_x - min_label_x;
+        const thin_grid_height = max_label_y - min_label_y;
+        const ni_thin_grid = Math.round(thin_grid_width * thin_fac); // thin_fac was 4 / contour_label_spacing for the contour labels
+        const nj_thin_grid = Math.round(thin_grid_height * thin_fac);
+        const thin_grid_xs = [];
+        const thin_grid_ys = [];
+        for (let idx = 0; idx < ni_thin_grid; idx++) {
+            thin_grid_xs.push(min_label_x + (idx / ni_thin_grid) * thin_grid_width);
+        }
+        for (let jdy = 0; jdy < nj_thin_grid; jdy++) {
+            thin_grid_ys.push(min_label_y + (jdy / nj_thin_grid) * thin_grid_height);
+        }
+        for (let idx = 0; idx < ni_thin_grid; idx++) {
+            for (let jdy = 0; jdy < nj_thin_grid; jdy++) {
+                const zoom = getMinZoom(jdy, idx, Math.pow(2, map_max_zoom));
+                const grid_x = thin_grid_xs[idx];
+                const grid_y = thin_grid_ys[jdy];
+                const ll = LngLat.fromMercatorCoord(grid_x, grid_y);
+                const [label, dist] = tree.nearest({ lon: ll.lng, lat: ll.lat, min_zoom: 0 }, 1)[0];
+                label.min_zoom = zoom;
+            }
+        }
+        return kd_nodes.map(n => n.min_zoom);
+    }
+}
+class ObsField {
+    constructor(data) {
+        this.grid = new UnstructuredGrid(data.map(d => d.coord));
+        this.data = data;
+    }
+}
+const station_plot_opts_defaults = {};
+class StationPlot extends PlotComponent {
+    constructor(field, data_positions, opts) {
+        super();
+        this.field = field;
+        this.data_positions = data_positions;
+        this.opts = normalizeOptions(opts, station_plot_opts_defaults);
+    }
+    async onAdd(map, gl) {
+    }
+    render(gl, matrix) {
+        if (matrix instanceof Float32Array)
+            matrix = [...matrix];
+    }
+}
+export { StationPlot };

package/lib/TextCollection.d.ts

@@ -1,4 +1,5 @@
 import { WebGLAnyRenderingContext } from "./AutumnTypes";
+import { Color } from "./Color";
 import { WGLBuffer, WGLProgram, WGLTexture } from "autumn-wgl";
 interface TextSpec {
     lat: number;
@@ -12,8 +13,8 @@ interface TextCollectionOptions {
     horizontal_align?: HorizontalAlign;
     vertical_align?: VerticalAlign;
     font_size?: number;
-    text_color?: [number, number, number];
-    halo_color?: [number, number, number];
+    text_color?: Color;
+    halo_color?: Color;
     halo?: boolean;
 }
 declare class TextCollection {

package/lib/TextCollection.js

@@ -1,4 +1,5 @@
 import { isWebGL2Ctx } from "./AutumnTypes";
+import { Color } from "./Color";
 import { LngLat } from "./Map";
 import { Cache, normalizeOptions } from "./utils";
 import { WGLBuffer, WGLProgram, WGLTexture } from "autumn-wgl";
@@ -45,8 +46,8 @@ varying highp vec2 v_tex_coord;
 uniform sampler2D u_sdf_sampler;
 uniform int u_is_halo;
 
-uniform lowp vec3 u_text_color;
-uniform lowp vec3 u_halo_color;
+uniform lowp vec4 u_text_color;
+uniform lowp vec4 u_halo_color;
 
 #define SDF_FILL 0.75
 #define SDF_HALO 0.45
@@ -57,18 +58,21 @@ void main() {
     lowp float step_width = 0.08;
     lowp float alpha = smoothstep(SDF_FILL - step_width, SDF_FILL + step_width, sdf_val);
 
-    lowp vec3 color = u_is_halo == 1 ? u_halo_color : u_text_color;
+    lowp vec4 color = u_is_halo == 1 ? u_halo_color : u_text_color;
 
     if (u_is_halo == 1) {
         alpha = min(smoothstep(SDF_HALO - step_width, SDF_HALO + step_width, sdf_val), 1.0 - alpha);
     }
 
-    gl_FragColor = vec4(color, alpha);
+    color.a *= alpha;
+    gl_FragColor = color;
 }`
 const program_cache = new Cache((gl) => new WGLProgram(gl, text_vertex_shader_src, text_fragment_shader_src));
 const PADDING = 3;
 function parseFontPBF(data) {
     const readGlyph = (tag, glyph, pbf) => {
+        if (pbf === undefined)
+            return;
         switch (tag) {
             case 1:
                 glyph.id = pbf.readVarint();
@@ -94,12 +98,16 @@ function parseFontPBF(data) {
         }
     };
     const readFontStack = (tag, glyphs, pbf) => {
+        if (glyphs === undefined || pbf === undefined)
+            return;
         if (tag == 3) {
             const glyph = pbf.readMessage(readGlyph, {});
             glyphs.push(glyph);
         }
     };
     const readFontStacks = (tag, glyphs, pbf) => {
+        if (pbf === undefined)
+            return;
         if (tag == 1) {
             pbf.readMessage(readFontStack, glyphs);
         }
@@ -119,6 +127,8 @@ function createAtlas(pbf_glyphs) {
     const glyphs = {};
     glyph_bins.forEach(glyph_bin => {
         const { bin, glyph } = glyph_bin;
+        if (bin.x === undefined || bin.y === undefined)
+            throw `Potpack couldn't pack this pot, I guess?`;
         glyphs[glyph.id] = {
             id: glyph.id, width: glyph.width, height: glyph.height, left: glyph.left, top: glyph.top,
             atlas_i: bin.x, atlas_j: bin.y, advance: glyph.advance
@@ -149,8 +159,8 @@ const text_collection_opt_defaults = {
     horizontal_align: 'left',
     vertical_align: 'baseline',
     font_size: 12,
-    text_color: [0, 0, 0],
-    halo_color: [0, 0, 0],
+    text_color: new Color([0, 0, 0, 1]),
+    halo_color: new Color([0, 0, 0, 1]),
     halo: false
 };
 class TextCollection {
@@ -229,22 +239,22 @@ class TextCollection {
                 tc_data[i_tc++] = glyph_info.atlas_j / font_atlas.atlas_height;
                 x_offset += glyph_info.advance - glyph_info.left;
             }
-            if (opts.horizontal_align == 'center') {
+            if (this.opts.horizontal_align == 'center') {
                 for (let i = init_i_off; i < init_i_off + text.length * 12; i += 2) {
                     offset_data[i] -= x_offset / 2;
                 }
             }
-            else if (opts.horizontal_align == 'right') {
+            else if (this.opts.horizontal_align == 'right') {
                 for (let i = init_i_off; i < init_i_off + text.length * 12; i += 2) {
                     offset_data[i] -= x_offset;
                 }
             }
-            if (opts.vertical_align == 'top') {
+            if (this.opts.vertical_align == 'top') {
                 for (let i = init_i_off + 1; i < init_i_off + text.length * 12; i += 2) {
                     offset_data[i] -= (font_atlas.baseline - font_atlas.top);
                 }
             }
-            else if (opts.vertical_align == 'middle') {
+            else if (this.opts.vertical_align == 'middle') {
                 for (let i = init_i_off + 1; i < init_i_off + text.length * 12; i += 2) {
                     offset_data[i] -= (font_atlas.baseline - font_atlas.top) / 2;
                 }
@@ -261,7 +271,7 @@ class TextCollection {
     render(gl, matrix, [map_width, map_height], map_zoom) {
         const uniforms = {
             'u_matrix': matrix, 'u_map_width': map_width, 'u_map_height': map_height, 'u_map_zoom': map_zoom, 'u_font_size': this.opts.font_size,
-            'u_text_color': this.opts.text_color, 'u_halo_color': this.opts.halo_color, 'u_offset': 0
+            'u_text_color': this.opts.text_color.toRGBATuple(), 'u_halo_color': this.opts.halo_color.toRGBATuple(), 'u_offset': 0
         };
         uniforms['u_is_halo'] = this.opts.halo ? 1 : 0;
         this.program.use({ 'a_pos': this.anchors, 'a_offset': this.offsets, 'a_tex_coord': this.texcoords }, uniforms, { 'u_sdf_sampler': this.texture });