@math.gl/polygon 4.0.0 → 4.0.1

package/dist/lineclip.js

@@ -1,129 +1,178 @@
-import { push, copy, getPointAtIndex } from "./utils.js";
-export function clipPolyline(positions, bbox, options) {
-  const {
-    size = 2,
-    startIndex = 0,
-    endIndex = positions.length
-  } = options || {};
-  const numPoints = (endIndex - startIndex) / size;
-  const result = [];
-  let part = [];
-  let a;
-  let b;
-  let codeA = -1;
-  let codeB;
-  let lastCode;
-
-  for (let i = 1; i < numPoints; i++) {
-    a = getPointAtIndex(positions, i - 1, size, startIndex, a);
-    b = getPointAtIndex(positions, i, size, startIndex, b);
+/*
+  Adapted from https://github.com/mapbox/lineclip to work with flat arrays
+  and 3d positions
 
-    if (codeA < 0) {
-      codeA = bitCode(a, bbox);
-    }
+  ISC License
 
-    codeB = lastCode = bitCode(b, bbox);
+  Copyright (c) 2015, Mapbox
 
-    while (true) {
-      if (!(codeA | codeB)) {
-        push(part, a);
+  Permission to use, copy, modify, and/or distribute this software for any purpose
+  with or without fee is hereby granted, provided that the above copyright notice
+  and this permission notice appear in all copies.
 
-        if (codeB !== lastCode) {
-          push(part, b);
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+  OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+  TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+  THIS SOFTWARE.
 
-          if (i < numPoints - 1) {
-            result.push(part);
-            part = [];
-          }
-        } else if (i === numPoints - 1) {
-          push(part, b);
+ */
+/* eslint-disable max-statements, max-depth, complexity */
+import { push, copy, getPointAtIndex } from "./utils.js";
+/**
+ * Cohen-Sutherland line clipping algorithm, adapted to efficiently
+ * handle polylines rather than just segments
+ */
+export function clipPolyline(positions, bbox, options) {
+    const { size = 2, startIndex = 0, endIndex = positions.length } = options || {};
+    const numPoints = (endIndex - startIndex) / size;
+    const result = [];
+    let part = [];
+    let a;
+    let b;
+    let codeA = -1;
+    let codeB;
+    let lastCode;
+    for (let i = 1; i < numPoints; i++) {
+        a = getPointAtIndex(positions, i - 1, size, startIndex, a);
+        b = getPointAtIndex(positions, i, size, startIndex, b);
+        if (codeA < 0) {
+            codeA = bitCode(a, bbox);
         }
-
-        break;
-      } else if (codeA & codeB) {
-        break;
-      } else if (codeA) {
-        intersect(a, b, codeA, bbox, a);
-        codeA = bitCode(a, bbox);
-      } else {
-        intersect(a, b, codeB, bbox, b);
-        codeB = bitCode(b, bbox);
-      }
+        codeB = lastCode = bitCode(b, bbox);
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            if (!(codeA | codeB)) {
+                // accept
+                push(part, a);
+                if (codeB !== lastCode) {
+                    // segment went outside
+                    push(part, b);
+                    if (i < numPoints - 1) {
+                        // start a new line
+                        result.push(part);
+                        part = [];
+                    }
+                }
+                else if (i === numPoints - 1) {
+                    push(part, b);
+                }
+                break;
+            }
+            else if (codeA & codeB) {
+                // trivial reject
+                break;
+            }
+            else if (codeA) {
+                // a outside, intersect with clip edge
+                intersect(a, b, codeA, bbox, a);
+                codeA = bitCode(a, bbox);
+            }
+            else {
+                // b outside
+                intersect(a, b, codeB, bbox, b);
+                codeB = bitCode(b, bbox);
+            }
+        }
+        codeA = lastCode;
     }
-
-    codeA = lastCode;
-  }
-
-  if (part.length) result.push(part);
-  return result;
+    if (part.length)
+        result.push(part);
+    return result;
 }
