@gitborlando/geo 4.1.0 → 5.1.0

package/dist/index.d.ts

@@ -0,0 +1,143 @@
+interface IXY {
+    x: number;
+    y: number;
+}
+interface IRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface IRectWithCenter extends IRect {
+    centerX: number;
+    centerY: number;
+}
+
+type IAxis = {
+    widthAxis: IXY;
+    heightAxis: IXY;
+};
+declare class OBB {
+    #private;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation: number;
+    center: IXY;
+    axis: IAxis;
+    aabb: AABB;
+    vertexes: [IXY, IXY, IXY, IXY];
+    constructor(x: number, y: number, width: number, height: number, rotation: number);
+    get xy(): {
+        x: number;
+        y: number;
+    };
+    calcVertexXY: () => [{
+        x: number;
+        y: number;
+    }, {
+        x: number;
+        y: number;
+    }, {
+        x: number;
+        y: number;
+    }, {
+        x: number;
+        y: number;
+    }];
+    clone: () => OBB;
+    projectAt: (anotherAxis: IXY) => number;
+    collide: (another: OBB) => boolean;
+    static identityOBB(): OBB;
+    static fromRect(rect: IRect, rotation?: number): OBB;
+    static fromCenter(center: IXY, width: number, height: number, rotation?: number): OBB;
+    static fromAABB(aabb: AABB): OBB;
+}
+
+declare class AABB {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    constructor(minX: number, minY: number, maxX: number, maxY: number);
+    static rect(aabb: AABB): IRectWithCenter;
+    static rectTuple(aabb: AABB): readonly [number, number, number, number];
+    static update(aabb: AABB, minX: number, minY: number, maxX: number, maxY: number): AABB;
+    static updateFromRect(aabb: AABB, rect: IRect): AABB;
+    static shift(aabb: AABB, delta: IXY): AABB;
+    static collide(one: AABB, another: AABB): boolean;
+    static include(one: AABB, another: AABB): number;
+    static extend(aabb: AABB, ...expands: [number] | [number, number, number, number]): AABB;
+    static merge(aabbList: AABB[] | Set<AABB>): AABB;
+    static fromOBB(obb: OBB): AABB;
+    static updateFromOBB(aabb: AABB, obb: OBB): AABB;
+}
+
+declare class Angle {
+    static cos(angle: number): number;
+    static sin(angle: number): number;
+    static cosSin(angle: number): {
+        cos: number;
+        sin: number;
+    };
+    static tan(angle: number): number;
+    static atan2(y: number, x: number): number;
+    static angleFy(radians: number): number;
+    static radianFy(angle: number): number;
+    static normal(angle: number): number;
+    static minor(angle: number): number;
+    static snap(angle: number, step?: number): number;
+    static sweep(v1: IXY, v2?: IXY, clockwise?: boolean): number;
+}
+
+declare function twoDecimal(number: number): number;
+declare function minMax(val: number, min: number, max: number): number;
+
+declare class XY {
+    x: number;
+    y: number;
+    constructor(x: number, y: number);
+    $(): {
+        x: number;
+        y: number;
+    };
+    tuple(): readonly [number, number];
+    plus(...others: IXY[]): this;
+    plusNum(num: number): this;
+    minus(...others: IXY[]): this;
+    multiply(...numbers: number[]): this;
+    multiplyNum(num: number): this;
+    divide(...numbers: number[]): this;
+    rotate(origin: IXY, rotation: number): this;
+    static $(x?: number, y?: number): {
+        x: number;
+        y: number;
+    };
+    static of(xy: IXY): XY;
+    static from(x: number, y: number): XY;
+    static center(wh: {
+        width: number;
+        height: number;
+    }): XY;
+    static leftTop(e: {
+        left: number;
+        top: number;
+    }): XY;
+    static client(e: {
+        clientX: number;
+        clientY: number;
+    }): XY;
+    static xAxis(rotation?: number): XY;
+    static yAxis(rotation?: number): XY;
+    static dot(self: IXY, another: IXY): number;
+    static distance(self: IXY, another: IXY): number;
+    static vector(self: IXY, another: IXY): XY;
+    static symmetric(self: IXY, origin?: {
+        x: number;
+        y: number;
+    }): XY;
+    static lerp(self: IXY, origin: IXY, t: number): XY;
+}
+
+export { AABB, Angle, type IRect, type IRectWithCenter, type IXY, OBB, XY, minMax, twoDecimal };

