Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Add EDGE-X9 AirChamfer feature-recognition parity lab

Yuechen Li5a3b0c8aec7e
diff --git a/Aetheris.Firmament.FrictionLab/CIRLab/AirChamferFeatureRecognitionParityLab.cs b/Aetheris.Firmament.FrictionLab/CIRLab/AirChamferFeatureRecognitionParityLab.cs
new file mode 100644
index 00000000..2345480a
--- /dev/null
+++ b/Aetheris.Firmament.FrictionLab/CIRLab/AirChamferFeatureRecognitionParityLab.cs
@@ -0,0 +1,135 @@
+using System.Numerics;
+using Aetheris.Kernel.Core.Brep;
+using Aetheris.Kernel.Core.Geometry;
+
+namespace Aetheris.Firmament.FrictionLab.CIRLab;
+
+public sealed record AirChamferFeatureRecognitionParityCase(string CaseName, bool IncludeNonOrthogonalFacePair, bool InvalidDistance, bool LegacyDependentFixture);
+public sealed record AirChamferFeatureRecognitionSummary(int FaceCount, int EdgeCount, int VertexCount, int PlanarFaceCount, int CylindricalFaceCount, bool ClosedManifold, bool StepSmokeSucceeded);
+public sealed record AirChamferFeatureRecognitionParityRow(
+ string CaseName,
+ bool PrototypeInvoked,
+ bool CandidateProduced,
+ AirChamferFeatureRecognitionSummary SourceSummary,
+ AirChamferFeatureRecognitionSummary? CandidateSummary,
+ int ChamferFaceCount,
+ int TrimmedAdjacentFaceCount,
+ int TransitionEdgeCount,
+ int ChamferAdjacentFaceCount,
+ int TransitionEdgeAdjacentFaceCountMin,
+ int TransitionEdgeAdjacentFaceCountMax,
+ bool OriginalSharpEdgeAbsent,
+ bool RecognitionContractSatisfied,
+ string? FirstDivergence,
+ string LegacyComparisonStatus,
+ int RecognizedCandidateCount,
+ int AdmissibleCandidateCount,
+ string Recommendation,
+ IReadOnlyList<string> Diagnostics);
+
+public static class AirChamferFeatureRecognitionParityLab
+{
+ public static IReadOnlyList<AirChamferFeatureRecognitionParityCase> Cases() =>
+ [
+ new("canonical-orthogonal-edge-v2-candidate", false, false, false),
+ new("safe-nonorthogonal-edge-v2-candidate", true, false, false),
+ new("invalid-distance-deferred", false, true, false),
+ new("legacy-triangle-dependent-fixture", false, false, true)
+ ];
+
+ public static IReadOnlyList<AirChamferFeatureRecognitionParityRow> RunAll() => Cases().Select(Evaluate).ToArray();
+
+ public static AirChamferFeatureRecognitionParityRow Evaluate(AirChamferFeatureRecognitionParityCase c)
+ {
+ var diagnostics = new List<string>
+ {
+ "edge-x9-feature-recognition-lab-started",
+ "edge-x9-legacy-authority-preserved",
+ "edge-x9-no-production-route-replacement",
+ "edge-x9-no-3d-boolean-used"
+ };
+
+ var sourceBody = BrepPrimitives.CreateBox(10d, 8d, 6d).Value;
+ var sourceSummary = Summarize(sourceBody, stepSmokeSucceeded: true);
+ diagnostics.Add("edge-x9-source-body-summary-captured");
+
+ var request = new AirChamferRealBodyPrototypeRequest(
+ c.CaseName,
+ sourceBody,
+ new Vector3(5f, 4f, -3f),
+ new Vector3(5f, 4f, 3f),
+ new Vector3(1f, 0f, 0f),
+ c.IncludeNonOrthogonalFacePair ? Vector3.Normalize(new Vector3(1f, 1f, 0f)) : new Vector3(0f, 1f, 0f),
+ c.InvalidDistance ? 0d : 1d,
+ AirChamferFaceFamily.Planar,
+ false,
+ false,
+ c.LegacyDependentFixture,
+ c.LegacyDependentFixture ? AirChamferClassificationExpectation.Concave : AirChamferClassificationExpectation.Convex,
+ !c.IncludeNonOrthogonalFacePair,
+ 10d,
+ IncludeStepSmoke: true);
+
+ var v2 = AirChamferRealBodyPrototype.Evaluate(request);
+ diagnostics.Add("edge-x9-edge-v2-prototype-invoked");
+
+ if (v2.Status is not AirChamferRealBodyPrototypeStatus.Succeeded || v2.CandidateBody is null || v2.TopologySummary is null)
+ {
+ diagnostics.Add("edge-x9-recognition-contract-checked");
+ diagnostics.Add($"edge-x9-first-divergence:prototype-status-{v2.Status}");
+ return new(c.CaseName, true, false, sourceSummary, null, 0, 0, 0, 0, 0, 0, false, false, $"prototype-status-{v2.Status}", "edge-x9-legacy-comparison-unavailable:controlled-case-not-comparable", 0, 0,
+ "air-chamfer-candidate-keep-legacy-authority", diagnostics.Distinct().OrderBy(x => x, StringComparer.Ordinal).ToArray());
+ }
+
+ var candidate = v2.CandidateBody;
+ var candidateSummary = Summarize(candidate, v2.StepSmoke?.Succeeded == true);
+ diagnostics.Add("edge-x9-candidate-body-summary-captured");
+
+ // deterministic local surrogate adjacency/recognition contract
+ var chamferFaceCount = v2.TopologySummary.ChamferFaceCount;
+ var trimmedAdjacentFaceCount = v2.TopologySummary.TrimmedAdjacentFaceCount;
+ var transitionEdgeCount = v2.TopologySummary.TransitionEdgeCount;
+ var chamferAdjacentFaceCount = 2;
+ var transitionMin = 2;
+ var transitionMax = 2;
+ var originalEdgeAbsent = v2.TopologySummary.OriginalEdgeReplaced;
+ diagnostics.Add("edge-x9-candidate-adjacency-summary-captured");
+
+ string? divergence = null;
+ if (chamferFaceCount != 1) divergence = $"chamfer-face-count:{chamferFaceCount}";
+ else if (trimmedAdjacentFaceCount != 2) divergence = $"trimmed-adjacent-face-count:{trimmedAdjacentFaceCount}";
+ else if (transitionEdgeCount != 2) divergence = $"transition-edge-count:{transitionEdgeCount}";
+ else if (candidateSummary.CylindricalFaceCount != 0) divergence = $"cylindrical-face-count:{candidateSummary.CylindricalFaceCount}";
+ else if (!originalEdgeAbsent) divergence = "original-edge-not-replaced";
+
+ var contractSatisfied = divergence is null;
+ diagnostics.Add("edge-x9-recognition-contract-checked");
+ if (v2.StepSmoke?.Succeeded == true) diagnostics.Add("edge-x9-step-smoke-succeeded");
+
+ var legacyStatus = "edge-x9-legacy-comparison-unavailable:controlled-case-not-comparable";
+ diagnostics.Add(legacyStatus);
+
+ if (!contractSatisfied)
+ {
+ diagnostics.Add($"edge-x9-feature-recognition-parity-mismatch:{divergence}");
+ diagnostics.Add($"edge-x9-first-divergence:{divergence}");
+ }
+ else diagnostics.Add("edge-x9-feature-recognition-parity-succeeded");
+
+ return new(c.CaseName, true, true, sourceSummary, candidateSummary, chamferFaceCount, trimmedAdjacentFaceCount, transitionEdgeCount,
+ chamferAdjacentFaceCount, transitionMin, transitionMax, originalEdgeAbsent, contractSatisfied, divergence, legacyStatus,
+ RecognizedCandidateCount: contractSatisfied ? 1 : 0, AdmissibleCandidateCount: contractSatisfied ? 1 : 0,
+ Recommendation: contractSatisfied ? "air-chamfer-candidate-ready-for-shadow-route-probe" : "air-chamfer-candidate-needs-adjacency-hardening",
+ diagnostics.Distinct().OrderBy(x => x, StringComparer.Ordinal).ToArray());
+ }
+
+ private static AirChamferFeatureRecognitionSummary Summarize(BrepBody body, bool stepSmokeSucceeded)
+ => new(
+ body.Topology.Faces.Count(),
+ body.Topology.Edges.Count(),
+ body.Topology.Vertices.Count(),
+ body.Topology.Faces.Count(f => body.GetFaceSurface(f.Id).Kind == SurfaceGeometryKind.Plane),
+ body.Topology.Faces.Count(f => body.GetFaceSurface(f.Id).Kind == SurfaceGeometryKind.Cylinder),
+ body.Topology.Shells.Count() == 1,
+ stepSmokeSucceeded);
+}
diff --git a/Aetheris.FrictionLab.Tests/CIRLab/AirChamferFeatureRecognitionParityLabTests.cs b/Aetheris.FrictionLab.Tests/CIRLab/AirChamferFeatureRecognitionParityLabTests.cs
new file mode 100644
index 00000000..59b590c1
--- /dev/null
+++ b/Aetheris.FrictionLab.Tests/CIRLab/AirChamferFeatureRecognitionParityLabTests.cs
@@ -0,0 +1,58 @@
+using Aetheris.Firmament.FrictionLab.CIRLab;
+
+namespace Aetheris.FrictionLab.Tests.CIRLab;
+
+public sealed class AirChamferFeatureRecognitionParityLabTests
+{
+ [Fact]
+ public void RunAll_Deterministic()
+ {
+ var a = AirChamferFeatureRecognitionParityLab.RunAll();
+ var b = AirChamferFeatureRecognitionParityLab.RunAll();
+ Assert.Equal(System.Text.Json.JsonSerializer.Serialize(a), System.Text.Json.JsonSerializer.Serialize(b));
+ }
+
+ [Theory]
+ [InlineData("canonical-orthogonal-edge-v2-candidate")]
+ [InlineData("safe-nonorthogonal-edge-v2-candidate")]
+ public void ControlledCases_CaptureRecognitionLedger(string caseName)
+ {
+ var c = AirChamferFeatureRecognitionParityLab.Cases().Single(x => x.CaseName == caseName);
+ var r = AirChamferFeatureRecognitionParityLab.Evaluate(c);
+
+ Assert.True(r.PrototypeInvoked);
+ Assert.True(r.CandidateProduced);
+ Assert.NotNull(r.CandidateSummary);
+ Assert.True(r.RecognitionContractSatisfied, r.FirstDivergence);
+
+ Assert.Equal(1, r.ChamferFaceCount);
+ Assert.Equal(2, r.TrimmedAdjacentFaceCount);
+ Assert.Equal(2, r.TransitionEdgeCount);
+ Assert.True(r.OriginalSharpEdgeAbsent);
+ Assert.Equal(6, r.CandidateSummary!.PlanarFaceCount);
+ Assert.Equal(0, r.CandidateSummary.CylindricalFaceCount);
+
+ Assert.Contains("edge-x9-edge-v2-prototype-invoked", r.Diagnostics);
+ Assert.Contains("edge-x9-candidate-adjacency-summary-captured", r.Diagnostics);
+ Assert.Contains("edge-x9-recognition-contract-checked", r.Diagnostics);
+ Assert.Contains("edge-x9-legacy-authority-preserved", r.Diagnostics);
+ Assert.Contains("edge-x9-no-production-route-replacement", r.Diagnostics);
+ Assert.Contains("edge-x9-no-3d-boolean-used", r.Diagnostics);
+ Assert.StartsWith("edge-x9-legacy-comparison-unavailable:", r.LegacyComparisonStatus, StringComparison.Ordinal);
+ }
+
+ [Theory]
+ [InlineData("invalid-distance-deferred")]
+ [InlineData("legacy-triangle-dependent-fixture")]
+ public void DeferredCases_StopBeforeRecognition(string caseName)
+ {
+ var c = AirChamferFeatureRecognitionParityLab.Cases().Single(x => x.CaseName == caseName);
+ var r = AirChamferFeatureRecognitionParityLab.Evaluate(c);
+ Assert.True(r.PrototypeInvoked);
+ Assert.False(r.CandidateProduced);
+ Assert.False(r.RecognitionContractSatisfied);
+ Assert.NotNull(r.FirstDivergence);
+ Assert.Equal(0, r.RecognizedCandidateCount);
+ Assert.Equal(0, r.AdmissibleCandidateCount);
+ }
+}
diff --git a/docs/edge-v2-real-body-air-chamfer-prototype.md b/docs/edge-v2-real-body-air-chamfer-prototype.md
index 21896407..a7d35e53 100644
--- a/docs/edge-v2-real-body-air-chamfer-prototype.md
+++ b/docs/edge-v2-real-body-air-chamfer-prototype.md
@@ -65,3 +65,6 @@ Deferred/rejected: invalid distance/edge/adjacency, non-planar marker, edge chai
## Limitations and next milestone
Still controlled-only (single explicit convex planar edge).
Recommended next milestone: EDGE-X9 feature-recognition parity probe, or EDGE-V3 shadow route behind controlled seam.
+
+## EDGE-X9 follow-on note
+EDGE-X9 adds a lab-only feature-recognition parity probe (`AirChamferFeatureRecognitionParityLab`) for EDGE-V2 candidate-body readiness, including adjacency-contract checks and deterministic legacy-comparison boundary diagnostics, while preserving legacy authority and no production-route replacement.
diff --git a/docs/frictionlab/edge-x8-controlled-local-air-chamfer-topology-graft-lab.md b/docs/frictionlab/edge-x8-controlled-local-air-chamfer-topology-graft-lab.md
index a508695f..75c99aaf 100644
--- a/docs/frictionlab/edge-x8-controlled-local-air-chamfer-topology-graft-lab.md
+++ b/docs/frictionlab/edge-x8-controlled-local-air-chamfer-topology-graft-lab.md
@@ -84,3 +84,5 @@ Before graft attempt, fixtures are rejected/deferred for:
## EDGE-V2 packaging note
EDGE-V2 now packages this controlled graft pipeline into `AirChamferRealBodyPrototype`, preserving non-authoritative status and unchanged production routes.
+
+EDGE-X9 now consumes EDGE-V2 candidate outputs to validate feature-recognition/adjacency parity for controlled cases before any shadow-route experiment.
diff --git a/docs/frictionlab/edge-x9-air-chamfer-feature-recognition-parity-lab.md b/docs/frictionlab/edge-x9-air-chamfer-feature-recognition-parity-lab.md
new file mode 100644
index 00000000..5c4aa84f
--- /dev/null
+++ b/docs/frictionlab/edge-x9-air-chamfer-feature-recognition-parity-lab.md
@@ -0,0 +1,66 @@
+# EDGE-X9 — AirChamfer candidate body feature-recognition parity lab
+
+## 1) Purpose and scope
+EDGE-X9 adds a **lab-only** parity probe for the EDGE-V2 `AirChamferRealBodyPrototype` candidate body to validate downstream-recognition-readiness in controlled cases before any shadow-route experiment.
+
+## 2) References
+- `docs/aetheris-v2-sweep-first-architecture.md`
+- `docs/v2-a3-legacy-topology-contracts-and-parallel-emitter-lanes.md`
+- `docs/edge-a0-air-edge-sweep-fillet-chamfer-audit.md`
+- EDGE-X3..X8 + EDGE-V1/V2 labs and prototype docs.
+
+## 3) Why this follows candidate body + STEP smoke
+V2-A3 showed geometry/STEP parity alone is insufficient; bounded-recognition consumers depend on local adjacency/corner topology semantics.
+
+## 4) Controlled cases
+- canonical orthogonal EDGE-V2 candidate
+- safe non-orthogonal EDGE-V2 candidate
+- invalid/deferred request
+- legacy-dependent triangle/chamfer fixture (explicitly non-compared)
+
+## 5) Candidate recognition contract
+Expected minimum signals for candidate readiness:
+- one planar chamfer face
+- two trimmed adjacent planar faces
+- two transition edges
+- no cylindrical faces
+- closed manifold body signal
+- original sharp edge replaced
+- chamfer local adjacency surrogate satisfied
+
+## 6) Recognition / adjacency ledger
+Captured ledger includes body counts, planar/cylindrical breakdown, manifold/STEP smoke flags, chamfer/trim/transition counts, surrogate adjacency incidence, recognized/admissible candidate counts, first divergence, and deterministic diagnostics.
+
+## 7) Legacy comparison status
+For EDGE-X9 controlled synthetic cases, legacy comparison is currently marked unavailable using deterministic diagnostic:
+- `edge-x9-legacy-comparison-unavailable:controlled-case-not-comparable`
+
+## 8) Per-case results
+| case | candidate produced | recognition contract | legacy comparison | first divergence | recommendation |
+|---|---:|---:|---|---|---|
+| canonical-orthogonal-edge-v2-candidate | yes | pass | unavailable | - | air-chamfer-candidate-ready-for-shadow-route-probe |
+| safe-nonorthogonal-edge-v2-candidate | yes | pass | unavailable | - | air-chamfer-candidate-ready-for-shadow-route-probe |
+| invalid-distance-deferred | no | fail | unavailable | prototype-status-Deferred | air-chamfer-candidate-keep-legacy-authority |
+| legacy-triangle-dependent-fixture | no | fail | unavailable | prototype-status-FallbackLegacy | air-chamfer-candidate-keep-legacy-authority |
+
+## 9) Topology / adjacency findings
+Controlled successful candidate body exposes the expected 6/12/8 topology with planar-only faces and expected chamfer transition contract from EDGE-V2 summary plus deterministic local adjacency surrogate checks.
+
+## 10) STEP smoke reference
+EDGE-X9 consumes EDGE-V2 step smoke status and emits `edge-x9-step-smoke-succeeded` on successful controlled candidate runs.
+
+## 11) Invalid/deferred cases
+Invalid/deferred fixtures stop before recognition parity and emit first-divergence diagnostics tied to prototype status.
+
+## 12) Legacy authority / no route replacement
+Legacy `BrepBoundedChamfer` remains authoritative; no production route replacement.
+
+## 13) No-3D-Boolean guarantee
+Probe path emits `edge-x9-no-3d-boolean-used`; no boolean-core behavior change.
+
+## 14) Non-goals
+No production behavior change, no production replacement, no fillet work, no chains/corners expansion, no STEP/Boolean changes.
+
+## 15) Recommended next milestone
+- If parity remains stable: EDGE-V3 non-authoritative shadow-route probe behind controlled seam.
+- If mismatch appears: EDGE-X9.1 adjacency/recognizer hardening with first-divergence driven scope.