@math.gl/polygon 3.5.6 → 3.6.0-alpha.2

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

@@ -0,0 +1,21 @@
+import type { NumericArray } from '@math.gl/core';
+export declare type Polygon = {
+    positions: number[];
+    holeIndices?: number[];
+    edgeTypes?: number[];
+};
+export declare function cutPolylineByGrid(positions: NumericArray, options?: {
+    size?: number;
+    broken?: boolean;
+    gridResolution?: number;
+    gridOffset?: [number, number];
+    startIndex?: number;
+    endIndex?: number;
+}): number[] | number[][];
+export declare function cutPolygonByGrid(positions: number[], holeIndices?: number[] | null, options?: {
+    size?: number;
+    gridResolution?: number;
+    gridOffset?: [number, number];
+    edgeTypes?: boolean;
+}): Polygon[];
+//# sourceMappingURL=cut-by-grid.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cut-by-grid.d.ts","sourceRoot":"","sources":["../src/cut-by-grid.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAEhD,oBAAY,OAAO,GAAG;IACpB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAEF,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,YAAY,EACvB,OAAO,CAAC,EAAE;IACR,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GACA,MAAM,EAAE,GAAG,MAAM,EAAE,EAAE,CAkDvB;AAYD,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,MAAM,EAAE,EACnB,WAAW,GAAE,MAAM,EAAE,GAAG,IAAW,EACnC,OAAO,CAAC,EAAE;IACR,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,GACA,OAAO,EAAE,CAmEX"}

package/dist/cut-by-grid.js

@@ -0,0 +1,214 @@
+/* eslint-disable max-statements, max-depth, complexity, no-unused-expressions */
+import { bitCode, intersect } from './lineclip';
+import { getPointAtIndex, copy, push } from './utils';
+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) {
+            // 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);
+    }
+    return broken ? result : result[0];
+}
+const TYPE_INSIDE = 0;
+const TYPE_BORDER = 1;
+function concatInPlace(arr1, arr2) {
+    for (let i = 0; i < arr2.length; i++) {
+        arr1.push(arr2[i]);
+    }
+    return arr1;
+}
+export function cutPolygonByGrid(positions, holeIndices = null, options) {
+    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 || []
+        }
+    ];
+    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);
+        }
+    }
+    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 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;
+    }
+    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;
+}
+function moveToNeighborCell(cell, gridResolution, edge) {
+    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;
+}

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

@@ -0,0 +1,17 @@
+import type { Polygon } from './cut-by-grid';
+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: NumericArray, options?: {
+    size?: number;
+    startIndex?: number;
+    endIndex?: number;
+    normalize?: boolean;
+}): number[][];
+/** https://user-images.githubusercontent.com/2059298/78465770-94241080-76ae-11ea-809a-6a8534dac1d9.png */
+export declare function cutPolygonByMercatorBounds(positions: number[], holeIndices?: number[] | null, options?: {
+    size?: number;
+    normalize?: boolean;
+    maxLatitude?: number;
+    edgeTypes?: boolean;
+}): Polygon[];
+//# sourceMappingURL=cut-by-mercator-bounds.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cut-by-mercator-bounds.d.ts","sourceRoot":"","sources":["../src/cut-by-mercator-bounds.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,eAAe,CAAC;AAC3C,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAKhD,0GAA0G;AAC1G,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,YAAY,EACvB,OAAO,CAAC,EAAE;IACR,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,GACA,MAAM,EAAE,EAAE,CAsBZ;AAED,0GAA0G;AAC1G,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,MAAM,EAAE,EACnB,WAAW,GAAE,MAAM,EAAE,GAAG,IAAW,EACnC,OAAO,CAAC,EAAE;IACR,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,GACA,OAAO,EAAE,CAmDX"}

package/dist/cut-by-mercator-bounds.js

