Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

29.0 KB
Raw Blame
using Aetheris.Kernel.Core.Diagnostics;
using Aetheris.Kernel.Core.Geometry;
using Aetheris.Kernel.Core.Geometry.Curves;
using Aetheris.Kernel.Core.Geometry.Surfaces;
using Aetheris.Kernel.Core.Math;
using Aetheris.Kernel.Core.Numerics;
using Aetheris.Kernel.Core.Results;
using Aetheris.Kernel.Core.Topology;


namespace Aetheris.Kernel.Core.Brep.Features;

public sealed record HollowRadialCutPlacement(string StableId, double Radius, double Z, double AngleRadians);
public sealed record HollowRadialCutPatternResult(BrepBody Body, HollowRadialCutTopologyMap TopologyMap,
    IReadOnlyDictionary<string, HollowRadialCutCertificate> Certificates, double HostSeamAngleRadians);

/// <summary>Compose qualified local radial cuts on one analytic Hollow wall.
/// The stock faces are constructed once; each instance contributes two trim loops
/// and one cylindrical connector face. No Boolean or faceted topology is involved.</summary>
public static class BrepHollowRadialCutPattern
{
    public static KernelResult<HollowRadialCutPatternResult> Build(ThinWalledBodyRealization hollow,
        IReadOnlyList<HollowRadialCutPlacement> placements, ToleranceContext? tolerance = null)
    {
        ArgumentNullException.ThrowIfNull(hollow);
        ArgumentNullException.ThrowIfNull(placements);
        var tol = tolerance ?? ToleranceContext.Default;
        KernelResult<HollowRadialCutPatternResult> Reject(string code, string message) =>
            KernelResult<HollowRadialCutPatternResult>.Failure([
                new KernelDiagnostic(KernelDiagnosticCode.ValidationFailed, KernelDiagnosticSeverity.Error, message, code)]);
        if (hollow.Feature.PrimitiveKind != "Cylinder" || hollow.Feature.Openings.Count != 1 || hollow.Feature.Openings[0] != "Top")
            return Reject("Brep.HollowRadialCutPattern.UnsupportedHost", "A top-open Cylinder<Hollow> is required.");
        if (placements.Count == 0 || placements.Count > 1000 || placements.Select(p => p.StableId).Distinct(StringComparer.Ordinal).Count() != placements.Count)
            return Reject("Brep.HollowRadialCutPattern.InvalidInstances", "Provide one to 1000 uniquely identified local holes.");
        var radius = hollow.Feature.PrimitiveParameters["Radius"];
        var height = hollow.Feature.PrimitiveParameters["Height"];
        var thickness = hollow.Feature.WallThickness;
        var innerRadius = radius - thickness;
        var blendRadius = hollow.Feature.PrimitiveParameters.GetValueOrDefault("BottomBlendRadius");
        var blended = blendRadius > 0;
        var wallStart = blended ? blendRadius : 0d;
        if (placements.Any(p => !double.IsFinite(p.Radius) || !double.IsFinite(p.Z) || !double.IsFinite(p.AngleRadians) ||
            p.Radius <= 0 || p.Radius >= innerRadius - tol.Linear || p.Z - p.Radius <= wallStart + tol.Linear ||
            p.Z + p.Radius >= height - tol.Linear))
            return Reject("Brep.HollowRadialCutPattern.InvalidPlacement", "Every opening must clear the inner bottom, top rim, and inner-cylinder tangent case.");
        // The current single-loop pcurve representation needs a host seam outside
        // every opening. Choose the midpoint of the largest free angular gap.
        var centers = placements.Select(p => Normalize(p.AngleRadians)).Distinct().Order().ToArray();
        var bestGap = -1d; var seamAngle = 0d;
        for (var i = 0; i < centers.Length; i++)
        {
            var next = i + 1 < centers.Length ? centers[i + 1] : centers[0] + 2 * System.Math.PI;
            var gap = next - centers[i];
            if (gap > bestGap) { bestGap = gap; seamAngle = Normalize(centers[i] + gap / 2); }
        }
        if (placements.Any(p => AngularDistance(seamAngle, Normalize(p.AngleRadians)) <= System.Math.Asin(p.Radius / innerRadius) + tol.Angular))
            return Reject("Brep.HollowRadialCutPattern.SeamClearance", "No host seam clears all local opening loops; periodic seam splitting is required.");
        for (var i = 0; i < placements.Count; i++)
            for (var j = i + 1; j < placements.Count; j++)
            {
                var arc = innerRadius * AngularDistance(Normalize(placements[i].AngleRadians), Normalize(placements[j].AngleRadians));
                var dz = placements[i].Z - placements[j].Z;
                if (System.Math.Sqrt(arc * arc + dz * dz) <= placements[i].Radius + placements[j].Radius + tol.Linear)
                    return Reject("Brep.HollowRadialCutPattern.Overlap", $"Openings {placements[i].StableId} and {placements[j].StableId} overlap.");
            }

        var z = Direction3D.Create(new Vector3D(0, 0, 1));
        var hostReference = Direction3D.Create(new Vector3D(System.Math.Cos(seamAngle), System.Math.Sin(seamAngle), 0));
        var origin = new Point3D(0, 0, 0);
        var outer = new CylinderSurface(origin, z, radius, hostReference);
        var inner = new CylinderSurface(new Point3D(0, 0, thickness), z, innerRadius, hostReference);
        var full = new ParameterInterval(0, 2 * System.Math.PI);
        var first = new ParameterInterval(0, System.Math.PI);
        var second = new ParameterInterval(System.Math.PI, 2 * System.Math.PI);
        var builder = new TopologyBuilder();
        var points = new Dictionary<VertexId, Point3D>();
        VertexId V(Point3D point) { var id = builder.AddVertex(); points.Add(id, point); return id; }
        var ob = V(new Point3D(0, 0, wallStart) + hostReference.ToVector() * radius);
        var ot = V(new Point3D(0, 0, height) + hostReference.ToVector() * radius);
        var ib = V(new Point3D(0, 0, wallStart > 0 ? wallStart : thickness) + hostReference.ToVector() * innerRadius);
        var it = V(new Point3D(0, 0, height) + hostReference.ToVector() * innerRadius);
        var outerSeam = builder.AddEdge(ob, ot); var innerSeam = builder.AddEdge(ib, it);
        var outerBottom = builder.AddEdge(ob, ob); var outerTop = builder.AddEdge(ot, ot);
        var innerBottom = builder.AddEdge(ib, ib); var innerTop = builder.AddEdge(it, it);
        var floorRadius = blended ? radius - blendRadius : radius;
        var outerFloorVertex = blended ? V(origin + hostReference.ToVector() * floorRadius) : ob;
        var innerFloorVertex = blended ? V(new Point3D(0, 0, thickness) + hostReference.ToVector() * floorRadius) : ib;
        var outerFloor = blended ? builder.AddEdge(outerFloorVertex, outerFloorVertex) : outerBottom;
        var innerFloor = blended ? builder.AddEdge(innerFloorVertex, innerFloorVertex) : innerBottom;
        // Loops run counter-clockwise about the face's outward normal: the outer wall goes round +u at its bottom circle,
        // the inner wall (whose outward normal faces the axis) round +u at its top circle.
        var outerEnvelope = AddLoop(builder, [new(outerSeam), new(outerTop, true), new(outerSeam, true), new(outerBottom)]);
        var innerEnvelope = AddLoop(builder, [new(innerSeam), new(innerTop), new(innerSeam, true), new(innerBottom, true)]);
        var geometry = new BrepGeometryStore();
        geometry.AddCurve(new CurveGeometryId(1), CurveGeometry.FromLine(new Line3Curve(points[ob], z)));
        geometry.AddCurve(new CurveGeometryId(2), CurveGeometry.FromLine(new Line3Curve(points[ib], z)));
        geometry.AddCurve(new CurveGeometryId(3), CurveGeometry.FromCircle(new Circle3Curve(new Point3D(0, 0, wallStart), z, radius, hostReference)));
        geometry.AddCurve(new CurveGeometryId(4), CurveGeometry.FromCircle(new Circle3Curve(new Point3D(0, 0, height), z, radius, hostReference)));
        geometry.AddCurve(new CurveGeometryId(5), CurveGeometry.FromCircle(new Circle3Curve(new Point3D(0, 0, blended ? wallStart : thickness), z, innerRadius, hostReference)));
        geometry.AddCurve(new CurveGeometryId(6), CurveGeometry.FromCircle(new Circle3Curve(new Point3D(0, 0, height), z, innerRadius, hostReference)));
        if (blended)
        {
            geometry.AddCurve(new CurveGeometryId(7), CurveGeometry.FromCircle(new Circle3Curve(origin, z, floorRadius, hostReference)));
            geometry.AddCurve(new CurveGeometryId(8), CurveGeometry.FromCircle(new Circle3Curve(new Point3D(0, 0, thickness), z, floorRadius, hostReference)));
        }
        geometry.AddSurface(new SurfaceGeometryId(1), SurfaceGeometry.FromCylinder(outer));
        geometry.AddSurface(new SurfaceGeometryId(2), SurfaceGeometry.FromCylinder(inner));
        geometry.AddSurface(new SurfaceGeometryId(3), SurfaceGeometry.FromPlane(new PlaneSurface(origin, Direction3D.Create(-z.ToVector()), hostReference)));
        geometry.AddSurface(new SurfaceGeometryId(4), SurfaceGeometry.FromPlane(new PlaneSurface(new Point3D(0, 0, thickness), z, hostReference)));
        geometry.AddSurface(new SurfaceGeometryId(5), SurfaceGeometry.FromPlane(new PlaneSurface(new Point3D(0, 0, height), z, hostReference)));
        if (blended)
        {
            var blendCenter = new Point3D(0, 0, blendRadius);
            geometry.AddSurface(new SurfaceGeometryId(6), SurfaceGeometry.FromTorus(new TorusSurface(blendCenter, z, floorRadius, blendRadius, hostReference)));
            geometry.AddSurface(new SurfaceGeometryId(7), SurfaceGeometry.FromTorus(new TorusSurface(blendCenter, z, floorRadius, blendRadius - thickness, hostReference)));
        }
        var bindings = new BrepBindingModel();
        void Edge(EdgeId edge, int curve, ParameterInterval interval) => bindings.AddEdgeBinding(new EdgeGeometryBinding(edge, new CurveGeometryId(curve), interval));
        Edge(outerSeam, 1, new(0, height - wallStart)); Edge(innerSeam, 2, new(0, height - (blended ? wallStart : thickness)));
        Edge(outerBottom, 3, full); Edge(outerTop, 4, full); Edge(innerBottom, 5, full); Edge(innerTop, 6, full);
        if (blended) { Edge(outerFloor, 7, full); Edge(innerFloor, 8, full); }
        void Bind(CoedgeId id, FaceId face, int surface, PcurveGeometry uv) =>
            bindings.AddPcurveBinding(new CoedgePcurveBinding(id, face, new SurfaceGeometryId(surface), uv));
        void Role(FaceId face, LoopId loop, FaceBoundaryRole role) =>
            bindings.AddFaceBoundaryRoleBinding(new FaceBoundaryRoleBinding(face, loop, role));
        var holes = new List<Hole>();
        var faceNames = new Dictionary<string, FaceId>(StringComparer.Ordinal);
        var loopNames = new Dictionary<string, LoopId>(StringComparer.Ordinal);
        var edgeNames = new Dictionary<string, IReadOnlyList<EdgeId>>(StringComparer.Ordinal);
        var certificates = new Dictionary<string, HollowRadialCutCertificate>(StringComparer.Ordinal);
        var nextCurve = blended ? 9 : 7; var nextSurface = blended ? 8 : 6;
        var templates = new Dictionary<double, OpeningTemplate>();
        foreach (var placement in placements)
        {
            var canonicalAngle = Normalize(placement.AngleRadians);
            if (canonicalAngle <= tol.Angular || 2 * System.Math.PI - canonicalAngle <= tol.Angular)
                canonicalAngle = 0;
            var radial = Direction3D.Create(new Vector3D(System.Math.Cos(canonicalAngle), System.Math.Sin(canonicalAngle), 0));
            var toolReference = Direction3D.Create(z.ToVector().Cross(radial.ToVector()));
            var center = new Point3D(0, 0, placement.Z);
            var tool = new CylinderSurface(center, radial, placement.Radius, toolReference);
            var outerAuthority = CylinderCylinderIntersectionCurve.Create(outer, tool, center, CylinderIntersectionBranch.PositiveCutterAxis, full, tolerance: tol);
            if (!outerAuthority.IsSuccess) return InstanceFailure(placement, outerAuthority.Diagnostics);
            var innerAuthority = CylinderCylinderIntersectionCurve.Create(inner, tool, center, CylinderIntersectionBranch.PositiveCutterAxis, full, tolerance: tol);
            if (!innerAuthority.IsSuccess) return InstanceFailure(placement, innerAuthority.Diagnostics);
            // Openings of one radius are congruent: a rotation about the host axis and a shift along it. The
            // first is realized adaptively; every other is that realization moved rigidly, so identical holes
            // carry identical representations and the realization cost is paid once per radius.
            KernelResult<QualifiedCylinderIntersectionRepresentation> outerCurve, innerCurve;
            KernelResult<QualifiedCylinderIntersectionPcurves> outerUv, innerUv;
            if (templates.TryGetValue(placement.Radius, out var template)
                && Place(template.Outer, outerAuthority.Value, canonicalAngle - template.Angle, placement.Z - template.Z) is { } placedOuter
                && Place(template.Inner, innerAuthority.Value, canonicalAngle - template.Angle, placement.Z - template.Z) is { } placedInner)
            {
                outerCurve = KernelResult<QualifiedCylinderIntersectionRepresentation>.Success(placedOuter.Edge);
                innerCurve = KernelResult<QualifiedCylinderIntersectionRepresentation>.Success(placedInner.Edge);
                outerUv = KernelResult<QualifiedCylinderIntersectionPcurves>.Success(placedOuter);
                innerUv = KernelResult<QualifiedCylinderIntersectionPcurves>.Success(placedInner);
            }
            else
            {
                outerCurve = CylinderIntersectionCurveRealizer.Realize(outerAuthority.Value, tol);
                if (!outerCurve.IsSuccess) return InstanceFailure(placement, outerCurve.Diagnostics);
                innerCurve = CylinderIntersectionCurveRealizer.Realize(innerAuthority.Value, tol);
                if (!innerCurve.IsSuccess) return InstanceFailure(placement, innerCurve.Diagnostics);
                outerUv = CylinderIntersectionPcurveRealizer.Realize(outerCurve.Value, tol);
                if (!outerUv.IsSuccess) return InstanceFailure(placement, outerUv.Diagnostics);
                innerUv = CylinderIntersectionPcurveRealizer.Realize(innerCurve.Value, tol);
                if (!innerUv.IsSuccess) return InstanceFailure(placement, innerUv.Diagnostics);
                templates.TryAdd(placement.Radius, new(canonicalAngle, placement.Z, outerUv.Value, innerUv.Value));
            }
            var o0 = V(outerAuthority.Value.Evaluate(0)); var oPi = V(outerAuthority.Value.Evaluate(System.Math.PI));
            var i0 = V(innerAuthority.Value.Evaluate(0)); var iPi = V(innerAuthority.Value.Evaluate(System.Math.PI));
            var outerFirst = builder.AddEdge(o0, oPi); var outerSecond = builder.AddEdge(oPi, o0);
            var innerFirst = builder.AddEdge(i0, iPi); var innerSecond = builder.AddEdge(iPi, i0);
            var toolSeam = builder.AddEdge(o0, i0);
            var outerOpening = AddLoop(builder, [new(outerSecond, true), new(outerFirst, true)]);
            var innerOpening = AddLoop(builder, [new(innerFirst), new(innerSecond)]);
            var wall = AddLoop(builder, [new(outerFirst), new(outerSecond), new(toolSeam),
                new(innerSecond, true), new(innerFirst, true), new(toolSeam, true)]);
            var wallFace = builder.AddFace([wall.Id]);
            var outerCurveId = nextCurve++; var innerCurveId = nextCurve++; var toolSeamCurveId = nextCurve++;
            geometry.AddCurve(new CurveGeometryId(outerCurveId), CurveGeometry.FromCertifiedIntersection(outerCurve.Value));
            geometry.AddCurve(new CurveGeometryId(innerCurveId), CurveGeometry.FromCertifiedIntersection(innerCurve.Value));
            geometry.AddCurve(new CurveGeometryId(toolSeamCurveId), CurveGeometry.FromLine(new Line3Curve(points[o0], Direction3D.Create(points[i0] - points[o0]))));
            var seamLength = (points[o0] - points[i0]).Length;
            Edge(outerFirst, outerCurveId, first); Edge(outerSecond, outerCurveId, second);
            Edge(innerFirst, innerCurveId, first); Edge(innerSecond, innerCurveId, second);
            Edge(toolSeam, toolSeamCurveId, new(0, seamLength));
            var surface = nextSurface++;
            geometry.AddSurface(new SurfaceGeometryId(surface), SurfaceGeometry.FromCylinder(tool));
            bindings.AddFaceBinding(new FaceGeometryBinding(wallFace, new SurfaceGeometryId(surface), IsAlignedWithSurface: false));
            Role(wallFace, wall.Id, FaceBoundaryRole.Outer);
            Bind(wall.Coedges[0], wallFace, surface, PcurveGeometry.Polynomial(first, outerUv.Value.Tool));
            Bind(wall.Coedges[1], wallFace, surface, PcurveGeometry.Polynomial(second, outerUv.Value.Tool));
            Bind(wall.Coedges[2], wallFace, surface, PcurveGeometry.Line(new(0, seamLength),
                new(2 * System.Math.PI, (points[o0] - center).Dot(radial.ToVector())),
                new(2 * System.Math.PI, (points[i0] - center).Dot(radial.ToVector()))));
            Bind(wall.Coedges[3], wallFace, surface, PcurveGeometry.Polynomial(second, innerUv.Value.Tool));
            Bind(wall.Coedges[4], wallFace, surface, PcurveGeometry.Polynomial(first, innerUv.Value.Tool));
            Bind(wall.Coedges[5], wallFace, surface, PcurveGeometry.Line(new(0, seamLength),
                new(0, (points[o0] - center).Dot(radial.ToVector())),
                new(0, (points[i0] - center).Dot(radial.ToVector()))));
            var identity = placement.StableId;
            faceNames[$"{identity}.Wall"] = wallFace;
            loopNames[$"{identity}.OuterOpening"] = outerOpening.Id;
            loopNames[$"{identity}.InnerOpening"] = innerOpening.Id;
            edgeNames[$"{identity}.OuterOpening"] = [outerFirst, outerSecond];
            edgeNames[$"{identity}.InnerOpening"] = [innerFirst, innerSecond];
            certificates[identity] = new(outerCurve.Value.CertifiedDeviationBoundMm, innerCurve.Value.CertifiedDeviationBoundMm,
                outerUv.Value.HostEdgeMismatchBoundMm, outerUv.Value.ToolEdgeMismatchBoundMm,
                innerUv.Value.HostEdgeMismatchBoundMm, innerUv.Value.ToolEdgeMismatchBoundMm,
                outerCurve.Value.SegmentCount, innerCurve.Value.SegmentCount);
            holes.Add(new(outerOpening, innerOpening, wallFace, outerUv.Value, innerUv.Value));
        }
        var outerFace = builder.AddFace([outerEnvelope.Id, .. holes.Select(h => h.Outer.Id)]);
        var innerFace = builder.AddFace([innerEnvelope.Id, .. holes.Select(h => h.Inner.Id)]);
        var bottomOutside = AddLoop(builder, [new(outerFloor, true)]); var outerBottomFace = builder.AddFace([bottomOutside.Id]);
        var bottomInside = AddLoop(builder, [new(innerFloor)]); var innerBottomFace = builder.AddFace([bottomInside.Id]);
        var outerBlendFloor = blended ? AddLoop(builder, [new(outerFloor)]) : default;
        var outerBlendWall = blended ? AddLoop(builder, [new(outerBottom, true)]) : default;
        var innerBlendFloor = blended ? AddLoop(builder, [new(innerFloor, true)]) : default;
        var innerBlendWall = blended ? AddLoop(builder, [new(innerBottom)]) : default;
        var outerBlendFace = blended ? builder.AddFace([outerBlendFloor.Id, outerBlendWall.Id]) : default;
        var innerBlendFace = blended ? builder.AddFace([innerBlendFloor.Id, innerBlendWall.Id]) : default;
        var rimOuter = AddLoop(builder, [new(outerTop)]); var rimInner = AddLoop(builder, [new(innerTop, true)]);
        var rimFace = builder.AddFace([rimOuter.Id, rimInner.Id]);
        var shell = builder.AddShell(blended
            ? [outerFace, innerFace, outerBottomFace, innerBottomFace, rimFace, outerBlendFace, innerBlendFace, .. holes.Select(h => h.WallFace)]
            : [outerFace, innerFace, outerBottomFace, innerBottomFace, rimFace, .. holes.Select(h => h.WallFace)]);
        builder.AddBody([shell]);
        bindings.AddFaceBinding(new FaceGeometryBinding(outerFace, new SurfaceGeometryId(1)));
        bindings.AddFaceBinding(new FaceGeometryBinding(innerFace, new SurfaceGeometryId(2), IsAlignedWithSurface: false));
        bindings.AddFaceBinding(new FaceGeometryBinding(outerBottomFace, new SurfaceGeometryId(3)));
        bindings.AddFaceBinding(new FaceGeometryBinding(innerBottomFace, new SurfaceGeometryId(4)));
        bindings.AddFaceBinding(new FaceGeometryBinding(rimFace, new SurfaceGeometryId(5)));
        if (blended)
        {
            bindings.AddFaceBinding(new FaceGeometryBinding(outerBlendFace, new SurfaceGeometryId(6)));
            bindings.AddFaceBinding(new FaceGeometryBinding(innerBlendFace, new SurfaceGeometryId(7), IsAlignedWithSurface: false));
        }
        Role(outerFace, outerEnvelope.Id, FaceBoundaryRole.Outer);
        Role(innerFace, innerEnvelope.Id, FaceBoundaryRole.Outer);
        foreach (var h in holes)
        {
            Role(outerFace, h.Outer.Id, FaceBoundaryRole.Inner);
            Role(innerFace, h.Inner.Id, FaceBoundaryRole.Inner);
            Bind(h.Outer.Coedges[0], outerFace, 1, PcurveGeometry.Polynomial(second, h.OuterUv.Host));
            Bind(h.Outer.Coedges[1], outerFace, 1, PcurveGeometry.Polynomial(first, h.OuterUv.Host));
            Bind(h.Inner.Coedges[0], innerFace, 2, PcurveGeometry.Polynomial(first, h.InnerUv.Host));
            Bind(h.Inner.Coedges[1], innerFace, 2, PcurveGeometry.Polynomial(second, h.InnerUv.Host));
        }
        Role(outerBottomFace, bottomOutside.Id, FaceBoundaryRole.Outer);
        Role(innerBottomFace, bottomInside.Id, FaceBoundaryRole.Outer);
        Role(rimFace, rimOuter.Id, FaceBoundaryRole.Outer); Role(rimFace, rimInner.Id, FaceBoundaryRole.Inner);
        if (blended)
        {
            Role(outerBlendFace, outerBlendFloor.Id, FaceBoundaryRole.Outer);
            Role(outerBlendFace, outerBlendWall.Id, FaceBoundaryRole.Inner);
            Role(innerBlendFace, innerBlendFloor.Id, FaceBoundaryRole.Outer);
            Role(innerBlendFace, innerBlendWall.Id, FaceBoundaryRole.Inner);
        }
        // The seam is walked up one side of the envelope and down the other: up at u = 2π on the outer wall, whose
        // loop runs +u along its bottom, and up at u = 0 on the inner wall, whose loop runs +u along its top.
        void HostEnvelope((LoopId Id, CoedgeId[] Coedges) loop, FaceId face, int surface, double startZ, double originZ, bool upAtEnd)
        {
            var length = height - startZ; var uvStart = startZ - originZ; var uvEnd = height - originZ;
            var (up, down) = upAtEnd ? (2 * System.Math.PI, 0d) : (0d, 2 * System.Math.PI);
            Bind(loop.Coedges[0], face, surface, PcurveGeometry.Line(new(0, length), new(up, uvStart), new(up, uvEnd)));
            Bind(loop.Coedges[1], face, surface, PcurveGeometry.Line(full, new(0, uvEnd), new(2 * System.Math.PI, uvEnd)));
            Bind(loop.Coedges[2], face, surface, PcurveGeometry.Line(new(0, length), new(down, uvStart), new(down, uvEnd)));
            Bind(loop.Coedges[3], face, surface, PcurveGeometry.Line(full, new(0, uvStart), new(2 * System.Math.PI, uvStart)));
        }
        HostEnvelope(outerEnvelope, outerFace, 1, wallStart, 0, upAtEnd: true);
        HostEnvelope(innerEnvelope, innerFace, 2, blended ? wallStart : thickness, thickness, upAtEnd: false);
        Bind(bottomOutside.Coedges[0], outerBottomFace, 3, PcurveGeometry.Circle(full, new(0, 0), floorRadius, -floorRadius));
        Bind(bottomInside.Coedges[0], innerBottomFace, 4, PcurveGeometry.Circle(full, new(0, 0), blended ? floorRadius : innerRadius, blended ? floorRadius : innerRadius));
        Bind(rimOuter.Coedges[0], rimFace, 5, PcurveGeometry.Circle(full, new(0, 0), radius, radius));
        Bind(rimInner.Coedges[0], rimFace, 5, PcurveGeometry.Circle(full, new(0, 0), innerRadius, innerRadius));
        if (blended)
        {
            void TorusCircle((LoopId Id, CoedgeId[] Coedges) loop, FaceId face, int surface, double minorAngle) =>
                Bind(loop.Coedges[0], face, surface, PcurveGeometry.Line(full,
                    new(0, minorAngle), new(2 * System.Math.PI, minorAngle)));
            TorusCircle(outerBlendFloor, outerBlendFace, 6, -System.Math.PI / 2);
            TorusCircle(outerBlendWall, outerBlendFace, 6, 0);
            TorusCircle(innerBlendFloor, innerBlendFace, 7, -System.Math.PI / 2);
            TorusCircle(innerBlendWall, innerBlendFace, 7, 0);
        }
        var body = new BrepBody(builder.Model, geometry, bindings, points);
        var bindingValidation = BrepBindingValidator.Validate(body, requireAllEdgeAndFaceBindings: true);
        if (!bindingValidation.IsSuccess) return KernelResult<HollowRadialCutPatternResult>.Failure(bindingValidation.Diagnostics);
        var pcurveValidation = BrepPcurveValidator.Validate(body, tol.Linear, requireEveryCoedge: true, samples: 129);
        if (!pcurveValidation.IsValid) return Reject("Brep.HollowRadialCutPattern.PcurveValidation", string.Join("; ", pcurveValidation.Diagnostics));
        var preflight = BrepExportPreflight.Validate(body);
        if (!preflight.IsValid) return Reject("Brep.HollowRadialCutPattern.Preflight", string.Join("; ", preflight.Diagnostics.Where(d => d.Severity == BrepExportPreflightSeverity.Error).Select(d => $"{d.Code}: {d.Message}")));
        return KernelResult<HollowRadialCutPatternResult>.Success(new(body,
            new HollowRadialCutTopologyMap(faceNames, loopNames, edgeNames), certificates, seamAngle));
    }

