geometric-library 1.3.0

package/dist/cjs/utilities/Calculator.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Calculator = void 0;
+const decimal_js_1 = require("decimal.js");
+class Calculator {
+    _instance;
+    constructor(arg) {
+        this._instance = new decimal_js_1.Decimal(arg);
+    }
+    // STATIC METHODS
+    static abs(arg) {
+        return Calculator.computeUnaryOperation('abs', arg);
+    }
+    static acos(arg) {
+        return Calculator.computeUnaryOperation('acos', arg);
+    }
+    static add(first, second) {
+        return Calculator.computeBinaryOperation('add', [first, second]);
+    }
+    static atan(arg) {
+        return Calculator.computeUnaryOperation('atan', arg);
+    }
+    static atan2(first, second) {
+        return Calculator.computeBinaryOperation('atan2', [first, second]);
+    }
+    static cos(arg) {
+        return Calculator.computeUnaryOperation('cos', arg);
+    }
+    static div(first, second) {
+        return Calculator.computeBinaryOperation('div', [first, second]);
+    }
+    static max(args) {
+        return Calculator.computeIndefiniteOperation('max', args);
+    }
+    static min(args) {
+        return Calculator.computeIndefiniteOperation('min', args);
+    }
+    static mod(first, second) {
+        return Calculator.computeBinaryOperation('mod', [first, second]);
+    }
+    static mul(first, second) {
+        return Calculator.computeBinaryOperation('mul', [first, second]);
+    }
+    static neg(arg) {
+        return Calculator.computeUnaryOperation('neg', arg);
+    }
+    static pow(first, second) {
+        return Calculator.computeBinaryOperation('pow', [first, second]);
+    }
+    static sin(arg) {
+        return Calculator.computeUnaryOperation('sin', arg);
+    }
+    static sqrt(arg) {
+        return Calculator.computeUnaryOperation('sqrt', arg);
+    }
+    static sub(first, second) {
+        return Calculator.computeBinaryOperation('sub', [first, second]);
+    }
+    static tan(arg) {
+        return Calculator.computeUnaryOperation('tan', arg);
+    }
+    // PRIVATE METHODS
+    static computeBinaryOperation(operation, args) {
+        const [a, b] = Calculator.toDecimalArgs(args);
+        const result = decimal_js_1.Decimal[operation](a, b);
+        const roundedResult = this.roundDecimalWithPrecision(result);
+        return new Calculator(roundedResult);
+    }
+    static computeIndefiniteOperation(operation, args) {
+        const nargs = Calculator.toDecimalArgs(args);
+        const result = decimal_js_1.Decimal[operation](...nargs);
+        const roundedResult = this.roundDecimalWithPrecision(result);
+        return new Calculator(roundedResult);
+    }
+    static computeUnaryOperation(operation, arg) {
+        const [a] = Calculator.toDecimalArgs([arg]);
+        const result = new decimal_js_1.Decimal(a)[operation]();
+        const roundedResult = this.roundDecimalWithPrecision(result);
+        return new Calculator(roundedResult);
+    }
+    /**
+     * @todo The precision calculation could be improved to test at what decimal point is the distance less
+     * than epsilon, and then to round up to that point instead of choosing an arbitrary precision.
+     */
+    static roundDecimalWithPrecision(value) {
+        const epsilon = new decimal_js_1.Decimal('1e-8');
+        const distanceToLowerInt = value.sub(value.floor());
+        const distanceToUpperInt = value.ceil().sub(value);
+        if (distanceToLowerInt.lte(epsilon)) {
+            return value.floor().toNumber();
+        }
+        if (distanceToUpperInt.lte(epsilon)) {
+            return value.ceil().toNumber();
+        }
+        return value.toNumber();
+    }
+    static toDecimalArgs(args) {
+        return args.map((arg) => +arg);
+    }
+    // INSTANCE METHODS
+    abs() {
+        return Calculator.computeUnaryOperation('abs', this);
+    }
+    acos() {
+        return Calculator.computeUnaryOperation('acos', this);
+    }
+    add(second) {
+        return Calculator.computeBinaryOperation('add', [this, second]);
+    }
+    atan() {
+        return Calculator.computeUnaryOperation('atan', this);
+    }
+    atan2(second) {
+        return Calculator.computeBinaryOperation('atan2', [this, second]);
+    }
+    cos() {
+        return Calculator.computeUnaryOperation('cos', this);
+    }
+    div(second) {
+        return Calculator.computeBinaryOperation('div', [this, second]);
+    }
+    isFinite() {
+        return this._instance.isFinite();
+    }
+    mod(second) {
+        return Calculator.computeBinaryOperation('mod', [this, second]);
+    }
+    mul(second) {
+        return Calculator.computeBinaryOperation('mul', [this, second]);
+    }
+    neg() {
+        return Calculator.computeUnaryOperation('neg', this);
+    }
+    pow(second) {
+        return Calculator.computeBinaryOperation('pow', [this, second]);
+    }
+    sin() {
+        return Calculator.computeUnaryOperation('sin', this);
+    }
+    sqrt() {
+        return Calculator.computeUnaryOperation('sqrt', this);
+    }
+    sub(second) {
+        return Calculator.computeBinaryOperation('sub', [this, second]);
+    }
+    tan() {
+        return Calculator.computeUnaryOperation('tan', this);
+    }
+    valueOf() {
+        return this._instance.toNumber();
+    }
+}
+exports.Calculator = Calculator;