+/**
+ * Sutherland-Hodgeman polygon clipping algorithm
+ * polygon must be closed (first vertex == last vertex)
+ */
 export function clipPolygon(positions, bbox, options) {
-  const {
-    size = 2,
-    endIndex = positions.length
-  } = options || {};
-  let {
-    startIndex = 0
-  } = options || {};
-  let numPoints = (endIndex - startIndex) / size;
-  let result;
-  let p;
-  let prev;
-  let inside;
-  let prevInside;
-
-  for (let edge = 1; edge <= 8; edge *= 2) {
-    result = [];
-    prev = getPointAtIndex(positions, numPoints - 1, size, startIndex, prev);
-    prevInside = !(bitCode(prev, bbox) & edge);
-
-    for (let i = 0; i < numPoints; i++) {
-      p = getPointAtIndex(positions, i, size, startIndex, p);
-      inside = !(bitCode(p, bbox) & edge);
-      if (inside !== prevInside) push(result, intersect(prev, p, edge, bbox));
-      if (inside) push(result, p);
-      copy(prev, p);
-      prevInside = inside;
+    const { size = 2, endIndex = positions.length } = options || {};
+    let { startIndex = 0 } = options || {};
+    let numPoints = (endIndex - startIndex) / size;
+    let result;
+    let p;
+    let prev;
+    let inside;
+    let prevInside;
+    // clip against each side of the clip rectangle
+    for (let edge = 1; edge <= 8; edge *= 2) {
+        result = [];
+        prev = getPointAtIndex(positions, numPoints - 1, size, startIndex, prev);
+        prevInside = !(bitCode(prev, bbox) & edge);
+        for (let i = 0; i < numPoints; i++) {
+            p = getPointAtIndex(positions, i, size, startIndex, p);
+            inside = !(bitCode(p, bbox) & edge);
+            // if segment goes through the clip window, add an intersection
+            if (inside !== prevInside)
+                push(result, intersect(prev, p, edge, bbox));
+            if (inside)
+                push(result, p); // add a point if it's inside
+            copy(prev, p);
+            prevInside = inside;
+        }
+        // close loop
+        positions = result;
+        startIndex = 0;
+        numPoints = result.length / size;
+        if (!numPoints)
+            break;
     }
-
-    positions = result;
-    startIndex = 0;
-    numPoints = result.length / size;
-    if (!numPoints) break;
-  }
-
-  return result;
+    return result;
 }
+/** intersect a segment against one of the 4 lines that make up the bbox */
 export function intersect(a, b, edge, bbox, out = []) {
-  let t;
-  let snap;
-
-  if (edge & 8) {
-    t = (bbox[3] - a[1]) / (b[1] - a[1]);
-    snap = 3;
-  } else if (edge & 4) {
-    t = (bbox[1] - a[1]) / (b[1] - a[1]);
-    snap = 1;
-  } else if (edge & 2) {
-    t = (bbox[2] - a[0]) / (b[0] - a[0]);
-    snap = 2;
-  } else if (edge & 1) {
-    t = (bbox[0] - a[0]) / (b[0] - a[0]);
-    snap = 0;
-  } else {
-    return null;
-  }
-
-  for (let i = 0; i < a.length; i++) {
-    out[i] = (snap & 1) === i ? bbox[snap] : t * (b[i] - a[i]) + a[i];
-  }
-
-  return out;
+    let t;
+    // Forces out[snapI] to be on the bbox edge
+    // Interpolation introduces precision issue which may cause lineclip to be
+    // stuck in an infinite loop
+    let snap;
+    if (edge & 8) {
+        // top
+        t = (bbox[3] - a[1]) / (b[1] - a[1]);
+        snap = 3;
+    }
+    else if (edge & 4) {
+        // bottom
+        t = (bbox[1] - a[1]) / (b[1] - a[1]);
+        snap = 1;
+    }
+    else if (edge & 2) {
+        // right
+        t = (bbox[2] - a[0]) / (b[0] - a[0]);
+        snap = 2;
+    }
+    else if (edge & 1) {
+        // left
+        t = (bbox[0] - a[0]) / (b[0] - a[0]);
+        snap = 0;
+    }
+    else {
+        return null;
+    }
+    for (let i = 0; i < a.length; i++) {
+        out[i] = (snap & 1) === i ? bbox[snap] : t * (b[i] - a[i]) + a[i];
+    }
+    return out;
 }
+/**
+ * bit code reflects the point position relative to the bbox:
+ *         left  mid  right
+ *    top  1001  1000  1010
+ *    mid  0001  0000  0010
+ * bottom  0101  0100  0110
+ */
 export function bitCode(p, bbox) {
-  let code = 0;
-  if (p[0] < bbox[0]) code |= 1;else if (p[0] > bbox[2]) code |= 2;
-  if (p[1] < bbox[1]) code |= 4;else if (p[1] > bbox[3]) code |= 8;
-  return code;
+    let code = 0;
+    if (p[0] < bbox[0])
+        code |= 1;
+    // left
+    else if (p[0] > bbox[2])
+        code |= 2; // right
+    if (p[1] < bbox[1])
+        code |= 4;
+    // bottom
+    else if (p[1] > bbox[3])
+        code |= 8; // top
+    return code;
 }
-//# sourceMappingURL=lineclip.js.map

package/dist/polygon-utils.d.ts

@@ -4,14 +4,14 @@ export declare const WINDING: {
     readonly COUNTER_CLOCKWISE: -1;
 };
 /** Polygon representation where each point is represented as a separate array of positions. */
-declare type PointsArray = NumericArray[];
+type PointsArray = NumericArray[];
 /** Segment visitor callback type for polygons defined with flat arrays, */
-declare type SegmentVisitorFlat = (p1x: number, p1y: number, p2x: number, p2y: number, i1: number, i2: number) => void;
+type SegmentVisitorFlat = (p1x: number, p1y: number, p2x: number, p2y: number, i1: number, i2: number) => void;
 /** Segment visitor callback type for polygons defined with array of points. */
-export declare type SegmentVisitorPoints = (p1: NumericArray, p2: NumericArray, i1: number, i2: number) => void;
-export declare type Plane2D = 'xy' | 'yz' | 'xz';
+export type SegmentVisitorPoints = (p1: NumericArray, p2: NumericArray, i1: number, i2: number) => void;
+export type Plane2D = 'xy' | 'yz' | 'xz';
 /** Parameters of a polygon. */
-declare type PolygonParams = {
+type PolygonParams = {
     /**
      * Start index of the polygon in the array of positions.
      * @default `0`
@@ -100,4 +100,3 @@ export declare function getPolygonSignedAreaPoints(points: PointsArray, options?
  */
 export declare function forEachSegmentInPolygonPoints(points: PointsArray, visitor: SegmentVisitorPoints, options?: PolygonParams): void;
 export {};
-//# sourceMappingURL=polygon-utils.d.ts.map

package/dist/polygon-utils.js

@@ -1,131 +1,148 @@
+/* eslint-disable max-statements, max-depth, complexity, no-unused-expressions */
 import { equals } from '@math.gl/core';
 export const WINDING = {
-  CLOCKWISE: 1,
-  COUNTER_CLOCKWISE: -1
+    CLOCKWISE: 1,
+    COUNTER_CLOCKWISE: -1
 };
+/**
+ * Checks winding direction of the polygon and reverses the polygon in case of opposite winding direction.
+ * Note: points are modified in-place.
+ * @param points An array that represents points of the polygon.
+ * @param direction Requested winding direction. 1 is for clockwise, -1 for counterclockwise winding direction.
+ * @param options Parameters of the polygon.
+ * @return Returns true if the winding direction was changed.
+ */
 export function modifyPolygonWindingDirection(points, direction, options = {}) {
-  const windingDirection = getPolygonWindingDirection(points, options);
-
-  if (windingDirection !== direction) {
-    reversePolygon(points, options);
-    return true;
-  }
-
-  return false;
+    const windingDirection = getPolygonWindingDirection(points, options);
+    if (windingDirection !== direction) {
+        reversePolygon(points, options);
+        return true;
+    }
+    return false;
 }
+/**
+ * Returns winding direction of the polygon.
+ * @param points An array that represents points of the polygon.
+ * @param options Parameters of the polygon.
+ * @returns Winding direction of the polygon.
+ */
 export function getPolygonWindingDirection(points, options = {}) {
-  return Math.sign(getPolygonSignedArea(points, options));
+    return Math.sign(getPolygonSignedArea(points, options));
 }
 export const DimIndex = {
-  x: 0,
-  y: 1,
-  z: 2
+    x: 0,
+    y: 1,
+    z: 2
 };
+/**
+ * Returns signed area of the polygon.
+ * @param points An array that represents points of the polygon.
+ * @param options Parameters of the polygon.
+ * @returns Signed area of the polygon.
+ * https://en.wikipedia.org/wiki/Shoelace_formula
+ */
 export function getPolygonSignedArea(points, 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 + i0] - points[j + i0]) * (points[i + i1] + points[j + i1]);
-    j = i;
-  }
-
-  return area / 2;
+    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 + i0] - points[j + i0]) * (points[i + i1] + points[j + i1]);
+        j = i;
+    }
+    return area / 2;
 }
