@math.gl/polygon 3.6.3 → 4.0.0-alpha.2

package/src/earcut.ts

@@ -22,9 +22,12 @@
 
  */
 
+// @ts-nocheck
+
 /* eslint-disable */
 
-import {getPolygonSignedArea} from './polygon-utils';
+import type {NumericArray} from '@math.gl/core';
+import {getPolygonSignedArea, DimIndex, Plane2D} from './polygon-utils';
 
 /**
  * Computes a triangulation of a polygon
@@ -36,14 +39,15 @@ import {getPolygonSignedArea} from './polygon-utils';
  * Adapted from https://github.com/mapbox/earcut
  */
 export function earcut(
-  positions: number[],
-  holeIndices?: number[],
+  positions: NumericArray,
+  holeIndices?: NumericArray,
   dim: number = 2,
-  areas?: number[]
+  areas?: NumericArray,
+  plane: Plane2D = 'xy'
 ): number[] {
   const hasHoles = holeIndices && holeIndices.length;
   const outerLen = hasHoles ? holeIndices[0] * dim : positions.length;
-  let outerNode = linkedList(positions, 0, outerLen, dim, true, areas && areas[0]);
+  let outerNode = linkedList(positions, 0, outerLen, dim, true, areas && areas[0], plane);
   const triangles = [];
 
   if (!outerNode || outerNode.next === outerNode.prev) return triangles;
@@ -56,7 +60,7 @@ export function earcut(
   let x;
   let y;
 
-  if (hasHoles) outerNode = eliminateHoles(positions, holeIndices, outerNode, dim, areas);
+  if (hasHoles) outerNode = eliminateHoles(positions, holeIndices, outerNode, dim, areas, plane);
 
   // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
   if (positions.length > 80 * dim) {
@@ -74,29 +78,40 @@ export function earcut(
 
     // minX, minY and invSize are later used to transform coords into integers for z-order calculation
     invSize = Math.max(maxX - minX, maxY - minY);
-    invSize = invSize !== 0 ? 1 / invSize : 0;
+    invSize = invSize !== 0 ? 32767 / invSize : 0;
   }
 
-  earcutLinked(outerNode, triangles, dim, minX, minY, invSize);
+  earcutLinked(outerNode, triangles, dim, minX, minY, invSize, 0);
 
   return triangles;
 }
 
 // create a circular doubly linked list from polygon points in the specified winding order
-function linkedList(data, start, end, dim, clockwise, area) {
+function linkedList(
+  data: NumericArray,
+  start: number,
+  end: number,
+  dim: number,
+  clockwise: boolean,
+  area: number | undefined,
+  plane: Plane2D
+): Vertex {
   let i;
   let last;
   if (area === undefined) {
-    area = getPolygonSignedArea(data, {start, end, size: dim});
+    area = getPolygonSignedArea(data, {start, end, size: dim, plane});
   }
 
+  let i0 = DimIndex[plane[0]];
+  let i1 = DimIndex[plane[1]];
   // Note that the signed area calculation in math.gl
   // has the opposite sign to that which was originally
   // present in earcut, thus the `< 0` is reversed
   if (clockwise === area < 0) {
-    for (i = start; i < end; i += dim) last = insertNode(i, data[i], data[i + 1], last);
+    for (i = start; i < end; i += dim) last = insertNode(i, data[i + i0], data[i + i1], last);
   } else {
-    for (i = end - dim; i >= start; i -= dim) last = insertNode(i, data[i], data[i + 1], last);
+    for (i = end - dim; i >= start; i -= dim)
+      last = insertNode(i, data[i + i0], data[i + i1], last);
   }
 
   if (last && equals(last, last.next)) {
@@ -148,9 +163,9 @@ function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass?) {
 
     if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
       // cut off the triangle
-      triangles.push(prev.i / dim);
-      triangles.push(ear.i / dim);
-      triangles.push(next.i / dim);
+      triangles.push((prev.i / dim) | 0);
+      triangles.push((ear.i / dim) | 0);
+      triangles.push((next.i / dim) | 0);
 
       removeNode(ear);
 
@@ -193,10 +208,29 @@ function isEar(ear) {
   if (area(a, b, c) >= 0) return false; // reflex, can't be an ear
 
   // now make sure we don't have other points inside the potential ear
-  let p = ear.next.next;
+  const ax = a.x;
+  const bx = b.x;
+  const cx = c.x;
+  const ay = a.y;
+  const by = b.y;
+  const cy = c.y;
+
+  // triangle bbox; min & max are calculated like this for speed
+  const x0 = ax < bx ? (ax < cx ? ax : cx) : bx < cx ? bx : cx;
+  const y0 = ay < by ? (ay < cy ? ay : cy) : by < cy ? by : cy;
+  const x1 = ax > bx ? (ax > cx ? ax : cx) : bx > cx ? bx : cx;
+  const y1 = ay > by ? (ay > cy ? ay : cy) : by > cy ? by : cy;
 
-  while (p !== ear.prev) {
-    if (pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+  let p = c.next;
+  while (p !== a) {
+    if (
+      p.x >= x0 &&
+      p.x <= x1 &&
+      p.y >= y0 &&
+      p.y <= y1 &&
+      pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) &&
+      area(p.prev, p, p.next) >= 0
+    )
       return false;
     p = p.next;
   }
@@ -211,15 +245,22 @@ function isEarHashed(ear, minX, minY, invSize) {
 
   if (area(a, b, c) >= 0) return false; // reflex, can't be an ear
 
+  const ax = a.x;
+  const bx = b.x;
+  const cx = c.x;
+  const ay = a.y;
+  const by = b.y;
+  const cy = c.y;
+
   // triangle bbox; min & max are calculated like this for speed
-  const minTX = a.x < b.x ? (a.x < c.x ? a.x : c.x) : b.x < c.x ? b.x : c.x;
-  const minTY = a.y < b.y ? (a.y < c.y ? a.y : c.y) : b.y < c.y ? b.y : c.y;
-  const maxTX = a.x > b.x ? (a.x > c.x ? a.x : c.x) : b.x > c.x ? b.x : c.x;
-  const maxTY = a.y > b.y ? (a.y > c.y ? a.y : c.y) : b.y > c.y ? b.y : c.y;
+  const x0 = ax < bx ? (ax < cx ? ax : cx) : bx < cx ? bx : cx;
+  const y0 = ay < by ? (ay < cy ? ay : cy) : by < cy ? by : cy;
+  const x1 = ax > bx ? (ax > cx ? ax : cx) : bx > cx ? bx : cx;
+  const y1 = ay > by ? (ay > cy ? ay : cy) : by > cy ? by : cy;
 
   // z-order range for the current triangle bbox;
-  const minZ = zOrder(minTX, minTY, minX, minY, invSize);
-  const maxZ = zOrder(maxTX, maxTY, minX, minY, invSize);
+  const minZ = zOrder(x0, y0, minX, minY, invSize);
+  const maxZ = zOrder(x1, y1, minX, minY, invSize);
 
   let p = ear.prevZ;
   let n = ear.nextZ;
@@ -227,18 +268,26 @@ function isEarHashed(ear, minX, minY, invSize) {
   // look for points inside the triangle in both directions
   while (p && p.z >= minZ && n && n.z <= maxZ) {
     if (
-      p !== ear.prev &&
-      p !== ear.next &&
-      pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) &&
+      p.x >= x0 &&
+      p.x <= x1 &&
+      p.y >= y0 &&
+      p.y <= y1 &&
+      p !== a &&
+      p !== c &&
+      pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) &&
       area(p.prev, p, p.next) >= 0
     )
       return false;
     p = p.prevZ;
 
     if (
-      n !== ear.prev &&
-      n !== ear.next &&
-      pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) &&
+      n.x >= x0 &&
+      n.x <= x1 &&
+      n.y >= y0 &&
+      n.y <= y1 &&
+      n !== a &&
+      n !== c &&
+      pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) &&
       area(n.prev, n, n.next) >= 0
     )
       return false;
@@ -248,9 +297,13 @@ function isEarHashed(ear, minX, minY, invSize) {
   // look for remaining points in decreasing z-order
   while (p && p.z >= minZ) {
     if (
-      p !== ear.prev &&
-      p !== ear.next &&
-      pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) &&
+      p.x >= x0 &&
+      p.x <= x1 &&
+      p.y >= y0 &&
+      p.y <= y1 &&
+      p !== a &&
+      p !== c &&
+      pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) &&
       area(p.prev, p, p.next) >= 0
     )
       return false;
@@ -260,9 +313,13 @@ function isEarHashed(ear, minX, minY, invSize) {
   // look for remaining points in increasing z-order
   while (n && n.z <= maxZ) {
     if (
-      n !== ear.prev &&
-      n !== ear.next &&
-      pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) &&
+      n.x >= x0 &&
+      n.x <= x1 &&
+      n.y >= y0 &&
+      n.y <= y1 &&
+      n !== a &&
+      n !== c &&
+      pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) &&
       area(n.prev, n, n.next) >= 0
     )
       return false;
@@ -285,9 +342,9 @@ function cureLocalIntersections(start, triangles, dim) {
       locallyInside(a, b) &&
       locallyInside(b, a)
     ) {
-      triangles.push(a.i / dim);
-      triangles.push(p.i / dim);
-      triangles.push(b.i / dim);
+      triangles.push((a.i / dim) | 0);
+      triangles.push((p.i / dim) | 0);
+      triangles.push((b.i / dim) | 0);
 
       // remove two nodes involved
       removeNode(p);
@@ -317,8 +374,8 @@ function splitEarcut(start, triangles, dim, minX, minY, invSize) {
         c = filterPoints(c, c.next);
 
         // run earcut on each half
-        earcutLinked(a, triangles, dim, minX, minY, invSize);
-        earcutLinked(c, triangles, dim, minX, minY, invSize);
+        earcutLinked(a, triangles, dim, minX, minY, invSize, 0);
+        earcutLinked(c, triangles, dim, minX, minY, invSize, 0);
         return;
       }
       b = b.next;
@@ -328,7 +385,14 @@ function splitEarcut(start, triangles, dim, minX, minY, invSize) {
 }
 
 // link every hole into the outer loop, producing a single-ring polygon without holes
-function eliminateHoles(data, holeIndices, outerNode, dim, areas) {
+function eliminateHoles(
+  data: NumericArray,
+  holeIndices: NumericArray,
+  outerNode: Vertex,
+  dim: number,
+  areas: NumericArray | undefined,
+  plane: Plane2D
+): Vertex {
   const queue = [];
   let i;
   let len;
@@ -339,7 +403,7 @@ function eliminateHoles(data, holeIndices, outerNode, dim, areas) {
   for (i = 0, len = holeIndices.length; i < len; i++) {
     start = holeIndices[i] * dim;
     end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
-    list = linkedList(data, start, end, dim, false, areas && areas[i + 1]);
+    list = linkedList(data, start, end, dim, false, areas && areas[i + 1], plane);
     if (list === list.next) list.steiner = true;
     queue.push(getLeftmost(list));
   }
@@ -348,8 +412,7 @@ function eliminateHoles(data, holeIndices, outerNode, dim, areas) {
 
   // process holes from left to right
   for (i = 0; i < queue.length; i++) {
-    eliminateHole(queue[i], outerNode);
-    outerNode = filterPoints(outerNode, outerNode.next);
+    outerNode = eliminateHole(queue[i], outerNode);
   }
 
   return outerNode;
@@ -361,14 +424,16 @@ function compareX(a, b) {
 
 // find a bridge between vertices that connects hole with an outer ring and and link it
 function eliminateHole(hole, outerNode) {
-  outerNode = findHoleBridge(hole, outerNode);
-  if (outerNode) {
-    const b = splitPolygon(outerNode, hole);
-
-    // filter collinear points around the cuts
-    filterPoints(outerNode, outerNode.next);
-    filterPoints(b, b.next);
+  const bridge = findHoleBridge(hole, outerNode);
+  if (!bridge) {
+    return outerNode;
   }
+
+  const bridgeReverse = splitPolygon(bridge, hole);
+
+  // filter collinear points around the cuts
+  filterPoints(bridgeReverse, bridgeReverse.next);
+  return filterPoints(bridge, bridge.next);
 }
 
 // David Eberly's algorithm for finding a bridge between hole and outer polygon
@@ -386,11 +451,8 @@ function findHoleBridge(hole, outerNode) {
       const x = p.x + ((hy - p.y) * (p.next.x - p.x)) / (p.next.y - p.y);
       if (x <= hx && x > qx) {
         qx = x;
-        if (x === hx) {
-          if (hy === p.y) return p;
-          if (hy === p.next.y) return p.next;
-        }
         m = p.x < p.next.x ? p : p.next;
+        if (x === hx) return m; // hole touches outer segment; pick leftmost endpoint
       }
     }
     p = p.next;
@@ -398,8 +460,6 @@ function findHoleBridge(hole, outerNode) {
 
   if (!m) return null;
 
-  if (hx === qx) return m; // hole touches outer segment; pick leftmost endpoint
-
   // look for points inside the triangle of hole point, segment intersection and endpoint;
   // if there are no points found, we have a valid connection;
   // otherwise choose the point of the minimum angle with the ray as connection point
@@ -446,7 +506,7 @@ function sectorContainsSector(m, p) {
 function indexCurve(start, minX, minY, invSize) {
   let p = start;
   do {
-    if (p.z === null) p.z = zOrder(p.x, p.y, minX, minY, invSize);
+    if (p.z === 0) p.z = zOrder(p.x, p.y, minX, minY, invSize);
     p.prevZ = p.prev;
     p.nextZ = p.next;
     p = p.next;
@@ -519,8 +579,8 @@ function sortLinked(list) {
 // z-order of a point given coords and inverse of the longer side of data bbox
 function zOrder(x, y, minX, minY, invSize) {
   // coords are transformed into non-negative 15-bit integer range
-  x = 32767 * (x - minX) * invSize;
-  y = 32767 * (y - minY) * invSize;
+  x = ((x - minX) * invSize) | 0;
+  y = ((y - minY) * invSize) | 0;
 
   x = (x | (x << 8)) & 0x00ff00ff;
   x = (x | (x << 4)) & 0x0f0f0f0f;
@@ -550,9 +610,9 @@ function getLeftmost(start) {
 // check if a point lies within a convex triangle
 function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
   return (
-    (cx - px) * (ay - py) - (ax - px) * (cy - py) >= 0 &&
-    (ax - px) * (by - py) - (bx - px) * (ay - py) >= 0 &&
-    (bx - px) * (cy - py) - (cx - px) * (by - py) >= 0
+    (cx - px) * (ay - py) >= (ax - px) * (cy - py) &&
+    (ax - px) * (by - py) >= (bx - px) * (ay - py) &&
+    (bx - px) * (cy - py) >= (cx - px) * (by - py)
   );
 }
 
@@ -658,8 +718,8 @@ function middleInside(a, b) {
 // link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits polygon into two;
 // if one belongs to the outer ring and another to a hole, it merges it into a single ring
 function splitPolygon(a, b) {
-  const a2 = new Node(a.i, a.x, a.y);
-  const b2 = new Node(b.i, b.x, b.y);
+  const a2 = new Vertex(a.i, a.x, a.y);
+  const b2 = new Vertex(b.i, b.x, b.y);
   const an = a.next;
   const bp = b.prev;
 
@@ -680,7 +740,7 @@ function splitPolygon(a, b) {
 
 // create a node and optionally link it with previous one (in a circular doubly linked list)
 function insertNode(i, x, y, last) {
-  const p = new Node(i, x, y);
+  const p = new Vertex(i, x, y);
 
   if (!last) {
     p.prev = p;
@@ -702,25 +762,31 @@ function removeNode(p) {
   if (p.nextZ) p.nextZ.prevZ = p.prevZ;
 }
 
-function Node(i, x, y) {
+class Vertex {
   // vertex index in coordinates array
-  this.i = i;
+  i: number;
 
   // vertex coordinates
-  this.x = x;
-  this.y = y;
+  x: number;
+  y: number;
 
   // previous and next vertex nodes in a polygon ring
-  this.prev = null;
-  this.next = null;
+  prev: Vertex = null;
+  next: Vertex = null;
 
   // z-order curve value
-  this.z = null;
+  z: number = 0;
 
   // previous and next nodes in z-order
-  this.prevZ = null;
-  this.nextZ = null;
+  prevZ: Vertex = null;
+  nextZ: Vertex = null;
 
   // indicates whether this is a steiner point
-  this.steiner = false;
+  steiner: boolean = false;
+
+  constructor(i: number, x: number, y: number) {
+    this.i = i;
+    this.x = x;
+    this.y = y;
+  }
 }

package/src/index.ts

@@ -1,4 +1,4 @@
-export {default as Polygon} from './polygon';
+export {Polygon} from './polygon';
 
 export {
   getPolygonSignedArea,
@@ -16,5 +16,5 @@ export {cutPolygonByGrid, cutPolylineByGrid} from './cut-by-grid';
 
 export {cutPolylineByMercatorBounds, cutPolygonByMercatorBounds} from './cut-by-mercator-bounds';
 
-// DEPRECATED
-export {default as _Polygon} from './polygon';
+/** @deprecated */
+export {Polygon as _Polygon} from './polygon';

package/src/polygon-utils.ts

@@ -29,12 +29,34 @@ export type SegmentVisitorPoints = (
   i2: number
 ) => void;
 
+export type Plane2D = 'xy' | 'yz' | 'xz';
+
 /** Parameters of a polygon. */
 type PolygonParams = {
-  start?: number; // Start index of the polygon in the array of positions. Defaults to 0.
-  end?: number; // End index of the polygon in the array of positions. Defaults to number of positions.
-  size?: number; // Size of a point, 2 (XZ) or 3 (XYZ). Defaults to 2. Affects only polygons stored in flat arrays.
-  isClosed?: boolean; // Indicates that the first point of the polygon is equal to the last point, and additional checks should be ommited.
+  /**
+   * Start index of the polygon in the array of positions.
+   * @default `0`
+   */
+  start?: number;
+  /**
+   * End index of the polygon in the array of positions.
+   * @default number of positions
+   */
+  end?: number;
+  /**
+   * Size of a point, 2 (XZ) or 3 (XYZ). Affects only polygons stored in flat arrays.
+   * @default `2`
+   */
+  size?: number;
+  /**
+   * Indicates that the first point of the polygon is equal to the last point, and additional checks should be ommited.
+   */
+  isClosed?: boolean;
+  /**
+   * The 2D projection plane on which to calculate the area of a 3D polygon.
+   * @default `'xy'`
+   */
+  plane?: Plane2D;
 };
 
 /**
@@ -71,6 +93,12 @@ export function getPolygonWindingDirection(
   return Math.sign(getPolygonSignedArea(points, options));
 }
 
+export const DimIndex: Record<string, number> = {
+  x: 0,
+  y: 1,
+  z: 2
+} as const;
+
 /**
  * Returns signed area of the polygon.
  * @param points An array that represents points of the polygon.
@@ -79,11 +107,14 @@ export function getPolygonWindingDirection(
  * https://en.wikipedia.org/wiki/Shoelace_formula
  */
 export function getPolygonSignedArea(points: NumericArray, options: PolygonParams = {}): number {
-  const {start = 0, end = points.length} = options;
+  const {start = 0, end = points.length, plane = 'xy'} = options;
   const dim = options.size || 2;
   let area = 0;
+  const i0 = DimIndex[plane[0]];
+  const i1 = DimIndex[plane[1]];
+
   for (let i = start, j = end - dim; i < end; i += dim) {
-    area += (points[i] - points[j]) * (points[i + 1] + points[j + 1]);
+    area += (points[i + i0] - points[j + i0]) * (points[i + i1] + points[j + i1]);
     j = i;
   }
   return area / 2;
@@ -196,10 +227,13 @@ export function getPolygonSignedAreaPoints(
   options: PolygonParams = {}
 ): number {
   // https://en.wikipedia.org/wiki/Shoelace_formula
-  const {start = 0, end = points.length} = options;
+  const {start = 0, end = points.length, plane = 'xy'} = options;
   let area = 0;
+  const i0 = DimIndex[plane[0]];
+  const i1 = DimIndex[plane[1]];
+
   for (let i = start, j = end - 1; i < end; ++i) {
-    area += (points[i][0] - points[j][0]) * (points[i][1] + points[j][1]);
+    area += (points[i][i0] - points[j][i0]) * (points[i][i1] + points[j][i1]);
     j = i;
   }
   return area / 2;

package/src/polygon.ts

@@ -19,7 +19,7 @@ export type PolygonOptions = {
   isClosed?: boolean;
 };
 
-export default class Polygon {
+export class Polygon {
   points: NumericArray | number[][];
   isFlatArray: boolean;
   options: PolygonOptions;