Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
Implement bounded CNC manufacturability schema baseline
Yuechen Li1750d10a525f
diff --git a/Aetheris.Kernel.Core.Tests/Brep/Queries/BrepCncManufacturabilitySchemaTests.cs b/Aetheris.Kernel.Core.Tests/Brep/Queries/BrepCncManufacturabilitySchemaTests.csnew file mode 100644index 00000000..22605e91--- /dev/null+++ b/Aetheris.Kernel.Core.Tests/Brep/Queries/BrepCncManufacturabilitySchemaTests.cs@@ -0,0 +1,104 @@+using Aetheris.Kernel.Core.Brep;+using Aetheris.Kernel.Core.Brep.Boolean;+using Aetheris.Kernel.Core.Brep.Queries;+using Aetheris.Kernel.Core.Math;++namespace Aetheris.Kernel.Core.Tests.Brep.Queries;++public sealed class BrepCncManufacturabilitySchemaTests+{+ [Fact]+ public void Evaluate_PassingCanonicalBody_ReturnsPassWithoutIssues()+ {+ var body = CreateOccupiedCellBody([+ new AxisAlignedBoxExtents(0d, 4d, 0d, 3d, 0d, 2d),+ ]);++ var result = BrepCncManufacturabilitySchema.Evaluate(body, new CncManufacturabilitySchemaInput(0.25d, 0.5d));++ Assert.True(result.IsPass);+ Assert.Empty(result.Issues);+ }++ [Fact]+ public void Evaluate_LShapedInternalSharpCorner_ViolatesMinimumToolRadius()+ {+ var body = CreateOccupiedCellBody([+ new AxisAlignedBoxExtents(0d, 2d, 0d, 2d, 0d, 1d),+ new AxisAlignedBoxExtents(2d, 4d, 0d, 2d, 0d, 1d),+ new AxisAlignedBoxExtents(0d, 2d, 2d, 4d, 0d, 1d),+ ]);++ var result = BrepCncManufacturabilitySchema.Evaluate(body, new CncManufacturabilitySchemaInput(0.75d, 0.5d));++ Assert.False(result.IsPass);+ var violation = Assert.Single(result.Issues.Where(issue => issue.Kind == CncManufacturabilityIssueKind.Violation && issue.RuleId == CncManufacturabilityRuleIds.MinimumInternalCornerRadius));+ Assert.Equal(0d, violation.MeasuredValue);+ Assert.Equal(0.75d, violation.RequiredThreshold);+ Assert.StartsWith("edge:", violation.Location, StringComparison.Ordinal);+ }++ [Fact]+ public void Evaluate_ThinWall_ViolatesMinimumWallThickness()+ {+ var body = CreateOccupiedCellBody([+ new AxisAlignedBoxExtents(0d, 8d, 0d, 0.5d, 0d, 2d),+ ]);++ var result = BrepCncManufacturabilitySchema.Evaluate(body, new CncManufacturabilitySchemaInput(0.25d, 1d));++ Assert.False(result.IsPass);+ Assert.Contains(result.Issues, issue =>+ issue.Kind == CncManufacturabilityIssueKind.Violation+ && issue.RuleId == CncManufacturabilityRuleIds.MinimumWallThickness+ && issue.MeasuredValue.HasValue+ && issue.MeasuredValue.Value < 1d);+ }++ [Fact]+ public void Evaluate_NonPlanarBody_ReturnsExplicitUnsupportedDiagnostic()+ {+ var sphere = BrepPrimitives.CreateSphere(2d).Value;++ var result = BrepCncManufacturabilitySchema.Evaluate(sphere, new CncManufacturabilitySchemaInput(0.5d, 1d));++ Assert.False(result.IsPass);+ Assert.Contains(result.Issues, issue =>+ issue.Kind == CncManufacturabilityIssueKind.Unsupported+ && issue.RuleId == CncManufacturabilityRuleIds.MinimumWallThickness+ && issue.Message.Contains("planar", StringComparison.OrdinalIgnoreCase));+ }++ private static BrepBody CreateOccupiedCellBody(IReadOnlyList<AxisAlignedBoxExtents> cells)+ {+ var built = BrepBooleanOrthogonalUnionBuilder.BuildFromCells(cells);+ Assert.True(built.IsSuccess);++ var minX = cells.Min(c => c.MinX);+ var maxX = cells.Max(c => c.MaxX);+ var minY = cells.Min(c => c.MinY);+ var maxY = cells.Max(c => c.MaxY);+ var minZ = cells.Min(c => c.MinZ);+ var maxZ = cells.Max(c => c.MaxZ);++ var composition = new SafeBooleanComposition(+ new AxisAlignedBoxExtents(minX, maxX, minY, maxY, minZ, maxZ),+ [],+ SafeBooleanRootDescriptor.FromBox(new AxisAlignedBoxExtents(minX, maxX, minY, maxY, minZ, maxZ)),+ OccupiedCells: cells);++ return new BrepBody(+ built.Value.Topology,+ built.Value.Geometry,+ built.Value.Bindings,+ built.Value.Topology.Vertices+ .Where(v => built.Value.TryGetVertexPoint(v.Id, out _))+ .ToDictionary(v => v.Id, v =>+ {+ built.Value.TryGetVertexPoint(v.Id, out var point);+ return point;+ }),+ composition,+ built.Value.ShellRepresentation);+ }+}diff --git a/Aetheris.Kernel.Core/Brep/Queries/BrepCncManufacturabilitySchema.cs b/Aetheris.Kernel.Core/Brep/Queries/BrepCncManufacturabilitySchema.csnew file mode 100644index 00000000..495ab0b2--- /dev/null+++ b/Aetheris.Kernel.Core/Brep/Queries/BrepCncManufacturabilitySchema.cs@@ -0,0 +1,277 @@+using Aetheris.Kernel.Core.Geometry.Surfaces;+using Aetheris.Kernel.Core.Geometry;+using Aetheris.Kernel.Core.Math;+using Aetheris.Kernel.Core.Numerics;+using Aetheris.Kernel.Core.Topology;++namespace Aetheris.Kernel.Core.Brep.Queries;++public static class BrepCncManufacturabilitySchema+{+ public static CncManufacturabilitySchemaResult Evaluate(+ BrepBody body,+ CncManufacturabilitySchemaInput input,+ ToleranceContext? tolerance = null)+ {+ ArgumentNullException.ThrowIfNull(body);++ var context = tolerance ?? ToleranceContext.Default;+ var issues = new List<CncManufacturabilitySchemaIssue>();++ EvaluateInternalCornerRadiusRule(body, input, issues, context);+ EvaluateMinimumWallThicknessRule(body, input, issues, context);++ var hasFailure = issues.Any(issue => issue.Kind is CncManufacturabilityIssueKind.Violation or CncManufacturabilityIssueKind.Unsupported);+ return new CncManufacturabilitySchemaResult(!hasFailure, issues);+ }++ private static void EvaluateInternalCornerRadiusRule(+ BrepBody body,+ CncManufacturabilitySchemaInput input,+ List<CncManufacturabilitySchemaIssue> issues,+ ToleranceContext tolerance)+ {+ var concaveEdges = BrepManufacturingQueries.EnumerateInternalConcaveEdges(body, tolerance);+ if (!concaveEdges.IsSuccess)+ {+ issues.Add(new CncManufacturabilitySchemaIssue(+ CncManufacturabilityIssueKind.Unsupported,+ CncManufacturabilityRuleIds.MinimumInternalCornerRadius,+ Location: "body",+ MeasuredValue: null,+ RequiredThreshold: input.MinimumToolRadius,+ "Cannot evaluate minimum internal corner radius: internal concave-edge query is unsupported for this body."));+ return;+ }++ foreach (var edge in concaveEdges.Value)+ {+ if (!edge.RequiresFiniteToolRadius)+ {+ continue;+ }++ if (edge.MinimumToolRadiusLowerBound + tolerance.Linear >= input.MinimumToolRadius)+ {+ continue;+ }++ issues.Add(new CncManufacturabilitySchemaIssue(+ CncManufacturabilityIssueKind.Violation,+ CncManufacturabilityRuleIds.MinimumInternalCornerRadius,+ Location: $"edge:{edge.EdgeId.Value}",+ MeasuredValue: edge.MinimumToolRadiusLowerBound,+ RequiredThreshold: input.MinimumToolRadius,+ $"Internal concave edge '{edge.EdgeId}' is sharp/local-radius-bounded below minimum tool radius."));+ }+ }++ private static void EvaluateMinimumWallThicknessRule(+ BrepBody body,+ CncManufacturabilitySchemaInput input,+ List<CncManufacturabilitySchemaIssue> issues,+ ToleranceContext tolerance)+ {+ var planarFaces = new List<(FaceId FaceId, PlaneSurface Plane)>();+ var hasNonPlanarFace = false;++ foreach (var binding in body.Bindings.FaceBindings)+ {+ if (!body.TryGetFaceSurfaceGeometry(binding.FaceId, out var surface) || surface is null)+ {+ continue;+ }++ if (surface.Kind != SurfaceGeometryKind.Plane || surface.Plane is null)+ {+ hasNonPlanarFace = true;+ continue;+ }++ planarFaces.Add((binding.FaceId, surface.Plane.Value));+ }++ if (planarFaces.Count == 0)+ {+ issues.Add(new CncManufacturabilitySchemaIssue(+ CncManufacturabilityIssueKind.Unsupported,+ CncManufacturabilityRuleIds.MinimumWallThickness,+ Location: "body",+ MeasuredValue: null,+ RequiredThreshold: input.MinimumWallThickness,+ "Cannot evaluate minimum wall thickness: no planar faces are available for bounded probing."));+ return;+ }++ if (hasNonPlanarFace)+ {+ issues.Add(new CncManufacturabilitySchemaIssue(+ CncManufacturabilityIssueKind.Unsupported,+ CncManufacturabilityRuleIds.MinimumWallThickness,+ Location: "body",+ MeasuredValue: null,+ RequiredThreshold: input.MinimumWallThickness,+ "Minimum wall thickness v1 evaluates planar faces only; non-planar faces are present."));+ }++ foreach (var (faceId, plane) in planarFaces)+ {+ if (!TryResolvePlanarProbePoint(body, faceId, plane, tolerance, out var probePoint))+ {+ issues.Add(new CncManufacturabilitySchemaIssue(+ CncManufacturabilityIssueKind.Unsupported,+ CncManufacturabilityRuleIds.MinimumWallThickness,+ Location: $"face:{faceId.Value}",+ MeasuredValue: null,+ RequiredThreshold: input.MinimumWallThickness,+ "Could not resolve a bounded planar-face sample point for local thickness probing."));+ continue;+ }++ var thickness = BrepManufacturingQueries.ProbeLocalThickness(+ body,+ new LocalThicknessProbe(faceId, probePoint),+ tolerance);+ if (!thickness.IsSuccess)+ {+ issues.Add(new CncManufacturabilitySchemaIssue(+ CncManufacturabilityIssueKind.Unsupported,+ CncManufacturabilityRuleIds.MinimumWallThickness,+ Location: $"face:{faceId.Value}",+ MeasuredValue: null,+ RequiredThreshold: input.MinimumWallThickness,+ "Local thickness probe failed for planar-face inward measurement."));+ continue;+ }++ if (thickness.Value.Thickness + tolerance.Linear >= input.MinimumWallThickness)+ {+ continue;+ }++ issues.Add(new CncManufacturabilitySchemaIssue(+ CncManufacturabilityIssueKind.Violation,+ CncManufacturabilityRuleIds.MinimumWallThickness,+ Location: $"face:{faceId.Value}",+ MeasuredValue: thickness.Value.Thickness,+ RequiredThreshold: input.MinimumWallThickness,+ $"Local wall thickness on planar face '{faceId}' is below minimum wall threshold."));+ }+ }++ private static bool TryResolvePlanarProbePoint(+ BrepBody body,+ FaceId faceId,+ PlaneSurface plane,+ ToleranceContext tolerance,+ out Point3D probePoint)+ {+ probePoint = plane.Origin;++ if (!AnalyticPlanarFaceDomain.TryCreate(body, faceId, plane, out var domain))+ {+ return false;+ }++ if (domain.Contains(probePoint, tolerance))+ {+ return true;+ }++ var points = GetDistinctFaceVertices(body, faceId);+ if (points.Count == 0)+ {+ return false;+ }++ var centroid = new Point3D(points.Average(p => p.X), points.Average(p => p.Y), points.Average(p => p.Z));+ if (domain.Contains(centroid, tolerance))+ {+ probePoint = centroid;+ return true;+ }++ foreach (var point in points)+ {+ if (!domain.Contains(point, tolerance))+ {+ continue;+ }++ probePoint = point;+ return true;+ }++ return false;+ }++ private static IReadOnlyList<Point3D> GetDistinctFaceVertices(BrepBody body, FaceId faceId)+ {+ var points = new List<Point3D>();+ var seen = new HashSet<VertexId>();+ foreach (var edgeId in body.GetEdges(faceId))+ {+ foreach (var vertexId in body.GetVertices(edgeId))+ {+ if (!seen.Add(vertexId))+ {+ continue;+ }++ if (body.TryGetVertexPoint(vertexId, out var point))+ {+ points.Add(point);+ }+ }+ }++ return points;+ }+}++public readonly record struct CncManufacturabilitySchemaInput+{+ public CncManufacturabilitySchemaInput(double minimumToolRadius, double minimumWallThickness)+ {+ if (minimumToolRadius <= 0d)+ {+ throw new ArgumentOutOfRangeException(nameof(minimumToolRadius), "minimumToolRadius must be greater than 0.");+ }++ if (minimumWallThickness <= 0d)+ {+ throw new ArgumentOutOfRangeException(nameof(minimumWallThickness), "minimumWallThickness must be greater than 0.");+ }++ MinimumToolRadius = minimumToolRadius;+ MinimumWallThickness = minimumWallThickness;+ }++ public double MinimumToolRadius { get; }++ public double MinimumWallThickness { get; }+}++public static class CncManufacturabilityRuleIds+{+ public const string MinimumInternalCornerRadius = "cnc.minimum_internal_corner_radius";+ public const string MinimumWallThickness = "cnc.minimum_wall_thickness";+}++public enum CncManufacturabilityIssueKind+{+ Violation,+ Unsupported,+}++public readonly record struct CncManufacturabilitySchemaIssue(+ CncManufacturabilityIssueKind Kind,+ string RuleId,+ string Location,+ double? MeasuredValue,+ double RequiredThreshold,+ string Message);++public readonly record struct CncManufacturabilitySchemaResult(+ bool IsPass,+ IReadOnlyList<CncManufacturabilitySchemaIssue> Issues);diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentCompiledSchemaAttachmentTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentCompiledSchemaAttachmentTests.csindex 0c96dd3f..93780d2f 100644--- a/Aetheris.Kernel.Firmament.Tests/FirmamentCompiledSchemaAttachmentTests.cs+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentCompiledSchemaAttachmentTests.cs@@ -23,6 +23,7 @@ public sealed class FirmamentCompiledSchemaAttachmentTestsschema:process: cncminimum_tool_radius: 1.5+ minimum_wall_thickness: 1{OpsSingleBox}""");@@ -33,6 +34,7 @@ schema:var payload = Assert.IsType<FirmamentCompiledCncSchema>(compiledSchema.Payload);Assert.Equal(1.5d, payload.MinimumToolRadius);+ Assert.Equal(1d, payload.MinimumWallThickness);}[Fact]@@ -130,6 +132,7 @@ model:schema:process: cncminimum_tool_radius: 1+ minimum_wall_thickness: 1ops[3]:-diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentFormatterTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentFormatterTests.csindex 3b8c4491..450e2199 100644--- a/Aetheris.Kernel.Firmament.Tests/FirmamentFormatterTests.cs+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentFormatterTests.cs@@ -349,6 +349,8 @@ public sealed class FirmamentFormatterTestsschema.ProcessRaw,schema.MinimumToolRadius,schema.MinimumToolRadiusRaw,+ schema.MinimumWallThickness,+ schema.MinimumWallThicknessRaw,schema.PartingPlane,schema.HasGateLocation,schema.GateLocation is null ? null : new FirmamentGateLocationMeaningSnapshot(schema.GateLocation.XRaw, schema.GateLocation.YRaw, schema.GateLocation.ZRaw),@@ -416,6 +418,8 @@ public sealed class FirmamentFormatterTestsstring? ProcessRaw,double? MinimumToolRadius,string? MinimumToolRadiusRaw,+ double? MinimumWallThickness,+ string? MinimumWallThicknessRaw,string? PartingPlane,bool HasGateLocation,FirmamentGateLocationMeaningSnapshot? GateLocation,diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentSchemaCncDfmValidationTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentSchemaCncDfmValidationTests.csindex f76cd60e..07b3decd 100644--- a/Aetheris.Kernel.Firmament.Tests/FirmamentSchemaCncDfmValidationTests.cs+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentSchemaCncDfmValidationTests.cs@@ -1,12 +1,12 @@-using System.Linq;using Aetheris.Kernel.Firmament.Diagnostics;+using Aetheris.Kernel.Core.Brep.Queries;namespace Aetheris.Kernel.Firmament.Tests;public sealed class FirmamentSchemaCncDfmValidationTests{[Fact]- public void Compile_WithoutSchema_DoesNotApply_CncMinimumToolRadiusRule()+ public void Compile_WithCncSchema_CanonicalPassBody_Succeeds(){const string source = """firmament:@@ -16,101 +16,40 @@ model:name: demounits: mm-ops[2]:+schema:+ process: cnc+ minimum_tool_radius: 0.25+ minimum_wall_thickness: 0.5++ops[1]:-op: boxid: basesize[3]:6- 6- 6- -- op: subtract- id: hole- from: base- with:- op: cylinder- radius: 0.5- height: 8+ 4+ 2""";var result = Compile(source);- Assert.True(result.Compilation.IsSuccess);- Assert.Empty(result.Compilation.Diagnostics);- Assert.DoesNotContain(result.Compilation.Diagnostics, diagnostic => diagnostic.Message.Contains(FirmamentDiagnosticCodes.SchemaCncMinimumToolRadiusViolated.Value, StringComparison.Ordinal));- }-- [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);Assert.Empty(result.Compilation.Diagnostics);}[Fact]- public void Compile_WithCncSchema_Rejects_SubtractCylinderBelow_MinimumToolRadius_Deterministically()+ public void Compile_WithCncSchema_FailsForInternalCornerToolRadiusViolation(){- 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-""");+ var result = CompileFixture("testdata/firmament/fixtures/m8c-invalid-schema-cnc-minimum-tool-radius.firmament");- Assert.True(result.Compilation.IsSuccess);- Assert.Empty(result.Compilation.Diagnostics);- Assert.DoesNotContain(result.Compilation.Diagnostics, diagnostic => diagnostic.Message.Contains(FirmamentDiagnosticCodes.SchemaCncMinimumToolRadiusViolated.Value, StringComparison.Ordinal));+ Assert.False(result.Compilation.IsSuccess);+ var diagnostic = Assert.Single(result.Compilation.Diagnostics);+ Assert.Contains(FirmamentDiagnosticCodes.SchemaCncManufacturabilityViolated.Value, diagnostic.Message, StringComparison.Ordinal);+ Assert.Contains(CncManufacturabilityRuleIds.MinimumInternalCornerRadius, diagnostic.Message, StringComparison.Ordinal);}[Fact]- public void Compile_WithCncSchema_DoesNotApply_Rule_ToNonCylinderSubtractTools()+ public void Compile_WithCncSchema_FailsForWallThicknessViolation(){const string source = """firmament:@@ -122,99 +61,26 @@ model:schema:process: cnc- minimum_tool_radius: 2+ minimum_tool_radius: 0.25+ minimum_wall_thickness: 1-ops[2]:+ops[1]:-op: box- id: base+ id: thinsize[3]:- 6- 6- 6- -- op: subtract- id: pocket- from: base- with:- op: cone- bottom_radius: 1.2- top_radius: 0.8- height: 8-""";-- var result = Compile(source);-- Assert.True(result.Compilation.IsSuccess);- Assert.DoesNotContain(result.Compilation.Diagnostics, diagnostic => diagnostic.Message.Contains(FirmamentDiagnosticCodes.SchemaCncMinimumToolRadiusViolated.Value, StringComparison.Ordinal));- }-- [Fact]- public void Compile_WithValidCncSchema_Preserves_Failure_Truth_For_Unsupported_Boolean_Execution()- {- const string baseline = """-firmament:- version: 1--model:- name: demo- units: mm--ops[2]:- -- op: box- id: base- size[3]:- 88- 8- -- op: subtract- id: hole- from: base- with:- op: cylinder- radius: 2- height: 8+ 0.5+ 2""";- 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);+ var result = Compile(source);- Assert.True(first.Compilation.IsSuccess);- Assert.True(second.Compilation.IsSuccess);- Assert.Equal(first.Compilation.Diagnostics, second.Compilation.Diagnostics);- Assert.Empty(first.Compilation.Diagnostics);+ Assert.False(result.Compilation.IsSuccess);+ Assert.Contains(result.Compilation.Diagnostics, diagnostic =>+ diagnostic.Message.Contains(FirmamentDiagnosticCodes.SchemaCncManufacturabilityViolated.Value, StringComparison.Ordinal)+ && diagnostic.Message.Contains(CncManufacturabilityRuleIds.MinimumWallThickness, StringComparison.Ordinal)+ && diagnostic.Message.Contains("required>=1", StringComparison.Ordinal));}private static FirmamentCompileResult Compile(string source)diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentSchemaEnclosedVoidValidationTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentSchemaEnclosedVoidValidationTests.csindex 09ca9d87..c54cf0ca 100644--- a/Aetheris.Kernel.Firmament.Tests/FirmamentSchemaEnclosedVoidValidationTests.cs+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentSchemaEnclosedVoidValidationTests.cs@@ -53,6 +53,7 @@ model:schema:process: cncminimum_tool_radius: 1+ minimum_wall_thickness: 1ops[2]:-diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentSchemaValidationTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentSchemaValidationTests.csindex 36478b26..36910be5 100644--- a/Aetheris.Kernel.Firmament.Tests/FirmamentSchemaValidationTests.cs+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentSchemaValidationTests.cs@@ -22,6 +22,7 @@ public sealed class FirmamentSchemaValidationTestsschema:process: cncminimum_tool_radius: 1.5+ minimum_wall_thickness: 1{OpsSingleBox}""");@@ -31,6 +32,7 @@ schema:Assert.NotNull(schema);Assert.Equal("cnc", schema!.ProcessRaw);Assert.Equal(1.5d, schema.MinimumToolRadius);+ Assert.Equal(1d, schema.MinimumWallThickness);}[Fact]@@ -234,6 +236,7 @@ model:schema:process: cncminimum_tool_radius: 1+ minimum_wall_thickness: 1ops[2]:-diff --git a/Aetheris.Kernel.Firmament/CompiledModel/FirmamentCompiledSchema.cs b/Aetheris.Kernel.Firmament/CompiledModel/FirmamentCompiledSchema.csindex 3d35bef0..f7ef3fb4 100644--- a/Aetheris.Kernel.Firmament/CompiledModel/FirmamentCompiledSchema.cs+++ b/Aetheris.Kernel.Firmament/CompiledModel/FirmamentCompiledSchema.cs@@ -13,7 +13,7 @@ public enum FirmamentCompiledSchemaProcesspublic abstract record FirmamentCompiledSchemaPayload;-public sealed record FirmamentCompiledCncSchema(double MinimumToolRadius)+public sealed record FirmamentCompiledCncSchema(double MinimumToolRadius, double MinimumWallThickness): FirmamentCompiledSchemaPayload;public sealed record FirmamentCompiledInjectionMoldedSchema(diff --git a/Aetheris.Kernel.Firmament/Diagnostics/FirmamentDiagnosticCodes.cs b/Aetheris.Kernel.Firmament/Diagnostics/FirmamentDiagnosticCodes.csindex 7af52c19..7ea64281 100644--- a/Aetheris.Kernel.Firmament/Diagnostics/FirmamentDiagnosticCodes.cs+++ b/Aetheris.Kernel.Firmament/Diagnostics/FirmamentDiagnosticCodes.cs@@ -52,6 +52,8 @@ public static class FirmamentDiagnosticCodespublic static readonly FirmamentDiagnosticCode SchemaInvalidFieldValue = new($"{FirmamentDiagnosticConventions.SchemaPrefix}-0004");public static readonly FirmamentDiagnosticCode SchemaCncMinimumToolRadiusViolated = new($"{FirmamentDiagnosticConventions.SchemaPrefix}-0005");public static readonly FirmamentDiagnosticCode SchemaEnclosedVoidsNotAllowed = new($"{FirmamentDiagnosticConventions.SchemaPrefix}-0006");+ public static readonly FirmamentDiagnosticCode SchemaCncManufacturabilityViolated = new($"{FirmamentDiagnosticConventions.SchemaPrefix}-0007");+ public static readonly FirmamentDiagnosticCode SchemaCncManufacturabilityUnsupported = new($"{FirmamentDiagnosticConventions.SchemaPrefix}-0008");public static readonly FirmamentDiagnosticCode LoweringPlaceholder = new($"{FirmamentDiagnosticConventions.LoweringPrefix}-0001");}diff --git a/Aetheris.Kernel.Firmament/FirmamentCompiler.cs b/Aetheris.Kernel.Firmament/FirmamentCompiler.csindex c47212b6..7fccfd28 100644--- a/Aetheris.Kernel.Firmament/FirmamentCompiler.cs+++ b/Aetheris.Kernel.Firmament/FirmamentCompiler.cs@@ -72,13 +72,6 @@ public sealed class FirmamentCompilervar 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){@@ -93,6 +86,13 @@ public sealed class FirmamentCompilerKernelResult<FirmamentCompilationArtifact>.Failure(primitiveExecutionResult.Diagnostics));}+ var schemaDfmValidationResult = FirmamentSchemaCncDfmValidator.Validate(compiledSchema, primitiveExecutionResult.Value);+ if (!schemaDfmValidationResult.IsSuccess)+ {+ return new FirmamentCompileResult(+ KernelResult<FirmamentCompilationArtifact>.Failure(schemaDfmValidationResult.Diagnostics));+ }+var enclosedVoidValidationResult = FirmamentSchemaEnclosedVoidValidator.Validate(primitiveExecutionResult.Value, compiledSchema);if (!enclosedVoidValidationResult.IsSuccess){diff --git a/Aetheris.Kernel.Firmament/Formatting/FirmamentCanonicalFormatter.cs b/Aetheris.Kernel.Firmament/Formatting/FirmamentCanonicalFormatter.csindex e620dd53..f9bd6569 100644--- a/Aetheris.Kernel.Firmament/Formatting/FirmamentCanonicalFormatter.cs+++ b/Aetheris.Kernel.Firmament/Formatting/FirmamentCanonicalFormatter.cs@@ -62,6 +62,10 @@ internal static class FirmamentCanonicalFormatter{AppendScalarField(builder, 1, "minimum_tool_radius", schema.MinimumToolRadiusRaw);}+ if (schema.MinimumWallThicknessRaw is not null)+ {+ AppendScalarField(builder, 1, "minimum_wall_thickness", schema.MinimumWallThicknessRaw);+ }if (schema.PartingPlane is not null){diff --git a/Aetheris.Kernel.Firmament/Mapping/FirmamentCompiledSchemaMapper.cs b/Aetheris.Kernel.Firmament/Mapping/FirmamentCompiledSchemaMapper.csindex 48bf5e90..dea4b0b1 100644--- a/Aetheris.Kernel.Firmament/Mapping/FirmamentCompiledSchemaMapper.cs+++ b/Aetheris.Kernel.Firmament/Mapping/FirmamentCompiledSchemaMapper.cs@@ -17,7 +17,7 @@ internal static class FirmamentCompiledSchemaMapper{FirmamentParsedSchemaProcess.Cnc => new FirmamentCompiledSchema(FirmamentCompiledSchemaProcess.Cnc,- new FirmamentCompiledCncSchema(schema.MinimumToolRadius!.Value)),+ new FirmamentCompiledCncSchema(schema.MinimumToolRadius!.Value, schema.MinimumWallThickness!.Value)),FirmamentParsedSchemaProcess.InjectionMolded => new FirmamentCompiledSchema(FirmamentCompiledSchemaProcess.InjectionMolded,new FirmamentCompiledInjectionMoldedSchema(diff --git a/Aetheris.Kernel.Firmament/ParsedModel/FirmamentParsedSchema.cs b/Aetheris.Kernel.Firmament/ParsedModel/FirmamentParsedSchema.csindex 3ee34047..1d96158c 100644--- a/Aetheris.Kernel.Firmament/ParsedModel/FirmamentParsedSchema.cs+++ b/Aetheris.Kernel.Firmament/ParsedModel/FirmamentParsedSchema.cs@@ -6,6 +6,8 @@ public sealed record FirmamentParsedSchema(FirmamentParsedSchemaProcess Process,string? MinimumToolRadiusRaw = null,double? MinimumToolRadius = null,+ string? MinimumWallThicknessRaw = null,+ double? MinimumWallThickness = null,string? PartingPlane = null,bool HasGateLocation = false,bool GateLocationIsObjectLike = false,diff --git a/Aetheris.Kernel.Firmament/Parsing/FirmamentTopLevelParser.cs b/Aetheris.Kernel.Firmament/Parsing/FirmamentTopLevelParser.csindex 94c05a47..f11aad8e 100644--- a/Aetheris.Kernel.Firmament/Parsing/FirmamentTopLevelParser.cs+++ b/Aetheris.Kernel.Firmament/Parsing/FirmamentTopLevelParser.cs@@ -572,6 +572,13 @@ internal static class FirmamentTopLevelParser{minimumToolRadius = minimumToolRadiusElement.GetDouble();}+ schemaElement.TryGetProperty("minimum_wall_thickness", out var minimumWallThicknessElement);+ var minimumWallThicknessRaw = minimumWallThicknessElement.ToString();+ double? minimumWallThickness = null;+ if (minimumWallThicknessElement.ValueKind == JsonValueKind.Number)+ {+ minimumWallThickness = minimumWallThicknessElement.GetDouble();+ }string? partingPlane = null;if (schemaElement.TryGetProperty("parting_plane", out var partingPlaneElement))@@ -606,7 +613,7 @@ internal static class FirmamentTopLevelParserprinterResolution = printerResolutionElement.GetDouble();}- return new FirmamentParsedSchema(true, processRaw, process, minimumToolRadiusRaw, minimumToolRadius, partingPlane, hasGateLocation, gateLocationIsObjectLike, gateLocation, draftAngleRaw, draftAngle, printerResolutionRaw, printerResolution);+ return new FirmamentParsedSchema(true, processRaw, process, minimumToolRadiusRaw, minimumToolRadius, minimumWallThicknessRaw, minimumWallThickness, partingPlane, hasGateLocation, gateLocationIsObjectLike, gateLocation, draftAngleRaw, draftAngle, printerResolutionRaw, printerResolution);}private static FirmamentParsedSchema? ParseSchemaFromToonSections(IReadOnlyDictionary<string, FirmamentToonSection> sections)@@ -631,6 +638,13 @@ internal static class FirmamentTopLevelParser{minimumToolRadius = minimumToolRadiusValue;}+ schemaSection.Fields.TryGetValue("minimum_wall_thickness", out var minimumWallThicknessRaw);+ double? minimumWallThickness = null;+ if (!string.IsNullOrWhiteSpace(minimumWallThicknessRaw)+ && TryParseNumeric(minimumWallThicknessRaw, out var minimumWallThicknessValue))+ {+ minimumWallThickness = minimumWallThicknessValue;+ }schemaSection.Fields.TryGetValue("parting_plane", out var partingPlane);@@ -668,7 +682,7 @@ internal static class FirmamentTopLevelParserprinterResolution = printerResolutionValue;}- return new FirmamentParsedSchema(true, processRaw, process, minimumToolRadiusRaw, minimumToolRadius, partingPlane, hasGateLocation, gateLocationIsObjectLike, gateLocation, draftAngleRaw, draftAngle, printerResolutionRaw, printerResolution);+ return new FirmamentParsedSchema(true, processRaw, process, minimumToolRadiusRaw, minimumToolRadius, minimumWallThicknessRaw, minimumWallThickness, partingPlane, hasGateLocation, gateLocationIsObjectLike, gateLocation, draftAngleRaw, draftAngle, printerResolutionRaw, printerResolution);}private static FirmamentParsedSchemaProcess ParseSchemaProcess(string? raw)diff --git a/Aetheris.Kernel.Firmament/Validation/FirmamentSchemaCncDfmValidator.cs b/Aetheris.Kernel.Firmament/Validation/FirmamentSchemaCncDfmValidator.csindex 37763927..695f92ae 100644--- a/Aetheris.Kernel.Firmament/Validation/FirmamentSchemaCncDfmValidator.cs+++ b/Aetheris.Kernel.Firmament/Validation/FirmamentSchemaCncDfmValidator.cs@@ -1,179 +1,90 @@using System.Globalization;-using System.Text.Json;+using Aetheris.Kernel.Core.Brep;+using Aetheris.Kernel.Core.Brep.Queries;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;+using Aetheris.Kernel.Firmament.Execution;namespace Aetheris.Kernel.Firmament.Validation;internal static class FirmamentSchemaCncDfmValidator{- public static KernelResult<bool> Validate(FirmamentParsedDocument parsedDocument, FirmamentCompiledSchema? compiledSchema)+ public static KernelResult<bool> Validate(+ FirmamentCompiledSchema? compiledSchema,+ FirmamentPrimitiveExecutionResult? primitiveExecutionResult){- 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 terminalBody = ResolveTerminalBody(primitiveExecutionResult);+ if (terminalBody is null){- 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);}- return KernelResult<bool>.Success(true);- }-- private static string FormatNumeric(double value) =>- value.ToString("0.0###############", CultureInfo.InvariantCulture);+ var schemaResult = BrepCncManufacturabilitySchema.Evaluate(+ terminalBody,+ new CncManufacturabilitySchemaInput(cncSchema.MinimumToolRadius, cncSchema.MinimumWallThickness));- private static bool TryGetWithFields(string raw, out Dictionary<string, string> fields)- {- fields = new Dictionary<string, string>(StringComparer.Ordinal);-- if (TryParseJsonObject(raw, out var objectElement))+ if (schemaResult.IsPass){- foreach (var property in objectElement.EnumerateObject())- {- fields[property.Name] = property.Value.ToString();- }-- return true;+ return KernelResult<bool>.Success(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;- }+ var diagnostics = schemaResult.Issues+ .Where(issue => issue.Kind == CncManufacturabilityIssueKind.Violation)+ .Select(CreateIssueDiagnostic)+ .ToArray();- objectElement = document.RootElement.Clone();- return true;- }- catch (JsonException)+ if (diagnostics.Length == 0){- return false;+ return KernelResult<bool>.Success(true);}++ return KernelResult<bool>.Failure(diagnostics);}- private static bool TryParseToonInlineObject(string raw, out Dictionary<string, string> fields)+ private static BrepBody? ResolveTerminalBody(FirmamentPrimitiveExecutionResult? execution){- fields = new Dictionary<string, string>(StringComparer.Ordinal);- var trimmed = raw.Trim();- if (!trimmed.StartsWith("{", StringComparison.Ordinal) || !trimmed.EndsWith("}", StringComparison.Ordinal))+ if (execution is null){- return false;+ return null;}- var inner = trimmed[1..^1].Trim();- if (inner.Length == 0)+ var terminalBoolean = execution.ExecutedBooleans+ .OrderByDescending(entry => entry.OpIndex)+ .FirstOrDefault();+ if (terminalBoolean is not null){- 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 terminalBoolean.Body;}- return true;+ return execution.ExecutedPrimitives+ .OrderByDescending(entry => entry.OpIndex)+ .FirstOrDefault()+ ?.Body;}- private static List<string> SplitTopLevelCommaSeparated(string input)+ private static KernelDiagnostic CreateIssueDiagnostic(CncManufacturabilitySchemaIssue issue){- 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;+ var code = issue.Kind == CncManufacturabilityIssueKind.Unsupported+ ? FirmamentDiagnosticCodes.SchemaCncManufacturabilityUnsupported+ : FirmamentDiagnosticCodes.SchemaCncManufacturabilityViolated;++ var measured = issue.MeasuredValue.HasValue+ ? issue.MeasuredValue.Value.ToString("0.0###############", CultureInfo.InvariantCulture)+ : "n/a";+ var required = issue.RequiredThreshold.ToString("0.0###############", CultureInfo.InvariantCulture);++ return new KernelDiagnostic(+ KernelDiagnosticCode.ValidationFailed,+ KernelDiagnosticSeverity.Error,+ $"[{code.Value}] CNC rule '{issue.RuleId}' failed at {issue.Location}: measured={measured}, required>={required}. {issue.Message}",+ Source: FirmamentDiagnosticConventions.Source);}-- 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/Aetheris.Kernel.Firmament/Validation/FirmamentSchemaValidator.cs b/Aetheris.Kernel.Firmament/Validation/FirmamentSchemaValidator.csindex 3d8ef7b5..d689d265 100644--- a/Aetheris.Kernel.Firmament/Validation/FirmamentSchemaValidator.cs+++ b/Aetheris.Kernel.Firmament/Validation/FirmamentSchemaValidator.cs@@ -59,6 +59,21 @@ internal static class FirmamentSchemaValidatorreturn InvalidFieldValue("minimum_tool_radius", "expected a numeric value greater than 0");}+ if (string.IsNullOrWhiteSpace(schema.MinimumWallThicknessRaw))+ {+ return MissingField("minimum_wall_thickness");+ }++ if (schema.MinimumWallThickness is null)+ {+ return InvalidFieldTypeOrShape("minimum_wall_thickness", "expected a numeric scalar");+ }++ if (schema.MinimumWallThickness <= 0)+ {+ return InvalidFieldValue("minimum_wall_thickness", "expected a numeric value greater than 0");+ }+return KernelResult<bool>.Success(true);}diff --git a/testdata/firmament/fixtures/m8a-valid-schema-cnc.firmament b/testdata/firmament/fixtures/m8a-valid-schema-cnc.firmamentindex d96d9930..68d4efd5 100644--- a/testdata/firmament/fixtures/m8a-valid-schema-cnc.firmament+++ b/testdata/firmament/fixtures/m8a-valid-schema-cnc.firmament@@ -8,5 +8,6 @@ model:schema:process: cncminimum_tool_radius: 1.5+ minimum_wall_thickness: 1ops[0]: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.firmamentindex 6c1ece8c..dc563dbe 100644--- a/testdata/firmament/fixtures/m8c-invalid-schema-cnc-minimum-tool-radius.firmament+++ b/testdata/firmament/fixtures/m8c-invalid-schema-cnc-minimum-tool-radius.firmament@@ -7,22 +7,30 @@ model:schema:process: cnc- minimum_tool_radius: 2+ minimum_tool_radius: 1+ minimum_wall_thickness: 0.5ops[2]:-op: boxid: basesize[3]:- 8- 8- 8-+ 4+ 2+ 2-- op: subtract- id: hole- from: base+ op: add+ id: lshape+ to: basewith:- op: cylinder- radius: 1- height: 8+ op: box+ size[3]:+ 2+ 4+ 2+ place:+ on: origin+ offset[3]:+ -1+ 1+ 0diff --git a/testdata/firmament/fixtures/m8c-valid-schema-cnc-minimum-tool-radius.firmament b/testdata/firmament/fixtures/m8c-valid-schema-cnc-minimum-tool-radius.firmamentindex 7244ed7f..2de65d2f 100644--- a/testdata/firmament/fixtures/m8c-valid-schema-cnc-minimum-tool-radius.firmament+++ b/testdata/firmament/fixtures/m8c-valid-schema-cnc-minimum-tool-radius.firmament@@ -7,9 +7,10 @@ model:schema:process: cnc- minimum_tool_radius: 2+ minimum_tool_radius: 0.25+ minimum_wall_thickness: 0.5-ops[2]:+ops[1]:-op: boxid: base@@ -17,12 +18,3 @@ ops[2]:888-- -- op: subtract- id: hole- from: base- with:- op: cylinder- radius: 2- height: 8