@metamesh/modeling 0.19.0 → 0.20.0

package/dist/engine/operations/hole-cutter.js

@@ -1,7 +1,12 @@
-import { convexContourOffsets } from "../../geometry/convex-offset.js";
 import { GeometryError } from "../../geometry/errors.js";
-import { assertPrimitiveOptions } from "../../geometry/primitive-resolvers.js";
-/** Composes cutters inside the evaluating host, retaining deferred Section and sampling ownership. */
+import { assertMeshAllocationWithinLimits } from "../../geometry/limits.js";
+import { pointLoftProfile } from "../../geometry/loft/geometry.js";
+import { edgeTreatmentPointCount, edgeTreatmentSetbacks, sampleEdgeTreatment, } from "../../geometry/primitives/edges.js";
+import { assertPrimitiveOptions } from "../../geometry/primitives/resolvers.js";
+import { circleContour } from "../../geometry/profiles/primitives/circle.js";
+import { convexContourOffsets } from "../../geometry/regions/convex-offset.js";
+import { assertSamplingCount } from "../../geometry/sampling/limits.js";
+/** Composes one corresponding loft, retaining deferred Section and host sampling ownership. */
 export function createHoleCutterOperation(environment, operations) {
     return (options) => {
         environment.assertActive();
@@ -11,137 +16,143 @@ export function createHoleCutterOperation(environment, operations) {
         };
         const positive = (value, name) => {
             if (!Number.isFinite(value) || value <= 0)
-                fail(`${name} must be finite and positive.`);
+                fail(name + " must be finite and positive.");
             return value;
         };
         const nonnegative = (value, name) => {
             if (!Number.isFinite(value) || value < 0)
-                fail(`${name} must be finite and nonnegative.`);
+                fail(name + " must be finite and nonnegative.");
             return value;
         };
         const height = positive(options.height, "height");
         const circular = options.diameter !== undefined;
         if (circular === (options.profile !== undefined))
             fail("Specify exactly one diameter or Section profile.");
-        if (!circular &&
-            (options.recess !== undefined ||
-                options.segments !== undefined ||
-                options.sizing !== undefined))
-            fail("Circular recess, segments and sizing options require a diameter.");
-        if (options.recess !== undefined && options.entryChamfer !== undefined)
-            fail("A recess and entryChamfer are mutually exclusive.");
-        const face = options.face ?? "top";
-        if (face !== "top" && face !== "bottom")
-            fail("face must be top or bottom.");
+        if (!circular && (options.segments !== undefined || options.sizing !== undefined))
+            fail("Circular segments and sizing options require a diameter.");
+        if (options.sizing !== undefined && options.sizing !== "vertex" && options.sizing !== "face")
+            fail("sizing must be vertex or face.");
         if (options.overrun !== undefined)
             assertPrimitiveOptions(options.overrun, "holeCutter");
+        if (options.openings !== undefined)
+            assertPrimitiveOptions(options.openings, "holeCutter");
         const bottom = nonnegative(options.overrun?.bottom ?? 0, "overrun.bottom");
         const top = nonnegative(options.overrun?.top ?? 0, "overrun.top");
         const length = positive(height + bottom + top, "extended height");
-        const chamfer = nonnegative(options.entryChamfer ?? 0, "entryChamfer");
-        if (chamfer >= height)
-            fail("entryChamfer must be smaller than height.");
         const selected = environment.withResolutionDefaults(options);
         const sampling = { resolution: selected.resolution, limits: selected.limits };
-        if (circular)
-            positive(options.diameter, "diameter");
-        if (options.recess !== undefined) {
-            const recess = options.recess;
-            assertPrimitiveOptions(recess, "holeCutter");
-            positive(recess.diameter, "recess.diameter");
-            if (recess.diameter <= options.diameter)
-                fail("The recess diameter must exceed the bore diameter.");
-            let depth;
-            if (recess.kind === "counterbore")
-                depth = positive(recess.depth, "recess.depth");
-            else if (recess.kind === "countersink") {
-                if (!Number.isFinite(recess.includedAngle) ||
-                    recess.includedAngle <= 0 ||
-                    recess.includedAngle >= 180)
-                    fail("Countersink includedAngle must be between zero and 180 degrees.");
-                depth = positive((recess.diameter - options.diameter) /
-                    (2 * Math.tan((recess.includedAngle * Math.PI) / 360)), "recess depth");
+        const radius = circular ? positive(options.diameter, "diameter") / 2 : 0;
+        const plan = (opening) => {
+            if (opening === undefined)
+                return { width: 0, depth: 0 };
+            assertPrimitiveOptions(opening, "holeCutter");
+            if (opening.kind === "counterbore" || opening.kind === "countersink") {
+                if (!circular)
+                    fail("Screw seats require a circular diameter.");
+                positive(opening.diameter, "opening.diameter");
+                if (opening.diameter <= radius * 2)
+                    fail("The opening seat diameter must exceed the bore diameter.");
+                const width = opening.diameter / 2 - radius;
+                let depth;
+                if (opening.kind === "counterbore")
+                    depth = positive(opening.depth, "opening.depth");
+                else {
+                    if (!Number.isFinite(opening.includedAngle) ||
+                        opening.includedAngle <= 0 ||
+                        opening.includedAngle >= 180)
+                        fail("Countersink includedAngle must be between zero and 180 degrees.");
+                    depth = positive(width / Math.tan((opening.includedAngle * Math.PI) / 360), "opening depth");
+                }
+                return { width, depth, recess: opening };
             }
-            else
-                return fail("Unsupported recess kind.");
-            if (depth > height)
-                fail("The recess must fit within height.");
-            const segments = environment.resolveCircularSegments(recess.diameter / 2, options);
-            const common = { ...sampling, segments, sizing: options.sizing ?? "vertex", center: false };
-            const bore = operations.translate(operations.cylinder({ ...common, diameter: options.diameter, height: length }), [0, 0, -bottom]);
-            const seat = operations.translate(operations.cylinder({
-                ...common,
-                diameter: recess.kind === "counterbore"
-                    ? recess.diameter
-                    : face === "top"
-                        ? [options.diameter, recess.diameter]
-                        : [recess.diameter, options.diameter],
-                height: depth,
-            }), [0, 0, face === "top" ? height - depth : 0]);
-            const excess = face === "top" ? top : bottom;
-            return operations.union([
-                bore,
-                seat,
-                ...(excess === 0
-                    ? []
-                    : [
-                        operations.translate(operations.cylinder({
-                            ...common,
-                            diameter: recess.diameter,
-                            height: excess,
-                        }), [0, 0, face === "top" ? height : -bottom]),
-                    ]),
-            ]);
-        }
-        if (circular) {
-            const openingOverrun = face === "top" ? top : bottom;
-            const segments = environment.resolveCircularSegments(options.diameter / 2 + chamfer + (chamfer === 0 ? 0 : openingOverrun), options);
-            const common = { ...sampling, segments, sizing: options.sizing ?? "vertex", center: false };
-            const bore = operations.translate(operations.cylinder({
-                ...common,
-                diameter: options.diameter,
-                height: length,
-            }), [0, 0, -bottom]);
-            if (chamfer === 0)
-                return bore;
-            // Circular entries retain nominal radial dimensions. Section entries below instead
-            // offset their supplied polygon edges; their faceted envelope remains authoritative.
-            const mouth = options.diameter + 2 * (chamfer + openingOverrun);
-            const entry = operations.translate(operations.cylinder({
-                ...common,
-                diameter: face === "top" ? [options.diameter, mouth] : [mouth, options.diameter],
-                height: chamfer + openingOverrun,
-            }), [0, 0, face === "top" ? height - chamfer : -bottom]);
-            return operations.union([bore, entry]);
+            const [width, depth] = edgeTreatmentSetbacks(opening, "holeCutter", Math.PI / 2, selected.limits);
+            return { width, depth, treatment: opening };
+        };
+        const lower = plan(options.openings?.bottom), upper = plan(options.openings?.top);
+        if (lower.depth + upper.depth >= height)
+            fail("Opening depths must leave a positive untreated bore interval.");
+        const maximumRadius = radius + Math.max(lower.width, upper.width);
+        const segments = circular
+            ? environment.resolveCircularSegments(maximumRadius, options)
+            : undefined;
+        if (lower.depth === 0 && upper.depth === 0) {
+            // Shared validation still applies before taking the disabled-treatment fast path.
+            for (const opening of [lower, upper])
+                if (opening.treatment)
+                    edgeTreatmentPointCount(opening.treatment, "holeCutter", sampling);
+            return operations.translate(circular
+                ? operations.cylinder({
+                    ...sampling,
+                    diameter: options.diameter,
+                    height: length,
+                    segments: segments,
+                    sizing: options.sizing ?? "vertex",
+                    center: false,
+                })
+                : operations.extrude(options.profile, { ...sampling, height: length }), [0, 0, -bottom]);
         }
-        const profile = options.profile;
-        if (chamfer === 0)
-            return operations.translate(operations.extrude(profile, { ...sampling, height: length }), [
-                0,
-                0,
-                -bottom,
-            ]);
-        const source = environment.sectionProfileFor(profile);
-        if (source.components.length !== 1 || source.components[0].holes.length !== 0)
-            fail("Entry chamfers require one strictly convex contour without holes.");
-        const component = source.components[0];
-        const offset = convexContourOffsets(component.outer.points, "holeCutter").offset;
-        const rows = face === "top"
-            ? [
-                { z: -bottom, inset: 0 },
-                { z: height - chamfer, inset: 0 },
-                { z: height + top, inset: -chamfer - top },
-            ]
-            : [
-                { z: -bottom, inset: -chamfer - bottom },
-                { z: chamfer, inset: 0 },
-                { z: height + top, inset: 0 },
-            ];
-        const stations = rows.map(({ z, inset }) => ({
+        const source = circular ? undefined : environment.sectionProfileFor(options.profile);
+        if (source && (source.components.length !== 1 || source.components[0].holes.length !== 0))
+            fail("Opening treatments require one strictly convex contour without holes.");
+        const component = source?.components[0];
+        const offsets = component
+            ? convexContourOffsets(component.outer.points, "holeCutter")
+            : undefined;
+        const magnification = offsets?.magnification ?? (options.sizing === "face" ? 1 / Math.cos(Math.PI / segments) : 1);
+        const treatmentSampling = { ...sampling, magnification };
+        const count = (opening) => opening.recess
+            ? opening.recess.kind === "counterbore"
+                ? 3
+                : 2
+            : opening.treatment
+                ? edgeTreatmentPointCount(opening.treatment, "holeCutter", treatmentSampling)
+                : 1;
+        const rowCount = count(lower) + count(upper) + (bottom > 0 ? 1 : 0) + (top > 0 ? 1 : 0);
+        const pointCount = segments ?? component.outer.points.length;
+        assertSamplingCount(rowCount, "holeCutter", selected.limits.maxPathPoints);
+        const vertices = rowCount * pointCount, triangles = 2 * pointCount * (rowCount - 1) + 2 * (pointCount - 2);
+        assertMeshAllocationWithinLimits(vertices, triangles, 12 * (vertices + triangles), "holeCutter", selected.limits);
+        const points = (opening) => {
+            if (opening.recess)
+                return opening.recess.kind === "counterbore"
+                    ? [
+                        [opening.width, 0],
+                        [opening.width, opening.depth],
+                        [0, opening.depth],
+                    ]
+                    : [
+                        [opening.width, 0],
+                        [0, opening.depth],
+                    ];
+            return opening.treatment
+                ? sampleEdgeTreatment(opening.treatment, "holeCutter", treatmentSampling)
+                : [[0, 0]];
+        };
+        const rows = [
+            ...(bottom > 0 ? [{ z: -bottom, expansion: lower.width }] : []),
+            ...points(lower).map(([expansion, z]) => ({ z, expansion })),
+            ...[...points(upper)]
+                .reverse()
+                .map(([expansion, depth]) => ({ z: height - depth, expansion })),
+            ...(top > 0 ? [{ z: height + top, expansion: upper.width }] : []),
+        ];
+        const contour = (expansion) => circular
+            ? circleContour({
+                ...sampling,
+                radius: radius + expansion,
+                segments: segments,
+                sizing: options.sizing ?? "vertex",
+            })
+            : offsets.offset(-expansion);
+        const stations = rows.map(({ z, expansion }) => ({
             z,
-            profile: {
-                components: [{ ...component, outer: { ...component.outer, points: offset(inset) } }],
-            },
+            profile: component
+                ? {
+                    components: [
+                        { ...component, outer: { ...component.outer, points: contour(expansion) } },
+                    ],
+                }
+                : pointLoftProfile(contour(expansion)),
         }));
         return operations.loft(stations, sampling);
     };

package/dist/engine/operations/join-collar-profile.js

@@ -1,8 +1,8 @@
 import { GeometryError } from "../../geometry/errors.js";
-import { assertMeshAllocationWithinLimits, } from "../../geometry/model-limits.js";
-import { assertSamplingCount } from "../../geometry/sampling-limits.js";
+import { assertMeshAllocationWithinLimits } from "../../geometry/limits.js";
+import { assertSamplingCount } from "../../geometry/sampling/limits.js";
 import { observeNativeMesh } from "../native/mesh-observation.js";
-import { regionFromLoops } from "../native/regions.js";
+import { regionFromContours } from "../native/regions.js";
 /** Slices original native facets; CrossSection quantization must not move the feature wall datum. */
 export function nativeCollarProfile(scope, feature, height, limits, work) {
     const raw = observeNativeMesh(scope, feature, limits, "join");
@@ -60,52 +60,52 @@ export function nativeCollarProfile(scope, feature, height, limits, work) {
         assertSamplingCount(next.size, "join", limits.maxProfilePoints);
         assertMeshAllocationWithinLimits(0, 0, next.size * 192, "join", limits);
     }
-    const loops = [];
+    const contours = [];
     const visited = new Set();
     for (const start of next.keys()) {
         if (visited.has(start))
             continue;
-        const loop = [];
+        const contour = [];
         let id = start;
         do {
             work.use();
             if (visited.has(id))
                 fail();
             visited.add(id);
-            loop.push(points.get(id));
+            contour.push(points.get(id));
             id = next.get(id) ?? fail();
         } while (id !== start);
-        // Remove tessellation diagonals along the same physical wall, at Double comparison precision.
+        // Remove tessellation diagonals along the same physical wall within Float64 comparison tolerance.
         let scale = 1;
-        for (const [x, y] of loop) {
+        for (const [x, y] of contour) {
             work.use();
             scale = Math.max(scale, Math.abs(x), Math.abs(y));
         }
         const tolerance = scale * Number.EPSILON * 64;
         let changed = true;
-        while (changed && loop.length > 3) {
+        while (changed && contour.length > 3) {
             changed = false;
-            for (let index = 0; index < loop.length; index++) {
+            for (let index = 0; index < contour.length; index++) {
                 work.use();
-                const a = loop[(index + loop.length - 1) % loop.length], b = loop[index], c = loop[(index + 1) % loop.length];
+                const a = contour[(index + contour.length - 1) % contour.length], b = contour[index], c = contour[(index + 1) % contour.length];
                 const dx = c[0] - a[0], dy = c[1] - a[1], length = Math.hypot(dx, dy);
                 const fraction = ((b[0] - a[0]) * dx + (b[1] - a[1]) * dy) / (length * length);
                 if (fraction >= 0 &&
                     fraction <= 1 &&
                     Math.abs(dx * (b[1] - a[1]) - dy * (b[0] - a[0])) <= tolerance * length) {
-                    work.use(loop.length - index - 1);
-                    loop.splice(index, 1);
+                    work.use(contour.length - index - 1);
+                    contour.splice(index, 1);
                     changed = true;
                     break;
                 }
             }
         }
-        loops.push(loop);
+        contours.push(contour);
     }
-    if (loops.length === 0)
+    if (contours.length === 0)
         fail();
-    const region = regionFromLoops(loops);
-    const contour = (id, points) => ({
+    const region = regionFromContours(contours);
+    const profileContour = (id, points) => ({
         id,
         points,
         spans: points.map((_, index) => `point-${index}`),
@@ -113,8 +113,8 @@ export function nativeCollarProfile(scope, feature, height, limits, work) {
     return {
         components: region.map((component, index) => ({
             id: `component-${index}`,
-            outer: contour("outer", component.outer),
-            holes: component.holes.map((hole, index) => contour(`hole-${index}`, hole)),
+            outer: profileContour("outer", component.outer),
+            holes: component.holes.map((hole, index) => profileContour(`hole-${index}`, hole)),
         })),
     };
 }