    private sealed record OpeningTemplate(double Angle, double Z, QualifiedCylinderIntersectionPcurves Outer, QualifiedCylinderIntersectionPcurves Inner);

    /// <summary>
    /// Moves a realized opening curve and its pcurves to another congruent opening on the same host: the 3D curve
    /// rotates about +Z by <paramref name="angle"/> and shifts by <paramref name="dz"/>; the host pcurve shifts in
    /// (u, v) by the exact authority's own offset; the cutter pcurve lives in the cutter's frame and is unchanged.
    /// Rigid motion preserves every analytic bound; the numerical allowance grows by the transform's round-off.
    /// Returns null when the exact authorities disagree with that model, so the caller realizes the instance itself.
    /// </summary>
    private static QualifiedCylinderIntersectionPcurves? Place(QualifiedCylinderIntersectionPcurves template,
        CylinderCylinderIntersectionCurve authority, double angle, double dz)
    {
        var source = template.Edge.Authority;
        var probes = new[] { source.Domain.Start, (source.Domain.Start + source.Domain.End) / 2, source.Domain.End };
        var (cos, sin) = (System.Math.Cos(angle), System.Math.Sin(angle));
        Point3D Move(Point3D p) => new(p.X * cos - p.Y * sin, p.X * sin + p.Y * cos, p.Z + dz);
        var hostShift = authority.EvaluateHostPcurve(probes[0]);
        var hostOrigin = source.EvaluateHostPcurve(probes[0]);
        var (du, dv) = (hostShift.U - hostOrigin.U, hostShift.V - hostOrigin.V);
        foreach (var t in probes)
        {
            var exact = authority.Evaluate(t); var moved = Move(source.Evaluate(t));
            var host = authority.EvaluateHostPcurve(t); var sourceHost = source.EvaluateHostPcurve(t);
            var tool = authority.EvaluateToolPcurve(t); var sourceTool = source.EvaluateToolPcurve(t);
            if ((exact - moved).Length > 1e-9 || System.Math.Abs(host.U - sourceHost.U - du) > 1e-12 || System.Math.Abs(host.V - sourceHost.V - dv) > 1e-9
                || System.Math.Abs(tool.U - sourceTool.U) > 1e-12 || System.Math.Abs(tool.V - sourceTool.V) > 1e-9) return null;
        }

        static BSpline3Curve Map(BSpline3Curve curve, Func<Point3D, Point3D> map) => new(curve.Degree, curve.ControlPoints.Select(map).ToArray(),
            curve.KnotMultiplicities, curve.KnotValues, curve.CurveForm, curve.ClosedCurve, curve.SelfIntersect, curve.KnotSpec);
        var scale = template.Edge.Curve.ControlPoints.Max(p => System.Math.Abs(p.X) + System.Math.Abs(p.Y) + System.Math.Abs(p.Z)) + System.Math.Abs(dz);
        var roundOff = 8 * 2.2204460492503131e-16 * scale;
        var edge = template.Edge with { Authority = authority, Curve = Map(template.Edge.Curve, Move), NumericalAllowanceMm = template.Edge.NumericalAllowanceMm + roundOff };
        return template with
        {
            Edge = edge,
            Host = Map(template.Host, p => new Point3D(p.X + du, p.Y + dv, p.Z)),
            NumericalAllowanceMm = template.NumericalAllowanceMm + roundOff
        };
    }