+/**
+ * Calls the visitor callback for each segment in the polygon.
+ * @param points An array that represents points of the polygon
+ * @param visitor A callback to call for each segment.
+ * @param options Parameters of the polygon.
+ */
 export function forEachSegmentInPolygon(points, visitor, options = {}) {
-  const {
-    start = 0,
-    end = points.length,
-    size = 2,
-    isClosed
-  } = options;
-  const numPoints = (end - start) / size;
-
-  for (let i = 0; i < numPoints - 1; ++i) {
-    visitor(points[start + i * size], points[start + i * size + 1], points[start + (i + 1) * size], points[start + (i + 1) * size + 1], i, i + 1);
-  }
-
-  const endPointIndex = start + (numPoints - 1) * size;
-  const isClosedEx = isClosed || equals(points[start], points[endPointIndex]) && equals(points[start + 1], points[endPointIndex + 1]);
-
-  if (!isClosedEx) {
-    visitor(points[endPointIndex], points[endPointIndex + 1], points[start], points[start + 1], numPoints - 1, 0);
-  }
+    const { start = 0, end = points.length, size = 2, isClosed } = options;
+    const numPoints = (end - start) / size;
+    for (let i = 0; i < numPoints - 1; ++i) {
+        visitor(points[start + i * size], points[start + i * size + 1], points[start + (i + 1) * size], points[start + (i + 1) * size + 1], i, i + 1);
+    }
+    const endPointIndex = start + (numPoints - 1) * size;
+    const isClosedEx = isClosed ||
+        (equals(points[start], points[endPointIndex]) &&
+            equals(points[start + 1], points[endPointIndex + 1]));
+    if (!isClosedEx) {
+        visitor(points[endPointIndex], points[endPointIndex + 1], points[start], points[start + 1], numPoints - 1, 0);
+    }
 }
