@immugio/three-math-extensions 0.3.4 → 0.3.6

package/src/Vec3.ts

@@ -1,168 +1,168 @@
-import { Vector3 } from "three";
-import { Vec2 } from "./Vec2";
-import { Point3 } from "./Point3";
-
-/**
- * Vec3 represents a 3D vector. It extends `Vector3` from the `threejs` library.
- */
-export class Vec3 extends Vector3 {
-
-    #target: Vector3;
-
-    /**
-     * Creates a new Vec3 instance from an {x, y, z} object.
-     * @param point - The {x, y, z} instance.
-     * @returns A new Vec3 instance.
-     */
-    public static fromPoint(point: Point3): Vec3 {
-        return new Vec3(point?.x, point?.y, point?.z);
-    }
-
-    /**
-     * Creates a new Vec3[] array from arguments of {x, y, z} objects.
-     * @param points - The ...{x, y, z} instances.
-     */
-    public static fromPoints(...points: Point3[]): Vec3[] {
-        return points?.map(p => Vec3.fromPoint(p)) ?? [];
-    }
-
-    /**
-     * Moves this Vec3 instance towards the target Vec3 by the given amount.
-     * @param target - The target Vec3.
-     * @param amount - The distance to move.
-     * @returns This Vec3 instance.
-     */
-    public moveTowards(target: Vector3, amount: number): this {
-        if (this.#target === undefined) {
-            this.#target = new Vector3();
-        }
-
-        this.#target.copy(target);
-        this.add(this.#target.sub(this).normalize().multiplyScalar(amount));
-
-        return this;
-    }
-
-    /**
-     * Moves this Vec3 instance halfway towards the target Vec3 by the given amount.
-     * @param target - The target Vec3.
-     * @returns This Vec3 instance.
-     */
-    public moveHalfWayTowards(target: Vector3): this {
-        if (this.#target === undefined) {
-            this.#target = new Vector3();
-        }
-
-        return this.moveTowards(target, this.distanceTo(target) / 2);
-    }
-
-    /**
-     * Adds y amount to this Vec3 instance and return this
-     * @param y
-     */
-    public addY(y: number): this {
-        this.y += y;
-        return this;
-    }
-
-    /**
-     * Adds x amount to this Vec3 instance and return this
-     * @param x
-     */
-    public addX(x: number): this {
-        this.x += x;
-        return this;
-    }
-
-    /**
-     * Adds z amount to this Vec3 instance and return this
-     * @param z
-     */
-    public addZ(z: number): this {
-        this.z += z;
-        return this;
-    }
-
-    /**
-     * Returns a clone of the point closest to this from the given points.
-     * @param points
-     */
-    public closest(...points: Vector3[]): Vec3 {
-        const withDistances = points.map(p => ({ point: p, distance: this.distanceTo(p) }));
-        const closest = withDistances.reduce((a, b) => a.distance < b.distance ? a : b);
-        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);
-        }
-        if (Math.abs(this.y - Math.round(this.y)) < max) {
-            this.y = Math.round(this.y);
-        }
-        if (Math.abs(this.z - Math.round(this.z)) < max) {
-            this.z = Math.round(this.z);
-        }
-        if (Object.is(this.x, -0)) {
-            this.x = 0;
-        }
-        if (Object.is(this.y, -0)) {
-            this.y = 0;
-        }
-        if (Object.is(this.z, -0)) {
-            this.z = 0;
-        }
-        return this;
-    }
-
-    /**
-     * Returns a clone of this Vec3 instance with y and z swapped.
-     */
-    public toPointWithFlippedYZ(): Vec3 {
-        return new Vec3(this.x, this.z, this.y);
-    }
-
-    /**
-     * Projects this Vec3 instance onto 2d plan. Vec3.z becomes Vec2.y and Vec3.y is ignored.
-     */
-    public onPlan(): Vec2 {
-        return new Vec2(this.x, this.z);
-    }
-
-    /**
-     * Get distance to another vector while ignoring the y-axis.
-     * @param point
-     */
-    public horizontalDistanceTo(point: Vector3): number {
-        return new Vector3(this.x, 0, this.z).distanceTo(new Vector3(point.x, 0, point.z));
-    }
-
-    /**
-     * Determines if this Vec2 instance is near the target Vec2.
-     * maxDistance is the maximum distance between the two vectors within which they are considered `near`.
-     */
-    public isNear(v: Vector3, maxDistance: number = undefined): boolean {
-        if (maxDistance === undefined) {
-            return this.equals(v);
-        }
-
-        return this.distanceTo(v) <= maxDistance;
-    }
-
-    public clone(): this {
-        return super.clone();
-    }
+import { Vector3 } from "three";
+import { Vec2 } from "./Vec2";
+import { Point3 } from "./Point3";
+
+/**
+ * Vec3 represents a 3D vector. It extends `Vector3` from the `threejs` library.
+ */
+export class Vec3 extends Vector3 {
+
+    #target: Vector3;
+
+    /**
+     * Creates a new Vec3 instance from an {x, y, z} object.
+     * @param point - The {x, y, z} instance.
+     * @returns A new Vec3 instance.
+     */
+    public static fromPoint(point: Point3): Vec3 {
+        return new Vec3(point?.x, point?.y, point?.z);
+    }
+
+    /**
+     * Creates a new Vec3[] array from arguments of {x, y, z} objects.
+     * @param points - The ...{x, y, z} instances.
+     */
+    public static fromPoints(...points: Point3[]): Vec3[] {
+        return points?.map(p => Vec3.fromPoint(p)) ?? [];
+    }
+
+    /**
+     * Moves this Vec3 instance towards the target Vec3 by the given amount.
+     * @param target - The target Vec3.
+     * @param amount - The distance to move.
+     * @returns This Vec3 instance.
+     */
+    public moveTowards(target: Vector3, amount: number): this {
+        if (this.#target === undefined) {
+            this.#target = new Vector3();
+        }
+
+        this.#target.copy(target);
+        this.add(this.#target.sub(this).normalize().multiplyScalar(amount));
+
+        return this;
+    }
+
+    /**
+     * Moves this Vec3 instance halfway towards the target Vec3 by the given amount.
+     * @param target - The target Vec3.
+     * @returns This Vec3 instance.
+     */
+    public moveHalfWayTowards(target: Vector3): this {
+        if (this.#target === undefined) {
+            this.#target = new Vector3();
+        }
+
+        return this.moveTowards(target, this.distanceTo(target) / 2);
+    }
+
+    /**
+     * Adds y amount to this Vec3 instance and return this
+     * @param y
+     */
+    public addY(y: number): this {
+        this.y += y;
+        return this;
+    }
+
+    /**
+     * Adds x amount to this Vec3 instance and return this
+     * @param x
+     */
+    public addX(x: number): this {
+        this.x += x;
+        return this;
+    }
+
+    /**
+     * Adds z amount to this Vec3 instance and return this
+     * @param z
+     */
+    public addZ(z: number): this {
+        this.z += z;
+        return this;
+    }
+
+    /**
+     * Returns a clone of the point closest to this from the given points.
+     * @param points
+     */
+    public closest(...points: Vector3[]): Vec3 {
+        const withDistances = points.map(p => ({ point: p, distance: this.distanceTo(p) }));
+        const closest = withDistances.reduce((a, b) => a.distance < b.distance ? a : b);
+        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);
+        }
+        if (Math.abs(this.y - Math.round(this.y)) < max) {
+            this.y = Math.round(this.y);
+        }
+        if (Math.abs(this.z - Math.round(this.z)) < max) {
+            this.z = Math.round(this.z);
+        }
+        if (Object.is(this.x, -0)) {
+            this.x = 0;
+        }
+        if (Object.is(this.y, -0)) {
+            this.y = 0;
+        }
+        if (Object.is(this.z, -0)) {
+            this.z = 0;
+        }
+        return this;
+    }
+
+    /**
+     * Returns a clone of this Vec3 instance with y and z swapped.
+     */
+    public toPointWithFlippedYZ(): Vec3 {
+        return new Vec3(this.x, this.z, this.y);
+    }
+
+    /**
+     * Projects this Vec3 instance onto 2d plan. Vec3.z becomes Vec2.y and Vec3.y is ignored.
+     */
+    public onPlan(): Vec2 {
+        return new Vec2(this.x, this.z);
+    }
+
+    /**
+     * Get distance to another vector while ignoring the y-axis.
+     * @param point
+     */
+    public horizontalDistanceTo(point: Vector3): number {
+        return new Vector3(this.x, 0, this.z).distanceTo(new Vector3(point.x, 0, point.z));
+    }
+
+    /**
+     * Determines if this Vec2 instance is near the target Vec2.
+     * maxDistance is the maximum distance between the two vectors within which they are considered `near`.
+     */
+    public isNear(v: Vector3, maxDistance: number = undefined): boolean {
+        if (maxDistance === undefined) {
+            return this.equals(v);
+        }
+
+        return this.distanceTo(v) <= maxDistance;
+    }
+
+    public clone(): this {
+        return super.clone();
+    }
 }