package/dist/index.js

@@ -0,0 +1,348 @@
+// src/angle.ts
+var Angle = class _Angle {
+  static cos(angle) {
+    return Math.cos(_Angle.radianFy(angle));
+  }
+  static sin(angle) {
+    return Math.sin(_Angle.radianFy(angle));
+  }
+  static cosSin(angle) {
+    const radians = _Angle.radianFy(angle);
+    return { cos: Math.cos(radians), sin: Math.sin(radians) };
+  }
+  static tan(angle) {
+    return Math.tan(_Angle.radianFy(angle));
+  }
+  static atan2(y, x) {
+    return _Angle.angleFy(Math.atan2(y, x));
+  }
+  static angleFy(radians) {
+    return radians * (180 / Math.PI);
+  }
+  static radianFy(angle) {
+    return angle * (Math.PI / 180);
+  }
+  static normal(angle) {
+    return (angle % 360 + 360) % 360;
+  }
+  static minor(angle) {
+    return Math.min(angle, 360 - angle);
+  }
+  static snap(angle, step = 90) {
+    return _Angle.normal(Math.round(angle / step) * step);
+  }
+  static sweep(v1, v2 = XY.xAxis(), clockwise = false) {
+    const dot = v1.x * v2.x + v1.y * v2.y;
+    const det = v1.x * v2.y - v1.y * v2.x;
+    return _Angle.normal(_Angle.atan2(det, dot) * (clockwise ? 1 : -1));
+  }
+};
+
+// src/xy.ts
+var XY = class _XY {
+  constructor(x, y) {
+    this.x = x;
+    this.y = y;
+  }
+  $() {
+    return { x: this.x, y: this.y };
+  }
+  tuple() {
+    return [this.x, this.y];
+  }
+  plus(...others) {
+    this.x = others.reduce((sum, cur) => sum + cur.x, this.x);
+    this.y = others.reduce((sum, cur) => sum + cur.y, this.y);
+    return this;
+  }
+  plusNum(num) {
+    this.x += num;
+    this.y += num;
+    return this;
+  }
+  minus(...others) {
+    this.x = others.reduce((sum, cur) => sum - cur.x, this.x);
+    this.y = others.reduce((sum, cur) => sum - cur.y, this.y);
+    return this;
+  }
+  multiply(...numbers) {
+    const n = numbers.reduce((a, b) => a * b, 1);
+    this.x *= n;
+    this.y *= n;
+    return this;
+  }
+  multiplyNum(num) {
+    this.x *= num;
+    this.y *= num;
+    return this;
+  }
+  divide(...numbers) {
+    const n = numbers.reduce((a, b) => a * b, 1);
+    this.x /= n;
+    this.y /= n;
+    return this;
+  }
+  rotate(origin, rotation) {
+    const { cos, sin } = Angle.cosSin(rotation);
+    const dx = this.x - origin.x;
+    const dy = this.y - origin.y;
+    this.x = dx * cos - dy * sin + origin.x;
+    this.y = dx * sin + dy * cos + origin.y;
+    return this;
+  }
+  static $(x = 0, y = 0) {
+    return { x, y };
+  }
+  static of(xy) {
+    return new _XY(xy.x, xy.y);
+  }
+  static from(x, y) {
+    return new _XY(x, y);
+  }
+  static center(wh) {
+    return new _XY(wh.width / 2, wh.height / 2);
+  }
+  static leftTop(e) {
+    return new _XY(e.left, e.top);
+  }
+  static client(e) {
+    return new _XY(e.clientX, e.clientY);
+  }
+  static xAxis(rotation = 0) {
+    const { cos, sin } = Angle.cosSin(rotation);
+    return new _XY(cos, sin);
+  }
+  static yAxis(rotation = 0) {
+    const { cos, sin } = Angle.cosSin(rotation);
+    return new _XY(-sin, cos);
+  }
+  static dot(self, another) {
+    return self.x * another.x + self.y * another.y;
+  }
+  static distance(self, another) {
+    return Math.hypot(self.x - another.x, self.y - another.y);
+  }
+  static vector(self, another) {
+    return new _XY(self.x - another.x, self.y - another.y);
+  }
+  static symmetric(self, origin = _XY.$()) {
+    return new _XY(2 * origin.x - self.x, 2 * origin.y - self.y);
+  }
+  static lerp(self, origin, t) {
+    const distance = _XY.distance(self, origin);
+    return new _XY(
+      self.x + (self.x - origin.x) * (t / distance),
+      self.y + (self.y - origin.y) * (t / distance)
+    );
+  }
+};
+
+// src/aabb.ts
+var AABB = class _AABB {
+  constructor(minX, minY, maxX, maxY) {
+    this.minX = minX;
+    this.minY = minY;
+    this.maxX = maxX;
+    this.maxY = maxY;
+  }
+  static rect(aabb) {
+    return {
+      x: aabb.minX,
+      y: aabb.minY,
+      width: aabb.maxX - aabb.minX,
+      height: aabb.maxY - aabb.minY,
+      centerX: aabb.minX + (aabb.maxX - aabb.minX) / 2,
+      centerY: aabb.minY + (aabb.maxY - aabb.minY) / 2
+    };
+  }
+  static rectTuple(aabb) {
+    return [
+      aabb.minX,
+      aabb.minY,
+      aabb.maxX - aabb.minX,
+      aabb.maxY - aabb.minY
+    ];
+  }
+  static update(aabb, minX, minY, maxX, maxY) {
+    aabb.minX = minX;
+    aabb.minY = minY;
+    aabb.maxX = maxX;
+    aabb.maxY = maxY;
+    return aabb;
+  }
+  static updateFromRect(aabb, rect) {
+    return _AABB.update(
+      aabb,
+      rect.x,
+      rect.y,
+      rect.x + rect.width,
+      rect.y + rect.height
+    );
+  }
+  static shift(aabb, delta) {
+    aabb.minX += delta.x;
+    aabb.minY += delta.y;
+    aabb.maxX += delta.x;
+    aabb.maxY += delta.y;
+    return aabb;
+  }
+  static collide(one, another) {
+    return one.minX <= another.maxX && one.maxX >= another.minX && one.minY <= another.maxY && one.maxY >= another.minY;
+  }
+  static include(one, another) {
+    let result = 1;
+    let [large, small] = [one, another];
+    if (one.maxX - one.minX < another.maxX - another.minX) {
+      result = 0;
+      large = another;
+      small = one;
+    }
+    const included = large.minX <= small.minX && large.maxX >= small.maxX && large.minY <= small.minY && large.maxY >= small.maxY;
+    return included ? result : -1;
+  }
+  static extend(aabb, ...expands) {
+    const { minX, minY, maxX, maxY } = aabb;
+    if (expands.length === 1) {
+      const expand = expands[0];
+      return new _AABB(minX - expand, minY - expand, maxX + expand, maxY + expand);
+    } else {
+      return new _AABB(
+        minX - expands[0],
+        minY - expands[1],
+        maxX + expands[2],
+        maxY + expands[3]
+      );
+    }
+  }
+  static merge(aabbList) {
+    if (Array.isArray(aabbList)) {
+      if (aabbList.length === 0) return new _AABB(0, 0, 0, 0);
+    } else {
+      if (aabbList.size === 0) return new _AABB(0, 0, 0, 0);
+    }
+    let xMin = Infinity, yMin = Infinity, xMax = -Infinity, yMax = -Infinity;
+    for (const aabb of aabbList) {
+      xMin = Math.min(xMin, aabb.minX);
+      yMin = Math.min(yMin, aabb.minY);
+      xMax = Math.max(xMax, aabb.maxX);
+      yMax = Math.max(yMax, aabb.maxY);
+    }
+    return new _AABB(xMin, yMin, xMax, yMax);
+  }
+  static fromOBB(obb) {
+    const width = obb.projectAt(XY.$(1, 0));
+    const height = obb.projectAt(XY.$(0, 1));
+    return new _AABB(
+      obb.center.x - width / 2,
+      obb.center.y - height / 2,
+      obb.center.x + width / 2,
+      obb.center.y + height / 2
+    );
+  }
+  static updateFromOBB(aabb, obb) {
+    const width = obb.projectAt(XY.$(1, 0));
+    const height = obb.projectAt(XY.$(0, 1));
+    aabb.minX = obb.center.x - width / 2;
+    aabb.minY = obb.center.y - height / 2;
+    aabb.maxX = obb.center.x + width / 2;
+    aabb.maxY = obb.center.y + height / 2;
+    return aabb;
+  }
+};
+
+// src/misc.ts
+function twoDecimal(number) {
+  return Number(number.toFixed(Number.isInteger(number) ? 0 : 2));
+}
+function minMax(val, min, max) {
+  return Math.min(Math.max(val, min), max);
+}
+
+// src/obb.ts
+var OBB = class _OBB {
+  constructor(x, y, width, height, rotation) {
+    this.x = x;
+    this.y = y;
+    this.width = width;
+    this.height = height;
+    this.rotation = rotation;
+    this.center = this.#calcCenter();
+    this.axis = this.#calcAxis();
+    this.vertexes = this.calcVertexXY();
+    this.aabb = AABB.fromOBB(this);
+  }
+  center;
+  axis;
+  aabb;
+  vertexes;
+  get xy() {
+    return XY.$(this.x, this.y);
+  }
+  #calcCenter = () => {
+    const center = XY.center(this);
+    return center.rotate(this.xy, this.rotation);
+  };
+  #calcAxis = () => {
+    const { cos, sin } = Angle.cosSin(this.rotation);
+    const widthAxis = XY.$(cos, -sin);
+    const heightAxis = XY.$(sin, cos);
+    return this.axis = { widthAxis, heightAxis };
+  };
+  calcVertexXY = () => {
+    const cos = Angle.cos(this.rotation);
+    const sin = Angle.sin(this.rotation);
+    const cosWidth = cos * this.width;
+    const sinWidth = sin * this.width;
+    const cosHeight = cos * this.height;
+    const sinHeight = sin * this.height;
+    const TL = XY.$(this.x, this.y);
+    const TR = XY.$(this.x + cosWidth, this.y + sinWidth);
+    const BR = XY.$(this.x + cosWidth - sinHeight, this.y + sinWidth + cosHeight);
+    const BL = XY.$(this.x - sinHeight, this.y + cosHeight);
+    return this.vertexes = [TL, TR, BR, BL];
+  };
+  clone = () => {
+    return new _OBB(this.x, this.y, this.width, this.height, this.rotation);
+  };
+  projectAt = (anotherAxis) => {
+    const { widthAxis, heightAxis } = this.axis;
+    return Math.abs(XY.dot(widthAxis, anotherAxis)) * this.width + Math.abs(XY.dot(heightAxis, anotherAxis)) * this.height;
+  };
+  collide = (another) => {
+    const centerVector = XY.vector(this.center, another.center);
+    if (this.projectAt(another.axis.widthAxis) + another.width <= 2 * Math.abs(XY.dot(centerVector, another.axis.widthAxis)))
+      return false;
+    if (this.projectAt(another.axis.heightAxis) + another.height <= 2 * Math.abs(XY.dot(centerVector, another.axis.heightAxis)))
+      return false;
+    if (another.projectAt(this.axis.widthAxis) + this.width <= 2 * Math.abs(XY.dot(centerVector, this.axis.widthAxis)))
+      return false;
+    if (another.projectAt(this.axis.heightAxis) + this.height <= 2 * Math.abs(XY.dot(centerVector, this.axis.heightAxis)))
+      return false;
+    return true;
+  };
+  static identityOBB() {
+    return new _OBB(0, 0, 0, 0, 0);
+  }
+  static fromRect(rect, rotation = 0) {
+    const { x, y, width, height } = rect;
+    return new _OBB(x, y, width, height, rotation);
+  }
+  static fromCenter(center, width, height, rotation = 0) {
+    const dx = center.x - width / 2;
+    const dy = center.y - height / 2;
+    const xy = XY.from(dx, dy).rotate(center, rotation);
+    return new _OBB(xy.x, xy.y, width, height, rotation);
+  }
+  static fromAABB(aabb) {
+    const { minX, minY, maxX, maxY } = aabb;
+    return new _OBB(minX, minY, maxX - minX, maxY - minY, 0);
+  }
+};
+export {
+  AABB,
+  Angle,
+  OBB,
+  XY,
+  minMax,
+  twoDecimal
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gitborlando/geo",
-  "version": "4.1.0",
+  "version": "5.1.0",
   "description": "",
   "type": "module",
   "exports": {
@@ -9,6 +9,10 @@
       "types": "./dist/index.d.ts"
     }
   },