package/dist/cjs/utilities/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PI2 = exports.yAxis = exports.xAxis = exports.coordinateOrigin = void 0;
+const Calculator_1 = require("./Calculator");
+const Point_1 = require("../abstracts/Point");
+const Line_1 = require("../figures/Line");
+exports.coordinateOrigin = new Point_1.Point([0, 0]);
+exports.xAxis = new Line_1.Line([exports.coordinateOrigin, new Point_1.Point([1, 0])]);
+exports.yAxis = new Line_1.Line([exports.coordinateOrigin, new Point_1.Point([0, 1])]);
+exports.PI2 = +Calculator_1.Calculator.mul(Math.PI, 2); // 360 degrees

package/dist/esm/abstracts/Angle.js

@@ -0,0 +1,56 @@
+import { Calculator } from '../utilities/Calculator';
+const PI2 = +Calculator.mul(Math.PI, 2);
+export class Angle {
+    _radians;
+    constructor(value, unit) {
+        this._radians = unit === 'radians' ? value : Angle.toRadians(value);
+    }
+    get cos() {
+        return +Calculator.cos(this.radians);
+    }
+    get cot() {
+        return +Calculator.div(1, this.tan);
+    }
+    get degrees() {
+        return Angle.toDegrees(this.radians);
+    }
+    get radians() {
+        return this._radians;
+    }
+    get sin() {
+        return +Calculator.sin(this.radians);
+    }
+    get tan() {
+        return +Calculator.tan(this.radians);
+    }
+    static toDegrees(radians) {
+        return +Calculator.mul(radians, 180).div(Math.PI);
+    }
+    static toRadians(degrees) {
+        return +Calculator.mul(degrees, Math.PI).div(180);
+    }
+    clone() {
+        return new Angle(this.radians, 'radians');
+    }
+    normalize() {
+        const { radians } = this;
+        if (radians < 0) {
+            this._radians = +Calculator.add(radians, PI2);
+        }
+        else if (radians > 0) {
+            this._radians = +Calculator.mod(radians, PI2);
+        }
+        return this;
+    }
+    replace(value, unit) {
+        this._radians = unit === 'radians' ? value : Angle.toRadians(value);
+        return this;
+    }
+    scale(factor) {
+        this._radians = +Calculator.mul(this.radians, factor);
+        return this;
+    }
+    valueOf() {
+        return this.radians;
+    }
+}

package/dist/esm/abstracts/Figure.js

