Skip to content

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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
index 0c96dd3f..93780d2f 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentCompiledSchemaAttachmentTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentCompiledSchemaAttachmentTests.cs
@@ -23,6 +23,7 @@ public sealed class FirmamentCompiledSchemaAttachmentTests
schema:
process: cnc
minimum_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: cnc
minimum_tool_radius: 1
+ minimum_wall_thickness: 1
ops[3]:
-
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentFormatterTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentFormatterTests.cs
index 3b8c4491..450e2199 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentFormatterTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentFormatterTests.cs
@@ -349,6 +349,8 @@ public sealed class FirmamentFormatterTests
schema.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 FirmamentFormatterTests
string? 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.cs
index 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: demo
units: mm
-ops[2]:
+schema:
+ process: cnc
+ minimum_tool_radius: 0.25
+ minimum_wall_thickness: 0.5
+
+ops[1]:
-
op: box
id: base
size[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: thin
size[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]:
- 8
8
- 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.cs
index 09ca9d87..c54cf0ca 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentSchemaEnclosedVoidValidationTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentSchemaEnclosedVoidValidationTests.cs
@@ -53,6 +53,7 @@ model:
schema:
process: cnc
minimum_tool_radius: 1
+ minimum_wall_thickness: 1
ops[2]:
-
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentSchemaValidationTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentSchemaValidationTests.cs
index 36478b26..36910be5 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentSchemaValidationTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentSchemaValidationTests.cs
@@ -22,6 +22,7 @@ public sealed class FirmamentSchemaValidationTests
schema:
process: cnc
minimum_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: cnc
minimum_tool_radius: 1
+ minimum_wall_thickness: 1
ops[2]:
-
diff --git a/Aetheris.Kernel.Firmament/CompiledModel/FirmamentCompiledSchema.cs b/Aetheris.Kernel.Firmament/CompiledModel/FirmamentCompiledSchema.cs
index 3d35bef0..f7ef3fb4 100644
--- a/Aetheris.Kernel.Firmament/CompiledModel/FirmamentCompiledSchema.cs
+++ b/Aetheris.Kernel.Firmament/CompiledModel/FirmamentCompiledSchema.cs
@@ -13,7 +13,7 @@ public enum FirmamentCompiledSchemaProcess
public 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.cs
index 7af52c19..7ea64281 100644
--- a/Aetheris.Kernel.Firmament/Diagnostics/FirmamentDiagnosticCodes.cs
+++ b/Aetheris.Kernel.Firmament/Diagnostics/FirmamentDiagnosticCodes.cs
@@ -52,6 +52,8 @@ public static class FirmamentDiagnosticCodes
public 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.cs
index c47212b6..7fccfd28 100644
--- a/Aetheris.Kernel.Firmament/FirmamentCompiler.cs
+++ b/Aetheris.Kernel.Firmament/FirmamentCompiler.cs
@@ -72,13 +72,6 @@ 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)
{
@@ -93,6 +86,13 @@ public sealed class FirmamentCompiler
KernelResult<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.cs
index 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.cs
index 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.cs
index 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.cs
index 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 FirmamentTopLevelParser
printerResolution = 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 FirmamentTopLevelParser
printerResolution = 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.cs
index 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.cs
index 3d8ef7b5..d689d265 100644
--- a/Aetheris.Kernel.Firmament/Validation/FirmamentSchemaValidator.cs
+++ b/Aetheris.Kernel.Firmament/Validation/FirmamentSchemaValidator.cs
@@ -59,6 +59,21 @@ internal static class FirmamentSchemaValidator
return 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.firmament
index 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: cnc
minimum_tool_radius: 1.5
+ minimum_wall_thickness: 1
ops[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.firmament
index 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.5
ops[2]:
-
op: box
id: base
size[3]:
- 8
- 8
- 8
-
+ 4
+ 2
+ 2
-
- op: subtract
- id: hole
- from: base
+ op: add
+ id: lshape
+ to: base
with:
- op: cylinder
- radius: 1
- height: 8
+ op: box
+ size[3]:
+ 2
+ 4
+ 2
+ place:
+ on: origin
+ offset[3]:
+ -1
+ 1
+ 0
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
index 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: box
id: base
@@ -17,12 +18,3 @@ ops[2]:
8
8
8
-
- -
- op: subtract
- id: hole
- from: base
- with:
- op: cylinder
- radius: 2
- height: 8