mapbox-gl 1.13.2

package/src/symbol/grid_index.js

@@ -0,0 +1,335 @@
+// @flow
+
+/**
+ * GridIndex is a data structure for testing the intersection of
+ * circles and rectangles in a 2d plane.
+ * It is optimized for rapid insertion and querying.
+ * GridIndex splits the plane into a set of "cells" and keeps track
+ * of which geometries intersect with each cell. At query time,
+ * full geometry comparisons are only done for items that share
+ * at least one cell. As long as the geometries are relatively
+ * uniformly distributed across the plane, this greatly reduces
+ * the number of comparisons necessary.
+ *
+ * @private
+ */
+class GridIndex {
+    circleKeys: Array<any>;
+    boxKeys: Array<any>;
+    boxCells: Array<Array<number>>;
+    circleCells: Array<Array<number>>;
+    bboxes: Array<number>;
+    circles: Array<number>;
+    xCellCount: number;
+    yCellCount: number;
+    width: number;
+    height: number;
+    xScale: number;
+    yScale: number;
+    boxUid: number;
+    circleUid: number;
+
+    constructor (width: number, height: number, cellSize: number) {
+        const boxCells = this.boxCells = [];
+        const circleCells = this.circleCells = [];
+
+        // More cells -> fewer geometries to check per cell, but items tend
+        // to be split across more cells.
+        // Sweet spot allows most small items to fit in one cell
+        this.xCellCount = Math.ceil(width / cellSize);
+        this.yCellCount = Math.ceil(height / cellSize);
+
+        for (let i = 0; i < this.xCellCount * this.yCellCount; i++) {
+            boxCells.push([]);
+            circleCells.push([]);
+        }
+        this.circleKeys = [];
+        this.boxKeys = [];
+        this.bboxes = [];
+        this.circles = [];
+
+        this.width = width;
+        this.height = height;
+        this.xScale = this.xCellCount / width;
+        this.yScale = this.yCellCount / height;
+        this.boxUid = 0;
+        this.circleUid = 0;
+    }
+
+    keysLength() {
+        return this.boxKeys.length + this.circleKeys.length;
+    }
+
+    insert(key: any, x1: number, y1: number, x2: number, y2: number) {
+        this._forEachCell(x1, y1, x2, y2, this._insertBoxCell, this.boxUid++);
+        this.boxKeys.push(key);
+        this.bboxes.push(x1);
+        this.bboxes.push(y1);
+        this.bboxes.push(x2);
+        this.bboxes.push(y2);
+    }
+
+    insertCircle(key: any, x: number, y: number, radius: number) {
+        // Insert circle into grid for all cells in the circumscribing square
+        // It's more than necessary (by a factor of 4/PI), but fast to insert
+        this._forEachCell(x - radius, y - radius, x + radius, y + radius, this._insertCircleCell, this.circleUid++);
+        this.circleKeys.push(key);
+        this.circles.push(x);
+        this.circles.push(y);
+        this.circles.push(radius);
+    }
+
+    _insertBoxCell(x1: number, y1: number, x2: number, y2: number, cellIndex: number, uid: number) {
+        this.boxCells[cellIndex].push(uid);
+    }
+
+    _insertCircleCell(x1: number, y1: number, x2: number, y2: number, cellIndex: number, uid: number)  {
+        this.circleCells[cellIndex].push(uid);
+    }
+
+    _query(x1: number, y1: number, x2: number, y2: number, hitTest: boolean, predicate?: any) {
+        if (x2 < 0 || x1 > this.width || y2 < 0 || y1 > this.height) {
+            return hitTest ? false : [];
+        }
+        const result = [];
+        if (x1 <= 0 && y1 <= 0 && this.width <= x2 && this.height <= y2) {
+            if (hitTest) {
+                return true;
+            }
+            for (let boxUid = 0; boxUid < this.boxKeys.length; boxUid++) {
+                result.push({
+                    key: this.boxKeys[boxUid],
+                    x1: this.bboxes[boxUid * 4],
+                    y1: this.bboxes[boxUid * 4 + 1],
+                    x2: this.bboxes[boxUid * 4 + 2],
+                    y2: this.bboxes[boxUid * 4 + 3]
+                });
+            }
+            for (let circleUid = 0; circleUid < this.circleKeys.length; circleUid++) {
+                const x = this.circles[circleUid * 3];
+                const y = this.circles[circleUid * 3 + 1];
+                const radius = this.circles[circleUid * 3 + 2];
+                result.push({
+                    key: this.circleKeys[circleUid],
+                    x1: x - radius,
+                    y1: y - radius,
+                    x2: x + radius,
+                    y2: y + radius
+                });
+            }
+            return predicate ? result.filter(predicate) : result;
+        } else {
+            const queryArgs = {
+                hitTest,
+                seenUids: {box: {}, circle: {}}
+            };
+            this._forEachCell(x1, y1, x2, y2, this._queryCell, result, queryArgs, predicate);
+            return hitTest ? result.length > 0 : result;
+        }
+    }
+
+    _queryCircle(x: number, y: number, radius: number, hitTest: boolean, predicate?: any) {
+        // Insert circle into grid for all cells in the circumscribing square
+        // It's more than necessary (by a factor of 4/PI), but fast to insert
+        const x1 = x - radius;
+        const x2 = x + radius;
+        const y1 = y - radius;
+        const y2 = y + radius;
+        if (x2 < 0 || x1 > this.width || y2 < 0 || y1 > this.height) {
+            return hitTest ? false : [];
+        }
+
+        // Box query early exits if the bounding box is larger than the grid, but we don't do
+        // the equivalent calculation for circle queries because early exit is less likely
+        // and the calculation is more expensive
+        const result = [];
+        const queryArgs = {
+            hitTest,
+            circle: {x, y, radius},
+            seenUids: {box: {}, circle: {}}
+        };
+        this._forEachCell(x1, y1, x2, y2, this._queryCellCircle, result, queryArgs, predicate);
+        return hitTest ? result.length > 0 : result;
+    }
+
+    query(x1: number, y1: number, x2: number, y2: number, predicate?: any): Array<any> {
+        return (this._query(x1, y1, x2, y2, false, predicate): any);
+    }
+
+    hitTest(x1: number, y1: number, x2: number, y2: number, predicate?: any): boolean  {
+        return (this._query(x1, y1, x2, y2, true, predicate): any);
+    }
+
+    hitTestCircle(x: number, y: number, radius: number, predicate?: any): boolean {
+        return (this._queryCircle(x, y, radius, true, predicate): any);
+    }
+
+    _queryCell(x1: number, y1: number, x2: number, y2: number, cellIndex: number, result: any, queryArgs: any, predicate?: any) {
+        const seenUids = queryArgs.seenUids;
+        const boxCell = this.boxCells[cellIndex];
+        if (boxCell !== null) {
+            const bboxes = this.bboxes;
+            for (const boxUid of boxCell) {
+                if (!seenUids.box[boxUid]) {
+                    seenUids.box[boxUid] = true;
+                    const offset = boxUid * 4;
+                    if ((x1 <= bboxes[offset + 2]) &&
+                        (y1 <= bboxes[offset + 3]) &&
+                        (x2 >= bboxes[offset + 0]) &&
+                        (y2 >= bboxes[offset + 1]) &&
+                        (!predicate || predicate(this.boxKeys[boxUid]))) {
+                        if (queryArgs.hitTest) {
+                            result.push(true);
+                            return true;
+                        } else {
+                            result.push({
+                                key: this.boxKeys[boxUid],
+                                x1: bboxes[offset],
+                                y1: bboxes[offset + 1],
+                                x2: bboxes[offset + 2],
+                                y2: bboxes[offset + 3]
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        const circleCell = this.circleCells[cellIndex];
+        if (circleCell !== null) {
+            const circles = this.circles;
+            for (const circleUid of circleCell) {
+                if (!seenUids.circle[circleUid]) {
+                    seenUids.circle[circleUid] = true;
+                    const offset = circleUid * 3;
+                    if (this._circleAndRectCollide(
+                        circles[offset],
+                        circles[offset + 1],
+                        circles[offset + 2],
+                        x1,
+                        y1,
+                        x2,
+                        y2) &&
+                        (!predicate || predicate(this.circleKeys[circleUid]))) {
+                        if (queryArgs.hitTest) {
+                            result.push(true);
+                            return true;
+                        } else {
+                            const x = circles[offset];
+                            const y = circles[offset + 1];
+                            const radius = circles[offset + 2];
+                            result.push({
+                                key: this.circleKeys[circleUid],
+                                x1: x - radius,
+                                y1: y - radius,
+                                x2: x + radius,
+                                y2: y + radius
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    _queryCellCircle(x1: number, y1: number, x2: number, y2: number, cellIndex: number, result: any, queryArgs: any, predicate?: any) {
+        const circle = queryArgs.circle;
+        const seenUids = queryArgs.seenUids;
+        const boxCell = this.boxCells[cellIndex];
+        if (boxCell !== null) {
+            const bboxes = this.bboxes;
+            for (const boxUid of boxCell) {
+                if (!seenUids.box[boxUid]) {
+                    seenUids.box[boxUid] = true;
+                    const offset = boxUid * 4;
+                    if (this._circleAndRectCollide(
+                        circle.x,
+                        circle.y,
+                        circle.radius,
+                        bboxes[offset + 0],
+                        bboxes[offset + 1],
+                        bboxes[offset + 2],
+                        bboxes[offset + 3]) &&
+                        (!predicate || predicate(this.boxKeys[boxUid]))) {
+                        result.push(true);
+                        return true;
+                    }
+                }
+            }
+        }
+
+        const circleCell = this.circleCells[cellIndex];
+        if (circleCell !== null) {
+            const circles = this.circles;
+            for (const circleUid of circleCell) {
+                if (!seenUids.circle[circleUid]) {
+                    seenUids.circle[circleUid] = true;
+                    const offset = circleUid * 3;
+                    if (this._circlesCollide(
+                        circles[offset],
+                        circles[offset + 1],
+                        circles[offset + 2],
+                        circle.x,
+                        circle.y,
+                        circle.radius) &&
+                        (!predicate || predicate(this.circleKeys[circleUid]))) {
+                        result.push(true);
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+
+    _forEachCell(x1: number, y1: number, x2: number, y2: number, fn: any, arg1: any, arg2?: any, predicate?: any) {
+        const cx1 = this._convertToXCellCoord(x1);
+        const cy1 = this._convertToYCellCoord(y1);
+        const cx2 = this._convertToXCellCoord(x2);
+        const cy2 = this._convertToYCellCoord(y2);
+
+        for (let x = cx1; x <= cx2; x++) {
+            for (let y = cy1; y <= cy2; y++) {
+                const cellIndex = this.xCellCount * y + x;
+                if (fn.call(this, x1, y1, x2, y2, cellIndex, arg1, arg2, predicate)) return;
+            }
+        }
+    }
+
+    _convertToXCellCoord(x: number) {
+        return Math.max(0, Math.min(this.xCellCount - 1, Math.floor(x * this.xScale)));
+    }
+
+    _convertToYCellCoord(y: number) {
+        return Math.max(0, Math.min(this.yCellCount - 1, Math.floor(y * this.yScale)));
+    }
+
+    _circlesCollide(x1: number, y1: number, r1: number, x2: number, y2: number, r2: number): boolean {
+        const dx = x2 - x1;
+        const dy = y2 - y1;
+        const bothRadii = r1 + r2;
+        return (bothRadii * bothRadii) > (dx * dx + dy * dy);
+    }
+
+    _circleAndRectCollide(circleX: number, circleY: number, radius: number, x1: number, y1: number, x2: number, y2: number): boolean {
+        const halfRectWidth = (x2 - x1) / 2;
+        const distX = Math.abs(circleX - (x1 + halfRectWidth));
+        if (distX > (halfRectWidth + radius)) {
+            return false;
+        }
+
+        const halfRectHeight = (y2 - y1) / 2;
+        const distY = Math.abs(circleY - (y1 + halfRectHeight));
+        if (distY > (halfRectHeight + radius)) {
+            return false;
+        }
+
+        if (distX <= halfRectWidth || distY <= halfRectHeight) {
+            return true;
+        }
+
+        const dx = distX - halfRectWidth;
+        const dy = distY - halfRectHeight;
+        return (dx * dx + dy * dy <= (radius * radius));
+    }
+}
+
+export default GridIndex;

package/src/symbol/mergelines.js

@@ -0,0 +1,82 @@
+// @flow
+
+import type {SymbolFeature} from '../data/bucket/symbol_bucket';
+
+export default function (features: Array<SymbolFeature>): Array<SymbolFeature> {
+    const leftIndex: {[_: string]: number} = {};
+    const rightIndex: {[_: string]: number} = {};
+    const mergedFeatures = [];
+    let mergedIndex = 0;
+
+    function add(k) {
+        mergedFeatures.push(features[k]);
+        mergedIndex++;
+    }
+
+    function mergeFromRight(leftKey: string, rightKey: string, geom) {
+        const i = rightIndex[leftKey];
+        delete rightIndex[leftKey];
+        rightIndex[rightKey] = i;
+
+        mergedFeatures[i].geometry[0].pop();
+        mergedFeatures[i].geometry[0] = mergedFeatures[i].geometry[0].concat(geom[0]);
+        return i;
+    }
+
+    function mergeFromLeft(leftKey: string, rightKey: string, geom) {
+        const i = leftIndex[rightKey];
+        delete leftIndex[rightKey];
+        leftIndex[leftKey] = i;
+
+        mergedFeatures[i].geometry[0].shift();
+        mergedFeatures[i].geometry[0] = geom[0].concat(mergedFeatures[i].geometry[0]);
+        return i;
+    }
+
+    function getKey(text, geom, onRight) {
+        const point = onRight ? geom[0][geom[0].length - 1] : geom[0][0];
+        return `${text}:${point.x}:${point.y}`;
+    }
+
+    for (let k = 0; k < features.length; k++) {
+        const feature = features[k];
+        const geom = feature.geometry;
+        const text = feature.text ? feature.text.toString() : null;
+
+        if (!text) {
+            add(k);
+            continue;
+        }
+
+        const leftKey = getKey(text, geom),
+            rightKey = getKey(text, geom, true);
+
+        if ((leftKey in rightIndex) && (rightKey in leftIndex) && (rightIndex[leftKey] !== leftIndex[rightKey])) {
+            // found lines with the same text adjacent to both ends of the current line, merge all three
+            const j = mergeFromLeft(leftKey, rightKey, geom);
+            const i = mergeFromRight(leftKey, rightKey, mergedFeatures[j].geometry);
+
+            delete leftIndex[leftKey];
+            delete rightIndex[rightKey];
+
+            rightIndex[getKey(text, mergedFeatures[i].geometry, true)] = i;
+            mergedFeatures[j].geometry = (null: any);
+
+        } else if (leftKey in rightIndex) {
+            // found mergeable line adjacent to the start of the current line, merge
+            mergeFromRight(leftKey, rightKey, geom);
+
+        } else if (rightKey in leftIndex) {
+            // found mergeable line adjacent to the end of the current line, merge
+            mergeFromLeft(leftKey, rightKey, geom);
+
+        } else {
+            // no adjacent lines, add as a new item
+            add(k);
+            leftIndex[leftKey] = mergedIndex - 1;
+            rightIndex[rightKey] = mergedIndex - 1;
+        }
+    }
+
+    return mergedFeatures.filter((f) => f.geometry);
+}

package/src/symbol/one_em.js

@@ -0,0 +1,4 @@
+// @flow
+// ONE_EM constant used to go between "em" units used in style spec and "points" used internally for layout
+
+export default 24;

package/src/symbol/opacity_state.js

@@ -0,0 +1,27 @@
+// @flow
+
+import {register} from '../util/web_worker_transfer';
+
+class OpacityState {
+    opacity: number;
+    targetOpacity: number;
+    time: number
+
+    constructor() {
+        this.opacity = 0;
+        this.targetOpacity = 0;
+        this.time = 0;
+    }
+
+    clone() {
+        const clone = new OpacityState();
+        clone.opacity = this.opacity;
+        clone.targetOpacity = this.targetOpacity;
+        clone.time = this.time;
+        return clone;
+    }
+}
+
+register('OpacityState', OpacityState);
+
+export default OpacityState;

package/src/symbol/path_interpolator.js

@@ -0,0 +1,61 @@
+// @flow
+
+import {clamp} from '../util/util';
+import Point from '@mapbox/point-geometry';
+import assert from 'assert';
+
+class PathInterpolator {
+    points: Array<Point>;
+    length: number;
+    paddedLength: number;
+    padding: number;
+    _distances: Array<number>;
+
+    constructor(points_: ?Array<Point>, padding_: ?number) {
+        this.reset(points_, padding_);
+    }
+
+    reset(points_: ?Array<Point>, padding_: ?number) {
+        this.points = points_ || [];
+
+        // Compute cumulative distance from first point to every other point in the segment.
+        // Last entry in the array is total length of the path
+        this._distances = [0.0];
+
+        for (let i = 1; i < this.points.length; i++) {
+            this._distances[i] = this._distances[i - 1] + this.points[i].dist(this.points[i - 1]);
+        }
+
+        this.length = this._distances[this._distances.length - 1];
+        this.padding = Math.min(padding_ || 0, this.length * 0.5);
+        this.paddedLength = this.length - this.padding * 2.0;
+    }
+
+    lerp(t: number): Point {
+        assert(this.points.length > 0);
+        if (this.points.length === 1) {
+            return this.points[0];
+        }
+
+        t = clamp(t, 0, 1);
+
+        // Find the correct segment [p0, p1] where p0 <= x < p1
+        let currentIndex = 1;
+        let distOfCurrentIdx = this._distances[currentIndex];
+        const distToTarget = t * this.paddedLength + this.padding;
+
+        while (distOfCurrentIdx < distToTarget && currentIndex < this._distances.length) {
+            distOfCurrentIdx = this._distances[++currentIndex];
+        }
+
+        // Interpolate between the two points of the segment
+        const idxOfPrevPoint = currentIndex - 1;
+        const distOfPrevIdx = this._distances[idxOfPrevPoint];
+        const segmentLength = distOfCurrentIdx - distOfPrevIdx;
+        const segmentT = segmentLength > 0 ? (distToTarget - distOfPrevIdx) / segmentLength : 0;
+
+        return this.points[idxOfPrevPoint].mult(1.0 - segmentT).add(this.points[currentIndex].mult(segmentT));
+    }
+}
+
+export default PathInterpolator;