@math.gl/polygon 4.0.0-beta.1 → 4.0.1

package/dist/cut-by-grid.d.ts

@@ -1,5 +1,5 @@
 import type { NumericArray } from '@math.gl/core';
-export declare type Polygon = {
+export type Polygon = {
     positions: Readonly<NumericArray>;
     holeIndices?: Readonly<NumericArray>;
     edgeTypes?: Readonly<NumericArray>;
@@ -21,4 +21,3 @@ export declare function cutPolygonByGrid(positions: Readonly<NumericArray>, hole
     gridOffset?: [number, number];
     edgeTypes?: boolean;
 }): Polygon[];
-//# sourceMappingURL=cut-by-grid.d.ts.map

package/dist/cut-by-grid.js

@@ -1,251 +1,217 @@
+/* eslint-disable max-statements, max-depth, complexity, no-unused-expressions */
 import { bitCode, intersect } from "./lineclip.js";
 import { getPointAtIndex, copy, push } from "./utils.js";
 export function cutPolylineByGrid(positions, options) {
-  const {
-    size = 2,
-    broken = false,
-    gridResolution = 10,
-    gridOffset = [0, 0],
-    startIndex = 0,
-    endIndex = positions.length
-  } = options || {};
-  const numPoints = (endIndex - startIndex) / size;
-  let part = [];
-  const result = [part];
-  const a = getPointAtIndex(positions, 0, size, startIndex);
-  let b;
-  let codeB;
-  const cell = getGridCell(a, gridResolution, gridOffset, []);
-  const scratchPoint = [];
-  push(part, a);
-
-  for (let i = 1; i < numPoints; i++) {
-    b = getPointAtIndex(positions, i, size, startIndex, b);
-    codeB = bitCode(b, cell);
-
-    while (codeB) {
-      intersect(a, b, codeB, cell, scratchPoint);
-      const codeAlt = bitCode(scratchPoint, cell);
-
-      if (codeAlt) {
-        intersect(a, scratchPoint, codeAlt, cell, scratchPoint);
-        codeB = codeAlt;
-      }
-
-      push(part, scratchPoint);
-      copy(a, scratchPoint);
-      moveToNeighborCell(cell, gridResolution, codeB);
-
-      if (broken && part.length > size) {
-        part = [];
-        result.push(part);
-        push(part, a);
-      }
-
-      codeB = bitCode(b, cell);
+    const { size = 2, broken = false, gridResolution = 10, gridOffset = [0, 0], startIndex = 0, endIndex = positions.length } = options || {};
+    const numPoints = (endIndex - startIndex) / size;
+    let part = [];
+    const result = [part];
+    const a = getPointAtIndex(positions, 0, size, startIndex);
+    let b;
+    let codeB;
+    const cell = getGridCell(a, gridResolution, gridOffset, []);
+    const scratchPoint = [];
+    push(part, a);
+    for (let i = 1; i < numPoints; i++) {
+        b = getPointAtIndex(positions, i, size, startIndex, b);
+        codeB = bitCode(b, cell);
+        while (codeB) {
+            // find the intersection with the current cell
+            intersect(a, b, codeB, cell, scratchPoint);
+            const codeAlt = bitCode(scratchPoint, cell);
+            if (codeAlt) {
+                intersect(a, scratchPoint, codeAlt, cell, scratchPoint);
+                codeB = codeAlt;
+            }
+            push(part, scratchPoint);
+            // move to the next cell
+            copy(a, scratchPoint);
+            moveToNeighborCell(cell, gridResolution, codeB);
+            if (broken && part.length > size) {
+                part = [];
+                result.push(part);
+                push(part, a);
+            }
+            codeB = bitCode(b, cell);
+        }
+        push(part, b);
+        copy(a, b);
     }
-
-    push(part, b);
-    copy(a, b);
-  }
-
-  return broken ? result : result[0];
+    return broken ? result : result[0];
 }
 const TYPE_INSIDE = 0;
 const TYPE_BORDER = 1;
+/**
+ * Cuts a polygon by a pre-defined grid
+ */
 export function cutPolygonByGrid(positions, holeIndices = null, options) {
-  if (!positions.length) {
-    return [];
-  }
-
-  const {
-    size = 2,
-    gridResolution = 10,
-    gridOffset = [0, 0],
-    edgeTypes = false
-  } = options || {};
-  const result = [];
-  const queue = [{
-    pos: positions,
-    types: edgeTypes ? new Array(positions.length / size).fill(TYPE_BORDER) : null,
-    holes: holeIndices || []
-  }];
-  const bbox = [[], []];
-  let cell = [];
-
-  while (queue.length) {
-    const {
-      pos,
-      types,
-      holes
-    } = queue.shift();
-    getBoundingBox(pos, size, holes[0] || pos.length, bbox);
-    cell = getGridCell(bbox[0], gridResolution, gridOffset, cell);
-    const code = bitCode(bbox[1], cell);
-
-    if (code) {
-      let parts = bisectPolygon(pos, types, size, 0, holes[0] || pos.length, cell, code);
-      const polygonLow = {
-        pos: parts[0].pos,
-        types: parts[0].types,
-        holes: []
-      };
-      const polygonHigh = {
-        pos: parts[1].pos,
-        types: parts[1].types,
-        holes: []
-      };
-      queue.push(polygonLow, polygonHigh);
-
-      for (let i = 0; i < holes.length; i++) {
-        parts = bisectPolygon(pos, types, size, holes[i], holes[i + 1] || pos.length, cell, code);
-
-        if (parts[0]) {
-          polygonLow.holes.push(polygonLow.pos.length);
-          polygonLow.pos = concatInPlace(polygonLow.pos, parts[0].pos);
-
-          if (edgeTypes) {
-            polygonLow.types = concatInPlace(polygonLow.types, parts[0].types);
-          }
+    if (!positions.length) {
+        // input is empty
+        return [];
+    }
+    const { size = 2, gridResolution = 10, gridOffset = [0, 0], edgeTypes = false } = options || {};
+    const result = [];
+    const queue = [
+        {
+            pos: positions,
+            types: edgeTypes ? new Array(positions.length / size).fill(TYPE_BORDER) : null,
+            holes: holeIndices || []
         }
-
-        if (parts[1]) {
-          polygonHigh.holes.push(polygonHigh.pos.length);
-          polygonHigh.pos = concatInPlace(polygonHigh.pos, parts[1].pos);
-
-          if (edgeTypes) {
-            polygonHigh.types = concatInPlace(polygonHigh.types, parts[1].types);
-          }
+    ];
+    const bbox = [[], []];
+    // @ts-ignore
+    let cell = [];
+    // Recursively bisect polygon until every part fit in a single grid cell
+    while (queue.length) {
+        const { pos, types, holes } = queue.shift();
+        // Get the bounding box of the outer polygon
+        getBoundingBox(pos, size, holes[0] || pos.length, bbox);
+        cell = getGridCell(bbox[0], gridResolution, gridOffset, cell);
+        const code = bitCode(bbox[1], cell);
+        if (code) {
+            // Split the outer ring at the boundary
+            let parts = bisectPolygon(pos, types, size, 0, holes[0] || pos.length, cell, code);
+            const polygonLow = { pos: parts[0].pos, types: parts[0].types, holes: [] };
+            const polygonHigh = { pos: parts[1].pos, types: parts[1].types, holes: [] };
+            queue.push(polygonLow, polygonHigh);
+            // Split each hole at the boundary
+            for (let i = 0; i < holes.length; i++) {
+                parts = bisectPolygon(pos, types, size, holes[i], holes[i + 1] || pos.length, cell, code);
+                if (parts[0]) {
+                    polygonLow.holes.push(polygonLow.pos.length);
+                    polygonLow.pos = concatInPlace(polygonLow.pos, parts[0].pos);
+                    if (edgeTypes) {
+                        polygonLow.types = concatInPlace(polygonLow.types, parts[0].types);
+                    }
+                }
+                if (parts[1]) {
+                    polygonHigh.holes.push(polygonHigh.pos.length);
+                    polygonHigh.pos = concatInPlace(polygonHigh.pos, parts[1].pos);
+                    if (edgeTypes) {
+                        polygonHigh.types = concatInPlace(polygonHigh.types, parts[1].types);
+                    }
+                }
+            }
+        }
+        else {
+            // Polygon fits in a single cell, no more processing required
+            const polygon = { positions: pos };
+            if (edgeTypes) {
+                polygon.edgeTypes = types;
+            }
+            if (holes.length) {
+                polygon.holeIndices = holes;
+            }
+            result.push(polygon);
         }
-      }
-    } else {
-      const polygon = {
-        positions: pos
-      };
-
-      if (edgeTypes) {
-        polygon.edgeTypes = types;
-      }
-
-      if (holes.length) {
-        polygon.holeIndices = holes;
-      }
-
-      result.push(polygon);
     }
-  }
-
-  return result;
+    return result;
 }
-
+// edgeTypes:
+// TYPE_BORDER - edge from the original polygon
+// TYPE_INSIDE - inside the original polygon
+// eslint-disable-next-line max-params
 function bisectPolygon(positions, edgeTypes, size, startIndex, endIndex, bbox, edge) {
-  const numPoints = (endIndex - startIndex) / size;
-  const resultLow = [];
-  const resultHigh = [];
-  const typesLow = [];
-  const typesHigh = [];
-  const scratchPoint = [];
-  let p;
-  let side;
-  let type;
-  const prev = getPointAtIndex(positions, numPoints - 1, size, startIndex);
-  let prevSide = Math.sign(edge & 8 ? prev[1] - bbox[3] : prev[0] - bbox[2]);
-  let prevType = edgeTypes && edgeTypes[numPoints - 1];
-  let lowPointCount = 0;
-  let highPointCount = 0;
-
-  for (let i = 0; i < numPoints; i++) {
-    p = getPointAtIndex(positions, i, size, startIndex, p);
-    side = Math.sign(edge & 8 ? p[1] - bbox[3] : p[0] - bbox[2]);
-    type = edgeTypes && edgeTypes[startIndex / size + i];
-
-    if (side && prevSide && prevSide !== side) {
-      intersect(prev, p, edge, bbox, scratchPoint);
-      push(resultLow, scratchPoint) && typesLow.push(prevType);
-      push(resultHigh, scratchPoint) && typesHigh.push(prevType);
-    }
-
-    if (side <= 0) {
-      push(resultLow, p) && typesLow.push(type);
-      lowPointCount -= side;
-    } else if (typesLow.length) {
-      typesLow[typesLow.length - 1] = TYPE_INSIDE;
-    }
-
-    if (side >= 0) {
-      push(resultHigh, p) && typesHigh.push(type);
-      highPointCount += side;
-    } else if (typesHigh.length) {
-      typesHigh[typesHigh.length - 1] = TYPE_INSIDE;
+    const numPoints = (endIndex - startIndex) / size;
+    const resultLow = [];
+    const resultHigh = [];
+    const typesLow = [];
+    const typesHigh = [];
+    const scratchPoint = [];
+    let p;
+    let side;
+    let type;
+    const prev = getPointAtIndex(positions, numPoints - 1, size, startIndex);
+    let prevSide = Math.sign(edge & 8 ? prev[1] - bbox[3] : prev[0] - bbox[2]);
+    let prevType = edgeTypes && edgeTypes[numPoints - 1];
+    let lowPointCount = 0;
+    let highPointCount = 0;
+    for (let i = 0; i < numPoints; i++) {
+        p = getPointAtIndex(positions, i, size, startIndex, p);
+        side = Math.sign(edge & 8 ? p[1] - bbox[3] : p[0] - bbox[2]);
+        type = edgeTypes && edgeTypes[startIndex / size + i];
+        // if segment goes through the boundary, add an intersection
+        if (side && prevSide && prevSide !== side) {
+            intersect(prev, p, edge, bbox, scratchPoint);
+            push(resultLow, scratchPoint) && typesLow.push(prevType);
+            push(resultHigh, scratchPoint) && typesHigh.push(prevType);
+        }
+        if (side <= 0) {
+            push(resultLow, p) && typesLow.push(type);
+            lowPointCount -= side;
+        }
+        else if (typesLow.length) {
+            typesLow[typesLow.length - 1] = TYPE_INSIDE;
+        }
+        if (side >= 0) {
+            push(resultHigh, p) && typesHigh.push(type);
+            highPointCount += side;
+        }
+        else if (typesHigh.length) {
+            typesHigh[typesHigh.length - 1] = TYPE_INSIDE;
+        }
+        copy(prev, p);
+        prevSide = side;
+        prevType = type;
     }
-
-    copy(prev, p);
-    prevSide = side;
-    prevType = type;
-  }
-
-  return [lowPointCount ? {
-    pos: resultLow,
-    types: edgeTypes && typesLow
-  } : null, highPointCount ? {
-    pos: resultHigh,
-    types: edgeTypes && typesHigh
-  } : null];
+    return [
+        lowPointCount ? { pos: resultLow, types: edgeTypes && typesLow } : null,
+        highPointCount ? { pos: resultHigh, types: edgeTypes && typesHigh } : null
+    ];
 }
-
 function getGridCell(p, gridResolution, gridOffset, out) {
-  const left = Math.floor((p[0] - gridOffset[0]) / gridResolution) * gridResolution + gridOffset[0];
-  const bottom = Math.floor((p[1] - gridOffset[1]) / gridResolution) * gridResolution + gridOffset[1];
-  out[0] = left;
-  out[1] = bottom;
-  out[2] = left + gridResolution;
-  out[3] = bottom + gridResolution;
-  return out;
+    const left = Math.floor((p[0] - gridOffset[0]) / gridResolution) * gridResolution + gridOffset[0];
+    const bottom = Math.floor((p[1] - gridOffset[1]) / gridResolution) * gridResolution + gridOffset[1];
+    out[0] = left;
+    out[1] = bottom;
+    out[2] = left + gridResolution;
+    out[3] = bottom + gridResolution;
+    return out;
 }
-
 function moveToNeighborCell(cell, gridResolution, edge) {
-  if (edge & 8) {
-    cell[1] += gridResolution;
-    cell[3] += gridResolution;
-  } else if (edge & 4) {
-    cell[1] -= gridResolution;
-    cell[3] -= gridResolution;
-  } else if (edge & 2) {
-    cell[0] += gridResolution;
-    cell[2] += gridResolution;
-  } else if (edge & 1) {
-    cell[0] -= gridResolution;
-    cell[2] -= gridResolution;
-  }
+    if (edge & 8) {
+        // top
+        cell[1] += gridResolution;
+        cell[3] += gridResolution;
+    }
+    else if (edge & 4) {
+        // bottom
+        cell[1] -= gridResolution;
+        cell[3] -= gridResolution;
+    }
+    else if (edge & 2) {
+        // right
+        cell[0] += gridResolution;
+        cell[2] += gridResolution;
+    }
+    else if (edge & 1) {
+        // left
+        cell[0] -= gridResolution;
+        cell[2] -= gridResolution;
+    }
 }
-
 function getBoundingBox(positions, size, endIndex, out) {
-  let minX = Infinity;
-  let maxX = -Infinity;
-  let minY = Infinity;
-  let maxY = -Infinity;
-
-  for (let i = 0; i < endIndex; i += size) {
-    const x = positions[i];
-    const y = positions[i + 1];
-    minX = x < minX ? x : minX;
-    maxX = x > maxX ? x : maxX;
-    minY = y < minY ? y : minY;
-    maxY = y > maxY ? y : maxY;
-  }
-
-  out[0][0] = minX;
-  out[0][1] = minY;
-  out[1][0] = maxX;
-  out[1][1] = maxY;
-  return out;
+    let minX = Infinity;
+    let maxX = -Infinity;
+    let minY = Infinity;
+    let maxY = -Infinity;
+    for (let i = 0; i < endIndex; i += size) {
+        const x = positions[i];
+        const y = positions[i + 1];
+        minX = x < minX ? x : minX;
+        maxX = x > maxX ? x : maxX;
+        minY = y < minY ? y : minY;
+        maxY = y > maxY ? y : maxY;
+    }
+    out[0][0] = minX;
+    out[0][1] = minY;
+    out[1][0] = maxX;
+    out[1][1] = maxY;
+    return out;
 }
-
 function concatInPlace(arr1, arr2) {
-  for (let i = 0; i < arr2.length; i++) {
-    arr1.push(arr2[i]);
-  }
-
-  return arr1;
+    for (let i = 0; i < arr2.length; i++) {
+        arr1.push(arr2[i]);
+    }
+    return arr1;
 }
-//# sourceMappingURL=cut-by-grid.js.map

package/dist/cut-by-mercator-bounds.d.ts

@@ -1,4 +1,4 @@
-import type { Polygon } from './cut-by-grid';
+import type { Polygon } from "./cut-by-grid.js";
 import type { NumericArray } from '@math.gl/core';
 /** https://user-images.githubusercontent.com/2059298/78465769-938b7a00-76ae-11ea-9b95-1f4c26425ab9.png */
 export declare function cutPolylineByMercatorBounds(positions: Readonly<NumericArray>, options?: {
@@ -14,4 +14,3 @@ export declare function cutPolygonByMercatorBounds(positions: Readonly<NumericAr
     maxLatitude?: number;
     edgeTypes?: boolean;
 }): Polygon[];
-//# sourceMappingURL=cut-by-mercator-bounds.d.ts.map