@@ -0,0 +1,143 @@
+import { Calculator } from '../utilities/Calculator';
+import { Magnitude } from './Magnitude';
+import { Point } from './Point';
+import { Vector } from './Vector';
+export class Figure {
+    angles = [];
+    isRelative = false;
+    magnitudes = [];
+    points = [];
+    vectors = [];
+    _values;
+    constructor(values) {
+        this.values = this._values = values;
+    }
+    get boundingBox() {
+        const { points } = this;
+        return Figure.computeBoundingBox(points);
+    }
+    get values() {
+        return this._values;
+    }
+    /**
+     * @todo Figure out a better way to type narrow than iterating again.
+     */
+    set values(values) {
+        this._values = values;
+        const [points, vectors, magnitudes, angles] = values.reduce((result, value) => {
+            if (value instanceof Point) {
+                result[0].push(value);
+            }
+            if (value instanceof Vector) {
+                result[1].push(value);
+            }
+            if (value instanceof Magnitude) {
+                result[2].push(value);
+            }
+            if (typeof value === 'object' && 'radians' in value) {
+                result[3].push(value);
+            }
+            return result;
+        }, [[], [], [], []]);
+        this.magnitudes = magnitudes;
+        this.points = points;
+        this.vectors = vectors;
+        this.angles = angles;
+        this.isRelative = !!vectors.length;
+    }
+    static computeBoundingBox(points) {
+        if (!points) {
+            throw new Error(this.getNoPointsErrorMessage('boundingBox', true));
+        }
+        const [xValues, yValues] = points.reduce((values, point) => {
+            values[0].push(point.x);
+            values[1].push(point.y);
+            return values;
+        }, [[], []]);
+        const xMax = +Calculator.max(xValues);
+        const xMin = +Calculator.min(xValues);
+        const yMax = +Calculator.max(yValues);
+        const yMin = +Calculator.min(yValues);
+        return { xMax, xMin, yMax, yMin };
+    }
+    static getNoPointsErrorMessage(name, property = false) {
+        return `Attempting to ${property ? 'get' : 'call'} ${name} of Figure with no points assigned. Assign 'this.points' from the child class and try again.`;
+    }
+    reflect(about) {
+        const { points, vectors } = this;
+        if (!points) {
+            throw new Error(Figure.getNoPointsErrorMessage('reflect'));
+        }
+        if ('getPerpendicularProjection' in about) {
+            points.forEach((point) => {
+                const perpendicularRoot = about.getPerpendicularProjection(point);
+                point.reflect(perpendicularRoot);
+            });
+            vectors.forEach((vector) => {
+                vector.reflect({
+                    x: !about.isHorizontal,
+                    y: !about.isVertical
+                });
+            });
+            return this;
+        }
+        points.forEach((point) => {
+            point.reflect(about);
+        });
+        vectors.forEach((vector) => {
+            vector.reflect({
+                x: true,
+                y: true
+            });
+        });
+        return this;
+    }
+    rotate(phi, about) {
+        const { points, vectors, angles } = this;
+        if (!points) {
+            throw new Error(Figure.getNoPointsErrorMessage('rotate'));
+        }
+        points.forEach((point) => {
+            point.rotate(phi, about);
+        });
+        vectors.forEach((vector) => {
+            const referencePoint = points[0].clone().rotate(phi, about);
+            const positionalPoint = points[0].clone().translate(vector).rotate(phi, about);
+            const rotatedVector = new Vector([referencePoint, positionalPoint]);
+            vector.replace(rotatedVector);
+        });
+        angles.forEach((angle) => {
+            angle.replace(+Calculator.add(+angle, +phi), 'radians').normalize();
+        });
+        return this;
+    }
+    scale(factor, about = new Point([0, 0])) {
+        const { points, vectors, magnitudes } = this;
+        if (!points) {
+            throw new Error(Figure.getNoPointsErrorMessage('scale'));
+        }
+        points.forEach((point) => {
+            const positionalVector = new Vector([about, point]);
+            const scaledPositionalVector = positionalVector.clone().scale(factor);
+            const scaledPoint = about.clone().translate(scaledPositionalVector);
+            point.replace(scaledPoint);
+        });
+        vectors.forEach((vector) => {
+            vector.scale(factor);
+        });
+        magnitudes.forEach((magnitude) => {
+            magnitude.scale(factor);
+        });
+        return this;
+    }
+    translate(vector) {
+        const { points } = this;
+        if (!points) {
+            throw new Error(Figure.getNoPointsErrorMessage('translate'));
+        }
+        points.forEach((point) => {
+            point.translate(vector);
+        });
+        return this;
+    }
+}

package/dist/esm/abstracts/Flag.js

