@twick/2d 0.11.0

package/lib/curves/UniformPolynomialCurveSampler.js

@@ -0,0 +1,73 @@
+import { clamp, remap } from '@twick/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 '@twick/core';
+import type { 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,aAAa,CAAC;AACpC,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAsLjD;;;;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 '@twick/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 type { CurveProfile } from './CurveProfile';
+import type { 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,KAAK,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AACjD,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,YAAY,CAAC;AAsGzC;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,QAAQ,EAAE,EACjB,MAAM,EAAE,OAAO,EACf,UAAU,EAAE,MAAM,GACjB,YAAY,CAyGd"}

package/lib/curves/getBezierSplineProfile.js

@@ -0,0 +1,137 @@
+import { Vector2, clamp } from '@twick/core';
+import { CubicBezierSegment } from './CubicBezierSegment';
+import { QuadBezierSegment } from './QuadBezierSegment';
+function isCubicSegment(segment) {
+    return segment instanceof CubicBezierSegment;
+}
+/**
+ * Update a given knot's handles to be a blend between the user provided handles
+ * and a set of auto calculated handles that smoothly connect the knot to its
+ * two neighboring knots.
+ *
+ * @param knot - The knot for which to calculate the handles
+ * @param previous - The previous knot in the spline, relative to the provided
+ *                   knot.
+ * @param next - The next knot in the spline, relative to the provided knot.
+ * @param smoothness - The desired smoothness of the spline. Affects the scaling
+ *                     of the auto calculated handles.
+ */
+function calculateSmoothHandles(knot, previous, next, smoothness) {
+    if (knot.auto.start === 0 && knot.auto.end === 0) {
+        return;
+    }
+    // See for reference:
+    // http://scaledinnovation.com/analytics/splines/aboutSplines.html
+    const distanceToPrev = knot.position.sub(previous.position).magnitude;
+    const distanceToNext = next.position.sub(knot.position).magnitude;
+    const fa = (smoothness * distanceToPrev) / (distanceToPrev + distanceToNext);
+    const fb = smoothness - fa;
+    const startHandle = new Vector2(knot.position.x - fa * (next.position.x - previous.position.x), knot.position.y - fa * (next.position.y - previous.position.y));
+    const endHandle = new Vector2(knot.position.x + fb * (next.position.x - previous.position.x), knot.position.y + fb * (next.position.y - previous.position.y));
+    knot.startHandle = knot.startHandle.lerp(startHandle, knot.auto.start);
+    knot.endHandle = knot.endHandle.lerp(endHandle, knot.auto.end);
+}
+/**
+ * Calculate the `minSin` value of the curve profile so that miter joins get
+ * taken into account properly.
+ */
+function updateMinSin(profile) {
+    for (let i = 0; i < profile.segments.length; i++) {
+        const segmentA = profile.segments[i];
+        const segmentB = profile.segments[(i + 1) % profile.segments.length];
+        // Quadratic Bézier segments will always join smoothly with the previous
+        // segment. This means that we can skip the segment since it's impossible
+        // to have a miter join between the two segments.
+        if (!isCubicSegment(segmentA) || !isCubicSegment(segmentB)) {
+            continue;
+        }
+        const startVector = segmentA.p2.sub(segmentA.p3).normalized.safe;
+        const endVector = segmentB.p1.sub(segmentB.p0).normalized.safe;
+        const dot = startVector.dot(endVector);
+        // A miter join can only occur if the handle is broken, so we can skip the
+        // segment if the handles are mirrored.
+        const isBroken = 1 - Math.abs(dot) > 0.0001;
+        if (!isBroken) {
+            continue;
+        }
+        const angleBetween = Math.acos(clamp(-1, 1, dot));
+        const angleSin = Math.sin(angleBetween / 2);
+        profile.minSin = Math.min(profile.minSin, Math.abs(angleSin));
+    }
+}
+function addSegmentToProfile(profile, p0, p1, p2, p3) {
+    const segment = p3 !== undefined
+        ? new CubicBezierSegment(p0, p1, p2, p3)
+        : new QuadBezierSegment(p0, p1, p2);
+    profile.segments.push(segment);
+    profile.arcLength += segment.arcLength;
+}
+/**
+ * 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 function getBezierSplineProfile(knots, closed, smoothness) {
+    const profile = {
+        segments: [],
+        arcLength: 0,
+        minSin: 1,
+    };
+    // First, we want to calculate the actual handle positions for each knot. We
+    // do so using the knot's `auto` value to blend between the user-provided
+    // handles and the auto calculated smooth handles.
+    const numberOfKnots = knots.length;
+    for (let i = 0; i < numberOfKnots; i++) {
+        // Calculating the auto handles for a given knot requires both of the knot's
+        // neighboring knots. To make sure that this works properly for the first
+        // and last knots of the spline, we want to make sure to wrap around to the
+        // beginning and end of the array, respectively.
+        const prevIndex = (i - 1 + numberOfKnots) % numberOfKnots;
+        const nextIndex = (i + 1) % numberOfKnots;
+        calculateSmoothHandles(knots[i], knots[prevIndex], knots[nextIndex], smoothness);
+    }
+    const firstKnot = knots[0];
+    const secondKnot = knots[1];
+    // Drawing the first and last segments of a spline has a few edge cases we
+    // need to consider:
+    // If the spline is not closed and the first knot should use the auto
+    // calculated handles, we want to draw a quadratic Bézier curve instead of a
+    // cubic one.
+    if (!closed && firstKnot.auto.start === 1 && firstKnot.auto.end === 1) {
+        addSegmentToProfile(profile, firstKnot.position, secondKnot.startHandle, secondKnot.position);
+    }
+    else {
+        // Otherwise, draw a cubic Bézier segment like we do for the other segments.
+        addSegmentToProfile(profile, firstKnot.position, firstKnot.endHandle, secondKnot.startHandle, secondKnot.position);
+    }
+    // Add all intermediate spline segments as cubic Bézier curve segments.
+    for (let i = 1; i < numberOfKnots - 2; i++) {
+        const start = knots[i];
+        const end = knots[i + 1];
+        addSegmentToProfile(profile, start.position, start.endHandle, end.startHandle, end.position);
+    }
+    const lastKnot = knots.at(-1);
+    const secondToLastKnot = knots.at(-2);
+    if (knots.length > 2) {
+        // Similar to the first segment, we also want to draw the last segment as a
+        // quadratic Bézier curve if the curve is not closed and the knot should
+        // use the auto calculated handles.
+        if (!closed && lastKnot.auto.start === 1 && lastKnot.auto.end === 1) {
+            addSegmentToProfile(profile, secondToLastKnot.position, secondToLastKnot.endHandle, lastKnot.position);
+        }
+        else {
+            addSegmentToProfile(profile, secondToLastKnot.position, secondToLastKnot.endHandle, lastKnot.startHandle, lastKnot.position);
+        }
+    }
+    // If the spline should be closed, add one final cubic Bézier segment
+    // connecting the last and first knots.
+    if (closed) {
+        addSegmentToProfile(profile, lastKnot.position, lastKnot.endHandle, firstKnot.startHandle, firstKnot.position);
+    }
+    updateMinSin(profile);
+    return profile;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/curves/getCircleProfile.d.ts

@@ -0,0 +1,4 @@
+import { Vector2 } from '@twick/core';
+import type { CurveProfile } from './CurveProfile';
+export declare function getCircleProfile(size: Vector2, startAngle: number, endAngle: number, closed: boolean, counterclockwise?: boolean): CurveProfile;
+//# sourceMappingURL=getCircleProfile.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getCircleProfile.d.ts","sourceRoot":"","sources":["../../src/lib/curves/getCircleProfile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAAC,MAAM,aAAa,CAAC;AAEpC,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAIjD,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,OAAO,EACb,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,OAAO,EACf,gBAAgB,UAAQ,GACvB,YAAY,CAkDd"}