@js-draw/math 1.0.0

package/dist/cjs/shapes/BezierJSWrapper.js

@@ -0,0 +1,94 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _BezierJSWrapper_bezierJs;
+Object.defineProperty(exports, "__esModule", { value: true });
+const bezier_js_1 = require("bezier-js");
+const Vec2_1 = require("../Vec2");
+const Abstract2DShape_1 = __importDefault(require("./Abstract2DShape"));
+const Rect2_1 = __importDefault(require("./Rect2"));
+/**
+ * A lazy-initializing wrapper around Bezier-js.
+ *
+ * Subclasses may override `at`, `derivativeAt`, and `normal` with functions
+ * that do not initialize a `bezier-js` `Bezier`.
+ *
+ * Do not use this class directly. It may be removed/replaced in a future release.
+ * @internal
+ */
+class BezierJSWrapper extends Abstract2DShape_1.default {
+    constructor() {
+        super(...arguments);
+        _BezierJSWrapper_bezierJs.set(this, null);
+    }
+    getBezier() {
+        if (!__classPrivateFieldGet(this, _BezierJSWrapper_bezierJs, "f")) {
+            __classPrivateFieldSet(this, _BezierJSWrapper_bezierJs, new bezier_js_1.Bezier(this.getPoints().map(p => p.xy)), "f");
+        }
+        return __classPrivateFieldGet(this, _BezierJSWrapper_bezierJs, "f");
+    }
+    signedDistance(point) {
+        // .d: Distance
+        return this.getBezier().project(point.xy).d;
+    }
+    /**
+     * @returns the (more) exact distance from `point` to this.
+     *
+     * @see {@link approximateDistance}
+     */
+    distance(point) {
+        // A Bézier curve has no interior, thus, signed distance is the same as distance.
+        return this.signedDistance(point);
+    }
+    /**
+     * @returns the curve evaluated at `t`.
+     */
+    at(t) {
+        return Vec2_1.Vec2.ofXY(this.getBezier().get(t));
+    }
+    derivativeAt(t) {
+        return Vec2_1.Vec2.ofXY(this.getBezier().derivative(t));
+    }
+    normal(t) {
+        return Vec2_1.Vec2.ofXY(this.getBezier().normal(t));
+    }
+    getTightBoundingBox() {
+        const bbox = this.getBezier().bbox();
+        const width = bbox.x.max - bbox.x.min;
+        const height = bbox.y.max - bbox.y.min;
+        return new Rect2_1.default(bbox.x.min, bbox.y.min, width, height);
+    }
+    intersectsLineSegment(line) {
+        const bezier = this.getBezier();
+        const intersectionPoints = bezier.intersects(line).map(t => {
+            // We're using the .intersects(line) function, which is documented
+            // to always return numbers. However, to satisfy the type checker (and
+            // possibly improperly-defined types),
+            if (typeof t === 'string') {
+                t = parseFloat(t);
+            }
+            const point = Vec2_1.Vec2.ofXY(bezier.get(t));
+            // Ensure that the intersection is on the line segment
+            if (point.minus(line.p1).magnitude() > line.length
+                || point.minus(line.p2).magnitude() > line.length) {
+                return null;
+            }
+            return point;
+        }).filter(entry => entry !== null);
+        return intersectionPoints;
+    }
+}
+_BezierJSWrapper_bezierJs = new WeakMap();
+exports.default = BezierJSWrapper;

package/dist/cjs/shapes/CubicBezier.d.ts

@@ -0,0 +1,17 @@
+import { Point2 } from '../Vec2';
+import BezierJSWrapper from './BezierJSWrapper';
+import Rect2 from './Rect2';
+/**
+ * A wrapper around [`bezier-js`](https://github.com/Pomax/bezierjs)'s cubic Bezier.
+ */
+declare class CubicBezier extends BezierJSWrapper {
+    readonly p0: Point2;
+    readonly p1: Point2;
+    readonly p2: Point2;
+    readonly p3: Point2;
+    constructor(p0: Point2, p1: Point2, p2: Point2, p3: Point2);
+    getPoints(): import("../Vec3").Vec3[];
+    /** Returns an overestimate of this shape's bounding box. */
+    getLooseBoundingBox(): Rect2;
+}
+export default CubicBezier;

