@js-draw/math 1.0.0

package/dist/mjs/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/mjs/shapes/CubicBezier.mjs

@@ -0,0 +1,30 @@
+import  BezierJSWrapper  from './BezierJSWrapper.mjs';
+import  Rect2  from './Rect2.mjs';
+/**
+ * A wrapper around [`bezier-js`](https://github.com/Pomax/bezierjs)'s cubic Bezier.
+ */
+class CubicBezier extends BezierJSWrapper {
+    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.bboxOf([this.p0, this.p1, this.p2, this.p3]);
+    }
+}
+export default CubicBezier;

package/dist/mjs/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/mjs/shapes/LineSegment2.mjs

@@ -0,0 +1,176 @@
+import  Rect2  from './Rect2.mjs';
+import  { Vec2 }  from '../Vec2.mjs';
+import  Abstract2DShape  from './Abstract2DShape.mjs';
+/** Represents a line segment. A `LineSegment2` is immutable. */
+export class LineSegment2 extends Abstract2DShape {
+    /** Creates a new `LineSegment2` from its endpoints. */
+    constructor(point1, point2) {
+        super();
+        this.point1 = point1;
+        this.point2 = point2;
+        this.bbox = Rect2.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.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.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()})`;
+    }
+}
+export default LineSegment2;

package/dist/mjs/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;