@metamesh/modeling 0.0.0-stage → 0.7.0

package/dist/engine/primitive-correspondence.js

@@ -0,0 +1,74 @@
+import { GeometryError } from "../geometry/errors.js";
+import { matchProfiles, } from "../geometry/profiles/matched.js";
+import { createProfileSpanSampler } from "../geometry/profiles/span-sampling.js";
+import { assertSamplingCount } from "../geometry/sampling-limits.js";
+/** Primitive exact counts describe physical facets; identified user Profile counts describe analytic grids. */
+export function samplePrimitiveFamily(sources, profiles, resolution, limits) {
+    const matched = matchProfiles(profiles, { resolution, limits });
+    const first = profiles[0].components[0].outer;
+    const baseline = new Map();
+    for (const id of matched[0].components[0].outer.spans)
+        baseline.set(id, (baseline.get(id) ?? 0) + 1);
+    const needsFacets = sources.some((source, index) => source.profile.components[0].outer.spans.some((span, slot) => span.kind !== "line" &&
+        (span.segments !== undefined ||
+            (span.kind === "arc" && resolution.circularSegments !== undefined)) &&
+        profiles[index].components[0].outer.spans[slot].segments !== baseline.get(span.id)));
+    if (!needsFacets)
+        return matched;
+    let count = 0;
+    const grids = first.spans.map((span, slot) => {
+        const common = baseline.get(span.id);
+        const knots = new Set(Array.from({ length: common }, (_, i) => i / common));
+        const facets = sources.map((source, index) => {
+            const original = source.profile.components[0].outer.spans[slot];
+            const exact = original.segments !== undefined ||
+                (original.kind === "arc" && resolution.circularSegments !== undefined);
+            const intervals = profiles[index].components[0].outer.spans[slot].segments;
+            if (exact)
+                for (let i = 0; i < intervals; i++)
+                    knots.add(i / intervals);
+            return exact ? intervals : undefined;
+        });
+        const parameters = [...knots].sort((a, b) => a - b);
+        count += parameters.length;
+        assertSamplingCount(count, "loft", limits.maxProfilePoints);
+        assertSamplingCount(count * sources.length, "loft", 1_000_000);
+        return { parameters, facets };
+    });
+    return profiles.map((profile, index) => {
+        const contour = profile.components[0].outer;
+        const points = [], spans = [];
+        contour.spans.forEach((span, slot) => {
+            const sample = createProfileSpanSampler(span);
+            const plan = grids[slot];
+            const intervals = plan.facets[index];
+            const vertices = intervals === undefined
+                ? undefined
+                : Array.from({ length: intervals + 1 }, (_, i) => sample(i / intervals));
+            for (const parameter of plan.parameters) {
+                if (vertices === undefined)
+                    points.push(sample(parameter));
+                else {
+                    const at = parameter * intervals;
+                    const nearest = Math.round(at);
+                    if (Math.abs(at - nearest) <= Number.EPSILON * 8 * Math.max(1, intervals)) {
+                        points.push(vertices[nearest]);
+                        spans.push(span.id);
+                        continue;
+                    }
+                    const start = Math.min(Math.floor(at), intervals - 1);
+                    const a = vertices[start], b = vertices[start + 1], amount = at - start;
+                    points.push(amount === 0 ? a : [a[0] + (b[0] - a[0]) * amount, a[1] + (b[1] - a[1]) * amount]);
+                }
+                spans.push(span.id);
+            }
+        });
+        if (points.length !== count)
+            throw new GeometryError("INVALID_TOPOLOGY", "Primitive sampling grid must retain every shared knot.", { operation: "loft" });
+        return {
+            components: [
+                { id: profile.components[0].id, holes: [], outer: { id: contour.id, points, spans } },
+            ],
+        };
+    });
+}

package/dist/engine/primitive-operations.js