package/dist/cjs/shapes/CubicBezier.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BezierJSWrapper_1 = __importDefault(require("./BezierJSWrapper"));
+const Rect2_1 = __importDefault(require("./Rect2"));
+/**
+ * A wrapper around [`bezier-js`](https://github.com/Pomax/bezierjs)'s cubic Bezier.
+ */
+class CubicBezier extends BezierJSWrapper_1.default {
+    constructor(
+    // Start point
+    p0, 
+    // Control point 1
+    p1, 
+    // Control point 2
+    p2, 
+    // End point
+    p3) {
+        super();
+        this.p0 = p0;
+        this.p1 = p1;
+        this.p2 = p2;
+        this.p3 = p3;
+    }
+    getPoints() {
+        return [this.p0, this.p1, this.p2, this.p3];
+    }
+    /** Returns an overestimate of this shape's bounding box. */
+    getLooseBoundingBox() {
+        return Rect2_1.default.bboxOf([this.p0, this.p1, this.p2, this.p3]);
+    }
+}
+exports.default = CubicBezier;

package/dist/cjs/shapes/LineSegment2.d.ts

@@ -0,0 +1,70 @@
+import Mat33 from '../Mat33';
+import Rect2 from './Rect2';
+import { Vec2, Point2 } from '../Vec2';
+import Abstract2DShape from './Abstract2DShape';
+interface IntersectionResult {
+    point: Point2;
+    t: number;
+}
+/** Represents a line segment. A `LineSegment2` is immutable. */
+export declare class LineSegment2 extends Abstract2DShape {
+    private readonly point1;
+    private readonly point2;
+    /**
+     * The **unit** direction vector of this line segment, from
+     * `point1` to `point2`.
+     *
+     * In other words, `direction` is `point2.minus(point1).normalized()`
+     * (perhaps except when `point1` is equal to `point2`).
+     */
+    readonly direction: Vec2;
+    /** The distance between `point1` and `point2`. */
+    readonly length: number;
+    /** The bounding box of this line segment. */
+    readonly bbox: Rect2;
+    /** Creates a new `LineSegment2` from its endpoints. */
+    constructor(point1: Point2, point2: Point2);
+    /** Alias for `point1`. */
+    get p1(): Point2;
+    /** Alias for `point2`. */
+    get p2(): Point2;
+    /**
+     * Gets a point a distance `t` along this line.
+     *
+     * @deprecated
+     */
+    get(t: number): Point2;
+    /**
+     * Returns a point a fraction, `t`, along this line segment.
+     * Thus, `segment.at(0)` returns `segment.p1` and `segment.at(1)` returns
+     * `segment.p2`.
+     *
+     * `t` should be in `[0, 1]`.
+     */
+    at(t: number): Point2;
+    intersection(other: LineSegment2): IntersectionResult | null;
+    intersects(other: LineSegment2): boolean;
+    /**
+     * Returns the points at which this line segment intersects the
+     * given line segment.
+     *
+     * Note that {@link intersects} returns *whether* this line segment intersects another
+     * line segment. This method, by contrast, returns **the point** at which the intersection
+     * occurs, if such a point exists.
+     */
+    intersectsLineSegment(lineSegment: LineSegment2): import("../Vec3").Vec3[];
+    closestPointTo(target: Point2): import("../Vec3").Vec3;
+    /**
+     * Returns the distance from this line segment to `target`.
+     *
+     * Because a line segment has no interior, this signed distance is equivalent to
+     * the full distance between `target` and this line segment.
+     */
+    signedDistance(target: Point2): number;
+    /** Returns a copy of this line segment transformed by the given `affineTransfm`. */
+    transformedBy(affineTransfm: Mat33): LineSegment2;
+    /** @inheritdoc */
+    getTightBoundingBox(): Rect2;
+    toString(): string;
+}
+export default LineSegment2;

package/dist/cjs/shapes/LineSegment2.js

