@escapace/minimum-perimeter-triangle 0.1.0

package/lib/cjs/index.cjs

@@ -0,0 +1,590 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  lineTangentToHull: () => lineTangentToHull,
+  minTriangle: () => minTriangle,
+  minTriangleWithBase: () => minTriangleWithBase
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/line.ts
+var Line = class {
+  start;
+  end;
+  delta;
+  constructor(start, end) {
+    this.start = start;
+    this.end = end;
+    this.delta = end.minus(start);
+  }
+  /**
+   * Length of a line is the length between its two defining points
+   */
+  get length() {
+    return this.delta.norm;
+  }
+  evaluate(t) {
+    return this.start.plus(this.delta.times(t));
+  }
+  distanceToPoint(p) {
+    return Math.abs(p.cross(this.delta) - this.start.cross(this.end)) / this.delta.norm;
+  }
+  pointOnSide(p, err = 0) {
+    const num = this.start.cross(this.end) - p.cross(this.delta);
+    if (num === 0 || Math.abs(num) / this.delta.norm < err) {
+      return 0 /* Top */;
+    }
+    return num > 0 ? 1 /* Left */ : -1 /* Right */;
+  }
+  pointOnTop(p, err) {
+    return this.pointOnSide(p, err) === 0 /* Top */;
+  }
+  overlaps(that, err) {
+    return this.pointOnTop(that.start, err) && this.pointOnTop(that.end, err);
+  }
+  /**
+   *  If alpha is less than deviationFromZeroAngle, the 2 lines are
+   *  considered parallel.
+   *  _______________________________
+   *                        alpha (/
+   *                              /
+   *                             /
+   *                            /
+   */
+  parallel(that, deviationFromZeroAngle) {
+    const d = Math.abs(this.delta.cross(that.delta));
+    return d === 0 || d < this.length * this.length * Math.sin(deviationFromZeroAngle);
+  }
+  intersectionParameter(that, err) {
+    const d = this.delta.cross(that.delta);
+    if (d === 0 || Math.abs(d) < err) {
+      return null;
+    }
+    const dStart = this.start.minus(that.start);
+    return that.delta.cross(dStart) / d;
+  }
+  closestPointParam(p) {
+    return this.delta.dot(p.minus(this.start)) / this.delta.normSquared;
+  }
+  closestPoint(p) {
+    return this.evaluate(this.closestPointParam(p));
+  }
+  intersectionPoint(that, err) {
+    const t = this.intersectionParameter(that, err);
+    return t === null ? null : this.evaluate(t);
+  }
+};
+
+// src/vec2.ts
+var Vec2 = class {
+  _x;
+  _y;
+  _normSquared;
+  _norm;
+  _normalized;
+  constructor(x, y) {
+    this._x = x;
+    this._y = y;
+  }
+  times(s) {
+    return new Vec2(this._x * s, this._y * s);
+  }
+  over(s) {
+    return new Vec2(this._x / s, this._y / s);
+  }
+  get x() {
+    return this._x;
+  }
+  get y() {
+    return this._y;
+  }
+  plus(that) {
+    return new Vec2(this._x + that._x, this._y + that._y);
+  }
+  minus(that) {
+    return new Vec2(this._x - that._x, this._y - that._y);
+  }
+  get normSquared() {
+    return this._normSquared === void 0 ? this._normSquared = this.dot(this) : this._normSquared;
+  }
+  get norm() {
+    return this._norm === void 0 ? this._norm = Math.sqrt(this.normSquared) : this._norm;
+  }
+  get normalized() {
+    return this._normalized === void 0 ? this._normalized = this.over(this.norm) : this._normalized;
+  }
+  dot(that) {
+    return this._x * that._x + this._y * that._y;
+  }
+  cross(that) {
+    return this._x * that._y - this._y * that._x;
+  }
+  equals(that, err) {
+    if (err === 0) {
+      return this.x === that.x && this.y === that.y;
+    }
+    return this.minus(that).normSquared < err * err;
+  }
+  normal() {
+    return new Vec2(this._y, -this._x);
+  }
+  toString() {
+    return `(${this.x}, ${this.y})`;
+  }
+};
+
+// src/inscribe.ts
+var Wedge = class {
+  leftArm;
+  rightArm;
+  isDegenerate;
+  constructor(leftArm, rightArm, isDegenerate = false) {
+    this.leftArm = leftArm;
+    this.rightArm = rightArm;
+    this.isDegenerate = isDegenerate;
+  }
+  static new(leftArm, rightArm, err) {
+    if (leftArm === null || rightArm === null) {
+      return null;
+    }
+    if (err !== 0 && leftArm.overlaps(rightArm, err)) {
+      return null;
+    }
+    const deviationFromZeroAngle = 0.1 / (leftArm.length * rightArm.length);
+    if (leftArm.parallel(rightArm, deviationFromZeroAngle)) {
+      const middle = new Line(leftArm.evaluate(0.5), rightArm.evaluate(0.5));
+      const p = middle.evaluate(0.5);
+      const sideLeft = leftArm.pointOnSide(p, err);
+      const sideRight = rightArm.pointOnSide(p, err);
+      if (sideLeft === 0 /* Top */ || sideRight === 0 /* Top */) {
+        throw new Error();
+      }
+      return sideLeft !== sideRight ? new Wedge(leftArm, rightArm, true) : new Wedge(leftArm, new Line(rightArm.end, rightArm.start));
+    }
+    const tLA = leftArm.intersectionParameter(rightArm, 0);
+    const tRA = rightArm.intersectionParameter(leftArm, 0);
+    if (tLA === 0.5 || tRA === 0.5) {
+      return null;
+    }
+    const W = leftArm.evaluate(tLA);
+    const eLA = tLA < 1 - tLA ? leftArm.end : leftArm.start;
+    const eRA = tRA < 1 - tRA ? rightArm.end : rightArm.start;
+    return new Wedge(new Line(W, eLA), new Line(W, eRA));
+  }
+  formTriangle(line, err) {
+    const thin = this.leftArm.parallel(line, 0.1 / (this.leftArm.length * line.length)) || this.rightArm.parallel(line, 0.1 / (this.rightArm.length * line.length));
+    if (thin) {
+      return false;
+    }
+    const A = line.intersectionPoint(this.leftArm, 0);
+    const B = line.intersectionPoint(this.rightArm, 0);
+    if (this.isDegenerate) {
+      return !A.equals(B, err);
+    }
+    const C = this.leftArm.intersectionPoint(this.rightArm, 0);
+    return !C.equals(A, err) && !C.equals(B, err) && !A.equals(B, err) && !new Line(A, B).pointOnTop(C, err);
+  }
+  looselyContains(p, err) {
+    const pLeft = this.leftArm.pointOnSide(p, err);
+    const pRight = this.rightArm.pointOnSide(p, err);
+    if (pLeft === 0 /* Top */ || pRight === 0 /* Top */) {
+      return true;
+    }
+    if (pLeft === pRight) {
+      return false;
+    }
+    return this.isDegenerate ? (
+      // degenerate + different sides => true
+      true
+    ) : (
+      // 2. (Because the arms intersect)
+      // Projection params of the point onto the arms must be larger than 0
+      this.leftArm.closestPointParam(p) >= 0 && this.rightArm.closestPointParam(p) >= 0
+    );
+  }
+  strictlyContains(p, err) {
+    const pLeft = this.leftArm.pointOnSide(p, err);
+    const pRight = this.rightArm.pointOnSide(p, err);
+    if (pLeft === 0 /* Top */ || pRight === 0 /* Top */) {
+      return false;
+    }
+    if (pLeft === pRight) {
+      return false;
+    }
+    return this.isDegenerate ? (
+      // degenerate + different sides => true
+      true
+    ) : (
+      // 2. (Because the arms intersect)
+      // Projection params of the point onto the arms must be larger than 0
+      this.leftArm.closestPointParam(p) >= 0 && this.rightArm.closestPointParam(p) >= 0
+    );
+  }
+  // While fitting circles into a wedge
+  // There are four distinct cases:
+  // 1. Wedge is degenerate and additional element is a point
+  // 2. Wedge is degenerate and additional element is a line
+  // 3. Wedge is non-degenerate and additional element is a point
+  // 4. Wedge is non-degenerate and additional element is a line
+  // according to these assumptions, the following methods are named
+  fit_Dp(p, err) {
+    if (!this.strictlyContains(p, err)) {
+      return null;
+    }
+    const A = this.rightArm.closestPoint(p);
+    const Ap = this.leftArm.closestPoint(A);
+    const I = A.plus(Ap).over(2);
+    const r = A.minus(Ap).norm / 2;
+    const a = this.rightArm.delta.normSquared;
+    const b = I.minus(p).dot(this.rightArm.delta) * 2;
+    const c = I.minus(p).normSquared - r * r;
+    const discriminant = b * b - 4 * a * c;
+    if (discriminant < (-10) ** -5) {
+      return null;
+    }
+    const t = [];
+    if (Math.abs(discriminant) < 10 ** -5) {
+      t.push(-b / (2 * a));
+    } else {
+      t.push((-b + Math.sqrt(discriminant)) / (2 * a));
+      t.push((-b - Math.sqrt(discriminant)) / (2 * a));
+    }
+    const result = [];
+    t.forEach((t0) => {
+      const O = this.rightArm.delta.times(t0).plus(I);
+      result.push({
+        circle: { centre: O, r },
+        tangent: new Line(p, p.plus(O.minus(p).normal()))
+      });
+    });
+    return result;
+  }
+  fit_Dl(l, err) {
+    if (!this.formTriangle(l, err)) {
+      return null;
+    }
+    const A = l.intersectionPoint(this.rightArm, 0);
+    const B = l.intersectionPoint(this.leftArm, 0);
+    const AB = new Line(A, B);
+    const Ap = this.leftArm.closestPoint(A);
+    const I = A.plus(Ap).over(2);
+    const r = A.minus(Ap).norm / 2;
+    const t1 = (AB.delta.cross(A.minus(I)) + r * AB.delta.norm) / AB.delta.cross(this.rightArm.delta);
+    const t2 = (AB.delta.cross(A.minus(I)) - r * AB.delta.norm) / AB.delta.cross(this.rightArm.delta);
+    const o1 = this.rightArm.delta.times(t1).plus(I);
+    const o2 = this.rightArm.delta.times(t2).plus(I);
+    return [
+      {
+        circle: { centre: o1, r },
+        tangentParameter: l.closestPointParam(o1)
+      },
+      {
+        circle: { centre: o2, r },
+        tangentParameter: l.closestPointParam(o2)
+      }
+    ];
+  }
+  fit_NDp(p, err) {
+    if (!this.strictlyContains(p, err)) {
+      return null;
+    }
+    const C = this.leftArm.start;
+    const A = this.leftArm.end;
+    const B = this.rightArm.end;
+    const a = C.minus(B).norm;
+    const b = C.minus(A).norm;
+    const D = A.minus(B).times(a / (a + b)).plus(B);
+    const bisector = new Line(C, D);
+    const eA = D.minus(C).normSquared - (A.minus(C).cross(D.minus(C)) / b) ** 2;
+    const eB = D.minus(C).dot(C.minus(p)) * 2;
+    const eC = C.minus(p).normSquared;
+    const discriminant = eB * eB - 4 * eA * eC;
+    if (discriminant < (-10) ** -5) {
+      return null;
+    }
+    let O, r;
+    if (Math.abs(discriminant) < 10 ** -5) {
+      const t = -eB / (2 * eA);
+      O = bisector.evaluate(t);
+      r = O.minus(p).norm;
+    } else {
+      const t1 = (-eB + Math.sqrt(discriminant)) / (2 * eA);
+      const t2 = (-eB - Math.sqrt(discriminant)) / (2 * eA);
+      if (bisector.evaluate(t1).minus(p).normSquared > bisector.evaluate(t2).minus(p).normSquared) {
+        O = bisector.evaluate(t1);
+        r = bisector.evaluate(t1).minus(p).norm;
+      } else {
+        O = bisector.evaluate(t2);
+        r = bisector.evaluate(t2).minus(p).norm;
+      }
+    }
+    return [
+      {
+        circle: { centre: O, r },
+        tangent: new Line(p, p.plus(O.minus(p).normal()))
+      }
+    ];
+  }
+  fit_NDl(l, err) {
+    if (!this.formTriangle(l, err)) {
+      return null;
+    }
+    const C = this.leftArm.start;
+    const A = l.intersectionPoint(this.leftArm, 0);
+    const B = l.intersectionPoint(this.rightArm, 0);
+    const AC = new Line(A, C);
+    const BC = new Line(B, C);
+    const AB = new Line(A, B);
+    const a = AC.length;
+    const b = BC.length;
+    const c = AB.length;
+    const s = (a + b + c) / 2;
+    if (s * (s - a) * (s - b) / (s - c) < 0) {
+      return null;
+    }
+    const r = Math.sqrt(s * (s - a) * (s - b) / (s - c));
+    const det = AB.delta.cross(AC.delta);
+    const lhsAll = [
+      new Vec2(B.cross(A) + r * c, C.cross(A) + r * a),
+      new Vec2(B.cross(A) + r * c, C.cross(A) - r * a),
+      new Vec2(B.cross(A) - r * c, C.cross(A) + r * a),
+      new Vec2(B.cross(A) - r * c, C.cross(A) - r * a)
+    ];
+    const OAll = [];
+    lhsAll.forEach((lhs) => {
+      OAll.push(
+        new Vec2(
+          new Vec2(AB.delta.x, AC.delta.x).cross(lhs),
+          new Vec2(AB.delta.y, AC.delta.y).cross(lhs)
+        ).over(-det)
+      );
+    });
+    let o = null;
+    const dists = [];
+    for (const O of OAll) {
+      dists.push({
+        raw: Math.abs(BC.distanceToPoint(O) - r),
+        norm: Math.abs(BC.distanceToPoint(O) / r - 1)
+      });
+      const absoluteError = Math.abs(BC.distanceToPoint(O) - r);
+      const relativeError = Math.abs(BC.distanceToPoint(O) / r - 1);
+      if ((absoluteError < 10 ** -5 || relativeError < 10 ** -5) && AC.pointOnSide(O) !== BC.pointOnSide(O)) {
+        o = O;
+        break;
+      }
+    }
+    let msg = "";
+    if (o === null) {
+      msg = "fit_NDl, centre is undefined";
+      for (let i = 0; i < OAll.length; i++) {
+        msg += `centre: (${OAll[i].x}, ${OAll[i].y}), r: ${r}, dist raw: ${dists[i].raw},  dist norm: ${dists[i].norm}
+`;
+      }
+    }
+    if (o === null) {
+      throw new Error(msg);
+    }
+    return [
+      {
+        circle: { centre: o, r },
+        tangentParameter: l.closestPointParam(o)
+      }
+    ];
+  }
+  fitCircles(element, err) {
+    if (element instanceof Vec2) {
+      return this.isDegenerate ? this.fit_Dp(element, err) : this.fit_NDp(element, err);
+    }
+    if (element instanceof Line) {
+      return this.isDegenerate ? this.fit_Dl(element instanceof Line ? element : element, err) : this.fit_NDl(element instanceof Line ? element : element, err);
+    }
+    return null;
+  }
+  toString() {
+    return `LA: ${this.leftArm.start.toString()} --> ${this.leftArm.end.toString()}
+RA: ${this.rightArm.start.toString()} --> ${this.rightArm.end.toString()}`;
+  }
+};
+
+// src/index.ts
+function lineTangentToHull(line, points, halo) {
+  let holds = true;
+  let side = 0 /* Top */;
+  let k = 0;
+  while (side === 0 /* Top */ && k < points.length) {
+    side = line.pointOnSide(points[k], halo);
+    k++;
+  }
+  for (let i = k; i < points.length; i++) {
+    const testSide = line.pointOnSide(points[i], halo);
+    if (testSide === 0 /* Top */) {
+      continue;
+    }
+    if (testSide !== side) {
+      holds = false;
+      break;
+    }
+  }
+  return { holds, side };
+}
+function findEnclosingSide(wedge, startVertex, endVertex, points, halo) {
+  let side = null;
+  let stopVertex = startVertex;
+  let vertex = startVertex;
+  while (side === null && vertex > endVertex) {
+    const p1 = points[vertex];
+    const p2 = points[vertex - 1];
+    const edge = new Line(p1, p2);
+    const circlesEdge = wedge.fitCircles(edge, halo);
+    if (circlesEdge !== null) {
+      let tangentParameter = 100;
+      if (wedge.isDegenerate) {
+        let sidedness = 0 /* Top */;
+        let k = 0;
+        while (sidedness === 0 /* Top */ && k < points.length) {
+          sidedness = edge.pointOnSide(points[k], halo);
+          k++;
+        }
+        tangentParameter = edge.pointOnSide(circlesEdge[0].circle.centre) !== sidedness ? circlesEdge[0].tangentParameter : circlesEdge[1].tangentParameter;
+      } else {
+        tangentParameter = circlesEdge[0].tangentParameter;
+      }
+      if (tangentParameter > 0 && tangentParameter < 1) {
+        const Y = edge.evaluate(tangentParameter);
+        const joint = wedge.leftArm.intersectionPoint(edge, halo);
+        side = new Line(joint, Y);
+      }
+    }
+    if (side === null) {
+      const circlesPoint = wedge.fitCircles(p2, halo);
+      if (circlesPoint !== null) {
+        let tangent;
+        if (wedge.isDegenerate) {
+          let sidedness = 0 /* Top */;
+          let k = 0;
+          while (sidedness === 0 /* Top */ && k < points.length) {
+            sidedness = circlesPoint[0].tangent.pointOnSide(points[k], halo);
+            k++;
+          }
+          tangent = circlesPoint[0].tangent.pointOnSide(
+            circlesPoint[0].circle.centre,
+            halo
+          ) !== sidedness ? circlesPoint[0].tangent : circlesPoint[1].tangent;
+        } else {
+          tangent = circlesPoint[0].tangent;
+        }
+        if (lineTangentToHull(tangent, points, halo).holds) {
+          const joint = wedge.leftArm.intersectionPoint(tangent, halo);
+          side = new Line(joint, p2);
+        }
+      }
+    }
+    stopVertex = vertex;
+    vertex--;
+  }
+  return side === null ? null : { side, stopVertex };
+}
+function findAntipode(points) {
+  let farthestIndex = 0;
+  let farthestDist = 0;
+  for (let i = 0, n = points.length; i < n; i++) {
+    const testDist = new Line(points[0], points[n - 1]).distanceToPoint(
+      points[i]
+    );
+    if (testDist > farthestDist) {
+      farthestDist = testDist;
+      farthestIndex = i;
+    }
+  }
+  return farthestIndex;
+}
+function minTriangleWithBase(convexHull, err, tol) {
+  let AB, AC;
+  const n = convexHull.length;
+  const BC = new Line(convexHull[0], convexHull[n - 1]);
+  const antipodIndex = findAntipode(convexHull);
+  const baseParallel = new Line(
+    convexHull[antipodIndex],
+    convexHull[antipodIndex].plus(BC.delta)
+  );
+  let wedge = Wedge.new(BC, baseParallel, err);
+  let Pn = n - 1;
+  let Qn = antipodIndex;
+  do {
+    const CQinfo = findEnclosingSide(wedge, Pn, antipodIndex, convexHull, err);
+    if (CQinfo === null) {
+      return null;
+    }
+    ;
+    ({ side: AC, stopVertex: Pn } = CQinfo);
+    wedge = Wedge.new(wedge.leftArm, AC, err);
+    const BPinfo = findEnclosingSide(wedge, Qn, 0, convexHull, err);
+    if (BPinfo === null) {
+      return null;
+    }
+    ;
+    ({ side: AB, stopVertex: Qn } = BPinfo);
+    wedge = Wedge.new(wedge.leftArm, AB, err);
+  } while (AB.length - AC.length > tol);
+  const A = AC.intersectionPoint(AB, 0);
+  const B = AB.start;
+  const C = AC.start;
+  return { A, B, C };
+}
+function minTriangle(convexHull, err, tol) {
+  if (convexHull.length < 3) {
+    return null;
+  }
+  if (convexHull.length === 3) {
+    return { A: convexHull[0], B: convexHull[1], C: convexHull[2] };
+  }
+  const points = convexHull.map((p) => {
+    return new Vec2(p.x, p.y);
+  });
+  let A = null;
+  let B = null;
+  let C = null;
+  let perimeter = -1;
+  let rotations = 0;
+  while (rotations < points.length) {
+    if (rotations > 0) {
+      points.push(points.shift());
+    }
+    const triangle = minTriangleWithBase(points, err, tol);
+    if (triangle !== null) {
+      const { A: A1, B: B1, C: C1 } = triangle;
+      const perimeter1 = A1.minus(B1).norm + B1.minus(C1).norm + C1.minus(A1).norm;
+      if (perimeter1 < perimeter || perimeter === -1) {
+        ;
+        [A, B, C] = [A1, B1, C1];
+        perimeter = perimeter1;
+      }
+    }
+    rotations++;
+  }
+  return perimeter === -1 ? null : {
+    A: { x: A.x, y: A.y },
+    B: { x: B.x, y: B.y },
+    C: { x: C.x, y: C.y }
+  };
+}
+//# sourceMappingURL=index.cjs.map