@immugio/three-math-extensions 0.2.30 → 0.2.32

package/CHANGELOG.md

@@ -7,7 +7,20 @@ 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.30](https://github.com/Immugio/three-math-extensions/compare/0.2.29...0.2.30)
+## [0.2.32](https://github.com/Immugio/three-math-extensions/compare/0.2.31...0.2.32)
+
+### Commits
+
+- Improve offsetPolyline to correctly handle open polylines [`4c5a003`](https://github.com/Immugio/three-math-extensions/commit/4c5a003e9d46fc1ef8a63ec765941232d2dda933)
+- Line2D.groupConnectedLines sorts each group based on connection order [`16e22f9`](https://github.com/Immugio/three-math-extensions/commit/16e22f9adb7df290e36381b198d7f0381dfb1f5c)
+
+## [0.2.31](https://github.com/Immugio/three-math-extensions/compare/0.2.30...0.2.31) - 2024-09-17
+
+### Commits
+
+- Add Vec3.applyAxisAngleAroundCenter [`a45aaea`](https://github.com/Immugio/three-math-extensions/commit/a45aaea2b6579e8f94859d1ed29abf81479d3a76)
+
+## [0.2.30](https://github.com/Immugio/three-math-extensions/compare/0.2.29...0.2.30) - 2024-09-12
 
 ### Commits
 

package/cjs/Line2D.js

@@ -658,7 +658,7 @@ class Line2D {
      * 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
+     * @param breakpoints Endpoints on breakpoints are not considered as connected
      */
     static groupConnectedLines(lines, tolerance = 0, breakpoints = []) {
         const visited = new Set();
@@ -685,6 +685,18 @@ class Line2D {
                 connectedLines.push(group);
             }
         });
+        // Sort each group based on connection order
+        connectedLines.forEach(group => {
+            group.sort((a, b) => {
+                if (a.start.isNear(b.start, tolerance) || a.end.isNear(b.start, tolerance)) {
+                    return -1;
+                }
+                if (a.start.isNear(b.end, tolerance) || a.end.isNear(b.end, tolerance)) {
+                    return 1;
+                }
+                return 0;
+            });
+        });
         return connectedLines;
     }
     /**

package/cjs/Vec3.js

@@ -81,6 +81,15 @@ class Vec3 extends three_1.Vector3 {
         const closest = withDistances.reduce((a, b) => a.distance < b.distance ? a : b);
         return Vec3.fromPoint(closest.point);
     }
+    applyAxisAngleAroundCenter(axis, angle, center) {
+        // Translate the vector to the origin
+        this.sub(center);
+        // Apply the axis-angle rotation
+        this.applyAxisAngle(axis, angle);
+        // Translate the vector back to the original position
+        this.add(center);
+        return this;
+    }
     roundIfCloseToInteger(max = 0.000000000001) {
         if (Math.abs(this.x - Math.round(this.x)) < max) {
             this.x = Math.round(this.x);

package/cjs/offsetPolyline.js

@@ -1,16 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.offsetPolyline = void 0;
-function offsetPolyline(lines, offset) {
+function offsetPolyline(lines, offset, tolerance = 0) {
+    const isClosed = lines[0].start.isNear(lines.at(-1).end, tolerance);
     for (let i = 0; i < lines.length; i++) {
+        const isFirst = i === 0;
+        const isLast = i === lines.length - 1;
         const line = lines[i];
         line.translateLeft(offset);
         const next = lines[(i + 1) % lines.length];
-        line.extendToOrTrimAtIntersection(next);
-        next.extendToOrTrimAtIntersection(line);
+        if (!isLast || isClosed) {
+            line.extendToOrTrimAtIntersection(next);
+            next.extendToOrTrimAtIntersection(line);
+        }
         const previous = lines[(i + lines.length - 1) % lines.length];
-        line.extendToOrTrimAtIntersection(previous);
-        previous.extendToOrTrimAtIntersection(line);
+        if (!isFirst || isClosed) {
+            line.extendToOrTrimAtIntersection(previous);
+            previous.extendToOrTrimAtIntersection(line);
+        }
     }
     return lines;
 }

package/esm/Line2D.js

@@ -655,7 +655,7 @@ export class Line2D {
      * 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
+     * @param breakpoints Endpoints on breakpoints are not considered as connected
      */
     static groupConnectedLines(lines, tolerance = 0, breakpoints = []) {
         const visited = new Set();
@@ -682,6 +682,18 @@ export class Line2D {
                 connectedLines.push(group);
             }
         });
+        // Sort each group based on connection order
+        connectedLines.forEach(group => {
+            group.sort((a, b) => {
+                if (a.start.isNear(b.start, tolerance) || a.end.isNear(b.start, tolerance)) {
+                    return -1;
+                }
+                if (a.start.isNear(b.end, tolerance) || a.end.isNear(b.end, tolerance)) {
+                    return 1;
+                }
+                return 0;
+            });
+        });
         return connectedLines;
     }
     /**

package/esm/Vec3.js

@@ -78,6 +78,15 @@ export class Vec3 extends Vector3 {
         const closest = withDistances.reduce((a, b) => a.distance < b.distance ? a : b);
         return Vec3.fromPoint(closest.point);
     }
+    applyAxisAngleAroundCenter(axis, angle, center) {
+        // Translate the vector to the origin
+        this.sub(center);
+        // Apply the axis-angle rotation
+        this.applyAxisAngle(axis, angle);
+        // Translate the vector back to the original position
+        this.add(center);
+        return this;
+    }
     roundIfCloseToInteger(max = 0.000000000001) {
         if (Math.abs(this.x - Math.round(this.x)) < max) {
             this.x = Math.round(this.x);

package/esm/offsetPolyline.js

@@ -1,13 +1,20 @@
-export function offsetPolyline(lines, offset) {
+export function offsetPolyline(lines, offset, tolerance = 0) {
+    const isClosed = lines[0].start.isNear(lines.at(-1).end, tolerance);
     for (let i = 0; i < lines.length; i++) {
+        const isFirst = i === 0;
+        const isLast = i === lines.length - 1;
         const line = lines[i];
         line.translateLeft(offset);
         const next = lines[(i + 1) % lines.length];
-        line.extendToOrTrimAtIntersection(next);
-        next.extendToOrTrimAtIntersection(line);
+        if (!isLast || isClosed) {
+            line.extendToOrTrimAtIntersection(next);
+            next.extendToOrTrimAtIntersection(line);
+        }
         const previous = lines[(i + lines.length - 1) % lines.length];
-        line.extendToOrTrimAtIntersection(previous);
-        previous.extendToOrTrimAtIntersection(line);
+        if (!isFirst || isClosed) {
+            line.extendToOrTrimAtIntersection(previous);
+            previous.extendToOrTrimAtIntersection(line);
+        }
     }
     return lines;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@immugio/three-math-extensions",
-  "version": "0.2.30",
+  "version": "0.2.32",
   "description": "Set of utilities for 2d and 3d line math built on top of three.js",
   "author": "Jan Mikeska <janmikeska@gmail.com>",
   "license": "ISC",

package/src/Line2D.ts

@@ -776,7 +776,7 @@ export class Line2D {
      * 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
+     * @param breakpoints Endpoints on breakpoints are not considered as connected
      */
     public static groupConnectedLines(lines: Line2D[], tolerance: number = 0, breakpoints: Vec2[] = []): Line2D[][] {
         const visited: Set<Line2D> = new Set();
@@ -790,9 +790,7 @@ export class Line2D {
 
             lines.forEach((neighbor) => {
                 if (!visited.has(neighbor)) {
-                    if (
-                        line.connectsTo(neighbor, tolerance, breakpoints)
-                    ) {
+                    if (line.connectsTo(neighbor, tolerance, breakpoints)) {
                         dfs(neighbor, group);
                     }
                 }
@@ -809,6 +807,19 @@ export class Line2D {
             }
         });
 
+        // Sort each group based on connection order
+        connectedLines.forEach(group => {
+            group.sort((a, b) => {
+                if (a.start.isNear(b.start, tolerance) || a.end.isNear(b.start, tolerance)) {
+                    return -1;
+                }
+                if (a.start.isNear(b.end, tolerance) || a.end.isNear(b.end, tolerance)) {
+                    return 1;
+                }
+                return 0;
+            });
+        });
+
         return connectedLines;
     }
 

package/src/Vec3.ts

@@ -94,6 +94,19 @@ export class Vec3 extends Vector3 {
         return Vec3.fromPoint(closest.point);
     }
 
+    public applyAxisAngleAroundCenter(axis: Vector3, angle: number, center: Vector3): this {
+        // Translate the vector to the origin
+        this.sub(center);
+
+        // Apply the axis-angle rotation
+        this.applyAxisAngle(axis, angle);
+
+        // Translate the vector back to the original position
+        this.add(center);
+
+        return this;
+    }
+
     public roundIfCloseToInteger(max: number = 0.000000000001): this {
         if (Math.abs(this.x - Math.round(this.x)) < max) {
             this.x = Math.round(this.x);

package/src/offsetPolyline.ts

@@ -1,17 +1,26 @@
 import { Line2D } from "./Line2D";
 
-export function offsetPolyline(lines: Line2D[], offset: number): Line2D[] {
-    for (let i = 0; i < lines.length; i++){
+export function offsetPolyline(lines: Line2D[], offset: number, tolerance: number = 0): Line2D[] {
+    const isClosed = lines[0].start.isNear(lines.at(-1).end, tolerance);
+
+    for (let i = 0; i < lines.length; i++) {
+        const isFirst = i === 0;
+        const isLast = i === lines.length - 1;
+
         const line = lines[i];
         line.translateLeft(offset);
 
         const next = lines[(i + 1) % lines.length];
-        line.extendToOrTrimAtIntersection(next);
-        next.extendToOrTrimAtIntersection(line);
+        if (!isLast || isClosed) {
+            line.extendToOrTrimAtIntersection(next);
+            next.extendToOrTrimAtIntersection(line);
+        }
 
         const previous = lines[(i + lines.length - 1) % lines.length];
-        line.extendToOrTrimAtIntersection(previous);
-        previous.extendToOrTrimAtIntersection(line);
+        if (!isFirst || isClosed) {
+            line.extendToOrTrimAtIntersection(previous);
+            previous.extendToOrTrimAtIntersection(line);
+        }
     }
 
     return lines;

package/types/Line2D.d.ts

@@ -251,7 +251,7 @@ export declare class Line2D {
      * 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
+     * @param breakpoints Endpoints on breakpoints are not considered as connected
      */
     static groupConnectedLines(lines: Line2D[], tolerance?: number, breakpoints?: Vec2[]): Line2D[][];
     /**

package/types/Vec3.d.ts

@@ -50,6 +50,7 @@ export declare class Vec3 extends Vector3 {
      * @param points
      */
     closest(...points: Vector3[]): Vec3;
+    applyAxisAngleAroundCenter(axis: Vector3, angle: number, center: Vector3): this;
     roundIfCloseToInteger(max?: number): this;
     /**
      * Returns a clone of this Vec3 instance with y and z swapped.

package/types/offsetPolyline.d.ts

@@ -1,2 +1,2 @@
 import { Line2D } from "./Line2D";
-export declare function offsetPolyline(lines: Line2D[], offset: number): Line2D[];
+export declare function offsetPolyline(lines: Line2D[], offset: number, tolerance?: number): Line2D[];