@mapwhit/tilerenderer 0.47.1

package/src/symbol/get_anchors.js

@@ -0,0 +1,177 @@
+const interpolate = require('../util/interpolate');
+
+const Anchor = require('../symbol/anchor');
+const checkMaxAngle = require('./check_max_angle');
+
+module.exports = { getAnchors, getCenterAnchor };
+
+function getLineLength(line) {
+  let lineLength = 0;
+  for (let k = 0; k < line.length - 1; k++) {
+    lineLength += line[k].dist(line[k + 1]);
+  }
+  return lineLength;
+}
+
+function getAngleWindowSize(shapedText, glyphSize, boxScale) {
+  return shapedText ? (3 / 5) * glyphSize * boxScale : 0;
+}
+
+function getLabelLength(shapedText, shapedIcon) {
+  return Math.max(
+    shapedText ? shapedText.right - shapedText.left : 0,
+    shapedIcon ? shapedIcon.right - shapedIcon.left : 0
+  );
+}
+
+function getCenterAnchor(line, maxAngle, shapedText, shapedIcon, glyphSize, boxScale) {
+  const angleWindowSize = getAngleWindowSize(shapedText, glyphSize, boxScale);
+  const labelLength = getLabelLength(shapedText, shapedIcon);
+
+  let prevDistance = 0;
+  const centerDistance = getLineLength(line) / 2;
+
+  for (let i = 0; i < line.length - 1; i++) {
+    const a = line[i];
+    const b = line[i + 1];
+
+    const segmentDistance = a.dist(b);
+
+    if (prevDistance + segmentDistance > centerDistance) {
+      // The center is on this segment
+      const t = (centerDistance - prevDistance) / segmentDistance;
+      const x = interpolate(a.x, b.x, t);
+      const y = interpolate(a.y, b.y, t);
+
+      const anchor = new Anchor(x, y, b.angleTo(a), i);
+      anchor._round();
+      if (angleWindowSize && !checkMaxAngle(line, anchor, labelLength, angleWindowSize, maxAngle)) {
+        return;
+      }
+
+      return anchor;
+    }
+
+    prevDistance += segmentDistance;
+  }
+}
+
+function getAnchors(line, spacing, maxAngle, shapedText, shapedIcon, glyphSize, boxScale, overscaling, tileExtent) {
+  // Resample a line to get anchor points for labels and check that each
+  // potential label passes text-max-angle check and has enough froom to fit
+  // on the line.
+
+  const angleWindowSize = getAngleWindowSize(shapedText, glyphSize, boxScale);
+
+  const labelLength = getLabelLength(shapedText, shapedIcon);
+
+  // Is the line continued from outside the tile boundary?
+  const isLineContinued = line[0].x === 0 || line[0].x === tileExtent || line[0].y === 0 || line[0].y === tileExtent;
+
+  // Is the label long, relative to the spacing?
+  // If so, adjust the spacing so there is always a minimum space of `spacing / 4` between label edges.
+  if (spacing - labelLength * boxScale < spacing / 4) {
+    spacing = labelLength * boxScale + spacing / 4;
+  }
+
+  // Offset the first anchor by:
+  // Either half the label length plus a fixed extra offset if the line is not continued
+  // Or half the spacing if the line is continued.
+
+  // For non-continued lines, add a bit of fixed extra offset to avoid collisions at T intersections.
+  const fixedExtraOffset = glyphSize * 2;
+
+  const offset = !isLineContinued
+    ? ((labelLength / 2 + fixedExtraOffset) * boxScale * overscaling) % spacing
+    : ((spacing / 2) * overscaling) % spacing;
+
+  return resample(
+    line,
+    offset,
+    spacing,
+    angleWindowSize,
+    maxAngle,
+    labelLength * boxScale,
+    isLineContinued,
+    false,
+    tileExtent
+  );
+}
+
+function resample(
+  line,
+  offset,
+  spacing,
+  angleWindowSize,
+  maxAngle,
+  labelLength,
+  isLineContinued,
+  placeAtMiddle,
+  tileExtent
+) {
+  const halfLabelLength = labelLength / 2;
+  const lineLength = getLineLength(line);
+
+  let distance = 0;
+  let markedDistance = offset - spacing;
+
+  let anchors = [];
+
+  for (let i = 0; i < line.length - 1; i++) {
+    const a = line[i];
+    const b = line[i + 1];
+
+    const segmentDist = a.dist(b);
+    const angle = b.angleTo(a);
+
+    while (markedDistance + spacing < distance + segmentDist) {
+      markedDistance += spacing;
+
+      const t = (markedDistance - distance) / segmentDist;
+      const x = interpolate(a.x, b.x, t);
+      const y = interpolate(a.y, b.y, t);
+
+      // Check that the point is within the tile boundaries and that
+      // the label would fit before the beginning and end of the line
+      // if placed at this point.
+      if (
+        x >= 0 &&
+        x < tileExtent &&
+        y >= 0 &&
+        y < tileExtent &&
+        markedDistance - halfLabelLength >= 0 &&
+        markedDistance + halfLabelLength <= lineLength
+      ) {
+        const anchor = new Anchor(x, y, angle, i);
+        anchor._round();
+
+        if (!angleWindowSize || checkMaxAngle(line, anchor, labelLength, angleWindowSize, maxAngle)) {
+          anchors.push(anchor);
+        }
+      }
+    }
+
+    distance += segmentDist;
+  }
+
+  if (!placeAtMiddle && !anchors.length && !isLineContinued) {
+    // The first attempt at finding anchors at which labels can be placed failed.
+    // Try again, but this time just try placing one anchor at the middle of the line.
+    // This has the most effect for short lines in overscaled tiles, since the
+    // initial offset used in overscaled tiles is calculated to align labels with positions in
+    // parent tiles instead of placing the label as close to the beginning as possible.
+    anchors = resample(
+      line,
+      distance / 2,
+      spacing,
+      angleWindowSize,
+      maxAngle,
+      labelLength,
+      isLineContinued,
+      true,
+      tileExtent
+    );
+  }
+
+  return anchors;
+}