@@ -0,0 +1,151 @@
+import { resolveCylinderRadii } from "../geometry/cylinder.js";
+import { resolveModelingLimits } from "../geometry/model-limits.js";
+import { assertPrimitiveOptions } from "../geometry/primitive-resolvers.js";
+import { regularPolygonLoop, starLoop } from "../geometry/profiles/profiles.js";
+import { rectangleLoop, resolveRectangle, } from "../geometry/profiles/rectangle.js";
+import { ellipseLoop } from "../geometry/profiles/shapes.js";
+import { requireProfileVertexCount } from "../geometry/profiles/validation.js";
+import * as kernel from "./native/index.js";
+import { boxAnchors, cylinderAnchors, originAnchor, planarAnchors, sphereAnchors, torusAnchors, tubeAnchors, } from "./primitive-anchors.js";
+import { ellipticalSectionProfile, polygonSectionProfile, rectangleSectionProfile, } from "./primitive-profiles.js";
+/** Internal host-bound primitive operations. */
+export function createPrimitiveOperations(environment, transforms, sections) {
+    const { module, scope, assertActive, throwGeometryError, ownSection, validateFiniteNumber, requirePositiveNumber, validateCoordinates, withResolutionDefaults, resolveCircularSegments, } = environment;
+    const { placedSolid, placedSection } = transforms;
+    const fromContours = sections.sectionFromContours;
+    const operations = {
+        box: (value) => {
+            assertActive();
+            assertPrimitiveOptions(value, "box");
+            const resolved = withResolutionDefaults(value);
+            const resolveTreatment = (treatment) => {
+                assertPrimitiveOptions(treatment, "box");
+                return treatment.kind === "round" || treatment.kind === "smooth"
+                    ? withResolutionDefaults({
+                        ...treatment,
+                        limits: resolveModelingLimits(treatment.limits, resolved.limits),
+                    })
+                    : treatment;
+            };
+            if (value.treatment !== undefined)
+                assertPrimitiveOptions(value.treatment, "box");
+            const treatment = value.treatment === undefined
+                ? undefined
+                : "kind" in value.treatment
+                    ? resolveTreatment(value.treatment)
+                    : Object.fromEntries(Object.entries(value.treatment).map(([edge, treatment]) => [
+                        edge,
+                        resolveTreatment(treatment),
+                    ]));
+            return placedSolid(value, () => kernel.box(scope, treatment === undefined ? resolved : { ...resolved, treatment }), () => boxAnchors(value));
+        },
+        cylinder: (value) => {
+            assertActive();
+            assertPrimitiveOptions(value, "cylinder");
+            const resolved = withResolutionDefaults(value);
+            if (value.sizing !== undefined && value.sizing !== "vertex" && value.sizing !== "face")
+                throwGeometryError("INVALID_ARGUMENT", "cylinder", "sizing must be vertex or face.");
+            if (value.sizing !== "face")
+                return placedSolid(value, () => kernel.cylinder(scope, resolved), () => cylinderAnchors(value));
+            const radii = resolveCylinderRadii(value);
+            const count = resolveCircularSegments(Math.max(...radii), value), correction = 1 / Math.cos(Math.PI / count);
+            return placedSolid(value, () => kernel.cylinder(scope, {
+                height: resolved.height,
+                radius: [radii[0] * correction, radii[1] * correction],
+                segments: count,
+                resolution: resolved.resolution,
+                limits: resolved.limits,
+                ...(resolved.center === undefined ? {} : { center: resolved.center }),
+                ...(resolved.ends === undefined ? {} : { ends: resolved.ends }),
+            }), () => cylinderAnchors(value));
+        },
+        tube: (value) => {
+            assertActive();
+            return placedSolid(value, () => kernel.tube(scope, withResolutionDefaults(value)), () => tubeAnchors(value));
+        },
+        sphere: (value) => {
+            assertActive();
+            return placedSolid(value, () => kernel.sphere(scope, withResolutionDefaults(value)), () => sphereAnchors(value));
+        },
+        torus: (value) => {
+            assertActive();
+            return placedSolid(value, () => kernel.torus(scope, withResolutionDefaults(value)), () => torusAnchors(value));
+        },
+        rectangle: (value) => placedSection(value, () => {
+            assertActive();
+            const resolved = withResolutionDefaults(value);
+            resolveRectangle(resolved, "rectangle");
+            const treatment = value.treatment;
+            const resolvedCorner = (corner) => corner.kind === "round" || corner.kind === "smooth"
+                ? withResolutionDefaults({
+                    ...corner,
+                    limits: resolveModelingLimits(corner.limits, resolved.limits),
+                })
+                : corner;
+            const options = {
+                ...resolved,
+                ...(treatment === undefined
+                    ? {}
+                    : {
+                        treatment: Array.isArray(treatment)
+                            ? treatment.map(resolvedCorner)
+                            : resolvedCorner(treatment),
+                    }),
+            };
+            const points = rectangleLoop(options);
+            const dimensions = typeof value.size === "number" ? [value.size, value.size] : value.size;
+            const section = treatment === undefined
+                ? ownSection(module.CrossSection.square(dimensions, value.center ?? true))
+                : fromContours([points]);
+            environment.rememberAnchors(section, planarAnchors(dimensions, value.center ?? true));
+            return environment.rememberPrimitiveProfile(section, rectangleSectionProfile(options, resolved.resolution, resolved.limits));
+        }),
+        circle: (value) => placedSection(value, () => {
+            assertActive();
+            if ((value.radius === undefined) === (value.diameter === undefined))
+                throwGeometryError("INVALID_ARGUMENT", "circle", "Specify exactly one radius or diameter.");
+            const radius = value.radius ?? value.diameter / 2;
+            requirePositiveNumber(radius, "circle");
+            const count = resolveCircularSegments(radius, value);
+            requireProfileVertexCount(count, 3, "circle", withResolutionDefaults(value).limits);
+            if (value.sizing !== undefined && value.sizing !== "vertex" && value.sizing !== "face")
+                throwGeometryError("INVALID_ARGUMENT", "circle", "sizing must be vertex or face.");
+            const section = ownSection(module.CrossSection.circle(value.sizing === "face" ? radius / Math.cos(Math.PI / count) : radius, count));
+            const resolved = withResolutionDefaults(value);
+            environment.rememberAnchors(section, planarAnchors([2 * radius, 2 * radius]));
+            return environment.rememberPrimitiveProfile(section, ellipticalSectionProfile([radius, radius], value, resolved.resolution, resolved.limits, value.sizing === "face"));
+        }),
+        ellipse: (value) => placedSection(value, () => {
+            if ((value.radius === undefined) === (value.size === undefined))
+                throwGeometryError("INVALID_ARGUMENT", "ellipse", "Specify exactly one radius or size tuple.");
+            const radii = value.radius ?? [value.size[0] / 2, value.size[1] / 2];
+            validateCoordinates(radii, 2, "ellipse");
+            const resolved = withResolutionDefaults(value);
+            const section = fromContours([
+                ellipseLoop({
+                    radius: radii,
+                    segments: resolveCircularSegments(Math.max(...radii), value),
+                    limits: resolved.limits,
+                }),
+            ]);
+            environment.rememberAnchors(section, planarAnchors([2 * radii[0], 2 * radii[1]]));
+            return environment.rememberPrimitiveProfile(section, ellipticalSectionProfile(radii, value, resolved.resolution, resolved.limits));
+        }),
+        regularPolygon: (value) => placedSection(value, () => {
+            const resolved = withResolutionDefaults(value), loop = regularPolygonLoop(resolved);
+            const section = environment.rememberAnchors(fromContours([loop]), originAnchor());
+            return environment.rememberPrimitiveProfile(section, polygonSectionProfile(`polygon-${value.sides}`, loop, resolved.resolution, resolved.limits));
+        }),
+        star: (value) => placedSection(value, () => {
+            const angle = (validateFiniteNumber(value.rotationDegrees ?? 0, "star") * Math.PI) / 180;
+            const resolved = withResolutionDefaults(value);
+            const loop = starLoop(value.outerRadius, value.points, value.innerRadius, resolved.limits).map(([x, y]) => [
+                x * Math.cos(angle) - y * Math.sin(angle),
+                x * Math.sin(angle) + y * Math.cos(angle),
+            ]);
+            const section = environment.rememberAnchors(fromContours([loop]), originAnchor());
+            return environment.rememberPrimitiveProfile(section, polygonSectionProfile(`star-${value.points}`, loop, resolved.resolution, resolved.limits));
+        }),
+    };
+    return operations;
+}