@@ -0,0 +1,144 @@
+import { cutPolylineByGrid, cutPolygonByGrid } from './cut-by-grid';
+import { getPointAtIndex, push } from './utils';
+// https://en.wikipedia.org/wiki/Web_Mercator_projection
+const DEFAULT_MAX_LATITUDE = 85.051129;
+/** https://user-images.githubusercontent.com/2059298/78465769-938b7a00-76ae-11ea-9b95-1f4c26425ab9.png */
+export function cutPolylineByMercatorBounds(positions, options) {
+    const { size = 2, startIndex = 0, endIndex = positions.length, normalize = true } = options || {};
+    // Remap longitudes so that each segment takes the shorter path
+    const newPositions = positions.slice(startIndex, endIndex);
+    wrapLongitudesForShortestPath(newPositions, size, 0, endIndex - startIndex);
+    const parts = cutPolylineByGrid(newPositions, {
+        size,
+        broken: true,
+        gridResolution: 360,
+        gridOffset: [-180, -180]
+    });
+    if (normalize) {
+        // Each part is guaranteed to be in a single copy of the world
+        // Map longitudes back to [-180, 180]
+        for (const part of parts) {
+            shiftLongitudesIntoRange(part, size);
+        }
+    }
+    return parts;
+}
+/** https://user-images.githubusercontent.com/2059298/78465770-94241080-76ae-11ea-809a-6a8534dac1d9.png */
+export function cutPolygonByMercatorBounds(positions, holeIndices = null, options) {
+    const { size = 2, normalize = true, edgeTypes = false } = options || {};
+    holeIndices = holeIndices || [];
+    const newPositions = [];
+    const newHoleIndices = [];
+    let srcStartIndex = 0;
+    let targetIndex = 0;
+    for (let ringIndex = 0; ringIndex <= holeIndices.length; ringIndex++) {
+        // srcStartIndex/srcEndIndex define the ring in the original positions
+        const srcEndIndex = holeIndices[ringIndex] || positions.length;
+        // targetStartIndex/targetIndex define the ring in newPositions
+        const targetStartIndex = targetIndex;
+        // In case the ring contains a pole (e.g. Antarctica), we'll have to insert vertices
+        // The insertion point is defined by the vertex closest to the pole
+        // Split the the ring by the insertion point when copying to newPositions
+        const splitIndex = findSplitIndex(positions, size, srcStartIndex, srcEndIndex);
+        for (let i = splitIndex; i < srcEndIndex; i++) {
+            newPositions[targetIndex++] = positions[i];
+        }
+        for (let i = srcStartIndex; i < splitIndex; i++) {
+            newPositions[targetIndex++] = positions[i];
+        }
+        // Remap longitudes so that each segment takes the shorter path
+        wrapLongitudesForShortestPath(newPositions, size, targetStartIndex, targetIndex);
+        // Handle the case when the ring contains a pole
+        insertPoleVertices(newPositions, size, targetStartIndex, targetIndex, options?.maxLatitude);
+        srcStartIndex = srcEndIndex;
+        newHoleIndices[ringIndex] = targetIndex;
+    }
+    newHoleIndices.pop();
+    const parts = cutPolygonByGrid(newPositions, newHoleIndices, {
+        size,
+        gridResolution: 360,
+        gridOffset: [-180, -180],
+        edgeTypes
+    });
+    if (normalize) {
+        // Each part is guaranteed to be in a single copy of the world
+        // Map longitudes back to [-180, 180]
+        for (const part of parts) {
+            shiftLongitudesIntoRange(part.positions, size);
+        }
+    }
+    return parts;
+}
+/* Helpers */
+// See comments for insertPoleVertices
+function findSplitIndex(positions, size, startIndex, endIndex) {
+    let maxLat = -1;
+    let pointIndex = -1;
+    for (let i = startIndex + 1; i < endIndex; i += size) {
+        const lat = Math.abs(positions[i]);
+        if (lat > maxLat) {
+            maxLat = lat;
+            pointIndex = i - 1;
+        }
+    }
+    return pointIndex;
+}
+// https://user-images.githubusercontent.com/2059298/78857483-5987e400-79de-11ea-98fc-0631287a8431.png
+//
+// If the polygon contains a pole, to tesselate it correctly, we need to insert the edge
+// of map into the polygon. This requires adding two vertices that represent the pole, by
+// drawing a perpendicular line to the Mercator map edge from a selected vertex on the ring.
+//
+// We select the insertion position carefully so that the inserted line segments do not
+// intersect with the ring itself. This is ensured by findSplitIndex, which returns the
+// vertex closest to the pole.
+function insertPoleVertices(positions, size, startIndex, endIndex, maxLatitude = DEFAULT_MAX_LATITUDE) {
+    // Check if the ring contains a pole
+    const firstLng = positions[startIndex];
+    const lastLng = positions[endIndex - size];
+    if (Math.abs(firstLng - lastLng) > 180) {
+        // The ring does not make a round trip
+        // Add the nearest pole to the vertices so that the polygon tesselates correctly
+        const p = getPointAtIndex(positions, 0, size, startIndex);
+        // Copy the first vertex to the world of the last vertex
+        p[0] += Math.round((lastLng - firstLng) / 360) * 360;
+        push(positions, p);
+        // Project the copied vertex to the edge of the map
+        p[1] = Math.sign(p[1]) * maxLatitude;
+        push(positions, p);
+        // Project the first vertex to the edge of the map
+        p[0] = firstLng;
+        push(positions, p);
+    }
+}
+function wrapLongitudesForShortestPath(positions, size, startIndex, endIndex) {
+    let prevLng = positions[0];
+    let lng;
+    for (let i = startIndex; i < endIndex; i += size) {
+        lng = positions[i];
+        const delta = lng - prevLng;
+        if (delta > 180 || delta < -180) {
+            lng -= Math.round(delta / 360) * 360;
+        }
+        positions[i] = prevLng = lng;
+    }
+}
+function shiftLongitudesIntoRange(positions, size) {
+    let refLng;
+    const pointCount = positions.length / size;
+    // Find a longitude that is not on the edge of a world
+    // Which we will use to determine which world copy it is
+    for (let i = 0; i < pointCount; i++) {
+        refLng = positions[i * size];
+        if ((refLng + 180) % 360 !== 0) {
+            break;
+        }
+    }
+    const delta = -Math.round(refLng / 360) * 360;
+    if (delta === 0) {
+        return;
+    }
+    for (let i = 0; i < pointCount; i++) {
+        positions[i * size] += delta;
+    }
+}

