@immugio/three-math-extensions 0.0.3 → 0.0.5

package/CHANGELOG.md

@@ -0,0 +1,34 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+Generated by [`auto-changelog`](https://github.com/CookPete/auto-changelog).
+
+## 0.0.4 - 2022-11-21
+
+### Commits
+
+- Automatic publish with change log [`a70c99d`](https://github.com/Immugio/three-math-extensions/commit/a70c99d0d42e60411ce01bcdb8dd4f3f489bb949)
+- Switch to npm [`ed47a17`](https://github.com/Immugio/three-math-extensions/commit/ed47a1787522db3bde5a2112bfd02480fe2edc54)
+- Initial commit [`3d1bf9e`](https://github.com/Immugio/three-math-extensions/commit/3d1bf9ef015570830007c9be99140c8c8d760d7f)
+- Add Line2D [`9a1dd0f`](https://github.com/Immugio/three-math-extensions/commit/9a1dd0f58352b7b25828693c688aa4770e95c174)
+- Readme, npm info [`dda4a28`](https://github.com/Immugio/three-math-extensions/commit/dda4a282a71a00308dcae858ffe53d67d4185be8)
+- Run tests in CI on commit [`e3f77ca`](https://github.com/Immugio/three-math-extensions/commit/e3f77ca76e25f4d99eef0130e5779b5e7c5aec6b)
+- Remove babel.config.js [`c9a1e16`](https://github.com/Immugio/three-math-extensions/commit/c9a1e1607cffec8a3d74adcca644320a79ca4c43)
+- Initial changelog [`6c98aa6`](https://github.com/Immugio/three-math-extensions/commit/6c98aa6ad631cf5e73d32dd76276f99b3ba5089f)
+- Release 0.0.4 [`bdac840`](https://github.com/Immugio/three-math-extensions/commit/bdac840f33261a3f39ef33bc05c80772169cfe87)
+- Add test badge [`37c62e8`](https://github.com/Immugio/three-math-extensions/commit/37c62e809bdcdfc63f7fe135469fd131f190f950)
+- Edit publish script condition [`dc77d89`](https://github.com/Immugio/three-math-extensions/commit/dc77d8978d87daab8732d6429ad1b01ba0ca6f97)
+- CI to use node version 16 [`dc42650`](https://github.com/Immugio/three-math-extensions/commit/dc426508939de922cc0316b7652bbd09aeed4610)
+- Action rename [`26a1f01`](https://github.com/Immugio/three-math-extensions/commit/26a1f014827faab2c02d30ca8ed18dac8f9ff8af)
+- Release 0.0.4 - tag pattern 4 [`ab9ad4e`](https://github.com/Immugio/three-math-extensions/commit/ab9ad4e49477a991482ed6d4d3a3ca4687a70b44)
+- Release 0.0.4 - tag pattern 3 [`d7d4c8f`](https://github.com/Immugio/three-math-extensions/commit/d7d4c8f546e6550868ddd06a5213fdec6c68bcd2)
+- Release 0.0.4 - tag pattern 2 [`0dcf801`](https://github.com/Immugio/three-math-extensions/commit/0dcf80190bd67a3ca93d45131a403201ab39e00f)
+- Release 0.0.4 - tag pattern [`e7f2f76`](https://github.com/Immugio/three-math-extensions/commit/e7f2f76aa247e1c51f0522c300a7aaf07253039c)
+- Release 0.0.5 [`c80d6bd`](https://github.com/Immugio/three-math-extensions/commit/c80d6bd12c25ddad0f67610cdf5c804d5759f084)
+- Status badge update [`370843e`](https://github.com/Immugio/three-math-extensions/commit/370843ed0a28b024761555572b7d51ccbdb4b77d)
+- Run tests in CI on commit [`aee8c55`](https://github.com/Immugio/three-math-extensions/commit/aee8c556ae1cab9025dbe0984dd17278fe6275a1)
+- Add Line2D to index [`a5fb6bd`](https://github.com/Immugio/three-math-extensions/commit/a5fb6bdeee5d9f07f325bfffc31ef96f0ce167d1)

package/README.md

@@ -1 +1,3 @@
-Set of utilities for 2d and 3d line math built on top of three.js
+# Set of utilities for 2d and 3d line math built on top of three.js
+
+[![Build](https://github.com/Immugio/three-math-extensions/actions/workflows/build.yml/badge.svg)](https://github.com/Immugio/three-math-extensions/actions/workflows/build.yml)

package/cjs/Line2D.js

@@ -18,14 +18,23 @@ class Line2D {
     static fromPoints(p1, p2, index = 0) {
         return new Line2D(new Vec2_1.Vec2(p1.x, p1.y), new Vec2_1.Vec2(p2.x, p2.y), index);
     }
-    static fromPolygon(polygon) {
-        if (polygon[0].x === polygon[polygon.length - 1].x && polygon[0].y === polygon[polygon.length - 1].y) {
-            polygon = polygon.slice(0, polygon.length - 1);
+    /**
+     * Creates a polygon formed by an array of lines from points provided.
+     * The polygon will only be closed if either
+     * 1) the first and last points are the same or 2) `forceClosedPolygon` is true.
+     */
+    static fromPolygon(polygon, forceClosedPolygon = false) {
+        if (!polygon || polygon.length < 2) {
+            return [];
         }
-        return polygon.map((p, i) => {
-            const next = polygon[(i + 1) % polygon.length];
-            return Line2D.fromPoints(p, next, i);
-        });
+        if (forceClosedPolygon && (polygon[0].x !== polygon.at(-1).x || polygon[0].y !== polygon.at(-1).y)) {
+            polygon = [...polygon, polygon[0]];
+        }
+        const lines = [];
+        for (let i = 0; i < polygon.length - 1; i++) {
+            lines.push(Line2D.fromPoints(polygon[i], polygon[i + 1], i));
+        }
+        return lines;
     }
     static fromLength(length) {
         return Line2D.fromCoordinates(-length / 2, 0, length / 2, 0);
@@ -101,6 +110,14 @@ class Line2D {
     get length() {
         return this.start.distanceTo(this.end);
     }
+    /**
+     * Set the length of this line. Center and direction remain unchanged.
+     * @param length
+     */
+    setLength(length) {
+        this.length = length;
+        return this;
+    }
     /**
      * Returns the start and end points of the line as an array.
      * Endpoints are not cloned.

package/cjs/Line3D.js

@@ -13,6 +13,24 @@ class Line3D extends three_1.Line3 {
     static fromPoints(start, end) {
         return new Line3D(new Vec3_1.Vec3(start.x, start.y, start.z), new Vec3_1.Vec3(end.x, end.y, end.z));
     }
+    /**
+     * Creates a polygon formed by an array of lines from points provided.
+     * The polygon will only be closed if either
+     * 1) the first and last points are the same or 2) `forceClosedPolygon` is true.
+     */
+    static fromPolygon(polygon, forceClosedPolygon = false) {
+        if (!polygon || polygon.length < 2) {
+            return [];
+        }
+        if (forceClosedPolygon && (polygon[0].x !== polygon.at(-1).x || polygon[0].y !== polygon.at(-1).y || polygon[0].z !== polygon.at(-1).z)) {
+            polygon = [...polygon, polygon[0]];
+        }
+        const lines = [];
+        for (let i = 0; i < polygon.length - 1; i++) {
+            lines.push(Line3D.fromPoints(polygon[i], polygon[i + 1]));
+        }
+        return lines;
+    }
     /**
      * Returns lines that are the result of clipping this line by the @other line.
      * Clips must be parallel to this line.

package/cjs/Vec2.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Vec2 = void 0;
 const three_1 = require("three");
+const Vec3_1 = require("./Vec3");
 class Vec2 extends three_1.Vector2 {
     static fromPoint(point) {
         return new Vec2(point.x, point.y);
@@ -15,5 +16,8 @@ class Vec2 extends three_1.Vector2 {
         }
         return this;
     }
+    in3DSpace(z = 0) {
+        return new Vec3_1.Vec3(this.x, z, this.y);
+    }
 }
 exports.Vec2 = Vec2;

package/esm/Line2D.js

@@ -0,0 +1,540 @@
+import { Vector2 } from "three";
+import { Vec2 } from "./Vec2";
+export class Line2D {
+    start;
+    end;
+    index;
+    constructor(start, end, index = 0) {
+        this.start = start;
+        this.end = end;
+        this.index = index;
+    }
+    static fromCoordinates(x1, y1, x2, y2, index = 0) {
+        return new Line2D(new Vec2(x1, y1), new Vec2(x2, y2), index);
+    }
+    static fromPoints(p1, p2, index = 0) {
+        return new Line2D(new Vec2(p1.x, p1.y), new Vec2(p2.x, p2.y), index);
+    }
+    /**
+     * Creates a polygon formed by an array of lines from points provided.
+     * The polygon will only be closed if either
+     * 1) the first and last points are the same or 2) `forceClosedPolygon` is true.
+     */
+    static fromPolygon(polygon, forceClosedPolygon = false) {
+        if (!polygon || polygon.length < 2) {
+            return [];
+        }
+        if (forceClosedPolygon && (polygon[0].x !== polygon.at(-1).x || polygon[0].y !== polygon.at(-1).y)) {
+            polygon = [...polygon, polygon[0]];
+        }
+        const lines = [];
+        for (let i = 0; i < polygon.length - 1; i++) {
+            lines.push(Line2D.fromPoints(polygon[i], polygon[i + 1], i));
+        }
+        return lines;
+    }
+    static fromLength(length) {
+        return Line2D.fromCoordinates(-length / 2, 0, length / 2, 0);
+    }
+    get center() {
+        return new Vec2((this.start.x + this.end.x) / 2, (this.start.y + this.end.y) / 2);
+    }
+    /**
+     * Set the center of the line to the provided point. Length and direction remain unchanged.
+     * Modifies this line.
+     * @param value
+     */
+    set center(value) {
+        const current = this.center;
+        const diffX = current.x - value.x;
+        const diffY = current.y - value.y;
+        this.start.x -= diffX;
+        this.start.y -= diffY;
+        this.end.x -= diffX;
+        this.end.y -= diffY;
+    }
+    /**
+     * Set the center of the line to the provided point. Length and direction remain unchanged.
+     * Modifies this line.
+     * @param value
+     */
+    setCenter(value) {
+        this.center = value;
+        return this;
+    }
+    /*
+    * Extends or reduces the line by the given length while keeping the center of the line constant.
+    * Modifies this line.
+    */
+    resize(amount) {
+        this.moveStartPoint(amount / 2);
+        this.moveEndPoint(amount / 2);
+        return this;
+    }
+    /*
+    * Moves start point on the line by the given amount. Plus values move the point further away from the center.
+    * Modifies this line.
+    */
+    moveStartPoint(amount) {
+        const p1 = this.movePointOnThisLine(this.start, amount);
+        this.start.copy(p1);
+        return this;
+    }
+    /**
+     * Moves end point on the line by the given amount. Plus values move the point further away from the center.
+     * Modifies this line.
+     */
+    moveEndPoint(amount) {
+        const p2 = this.movePointOnThisLine(this.end, amount);
+        this.end.copy(p2);
+        return this;
+    }
+    movePointOnThisLine(point, amount) {
+        const vec = new Vector2(this.center.x - point.x, this.center.y - point.y);
+        const length = vec.length();
+        vec.normalize().multiplyScalar(length + amount);
+        return new Vec2(this.center.x - vec.x, this.center.y - vec.y);
+    }
+    /**
+     * Set the length of this line. Center and direction remain unchanged.
+     * Modifies this line.
+     * @param l
+     */
+    set length(l) {
+        const length = this.length;
+        this.resize(l - length);
+    }
+    get length() {
+        return this.start.distanceTo(this.end);
+    }
+    /**
+     * Set the length of this line. Center and direction remain unchanged.
+     * @param length
+     */
+    setLength(length) {
+        this.length = length;
+        return this;
+    }
+    /**
+     * Returns the start and end points of the line as an array.
+     * Endpoints are not cloned.
+     */
+    get endpoints() {
+        return [this.start, this.end];
+    }
+    /**
+     * Returns the direction of this line.
+     */
+    get direction() {
+        return this.end.clone().sub(this.start).normalize();
+    }
+    /**
+     * Inverts the direction of the line.
+     * Modifies this line.
+     */
+    flip() {
+        const temp = this.start.clone();
+        this.start.copy(this.end);
+        this.end.copy(temp);
+        return this;
+    }
+    /**
+     * Rotates the line around the center by the given angle in radians.
+     * Modifies this line.
+     * @param radians Positive values rotate counter-clockwise.
+     * @param center
+     */
+    rotate(radians, center = this.center) {
+        this.start.rotateAround(center, radians);
+        this.end.rotateAround(center, radians);
+        return this;
+    }
+    /**
+     * Move the line by the given vector.
+     * Modifies this line.
+     */
+    translate(value) {
+        this.start.x += value.x;
+        this.start.y += value.y;
+        this.end.x += value.x;
+        this.end.y += value.y;
+        return this;
+    }
+    /**
+     * Move the line to its left by the given amount.
+     * Modifies this line.
+     */
+    translateLeft(amount) {
+        const translation = this.direction.rotateAround(new Vec2(), -Math.PI / 2).multiplyScalar(amount);
+        return this.translate(translation);
+    }
+    /**
+     * Move the line to its right by the given amount.
+     * Modifies this line.
+     */
+    translateRight(amount) {
+        const translation = this.direction.rotateAround(new Vec2(), Math.PI / 2).multiplyScalar(amount);
+        return this.translate(translation);
+    }
+    /**
+     * Returns true when the point is actually inside the (finite) line segment.
+     * https://jsfiddle.net/c06zdxtL/2/
+     * https://stackoverflow.com/questions/6865832/detecting-if-a-point-is-of-a-line-segment/6877674
+     * @param point: Point2
+     */
+    isPointOnLineSection(point) {
+        if (!this.isPointOnInfiniteLine(point)) {
+            return false;
+        }
+        return this.isPointBesideLineSection(point);
+    }
+    /**
+     * Returns true when the point is beside the line **segment** and within the maxDistance.
+     * @param point
+     * @param maxDistance
+     */
+    isPointCloseToAndBesideLineSection(point, maxDistance) {
+        const distance = this.distanceToPointOnInfiniteLine(point);
+        return distance <= maxDistance && this.isPointBesideLineSection(point);
+    }
+    /**
+     * Returns true when the point is beside the line **segment**
+     * @param point
+     */
+    isPointBesideLineSection(point) {
+        const l2 = (((this.end.x - this.start.x) * (this.end.x - this.start.x)) + ((this.end.y - this.start.y) * (this.end.y - this.start.y)));
+        if (l2 == 0)
+            return false;
+        const r = (((point.x - this.start.x) * (this.end.x - this.start.x)) + ((point.y - this.start.y) * (this.end.y - this.start.y))) / l2;
+        return (0 <= r) && (r <= 1);
+    }
+    /**
+     * Returns true when the point is on the **infinite** line.
+     * @param point
+     */
+    isPointOnInfiniteLine(point) {
+        return (point.y - this.start.y) * (this.end.x - this.start.x) === (this.end.y - this.start.y) * (point.x - this.start.x);
+    }
+    /**
+     * Returns true if other line is collinear and overlaps or at least touching this line.
+     * @param other
+     */
+    isCollinearWithTouchOrOverlap(other) {
+        if (!this.isPointOnInfiniteLine(other.start) || !this.isPointOnInfiniteLine(other.end)) {
+            return false;
+        }
+        return this.isPointOnLineSection(other.start) || this.isPointOnLineSection(other.end) ||
+            other.isPointOnLineSection(this.start) || other.isPointOnLineSection(this.end);
+    }
+    /**
+     * Returns true if there is any overlap between this line and the @other line section.
+     */
+    overlaps(other) {
+        if (!this.isCollinearWithTouchOrOverlap(other)) {
+            return false;
+        }
+        if (this.start.equals(other.start) && this.end.equals(other.end)) {
+            return true;
+        }
+        return !this.start.equals(other.end) && !this.end.equals(other.start);
+    }
+    /**
+     * Logical AND of this and the other line section.
+     * @param other
+     */
+    getOverlap(other) {
+        if (!this.overlaps(other)) {
+            return null;
+        }
+        if (this.equals(other)) {
+            return this.clone();
+        }
+        const points = [
+            [this.start, this.end].filter(thisPoint => other.isPointOnLineSection(thisPoint)),
+            [other.start, other.end].filter(otherPoint => this.isPointOnLineSection(otherPoint))
+        ].flat();
+        if (points.length !== 2) {
+            return null;
+        }
+        const overlap = Line2D.fromPoints(points[0], points[1]);
+        if (overlap.direction.manhattanDistanceTo(this.direction) > Number.EPSILON) {
+            overlap.flip();
+        }
+        return overlap;
+    }
+    /**
+     * Joins a copy of @line with the @other line.
+     * Other must be parallel to this line.
+     * Returns null if there is no overlap
+     * Clones the line, does not modify.
+     * @param line
+     * @param other
+     */
+    static joinLine(line, other) {
+        if (!line.isCollinearWithTouchOrOverlap(other)) {
+            return null;
+        }
+        const p1 = !line.isPointOnLineSection(other.start) ? other.start : line.start;
+        const p2 = !line.isPointOnLineSection(other.end) ? other.end : line.end;
+        return new Line2D(p1.clone(), p2.clone(), line.index);
+    }
+    /**
+     * Joins provided lines into several joined lines.
+     * Lines must be parallel for joining.
+     * Clone the lines, does not modify.
+     * @param lines
+     */
+    static joinLines(lines) {
+        if (lines.length < 2) {
+            return lines.map(x => x.clone());
+        }
+        const toProcess = lines.slice();
+        const result = [];
+        while (toProcess.length > 0) {
+            const current = toProcess.pop();
+            let joined = false;
+            for (let i = 0; i < result.length; i++) {
+                const other = result[i];
+                const joinedLine = Line2D.joinLine(current, other);
+                if (joinedLine) {
+                    result[i] = joinedLine;
+                    joined = true;
+                    break;
+                }
+            }
+            if (!joined) {
+                result.push(current.clone());
+            }
+        }
+        return result;
+    }
+    /**
+     * Divides the Line3D into a number of segments of the given length.
+     * Clone the line, does not modify.
+     * @param maxSegmentLength number
+     */
+    chunk(maxSegmentLength) {
+        const source = this.clone();
+        const result = [];
+        while (source.length > maxSegmentLength) {
+            const chunk = source.clone();
+            chunk.moveEndPoint(-(chunk.length - maxSegmentLength));
+            result.push(chunk);
+            source.start = chunk.end.clone();
+        }
+        result.push(source);
+        return result;
+    }
+    /**
+     * Returns the closest point parameter on the **infinite** line to the given point.
+     * @param point
+     */
+    closestPointToPointParameterOnInfiniteLine(point) {
+        const startP = new Vec2().subVectors(point, this.start);
+        const startEnd = new Vec2().subVectors(this.end, this.start);
+        const startEnd2 = startEnd.dot(startEnd);
+        const startEnd_startP = startEnd.dot(startP);
+        return startEnd_startP / startEnd2;
+    }
+    /**
+     * Returns the closest point on the **infinite** line to the given point.
+     * @param point
+     */
+    closestPointOnInfiniteLine(point) {
+        const t = this.closestPointToPointParameterOnInfiniteLine(point);
+        return new Vec2().subVectors(this.end, this.start).multiplyScalar(t).add(this.start);
+    }
+    /**
+     * Returns the closest point on the line **section** to the given point.
+     * @param point
+     */
+    closestPointOnLine(point) {
+        const closestPoint = this.closestPointOnInfiniteLine(point);
+        if (this.isPointOnLineSection(closestPoint)) {
+            return closestPoint;
+        }
+        return closestPoint.distanceTo(this.start) < closestPoint.distanceTo(this.end) ? this.start : this.end;
+    }
+    /**
+     * Returns the distance between the **infinite** line and the point.
+     * @param point
+     */
+    distanceToPointOnInfiniteLine(point) {
+        const l2 = (((this.end.x - this.start.x) * (this.end.x - this.start.x)) + ((this.end.y - this.start.y) * (this.end.y - this.start.y)));
+        if (l2 == 0)
+            return Infinity;
+        const s = (((this.start.y - point.y) * (this.end.x - this.start.x)) - ((this.start.x - point.x) * (this.end.y - this.start.y))) / l2;
+        return Math.abs(s) * Math.sqrt(l2);
+    }
+    /**
+     * Returns lines that are the result of clipping @source line by the @clips.
+     * Clips must be parallel to this line.
+     * Clones the line, does not modify this.
+     * @param source
+     * @param clips
+     */
+    static clipLines(source, clips) {
+        if (!clips || clips.length === 0)
+            return [source];
+        clips = clips.map(c => {
+            const copy = c.clone();
+            if (copy.direction.manhattanDistanceTo(source.direction) > Number.EPSILON) {
+                copy.flip();
+            }
+            return copy;
+        });
+        const free = [];
+        const sources = [source];
+        while (sources.length > 0) {
+            let isFree = true;
+            const tested = sources.pop();
+            for (const cover of clips) {
+                if (tested.overlaps(cover)) {
+                    isFree = false;
+                    const subtracted = this.subtractSingle(tested, cover);
+                    sources.push(...subtracted);
+                    break;
+                }
+            }
+            if (isFree)
+                free.push(tested);
+        }
+        return this.order(source, free);
+    }
+    /**
+     * Returns the original line section split into two parts, if the line **sections** overlap, otherwise null
+     */
+    splitAtIntersection(other, tolerance = 0) {
+        const intersection = this.intersect(other);
+        if (intersection) {
+            if (this.isPointCloseToAndBesideLineSection(intersection, tolerance) && other.isPointCloseToAndBesideLineSection(intersection, tolerance)) {
+                return [
+                    Line2D.fromPoints(this.start, intersection),
+                    Line2D.fromPoints(intersection, this.end)
+                ];
+            }
+        }
+        return null;
+    }
+    /**
+     * If lines **sections** overlap, returns the original line section split into two parts, sorted by length
+     * Else, if the **infinite** lines intersect, returns a new line extended to the intersection point
+     * Otherwise, null if the lines are parallel and do not intersect
+     */
+    splitAtOrExtendToIntersection(other) {
+        const intersection = this.intersect(other);
+        if (intersection) {
+            return [
+                Line2D.fromPoints(this.start, intersection),
+                Line2D.fromPoints(intersection, this.end)
+            ].filter(x => x.length > Number.EPSILON).sort((a, b) => a.length - b.length);
+        }
+        return null;
+    }
+    static order(source, lines) {
+        if (source.start.x < source.end.x) {
+            lines.sort((a, b) => a.start.x - b.start.x);
+        }
+        else if (source.start.x > source.end.x) {
+            lines.sort((a, b) => b.start.x - a.start.x);
+        }
+        if (source.start.y < source.end.y) {
+            lines.sort((a, b) => a.start.y - b.start.y);
+        }
+        else if (source.start.y > source.end.y) {
+            lines.sort((a, b) => b.start.y - a.start.y);
+        }
+        return lines;
+    }
+    static subtractSingle(source, cover) {
+        const left = source.clone();
+        left.end.copy(cover.start);
+        const right = source.clone();
+        right.start.copy(cover.end);
+        return [left, right].filter(x => x.length > 1 && x.direction.manhattanDistanceTo(source.direction) < Number.EPSILON);
+    }
+    /**
+     * If other line is not contained within this line, the excess is trimmed.
+     * Does not create a copy. Provided line is modified.
+     * @param lineToTrim
+     */
+    trimExcess(lineToTrim) {
+        if (!this.isCollinearWithTouchOrOverlap(lineToTrim)) {
+            return;
+        }
+        if (!this.isPointOnLineSection(lineToTrim.start)) {
+            const closest = this.closestPointOnLine(lineToTrim.start);
+            lineToTrim.start.copy(closest);
+        }
+        if (!this.isPointOnLineSection(lineToTrim.end)) {
+            const closest = this.closestPointOnLine(lineToTrim.end);
+            lineToTrim.end.copy(closest);
+        }
+    }
+    /**
+     * If other line is shorter than this, endpoints are moved to extend other
+     * Does not create a copy. Provided line is modified.
+     * @param lineToExtend
+     * @param tolerance
+     */
+    extendToEnds(lineToExtend, tolerance) {
+        if (!this.isCollinearWithTouchOrOverlap(lineToExtend)) {
+            console.log("Can't clip, lines that are not collinear with touch or overlap");
+            return;
+        }
+        if (this.start.distanceTo(lineToExtend.start) <= tolerance) {
+            lineToExtend.start.copy(this.start);
+        }
+        if (this.end.distanceTo(lineToExtend.end) <= tolerance) {
+            lineToExtend.end.copy(this.end);
+        }
+    }
+    /**
+     * Returns the intersection point of two lines. The lines are assumed to be infinite.
+     */
+    intersect(other) {
+        // Check if none of the lines are of length 0
+        if ((this.start.x === this.end.x && this.start.y === this.end.y) || (other.start.x === other.end.x && other.start.y === other.end.y)) {
+            return null;
+        }
+        const denominator = ((other.end.y - other.start.y) * (this.end.x - this.start.x) - (other.end.x - other.start.x) * (this.end.y - this.start.y));
+        // Lines are parallel
+        if (denominator === 0) {
+            return null;
+        }
+        const ua = ((other.end.x - other.start.x) * (this.start.y - other.start.y) - (other.end.y - other.start.y) * (this.start.x - other.start.x)) / denominator;
+        // Return an object with the x and y coordinates of the intersection
+        const x = this.start.x + ua * (this.end.x - this.start.x);
+        const y = this.start.y + ua * (this.end.y - this.start.y);
+        return new Vec2(x, y);
+    }
+    /**
+     * Check that the infinite lines intersect and that they are in the specified angle to each other
+     * @param other Line
+     * @param expectedAngleInRads number
+     */
+    hasIntersectionWithAngle(other, expectedAngleInRads) {
+        const angle = this.direction.angle();
+        const otherAngle = other.direction.angle();
+        const actualAngle = Math.abs(angle - otherAngle);
+        if (Math.abs(actualAngle - expectedAngleInRads) < Number.EPSILON) {
+            const intersection = this.intersect(other);
+            if (intersection && this.isPointOnLineSection(intersection) && other.isPointOnLineSection(intersection)) {
+                return intersection;
+            }
+        }
+        return null;
+    }
+    /**
+     * Deep clone of this line
+     */
+    clone() {
+        return new Line2D(this.start.clone(), this.end.clone(), this.index);
+    }
+    toString() {
+        return `Line(${this.start.x}, ${this.start.y}, ${this.end.x}, ${this.end.y})`;
+    }
+    equals(other) {
+        return !!other && this.start.equals(other.start) && this.end.equals(other.end);
+    }
+}