@revideo/2d 0.1.0

package/lib/curves/QuadBezierSegment.d.ts

@@ -0,0 +1,17 @@
+import { Vector2 } from '@revideo/core';
+import { PolynomialSegment } from './PolynomialSegment';
+/**
+ * A spline segment representing a quadratic Bézier curve.
+ */
+export declare class QuadBezierSegment extends PolynomialSegment {
+    readonly p0: Vector2;
+    readonly p1: Vector2;
+    readonly p2: Vector2;
+    private static el;
+    get points(): Vector2[];
+    constructor(p0: Vector2, p1: Vector2, p2: Vector2);
+    split(t: number): [PolynomialSegment, PolynomialSegment];
+    protected static getLength(p0: Vector2, p1: Vector2, p2: Vector2): number;
+    protected doDraw(context: CanvasRenderingContext2D | Path2D): void;
+}
+//# sourceMappingURL=QuadBezierSegment.d.ts.map

package/lib/curves/QuadBezierSegment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QuadBezierSegment.d.ts","sourceRoot":"","sources":["../../src/lib/curves/QuadBezierSegment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAAO,MAAM,eAAe,CAAC;AAG5C,OAAO,EAAC,iBAAiB,EAAC,MAAM,qBAAqB,CAAC;AAEtD;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,iBAAiB;aASpC,EAAE,EAAE,OAAO;aACX,EAAE,EAAE,OAAO;aACX,EAAE,EAAE,OAAO;IAT7B,OAAO,CAAC,MAAM,CAAC,EAAE,CAAiB;IAElC,IAAW,MAAM,IAAI,OAAO,EAAE,CAE7B;gBAGiB,EAAE,EAAE,OAAO,EACX,EAAE,EAAE,OAAO,EACX,EAAE,EAAE,OAAO;IActB,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,CAAC,iBAAiB,EAAE,iBAAiB,CAAC;IAiB/D,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,GAAG,MAAM;cAUtD,MAAM,CAAC,OAAO,EAAE,wBAAwB,GAAG,MAAM;CAGrE"}

package/lib/curves/QuadBezierSegment.js

@@ -0,0 +1,49 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Vector2, lazy } from '@revideo/core';
+import { quadraticCurveTo } from '../utils';
+import { Polynomial2D } from './Polynomial2D';
+import { PolynomialSegment } from './PolynomialSegment';
+/**
+ * A spline segment representing a quadratic Bézier curve.
+ */
+export class QuadBezierSegment extends PolynomialSegment {
+    get points() {
+        return [this.p0, this.p1, this.p2];
+    }
+    constructor(p0, p1, p2) {
+        super(new Polynomial2D(p0, 
+        // 2*(-p0+p1)
+        p0.flipped.add(p1).scale(2), 
+        // p0-2*p1+p2
+        p0.sub(p1.scale(2)).add(p2)), QuadBezierSegment.getLength(p0, p1, p2));
+        this.p0 = p0;
+        this.p1 = p1;
+        this.p2 = p2;
+    }
+    split(t) {
+        const a = new Vector2(this.p0.x + (this.p1.x - this.p0.x) * t, this.p0.y + (this.p1.y - this.p0.y) * t);
+        const b = new Vector2(this.p1.x + (this.p2.x - this.p1.x) * t, this.p1.y + (this.p2.y - this.p1.y) * t);
+        const p = new Vector2(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t);
+        const left = new QuadBezierSegment(this.p0, a, p);
+        const right = new QuadBezierSegment(p, b, this.p2);
+        return [left, right];
+    }
+    static getLength(p0, p1, p2) {
+        // Let the browser do the work for us instead of calculating the arclength
+        // manually.
+        QuadBezierSegment.el.setAttribute('d', `M ${p0.x} ${p0.y} Q ${p1.x} ${p1.y} ${p2.x} ${p2.y}`);
+        return QuadBezierSegment.el.getTotalLength();
+    }
+    doDraw(context) {
+        quadraticCurveTo(context, this.p1, this.p2);
+    }
+}
+__decorate([
+    lazy(() => document.createElementNS('http://www.w3.org/2000/svg', 'path'))
+], QuadBezierSegment, "el", void 0);
+//# sourceMappingURL=data:application/json;base64,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

package/lib/curves/Segment.d.ts

