@immugio/three-math-extensions 0.2.21 → 0.2.23

package/src/Line2D.ts

@@ -1,7 +1,6 @@
 import { Point2 } from "./Point2";
-import { Vector2 } from "three";
+import { MathUtils, Vector2 } from "three";
 import { Vec2 } from "./Vec2";
-import { MathUtils } from "three";
 import { TwoPI } from "./MathConstants";
 import { Line3D } from "./Line3D";
 import { directions2d } from "./directions2d";
@@ -11,6 +10,8 @@ const _startEnd = /*@__PURE__*/ new Vec2();
 
 export class Line2D {
 
+    readonly #target: Vec2 = new Vec2();
+
     constructor(public start: Vec2, public end: Vec2, public index: number = 0) {
     }
 
@@ -161,6 +162,47 @@ export class Line2D {
         return [this.start, this.end];
     }
 
+    /**
+     * Check that this line segment contains provided point.
+     * @param p
+     * @param tolerance
+     */
+    public containsPoint(p: Vector2, tolerance: number = 0): boolean {
+        const closestPointToPoint = this.closestPointToPoint(p, true, this.#target);
+        return closestPointToPoint.distanceTo(p) <= tolerance;
+    }
+
+    /**
+     * Distance from this line to the provided point.
+     * @param param
+     * @param clampToLine
+     */
+    public distanceToPoint(p: Vector2, clampToLine: boolean = true): number {
+        const closestPointToPoint = this.closestPointToPoint(p, clampToLine, this.#target);
+        return closestPointToPoint.distanceTo(p);
+    }
+
+    /**
+     * Returns a copy of @other line, the direction of @other is reversed if needed.
+     * Returns null if lines are not parallel.
+     * @param other
+     * @param parallelTolerance
+     */
+    public getParallelLineInTheSameDirection(other: Line2D, parallelTolerance: number = 0): Line2D {
+        const direction = this.direction;
+
+        if (direction.angleTo(other.direction) <= parallelTolerance) {
+            return other.clone();
+        }
+
+        const otherLineOppositeDirection = other.clone().flip();
+        if (otherLineOppositeDirection.direction.angleTo(direction) <= parallelTolerance) {
+            return otherLineOppositeDirection;
+        }
+
+        return null;
+    }
+
     /**
      * Returns the direction of this line.
      */
@@ -173,9 +215,9 @@ export class Line2D {
      * Modifies this line.
      */
     public flip(): this {
-        const temp = this.start.clone();
+        this.#target.copy(this.start);
         this.start.copy(this.end);
-        this.end.copy(temp);
+        this.end.copy(this.#target);
 
         return this;
     }
@@ -284,16 +326,38 @@ export class Line2D {
     /**
      * Returns true if there is any overlap between this line and the @other line section.
      */
-    public overlaps(other: Line2D): boolean {
-        if (!this.isCollinearWithTouchOrOverlap(other)) {
-            return false;
+    public overlaps(other: Line2D, distanceTolerance: number = 0, parallelTolerance: number = 0): boolean {
+        // Special case
+        if (this.equals(other, distanceTolerance)) {
+            return true;
         }
 
-        if (this.start.equals(other.start) && this.end.equals(other.end)) {
-            return true;
+        // Always have to be parallel
+        if (this.isParallelTo(other, parallelTolerance)) {
+            // To pass as overlapping, at least one point has to be within the other line, but they mush not be equal - "touching" is not considered overlapping
+
+            const otherStartEqualsToAnyOfThisPoint = other.start.distanceTo(this.start) <= distanceTolerance || other.start.distanceTo(this.end) <= distanceTolerance;
+            if (this.containsPoint(other.start, distanceTolerance) && !otherStartEqualsToAnyOfThisPoint) {
+                return true;
+            }
+
+            const otherEndEqualsToAnyOfThisPoint = other.end.distanceTo(this.start) <= distanceTolerance || other.end.distanceTo(this.end) <= distanceTolerance;
+            if (this.containsPoint(other.end, distanceTolerance) && !otherEndEqualsToAnyOfThisPoint) {
+                return true;
+            }
+
+            const thisStartEqualsToAnyOfOtherPoint = this.start.distanceTo(other.start) <= distanceTolerance || this.start.distanceTo(other.end) <= distanceTolerance;
+            if (other.containsPoint(this.start, distanceTolerance) && !thisStartEqualsToAnyOfOtherPoint) {
+                return true;
+            }
+
+            const thisEndEqualsToAnyOfOtherPoint = this.end.distanceTo(other.start) <= distanceTolerance || this.end.distanceTo(other.end) <= distanceTolerance;
+            if (other.containsPoint(this.end, distanceTolerance) && !thisEndEqualsToAnyOfOtherPoint) {
+                return true;
+            }
         }
 
-        return !this.start.equals(other.end) && !this.end.equals(other.start);
+        return false;
     }
 
     /**
@@ -382,6 +446,19 @@ export class Line2D {
         return result;
     }
 
+    /**
+     * Checks if the current line covers another line.
+     * A line is considered to cover another line if they are parallel and both the start and end points of the other line are contained within the current line.
+     * Both distance and angle tolerance can be provided.
+     */
+    public covers(other: Line2D, tolerance: number = 0, parallelTolerance: number = 0): boolean {
+        if (!this.isParallelTo(other, parallelTolerance)) {
+            return false;
+        }
+
+        return this.containsPoint(other.start, tolerance) && this.containsPoint(other.end, tolerance);
+    }
+
     /**
      * Returns a new line that is the projection of this line onto @other. Uses `closestPointToPoint` to find the projection.
      * @param other
@@ -759,8 +836,12 @@ export class Line2D {
         return new Line3D(this.start.in3DSpace(y), this.end.in3DSpace(y));
     }
 
-    public equals(other: Line2D): boolean {
-        return !!other && this.start.equals(other.start) && this.end.equals(other.end);
+    public equals(other: Line2D, tolerance: number = 0): boolean {
+        if (!tolerance) {
+            return !!other && this.start.equals(other.start) && this.end.equals(other.end);
+        }
+
+        return !!other && this.start.distanceTo(other.start) <= tolerance && this.end.distanceTo(other.end) <= tolerance;
     }
 
     /**

package/src/Line3D.ts

@@ -305,7 +305,7 @@ export class Line3D extends Line3 {
     }
 
     /**
-     * Distance from this line to provided point.
+     * Distance from this line to the provided point.
      * @param p
      * @param clampToLine
      */

package/types/Line2D.d.ts

@@ -3,6 +3,7 @@ import { Vector2 } from "three";
 import { Vec2 } from "./Vec2";
 import { Line3D } from "./Line3D";
 export declare class Line2D {
+    #private;
     start: Vec2;
     end: Vec2;
     index: number;
@@ -55,6 +56,25 @@ export declare class Line2D {
      * Endpoints are not cloned.
      */
     get endpoints(): Vec2[];
+    /**
+     * Check that this line segment contains provided point.
+     * @param p
+     * @param tolerance
+     */
+    containsPoint(p: Vector2, tolerance?: number): boolean;
+    /**
+     * Distance from this line to the provided point.
+     * @param param
+     * @param clampToLine
+     */
+    distanceToPoint(p: Vector2, clampToLine?: boolean): number;
+    /**
+     * Returns a copy of @other line, the direction of @other is reversed if needed.
+     * Returns null if lines are not parallel.
+     * @param other
+     * @param parallelTolerance
+     */
+    getParallelLineInTheSameDirection(other: Line2D, parallelTolerance?: number): Line2D;
     /**
      * Returns the direction of this line.
      */
@@ -117,7 +137,7 @@ export declare class Line2D {
     /**
      * Returns true if there is any overlap between this line and the @other line section.
      */
-    overlaps(other: Line2D): boolean;
+    overlaps(other: Line2D, distanceTolerance?: number, parallelTolerance?: number): boolean;
     /**
      * Logical AND of this and the other line section.
      * @param other
@@ -139,6 +159,12 @@ export declare class Line2D {
      * @param lines
      */
     static joinLines(lines: Line2D[]): Line2D[];
+    /**
+     * Checks if the current line covers another line.
+     * A line is considered to cover another line if they are parallel and both the start and end points of the other line are contained within the current line.
+     * Both distance and angle tolerance can be provided.
+     */
+    covers(other: Line2D, tolerance?: number, parallelTolerance?: number): boolean;
     /**
      * Returns a new line that is the projection of this line onto @other. Uses `closestPointToPoint` to find the projection.
      * @param other
@@ -241,7 +267,7 @@ export declare class Line2D {
      * @returns A new Line3D instance.
      */
     in3DSpace(y?: number): Line3D;
-    equals(other: Line2D): boolean;
+    equals(other: Line2D, tolerance?: number): boolean;
     /**
      * Deep clone of this line
      */

package/types/Line3D.d.ts

@@ -94,7 +94,7 @@ export declare class Line3D extends Line3 {
      */
     containsPoint(p: Vector3, tolerance?: number): boolean;
     /**
-     * Distance from this line to provided point.
+     * Distance from this line to the provided point.
      * @param p
      * @param clampToLine
      */

package/docs/README.md

@@ -1,90 +0,0 @@
-@immugio/three-math-extensions / [Exports](modules.md)
-
-# Set of utilities for 2d and 3d math built on top of three.js
-
-[![Build](https://github.com/Immugio/three-math-extensions/actions/workflows/build.yml/badge.svg)](https://github.com/Immugio/three-math-extensions/actions/workflows/build.yml)
-
-[@immugio/three-math-extensions](README.md) / Exports
-
-# @immugio/three-math-extensions
-
-## Table of contents
-
-### Classes
-
-- [BoundingBox](docs/classes/BoundingBox.md)
-- [Line2D](docs/classes/Line2D.md)
-- [Line3D](docs/classes/Line3D.md)
-- [Polygon](docs/classes/Polygon.md)
-- [Rectangle](docs/classes/Rectangle.md)
-- [Size2](docs/classes/Size2.md)
-- [Vec2](docs/classes/Vec2.md)
-- [Vec3](docs/classes/Vec3.md)
-
-### Interfaces
-
-- [Point2](docs/interfaces/Point2.md)
-- [Point3](docs/interfaces/Point3.md)
-
-### Variables
-
-- [TwoPI](docs/modules.md#twopi)
-
-### Functions
-
-- [normalizeAngleDegrees](docs/modules.md#normalizeangledegrees)
-- [normalizeAngleRadians](docs/modules.md#normalizeangleradians)
-
-## Variables
-
-### TwoPI
-
-• `Const` **TwoPI**: `number`
-
-#### Defined in
-
-[src/MathConstants.ts:1](https://github.com/Immugio/three-math-extensions/blob/151f214/src/MathConstants.ts#L1)
-
-## Functions
-
-### normalizeAngleDegrees
-
-▸ **normalizeAngleDegrees**(`angle`): `number`
-
-Normalizes an angle in degrees to the range [0, 360].
-
-#### Parameters
-
-| Name | Type | Description |
-| :------ | :------ | :------ |
-| `angle` | `number` | in degrees |
-
-#### Returns
-
-`number`
-
-#### Defined in
-
-[src/normalizeAngleDegrees.ts:5](https://github.com/Immugio/three-math-extensions/blob/151f214/src/normalizeAngleDegrees.ts#L5)
-
-___
-
-### normalizeAngleRadians
-
-▸ **normalizeAngleRadians**(`angle`): `number`
-
-Normalize an angle in radians to the range of 0 to 2π.
-
-#### Parameters
-
-| Name | Type | Description |
-| :------ | :------ | :------ |
-| `angle` | `number` | in radians |
-
-#### Returns
-
-`number`
-
-#### Defined in
-
-[src/normalizeAngleRadians.ts:7](https://github.com/Immugio/three-math-extensions/blob/151f214/src/normalizeAngleRadians.ts#L7)