@immugio/three-math-extensions 0.2.29 → 0.2.31

package/CHANGELOG.md

@@ -7,7 +7,19 @@ 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.29](https://github.com/Immugio/three-math-extensions/compare/0.2.28...0.2.29)
+## [0.2.31](https://github.com/Immugio/three-math-extensions/compare/0.2.30...0.2.31)
+
+### 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
+
+- Improve offset algorithm implementation [`79bac64`](https://github.com/Immugio/three-math-extensions/commit/79bac64c799de39d022fcf4496dab3fcef497b60)
+
+## [0.2.29](https://github.com/Immugio/three-math-extensions/compare/0.2.28...0.2.29) - 2024-09-12
 
 ### Commits
 

package/cjs/Line2D.js

@@ -27,28 +27,18 @@ class Line2D {
     /**
      * 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.
-     * Similar to Line2.fromVectors but creates new instances of Vec2.
+     * 1) the first and last points are the same or 2) `forceClosedPolygon` is true.
      */
     static fromPolygon(polygon, forceClosedPolygon = false) {
-        return Line2D.fromVectors(polygon?.map(p => Vec2_1.Vec2.fromPoint(p)), forceClosedPolygon);
-    }
-    /**
-     * 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.
-     * Similar to Line2.fromPolygon but keeps the original instances of Vec2.
-     */
-    static fromVectors(polygon, forceClosedPolygon = false) {
         if (!polygon || polygon.length < 2) {
             return [];
         }
-        if (forceClosedPolygon && !polygon[0].equals(polygon.at(-1))) {
+        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(new Line2D(polygon[i], polygon[i + 1], i));
+            lines.push(Line2D.fromPoints(polygon[i], polygon[i + 1], i));
         }
         return lines;
     }

package/cjs/Polygon.js

@@ -7,8 +7,6 @@ const BoundingBox_1 = require("./BoundingBox");
 const polygonPerimeter_1 = require("./polygonPerimeter");
 const isPointInPolygon_1 = require("./isPointInPolygon");
 const Line2D_1 = require("./Line2D");
-const offsetPolyline_1 = require("./offsetPolyline");
-const extendOrTrimPolylinesAtIntersections_1 = require("./extendOrTrimPolylinesAtIntersections");
 class Polygon {
     contour;
     holes;
@@ -124,13 +122,38 @@ class Polygon {
         return this;
     }
     offsetContour(offset) {
-        (0, offsetPolyline_1.offsetPolyline)(Line2D_1.Line2D.fromVectors(this.contour), offset);
+        if (!this.contour[0].equals(this.contour.at(-1))) {
+            console.error("The contour should be closed");
+            return this;
+        }
+        for (let i = 0; i < this.contour.length - 1; i++) {
+            this.translateContourLine(i, offset);
+        }
         return this;
     }
     translateContourLine(index, offset) {
-        const lines = Line2D_1.Line2D.fromVectors(this.contour);
-        lines[index].translateLeft(offset);
-        (0, extendOrTrimPolylinesAtIntersections_1.extendOrTrimPolylinesAtIntersections)(lines);
+        if (index < 0 || index > this.contour.length - 2) {
+            console.error(`Index out of bounds: ${index}`);
+            return this;
+        }
+        if (!this.contour[0].equals(this.contour.at(-1))) {
+            console.error("The contour should be closed");
+            return this;
+        }
+        const line = Line2D_1.Line2D.fromPoints(this.contour[index], this.contour[index + 1]);
+        const prev = Line2D_1.Line2D.fromPoints(this.contour[(index - 1 + this.contour.length) % this.contour.length], this.contour[index]);
+        const next = Line2D_1.Line2D.fromPoints(this.contour[index + 1], this.contour[(index + 2) % this.contour.length]);
+        line.translateLeft(offset);
+        line.extendToOrTrimAtIntersection(prev);
+        line.extendToOrTrimAtIntersection(next);
+        this.contour[index].copy(line.start);
+        this.contour[index + 1].copy(line.end);
+        if (index === 0) {
+            this.contour.at(-1).copy(line.start);
+        }
+        if (index === this.contour.length - 2) {
+            this.contour[0].copy(line.end);
+        }
         return this;
     }
     rotate(angle, center = this.center()) {

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,10 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.offsetPolyline = void 0;
-const extendOrTrimPolylinesAtIntersections_1 = require("./extendOrTrimPolylinesAtIntersections");
 function offsetPolyline(lines, offset) {
-    lines.forEach(line => line.translateLeft(offset));
-    (0, extendOrTrimPolylinesAtIntersections_1.extendOrTrimPolylinesAtIntersections)(lines);
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        line.translateLeft(offset);
+        const next = lines[(i + 1) % lines.length];
+        line.extendToOrTrimAtIntersection(next);
+        next.extendToOrTrimAtIntersection(line);
+        const previous = lines[(i + lines.length - 1) % lines.length];
+        line.extendToOrTrimAtIntersection(previous);
+        previous.extendToOrTrimAtIntersection(line);
+    }
     return lines;
 }
 exports.offsetPolyline = offsetPolyline;

package/esm/Line2D.js

@@ -24,28 +24,18 @@ export class Line2D {
     /**
      * 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.
-     * Similar to Line2.fromVectors but creates new instances of Vec2.
+     * 1) the first and last points are the same or 2) `forceClosedPolygon` is true.
      */
     static fromPolygon(polygon, forceClosedPolygon = false) {
-        return Line2D.fromVectors(polygon?.map(p => Vec2.fromPoint(p)), forceClosedPolygon);
-    }
-    /**
-     * 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.
-     * Similar to Line2.fromPolygon but keeps the original instances of Vec2.
-     */
-    static fromVectors(polygon, forceClosedPolygon = false) {
         if (!polygon || polygon.length < 2) {
             return [];
         }
-        if (forceClosedPolygon && !polygon[0].equals(polygon.at(-1))) {
+        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(new Line2D(polygon[i], polygon[i + 1], i));
+            lines.push(Line2D.fromPoints(polygon[i], polygon[i + 1], i));
         }
         return lines;
     }

package/esm/Polygon.js

@@ -4,8 +4,6 @@ import { BoundingBox } from "./BoundingBox";
 import { polygonPerimeter } from "./polygonPerimeter";
 import { isPointInPolygon } from "./isPointInPolygon";
 import { Line2D } from "./Line2D";
-import { offsetPolyline } from "./offsetPolyline";
-import { extendOrTrimPolylinesAtIntersections } from "./extendOrTrimPolylinesAtIntersections";
 export class Polygon {
     contour;
     holes;
@@ -121,13 +119,38 @@ export class Polygon {
         return this;
     }
     offsetContour(offset) {
-        offsetPolyline(Line2D.fromVectors(this.contour), offset);
+        if (!this.contour[0].equals(this.contour.at(-1))) {
+            console.error("The contour should be closed");
+            return this;
+        }
+        for (let i = 0; i < this.contour.length - 1; i++) {
+            this.translateContourLine(i, offset);
+        }
         return this;
     }
     translateContourLine(index, offset) {
-        const lines = Line2D.fromVectors(this.contour);
-        lines[index].translateLeft(offset);
-        extendOrTrimPolylinesAtIntersections(lines);
+        if (index < 0 || index > this.contour.length - 2) {
+            console.error(`Index out of bounds: ${index}`);
+            return this;
+        }
+        if (!this.contour[0].equals(this.contour.at(-1))) {
+            console.error("The contour should be closed");
+            return this;
+        }
+        const line = Line2D.fromPoints(this.contour[index], this.contour[index + 1]);
+        const prev = Line2D.fromPoints(this.contour[(index - 1 + this.contour.length) % this.contour.length], this.contour[index]);
+        const next = Line2D.fromPoints(this.contour[index + 1], this.contour[(index + 2) % this.contour.length]);
+        line.translateLeft(offset);
+        line.extendToOrTrimAtIntersection(prev);
+        line.extendToOrTrimAtIntersection(next);
+        this.contour[index].copy(line.start);
+        this.contour[index + 1].copy(line.end);
+        if (index === 0) {
+            this.contour.at(-1).copy(line.start);
+        }
+        if (index === this.contour.length - 2) {
+            this.contour[0].copy(line.end);
+        }
         return this;
     }
     rotate(angle, center = this.center()) {

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,6 +1,13 @@
-import { extendOrTrimPolylinesAtIntersections } from "./extendOrTrimPolylinesAtIntersections";
 export function offsetPolyline(lines, offset) {
-    lines.forEach(line => line.translateLeft(offset));
-    extendOrTrimPolylinesAtIntersections(lines);
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        line.translateLeft(offset);
+        const next = lines[(i + 1) % lines.length];
+        line.extendToOrTrimAtIntersection(next);
+        next.extendToOrTrimAtIntersection(line);
+        const previous = lines[(i + lines.length - 1) % lines.length];
+        line.extendToOrTrimAtIntersection(previous);
+        previous.extendToOrTrimAtIntersection(line);
+    }
     return lines;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@immugio/three-math-extensions",
-  "version": "0.2.29",
+  "version": "0.2.31",
   "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

@@ -26,31 +26,20 @@ export class Line2D {
     /**
      * 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.
-     * Similar to Line2.fromVectors but creates new instances of Vec2.
+     * 1) the first and last points are the same or 2) `forceClosedPolygon` is true.
      */
     public static fromPolygon(polygon: Point2[], forceClosedPolygon: boolean = false): Line2D[] {
-        return Line2D.fromVectors(polygon?.map(p => Vec2.fromPoint(p)), forceClosedPolygon);
-    }
-
-    /**
-     * 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.
-     * Similar to Line2.fromPolygon but keeps the original instances of Vec2.
-     */
-    public static fromVectors(polygon: Vec2[], forceClosedPolygon: boolean = false): Line2D[] {
         if (!polygon || polygon.length < 2) {
             return [];
         }
 
-        if (forceClosedPolygon && !polygon[0].equals(polygon.at(-1))) {
+        if (forceClosedPolygon && (polygon[0].x !== polygon.at(-1).x || polygon[0].y !== polygon.at(-1).y)) {
             polygon = [...polygon, polygon[0]];
         }
 
         const lines: Line2D[] = [];
         for (let i = 0; i < polygon.length - 1; i++) {
-            lines.push(new Line2D(polygon[i], polygon[i + 1], i));
+            lines.push(Line2D.fromPoints(polygon[i], polygon[i + 1], i));
         }
 
         return lines;

package/src/Polygon.ts

@@ -5,8 +5,6 @@ import { BoundingBox } from "./BoundingBox";
 import { polygonPerimeter } from "./polygonPerimeter";
 import { isPointInPolygon } from "./isPointInPolygon";
 import { Line2D } from "./Line2D";
-import { offsetPolyline } from "./offsetPolyline";
-import { extendOrTrimPolylinesAtIntersections } from "./extendOrTrimPolylinesAtIntersections";
 
 export class Polygon {
 
@@ -144,14 +142,47 @@ export class Polygon {
     }
 
     public offsetContour(offset: number): this {
-        offsetPolyline(Line2D.fromVectors(this.contour), offset);
+        if (!this.contour[0].equals(this.contour.at(-1))) {
+            console.error("The contour should be closed");
+            return this;
+        }
+
+        for (let i = 0; i < this.contour.length - 1; i++) {
+            this.translateContourLine(i, offset);
+        }
         return this;
     }
 
     public translateContourLine(index: number, offset: number): this {
-        const lines = Line2D.fromVectors(this.contour);
-        lines[index].translateLeft(offset);
-        extendOrTrimPolylinesAtIntersections(lines);
+        if (index < 0 || index > this.contour.length - 2) {
+            console.error(`Index out of bounds: ${index}`);
+            return this;
+        }
+
+        if (!this.contour[0].equals(this.contour.at(-1))) {
+            console.error("The contour should be closed");
+            return this;
+        }
+
+        const line = Line2D.fromPoints(this.contour[index], this.contour[index + 1]);
+        const prev = Line2D.fromPoints(this.contour[(index - 1 + this.contour.length) % this.contour.length], this.contour[index]);
+        const next = Line2D.fromPoints(this.contour[index + 1], this.contour[(index + 2) % this.contour.length]);
+
+        line.translateLeft(offset);
+        line.extendToOrTrimAtIntersection(prev);
+        line.extendToOrTrimAtIntersection(next);
+
+        this.contour[index].copy(line.start);
+        this.contour[index + 1].copy(line.end);
+
+        if (index === 0) {
+            this.contour.at(-1).copy(line.start);
+        }
+
+        if (index === this.contour.length - 2) {
+            this.contour[0].copy(line.end);
+        }
+
         return this;
     }
 

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,8 +1,18 @@
 import { Line2D } from "./Line2D";
-import { extendOrTrimPolylinesAtIntersections } from "./extendOrTrimPolylinesAtIntersections";
 
 export function offsetPolyline(lines: Line2D[], offset: number): Line2D[] {
-    lines.forEach(line => line.translateLeft(offset));
-    extendOrTrimPolylinesAtIntersections(lines);
+    for (let i = 0; i < lines.length; i++){
+        const line = lines[i];
+        line.translateLeft(offset);
+
+        const next = lines[(i + 1) % lines.length];
+        line.extendToOrTrimAtIntersection(next);
+        next.extendToOrTrimAtIntersection(line);
+
+        const previous = lines[(i + lines.length - 1) % lines.length];
+        line.extendToOrTrimAtIntersection(previous);
+        previous.extendToOrTrimAtIntersection(line);
+    }
+
     return lines;
 }

package/types/Line2D.d.ts

@@ -13,17 +13,9 @@ export declare class Line2D {
     /**
      * 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.
-     * Similar to Line2.fromVectors but creates new instances of Vec2.
+     * 1) the first and last points are the same or 2) `forceClosedPolygon` is true.
      */
     static fromPolygon(polygon: Point2[], forceClosedPolygon?: boolean): Line2D[];
-    /**
-     * 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.
-     * Similar to Line2.fromPolygon but keeps the original instances of Vec2.
-     */
-    static fromVectors(polygon: Vec2[], forceClosedPolygon?: boolean): Line2D[];
     static fromLength(length: number): Line2D;
     get center(): Vec2;
     /**

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.