mapbox-gl 1.13.2

package/src/source/canvas_source.js

@@ -0,0 +1,238 @@
+// @flow
+
+import ImageSource from './image_source';
+
+import window from '../util/window';
+import rasterBoundsAttributes from '../data/raster_bounds_attributes';
+import SegmentVector from '../data/segment';
+import Texture from '../render/texture';
+import {ErrorEvent} from '../util/evented';
+import ValidationError from '../style-spec/error/validation_error';
+
+import type Map from '../ui/map';
+import type Dispatcher from '../util/dispatcher';
+import type {Evented} from '../util/evented';
+
+export type CanvasSourceSpecification = {|
+    "type": "canvas",
+    "coordinates": [[number, number], [number, number], [number, number], [number, number]],
+    "animate"?: boolean,
+    "canvas": string | HTMLCanvasElement
+|};
+
+/**
+ * Options to add a canvas source type to the map.
+ *
+ * @typedef {Object} CanvasSourceOptions
+ * @property {string} type Source type. Must be `"canvas"`.
+ * @property {string|HTMLCanvasElement} canvas Canvas source from which to read pixels. Can be a string representing the ID of the canvas element, or the `HTMLCanvasElement` itself.
+ * @property {Array<Array<number>>} coordinates Four geographical coordinates denoting where to place the corners of the canvas, specified in `[longitude, latitude]` pairs.
+ * @property {boolean} [animate=true] Whether the canvas source is animated. If the canvas is static (i.e. pixels do not need to be re-read on every frame), `animate` should be set to `false` to improve performance.
+ */
+
+/**
+ * A data source containing the contents of an HTML canvas. See {@link CanvasSourceOptions} for detailed documentation of options.
+ *
+ * @example
+ * // add to map
+ * map.addSource('some id', {
+ *    type: 'canvas',
+ *    canvas: 'idOfMyHTMLCanvas',
+ *    animate: true,
+ *    coordinates: [
+ *        [-76.54, 39.18],
+ *        [-76.52, 39.18],
+ *        [-76.52, 39.17],
+ *        [-76.54, 39.17]
+ *    ]
+ * });
+ *
+ * // update
+ * var mySource = map.getSource('some id');
+ * mySource.setCoordinates([
+ *     [-76.54335737228394, 39.18579907229748],
+ *     [-76.52803659439087, 39.1838364847587],
+ *     [-76.5295386314392, 39.17683392507606],
+ *     [-76.54520273208618, 39.17876344106642]
+ * ]);
+ *
+ * map.removeSource('some id');  // remove
+ */
+class CanvasSource extends ImageSource {
+    options: CanvasSourceSpecification;
+    animate: boolean;
+    canvas: HTMLCanvasElement;
+    width: number;
+    height: number;
+    play: () => void;
+    pause: () => void;
+    _playing: boolean;
+
+    /**
+     * @private
+     */
+    constructor(id: string, options: CanvasSourceSpecification, dispatcher: Dispatcher, eventedParent: Evented) {
+        super(id, options, dispatcher, eventedParent);
+
+        // We build in some validation here, since canvas sources aren't included in the style spec:
+        if (!options.coordinates) {
+            this.fire(new ErrorEvent(new ValidationError(`sources.${id}`, null, 'missing required property "coordinates"')));
+        } else if (!Array.isArray(options.coordinates) || options.coordinates.length !== 4 ||
+                options.coordinates.some(c => !Array.isArray(c) || c.length !== 2 || c.some(l => typeof l !== 'number'))) {
+            this.fire(new ErrorEvent(new ValidationError(`sources.${id}`, null, '"coordinates" property must be an array of 4 longitude/latitude array pairs')));
+        }
+
+        if (options.animate && typeof options.animate !== 'boolean') {
+            this.fire(new ErrorEvent(new ValidationError(`sources.${id}`, null, 'optional "animate" property must be a boolean value')));
+        }
+
+        if (!options.canvas) {
+            this.fire(new ErrorEvent(new ValidationError(`sources.${id}`, null, 'missing required property "canvas"')));
+        } else if (typeof options.canvas !== 'string' && !(options.canvas instanceof window.HTMLCanvasElement)) {
+            this.fire(new ErrorEvent(new ValidationError(`sources.${id}`, null, '"canvas" must be either a string representing the ID of the canvas element from which to read, or an HTMLCanvasElement instance')));
+        }
+
+        this.options = options;
+        this.animate = options.animate !== undefined ? options.animate : true;
+    }
+
+    /**
+     * Enables animation. The image will be copied from the canvas to the map on each frame.
+     * @method play
+     * @instance
+     * @memberof CanvasSource
+     */
+
+    /**
+     * Disables animation. The map will display a static copy of the canvas image.
+     * @method pause
+     * @instance
+     * @memberof CanvasSource
+     */
+
+    load() {
+        this._loaded = true;
+        if (!this.canvas) {
+            this.canvas = (this.options.canvas instanceof window.HTMLCanvasElement) ?
+                this.options.canvas :
+                window.document.getElementById(this.options.canvas);
+        }
+        this.width = this.canvas.width;
+        this.height = this.canvas.height;
+
+        if (this._hasInvalidDimensions()) {
+            this.fire(new ErrorEvent(new Error('Canvas dimensions cannot be less than or equal to zero.')));
+            return;
+        }
+
+        this.play = function() {
+            this._playing = true;
+            this.map.triggerRepaint();
+        };
+
+        this.pause = function() {
+            if (this._playing) {
+                this.prepare();
+                this._playing = false;
+            }
+        };
+
+        this._finishLoading();
+    }
+
+    /**
+     * Returns the HTML `canvas` element.
+     *
+     * @returns {HTMLCanvasElement} The HTML `canvas` element.
+     */
+    getCanvas() {
+        return this.canvas;
+    }
+
+    onAdd(map: Map) {
+        this.map = map;
+        this.load();
+        if (this.canvas) {
+            if (this.animate) this.play();
+        }
+    }
+
+    onRemove() {
+        this.pause();
+    }
+
+    /**
+     * Sets the canvas's coordinates and re-renders the map.
+     *
+     * @method setCoordinates
+     * @instance
+     * @memberof CanvasSource
+     * @param {Array<Array<number>>} coordinates Four geographical coordinates,
+     *   represented as arrays of longitude and latitude numbers, which define the corners of the canvas.
+     *   The coordinates start at the top left corner of the canvas and proceed in clockwise order.
+     *   They do not have to represent a rectangle.
+     * @returns {CanvasSource} this
+     */
+    // setCoordinates inherited from ImageSource
+
+    prepare() {
+        let resize = false;
+        if (this.canvas.width !== this.width) {
+            this.width = this.canvas.width;
+            resize = true;
+        }
+        if (this.canvas.height !== this.height) {
+            this.height = this.canvas.height;
+            resize = true;
+        }
+
+        if (this._hasInvalidDimensions()) return;
+
+        if (Object.keys(this.tiles).length === 0) return; // not enough data for current position
+
+        const context = this.map.painter.context;
+        const gl = context.gl;
+
+        if (!this.boundsBuffer) {
+            this.boundsBuffer = context.createVertexBuffer(this._boundsArray, rasterBoundsAttributes.members);
+        }
+
+        if (!this.boundsSegments) {
+            this.boundsSegments = SegmentVector.simpleSegment(0, 0, 4, 2);
+        }
+
+        if (!this.texture) {
+            this.texture = new Texture(context, this.canvas, gl.RGBA, {premultiply: true});
+        } else if (resize || this._playing) {
+            this.texture.update(this.canvas, {premultiply: true});
+        }
+
+        for (const w in this.tiles) {
+            const tile = this.tiles[w];
+            if (tile.state !== 'loaded') {
+                tile.state = 'loaded';
+                tile.texture = this.texture;
+            }
+        }
+    }
+
+    serialize(): Object {
+        return {
+            type: 'canvas',
+            coordinates: this.coordinates
+        };
+    }
+
+    hasTransition() {
+        return this._playing;
+    }
+
+    _hasInvalidDimensions() {
+        for (const x of [this.canvas.width, this.canvas.height]) {
+            if (isNaN(x) || x <= 0) return true;
+        }
+        return false;
+    }
+}
+
+export default CanvasSource;