@@ -0,0 +1,23 @@
+export class Flag {
+    _value;
+    constructor(value) {
+        this._value = value;
+    }
+    get value() {
+        return this._value;
+    }
+    clone() {
+        return new Flag(this._value);
+    }
+    invert() {
+        this._value = !this._value;
+        return this;
+    }
+    replace(value) {
+        this._value = value;
+        return this;
+    }
+    valueOf() {
+        return +this._value;
+    }
+}

package/dist/esm/abstracts/Magnitude.js

@@ -0,0 +1,21 @@
+import { Calculator } from '../utilities/Calculator';
+export class Magnitude {
+    _value;
+    constructor(value) {
+        this._value = value;
+    }
+    clone() {
+        return new Magnitude(+this);
+    }
+    replace(value) {
+        this._value = value;
+        return this;
+    }
+    scale(factor) {
+        this._value = +Calculator.mul(+this, factor);
+        return this;
+    }
+    valueOf() {
+        return this._value;
+    }
+}

package/dist/esm/abstracts/Point.js

@@ -0,0 +1,46 @@
+import { Calculator } from '../utilities/Calculator';
+export class Point {
+    _x;
+    _y;
+    constructor([x, y]) {
+        this._x = x;
+        this._y = y;
+    }
+    get values() {
+        return [this.x, this.y];
+    }
+    get x() {
+        return +this._x;
+    }
+    get y() {
+        return +this._y;
+    }
+    clone() {
+        const { x, y } = this;
+        return new Point([x, y]);
+    }
+    reflect(about) {
+        const { x, y } = this;
+        this._x = +Calculator.sub(about.x, x).mul(2).add(x);
+        this._y = +Calculator.sub(about.y, y).mul(2).add(y);
+        return this;
+    }
+    replace(point) {
+        this._x = point.x;
+        this._y = point.y;
+        return this;
+    }
+    rotate(phi, about = new Point([0, 0])) {
+        const dx = Calculator.sub(this.x, about.x);
+        const dy = Calculator.sub(this.y, about.y);
+        this._x = +dx.mul(phi.cos).sub(dy.mul(phi.sin)).add(about.x);
+        this._y = +dy.mul(phi.cos).add(dx.mul(phi.sin)).add(about.y);
+        return this;
+    }
+    translate(vector) {
+        const { x, y } = this;
+        this._x = +Calculator.add(x, vector.dx);
+        this._y = +Calculator.add(y, vector.dy);
+        return this;
+    }
+}

package/dist/esm/abstracts/Vector.js

@@ -0,0 +1,70 @@
+import { Calculator } from '../utilities/Calculator';
+import { Angle } from './Angle';
+export class Vector {
+    _dx;
+    _dy;
+    constructor(values) {
+        const fromPoints = values.some((value) => typeof value !== 'number');
+        if (fromPoints) {
+            const [P1, P2] = values;
+            this._dx = +Calculator.sub(P2.x, P1.x);
+            this._dy = +Calculator.sub(P2.y, P1.y);
+            return;
+        }
+        const [dx, dy] = values;
+        this._dx = dx;
+        this._dy = dy;
+    }
+    get dx() {
+        return this._dx;
+    }
+    get dy() {
+        return this._dy;
+    }
+    get magnitude() {
+        const { dx, dy } = this;
+        return +Calculator.pow(dx, 2).add(Calculator.pow(dy, 2)).sqrt();
+    }
+    get values() {
+        return [this.dx, this.dy];
+    }
+    angleTo(vector) {
+        const dotProd = this.dotProduct(vector);
+        const magV1 = this.magnitude;
+        const magV2 = vector.magnitude;
+        const magProd = Calculator.mul(magV1, magV2);
+        const cosAngle = Calculator.div(dotProd, magProd);
+        const angle = cosAngle.acos();
+        return new Angle(+angle, 'radians');
+    }
+    clone() {
+        const { dx, dy } = this;
+        return new Vector([dx, dy]);
+    }
+    dotProduct(vector) {
+        const { dx, dy } = this;
+        return +Calculator.mul(dx, vector.dx).add(Calculator.mul(dy, vector.dy));
+    }
+    reflect({ x, y }) {
+        this._dx = x ? +Calculator.neg(this.dx) : this.dx;
+        this._dy = y ? +Calculator.neg(this.dy) : this.dy;
+        return this;
+    }
+    replace(vector) {
+        this._dx = vector.dx;
+        this._dy = vector.dy;
+        return this;
+    }
+    rotate(phi) {
+        const { dx, dy } = this;
+        this._dx = +Calculator.mul(phi.cos, dx).sub(Calculator.mul(phi.sin, dy));
+        this._dy = +Calculator.mul(phi.sin, dx).add(Calculator.mul(phi.cos, dy));
+        return this;
+    }
+    scale(factor) {
+        const { dx, dy } = this;
+        this._dx = +Calculator.mul(dx, factor);
+        this._dy = +Calculator.mul(dy, factor);
+        return this;
+    }
+}

