@immugio/three-math-extensions 0.0.14 → 0.0.15

package/CHANGELOG.md

@@ -7,7 +7,13 @@ 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.0.14](https://github.com/Immugio/three-math-extensions/compare/0.0.13...0.0.14)
+## [0.0.15](https://github.com/Immugio/three-math-extensions/compare/0.0.14...0.0.15)
+
+### Commits
+
+- Add intersect method to Line3D [`6fe47de`](https://github.com/Immugio/three-math-extensions/commit/6fe47de7caaa1807b47a4363e551510c463757d7)
+
+## [0.0.14](https://github.com/Immugio/three-math-extensions/compare/0.0.13...0.0.14) - 2022-12-26
 
 ### Commits
 

package/cjs/Line2D.js

@@ -550,6 +550,9 @@ class Line2D {
         }
         return null;
     }
+    equals(other) {
+        return !!other && this.start.equals(other.start) && this.end.equals(other.end);
+    }
     /**
      * Deep clone of this line
      */
@@ -559,8 +562,5 @@ class Line2D {
     toString() {
         return `Line(${this.start.x}, ${this.start.y}, ${this.end.x}, ${this.end.y})`;
     }
-    equals(other) {
-        return !!other && this.start.equals(other.start) && this.end.equals(other.end);
-    }
 }
 exports.Line2D = Line2D;

package/cjs/Line3D.js

@@ -367,6 +367,45 @@ class Line3D extends three_1.Line3 {
         this.end.add(p);
         return 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.
+     * 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
+     * @param other
+     */
+    intersect(other) {
+        const p1 = this.start.clone();
+        const p2 = this.end.clone();
+        const p3 = other.start.clone();
+        const p4 = other.end.clone();
+        const p13 = p1.clone().sub(p3);
+        const p43 = p4.clone().sub(p3);
+        if (p43.lengthSq() <= Number.EPSILON) {
+            return null;
+        }
+        const p21 = p2.clone().sub(p1);
+        if (p21.lengthSq() <= Number.EPSILON) {
+            return null;
+        }
+        const d1343 = p13.x * p43.x + p13.y * p43.y + p13.z * p43.z;
+        const d4321 = p43.x * p21.x + p43.y * p21.y + p43.z * p21.z;
+        const d1321 = p13.x * p21.x + p13.y * p21.y + p13.z * p21.z;
+        const d4343 = p43.x * p43.x + p43.y * p43.y + p43.z * p43.z;
+        const d2121 = p21.x * p21.x + p21.y * p21.y + p21.z * p21.z;
+        const denominator = d2121 * d4343 - d4321 * d4321;
+        if (Math.abs(denominator) <= Number.EPSILON) {
+            return null;
+        }
+        const numerator = d1343 * d4321 - d1321 * d4343;
+        const mua = numerator / denominator;
+        const mub = (d1343 + d4321 * (mua)) / d4343;
+        const resultSegmentPoint1 = new Vec3_1.Vec3((p1.x + mua * p21.x), (p1.y + mua * p21.y), (p1.z + mua * p21.z));
+        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);
+    }
     /**
      * Project the line to 2D space, Y value is dropped
      */

package/esm/Line2D.js

@@ -547,6 +547,9 @@ export class Line2D {
         }
         return null;
     }
+    equals(other) {
+        return !!other && this.start.equals(other.start) && this.end.equals(other.end);
+    }
     /**
      * Deep clone of this line
      */
@@ -556,7 +559,4 @@ export class Line2D {
     toString() {
         return `Line(${this.start.x}, ${this.start.y}, ${this.end.x}, ${this.end.y})`;
     }
-    equals(other) {
-        return !!other && this.start.equals(other.start) && this.end.equals(other.end);
-    }
 }

package/esm/Line3D.js

