geometric-library 1.3.0

package/dist/esm/figures/CubicBezierCurve.js

@@ -0,0 +1,145 @@
+import { Calculator } from '../utilities/Calculator';
+import { Point } from '../abstracts/Point';
+import { Figure } from '../abstracts/Figure';
+export class CubicBezierCurve extends Figure {
+    _criticalPoints;
+    constructor(values) {
+        super(values);
+        this._criticalPoints = this.computeCriticalPoints();
+    }
+    get boundingBox() {
+        const [P0, , , P3] = this.values;
+        const points = [P0, P3, ...this._criticalPoints];
+        return Figure.computeBoundingBox(points);
+    }
+    get criticalPoints() {
+        return this._criticalPoints;
+    }
+    get P0() {
+        return this.points[0];
+    }
+    get P1() {
+        if (this.isRelative) {
+            return this.P0.clone().translate(this.vectors[0]);
+        }
+        return this.points[1];
+    }
+    get P2() {
+        if (this.isRelative) {
+            return this.P0.clone().translate(this.vectors[1]);
+        }
+        return this.points[2];
+    }
+    get P3() {
+        if (this.isRelative) {
+            return this.P0.clone().translate(this.vectors[2]);
+        }
+        return this.points[3];
+    }
+    clone() {
+        const values = this.values.map((value) => value.clone());
+        return new CubicBezierCurve(values);
+    }
+    recompute() {
+        this._criticalPoints = this.computeCriticalPoints();
+    }
+    reflect(about) {
+        super.reflect(about);
+        this.recompute();
+        return this;
+    }
+    rotate(phi, about) {
+        super.rotate(phi, about);
+        this.recompute();
+        return this;
+    }
+    scale(factor, about) {
+        super.scale(factor, about);
+        this.recompute();
+        return this;
+    }
+    translate(vector) {
+        super.translate(vector);
+        this.recompute();
+        return this;
+    }
+    computeCriticalPoints() {
+        const tValues = this.computeCriticalPointsTValues();
+        if (!tValues) {
+            return [];
+        }
+        const criticalPoints = tValues.reduce((criticalPoints, t) => {
+            const criticalPoint = this.getPointAtParameter(t);
+            criticalPoint && criticalPoints.push(criticalPoint);
+            return criticalPoints;
+        }, []);
+        return criticalPoints;
+    }
+    computeCriticalPointsTValues() {
+        const axii = ['x', 'y'];
+        const { P0, P1, P2, P3 } = this;
+        const signs = [1, -1];
+        const tValues = [];
+        for (let i = 0; i < axii.length; i++) {
+            const axis = axii[i];
+            const p0 = new Calculator(P0[axis]);
+            const p1 = new Calculator(P1[axis]);
+            const p2 = new Calculator(P2[axis]);
+            const p3 = new Calculator(P3[axis]);
+            const a = p3.sub(p2.mul(3)).add(p1.mul(3)).sub(p0).mul(3);
+            const b = p2.sub(p1.mul(2)).add(p0).mul(6);
+            const c = p1.sub(p0).mul(3);
+            for (let n = 0; n < signs.length; n++) {
+                const sign = signs[n];
+                let tValue;
+                if (+a === 0) {
+                    // 1st degree equation to avoid n/0
+                    tValue = c.neg().div(b);
+                }
+                else {
+                    // 2nd degree equation
+                    tValue = b
+                        .neg()
+                        .add(Calculator.mul(sign, b.pow(2).sub(a.mul(c).mul(4)).sqrt()))
+                        .div(a.mul(2));
+                }
+                if (this.isValidParameter(tValue)) {
+                    tValues.push(tValue);
+                }
+            }
+        }
+        if (!tValues.length) {
+            return;
+        }
+        return tValues.filter((value, index, array) => index === array.findIndex((v) => +value === +v));
+    }
+    getCoordinateAtParameter(t, axis) {
+        const { P0, P1, P2, P3 } = this;
+        const p0 = P0[axis];
+        const p1 = P1[axis];
+        const p2 = P2[axis];
+        const p3 = P3[axis];
+        // parametric cubic bezier equation
+        const coordinate = Calculator.sub(1, t)
+            .pow(3)
+            .mul(p0)
+            .add(Calculator.sub(1, t).pow(2).mul(3).mul(t).mul(p1))
+            .add(Calculator.sub(1, t).mul(3).mul(t.pow(2)).mul(p2))
+            .add(t.pow(3).mul(p3));
+        if (!coordinate.isFinite()) {
+            return;
+        }
+        return coordinate;
+    }
+    getPointAtParameter(t) {
+        const x = this.getCoordinateAtParameter(t, 'x');
+        const y = this.getCoordinateAtParameter(t, 'y');
+        if (typeof x === 'undefined' || typeof y === 'undefined') {
+            return;
+        }
+        return new Point([+x, +y]);
+    }
+    isValidParameter(t) {
+        return t.isFinite() && +t > 0 && +t < 1;
+    }
+}

