@vived/core 1.0.0

package/src/ValueObjects/LineSegment2D.test.ts

@@ -0,0 +1,144 @@
+import { Vector2 } from "./Vector2";
+import { LineSegment2D } from "./LineSegment2D";
+
+test("Construction stores the start and end pos", () => {
+  const start = new Vector2(2, 3);
+  const end = new Vector2(4, 5);
+  const seg = new LineSegment2D(start, end);
+
+  expect(seg.end.x).toEqual(4);
+  expect(seg.end.y).toEqual(5);
+
+  expect(seg.start.x).toEqual(2);
+  expect(seg.start.y).toEqual(3);
+});
+
+test("Direction", () => {
+  const start = new Vector2(2, 3);
+  const end = new Vector2(2, 5);
+  const seg = new LineSegment2D(start, end);
+
+  expect(seg.direction.x).toEqual(0);
+  expect(seg.direction.y).toEqual(1);
+});
+
+test("Direction", () => {
+  const start = new Vector2(2, 3);
+  const end = new Vector2(-10, 3);
+  const seg = new LineSegment2D(start, end);
+
+  expect(seg.direction.x).toEqual(-1);
+  expect(seg.direction.y).toEqual(0);
+});
+
+test("Length", () => {
+  const start = new Vector2(0, 0);
+  const end = new Vector2(10, 0);
+  const seg = new LineSegment2D(start, end);
+
+  expect(seg.length).toEqual(10);
+});
+
+test("Position at percent", () => {
+  const start = new Vector2(0, 0);
+  const end = new Vector2(10, 0);
+  const seg = new LineSegment2D(start, end);
+
+  const zero = LineSegment2D.GetPositionAtPercent(seg, 0);
+  expect(zero.x).toEqual(0);
+  expect(zero.y).toEqual(0);
+
+  const one = LineSegment2D.GetPositionAtPercent(seg, 1);
+  expect(one.x).toEqual(10);
+  expect(one.y).toEqual(0);
+});
+
+test("Intersect", () => {
+  const lineA = new LineSegment2D(new Vector2(1, 1), new Vector2(15, 1));
+  const lineB = new LineSegment2D(new Vector2(10, -2), new Vector2(10, 2));
+
+  const intersection = LineSegment2D.Intersect(lineA, lineB);
+
+  expect(intersection?.x).toEqual(10);
+  expect(intersection?.y).toEqual(1);
+});
+
+test("Intersect with tolerance", () => {
+  const lineA = new LineSegment2D(new Vector2(1, 1), new Vector2(9.5, 1));
+  const lineB = new LineSegment2D(new Vector2(10, -2), new Vector2(10, 2));
+
+  const intersection1 = LineSegment2D.Intersect(lineA, lineB, 0.2);
+  expect(intersection1).toBeUndefined();
+
+  const intersection2 = LineSegment2D.Intersect(lineA, lineB, 0.5);
+
+  expect(intersection2?.x).toEqual(10);
+  expect(intersection2?.y).toEqual(1);
+});
+
+test("Parallel line should not intersect", () => {
+  const lineA = new LineSegment2D(new Vector2(1, 0), new Vector2(15, 0));
+  const lineB = new LineSegment2D(new Vector2(0, 0), new Vector2(10, 0));
+
+  const intersection = LineSegment2D.Intersect(lineA, lineB);
+
+  expect(intersection).toBeUndefined();
+});
+
+test("Short segments should not intersect", () => {
+  const lineA = new LineSegment2D(new Vector2(1, 1), new Vector2(9, 1));
+  const lineB = new LineSegment2D(new Vector2(10, -2), new Vector2(10, 2));
+
+  const intersection = LineSegment2D.Intersect(lineA, lineB);
+
+  expect(intersection).toBeUndefined();
+});
+
+test("Equality", () => {
+  const lineA = new LineSegment2D(new Vector2(1, 0), new Vector2(15, 0));
+  const lineB = new LineSegment2D(new Vector2(1, 0), new Vector2(15, 0));
+
+  expect(lineA).toEqual(lineB);
+});
+
+test("Closest point", () => {
+  const startPosition = new Vector2(-9, 2);
+  const endPosition = new Vector2(3, 2);
+  const line = new LineSegment2D(startPosition, endPosition);
+
+  const closestPoint = LineSegment2D.ClosestPointOnLine(
+    line,
+    new Vector2(1, 1)
+  );
+
+  expect(closestPoint.x).toEqual(1);
+  expect(closestPoint.y).toEqual(2);
+});
+
+test("Closest point should be clamped to the start", () => {
+  const startPosition = new Vector2(-9, 2);
+  const endPosition = new Vector2(3, 2);
+  const line = new LineSegment2D(startPosition, endPosition);
+
+  const closestPoint = LineSegment2D.ClosestPointOnLine(
+    line,
+    new Vector2(-12, 2)
+  );
+
+  expect(closestPoint.x).toEqual(-9);
+  expect(closestPoint.y).toEqual(2);
+});
+
+test("Closest point should be clamped to the end", () => {
+  const startPosition = new Vector2(-9, 2);
+  const endPosition = new Vector2(3, 2);
+  const line = new LineSegment2D(startPosition, endPosition);
+
+  const closestPoint = LineSegment2D.ClosestPointOnLine(
+    line,
+    new Vector2(5, 2)
+  );
+
+  expect(closestPoint.x).toEqual(3);
+  expect(closestPoint.y).toEqual(2);
+});