package/src/containsPoint.ts

@@ -1,66 +1,66 @@
-import { Point2 } from "./Point2";
-
-/**
- * Return if polygon contains @point or when the point is on the polygon boundary.
- * Works consistently with points on the boundary.
- * Works with simple polygons only.
- * The code is copied from PolyK library.
- * @returns {boolean} depth
- * @param polygon
- * @param point
- */
-export function containsPoint(polygon: Point2[], point: Point2): boolean {
-    const p: number[] = [];
-    for (let i = 0; i < polygon.length; i++) {
-        p.push(polygon[i].x);
-        p.push(polygon[i].y);
-    }
-
-    const px = point.x;
-    const py = point.y;
-    const n = p.length >> 1;
-
-    let ax: number;
-
-    let ay = p[2 * n - 3] - py;
-    let bx = p[2 * n - 2] - px;
-    let by = p[2 * n - 1] - py;
-    let lup: boolean;
-
-    // var lup = by > ay;
-    for (let i = 0; i < n; i++) {
-        ax = bx;
-        ay = by;
-        bx = p[2 * i] - px;
-        by = p[2 * i + 1] - py;
-        if (ay === by) continue;
-        lup = by > ay;
-    }
-
-    let depth = 0;
-    for (let i = 0; i < n; i++) {
-        ax = bx;
-        ay = by;
-        bx = p[2 * i] - px;
-        by = p[2 * i + 1] - py;
-        if (ay < 0 && by < 0) continue;  // both "up" or both "down"
-        if (ay > 0 && by > 0) continue;  // both "up" or both "down"
-        if (ax < 0 && bx < 0) continue;   // both points on the left
-
-        if (ay === by && Math.min(ax, bx) <= 0) return true;
-        if (ay === by) continue;
-
-        const lx = ax + (bx - ax) * (-ay) / (by - ay);
-        if (lx === 0) return true;      // point on edge
-        if (lx > 0) depth++;
-        if (ay === 0 && lup && by > ay) depth--;  // hit vertex, both up
-        if (ay === 0 && !lup && by < ay) depth--; // hit vertex, both down(x < (p[j].x - p[i].x) * (y - p[i].y) / (p[j].y - p[i].y) + p[i].x)) {
-        lup = by > ay;
-    }
-
-    return (depth & 1) === 1;
-}
-
-export function containsPoints(polygon: Point2[], points: Point2[]): boolean {
-    return points.every(p => containsPoint(polygon, p));
+import { Point2 } from "./Point2";
+
+/**
+ * Return if polygon contains @point or when the point is on the polygon boundary.
+ * Works consistently with points on the boundary.
+ * Works with simple polygons only.
+ * The code is copied from PolyK library.
+ * @returns {boolean} depth
+ * @param polygon
+ * @param point
+ */
+export function containsPoint(polygon: Point2[], point: Point2): boolean {
+    const p: number[] = [];
+    for (let i = 0; i < polygon.length; i++) {
+        p.push(polygon[i].x);
+        p.push(polygon[i].y);
+    }
+
+    const px = point.x;
+    const py = point.y;
+    const n = p.length >> 1;
+
+    let ax: number;
+
+    let ay = p[2 * n - 3] - py;
+    let bx = p[2 * n - 2] - px;
+    let by = p[2 * n - 1] - py;
+    let lup: boolean;
+
+    // var lup = by > ay;
+    for (let i = 0; i < n; i++) {
+        ax = bx;
+        ay = by;
+        bx = p[2 * i] - px;
+        by = p[2 * i + 1] - py;
+        if (ay === by) continue;
+        lup = by > ay;
+    }
+
+    let depth = 0;
+    for (let i = 0; i < n; i++) {
+        ax = bx;
+        ay = by;
+        bx = p[2 * i] - px;
+        by = p[2 * i + 1] - py;
+        if (ay < 0 && by < 0) continue;  // both "up" or both "down"
+        if (ay > 0 && by > 0) continue;  // both "up" or both "down"
+        if (ax < 0 && bx < 0) continue;   // both points on the left
+
+        if (ay === by && Math.min(ax, bx) <= 0) return true;
+        if (ay === by) continue;
+
+        const lx = ax + (bx - ax) * (-ay) / (by - ay);
+        if (lx === 0) return true;      // point on edge
+        if (lx > 0) depth++;
+        if (ay === 0 && lup && by > ay) depth--;  // hit vertex, both up
+        if (ay === 0 && !lup && by < ay) depth--; // hit vertex, both down(x < (p[j].x - p[i].x) * (y - p[i].y) / (p[j].y - p[i].y) + p[i].x)) {
+        lup = by > ay;
+    }
+
+    return (depth & 1) === 1;
+}
+
+export function containsPoints(polygon: Point2[], points: Point2[]): boolean {
+    return points.every(p => containsPoint(polygon, p));
 }

package/src/directions.ts

@@ -1,10 +1,10 @@
-import { Vec3 } from "./Vec3";
-
-export const directions = {
-    North: new Vec3(0, 0, -1),
-    South: new Vec3(0, 0, 1),
-    East: new Vec3(1, 0, 0),
-    West: new Vec3(-1, 0, 0),
-    Up: new Vec3(0, 1, 0),
-    Down: new Vec3(0, -1, 0)
+import { Vec3 } from "./Vec3";
+
+export const directions = {
+    North: new Vec3(0, 0, -1),
+    South: new Vec3(0, 0, 1),
+    East: new Vec3(1, 0, 0),
+    West: new Vec3(-1, 0, 0),
+    Up: new Vec3(0, 1, 0),
+    Down: new Vec3(0, -1, 0)
 };

package/src/directions2d.ts

@@ -1,8 +1,8 @@
-import { Vec2 } from "./Vec2";
-
-export const directions2d = {
-    Up: new Vec2(0, -1),
-    Down: new Vec2(0, 1),
-    Left: new Vec2(-1, 0),
-    Right: new Vec2(1, 0)
+import { Vec2 } from "./Vec2";
+
+export const directions2d = {
+    Up: new Vec2(0, -1),
+    Down: new Vec2(0, 1),
+    Left: new Vec2(-1, 0),
+    Right: new Vec2(1, 0)
 };

package/src/ensurePolygonClockwise.ts

@@ -1,10 +1,10 @@
-import { Point2 } from "./Point2";
-import { isPolygonClockwise } from "./isPolygonClockwise";
-
-export function ensurePolygonClockwise<T extends Point2>(poly: T[]): T[] {
-    if (!isPolygonClockwise(poly)) {
-        return poly.reverse();
-    }
-
-    return poly;
+import { Point2 } from "./Point2";
+import { isPolygonClockwise } from "./isPolygonClockwise";
+
+export function ensurePolygonClockwise<T extends Point2>(poly: T[]): T[] {
+    if (!isPolygonClockwise(poly)) {
+        return poly.reverse();
+    }
+
+    return poly;
 }

package/src/extendOrTrimPolylinesAtIntersections.ts

@@ -1,11 +1,11 @@
-import { Line2D } from "./Line2D";
-
-export function extendOrTrimPolylinesAtIntersections(lines: Line2D[]): void {
-    for (let i = 0; i < lines.length; i++) {
-        const current = lines[i];
-        const next = lines[(i + 1) % lines.length];
-
-        current.extendToOrTrimAtIntersection(next);
-        next.extendToOrTrimAtIntersection(current);
-    }
+import { Line2D } from "./Line2D";
+
+export function extendOrTrimPolylinesAtIntersections(lines: Line2D[]): void {
+    for (let i = 0; i < lines.length; i++) {
+        const current = lines[i];
+        const next = lines[(i + 1) % lines.length];
+
+        current.extendToOrTrimAtIntersection(next);
+        next.extendToOrTrimAtIntersection(current);
+    }
 }

package/src/getPolygonArea.ts

@@ -1,22 +1,22 @@
-import { Point2 } from "./Point2";
-
-/**
- * Returns the area of polygon.
- * @returns {number}
- * @param polygon {Point2[]}
- */
-export function getPolygonArea(polygon: Point2[]): number {
-    const p: number[] = [];
-    for (const point of polygon) {
-        p.push(point.x, point.y);
-    }
-
-    if (p.length < 6) return 0;
-    const l = p.length - 2;
-    let sum = 0;
-    for (let i = 0; i < l; i += 2) {
-        sum += (p[i + 2] - p[i]) * (p[i + 1] + p[i + 3]);
-    }
-    sum += (p[0] - p[l]) * (p[l + 1] + p[1]);
-    return Math.abs(-sum * 0.5); // Handles -0
+import { Point2 } from "./Point2";
+
+/**
+ * Returns the area of polygon.
+ * @returns {number}
+ * @param polygon {Point2[]}
+ */
+export function getPolygonArea(polygon: Point2[]): number {
+    const p: number[] = [];
+    for (const point of polygon) {
+        p.push(point.x, point.y);
+    }
+
+    if (p.length < 6) return 0;
+    const l = p.length - 2;
+    let sum = 0;
+    for (let i = 0; i < l; i += 2) {
+        sum += (p[i + 2] - p[i]) * (p[i + 1] + p[i + 3]);
+    }
+    sum += (p[0] - p[l]) * (p[l + 1] + p[1]);
+    return Math.abs(-sum * 0.5); // Handles -0
 }

package/src/index.ts

@@ -1,25 +1,25 @@
-export { Vec2 } from "./Vec2";
-export { Vec3 } from "./Vec3";
-export { Line2D } from "./Line2D";
-export { Line3D } from "./Line3D";
-export { Size2 } from "./Size2";
-export { Polygon } from "./Polygon";
-export { BoundingBox } from "./BoundingBox";
-export { Rectangle } from "./Rectangle";
-export { normalizeAngleDegrees } from "./normalizeAngleDegrees";
-export { normalizeAngleRadians } from "./normalizeAngleRadians";
-export { TwoPI, HalfPI } from "./MathConstants";
-export { Point2 } from "./Point2";
-export { Point3 } from "./Point3";
-export { isPointInPolygon } from "./isPointInPolygon";
-export { directions } from "./directions";
-export { directions2d } from "./directions2d";
-export { isContinuousClosedShape } from "./isContinuousClosedShape";
-export { polygonPerimeter } from "./polygonPerimeter";
-export { offsetPolyline } from "./offsetPolyline";
-export { extendOrTrimPolylinesAtIntersections } from "./extendOrTrimPolylinesAtIntersections";
-export { sortLinesByConnections } from "./sortLinesByConnections";
-export { isPolygonClockwise } from "./isPolygonClockwise";
-export { ensurePolygonClockwise } from "./ensurePolygonClockwise";
-export { containsPoint, containsPoints } from "./containsPoint";
+export { Vec2 } from "./Vec2";
+export { Vec3 } from "./Vec3";
+export { Line2D } from "./Line2D";
+export { Line3D } from "./Line3D";
+export { Size2 } from "./Size2";
+export { Polygon } from "./Polygon";
+export { BoundingBox } from "./BoundingBox";
+export { Rectangle } from "./Rectangle";
+export { normalizeAngleDegrees } from "./normalizeAngleDegrees";
+export { normalizeAngleRadians } from "./normalizeAngleRadians";
+export { TwoPI, HalfPI } from "./MathConstants";
+export { Point2 } from "./Point2";
+export { Point3 } from "./Point3";
+export { isPointInPolygon } from "./isPointInPolygon";
+export { directions } from "./directions";
+export { directions2d } from "./directions2d";
+export { isContinuousClosedShape } from "./isContinuousClosedShape";
+export { polygonPerimeter } from "./polygonPerimeter";
+export { offsetPolyline } from "./offsetPolyline";
+export { extendOrTrimPolylinesAtIntersections } from "./extendOrTrimPolylinesAtIntersections";
+export { sortLinesByConnections } from "./sortLinesByConnections";
+export { isPolygonClockwise } from "./isPolygonClockwise";
+export { ensurePolygonClockwise } from "./ensurePolygonClockwise";
+export { containsPoint, containsPoints } from "./containsPoint";
 export { getPolygonArea } from "./getPolygonArea";