Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
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);
}