@@ -0,0 +1,183 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LineSegment2 = void 0;
+const Rect2_1 = __importDefault(require("./Rect2"));
+const Vec2_1 = require("../Vec2");
+const Abstract2DShape_1 = __importDefault(require("./Abstract2DShape"));
+/** Represents a line segment. A `LineSegment2` is immutable. */
+class LineSegment2 extends Abstract2DShape_1.default {
+    /** Creates a new `LineSegment2` from its endpoints. */
+    constructor(point1, point2) {
+        super();
+        this.point1 = point1;
+        this.point2 = point2;
+        this.bbox = Rect2_1.default.bboxOf([point1, point2]);
+        this.direction = point2.minus(point1);
+        this.length = this.direction.magnitude();
+        // Normalize
+        if (this.length > 0) {
+            this.direction = this.direction.times(1 / this.length);
+        }
+    }
+    // Accessors to make LineSegment2 compatible with bezier-js's
+    // interface
+    /** Alias for `point1`. */
+    get p1() {
+        return this.point1;
+    }
+    /** Alias for `point2`. */
+    get p2() {
+        return this.point2;
+    }
+    /**
+     * Gets a point a distance `t` along this line.
+     *
+     * @deprecated
+     */
+    get(t) {
+        return this.point1.plus(this.direction.times(t));
+    }
+    /**
+     * Returns a point a fraction, `t`, along this line segment.
+     * Thus, `segment.at(0)` returns `segment.p1` and `segment.at(1)` returns
+     * `segment.p2`.
+     *
+     * `t` should be in `[0, 1]`.
+     */
+    at(t) {
+        return this.get(t * this.length);
+    }
+    intersection(other) {
+        // We want x₁(t) = x₂(t) and y₁(t) = y₂(t)
+        // Observe that
+        // x = this.point1.x + this.direction.x · t₁
+        //   = other.point1.x + other.direction.x · t₂
+        // Thus,
+        //  t₁ = (x - this.point1.x) / this.direction.x
+        //     = (y - this.point1.y) / this.direction.y
+        // and
+        //  t₂ = (x - other.point1.x) / other.direction.x
+        // (and similarly for y)
+        //
+        // Letting o₁ₓ = this.point1.x, o₂ₓ = other.point1.x,
+        //         d₁ᵧ = this.direction.y, ...
+        //
+        // We can substitute these into the equations for y:
+        // y = o₁ᵧ + d₁ᵧ · (x - o₁ₓ) / d₁ₓ
+        //   = o₂ᵧ + d₂ᵧ · (x - o₂ₓ) / d₂ₓ
+        // ⇒ o₁ᵧ - o₂ᵧ = d₂ᵧ · (x - o₂ₓ) / d₂ₓ - d₁ᵧ · (x - o₁ₓ) / d₁ₓ
+        //            = (d₂ᵧ/d₂ₓ)(x) - (d₂ᵧ/d₂ₓ)(o₂ₓ) - (d₁ᵧ/d₁ₓ)(x) + (d₁ᵧ/d₁ₓ)(o₁ₓ)
+        //            = (x)(d₂ᵧ/d₂ₓ - d₁ᵧ/d₁ₓ) - (d₂ᵧ/d₂ₓ)(o₂ₓ) + (d₁ᵧ/d₁ₓ)(o₁ₓ)
+        // ⇒ (x)(d₂ᵧ/d₂ₓ - d₁ᵧ/d₁ₓ) = o₁ᵧ - o₂ᵧ + (d₂ᵧ/d₂ₓ)(o₂ₓ) - (d₁ᵧ/d₁ₓ)(o₁ₓ)
+        // ⇒ x = (o₁ᵧ - o₂ᵧ + (d₂ᵧ/d₂ₓ)(o₂ₓ) - (d₁ᵧ/d₁ₓ)(o₁ₓ))/(d₂ᵧ/d₂ₓ - d₁ᵧ/d₁ₓ)
+        //     = (d₁ₓd₂ₓ)(o₁ᵧ - o₂ᵧ + (d₂ᵧ/d₂ₓ)(o₂ₓ) - (d₁ᵧ/d₁ₓ)(o₁ₓ))/(d₂ᵧd₁ₓ - d₁ᵧd₂ₓ)
+        //     = ((o₁ᵧ - o₂ᵧ)((d₁ₓd₂ₓ)) + (d₂ᵧd₁ₓ)(o₂ₓ) - (d₁ᵧd₂ₓ)(o₁ₓ))/(d₂ᵧd₁ₓ - d₁ᵧd₂ₓ)
+        // ⇒ y = o₁ᵧ + d₁ᵧ · (x - o₁ₓ) / d₁ₓ = ...
+        let resultPoint, resultT;
+        if (this.direction.x === 0) {
+            // Vertical line: Where does the other have x = this.point1.x?
+            // x = o₁ₓ = o₂ₓ + d₂ₓ · (y - o₂ᵧ) / d₂ᵧ
+            // ⇒ (o₁ₓ - o₂ₓ)(d₂ᵧ/d₂ₓ) + o₂ᵧ = y
+            // Avoid division by zero
+            if (other.direction.x === 0 || this.direction.y === 0) {
+                return null;
+            }
+            const xIntersect = this.point1.x;
+            const yIntersect = (this.point1.x - other.point1.x) * other.direction.y / other.direction.x + other.point1.y;
+            resultPoint = Vec2_1.Vec2.of(xIntersect, yIntersect);
+            resultT = (yIntersect - this.point1.y) / this.direction.y;
+        }
+        else {
+            // From above,
+            // x = ((o₁ᵧ - o₂ᵧ)(d₁ₓd₂ₓ) + (d₂ᵧd₁ₓ)(o₂ₓ) - (d₁ᵧd₂ₓ)(o₁ₓ))/(d₂ᵧd₁ₓ - d₁ᵧd₂ₓ)
+            const numerator = ((this.point1.y - other.point1.y) * this.direction.x * other.direction.x
+                + this.direction.x * other.direction.y * other.point1.x
+                - this.direction.y * other.direction.x * this.point1.x);
+            const denominator = (other.direction.y * this.direction.x
+                - this.direction.y * other.direction.x);
+            // Avoid dividing by zero. It means there is no intersection
+            if (denominator === 0) {
+                return null;
+            }
+            const xIntersect = numerator / denominator;
+            const t1 = (xIntersect - this.point1.x) / this.direction.x;
+            const yIntersect = this.point1.y + this.direction.y * t1;
+            resultPoint = Vec2_1.Vec2.of(xIntersect, yIntersect);
+            resultT = (xIntersect - this.point1.x) / this.direction.x;
+        }
+        // Ensure the result is in this/the other segment.
+        const resultToP1 = resultPoint.minus(this.point1).magnitude();
+        const resultToP2 = resultPoint.minus(this.point2).magnitude();
+        const resultToP3 = resultPoint.minus(other.point1).magnitude();
+        const resultToP4 = resultPoint.minus(other.point2).magnitude();
+        if (resultToP1 > this.length
+            || resultToP2 > this.length
+            || resultToP3 > other.length
+            || resultToP4 > other.length) {
+            return null;
+        }
+        return {
+            point: resultPoint,
+            t: resultT,
+        };
+    }
+    intersects(other) {
+        return this.intersection(other) !== null;
+    }
+    /**
+     * Returns the points at which this line segment intersects the
+     * given line segment.
+     *
+     * Note that {@link intersects} returns *whether* this line segment intersects another
+     * line segment. This method, by contrast, returns **the point** at which the intersection
+     * occurs, if such a point exists.
+     */
+    intersectsLineSegment(lineSegment) {
+        const intersection = this.intersection(lineSegment);
+        if (intersection) {
+            return [intersection.point];
+        }
+        return [];
+    }
+    // Returns the closest point on this to [target]
+    closestPointTo(target) {
+        // Distance from P1 along this' direction.
+        const projectedDistFromP1 = target.minus(this.p1).dot(this.direction);
+        const projectedDistFromP2 = this.length - projectedDistFromP1;
+        const projection = this.p1.plus(this.direction.times(projectedDistFromP1));
+        if (projectedDistFromP1 > 0 && projectedDistFromP1 < this.length) {
+            return projection;
+        }
+        if (Math.abs(projectedDistFromP2) < Math.abs(projectedDistFromP1)) {
+            return this.p2;
+        }
+        else {
+            return this.p1;
+        }
+    }
+    /**
+     * Returns the distance from this line segment to `target`.
+     *
+     * Because a line segment has no interior, this signed distance is equivalent to
+     * the full distance between `target` and this line segment.
+     */
+    signedDistance(target) {
+        return this.closestPointTo(target).minus(target).magnitude();
+    }
+    /** Returns a copy of this line segment transformed by the given `affineTransfm`. */
+    transformedBy(affineTransfm) {
+        return new LineSegment2(affineTransfm.transformVec2(this.p1), affineTransfm.transformVec2(this.p2));
+    }
+    /** @inheritdoc */
+    getTightBoundingBox() {
+        return this.bbox;
+    }
+    toString() {
+        return `LineSegment(${this.p1.toString()}, ${this.p2.toString()})`;
+    }
+}
+exports.LineSegment2 = LineSegment2;
+exports.default = LineSegment2;

