autumnplot-gl 2.2.3 → 3.1.0

package/lib/PolylineCollection.js

@@ -1,20 +1,39 @@
+import { Float16Array } from "@petamoriken/float16";
 import { WGLBuffer, WGLProgram, WGLTexture } from "autumn-wgl";
+import { makeIndexMap, makeTextureImage } from "./Colormap";
+import { getGLFormatTypeAlignment, layer_worker } from "./PlotComponent";
+import { hex2rgba } from "./utils";
 const polyline_vertex_src = `uniform mat4 u_matrix;
 uniform int u_offset;
 
 attribute vec2 a_pos;
-attribute float a_min_zoom;
 attribute vec2 a_extrusion;
+attribute float a_data;
+
+#ifdef ZOOM
+attribute float a_min_zoom;
+#endif
+
+#ifdef OFFSET
 attribute vec2 a_offset;
-attribute vec2 a_tex_coord;
-uniform lowp float u_offset_scale;
-uniform lowp float u_map_aspect;
-uniform lowp float u_zoom;
+#endif
+
 uniform lowp float u_line_width;
+uniform lowp float u_map_width;
+uniform lowp float u_map_height;
 uniform highp float u_map_bearing;
 
+#ifdef ZOOM
+uniform lowp float u_zoom;
+#endif
 
-varying highp vec2 v_tex_coord;
+#ifdef OFFSET
+uniform lowp float u_offset_scale;
+#endif
+
+#ifdef DATA
+varying highp float v_data;
+#endif
 
 mat4 scalingMatrix(float x_scale, float y_scale, float z_scale) {
     return mat4(x_scale, 0.0,     0.0,     0.0,
@@ -29,8 +48,8 @@ mat4 rotationZMatrix(float angle) {
 
     return mat4( c,  s,  0., 0.,
                 -s,  c,  0., 0.,
-                    0., 0., 1., 0.,
-                    0., 0., 0., 1.);
+                 0., 0., 1., 0.,
+                 0., 0., 0., 1.);
 }
 
 mat4 rotationXMatrix(float angle) {
@@ -38,9 +57,9 @@ mat4 rotationXMatrix(float angle) {
     float c = cos(angle);
 
     return mat4( 1.,  0., 0., 0.,
-                    0.,  c,  s,  0.,
-                    0., -s,  c,  0.,
-                    0.,  0., 0., 1.);
+                 0.,  c,  s,  0.,
+                 0., -s,  c,  0.,
+                 0.,  0., 0., 1.);
 }
 
 void main() {
@@ -49,47 +68,154 @@ void main() {
 
     vec4 center_pos = u_matrix * vec4(a_pos.xy + globe_offset, 0.0, 1.0);
     vec4 offset = vec4(0.0, 0.0, 0.0, 0.0);
-    
+
+#ifdef ZOOM
     if (u_zoom >= a_min_zoom) {
-        vec2 offset_2d = a_offset + u_line_width * a_extrusion;
+#endif
+
+        vec2 offset_ext = u_line_width * 1.5 * a_extrusion;
+
+        mat4 map_stretch_matrix = scalingMatrix(u_map_height / u_map_width, 1., 1.);
+        mat4 rotation_matrix = rotationZMatrix(radians(u_map_bearing));  
+        offset = map_stretch_matrix * rotation_matrix * vec4(offset_ext, 0., 0.);
 
-        mat4 rotation_matrix = rotationZMatrix(radians(u_map_bearing));
-        mat4 map_stretch_matrix = scalingMatrix(u_offset_scale, u_offset_scale / u_map_aspect, 1.);
-        offset = map_stretch_matrix * rotation_matrix * vec4(offset_2d, 0., 0.);
+#ifdef OFFSET
+        map_stretch_matrix = scalingMatrix(1., u_map_width / u_map_height, 1.);
+        vec2 offset_offset = u_offset_scale * a_offset;
+        offset += map_stretch_matrix * rotation_matrix * vec4(offset_offset, 0., 0.);
+#endif
+
+#ifdef ZOOM
     }
+#endif
 
     gl_Position = center_pos + offset;
-    v_tex_coord = a_tex_coord;
+
+#ifdef DATA
+    v_data = a_data;
+#endif
 }`