package/dist/esm/figures/ArcCurve.js

@@ -0,0 +1,128 @@
+import { Calculator } from '../utilities/Calculator';
+import { Point } from '../abstracts/Point';
+import { Figure } from '../abstracts/Figure';
+import { Ellipse } from './Ellipse';
+export class ArcCurve extends Figure {
+    ellipse;
+    largeArcFlag;
+    phi;
+    rx;
+    ry;
+    sweepFlag;
+    constructor(values) {
+        super(values);
+        const [, rx, ry, phi, largeArcFlag, sweepFlag] = values;
+        this.rx = rx;
+        this.ry = ry;
+        this.phi = phi;
+        this.largeArcFlag = largeArcFlag;
+        this.sweepFlag = sweepFlag;
+        this.adjustRadii();
+        const center = this.computeCenter();
+        this.ellipse = new Ellipse([center, rx, ry, phi]);
+    }
+    get boundingBox() {
+        const { P0, P1 } = this;
+        const points = [P0, P1, ...this.criticalPoints];
+        return Figure.computeBoundingBox(points);
+    }
+    get center() {
+        return this.ellipse.center;
+    }
+    get criticalPoints() {
+        const { ellipse } = this;
+        const [minTheta, maxTheta] = this.computeThetaRange();
+        return ellipse.criticalPoints.filter((point) => {
+            const { P0, P1 } = this;
+            if ((point.x === P0.x && point.y === P0.y) || (point.x === P1.x && point.y === P1.y)) {
+                return false;
+            }
+            const theta = ellipse.computeThetaForPoint(point);
+            return +theta >= +minTheta && +theta <= +maxTheta;
+        });
+    }
+    get P0() {
+        return this.points[0];
+    }
+    get P1() {
+        if (this.isRelative) {
+            return this.P0.clone().translate(this.vectors[0]);
+        }
+        return this.points[1];
+    }
+    clone() {
+        const values = this.values.map((value) => (typeof value === 'object' && 'clone' in value ? value.clone() : value));
+        return new ArcCurve(values);
+    }
+    reflect(about) {
+        super.reflect(about);
+        this.sweepFlag.invert();
+        return this;
+    }
+    adjustRadii() {
+        const { rx, ry } = this;
+        const P0_prime = this.computeP0Prime();
+        const { x: x1_prime, y: y1_prime } = P0_prime;
+        const rx_sq = Calculator.pow(+rx, 2);
+        const ry_sq = Calculator.pow(+ry, 2);
+        const x1_prime_sq = Calculator.pow(x1_prime, 2);
+        const y1_prime_sq = Calculator.pow(y1_prime, 2);
+        const radii_check = x1_prime_sq.div(rx_sq).add(y1_prime_sq.div(ry_sq));
+        if (+radii_check > 1) {
+            rx.replace(+Calculator.mul(+rx, radii_check.sqrt()));
+            ry.replace(+Calculator.mul(+ry, radii_check.sqrt()));
+        }
+    }
+    computeCenter() {
+        const { P0, P1, phi } = this;
+        const center_prime = this.computeCenterPrime();
+        const { x: x1, y: y1 } = P0;
+        const { x: x2, y: y2 } = P1;
+        const { x: cx_prime, y: cy_prime } = center_prime;
+        const dx = Calculator.add(x1, x2).div(2);
+        const dy = Calculator.add(y1, y2).div(2);
+        const cx = Calculator.mul(phi.cos, cx_prime).sub(Calculator.mul(phi.sin, cy_prime)).add(dx);
+        const cy = Calculator.mul(phi.sin, cx_prime).add(Calculator.mul(phi.cos, cy_prime)).add(dy);
+        return new Point([+cx, +cy]);
+    }
+    computeCenterPrime() {
+        const { largeArcFlag, sweepFlag, rx, ry } = this;
+        const P0_prime = this.computeP0Prime();
+        const { x: x1_prime, y: y1_prime } = P0_prime;
+        const rx_sq = Calculator.pow(+rx, 2);
+        const ry_sq = Calculator.pow(+ry, 2);
+        const x1_prime_sq = Calculator.pow(x1_prime, 2);
+        const y1_prime_sq = Calculator.pow(y1_prime, 2);
+        const sign = new Calculator(+largeArcFlag === +sweepFlag ? -1 : 1);
+        let sq = rx_sq
+            .mul(ry_sq)
+            .sub(rx_sq.mul(y1_prime_sq))
+            .sub(ry_sq.mul(x1_prime_sq))
+            .div(rx_sq.mul(y1_prime_sq).add(ry_sq.mul(x1_prime_sq)));
+        sq = +sq < 0 ? new Calculator(0) : sq;
+        const coef = sign.mul(sq.sqrt());
+        const cx_prime = coef.mul(Calculator.mul(+rx, y1_prime).div(+ry));
+        const cy_prime = coef.mul(Calculator.mul(+ry, x1_prime).div(+rx).neg());
+        return new Point([+cx_prime, +cy_prime]);
+    }
+    computeP0Prime() {
+        const { P0, P1, phi } = this;
+        const { x: x1, y: y1 } = P0;
+        const { x: x2, y: y2 } = P1;
+        const mx = Calculator.sub(x1, x2).div(2);
+        const my = Calculator.sub(y1, y2).div(2);
+        const x1_prime = Calculator.mul(phi.cos, mx).add(Calculator.mul(phi.sin, my));
+        const y1_prime = Calculator.mul(phi.sin, mx).neg().add(Calculator.mul(phi.cos, my));
+        return new Point([+x1_prime, +y1_prime]);
+    }
+    computeThetaRange() {
+        const { P0, P1, ellipse, sweepFlag } = this;
+        const theta1 = ellipse.computeThetaForPoint(P0);
+        const theta2 = ellipse.computeThetaForPoint(P1);
+        if (+theta2 === 0 && !sweepFlag.value) {
+            theta2.replace(360, 'degrees');
+        }
+        const thetaRange = [theta1, theta2].sort((a, b) => +Calculator.sub(a.radians, b.radians));
+        return thetaRange;
+    }
+}

