@immugio/three-math-extensions 0.2.13 → 0.2.15

package/CHANGELOG.md

@@ -7,16 +7,18 @@ 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.13](https://github.com/Immugio/three-math-extensions/compare/16.15.10...0.2.13)
+## [0.2.15](https://github.com/Immugio/three-math-extensions/compare/16.15.10...0.2.15)
 
 ### Commits
 
+- Packages update [`0d85b39`](https://github.com/Immugio/three-math-extensions/commit/0d85b392029f7bbaa5063cd0494e34f593d62ea5)
 - 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)
+- Add isContinuousClosedShape, add Line2D.groupConnectedLines [`4ef8c2f`](https://github.com/Immugio/three-math-extensions/commit/4ef8c2fe83fdc71dd87fee4cbc478ddf0a086442)
 - 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)
@@ -27,6 +29,7 @@ Generated by [`auto-changelog`](https://github.com/CookPete/auto-changelog).
 - 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)
+- Line3D.groupConnectedLines now supports line breaks [`417a9ea`](https://github.com/Immugio/three-math-extensions/commit/417a9ea471bf4c539f73f5fb170c962a78ee4ab4)
 - 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)
@@ -39,10 +42,23 @@ Generated by [`auto-changelog`](https://github.com/CookPete/auto-changelog).
 - 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)
+- Add HalfPI [`7a6614c`](https://github.com/Immugio/three-math-extensions/commit/7a6614c3d6f59ac216e58986927112f94207a755)
 - 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.12...16.15.10) - 2023-01-02
+## [16.15.10](https://github.com/Immugio/three-math-extensions/compare/0.2.14...16.15.10) - 2023-01-02
+
+## [0.2.14](https://github.com/Immugio/three-math-extensions/compare/0.2.13...0.2.14) - 2023-08-31
+
+### Commits
+
+- Line3D.groupConnectedLines now supports line breaks [`417a9ea`](https://github.com/Immugio/three-math-extensions/commit/417a9ea471bf4c539f73f5fb170c962a78ee4ab4)
+
+## [0.2.13](https://github.com/Immugio/three-math-extensions/compare/0.2.12...0.2.13) - 2023-08-31
+
+### Commits
+
+- Line3D.connectsTo added [`6d2cfa0`](https://github.com/Immugio/three-math-extensions/commit/6d2cfa0f5335c665f325a694a32c57b574ec326d)
 
 ## [0.2.12](https://github.com/Immugio/three-math-extensions/compare/0.2.11...0.2.12) - 2023-08-30
 
@@ -214,15 +230,62 @@ Generated by [`auto-changelog`](https://github.com/CookPete/auto-changelog).
 
 ## [0.0.7](https://github.com/Immugio/three-math-extensions/compare/0.0.6...0.0.7) - 2022-11-21
 
-## [0.0.6](https://github.com/Immugio/three-math-extensions/compare/0.0.4...0.0.6) - 2022-11-24
+## [0.0.6](https://github.com/Immugio/three-math-extensions/compare/0.0.5...0.0.6) - 2022-11-24
+
+## [0.0.5](https://github.com/Immugio/three-math-extensions/compare/0.0.4...0.0.5) - 2023-09-01
 
 ### Commits
 
+- Generate documentation using TSDoc [`304c3a8`](https://github.com/Immugio/three-math-extensions/commit/304c3a84b5dcc49183db57083f550d134ae641b2)
+- 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)
 - Improve API, minor bug fix, improve test coverage [`881a5f0`](https://github.com/Immugio/three-math-extensions/commit/881a5f096823f0d5fd90faa76cd602f076291bc5)
+- 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 intersect method to Line3D [`6fe47de`](https://github.com/Immugio/three-math-extensions/commit/6fe47de7caaa1807b47a4363e551510c463757d7)
+- Add Line2D.extendToOrTrimAtIntersection [`ab82a36`](https://github.com/Immugio/three-math-extensions/commit/ab82a36db52b9ae83cf8bfb848362d295140d073)
+- Add Vec2.fromPoints to accept multiple points [`a261402`](https://github.com/Immugio/three-math-extensions/commit/a2614027cf5fb8263189b48f7e0bb9a23a552c15)
+- Improve documentation for Vec2 and Vec3 [`6a2373d`](https://github.com/Immugio/three-math-extensions/commit/6a2373d8b6754a87720dcaea5d98336bfa7bc5b5)
+- 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)
+- Line3D.groupConnectedLines now supports line breaks [`417a9ea`](https://github.com/Immugio/three-math-extensions/commit/417a9ea471bf4c539f73f5fb170c962a78ee4ab4)
+- Add Line2D.projectOn [`4c52c5c`](https://github.com/Immugio/three-math-extensions/commit/4c52c5c2e649fbddb72ce3fca60cfd3f1319f72f)
+- Added "isNear" to Vec2 & Vec3 as a shorthand for distanceTo <= maxDistance [`a27cff8`](https://github.com/Immugio/three-math-extensions/commit/a27cff8421472f625ed240439b9e6a7d2c430db8)
+- Add Line3D.index [`7ed13d2`](https://github.com/Immugio/three-math-extensions/commit/7ed13d213748056c9dafd86288c3bcec9a28d1ba)
 - Add .npmignore [`f58329a`](https://github.com/Immugio/three-math-extensions/commit/f58329a86b96589bb574d6ebed37d4cc4474663a)
+- Polygon from bounding size [`eae6701`](https://github.com/Immugio/three-math-extensions/commit/eae67012f57f426f8b5259b765000447ce06d608)
+- Add Vec2 documentation [`f625e66`](https://github.com/Immugio/three-math-extensions/commit/f625e66b60ee0d90c5c788a80989f64013d60265)
+- Clean up documentation [`70c8d5e`](https://github.com/Immugio/three-math-extensions/commit/70c8d5efe8b7095d7a03af637df3af5d46615293)
+- 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)
+- Line3D.connectsTo added [`6d2cfa0`](https://github.com/Immugio/three-math-extensions/commit/6d2cfa0f5335c665f325a694a32c57b574ec326d)
+- Line2D.hasIntersectionWithAngle to support optional tolerance [`b313bbe`](https://github.com/Immugio/three-math-extensions/commit/b313bbe118d435d53750deefd9a9e29ba6ec5c71)
+- Add Vec2.moveTowards [`b46ba12`](https://github.com/Immugio/three-math-extensions/commit/b46ba1286f9924cd9bfecfb37200664202e964ba)
+- 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)
+- Add release instructions into README.md [`03653b1`](https://github.com/Immugio/three-math-extensions/commit/03653b1ffa55be606d3f9cd588e28a6084462c2e)
+- Documentation improvements [`160db8b`](https://github.com/Immugio/three-math-extensions/commit/160db8ba6d6e5eb63a4e91ed9c40efd6fa70181a)
+- 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 improvements [`2f3e676`](https://github.com/Immugio/three-math-extensions/commit/2f3e6768b3b0139b60688fc151a4084f15566f8d)
+- Documentation update [`d5c7a07`](https://github.com/Immugio/three-math-extensions/commit/d5c7a0765f6097f5d3a3be01967d4059f19682fb)
+- Fix peer dependency version [`00dd116`](https://github.com/Immugio/three-math-extensions/commit/00dd1169f578d5769207031fa625f29c96a38c31)
+- Add Line2D.extendToOrTrimAtIntersection [`b22aa12`](https://github.com/Immugio/three-math-extensions/commit/b22aa120b5eb02562cebc4573374ebb61e2dba14)
 - Correct change log version [`c6244bf`](https://github.com/Immugio/three-math-extensions/commit/c6244bf1488ad21bcc5589d1dff62c41d8182d48)
 - Release 0.0.4 - tag pattern 6 [`c1c5454`](https://github.com/Immugio/three-math-extensions/commit/c1c54541ed400e1ad49bf42fe8926cd5293efefd)
 - Release 0.0.4 - tag pattern 5 [`5245eed`](https://github.com/Immugio/three-math-extensions/commit/5245eed60195103e989c0fadf9bd642f39ef4589)
+- Excluded files from build [`ec70614`](https://github.com/Immugio/three-math-extensions/commit/ec70614bc7df7a98f854c7a6693365118e04faf7)
+- Revert npm ignore [`590b26a`](https://github.com/Immugio/three-math-extensions/commit/590b26a9e57fc41466b51e711f3f5c648e2d56ed)
 
 ## 0.0.4 - 2022-11-21
 

package/cjs/Line2D.js

@@ -580,6 +580,51 @@ class Line2D {
     get isCloserToVertical() {
         return !this.isCloserToHorizontal;
     }
+    /**
+     * Accepts an array of Line2D and groups them into arrays of connected lines
+     * @param lines Lines to be grouped
+     * @param tolerance Tolerance for considering lines as connected
+     * @param breakpoints
+     */
+    static groupConnectedLines(lines, tolerance = 0, breakpoints = []) {
+        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.connectsTo(neighbor, tolerance, breakpoints)) {
+                        dfs(neighbor, group);
+                    }
+                }
+            });
+        };
+        const connectedLines = [];
+        lines.forEach((line) => {
+            if (!visited.has(line)) {
+                const group = [];
+                dfs(line, group);
+                connectedLines.push(group);
+            }
+        });
+        return connectedLines;
+    }
+    /**
+     * Returns true if any endpoint of this line is within the tolerance of any @other line's endpoints.
+     * @param other
+     * @param tolerance
+     * @param breakpoints
+     */
+    connectsTo(other, tolerance = 0, breakpoints = []) {
+        return ((this.start.isNear(other.start, tolerance) && breakpoints.every(b => !b.isNear(this.start, tolerance))) ||
+            (this.start.isNear(other.end, tolerance) && breakpoints.every(b => !b.isNear(this.start, tolerance))) ||
+            (this.end.isNear(other.start, tolerance) && breakpoints.every(b => !b.isNear(this.end, tolerance))) ||
+            (this.end.isNear(other.end, tolerance) && breakpoints.every(b => !b.isNear(this.end, tolerance))));
+    }
     /**
      * 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

@@ -371,8 +371,8 @@ class Line3D extends three_1.Line3 {
     }
     /**
      * Calculates the intersection between this and `other` line. The lines are assumed to be infinite.
-     * In a lot of cases an actual intersection cannot be calculated due to rounding errors.
-     * Therefore, the intersection calculated by this method comes in a form of the shorted possible line segment connecting the two lines.
+     * In a lot of cases, an actual intersection cannot be calculated due to rounding errors.
+     * Therefore, the intersection calculated by this method comes in the form of the shorted possible line segment connecting the two lines.
      * Sources:
      * http://paulbourke.net/geometry/pointlineplane/
      * https://stackoverflow.com/questions/2316490/the-algorithm-to-find-the-point-of-intersection-of-two-3d-line-segment/2316934#2316934
@@ -412,8 +412,9 @@ class Line3D extends three_1.Line3 {
      * 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
+     * @param breakpoints
      */
-    static groupConnectedLines(lines, tolerance = 0) {
+    static groupConnectedLines(lines, tolerance = 0, breakpoints = []) {
         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.
@@ -424,7 +425,7 @@ class Line3D extends three_1.Line3 {
             group.push(line);
             lines.forEach((neighbor) => {
                 if (!visited.has(neighbor)) {
-                    if (line.connectsTo(neighbor, tolerance)) {
+                    if (line.connectsTo(neighbor, tolerance, breakpoints)) {
                         dfs(neighbor, group);
                     }
                 }
@@ -441,15 +442,16 @@ class Line3D extends three_1.Line3 {
         return connectedLines;
     }
     /**
-     * Returns true if any endpoint of this line if within the tolerance distance of any endpoint of the @other line.
+     * Returns true if any endpoint of this line is within the tolerance of any @other line's endpoints.
      * @param other
      * @param tolerance
+     * @param breakpoints
      */
-    connectsTo(other, tolerance = 0) {
-        return this.start.isNear(other.start, tolerance) ||
-            this.start.isNear(other.end, tolerance) ||
-            this.end.isNear(other.start, tolerance) ||
-            this.end.isNear(other.end, tolerance);
+    connectsTo(other, tolerance = 0, breakpoints = []) {
+        return ((this.start.isNear(other.start, tolerance) && breakpoints.every(b => !b.isNear(this.start, tolerance))) ||
+            (this.start.isNear(other.end, tolerance) && breakpoints.every(b => !b.isNear(this.start, tolerance))) ||
+            (this.end.isNear(other.start, tolerance) && breakpoints.every(b => !b.isNear(this.end, tolerance))) ||
+            (this.end.isNear(other.end, tolerance) && breakpoints.every(b => !b.isNear(this.end, tolerance))));
     }
     /**
      * Project the line to 2D space, Y value is dropped

package/cjs/MathConstants.js

@@ -1,4 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TwoPI = void 0;
+exports.HalfPI = exports.TwoPI = void 0;
 exports.TwoPI = 2 * Math.PI;
+exports.HalfPI = Math.PI / 2;

package/cjs/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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;
+exports.isContinuousClosedShape = exports.directions2d = exports.directions = exports.isPointInPolygon = exports.HalfPI = 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");
@@ -23,9 +23,12 @@ var normalizeAngleRadians_1 = require("./normalizeAngleRadians");
 Object.defineProperty(exports, "normalizeAngleRadians", { enumerable: true, get: function () { return normalizeAngleRadians_1.normalizeAngleRadians; } });
 var MathConstants_1 = require("./MathConstants");
 Object.defineProperty(exports, "TwoPI", { enumerable: true, get: function () { return MathConstants_1.TwoPI; } });
+Object.defineProperty(exports, "HalfPI", { enumerable: true, get: function () { return MathConstants_1.HalfPI; } });
 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; } });
+var isContinuousClosedShape_1 = require("./isContinuousClosedShape");
+Object.defineProperty(exports, "isContinuousClosedShape", { enumerable: true, get: function () { return isContinuousClosedShape_1.isContinuousClosedShape; } });

package/cjs/isContinuousClosedShape.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isContinuousClosedShape = void 0;
+function isContinuousClosedShape(lines, tolerance = 0) {
+    if (lines.length < 3) {
+        return false; // A shape needs at least 3 lines to be closed
+    }
+    // Starting from the first line, check if the end of the current line is the start of the next line
+    for (let i = 0; i < lines.length - 1; i++) {
+        const endCurrent = lines[i].end;
+        const startNext = lines[i + 1].start;
+        if (!endCurrent.isNear(startNext, tolerance)) {
+            return false; // If the end of the current line and start of the next line are not close, return false
+        }
+    }
+    // Lastly, we should check the end of the last line with the start of the first line
+    const endLast = lines[lines.length - 1].end;
+    const startFirst = lines[0].start;
+    return endLast.isNear(startFirst, tolerance);
+}
+exports.isContinuousClosedShape = isContinuousClosedShape;

package/esm/Line2D.js

@@ -577,6 +577,51 @@ export class Line2D {
     get isCloserToVertical() {
         return !this.isCloserToHorizontal;
     }
+    /**
+     * Accepts an array of Line2D and groups them into arrays of connected lines
+     * @param lines Lines to be grouped
+     * @param tolerance Tolerance for considering lines as connected
+     * @param breakpoints
+     */
+    static groupConnectedLines(lines, tolerance = 0, breakpoints = []) {
+        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.connectsTo(neighbor, tolerance, breakpoints)) {
+                        dfs(neighbor, group);
+                    }
+                }
+            });
+        };
+        const connectedLines = [];
+        lines.forEach((line) => {
+            if (!visited.has(line)) {
+                const group = [];
+                dfs(line, group);
+                connectedLines.push(group);
+            }
+        });
+        return connectedLines;
+    }
+    /**
+     * Returns true if any endpoint of this line is within the tolerance of any @other line's endpoints.
+     * @param other
+     * @param tolerance
+     * @param breakpoints
+     */
+    connectsTo(other, tolerance = 0, breakpoints = []) {
+        return ((this.start.isNear(other.start, tolerance) && breakpoints.every(b => !b.isNear(this.start, tolerance))) ||
+            (this.start.isNear(other.end, tolerance) && breakpoints.every(b => !b.isNear(this.start, tolerance))) ||
+            (this.end.isNear(other.start, tolerance) && breakpoints.every(b => !b.isNear(this.end, tolerance))) ||
+            (this.end.isNear(other.end, tolerance) && breakpoints.every(b => !b.isNear(this.end, tolerance))));
+    }
     /**
      * 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

@@ -368,8 +368,8 @@ export class Line3D extends Line3 {
     }
     /**
      * Calculates the intersection between this and `other` line. The lines are assumed to be infinite.
-     * In a lot of cases an actual intersection cannot be calculated due to rounding errors.
-     * Therefore, the intersection calculated by this method comes in a form of the shorted possible line segment connecting the two lines.
+     * In a lot of cases, an actual intersection cannot be calculated due to rounding errors.
+     * Therefore, the intersection calculated by this method comes in the form of the shorted possible line segment connecting the two lines.
      * Sources:
      * http://paulbourke.net/geometry/pointlineplane/
      * https://stackoverflow.com/questions/2316490/the-algorithm-to-find-the-point-of-intersection-of-two-3d-line-segment/2316934#2316934
@@ -409,8 +409,9 @@ export class Line3D extends Line3 {
      * 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
+     * @param breakpoints
      */
-    static groupConnectedLines(lines, tolerance = 0) {
+    static groupConnectedLines(lines, tolerance = 0, breakpoints = []) {
         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.
@@ -421,7 +422,7 @@ export class Line3D extends Line3 {
             group.push(line);
             lines.forEach((neighbor) => {
                 if (!visited.has(neighbor)) {
-                    if (line.connectsTo(neighbor, tolerance)) {
+                    if (line.connectsTo(neighbor, tolerance, breakpoints)) {
                         dfs(neighbor, group);
                     }
                 }
@@ -438,15 +439,16 @@ export class Line3D extends Line3 {
         return connectedLines;
     }
     /**
-     * Returns true if any endpoint of this line if within the tolerance distance of any endpoint of the @other line.
+     * Returns true if any endpoint of this line is within the tolerance of any @other line's endpoints.
      * @param other
      * @param tolerance
+     * @param breakpoints
      */
-    connectsTo(other, tolerance = 0) {
-        return this.start.isNear(other.start, tolerance) ||
-            this.start.isNear(other.end, tolerance) ||
-            this.end.isNear(other.start, tolerance) ||
-            this.end.isNear(other.end, tolerance);
+    connectsTo(other, tolerance = 0, breakpoints = []) {
+        return ((this.start.isNear(other.start, tolerance) && breakpoints.every(b => !b.isNear(this.start, tolerance))) ||
+            (this.start.isNear(other.end, tolerance) && breakpoints.every(b => !b.isNear(this.start, tolerance))) ||
+            (this.end.isNear(other.start, tolerance) && breakpoints.every(b => !b.isNear(this.end, tolerance))) ||
+            (this.end.isNear(other.end, tolerance) && breakpoints.every(b => !b.isNear(this.end, tolerance))));
     }
     /**
      * Project the line to 2D space, Y value is dropped

package/esm/MathConstants.js

@@ -1 +1,2 @@
 export const TwoPI = 2 * Math.PI;
+export const HalfPI = Math.PI / 2;

package/esm/index.js

@@ -8,7 +8,8 @@ export { BoundingBox } from "./BoundingBox";
 export { Rectangle } from "./Rectangle";
 export { normalizeAngleDegrees } from "./normalizeAngleDegrees";
 export { normalizeAngleRadians } from "./normalizeAngleRadians";
-export { TwoPI } from "./MathConstants";
+export { TwoPI, HalfPI } from "./MathConstants";
 export { isPointInPolygon } from "./isPointInPolygon";
 export { directions } from "./directions";
 export { directions2d } from "./directions2d";
+export { isContinuousClosedShape } from "./isContinuousClosedShape";

package/esm/isContinuousClosedShape.js

@@ -0,0 +1,17 @@
+export function isContinuousClosedShape(lines, tolerance = 0) {
+    if (lines.length < 3) {
+        return false; // A shape needs at least 3 lines to be closed
+    }
+    // Starting from the first line, check if the end of the current line is the start of the next line
+    for (let i = 0; i < lines.length - 1; i++) {
+        const endCurrent = lines[i].end;
+        const startNext = lines[i + 1].start;
+        if (!endCurrent.isNear(startNext, tolerance)) {
+            return false; // If the end of the current line and start of the next line are not close, return false
+        }
+    }
+    // Lastly, we should check the end of the last line with the start of the first line
+    const endLast = lines[lines.length - 1].end;
+    const startFirst = lines[0].start;
+    return endLast.isNear(startFirst, tolerance);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@immugio/three-math-extensions",
-  "version": "0.2.13",
+  "version": "0.2.15",
   "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,18 +33,18 @@
     "postversion": "git push && git push --tags"
   },
   "devDependencies": {
-    "@types/jest": "^29.5.4",
-    "@types/offscreencanvas": "2019.7.0",
+    "@types/jest": "^29.5.5",
+    "@types/offscreencanvas": "2019.7.1",
     "@types/three": "0.152.0",
-    "@typescript-eslint/eslint-plugin": "^6.5.0",
+    "@typescript-eslint/eslint-plugin": "^6.7.5",
     "auto-changelog": "^2.4.0",
-    "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",
-    "eslint": "^8.48.0"
+    "jest": "^29.7.0",
+    "rimraf": "^5.0.5",
+    "ts-jest": "^29.1.1",
+    "typedoc": "^0.25.2",
+    "typedoc-plugin-markdown": "^3.16.0",
+    "typescript": "5.2.2",
+    "eslint": "^8.51.0"
   },
   "peerDependencies": {
     "three": "0.152.2"

package/src/Line2D.ts

@@ -682,6 +682,61 @@ export class Line2D {
         return !this.isCloserToHorizontal;
     }
 
+    /**
+     * Accepts an array of Line2D and groups them into arrays of connected lines
+     * @param lines Lines to be grouped
+     * @param tolerance Tolerance for considering lines as connected
+     * @param breakpoints
+     */
+    public static groupConnectedLines(lines: Line2D[], tolerance: number = 0, breakpoints: Vec2[] = []): Line2D[][] {
+        const visited: Set<Line2D> = 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: Line2D, group: Line2D[]) => {
+            if (visited.has(line)) return;
+            visited.add(line);
+            group.push(line);
+
+            lines.forEach((neighbor) => {
+                if (!visited.has(neighbor)) {
+                    if (
+                        line.connectsTo(neighbor, tolerance, breakpoints)
+                    ) {
+                        dfs(neighbor, group);
+                    }
+                }
+            });
+        };
+
+        const connectedLines: Line2D[][] = [];
+
+        lines.forEach((line) => {
+            if (!visited.has(line)) {
+                const group: Line2D[] = [];
+                dfs(line, group);
+                connectedLines.push(group);
+            }
+        });
+
+        return connectedLines;
+    }
+
+    /**
+     * Returns true if any endpoint of this line is within the tolerance of any @other line's endpoints.
+     * @param other
+     * @param tolerance
+     * @param breakpoints
+     */
+    public connectsTo(other: Line2D, tolerance: number = 0, breakpoints: typeof other.start[] = []): boolean {
+        return (
+            (this.start.isNear(other.start, tolerance) && breakpoints.every(b => !b.isNear(this.start, tolerance))) ||
+            (this.start.isNear(other.end, tolerance) && breakpoints.every(b => !b.isNear(this.start, tolerance))) ||
+            (this.end.isNear(other.start, tolerance) && breakpoints.every(b => !b.isNear(this.end, tolerance))) ||
+            (this.end.isNear(other.end, tolerance) && breakpoints.every(b => !b.isNear(this.end, tolerance)))
+        );
+    }
+
     /**
      * 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

@@ -446,8 +446,8 @@ export class Line3D extends Line3 {
 
     /**
      * Calculates the intersection between this and `other` line. The lines are assumed to be infinite.
-     * In a lot of cases an actual intersection cannot be calculated due to rounding errors.
-     * Therefore, the intersection calculated by this method comes in a form of the shorted possible line segment connecting the two lines.
+     * In a lot of cases, an actual intersection cannot be calculated due to rounding errors.
+     * Therefore, the intersection calculated by this method comes in the form of the shorted possible line segment connecting the two lines.
      * Sources:
      * http://paulbourke.net/geometry/pointlineplane/
      * https://stackoverflow.com/questions/2316490/the-algorithm-to-find-the-point-of-intersection-of-two-3d-line-segment/2316934#2316934
@@ -506,8 +506,9 @@ export class Line3D extends Line3 {
      * 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
+     * @param breakpoints
      */
-    public static groupConnectedLines(lines: Line3D[], tolerance: number = 0): Line3D[][] {
+    public static groupConnectedLines(lines: Line3D[], tolerance: number = 0, breakpoints: Vec3[] = []): 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.
@@ -520,7 +521,7 @@ export class Line3D extends Line3 {
             lines.forEach((neighbor) => {
                 if (!visited.has(neighbor)) {
                     if (
-                        line.connectsTo(neighbor, tolerance)
+                        line.connectsTo(neighbor, tolerance, breakpoints)
                     ) {
                         dfs(neighbor, group);
                     }
@@ -542,15 +543,18 @@ export class Line3D extends Line3 {
     }
 
     /**
-     * Returns true if any endpoint of this line if within the tolerance distance of any endpoint of the @other line.
+     * Returns true if any endpoint of this line is within the tolerance of any @other line's endpoints.
      * @param other
      * @param tolerance
+     * @param breakpoints
      */
-    public connectsTo(other: Line3D, tolerance: number = 0): boolean {
-        return this.start.isNear(other.start, tolerance) ||
-            this.start.isNear(other.end, tolerance) ||
-            this.end.isNear(other.start, tolerance) ||
-            this.end.isNear(other.end, tolerance);
+    public connectsTo(other: Line3D, tolerance: number = 0, breakpoints: Vec3[] = []): boolean {
+        return (
+            (this.start.isNear(other.start, tolerance) && breakpoints.every(b => !b.isNear(this.start, tolerance))) ||
+            (this.start.isNear(other.end, tolerance) && breakpoints.every(b => !b.isNear(this.start, tolerance))) ||
+            (this.end.isNear(other.start, tolerance) && breakpoints.every(b => !b.isNear(this.end, tolerance))) ||
+            (this.end.isNear(other.end, tolerance) && breakpoints.every(b => !b.isNear(this.end, tolerance)))
+        );
     }
 
     /**

package/src/MathConstants.ts

@@ -1 +1,2 @@
-export const TwoPI = 2 * Math.PI;
+export const TwoPI = 2 * Math.PI;
+export const HalfPI = Math.PI / 2;

package/src/index.ts

@@ -8,9 +8,10 @@ export { BoundingBox } from "./BoundingBox";
 export { Rectangle } from "./Rectangle";
 export { normalizeAngleDegrees } from "./normalizeAngleDegrees";
 export { normalizeAngleRadians } from "./normalizeAngleRadians";
-export { TwoPI } from "./MathConstants";
+export { TwoPI, HalfPI } from "./MathConstants";
 export { Point2 } from "./Point2";
 export { Point3 } from "./Point3";
 export { isPointInPolygon } from "./isPointInPolygon";
 export { directions } from "./directions";
-export { directions2d } from "./directions2d";
+export { directions2d } from "./directions2d";
+export { isContinuousClosedShape } from "./isContinuousClosedShape";

package/src/isContinuousClosedShape.ts

@@ -0,0 +1,24 @@
+import { Line3D } from "./Line3D";
+import { Line2D } from "./Line2D";
+
+export function isContinuousClosedShape<T extends Line2D | Line3D>(lines: T[], tolerance: number = 0): boolean {
+    if (lines.length < 3) {
+        return false; // A shape needs at least 3 lines to be closed
+    }
+
+    // Starting from the first line, check if the end of the current line is the start of the next line
+    for (let i = 0; i < lines.length - 1; i++) {
+        const endCurrent = lines[i].end;
+        const startNext = lines[i + 1].start;
+
+        if (!endCurrent.isNear(startNext as any, tolerance)) {
+            return false; // If the end of the current line and start of the next line are not close, return false
+        }
+    }
+
+    // Lastly, we should check the end of the last line with the start of the first line
+    const endLast = lines[lines.length - 1].end;
+    const startFirst = lines[0].start;
+
+    return endLast.isNear(startFirst as any, tolerance);
+}

package/types/Line2D.d.ts

@@ -220,6 +220,20 @@ export declare class Line2D {
     hasIntersectionWithAngle(other: Line2D, expectedAngleInRads: number, angleTolerance?: number, distanceTolerance?: number): Vec2;
     get isCloserToHorizontal(): boolean;
     get isCloserToVertical(): boolean;
+    /**
+     * Accepts an array of Line2D and groups them into arrays of connected lines
+     * @param lines Lines to be grouped
+     * @param tolerance Tolerance for considering lines as connected
+     * @param breakpoints
+     */
+    static groupConnectedLines(lines: Line2D[], tolerance?: number, breakpoints?: Vec2[]): Line2D[][];
+    /**
+     * Returns true if any endpoint of this line is within the tolerance of any @other line's endpoints.
+     * @param other
+     * @param tolerance
+     * @param breakpoints
+     */
+    connectsTo(other: Line2D, tolerance?: number, breakpoints?: typeof other.start[]): 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

@@ -138,8 +138,8 @@ export declare class Line3D extends Line3 {
     translate(p: Vector3): this;
     /**
      * Calculates the intersection between this and `other` line. The lines are assumed to be infinite.
-     * In a lot of cases an actual intersection cannot be calculated due to rounding errors.
-     * Therefore, the intersection calculated by this method comes in a form of the shorted possible line segment connecting the two lines.
+     * In a lot of cases, an actual intersection cannot be calculated due to rounding errors.
+     * Therefore, the intersection calculated by this method comes in the form of the shorted possible line segment connecting the two lines.
      * Sources:
      * http://paulbourke.net/geometry/pointlineplane/
      * https://stackoverflow.com/questions/2316490/the-algorithm-to-find-the-point-of-intersection-of-two-3d-line-segment/2316934#2316934
@@ -150,14 +150,16 @@ export declare class Line3D extends Line3 {
      * 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
+     * @param breakpoints
      */
-    static groupConnectedLines(lines: Line3D[], tolerance?: number): Line3D[][];
+    static groupConnectedLines(lines: Line3D[], tolerance?: number, breakpoints?: Vec3[]): Line3D[][];
     /**
-     * Returns true if any endpoint of this line if within the tolerance distance of any endpoint of the @other line.
+     * Returns true if any endpoint of this line is within the tolerance of any @other line's endpoints.
      * @param other
      * @param tolerance
+     * @param breakpoints
      */
-    connectsTo(other: Line3D, tolerance?: number): boolean;
+    connectsTo(other: Line3D, tolerance?: number, breakpoints?: Vec3[]): boolean;
     /**
      * Project the line to 2D space, Y value is dropped
      */

package/types/MathConstants.d.ts

@@ -1 +1,2 @@
 export declare const TwoPI: number;
+export declare const HalfPI: number;

package/types/index.d.ts

@@ -8,9 +8,10 @@ export { BoundingBox } from "./BoundingBox";
 export { Rectangle } from "./Rectangle";
 export { normalizeAngleDegrees } from "./normalizeAngleDegrees";
 export { normalizeAngleRadians } from "./normalizeAngleRadians";
-export { TwoPI } from "./MathConstants";
+export { TwoPI, HalfPI } from "./MathConstants";
 export { Point2 } from "./Point2";
 export { Point3 } from "./Point3";
 export { isPointInPolygon } from "./isPointInPolygon";
 export { directions } from "./directions";
 export { directions2d } from "./directions2d";
+export { isContinuousClosedShape } from "./isContinuousClosedShape";

package/types/isContinuousClosedShape.d.ts

@@ -0,0 +1,3 @@
+import { Line3D } from "./Line3D";
+import { Line2D } from "./Line2D";
+export declare function isContinuousClosedShape<T extends Line2D | Line3D>(lines: T[], tolerance?: number): boolean;