@mapwhit/tilerenderer 0.47.1

package/src/util/find_pole_of_inaccessibility.js

@@ -0,0 +1,129 @@
+const Queue = require('tinyqueue');
+
+const Point = require('@mapbox/point-geometry');
+const { distToSegmentSquared } = require('./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
+ */
+module.exports = function (polygonRings, precision = 1, debug = false) {
+  // find the bounding box of the outer ring
+  let minX = Number.POSITIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let maxX = Number.NEGATIVE_INFINITY;
+  let maxY = Number.NEGATIVE_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(null, 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 = Number.POSITIVE_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,15 @@
+const workerPool = require('./worker_pool');
+
+let globalWorkerPool;
+
+/**
+ * Creates (if necessary) and returns the single, global WorkerPool instance
+ * to be shared across each Map
+ * @private
+ */
+module.exports = function getGlobalWorkerPool() {
+  if (!globalWorkerPool) {
+    globalWorkerPool = workerPool();
+  }
+  return globalWorkerPool;
+};

package/src/util/image.js

@@ -0,0 +1,124 @@
+const assert = require('assert');
+
+const { register } = require('./web_worker_transfer');
+
+function createImage(image, { width, height }, channels, data) {
+  if (!data) {
+    data = new Uint8Array(width * height * channels);
+  } 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 }, channels) {
+  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, dstPt, size, channels) {
+  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;
+}
+
+class AlphaImage {
+  constructor(size, data) {
+    createImage(this, size, 1, data);
+  }
+
+  resize(size) {
+    resizeImage(this, size, 1);
+  }
+
+  clone() {
+    return new AlphaImage({ width: this.width, height: this.height }, new Uint8Array(this.data));
+  }
+
+  static copy(srcImg, dstImg, srcPt, dstPt, 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.
+class RGBAImage {
+  constructor(size, data) {
+    createImage(this, size, 4, data);
+  }
+
+  resize(size) {
+    resizeImage(this, size, 4);
+  }
+
+  clone() {
+    return new RGBAImage({ width: this.width, height: this.height }, new Uint8Array(this.data));
+  }
+
+  static copy(srcImg, dstImg, srcPt, dstPt, size) {
+    copyImage(srcImg, dstImg, srcPt, dstPt, size, 4);
+  }
+}
+
+register('AlphaImage', AlphaImage);
+register('RGBAImage', RGBAImage);
+
+module.exports = {
+  AlphaImage,
+  RGBAImage
+};

package/src/util/interpolate.js

@@ -0,0 +1,5 @@
+module.exports = interpolate;
+
+function interpolate(a, b, t) {
+  return a * (1 - t) + b * t;
+}

package/src/util/intersection_tests.js

@@ -0,0 +1,207 @@
+const { isCounterClockwise } = require('./util');
+const Point = require('@mapbox/point-geometry');
+
+module.exports = {
+  polygonIntersectsBufferedPoint,
+  polygonIntersectsMultiPolygon,
+  polygonIntersectsBufferedMultiLine,
+  polygonIntersectsPolygon,
+  distToSegmentSquared,
+  polygonIntersectsBox
+};
+
+function polygonIntersectsPolygon(polygonA, polygonB) {
+  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, point, radius) {
+  if (polygonContainsPoint(polygon, point)) return true;
+  if (pointIntersectsBufferedLine(point, polygon, radius)) return true;
+  return false;
+}
+
+function polygonIntersectsMultiPolygon(polygon, 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, multiLine, radius) {
+  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, lineB, radius) {
+  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, lineB) {
+  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, a1, b0, b1) {
+  return (
+    isCounterClockwise(a0, b0, b1) !== isCounterClockwise(a1, b0, b1) &&
+    isCounterClockwise(a0, a1, b0) !== isCounterClockwise(a0, a1, b1)
+  );
+}
+
+function pointIntersectsBufferedLine(p, line, radius) {
+  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];
+    const w = line[i];
+    if (distToSegmentSquared(p, v, w) < radiusSquared) return true;
+  }
+  return false;
+}
+
+// Code from http://stackoverflow.com/a/1501725/331379.
+function distToSegmentSquared(p, v, w) {
+  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, p) {
+  let c = false;
+  let ring;
+  let p1;
+  let 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, p) {
+  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, boxX1, boxY1, boxX2, boxY2) {
+  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, e2, corners) {
+  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])
+  );
+}