Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

CIR-F10.7 emit planar rectangle with one inner circle

Yuechen Li27ebcc1e4cfd
diff --git a/Aetheris.Kernel.Firmament.Tests/SurfacePatchDescriptorScaffoldTests.cs b/Aetheris.Kernel.Firmament.Tests/SurfacePatchDescriptorScaffoldTests.cs
index d7f20d6a..e8a5f346 100644
--- a/Aetheris.Kernel.Firmament.Tests/SurfacePatchDescriptorScaffoldTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/SurfacePatchDescriptorScaffoldTests.cs
@@ -137,10 +137,10 @@ public sealed class SurfacePatchDescriptorScaffoldTests
var policy = PlanarSurfaceMaterializer.GetLoopEmissionPolicy();
Assert.True(policy.SupportsOuterRectangle);
Assert.True(policy.SupportsOuterCircle);
- Assert.False(policy.SupportsInnerCircle);
+ Assert.True(policy.SupportsInnerCircle);
Assert.False(policy.SupportsMultipleInnerLoops);
- Assert.Equal(PlanarSurfaceMaterializer.PlanarLoopSupportStatus.Deferred, policy.Status);
- Assert.Contains("inner circular loop emission deferred", policy.Diagnostic, StringComparison.OrdinalIgnoreCase);
+ Assert.Equal(PlanarSurfaceMaterializer.PlanarLoopSupportStatus.Supported, policy.Status);
+ Assert.Contains("supports one rectangular outer loop plus one canonical retained inner circular loop", policy.Diagnostic, StringComparison.OrdinalIgnoreCase);
}
[Fact]
@@ -152,10 +152,9 @@ public sealed class SurfacePatchDescriptorScaffoldTests
var readiness = new MaterializationReadinessReport(true, EmissionReadiness.EvidenceReadyForEmission, [], [], 1, 1, 1, 0, 0, 0, 0, [], false);
var result = new PlanarSurfaceMaterializer().Emit(patch, readiness);
-
Assert.False(result.Success);
Assert.Null(result.Body);
- Assert.Contains(result.Diagnostics, d => d.Contains("inner circular loop emission deferred", StringComparison.OrdinalIgnoreCase));
+ Assert.Contains(result.Diagnostics, d => d.Contains("bounded rectangle-with-inner-circle emission path", StringComparison.OrdinalIgnoreCase));
}
[Fact]
@@ -174,6 +173,65 @@ public sealed class SurfacePatchDescriptorScaffoldTests
Assert.Contains(result.Diagnostics, d => d.Contains("multiple inner loops", StringComparison.OrdinalIgnoreCase));
}
+ [Fact]
+ public void PlanarSurfaceMaterializer_RectangleWithInnerCircle_FromRealBoxCylinderEvidence_EmitsTrimmedFace()
+ {
+ var root = new CirSubtractNode(new CirBoxNode(10, 10, 10), new CirCylinderNode(2, 8));
+ var generation = FacePatchCandidateGenerator.Generate(root);
+ var candidate = generation.Candidates.First(c =>
+ c.RetentionRole == FacePatchRetentionRole.BaseBoundaryRetainedOutsideTool
+ && c.SourceSurface.BoundedPlanarGeometry is { Kind: BoundedPlanarPatchGeometryKind.Rectangle }
+ && c.RetainedRegionLoops.Count(l => l.LoopKind == RetainedRegionLoopKind.InnerTrim && l.CircularGeometry is not null) == 1);
+ var inner = candidate.RetainedRegionLoops.Single(l => l.LoopKind == RetainedRegionLoopKind.InnerTrim && l.CircularGeometry is not null).CircularGeometry!.Value;
+ var readiness = new MaterializationReadinessReport(true, EmissionReadiness.EvidenceReadyForEmission, [], [], 1, 1, 1, 0, 0, 0, 0, [], false);
+
+ var result = new PlanarSurfaceMaterializer().EmitRectangleWithInnerCircle(new(candidate.SourceSurface, inner, null, readiness));
+ Assert.True(result.Success);
+ Assert.NotNull(result.Body);
+ Assert.Single(result.Body!.Topology.Faces);
+ Assert.Equal(2, result.Body.Topology.Loops.Count());
+ Assert.Equal(5, result.Body.Topology.Edges.Count());
+ var face = result.Body.Topology.Faces.Single();
+ Assert.Equal(2, face.LoopIds.Count);
+ var edgeBinding = result.Body.Bindings.EdgeBindings.Single(b => b.TrimInterval?.End == 2d * double.Pi);
+ Assert.True(result.Body.Geometry.TryGetCurve(edgeBinding.CurveGeometryId, out var curve));
+ Assert.Equal(CurveGeometryKind.Circle3, curve!.Kind);
+ Assert.Contains(result.Diagnostics, d => d.Contains("inner loop", StringComparison.OrdinalIgnoreCase));
+ }
+
+ [Fact]
+ public void PlanarSurfaceMaterializer_RectangleWithInnerCircle_RejectsDeferredReadiness()
+ {
+ var source = SourceSurfaceExtractor.Extract(new CirBoxNode(10, 10, 10)).Descriptors.First(d => d.BoundedPlanarGeometry?.Kind == BoundedPlanarPatchGeometryKind.Rectangle);
+ var circle = new RetainedCircularLoopGeometry(new Point3D(0, 0, 0), new Vector3D(0, 0, 1), 1d, RetainedRegionLoopOrientationPolicy.ReverseForToolCavity, "token", "diag");
+ var readiness = new MaterializationReadinessReport(true, EmissionReadiness.Deferred, [EmissionBlockingReason.TopologyPlanning], [], 1, 1, 1, 0, 0, 0, 0, [], false);
+ var result = new PlanarSurfaceMaterializer().EmitRectangleWithInnerCircle(new(source, circle, null, readiness));
+ Assert.False(result.Success);
+ Assert.Contains(result.Diagnostics, d => d.Contains("no readiness, no emission", StringComparison.OrdinalIgnoreCase));
+ }
+
+ [Fact]
+ public void PlanarSurfaceMaterializer_RectangleWithInnerCircle_RejectsMissingInnerCircleGeometry()
+ {
+ var source = SourceSurfaceExtractor.Extract(new CirBoxNode(10, 10, 10)).Descriptors.First(d => d.BoundedPlanarGeometry?.Kind == BoundedPlanarPatchGeometryKind.Rectangle);
+ var readiness = new MaterializationReadinessReport(true, EmissionReadiness.EvidenceReadyForEmission, [], [], 1, 1, 1, 0, 0, 0, 0, [], false);
+ var result = new PlanarSurfaceMaterializer().EmitRectangleWithInnerCircle(new(source, null, null, readiness));
+ Assert.False(result.Success);
+ Assert.Contains(result.Diagnostics, d => d.Contains("inner-circle-missing", StringComparison.OrdinalIgnoreCase));
+ }
+
+ [Fact]
+ public void PlanarSurfaceMaterializer_RectangleWithInnerCircle_RejectsMultipleInnerLoops()
+ {
+ var source = SourceSurfaceExtractor.Extract(new CirBoxNode(10, 10, 10)).Descriptors.First(d => d.BoundedPlanarGeometry?.Kind == BoundedPlanarPatchGeometryKind.Rectangle);
+ var circleA = new RetainedCircularLoopGeometry(new Point3D(0, 0, 0), new Vector3D(0, 0, 1), 1d, RetainedRegionLoopOrientationPolicy.ReverseForToolCavity, "a", "diag");
+ var circleB = new RetainedCircularLoopGeometry(new Point3D(1, 0, 0), new Vector3D(0, 0, 1), 1d, RetainedRegionLoopOrientationPolicy.ReverseForToolCavity, "b", "diag");
+ var readiness = new MaterializationReadinessReport(true, EmissionReadiness.EvidenceReadyForEmission, [], [], 1, 1, 1, 0, 0, 0, 0, [], false);
+ var result = new PlanarSurfaceMaterializer().EmitRectangleWithInnerCircle(new(source, null, [circleA, circleB], readiness));
+ Assert.False(result.Success);
+ Assert.Contains(result.Diagnostics, d => d.Contains("multiple inner loops", StringComparison.OrdinalIgnoreCase));
+ }
+
[Fact]
public void PlanarPayloadBuilder_RejectsNonPlanarSource()
{
diff --git a/Aetheris.Kernel.Firmament/Execution/SurfacePatchDescriptorScaffold.cs b/Aetheris.Kernel.Firmament/Execution/SurfacePatchDescriptorScaffold.cs
index 4ec7be2c..7cd2425f 100644
--- a/Aetheris.Kernel.Firmament/Execution/SurfacePatchDescriptorScaffold.cs
+++ b/Aetheris.Kernel.Firmament/Execution/SurfacePatchDescriptorScaffold.cs
@@ -188,11 +188,17 @@ internal sealed class PlanarSurfaceMaterializer : ISurfaceFamilyMaterializer
=> new(
SupportsOuterRectangle: true,
SupportsOuterCircle: true,
- SupportsInnerCircle: false,
+ SupportsInnerCircle: true,
SupportsMultipleInnerLoops: false,
- InnerLoopOrientation: InnerLoopOrientationPolicy.Deferred,
- Status: PlanarLoopSupportStatus.Deferred,
- Diagnostic: "PlanarSurfaceMaterializer inner circular loop emission deferred: trim-loop geometry descriptors do not yet carry canonical circle/topology bindings for safe inner-loop BRep emission.");
+ InnerLoopOrientation: InnerLoopOrientationPolicy.FollowFaceBoundConvention,
+ Status: PlanarLoopSupportStatus.Supported,
+ Diagnostic: "PlanarSurfaceMaterializer supports one rectangular outer loop plus one canonical retained inner circular loop.");
+
+ internal sealed record RectWithInnerCircleEmissionRequest(
+ SourceSurfaceDescriptor Source,
+ RetainedCircularLoopGeometry? InnerCircle,
+ IReadOnlyList<RetainedCircularLoopGeometry>? InnerCircles,
+ MaterializationReadinessReport Readiness);
public SurfaceMaterializerAdmissibility Evaluate(FacePatchDescriptor patch)
{
@@ -228,12 +234,7 @@ internal sealed class PlanarSurfaceMaterializer : ISurfaceFamilyMaterializer
]);
}
- var policy = GetLoopEmissionPolicy();
- return new(false, null, SurfacePatchFamily.Planar, false,
- [
- "planar-trimmed-loop-rejected: one outer loop + one inner circular loop requested.",
- policy.Diagnostic
- ]);
+ return new(false, null, SurfacePatchFamily.Planar, false, ["planar-trimmed-loop-rejected: use bounded rectangle-with-inner-circle emission path requiring canonical retained circular loop geometry evidence."]);
}
if (patch.OuterLoop.Count > 0)
@@ -257,6 +258,69 @@ internal sealed class PlanarSurfaceMaterializer : ISurfaceFamilyMaterializer
return EmitRectangleBody(points!);
}
+ internal SurfaceMaterializationResult EmitRectangleWithInnerCircle(RectWithInnerCircleEmissionRequest request)
+ {
+ if (request.Readiness.OverallReadiness is EmissionReadiness.NotApplicable or EmissionReadiness.Deferred or EmissionReadiness.Unsupported)
+ {
+ return new(false, null, SurfacePatchFamily.Planar, false, ["readiness-gate-rejected: no readiness, no emission."]);
+ }
+
+ if (request.Source.BoundedPlanarGeometry is not { Kind: BoundedPlanarPatchGeometryKind.Rectangle } outer)
+ {
+ return new(false, null, SurfacePatchFamily.Planar, false, ["outer-rectangle-missing: bounded planar rectangle geometry is required."]);
+ }
+
+ var circles = request.InnerCircles ?? (request.InnerCircle is { } one ? [one] : []);
+ if (circles.Count == 0) return new(false, null, SurfacePatchFamily.Planar, false, ["inner-circle-missing: canonical retained circular loop geometry evidence is required."]);
+ if (circles.Count > 1) return new(false, null, SurfacePatchFamily.Planar, false, ["inner-circle-unsupported: multiple inner loops are unsupported in CIR-F10.7."]);
+
+ return EmitRectangleWithInnerCircleBody(outer, circles[0]);
+ }
+
+ private static SurfaceMaterializationResult EmitRectangleWithInnerCircleBody(BoundedPlanarPatchGeometry rect, RetainedCircularLoopGeometry inner)
+ {
+ var p = new[] { rect.Corner00, rect.Corner10, rect.Corner11, rect.Corner01 };
+ var builder = new TopologyBuilder();
+ var v = new[] { builder.AddVertex(), builder.AddVertex(), builder.AddVertex(), builder.AddVertex(), builder.AddVertex() };
+ var e = new[] { builder.AddEdge(v[0], v[1]), builder.AddEdge(v[1], v[2]), builder.AddEdge(v[2], v[3]), builder.AddEdge(v[3], v[0]), builder.AddEdge(v[4], v[4]) };
+
+ var outerLoopId = builder.AllocateLoopId();
+ var outerCoedgeIds = new[] { builder.AllocateCoedgeId(), builder.AllocateCoedgeId(), builder.AllocateCoedgeId(), builder.AllocateCoedgeId() };
+ for (var i = 0; i < 4; i++) builder.AddCoedge(new Coedge(outerCoedgeIds[i], e[i], outerLoopId, outerCoedgeIds[(i + 1) % 4], outerCoedgeIds[(i + 3) % 4], IsReversed: false));
+ builder.AddLoop(new Loop(outerLoopId, outerCoedgeIds));
+
+ var innerLoopId = builder.AllocateLoopId();
+ var innerCoedgeId = builder.AllocateCoedgeId();
+ builder.AddCoedge(new Coedge(innerCoedgeId, e[4], innerLoopId, innerCoedgeId, innerCoedgeId, IsReversed: true));
+ builder.AddLoop(new Loop(innerLoopId, [innerCoedgeId]));
+
+ var face = builder.AddFace([outerLoopId, innerLoopId]);
+ var shell = builder.AddShell([face]);
+ builder.AddBody([shell]);
+
+ var normal = Direction3D.Create(rect.Normal);
+ var xAxis = Direction3D.Create(p[1] - p[0]);
+ var geometry = new BrepGeometryStore();
+ geometry.AddCurve(new CurveGeometryId(1), CurveGeometry.FromLine(new Line3Curve(p[0], Direction3D.Create(p[1] - p[0]))));
+ geometry.AddCurve(new CurveGeometryId(2), CurveGeometry.FromLine(new Line3Curve(p[1], Direction3D.Create(p[2] - p[1]))));
+ geometry.AddCurve(new CurveGeometryId(3), CurveGeometry.FromLine(new Line3Curve(p[2], Direction3D.Create(p[3] - p[2]))));
+ geometry.AddCurve(new CurveGeometryId(4), CurveGeometry.FromLine(new Line3Curve(p[3], Direction3D.Create(p[0] - p[3]))));
+ geometry.AddCurve(new CurveGeometryId(5), CurveGeometry.FromCircle(new Circle3Curve(inner.Center, Direction3D.Create(inner.Normal), inner.Radius, BuildReferenceAxis(Direction3D.Create(inner.Normal)))));
+ geometry.AddSurface(new SurfaceGeometryId(1), SurfaceGeometry.FromPlane(new PlaneSurface(p[0], normal, xAxis)));
+
+ var bindings = new BrepBindingModel();
+ for (var i = 0; i < 4; i++) bindings.AddEdgeBinding(new EdgeGeometryBinding(e[i], new CurveGeometryId(i + 1), new ParameterInterval(0d, 1d)));
+ bindings.AddEdgeBinding(new EdgeGeometryBinding(e[4], new CurveGeometryId(5), new ParameterInterval(0d, 2d * double.Pi)));
+ bindings.AddFaceBinding(new FaceGeometryBinding(face, new SurfaceGeometryId(1)));
+ return new(true, new BrepBody(builder.Model, geometry, bindings), SurfacePatchFamily.Planar, true,
+ [
+ "inner-loop-emitted: one circular inner loop emitted from canonical retained loop geometry.",
+ "orientation-policy-applied: inner loop coedge orientation follows face-bound convention for cavity loops.",
+ "topology-emitted: planar trimmed face emitted as one face with outer rectangle then inner circle.",
+ "scope-note: full shell/solid assembly not attempted."
+ ]);
+ }
+
private static SurfaceMaterializationResult EmitRectangleBody(IReadOnlyList<Point3D> p)
{
var builder = new TopologyBuilder();
diff --git a/docs/cir-f107-planar-one-inner-circle-emission.md b/docs/cir-f107-planar-one-inner-circle-emission.md
new file mode 100644
index 00000000..f93d2447
--- /dev/null
+++ b/docs/cir-f107-planar-one-inner-circle-emission.md
@@ -0,0 +1,49 @@
+# CIR-F10.7: bounded planar one-inner-circle emission
+
+CIR-F10.7 adds a tightly-scoped planar trimmed-face emission path in `PlanarSurfaceMaterializer`:
+
+- supported shape: one planar face with outer rectangle + one inner circle,
+- evidence source: canonical `RetainedCircularLoopGeometry` from real dry-run (`Subtract(Box,Cylinder)`),
+- readiness gate: `No readiness, no emission` (deferred/unsupported readiness rejects).
+
+## Supported/required evidence
+
+`EmitRectangleWithInnerCircle(...)` requires:
+
+1. planar source with `BoundedPlanarPatchGeometryKind.Rectangle`,
+2. exactly one canonical retained inner-circle geometry,
+3. readiness not deferred/unsupported.
+
+If any is missing, emission is rejected with specific diagnostics.
+
+## Topology convention
+
+- one face,
+- two loops in order: outer loop first, inner loop second,
+- outer loop = four line edges,
+- inner loop = one circular self-edge,
+- inner coedge orientation is explicitly set for cavity convention,
+- face is bound to one plane surface, and the inner edge is bound to circle geometry.
+
+## Explicit rejections
+
+- multiple inner loops,
+- missing canonical circular loop geometry,
+- missing bounded rectangle,
+- deferred/unsupported readiness,
+- non-circular inner loops,
+- circular outer + inner annulus.
+
+## Scope boundaries
+
+This milestone does **not** implement:
+
+- full box-cylinder body materialization,
+- cylindrical side emission,
+- shell closure/solid completion,
+- multi-hole emission,
+- STEP export behavior changes,
+- public CLI exposure,
+- generated topology names.
+
+SEM-A0 guardrails remain: no generated topology naming/provenance expansion.