@metamesh/modeling 0.0.0-stage → 0.7.0

package/dist/geometry/svg/fill.js

@@ -0,0 +1,172 @@
+import { polygonClipping, unionPolygonGeometry, xorPolygonGeometry } from "../polygon-clipping.js";
+import { normalizeRegion2, signedAreaLoop2 } from "../regions.js";
+import { assertSamplingCount } from "../sampling-limits.js";
+/** Private clipping stage with the selected execution's immutable allocation ceiling. */
+export function createBoundedSvgClipping(maximumVertices) {
+    function ring(points) {
+        const result = points.map(([x, y]) => [x, y]);
+        const first = result[0];
+        const last = result.at(-1);
+        if (first !== undefined && last !== undefined && (first[0] !== last[0] || first[1] !== last[1]))
+            result.push([...first]);
+        return result;
+    }
+    function ringVertexCount(value) {
+        const first = value[0];
+        const last = value.at(-1);
+        const repeatedSeam = first !== undefined && last !== undefined && first[0] === last[0] && first[1] === last[1];
+        return value.length - (repeatedSeam ? 1 : 0);
+    }
+    function multiPolygonVertexCount(value) {
+        return value.reduce((total, polygon) => total + polygon.reduce((polygonTotal, path) => polygonTotal + ringVertexCount(path), 0), 0);
+    }
+    function assertExpandedVertexCount(vertices, stage) {
+        assertSamplingCount(vertices, "preflightSvgRegion", maximumVertices, `SVG ${stage} exceeds ${maximumVertices} expanded vertices (requires ${vertices}).`);
+    }
+    function boundedMultiPolygon(value, stage) {
+        assertExpandedVertexCount(multiPolygonVertexCount(value), stage);
+        return value;
+    }
+    function boundedUnion(values, stage) {
+        const nonEmpty = values.filter((value) => value.length > 0);
+        assertExpandedVertexCount(nonEmpty.reduce((total, value) => total + multiPolygonVertexCount(value), 0), `${stage} input`);
+        return boundedMultiPolygon(unionPolygonGeometry(nonEmpty), stage);
+    }
+    function boundedXor(values, stage) {
+        const nonEmpty = values.filter((value) => value.length > 0);
+        assertExpandedVertexCount(nonEmpty.reduce((total, value) => total + multiPolygonVertexCount(value), 0), `${stage} input`);
+        return boundedMultiPolygon(xorPolygonGeometry(nonEmpty), stage);
+    }
+    function unionAll(polygons) {
+        return boundedUnion(polygons, "union output");
+    }
+    function intersectGeometry(left, right) {
+        if (left.length === 0 || right.length === 0)
+            return [];
+        assertExpandedVertexCount(multiPolygonVertexCount(left) + multiPolygonVertexCount(right), "intersection input");
+        return boundedMultiPolygon(polygonClipping.intersection(left, right), "intersection output");
+    }
+    function multiPolygonArea(value) {
+        return value.reduce((total, polygon) => {
+            const [outer, ...holes] = polygon;
+            if (outer === undefined)
+                return total;
+            return (total +
+                Math.abs(signedAreaLoop2(outer)) -
+                holes.reduce((holeTotal, hole) => holeTotal + Math.abs(signedAreaLoop2(hole)), 0));
+        }, 0);
+    }
+    function coverageHasMultiplicity(rings, union) {
+        const summedArea = rings.reduce((total, points) => total + Math.abs(signedAreaLoop2(points)), 0);
+        const tolerance = Math.max(1, summedArea) * 1e-9;
+        return Math.abs(summedArea - multiPolygonArea(union)) > tolerance;
+    }
+    function addCoverageBits(left, right) {
+        const output = [];
+        let carry = [];
+        const inputBits = Math.max(left.length, right.length);
+        for (let index = 0; index < inputBits || carry.length > 0; index += 1) {
+            const inputs = [left[index] ?? [], right[index] ?? [], carry].filter((geometry) => geometry.length > 0);
+            if (inputs.length === 0) {
+                output.push([]);
+                carry = [];
+            }
+            else if (inputs.length === 1) {
+                output.push(inputs[0]);
+                carry = [];
+            }
+            else if (inputs.length === 2) {
+                output.push(boundedXor(inputs, "nonzero coverage XOR"));
+                carry = intersectGeometry(inputs[0], inputs[1]);
+            }
+            else {
+                output.push(boundedXor(inputs, "nonzero coverage XOR"));
+                carry = boundedUnion([
+                    intersectGeometry(inputs[0], inputs[1]),
+                    intersectGeometry(inputs[0], inputs[2]),
+                    intersectGeometry(inputs[1], inputs[2]),
+                ], "nonzero coverage carry");
+            }
+        }
+        return output;
+    }
+    function coverageBits(polygons) {
+        let level = polygons.map((polygon) => [
+            boundedUnion([[polygon]], "nonzero coverage seed"),
+        ]);
+        while (level.length > 1) {
+            const next = [];
+            for (let index = 0; index < level.length; index += 2) {
+                const left = level[index];
+                const right = level[index + 1];
+                next.push(right === undefined ? left : addCoverageBits(left, right));
+            }
+            level = next;
+        }
+        return level[0] ?? [];
+    }
+    function differingCoverage(positive, negative) {
+        const positiveUnion = boundedUnion([positive.slice()], "positive winding union");
+        const negativeUnion = boundedUnion([negative.slice()], "negative winding union");
+        if (intersectGeometry(positiveUnion, negativeUnion).length === 0) {
+            return boundedUnion([positiveUnion, negativeUnion], "disconnected winding union");
+        }
+        const positiveBits = coverageHasMultiplicity(positive.map((polygon) => polygon[0] ?? []), positiveUnion)
+            ? coverageBits(positive)
+            : [positiveUnion];
+        const negativeBits = coverageHasMultiplicity(negative.map((polygon) => polygon[0] ?? []), negativeUnion)
+            ? coverageBits(negative)
+            : [negativeUnion];
+        const differingBits = [];
+        for (let index = 0; index < Math.max(positiveBits.length, negativeBits.length); index += 1) {
+            const positiveBit = positiveBits[index] ?? [];
+            const negativeBit = negativeBits[index] ?? [];
+            if (positiveBit.length === 0)
+                differingBits.push(negativeBit);
+            else if (negativeBit.length === 0)
+                differingBits.push(positiveBit);
+            else
+                differingBits.push(boundedXor([positiveBit, negativeBit], "winding difference XOR"));
+        }
+        return boundedUnion(differingBits, "winding difference union");
+    }
+    function fillGeometry(subpaths, fillRule) {
+        const rings = subpaths
+            .filter((subpath) => subpath.points.length >= 3)
+            .map((subpath) => subpath.points);
+        if (rings.length === 0)
+            return [];
+        const polygons = rings.map((points) => [ring(points)]);
+        if (fillRule === "evenodd") {
+            return boundedXor(polygons.map((polygon) => [polygon]), "even-odd fill output");
+        }
+        const positive = rings
+            .filter((points) => signedAreaLoop2(points) >= 0)
+            .map((points) => [ring(points)]);
+        const negative = rings
+            .filter((points) => signedAreaLoop2(points) < 0)
+            .map((points) => [ring(points)]);
+        if (positive.length === 0)
+            return boundedUnion([negative], "negative fill output");
+        if (negative.length === 0)
+            return boundedUnion([positive], "positive fill output");
+        // Compare the binary coverage counts instead of choosing one global exterior winding. This
+        // preserves disconnected opposite-winding components and nested islands while still cancelling
+        // precisely where positive and negative nonzero winding counts match.
+        return differingCoverage(positive, negative);
+    }
+    function regionFromMultiPolygon(value) {
+        return normalizeRegion2(value.map((polygon) => ({
+            outer: polygon[0].slice(0, -1).map(([x, y]) => [x, y]),
+            holes: polygon.slice(1).map((hole) => hole.slice(0, -1).map(([x, y]) => [x, y])),
+        })));
+    }
+    return {
+        assertExpandedVertexCount,
+        boundedMultiPolygon,
+        fillGeometry,
+        multiPolygonVertexCount,
+        regionFromMultiPolygon,
+        unionAll,
+    };
+}