package/src/source/geojson_source.js

@@ -0,0 +1,370 @@
+// @flow
+
+import {Event, ErrorEvent, Evented} from '../util/evented';
+
+import {extend} from '../util/util';
+import EXTENT from '../data/extent';
+import {ResourceType} from '../util/ajax';
+import browser from '../util/browser';
+
+import type {Source} from './source';
+import type Map from '../ui/map';
+import type Dispatcher from '../util/dispatcher';
+import type Tile from './tile';
+import type Actor from '../util/actor';
+import type {Callback} from '../types/callback';
+import type {GeoJSON, GeoJSONFeature} from '@mapbox/geojson-types';
+import type {GeoJSONSourceSpecification, PromoteIdSpecification} from '../style-spec/types';
+
+/**
+ * A source containing GeoJSON.
+ * (See the [Style Specification](https://www.mapbox.com/mapbox-gl-style-spec/#sources-geojson) for detailed documentation of options.)
+ *
+ * @example
+ * map.addSource('some id', {
+ *     type: 'geojson',
+ *     data: 'https://d2ad6b4ur7yvpq.cloudfront.net/naturalearth-3.3.0/ne_10m_ports.geojson'
+ * });
+ *
+ * @example
+ * map.addSource('some id', {
+ *    type: 'geojson',
+ *    data: {
+ *        "type": "FeatureCollection",
+ *        "features": [{
+ *            "type": "Feature",
+ *            "properties": {},
+ *            "geometry": {
+ *                "type": "Point",
+ *                "coordinates": [
+ *                    -76.53063297271729,
+ *                    39.18174077994108
+ *                ]
+ *            }
+ *        }]
+ *    }
+ * });
+ *
+ * @example
+ * map.getSource('some id').setData({
+ *   "type": "FeatureCollection",
+ *   "features": [{
+ *       "type": "Feature",
+ *       "properties": { "name": "Null Island" },
+ *       "geometry": {
+ *           "type": "Point",
+ *           "coordinates": [ 0, 0 ]
+ *       }
+ *   }]
+ * });
+ * @see [Draw GeoJSON points](https://www.mapbox.com/mapbox-gl-js/example/geojson-markers/)
+ * @see [Add a GeoJSON line](https://www.mapbox.com/mapbox-gl-js/example/geojson-line/)
+ * @see [Create a heatmap from points](https://www.mapbox.com/mapbox-gl-js/example/heatmap/)
+ * @see [Create and style clusters](https://www.mapbox.com/mapbox-gl-js/example/cluster/)
+ */
+class GeoJSONSource extends Evented implements Source {
+    type: 'geojson';
+    id: string;
+    minzoom: number;
+    maxzoom: number;
+    tileSize: number;
+    attribution: string;
+    promoteId: ?PromoteIdSpecification;
+
+    isTileClipped: boolean;
+    reparseOverscaled: boolean;
+    _data: GeoJSON | string;
+    _options: any;
+    workerOptions: any;
+    map: Map;
+    actor: Actor;
+    _loaded: boolean;
+    _collectResourceTiming: boolean;
+    _resourceTiming: Array<PerformanceResourceTiming>;
+    _removed: boolean;
+
+    /**
+     * @private
+     */
+    constructor(id: string, options: GeoJSONSourceSpecification & {workerOptions?: any, collectResourceTiming: boolean}, dispatcher: Dispatcher, eventedParent: Evented) {
+        super();
+
+        this.id = id;
+
+        // `type` is a property rather than a constant to make it easy for 3rd
+        // parties to use GeoJSONSource to build their own source types.
+        this.type = 'geojson';
+
+        this.minzoom = 0;
+        this.maxzoom = 18;
+        this.tileSize = 512;
+        this.isTileClipped = true;
+        this.reparseOverscaled = true;
+        this._removed = false;
+        this._loaded = false;
+
+        this.actor = dispatcher.getActor();
+        this.setEventedParent(eventedParent);
+
+        this._data = (options.data: any);
+        this._options = extend({}, options);
+
+        this._collectResourceTiming = options.collectResourceTiming;
+        this._resourceTiming = [];
+
+        if (options.maxzoom !== undefined) this.maxzoom = options.maxzoom;
+        if (options.type) this.type = options.type;
+        if (options.attribution) this.attribution = options.attribution;
+        this.promoteId = options.promoteId;
+
+        const scale = EXTENT / this.tileSize;
+
+        // sent to the worker, along with `url: ...` or `data: literal geojson`,
+        // so that it can load/parse/index the geojson data
+        // extending with `options.workerOptions` helps to make it easy for
+        // third-party sources to hack/reuse GeoJSONSource.
+        this.workerOptions = extend({
+            source: this.id,
+            cluster: options.cluster || false,
+            geojsonVtOptions: {
+                buffer: (options.buffer !== undefined ? options.buffer : 128) * scale,
+                tolerance: (options.tolerance !== undefined ? options.tolerance : 0.375) * scale,
+                extent: EXTENT,
+                maxZoom: this.maxzoom,
+                lineMetrics: options.lineMetrics || false,
+                generateId: options.generateId || false
+            },
+            superclusterOptions: {
+                maxZoom: options.clusterMaxZoom !== undefined ?
+                    Math.min(options.clusterMaxZoom, this.maxzoom - 1) :
+                    (this.maxzoom - 1),
+                minPoints: Math.max(2, options.clusterMinPoints || 2),
+                extent: EXTENT,
+                radius: (options.clusterRadius || 50) * scale,
+                log: false,
+                generateId: options.generateId || false
+            },
+            clusterProperties: options.clusterProperties,
+            filter: options.filter
+        }, options.workerOptions);
+    }
+
+    load() {
+        this.fire(new Event('dataloading', {dataType: 'source'}));
+        this._updateWorkerData((err) => {
+            if (err) {
+                this.fire(new ErrorEvent(err));
+                return;
+            }
+
+            const data: Object = {dataType: 'source', sourceDataType: 'metadata'};
+            if (this._collectResourceTiming && this._resourceTiming && (this._resourceTiming.length > 0)) {
+                data.resourceTiming = this._resourceTiming;
+                this._resourceTiming = [];
+            }
+
+            // although GeoJSON sources contain no metadata, we fire this event to let the SourceCache
+            // know its ok to start requesting tiles.
+            this.fire(new Event('data', data));
+        });
+    }
+
+    onAdd(map: Map) {
+        this.map = map;
+        this.load();
+    }
+
+    /**
+     * Sets the GeoJSON data and re-renders the map.
+     *
+     * @param {Object|string} data A GeoJSON data object or a URL to one. The latter is preferable in the case of large GeoJSON files.
+     * @returns {GeoJSONSource} this
+     */
+    setData(data: GeoJSON | string) {
+        this._data = data;
+        this.fire(new Event('dataloading', {dataType: 'source'}));
+        this._updateWorkerData((err) => {
+            if (err) {
+                this.fire(new ErrorEvent(err));
+                return;
+            }
+
+            const data: Object = {dataType: 'source', sourceDataType: 'content'};
+            if (this._collectResourceTiming && this._resourceTiming && (this._resourceTiming.length > 0)) {
+                data.resourceTiming = this._resourceTiming;
+                this._resourceTiming = [];
+            }
+            this.fire(new Event('data', data));
+        });
+
+        return this;
+    }
+
+    /**
+     * For clustered sources, fetches the zoom at which the given cluster expands.
+     *
+     * @param clusterId The value of the cluster's `cluster_id` property.
+     * @param callback A callback to be called when the zoom value is retrieved (`(error, zoom) => { ... }`).
+     * @returns {GeoJSONSource} this
+     */
+    getClusterExpansionZoom(clusterId: number, callback: Callback<number>) {
+        this.actor.send('geojson.getClusterExpansionZoom', {clusterId, source: this.id}, callback);
+        return this;
+    }
+
+    /**
+     * For clustered sources, fetches the children of the given cluster on the next zoom level (as an array of GeoJSON features).
+     *
+     * @param clusterId The value of the cluster's `cluster_id` property.
+     * @param callback A callback to be called when the features are retrieved (`(error, features) => { ... }`).
+     * @returns {GeoJSONSource} this
+     */
+    getClusterChildren(clusterId: number, callback: Callback<Array<GeoJSONFeature>>) {
+        this.actor.send('geojson.getClusterChildren', {clusterId, source: this.id}, callback);
+        return this;
+    }
+
+    /**
+     * For clustered sources, fetches the original points that belong to the cluster (as an array of GeoJSON features).
+     *
+     * @param clusterId The value of the cluster's `cluster_id` property.
+     * @param limit The maximum number of features to return.
+     * @param offset The number of features to skip (e.g. for pagination).
+     * @param callback A callback to be called when the features are retrieved (`(error, features) => { ... }`).
+     * @returns {GeoJSONSource} this
+     * @example
+     * // Retrieve cluster leaves on click
+     * map.on('click', 'clusters', function(e) {
+     *   var features = map.queryRenderedFeatures(e.point, {
+     *     layers: ['clusters']
+     *   });
+     *
+     *   var clusterId = features[0].properties.cluster_id;
+     *   var pointCount = features[0].properties.point_count;
+     *   var clusterSource = map.getSource('clusters');
+     *
+     *   clusterSource.getClusterLeaves(clusterId, pointCount, 0, function(error, features) {
+     *     // Print cluster leaves in the console
+     *     console.log('Cluster leaves:', error, features);
+     *   })
+     * });
+     */
+    getClusterLeaves(clusterId: number, limit: number, offset: number, callback: Callback<Array<GeoJSONFeature>>) {
+        this.actor.send('geojson.getClusterLeaves', {
+            source: this.id,
+            clusterId,
+            limit,
+            offset
+        }, callback);
+        return this;
+    }
+
+    /*
+     * Responsible for invoking WorkerSource's geojson.loadData target, which
+     * handles loading the geojson data and preparing to serve it up as tiles,
+     * using geojson-vt or supercluster as appropriate.
+     */
+    _updateWorkerData(callback: Callback<void>) {
+        this._loaded = false;
+        const options = extend({}, this.workerOptions);
+        const data = this._data;
+        if (typeof data === 'string') {
+            options.request = this.map._requestManager.transformRequest(browser.resolveURL(data), ResourceType.Source);
+            options.request.collectResourceTiming = this._collectResourceTiming;
+        } else {
+            options.data = JSON.stringify(data);
+        }
+
+        // target {this.type}.loadData rather than literally geojson.loadData,
+        // so that other geojson-like source types can easily reuse this
+        // implementation
+        this.actor.send(`${this.type}.loadData`, options, (err, result) => {
+            if (this._removed || (result && result.abandoned)) {
+                return;
+            }
+
+            this._loaded = true;
+
+            if (result && result.resourceTiming && result.resourceTiming[this.id])
+                this._resourceTiming = result.resourceTiming[this.id].slice(0);
+            // Any `loadData` calls that piled up while we were processing
+            // this one will get coalesced into a single call when this
+            // 'coalesce' message is processed.
+            // We would self-send from the worker if we had access to its
+            // message queue. Waiting instead for the 'coalesce' to round-trip
+            // through the foreground just means we're throttling the worker
+            // to run at a little less than full-throttle.
+            this.actor.send(`${this.type}.coalesce`, {source: options.source}, null);
+            callback(err);
+        });
+    }
+
+    loaded(): boolean {
+        return this._loaded;
+    }
+
+    loadTile(tile: Tile, callback: Callback<void>) {
+        const message = !tile.actor ? 'loadTile' : 'reloadTile';
+        tile.actor = this.actor;
+        const params = {
+            type: this.type,
+            uid: tile.uid,
+            tileID: tile.tileID,
+            zoom: tile.tileID.overscaledZ,
+            maxZoom: this.maxzoom,
+            tileSize: this.tileSize,
+            source: this.id,
+            pixelRatio: browser.devicePixelRatio,
+            showCollisionBoxes: this.map.showCollisionBoxes,
+            promoteId: this.promoteId
+        };
+
+        tile.request = this.actor.send(message, params, (err, data) => {
+            delete tile.request;
+            tile.unloadVectorData();
+
+            if (tile.aborted) {
+                return callback(null);
+            }
+
+            if (err) {
+                return callback(err);
+            }
+
+            tile.loadVectorData(data, this.map.painter, message === 'reloadTile');
+
+            return callback(null);
+        });
+    }
+
+    abortTile(tile: Tile) {
+        if (tile.request) {
+            tile.request.cancel();
+            delete tile.request;
+        }
+        tile.aborted = true;
+    }
+
+    unloadTile(tile: Tile) {
+        tile.unloadVectorData();
+        this.actor.send('removeTile', {uid: tile.uid, type: this.type, source: this.id});
+    }
+
+    onRemove() {
+        this._removed = true;
+        this.actor.send('removeSource', {type: this.type, source: this.id});
+    }
+
+    serialize() {
+        return extend({}, this._options, {
+            type: this.type,
+            data: this._data
+        });
+    }
+
+    hasTransition() {
+        return false;
+    }
+}
+
+export default GeoJSONSource;