mapbox-gl 1.13.2

package/src/util/find_pole_of_inaccessibility.js

@@ -0,0 +1,129 @@
+// @flow
+
+import Queue from 'tinyqueue';
+
+import Point from '@mapbox/point-geometry';
+import {distToSegmentSquared} from './intersection_tests';
+
+/**
+ * Finds an approximation of a polygon's Pole Of Inaccessibiliy https://en.wikipedia.org/wiki/Pole_of_inaccessibility
+ * This is a copy of http://github.com/mapbox/polylabel adapted to use Points
+ *
+ * @param polygonRings first item in array is the outer ring followed optionally by the list of holes, should be an element of the result of util/classify_rings
+ * @param precision Specified in input coordinate units. If 0 returns after first run, if > 0 repeatedly narrows the search space until the radius of the area searched for the best pole is less than precision
+ * @param debug Print some statistics to the console during execution
+ * @returns Pole of Inaccessibiliy.
+ * @private
+ */
+export default function (polygonRings: Array<Array<Point>>, precision?: number = 1, debug?: boolean = false): Point {
+    // find the bounding box of the outer ring
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    const outerRing = polygonRings[0];
+    for (let i = 0; i < outerRing.length; i++) {
+        const p = outerRing[i];
+        if (!i || p.x < minX) minX = p.x;
+        if (!i || p.y < minY) minY = p.y;
+        if (!i || p.x > maxX) maxX = p.x;
+        if (!i || p.y > maxY) maxY = p.y;
+    }
+
+    const width = maxX - minX;
+    const height = maxY - minY;
+    const cellSize = Math.min(width, height);
+    let h = cellSize / 2;
+
+    // a priority queue of cells in order of their "potential" (max distance to polygon)
+    const cellQueue = new Queue([], compareMax);
+
+    if (cellSize === 0) return new Point(minX, minY);
+
+    // cover polygon with initial cells
+    for (let x = minX; x < maxX; x += cellSize) {
+        for (let y = minY; y < maxY; y += cellSize) {
+            cellQueue.push(new Cell(x + h, y + h, h, polygonRings));
+        }
+    }
+
+    // take centroid as the first best guess
+    let bestCell = getCentroidCell(polygonRings);
+    let numProbes = cellQueue.length;
+
+    while (cellQueue.length) {
+        // pick the most promising cell from the queue
+        const cell = cellQueue.pop();
+
+        // update the best cell if we found a better one
+        if (cell.d > bestCell.d || !bestCell.d) {
+            bestCell = cell;
+            if (debug) console.log('found best %d after %d probes', Math.round(1e4 * cell.d) / 1e4, numProbes);
+        }
+
+        // do not drill down further if there's no chance of a better solution
+        if (cell.max - bestCell.d <= precision) continue;
+
+        // split the cell into four cells
+        h = cell.h / 2;
+        cellQueue.push(new Cell(cell.p.x - h, cell.p.y - h, h, polygonRings));
+        cellQueue.push(new Cell(cell.p.x + h, cell.p.y - h, h, polygonRings));
+        cellQueue.push(new Cell(cell.p.x - h, cell.p.y + h, h, polygonRings));
+        cellQueue.push(new Cell(cell.p.x + h, cell.p.y + h, h, polygonRings));
+        numProbes += 4;
+    }
+
+    if (debug) {
+        console.log(`num probes: ${numProbes}`);
+        console.log(`best distance: ${bestCell.d}`);
+    }
+
+    return bestCell.p;
+}
+
+function compareMax(a, b) {
+    return b.max - a.max;
+}
+
+function Cell(x, y, h, polygon) {
+    this.p = new Point(x, y);
+    this.h = h; // half the cell size
+    this.d = pointToPolygonDist(this.p, polygon); // distance from cell center to polygon
+    this.max = this.d + this.h * Math.SQRT2; // max distance to polygon within a cell
+}
+
+// signed distance from point to polygon outline (negative if point is outside)
+function pointToPolygonDist(p, polygon) {
+    let inside = false;
+    let minDistSq = Infinity;
+
+    for (let k = 0; k < polygon.length; k++) {
+        const ring = polygon[k];
+
+        for (let i = 0, len = ring.length, j = len - 1; i < len; j = i++) {
+            const a = ring[i];
+            const b = ring[j];
+
+            if ((a.y > p.y !== b.y > p.y) &&
+                (p.x < (b.x - a.x) * (p.y - a.y) / (b.y - a.y) + a.x)) inside = !inside;
+
+            minDistSq = Math.min(minDistSq, distToSegmentSquared(p, a, b));
+        }
+    }
+
+    return (inside ? 1 : -1) * Math.sqrt(minDistSq);
+}
+
+// get polygon centroid
+function getCentroidCell(polygon) {
+    let area = 0;
+    let x = 0;
+    let y = 0;
+    const points = polygon[0];
+    for (let i = 0, len = points.length, j = len - 1; i < len; j = i++) {
+        const a = points[i];
+        const b = points[j];
+        const f = a.x * b.y - b.x * a.y;
+        x += (a.x + b.x) * f;
+        y += (a.y + b.y) * f;
+        area += f * 3;
+    }
+    return new Cell(x / area, y / area, 0, polygon);
+}