package/dist/geometry/svg/index.js

@@ -0,0 +1 @@
+export { parseSvgDocument, parseSvgPath } from "./parser.js";

package/dist/geometry/svg/matrix.js

@@ -0,0 +1,130 @@
+import { invalid } from "./errors.js";
+export const IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];
+export function multiplyMatrices(left, right) {
+    return [
+        left[0] * right[0] + left[2] * right[1],
+        left[1] * right[0] + left[3] * right[1],
+        left[0] * right[2] + left[2] * right[3],
+        left[1] * right[2] + left[3] * right[3],
+        left[0] * right[4] + left[2] * right[5] + left[4],
+        left[1] * right[4] + left[3] * right[5] + left[5],
+    ];
+}
+export function transformPoint(matrix, point) {
+    return [
+        matrix[0] * point[0] + matrix[2] * point[1] + matrix[4],
+        matrix[1] * point[0] + matrix[3] * point[1] + matrix[5],
+    ];
+}
+const NUMBER_PATTERN = /[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?/g;
+/** Parses compact SVG number sequences while rejecting unconsumed syntax. */
+export function parseNumberSequence(value, operation) {
+    const numbers = [];
+    let end = 0;
+    NUMBER_PATTERN.lastIndex = 0;
+    for (let match = NUMBER_PATTERN.exec(value); match !== null; match = NUMBER_PATTERN.exec(value)) {
+        const separator = value.slice(end, match.index);
+        if (!/^[\s,]*$/.test(separator) ||
+            (separator.match(/,/g)?.length ?? 0) > 1 ||
+            (numbers.length === 0 && separator.includes(","))) {
+            invalid(operation, `Invalid numeric syntax near "${separator}".`);
+        }
+        const parsed = Number(match[0]);
+        if (!Number.isFinite(parsed)) {
+            invalid(operation, "SVG numeric values must be finite.");
+        }
+        numbers.push(parsed);
+        end = match.index + match[0].length;
+    }
+    if (!/^\s*$/.test(value.slice(end))) {
+        invalid(operation, "Invalid trailing numeric syntax.");
+    }
+    if (numbers.length === 0 && value.trim() !== "") {
+        invalid(operation, `Expected a numeric value, received "${value}".`);
+    }
+    return numbers;
+}
+function transformFor(name, values, operation) {
+    switch (name) {
+        case "matrix":
+            if (values.length !== 6)
+                invalid(operation, "matrix() requires six numbers.");
+            return values;
+        case "translate":
+            if (values.length < 1 || values.length > 2) {
+                invalid(operation, "translate() requires one or two numbers.");
+            }
+            return [1, 0, 0, 1, values[0] ?? 0, values[1] ?? 0];
+        case "scale": {
+            if (values.length < 1 || values.length > 2) {
+                invalid(operation, "scale() requires one or two numbers.");
+            }
+            const sx = values[0] ?? 1;
+            return [sx, 0, 0, values[1] ?? sx, 0, 0];
+        }
+        case "rotate": {
+            if (values.length !== 1 && values.length !== 3) {
+                invalid(operation, "rotate() requires an angle, optionally followed by a center.");
+            }
+            const radians = ((values[0] ?? 0) * Math.PI) / 180;
+            const rotation = [
+                Math.cos(radians),
+                Math.sin(radians),
+                -Math.sin(radians),
+                Math.cos(radians),
+                0,
+                0,
+            ];
+            if (values.length === 1)
+                return rotation;
+            const cx = values[1] ?? 0;
+            const cy = values[2] ?? 0;
+            return multiplyMatrices(multiplyMatrices([1, 0, 0, 1, cx, cy], rotation), [
+                1,
+                0,
+                0,
+                1,
+                -cx,
+                -cy,
+            ]);
+        }
+        case "skewX": {
+            if (values.length !== 1)
+                invalid(operation, "skewX() requires one angle.");
+            const tangent = Math.tan(((values[0] ?? 0) * Math.PI) / 180);
+            if (!Number.isFinite(tangent))
+                invalid(operation, "skewX() produced a non-finite matrix.");
+            return [1, 0, tangent, 1, 0, 0];
+        }
+        case "skewY": {
+            if (values.length !== 1)
+                invalid(operation, "skewY() requires one angle.");
+            const tangent = Math.tan(((values[0] ?? 0) * Math.PI) / 180);
+            if (!Number.isFinite(tangent))
+                invalid(operation, "skewY() produced a non-finite matrix.");
+            return [1, tangent, 0, 1, 0, 0];
+        }
+        default:
+            invalid(operation, `Unsupported SVG transform "${name}".`);
+    }
+}
+/** Parses an SVG transform list using standard post-multiplication order. */
+export function parseTransform(value, operation) {
+    if (value === undefined || value.trim() === "")
+        return IDENTITY_MATRIX;
+    const callPattern = /([A-Za-z]+)\s*\(([^()]*)\)/g;
+    let result = IDENTITY_MATRIX;
+    let end = 0;
+    for (let match = callPattern.exec(value); match !== null; match = callPattern.exec(value)) {
+        if (!/^[\s,]*$/.test(value.slice(end, match.index))) {
+            invalid(operation, "Malformed SVG transform list.");
+        }
+        const values = parseNumberSequence(match[2] ?? "", operation);
+        result = multiplyMatrices(result, transformFor(match[1] ?? "", values, operation));
+        end = match.index + match[0].length;
+    }
+    if (end === 0 || !/^\s*$/.test(value.slice(end))) {
+        invalid(operation, "Malformed SVG transform list.");
+    }
+    return result;
+}