    private static double Normalize(double value) { value %= 2 * System.Math.PI; return value < 0 ? value + 2 * System.Math.PI : value; }
    private static double AngularDistance(double a, double b) { var d = System.Math.Abs(a - b); return System.Math.Min(d, 2 * System.Math.PI - d); }
    private static KernelResult<HollowRadialCutPatternResult> InstanceFailure(HollowRadialCutPlacement placement,
        IReadOnlyList<KernelDiagnostic> diagnostics) => KernelResult<HollowRadialCutPatternResult>.Failure(
            diagnostics.Select(d => d with { Message = $"{placement.StableId}: {d.Message}" }).ToArray());
    private static (LoopId Id, CoedgeId[] Coedges) AddLoop(TopologyBuilder builder, IReadOnlyList<Use> uses)
    {
        var loop = builder.AllocateLoopId();
        var coedges = uses.Select(_ => builder.AllocateCoedgeId()).ToArray();
        for (var i = 0; i < uses.Count; i++)
            builder.AddCoedge(new Coedge(coedges[i], uses[i].Edge, loop,
                coedges[(i + 1) % uses.Count], coedges[(i + uses.Count - 1) % uses.Count], uses[i].Reversed));
        builder.AddLoop(new Loop(loop, coedges));
        return (loop, coedges);
    }
    private sealed record Hole((LoopId Id, CoedgeId[] Coedges) Outer, (LoopId Id, CoedgeId[] Coedges) Inner,
        FaceId WallFace, QualifiedCylinderIntersectionPcurves OuterUv, QualifiedCylinderIntersectionPcurves InnerUv);
    private readonly record struct Use(EdgeId Edge, bool Reversed = false);
}