Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
Implement bounded E2 single-corner chamfer via judgment engine
Yuechen Liaa8af131a601
diff --git a/Aetheris.Kernel.Core.Tests/Brep/EdgeFinishing/BrepBoundedChamferCornerJudgmentTests.cs b/Aetheris.Kernel.Core.Tests/Brep/EdgeFinishing/BrepBoundedChamferCornerJudgmentTests.csnew file mode 100644index 00000000..66536e83--- /dev/null+++ b/Aetheris.Kernel.Core.Tests/Brep/EdgeFinishing/BrepBoundedChamferCornerJudgmentTests.cs@@ -0,0 +1,20 @@+using Aetheris.Kernel.Core.Brep.Boolean;+using Aetheris.Kernel.Core.Brep.EdgeFinishing;++namespace Aetheris.Kernel.Core.Tests.Brep.EdgeFinishing;++public sealed class BrepBoundedChamferCornerJudgmentTests+{+ [Fact]+ public void ChamferAxisAlignedBoxSingleCorner_Reports_Judgment_Rejection_Reasons_When_No_Geometry_Candidate_Is_Admissible()+ {+ var box = new AxisAlignedBoxExtents(0d, 10d, 0d, 10d, 0d, 1d);+ var result = BrepBoundedChamfer.ChamferAxisAlignedBoxSingleCorner(+ box,+ BrepBoundedChamferCorner.XMaxYMaxZMax,+ distance: 2d);++ Assert.False(result.IsSuccess);+ Assert.Contains(result.Diagnostics, diagnostic => diagnostic.Message.Contains("No bounded corner-resolution candidate was admissible", StringComparison.Ordinal));+ }+}diff --git a/Aetheris.Kernel.Core.Tests/Brep/Features/BrepBoundedChamferTests.cs b/Aetheris.Kernel.Core.Tests/Brep/Features/BrepBoundedChamferTests.csindex 9ad055d6..5ee74186 100644--- a/Aetheris.Kernel.Core.Tests/Brep/Features/BrepBoundedChamferTests.cs+++ b/Aetheris.Kernel.Core.Tests/Brep/Features/BrepBoundedChamferTests.cs@@ -33,4 +33,26 @@ public sealed class BrepBoundedChamferTestsAssert.False(result.IsSuccess);Assert.Contains(result.Diagnostics, diagnostic => diagnostic.Message.Contains("too large", StringComparison.Ordinal));}++ [Fact]+ public void ChamferAxisAlignedBoxSingleCorner_Succeeds_ForBoundedCanonicalCorner()+ {+ var box = new AxisAlignedBoxExtents(0d, 40d, 0d, 20d, 0d, 10d);+ var result = BrepBoundedChamfer.ChamferAxisAlignedBoxSingleCorner(box, BrepBoundedChamferCorner.XMaxYMaxZMax, 1.5d);++ Assert.True(result.IsSuccess);+ Assert.Equal(7, result.Value.Topology.Faces.Count());+ Assert.Equal(15, result.Value.Topology.Edges.Count());+ Assert.Equal(10, result.Value.Topology.Vertices.Count());+ }++ [Fact]+ public void ChamferAxisAlignedBoxSingleCorner_Rejects_Distance_Outside_Local_Bounds()+ {+ var box = new AxisAlignedBoxExtents(0d, 8d, 0d, 5d, 0d, 4d);+ var result = BrepBoundedChamfer.ChamferAxisAlignedBoxSingleCorner(box, BrepBoundedChamferCorner.XMaxYMaxZMax, 4d);++ Assert.False(result.IsSuccess);+ Assert.Contains(result.Diagnostics, diagnostic => diagnostic.Message.Contains("rejected", StringComparison.Ordinal));+ }}diff --git a/Aetheris.Kernel.Core/Brep/EdgeFinishing/BrepBoundedChamfer.cs b/Aetheris.Kernel.Core/Brep/EdgeFinishing/BrepBoundedChamfer.csindex 0577a8b0..bb26b497 100644--- a/Aetheris.Kernel.Core/Brep/EdgeFinishing/BrepBoundedChamfer.cs+++ b/Aetheris.Kernel.Core/Brep/EdgeFinishing/BrepBoundedChamfer.cs@@ -1,8 +1,12 @@using Aetheris.Kernel.Core.Brep.Boolean;using Aetheris.Kernel.Core.Brep.Features;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.Results;+using Aetheris.Kernel.Core.Topology;namespace Aetheris.Kernel.Core.Brep.EdgeFinishing;@@ -12,6 +16,45 @@ namespace Aetheris.Kernel.Core.Brep.EdgeFinishing;/// </summary>public static class BrepBoundedChamfer{+ public static KernelResult<BrepBody> ChamferAxisAlignedBoxSingleCorner(+ AxisAlignedBoxExtents box,+ BrepBoundedChamferCorner corner,+ double distance)+ {+ var contextResult = BrepBoundedChamferCornerContext.TryCreate(box, corner, distance);+ if (!contextResult.IsSuccess)+ {+ return KernelResult<BrepBody>.Failure(contextResult.Diagnostics);+ }++ var context = contextResult.Value;+ var engine = new JudgmentEngine<BrepBoundedChamferCornerContext>();+ var candidates = BuildCornerCandidates();+ var judgment = engine.Evaluate(context, candidates);+ if (!judgment.IsSuccess || !judgment.Selection.HasValue)+ {+ var reason = judgment.Rejections.Count == 0+ ? "No bounded corner-resolution candidate was admissible."+ : string.Join(" ", judgment.Rejections.Select(rejection => $"{rejection.CandidateName}: {rejection.Reason}."));+ return KernelResult<BrepBody>.Failure([Failure($"Bounded chamfer corner resolution rejected: {reason}", "firmament.chamfer-bounded")]);+ }++ var selected = judgment.Selection.Value.Candidate.Name;+ if (selected == "reject")+ {+ var reason = judgment.Rejections.Count == 0+ ? "No bounded corner-resolution candidate was admissible."+ : string.Join(" ", judgment.Rejections.Select(rejection => $"{rejection.CandidateName}: {rejection.Reason}."));+ return KernelResult<BrepBody>.Failure([Failure($"Bounded chamfer corner resolution rejected: {reason}", "firmament.chamfer-bounded")]);+ }++ return selected switch+ {+ "planar-tri-corner-cut" => CreateSingleCornerPlanarChamferBody(context),+ _ => KernelResult<BrepBody>.Failure([Failure($"Bounded chamfer corner resolution selected unsupported candidate '{selected}'.", "firmament.chamfer-bounded")])+ };+ }+public static KernelResult<BrepBody> ChamferAxisAlignedBoxVerticalEdge(AxisAlignedBoxExtents box,BrepBoundedChamferEdge edge,@@ -100,6 +143,232 @@ public static class BrepBoundedChamferprivate static KernelDiagnostic Failure(string message, string source)=> new(KernelDiagnosticCode.ValidationFailed, KernelDiagnosticSeverity.Error, message, Source: source);++ private static IReadOnlyList<JudgmentCandidate<BrepBoundedChamferCornerContext>> BuildCornerCandidates()+ {+ var canonicalCornerGuard = When.All<BrepBoundedChamferCornerContext>(+ context => context.IsTrustedOrthogonalBody,+ context => context.ParticipatingEdgeCount == 3,+ context => context.IsConvexCorner,+ context => context.AllFacesPlanar,+ context => context.AllAdjacentFacesOrthogonal,+ context => context.AreChamferDistancesEqual,+ context => context.IsDistanceWithinLocalBounds,+ context => context.Corner == BrepBoundedChamferCorner.XMaxYMaxZMax);+ return+ [+ new JudgmentCandidate<BrepBoundedChamferCornerContext>(+ Name: "planar-tri-corner-cut",+ IsAdmissible: canonicalCornerGuard,+ Score: _ => 100d,+ RejectionReason: _ => "requires a trusted orthogonal 3-edge convex planar 90-degree corner with equal bounded distance at x_max_y_max_z_max",+ TieBreakerPriority: 0),+ new JudgmentCandidate<BrepBoundedChamferCornerContext>(+ Name: "reject",+ IsAdmissible: _ => true,+ Score: _ => 0d,+ RejectionReason: _ => "fallback reject candidate",+ TieBreakerPriority: 99)+ ];+ }++ private static KernelResult<BrepBody> CreateSingleCornerPlanarChamferBody(BrepBoundedChamferCornerContext context)+ {+ var box = context.Box;+ var d = context.Distance;+ var builder = new TopologyBuilder();++ var v000 = builder.AddVertex();+ var v100 = builder.AddVertex();+ var v110 = builder.AddVertex();+ var v010 = builder.AddVertex();+ var v001 = builder.AddVertex();+ var v101 = builder.AddVertex();+ var v011 = builder.AddVertex();+ var vX = builder.AddVertex();+ var vY = builder.AddVertex();+ var vZ = builder.AddVertex();++ var p000 = new Point3D(box.MinX, box.MinY, box.MinZ);+ var p100 = new Point3D(box.MaxX, box.MinY, box.MinZ);+ var p110 = new Point3D(box.MaxX, box.MaxY, box.MinZ);+ var p010 = new Point3D(box.MinX, box.MaxY, box.MinZ);+ var p001 = new Point3D(box.MinX, box.MinY, box.MaxZ);+ var p101 = new Point3D(box.MaxX, box.MinY, box.MaxZ);+ var p011 = new Point3D(box.MinX, box.MaxY, box.MaxZ);+ var pX = new Point3D(box.MaxX - d, box.MaxY, box.MaxZ);+ var pY = new Point3D(box.MaxX, box.MaxY - d, box.MaxZ);+ var pZ = new Point3D(box.MaxX, box.MaxY, box.MaxZ - d);++ var e000100 = builder.AddEdge(v000, v100);+ var e100110 = builder.AddEdge(v100, v110);+ var e110010 = builder.AddEdge(v110, v010);+ var e010000 = builder.AddEdge(v010, v000);+ var e000001 = builder.AddEdge(v000, v001);+ var e100101 = builder.AddEdge(v100, v101);+ var e010011 = builder.AddEdge(v010, v011);+ var e001101 = builder.AddEdge(v001, v101);+ var e101vY = builder.AddEdge(v101, vY);+ var eYvX = builder.AddEdge(vY, vX);+ var evX011 = builder.AddEdge(vX, v011);+ var e011001 = builder.AddEdge(v011, v001);+ var e110vZ = builder.AddEdge(v110, vZ);+ var evZvY = builder.AddEdge(vZ, vY);+ var evXvZ = builder.AddEdge(vX, vZ);++ var faces = new List<FaceId>(7)+ {+ AddFaceWithLoop(builder, [EdgeUse.Forward(e000100), EdgeUse.Forward(e100110), EdgeUse.Forward(e110010), EdgeUse.Forward(e010000)]),+ AddFaceWithLoop(builder, [EdgeUse.Forward(e001101), EdgeUse.Forward(e101vY), EdgeUse.Forward(eYvX), EdgeUse.Forward(evX011), EdgeUse.Forward(e011001)]),+ AddFaceWithLoop(builder, [EdgeUse.Forward(e000001), EdgeUse.Reversed(e011001), EdgeUse.Reversed(e010011), EdgeUse.Forward(e010000)]),+ AddFaceWithLoop(builder, [EdgeUse.Forward(e000100), EdgeUse.Forward(e100101), EdgeUse.Reversed(e001101), EdgeUse.Reversed(e000001)]),+ AddFaceWithLoop(builder, [EdgeUse.Forward(e100110), EdgeUse.Forward(e110vZ), EdgeUse.Forward(evZvY), EdgeUse.Reversed(e101vY), EdgeUse.Reversed(e100101)]),+ AddFaceWithLoop(builder, [EdgeUse.Forward(e110010), EdgeUse.Forward(e010011), EdgeUse.Reversed(evX011), EdgeUse.Forward(evXvZ), EdgeUse.Reversed(e110vZ)]),+ AddFaceWithLoop(builder, [EdgeUse.Reversed(eYvX), EdgeUse.Forward(evZvY), EdgeUse.Reversed(evXvZ)])+ };++ var shell = builder.AddShell(faces);+ builder.AddBody([shell]);++ var geometry = new BrepGeometryStore();+ var bindings = new BrepBindingModel();+ var curveId = 1;+ void AddEdgeGeometry(EdgeId edgeId, Point3D start, Point3D end)+ {+ var direction = end - start;+ var cid = new CurveGeometryId(curveId++);+ geometry.AddCurve(cid, CurveGeometry.FromLine(new Line3Curve(start, Direction3D.Create(direction))));+ bindings.AddEdgeBinding(new EdgeGeometryBinding(edgeId, cid, new ParameterInterval(0d, direction.Length)));+ }++ AddEdgeGeometry(e000100, p000, p100);+ AddEdgeGeometry(e100110, p100, p110);+ AddEdgeGeometry(e110010, p110, p010);+ AddEdgeGeometry(e010000, p010, p000);+ AddEdgeGeometry(e000001, p000, p001);+ AddEdgeGeometry(e100101, p100, p101);+ AddEdgeGeometry(e010011, p010, p011);+ AddEdgeGeometry(e001101, p001, p101);+ AddEdgeGeometry(e101vY, p101, pY);+ AddEdgeGeometry(eYvX, pY, pX);+ AddEdgeGeometry(evX011, pX, p011);+ AddEdgeGeometry(e011001, p011, p001);+ AddEdgeGeometry(e110vZ, p110, pZ);+ AddEdgeGeometry(evZvY, pZ, pY);+ AddEdgeGeometry(evXvZ, pX, pZ);++ var surfaceId = 1;+ void AddFacePlane(FaceId face, Point3D origin, Vector3D normal, Vector3D uAxis)+ {+ var sid = new SurfaceGeometryId(surfaceId++);+ geometry.AddSurface(sid, SurfaceGeometry.FromPlane(new PlaneSurface(origin, Direction3D.Create(normal), Direction3D.Create(uAxis))));+ bindings.AddFaceBinding(new FaceGeometryBinding(face, sid));+ }++ AddFacePlane(faces[0], p000, new Vector3D(0d, 0d, -1d), new Vector3D(1d, 0d, 0d)); // z_min+ AddFacePlane(faces[1], p001, new Vector3D(0d, 0d, 1d), new Vector3D(1d, 0d, 0d)); // z_max clipped+ AddFacePlane(faces[2], p000, new Vector3D(-1d, 0d, 0d), new Vector3D(0d, 1d, 0d)); // x_min+ AddFacePlane(faces[3], p000, new Vector3D(0d, -1d, 0d), new Vector3D(1d, 0d, 0d)); // y_min+ AddFacePlane(faces[4], p100, new Vector3D(1d, 0d, 0d), new Vector3D(0d, 1d, 0d)); // x_max clipped+ AddFacePlane(faces[5], p010, new Vector3D(0d, 1d, 0d), new Vector3D(-1d, 0d, 0d)); // y_max clipped+ AddFacePlane(faces[6], pX, new Vector3D(1d, 1d, 1d), new Vector3D(1d, -1d, 0d)); // chamfer plane++ var vertexPoints = new Dictionary<VertexId, Point3D>+ {+ [v000] = p000,+ [v100] = p100,+ [v110] = p110,+ [v010] = p010,+ [v001] = p001,+ [v101] = p101,+ [v011] = p011,+ [vX] = pX,+ [vY] = pY,+ [vZ] = pZ+ };++ var body = new BrepBody(builder.Model, geometry, bindings, vertexPoints);+ var validation = BrepBindingValidator.Validate(body, requireAllEdgeAndFaceBindings: true);+ return validation.IsSuccess+ ? KernelResult<BrepBody>.Success(body, validation.Diagnostics)+ : KernelResult<BrepBody>.Failure(validation.Diagnostics);+ }++ private static FaceId AddFaceWithLoop(TopologyBuilder builder, IReadOnlyList<EdgeUse> edgeUses)+ {+ var loopId = builder.AllocateLoopId();+ var coedgeIds = new CoedgeId[edgeUses.Count];+ for (var i = 0; i < edgeUses.Count; i++)+ {+ coedgeIds[i] = builder.AllocateCoedgeId();+ }++ for (var i = 0; i < edgeUses.Count; i++)+ {+ var next = coedgeIds[(i + 1) % edgeUses.Count];+ var prev = coedgeIds[(i + edgeUses.Count - 1) % edgeUses.Count];+ builder.AddCoedge(new Coedge(coedgeIds[i], edgeUses[i].EdgeId, loopId, next, prev, edgeUses[i].IsReversed));+ }++ builder.AddLoop(new Loop(loopId, coedgeIds));+ return builder.AddFace([loopId]);+ }++ private readonly record struct EdgeUse(EdgeId EdgeId, bool IsReversed)+ {+ public static EdgeUse Forward(EdgeId edgeId) => new(edgeId, false);+ public static EdgeUse Reversed(EdgeId edgeId) => new(edgeId, true);+ }+}++public readonly record struct BrepBoundedChamferCornerContext(+ AxisAlignedBoxExtents Box,+ BrepBoundedChamferCorner Corner,+ double Distance,+ int ParticipatingEdgeCount,+ bool IsConvexCorner,+ bool AllFacesPlanar,+ bool AllAdjacentFacesOrthogonal,+ bool AreChamferDistancesEqual,+ bool IsDistanceWithinLocalBounds,+ bool IsTrustedOrthogonalBody)+{+ public static KernelResult<BrepBoundedChamferCornerContext> TryCreate(+ AxisAlignedBoxExtents box,+ BrepBoundedChamferCorner corner,+ double distance)+ {+ if (!double.IsFinite(distance) || distance <= 0d)+ {+ return KernelResult<BrepBoundedChamferCornerContext>.Failure([new KernelDiagnostic(KernelDiagnosticCode.ValidationFailed, KernelDiagnosticSeverity.Error, "Bounded chamfer corner distance must be finite and greater than 0.", Source: "firmament.chamfer-bounded")]);+ }++ var sizeX = box.MaxX - box.MinX;+ var sizeY = box.MaxY - box.MinY;+ var sizeZ = box.MaxZ - box.MinZ;+ if (sizeX <= 0d || sizeY <= 0d || sizeZ <= 0d)+ {+ return KernelResult<BrepBoundedChamferCornerContext>.Failure([new KernelDiagnostic(KernelDiagnosticCode.ValidationFailed, KernelDiagnosticSeverity.Error, "Bounded chamfer corner requires a source box with strictly positive extents.", Source: "firmament.chamfer-bounded")]);+ }++ var withinBounds = distance < System.Math.Min(sizeX, System.Math.Min(sizeY, sizeZ));+ return KernelResult<BrepBoundedChamferCornerContext>.Success(new BrepBoundedChamferCornerContext(+ box,+ corner,+ distance,+ ParticipatingEdgeCount: 3,+ IsConvexCorner: true,+ AllFacesPlanar: true,+ AllAdjacentFacesOrthogonal: true,+ AreChamferDistancesEqual: true,+ IsDistanceWithinLocalBounds: withinBounds,+ IsTrustedOrthogonalBody: true));+ }+}++public enum BrepBoundedChamferCorner+{+ XMaxYMaxZMax}public enum BrepBoundedChamferEdgediff --git a/Aetheris.Kernel.Core/Brep/EdgeFinishing/BrepBoundedEdgeFinishingToolParser.cs b/Aetheris.Kernel.Core/Brep/EdgeFinishing/BrepBoundedEdgeFinishingToolParser.csindex c950feb5..9dff6f04 100644--- a/Aetheris.Kernel.Core/Brep/EdgeFinishing/BrepBoundedEdgeFinishingToolParser.cs+++ b/Aetheris.Kernel.Core/Brep/EdgeFinishing/BrepBoundedEdgeFinishingToolParser.cs@@ -6,6 +6,57 @@ namespace Aetheris.Kernel.Core.Brep.EdgeFinishing;/// </summary>public static class BrepBoundedEdgeFinishingToolParser{+ public static bool TryParseChamferSelection(+ IReadOnlyDictionary<string, string> fields,+ out BrepBoundedChamferEdge? edge,+ out BrepBoundedChamferCorner? corner,+ out string error)+ {+ edge = null;+ corner = null;+ error = string.Empty;++ var hasEdges = fields.TryGetValue("edges", out var edgesRaw) && !string.IsNullOrWhiteSpace(edgesRaw);+ var hasCorners = fields.TryGetValue("corners", out var cornersRaw) && !string.IsNullOrWhiteSpace(cornersRaw);+ if (hasEdges == hasCorners)+ {+ error = "provide exactly one of edges or corners";+ return false;+ }++ if (hasEdges)+ {+ if (!TryParseChamferEdge(fields, out var parsedEdge, out error))+ {+ return false;+ }++ edge = parsedEdge;+ return true;+ }++ var tokens = ParseSingleTokenArray(cornersRaw!, out error);+ if (tokens is null)+ {+ return false;+ }++ if (tokens.Length != 1)+ {+ error = "bounded E2 supports exactly one explicit corner token";+ return false;+ }++ if (tokens[0] is not "x_max_y_max_z_max")+ {+ error = "supported corner tokens are x_max_y_max_z_max";+ return false;+ }++ corner = BrepBoundedChamferCorner.XMaxYMaxZMax;+ return true;+ }+public static bool TryParseChamferEdge(IReadOnlyDictionary<string, string> fields,out BrepBoundedChamferEdge edge,diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentBooleanRequiredFieldValidationTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentBooleanRequiredFieldValidationTests.csindex d1da8247..218de2d6 100644--- a/Aetheris.Kernel.Firmament.Tests/FirmamentBooleanRequiredFieldValidationTests.cs+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentBooleanRequiredFieldValidationTests.cs@@ -227,6 +227,63 @@ public sealed class FirmamentBooleanRequiredFieldValidationTestsFirmamentDiagnosticCodes.BooleanInvalidFieldValue,"Boolean op 'chamfer' at index 1 has invalid field 'edges'; supported bounded M5a edge tokens are x_min_y_min, x_min_y_max, x_max_y_min, x_max_y_max.");+ [Fact]+ public void Compiler_Accepts_ValidBoundedChamferCornerE2Shape() =>+ AssertValidBooleanOp("""+ firmament:+ version: 1++ model:+ name: demo+ units: mm++ ops[2]:+ -+ op: box+ id: base+ size[3]:+ 40+ 20+ 10+ -+ op: chamfer+ id: corner_break+ from: base+ corners[1]:+ x_max_y_max_z_max+ distance: 1.5+ """);++ [Fact]+ public void Compiler_Rejects_Chamfer_UnsupportedCornerToken() =>+ AssertBooleanFailure(+ """+ firmament:+ version: 1++ model:+ name: demo+ units: mm++ ops[2]:+ -+ op: box+ id: base+ size[3]:+ 20+ 20+ 20+ -+ op: chamfer+ id: corner_break+ from: base+ corners[1]:+ x_min_y_min_z_min+ distance: 1+ """,+ FirmamentDiagnosticCodes.BooleanInvalidFieldValue,+ "Boolean op 'chamfer' at index 1 has invalid field 'corners'; supported bounded E2 corner tokens are x_max_y_max_z_max.");+[Fact]public void Compiler_Allows_ValidBoundedFilletShape_Past_FieldValidation(){diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentBuildAndExportTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentBuildAndExportTests.csindex 96317786..b787c0a0 100644--- a/Aetheris.Kernel.Firmament.Tests/FirmamentBuildAndExportTests.cs+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentBuildAndExportTests.cs@@ -222,6 +222,18 @@ public sealed class FirmamentBuildAndExportTests"chamfer");}+ [Fact]+ public void Run_M5aChamferBoxCornerE2Example_Writes_Default_Export_Artifact()+ {+ AssertExampleBuildAndExport(+ "testdata/firmament/examples/m5a_chamfer_box_corner_e2_basic.firmament",+ "m5a_chamfer_box_corner_e2_basic.step",+ "corner_break",+ 1,+ "boolean",+ "chamfer");+ }+[Fact]public void Run_BooleanBoxCylinderHoleExample_Writes_Default_Export_Artifact(){diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.csindex 3f93b7de..c1c05655 100644--- a/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs@@ -302,6 +302,29 @@ public sealed class FirmamentPrimitiveExecutionTestsdiagnostic.Message.Contains("distance is too large", StringComparison.Ordinal));}+ [Fact]+ public void Compile_Executes_BoundedChamfer_SingleCorner_E2_On_BoxRoot_Into_Real_Body()+ {+ var result = CompileFixture("testdata/firmament/fixtures/m5a-valid-chamfer-box-corner-e2-exec.firmament");++ Assert.True(result.Compilation.IsSuccess);+ var executedBoolean = Assert.Single(result.Compilation.Value.PrimitiveExecutionResult!.ExecutedBooleans);+ Assert.Equal("corner_break", executedBoolean.FeatureId);+ Assert.Equal(FirmamentLoweredBooleanKind.Chamfer, executedBoolean.Kind);+ Assert.Equal(7, executedBoolean.Body.Topology.Faces.Count());+ Assert.Equal(15, executedBoolean.Body.Topology.Edges.Count());+ }++ [Fact]+ public void Compile_Rejects_BoundedChamfer_SingleCorner_For_UnsupportedCornerToken()+ {+ var result = CompileFixture("testdata/firmament/fixtures/m5a-invalid-chamfer-corner-unsupported-token.firmament");++ Assert.False(result.Compilation.IsSuccess);+ Assert.Contains(result.Compilation.Diagnostics, diagnostic =>+ diagnostic.Message.Contains("supported bounded E2 corner tokens", StringComparison.Ordinal));+ }+[Fact]public void Compile_BoundedFilletCanonicalInternalCase_Reaches_Narrow_TruthfulRebuildBlocker(){diff --git a/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs b/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.csindex 57a1c4ab..0b374302 100644--- a/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs+++ b/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs@@ -751,7 +751,7 @@ internal static class FirmamentPrimitiveExecutor]);}- if (!BrepBoundedEdgeFinishingToolParser.TryParseChamferEdge(boolean.Tool.RawFields, out var edge, out var edgeError))+ if (!BrepBoundedEdgeFinishingToolParser.TryParseChamferSelection(boolean.Tool.RawFields, out var edge, out var corner, out var edgeError)){return KernelResult<BrepBody>.Failure([@@ -763,7 +763,24 @@ internal static class FirmamentPrimitiveExecutor]);}- return BrepBoundedChamfer.ChamferAxisAlignedBoxVerticalEdge(box, edge, distance);+ if (edge.HasValue)+ {+ return BrepBoundedChamfer.ChamferAxisAlignedBoxVerticalEdge(box, edge.Value, distance);+ }++ if (corner.HasValue)+ {+ return BrepBoundedChamfer.ChamferAxisAlignedBoxSingleCorner(box, corner.Value, distance);+ }++ return KernelResult<BrepBody>.Failure(+ [+ new KernelDiagnostic(+ KernelDiagnosticCode.ValidationFailed,+ KernelDiagnosticSeverity.Error,+ "Bounded chamfer expected either one edge or one corner selection token.",+ Source: "firmament.chamfer-bounded")+ ]);}private static KernelResult<BrepBody> ExecuteBoundedManufacturingFilletOnRecognizedOrthogonalRoot(diff --git a/Aetheris.Kernel.Firmament/Validation/FirmamentBooleanRequiredFieldValidator.cs b/Aetheris.Kernel.Firmament/Validation/FirmamentBooleanRequiredFieldValidator.csindex 07ea8ea4..2cf90241 100644--- a/Aetheris.Kernel.Firmament/Validation/FirmamentBooleanRequiredFieldValidator.cs+++ b/Aetheris.Kernel.Firmament/Validation/FirmamentBooleanRequiredFieldValidator.cs@@ -161,19 +161,36 @@ internal static class FirmamentBooleanRequiredFieldValidatorreturn InvalidFieldValue("distance", opIndex, entry.OpName, "expected a numeric value greater than 0 for bounded M5a chamfer");}- if (!entry.RawFields.TryGetValue("edges", out var edgesRaw) || string.IsNullOrWhiteSpace(edgesRaw))+ var hasEdges = entry.RawFields.TryGetValue("edges", out var edgesRaw) && !string.IsNullOrWhiteSpace(edgesRaw);+ var hasCorners = entry.RawFields.TryGetValue("corners", out var cornersRaw) && !string.IsNullOrWhiteSpace(cornersRaw);+ if (hasEdges == hasCorners){- return MissingField("edges", opIndex, entry.OpName);+ return InvalidFieldValue("edges", opIndex, entry.OpName, "bounded E2 chamfer requires exactly one selector family: either edges[1] or corners[1]");}- if (!TryParseFaceTokens(edgesRaw, out var tokens) || tokens.Count != 1)+ if (hasEdges){- return InvalidFieldTypeOrShape("edges", opIndex, entry.OpName, "expected a single-item string array with one explicit edge token");- }+ if (!TryParseFaceTokens(edgesRaw!, out var edgeTokens) || edgeTokens.Count != 1)+ {+ return InvalidFieldTypeOrShape("edges", opIndex, entry.OpName, "expected a single-item string array with one explicit edge token");+ }- if (tokens[0] is not ("x_min_y_min" or "x_min_y_max" or "x_max_y_min" or "x_max_y_max"))+ if (edgeTokens[0] is not ("x_min_y_min" or "x_min_y_max" or "x_max_y_min" or "x_max_y_max"))+ {+ return InvalidFieldValue("edges", opIndex, entry.OpName, "supported bounded M5a edge tokens are x_min_y_min, x_min_y_max, x_max_y_min, x_max_y_max");+ }+ }+ else{- return InvalidFieldValue("edges", opIndex, entry.OpName, "supported bounded M5a edge tokens are x_min_y_min, x_min_y_max, x_max_y_min, x_max_y_max");+ if (!TryParseFaceTokens(cornersRaw!, out var cornerTokens) || cornerTokens.Count != 1)+ {+ return InvalidFieldTypeOrShape("corners", opIndex, entry.OpName, "expected a single-item string array with one explicit corner token");+ }++ if (cornerTokens[0] is not "x_max_y_max_z_max")+ {+ return InvalidFieldValue("corners", opIndex, entry.OpName, "supported bounded E2 corner tokens are x_max_y_max_z_max");+ }}return KernelResult<bool>.Success(true);diff --git a/testdata/firmament/examples/m5a_chamfer_box_corner_e2_basic.firmament b/testdata/firmament/examples/m5a_chamfer_box_corner_e2_basic.firmamentnew file mode 100644index 00000000..b3266e69--- /dev/null+++ b/testdata/firmament/examples/m5a_chamfer_box_corner_e2_basic.firmament@@ -0,0 +1,22 @@+firmament:+ version: 1++model:+ name: m5a_chamfer_box_corner_e2_basic+ units: mm++ops[2]:+ -+ op: box+ id: base+ size[3]:+ 40+ 20+ 10+ -+ op: chamfer+ id: corner_break+ from: base+ corners[1]:+ x_max_y_max_z_max+ distance: 1.5diff --git a/testdata/firmament/fixtures/m5a-invalid-chamfer-corner-unsupported-token.firmament b/testdata/firmament/fixtures/m5a-invalid-chamfer-corner-unsupported-token.firmamentnew file mode 100644index 00000000..e7d9a734--- /dev/null+++ b/testdata/firmament/fixtures/m5a-invalid-chamfer-corner-unsupported-token.firmament@@ -0,0 +1,22 @@+firmament:+ version: 1++model:+ name: m5a_invalid_chamfer_corner_token+ units: mm++ops[2]:+ -+ op: box+ id: base+ size[3]:+ 40+ 20+ 10+ -+ op: chamfer+ id: corner_break+ from: base+ corners[1]:+ x_min_y_min_z_min+ distance: 1.5diff --git a/testdata/firmament/fixtures/m5a-valid-chamfer-box-corner-e2-exec.firmament b/testdata/firmament/fixtures/m5a-valid-chamfer-box-corner-e2-exec.firmamentnew file mode 100644index 00000000..55100e67--- /dev/null+++ b/testdata/firmament/fixtures/m5a-valid-chamfer-box-corner-e2-exec.firmament@@ -0,0 +1,22 @@+firmament:+ version: 1++model:+ name: m5a_chamfer_box_corner_e2_exec+ units: mm++ops[2]:+ -+ op: box+ id: base+ size[3]:+ 40+ 20+ 10+ -+ op: chamfer+ id: corner_break+ from: base+ corners[1]:+ x_max_y_max_z_max+ distance: 1.5