@matboks/utilities 0.0.1

package/dist/geometry/polygon-operations.js

@@ -0,0 +1,159 @@
+import * as polyclip from "polyclip-ts";
+import { Hollowgon } from "./hollowgon.js";
+import { Line } from "./line.js";
+import { Polygon } from "./polygon.js";
+import { Polyline } from "./polyline.js";
+import { Ray } from "./ray.js";
+import { Segment } from "./segment.js";
+import { Vec2, vec2 } from "./vec2.js";
+import { ensureArray } from "../utilities/ensure-array.js";
+polyclip.setPrecision(1e-12);
+export function subdivide(shape, subdivisionObject) {
+    const shapes = ensureArray(shape);
+    let subdividedShapes = [];
+    for (const shape of shapes) {
+        const subdivideBy = typeof subdivisionObject === "function" ? subdivisionObject(shape) : subdivisionObject;
+        const subdivisionPolygon = createSubdivisionPolygon(shape, subdivideBy);
+        if (!subdivisionPolygon) {
+            subdividedShapes.push(shape);
+            continue;
+        }
+        const results = polyclip.difference(shapeToArray(shape), [subdivisionPolygon.toArray()]);
+        for (const result of results) {
+            subdividedShapes.push(processPolyclipShape(result));
+        }
+    }
+    return subdividedShapes;
+}
+export function intersect(shapes) {
+    const [first, ...rest] = shapes.map(shapeToArray);
+    const result = polyclip.intersection(first, rest);
+    return result.map(processPolyclipShape);
+}
+export function union(shapes) {
+    const [first, ...rest] = shapes.map(shapeToArray);
+    const result = polyclip.union(first, rest);
+    return result.map(processPolyclipShape);
+}
+export function difference(shapes) {
+    const [first, ...rest] = shapes.map(shapeToArray);
+    const result = polyclip.difference(first, rest);
+    return result.map(processPolyclipShape);
+}
+export function xor(shapes) {
+    const [first, ...rest] = shapes.map(shapeToArray);
+    const result = polyclip.xor(first, rest);
+    return result.map(processPolyclipShape);
+}
+export function clip(shapes, clipShapes) {
+    shapes = ensureArray(shapes);
+    clipShapes = ensureArray(clipShapes);
+    const clipUnion = clipShapes.length > 1 ? union(clipShapes) : clipShapes;
+    let clippedPolygons = [];
+    for (const shape of shapes) {
+        clippedPolygons = clippedPolygons.concat(intersect([shape, ...clipUnion]));
+    }
+    return clippedPolygons;
+}
+export const polygonOperations = {
+    subdivide,
+    intersect,
+    union,
+    difference,
+    xor,
+    clip
+};
+function shapeToArray(shape) {
+    return shape instanceof Polygon ? [shape.toArray()] : shape.toArray();
+}
+const subdivisionPolygonPadding = 1e-5;
+export function createSubdivisionPolygon(shape, subdivisionObject) {
+    if (subdivisionObject instanceof Polyline) {
+        const { vertices } = subdivisionObject;
+        const n = vertices.length;
+        if (n < 2) {
+            return null;
+        }
+        else if (n === 2) {
+            subdivisionObject = new Segment(vertices[0], vertices[1]);
+        }
+        else {
+            return createPolylinePolygon(shape, subdivisionObject);
+        }
+    }
+    const intersections = shape.computeIntersections(subdivisionObject);
+    const n = intersections.length;
+    if (n < 2)
+        return null;
+    let { position: start } = intersections[0];
+    let { position: end } = intersections[n - 1];
+    if (subdivisionObject instanceof Segment) {
+        start = (shape.isPointInside(subdivisionObject.start) ? intersections[1] : intersections[0]).position;
+        end = (shape.isPointInside(subdivisionObject.end) ? intersections[n - 2] : intersections[n - 1]).position;
+    }
+    else if (subdivisionObject instanceof Ray) {
+        start = (shape.isPointInside(subdivisionObject.point) ? intersections[1] : intersections[0]).position;
+    }
+    const center = Vec2.midpoint(start, end);
+    const length = Vec2.distance(start, end);
+    const angle = Vec2.subtract(end, start).angle();
+    const subdivisionPolygon = new Polygon([
+        vec2(-length / 2 - subdivisionPolygonPadding, -subdivisionPolygonPadding),
+        vec2(length / 2 + subdivisionPolygonPadding, -subdivisionPolygonPadding),
+        vec2(length / 2 + subdivisionPolygonPadding, subdivisionPolygonPadding),
+        vec2(-length / 2 - subdivisionPolygonPadding, subdivisionPolygonPadding),
+    ]).rotate(angle).translate(center);
+    return subdivisionPolygon;
+}
+// TODO finish. Incorrect when polyline starts and/or ends inside shape
+// A very crude offsetting implementation
+function createPolylinePolygon(_shape, polyline) {
+    const { vertices } = polyline;
+    // const intersections = shape.computeIntersections(polyline);
+    const n = polyline.numVertices();
+    const edges = polyline.edges();
+    const startVector = edges[0].vector.clone().normalize();
+    const startNormal = vec2(-startVector.y, startVector.x);
+    const firstOffsetA = Vec2.add(vertices[0], Vec2.multiply(startVector, -subdivisionPolygonPadding), Vec2.multiply(startNormal, subdivisionPolygonPadding));
+    const firstOffsetB = Vec2.add(vertices[0], Vec2.multiply(startVector, -subdivisionPolygonPadding), Vec2.multiply(startNormal, -subdivisionPolygonPadding));
+    let verticesA = [firstOffsetA];
+    let verticesB = [firstOffsetB];
+    let prevLineA = new Line(firstOffsetA, startVector);
+    let prevLineB = new Line(firstOffsetB, startVector);
+    for (let i = 1; i < n - 1; i++) {
+        const e0 = edges[i];
+        const { vector } = e0;
+        const normal = vec2(-vector.y, vector.x).normalize();
+        const lineA = new Line(Vec2.add(e0.start, Vec2.multiply(normal, subdivisionPolygonPadding)), vector);
+        const lineB = new Line(Vec2.add(e0.start, Vec2.multiply(normal, -subdivisionPolygonPadding)), vector);
+        verticesA.push(lineA.computeIntersection(prevLineA));
+        verticesB.push(lineB.computeIntersection(prevLineB));
+        prevLineA = lineA;
+        prevLineB = lineB;
+    }
+    const endVector = edges[n - 2].vector.clone().normalize();
+    const endNormal = vec2(-endVector.y, endVector.x);
+    verticesA.push(Vec2.add(vertices[n - 1], Vec2.multiply(endVector, subdivisionPolygonPadding), Vec2.multiply(endNormal, subdivisionPolygonPadding)));
+    verticesB.push(Vec2.add(vertices[n - 1], Vec2.multiply(endVector, subdivisionPolygonPadding), Vec2.multiply(endNormal, -subdivisionPolygonPadding)));
+    const newVertices = verticesA.concat(verticesB.reverse());
+    return new Polygon(newVertices);
+}
+function processPolyclipShape(rings) {
+    const boundary = parseRingToPolygon(rings[0]);
+    const numRings = rings.length;
+    if (numRings === 1)
+        return boundary;
+    const holes = [];
+    for (let i = 1; i < numRings; i++) {
+        holes.push(parseRingToPolygon(rings[i]));
+    }
+    return new Hollowgon(boundary, holes);
+}
+function parseRingToPolygon(ring) {
+    let vertices = [];
+    for (let i = 0, n = ring.length; i < n - 1; i++) {
+        const [x, y] = ring[i];
+        vertices.push(vec2(x, y));
+    }
+    return new Polygon(vertices);
+}

