@immugio/three-math-extensions 0.2.10 → 0.2.12

package/CHANGELOG.md

@@ -7,31 +7,57 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 Generated by [`auto-changelog`](https://github.com/CookPete/auto-changelog).
 
-## [0.2.10](https://github.com/Immugio/three-math-extensions/compare/16.15.10...0.2.10)
+## [0.2.12](https://github.com/Immugio/three-math-extensions/compare/16.15.10...0.2.12)
 
 ### Commits
 
+- Add eslint [`98e4912`](https://github.com/Immugio/three-math-extensions/commit/98e4912d637b42ba80e2f3267638b43296113019)
+- Update jest packages [`af23b4f`](https://github.com/Immugio/three-math-extensions/commit/af23b4f08154bba3407f05b773865215e7e1cba8)
 - Add Rectangle, update Polygon [`58ee875`](https://github.com/Immugio/three-math-extensions/commit/58ee87539af8f9ade186e5250cba9e01926da514)
 - Add isPointInPolygon [`a59eb4b`](https://github.com/Immugio/three-math-extensions/commit/a59eb4be026f17a3106070ae626a0588cd4f4411)
 - Improve Line2D.closestPointToPoint, add Vec2.signedAngle [`151f214`](https://github.com/Immugio/three-math-extensions/commit/151f21462e0358057ad8e9d75d5782563a1061f6)
 - Improve documentation [`d0fcb51`](https://github.com/Immugio/three-math-extensions/commit/d0fcb5132f127b4382ac5f7291575a061b8ec121)
 - Vec3, Line3D - update documentation [`67d9c32`](https://github.com/Immugio/three-math-extensions/commit/67d9c328e08cc0a5599932d2f0529e97f31c9213)
 - Add Polygon [`629cff8`](https://github.com/Immugio/three-math-extensions/commit/629cff8ecbb963477e8ea76d7f8b16d95435cbad)
+- Line3D.groupConnectedLines added [`29f372b`](https://github.com/Immugio/three-math-extensions/commit/29f372bc984c06b00c50fcd9428ce9a7b9cab799)
+- Dependencies update and remove now duplicate Vec2.angleTo implementation [`4774abb`](https://github.com/Immugio/three-math-extensions/commit/4774abb81d882082df0da606c79a3c7bd3aecc57)
+- Line2D.isCloserToHorizontal [`b6f1429`](https://github.com/Immugio/three-math-extensions/commit/b6f14292d1d2765f7314c45e4c74be91280ac764)
+- Add Vec2.angleTo and tests [`dcf1e53`](https://github.com/Immugio/three-math-extensions/commit/dcf1e531aecf8c115f323e14e5e44059e5c5d15c)
 - Add Vec2.signedAngle [`863c8f2`](https://github.com/Immugio/three-math-extensions/commit/863c8f27f11288cbda535e21bb688206259269ed)
 - Add Vec2.fromPoints to accept multiple points [`a261402`](https://github.com/Immugio/three-math-extensions/commit/a2614027cf5fb8263189b48f7e0bb9a23a552c15)
 - Add Vec2.parallelTo [`989874d`](https://github.com/Immugio/three-math-extensions/commit/989874dcfe122d3ee84d8d56d79cb88e4e441736)
 - Line2D.intersect - enable line segments intersection only [`1f1470e`](https://github.com/Immugio/three-math-extensions/commit/1f1470e1cf00118e643f5c44a135e0baf6b76d41)
+- Add Line2D.projectOn [`4c52c5c`](https://github.com/Immugio/three-math-extensions/commit/4c52c5c2e649fbddb72ce3fca60cfd3f1319f72f)
+- Add Line3D.index [`7ed13d2`](https://github.com/Immugio/three-math-extensions/commit/7ed13d213748056c9dafd86288c3bcec9a28d1ba)
 - Polygon from bounding size [`eae6701`](https://github.com/Immugio/three-math-extensions/commit/eae67012f57f426f8b5259b765000447ce06d608)
 - Line2D and Line3D to return this instead of specific type [`761ef6a`](https://github.com/Immugio/three-math-extensions/commit/761ef6a9d8cc4e35120b666576794e521aa3b991)
 - Line2D.in3DSpace added [`a6ce0ec`](https://github.com/Immugio/three-math-extensions/commit/a6ce0ecb67f5c7b2a75fcc283c28af626153a4af)
 - Line2D.hasIntersectionWithAngle to support optional tolerance [`b313bbe`](https://github.com/Immugio/three-math-extensions/commit/b313bbe118d435d53750deefd9a9e29ba6ec5c71)
 - Line2D.hasIntersectionWithAngle - modulo all angles [`5409aa0`](https://github.com/Immugio/three-math-extensions/commit/5409aa0bc41510efa86d548e91837e44e5b6c343)
+- Use Vec2 instead of Vector2 [`7e6a6ea`](https://github.com/Immugio/three-math-extensions/commit/7e6a6ea272f4441ef4bc78b3fdec23fc783fa1db)
 - Update release instructions [`5b41a2e`](https://github.com/Immugio/three-math-extensions/commit/5b41a2ed7e15450dbb6088a7f7ed0031a013badc)
 - Add Polygon to exports [`ed66775`](https://github.com/Immugio/three-math-extensions/commit/ed66775c33e961835b23843222b822cfd9c16b1d)
 - Vec2.fromPoint and Vec3.fromPoint should accept null [`4b871af`](https://github.com/Immugio/three-math-extensions/commit/4b871af297bdcbe8584f1e2b99d602247b77687c)
+- Documentation update [`d5c7a07`](https://github.com/Immugio/three-math-extensions/commit/d5c7a0765f6097f5d3a3be01967d4059f19682fb)
 - Excluded files from build [`ec70614`](https://github.com/Immugio/three-math-extensions/commit/ec70614bc7df7a98f854c7a6693365118e04faf7)
 
-## [16.15.10](https://github.com/Immugio/three-math-extensions/compare/0.2.9...16.15.10) - 2023-01-02
+## [16.15.10](https://github.com/Immugio/three-math-extensions/compare/0.2.11...16.15.10) - 2023-01-02
+
+## [0.2.11](https://github.com/Immugio/three-math-extensions/compare/0.2.10...0.2.11) - 2023-08-24
+
+### Commits
+
+- Line2D.isCloserToHorizontal [`b6f1429`](https://github.com/Immugio/three-math-extensions/commit/b6f14292d1d2765f7314c45e4c74be91280ac764)
+- Add Vec2.angleTo and tests [`dcf1e53`](https://github.com/Immugio/three-math-extensions/commit/dcf1e531aecf8c115f323e14e5e44059e5c5d15c)
+- Add Line2D.projectOn [`4c52c5c`](https://github.com/Immugio/three-math-extensions/commit/4c52c5c2e649fbddb72ce3fca60cfd3f1319f72f)
+- Use Vec2 instead of Vector2 [`7e6a6ea`](https://github.com/Immugio/three-math-extensions/commit/7e6a6ea272f4441ef4bc78b3fdec23fc783fa1db)
+- Documentation update [`d5c7a07`](https://github.com/Immugio/three-math-extensions/commit/d5c7a0765f6097f5d3a3be01967d4059f19682fb)
+
+## [0.2.10](https://github.com/Immugio/three-math-extensions/compare/0.2.9...0.2.10) - 2023-05-30
+
+### Commits
+
+- Add isPointInPolygon [`a59eb4b`](https://github.com/Immugio/three-math-extensions/commit/a59eb4be026f17a3106070ae626a0588cd4f4411)
 
 ## [0.2.9](https://github.com/Immugio/three-math-extensions/compare/0.2.8...0.2.9) - 2023-05-22
 

package/cjs/Line2D.js

@@ -6,6 +6,7 @@ const Vec2_1 = require("./Vec2");
 const three_2 = require("three");
 const MathConstants_1 = require("./MathConstants");
 const Line3D_1 = require("./Line3D");
+const directions2d_1 = require("./directions2d");
 const _startP = /*@__PURE__*/ new Vec2_1.Vec2();
 const _startEnd = /*@__PURE__*/ new Vec2_1.Vec2();
 class Line2D {
@@ -316,6 +317,16 @@ class Line2D {
         }
         return result;
     }
+    /**
+     * Returns a new line that is the projection of this line onto @other. Uses `closestPointToPoint` to find the projection.
+     * @param other
+     * @param clampToLine
+     */
+    projectOn(other, clampToLine) {
+        const p1 = other.closestPointToPoint(this.start, clampToLine, new Vec2_1.Vec2());
+        const p2 = other.closestPointToPoint(this.end, clampToLine, new Vec2_1.Vec2());
+        return p1.distanceTo(this.start) < p2.distanceTo(this.start) ? new Line2D(p1, p2) : new Line2D(p2, p1);
+    }
     /**
      * Divides the Line3D into a number of segments of the given length.
      * Clone the line, does not modify.
@@ -562,6 +573,13 @@ class Line2D {
         }
         return null;
     }
+    get isCloserToHorizontal() {
+        const direction = this.direction;
+        return direction.angleTo(directions2d_1.directions2d.Right) < Math.PI / 4 || direction.angleTo(directions2d_1.directions2d.Left) < Math.PI / 4;
+    }
+    get isCloserToVertical() {
+        return !this.isCloserToHorizontal;
+    }
     /**
      * Project the line to 2D space. For start and end points Vec2.y becomes Vec3.z. and Vec3.y is provided as an argument.
      * @param y - The y value of the new Vec3 instance.

package/cjs/Line3D.js

@@ -5,13 +5,15 @@ const three_1 = require("three");
 const Vec3_1 = require("./Vec3");
 const Line2D_1 = require("./Line2D");
 class Line3D extends three_1.Line3 {
+    index;
     #target;
-    constructor(start, end) {
+    constructor(start, end, index = 0) {
         super(start, end);
+        this.index = index;
         this.#target = new Vec3_1.Vec3();
     }
-    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));
+    static fromPoints(start, end, index = 0) {
+        return new Line3D(new Vec3_1.Vec3(start.x, start.y, start.z), new Vec3_1.Vec3(end.x, end.y, end.z), index);
     }
     /**
      * Creates a polygon formed by an array of lines from points provided.
@@ -27,7 +29,7 @@ class Line3D extends three_1.Line3 {
         }
         const lines = [];
         for (let i = 0; i < polygon.length - 1; i++) {
-            lines.push(Line3D.fromPoints(polygon[i], polygon[i + 1]));
+            lines.push(Line3D.fromPoints(polygon[i], polygon[i + 1], i));
         }
         return lines;
     }
@@ -406,6 +408,41 @@ class Line3D extends three_1.Line3 {
         const resultSegmentPoint2 = new Vec3_1.Vec3((p3.x + mub * p43.x), (p3.y + mub * p43.y), (p3.z + mub * p43.z));
         return new Line3D(resultSegmentPoint1, resultSegmentPoint2);
     }
+    /**
+     * Accepts an array of Line3D and groups them into arrays of connected lines
+     * @param lines Lines to be grouped
+     * @param tolerance Tolerance for considering lines as connected
+     */
+    static groupConnectedLines(lines, tolerance = 0) {
+        const visited = new Set();
+        // Use graph-based approach. Each line can be considered as an edge in the graph, and the endpoints of the lines can be considered as vertices.
+        // Then use Depth-First Search (DFS) to find connected components in the graph.
+        const dfs = (line, group) => {
+            if (visited.has(line))
+                return;
+            visited.add(line);
+            group.push(line);
+            lines.forEach((neighbor) => {
+                if (!visited.has(neighbor)) {
+                    if ((line.start).isNear(neighbor.start, tolerance) ||
+                        (line.start).isNear(neighbor.end, tolerance) ||
+                        (line.end).isNear(neighbor.start, tolerance) ||
+                        (line.end).isNear(neighbor.end, tolerance)) {
+                        dfs(neighbor, group);
+                    }
+                }
+            });
+        };
+        const connectedLines = [];
+        lines.forEach((line) => {
+            if (!visited.has(line)) {
+                const group = [];
+                dfs(line, group);
+                connectedLines.push(group);
+            }
+        });
+        return connectedLines;
+    }
     /**
      * Project the line to 2D space, Y value is dropped
      */
@@ -422,7 +459,7 @@ class Line3D extends three_1.Line3 {
      * Deep clone of this line
      */
     clone() {
-        return new Line3D(this.start.clone(), this.end.clone());
+        return new Line3D(this.start.clone(), this.end.clone(), this.index);
     }
     toString() {
         return `Line3D { start: ${this.start.x}, ${this.start.y}, ${this.start.z}, end: ${this.end.x}, ${this.end.y}, ${this.end.z}}`;

package/cjs/directions.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.directions = void 0;
+const Vec3_1 = require("./Vec3");
+exports.directions = {
+    North: new Vec3_1.Vec3(0, 0, -1),
+    South: new Vec3_1.Vec3(0, 0, 1),
+    East: new Vec3_1.Vec3(1, 0, 0),
+    West: new Vec3_1.Vec3(-1, 0, 0),
+    Up: new Vec3_1.Vec3(0, 1, 0),
+    Down: new Vec3_1.Vec3(0, -1, 0)
+};

package/cjs/directions2d.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.directions2d = void 0;
+const Vec2_1 = require("./Vec2");
+exports.directions2d = {
+    Up: new Vec2_1.Vec2(0, -1),
+    Down: new Vec2_1.Vec2(0, 1),
+    Left: new Vec2_1.Vec2(-1, 0),
+    Right: new Vec2_1.Vec2(1, 0)
+};

package/cjs/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isPointInPolygon = exports.TwoPI = exports.normalizeAngleRadians = exports.normalizeAngleDegrees = exports.Rectangle = exports.BoundingBox = exports.Polygon = exports.Size2 = exports.Line3D = exports.Line2D = exports.Vec3 = exports.Vec2 = void 0;
+exports.directions2d = exports.directions = exports.isPointInPolygon = exports.TwoPI = exports.normalizeAngleRadians = exports.normalizeAngleDegrees = exports.Rectangle = exports.BoundingBox = exports.Polygon = exports.Size2 = exports.Line3D = exports.Line2D = exports.Vec3 = exports.Vec2 = void 0;
 var Vec2_1 = require("./Vec2");
 Object.defineProperty(exports, "Vec2", { enumerable: true, get: function () { return Vec2_1.Vec2; } });
 var Vec3_1 = require("./Vec3");
@@ -25,3 +25,7 @@ var MathConstants_1 = require("./MathConstants");
 Object.defineProperty(exports, "TwoPI", { enumerable: true, get: function () { return MathConstants_1.TwoPI; } });
 var isPointInPolygon_1 = require("./isPointInPolygon");
 Object.defineProperty(exports, "isPointInPolygon", { enumerable: true, get: function () { return isPointInPolygon_1.isPointInPolygon; } });
+var directions_1 = require("./directions");
+Object.defineProperty(exports, "directions", { enumerable: true, get: function () { return directions_1.directions; } });
+var directions2d_1 = require("./directions2d");
+Object.defineProperty(exports, "directions2d", { enumerable: true, get: function () { return directions2d_1.directions2d; } });

package/esm/Line2D.js

@@ -3,6 +3,7 @@ import { Vec2 } from "./Vec2";
 import { MathUtils } from "three";
 import { TwoPI } from "./MathConstants";
 import { Line3D } from "./Line3D";
+import { directions2d } from "./directions2d";
 const _startP = /*@__PURE__*/ new Vec2();
 const _startEnd = /*@__PURE__*/ new Vec2();
 export class Line2D {
@@ -313,6 +314,16 @@ export class Line2D {
         }
         return result;
     }
+    /**
+     * Returns a new line that is the projection of this line onto @other. Uses `closestPointToPoint` to find the projection.
+     * @param other
+     * @param clampToLine
+     */
+    projectOn(other, clampToLine) {
+        const p1 = other.closestPointToPoint(this.start, clampToLine, new Vec2());
+        const p2 = other.closestPointToPoint(this.end, clampToLine, new Vec2());
+        return p1.distanceTo(this.start) < p2.distanceTo(this.start) ? new Line2D(p1, p2) : new Line2D(p2, p1);
+    }
     /**
      * Divides the Line3D into a number of segments of the given length.
      * Clone the line, does not modify.
@@ -559,6 +570,13 @@ export class Line2D {
         }
         return null;
     }
+    get isCloserToHorizontal() {
+        const direction = this.direction;
+        return direction.angleTo(directions2d.Right) < Math.PI / 4 || direction.angleTo(directions2d.Left) < Math.PI / 4;
+    }
+    get isCloserToVertical() {
+        return !this.isCloserToHorizontal;
+    }
     /**
      * Project the line to 2D space. For start and end points Vec2.y becomes Vec3.z. and Vec3.y is provided as an argument.
      * @param y - The y value of the new Vec3 instance.

package/esm/Line3D.js

@@ -2,13 +2,15 @@ import { Line3 } from "three";
 import { Vec3 } from "./Vec3";
 import { Line2D } from "./Line2D";
 export class Line3D extends Line3 {
+    index;
     #target;
-    constructor(start, end) {
+    constructor(start, end, index = 0) {
         super(start, end);
+        this.index = index;
         this.#target = new Vec3();
     }
-    static fromPoints(start, end) {
-        return new Line3D(new Vec3(start.x, start.y, start.z), new Vec3(end.x, end.y, end.z));
+    static fromPoints(start, end, index = 0) {
+        return new Line3D(new Vec3(start.x, start.y, start.z), new Vec3(end.x, end.y, end.z), index);
     }
     /**
      * Creates a polygon formed by an array of lines from points provided.
@@ -24,7 +26,7 @@ export class Line3D extends Line3 {
         }
         const lines = [];
         for (let i = 0; i < polygon.length - 1; i++) {
-            lines.push(Line3D.fromPoints(polygon[i], polygon[i + 1]));
+            lines.push(Line3D.fromPoints(polygon[i], polygon[i + 1], i));
         }
         return lines;
     }
@@ -403,6 +405,41 @@ export class Line3D extends Line3 {
         const resultSegmentPoint2 = new Vec3((p3.x + mub * p43.x), (p3.y + mub * p43.y), (p3.z + mub * p43.z));
         return new Line3D(resultSegmentPoint1, resultSegmentPoint2);
     }
+    /**
+     * Accepts an array of Line3D and groups them into arrays of connected lines
+     * @param lines Lines to be grouped
+     * @param tolerance Tolerance for considering lines as connected
+     */
+    static groupConnectedLines(lines, tolerance = 0) {
+        const visited = new Set();
+        // Use graph-based approach. Each line can be considered as an edge in the graph, and the endpoints of the lines can be considered as vertices.
+        // Then use Depth-First Search (DFS) to find connected components in the graph.
+        const dfs = (line, group) => {
+            if (visited.has(line))
+                return;
+            visited.add(line);
+            group.push(line);
+            lines.forEach((neighbor) => {
+                if (!visited.has(neighbor)) {
+                    if ((line.start).isNear(neighbor.start, tolerance) ||
+                        (line.start).isNear(neighbor.end, tolerance) ||
+                        (line.end).isNear(neighbor.start, tolerance) ||
+                        (line.end).isNear(neighbor.end, tolerance)) {
+                        dfs(neighbor, group);
+                    }
+                }
+            });
+        };
+        const connectedLines = [];
+        lines.forEach((line) => {
+            if (!visited.has(line)) {
+                const group = [];
+                dfs(line, group);
+                connectedLines.push(group);
+            }
+        });
+        return connectedLines;
+    }
     /**
      * Project the line to 2D space, Y value is dropped
      */
@@ -419,7 +456,7 @@ export class Line3D extends Line3 {
      * Deep clone of this line
      */
     clone() {
-        return new Line3D(this.start.clone(), this.end.clone());
+        return new Line3D(this.start.clone(), this.end.clone(), this.index);
     }
     toString() {
         return `Line3D { start: ${this.start.x}, ${this.start.y}, ${this.start.z}, end: ${this.end.x}, ${this.end.y}, ${this.end.z}}`;

package/esm/directions.js

@@ -0,0 +1,9 @@
+import { Vec3 } from "./Vec3";
+export const directions = {
+    North: new Vec3(0, 0, -1),
+    South: new Vec3(0, 0, 1),
+    East: new Vec3(1, 0, 0),
+    West: new Vec3(-1, 0, 0),
+    Up: new Vec3(0, 1, 0),
+    Down: new Vec3(0, -1, 0)
+};

package/esm/directions2d.js

@@ -0,0 +1,7 @@
+import { Vec2 } from "./Vec2";
+export const directions2d = {
+    Up: new Vec2(0, -1),
+    Down: new Vec2(0, 1),
+    Left: new Vec2(-1, 0),
+    Right: new Vec2(1, 0)
+};

package/esm/index.js

@@ -10,3 +10,5 @@ export { normalizeAngleDegrees } from "./normalizeAngleDegrees";
 export { normalizeAngleRadians } from "./normalizeAngleRadians";
 export { TwoPI } from "./MathConstants";
 export { isPointInPolygon } from "./isPointInPolygon";
+export { directions } from "./directions";
+export { directions2d } from "./directions2d";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@immugio/three-math-extensions",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "description": "Set of utilities for 2d and 3d line math built on top of three.js",
   "author": "Jan Mikeska <janmikeska@gmail.com>",
   "license": "ISC",
@@ -33,19 +33,21 @@
     "postversion": "git push && git push --tags"
   },
   "devDependencies": {
-    "@types/jest": "^29.2.1",
+    "@types/jest": "^29.5.4",
     "@types/offscreencanvas": "2019.7.0",
-    "@types/three": "0.130.1",
+    "@types/three": "0.152.0",
+    "@typescript-eslint/eslint-plugin": "^6.5.0",
     "auto-changelog": "^2.4.0",
-    "jest": "^29.2.2",
+    "jest": "^29.6.4",
     "rimraf": "^3.0.2",
     "ts-jest": "^29.0.0",
     "typedoc": "^0.23.23",
     "typedoc-plugin-markdown": "^3.14.0",
-    "typescript": "4.9.5"
+    "typescript": "4.9.5",
+    "eslint": "^8.48.0"
   },
   "peerDependencies": {
-    "three": ">=0.130.1"
+    "three": "0.152.2"
   },
   "repository": {
     "type": "git",

package/src/Line2D.ts

@@ -4,6 +4,7 @@ import { Vec2 } from "./Vec2";
 import { MathUtils } from "three";
 import { TwoPI } from "./MathConstants";
 import { Line3D } from "./Line3D";
+import {directions2d} from "./directions2d";
 
 const _startP = /*@__PURE__*/ new Vec2();
 const _startEnd = /*@__PURE__*/ new Vec2();
@@ -368,6 +369,18 @@ export class Line2D {
         return result;
     }
 
+    /**
+     * Returns a new line that is the projection of this line onto @other. Uses `closestPointToPoint` to find the projection.
+     * @param other
+     * @param clampToLine
+     */
+    public projectOn(other: Line2D, clampToLine: boolean): Line2D {
+        const p1 = other.closestPointToPoint(this.start, clampToLine, new Vec2());
+        const p2 = other.closestPointToPoint(this.end, clampToLine, new Vec2());
+
+        return p1.distanceTo(this.start) < p2.distanceTo(this.start) ? new Line2D(p1, p2) : new Line2D(p2, p1);
+    }
+
     /**
      * Divides the Line3D into a number of segments of the given length.
      * Clone the line, does not modify.
@@ -660,6 +673,15 @@ export class Line2D {
         return null;
     }
 
+    public get isCloserToHorizontal(): boolean {
+        const direction = this.direction;
+        return direction.angleTo(directions2d.Right) < Math.PI / 4 || direction.angleTo(directions2d.Left) < Math.PI / 4;
+    }
+
+    public get isCloserToVertical(): boolean {
+        return !this.isCloserToHorizontal;
+    }
+
     /**
      * Project the line to 2D space. For start and end points Vec2.y becomes Vec3.z. and Vec3.y is provided as an argument.
      * @param y - The y value of the new Vec3 instance.

package/src/Line3D.ts

@@ -10,13 +10,13 @@ export class Line3D extends Line3 {
 
     readonly #target: Vec3;
 
-    constructor(start: Vec3, end: Vec3) {
+    constructor(start: Vec3, end: Vec3, public index: number = 0) {
         super(start, end);
         this.#target = new Vec3();
     }
 
-    public static fromPoints(start: Point3, end: Point3): Line3D {
-        return new Line3D(new Vec3(start.x, start.y, start.z), new Vec3(end.x, end.y, end.z));
+    public static fromPoints(start: Point3, end: Point3, index: number = 0): Line3D {
+        return new Line3D(new Vec3(start.x, start.y, start.z), new Vec3(end.x, end.y, end.z), index);
     }
 
     /**
@@ -35,7 +35,7 @@ export class Line3D extends Line3 {
 
         const lines: Line3D[] = [];
         for (let i = 0; i < polygon.length - 1; i++) {
-            lines.push(Line3D.fromPoints(polygon[i], polygon[i + 1]));
+            lines.push(Line3D.fromPoints(polygon[i], polygon[i + 1], i));
         }
 
         return lines;
@@ -502,6 +502,48 @@ export class Line3D extends Line3 {
         return new Line3D(resultSegmentPoint1, resultSegmentPoint2);
     }
 
+    /**
+     * Accepts an array of Line3D and groups them into arrays of connected lines
+     * @param lines Lines to be grouped
+     * @param tolerance Tolerance for considering lines as connected
+     */
+    public static groupConnectedLines(lines: Line3D[], tolerance: number = 0): Line3D[][] {
+        const visited: Set<Line3D> = new Set();
+
+        // Use graph-based approach. Each line can be considered as an edge in the graph, and the endpoints of the lines can be considered as vertices.
+        // Then use Depth-First Search (DFS) to find connected components in the graph.
+        const dfs = (line: Line3D, group: Line3D[]) => {
+            if (visited.has(line)) return;
+            visited.add(line);
+            group.push(line);
+
+            lines.forEach((neighbor) => {
+                if (!visited.has(neighbor)) {
+                    if (
+                        (line.start).isNear(neighbor.start, tolerance) ||
+                        (line.start).isNear(neighbor.end, tolerance) ||
+                        (line.end).isNear(neighbor.start, tolerance) ||
+                        (line.end).isNear(neighbor.end, tolerance)
+                    ) {
+                        dfs(neighbor, group);
+                    }
+                }
+            });
+        };
+
+        const connectedLines: Line3D[][] = [];
+
+        lines.forEach((line) => {
+            if (!visited.has(line)) {
+                const group: Line3D[] = [];
+                dfs(line, group);
+                connectedLines.push(group);
+            }
+        });
+
+        return connectedLines;
+    }
+
     /**
      * Project the line to 2D space, Y value is dropped
      */
@@ -520,7 +562,7 @@ export class Line3D extends Line3 {
      * Deep clone of this line
      */
     public clone(): this {
-        return new Line3D(this.start.clone(), this.end.clone()) as this;
+        return new Line3D(this.start.clone(), this.end.clone(), this.index) as this;
     }
 
     public toString(): string {

package/src/Vec2.ts

@@ -1,7 +1,7 @@
-import { Vector2 } from "three";
-import { Vec3 } from "./Vec3";
-import { Point2 } from "./Point2";
-import { normalizeAngleRadians } from "./normalizeAngleRadians";
+import {Vector2} from "three";
+import {Vec3} from "./Vec3";
+import {Point2} from "./Point2";
+import {normalizeAngleRadians} from "./normalizeAngleRadians";
 
 /**
  * Vec2 represents a 2D vector. It extends `Vector2` from the `threejs` library.

package/src/directions.ts

@@ -0,0 +1,10 @@
+import { Vec3 } from "./Vec3";
+
+export const directions = {
+    North: new Vec3(0, 0, -1),
+    South: new Vec3(0, 0, 1),
+    East: new Vec3(1, 0, 0),
+    West: new Vec3(-1, 0, 0),
+    Up: new Vec3(0, 1, 0),
+    Down: new Vec3(0, -1, 0)
+};

package/src/directions2d.ts

@@ -0,0 +1,8 @@
+import { Vec2 } from "./Vec2";
+
+export const directions2d = {
+    Up: new Vec2(0, -1),
+    Down: new Vec2(0, 1),
+    Left: new Vec2(-1, 0),
+    Right: new Vec2(1, 0)
+};

package/src/index.ts

@@ -11,4 +11,6 @@ export { normalizeAngleRadians } from "./normalizeAngleRadians";
 export { TwoPI } from "./MathConstants";
 export { Point2 } from "./Point2";
 export { Point3 } from "./Point3";
-export { isPointInPolygon } from "./isPointInPolygon";
+export { isPointInPolygon } from "./isPointInPolygon";
+export { directions } from "./directions";
+export { directions2d } from "./directions2d";

package/types/Line2D.d.ts

@@ -138,6 +138,12 @@ export declare class Line2D {
      * @param lines
      */
     static joinLines(lines: Line2D[]): Line2D[];
+    /**
+     * Returns a new line that is the projection of this line onto @other. Uses `closestPointToPoint` to find the projection.
+     * @param other
+     * @param clampToLine
+     */
+    projectOn(other: Line2D, clampToLine: boolean): Line2D;
     /**
      * Divides the Line3D into a number of segments of the given length.
      * Clone the line, does not modify.
@@ -212,6 +218,8 @@ export declare class Line2D {
      * @param distanceTolerance number
      */
     hasIntersectionWithAngle(other: Line2D, expectedAngleInRads: number, angleTolerance?: number, distanceTolerance?: number): Vec2;
+    get isCloserToHorizontal(): boolean;
+    get isCloserToVertical(): boolean;
     /**
      * Project the line to 2D space. For start and end points Vec2.y becomes Vec3.z. and Vec3.y is provided as an argument.
      * @param y - The y value of the new Vec3 instance.

package/types/Line3D.d.ts

@@ -4,10 +4,11 @@ import { Point3 } from "./Point3";
 import { Line2D } from "./Line2D";
 export declare class Line3D extends Line3 {
     #private;
+    index: number;
     start: Vec3;
     end: Vec3;
-    constructor(start: Vec3, end: Vec3);
-    static fromPoints(start: Point3, end: Point3): Line3D;
+    constructor(start: Vec3, end: Vec3, index?: number);
+    static fromPoints(start: Point3, end: Point3, index?: number): Line3D;
     /**
      * Creates a polygon formed by an array of lines from points provided.
      * The polygon will only be closed if either
@@ -145,6 +146,12 @@ export declare class Line3D extends Line3 {
      * @param other
      */
     intersect(other: Line3D): Line3D;
+    /**
+     * Accepts an array of Line3D and groups them into arrays of connected lines
+     * @param lines Lines to be grouped
+     * @param tolerance Tolerance for considering lines as connected
+     */
+    static groupConnectedLines(lines: Line3D[], tolerance?: number): Line3D[][];
     /**
      * Project the line to 2D space, Y value is dropped
      */

package/types/directions.d.ts

@@ -0,0 +1,9 @@
+import { Vec3 } from "./Vec3";
+export declare const directions: {
+    North: Vec3;
+    South: Vec3;
+    East: Vec3;
+    West: Vec3;
+    Up: Vec3;
+    Down: Vec3;
+};

package/types/directions2d.d.ts

@@ -0,0 +1,7 @@
+import { Vec2 } from "./Vec2";
+export declare const directions2d: {
+    Up: Vec2;
+    Down: Vec2;
+    Left: Vec2;
+    Right: Vec2;
+};

package/types/index.d.ts

@@ -12,3 +12,5 @@ export { TwoPI } from "./MathConstants";
 export { Point2 } from "./Point2";
 export { Point3 } from "./Point3";
 export { isPointInPolygon } from "./isPointInPolygon";
+export { directions } from "./directions";
+export { directions2d } from "./directions2d";