package/src/symbol/grid_index.js

@@ -0,0 +1,318 @@
+/**
+ * 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 {
+  constructor(width, height, cellSize) {
+    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, x1, y1, x2, y2) {
+    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, x, y, radius) {
+    // 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, y1, x2, y2, cellIndex, uid) {
+    this.boxCells[cellIndex].push(uid);
+  }
+
+  _insertCircleCell(x1, y1, x2, y2, cellIndex, uid) {
+    this.circleCells[cellIndex].push(uid);
+  }
+
+  _query(x1, y1, x2, y2, hitTest, predicate) {
+    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;
+    }
+    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, y, radius, hitTest, predicate) {
+    // 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: x, y: y, radius: radius },
+      seenUids: { box: {}, circle: {} }
+    };
+    this._forEachCell(x1, y1, x2, y2, this._queryCellCircle, result, queryArgs, predicate);
+    return hitTest ? result.length > 0 : result;
+  }
+
+  query(x1, y1, x2, y2, predicate) {
+    return this._query(x1, y1, x2, y2, false, predicate);
+  }
+
+  hitTest(x1, y1, x2, y2, predicate) {
+    return this._query(x1, y1, x2, y2, true, predicate);
+  }
+
+  hitTestCircle(x, y, radius, predicate) {
+    return this._queryCircle(x, y, radius, true, predicate);
+  }
+
+  _queryCell(x1, y1, x2, y2, cellIndex, result, queryArgs, predicate) {
+    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;
+            }
+            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;
+            }
+            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, y1, x2, y2, cellIndex, result, queryArgs, predicate) {
+    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, y1, x2, y2, fn, arg1, arg2, predicate) {
+    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) {
+    return Math.max(0, Math.min(this.xCellCount - 1, Math.floor(x * this.xScale)));
+  }
+
+  _convertToYCellCoord(y) {
+    return Math.max(0, Math.min(this.yCellCount - 1, Math.floor(y * this.yScale)));
+  }
+
+  _circlesCollide(x1, y1, r1, x2, y2, r2) {
+    const dx = x2 - x1;
+    const dy = y2 - y1;
+    const bothRadii = r1 + r2;
+    return bothRadii * bothRadii > dx * dx + dy * dy;
+  }
+
+  _circleAndRectCollide(circleX, circleY, radius, x1, y1, x2, y2) {
+    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;
+  }
+}
+
+module.exports = GridIndex;

package/src/symbol/mergelines.js

@@ -0,0 +1,75 @@
+module.exports = function (features) {
+  const leftIndex = {};
+  const rightIndex = {};
+  const mergedFeatures = [];
+  let mergedIndex = 0;
+
+  function add(k) {
+    mergedFeatures.push(features[k]);
+    mergedIndex++;
+  }
+
+  function mergeFromRight(leftKey, rightKey, 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, rightKey, 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;
+
+    if (!text) {
+      add(k);
+      continue;
+    }
+
+    const leftKey = getKey(text, geom);
+    const 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;
+    } 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/opacity_state.js

@@ -0,0 +1,21 @@
+const { register } = require('../util/web_worker_transfer');
+
+class OpacityState {
+  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);
+
+module.exports = OpacityState;