@gitborlando/geo 1.0.1

package/src/angle.ts

@@ -0,0 +1,55 @@
+export const { PI, cos, sin, tan, acos, asin, atan, atan2 } = Math
+
+export class Angle {
+  static Cos(angle: number) {
+    return cos(Angle.RadianFy(angle))
+  }
+
+  static Sin(angle: number) {
+    return 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 ATan(angle: number) {
+    return Angle.AngleFy(atan(Angle.RadianFy(angle)))
+  }
+
+  static ATan2(y: number, x: number) {
+    return Angle.AngleFy(atan2(y, x))
+  }
+
+  static AngleFy(radians: number) {
+    return radians * (180 / Math.PI)
+  }
+
+  static RadianFy(angle: number) {
+    return angle * (Math.PI / 180)
+  }
+
+  static Normal(angle: number) {
+    return (angle + 360) % 360
+  }
+
+  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,
+    }
+  }
+}

package/src/index.ts

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

package/src/math.ts

@@ -0,0 +1,22 @@
+export const { sqrt, abs, min, max, round, floor, ceil, random } = Math
+
+export function pow2(number: number) {
+  return Math.pow(number, 2)
+}
+export function pow3(number: number) {
+  return Math.pow(number, 3)
+}
+
+export function multiply(...numbers: number[]) {
+  return numbers.reduce((i, all) => (all *= i), 1)
+}
+export function divide(a: number, b: number) {
+  return b === 0 ? 1 : a / b
+}
+
+export function numberHalfFix(number: number) {
+  const integerPart = ~~number
+  const floatPart = number - integerPart
+  const halfFixed = floatPart >= 0.75 ? 1 : floatPart >= 0.25 ? 0.5 : 0
+  return integerPart + halfFixed
+}

package/src/matrix.ts

@@ -0,0 +1,48 @@
+import { AABB } from './aabb'
+import { max, min } from './math'
+import { IXY } from './types'
+import { xy_ } from './xy'
+
+export type IMatrix = [number, number, number, number, number, number]
+
+export class Matrix {
+  static Create() {
+    return [1, 0, 0, 1, 0, 0] as IMatrix
+  }
+
+  static Invert(matrix: IMatrix) {
+    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,
+    ) as IMatrix
+  }
+
+  static ApplyPoint(xy: IXY, matrix: IMatrix) {
+    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: AABB, matrix: IMatrix) {
+    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: IXY, matrix: IMatrix) {
+    return Matrix.ApplyPoint(xy, Matrix.Invert(matrix))
+  }
+
+  static InvertAABB(aabb: AABB, matrix: IMatrix) {
+    return Matrix.ApplyAABB(aabb, Matrix.Invert(matrix))
+  }
+}

package/src/obb.ts

@@ -0,0 +1,108 @@
+import { AABB } from './aabb'
+import { Angle } from './angle'
+import { IRect, IXY } from './types'
+import { xy_, xy_dot, xy_minus, xy_rotate } from './xy'
+
+type IAxis = { widthAxis: IXY; heightAxis: IXY }
+
+export class OBB {
+  center: IXY
+  axis: IAxis
+  aabb: AABB
+  vertexes: [IXY, IXY, IXY, IXY]
+
+  constructor(
+    public x: number,
+    public y: number,
+    public width: number,
+    public height: number,
+    public rotation: number,
+  ) {
+    this.center = this.#calcCenter()
+    this.axis = this.#calcAxis()
+    this.vertexes = this.calcVertexXY()
+    this.aabb = AABB.FromOBB(this)
+  }
+
+  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 cos = Angle.Cos(this.rotation)
+    const sin = Angle.Sin(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)
+  }
+
+  projectionLengthAt = (anotherAxis: IXY) => {
+    const { widthAxis, heightAxis } = this.axis
+    return (
+      Math.abs(xy_dot(widthAxis, anotherAxis)) * this.width +
+      Math.abs(xy_dot(heightAxis, anotherAxis)) * this.height
+    )
+  }
+
+  collide = (another: OBB) => {
+    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: IRect, rotation = 0): OBB {
+    const { x, y, width, height } = rect
+    return new OBB(x, y, width, height, rotation)
+  }
+
+  static FromAABB(aabb: AABB): OBB {
+    const { minX, minY, maxX, maxY } = aabb
+    return new OBB(minX, minY, maxX - minX, maxY - minY, 0)
+  }
+}