package/dist/geometry/polygon.d.ts

@@ -0,0 +1,55 @@
+import { AABB } from "./aabb.js";
+import { Line } from "./line.js";
+import { Polyline } from "./polyline.js";
+import { Ray } from "./ray.js";
+import { Segment } from "./segment.js";
+import { Vec2 } from "./vec2.js";
+type IndexedTessellation = {
+    indices: number[];
+    vertices: Vec2[];
+};
+export declare function polygon(vertices?: Vec2[]): Polygon;
+export declare class Polygon {
+    #private;
+    vertices: Vec2[];
+    constructor(vertices?: Vec2[]);
+    centroid(): Vec2;
+    signedArea(): number;
+    aabb(): AABB;
+    edges(): Segment[];
+    isConvex(): boolean;
+    area(): number;
+    numVertices(): number;
+    clone(): Polygon;
+    copy(polygon: Polygon): this;
+    getVertex(index: number): Vec2;
+    getEdge(index: number): Segment;
+    isCounterClockwise(): boolean;
+    switchOrientation(): this;
+    makeCounterClockwise(): this;
+    makeClockwise(): this;
+    addHole(hole: Polygon): this;
+    translate(translation: Vec2): this;
+    rotate(rotation: number, center?: Vec2): this;
+    scale(scale: number | Vec2, center?: Vec2): this;
+    isPointInside(position: Vec2): boolean;
+    distanceToBoundary(position: Vec2): number;
+    signedDistanceToBoundary(position: Vec2): number;
+    getNearestBoundaryPoint(point: Vec2): Vec2;
+    getNearestNormal(point: Vec2): Vec2;
+    indexedTessellation(): IndexedTessellation;
+    tessellation(): Polygon[];
+    computeIntersections(intersectionObject: IntersectionObject): PolygonIntersection[];
+    resetMemoized(): void;
+    render(ctx: CanvasRenderingContext2D, beginPath?: boolean): void;
+    toArray(): [number, number][];
+    toGeogebra(digits?: number): string;
+}
+export type PolygonIntersection = {
+    index: number;
+    position: Vec2;
+    edgeTime: number;
+    lineTime: number;
+};
+export type IntersectionObject = Line | Segment | Ray | Polyline;
+export {};