package/dist/esm/figures/Circle.js

@@ -0,0 +1,39 @@
+import { Calculator } from '../utilities/Calculator';
+import { Ellipse } from './Ellipse';
+import { Point } from '../abstracts/Point';
+import { Angle } from '../abstracts/Angle';
+export class Circle extends Ellipse {
+    _radius;
+    constructor(values) {
+        const [center, radius] = values;
+        const phi = new Angle(0, 'radians'); // Always 0 since circles don't change with rotation.
+        super([center, radius, radius.clone(), phi]);
+        this._radius = radius;
+    }
+    get isCircle() {
+        return true;
+    }
+    get radius() {
+        return this._radius;
+    }
+    get values() {
+        const [center, radius] = super.values;
+        return [center, radius];
+    }
+    set values(values) {
+        super.values = values;
+    }
+    clone() {
+        const values = this.values.map((value) => value.clone());
+        return new Circle(values);
+    }
+    computeCriticalPoints(ellipse = this) {
+        const { center, rx } = ellipse;
+        const radius = rx;
+        const first = new Point([center.x, +Calculator.add(center.y, +radius)]);
+        const second = new Point([+Calculator.add(center.x, +radius), center.y]);
+        const third = new Point([center.x, +Calculator.sub(center.y, +radius)]);
+        const fourth = new Point([+Calculator.sub(center.x, +radius), center.y]);
+        return [first, second, third, fourth];
+    }
+}