Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Implement Firmament M8c CNC tool radius validation

Yuechen Li36583458f2e8
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentSchemaCncDfmValidationTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentSchemaCncDfmValidationTests.cs
new file mode 100644
index 00000000..8eff8888
--- /dev/null
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentSchemaCncDfmValidationTests.cs
@@ -0,0 +1,235 @@
+using System.Linq;
+using Aetheris.Kernel.Firmament.Diagnostics;
+
+namespace Aetheris.Kernel.Firmament.Tests;
+
+public sealed class FirmamentSchemaCncDfmValidationTests
+{
+ [Fact]
+ public void Compile_WithoutSchema_DoesNotApply_CncMinimumToolRadiusRule()
+ {
+ const string source = """
+firmament:
+ version: 1
+
+model:
+ name: demo
+ units: mm
+
+ops[2]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 6
+ 6
+ 6
+ -
+ op: subtract
+ id: hole
+ from: base
+ with:
+ op: cylinder
+ radius: 0.5
+ height: 8
+""";
+
+ var result = Compile(source);
+
+ Assert.True(result.Compilation.IsSuccess);
+ var loweredBoolean = Assert.Single(result.Compilation.Value.PrimitiveLoweringPlan!.Booleans);
+ Assert.Equal("hole", loweredBoolean.FeatureId);
+ }
+
+ [Fact]
+ public void Compile_WithCncSchema_Allows_SubtractCylinderMeeting_MinimumToolRadius()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m8c-valid-schema-cnc-minimum-tool-radius.firmament");
+
+ Assert.True(result.Compilation.IsSuccess);
+ var loweredBoolean = Assert.Single(result.Compilation.Value.PrimitiveLoweringPlan!.Booleans);
+ Assert.Equal("hole", loweredBoolean.FeatureId);
+ Assert.Equal("2", loweredBoolean.Tool.RawFields["radius"]);
+ }
+
+ [Fact]
+ public void Compile_WithCncSchema_Rejects_SubtractCylinderBelow_MinimumToolRadius_Deterministically()
+ {
+ var first = CompileFixture("testdata/firmament/fixtures/m8c-invalid-schema-cnc-minimum-tool-radius.firmament");
+ var second = CompileFixture("testdata/firmament/fixtures/m8c-invalid-schema-cnc-minimum-tool-radius.firmament");
+
+ Assert.False(first.Compilation.IsSuccess);
+ Assert.False(second.Compilation.IsSuccess);
+
+ var firstDiagnostic = Assert.Single(first.Compilation.Diagnostics);
+ var secondDiagnostic = Assert.Single(second.Compilation.Diagnostics);
+
+ Assert.Equal(firstDiagnostic.Message, secondDiagnostic.Message);
+ Assert.Contains(FirmamentDiagnosticCodes.SchemaCncMinimumToolRadiusViolated.Value, firstDiagnostic.Message, StringComparison.Ordinal);
+ Assert.Equal(
+ $"[{FirmamentDiagnosticCodes.SchemaCncMinimumToolRadiusViolated.Value}] CNC minimum_tool_radius 2.0 exceeds subtract tool radius 1.0 for feature 'hole'.",
+ firstDiagnostic.Message);
+ }
+
+ [Theory]
+ [InlineData("additive", "printer_resolution: 0.1")]
+ [InlineData("injection_molded", "parting_plane: xy\n gate_location:\n x: 0\n y: 0\n z: 0\n draft_angle: 2")]
+ public void Compile_WithNonCncSchema_DoesNotApply_CncMinimumToolRadiusRule(string process, string schemaFields)
+ {
+ var result = Compile($$"""
+firmament:
+ version: 1
+
+model:
+ name: demo
+ units: mm
+
+schema:
+ process: {{process}}
+ {{schemaFields}}
+
+ops[2]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 6
+ 6
+ 6
+ -
+ op: subtract
+ id: hole
+ from: base
+ with:
+ op: cylinder
+ radius: 0.5
+ height: 8
+""");
+
+ Assert.True(result.Compilation.IsSuccess);
+ Assert.Single(result.Compilation.Value.PrimitiveLoweringPlan!.Booleans);
+ }
+
+ [Fact]
+ public void Compile_WithCncSchema_DoesNotApply_Rule_ToNonCylinderSubtractTools()
+ {
+ const string source = """
+firmament:
+ version: 1
+
+model:
+ name: demo
+ units: mm
+
+schema:
+ process: cnc
+ minimum_tool_radius: 2
+
+ops[2]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 6
+ 6
+ 6
+ -
+ op: subtract
+ id: pocket
+ from: base
+ with:
+ op: sphere
+ radius: 1
+""";
+
+ var result = Compile(source);
+
+ Assert.True(result.Compilation.IsSuccess);
+ var loweredBoolean = Assert.Single(result.Compilation.Value.PrimitiveLoweringPlan!.Booleans);
+ Assert.Equal("pocket", loweredBoolean.FeatureId);
+ }
+
+ [Fact]
+ public void Compile_WithValidCncSchema_Preserves_BooleanExecution_Metadata()
+ {
+ const string baseline = """
+firmament:
+ version: 1
+
+model:
+ name: demo
+ units: mm
+
+ops[2]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 8
+ 8
+ 8
+ -
+ op: subtract
+ id: hole
+ from: base
+ with:
+ op: cylinder
+ radius: 2
+ height: 8
+""";
+
+ const string withSchema = """
+firmament:
+ version: 1
+
+model:
+ name: demo
+ units: mm
+
+schema:
+ process: cnc
+ minimum_tool_radius: 2
+
+ops[2]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 8
+ 8
+ 8
+ -
+ op: subtract
+ id: hole
+ from: base
+ with:
+ op: cylinder
+ radius: 2
+ height: 8
+""";
+
+ var first = Compile(baseline);
+ var second = Compile(withSchema);
+
+ Assert.True(first.Compilation.IsSuccess);
+ Assert.True(second.Compilation.IsSuccess);
+
+ var firstMetadata = first.Compilation.Value.PrimitiveExecutionResult!.ExecutedBooleans
+ .Select(b => (b.OpIndex, b.FeatureId, Kind: b.Kind.ToString(), BodyCount: b.Body.Topology.Bodies.Count(), FaceCount: b.Body.Topology.Faces.Count()))
+ .ToArray();
+ var secondMetadata = second.Compilation.Value.PrimitiveExecutionResult!.ExecutedBooleans
+ .Select(b => (b.OpIndex, b.FeatureId, Kind: b.Kind.ToString(), BodyCount: b.Body.Topology.Bodies.Count(), FaceCount: b.Body.Topology.Faces.Count()))
+ .ToArray();
+
+ Assert.Equal(firstMetadata, secondMetadata);
+ }
+
+ private static FirmamentCompileResult Compile(string source)
+ {
+ var compiler = new FirmamentCompiler();
+ return compiler.Compile(new FirmamentCompileRequest(new FirmamentSourceDocument(source)));
+ }
+
+ private static FirmamentCompileResult CompileFixture(string fixturePath) =>
+ Compile(FirmamentCorpusHarness.ReadFixtureText(fixturePath));
+}
diff --git a/Aetheris.Kernel.Firmament/Diagnostics/FirmamentDiagnosticCodes.cs b/Aetheris.Kernel.Firmament/Diagnostics/FirmamentDiagnosticCodes.cs
index 7f2aa765..e9406243 100644
--- a/Aetheris.Kernel.Firmament/Diagnostics/FirmamentDiagnosticCodes.cs
+++ b/Aetheris.Kernel.Firmament/Diagnostics/FirmamentDiagnosticCodes.cs
@@ -44,6 +44,7 @@ public static class FirmamentDiagnosticCodes
public static readonly FirmamentDiagnosticCode SchemaMissingRequiredField = new($"{FirmamentDiagnosticConventions.SchemaPrefix}-0002");
public static readonly FirmamentDiagnosticCode SchemaInvalidFieldTypeOrShape = new($"{FirmamentDiagnosticConventions.SchemaPrefix}-0003");
public static readonly FirmamentDiagnosticCode SchemaInvalidFieldValue = new($"{FirmamentDiagnosticConventions.SchemaPrefix}-0004");
+ public static readonly FirmamentDiagnosticCode SchemaCncMinimumToolRadiusViolated = new($"{FirmamentDiagnosticConventions.SchemaPrefix}-0005");
public static readonly FirmamentDiagnosticCode LoweringPlaceholder = new($"{FirmamentDiagnosticConventions.LoweringPrefix}-0001");
}
diff --git a/Aetheris.Kernel.Firmament/FirmamentCompiler.cs b/Aetheris.Kernel.Firmament/FirmamentCompiler.cs
index dd32039e..94b8b2c7 100644
--- a/Aetheris.Kernel.Firmament/FirmamentCompiler.cs
+++ b/Aetheris.Kernel.Firmament/FirmamentCompiler.cs
@@ -65,6 +65,13 @@ public sealed class FirmamentCompiler
var validatedDocument = documentCoherenceValidationResult.Value;
var compiledSchema = FirmamentCompiledSchemaMapper.Map(validatedDocument.Schema);
+ var schemaDfmValidationResult = FirmamentSchemaCncDfmValidator.Validate(validatedDocument, compiledSchema);
+ if (!schemaDfmValidationResult.IsSuccess)
+ {
+ return new FirmamentCompileResult(
+ KernelResult<FirmamentCompilationArtifact>.Failure(schemaDfmValidationResult.Diagnostics));
+ }
+
var primitiveLoweringResult = FirmamentPrimitiveLowerer.Lower(validatedDocument);
if (!primitiveLoweringResult.IsSuccess)
{
diff --git a/Aetheris.Kernel.Firmament/Validation/FirmamentSchemaCncDfmValidator.cs b/Aetheris.Kernel.Firmament/Validation/FirmamentSchemaCncDfmValidator.cs
new file mode 100644
index 00000000..37763927
--- /dev/null
+++ b/Aetheris.Kernel.Firmament/Validation/FirmamentSchemaCncDfmValidator.cs
@@ -0,0 +1,179 @@
+using System.Globalization;
+using System.Text.Json;
+using Aetheris.Kernel.Core.Diagnostics;
+using Aetheris.Kernel.Core.Results;
+using Aetheris.Kernel.Firmament.CompiledModel;
+using Aetheris.Kernel.Firmament.Diagnostics;
+using Aetheris.Kernel.Firmament.ParsedModel;
+
+namespace Aetheris.Kernel.Firmament.Validation;
+
+internal static class FirmamentSchemaCncDfmValidator
+{
+ public static KernelResult<bool> Validate(FirmamentParsedDocument parsedDocument, FirmamentCompiledSchema? compiledSchema)
+ {
+ ArgumentNullException.ThrowIfNull(parsedDocument);
+
+ if (compiledSchema?.Process != FirmamentCompiledSchemaProcess.Cnc
+ || compiledSchema.Payload is not FirmamentCompiledCncSchema cncSchema)
+ {
+ return KernelResult<bool>.Success(true);
+ }
+
+ for (var index = 0; index < parsedDocument.Ops.Entries.Count; index++)
+ {
+ var entry = parsedDocument.Ops.Entries[index];
+ if (entry.KnownKind != FirmamentKnownOpKind.Subtract)
+ {
+ continue;
+ }
+
+ if (!entry.RawFields.TryGetValue("with", out var withRaw)
+ || string.IsNullOrWhiteSpace(withRaw)
+ || !TryGetWithFields(withRaw, out var withFields)
+ || !withFields.TryGetValue("op", out var withOpRaw)
+ || !string.Equals(withOpRaw, "cylinder", StringComparison.Ordinal))
+ {
+ continue;
+ }
+
+ if (!withFields.TryGetValue("radius", out var radiusRaw)
+ || !double.TryParse(radiusRaw, NumberStyles.Float, CultureInfo.InvariantCulture, out var radius))
+ {
+ continue;
+ }
+
+ if (radius >= cncSchema.MinimumToolRadius)
+ {
+ continue;
+ }
+
+ var featureId = entry.RawFields.TryGetValue("id", out var rawId) && !string.IsNullOrWhiteSpace(rawId)
+ ? rawId
+ : $"op_index_{index}";
+
+ return KernelResult<bool>.Failure([
+ CreateDiagnostic(
+ FirmamentDiagnosticCodes.SchemaCncMinimumToolRadiusViolated,
+ $"CNC minimum_tool_radius {FormatNumeric(cncSchema.MinimumToolRadius)} exceeds subtract tool radius {FormatNumeric(radius)} for feature '{featureId}'.")]);
+ }
+
+ return KernelResult<bool>.Success(true);
+ }
+
+ private static string FormatNumeric(double value) =>
+ value.ToString("0.0###############", CultureInfo.InvariantCulture);
+
+ private static bool TryGetWithFields(string raw, out Dictionary<string, string> fields)
+ {
+ fields = new Dictionary<string, string>(StringComparer.Ordinal);
+
+ if (TryParseJsonObject(raw, out var objectElement))
+ {
+ foreach (var property in objectElement.EnumerateObject())
+ {
+ fields[property.Name] = property.Value.ToString();
+ }
+
+ return true;
+ }
+
+ return TryParseToonInlineObject(raw, out fields);
+ }
+
+ private static bool TryParseJsonObject(string raw, out JsonElement objectElement)
+ {
+ objectElement = default;
+
+ try
+ {
+ using var document = JsonDocument.Parse(raw);
+ if (document.RootElement.ValueKind != JsonValueKind.Object)
+ {
+ return false;
+ }
+
+ objectElement = document.RootElement.Clone();
+ return true;
+ }
+ catch (JsonException)
+ {
+ return false;
+ }
+ }
+
+ private static bool TryParseToonInlineObject(string raw, out Dictionary<string, string> fields)
+ {
+ fields = new Dictionary<string, string>(StringComparer.Ordinal);
+ var trimmed = raw.Trim();
+ if (!trimmed.StartsWith("{", StringComparison.Ordinal) || !trimmed.EndsWith("}", StringComparison.Ordinal))
+ {
+ return false;
+ }
+
+ var inner = trimmed[1..^1].Trim();
+ if (inner.Length == 0)
+ {
+ return true;
+ }
+
+ foreach (var part in SplitTopLevelCommaSeparated(inner))
+ {
+ var separator = part.IndexOf(':');
+ if (separator <= 0)
+ {
+ return false;
+ }
+
+ var name = NormalizeArrayFieldName(part[..separator].Trim());
+ var value = part[(separator + 1)..].Trim();
+ if (name.Length == 0)
+ {
+ return false;
+ }
+
+ fields[name] = value;
+ }
+
+ return true;
+ }
+
+ private static List<string> SplitTopLevelCommaSeparated(string input)
+ {
+ var parts = new List<string>();
+ var depth = 0;
+ var start = 0;
+
+ for (var i = 0; i < input.Length; i++)
+ {
+ var ch = input[i];
+ switch (ch)
+ {
+ case '{':
+ case '[':
+ depth++;
+ break;
+ case '}':
+ case ']':
+ depth--;
+ break;
+ case ',' when depth == 0:
+ parts.Add(input[start..i].Trim());
+ start = i + 1;
+ break;
+ }
+ }
+
+ parts.Add(input[start..].Trim());
+ return parts;
+ }
+
+ private static string NormalizeArrayFieldName(string fieldName)
+ {
+ var bracketIndex = fieldName.IndexOf('[', StringComparison.Ordinal);
+ return bracketIndex >= 0 ? fieldName[..bracketIndex] : fieldName;
+ }
+
+ private static KernelDiagnostic CreateDiagnostic(FirmamentDiagnosticCode code, string message) =>
+ new(KernelDiagnosticCode.ValidationFailed, KernelDiagnosticSeverity.Error, $"[{code.Value}] {message}", FirmamentDiagnosticConventions.Source);
+}
diff --git a/testdata/firmament/fixtures/m8c-invalid-schema-cnc-minimum-tool-radius.firmament b/testdata/firmament/fixtures/m8c-invalid-schema-cnc-minimum-tool-radius.firmament
new file mode 100644
index 00000000..6c1ece8c
--- /dev/null
+++ b/testdata/firmament/fixtures/m8c-invalid-schema-cnc-minimum-tool-radius.firmament
@@ -0,0 +1,28 @@
+firmament:
+ version: 1
+
+model:
+ name: m8c-invalid-cnc-tool-radius
+ units: mm
+
+schema:
+ process: cnc
+ minimum_tool_radius: 2
+
+ops[2]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 8
+ 8
+ 8
+
+ -
+ op: subtract
+ id: hole
+ from: base
+ with:
+ op: cylinder
+ radius: 1
+ height: 8
diff --git a/testdata/firmament/fixtures/m8c-valid-schema-cnc-minimum-tool-radius.firmament b/testdata/firmament/fixtures/m8c-valid-schema-cnc-minimum-tool-radius.firmament
new file mode 100644
index 00000000..7244ed7f
--- /dev/null
+++ b/testdata/firmament/fixtures/m8c-valid-schema-cnc-minimum-tool-radius.firmament
@@ -0,0 +1,28 @@
+firmament:
+ version: 1
+
+model:
+ name: m8c-valid-cnc-tool-radius
+ units: mm
+
+schema:
+ process: cnc
+ minimum_tool_radius: 2
+
+ops[2]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 8
+ 8
+ 8
+
+ -
+ op: subtract
+ id: hole
+ from: base
+ with:
+ op: cylinder
+ radius: 2
+ height: 8