package/dist/esm/figures/Ellipse.js

@@ -0,0 +1,107 @@
+import { Calculator } from '../utilities/Calculator';
+import { Angle } from '../abstracts/Angle';
+import { Point } from '../abstracts/Point';
+import { Figure } from '../abstracts/Figure';
+import { xAxis } from '../utilities';
+export class Ellipse extends Figure {
+    _center;
+    _criticalPoints;
+    _phi;
+    _rx;
+    _ry;
+    constructor(values) {
+        super(values);
+        const [center, rx, ry, phi] = values;
+        this._center = center;
+        this._rx = rx;
+        this._ry = ry;
+        this._phi = phi;
+        this._criticalPoints = this.computeCriticalPoints({ center, rx, ry, phi });
+    }
+    get boundingBox() {
+        return Figure.computeBoundingBox(this.criticalPoints);
+    }
+    get center() {
+        return this._center;
+    }
+    get criticalPoints() {
+        return this._criticalPoints;
+    }
+    get isCircle() {
+        return +this.rx === +this.ry;
+    }
+    get phi() {
+        return this._phi;
+    }
+    get rx() {
+        return this._rx;
+    }
+    get ry() {
+        return this._ry;
+    }
+    clone() {
+        const values = this.values.map((value) => value.clone());
+        return new Ellipse(values);
+    }
+    computePointForTheta(theta, ellipse = this) {
+        const { center, rx, ry, phi } = ellipse;
+        const x = +Calculator.mul(+rx, phi.cos).mul(theta.cos).sub(Calculator.mul(+ry, phi.sin).mul(theta.sin)).add(center.x);
+        const y = +Calculator.mul(+rx, phi.sin).mul(theta.cos).add(Calculator.mul(+ry, phi.cos).mul(theta.sin)).add(center.y);
+        return new Point([x, y]);
+    }
+    computeThetaForPoint({ x, y }) {
+        const { center, phi, rx, ry } = this;
+        const { x: cx, y: cy } = center;
+        const dy = Calculator.sub(y, cy);
+        const dx = Calculator.sub(x, cx);
+        const sinTheta = dy.mul(phi.cos).sub(dx.mul(phi.sin)).div(+ry);
+        const cosTheta = dx.mul(phi.cos).add(dy.mul(phi.sin)).div(+rx);
+        const theta = new Angle(+Calculator.atan2(sinTheta, cosTheta), 'radians').normalize();
+        return theta;
+    }
+    reflect(about) {
+        super.reflect(about);
+        if (!this.isCircle && 'V' in about) {
+            const alpha = about.angleTo(xAxis);
+            this._phi.replace(+Calculator.mul(2, alpha.radians).sub(this.phi.radians), 'radians');
+            this._phi.normalize();
+        }
+        this.recompute();
+        return this;
+    }
+    rotate(alpha, about) {
+        this._center.rotate(alpha, about);
+        if (!this.isCircle) {
+            this._phi.replace(+Calculator.add(this.phi.radians, alpha.radians), 'radians');
+            this._phi.normalize();
+        }
+        this.recompute();
+        return this;
+    }
+    scale(factor, about = new Point([0, 0])) {
+        super.scale(factor, about);
+        this.recompute();
+        return this;
+    }
+    translate(vector) {
+        this._center.translate(vector);
+        this.recompute();
+        return this;
+    }
+    computeCriticalPoints(ellipse = this) {
+        const { rx, ry, phi } = ellipse;
+        const { computePointForTheta } = this;
+        const xThetaPrincipal = new Angle(+Calculator.neg(+ry).mul(phi.tan).div(+rx).atan(), 'radians');
+        const yThetaPrincipal = new Angle(+Calculator.mul(+ry, phi.cot).div(+rx).atan(), 'radians');
+        const xThetaSecondary = new Angle(+Calculator.add(+xThetaPrincipal, Math.PI), 'radians');
+        const yThetaSecondary = new Angle(+Calculator.add(+yThetaPrincipal, Math.PI), 'radians');
+        const firstPoint = computePointForTheta(xThetaPrincipal, ellipse);
+        const secondPoint = computePointForTheta(yThetaPrincipal, ellipse);
+        const thirdPoint = computePointForTheta(xThetaSecondary, ellipse);
+        const fourthPoint = computePointForTheta(yThetaSecondary, ellipse);
+        return [firstPoint, secondPoint, thirdPoint, fourthPoint];
+    }
+    recompute() {
+        this._criticalPoints = this.computeCriticalPoints();
+    }
+}