package/src/util/global_worker_pool.js

@@ -0,0 +1,35 @@
+// @flow
+
+import WorkerPool, {PRELOAD_POOL_ID} from './worker_pool';
+
+let globalWorkerPool;
+
+/**
+ * Creates (if necessary) and returns the single, global WorkerPool instance
+ * to be shared across each Map
+ * @private
+ */
+export default function getGlobalWorkerPool () {
+    if (!globalWorkerPool) {
+        globalWorkerPool = new WorkerPool();
+    }
+    return globalWorkerPool;
+}
+
+export function prewarm() {
+    const workerPool = getGlobalWorkerPool();
+    workerPool.acquire(PRELOAD_POOL_ID);
+}
+
+export function clearPrewarmedResources() {
+    const pool = globalWorkerPool;
+    if (pool) {
+        // Remove the pool only if all maps that referenced the preloaded global worker pool have been removed.
+        if (pool.isPreloaded() && pool.numActive() === 1) {
+            pool.release(PRELOAD_POOL_ID);
+            globalWorkerPool = null;
+        } else {
+            console.warn('Could not clear WebWorkers since there are active Map instances that still reference it. The pre-warmed WebWorker pool can only be cleared when all map instances have been removed with map.remove()');
+        }
+    }
+}

package/src/util/image.js