package/src/points-of-bezier.ts

@@ -0,0 +1,156 @@
+export type Point = {
+  x: number
+  y: number
+}
+
+// distance between 2 points
+function distance(p1: Point, p2: Point): number {
+  return Math.sqrt(distanceSq(p1, p2))
+}
+
+// distance between 2 points squared
+function distanceSq(p1: Point, p2: Point): number {
+  return Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2)
+}
+
+// Sistance squared from a point p to the line segment vw
+function distanceToSegmentSq(p: Point, v: Point, w: Point): number {
+  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: Point, b: Point, t: number): Point {
+  return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t }
+}
+
+// Adapted from https://seant23.wordpress.com/2010/11/12/offset-bezier-curves/
+function flatness(points: readonly Point[], offset: number): number {
+  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: readonly Point[],
+  offset: number,
+  tolerance: number,
+  newPoints?: Point[],
+): Point[] {
+  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 {
+    // subdivide
+    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
+}
+
+export function simplify(points: readonly Point[], distance: number): Point[] {
+  return simplifyPoints(points, 0, points.length, distance)
+}
+
+// Ramer–Douglas–Peucker algorithm
+// https://en.wikipedia.org/wiki/Ramer%E2%80%93Douglas%E2%80%93Peucker_algorithm
+export function simplifyPoints(
+  points: readonly Point[],
+  start: number,
+  end: number,
+  epsilon: number,
+  newPoints?: Point[],
+): Point[] {
+  const outPoints = newPoints || []
+
+  // find the most distance point from the endpoints
+  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 that point is too far, split
+  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
+}
+
+export function pointsOnBezierCurves(
+  points: readonly Point[],
+  tolerance: number = 0.15,
+  distance?: number,
+): Point[] {
+  const newPoints: Point[] = []
+  const numSegments = (points.length - 1) / 3
+  for (let i = 0; i < numSegments; i++) {
+    const offset = i * 3
+    getPointsOnBezierCurveWithSplitting(points, offset, tolerance, newPoints)
+  }
+  if (distance && distance > 0) {
+    return simplifyPoints(newPoints, 0, newPoints.length, distance)
+  }
+  return newPoints
+}

package/src/types.ts

@@ -0,0 +1,16 @@
+export interface IXY {
+  x: number
+  y: number
+}
+
+export interface IRect {
+  x: number
+  y: number
+  width: number
+  height: number
+}
+
+export interface IRectWithCenter extends IRect {
+  centerX: number
+  centerY: number
+}

package/src/xy.ts

@@ -0,0 +1,185 @@
+import { Angle } from './angle'
+import { sqrt } from './math'
+import { IXY } from './types'
+
+export function xy_(x: number = 0, y: number = 0) {
+  return { x, y }
+}
+
+export function xy_client(e: any) {
+  return { x: e.clientX, y: e.clientY }
+}
+
+export function xy_from(xy: IXY) {
+  return { x: xy.x, y: xy.y }
+}
+
+export function xy_center(xy: { centerX: number; centerY: number }) {
+  return { x: xy.centerX, y: xy.centerY }
+}
+
+export function xy_mutate(self: IXY, another: IXY) {
+  self.x = another.x
+  self.y = another.y
+}
+
+export function xy_plus(self: IXY, another: IXY) {
+  return { x: self.x + another.x, y: self.y + another.y }
+}
+export function xy_plus_mutate(self: IXY, another: IXY) {
+  self.x = self.x + another.x
+  self.y = self.y + another.y
+}
+export function xy_plus_all(...xys: IXY[]) {
+  return xys.reduce((a, b) => xy_plus(a, b))
+}
+
+export function xy_minus(self: IXY, another: IXY) {
+  return { x: self.x - another.x, y: self.y - another.y }
+}
+export function xy_minus_mutate(self: IXY, another: IXY) {
+  self.x = self.x - another.x
+  self.y = self.y - another.y
+}
+
+export function xy_multiply(self: IXY, ...numbers: number[]) {
+  const n = numbers.reduce((a, b) => a * b, 1)
+  return { x: self.x * n, y: self.y * n }
+}
+export function xy_multiply_mutate(self: IXY, ...numbers: number[]) {
+  const n = numbers.reduce((a, b) => a * b, 1)
+  self.x = self.x * n
+  self.y = self.y * n
+}
+
+export function xy_divide(self: IXY, ...numbers: number[]) {
+  const n = numbers.reduce((a, b) => a * b, 1)
+  return { x: self.x / n, y: self.y / n }
+}
+
+export function xy_distance(self: IXY, another: IXY = xy_(0, 0)) {
+  return Math.sqrt((self.x - another.x) ** 2 + (self.y - another.y) ** 2)
+}
+
+export function xy_rotate(self: IXY, origin: IXY, rotation: number) {
+  if (rotation === 0) return self
+  return Angle.RotatePoint(self.x, self.y, origin.x, origin.y, rotation)
+}
+
+export function xy_dot(self: IXY, another: IXY) {
+  return self.x * another.x + self.y * another.y
+}
+
+export function xy_symmetric(self: IXY, origin: IXY) {
+  return { x: 2 * origin.x - self.x, y: 2 * origin.y - self.y }
+}
+
+export function xy_opposite(self: IXY) {
+  return { x: -self.x, y: -self.y }
+}
+
+export function xy_getRotation(self: IXY, another: IXY, origin: IXY) {
+  return Angle.AngleFy(
+    Math.atan2(self.y - origin.y, self.x - origin.x) -
+      Math.atan2(another.y - origin.y, another.x - origin.x),
+  )
+}
+
+export function xy_toArray(self: IXY) {
+  return [self.x, self.y] as [number, number]
+}
+
+export function xy_xAxis(rotation: number) {
+  return { x: Angle.Cos(rotation), y: Angle.Sin(rotation) }
+}
+
+export function xy_yAxis(rotation: number) {
+  return { x: -Angle.Sin(rotation), y: Angle.Cos(rotation) }
+}
+
+export class XY {
+  constructor(
+    public x: number,
+    public y: number,
+  ) {}
+
+  from(xy: IXY) {
+    this.x = xy.x
+    this.y = xy.y
+    return this
+  }
+
+  client(e: { clientX: number; clientY: number }) {
+    this.x = e.clientX
+    this.y = e.clientY
+    return this
+  }
+
+  center(xy: { centerX: number; centerY: number }) {
+    this.x = xy.centerX
+    this.y = xy.centerY
+    return this
+  }
+
+  plus(another: IXY) {
+    this.x = this.x + another.x
+    this.y = this.y + another.y
+    return this
+  }
+
+  minus(another: IXY) {
+    this.x = this.x - another.x
+    this.y = this.y - another.y
+    return this
+  }
+
+  multiply(...numbers: number[]) {
+    const n = numbers.reduce((a, b) => a * b, 1)
+    this.x = this.x * n
+    this.y = this.y * n
+    return this
+  }
+
+  divide(...numbers: number[]) {
+    const n = numbers.reduce((a, b) => a * b, 1)
+    this.x = this.x / n
+    this.y = this.y / n
+    return this
+  }
+
+  distance(another: IXY) {
+    return sqrt((this.x - another.x) ** 2 + (this.y - another.y) ** 2)
+  }
+
+  rotate(origin: IXY, rotation: number) {
+    if (rotation === 0) return this
+    return Angle.RotatePoint(this.x, this.y, origin.x, origin.y, rotation)
+  }
+
+  dot(another: IXY) {
+    return this.x * another.x + this.y * another.y
+  }
+
+  opposite() {
+    return { x: -this.x, y: -this.y }
+  }
+
+  symmetric(another: IXY, origin: IXY) {
+    return { x: 2 * origin.x - another.x, y: 2 * origin.y - another.y }
+  }
+
+  angle(another: IXY, origin: IXY) {
+    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: IXY) {
+    return new XY(xy.x, xy.y)
+  }
+
+  static FromArray(arr: [number, number]) {
+    return new XY(arr[0], arr[1])
+  }
+}

package/tsup.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  outDir: 'dist',
+  format: ['esm'],
+  dts: true,
+  splitting: true,
+  clean: true,
+})

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    globals: true,
+  },
+})