package/dist/cjs/shapes/Path.d.ts

@@ -0,0 +1,96 @@
+import LineSegment2 from './LineSegment2';
+import Mat33 from '../Mat33';
+import Rect2 from './Rect2';
+import { Point2 } from '../Vec2';
+import Abstract2DShape from './Abstract2DShape';
+export declare enum PathCommandType {
+    LineTo = 0,
+    MoveTo = 1,
+    CubicBezierTo = 2,
+    QuadraticBezierTo = 3
+}
+export interface CubicBezierPathCommand {
+    kind: PathCommandType.CubicBezierTo;
+    controlPoint1: Point2;
+    controlPoint2: Point2;
+    endPoint: Point2;
+}
+export interface QuadraticBezierPathCommand {
+    kind: PathCommandType.QuadraticBezierTo;
+    controlPoint: Point2;
+    endPoint: Point2;
+}
+export interface LinePathCommand {
+    kind: PathCommandType.LineTo;
+    point: Point2;
+}
+export interface MoveToPathCommand {
+    kind: PathCommandType.MoveTo;
+    point: Point2;
+}
+export type PathCommand = CubicBezierPathCommand | QuadraticBezierPathCommand | MoveToPathCommand | LinePathCommand;
+interface IntersectionResult {
+    curve: Abstract2DShape;
+    /** @internal @deprecated */
+    parameterValue?: number;
+    point: Point2;
+}
+type GeometryType = Abstract2DShape;
+type GeometryArrayType = Array<GeometryType>;
+/**
+ * Represents a union of lines and curves.
+ */
+export declare class Path {
+    readonly startPoint: Point2;
+    readonly parts: PathCommand[];
+    /**
+     * A rough estimate of the bounding box of the path.
+     * A slight overestimate.
+     * See {@link getExactBBox}
+     */
+    readonly bbox: Rect2;
+    constructor(startPoint: Point2, parts: PathCommand[]);
+    getExactBBox(): Rect2;
+    private cachedGeometry;
+    get geometry(): GeometryArrayType;
+    private cachedPolylineApproximation;
+    polylineApproximation(): LineSegment2[];
+    static computeBBoxForSegment(startPoint: Point2, part: PathCommand): Rect2;
+    /**
+     * Let `S` be a closed path a distance `strokeRadius` from this path.
+     *
+     * @returns Approximate intersections of `line` with `S` using ray marching, starting from
+     * 	        both end points of `line` and each point in `additionalRaymarchStartPoints`.
+     */
+    private raymarchIntersectionWith;
+    /**
+     * Returns a list of intersections with this path. If `strokeRadius` is given,
+     * intersections are approximated with the surface `strokeRadius` away from this.
+     *
+     * If `strokeRadius > 0`, the resultant `parameterValue` has no defined value.
+     */
+    intersection(line: LineSegment2, strokeRadius?: number): IntersectionResult[];
+    private static mapPathCommand;
+    mapPoints(mapping: (point: Point2) => Point2): Path;
+    transformedBy(affineTransfm: Mat33): Path;
+    union(other: Path | null): Path;
+    private getEndPoint;
+    roughlyIntersects(rect: Rect2, strokeWidth?: number): boolean;
+    closedRoughlyIntersects(rect: Rect2): boolean;
+    static fromRect(rect: Rect2, lineWidth?: number | null): Path;
+    private cachedStringVersion;
+    toString(useNonAbsCommands?: boolean): string;
+    serialize(): string;
+    static toString(startPoint: Point2, parts: PathCommand[], onlyAbsCommands?: boolean): string;
+    /**
+     * Create a Path from a SVG path specification.
+     *
+     * ## To-do
+     * - TODO: Support a larger subset of SVG paths
+     *   - Elliptical arcs are currently unsupported.
+     * - TODO: Support `s`,`t` commands shorthands.
+     */
+    static fromString(pathString: string): Path;
+    static empty: Path;
+}
+export default Path;