@@ -0,0 +1,142 @@
+// @flow
+
+import assert from 'assert';
+
+import {register} from './web_worker_transfer';
+
+export type Size = {
+    width: number,
+    height: number
+};
+
+type Point = {
+    x: number,
+    y: number
+};
+
+function createImage(image: *, {width, height}: Size, channels: number, data?: Uint8Array | Uint8ClampedArray) {
+    if (!data) {
+        data = new Uint8Array(width * height * channels);
+    } else if (data instanceof Uint8ClampedArray) {
+        data = new Uint8Array(data.buffer);
+    } else if (data.length !== width * height * channels) {
+        throw new RangeError('mismatched image size');
+    }
+    image.width = width;
+    image.height = height;
+    image.data = data;
+    return image;
+}
+
+function resizeImage(image: *, {width, height}: Size, channels: number) {
+    if (width === image.width && height === image.height) {
+        return;
+    }
+
+    const newImage = createImage({}, {width, height}, channels);
+
+    copyImage(image, newImage, {x: 0, y: 0}, {x: 0, y: 0}, {
+        width: Math.min(image.width, width),
+        height: Math.min(image.height, height)
+    }, channels);
+
+    image.width = width;
+    image.height = height;
+    image.data = newImage.data;
+}
+
+function copyImage(srcImg: *, dstImg: *, srcPt: Point, dstPt: Point, size: Size, channels: number) {
+    if (size.width === 0 || size.height === 0) {
+        return dstImg;
+    }
+
+    if (size.width > srcImg.width ||
+        size.height > srcImg.height ||
+        srcPt.x > srcImg.width - size.width ||
+        srcPt.y > srcImg.height - size.height) {
+        throw new RangeError('out of range source coordinates for image copy');
+    }
+
+    if (size.width > dstImg.width ||
+        size.height > dstImg.height ||
+        dstPt.x > dstImg.width - size.width ||
+        dstPt.y > dstImg.height - size.height) {
+        throw new RangeError('out of range destination coordinates for image copy');
+    }
+
+    const srcData = srcImg.data;
+    const dstData = dstImg.data;
+
+    assert(srcData !== dstData);
+
+    for (let y = 0; y < size.height; y++) {
+        const srcOffset = ((srcPt.y + y) * srcImg.width + srcPt.x) * channels;
+        const dstOffset = ((dstPt.y + y) * dstImg.width + dstPt.x) * channels;
+        for (let i = 0; i < size.width * channels; i++) {
+            dstData[dstOffset + i] = srcData[srcOffset + i];
+        }
+    }
+    return dstImg;
+}
+
+export class AlphaImage {
+    width: number;
+    height: number;
+    data: Uint8Array;
+
+    constructor(size: Size, data?: Uint8Array | Uint8ClampedArray) {
+        createImage(this, size, 1, data);
+    }
+
+    resize(size: Size) {
+        resizeImage(this, size, 1);
+    }
+
+    clone() {
+        return new AlphaImage({width: this.width, height: this.height}, new Uint8Array(this.data));
+    }
+
+    static copy(srcImg: AlphaImage, dstImg: AlphaImage, srcPt: Point, dstPt: Point, size: Size) {
+        copyImage(srcImg, dstImg, srcPt, dstPt, size, 1);
+    }
+}
+
+// Not premultiplied, because ImageData is not premultiplied.
+// UNPACK_PREMULTIPLY_ALPHA_WEBGL must be used when uploading to a texture.
+export class RGBAImage {
+    width: number;
+    height: number;
+
+    // data must be a Uint8Array instead of Uint8ClampedArray because texImage2D does not
+    // support Uint8ClampedArray in all browsers
+    data: Uint8Array;
+
+    constructor(size: Size, data?: Uint8Array | Uint8ClampedArray) {
+        createImage(this, size, 4, data);
+    }
+
+    resize(size: Size) {
+        resizeImage(this, size, 4);
+    }
+
+    replace(data: Uint8Array | Uint8ClampedArray, copy?: boolean) {
+        if (copy) {
+            this.data.set(data);
+        } else if (data instanceof Uint8ClampedArray) {
+            this.data = new Uint8Array(data.buffer);
+        } else {
+            this.data = data;
+        }
+    }
+
+    clone() {
+        return new RGBAImage({width: this.width, height: this.height}, new Uint8Array(this.data));
+    }
+
+    static copy(srcImg: RGBAImage | ImageData, dstImg: RGBAImage, srcPt: Point, dstPt: Point, size: Size) {
+        copyImage(srcImg, dstImg, srcPt, dstPt, size, 4);
+    }
+}
+
+register('AlphaImage', AlphaImage);
+register('RGBAImage', RGBAImage);

package/src/util/intersection_tests.js