-const polyline_fragment_src = `varying highp vec2 v_tex_coord;
+const polyline_fragment_src = `#ifdef DATA
+varying highp float v_data;
 
-uniform sampler2D u_sampler;
+uniform sampler2D u_cmap_sampler;
+uniform sampler2D u_cmap_nonlin_sampler;
+uniform highp float u_cmap_min;
+uniform highp float u_cmap_max;
+uniform int u_n_index;
+#else
+uniform lowp vec4 u_color;
+#endif
 
 void main() {
-    if (v_tex_coord.x > 1.0) {
+    lowp vec4 color;
+#ifdef DATA
+    lowp float index_buffer = 1. / (2. * float(u_n_index));
+    lowp float normed_val = (v_data - u_cmap_min) / (u_cmap_max - u_cmap_min);
+
+    if (normed_val < 0.0 || normed_val > 1.0) {
         discard;
     }
 
-    lowp vec4 tex_color = texture2D(u_sampler, v_tex_coord);
-    gl_FragColor = tex_color;
+    normed_val = index_buffer + normed_val * (1. - 2. * index_buffer); 
+    highp float nonlin_val = texture2D(u_cmap_nonlin_sampler, vec2(normed_val, 0.5)).r;
+    color = texture2D(u_cmap_sampler, vec2(nonlin_val, 0.5));
+#else
+    color = u_color;
+#endif
+    gl_FragColor = color;
 }`
 class PolylineCollection {
-    constructor(gl, polyline, tex_image, line_width, offset_scale) {
+    constructor(gl, polyline, opts) {
+        opts = opts === undefined ? {} : opts;
+        this.color = opts.color === undefined ? [0., 0., 0., 1.] : hex2rgba(opts.color);
+        const line_width = opts.line_width === undefined ? 1 : opts.line_width;
         this.width = line_width;
-        this.scale = offset_scale;
-        this.program = new WGLProgram(gl, polyline_vertex_src, polyline_fragment_src);
-        this.origin = new WGLBuffer(gl, polyline['origin'], 2, gl.TRIANGLE_STRIP);
-        this.offset = new WGLBuffer(gl, polyline['verts'], 2, gl.TRIANGLE_STRIP);
+        const shader_defines = [];
+        this.vertices = new WGLBuffer(gl, polyline['vertices'], 3, gl.TRIANGLE_STRIP);
         this.extrusion = new WGLBuffer(gl, polyline['extrusion'], 2, gl.TRIANGLE_STRIP);
-        this.min_zoom = new WGLBuffer(gl, polyline['zoom'], 1, gl.TRIANGLE_STRIP);
-        this.texture = new WGLTexture(gl, tex_image);
-        this.texcoords = new WGLBuffer(gl, polyline['texcoords'], 2, gl.TRIANGLE_STRIP);
+        if (polyline.offsets !== undefined) {
+            this.offset = new WGLBuffer(gl, polyline.offsets, 2, gl.TRIANGLE_STRIP);
+            this.scale = opts.offset_scale === undefined ? 1 : opts.offset_scale;
+            shader_defines.push('OFFSET');
+        }
+        else {
+            this.offset = null;
+            this.scale = null;
+        }
+        if (polyline.zoom !== undefined) {
+            this.min_zoom = new WGLBuffer(gl, polyline.zoom, 1, gl.TRIANGLE_STRIP);
+            shader_defines.push('ZOOM');
+        }
+        else {
+            this.min_zoom = null;
+        }
+        this.cmap_min = -3.40282347e+38;
+        this.cmap_max = 3.40282347e+38;
+        if (polyline.data !== undefined) {
+            // TAS: this needs some cleanup (there's some repated code between here and the contour fills that should be combined?)
+            this.min_zoom = new WGLBuffer(gl, polyline.zoom, 1, gl.TRIANGLE_STRIP);
+            shader_defines.push('DATA');
+            const { format: format_nonlin, type: type_nonlin, row_alignment: row_alignment_nonlin } = getGLFormatTypeAlignment(gl, true);
+            let tex_image;
+            if (opts.cmap === undefined) {
+                tex_image = { 'format': gl.RGBA, 'type': gl.UNSIGNED_BYTE, 'width': 1, 'height': 1, 'image': new Uint8Array(this.color), 'mag_filter': gl.NEAREST };
+                this.index_map = new Float16Array([0., 1.]);
+            }
+            else {
+                tex_image = { 'format': gl.RGBA, 'type': gl.UNSIGNED_BYTE, 'image': makeTextureImage(opts.cmap), 'mag_filter': gl.NEAREST };
+                this.cmap_min = opts.cmap.levels[0];
+                this.cmap_max = opts.cmap.levels[opts.cmap.levels.length - 1];
+                this.index_map = makeIndexMap(opts.cmap);
+            }
+            const cmap_nonlin_image = { 'format': format_nonlin, 'type': type_nonlin,
+                'width': this.index_map.length, 'height': 1,
+                'image': new Uint16Array(this.index_map.buffer),
+                'mag_filter': gl.LINEAR, 'row_alignment': row_alignment_nonlin,
+            };
+            this.cmap_nonlin_texture = new WGLTexture(gl, cmap_nonlin_image);
+            this.line_texture = new WGLTexture(gl, tex_image);
+            this.line_data = new WGLBuffer(gl, polyline['data'], 1, gl.TRIANGLE_STRIP);
+        }
+        else {
+            this.line_texture = null;
+            this.line_data = null;
+            this.index_map = null;
+        }
+        this.program = new WGLProgram(gl, polyline_vertex_src, polyline_fragment_src, { define: shader_defines });
+    }
+    static async make(gl, lines, opts) {
+        const polylines = await layer_worker.makePolyLines(lines);
+        return new PolylineCollection(gl, polylines, opts);
     }
     render(gl, matrix, [map_width, map_height], map_zoom, map_bearing, map_pitch) {
         if (matrix instanceof Float32Array)
             matrix = [...matrix];
-        this.program.use({ 'a_pos': this.origin, 'a_offset': this.offset, 'a_extrusion': this.extrusion, 'a_min_zoom': this.min_zoom, 'a_tex_coord': this.texcoords }, { 'u_offset_scale': this.scale * (map_height / map_width), 'u_line_width': this.width, 'u_matrix': matrix,
-            'u_map_aspect': map_height / map_width, 'u_zoom': map_zoom, 'u_map_bearing': map_bearing, 'u_offset': 0 }, { 'u_sampler': this.texture });
+        const attributes = { 'a_pos': this.vertices, 'a_extrusion': this.extrusion };
+        const uniforms = {
+            'u_matrix': matrix, 'u_line_width': this.width, 'u_map_width': map_width, 'u_map_height': map_height, 'u_map_bearing': map_bearing, 'u_offset': 0
+        };
+        const textures = {};
+        if (this.offset !== null) {
+            attributes['a_offset'] = this.offset;
+            uniforms['u_offset_scale'] = this.scale * (map_height / map_width);
+        }
+        if (this.min_zoom !== null) {
+            attributes['a_min_zoom'] = this.min_zoom;
+            uniforms['u_zoom'] = map_zoom;
+        }
+        if (this.line_data !== null && this.line_texture !== null) {
+            attributes['a_data'] = this.line_data;
+            textures['u_cmap_sampler'] = this.line_texture;
+            textures['u_cmap_nonlin_sampler'] = this.cmap_nonlin_texture;
+            uniforms['u_cmap_min'] = this.cmap_min;
+            uniforms['u_cmap_max'] = this.cmap_max;
+            uniforms['u_n_index'] = this.index_map.length;
+        }
+        else {
+            uniforms['u_color'] = this.color;
+        }
+        this.program.use(attributes, uniforms, textures);
         gl.enable(gl.BLEND);
         gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
         this.program.draw();

package/lib/RawField.d.ts

@@ -1,170 +1,13 @@
 import { Float16Array } from "@petamoriken/float16";
-import { TypedArray, WebGLAnyRenderingContext, WindProfile } from "./AutumnTypes";
-import { WGLBuffer } from "autumn-wgl";
-interface EarthCoords {
-    lons: Float32Array;
-    lats: Float32Array;
-}
-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;
-    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 getEarthCoords(): EarthCoords;
-    abstract getGridCoords(): GridCoords;
-    abstract transform(x: number, y: number, opts?: {
-        inverse?: boolean;
-    }): [number, number];
-    abstract getThinnedGrid(thin_x: number, thin_y: number): Grid;
-    getWGLBuffers(gl: WebGLAnyRenderingContext): Promise<{
-        vertices: WGLBuffer;
-        texcoords: WGLBuffer;
-        cellsize: WGLBuffer;
-    }>;
-    getWGLBillboardBuffers(gl: WebGLAnyRenderingContext, thin_fac: number, max_zoom: number): Promise<{
-        vertices: WGLBuffer;
-        texcoords: WGLBuffer;
-    }>;
-}
-/** A plate carree (a.k.a. lat/lon) grid with uniform grid spacing */
-declare class PlateCarreeGrid extends Grid {
-    readonly ll_lon: number;
-    readonly ll_lat: number;
-    readonly ur_lon: number;
-    readonly ur_lat: number;
-    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
-     * @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);
-    copy(opts?: {
-        ni?: number;
-        nj?: number;
-        ll_lon?: number;
-        ll_lat?: number;
-        ur_lon?: number;
-        ur_lat?: number;
-    }): PlateCarreeGrid;
-    /**
-     * 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): 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;
-    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;
-    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
-     * @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
-     */
-    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);
-    copy(opts?: {
-        ni?: number;
-        nj?: number;
-        ll_x?: number;
-        ll_y?: number;
-        ur_x?: number;
-        ur_y?: number;
-    }): LambertGrid;
-    /**
-     * 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): LambertGrid;
-}
+import { ContourData, TypedArray, WindProfile } from "./AutumnTypes";
+import { FieldContourOpts } from "./ContourCreator";
+import { Grid } from "./Grid";
 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<ArrayType extends TypedArray> {
     readonly grid: Grid;
     readonly data: ArrayType;
+    private readonly contour_cache;
     /**
      * Create a data field.
      * @param grid - The grid on which the data are defined
@@ -173,8 +16,7 @@ declare class RawScalarField<ArrayType extends TypedArray> {
     constructor(grid: Grid, data: ArrayType);
     /** @internal */
     getTextureData(): TextureDataType<ArrayType>;
-    isFloat16(): boolean;
-    getThinnedField(thin_x: number, thin_y: number): RawScalarField<ArrayType>;
+    getContours(opts: FieldContourOpts): Promise<ContourData>;
     /**
      * 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.
@@ -199,7 +41,6 @@ declare class RawVectorField<ArrayType extends TypedArray> {
     readonly u: RawScalarField<ArrayType>;
     readonly v: RawScalarField<ArrayType>;
     readonly relative_to: VectorRelativeTo;
-    private readonly rotate_cache;
     /**
      * Create a vector field.
      * @param grid - The grid on which the vector components are defined
@@ -208,9 +49,12 @@ declare class RawVectorField<ArrayType extends TypedArray> {
      * @param opts - Options for creating the vector field.
      */
     constructor(grid: Grid, u: ArrayType, v: ArrayType, opts?: RawVectorFieldOptions);
+    getTextureData(): {
+        u: TextureDataType<ArrayType>;
+        v: TextureDataType<ArrayType>;
+    };
     getThinnedField(thin_x: number, thin_y: number): RawVectorField<ArrayType>;
     get grid(): Grid;
-    toEarthRelative(): RawVectorField<ArrayType>;
 }
 /** A class grid of wind profiles */
 declare class RawProfileField {
@@ -225,5 +69,5 @@ declare class RawProfileField {
     /** Get the gridded storm motion vector field (internal method) */
     getStormMotionGrid(): RawVectorField<Float16Array>;
 }
-export { RawScalarField, RawVectorField, RawProfileField, PlateCarreeGrid, PlateCarreeRotatedGrid, LambertGrid, Grid };
-export type { GridType, RawVectorFieldOptions, VectorRelativeTo, TextureDataType };
+export { RawScalarField, RawVectorField, RawProfileField };
+export type { RawVectorFieldOptions, VectorRelativeTo, TextureDataType };