package/dist/{esm/earcut.d.ts → earcut.d.ts}

@@ -2,8 +2,10 @@
  * Computes a triangulation of a polygon
  * @param positions a flat array of the vertex positions that define the polygon.
  * @param holeIndices an array of hole indices if any (e.g. [5, 8] for a 12-vertex input would mean one hole with vertices 5–7 and another with 8–11).
- * @param size the number of elements in each vertex. Size `2` will interpret `positions` as `[x0, y0, x1, y1, ...]` and size `3` will interpret `positions` as `[x0, y0, z0, x1, y1, z1, ...]`. Default `2`.
+ * @param dim the number of elements in each vertex. Size `2` will interpret `positions` as `[x0, y0, x1, y1, ...]` and size `3` will interpret `positions` as `[x0, y0, z0, x1, y1, z1, ...]`. Default `2`.
  * @param areas areas of outer polygon and holes as computed by `getPolygonSignedArea()`. Can be optionally supplied to speed up triangulation
  * @returns array of indices into the `positions` array that describes the triangulation of the polygon
+ * Adapted from https://github.com/mapbox/earcut
  */
-export function earcut(positions: number[], holeIndices?: number[], size?: number, areas?: number[]): number[];
+export declare function earcut(positions: number[], holeIndices?: number[], dim?: number, areas?: number[]): number[];
+//# sourceMappingURL=earcut.d.ts.map

package/dist/earcut.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"earcut.d.ts","sourceRoot":"","sources":["../src/earcut.ts"],"names":[],"mappings":"AA4BA;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CACpB,SAAS,EAAE,MAAM,EAAE,EACnB,WAAW,CAAC,EAAE,MAAM,EAAE,EACtB,GAAG,GAAE,MAAU,EACf,KAAK,CAAC,EAAE,MAAM,EAAE,GACf,MAAM,EAAE,CAwCV"}