-
 function reversePolygon(points, options) {
-  const {
-    start = 0,
-    end = points.length,
-    size = 2
-  } = options;
-  const numPoints = (end - start) / size;
-  const numSwaps = Math.floor(numPoints / 2);
-
-  for (let i = 0; i < numSwaps; ++i) {
-    const b1 = start + i * size;
-    const b2 = start + (numPoints - 1 - i) * size;
-
-    for (let j = 0; j < size; ++j) {
-      const tmp = points[b1 + j];
-      points[b1 + j] = points[b2 + j];
-      points[b2 + j] = tmp;
+    const { start = 0, end = points.length, size = 2 } = options;
+    const numPoints = (end - start) / size;
+    const numSwaps = Math.floor(numPoints / 2);
+    for (let i = 0; i < numSwaps; ++i) {
+        const b1 = start + i * size;
+        const b2 = start + (numPoints - 1 - i) * size;
+        for (let j = 0; j < size; ++j) {
+            const tmp = points[b1 + j];
+            points[b1 + j] = points[b2 + j];
+            points[b2 + j] = tmp;
+        }
     }
-  }
 }
-
+/**
+ * Checks winding direction of the polygon and reverses the polygon in case of opposite winding direction.
+ * Note: points are modified in-place.
+ * @param points Array of points that represent the polygon.
+ * @param direction Requested winding direction. 1 is for clockwise, -1 for counterclockwise winding direction.
+ * @param options Parameters of the polygon.
+ * @return Returns true if the winding direction was changed.
+ */
 export function modifyPolygonWindingDirectionPoints(points, direction, options = {}) {
-  const currentDirection = getPolygonWindingDirectionPoints(points, options);
-
-  if (currentDirection !== direction) {
-    points.reverse();
-    return true;
-  }
-
-  return false;
+    const currentDirection = getPolygonWindingDirectionPoints(points, options);
+    if (currentDirection !== direction) {
+        points.reverse();
+        return true;
+    }
+    return false;
 }
+/**
+ * Returns winding direction of the polygon.
+ * @param points Array of points that represent the polygon.
+ * @param options Parameters of the polygon.
+ * @returns Winding direction of the polygon.
+ */
 export function getPolygonWindingDirectionPoints(points, options = {}) {
-  return Math.sign(getPolygonSignedAreaPoints(points, options));
+    return Math.sign(getPolygonSignedAreaPoints(points, options));
 }
+/**
+ * Returns signed area of the polygon.
+ * @param points Array of points that represent the polygon.
+ * @param options Parameters of the polygon.
+ * @returns Signed area of the polygon.
+ */
 export function getPolygonSignedAreaPoints(points, 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][i0] - points[j][i0]) * (points[i][i1] + points[j][i1]);
