autumnplot-gl 2.2.3 → 3.1.0

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,11 +67,33 @@ 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;
+    }
+    /**
+     * Update the field displayed as a paintball plot
+     * @param field - The new field to display as a paintball plot
+     */
+    async updateField(field) {
+        this.field = field;
+        if (this.gl_elems === null)
+            return;
+        const gl = this.gl_elems.gl;
+        gl.pixelStorei(gl.UNPACK_ALIGNMENT, 2);
+        const tex_data = this.field.getTextureData();
+        const { format, type, row_alignment } = getGLFormatTypeAlignment(gl, !(tex_data instanceof Float32Array));
+        const fill_image = { 'format': format, 'type': type,
+            'width': this.field.grid.ni, 'height': this.field.grid.nj, 'image': tex_data,
+            'mag_filter': gl.NEAREST, 'row_alignment': row_alignment,
+        };
+        if (this.fill_texture === null) {
+            this.fill_texture = new WGLTexture(gl, fill_image);
+        }
+        else {
+            this.fill_texture.setImageData(fill_image);
+        }
     }
     /**
      * @internal
@@ -79,29 +105,23 @@ class Paintball extends PlotComponent {
         const { vertices: verts_buf, texcoords: tex_coords_buf } = await this.field.grid.getWGLBuffers(gl);
         const vertices = verts_buf;
         const texcoords = tex_coords_buf;
-        gl.pixelStorei(gl.UNPACK_ALIGNMENT, 2);
-        const { format, type, row_alignment } = getGLFormatTypeAlignment(gl, this.field.isFloat16());
-        const fill_image = { 'format': format, 'type': type,
-            'width': this.field.grid.ni, 'height': this.field.grid.nj, 'image': this.field.getTextureData(),
-            'mag_filter': gl.NEAREST, 'row_alignment': row_alignment,
-        };
-        const fill_texture = new WGLTexture(gl, fill_image);
         this.gl_elems = {
-            program: program, vertices: vertices, fill_texture: fill_texture, texcoords: texcoords,
+            gl: gl, program: program, vertices: vertices, texcoords: texcoords,
         };
+        this.updateField(this.field);
     }
     /**
      * @internal
      * Render the paintball plot
      */
     render(gl, matrix) {
-        if (this.gl_elems === null)
+        if (this.gl_elems === null || this.fill_texture === null)
             return;
         const gl_elems = this.gl_elems;
         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': gl_elems.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/PlotComponent.d.ts

@@ -1,5 +1,5 @@
 import * as Comlink from 'comlink';
-import { MapType } from './Map';
+import { MapLikeType } from './Map';
 import { WebGLAnyRenderingContext } from './AutumnTypes';
 declare const layer_worker: Comlink.Remote<{
     makeBBElements: (field_lats: Float32Array, field_lons: Float32Array, field_ni: number, field_nj: number, thin_fac_base: number, max_zoom: number) => {
@@ -11,15 +11,15 @@ declare const layer_worker: Comlink.Remote<{
         tex_coords: Float32Array;
         grid_cell_size: Float32Array;
     };
-    makePolyLines: (lines: import("./AutumnTypes").LineSpec[]) => import("./AutumnTypes").PolylineSpec;
+    makePolyLines: (lines: import("./AutumnTypes").LineData[]) => import("./AutumnTypes").Polyline;
 }>;
-declare abstract class PlotComponent {
+declare abstract class PlotComponent<MapType extends MapLikeType> {
     abstract onAdd(map: MapType, gl: WebGLAnyRenderingContext): Promise<void>;
     abstract render(gl: WebGLAnyRenderingContext, matrix: number[] | Float32Array): void;
 }
 declare function getGLFormatTypeAlignment(gl: WebGLAnyRenderingContext, is_float16: boolean): {
-    format: number;
-    type: number;
+    format: 33325 | 33326 | 6409;
+    type: 36193 | 5131 | 5126;
     row_alignment: number;
 };
 export { PlotComponent, layer_worker, getGLFormatTypeAlignment };

package/lib/PlotLayer.d.ts

@@ -1,12 +1,14 @@
 import { WebGLAnyRenderingContext } from './AutumnTypes';
-import { MapType } from './Map';
+import { MapLikeType } from './Map';
 import { PlotComponent } from './PlotComponent';
-declare abstract class PlotLayerBase {
+declare abstract class PlotLayerBase<MapType extends MapLikeType> {
     readonly type: 'custom';
     readonly id: string;
+    protected map: MapType;
     constructor(id: string);
     abstract onAdd(map: MapType, gl: WebGLAnyRenderingContext): void;
     abstract render(gl: WebGLAnyRenderingContext, matrix: number[] | Float32Array): void;
+    protected repaint(): void;
 }
 /**
  * A static map layer. The data are assumed to be static in time. If the data have a time component (e.g., a model forecast), an {@link MultiPlotLayer}
@@ -17,19 +19,19 @@ declare abstract class PlotLayerBase {
  * const wind_speed_layer = new PlotLayer('wind-speed-fill', wind_speed_fill);
  * const barb_layer = new PlotLayer('barbs', wind_barbs);
  */
-declare class PlotLayer extends PlotLayerBase {
+declare class PlotLayer<MapType extends MapLikeType> extends PlotLayerBase<MapType> {
     private readonly field;
     /**
      * Create a map layer from a field
      * @param id    - A unique id for this layer
      * @param field - The field to plot in this layer
      */
-    constructor(id: string, field: PlotComponent);
+    constructor(id: string, field: PlotComponent<MapType>);
     /**
      * @internal
      * Add this layer to a map
      */
-    onAdd(map: MapType, gl: WebGLAnyRenderingContext): void;
+    onAdd(map: MapType, gl: WebGLAnyRenderingContext): Promise<void>;
     /**
      * @internal
      * Render this layer
@@ -50,10 +52,9 @@ declare class PlotLayer extends PlotLayerBase {
  * // Set the date/time in the map layer
  * height_layer.setActiveKey('20230112_1200');
  */
-declare class MultiPlotLayer extends PlotLayerBase {
+declare class MultiPlotLayer<MapType extends MapLikeType> extends PlotLayerBase<MapType> {
     private fields;
     private field_key;
-    private map;
     private gl;
     /**
      * Create a time-varying map layer
@@ -72,7 +73,7 @@ declare class MultiPlotLayer extends PlotLayerBase {
     render(gl: WebGLAnyRenderingContext, matrix: number[] | Float32Array): void;
     /**
      * Set the active key
-     * @param key - The new key
+     * @param key - The new key. The field with that key is plotted immediately.
      */
     setActiveKey(key: string): void;
     /**
@@ -81,11 +82,10 @@ declare class MultiPlotLayer extends PlotLayerBase {
      */
     getKeys(): string[];
     /**
-     * Add a field valid at a specific date/time
+     * Add a field with a given key
      * @param field - The field to add
-     * @param dt    - The date/time at which the field is valid
+     * @param key   - The key to associate with the field
      */
-    addField(field: PlotComponent, key: string): void;
-    private repaintIfNecessary;
+    addField(field: PlotComponent<MapType>, key: string): void;
 }
 export { PlotLayer, MultiPlotLayer };

package/lib/PlotLayer.js

@@ -2,6 +2,12 @@ class PlotLayerBase {
     constructor(id) {
         this.type = 'custom';
         this.id = id;
+        this.map = null;
+    }
+    repaint() {
+        if (this.map !== null) {
+            this.map.triggerRepaint();
+        }
     }
 }
 /**
@@ -27,8 +33,9 @@ class PlotLayer extends PlotLayerBase {
      * @internal
      * Add this layer to a map
      */
-    onAdd(map, gl) {
-        this.field.onAdd(map, gl);
+    async onAdd(map, gl) {
+        this.map = map;
+        await this.field.onAdd(map, gl);
     }
     /**
      * @internal
@@ -73,10 +80,10 @@ class MultiPlotLayer extends PlotLayerBase {
         this.gl = gl;
         Object.values(this.fields).forEach(field => {
             field.onAdd(map, gl).then(res => {
-                this.repaintIfNecessary(null);
+                this.repaint();
             });
         });
-        this.repaintIfNecessary(null);
+        this.repaint();
     }
     /**
      * @internal
@@ -90,12 +97,12 @@ class MultiPlotLayer extends PlotLayerBase {
     }
     /**
      * Set the active key
-     * @param key - The new key
+     * @param key - The new key. The field with that key is plotted immediately.
      */
     setActiveKey(key) {
         const old_field_key = this.field_key;
         this.field_key = key;
-        this.repaintIfNecessary(old_field_key);
+        this.repaint();
     }
     /**
      * Get a list of all dates/times that have been added to the layer
@@ -105,15 +112,15 @@ class MultiPlotLayer extends PlotLayerBase {
         return Object.keys(this.fields);
     }
     /**
-     * Add a field valid at a specific date/time
+     * Add a field with a given key
      * @param field - The field to add
-     * @param dt    - The date/time at which the field is valid
+     * @param key   - The key to associate with the field
      */
     addField(field, key) {
         const old_field_key = this.field_key;
         if (this.map !== null && this.gl !== null && field !== null) {
             field.onAdd(this.map, this.gl).then(res => {
-                this.repaintIfNecessary(null);
+                this.repaint();
             });
         }
         this.fields[key] = field;
@@ -121,10 +128,5 @@ class MultiPlotLayer extends PlotLayerBase {
             this.field_key = key;
         }
     }
-    repaintIfNecessary(old_field_key) {
-        if (this.map !== null && old_field_key !== this.field_key) {
-            this.map.triggerRepaint();
-        }
-    }
 }
 export { PlotLayer, MultiPlotLayer };

package/lib/PlotLayer.worker.d.ts

@@ -1,4 +1,4 @@
-import { PolylineSpec, LineSpec } from "./AutumnTypes";
+import { LineData, Polyline } from "./AutumnTypes";
 declare function makeBBElements(field_lats: Float32Array, field_lons: Float32Array, field_ni: number, field_nj: number, thin_fac_base: number, max_zoom: number): {
     pts: Float32Array;
     tex_coords: Float32Array;
@@ -8,7 +8,7 @@ declare function makeDomainVerticesAndTexCoords(field_lats: Float32Array, field_
     tex_coords: Float32Array;
     grid_cell_size: Float32Array;
 };
-declare function makePolylines(lines: LineSpec[]): PolylineSpec;
+declare function makePolylines(lines: LineData[]): Polyline;
 declare const ep_interface: {
     makeBBElements: typeof makeBBElements;
     makeDomainVerticesAndTexCoords: typeof makeDomainVerticesAndTexCoords;

package/lib/PlotLayer.worker.js

@@ -239,13 +239,16 @@ 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 (v.length === undefined) {
+        if (typeof v === 'number') {
             n_verts = 1;
         }
-        else if (v[0].length === undefined) {
-            n_verts = v.length;
+        else if (typeof v[0] === 'number') {
+            n_verts = 1;
         }
         else {
             n_verts = v[0].length;
@@ -253,85 +256,121 @@ function makePolylines(lines) {
         return [k, n_verts];
     }));
     n_points_per_vert['extrusion'] = 2;
-    const n_verts = lines.map(l => l['verts'].length).reduce((a, b) => a + b);
-    const n_out_verts = (n_verts - lines.length) * 6;
+    n_points_per_vert['vertices'] += 1;
+    const n_verts = lines.map(l => l.vertices.length).reduce((a, b) => a + b);
+    const n_out_verts = n_verts * 4 - lines.length * 2;
     const ary_lens = Object.fromEntries(Object.entries(n_points_per_vert).map(([k, nppv]) => [k, n_out_verts * nppv]));
     let ret = {
-        'verts': new Float32Array(ary_lens['verts']),
-        'origin': new Float32Array(ary_lens['origin']),
-        'extrusion': new Float32Array(ary_lens['extrusion']),
-        'zoom': new Float32Array(ary_lens['zoom']),
-        'texcoords': new Float32Array(ary_lens['texcoords']),
+        vertices: new Float32Array(ary_lens['vertices']),
+        extrusion: new Float32Array(ary_lens['extrusion']),
     };
+    if ('offsets' in lines[0]) {
+        ret.offsets = new Float32Array(ary_lens['offsets']);
+    }
+    if ('data' in lines[0]) {
+        ret.data = new Float32Array(ary_lens['data']);
+    }
+    if ('zoom' in lines[0]) {
+        ret.zoom = new Float32Array(ary_lens['zoom']);
+    }
     let ilns = Object.fromEntries(Object.keys(ary_lens).map(k => [k, 0]));
-    const compute_normal_vec = (pt1, pt2) => {
+    const compute_normal_vec = (pt1, pt2, flip_y_coord) => {
         const line_vec_x = pt2[0] - pt1[0];
         const line_vec_y = pt2[1] - pt1[1];
         const line_vec_mag = Math.hypot(line_vec_x, line_vec_y);
-        return [line_vec_y / line_vec_mag, -line_vec_x / line_vec_mag];
+        const ext_x = line_vec_y / line_vec_mag;
+        const ext_y = -line_vec_x / line_vec_mag;
+        return [ext_x, flip_y_coord ? -ext_y : ext_y];
     };
     lines.forEach(line => {
-        const verts = line['verts'];
-        const texcoords = line['texcoords'];
-        let ary_ivt = ilns['verts'];
+        const verts = line.vertices.map(v => {
+            const v_ll = new LngLat(...v).toMercatorCoord();
+            return [v_ll.x, v_ll.y];
+        });
+        const has_offsets = line.offsets !== undefined;
+        const extrusion_verts = has_offsets ? line.offsets : verts;
         let pt_prev, pt_this = verts[0], pt_next = verts[1];
-        let tc_prev, tc_this = texcoords[0], tc_next = texcoords[1];
-        let [ext_x, ext_y] = compute_normal_vec(pt_this, pt_next);
-        ret['verts'][ary_ivt + 0] = pt_this[0];
-        ret['verts'][ary_ivt + 1] = pt_this[1];
-        ret['texcoords'][ary_ivt + 0] = tc_this[0];
-        ret['texcoords'][ary_ivt + 1] = tc_this[1];
-        ret['extrusion'][ary_ivt + 0] = ext_x;
-        ret['extrusion'][ary_ivt + 1] = ext_y;
+        let ept_prev, ept_this = extrusion_verts[0], ept_next = extrusion_verts[1];
+        let len_prev, len_this = 0;
+        let [ext_x, ext_y] = compute_normal_vec(ept_this, ept_next, !has_offsets);
+        ret.vertices[ilns.vertices++] = pt_this[0];
+        ret.vertices[ilns.vertices++] = pt_this[1];
+        ret.vertices[ilns.vertices++] = len_this;
+        ret.extrusion[ilns.extrusion++] = ext_x;
+        ret.extrusion[ilns.extrusion++] = ext_y;
         for (let ivt = 1; ivt < verts.length; ivt++) {
             pt_this = verts[ivt];
             pt_prev = verts[ivt - 1];
-            tc_this = texcoords[ivt];
-            tc_prev = texcoords[ivt - 1];
-            [ext_x, ext_y] = compute_normal_vec(pt_prev, pt_this);
-            ary_ivt = ilns['verts'] + (1 + (ivt - 1) * 4) * n_points_per_vert['verts'];
-            ret['verts'][ary_ivt + 0] = pt_prev[0];
-            ret['verts'][ary_ivt + 1] = pt_prev[1];
-            ret['verts'][ary_ivt + 2] = pt_prev[0];
-            ret['verts'][ary_ivt + 3] = pt_prev[1];
-            ret['verts'][ary_ivt + 4] = pt_this[0];
-            ret['verts'][ary_ivt + 5] = pt_this[1];
-            ret['verts'][ary_ivt + 6] = pt_this[0];
-            ret['verts'][ary_ivt + 7] = pt_this[1];
-            ret['texcoords'][ary_ivt + 0] = tc_prev[0];
-            ret['texcoords'][ary_ivt + 1] = tc_prev[1];
-            ret['texcoords'][ary_ivt + 2] = tc_prev[0];
-            ret['texcoords'][ary_ivt + 3] = tc_prev[1];
-            ret['texcoords'][ary_ivt + 4] = tc_this[0];
-            ret['texcoords'][ary_ivt + 5] = tc_this[1];
-            ret['texcoords'][ary_ivt + 6] = tc_this[0];
-            ret['texcoords'][ary_ivt + 7] = tc_this[1];
-            ret['extrusion'][ary_ivt + 0] = ext_x;
-            ret['extrusion'][ary_ivt + 1] = ext_y;
-            ret['extrusion'][ary_ivt + 2] = -ext_x;
-            ret['extrusion'][ary_ivt + 3] = -ext_y;
-            ret['extrusion'][ary_ivt + 4] = ext_x;
-            ret['extrusion'][ary_ivt + 5] = ext_y;
-            ret['extrusion'][ary_ivt + 6] = -ext_x;
-            ret['extrusion'][ary_ivt + 7] = -ext_y;
+            ept_this = extrusion_verts[ivt];
+            ept_prev = extrusion_verts[ivt - 1];
+            [ext_x, ext_y] = compute_normal_vec(ept_prev, ept_this, !has_offsets);
+            len_prev = len_this;
+            len_this += Math.hypot(verts[ivt - 1][0] - verts[ivt][0], verts[ivt - 1][1] - verts[ivt][1]);
+            ret.vertices[ilns.vertices++] = pt_prev[0];
+            ret.vertices[ilns.vertices++] = pt_prev[1];
+            ret.vertices[ilns.vertices++] = len_prev;
+            ret.vertices[ilns.vertices++] = pt_prev[0];
+            ret.vertices[ilns.vertices++] = pt_prev[1];
+            ret.vertices[ilns.vertices++] = len_prev;
+            ret.vertices[ilns.vertices++] = pt_this[0];
+            ret.vertices[ilns.vertices++] = pt_this[1];
+            ret.vertices[ilns.vertices++] = len_this;
+            ret.vertices[ilns.vertices++] = pt_this[0];
+            ret.vertices[ilns.vertices++] = pt_this[1];
+            ret.vertices[ilns.vertices++] = len_this;
+            ret.extrusion[ilns.extrusion++] = ext_x;
+            ret.extrusion[ilns.extrusion++] = ext_y;
+            ret.extrusion[ilns.extrusion++] = -ext_x;
+            ret.extrusion[ilns.extrusion++] = -ext_y;
+            ret.extrusion[ilns.extrusion++] = ext_x;
+            ret.extrusion[ilns.extrusion++] = ext_y;
+            ret.extrusion[ilns.extrusion++] = -ext_x;
+            ret.extrusion[ilns.extrusion++] = -ext_y;
         }
-        ret['verts'][ary_ivt + 8] = pt_this[0];
-        ret['verts'][ary_ivt + 9] = pt_this[1];
-        ret['texcoords'][ary_ivt + 8] = tc_this[0];
-        ret['texcoords'][ary_ivt + 9] = tc_this[1];
-        ret['extrusion'][ary_ivt + 8] = -ext_x;
-        ret['extrusion'][ary_ivt + 9] = -ext_y;
-        for (let ivt = 0; ivt < (verts.length - 1) * 6 * n_points_per_vert['origin']; ivt += n_points_per_vert['origin']) {
-            line['origin'].forEach((cd, icd) => {
-                ret['origin'][ilns['origin'] + ivt + icd] = cd;
-            });
+        ret.vertices[ilns.vertices++] = pt_this[0];
+        ret.vertices[ilns.vertices++] = pt_this[1];
+        ret.vertices[ilns.vertices++] = len_this;
+        ret.extrusion[ilns.extrusion++] = -ext_x;
+        ret.extrusion[ilns.extrusion++] = -ext_y;
+        if ('offsets' in ret) {
+            const offsets = line.offsets;
+            let off_prev, off_this = offsets[0];
+            ret.offsets[ilns.offsets++] = off_this[0];
+            ret.offsets[ilns.offsets++] = off_this[1];
+            for (let ivt = 1; ivt < offsets.length; ivt++) {
+                off_this = offsets[ivt];
+                off_prev = offsets[ivt - 1];
+                ret.offsets[ilns.offsets++] = off_prev[0];
+                ret.offsets[ilns.offsets++] = off_prev[1];
+                ret.offsets[ilns.offsets++] = off_prev[0];
+                ret.offsets[ilns.offsets++] = off_prev[1];
+                ret.offsets[ilns.offsets++] = off_this[0];
+                ret.offsets[ilns.offsets++] = off_this[1];
+                ret.offsets[ilns.offsets++] = off_this[0];
+                ret.offsets[ilns.offsets++] = off_this[1];
+            }
+            ret.offsets[ilns.offsets++] = off_this[0];
+            ret.offsets[ilns.offsets++] = off_this[1];
         }
-        for (let ivt = 0; ivt < (verts.length - 1) * 6 * n_points_per_vert['zoom']; ivt += n_points_per_vert['zoom']) {
-            ret['zoom'][ilns['zoom'] + ivt] = line['zoom'];
+        if ('data' in ret) {
+            const data = line.data;
+            let data_prev, data_this = data[0];
+            ret.data[ilns.data++] = data_this;
+            for (let ivt = 1; ivt < data.length; ivt++) {
+                data_this = data[ivt];
+                data_prev = data[ivt - 1];
+                ret.data[ilns.data++] = data_prev;
+                ret.data[ilns.data++] = data_prev;
+                ret.data[ilns.data++] = data_this;
+                ret.data[ilns.data++] = data_this;
+            }
+            ret.data[ilns.data++] = data_this;
+        }
+        if ('zoom' in ret) {
+            for (let ivt = 0; ivt < verts.length * 4 - 2; ivt++) {
+                ret.zoom[ilns.zoom++] = line['zoom'];
+            }
         }
-        Object.keys(ilns).forEach(k => {
-            ilns[k] += (verts.length - 1) * 6 * n_points_per_vert[k];
-        });
     });
     return ret;
 }

package/lib/PolylineCollection.d.ts

@@ -1,17 +1,28 @@
-import { WGLTextureSpec } from "autumn-wgl";
-import { PolylineSpec, LineSpec, WebGLAnyRenderingContext } from "./AutumnTypes";
+import { LineData, WebGLAnyRenderingContext } from "./AutumnTypes";
+import { ColorMap } from "./Colormap";
+interface PolylineCollectionOpts {
+    offset_scale?: number;
+    color?: string;
+    cmap?: ColorMap;
+    line_width?: number;
+}
 declare class PolylineCollection {
     readonly width: number;
-    readonly scale: number;
+    readonly scale: number | null;
     private readonly program;
-    private readonly origin;
-    private readonly offset;
+    private readonly vertices;
     private readonly extrusion;
+    private readonly offset;
     private readonly min_zoom;
-    private readonly texture;
-    private readonly texcoords;
-    constructor(gl: WebGLAnyRenderingContext, polyline: PolylineSpec, tex_image: WGLTextureSpec, line_width: number, offset_scale: number);
+    private readonly line_data;
+    private readonly line_texture;
+    private readonly color;
+    private readonly cmap_min;
+    private readonly cmap_max;
+    private readonly index_map;
+    private readonly cmap_nonlin_texture;
+    private constructor();
+    static make(gl: WebGLAnyRenderingContext, lines: LineData[], opts?: PolylineCollectionOpts): Promise<PolylineCollection>;
     render(gl: WebGLAnyRenderingContext, matrix: number[] | Float32Array, [map_width, map_height]: [number, number], map_zoom: number, map_bearing: number, map_pitch: number): void;
 }
 export { PolylineCollection };
-export type { PolylineSpec, LineSpec };