package/dist/esm/figures/Line.js

@@ -0,0 +1,260 @@
+import { Calculator } from '../utilities/Calculator';
+import { Angle } from '../abstracts/Angle';
+import { Point } from '../abstracts/Point';
+import { Vector } from '../abstracts/Vector';
+import { Figure } from '../abstracts/Figure';
+export class Line extends Figure {
+    _P0;
+    _P1;
+    _V;
+    _reciprocal;
+    _slope;
+    _xIntercept;
+    _yIntercept;
+    constructor(values) {
+        super(values);
+        const [P0, anchor] = values;
+        if (anchor instanceof Vector) {
+            this._V = anchor;
+            this._P1 = P0.clone().translate(anchor);
+            // anchor instanceof Point
+        }
+        else {
+            this._V = new Vector([P0, anchor]);
+            this._P1 = anchor;
+        }
+        this._P0 = P0;
+        this._slope = this.computeSlope();
+        this._yIntercept = this.computeYIntercept();
+        this._reciprocal = this.computeReciprocal();
+        this._xIntercept = this.computeXIntercept();
+        this.points = [this.P0, this.P1];
+        this.vectors = [this.V];
+    }
+    get P0() {
+        return this._P0;
+    }
+    get P1() {
+        return this._P1;
+    }
+    get V() {
+        return this._V;
+    }
+    // STANDARD EQUATION PARAMETERS (ax + by - c = 0)
+    get a() {
+        const { slope, isVertical, isHorizontal } = this;
+        if (isVertical) {
+            return 1;
+        }
+        if (isHorizontal) {
+            return 0;
+        }
+        return slope >= 0 ? slope : -slope;
+    }
+    get b() {
+        const { slope, isVertical, isHorizontal } = this;
+        if (isVertical) {
+            return 0;
+        }
+        if (isHorizontal) {
+            return 1;
+        }
+        return slope >= 0 ? -1 : 1;
+    }
+    get c() {
+        const { slope, isVertical, isHorizontal, yIntercept, xIntercept } = this;
+        if (isVertical) {
+            return xIntercept;
+        }
+        if (isHorizontal) {
+            return yIntercept;
+        }
+        return slope >= 0 ? -yIntercept : yIntercept;
+    }
+    get isHorizontal() {
+        const { slope, isVertical } = this;
+        return !isVertical && slope === 0;
+    }
+    get isVertical() {
+        const { slope } = this;
+        return typeof slope === 'undefined';
+    }
+    get reciprocal() {
+        return this._reciprocal;
+    }
+    get slope() {
+        return this._slope;
+    }
+    get xIntercept() {
+        return this._xIntercept;
+    }
+    get yIntercept() {
+        return this._yIntercept;
+    }
+    angleTo(line) {
+        if (this.isParallelTo(line)) {
+            return new Angle(0, 'radians');
+        }
+        if (this.isPerpendicularTo(line)) {
+            return new Angle(+Calculator.div(Math.PI, 2), 'radians');
+        }
+        if (typeof this.slope === 'undefined') {
+            return new Angle(+Calculator.atan(line.slope), 'radians');
+        }
+        if (typeof line.slope === 'undefined') {
+            return new Angle(+Calculator.atan(this.slope), 'radians');
+        }
+        const thisSlope = new Calculator(this.slope);
+        const lineSlope = new Calculator(line.slope);
+        return new Angle(+lineSlope.sub(thisSlope).div(thisSlope.mul(lineSlope).add(1)).abs().atan(), 'radians');
+    }
+    clone() {
+        const values = this.values.map((value) => value.clone());
+        return new Line(values);
+    }
+    getIntersectionPoint(line) {
+        if (this.isParallelTo(line)) {
+            return;
+        }
+        const denominator = Calculator.mul(this.a, line.b).sub(Calculator.mul(line.a, this.b));
+        const x = +Calculator.mul(this.b, line.c).sub(Calculator.mul(line.b, this.c)).div(denominator);
+        const y = +Calculator.mul(this.c, line.a).sub(Calculator.mul(line.c, this.a)).div(denominator);
+        return new Point([x, y]);
+    }
+    getPerpendicularProjection(point) {
+        const { P0, slope, isVertical, isHorizontal } = this;
+        let perpendicularProjection;
+        if (this.hasPoint(point)) {
+            return point.clone();
+        }
+        if (isVertical) {
+            perpendicularProjection = new Point([P0.x, point.y]);
+        }
+        else if (isHorizontal) {
+            perpendicularProjection = new Point([point.x, P0.y]);
+        }
+        else {
+            const x = new Calculator(1);
+            const y = x.mul(1).div(slope).neg().add(Calculator.div(point.x, slope)).add(point.y);
+            perpendicularProjection = new Point([+x, +y]);
+        }
+        return perpendicularProjection;
+    }
+    getPerpendicularThrough(point) {
+        if (this.hasPoint(point)) {
+            const phi = new Angle(+Calculator.div(Math.PI, 2), 'radians');
+            return this.clone().rotate(phi, point);
+        }
+        return new Line([point, this.getPerpendicularProjection(point)]);
+    }
+    getPointAtParameter(t) {
+        const { P0, V } = this;
+        const x = +Calculator.add(P0.x, Calculator.mul(V.dx, t));
+        const y = +Calculator.add(P0.y, Calculator.mul(V.dy, t));
+        return new Point([x, y]);
+    }
+    getXValueAtY(y) {
+        const { reciprocal, xIntercept } = this;
+        if (typeof reciprocal === 'undefined') {
+            return;
+        }
+        if (typeof xIntercept === 'undefined') {
+            return +Calculator.mul(reciprocal, y);
+        }
+        return +Calculator.mul(reciprocal, y).add(xIntercept);
+    }
+    getYValueAtX(x) {
+        const { slope, yIntercept } = this;
+        if (typeof slope === 'undefined') {
+            return;
+        }
+        if (typeof yIntercept === 'undefined') {
+            return +Calculator.mul(slope, x);
+        }
+        return +Calculator.mul(slope, x).add(yIntercept);
+    }
+    hasPoint(P) {
+        const potentialY = this.getYValueAtX(P.x);
+        return typeof potentialY === 'number' && potentialY === P.y;
+    }
+    isParallelTo(line) {
+        return this.slope == line.slope;
+    }
+    isPerpendicularTo(line) {
+        if (this.isVertical) {
+            return line.isHorizontal;
+        }
+        if (this.isHorizontal) {
+            return line.isVertical;
+        }
+        if (line.isVertical) {
+            return this.isHorizontal;
+        }
+        if (line.isHorizontal) {
+            return this.isVertical;
+        }
+        const thisSlope = new Calculator(this.slope);
+        const lineSlope = new Calculator(line.slope);
+        return +thisSlope === +Calculator.div(-1, lineSlope);
+    }
+    reflect(about) {
+        super.reflect(about);
+        this.recompute();
+        return this;
+    }
+    rotate(phi, about) {
+        super.rotate(phi, about);
+        this.recompute();
+        return this;
+    }
+    scale(factor, about) {
+        super.scale(factor, about);
+        this.recompute();
+        return this;
+    }
+    translate(vector) {
+        super.translate(vector);
+        this.recompute();
+        return this;
+    }
+    computeReciprocal() {
+        const { P0, P1 } = this;
+        const reciprocal = Calculator.sub(P1.x, P0.x).div(Calculator.sub(P1.y, P0.y));
+        if (reciprocal.isFinite()) {
+            return +reciprocal;
+        }
+    }
+    computeSlope() {
+        const { P0, P1 } = this;
+        const slope = Calculator.sub(P1.y, P0.y).div(Calculator.sub(P1.x, P0.x));
+        if (slope.isFinite()) {
+            return +slope;
+        }
+    }
+    computeXIntercept() {
+        const { P0, reciprocal, isHorizontal, isVertical } = this;
+        if (isVertical) {
+            return P0.x;
+        }
+        if (isHorizontal) {
+            return;
+        }
+        return +Calculator.sub(P0.x, Calculator.mul(reciprocal, P0.y));
+    }
+    computeYIntercept() {
+        const { P0, slope, isVertical, isHorizontal } = this;
+        if (isVertical) {
+            return;
+        }
+        if (isHorizontal) {
+            return P0.y;
+        }
+        return +Calculator.sub(P0.y, Calculator.mul(slope, P0.x));
+    }
+    recompute() {
+        this._slope = this.computeSlope();
+        this._yIntercept = this.computeYIntercept();
+        this._reciprocal = this.computeReciprocal();
+        this._xIntercept = this.computeXIntercept();
+    }
+}