package/src/ValueObjects/LineSegment2D.ts

@@ -0,0 +1,93 @@
+import { Vector2 } from "./Vector2";
+
+export class LineSegment2D {
+  public static GetPositionAtPercent(
+    line: LineSegment2D,
+    percent: number
+  ): Vector2 {
+    const dir = line.direction;
+    const length = percent * line.length;
+
+    const localPos = Vector2.NewVectorOfLength(dir, length);
+
+    return Vector2.Add(line.start, localPos);
+  }
+
+  public static Intersect(
+    a: LineSegment2D,
+    b: LineSegment2D,
+    tolerance = 0
+  ): Vector2 | undefined {
+    // See https://en.wikipedia.org/wiki/Line%E2%80%93line_intersection
+    const x1 = a.start.x;
+    const y1 = a.start.y;
+    const x2 = a.end.x;
+    const y2 = a.end.y;
+    const x3 = b.start.x;
+    const y3 = b.start.y;
+    const x4 = b.end.x;
+    const y4 = b.end.y;
+
+    const denominator = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);
+    if (denominator === 0) {
+      return undefined;
+    }
+
+    const tNumerator = (x1 - x3) * (y3 - y4) - (y1 - y3) * (x3 - x4);
+    const t = tNumerator / denominator;
+
+    const tTolearnce = tolerance / a.length;
+    if (t < -tTolearnce || t > 1 + tTolearnce) {
+      return undefined;
+    }
+
+    const uNumerator = (x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3);
+    const u = uNumerator / denominator;
+
+    const uTolearnce = tolerance / b.length;
+    if (u < -uTolearnce || u > 1 + uTolearnce) return undefined;
+
+    const px = x1 + t * (x2 - x1);
+    const py = y1 + t * (y2 - y1);
+
+    return new Vector2(px, py);
+  }
+
+  public static ClosestPointOnLine(
+    line: LineSegment2D,
+    point: Vector2
+  ): Vector2 {
+    // see https://monkeyproofsolutions.nl/wordpress/how-to-calculate-the-shortest-distance-between-a-point-and-a-line/
+    let direction = Vector2.Subtract(line.end, line.start);
+    const pointToStart = Vector2.Subtract(point, line.start);
+    const tNumerator = Vector2.Dot(direction, pointToStart);
+    const tDenominator = Vector2.Dot(direction, direction);
+    const t = tNumerator / tDenominator;
+
+    if (t < 0) {
+      return line.start;
+    } else if (t > 1) {
+      return line.end;
+    } else {
+      const length = t * direction.magnitued;
+      direction = Vector2.NewVectorOfLength(direction, length);
+      return Vector2.Add(line.start, direction);
+    }
+  }
+
+  readonly start: Vector2;
+  readonly end: Vector2;
+
+  public get length(): number {
+    return Vector2.Subtract(this.start, this.end).magnitued;
+  }
+
+  public get direction(): Vector2 {
+    return Vector2.Subtract(this.end, this.start).unit;
+  }
+
+  constructor(start: Vector2, end: Vector2) {
+    this.start = start;
+    this.end = end;
+  }
+}