@@ -0,0 +1,9 @@
+import { Vector2 } from '@revideo/core';
+import { CurvePoint } from './CurvePoint';
+export declare abstract class Segment {
+    abstract readonly points: Vector2[];
+    abstract draw(context: CanvasRenderingContext2D | Path2D, start: number, end: number, move: boolean): [CurvePoint, CurvePoint];
+    abstract getPoint(distance: number): CurvePoint;
+    abstract get arcLength(): number;
+}
+//# sourceMappingURL=Segment.d.ts.map

package/lib/curves/Segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Segment.d.ts","sourceRoot":"","sources":["../../src/lib/curves/Segment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAAC,MAAM,eAAe,CAAC;AACtC,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AAExC,8BAAsB,OAAO;IAC3B,kBAAyB,MAAM,EAAE,OAAO,EAAE,CAAC;aAE3B,IAAI,CAClB,OAAO,EAAE,wBAAwB,GAAG,MAAM,EAC1C,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,OAAO,GACZ,CAAC,UAAU,EAAE,UAAU,CAAC;aAEX,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU;IAEtD,aAAoB,SAAS,IAAI,MAAM,CAAC;CACzC"}

package/lib/curves/Segment.js

@@ -0,0 +1,3 @@
+export class Segment {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2VnbWVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9saWIvY3VydmVzL1NlZ21lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsTUFBTSxPQUFnQixPQUFPO0NBYTVCIn0=

package/lib/curves/UniformPolynomialCurveSampler.d.ts

@@ -0,0 +1,43 @@
+import { CurvePoint } from './CurvePoint';
+import { PolynomialSegment } from './PolynomialSegment';
+/**
+ * Class to uniformly sample points on a given polynomial curve.
+ *
+ * @remarks
+ * In order to uniformly sample points from non-linear curves, this sampler
+ * re-parameterizes the curve by arclength.
+ */
+export declare class UniformPolynomialCurveSampler {
+    private readonly curve;
+    private sampledDistances;
+    /**
+     * @param curve - The curve to sample
+     * @param samples - How many points to sample from the provided curve. The
+     *                  more points get sampled, the higher the resolution–and
+     *                  therefore precision–of the sampler.
+     */
+    constructor(curve: PolynomialSegment, samples?: number);
+    /**
+     * Discard all previously sampled points and resample the provided number of
+     * points from the curve.
+     *
+     * @param samples - The number of points to sample.
+     */
+    resample(samples: number): void;
+    /**
+     * Return the point at the provided distance along the sampled curve's
+     * arclength.
+     *
+     * @param distance - The distance along the curve's arclength for which to
+     *                   retrieve the point.
+     */
+    pointAtDistance(distance: number): CurvePoint;
+    /**
+     * Return the t value for the point at the provided distance along the sampled
+     * curve's arc length.
+     *
+     * @param distance - The distance along the arclength
+     */
+    distanceToT(distance: number): number;
+}
+//# sourceMappingURL=UniformPolynomialCurveSampler.d.ts.map

package/lib/curves/UniformPolynomialCurveSampler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UniformPolynomialCurveSampler.d.ts","sourceRoot":"","sources":["../../src/lib/curves/UniformPolynomialCurveSampler.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AACxC,OAAO,EAAC,iBAAiB,EAAC,MAAM,qBAAqB,CAAC;AAEtD;;;;;;GAMG;AACH,qBAAa,6BAA6B;IAUtC,OAAO,CAAC,QAAQ,CAAC,KAAK;IATxB,OAAO,CAAC,gBAAgB,CAAgB;IAExC;;;;;OAKG;gBAEgB,KAAK,EAAE,iBAAiB,EACzC,OAAO,SAAK;IAKd;;;;;OAKG;IACI,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAsBtC;;;;;;OAMG;IACI,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU;IAIpD;;;;;OAKG;IACI,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;CAoB7C"}

package/lib/curves/UniformPolynomialCurveSampler.js

@@ -0,0 +1,73 @@
+import { clamp, remap } from '@revideo/core';
+/**
+ * Class to uniformly sample points on a given polynomial curve.
+ *
+ * @remarks
+ * In order to uniformly sample points from non-linear curves, this sampler
+ * re-parameterizes the curve by arclength.
+ */
+export class UniformPolynomialCurveSampler {
+    /**
+     * @param curve - The curve to sample
+     * @param samples - How many points to sample from the provided curve. The
+     *                  more points get sampled, the higher the resolution–and
+     *                  therefore precision–of the sampler.
+     */
+    constructor(curve, samples = 20) {
+        this.curve = curve;
+        this.sampledDistances = [];
+        this.resample(samples);
+    }
+    /**
+     * Discard all previously sampled points and resample the provided number of
+     * points from the curve.
+     *
+     * @param samples - The number of points to sample.
+     */
+    resample(samples) {
+        this.sampledDistances = [0];
+        let length = 0;
+        let previous = this.curve.eval(0).position;
+        for (let i = 1; i < samples; i++) {
+            const t = i / (samples - 1);
+            const curvePoint = this.curve.eval(t);
+            const segmentLength = previous.sub(curvePoint.position).magnitude;
+            length += segmentLength;
+            this.sampledDistances.push(length);
+            previous = curvePoint.position;
+        }
+        // Account for any accumulated floating point errors and explicitly set the
+        // distance of the last point to the arclength of the curve.
+        this.sampledDistances[this.sampledDistances.length - 1] =
+            this.curve.arcLength;
+    }
+    /**
+     * Return the point at the provided distance along the sampled curve's
+     * arclength.
+     *
+     * @param distance - The distance along the curve's arclength for which to
+     *                   retrieve the point.
+     */
+    pointAtDistance(distance) {
+        return this.curve.eval(this.distanceToT(distance));
+    }
+    /**
+     * Return the t value for the point at the provided distance along the sampled
+     * curve's arc length.
+     *
+     * @param distance - The distance along the arclength
+     */
+    distanceToT(distance) {
+        const samples = this.sampledDistances.length;
+        distance = clamp(0, this.curve.arcLength, distance);
+        for (let i = 0; i < samples; i++) {
+            const lower = this.sampledDistances[i];
+            const upper = this.sampledDistances[i + 1];
+            if (distance >= lower && distance <= upper) {
+                return remap(lower, upper, i / (samples - 1), (i + 1) / (samples - 1), distance);
+            }
+        }
+        return 1;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/curves/createCurveProfileLerp.d.ts

@@ -0,0 +1,32 @@
+import { Vector2 } from '@revideo/core';
+import { CurveProfile } from './CurveProfile';
+/**
+ * Calculate polygon perimeter
+ * @param points - polygon points
+ * @returns - perimeter of polygon
+ */
+export declare function polygonLength(points: Vector2[]): number;
+/**
+ * Calculate total moving point distance when morphing between polygon points
+ * @param points - first polygon points
+ * @param reference - second polygon points
+ * @param offset - offset for first polygon points
+ * @returns
+ */
+export declare function calculateLerpDistance(points: Vector2[], reference: Vector2[], offset: number): number;
+/**
+ * Interpolate between two polygon points.
+ * @param from - source polygon points
+ * @param to - target polygon points
+ * @param value - interpolation progress
+ * @returns - new polygon points
+ */
+export declare function polygonPointsLerp(from: Vector2[], to: Vector2[], value: number): Vector2[];
+/**
+ * Create interpolator to tween between two curve
+ * @param a - source curve
+ * @param b - target curve
+ * @returns - curve interpolator
+ */
+export declare function createCurveProfileLerp(a: CurveProfile, b: CurveProfile): (progress: number) => CurveProfile;
+//# sourceMappingURL=createCurveProfileLerp.d.ts.map

package/lib/curves/createCurveProfileLerp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createCurveProfileLerp.d.ts","sourceRoot":"","sources":["../../src/lib/curves/createCurveProfileLerp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAAC,MAAM,eAAe,CAAC;AACtC,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAsL5C;;;;GAIG;AAEH,wBAAgB,aAAa,CAAC,MAAM,EAAE,OAAO,EAAE,UAK9C;AAqCD;;;;;;GAMG;AAEH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,OAAO,EAAE,EACjB,SAAS,EAAE,OAAO,EAAE,EACpB,MAAM,EAAE,MAAM,UAYf;AAyKD;;;;;;GAMG;AAEH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,OAAO,EAAE,EACf,EAAE,EAAE,OAAO,EAAE,EACb,KAAK,EAAE,MAAM,GACZ,OAAO,EAAE,CAWX;AAED;;;;;GAKG;AAEH,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,cAGnD,MAAM,kBAYzB"}

package/lib/curves/createCurveProfileLerp.js

@@ -0,0 +1,351 @@
+import { Vector2 } from '@revideo/core';
+import { LineSegment } from './LineSegment';
+import { getPointAtDistance } from './getPointAtDistance';
+import { getPolylineProfile } from './getPolylineProfile';
+/**
+ * Split segments of polygon until distance between adjacent point is less than or equal maxLength. This function mutate original points.
+ * @param points - Polygon points
+ * @param maxLength - max distance between two point
+ */
+function bisect(points, maxLength) {
+    for (let i = 0; i < points.length - 1; i++) {
+        const a = points[i];
+        let b = points[i + 1];
+        while (a.sub(b).magnitude > maxLength) {
+            b = Vector2.lerp(a, b, 0.5);
+            points.splice(i + 1, 0, b);
+        }
+    }
+}
+/**
+ * Convert curve which only contain LineSegment into polygon.
+ * @param curve - curve to convert. curve must contain 1 subpath
+ * @param maxLength - max distance between two point
+ * @returns - null if curve contain segment other than LineSegment
+ */
+function exactPolygonPoints(curve, maxLength) {
+    const points = [];
+    let endPoint = null;
+    for (const segment of curve.segments) {
+        if (!(segment instanceof LineSegment))
+            return null;
+        points.push(segment.from);
+        endPoint = segment.to;
+    }
+    if (endPoint)
+        points.push(endPoint);
+    if (!Number.isNaN(maxLength) && maxLength > 0) {
+        bisect(points, maxLength);
+    }
+    return points;
+}
+/**
+ * Calculate area of polygon
+ * @param points - polygon points
+ * @returns - area of polygon
+ */
+function polygonArea(points) {
+    return (points.reduce((area, a, i) => {
+        const b = points[(i + 1) % points.length];
+        return area + (a.y * b.x - a.x * b.y);
+    }, 0) / 2);
+}
+/**
+ * Convert curve into polygon by sampling curve profile
+ * @param curve - curve to convert. curve must contain only 1 subpath
+ * @param maxLength - max distance between point
+ * @returns - always return polygon points
+ */
+function approximatePolygonPoints(curve, maxLength) {
+    const points = [];
+    let numPoints = 3;
+    if (!Number.isNaN(maxLength) && maxLength > 0) {
+        numPoints = Math.max(numPoints, Math.ceil(curve.arcLength / maxLength));
+    }
+    for (let i = 0; i < numPoints; i += 1) {
+        const point = getPointAtDistance(curve, curve.arcLength * (i / (numPoints - 1)));
+        points.push(point.position);
+    }
+    if (polygonArea(points) > 0)
+        points.reverse();
+    return points;
+}
+/**
+ * Split curve into subpaths
+ * @param curve - curve to split
+ * @returns - subpaths of curve
+ */
+function splitCurve(curve) {
+    if (curve.segments.length === 0)
+        return [];
+    let current = {
+        arcLength: 0,
+        minSin: 0,
+        segments: [],
+        closed: false,
+    };
+    let endPoint = null;
+    const composite = [current];
+    for (const segment of curve.segments) {
+        const start = segment.getPoint(0).position;
+        if (endPoint && !start.equals(endPoint)) {
+            current = {
+                arcLength: 0,
+                minSin: 0,
+                segments: [],
+                closed: false,
+            };
+            composite.push(current);
+        }
+        current.segments.push(segment);
+        current.arcLength += segment.arcLength;
+        endPoint = segment.getPoint(1).position;
+    }
+    for (const sub of composite) {
+        sub.closed = sub.segments[0]
+            .getPoint(0)
+            .position.equals(sub.segments[sub.segments.length - 1].getPoint(1).position);
+    }
+    return composite;
+}
+/**
+ * Convert curve into polygon use best possible method
+ * @param curve - curve to convert
+ * @param maxLength - max distance between two point
+ * @returns - polgon points
+ */
+function subcurveToPolygon(curve, maxLength) {
+    const points = exactPolygonPoints(curve, maxLength) ||
+        approximatePolygonPoints(curve, maxLength);
+    return {
+        points: [...points],
+        closed: curve.closed,
+    };
+}
+/**
+ * Calculate polygon perimeter
+ * @param points - polygon points
+ * @returns - perimeter of polygon
+ */
+export function polygonLength(points) {
+    return points.reduce((length, point, i) => {
+        if (i)
+            return length + points[i - 1].sub(point).magnitude;
+        return 0;
+    }, 0);
+}
+/**s
+ * Sample additional points for polygon to better match its pair. This will mutate original points.
+ * @param points - polygon points
+ * @param numPoints - number of points to be added
+ */
+function addPoints(points, numPoints) {
+    const desiredLength = points.length + numPoints;
+    const step = polygonLength(points) / numPoints;
+    let i = 0;
+    let cursor = 0;
+    let insertAt = step / 2;
+    while (points.length < desiredLength) {
+        const a = points[i];
+        const b = points[(i + 1) % points.length];
+        const length = a.sub(b).magnitude;
+        if (insertAt <= cursor + length) {
+            points.splice(i + 1, 0, length
+                ? Vector2.lerp(a, b, (insertAt - cursor) / length)
+                : new Vector2(a));
+            insertAt += step;
+        }
+        else {
+            cursor += length;
+            i += 1;
+        }
+    }
+}
+/**
+ * Calculate total moving point distance when morphing between polygon points
+ * @param points - first polygon points
+ * @param reference - second polygon points
+ * @param offset - offset for first polygon points
+ * @returns
+ */
+export function calculateLerpDistance(points, reference, offset) {
+    const len = points.length;
+    let sumOfSquares = 0;
+    for (let i = 0; i < reference.length; i += 1) {
+        const a = points[(offset + i) % len];
+        const b = reference[i];
+        sumOfSquares += a.sub(b).squaredMagnitude;
+    }
+    return sumOfSquares;
+}
+/**
+ * Rotate polygon in order to minimize moving points.
+ * @param polygon - polygon to be rotated
+ * @param reference - polygon to be reference
+ */
+function rotatePolygon(polygon, reference) {
+    const { points, closed } = polygon;
+    const len = points.length;
+    if (!closed) {
+        const originalDistance = calculateLerpDistance(points, reference.points, 0);
+        const reversedPoints = [...points].reverse();
+        const reversedDistance = calculateLerpDistance(reversedPoints, reference.points, 0);
+        if (reversedDistance < originalDistance)
+            polygon.points = reversedPoints;
+    }
+    else {
+        let minDistance = Infinity;
+        let bestOffset = 0;
+        const last = points.pop();
+        // Closed polygon first point must equal last point
+        // When we rotate polygon, first point is changed which mean last point also must changed
+        // When we remove last point, calculateLerpDistance will assume last point is equal first point
+        // Proof:
+        // len = points.length = reference.length - 1
+        // When i = 0:
+        // (offset + i) % len = offset % len
+        // When i = reference.length - 1 or i = len
+        // (offset + i) % len = (offset + len) % len = offset % len
+        for (let offset = 0; offset < len; offset += 1) {
+            const distance = calculateLerpDistance(points, reference.points, offset);
+            if (distance < minDistance) {
+                minDistance = distance;
+                bestOffset = offset;
+            }
+        }
+        if (last)
+            points.push(last);
+        if (bestOffset) {
+            points.pop();
+            const spliced = points.splice(0, bestOffset);
+            points.splice(points.length, 0, ...spliced);
+            points.push(points[0]);
+        }
+    }
+}
+/**
+ * Round polygon's points coordinate to a specified amount of decimal
+ * @param points - polygon point to be rounded
+ * @param round - amount of decimal
+ * @returns - new polygon point
+ */
+function roundPolygon({ points, ...rest }, round) {
+    const pow = round >= 1 ? 10 ** round : 1;
+    return {
+        points: points.map(point => {
+            const [x, y] = [point.x, point.y].map(n => Math.round(n * pow) / pow);
+            return new Vector2(x, y);
+        }),
+        ...rest,
+    };
+}
+/**
+ * Create two polygon to tween between sub curve/path
+ * @param from - source curve
+ * @param to - targe curve
+ * @param precision - desired distance between two point
+ * @param round - amount of decimal when rounding
+ * @returns two polygon ready to tween
+ */
+function getSubcurveInterpolationPolygon(from, to, precision, round) {
+    const morphPrecision = precision;
+    const fromRing = subcurveToPolygon(from, morphPrecision);
+    const toRing = subcurveToPolygon(to, morphPrecision);
+    const diff = fromRing.points.length - toRing.points.length;
+    addPoints(fromRing.points, diff < 0 ? diff * -1 : 0);
+    addPoints(toRing.points, diff > 0 ? diff : 0);
+    if (!from.closed && to.closed)
+        rotatePolygon(toRing, fromRing);
+    else
+        rotatePolygon(fromRing, toRing);
+    return {
+        from: roundPolygon(fromRing, round),
+        to: roundPolygon(toRing, round),
+    };
+}
+/**
+ * Make two sub curve list have equal length
+ * @param subcurves - List to add
+ * @param reference - Reference list
+ */
+function balanceSubcurves(subcurves, reference) {
+    for (let i = subcurves.length; i < reference.length; i++) {
+        const point = reference[i].segments[0].getPoint(0).position;
+        subcurves.push({
+            arcLength: 0,
+            closed: false,
+            minSin: 0,
+            segments: [new LineSegment(point, point)],
+        });
+    }
+}
+/**
+ * Create two polygon to tween between curve
+ * @param from - source curve
+ * @param to - targe curve
+ * @param precision - desired distance between two point
+ * @param round - amount of decimal when rounding
+ * @returns list that contain list of polygon before and after tween
+ */
+function getInterpolationPolygon(from, to, precision, round) {
+    const fromSub = splitCurve(from);
+    const toSub = splitCurve(to);
+    if (fromSub.length < toSub.length)
+        balanceSubcurves(fromSub, toSub);
+    else
+        balanceSubcurves(toSub, fromSub);
+    return fromSub.map((sub, i) => getSubcurveInterpolationPolygon(sub, toSub[i], precision, round));
+}
+/**
+ * Add curve into another curve
+ * @param target - target curve
+ * @param source - curve to add
+ */
+function addCurveToCurve(target, source) {
+    const { segments, arcLength, minSin } = source;
+    target.segments.push(...segments);
+    target.arcLength += arcLength;
+    target.minSin = Math.min(target.minSin, minSin);
+}
+/**
+ * Interpolate between two polygon points.
+ * @param from - source polygon points
+ * @param to - target polygon points
+ * @param value - interpolation progress
+ * @returns - new polygon points
+ */
+export function polygonPointsLerp(from, to, value) {
+    const points = [];
+    if (value === 0)
+        return [...from];
+    if (value === 1)
+        return [...to];
+    for (let i = 0; i < from.length; i++) {
+        const a = from[i];
+        const b = to[i];
+        points.push(Vector2.lerp(a, b, value));
+    }
+    return points;
+}
+/**
+ * Create interpolator to tween between two curve
+ * @param a - source curve
+ * @param b - target curve
+ * @returns - curve interpolator
+ */
+export function createCurveProfileLerp(a, b) {
+    const interpolations = getInterpolationPolygon(a, b, 5, 4);
+    return (progress) => {
+        const curve = {
+            segments: [],
+            arcLength: 0,
+            minSin: 1,
+        };
+        for (const { from, to } of interpolations) {
+            const points = polygonPointsLerp(from.points, to.points, progress);
+            addCurveToCurve(curve, getPolylineProfile(points, 0, false));
+        }
+        return curve;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"createCurveProfileLerp.js","sourceRoot":"","sources":["../../src/lib/curves/createCurveProfileLerp.ts"],"names":[],"mappings":"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"}

package/lib/curves/getBezierSplineProfile.d.ts

@@ -0,0 +1,12 @@
+import { CurveProfile } from './CurveProfile';
+import { KnotInfo } from './KnotInfo';
+/**
+ * Calculate the curve profile of a spline based on a set of knots.
+ *
+ * @param knots - The knots defining the spline
+ * @param closed - Whether the spline should be closed or not
+ * @param smoothness - The desired smoothness of the spline when using auto
+ *                     calculated handles.
+ */
+export declare function getBezierSplineProfile(knots: KnotInfo[], closed: boolean, smoothness: number): CurveProfile;
+//# sourceMappingURL=getBezierSplineProfile.d.ts.map

package/lib/curves/getBezierSplineProfile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getBezierSplineProfile.d.ts","sourceRoot":"","sources":["../../src/lib/curves/getBezierSplineProfile.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAC,QAAQ,EAAC,MAAM,YAAY,CAAC;AAsGpC;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,QAAQ,EAAE,EACjB,MAAM,EAAE,OAAO,EACf,UAAU,EAAE,MAAM,GACjB,YAAY,CAyGd"}