@@ -364,6 +364,45 @@ export class Line3D extends Line3 {
         this.end.add(p);
         return 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.
+     * 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
+     * @param other
+     */
+    intersect(other) {
+        const p1 = this.start.clone();
+        const p2 = this.end.clone();
+        const p3 = other.start.clone();
+        const p4 = other.end.clone();
+        const p13 = p1.clone().sub(p3);
+        const p43 = p4.clone().sub(p3);
+        if (p43.lengthSq() <= Number.EPSILON) {
+            return null;
+        }
+        const p21 = p2.clone().sub(p1);
+        if (p21.lengthSq() <= Number.EPSILON) {
+            return null;
+        }
+        const d1343 = p13.x * p43.x + p13.y * p43.y + p13.z * p43.z;
+        const d4321 = p43.x * p21.x + p43.y * p21.y + p43.z * p21.z;
+        const d1321 = p13.x * p21.x + p13.y * p21.y + p13.z * p21.z;
+        const d4343 = p43.x * p43.x + p43.y * p43.y + p43.z * p43.z;
+        const d2121 = p21.x * p21.x + p21.y * p21.y + p21.z * p21.z;
+        const denominator = d2121 * d4343 - d4321 * d4321;
+        if (Math.abs(denominator) <= Number.EPSILON) {
+            return null;
+        }
+        const numerator = d1343 * d4321 - d1321 * d4343;
+        const mua = numerator / denominator;
+        const mub = (d1343 + d4321 * (mua)) / d4343;
+        const resultSegmentPoint1 = new Vec3((p1.x + mua * p21.x), (p1.y + mua * p21.y), (p1.z + mua * p21.z));
+        const resultSegmentPoint2 = new Vec3((p3.x + mub * p43.x), (p3.y + mub * p43.y), (p3.z + mub * p43.z));
+        return new Line3D(resultSegmentPoint1, resultSegmentPoint2);
+    }
     /**
      * Project the line to 2D space, Y value is dropped
      */

package/package.json

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

package/src/Line2D.ts

@@ -644,6 +644,10 @@ export class Line2D {
         return null;
     }
 
+    public equals(other: Line2D): boolean {
+        return !!other && this.start.equals(other.start) && this.end.equals(other.end);
+    }
+
     /**
      * Deep clone of this line
      */
@@ -654,8 +658,4 @@ export class Line2D {
     public toString(): string {
         return `Line(${this.start.x}, ${this.start.y}, ${this.end.x}, ${this.end.y})`;
     }
-
-    public equals(other: Line2D): boolean {
-        return !!other && this.start.equals(other.start) && this.end.equals(other.end);
-    }
 }

package/src/Line3D.ts

@@ -444,6 +444,64 @@ export class Line3D extends Line3 {
         return 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.
+     * 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
+     * @param other
+     */
+    public intersect(other: Line3D): Line3D {
+        const p1: Vec3 = this.start.clone();
+        const p2: Vec3 = this.end.clone();
+
+        const p3: Vec3 = other.start.clone();
+        const p4: Vec3 = other.end.clone();
+
+        const p13: Vec3 = p1.clone().sub(p3);
+        const p43: Vec3 = p4.clone().sub(p3);
+
+        if (p43.lengthSq() <= Number.EPSILON) {
+            return null;
+        }
+
+        const p21 = p2.clone().sub(p1);
+        if (p21.lengthSq() <= Number.EPSILON) {
+            return null;
+        }
+
+        const d1343: number = p13.x * p43.x + p13.y * p43.y + p13.z * p43.z;
+        const d4321: number = p43.x * p21.x + p43.y * p21.y + p43.z * p21.z;
+        const d1321: number = p13.x * p21.x + p13.y * p21.y + p13.z * p21.z;
+        const d4343: number = p43.x * p43.x + p43.y * p43.y + p43.z * p43.z;
+        const d2121: number = p21.x * p21.x + p21.y * p21.y + p21.z * p21.z;
+
+        const denominator: number = d2121 * d4343 - d4321 * d4321;
+        if (Math.abs(denominator) <= Number.EPSILON) {
+            return null;
+        }
+        const numerator: number = d1343 * d4321 - d1321 * d4343;
+
+        const mua: number = numerator / denominator;
+        const mub: number = (d1343 + d4321 * (mua)) / d4343;
+
+        const resultSegmentPoint1 = new Vec3(
+            (p1.x + mua * p21.x),
+            (p1.y + mua * p21.y),
+            (p1.z + mua * p21.z)
+        );
+
+        const resultSegmentPoint2 = new Vec3(
+            (p3.x + mub * p43.x),
+            (p3.y + mub * p43.y),
+            (p3.z + mub * p43.z)
+        );
+
+        return new Line3D(resultSegmentPoint1, resultSegmentPoint2);
+    }
+
     /**
      * Project the line to 2D space, Y value is dropped
      */

package/types/Line2D.d.ts

@@ -213,10 +213,10 @@ export declare class Line2D {
      * @param expectedAngleInRads number
      */
     hasIntersectionWithAngle(other: Line2D, expectedAngleInRads: number): Vec2;
+    equals(other: Line2D): boolean;
     /**
      * Deep clone of this line
      */
     clone(): Line2D;
     toString(): string;
-    equals(other: Line2D): boolean;
 }

package/types/Line3D.d.ts

@@ -135,6 +135,16 @@ export declare class Line3D extends Line3 {
      * @param p
      */
     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.
+     * 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
+     * @param other
+     */
+    intersect(other: Line3D): Line3D;
     /**
      * Project the line to 2D space, Y value is dropped
      */