@immugio/three-math-extensions 0.2.6 → 0.2.7

package/CHANGELOG.md

@@ -7,7 +7,7 @@ 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.6](https://github.com/Immugio/three-math-extensions/compare/16.15.10...0.2.6)
+## [0.2.7](https://github.com/Immugio/three-math-extensions/compare/16.15.10...0.2.7)
 
 ### Commits
 
@@ -17,13 +17,25 @@ Generated by [`auto-changelog`](https://github.com/CookPete/auto-changelog).
 - 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)
 - 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)
 - 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.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)
 - 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)
 - 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.5...16.15.10) - 2023-01-02
+## [16.15.10](https://github.com/Immugio/three-math-extensions/compare/0.2.6...16.15.10) - 2023-01-02
+
+## [0.2.6](https://github.com/Immugio/three-math-extensions/compare/0.2.5...0.2.6) - 2023-04-14
+
+### Commits
+
+- 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)
+- Excluded files from build [`ec70614`](https://github.com/Immugio/three-math-extensions/commit/ec70614bc7df7a98f854c7a6693365118e04faf7)
 
 ## [0.2.5](https://github.com/Immugio/three-math-extensions/compare/0.2.4...0.2.5) - 2023-04-11
 

package/cjs/Line2D.js

@@ -4,6 +4,7 @@ exports.Line2D = void 0;
 const three_1 = require("three");
 const Vec2_1 = require("./Vec2");
 const three_2 = require("three");
+const MathConstants_1 = require("./MathConstants");
 const _startP = /*@__PURE__*/ new Vec2_1.Vec2();
 const _startEnd = /*@__PURE__*/ new Vec2_1.Vec2();
 class Line2D {
@@ -531,17 +532,21 @@ class Line2D {
         return new Vec2_1.Vec2(x, y);
     }
     /**
-     * Check that the infinite lines intersect and that they are in the specified angle to each other
+     * Check that the line section intersect and that they are in the specified angle to each other
      * @param other Line
      * @param expectedAngleInRads number
+     * @param angleTolerance number
+     * @param distanceTolerance number
      */
-    hasIntersectionWithAngle(other, expectedAngleInRads) {
-        const angle = this.direction.angle();
-        const otherAngle = other.direction.angle();
+    hasIntersectionWithAngle(other, expectedAngleInRads, angleTolerance = Number.EPSILON, distanceTolerance = Number.EPSILON) {
+        const angle = this.direction.angle() % MathConstants_1.TwoPI;
+        const otherAngle = other.direction.angle() % MathConstants_1.TwoPI;
         const actualAngle = Math.abs(angle - otherAngle);
-        if (Math.abs(actualAngle - expectedAngleInRads) < Number.EPSILON) {
+        if (Math.abs(actualAngle - expectedAngleInRads) <= angleTolerance) {
             const intersection = this.intersect(other);
-            if (intersection && this.isPointOnLineSection(intersection) && other.isPointOnLineSection(intersection)) {
+            if (intersection &&
+                this.closestPointToPoint(intersection, true).distanceTo(intersection) <= distanceTolerance &&
+                other.closestPointToPoint(intersection, true).distanceTo(intersection) <= distanceTolerance) {
                 return intersection;
             }
         }

package/cjs/Vec2.js

@@ -16,6 +16,13 @@ class Vec2 extends three_1.Vector2 {
     static fromPoint(point) {
         return new Vec2(point?.x, point?.y);
     }
+    /**
+     * Creates a new Vec2[] array from arguments of {x, y} objects.
+      * @param points - The ...{x, y} instances.
+     */
+    static fromPoints(...points) {
+        return points?.map(p => Vec2.fromPoint(p)) ?? [];
+    }
     /**
      * Moves this Vec2 instance towards the target Vec2 by the given amount.
      * @param target - The target Vec2.
@@ -66,5 +73,19 @@ class Vec2 extends three_1.Vector2 {
         const signed_angle = Math.atan2(this.y, this.x) - Math.atan2(0, 1);
         return (0, normalizeAngleRadians_1.normalizeAngleRadians)(signed_angle);
     }
+    /**
+     * check if the angle between the two vectors is close enough to 0 or 180 degrees (same or opposite direction) within the given tolerance
+     * @param other Vector2
+     * @param toleranceRadians number angle tolerance in radians
+     */
+    parallelTo(other, toleranceRadians = 0) {
+        const v1 = this.clone().normalize(); // Normalize both vectors to remove magnitude influence
+        const v2 = other.clone().normalize();
+        const dotProduct = v1.dot(v2); // Calculate the dot product to find the cosine of the angle between the vectors
+        // Calculate the angle in radians
+        const angle = Math.acos(dotProduct);
+        // Check if the angle is within the tolerance of 0 or 180 degrees (Math.PI)
+        return Math.abs(angle) <= toleranceRadians || Math.abs(angle - Math.PI) <= toleranceRadians;
+    }
 }
 exports.Vec2 = Vec2;

package/esm/Line2D.js

@@ -1,6 +1,7 @@
 import { Vector2 } from "three";
 import { Vec2 } from "./Vec2";
 import { MathUtils } from "three";
+import { TwoPI } from "./MathConstants";
 const _startP = /*@__PURE__*/ new Vec2();
 const _startEnd = /*@__PURE__*/ new Vec2();
 export class Line2D {
@@ -528,17 +529,21 @@ export class Line2D {
         return new Vec2(x, y);
     }
     /**
-     * Check that the infinite lines intersect and that they are in the specified angle to each other
+     * Check that the line section intersect and that they are in the specified angle to each other
      * @param other Line
      * @param expectedAngleInRads number
+     * @param angleTolerance number
+     * @param distanceTolerance number
      */
-    hasIntersectionWithAngle(other, expectedAngleInRads) {
-        const angle = this.direction.angle();
-        const otherAngle = other.direction.angle();
+    hasIntersectionWithAngle(other, expectedAngleInRads, angleTolerance = Number.EPSILON, distanceTolerance = Number.EPSILON) {
+        const angle = this.direction.angle() % TwoPI;
+        const otherAngle = other.direction.angle() % TwoPI;
         const actualAngle = Math.abs(angle - otherAngle);
-        if (Math.abs(actualAngle - expectedAngleInRads) < Number.EPSILON) {
+        if (Math.abs(actualAngle - expectedAngleInRads) <= angleTolerance) {
             const intersection = this.intersect(other);
-            if (intersection && this.isPointOnLineSection(intersection) && other.isPointOnLineSection(intersection)) {
+            if (intersection &&
+                this.closestPointToPoint(intersection, true).distanceTo(intersection) <= distanceTolerance &&
+                other.closestPointToPoint(intersection, true).distanceTo(intersection) <= distanceTolerance) {
                 return intersection;
             }
         }

package/esm/Vec2.js

@@ -13,6 +13,13 @@ export class Vec2 extends Vector2 {
     static fromPoint(point) {
         return new Vec2(point?.x, point?.y);
     }
+    /**
+     * Creates a new Vec2[] array from arguments of {x, y} objects.
+      * @param points - The ...{x, y} instances.
+     */
+    static fromPoints(...points) {
+        return points?.map(p => Vec2.fromPoint(p)) ?? [];
+    }
     /**
      * Moves this Vec2 instance towards the target Vec2 by the given amount.
      * @param target - The target Vec2.
@@ -63,4 +70,18 @@ export class Vec2 extends Vector2 {
         const signed_angle = Math.atan2(this.y, this.x) - Math.atan2(0, 1);
         return normalizeAngleRadians(signed_angle);
     }
+    /**
+     * check if the angle between the two vectors is close enough to 0 or 180 degrees (same or opposite direction) within the given tolerance
+     * @param other Vector2
+     * @param toleranceRadians number angle tolerance in radians
+     */
+    parallelTo(other, toleranceRadians = 0) {
+        const v1 = this.clone().normalize(); // Normalize both vectors to remove magnitude influence
+        const v2 = other.clone().normalize();
+        const dotProduct = v1.dot(v2); // Calculate the dot product to find the cosine of the angle between the vectors
+        // Calculate the angle in radians
+        const angle = Math.acos(dotProduct);
+        // Check if the angle is within the tolerance of 0 or 180 degrees (Math.PI)
+        return Math.abs(angle) <= toleranceRadians || Math.abs(angle - Math.PI) <= toleranceRadians;
+    }
 }

package/package.json

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

@@ -2,6 +2,7 @@
 import { Vector2 } from "three";
 import { Vec2 } from "./Vec2";
 import { MathUtils } from "three";
+import { TwoPI } from "./MathConstants";
 
 const _startP = /*@__PURE__*/ new Vec2();
 const _startEnd = /*@__PURE__*/ new Vec2();
@@ -623,19 +624,24 @@ export class Line2D {
     }
 
     /**
-     * Check that the infinite lines intersect and that they are in the specified angle to each other
+     * Check that the line section intersect and that they are in the specified angle to each other
      * @param other Line
      * @param expectedAngleInRads number
+     * @param angleTolerance number
+     * @param distanceTolerance number
      */
-    public hasIntersectionWithAngle(other: Line2D, expectedAngleInRads: number): Vec2 {
-        const angle = this.direction.angle();
-        const otherAngle = other.direction.angle();
+    public hasIntersectionWithAngle(other: Line2D, expectedAngleInRads: number, angleTolerance = Number.EPSILON, distanceTolerance = Number.EPSILON): Vec2 {
+        const angle = this.direction.angle() % TwoPI;
+        const otherAngle = other.direction.angle() % TwoPI;
         const actualAngle = Math.abs(angle - otherAngle);
 
-        if (Math.abs(actualAngle - expectedAngleInRads) < Number.EPSILON) {
+        if (Math.abs(actualAngle - expectedAngleInRads) <= angleTolerance) {
             const intersection = this.intersect(other);
-            if (intersection && this.isPointOnLineSection(intersection) && other.isPointOnLineSection(intersection)) {
-
+            if (
+                intersection &&
+                this.closestPointToPoint(intersection, true).distanceTo(intersection) <= distanceTolerance &&
+                other.closestPointToPoint(intersection, true).distanceTo(intersection) <= distanceTolerance
+            ) {
                 return intersection;
             }
         }

package/src/Vec2.ts

@@ -17,6 +17,14 @@ export class Vec2 extends Vector2 {
         return new Vec2(point?.x, point?.y);
     }
 
+    /**
+     * Creates a new Vec2[] array from arguments of {x, y} objects.
+      * @param points - The ...{x, y} instances.
+     */
+    public static fromPoints(...points: Point2[]): Vec2[] {
+        return points?.map(p => Vec2.fromPoint(p)) ?? [];
+    }
+
     /**
      * Moves this Vec2 instance towards the target Vec2 by the given amount.
      * @param target - The target Vec2.
@@ -72,4 +80,22 @@ export class Vec2 extends Vector2 {
         const signed_angle = Math.atan2(this.y, this.x) - Math.atan2(0, 1);
         return normalizeAngleRadians(signed_angle);
     }
+
+    /**
+     * check if the angle between the two vectors is close enough to 0 or 180 degrees (same or opposite direction) within the given tolerance
+     * @param other Vector2
+     * @param toleranceRadians number angle tolerance in radians
+     */
+    public parallelTo(other: Vector2, toleranceRadians: number = 0): boolean {
+        const v1 = this.clone().normalize(); // Normalize both vectors to remove magnitude influence
+        const v2 = other.clone().normalize();
+
+        const dotProduct = v1.dot(v2); // Calculate the dot product to find the cosine of the angle between the vectors
+
+        // Calculate the angle in radians
+        const angle = Math.acos(dotProduct);
+
+        // Check if the angle is within the tolerance of 0 or 180 degrees (Math.PI)
+        return Math.abs(angle) <= toleranceRadians || Math.abs(angle - Math.PI) <= toleranceRadians;
+    }
 }

package/types/Line2D.d.ts

@@ -202,11 +202,13 @@ export declare class Line2D {
      */
     intersect(other: Line2D): Vec2;
     /**
-     * Check that the infinite lines intersect and that they are in the specified angle to each other
+     * Check that the line section intersect and that they are in the specified angle to each other
      * @param other Line
      * @param expectedAngleInRads number
+     * @param angleTolerance number
+     * @param distanceTolerance number
      */
-    hasIntersectionWithAngle(other: Line2D, expectedAngleInRads: number): Vec2;
+    hasIntersectionWithAngle(other: Line2D, expectedAngleInRads: number, angleTolerance?: number, distanceTolerance?: number): Vec2;
     equals(other: Line2D): boolean;
     /**
      * Deep clone of this line

package/types/Vec2.d.ts

@@ -11,6 +11,11 @@ export declare class Vec2 extends Vector2 {
      * @returns A new Vec2 instance.
      */
     static fromPoint(point: Point2): Vec2;
+    /**
+     * Creates a new Vec2[] array from arguments of {x, y} objects.
+      * @param points - The ...{x, y} instances.
+     */
+    static fromPoints(...points: Point2[]): Vec2[];
     /**
      * Moves this Vec2 instance towards the target Vec2 by the given amount.
      * @param target - The target Vec2.
@@ -39,4 +44,10 @@ export declare class Vec2 extends Vector2 {
      * Returns the angle between this vector and positive x-axis, the return value is between 0 and 2PI
      */
     signedAngle(): number;
+    /**
+     * check if the angle between the two vectors is close enough to 0 or 180 degrees (same or opposite direction) within the given tolerance
+     * @param other Vector2
+     * @param toleranceRadians number angle tolerance in radians
+     */
+    parallelTo(other: Vector2, toleranceRadians?: number): boolean;
 }