package/dist/engine/primitive-profile-types.js

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

package/dist/engine/primitive-profiles.js

@@ -0,0 +1,250 @@
+import { planarCubicControl } from "../geometry/curves/evaluation.js";
+import { resolveLineSegmentCount, resolveUniformCubicSegments, } from "../geometry/curves/sampling.js";
+import { GeometryError } from "../geometry/errors.js";
+import {} from "../geometry/profiles/matched.js";
+import { rectangleProfile, resolveRectangle, } from "../geometry/profiles/rectangle.js";
+import { resolveArcSegments, resolveGeometryResolution, } from "../geometry/resolution.js";
+import { samplePrimitiveFamily } from "./primitive-correspondence.js";
+const identity = [1, 0, 0, 0, 1, 0, 0, 0, 1];
+const cornerIds = ["top-right", "top-left", "bottom-left", "bottom-right"];
+/** Captures rectangle landmarks separately from its existing native filled geometry. */
+export function rectangleSectionProfile(options, resolution, limits) {
+    const { corners, width, height, limits: rectangleLimits, } = resolveRectangle({ ...options, limits }, "rectangle");
+    const spanResolution = {};
+    corners.forEach((corner, index) => {
+        if (corner.kind === "round" || corner.kind === "smooth")
+            spanResolution[cornerIds[index]] = { ...resolution, ...corner.resolution };
+    });
+    return {
+        family: "rectangle",
+        profile: rectangleProfile(options),
+        resolution: { ...resolution },
+        spanResolution,
+        limits: rectangleLimits,
+        matrix: identity,
+        origin: options.center === false ? [width / 2, height / 2] : [0, 0],
+    };
+}
+/** Circle and ellipse share the same explicit +X seam and counterclockwise ring family. */
+export function ellipticalSectionProfile(radii, options, resolution, limits, faceSizing = false) {
+    const radius = Math.max(...radii);
+    const segments = options.segments ?? resolution.circularSegments;
+    return {
+        family: "ellipse",
+        profile: {
+            components: [
+                {
+                    id: "body",
+                    holes: [],
+                    outer: {
+                        id: "outline",
+                        spans: [
+                            {
+                                id: "ring",
+                                kind: "arc",
+                                center: [0, 0],
+                                radius,
+                                startDegrees: 0,
+                                sweepDegrees: 360,
+                                ...(segments === undefined ? {} : { segments }),
+                            },
+                        ],
+                    },
+                },
+            ],
+        },
+        resolution: { ...resolution },
+        limits,
+        matrix: [radii[0] / radius, 0, 0, 0, radii[1] / radius, 0, 0, 0, 1],
+        origin: [0, 0],
+        ...(faceSizing ? { faceSizing: true } : {}),
+    };
+}
+/** Captures the explicitly indexed edges of a polygon or star; its topology is its family key. */
+export function polygonSectionProfile(family, loop, resolution, limits) {
+    return {
+        family,
+        profile: {
+            components: [
+                {
+                    id: "body",
+                    holes: [],
+                    outer: {
+                        id: "outline",
+                        spans: loop.map((start, index) => ({
+                            id: `edge-${index}`,
+                            kind: "line",
+                            start,
+                            end: loop[(index + 1) % loop.length],
+                        })),
+                    },
+                },
+            ],
+        },
+        resolution: { ...resolution },
+        limits,
+        matrix: identity,
+        origin: [0, 0],
+    };
+}
+/** Preserves a primitive's authored identity through an invertible XY affine transform. */
+export function transformPrimitiveSectionProfile(source, transform) {
+    const a = transform, b = source.matrix;
+    const matrix = [
+        a[0] * b[0] + a[1] * b[3],
+        a[0] * b[1] + a[1] * b[4],
+        a[0] * b[2] + a[1] * b[5] + a[2],
+        a[3] * b[0] + a[4] * b[3],
+        a[3] * b[1] + a[4] * b[4],
+        a[3] * b[2] + a[4] * b[5] + a[5],
+        0,
+        0,
+        1,
+    ];
+    if (!matrix.every(Number.isFinite))
+        fail("Primitive profile transforms must remain finite.");
+    return { ...source, matrix };
+}
+const fail = (message) => {
+    throw new GeometryError("INVALID_ARGUMENT", message, { operation: "loft" });
+};
+const determinant = (matrix) => matrix[0] * matrix[4] - matrix[1] * matrix[3];
+/** Circle/ellipse quadrants are the same corner landmarks as a fully rounded square. */
+export function rectangularPrimitiveFamily(sources) {
+    if (!sources.some((source) => source.family === "rectangle") ||
+        sources.some((source) => source.family !== "rectangle" && source.family !== "ellipse"))
+        return undefined;
+    return sources.map((source) => {
+        if (source.family === "rectangle")
+            return source;
+        const ring = source.profile.components[0].outer.spans[0];
+        if (ring.kind !== "arc")
+            return fail("Retained circular primitives require their analytic ring.");
+        if (ring.segments !== undefined && ring.segments % 4 !== 0)
+            fail("Circle/ellipse to rectangle landmark lofts require exact circular segments divisible by four. Select explicit correspondence to retain other faceted counts.");
+        const rectangular = rectangleSectionProfile({
+            size: 2 * ring.radius,
+            limits: source.limits,
+            treatment: {
+                kind: "round",
+                radius: ring.radius,
+                resolution: source.resolution,
+                ...(ring.segments === undefined ? {} : { segments: ring.segments }),
+            },
+        }, source.resolution, source.limits);
+        return {
+            ...rectangular,
+            matrix: source.matrix,
+            ...(source.faceSizing === true ? { faceSizing: true } : {}),
+        };
+    });
+}
+// Compute the greatest singular value after normalizing coefficients, avoiding squared overflow.
+const magnification = (matrix) => {
+    const maximum = Math.max(Math.abs(matrix[0]), Math.abs(matrix[1]), Math.abs(matrix[3]), Math.abs(matrix[4]));
+    const a = matrix[0] / maximum, b = matrix[1] / maximum, c = matrix[3] / maximum, d = matrix[4] / maximum;
+    const trace = a * a + b * b + c * c + d * d;
+    const det = a * d - b * c;
+    const result = maximum * Math.sqrt((trace + Math.sqrt(Math.max(0, trace * trace - 4 * det * det))) / 2);
+    if (!Number.isFinite(result) || result <= 0)
+        fail("Primitive profile transforms must be finite and nonsingular.");
+    return result;
+};
+/** Samples only compatible, retained primitive identities; arbitrary sections never enter this path. */
+export function correspondingPrimitiveProfiles(sources, options, limits) {
+    const first = sources[0];
+    if (sources.some((source) => source.family !== first.family))
+        fail("Primitive loft stations must retain the same identified shape family. Use explicit profiles for unlike shapes.");
+    const reflected = determinant(first.matrix) < 0;
+    if (sources.some((source) => determinant(source.matrix) < 0 !== reflected))
+        fail("Primitive loft stations must retain the same transform handedness.");
+    const selected = { ...limits };
+    for (const source of sources) {
+        for (const key of Object.keys(source.limits))
+            selected[key] = Math.min(selected[key], source.limits[key]);
+    }
+    const target = resolveGeometryResolution(options.resolution, selected);
+    if (first.family === "rectangle" &&
+        target.circularSegments !== undefined &&
+        target.circularSegments % 4 !== 0)
+        fail("Exact rectangle round segments describe a complete circle and must divide by four.");
+    const profiles = sources.map((source) => {
+        const scale = magnification(source.matrix);
+        return {
+            components: source.profile.components.map((component) => ({
+                ...component,
+                outer: {
+                    ...component.outer,
+                    spans: component.outer.spans.map((span) => {
+                        if (span.segments !== undefined)
+                            return span;
+                        const policy = source.spanResolution?.[span.id] ?? source.resolution;
+                        const original = resolveGeometryResolution({
+                            ...policy,
+                            maximumSegments: Math.min(policy.maximumSegments ?? selected.maxCircularSegments, selected.maxCircularSegments),
+                            minimumSegments: Math.min(policy.minimumSegments ?? 16, selected.maxCircularSegments),
+                        }, selected);
+                        const edgeLength = Math.min(original.maxSegmentLength ?? Infinity, target.maxSegmentLength ?? Infinity) /
+                            scale;
+                        const resolution = {
+                            maxChordError: Math.min(original.maxChordError, target.maxChordError) / scale,
+                            maximumSegments: Math.min(original.maximumSegments, target.maximumSegments),
+                            minimumSegments: Math.min(Math.max(original.minimumSegments, target.minimumSegments), Math.min(original.maximumSegments, target.maximumSegments)),
+                            ...(Number.isFinite(edgeLength) ? { maxSegmentLength: edgeLength } : {}),
+                            ...(target.circularSegments === undefined
+                                ? {}
+                                : { circularSegments: target.circularSegments }),
+                        };
+                        const segments = span.kind === "arc"
+                            ? span.radius === 0
+                                ? 1
+                                : resolveArcSegments(span.radius, Math.abs(span.sweepDegrees), resolution, selected)
+                            : span.kind === "line"
+                                ? resolveLineSegmentCount(Math.hypot(span.end[0] - span.start[0], span.end[1] - span.start[1]), resolution.maxSegmentLength)
+                                : resolveUniformCubicSegments(planarCubicControl(span), resolveGeometryResolution(resolution, selected), selected.maxProfilePoints);
+                        return { ...span, segments };
+                    }),
+                },
+            })),
+        };
+    });
+    const sampled = samplePrimitiveFamily(sources, profiles, target, selected);
+    return sampled.map((profile, index) => {
+        const source = sources[index], matrix = source.matrix;
+        return {
+            components: profile.components.map((component) => {
+                const contour = component.outer;
+                // Collapsed rectangle edge slots are landmarks rather than circular facets.
+                let radialScale = 1;
+                if (source.faceSizing) {
+                    const ring = source.profile.components[0].outer.spans.find((span) => span.kind === "arc");
+                    if (ring?.kind !== "arc" || !(ring.radius > 0))
+                        return fail("Face sizing requires a positive retained circular primitive.");
+                    let support = Infinity;
+                    for (let slot = 0; slot < contour.points.length; slot++) {
+                        const point = contour.points[slot], next = contour.points[(slot + 1) % contour.points.length];
+                        const ax = point[0] / ring.radius, ay = point[1] / ring.radius;
+                        const dx = next[0] / ring.radius - ax, dy = next[1] / ring.radius - ay, length = Math.hypot(dx, dy);
+                        if (length > 0)
+                            support = Math.min(support, Math.abs(ax * (dy / length) - ay * (dx / length)));
+                    }
+                    if (!Number.isFinite(support) || !(support > 0))
+                        return fail("Face-sized primitive facets must enclose their local origin.");
+                    radialScale = 1 / support;
+                }
+                const points = contour.points.map(([x, y]) => [
+                    matrix[0] * x * radialScale + matrix[1] * y * radialScale + matrix[2],
+                    matrix[3] * x * radialScale + matrix[4] * y * radialScale + matrix[5],
+                ]);
+                return {
+                    ...component,
+                    outer: {
+                        ...contour,
+                        points: reflected ? points.reverse() : points,
+                        spans: reflected ? [...contour.spans].reverse() : contour.spans,
+                    },
+                };
+            }),
+        };
+    });
+}