@metamesh/modeling 0.0.0-stage → 0.6.0

package/dist/geometry/svg/path.js

@@ -0,0 +1,349 @@
+import { SVGPathData, SVGPathDataTransformer } from "svg-pathdata";
+import { resolveArcSegments, resolveGeometryResolution, } from "../resolution.js";
+import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../sampling-limits.js";
+import { complexity, invalid, rethrowAsInvalid } from "./errors.js";
+import { transformPoint } from "./matrix.js";
+export const MAX_CURVE_RECURSION = 16;
+export class SvgVertexBudget {
+    limits;
+    #emittedCount = 0;
+    #parsedCount = 0;
+    #removedDuplicateCount = 0;
+    #removedSeamCount = 0;
+    constructor(limits = {}) {
+        this.limits = resolveGeometrySamplingLimits(limits);
+    }
+    get count() {
+        return this.#emittedCount;
+    }
+    get emittedCount() {
+        return this.#emittedCount;
+    }
+    get parsedCount() {
+        return this.#parsedCount;
+    }
+    get removedDuplicateCount() {
+        return this.#removedDuplicateCount;
+    }
+    get removedSeamCount() {
+        return this.#removedSeamCount;
+    }
+    add(operation) {
+        this.#emittedCount += 1;
+        assertSamplingCount(this.#emittedCount, operation, this.limits.maxProfilePoints);
+    }
+    addParsed(count, operation) {
+        this.#parsedCount += count;
+        assertSamplingCount(this.#parsedCount, operation, this.limits.maxProfilePoints, `SVG input requires ${this.#parsedCount} parsed vertices; the configured ceiling allows ${this.limits.maxProfilePoints}.`);
+    }
+    removeDuplicate() {
+        this.#removedDuplicateCount += 1;
+    }
+    removeSeam() {
+        this.#removedSeamCount += 1;
+    }
+}
+function squaredDistance(left, right) {
+    const dx = left[0] - right[0];
+    const dy = left[1] - right[1];
+    return dx * dx + dy * dy;
+}
+function pointSegmentDistance(point, start, end) {
+    const dx = end[0] - start[0];
+    const dy = end[1] - start[1];
+    const denominator = dx * dx + dy * dy;
+    if (denominator === 0)
+        return Math.sqrt(squaredDistance(point, start));
+    const projection = Math.max(0, Math.min(1, ((point[0] - start[0]) * dx + (point[1] - start[1]) * dy) / denominator));
+    return Math.hypot(point[0] - (start[0] + projection * dx), point[1] - (start[1] + projection * dy));
+}
+function midpoint(left, right) {
+    return [(left[0] + right[0]) / 2, (left[1] + right[1]) / 2];
+}
+function pushUnique(output, point, budget, operation) {
+    const previous = output.at(-1);
+    if (previous !== undefined && squaredDistance(previous, point) <= 1e-24) {
+        budget.removeDuplicate();
+        return;
+    }
+    if (!Number.isFinite(point[0]) || !Number.isFinite(point[1])) {
+        invalid(operation, "SVG geometry produced a non-finite vertex.");
+    }
+    budget.add(operation);
+    output.push(point);
+}
+function flattenQuadratic(start, control, end, resolution, depth, output, budget, operation) {
+    if (pointSegmentDistance(control, start, end) <= resolution.maxChordError &&
+        (resolution.maxSegmentLength === undefined ||
+            Math.sqrt(squaredDistance(start, end)) <= resolution.maxSegmentLength)) {
+        pushUnique(output, end, budget, operation);
+        return;
+    }
+    if (depth >= MAX_CURVE_RECURSION) {
+        complexity(operation, `Curve flattening exceeds ${MAX_CURVE_RECURSION} subdivisions.`, {
+            maxRecursion: MAX_CURVE_RECURSION,
+        });
+    }
+    const startControl = midpoint(start, control);
+    const controlEnd = midpoint(control, end);
+    const split = midpoint(startControl, controlEnd);
+    flattenQuadratic(start, startControl, split, resolution, depth + 1, output, budget, operation);
+    flattenQuadratic(split, controlEnd, end, resolution, depth + 1, output, budget, operation);
+}
+function flattenCubic(start, first, second, end, resolution, depth, output, budget, operation) {
+    if (Math.max(pointSegmentDistance(first, start, end), pointSegmentDistance(second, start, end)) <=
+        resolution.maxChordError &&
+        (resolution.maxSegmentLength === undefined ||
+            Math.sqrt(squaredDistance(start, end)) <= resolution.maxSegmentLength)) {
+        pushUnique(output, end, budget, operation);
+        return;
+    }
+    if (depth >= MAX_CURVE_RECURSION) {
+        complexity(operation, `Curve flattening exceeds ${MAX_CURVE_RECURSION} subdivisions.`, {
+            maxRecursion: MAX_CURVE_RECURSION,
+        });
+    }
+    const ab = midpoint(start, first);
+    const bc = midpoint(first, second);
+    const cd = midpoint(second, end);
+    const abc = midpoint(ab, bc);
+    const bcd = midpoint(bc, cd);
+    const split = midpoint(abc, bcd);
+    flattenCubic(start, ab, abc, split, resolution, depth + 1, output, budget, operation);
+    flattenCubic(split, bcd, cd, end, resolution, depth + 1, output, budget, operation);
+}
+function endpointArcToCenter(start, end, radiusX, radiusY, rotationDegrees, largeArc, sweep) {
+    let rx = Math.abs(radiusX);
+    let ry = Math.abs(radiusY);
+    if (rx === 0 || ry === 0 || squaredDistance(start, end) <= 1e-24)
+        return null;
+    const phi = ((rotationDegrees % 360) * Math.PI) / 180;
+    const cosPhi = Math.cos(phi);
+    const sinPhi = Math.sin(phi);
+    const halfDx = (start[0] - end[0]) / 2;
+    const halfDy = (start[1] - end[1]) / 2;
+    const xPrime = cosPhi * halfDx + sinPhi * halfDy;
+    const yPrime = -sinPhi * halfDx + cosPhi * halfDy;
+    const lambda = (xPrime * xPrime) / (rx * rx) + (yPrime * yPrime) / (ry * ry);
+    if (lambda > 1) {
+        const scale = Math.sqrt(lambda);
+        rx *= scale;
+        ry *= scale;
+    }
+    const rxSquared = rx * rx;
+    const rySquared = ry * ry;
+    const numerator = Math.max(0, rxSquared * rySquared - rxSquared * yPrime * yPrime - rySquared * xPrime * xPrime);
+    const denominator = rxSquared * yPrime * yPrime + rySquared * xPrime * xPrime;
+    const sign = largeArc === sweep ? -1 : 1;
+    const coefficient = denominator === 0 ? 0 : sign * Math.sqrt(numerator / denominator);
+    const centerPrimeX = (coefficient * rx * yPrime) / ry;
+    const centerPrimeY = (-coefficient * ry * xPrime) / rx;
+    const center = [
+        cosPhi * centerPrimeX - sinPhi * centerPrimeY + (start[0] + end[0]) / 2,
+        sinPhi * centerPrimeX + cosPhi * centerPrimeY + (start[1] + end[1]) / 2,
+    ];
+    const vectorAngle = (ux, uy, vx, vy) => Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy);
+    const ux = (xPrime - centerPrimeX) / rx;
+    const uy = (yPrime - centerPrimeY) / ry;
+    const vx = (-xPrime - centerPrimeX) / rx;
+    const vy = (-yPrime - centerPrimeY) / ry;
+    const startAngle = Math.atan2(uy, ux);
+    let delta = vectorAngle(ux, uy, vx, vy);
+    if (!sweep && delta > 0)
+        delta -= Math.PI * 2;
+    if (sweep && delta < 0)
+        delta += Math.PI * 2;
+    return { center, delta, phi, radii: [rx, ry], startAngle };
+}
+function arcPoint(arc, angle) {
+    const cosPhi = Math.cos(arc.phi);
+    const sinPhi = Math.sin(arc.phi);
+    const x = arc.radii[0] * Math.cos(angle);
+    const y = arc.radii[1] * Math.sin(angle);
+    return [arc.center[0] + cosPhi * x - sinPhi * y, arc.center[1] + sinPhi * x + cosPhi * y];
+}
+function arcSecondDerivativeBound(arc, matrix) {
+    const cosPhi = Math.cos(arc.phi);
+    const sinPhi = Math.sin(arc.phi);
+    const basisX = [cosPhi * arc.radii[0], sinPhi * arc.radii[0]];
+    const basisY = [-sinPhi * arc.radii[1], cosPhi * arc.radii[1]];
+    const transformVector = (vector) => [
+        matrix[0] * vector[0] + matrix[2] * vector[1],
+        matrix[1] * vector[0] + matrix[3] * vector[1],
+    ];
+    const transformedX = transformVector(basisX);
+    const transformedY = transformVector(basisY);
+    return Math.hypot(...transformedX) + Math.hypot(...transformedY);
+}
+function flattenArcRange(arc, matrix, from, to, end, resolution, output, budget, operation) {
+    // The transformed second-derivative norm is a conservative effective radius for eccentric
+    // ellipses under arbitrary affine transforms. Circular exact counts and both physical criteria
+    // therefore apply in final millimetre space.
+    const effectiveRadius = arcSecondDerivativeBound(arc, matrix);
+    const segments = resolveArcSegments(effectiveRadius, ((to - from) * 180) / Math.PI, resolution, budget.limits);
+    assertSamplingCount(segments, operation, budget.limits.maxProfilePoints);
+    for (let index = 1; index <= segments; index += 1) {
+        const point = index === segments
+            ? end
+            : transformPoint(matrix, arcPoint(arc, from + ((to - from) * index) / segments));
+        pushUnique(output, point, budget, operation);
+    }
+}
+function hasNonCollinearVertices(contour) {
+    const first = contour[0];
+    if (first === undefined)
+        return false;
+    const second = contour.find((point) => squaredDistance(first, point) > 1e-24);
+    if (second === undefined)
+        return false;
+    const dx = second[0] - first[0];
+    const dy = second[1] - first[1];
+    return contour.some((point) => Math.abs(dx * (point[1] - first[1]) - dy * (point[0] - first[0])) > 1e-12);
+}
+function finalizeSubpath(contour, output, closed, budget) {
+    if (closed && contour.length > 1 && squaredDistance(contour[0], contour.at(-1)) <= 1e-24) {
+        contour.pop();
+        budget.removeSeam();
+    }
+    if (contour.length >= 2)
+        output.push({ closed, points: contour });
+}
+function commandPoint(command) {
+    return [command.x, command.y];
+}
+/** Flattens complete SVG path data into transformed, non-seam-duplicated subpaths. */
+export function flattenSvgSubpaths(pathData, matrix, policy, budget, operation = "svgPath") {
+    const resolution = resolveGeometryResolution(policy, budget.limits);
+    let commands;
+    try {
+        const path = new SVGPathData(pathData).toAbs();
+        // Count source controls before shorthand expansion adds implicit S/T control points.
+        for (const command of path.commands) {
+            switch (command.type) {
+                case SVGPathData.CURVE_TO:
+                    budget.addParsed(3, operation);
+                    break;
+                case SVGPathData.SMOOTH_CURVE_TO:
+                case SVGPathData.QUAD_TO:
+                    budget.addParsed(2, operation);
+                    break;
+                case SVGPathData.CLOSE_PATH:
+                    break;
+                default:
+                    budget.addParsed(1, operation);
+            }
+        }
+        // Preserve explicit closure and Bézier sampling; only expand shorthand commands.
+        commands = path
+            .transform(SVGPathDataTransformer.NORMALIZE_HVZ(false, true, true, false))
+            .normalizeST().commands;
+    }
+    catch (error) {
+        rethrowAsInvalid(operation, error);
+    }
+    const subpaths = [];
+    let contour = [];
+    let current = [0, 0];
+    let start = [0, 0];
+    const startContour = (point) => {
+        finalizeSubpath(contour, subpaths, false, budget);
+        contour = [];
+        current = point;
+        start = point;
+        pushUnique(contour, transformPoint(matrix, point), budget, operation);
+    };
+    const lineTo = (point) => {
+        const transformedStart = transformPoint(matrix, current);
+        const transformedEnd = transformPoint(matrix, point);
+        if (![...transformedStart, ...transformedEnd].every(Number.isFinite))
+            invalid(operation, "SVG geometry produced a non-finite vertex.");
+        const segments = resolution.maxSegmentLength === undefined
+            ? 1
+            : Math.max(1, Math.ceil(Math.sqrt(squaredDistance(transformedStart, transformedEnd)) /
+                resolution.maxSegmentLength));
+        assertSamplingCount(segments, operation, budget.limits.maxProfilePoints);
+        for (let index = 1; index <= segments; index += 1) {
+            pushUnique(contour, index === segments
+                ? transformedEnd
+                : [
+                    transformedStart[0] + ((transformedEnd[0] - transformedStart[0]) * index) / segments,
+                    transformedStart[1] + ((transformedEnd[1] - transformedStart[1]) * index) / segments,
+                ], budget, operation);
+        }
+        current = point;
+    };
+    for (const command of commands) {
+        if (contour.length === 0 &&
+            command.type !== SVGPathData.MOVE_TO &&
+            command.type !== SVGPathData.CLOSE_PATH) {
+            pushUnique(contour, transformPoint(matrix, current), budget, operation);
+            start = current;
+        }
+        switch (command.type) {
+            case SVGPathData.MOVE_TO:
+                startContour(commandPoint(command));
+                break;
+            case SVGPathData.LINE_TO:
+                lineTo(commandPoint(command));
+                break;
+            case SVGPathData.CURVE_TO: {
+                const first = [command.x1, command.y1];
+                const second = [command.x2, command.y2];
+                const end = commandPoint(command);
+                flattenCubic(transformPoint(matrix, current), transformPoint(matrix, first), transformPoint(matrix, second), transformPoint(matrix, end), resolution, 0, contour, budget, operation);
+                current = end;
+                break;
+            }
+            case SVGPathData.QUAD_TO: {
+                const control = [command.x1, command.y1];
+                const end = commandPoint(command);
+                flattenQuadratic(transformPoint(matrix, current), transformPoint(matrix, control), transformPoint(matrix, end), resolution, 0, contour, budget, operation);
+                current = end;
+                break;
+            }
+            case SVGPathData.ARC: {
+                const end = commandPoint(command);
+                const arc = endpointArcToCenter(current, end, command.rX, command.rY, command.xRot, command.lArcFlag === 1, command.sweepFlag === 1);
+                if (arc === null) {
+                    lineTo(end);
+                }
+                else {
+                    flattenArcRange(arc, matrix, arc.startAngle, arc.startAngle + arc.delta, transformPoint(matrix, end), resolution, contour, budget, operation);
+                    current = end;
+                }
+                break;
+            }
+            case SVGPathData.CLOSE_PATH: {
+                if (resolution.maxSegmentLength !== undefined && squaredDistance(current, start) > 1e-24) {
+                    const transformedCurrent = transformPoint(matrix, current);
+                    const transformedStart = transformPoint(matrix, start);
+                    const segments = Math.max(1, Math.ceil(Math.sqrt(squaredDistance(transformedCurrent, transformedStart)) /
+                        resolution.maxSegmentLength));
+                    assertSamplingCount(segments, operation, budget.limits.maxProfilePoints);
+                    for (let index = 1; index < segments; index += 1) {
+                        pushUnique(contour, [
+                            transformedCurrent[0] +
+                                ((transformedStart[0] - transformedCurrent[0]) * index) / segments,
+                            transformedCurrent[1] +
+                                ((transformedStart[1] - transformedCurrent[1]) * index) / segments,
+                        ], budget, operation);
+                    }
+                }
+                current = start;
+                finalizeSubpath(contour, subpaths, true, budget);
+                contour = [];
+                break;
+            }
+            default:
+                invalid(operation, "Unsupported normalized SVG path command.");
+        }
+    }
+    finalizeSubpath(contour, subpaths, false, budget);
+    return subpaths;
+}
+/** Flattens a complete SVG path-data grammar into non-seam-duplicated filled contours. */
+export function flattenSvgPath(pathData, matrix, policy, budget, operation = "svgPath") {
+    return flattenSvgSubpaths(pathData, matrix, policy, budget, operation)
+        .map((subpath) => [...subpath.points])
+        .filter((contour) => contour.length >= 3 && hasNonCollinearVertices(contour));
+}

package/dist/geometry/svg/types.js

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