@immugio/three-math-extensions 0.1.0 → 0.2.0

package/src/BoundingBox.ts

@@ -0,0 +1,14 @@
+import { Vec2 } from "./Vec2";
+
+export class BoundingBox {
+  constructor(public minX: number, public maxX: number, public minY: number, public maxY: number) {
+  }
+
+  public equals(other: BoundingBox): boolean {
+    return this.minX === other.minX && this.maxX === other.maxX && this.minY === other.minY && this.maxY === other.maxY;
+  }
+
+  public get size(): Vec2 {
+    return new Vec2(this.maxX - this.minX, this.maxY - this.minY);
+  }
+}

package/src/Polygon.ts

@@ -1,19 +1,20 @@
 import { Point2 } from "./Point2";
 import { Vec2 } from "./Vec2";
-import { Size2 } from "./Size2";
+import { Rectangle } from "./Rectangle";
+import { BoundingBox } from "./BoundingBox";
 
 export class Polygon {
 
     constructor(public contour: Vec2[], public holes?: Vec2[][]) {
     }
 
-    public static fromPoints(contour: Point2[], holes?: Point2[][]) {
-        return new Polygon(contour.map(p => Vec2.fromPoint(p)), holes?.map(h => h.map(p => Vec2.fromPoint(p))));
+    public static fromPoints(contour: Point2[], holes?: Point2[][]): Polygon {
+        return new Polygon(contour.map(p => Vec2.fromPoint(p)), holes?.map(h => h.map(p => Vec2.fromPoint(p)))        );
     }
 
-    public get size(): Size2 {
-        const {minX, maxX, minY, maxY} = this.boundingBox();
-        return new Size2(maxX - minX, maxY - minY);
+    public get size(): Vec2 {
+        const { minX, maxX, minY, maxY } = this.boundingBox();
+        return new Vec2(maxX - minX, maxY - minY);
     }
 
     public centerOnOrigin(): Polygon {
@@ -36,7 +37,7 @@ export class Polygon {
     }
 
     public center(): Vec2 {
-        const {minX, maxX, minY, maxY} = this.boundingBox();
+        const { minX, maxX, minY, maxY } = this.boundingBox();
 
         const x = (maxX + minX) / 2;
         const y = (maxY + minY) / 2;
@@ -46,7 +47,7 @@ export class Polygon {
 
     public ensureLastPoint(): Polygon {
         function ensure(points: Vec2[]): void {
-            if (points[0].x !== points.at(-1).x || points[0].y !== points.at(-1).y) {
+            if (!points[0].equals(points.at(-1))) {
                 points.push(points[0].clone());
             }
         }
@@ -60,7 +61,7 @@ export class Polygon {
         return this;
     }
 
-    public boundingBox(): { minX: number, maxX: number, minY: number, maxY: number } {
+    public boundingBox(): BoundingBox {
         let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
 
         for (const p of this.contour) {
@@ -70,7 +71,7 @@ export class Polygon {
             if (maxY < p.y) maxY = p.y;
         }
 
-        return {minX, maxX, minY, maxY};
+        return new BoundingBox(minX, maxX, minY, maxY);
     }
 
     public toBoundingPolygon(): Polygon {
@@ -96,4 +97,47 @@ export class Polygon {
             point.x = point.x < centerX ? centerX + xDistanceToCenter : centerX - xDistanceToCenter;
         }
     }
-}
+
+    public toRectangle(): Rectangle {
+        const bounding = this.boundingBox();
+        return new Rectangle(bounding.minX, bounding.maxX, bounding.minY, bounding.maxY);
+    }
+
+    public clone(): Polygon {
+        return new Polygon(this.contour.map(p => p.clone()), this.holes?.map(h => h.map(p => p.clone())));
+    }
+
+    public equals(other: Polygon): boolean {
+        if (this.contour.length !== other.contour.length) {
+            return false;
+        }
+
+        for (let i = 0; i < this.contour.length; i++) {
+            if (!this.contour[i].equals(other.contour[i])) {
+                return false;
+            }
+        }
+
+        if (this.holes?.length !== other.holes?.length) {
+            return false;
+        }
+
+        for (let i = 0; i < this.holes?.length; i++) {
+            const hole = this.holes[i];
+            const otherHole = other.holes[i];
+
+            if (hole.length !== otherHole.length) {
+                return false;
+            }
+
+            for (let j = 0; j < hole.length; j++) {
+                if (!hole[j].equals(otherHole[j])) {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+}
+

package/src/Rectangle.ts

@@ -0,0 +1,93 @@
+import { Polygon } from "./Polygon";
+import { Vec2 } from "./Vec2";
+import { Point2 } from "./Point2";
+
+export class Rectangle {
+
+    constructor(public leftX: number, public rightX: number, public topY: number, public bottomY: number) { }
+
+    public clone(): Rectangle {
+        return new Rectangle(this.leftX, this.rightX, this.topY, this.bottomY);
+    }
+
+    public get size(): Vec2 {
+        return new Vec2(
+            this.rightX - this.leftX,
+            this.topY - this.bottomY
+        );
+    }
+
+    public get center(): Vec2 {
+        return new Vec2(
+            (this.leftX + this.rightX) / 2,
+            (this.topY + this.bottomY) / 2
+        );
+    }
+
+    public get offset(): Vec2 {
+        return new Vec2(
+            (this.leftX + this.rightX) / -2,
+            (this.topY + this.bottomY) / -2
+        );
+    }
+
+    public overlaps(other: Rectangle): boolean {
+        // Proof is by contradiction. Any one of four conditions guarantees that NO OVERLAP CAN EXIST.
+        const result = this.bottomY >= other.topY || this.topY <= other.bottomY || this.rightX <= other.leftX || this.leftX >= other.rightX;
+
+        return !result;
+    }
+
+    public get hasSize(): boolean {
+        return this.rightX - this.leftX > 1 && this.topY - this.bottomY > 1;
+    }
+
+    public translate(diff: Point2): Rectangle {
+        this.leftX += diff.x;
+        this.rightX += diff.x;
+        this.topY += diff.y;
+        this.bottomY += diff.y;
+
+        return this;
+    }
+
+    public centerOnOrigin(): Rectangle {
+        const center = this.center;
+        this.leftX -= center.x;
+        this.rightX -= center.x;
+        this.topY -= center.y;
+        this.bottomY -= center.y;
+
+        return this;
+    }
+
+    public toPolygon(): Polygon {
+        return new Polygon(this.toPoints());
+    }
+
+    /**
+     * The polygon is always constructed as "clockwise", assuming X axis to the right and Y axis down.
+     */
+    public toPoints(): Vec2[] {
+        return [
+            new Vec2(this.leftX, Math.min(this.topY, this.bottomY)),
+            new Vec2(this.rightX, Math.min(this.topY, this.bottomY)),
+            new Vec2(this.rightX, Math.max(this.topY, this.bottomY)),
+            new Vec2(this.leftX, Math.max(this.topY, this.bottomY)),
+        ];
+    }
+
+    public flipVertical(xCenter: number): Rectangle {
+        const left = xCenter - (this.rightX - xCenter);
+        const right = xCenter - (this.leftX - xCenter);
+
+        this.leftX = left;
+        this.rightX = right;
+
+        return this;
+    }
+
+    public equals(other: Rectangle): boolean {
+        return !!other && this.leftX === other.leftX && this.rightX === other.rightX && this.topY === other.topY && this.bottomY === other.bottomY;
+    }
+}

package/src/Vec3.ts

@@ -3,7 +3,7 @@ import { Vec2 } from "./Vec2";
 import { Point3 } from "./Point3";
 
 /**
- * Vec3 represents a 2D vector. It extends `Vector3` from the `threejs` library.
+ * Vec3 represents a 3D vector. It extends `Vector3` from the `threejs` library.
  */
 export class Vec3 extends Vector3 {
 

package/src/index.ts

@@ -1,4 +1,8 @@
 export { Vec2 } from "./Vec2";
 export { Vec3 } from "./Vec3";
 export { Line2D } from "./Line2D";
-export { Line3D } from "./Line3D";
+export { Line3D } from "./Line3D";
+export { Size2 } from "./Size2";
+export { Polygon } from "./Polygon";
+export { BoundingBox } from "./BoundingBox";
+export { Rectangle } from "./Rectangle";

package/types/BoundingBox.d.ts

@@ -0,0 +1,10 @@
+import { Vec2 } from "./Vec2";
+export declare class BoundingBox {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+    constructor(minX: number, maxX: number, minY: number, maxY: number);
+    equals(other: BoundingBox): boolean;
+    get size(): Vec2;
+}

package/types/Polygon.d.ts

@@ -1,22 +1,21 @@
 import { Point2 } from "./Point2";
 import { Vec2 } from "./Vec2";
-import { Size2 } from "./Size2";
+import { Rectangle } from "./Rectangle";
+import { BoundingBox } from "./BoundingBox";
 export declare class Polygon {
     contour: Vec2[];
     holes?: Vec2[][];
     constructor(contour: Vec2[], holes?: Vec2[][]);
     static fromPoints(contour: Point2[], holes?: Point2[][]): Polygon;
-    get size(): Size2;
+    get size(): Vec2;
     centerOnOrigin(): Polygon;
     center(): Vec2;
     ensureLastPoint(): Polygon;
-    boundingBox(): {
-        minX: number;
-        maxX: number;
-        minY: number;
-        maxY: number;
-    };
+    boundingBox(): BoundingBox;
     toBoundingPolygon(): Polygon;
     flip(): Polygon;
     private flipSingle;
+    toRectangle(): Rectangle;
+    clone(): Polygon;
+    equals(other: Polygon): boolean;
 }

package/types/Rectangle.d.ts

@@ -0,0 +1,25 @@
+import { Polygon } from "./Polygon";
+import { Vec2 } from "./Vec2";
+import { Point2 } from "./Point2";
+export declare class Rectangle {
+    leftX: number;
+    rightX: number;
+    topY: number;
+    bottomY: number;
+    constructor(leftX: number, rightX: number, topY: number, bottomY: number);
+    clone(): Rectangle;
+    get size(): Vec2;
+    get center(): Vec2;
+    get offset(): Vec2;
+    overlaps(other: Rectangle): boolean;
+    get hasSize(): boolean;
+    translate(diff: Point2): Rectangle;
+    centerOnOrigin(): Rectangle;
+    toPolygon(): Polygon;
+    /**
+     * The polygon is always constructed as "clockwise", assuming X axis to the right and Y axis down.
+     */
+    toPoints(): Vec2[];
+    flipVertical(xCenter: number): Rectangle;
+    equals(other: Rectangle): boolean;
+}

package/types/Vec3.d.ts

@@ -2,7 +2,7 @@ import { Vector3 } from "three";
 import { Vec2 } from "./Vec2";
 import { Point3 } from "./Point3";
 /**
- * Vec3 represents a 2D vector. It extends `Vector3` from the `threejs` library.
+ * Vec3 represents a 3D vector. It extends `Vector3` from the `threejs` library.
  */
 export declare class Vec3 extends Vector3 {
     #private;

package/types/index.d.ts

@@ -2,3 +2,7 @@ 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";