package/dist/esm/figures/Polygon.js

@@ -0,0 +1,13 @@
+import { Figure } from '../abstracts/Figure';
+export class Polygon extends Figure {
+    constructor(values) {
+        super(values);
+    }
+    get sides() {
+        return this.points.length;
+    }
+    clone() {
+        const values = this.values.map((value) => value.clone());
+        return new Polygon(values);
+    }
+}

package/dist/esm/figures/QuadraticBezierCurve.js

@@ -0,0 +1,100 @@
+import { Calculator } from '../utilities/Calculator';
+import { Point } from '../abstracts/Point';
+import { Figure } from '../abstracts/Figure';
+export class QuadraticBezierCurve extends Figure {
+    _criticalPoints;
+    constructor(values) {
+        super(values);
+        this._criticalPoints = this.computeCriticalPoints();
+    }
+    get boundingBox() {
+        const [P0, , P2] = this.values;
+        const points = [P0, P2, ...this._criticalPoints];
+        return Figure.computeBoundingBox(points);
+    }
+    get criticalPoints() {
+        return this._criticalPoints;
+    }
+    get P0() {
+        return this.points[0];
+    }
+    get P1() {
+        if (this.isRelative) {
+            return this.P0.clone().translate(this.vectors[0]);
+        }
+        return this.points[1];
+    }
+    get P2() {
+        if (this.isRelative) {
+            return this.P0.clone().translate(this.vectors[1]);
+        }
+        return this.points[2];
+    }
+    clone() {
+        const values = this.values.map((value) => value.clone());
+        return new QuadraticBezierCurve(values);
+    }
+    recompute() {
+        this._criticalPoints = this.computeCriticalPoints();
+    }
+    reflect(about) {
+        super.reflect(about);
+        this.recompute();
+        return this;
+    }
+    rotate(phi, about) {
+        super.rotate(phi, about);
+        this.recompute();
+        return this;
+    }
+    scale(factor, about) {
+        super.scale(factor, about);
+        this.recompute();
+        return this;
+    }
+    translate(vector) {
+        super.translate(vector);
+        this.recompute();
+        return this;
+    }
+    computeCriticalPoints() {
+        const t = this.getCriticalPointTValue();
+        if (typeof t === 'undefined') {
+            return [];
+        }
+        const point = this.getPointAtParameter(t);
+        if (!point) {
+            return [];
+        }
+        return [point];
+    }
+    getCoordinateAtParameter(t, axis) {
+        const { P0, P1, P2 } = this;
+        const coordinate = Calculator.sub(1, t).pow(2).mul(P0[axis]).add(Calculator.sub(1, t).mul(2).mul(t).mul(P1[axis])).add(t.pow(2).mul(P2[axis]));
+        if (coordinate.isFinite()) {
+            return coordinate;
+        }
+    }
+    getCriticalPointTValue() {
+        const axii = ['x', 'y'];
+        const { P0, P1, P2 } = this;
+        let value;
+        for (let i = 0; i < axii.length; i++) {
+            const axis = axii[i];
+            const potentialValue = Calculator.sub(P0[axis], P1[axis]).div(Calculator.sub(P0[axis], Calculator.mul(P1[axis], 2)).add(P2[axis]));
+            if (+potentialValue > 0 && +potentialValue < 1) {
+                value = potentialValue;
+                break;
+            }
+        }
+        return value;
+    }
+    getPointAtParameter(t) {
+        const x = this.getCoordinateAtParameter(t, 'x');
+        const y = this.getCoordinateAtParameter(t, 'y');
+        if (typeof x === 'undefined' || typeof y === 'undefined') {
+            return;
+        }
+        return new Point([+x, +y]);
+    }
+}

package/dist/esm/index.js

@@ -0,0 +1,17 @@
+/* v8 ignore */
+export { Angle } from './abstracts/Angle';
+export { Figure } from './abstracts/Figure';
+export { Flag } from './abstracts/Flag';
+export { Magnitude } from './abstracts/Magnitude';
+export { Point } from './abstracts/Point';
+export { Vector } from './abstracts/Vector.js';
+export { ArcCurve } from './figures/ArcCurve';
+export { Circle } from './figures/Circle';
+export { CubicBezierCurve } from './figures/CubicBezierCurve';
+export { Ellipse } from './figures/Ellipse';
+export { Line } from './figures/Line';
+export { Polygon } from './figures/Polygon';
+export { QuadraticBezierCurve } from './figures/QuadraticBezierCurve';
+export { Calculator } from './utilities/Calculator';
+export * from './utilities';
+export * from './types';

package/dist/esm/types/index.js

@@ -0,0 +1 @@
+export {};