Skip to content

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.cs
new file mode 100644
index 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.cs
index 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 BrepBoundedChamferTests
Assert.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.cs
index 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 BrepBoundedChamfer
private 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 BrepBoundedChamferEdge
diff --git a/Aetheris.Kernel.Core/Brep/EdgeFinishing/BrepBoundedEdgeFinishingToolParser.cs b/Aetheris.Kernel.Core/Brep/EdgeFinishing/BrepBoundedEdgeFinishingToolParser.cs
index 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.cs
index d1da8247..218de2d6 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentBooleanRequiredFieldValidationTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentBooleanRequiredFieldValidationTests.cs
@@ -227,6 +227,63 @@ public sealed class FirmamentBooleanRequiredFieldValidationTests
FirmamentDiagnosticCodes.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.cs
index 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.cs
index 3f93b7de..c1c05655 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs
@@ -302,6 +302,29 @@ public sealed class FirmamentPrimitiveExecutionTests
diagnostic.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.cs
index 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.cs
index 07ea8ea4..2cf90241 100644
--- a/Aetheris.Kernel.Firmament/Validation/FirmamentBooleanRequiredFieldValidator.cs
+++ b/Aetheris.Kernel.Firmament/Validation/FirmamentBooleanRequiredFieldValidator.cs
@@ -161,19 +161,36 @@ internal static class FirmamentBooleanRequiredFieldValidator
return 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.firmament
new file mode 100644
index 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.5
diff --git a/testdata/firmament/fixtures/m5a-invalid-chamfer-corner-unsupported-token.firmament b/testdata/firmament/fixtures/m5a-invalid-chamfer-corner-unsupported-token.firmament
new file mode 100644
index 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.5
diff --git a/testdata/firmament/fixtures/m5a-valid-chamfer-box-corner-e2-exec.firmament b/testdata/firmament/fixtures/m5a-valid-chamfer-box-corner-e2-exec.firmament
new file mode 100644
index 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