+  "files": [
+    "dist",
+    "src"
+  ],
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"

package/src/aabb.ts

@@ -1,6 +1,5 @@
-import { max, min } from './math'
 import { OBB } from './obb'
-import { IRectWithCenter } from './types'
+import { IRect, IRectWithCenter, IXY } from './types'
 import { XY } from './xy'
 
 export class AABB {
@@ -31,6 +30,32 @@ export class AABB {
     ] as const
   }
 
+  static update(aabb: AABB, minX: number, minY: number, maxX: number, maxY: number) {
+    aabb.minX = minX
+    aabb.minY = minY
+    aabb.maxX = maxX
+    aabb.maxY = maxY
+    return aabb
+  }
+
+  static updateFromRect(aabb: AABB, rect: IRect) {
+    return AABB.update(
+      aabb,
+      rect.x,
+      rect.y,
+      rect.x + rect.width,
+      rect.y + rect.height,
+    )
+  }
+
+  static shift(aabb: AABB, delta: IXY) {
+    aabb.minX += delta.x
+    aabb.minY += delta.y
+    aabb.maxX += delta.x
+    aabb.maxY += delta.y
+    return aabb
+  }
+
   static collide(one: AABB, another: AABB): boolean {
     return (
       one.minX <= another.maxX &&
@@ -74,20 +99,29 @@ export class AABB {
     }
   }
 
-  static merge(...aabbList: AABB[]) {
-    let [xMin, yMin, xMax, yMax] = [Infinity, Infinity, -Infinity, -Infinity]
-    aabbList.forEach((aabb) => {
-      xMin = min(xMin, aabb.minX)
-      yMin = min(yMin, aabb.minY)
-      xMax = max(xMax, aabb.maxX)
-      yMax = max(yMax, aabb.maxY)
-    })
+  static merge(aabbList: AABB[] | Set<AABB>) {
+    if (Array.isArray(aabbList)) {
+      if (aabbList.length === 0) return new AABB(0, 0, 0, 0)
+    } else {
+      if (aabbList.size === 0) return new AABB(0, 0, 0, 0)
+    }
+
+    let xMin = Infinity,
+      yMin = Infinity,
+      xMax = -Infinity,
+      yMax = -Infinity
+    for (const aabb of aabbList) {
+      xMin = Math.min(xMin, aabb.minX)
+      yMin = Math.min(yMin, aabb.minY)
+      xMax = Math.max(xMax, aabb.maxX)
+      yMax = Math.max(yMax, aabb.maxY)
+    }
     return new AABB(xMin, yMin, xMax, yMax)
   }
 
   static fromOBB(obb: OBB) {
-    const width = obb.projectionLengthAt(XY._(1, 0))
-    const height = obb.projectionLengthAt(XY._(0, 1))
+    const width = obb.projectAt(XY.$(1, 0))
+    const height = obb.projectAt(XY.$(0, 1))
     return new AABB(
       obb.center.x - width / 2,
       obb.center.y - height / 2,
@@ -95,4 +129,14 @@ export class AABB {
       obb.center.y + height / 2,
     )
   }
+
+  static updateFromOBB(aabb: AABB, obb: OBB) {
+    const width = obb.projectAt(XY.$(1, 0))
+    const height = obb.projectAt(XY.$(0, 1))
+    aabb.minX = obb.center.x - width / 2
+    aabb.minY = obb.center.y - height / 2
+    aabb.maxX = obb.center.x + width / 2
+    aabb.maxY = obb.center.y + height / 2
+    return aabb
+  }
 }

package/src/angle.ts

@@ -1,32 +1,26 @@
-export const { PI, cos, sin, tan, acos, asin, atan, atan2 } = Math
+import { IXY } from './types'
+import { XY } from './xy'
 
 export class Angle {
   static cos(angle: number) {
-    return cos(Angle.radianFy(angle))
+    return Math.cos(Angle.radianFy(angle))
   }
 
   static sin(angle: number) {
-    return sin(Angle.radianFy(angle))
+    return Math.sin(Angle.radianFy(angle))
   }
 
-  static tan(angle: number) {
-    return tan(Angle.radianFy(angle))
-  }
-
-  static acos(angle: number) {
-    return Angle.angleFy(acos(Angle.radianFy(angle)))
-  }
-
-  static asin(angle: number) {
-    return Angle.angleFy(asin(Angle.radianFy(angle)))
+  static cosSin(angle: number) {
+    const radians = Angle.radianFy(angle)
+    return { cos: Math.cos(radians), sin: Math.sin(radians) }
   }
 
-  static atan(angle: number) {
-    return Angle.angleFy(atan(Angle.radianFy(angle)))
+  static tan(angle: number) {
+    return Math.tan(Angle.radianFy(angle))
   }
 
   static atan2(y: number, x: number) {
-    return Angle.angleFy(atan2(y, x))
+    return Angle.angleFy(Math.atan2(y, x))
   }
 
   static angleFy(radians: number) {
@@ -38,18 +32,20 @@ export class Angle {
   }
 
   static normal(angle: number) {
-    return (angle + 360) % 360
+    return ((angle % 360) + 360) % 360
+  }
+
+  static minor(angle: number) {
+    return Math.min(angle, 360 - angle)
   }
 
   static snap(angle: number, step = 90) {
     return Angle.normal(Math.round(angle / step) * step)
   }
 
-  static rotatePoint(ax: number, ay: number, ox: number, oy: number, angle: number) {
-    const radian = Angle.radianFy(angle)
-    return {
-      x: (ax - ox) * cos(radian) - (ay - oy) * sin(radian) + ox,
-      y: (ax - ox) * sin(radian) + (ay - oy) * cos(radian) + oy,
-    }
+  static sweep(v1: IXY, v2: IXY = XY.xAxis(), clockwise = false) {
+    const dot = v1.x * v2.x + v1.y * v2.y
+    const det = v1.x * v2.y - v1.y * v2.x
+    return Angle.normal(Angle.atan2(det, dot) * (clockwise ? 1 : -1))
   }
 }

package/src/index.ts

@@ -1,8 +1,6 @@
 export * from './aabb'
 export * from './angle'
-export * from './math'
-export * from './matrix'
+export * from './misc'
 export * from './obb'
-export * from './points-of-bezier'
 export * from './types'
 export * from './xy'

package/src/misc.ts

@@ -0,0 +1,7 @@
+export function twoDecimal(number: number) {
+  return Number(number.toFixed(Number.isInteger(number) ? 0 : 2))
+}
+
+export function minMax(val: number, min: number, max: number) {
+  return Math.min(Math.max(val, min), max)
+}