-    j = i;
-  }
-
-  return area / 2;
+    // https://en.wikipedia.org/wiki/Shoelace_formula
+    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][i0] - points[j][i0]) * (points[i][i1] + points[j][i1]);
+        j = i;
+    }
+    return area / 2;
 }
+/**
+ * Calls visitor callback for each segment in the polygon.
+ * @param points Array of points that represent the polygon.
+ * @param visitor A callback to call for each segment.
+ * @param options Parameters of the polygon.
+ */
 export function forEachSegmentInPolygonPoints(points, visitor, options = {}) {
-  const {
-    start = 0,
-    end = points.length,
-    isClosed
-  } = options;
-
-  for (let i = start; i < end - 1; ++i) {
-    visitor(points[i], points[i + 1], i, i + 1);
-  }
-
-  const isClosedEx = isClosed || equals(points[end - 1], points[0]);
-
-  if (!isClosedEx) {
-    visitor(points[end - 1], points[0], end - 1, 0);
-  }
+    const { start = 0, end = points.length, isClosed } = options;
+    for (let i = start; i < end - 1; ++i) {
+        visitor(points[i], points[i + 1], i, i + 1);
+    }
+    const isClosedEx = isClosed || equals(points[end - 1], points[0]);
+    if (!isClosedEx) {
+        visitor(points[end - 1], points[0], end - 1, 0);
+    }
 }
-//# sourceMappingURL=polygon-utils.js.map

package/dist/polygon.d.ts

@@ -1,6 +1,6 @@
-import type { SegmentVisitorPoints } from './polygon-utils';
+import type { SegmentVisitorPoints } from "./polygon-utils.js";
 import type { NumericArray } from '@math.gl/core';
-export declare type PolygonOptions = {
+export type PolygonOptions = {
     start?: number;
     end?: number;
     size?: number;
@@ -38,4 +38,3 @@ export declare class Polygon {
      */
     modifyWindingDirection(direction: number): boolean;
 }
-//# sourceMappingURL=polygon.d.ts.map