package/dist/geometry/polygon.js

@@ -0,0 +1,353 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _Polygon_instances, _a, _Polygon_centroid, _Polygon_computeCentroid, _Polygon_signedArea, _Polygon_computeSignedArea, _Polygon_aabb, _Polygon_edges, _Polygon_computeEdges, _Polygon_isConvex, _Polygon_computeIsConvex, _Polygon_indexedTessellation, _Polygon_computeIndexedTessellation, _Polygon_tessellation, _Polygon_computeTessellation, _Polygon_modifyVertices, _Polygon_distanceToBoundary;
+import { EPS } from "../constants.js";
+import { mod } from "../math/mod.js";
+import { AABB } from "./aabb.js";
+import { Line } from "./line.js";
+import { Polyline } from "./polyline.js";
+import { Ray } from "./ray.js";
+import { Segment } from "./segment.js";
+import { computeLineIntersection } from "./shared.js";
+import { ensureVec2, vec2, Vec2 } from "./vec2.js";
+import earcut from "earcut";
+export function polygon(vertices) {
+    return new Polygon(vertices);
+}
+export class Polygon {
+    constructor(vertices) {
+        _Polygon_instances.add(this);
+        _Polygon_centroid.set(this, void 0);
+        _Polygon_signedArea.set(this, void 0);
+        _Polygon_aabb.set(this, void 0);
+        _Polygon_edges.set(this, void 0);
+        _Polygon_isConvex.set(this, void 0);
+        _Polygon_indexedTessellation.set(this, void 0);
+        _Polygon_tessellation.set(this, void 0);
+        this.vertices = vertices ?? [];
+    }
+    centroid() { return __classPrivateFieldSet(this, _Polygon_centroid, __classPrivateFieldGet(this, _Polygon_centroid, "f") ?? __classPrivateFieldGet(this, _Polygon_instances, "m", _Polygon_computeCentroid).call(this), "f"); }
+    signedArea() { return __classPrivateFieldSet(this, _Polygon_signedArea, __classPrivateFieldGet(this, _Polygon_signedArea, "f") ?? __classPrivateFieldGet(this, _Polygon_instances, "m", _Polygon_computeSignedArea).call(this), "f"); }
+    aabb() { return __classPrivateFieldSet(this, _Polygon_aabb, __classPrivateFieldGet(this, _Polygon_aabb, "f") ?? AABB.fromVertices(this.vertices), "f"); }
+    edges() { return __classPrivateFieldSet(this, _Polygon_edges, __classPrivateFieldGet(this, _Polygon_edges, "f") ?? __classPrivateFieldGet(this, _Polygon_instances, "m", _Polygon_computeEdges).call(this), "f"); }
+    isConvex() { return __classPrivateFieldSet(this, _Polygon_isConvex, __classPrivateFieldGet(this, _Polygon_isConvex, "f") ?? __classPrivateFieldGet(this, _Polygon_instances, "m", _Polygon_computeIsConvex).call(this), "f"); }
+    area() { return Math.abs(this.signedArea()); }
+    numVertices() { return this.vertices.length; }
+    clone() {
+        const clonedVertices = this.vertices.map(vertex => vertex.clone());
+        return new _a(clonedVertices);
+    }
+    copy(polygon) {
+        return __classPrivateFieldGet(this, _Polygon_instances, "m", _Polygon_modifyVertices).call(this, polygon.vertices.map(vertex => vertex.clone()));
+    }
+    getVertex(index) {
+        return this.vertices[mod(index, this.numVertices())];
+    }
+    getEdge(index) {
+        // TODO computes all edges for a single value. Is this desired?
+        return this.edges()[mod(index, this.numVertices())];
+    }
+    isCounterClockwise() {
+        return this.signedArea() > 0;
+    }
+    switchOrientation() {
+        __classPrivateFieldGet(this, _Polygon_instances, "m", _Polygon_modifyVertices).call(this, this.vertices.reverse());
+        return this;
+    }
+    makeCounterClockwise() {
+        if (!this.isCounterClockwise())
+            this.switchOrientation();
+        return this;
+    }
+    makeClockwise() {
+        if (this.isCounterClockwise())
+            this.switchOrientation();
+        return this;
+    }
+    addHole(hole) {
+        this.resetMemoized();
+        for (let i = 0, n = hole.numVertices(); i < n; i++) {
+            const holeVertex = hole.getVertex(i);
+            for (let j = 0, m = this.numVertices(); j < m; j++) {
+                const vertex = this.getVertex(j);
+                // Segment from hole vertex to contour vertex. If it doesn't intersect an edge on the contour, we are done
+                const segment = new Segment(holeVertex, vertex);
+                for (const edge of this.edges()) {
+                    if (!edge.intersects(segment)) {
+                        // Found valid hole vertex, at index i.
+                        // Insert hole vertices starting at index i, at current polygon index j
+                        // Result should be as follows, where c is this/current polygon and h is the hole:
+                        // ..., c(j - 1), c(j), h(i), h(i + 1), ..., h(i - 1), h(i), c(j), c(j + 1), ...
+                        const insertedVertices = [];
+                        for (let k = 0; k < n; k++)
+                            insertedVertices.push(hole.getVertex(i + k).clone());
+                        insertedVertices.push(hole.getVertex(i).clone());
+                        insertedVertices.push(this.getVertex(j).clone());
+                        this.vertices.splice(j + 1, 0, ...insertedVertices);
+                        return this;
+                    }
+                }
+            }
+        }
+        return this;
+    }
+    translate(translation) {
+        return __classPrivateFieldGet(this, _Polygon_instances, "m", _Polygon_modifyVertices).call(this, vertex => vertex.plus(translation));
+    }
+    rotate(rotation, center) {
+        center ?? (center = this.centroid());
+        return __classPrivateFieldGet(this, _Polygon_instances, "m", _Polygon_modifyVertices).call(this, vertex => vertex.rotate(rotation, center));
+    }
+    scale(scale, center) {
+        scale = ensureVec2(scale);
+        center ?? (center = this.centroid());
+        return __classPrivateFieldGet(this, _Polygon_instances, "m", _Polygon_modifyVertices).call(this, vertex => vertex.minus(center).times(scale).plus(center));
+    }
+    isPointInside(position) {
+        // const fuzzedPosition = Vec2.add(position, vec2(rng(-EPS, EPS), rng(-EPS, EPS)));
+        if (!this.aabb().isPointInside(position))
+            return false;
+        // Use raycasting
+        let numIntersections = 0;
+        for (let i = 0, n = this.numVertices(); i < n; i++) {
+            // if (i === 172) debugger
+            if (pointInPolygonHelper(position, this.getEdge(i))) {
+                numIntersections++;
+            }
+        }
+        return numIntersections % 2 === 1;
+    }
+    distanceToBoundary(position) {
+        return __classPrivateFieldGet(this, _Polygon_instances, "m", _Polygon_distanceToBoundary).call(this, position, false);
+    }
+    signedDistanceToBoundary(position) {
+        return __classPrivateFieldGet(this, _Polygon_instances, "m", _Polygon_distanceToBoundary).call(this, position, true);
+    }
+    getNearestBoundaryPoint(point) {
+        let minimumDistance = Infinity;
+        let nearestPoint = null;
+        for (let i = 0, n = this.numVertices(); i < n; i++) {
+            const currentEdge = this.getEdge(i);
+            const currentNearestPoint = currentEdge.getNearestPoint(point);
+            const currentDistance = point.distance(currentNearestPoint);
+            if (currentDistance < minimumDistance) {
+                minimumDistance = currentDistance;
+                nearestPoint = currentNearestPoint;
+            }
+        }
+        if (nearestPoint === null)
+            throw new Error("Could not find nearestPoint");
+        return nearestPoint;
+    }
+    // Returns vector from nearest point on boundary to point
+    // Combines edge normal and distance
+    getNearestNormal(point) {
+        return Vec2.subtract(point, this.getNearestBoundaryPoint(point));
+    }
+    indexedTessellation() { return __classPrivateFieldSet(this, _Polygon_indexedTessellation, __classPrivateFieldGet(this, _Polygon_indexedTessellation, "f") ?? __classPrivateFieldGet(this, _Polygon_instances, "m", _Polygon_computeIndexedTessellation).call(this), "f"); }
+    tessellation() { return __classPrivateFieldSet(this, _Polygon_tessellation, __classPrivateFieldGet(this, _Polygon_tessellation, "f") ?? __classPrivateFieldGet(this, _Polygon_instances, "m", _Polygon_computeTessellation).call(this), "f"); }
+    computeIntersections(intersectionObject) {
+        let intersections = [];
+        if (intersectionObject instanceof Polyline) {
+            for (const edge of intersectionObject.edges()) {
+                intersections = intersections.concat(this.computeIntersections(edge));
+            }
+            return intersections;
+        }
+        const { line, timeRange } = getIntersectionLine(intersectionObject);
+        const [minTime, maxTime] = timeRange ?? [];
+        for (let i = 0, n = this.numVertices(); i < n; i++) {
+            const edge = this.getEdge(i);
+            const intersection = computeLineIntersection(line, new Line(edge.start, edge.vector));
+            if (!intersection)
+                continue;
+            const [lineTime, edgeTime] = intersection;
+            if (timeRange && (lineTime < minTime || lineTime > maxTime))
+                continue;
+            if (edgeTime < -EPS || edgeTime > 1 + EPS)
+                continue;
+            const position = edge.interpolate(edgeTime);
+            intersections.push({ index: i, position, lineTime, edgeTime });
+        }
+        intersections.sort((a, b) => a.lineTime - b.lineTime);
+        intersections = intersections.filter((int, i) => {
+            if (i === intersections.length - 1)
+                return true;
+            const nextIntersection = intersections[i + 1];
+            const timeDifference = nextIntersection.lineTime - int.lineTime;
+            if (timeDifference > EPS)
+                return true;
+            return Math.abs(nextIntersection.index - int.index) <= 1;
+        });
+        return intersections;
+    }
+    resetMemoized() {
+        __classPrivateFieldSet(this, _Polygon_centroid, undefined, "f");
+        __classPrivateFieldSet(this, _Polygon_signedArea, undefined, "f");
+        __classPrivateFieldSet(this, _Polygon_aabb, undefined, "f");
+        __classPrivateFieldSet(this, _Polygon_edges, undefined, "f");
+        __classPrivateFieldSet(this, _Polygon_indexedTessellation, undefined, "f");
+        __classPrivateFieldSet(this, _Polygon_tessellation, undefined, "f");
+        __classPrivateFieldSet(this, _Polygon_isConvex, undefined, "f");
+    }
+    render(ctx, beginPath = true) {
+        const { vertices } = this;
+        if (beginPath)
+            ctx.beginPath();
+        ctx.moveTo(vertices[0].x, vertices[0].y);
+        for (let i = 1, n = vertices.length; i < n; i++) {
+            const { x, y } = vertices[i];
+            ctx.lineTo(x, y);
+        }
+        ctx.closePath();
+    }
+    toArray() {
+        let points = [];
+        for (const v of this.vertices)
+            points.push(v.toArray());
+        return points;
+    }
+    toGeogebra(digits = 4) {
+        return `Polygon({${this.vertices.map(({ x, y }) => `(${x.toFixed(digits)},${y.toFixed(digits)})`).join(",")}})`;
+    }
+}
+_a = Polygon, _Polygon_centroid = new WeakMap(), _Polygon_signedArea = new WeakMap(), _Polygon_aabb = new WeakMap(), _Polygon_edges = new WeakMap(), _Polygon_isConvex = new WeakMap(), _Polygon_indexedTessellation = new WeakMap(), _Polygon_tessellation = new WeakMap(), _Polygon_instances = new WeakSet(), _Polygon_computeCentroid = function _Polygon_computeCentroid() {
+    let x = 0, y = 0;
+    for (let i = 0, n = this.numVertices(); i < n; i++) {
+        const { start, end } = this.getEdge(i);
+        const cross = start.cross(end);
+        x += (start.x + end.x) * cross;
+        y += (start.y + end.y) * cross;
+    }
+    const divisor = 6 * this.signedArea();
+    return vec2(x / divisor, y / divisor);
+}, _Polygon_computeSignedArea = function _Polygon_computeSignedArea() {
+    let sum = 0;
+    for (let i = 0, n = this.numVertices(); i < n; i++) {
+        const { start, end } = this.getEdge(i);
+        sum += start.cross(end);
+    }
+    return sum / 2;
+}, _Polygon_computeEdges = function _Polygon_computeEdges() {
+    let edges = [];
+    for (let i = 0, n = this.numVertices(); i < n; i++) {
+        const start = this.getVertex(i);
+        const end = this.getVertex(i + 1);
+        edges.push(new Segment(start, end));
+    }
+    return edges;
+}, _Polygon_computeIsConvex = function _Polygon_computeIsConvex() {
+    const n = this.numVertices();
+    const sign = this.isCounterClockwise() ? 1 : -1;
+    let isConvex = true;
+    for (let i = 0; i < n; i++) {
+        const previous = this.getVertex(i - 1);
+        const current = this.getVertex(i);
+        const next = this.getVertex(i + 1);
+        const firstVector = Vec2.subtract(previous, current);
+        const secondVector = Vec2.subtract(next, current);
+        const internalAngle = mod(sign * Vec2.angle(secondVector, firstVector), 2 * Math.PI);
+        if (internalAngle > Math.PI) {
+            isConvex = false;
+            break;
+        }
+    }
+    return isConvex;
+}, _Polygon_computeIndexedTessellation = function _Polygon_computeIndexedTessellation() {
+    const flatVertices = [];
+    const clonedVertices = [];
+    for (let i = 0, n = this.vertices.length; i < n; i++) {
+        const vertex = this.getVertex(i);
+        flatVertices.push(vertex.x, vertex.y);
+        clonedVertices.push(vertex.clone());
+    }
+    const indices = earcut(flatVertices);
+    return {
+        indices,
+        vertices: clonedVertices
+    };
+}, _Polygon_computeTessellation = function _Polygon_computeTessellation() {
+    const { indices, vertices } = this.indexedTessellation();
+    const triangles = [];
+    for (let i = 0, n = indices.length; i < n; i += 3) {
+        triangles.push(new _a([
+            vertices[indices[i]].clone(),
+            vertices[indices[i + 1]].clone(),
+            vertices[indices[i + 2]].clone(),
+        ]));
+    }
+    return triangles;
+}, _Polygon_modifyVertices = function _Polygon_modifyVertices(modification) {
+    if (typeof modification === "function") {
+        this.vertices.forEach(modification);
+    }
+    else {
+        this.vertices = modification;
+    }
+    this.resetMemoized();
+    return this;
+}, _Polygon_distanceToBoundary = function _Polygon_distanceToBoundary(position, returnSigned) {
+    let smallestDistance = Infinity;
+    let distanceSign = 1;
+    // const fuzzedPosition = Vec2.add(position, vec2(rng(-EPS, EPS), rng(-EPS, EPS)));
+    for (let i = 0, n = this.numVertices(); i < n; i++) {
+        const edge = this.getEdge(i);
+        const edgeDistance = edge.distanceToPoint(position);
+        if (edgeDistance < smallestDistance)
+            smallestDistance = edgeDistance;
+        if (returnSigned && pointInPolygonHelper(position, this.getEdge(i)))
+            distanceSign *= -1;
+    }
+    return smallestDistance * distanceSign;
+};
+function pointInPolygonHelper(point, edge) {
+    const { start, end } = edge;
+    // Edge case: Point coincides with start or end. Check only start, so that
+    // the same vertex is not counted twice (end is start in the next edge)
+    // Ensure that false is returned if end point coincides
+    if (Math.abs(end.y - point.y) < EPS) {
+        return false;
+    }
+    else if (Math.abs(start.y - point.y) < EPS) {
+        return point.x < start.x + EPS;
+    }
+    let bottom, top;
+    if (start.y < end.y) {
+        bottom = start;
+        top = end;
+    }
+    else {
+        bottom = end;
+        top = start;
+    }
+    return point.y <= top.y && point.y >= bottom.y && ((point.x - top.x) * (top.y - bottom.y) > (point.y - top.y) * (top.x - bottom.x));
+}
+function getIntersectionLine(intersectionObject) {
+    if (intersectionObject instanceof Segment) {
+        return {
+            line: new Line(intersectionObject.start, intersectionObject.vector),
+            timeRange: [0, 1]
+        };
+    }
+    else if (intersectionObject instanceof Ray) {
+        return {
+            line: new Line(intersectionObject.point, intersectionObject.direction),
+            timeRange: [0, Infinity]
+        };
+    }
+    else {
+        return {
+            line: intersectionObject,
+            timeRange: undefined
+        };
+    }
+}

package/dist/geometry/polyline.d.ts

@@ -0,0 +1,23 @@
+import { AABB } from "./aabb.js";
+import { Polygon } from "./polygon.js";
+import { Segment } from "./segment.js";
+import { Vec2 } from "./vec2.js";
+export declare class Polyline {
+    #private;
+    vertices: Vec2[];
+    edges(): Segment[];
+    hull(): Polygon;
+    center(): Vec2;
+    aabb(): AABB;
+    numVertices(): number;
+    constructor(vertices: Vec2[]);
+    clone(): Polyline;
+    translate(translation: Vec2): this;
+    rotate(rotation: number, center?: Vec2): this;
+    scale(scale: number, center?: Vec2): this;
+    nearestPointOn(point: Vec2): Vec2;
+    nearestSegmentToPoint(point: Vec2): Segment;
+    distanceToPoint(point: Vec2): number;
+    render(ctx: CanvasRenderingContext2D, beginPath?: boolean): void;
+    private resetMemoized;
+}