@@ -0,0 +1,208 @@
+// @flow
+
+import {isCounterClockwise} from './util';
+
+import Point from '@mapbox/point-geometry';
+
+export {polygonIntersectsBufferedPoint, polygonIntersectsMultiPolygon, polygonIntersectsBufferedMultiLine, polygonIntersectsPolygon, distToSegmentSquared, polygonIntersectsBox};
+
+type Line = Array<Point>;
+type MultiLine = Array<Line>;
+type Ring = Array<Point>;
+type Polygon = Array<Point>;
+type MultiPolygon = Array<Polygon>;
+
+function polygonIntersectsPolygon(polygonA: Polygon, polygonB: Polygon) {
+    for (let i = 0; i < polygonA.length; i++) {
+        if (polygonContainsPoint(polygonB, polygonA[i])) return true;
+    }
+
+    for (let i = 0; i < polygonB.length; i++) {
+        if (polygonContainsPoint(polygonA, polygonB[i])) return true;
+    }
+
+    if (lineIntersectsLine(polygonA, polygonB)) return true;
+
+    return false;
+}
+
+function polygonIntersectsBufferedPoint(polygon: Polygon, point: Point, radius: number) {
+    if (polygonContainsPoint(polygon, point)) return true;
+    if (pointIntersectsBufferedLine(point, polygon, radius)) return true;
+    return false;
+}
+
+function polygonIntersectsMultiPolygon(polygon: Polygon, multiPolygon: MultiPolygon) {
+
+    if (polygon.length === 1) {
+        return multiPolygonContainsPoint(multiPolygon, polygon[0]);
+    }
+
+    for (let m = 0; m < multiPolygon.length; m++) {
+        const ring = multiPolygon[m];
+        for (let n = 0; n < ring.length; n++) {
+            if (polygonContainsPoint(polygon, ring[n])) return true;
+        }
+    }
+
+    for (let i = 0; i < polygon.length; i++) {
+        if (multiPolygonContainsPoint(multiPolygon, polygon[i])) return true;
+    }
+
+    for (let k = 0; k < multiPolygon.length; k++) {
+        if (lineIntersectsLine(polygon, multiPolygon[k])) return true;
+    }
+
+    return false;
+}
+
+function polygonIntersectsBufferedMultiLine(polygon: Polygon, multiLine: MultiLine, radius: number) {
+    for (let i = 0; i < multiLine.length; i++) {
+        const line = multiLine[i];
+
+        if (polygon.length >= 3) {
+            for (let k = 0; k < line.length; k++) {
+                if (polygonContainsPoint(polygon, line[k])) return true;
+            }
+        }
+
+        if (lineIntersectsBufferedLine(polygon, line, radius)) return true;
+    }
+    return false;
+}
+
+function lineIntersectsBufferedLine(lineA: Line, lineB: Line, radius: number) {
+
+    if (lineA.length > 1) {
+        if (lineIntersectsLine(lineA, lineB)) return true;
+
+        // Check whether any point in either line is within radius of the other line
+        for (let j = 0; j < lineB.length; j++) {
+            if (pointIntersectsBufferedLine(lineB[j], lineA, radius)) return true;
+        }
+    }
+
+    for (let k = 0; k < lineA.length; k++) {
+        if (pointIntersectsBufferedLine(lineA[k], lineB, radius)) return true;
+    }
+
+    return false;
+}
+
+function lineIntersectsLine(lineA: Line, lineB: Line) {
+    if (lineA.length === 0 || lineB.length === 0) return false;
+    for (let i = 0; i < lineA.length - 1; i++) {
+        const a0 = lineA[i];
+        const a1 = lineA[i + 1];
+        for (let j = 0; j < lineB.length - 1; j++) {
+            const b0 = lineB[j];
+            const b1 = lineB[j + 1];
+            if (lineSegmentIntersectsLineSegment(a0, a1, b0, b1)) return true;
+        }
+    }
+    return false;
+}
+
+function lineSegmentIntersectsLineSegment(a0: Point, a1: Point, b0: Point, b1: Point) {
+    return isCounterClockwise(a0, b0, b1) !== isCounterClockwise(a1, b0, b1) &&
+        isCounterClockwise(a0, a1, b0) !== isCounterClockwise(a0, a1, b1);
+}
+
+function pointIntersectsBufferedLine(p: Point, line: Line, radius: number) {
+    const radiusSquared = radius * radius;
+
+    if (line.length === 1) return p.distSqr(line[0]) < radiusSquared;
+
+    for (let i = 1; i < line.length; i++) {
+        // Find line segments that have a distance <= radius^2 to p
+        // In that case, we treat the line as "containing point p".
+        const v = line[i - 1], w = line[i];
+        if (distToSegmentSquared(p, v, w) < radiusSquared) return true;
+    }
+    return false;
+}
+
+// Code from http://stackoverflow.com/a/1501725/331379.
+function distToSegmentSquared(p: Point, v: Point, w: Point) {
+    const l2 = v.distSqr(w);
+    if (l2 === 0) return p.distSqr(v);
+    const t = ((p.x - v.x) * (w.x - v.x) + (p.y - v.y) * (w.y - v.y)) / l2;
+    if (t < 0) return p.distSqr(v);
+    if (t > 1) return p.distSqr(w);
+    return p.distSqr(w.sub(v)._mult(t)._add(v));
+}
+
+// point in polygon ray casting algorithm
+function multiPolygonContainsPoint(rings: Array<Ring>, p: Point) {
+    let c = false,
+        ring, p1, p2;
+
+    for (let k = 0; k < rings.length; k++) {
+        ring = rings[k];
+        for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+            p1 = ring[i];
+            p2 = ring[j];
+            if (((p1.y > p.y) !== (p2.y > p.y)) && (p.x < (p2.x - p1.x) * (p.y - p1.y) / (p2.y - p1.y) + p1.x)) {
+                c = !c;
+            }
+        }
+    }
+    return c;
+}
+
+function polygonContainsPoint(ring: Ring, p: Point) {
+    let c = false;
+    for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+        const p1 = ring[i];
+        const p2 = ring[j];
+        if (((p1.y > p.y) !== (p2.y > p.y)) && (p.x < (p2.x - p1.x) * (p.y - p1.y) / (p2.y - p1.y) + p1.x)) {
+            c = !c;
+        }
+    }
+    return c;
+}
+
+function polygonIntersectsBox(ring: Ring, boxX1: number, boxY1: number, boxX2: number, boxY2: number) {
+    for (const p of ring) {
+        if (boxX1 <= p.x &&
+            boxY1 <= p.y &&
+            boxX2 >= p.x &&
+            boxY2 >= p.y) return true;
+    }
+
+    const corners = [
+        new Point(boxX1, boxY1),
+        new Point(boxX1, boxY2),
+        new Point(boxX2, boxY2),
+        new Point(boxX2, boxY1)];
+
+    if (ring.length > 2) {
+        for (const corner of corners) {
+            if (polygonContainsPoint(ring, corner)) return true;
+        }
+    }
+
+    for (let i = 0; i < ring.length - 1; i++) {
+        const p1 = ring[i];
+        const p2 = ring[i + 1];
+        if (edgeIntersectsBox(p1, p2, corners)) return true;
+    }
+
+    return false;
+}
+
+function edgeIntersectsBox(e1: Point, e2: Point, corners: Array<Point>) {
+    const tl = corners[0];
+    const br = corners[2];
+    // the edge and box do not intersect in either the x or y dimensions
+    if (((e1.x < tl.x) && (e2.x < tl.x)) ||
+        ((e1.x > br.x) && (e2.x > br.x)) ||
+        ((e1.y < tl.y) && (e2.y < tl.y)) ||
+        ((e1.y > br.y) && (e2.y > br.y))) return false;
+
+    // check if all corners of the box are on the same side of the edge
+    const dir = isCounterClockwise(e1, e2, corners[0]);
+    return dir !== isCounterClockwise(e1, e2, corners[1]) ||
+        dir !== isCounterClockwise(e1, e2, corners[2]) ||
+        dir !== isCounterClockwise(e1, e2, corners[3]);
+}