Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Firmament M3b: lower boolean ops into plan

Yuechen Lice174333ab9b
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveLoweringTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveLoweringTests.cs
index 1492f092..f97caf35 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveLoweringTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveLoweringTests.cs
@@ -1,4 +1,5 @@
using Aetheris.Kernel.Firmament.Lowering;
+using Aetheris.Kernel.Firmament.ParsedModel;
namespace Aetheris.Kernel.Firmament.Tests;
@@ -29,6 +30,7 @@ public sealed class FirmamentPrimitiveLoweringTests
Assert.True(result.Compilation.IsSuccess);
var primitive = Assert.Single(result.Compilation.Value.PrimitiveLoweringPlan!.Primitives);
var parameters = Assert.IsType<FirmamentLoweredBoxParameters>(primitive.Parameters);
+ Assert.Equal(0, primitive.OpIndex);
Assert.Equal("base", primitive.FeatureId);
Assert.Equal(FirmamentLoweredPrimitiveKind.Box, primitive.Kind);
Assert.Equal(10, parameters.SizeX);
@@ -91,40 +93,102 @@ public sealed class FirmamentPrimitiveLoweringTests
}
[Fact]
- public void Compile_Lowers_Multiple_Primitives_In_Source_Order()
+ public void Compile_Lowers_Add_Boolean_With_Primary_Reference_And_Coarse_Tool()
{
- var result = Compile(FirmamentCorpusHarness.ReadFixtureText("testdata/firmament/fixtures/m3a-valid-multiple-primitives-lower.firmament"));
+ var result = Compile(FirmamentCorpusHarness.ReadFixtureText("testdata/firmament/fixtures/m1b-valid-add.firmament"));
+
+ Assert.True(result.Compilation.IsSuccess);
+ var boolean = Assert.Single(result.Compilation.Value.PrimitiveLoweringPlan!.Booleans);
+ Assert.Equal(1, boolean.OpIndex);
+ Assert.Equal("add1", boolean.FeatureId);
+ Assert.Equal(FirmamentLoweredBooleanKind.Add, boolean.Kind);
+ Assert.Equal("to", boolean.PrimaryReferenceField);
+ Assert.Equal("base", boolean.PrimaryReferenceFeatureId);
+ Assert.Equal("box", boolean.Tool.OpName);
+ Assert.Equal("box", boolean.Tool.RawFields["op"]);
+ Assert.Equal("{ op: box }", boolean.Tool.RawValue);
+ }
+
+ [Fact]
+ public void Compile_Lowers_Subtract_Boolean_With_Primary_Reference_And_Coarse_Tool()
+ {
+ var result = Compile(FirmamentCorpusHarness.ReadFixtureText("testdata/firmament/fixtures/m1b-valid-subtract.firmament"));
+
+ Assert.True(result.Compilation.IsSuccess);
+ var boolean = Assert.Single(result.Compilation.Value.PrimitiveLoweringPlan!.Booleans);
+ Assert.Equal(FirmamentLoweredBooleanKind.Subtract, boolean.Kind);
+ Assert.Equal("from", boolean.PrimaryReferenceField);
+ Assert.Equal("base", boolean.PrimaryReferenceFeatureId);
+ Assert.Equal("sphere", boolean.Tool.OpName);
+ }
+
+ [Fact]
+ public void Compile_Lowers_Intersect_Boolean_With_Primary_Reference_And_Coarse_Tool()
+ {
+ var result = Compile(FirmamentCorpusHarness.ReadFixtureText("testdata/firmament/fixtures/m1b-valid-intersect.firmament"));
+
+ Assert.True(result.Compilation.IsSuccess);
+ var boolean = Assert.Single(result.Compilation.Value.PrimitiveLoweringPlan!.Booleans);
+ Assert.Equal(FirmamentLoweredBooleanKind.Intersect, boolean.Kind);
+ Assert.Equal("left", boolean.PrimaryReferenceField);
+ Assert.Equal("base", boolean.PrimaryReferenceFeatureId);
+ Assert.Equal("cylinder", boolean.Tool.OpName);
+ }
+
+ [Fact]
+ public void Compile_Lowers_Mixed_Primitive_And_Boolean_In_Source_Order_With_Preserved_Ids()
+ {
+ var result = Compile(FirmamentCorpusHarness.ReadFixtureText("testdata/firmament/fixtures/m3b-mixed-primitive-boolean-validation.firmament"));
Assert.True(result.Compilation.IsSuccess);
var plan = result.Compilation.Value.PrimitiveLoweringPlan!;
+
Assert.Collection(
plan.Primitives,
- p => Assert.Equal("b1", p.FeatureId),
- p => Assert.Equal("c1", p.FeatureId),
- p => Assert.Equal("s1", p.FeatureId));
- Assert.Empty(plan.SkippedOps);
+ p =>
+ {
+ Assert.Equal(0, p.OpIndex);
+ Assert.Equal("base", p.FeatureId);
+ },
+ p =>
+ {
+ Assert.Equal(2, p.OpIndex);
+ Assert.Equal("cap", p.FeatureId);
+ });
+
+ Assert.Collection(
+ plan.Booleans,
+ b =>
+ {
+ Assert.Equal(1, b.OpIndex);
+ Assert.Equal("join1", b.FeatureId);
+ Assert.Equal("to", b.PrimaryReferenceField);
+ },
+ b =>
+ {
+ Assert.Equal(3, b.OpIndex);
+ Assert.Equal("cut1", b.FeatureId);
+ Assert.Equal("from", b.PrimaryReferenceField);
+ });
}
[Fact]
- public void Compile_Mixed_Primitive_And_Boolean_Produces_Explicit_SkippedOps()
+ public void Compile_Validation_Family_Ops_Remain_Explicitly_NonLowered()
{
- var result = Compile(FirmamentCorpusHarness.ReadFixtureText("testdata/firmament/fixtures/m3a-mixed-primitive-boolean.firmament"));
+ var result = Compile(FirmamentCorpusHarness.ReadFixtureText("testdata/firmament/fixtures/m3b-mixed-primitive-boolean-validation.firmament"));
Assert.True(result.Compilation.IsSuccess);
- var plan = result.Compilation.Value.PrimitiveLoweringPlan!;
- var primitive = Assert.Single(plan.Primitives);
- var skipped = Assert.Single(plan.SkippedOps);
-
- Assert.Equal("base", primitive.FeatureId);
- Assert.Equal(1, skipped.OpIndex);
- Assert.Equal("add", skipped.OpName);
- Assert.Equal("unsupported-op-in-m3a-primitive-only-lowering", skipped.Reason);
+ var skipped = Assert.Single(result.Compilation.Value.PrimitiveLoweringPlan!.SkippedOps);
+ Assert.Equal(4, skipped.OpIndex);
+ Assert.Equal(FirmamentOpFamily.Validation, skipped.Family);
+ Assert.Equal("expect_exists", skipped.OpName);
+ Assert.Equal("unsupported-op-in-m3b-boolean-lowering", skipped.Reason);
}
[Fact]
- public void Compile_Primitive_Lowering_Output_Is_Deterministic()
+ public void Compile_Primitive_And_Boolean_Lowering_Output_Is_Deterministic()
{
- var source = FirmamentCorpusHarness.ReadFixtureText("testdata/firmament/fixtures/m3a-valid-primitive-only-lower.firmament");
+ var source = FirmamentCorpusHarness.ReadFixtureText("testdata/firmament/fixtures/m3b-valid-primitives-and-booleans-lower.firmament");
var first = Compile(source);
var second = Compile(source);
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentScaffoldTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentScaffoldTests.cs
index 572181ac..4299754c 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-lowering-plan-built", artifact.ArtifactKind);
+ Assert.Equal("firmament-primitive-and-boolean-lowering-plan-built", 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/FirmamentCompilationArtifact.cs b/Aetheris.Kernel.Firmament/FirmamentCompilationArtifact.cs
index c634862b..9735fb2b 100644
--- a/Aetheris.Kernel.Firmament/FirmamentCompilationArtifact.cs
+++ b/Aetheris.Kernel.Firmament/FirmamentCompilationArtifact.cs
@@ -4,6 +4,6 @@ using Aetheris.Kernel.Firmament.ParsedModel;
namespace Aetheris.Kernel.Firmament;
public sealed record FirmamentCompilationArtifact(
- string ArtifactKind = "firmament-primitive-lowering-plan-built",
+ string ArtifactKind = "firmament-primitive-and-boolean-lowering-plan-built",
FirmamentParsedDocument? ParsedDocument = null,
FirmamentPrimitiveLoweringPlan? PrimitiveLoweringPlan = null);
diff --git a/Aetheris.Kernel.Firmament/FirmamentCompiler.cs b/Aetheris.Kernel.Firmament/FirmamentCompiler.cs
index 3412d077..e5b98dd3 100644
--- a/Aetheris.Kernel.Firmament/FirmamentCompiler.cs
+++ b/Aetheris.Kernel.Firmament/FirmamentCompiler.cs
@@ -63,7 +63,7 @@ public sealed class FirmamentCompiler
return new FirmamentCompileResult(
KernelResult<FirmamentCompilationArtifact>.Success(
new FirmamentCompilationArtifact(
- ArtifactKind: "firmament-primitive-lowering-plan-built",
+ ArtifactKind: "firmament-primitive-and-boolean-lowering-plan-built",
ParsedDocument: targetShapeValidationResult.Value,
PrimitiveLoweringPlan: primitiveLoweringResult.Value)));
}
diff --git a/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLowerer.cs b/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLowerer.cs
index 522d2265..ecbb48f4 100644
--- a/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLowerer.cs
+++ b/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLowerer.cs
@@ -8,13 +8,14 @@ namespace Aetheris.Kernel.Firmament.Lowering;
internal static class FirmamentPrimitiveLowerer
{
- private const string PrimitiveOnlySkipReason = "unsupported-op-in-m3a-primitive-only-lowering";
+ private const string ValidationSkipReason = "unsupported-op-in-m3b-boolean-lowering";
public static KernelResult<FirmamentPrimitiveLoweringPlan> Lower(FirmamentParsedDocument parsedDocument)
{
ArgumentNullException.ThrowIfNull(parsedDocument);
var loweredPrimitives = new List<FirmamentLoweredPrimitive>();
+ var loweredBooleans = new List<FirmamentLoweredBoolean>();
var skippedOps = new List<FirmamentLoweringSkippedOp>();
for (var index = 0; index < parsedDocument.Ops.Entries.Count; index++)
@@ -24,6 +25,7 @@ internal static class FirmamentPrimitiveLowerer
{
case FirmamentKnownOpKind.Box:
loweredPrimitives.Add(new FirmamentLoweredPrimitive(
+ OpIndex: index,
FeatureId: entry.RawFields["id"],
Kind: FirmamentLoweredPrimitiveKind.Box,
Parameters: LowerBoxParameters(entry.RawFields["size"])));
@@ -31,6 +33,7 @@ internal static class FirmamentPrimitiveLowerer
case FirmamentKnownOpKind.Cylinder:
loweredPrimitives.Add(new FirmamentLoweredPrimitive(
+ OpIndex: index,
FeatureId: entry.RawFields["id"],
Kind: FirmamentLoweredPrimitiveKind.Cylinder,
Parameters: new FirmamentLoweredCylinderParameters(
@@ -40,24 +43,99 @@ internal static class FirmamentPrimitiveLowerer
case FirmamentKnownOpKind.Sphere:
loweredPrimitives.Add(new FirmamentLoweredPrimitive(
+ OpIndex: index,
FeatureId: entry.RawFields["id"],
Kind: FirmamentLoweredPrimitiveKind.Sphere,
Parameters: new FirmamentLoweredSphereParameters(
Radius: ParseScalar(entry.RawFields["radius"]))));
break;
+ case FirmamentKnownOpKind.Add:
+ loweredBooleans.Add(LowerBoolean(index, entry, FirmamentLoweredBooleanKind.Add, "to"));
+ break;
+
+ case FirmamentKnownOpKind.Subtract:
+ loweredBooleans.Add(LowerBoolean(index, entry, FirmamentLoweredBooleanKind.Subtract, "from"));
+ break;
+
+ case FirmamentKnownOpKind.Intersect:
+ loweredBooleans.Add(LowerBoolean(index, entry, FirmamentLoweredBooleanKind.Intersect, "left"));
+ break;
+
default:
skippedOps.Add(new FirmamentLoweringSkippedOp(
OpIndex: index,
OpName: entry.OpName,
KnownKind: entry.KnownKind,
Family: entry.Family,
- Reason: PrimitiveOnlySkipReason));
+ Reason: ValidationSkipReason));
break;
}
}
- return KernelResult<FirmamentPrimitiveLoweringPlan>.Success(new FirmamentPrimitiveLoweringPlan(loweredPrimitives, skippedOps));
+ return KernelResult<FirmamentPrimitiveLoweringPlan>.Success(new FirmamentPrimitiveLoweringPlan(loweredPrimitives, loweredBooleans, skippedOps));
+ }
+
+ private static FirmamentLoweredBoolean LowerBoolean(
+ int opIndex,
+ FirmamentParsedOpEntry entry,
+ FirmamentLoweredBooleanKind booleanKind,
+ string primaryFieldName)
+ {
+ var tool = ParseTool(entry.RawFields["with"]);
+
+ return new FirmamentLoweredBoolean(
+ OpIndex: opIndex,
+ FeatureId: entry.RawFields["id"],
+ Kind: booleanKind,
+ PrimaryReferenceField: primaryFieldName,
+ PrimaryReferenceFeatureId: entry.RawFields[primaryFieldName],
+ Tool: tool);
+ }
+
+ private static FirmamentLoweredToolOp ParseTool(string rawWith)
+ {
+ var trimmed = rawWith.Trim();
+
+ if (trimmed.StartsWith("{", StringComparison.Ordinal) && trimmed.EndsWith("}", StringComparison.Ordinal))
+ {
+ var body = trimmed[1..^1].Trim();
+ var pairs = body.Split(',', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries);
+ var fields = new Dictionary<string, string>(StringComparer.Ordinal);
+ foreach (var pair in pairs)
+ {
+ var separator = pair.IndexOf(':');
+ if (separator <= 0)
+ {
+ continue;
+ }
+
+ var key = pair[..separator].Trim();
+ var value = pair[(separator + 1)..].Trim();
+ if (key.Length > 0)
+ {
+ fields[key] = value;
+ }
+ }
+
+ fields.TryGetValue("op", out var opName);
+ return new FirmamentLoweredToolOp(opName ?? string.Empty, fields, rawWith);
+ }
+
+ if (trimmed.StartsWith("{", StringComparison.Ordinal))
+ {
+ using var jsonDoc = JsonDocument.Parse(trimmed);
+ var fields = new Dictionary<string, string>(StringComparer.Ordinal);
+ foreach (var property in jsonDoc.RootElement.EnumerateObject())
+ {
+ fields[property.Name] = property.Value.ToString();
+ }
+
+ fields.TryGetValue("op", out var opName);
+ return new FirmamentLoweredToolOp(opName ?? string.Empty, fields, rawWith);
+ }
+
+ return new FirmamentLoweredToolOp(string.Empty, new Dictionary<string, string>(StringComparer.Ordinal), rawWith);
}
private static FirmamentLoweredBoxParameters LowerBoxParameters(string sizeRaw)
diff --git a/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLoweringPlan.cs b/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLoweringPlan.cs
index 7e5803f9..825da0d3 100644
--- a/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLoweringPlan.cs
+++ b/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLoweringPlan.cs
@@ -4,13 +4,30 @@ namespace Aetheris.Kernel.Firmament.Lowering;
public sealed record FirmamentPrimitiveLoweringPlan(
IReadOnlyList<FirmamentLoweredPrimitive> Primitives,
+ IReadOnlyList<FirmamentLoweredBoolean> Booleans,
IReadOnlyList<FirmamentLoweringSkippedOp> SkippedOps);
public sealed record FirmamentLoweredPrimitive(
+ int OpIndex,
string FeatureId,
FirmamentLoweredPrimitiveKind Kind,
FirmamentLoweredPrimitiveParameters Parameters);
+public sealed record FirmamentLoweredBoolean(
+ int OpIndex,
+ string FeatureId,
+ FirmamentLoweredBooleanKind Kind,
+ string PrimaryReferenceField,
+ string PrimaryReferenceFeatureId,
+ FirmamentLoweredToolOp Tool);
+
+public enum FirmamentLoweredBooleanKind
+{
+ Add,
+ Subtract,
+ Intersect
+}
+
public enum FirmamentLoweredPrimitiveKind
{
Box,
@@ -29,6 +46,11 @@ public sealed record FirmamentLoweredCylinderParameters(double Radius, double He
public sealed record FirmamentLoweredSphereParameters(double Radius)
: FirmamentLoweredPrimitiveParameters;
+public sealed record FirmamentLoweredToolOp(
+ string OpName,
+ IReadOnlyDictionary<string, string> RawFields,
+ string RawValue);
+
public sealed record FirmamentLoweringSkippedOp(
int OpIndex,
string OpName,
diff --git a/testdata/firmament/fixtures/m3b-mixed-primitive-boolean-validation.firmament b/testdata/firmament/fixtures/m3b-mixed-primitive-boolean-validation.firmament
new file mode 100644
index 00000000..adf2d82f
--- /dev/null
+++ b/testdata/firmament/fixtures/m3b-mixed-primitive-boolean-validation.firmament
@@ -0,0 +1,39 @@
+firmament:
+ version: 1
+
+model:
+ name: demo
+ units: mm
+
+ops[5]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 4
+ 5
+ 6
+
+ -
+ op: add
+ id: join1
+ to: base
+ with:
+ op: sphere
+
+ -
+ op: cylinder
+ id: cap
+ radius: 2
+ height: 9
+
+ -
+ op: subtract
+ id: cut1
+ from: join1
+ with:
+ op: box
+
+ -
+ op: expect_exists
+ target: cut1
diff --git a/testdata/firmament/fixtures/m3b-valid-primitives-and-booleans-lower.firmament b/testdata/firmament/fixtures/m3b-valid-primitives-and-booleans-lower.firmament
new file mode 100644
index 00000000..c8beb0a5
--- /dev/null
+++ b/testdata/firmament/fixtures/m3b-valid-primitives-and-booleans-lower.firmament
@@ -0,0 +1,45 @@
+firmament:
+ version: 1
+
+model:
+ name: demo
+ units: mm
+
+ops[6]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 10
+ 10
+ 10
+
+ -
+ op: add
+ id: join1
+ to: base
+ with:
+ op: cylinder
+
+ -
+ op: sphere
+ id: cap
+ radius: 3
+
+ -
+ op: subtract
+ id: cut1
+ from: join1
+ with:
+ op: sphere
+
+ -
+ op: intersect
+ id: clip1
+ left: cut1
+ with:
+ op: box
+
+ -
+ op: expect_exists
+ target: clip1