Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Implement M3c primitive execution into kernel bodies

Yuechen Lie7542444a1c7
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs
new file mode 100644
index 00000000..6edf23e4
--- /dev/null
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs
@@ -0,0 +1,130 @@
+using Aetheris.Kernel.Core.Brep;
+using Aetheris.Kernel.Firmament.Lowering;
+
+namespace Aetheris.Kernel.Firmament.Tests;
+
+public sealed class FirmamentPrimitiveExecutionTests
+{
+ [Fact]
+ public void Compile_Executes_Box_Primitive_Into_Real_Body()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m3c-valid-box-exec.firmament");
+
+ Assert.True(result.Compilation.IsSuccess);
+ var executed = Assert.Single(result.Compilation.Value.PrimitiveExecutionResult!.ExecutedPrimitives);
+ Assert.Equal("base", executed.FeatureId);
+ Assert.Equal(FirmamentLoweredPrimitiveKind.Box, executed.Kind);
+ Assert.NotEmpty(executed.Body.Topology.Bodies);
+ Assert.NotEmpty(executed.Body.Topology.Faces);
+ }
+
+ [Fact]
+ public void Compile_Executes_Cylinder_Primitive_Into_Real_Body()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m3c-valid-cylinder-exec.firmament");
+
+ Assert.True(result.Compilation.IsSuccess);
+ var executed = Assert.Single(result.Compilation.Value.PrimitiveExecutionResult!.ExecutedPrimitives);
+ Assert.Equal("post", executed.FeatureId);
+ Assert.Equal(FirmamentLoweredPrimitiveKind.Cylinder, executed.Kind);
+ Assert.NotEmpty(executed.Body.Topology.Bodies);
+ Assert.NotEmpty(executed.Body.Topology.Faces);
+ }
+
+ [Fact]
+ public void Compile_Executes_Sphere_Primitive_Into_Real_Body()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m3c-valid-sphere-exec.firmament");
+
+ Assert.True(result.Compilation.IsSuccess);
+ var executed = Assert.Single(result.Compilation.Value.PrimitiveExecutionResult!.ExecutedPrimitives);
+ Assert.Equal("ball", executed.FeatureId);
+ Assert.Equal(FirmamentLoweredPrimitiveKind.Sphere, executed.Kind);
+ Assert.NotEmpty(executed.Body.Topology.Bodies);
+ Assert.NotEmpty(executed.Body.Topology.Faces);
+ }
+
+ [Fact]
+ public void Compile_Executes_Multiple_Primitives_In_Source_Order_With_Preserved_Ids()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m3c-valid-multiple-primitives-exec.firmament");
+
+ Assert.True(result.Compilation.IsSuccess);
+ var executed = result.Compilation.Value.PrimitiveExecutionResult!.ExecutedPrimitives;
+
+ Assert.Collection(
+ executed,
+ first =>
+ {
+ Assert.Equal(0, first.OpIndex);
+ Assert.Equal("base", first.FeatureId);
+ Assert.Equal(FirmamentLoweredPrimitiveKind.Box, first.Kind);
+ },
+ second =>
+ {
+ Assert.Equal(1, second.OpIndex);
+ Assert.Equal("post", second.FeatureId);
+ Assert.Equal(FirmamentLoweredPrimitiveKind.Cylinder, second.Kind);
+ },
+ third =>
+ {
+ Assert.Equal(2, third.OpIndex);
+ Assert.Equal("ball", third.FeatureId);
+ Assert.Equal(FirmamentLoweredPrimitiveKind.Sphere, third.Kind);
+ });
+ }
+
+ [Fact]
+ public void Compile_Mixed_Document_Executes_Only_Primitives_And_Leaves_Booleans_NonExecuted()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m3c-mixed-primitive-boolean-validation.firmament");
+
+ Assert.True(result.Compilation.IsSuccess);
+ var artifact = result.Compilation.Value;
+
+ Assert.Equal("firmament-primitives-executed", artifact.ArtifactKind);
+ Assert.Equal(2, artifact.PrimitiveLoweringPlan!.Primitives.Count);
+ Assert.Equal(2, artifact.PrimitiveLoweringPlan.Booleans.Count);
+ Assert.Single(artifact.PrimitiveLoweringPlan.SkippedOps);
+
+ var executed = artifact.PrimitiveExecutionResult!.ExecutedPrimitives;
+ Assert.Equal(2, executed.Count);
+ Assert.Equal(new[] { "base", "cap" }, executed.Select(p => p.FeatureId).ToArray());
+ }
+
+ [Fact]
+ public void Compile_ValidationFailure_Still_Fails_Before_Execution()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m1a-invalid-sphere-missing-radius.firmament");
+
+ Assert.False(result.Compilation.IsSuccess);
+ }
+
+ [Fact]
+ public void Compile_Primitive_Execution_Output_Is_Deterministic_For_Metadata()
+ {
+ var fixture = "testdata/firmament/fixtures/m3c-valid-multiple-primitives-exec.firmament";
+
+ var first = CompileFixture(fixture);
+ var second = CompileFixture(fixture);
+
+ Assert.True(first.Compilation.IsSuccess);
+ Assert.True(second.Compilation.IsSuccess);
+
+ var firstMetadata = first.Compilation.Value.PrimitiveExecutionResult!.ExecutedPrimitives
+ .Select(p => (p.OpIndex, p.FeatureId, p.Kind, BodyCount: p.Body.Topology.Bodies.Count(), FaceCount: p.Body.Topology.Faces.Count()))
+ .ToArray();
+ var secondMetadata = second.Compilation.Value.PrimitiveExecutionResult!.ExecutedPrimitives
+ .Select(p => (p.OpIndex, p.FeatureId, p.Kind, BodyCount: p.Body.Topology.Bodies.Count(), FaceCount: p.Body.Topology.Faces.Count()))
+ .ToArray();
+
+ Assert.Equal(firstMetadata, secondMetadata);
+ }
+
+ private static FirmamentCompileResult CompileFixture(string fixturePath)
+ {
+ var source = FirmamentCorpusHarness.ReadFixtureText(fixturePath);
+ var compiler = new FirmamentCompiler();
+ return compiler.Compile(new FirmamentCompileRequest(new FirmamentSourceDocument(source)));
+ }
+}
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentScaffoldTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentScaffoldTests.cs
index 4299754c..b312ef13 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentScaffoldTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentScaffoldTests.cs
@@ -37,7 +37,7 @@ public sealed class FirmamentScaffoldTests
Assert.True(result.Compilation.IsSuccess);
var artifact = result.Compilation.Value;
- Assert.Equal("firmament-primitive-and-boolean-lowering-plan-built", artifact.ArtifactKind);
+ Assert.Equal("firmament-primitives-executed", artifact.ArtifactKind);
Assert.NotNull(artifact.ParsedDocument);
Assert.Equal("1", artifact.ParsedDocument!.Firmament.Version);
Assert.Equal("demo", artifact.ParsedDocument.Model.Name);
diff --git a/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutionResult.cs b/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutionResult.cs
new file mode 100644
index 00000000..58fae990
--- /dev/null
+++ b/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutionResult.cs
@@ -0,0 +1,13 @@
+using Aetheris.Kernel.Core.Brep;
+using Aetheris.Kernel.Firmament.Lowering;
+
+namespace Aetheris.Kernel.Firmament.Execution;
+
+public sealed record FirmamentPrimitiveExecutionResult(
+ IReadOnlyList<FirmamentExecutedPrimitive> ExecutedPrimitives);
+
+public sealed record FirmamentExecutedPrimitive(
+ int OpIndex,
+ string FeatureId,
+ FirmamentLoweredPrimitiveKind Kind,
+ BrepBody Body);
diff --git a/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs b/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs
new file mode 100644
index 00000000..eebc0680
--- /dev/null
+++ b/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs
@@ -0,0 +1,66 @@
+using Aetheris.Kernel.Core.Brep;
+using Aetheris.Kernel.Core.Diagnostics;
+using Aetheris.Kernel.Core.Results;
+using Aetheris.Kernel.Firmament.Lowering;
+
+namespace Aetheris.Kernel.Firmament.Execution;
+
+internal static class FirmamentPrimitiveExecutor
+{
+ public static KernelResult<FirmamentPrimitiveExecutionResult> Execute(FirmamentPrimitiveLoweringPlan loweringPlan)
+ {
+ ArgumentNullException.ThrowIfNull(loweringPlan);
+
+ var executedPrimitives = new List<FirmamentExecutedPrimitive>(loweringPlan.Primitives.Count);
+
+ foreach (var primitive in loweringPlan.Primitives.OrderBy(p => p.OpIndex))
+ {
+ var bodyResult = ExecutePrimitive(primitive);
+ if (!bodyResult.IsSuccess)
+ {
+ return KernelResult<FirmamentPrimitiveExecutionResult>.Failure(bodyResult.Diagnostics);
+ }
+
+ executedPrimitives.Add(new FirmamentExecutedPrimitive(
+ OpIndex: primitive.OpIndex,
+ FeatureId: primitive.FeatureId,
+ Kind: primitive.Kind,
+ Body: bodyResult.Value));
+ }
+
+ return KernelResult<FirmamentPrimitiveExecutionResult>.Success(new FirmamentPrimitiveExecutionResult(executedPrimitives));
+ }
+
+ private static KernelResult<BrepBody> ExecutePrimitive(FirmamentLoweredPrimitive primitive)
+ {
+ return primitive.Kind switch
+ {
+ FirmamentLoweredPrimitiveKind.Box => ExecuteBox(primitive),
+ FirmamentLoweredPrimitiveKind.Cylinder => ExecuteCylinder(primitive),
+ FirmamentLoweredPrimitiveKind.Sphere => ExecuteSphere(primitive),
+ _ => KernelResult<BrepBody>.Failure([
+ new KernelDiagnostic(
+ KernelDiagnosticCode.NotImplemented,
+ KernelDiagnosticSeverity.Error,
+ $"Primitive execution for kind '{primitive.Kind}' is not implemented.")])
+ };
+ }
+
+ private static KernelResult<BrepBody> ExecuteBox(FirmamentLoweredPrimitive primitive)
+ {
+ var parameters = (FirmamentLoweredBoxParameters)primitive.Parameters;
+ return BrepPrimitives.CreateBox(parameters.SizeX, parameters.SizeY, parameters.SizeZ);
+ }
+
+ private static KernelResult<BrepBody> ExecuteCylinder(FirmamentLoweredPrimitive primitive)
+ {
+ var parameters = (FirmamentLoweredCylinderParameters)primitive.Parameters;
+ return BrepPrimitives.CreateCylinder(parameters.Radius, parameters.Height);
+ }
+
+ private static KernelResult<BrepBody> ExecuteSphere(FirmamentLoweredPrimitive primitive)
+ {
+ var parameters = (FirmamentLoweredSphereParameters)primitive.Parameters;
+ return BrepPrimitives.CreateSphere(parameters.Radius);
+ }
+}
diff --git a/Aetheris.Kernel.Firmament/FirmamentCompilationArtifact.cs b/Aetheris.Kernel.Firmament/FirmamentCompilationArtifact.cs
index 9735fb2b..c29d2cfb 100644
--- a/Aetheris.Kernel.Firmament/FirmamentCompilationArtifact.cs
+++ b/Aetheris.Kernel.Firmament/FirmamentCompilationArtifact.cs
@@ -1,9 +1,11 @@
using Aetheris.Kernel.Firmament.Lowering;
+using Aetheris.Kernel.Firmament.Execution;
using Aetheris.Kernel.Firmament.ParsedModel;
namespace Aetheris.Kernel.Firmament;
public sealed record FirmamentCompilationArtifact(
- string ArtifactKind = "firmament-primitive-and-boolean-lowering-plan-built",
+ string ArtifactKind = "firmament-primitives-executed",
FirmamentParsedDocument? ParsedDocument = null,
- FirmamentPrimitiveLoweringPlan? PrimitiveLoweringPlan = null);
+ FirmamentPrimitiveLoweringPlan? PrimitiveLoweringPlan = null,
+ FirmamentPrimitiveExecutionResult? PrimitiveExecutionResult = null);
diff --git a/Aetheris.Kernel.Firmament/FirmamentCompiler.cs b/Aetheris.Kernel.Firmament/FirmamentCompiler.cs
index e5b98dd3..f4a89051 100644
--- a/Aetheris.Kernel.Firmament/FirmamentCompiler.cs
+++ b/Aetheris.Kernel.Firmament/FirmamentCompiler.cs
@@ -1,4 +1,5 @@
using Aetheris.Kernel.Core.Results;
+using Aetheris.Kernel.Firmament.Execution;
using Aetheris.Kernel.Firmament.Lowering;
using Aetheris.Kernel.Firmament.Parsing;
using Aetheris.Kernel.Firmament.Validation;
@@ -60,11 +61,19 @@ public sealed class FirmamentCompiler
KernelResult<FirmamentCompilationArtifact>.Failure(primitiveLoweringResult.Diagnostics));
}
+ var primitiveExecutionResult = FirmamentPrimitiveExecutor.Execute(primitiveLoweringResult.Value);
+ if (!primitiveExecutionResult.IsSuccess)
+ {
+ return new FirmamentCompileResult(
+ KernelResult<FirmamentCompilationArtifact>.Failure(primitiveExecutionResult.Diagnostics));
+ }
+
return new FirmamentCompileResult(
KernelResult<FirmamentCompilationArtifact>.Success(
new FirmamentCompilationArtifact(
- ArtifactKind: "firmament-primitive-and-boolean-lowering-plan-built",
+ ArtifactKind: "firmament-primitives-executed",
ParsedDocument: targetShapeValidationResult.Value,
- PrimitiveLoweringPlan: primitiveLoweringResult.Value)));
+ PrimitiveLoweringPlan: primitiveLoweringResult.Value,
+ PrimitiveExecutionResult: primitiveExecutionResult.Value)));
}
}
diff --git a/testdata/firmament/fixtures/m3c-mixed-primitive-boolean-validation.firmament b/testdata/firmament/fixtures/m3c-mixed-primitive-boolean-validation.firmament
new file mode 100644
index 00000000..407be4ab
--- /dev/null
+++ b/testdata/firmament/fixtures/m3c-mixed-primitive-boolean-validation.firmament
@@ -0,0 +1,38 @@
+firmament:
+ version: 1
+
+model:
+ name: m3c-mixed
+ units: mm
+
+ops[5]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 10
+ 10
+ 4
+
+ -
+ op: add
+ id: join1
+ to: base
+ with:
+ op: cylinder
+
+ -
+ op: sphere
+ id: cap
+ radius: 3
+
+ -
+ op: subtract
+ id: cut1
+ from: cap
+ with:
+ op: box
+
+ -
+ op: expect_exists
+ target: cap
diff --git a/testdata/firmament/fixtures/m3c-valid-box-exec.firmament b/testdata/firmament/fixtures/m3c-valid-box-exec.firmament
new file mode 100644
index 00000000..c41e7baa
--- /dev/null
+++ b/testdata/firmament/fixtures/m3c-valid-box-exec.firmament
@@ -0,0 +1,15 @@
+firmament:
+ version: 1
+
+model:
+ name: m3c-box
+ units: mm
+
+ops[1]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 10
+ 20
+ 30
diff --git a/testdata/firmament/fixtures/m3c-valid-cylinder-exec.firmament b/testdata/firmament/fixtures/m3c-valid-cylinder-exec.firmament
new file mode 100644
index 00000000..12244b1a
--- /dev/null
+++ b/testdata/firmament/fixtures/m3c-valid-cylinder-exec.firmament
@@ -0,0 +1,13 @@
+firmament:
+ version: 1
+
+model:
+ name: m3c-cylinder
+ units: mm
+
+ops[1]:
+ -
+ op: cylinder
+ id: post
+ radius: 2
+ height: 9
diff --git a/testdata/firmament/fixtures/m3c-valid-multiple-primitives-exec.firmament b/testdata/firmament/fixtures/m3c-valid-multiple-primitives-exec.firmament
new file mode 100644
index 00000000..3d2d216b
--- /dev/null
+++ b/testdata/firmament/fixtures/m3c-valid-multiple-primitives-exec.firmament
@@ -0,0 +1,26 @@
+firmament:
+ version: 1
+
+model:
+ name: m3c-multi
+ units: mm
+
+ops[3]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 8
+ 6
+ 4
+
+ -
+ op: cylinder
+ id: post
+ radius: 1
+ height: 5
+
+ -
+ op: sphere
+ id: ball
+ radius: 2
diff --git a/testdata/firmament/fixtures/m3c-valid-sphere-exec.firmament b/testdata/firmament/fixtures/m3c-valid-sphere-exec.firmament
new file mode 100644
index 00000000..75059cef
--- /dev/null
+++ b/testdata/firmament/fixtures/m3c-valid-sphere-exec.firmament
@@ -0,0 +1,12 @@
+firmament:
+ version: 1
+
+model:
+ name: m3c-sphere
+ units: mm
+
+ops[1]:
+ -
+ op: sphere
+ id: ball
+ radius: 4
diff --git a/testdata/firmament/manifests/m0c.corpus.json b/testdata/firmament/manifests/m0c.corpus.json
index 76b52e1b..11e4d334 100644
--- a/testdata/firmament/manifests/m0c.corpus.json
+++ b/testdata/firmament/manifests/m0c.corpus.json
@@ -718,6 +718,36 @@
"name": "Valid M3a mixed primitive and boolean with primitive-only lowering",
"fixturePath": "testdata/firmament/fixtures/m3a-mixed-primitive-boolean.firmament",
"expectedOutcome": "success"
+ },
+ {
+ "id": "m3c-valid-box-exec",
+ "name": "Valid M3c box primitive execution",
+ "fixturePath": "testdata/firmament/fixtures/m3c-valid-box-exec.firmament",
+ "expectedOutcome": "success"
+ },
+ {
+ "id": "m3c-valid-cylinder-exec",
+ "name": "Valid M3c cylinder primitive execution",
+ "fixturePath": "testdata/firmament/fixtures/m3c-valid-cylinder-exec.firmament",
+ "expectedOutcome": "success"
+ },
+ {
+ "id": "m3c-valid-sphere-exec",
+ "name": "Valid M3c sphere primitive execution",
+ "fixturePath": "testdata/firmament/fixtures/m3c-valid-sphere-exec.firmament",
+ "expectedOutcome": "success"
+ },
+ {
+ "id": "m3c-valid-multiple-primitives-exec",
+ "name": "Valid M3c multiple primitive execution",
+ "fixturePath": "testdata/firmament/fixtures/m3c-valid-multiple-primitives-exec.firmament",
+ "expectedOutcome": "success"
+ },
+ {
+ "id": "m3c-mixed-primitive-boolean-validation",
+ "name": "Valid M3c mixed document executes primitives only",
+ "fixturePath": "testdata/firmament/fixtures/m3c-mixed-primitive-boolean-validation.firmament",
+ "expectedOutcome": "success"
}
]
}