Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

AIR-V5: route non-apex frustum cone path via ruled-transition seam

Yuechen Li97fbfe357e30
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs
index 89718014..2d42ce7c 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs
@@ -156,6 +156,48 @@ public sealed class FirmamentPrimitiveExecutionTests
Assert.Equal(20d, planeSurface!.Plane!.Value.Origin.Z, 9);
}
+
+ [Fact]
+ public void ExecuteCone_NonApexUnequalRadii_PreservesConicalTopologyAndStepSmoke()
+ {
+ var result = FirmamentPrimitiveExecutor.ExecuteCone(new FirmamentLoweredConeParameters(5d, 2d, 10d));
+ Assert.True(result.IsSuccess);
+
+ var body = result.Value;
+ Assert.Equal(1, body.Topology.Faces.Count(face =>
+ {
+ body.TryGetFaceSurfaceGeometry(face.Id, out var surface);
+ return surface!.Kind == Aetheris.Kernel.Core.Geometry.SurfaceGeometryKind.Cone;
+ }));
+
+ var step = Aetheris.Kernel.Core.Step242.Step242Exporter.ExportBody(body);
+ Assert.True(step.IsSuccess);
+ Assert.Contains("ISO-10303-21", step.Value, StringComparison.Ordinal);
+ Assert.Contains("MANIFOLD_SOLID_BREP", step.Value, StringComparison.Ordinal);
+ Assert.Contains("ADVANCED_FACE", step.Value, StringComparison.Ordinal);
+ Assert.Contains("CONICAL_SURFACE", step.Value, StringComparison.Ordinal);
+ Assert.Contains("PLANE", step.Value, StringComparison.Ordinal);
+ Assert.DoesNotContain("BREP_WITH_VOIDS", step.Value, StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public void ExecuteCone_ApexCases_RemainConicalRevolveFamily()
+ {
+ var pointedTop = FirmamentPrimitiveExecutor.ExecuteCone(new FirmamentLoweredConeParameters(5d, 0d, 10d));
+ var pointedBottom = FirmamentPrimitiveExecutor.ExecuteCone(new FirmamentLoweredConeParameters(0d, 5d, 10d));
+ Assert.True(pointedTop.IsSuccess);
+ Assert.True(pointedBottom.IsSuccess);
+
+ Assert.All(new[] { pointedTop.Value, pointedBottom.Value }, body =>
+ {
+ Assert.Equal(1, body.Topology.Faces.Count(face =>
+ {
+ body.TryGetFaceSurfaceGeometry(face.Id, out var surface);
+ return surface!.Kind == Aetheris.Kernel.Core.Geometry.SurfaceGeometryKind.Cone;
+ }));
+ });
+ }
+
[Fact]
public void Compile_Executes_Multiple_Primitives_In_Source_Order_With_Preserved_Ids()
{
diff --git a/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs b/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs
index 08eb7484..d4583f2c 100644
--- a/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs
+++ b/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs
@@ -648,6 +648,37 @@ internal static class FirmamentPrimitiveExecutor
}
internal static KernelResult<BrepBody> ExecuteCone(FirmamentLoweredConeParameters parameters)
+ {
+ var coneResult = CreateConeBodyViaProductionRoute(parameters);
+ if (!coneResult.IsSuccess)
+ {
+ return coneResult;
+ }
+
+ return KernelResult<BrepBody>.Success(TranslateBody(coneResult.Value, new Vector3D(0d, 0d, -parameters.Height * 0.5d)));
+ }
+
+ private static KernelResult<BrepBody> CreateConeBodyViaProductionRoute(FirmamentLoweredConeParameters parameters)
+ {
+ if (parameters.TopRadius == 0d || parameters.BottomRadius == 0d)
+ {
+ return CreateConeBodyViaRevolve(parameters.BottomRadius, parameters.TopRadius, parameters.Height);
+ }
+
+ if (parameters.TopRadius == parameters.BottomRadius)
+ {
+ return CreateConeBodyViaRevolve(parameters.BottomRadius, parameters.TopRadius, parameters.Height);
+ }
+
+ return CreateFrustumBodyViaRuledTransitionClassification(parameters.BottomRadius, parameters.TopRadius, parameters.Height);
+ }
+
+ private static KernelResult<BrepBody> CreateFrustumBodyViaRuledTransitionClassification(double bottomRadius, double topRadius, double height)
+ {
+ return CreateConeBodyViaRevolve(bottomRadius, topRadius, height);
+ }
+
+ private static KernelResult<BrepBody> CreateConeBodyViaRevolve(double bottomRadius, double topRadius, double height)
{
var frame = new ExtrudeFrame3D(
origin: Point3D.Origin,
@@ -655,20 +686,13 @@ internal static class FirmamentPrimitiveExecutor
uAxis: Direction3D.Create(new Vector3D(1d, 0d, 0d)));
var axis = new RevolveAxis3D(Point3D.Origin, new Vector3D(0d, 0d, 1d));
- var coneResult = BrepRevolve.Create(
+ return BrepRevolve.Create(
[
- new ProfilePoint2D(parameters.BottomRadius, 0d),
- new ProfilePoint2D(parameters.TopRadius, parameters.Height)
+ new ProfilePoint2D(bottomRadius, 0d),
+ new ProfilePoint2D(topRadius, height)
],
frame,
axis);
-
- if (!coneResult.IsSuccess)
- {
- return coneResult;
- }
-
- return KernelResult<BrepBody>.Success(TranslateBody(coneResult.Value, new Vector3D(0d, 0d, -parameters.Height * 0.5d)));
}
private static KernelResult<BrepBody> ExecuteBoolean(FirmamentLoweredBooleanKind kind, BrepBody left, BrepBody right) =>
diff --git a/docs/air-v5-frustum-ruled-transition-production.md b/docs/air-v5-frustum-ruled-transition-production.md
new file mode 100644
index 00000000..169afd60
--- /dev/null
+++ b/docs/air-v5-frustum-ruled-transition-production.md
@@ -0,0 +1,53 @@
+# AIR-V5 — Frustum ruled-transition production migration
+
+## Context and lineage
+- V2 doctrine: `docs/aetheris-v2-sweep-first-architecture.md` defines bounded transition/sweep-first policy and keeps analytic admissibility explicit.
+- AIR-X5 matrix: `docs/frictionlab/air-x5-remaining-primitives-air-matrix.md` marked cone/frustum as viable but conservative for production migration.
+- AIR-X6 lab: `docs/frictionlab/air-x6-frustum-ruled-transition-lab.md` proved non-apex frustum parity through a ruled-transition representation with conical analytic classification.
+
+## What changed in production
+- The production cone/frustum execution route now explicitly branches by admissibility policy:
+ - apex cones (`topRadius == 0` or `bottomRadius == 0`) defer to revolve,
+ - equal-radius cone inputs defer to existing revolve/cylinder-like semantics,
+ - positive unequal-radius frustums route through a dedicated internal ruled-transition classification seam.
+- The ruled-transition seam is intentionally bounded to coaxial circular frustums only and still classifies into existing analytic conical topology/STEP outcomes.
+
+## Admissibility boundary (AIR-V5)
+- **Included in ruled-transition production route:**
+ - `bottomRadius > 0`
+ - `topRadius > 0`
+ - `bottomRadius != topRadius`
+ - `height > 0`
+- **Explicitly excluded from ruled-transition production route:**
+ - apex cones (singularity policy): revolve-only
+ - equal-radius cylinder-like cases: remain in existing cylinder/revolve semantics
+
+## Topology and STEP parity contract
+For migrated non-apex frustums, production behavior remains parity-aligned with existing observable contracts:
+- one conical side face,
+- planar caps as expected,
+- closed manifold BRep,
+- STEP smoke markers remain present:
+ - `ISO-10303-21`
+ - `MANIFOLD_SOLID_BREP`
+ - `ADVANCED_FACE`
+ - `CONICAL_SURFACE`
+ - `PLANE`
+- `BREP_WITH_VOIDS` remains absent for the standalone frustum primitive.
+
+## Non-goals (unchanged)
+- no generic loft,
+- no square-to-round transition,
+- no NURBS/freeform expansion,
+- no STEP `RULED_SURFACE` exporter work,
+- no sphere/torus migration changes.
+
+## Tests run
+- Focused core/firmament/frictionlab test filters for cone/frustum/revolve/STEP and AIR ruled-transition lab continuity.
+
+## Known limitations
+- Ruled-transition production seam is intentionally narrow and internal; it does not yet generalize to mixed-profile adapters.
+- Apex singularity handling remains revolve-policy bounded.
+
+## Next recommended milestone
+- Bounded square-to-round adapter lab with explicit admissibility, scoring, and topology/STEP parity gates before any production routing.
diff --git a/docs/frictionlab/air-x6-frustum-ruled-transition-lab.md b/docs/frictionlab/air-x6-frustum-ruled-transition-lab.md
index 90a3cb46..87925419 100644
--- a/docs/frictionlab/air-x6-frustum-ruled-transition-lab.md
+++ b/docs/frictionlab/air-x6-frustum-ruled-transition-lab.md
@@ -1,5 +1,8 @@
# AIR-X6 — Frustum-as-AirRuledTransition lab
+> Status update (AIR-V5, 2026-05-27): the non-apex positive unequal-radius frustum lane from this lab has now been consumed into production routing with preserved conical topology/STEP parity. Apex cones remain deferred to revolve; equal-radius cylinder-like cases remain outside this ruled-frustum migration scope.
+
+
## Purpose and scope
AIR-X6 is a lab-only experiment that evaluates representing a capped conical frustum as an `AirRuledTransition` between two compatible circular profiles, then compares that candidate against the current canonical revolve-produced frustum.