@gitborlando/geo 1.0.1

package/dist/index.js

@@ -0,0 +1,558 @@
+// src/math.ts
+var { sqrt, abs, min, max, round, floor, ceil, random } = Math;
+function pow2(number) {
+  return Math.pow(number, 2);
+}
+function pow3(number) {
+  return Math.pow(number, 3);
+}
+function multiply(...numbers) {
+  return numbers.reduce((i, all) => all *= i, 1);
+}
+function divide(a, b) {
+  return b === 0 ? 1 : a / b;
+}
+function numberHalfFix(number) {
+  const integerPart = ~~number;
+  const floatPart = number - integerPart;
+  const halfFixed = floatPart >= 0.75 ? 1 : floatPart >= 0.25 ? 0.5 : 0;
+  return integerPart + halfFixed;
+}
+
+// src/angle.ts
+var { PI, cos, sin, tan, acos, asin, atan, atan2 } = Math;
+var Angle = class _Angle {
+  static Cos(angle) {
+    return cos(_Angle.RadianFy(angle));
+  }
+  static Sin(angle) {
+    return sin(_Angle.RadianFy(angle));
+  }
+  static Tan(angle) {
+    return tan(_Angle.RadianFy(angle));
+  }
+  static ACos(angle) {
+    return _Angle.AngleFy(acos(_Angle.RadianFy(angle)));
+  }
+  static ASin(angle) {
+    return _Angle.AngleFy(asin(_Angle.RadianFy(angle)));
+  }
+  static ATan(angle) {
+    return _Angle.AngleFy(atan(_Angle.RadianFy(angle)));
+  }
+  static ATan2(y, x) {
+    return _Angle.AngleFy(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;
+  }
+  static Snap(angle, step = 90) {
+    return _Angle.Normal(Math.round(angle / step) * step);
+  }
+  static RotatePoint(ax, ay, ox, oy, angle) {
+    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
+    };
+  }
+};
+
+// src/xy.ts
+function xy_(x = 0, y = 0) {
+  return { x, y };
+}
+function xy_client(e) {
+  return { x: e.clientX, y: e.clientY };
+}
+function xy_from(xy) {
+  return { x: xy.x, y: xy.y };
+}
+function xy_center(xy) {
+  return { x: xy.centerX, y: xy.centerY };
+}
+function xy_mutate(self, another) {
+  self.x = another.x;
+  self.y = another.y;
+}
+function xy_plus(self, another) {
+  return { x: self.x + another.x, y: self.y + another.y };
+}
+function xy_plus_mutate(self, another) {
+  self.x = self.x + another.x;
+  self.y = self.y + another.y;
+}
+function xy_plus_all(...xys) {
+  return xys.reduce((a, b) => xy_plus(a, b));
+}
+function xy_minus(self, another) {
+  return { x: self.x - another.x, y: self.y - another.y };
+}
+function xy_minus_mutate(self, another) {
+  self.x = self.x - another.x;
+  self.y = self.y - another.y;
+}
+function xy_multiply(self, ...numbers) {
+  const n = numbers.reduce((a, b) => a * b, 1);
+  return { x: self.x * n, y: self.y * n };
+}
+function xy_multiply_mutate(self, ...numbers) {
+  const n = numbers.reduce((a, b) => a * b, 1);
+  self.x = self.x * n;
+  self.y = self.y * n;
+}
+function xy_divide(self, ...numbers) {
+  const n = numbers.reduce((a, b) => a * b, 1);
+  return { x: self.x / n, y: self.y / n };
+}
+function xy_distance(self, another = xy_(0, 0)) {
+  return Math.sqrt((self.x - another.x) ** 2 + (self.y - another.y) ** 2);
+}
+function xy_rotate(self, origin, rotation) {
+  if (rotation === 0) return self;
+  return Angle.RotatePoint(self.x, self.y, origin.x, origin.y, rotation);
+}
+function xy_dot(self, another) {
+  return self.x * another.x + self.y * another.y;
+}
+function xy_symmetric(self, origin) {
+  return { x: 2 * origin.x - self.x, y: 2 * origin.y - self.y };
+}
+function xy_opposite(self) {
+  return { x: -self.x, y: -self.y };
+}
+function xy_getRotation(self, another, origin) {
+  return Angle.AngleFy(
+    Math.atan2(self.y - origin.y, self.x - origin.x) - Math.atan2(another.y - origin.y, another.x - origin.x)
+  );
+}
+function xy_toArray(self) {
+  return [self.x, self.y];
+}
+function xy_xAxis(rotation) {
+  return { x: Angle.Cos(rotation), y: Angle.Sin(rotation) };
+}
+function xy_yAxis(rotation) {
+  return { x: -Angle.Sin(rotation), y: Angle.Cos(rotation) };
+}
+var XY = class _XY {
+  constructor(x, y) {
+    this.x = x;
+    this.y = y;
+  }
+  from(xy) {
+    this.x = xy.x;
+    this.y = xy.y;
+    return this;
+  }
+  client(e) {
+    this.x = e.clientX;
+    this.y = e.clientY;
+    return this;
+  }
+  center(xy) {
+    this.x = xy.centerX;
+    this.y = xy.centerY;
+    return this;
+  }
+  plus(another) {
+    this.x = this.x + another.x;
+    this.y = this.y + another.y;
+    return this;
+  }
+  minus(another) {
+    this.x = this.x - another.x;
+    this.y = this.y - another.y;
+    return this;
+  }
+  multiply(...numbers) {
+    const n = numbers.reduce((a, b) => a * b, 1);
+    this.x = this.x * n;
+    this.y = this.y * n;
+    return this;
+  }
+  divide(...numbers) {
+    const n = numbers.reduce((a, b) => a * b, 1);
+    this.x = this.x / n;
+    this.y = this.y / n;
+    return this;
+  }
+  distance(another) {
+    return sqrt((this.x - another.x) ** 2 + (this.y - another.y) ** 2);
+  }
+  rotate(origin, rotation) {
+    if (rotation === 0) return this;
+    return Angle.RotatePoint(this.x, this.y, origin.x, origin.y, rotation);
+  }
+  dot(another) {
+    return this.x * another.x + this.y * another.y;
+  }
+  opposite() {
+    return { x: -this.x, y: -this.y };
+  }
+  symmetric(another, origin) {
+    return { x: 2 * origin.x - another.x, y: 2 * origin.y - another.y };
+  }
+  angle(another, origin) {
+    return Angle.AngleFy(
+      Math.atan2(this.y - origin.y, this.x - origin.x) - Math.atan2(another.y - origin.y, another.x - origin.x)
+    );
+  }
+  static From(xy) {
+    return new _XY(xy.x, xy.y);
+  }
+  static FromArray(arr) {
+    return new _XY(arr[0], arr[1]);
+  }
+};
+
+// 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 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 Expand(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) {
+    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);
+    });
+    return new _AABB(xMin, yMin, xMax, yMax);
+  }
+  static FromOBB(obb) {
+    const width = obb.projectionLengthAt(xy_(1, 0));
+    const height = obb.projectionLengthAt(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
+    );
+  }
+};
+
+// src/matrix.ts
+var Matrix = class _Matrix {
+  static Create() {
+    return [1, 0, 0, 1, 0, 0];
+  }
+  static Invert(matrix) {
+    const [a, b, c, d, e, f] = matrix;
+    const invDet = 1 / (a * d - b * c);
+    return [d, -b, -c, a, c * f - d * e, b * e - a * f].map(
+      (i) => i * invDet
+    );
+  }
+  static ApplyPoint(xy, matrix) {
+    const { x, y } = xy;
+    const [a, b, c, d, e, f] = matrix;
+    return xy_(a * x + c * y + e, b * x + d * y + f);
+  }
+  static ApplyAABB(aabb, matrix) {
+    const { minX, minY, maxX, maxY } = aabb;
+    const xy1 = _Matrix.ApplyPoint(xy_(minX, minY), matrix);
+    const xy2 = _Matrix.ApplyPoint(xy_(maxX, minY), matrix);
+    const xy3 = _Matrix.ApplyPoint(xy_(maxX, maxY), matrix);
+    const xy4 = _Matrix.ApplyPoint(xy_(minX, maxY), matrix);
+    return {
+      minX: min(xy1.x, xy2.x, xy3.x, xy4.x),
+      minY: min(xy1.y, xy2.y, xy3.y, xy4.y),
+      maxX: max(xy1.x, xy2.x, xy3.x, xy4.x),
+      maxY: max(xy1.y, xy2.y, xy3.y, xy4.y)
+    };
+  }
+  static InvertPoint(xy, matrix) {
+    return _Matrix.ApplyPoint(xy, _Matrix.Invert(matrix));
+  }
+  static InvertAABB(aabb, matrix) {
+    return _Matrix.ApplyAABB(aabb, _Matrix.Invert(matrix));
+  }
+};
+
+// 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_(this.x + this.width / 2, this.y + this.height / 2);
+    return xy_rotate(center, xy_(this.x, this.y), this.rotation);
+  };
+  #calcAxis = () => {
+    const cos2 = Angle.Cos(this.rotation);
+    const sin2 = Angle.Sin(this.rotation);
+    const widthAxis = xy_(cos2, -sin2);
+    const heightAxis = xy_(sin2, cos2);
+    return this.axis = { widthAxis, heightAxis };
+  };
+  calcVertexXY = () => {
+    const cos2 = Angle.Cos(this.rotation);
+    const sin2 = Angle.Sin(this.rotation);
+    const cosWidth = cos2 * this.width;
+    const sinWidth = sin2 * this.width;
+    const cosHeight = cos2 * this.height;
+    const sinHeight = sin2 * 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);
+  };
+  projectionLengthAt = (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_minus(this.center, another.center);
+    if (this.projectionLengthAt(another.axis.widthAxis) + another.width <= 2 * Math.abs(xy_dot(centerVector, another.axis.widthAxis)))
+      return false;
+    if (this.projectionLengthAt(another.axis.heightAxis) + another.height <= 2 * Math.abs(xy_dot(centerVector, another.axis.heightAxis)))
+      return false;
+    if (another.projectionLengthAt(this.axis.widthAxis) + this.width <= 2 * Math.abs(xy_dot(centerVector, this.axis.widthAxis)))
+      return false;
+    if (another.projectionLengthAt(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 FromAABB(aabb) {
+    const { minX, minY, maxX, maxY } = aabb;
+    return new _OBB(minX, minY, maxX - minX, maxY - minY, 0);
+  }
+};
+
+// src/points-of-bezier.ts
+function distance(p1, p2) {
+  return Math.sqrt(distanceSq(p1, p2));
+}
+function distanceSq(p1, p2) {
+  return Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2);
+}
+function distanceToSegmentSq(p, v, w) {
+  const l2 = distanceSq(v, w);
+  if (l2 === 0) {
+    return distanceSq(p, v);
+  }
+  let t = ((p.x - v.x) * (w.x - v.x) + (p.y - v.y) * (w.y - v.y)) / l2;
+  t = Math.max(0, Math.min(1, t));
+  return distanceSq(p, lerp(v, w, t));
+}
+function lerp(a, b, t) {
+  return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };
+}
+function flatness(points, offset) {
+  const p1 = points[offset + 0];
+  const p2 = points[offset + 1];
+  const p3 = points[offset + 2];
+  const p4 = points[offset + 3];
+  let ux = 3 * p2.x - 2 * p1.x - p4.x;
+  ux *= ux;
+  let uy = 3 * p2.y - 2 * p1.y - p4.y;
+  uy *= uy;
+  let vx = 3 * p3.x - 2 * p4.x - p1.x;
+  vx *= vx;
+  let vy = 3 * p3.y - 2 * p4.y - p1.y;
+  vy *= vy;
+  if (ux < vx) {
+    ux = vx;
+  }
+  if (uy < vy) {
+    uy = vy;
+  }
+  return ux + uy;
+}
+function getPointsOnBezierCurveWithSplitting(points, offset, tolerance, newPoints) {
+  const outPoints = newPoints || [];
+  if (flatness(points, offset) < tolerance) {
+    const p0 = points[offset + 0];
+    if (outPoints.length) {
+      const d = distance(outPoints[outPoints.length - 1], p0);
+      if (d > 1) {
+        outPoints.push(p0);
+      }
+    } else {
+      outPoints.push(p0);
+    }
+    outPoints.push(points[offset + 3]);
+  } else {
+    const t = 0.5;
+    const p1 = points[offset + 0];
+    const p2 = points[offset + 1];
+    const p3 = points[offset + 2];
+    const p4 = points[offset + 3];
+    const q1 = lerp(p1, p2, t);
+    const q2 = lerp(p2, p3, t);
+    const q3 = lerp(p3, p4, t);
+    const r1 = lerp(q1, q2, t);
+    const r2 = lerp(q2, q3, t);
+    const red = lerp(r1, r2, t);
+    getPointsOnBezierCurveWithSplitting([p1, q1, r1, red], 0, tolerance, outPoints);
+    getPointsOnBezierCurveWithSplitting([red, r2, q3, p4], 0, tolerance, outPoints);
+  }
+  return outPoints;
+}
+function simplify(points, distance2) {
+  return simplifyPoints(points, 0, points.length, distance2);
+}
+function simplifyPoints(points, start, end, epsilon, newPoints) {
+  const outPoints = newPoints || [];
+  const s = points[start];
+  const e = points[end - 1];
+  let maxDistSq = 0;
+  let maxNdx = 1;
+  for (let i = start + 1; i < end - 1; ++i) {
+    const distSq = distanceToSegmentSq(points[i], s, e);
+    if (distSq > maxDistSq) {
+      maxDistSq = distSq;
+      maxNdx = i;
+    }
+  }
+  if (Math.sqrt(maxDistSq) > epsilon) {
+    simplifyPoints(points, start, maxNdx + 1, epsilon, outPoints);
+    simplifyPoints(points, maxNdx, end, epsilon, outPoints);
+  } else {
+    if (!outPoints.length) {
+      outPoints.push(s);
+    }
+    outPoints.push(e);
+  }
+  return outPoints;
+}
+function pointsOnBezierCurves(points, tolerance = 0.15, distance2) {
+  const newPoints = [];
+  const numSegments = (points.length - 1) / 3;
+  for (let i = 0; i < numSegments; i++) {
+    const offset = i * 3;
+    getPointsOnBezierCurveWithSplitting(points, offset, tolerance, newPoints);
+  }
+  if (distance2 && distance2 > 0) {
+    return simplifyPoints(newPoints, 0, newPoints.length, distance2);
+  }
+  return newPoints;
+}
+export {
+  AABB,
+  Angle,
+  Matrix,
+  OBB,
+  PI,
+  XY,
+  abs,
+  acos,
+  asin,
+  atan,
+  atan2,
+  ceil,
+  cos,
+  divide,
+  floor,
+  max,
+  min,
+  multiply,
+  numberHalfFix,
+  pointsOnBezierCurves,
+  pow2,
+  pow3,
+  random,
+  round,
+  simplify,
+  simplifyPoints,
+  sin,
+  sqrt,
+  tan,
+  xy_,
+  xy_center,
+  xy_client,
+  xy_distance,
+  xy_divide,
+  xy_dot,
+  xy_from,
+  xy_getRotation,
+  xy_minus,
+  xy_minus_mutate,
+  xy_multiply,
+  xy_multiply_mutate,
+  xy_mutate,
+  xy_opposite,
+  xy_plus,
+  xy_plus_all,
+  xy_plus_mutate,
+  xy_rotate,
+  xy_symmetric,
+  xy_toArray,
+  xy_xAxis,
+  xy_yAxis
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@gitborlando/geo",
+  "version": "1.0.1",
+  "description": "",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./src/index.js",
+      "types": "./src/index.d.ts"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@vitest/ui": "^3.2.4",
+    "vitest": "^3.2.4"
+  },
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "tsup",
+    "clean": "rm -rf node_modules",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:ui": "vitest --ui"
+  }
+}

package/src/aabb.ts

@@ -0,0 +1,89 @@
+import { max, min } from './math'
+import { OBB } from './obb'
+import { IRectWithCenter } from './types'
+import { xy_ } from './xy'
+
+export class AABB {
+  constructor(
+    public minX: number,
+    public minY: number,
+    public maxX: number,
+    public maxY: number,
+  ) {}
+
+  static Rect(aabb: AABB): IRectWithCenter {
+    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 Collide(one: AABB, another: AABB): boolean {
+    return (
+      one.minX <= another.maxX &&
+      one.maxX >= another.minX &&
+      one.minY <= another.maxY &&
+      one.maxY >= another.minY
+    )
+  }
+
+  static Include(one: AABB, another: AABB) {
+    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 Expand(
+    aabb: AABB,
+    ...expands: [number] | [number, number, number, number]
+  ): AABB {
+    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: 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)
+    })
+    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))
+    return new AABB(
+      obb.center.x - width / 2,
+      obb.center.y - height / 2,
+      obb.center.x + width / 2,
+      obb.center.y + height / 2,
+    )
+  }
+}