Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Implement Firmament M7c primitive placement execution

Yuechen Li68447ca49039
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentPlacementValidationTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentPlacementValidationTests.cs
index 7736b33f..ae2656ba 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentPlacementValidationTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentPlacementValidationTests.cs
@@ -1,3 +1,4 @@
+using System.Linq;
using Aetheris.Kernel.Firmament.Diagnostics;
namespace Aetheris.Kernel.Firmament.Tests;
@@ -40,10 +41,12 @@ public sealed class FirmamentPlacementValidationTests
}
[Fact]
- public void Primitive_With_Boolean_Edges_PlaceAnchor_Is_Valid()
+ public void Primitive_With_Boolean_Edges_PlaceAnchor_Runtime_Is_Deterministically_Reported_When_Unresolved()
{
var result = CompileFixture("testdata/firmament/fixtures/m7b-valid-placement-selector-anchor-boolean.firmament");
- Assert.True(result.Compilation.IsSuccess);
+ Assert.False(result.Compilation.IsSuccess);
+ var diagnostic = Assert.Single(result.Compilation.Diagnostics);
+ Assert.Contains(FirmamentDiagnosticCodes.ValidationTargetSelectorResolvedEmpty.Value, diagnostic.Message, StringComparison.Ordinal);
}
[Fact]
@@ -148,21 +151,14 @@ public sealed class FirmamentPlacementValidationTests
}
[Fact]
- public void Placement_Declarations_Do_Not_Change_Primitive_Execution_Output()
+ public void Placement_Runtime_Selector_Resolution_Failure_Is_Diagnostic()
{
- var baseline = CompileFixture("testdata/firmament/fixtures/m3c-valid-box-exec.firmament");
- var withPlacement = CompileFixture("testdata/firmament/fixtures/m7a-valid-box-origin-placement.firmament");
+ var result = CompileFixture("testdata/firmament/fixtures/m7c-invalid-placement-selector-runtime-empty.firmament");
- Assert.True(baseline.Compilation.IsSuccess);
- Assert.True(withPlacement.Compilation.IsSuccess);
-
- var basePrimitive = Assert.Single(baseline.Compilation.Value.PrimitiveExecutionResult!.ExecutedPrimitives);
- var placedPrimitive = Assert.Single(withPlacement.Compilation.Value.PrimitiveExecutionResult!.ExecutedPrimitives);
-
- Assert.Equal(basePrimitive.Kind, placedPrimitive.Kind);
- Assert.Equal(basePrimitive.FeatureId, placedPrimitive.FeatureId);
- Assert.Equal(basePrimitive.Body.Topology.Faces.Count(), placedPrimitive.Body.Topology.Faces.Count());
- Assert.Equal(basePrimitive.Body.Topology.Edges.Count(), placedPrimitive.Body.Topology.Edges.Count());
+ Assert.False(result.Compilation.IsSuccess);
+ var diagnostic = Assert.Single(result.Compilation.Diagnostics);
+ Assert.Contains(FirmamentDiagnosticCodes.ValidationTargetSelectorResolvedEmpty.Value, diagnostic.Message, StringComparison.Ordinal);
+ Assert.Contains("resolved empty", diagnostic.Message, StringComparison.OrdinalIgnoreCase);
}
[Fact]
@@ -181,6 +177,34 @@ public sealed class FirmamentPlacementValidationTests
Assert.Equal(firstDiagnostic.Code, secondDiagnostic.Code);
}
+
+
+ [Fact]
+ public void Selector_Placement_On_TopFace_Lands_At_Expected_Anchor_Point()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m7c-valid-selector-top-face-anchor.firmament");
+ Assert.True(result.Compilation.IsSuccess);
+
+ var placed = result.Compilation.Value.PrimitiveExecutionResult!.ExecutedPrimitives.Single(p => p.FeatureId == "placed");
+ Assert.True(placed.Body.TryGetVertexPoint(new Aetheris.Kernel.Core.Topology.VertexId(1), out var p1));
+ Assert.Equal(new Aetheris.Kernel.Core.Math.Point3D(-1d, -1d, 4d), p1);
+ }
+
+ [Fact]
+ public void Selector_Placement_On_Vertices_And_Edges_Uses_Deterministic_Centroid_Aggregates()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m7c-valid-selector-vertices-edges-anchors.firmament");
+ Assert.True(result.Compilation.IsSuccess);
+
+ var vertexPlaced = result.Compilation.Value.PrimitiveExecutionResult!.ExecutedPrimitives.Single(p => p.FeatureId == "on_vertices");
+ Assert.True(vertexPlaced.Body.TryGetVertexPoint(new Aetheris.Kernel.Core.Topology.VertexId(1), out var v1));
+ Assert.Equal(new Aetheris.Kernel.Core.Math.Point3D(-0.5d, -1.25d, 2d), v1);
+
+ var edgePlaced = result.Compilation.Value.PrimitiveExecutionResult.ExecutedPrimitives.Single(p => p.FeatureId == "on_edges");
+ Assert.True(edgePlaced.Body.TryGetVertexPoint(new Aetheris.Kernel.Core.Topology.VertexId(1), out var e1));
+ Assert.Equal(new Aetheris.Kernel.Core.Math.Point3D(-0.5d, -1.25d, 0d), e1);
+ }
+
private static FirmamentCompileResult CompileFixture(string fixturePath)
{
var source = FirmamentCorpusHarness.ReadFixtureText(fixturePath);
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs
index 396e0d00..7d94faca 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs
@@ -1,5 +1,8 @@
+using System.Linq;
using Aetheris.Kernel.Core.Brep;
using Aetheris.Kernel.Firmament.Lowering;
+using Aetheris.Kernel.Core.Math;
+using Aetheris.Kernel.Core.Topology;
namespace Aetheris.Kernel.Firmament.Tests;
@@ -118,7 +121,7 @@ public sealed class FirmamentPrimitiveExecutionTests
Assert.True(result.Compilation.IsSuccess);
var artifact = result.Compilation.Value;
- Assert.Equal("firmament-topology-manifold-validation-executed", artifact.ArtifactKind);
+ Assert.Equal("firmament-placement-executed", artifact.ArtifactKind);
Assert.Equal(2, artifact.PrimitiveLoweringPlan!.Primitives.Count);
Assert.Equal(2, artifact.PrimitiveLoweringPlan.Booleans.Count);
Assert.Single(artifact.PrimitiveLoweringPlan.SkippedOps);
@@ -202,6 +205,76 @@ public sealed class FirmamentPrimitiveExecutionTests
Assert.Equal(firstMetadata, secondMetadata);
}
+
+
+ [Fact]
+ public void Default_Box_Frame_Is_Centered_In_XY_And_Bottom_On_Z0()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m3c-valid-box-exec.firmament");
+ Assert.True(result.Compilation.IsSuccess);
+
+ var body = Assert.Single(result.Compilation.Value.PrimitiveExecutionResult!.ExecutedPrimitives).Body;
+
+ var bounds = GetBounds(body);
+ Assert.Equal(new Point3D(-5d, -10d, 0d), bounds.Min);
+ Assert.Equal(new Point3D(5d, 10d, 30d), bounds.Max);
+ }
+
+ [Fact]
+ public void Default_Cylinder_Frame_Is_Centered_In_XY_And_Bottom_On_Z0()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m3c-valid-cylinder-exec.firmament");
+ Assert.True(result.Compilation.IsSuccess);
+
+ var body = Assert.Single(result.Compilation.Value.PrimitiveExecutionResult!.ExecutedPrimitives).Body;
+ Assert.True(body.TryGetFaceSurfaceGeometry(new FaceId(1), out var side));
+ Assert.Equal(new Point3D(0d, 0d, 0d), side!.Cylinder!.Value.Origin);
+
+ Assert.True(body.TryGetFaceSurfaceGeometry(new FaceId(2), out var top));
+ Assert.Equal(new Point3D(0d, 0d, 9d), top!.Plane!.Value.Origin);
+
+ Assert.True(body.TryGetFaceSurfaceGeometry(new FaceId(3), out var bottom));
+ Assert.Equal(new Point3D(0d, 0d, 0d), bottom!.Plane!.Value.Origin);
+ }
+
+ [Fact]
+ public void Default_Sphere_Frame_Is_Centered_At_Origin()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m3c-valid-sphere-exec.firmament");
+ Assert.True(result.Compilation.IsSuccess);
+
+ var body = Assert.Single(result.Compilation.Value.PrimitiveExecutionResult!.ExecutedPrimitives).Body;
+ Assert.True(body.TryGetFaceSurfaceGeometry(new FaceId(1), out var surface));
+ Assert.Equal(Point3D.Origin, surface!.Sphere!.Value.Center);
+ }
+
+ [Fact]
+ public void Origin_Placement_With_Offset_Translates_Primitive()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m7c-valid-origin-placement-offset.firmament");
+ Assert.True(result.Compilation.IsSuccess);
+
+ var body = Assert.Single(result.Compilation.Value.PrimitiveExecutionResult!.ExecutedPrimitives).Body;
+ var bounds = GetBounds(body);
+ Assert.Equal(new Point3D(9d, -6d, 2d), bounds.Min);
+ Assert.Equal(new Point3D(11d, -4d, 4d), bounds.Max);
+ }
+
+ private static (Point3D Min, Point3D Max) GetBounds(BrepBody body)
+ {
+ var points = body.Topology.Vertices
+ .Select(v =>
+ {
+ Assert.True(body.TryGetVertexPoint(v.Id, out var p));
+ return p;
+ })
+ .ToArray();
+
+ return (
+ new Point3D(points.Min(p => p.X), points.Min(p => p.Y), points.Min(p => p.Z)),
+ new Point3D(points.Max(p => p.X), points.Max(p => p.Y), points.Max(p => p.Z)));
+ }
+
private static FirmamentCompileResult CompileFixture(string fixturePath)
{
var source = FirmamentCorpusHarness.ReadFixtureText(fixturePath);
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentScaffoldTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentScaffoldTests.cs
index 11ffa9c3..03135bce 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentScaffoldTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentScaffoldTests.cs
@@ -37,7 +37,7 @@ public sealed class FirmamentScaffoldTests
Assert.True(result.Compilation.IsSuccess);
var artifact = result.Compilation.Value;
- Assert.Equal("firmament-topology-manifold-validation-executed", artifact.ArtifactKind);
+ Assert.Equal("firmament-placement-executed", artifact.ArtifactKind);
Assert.NotNull(artifact.ParsedDocument);
Assert.Equal("1", artifact.ParsedDocument!.Firmament.Version);
Assert.Equal("demo", artifact.ParsedDocument.Model.Name);
diff --git a/Aetheris.Kernel.Firmament/Execution/FirmamentPlacementResolver.cs b/Aetheris.Kernel.Firmament/Execution/FirmamentPlacementResolver.cs
new file mode 100644
index 00000000..7f47fed9
--- /dev/null
+++ b/Aetheris.Kernel.Firmament/Execution/FirmamentPlacementResolver.cs
@@ -0,0 +1,157 @@
+using System.Linq;
+using Aetheris.Kernel.Core.Brep;
+using Aetheris.Kernel.Core.Diagnostics;
+using Aetheris.Kernel.Core.Geometry;
+using Aetheris.Kernel.Core.Math;
+using Aetheris.Kernel.Core.Results;
+using Aetheris.Kernel.Core.Topology;
+using Aetheris.Kernel.Firmament.Diagnostics;
+using Aetheris.Kernel.Firmament.Lowering;
+using Aetheris.Kernel.Firmament.ParsedModel;
+using Aetheris.Kernel.Firmament.Validation;
+
+namespace Aetheris.Kernel.Firmament.Execution;
+
+internal static class FirmamentPlacementResolver
+{
+ public static KernelResult<Vector3D> ResolvePlacementTranslation(FirmamentLoweredPrimitive primitive, IReadOnlyDictionary<string, BrepBody> featureBodies)
+ {
+ if (primitive.Placement is null) return KernelResult<Vector3D>.Success(Vector3D.Zero);
+
+ var anchorResult = ResolveAnchorPoint(primitive.Placement.On, featureBodies);
+ if (!anchorResult.IsSuccess) return KernelResult<Vector3D>.Failure(anchorResult.Diagnostics);
+
+ var o = primitive.Placement.Offset;
+ return KernelResult<Vector3D>.Success((anchorResult.Value - Point3D.Origin) + new Vector3D(o[0], o[1], o[2]));
+ }
+
+ private static KernelResult<Point3D> ResolveAnchorPoint(FirmamentLoweredPlacementAnchor anchor, IReadOnlyDictionary<string, BrepBody> featureBodies)
+ {
+ if (anchor is FirmamentLoweredPlacementOriginAnchor) return KernelResult<Point3D>.Success(Point3D.Origin);
+ if (anchor is not FirmamentLoweredPlacementSelectorAnchor selectorAnchor) return Failure("Placement anchor extraction failed: unsupported placement anchor shape.");
+
+ var selector = selectorAnchor.Selector;
+ var i = selector.IndexOf('.', StringComparison.Ordinal);
+ if (i <= 0 || i >= selector.Length - 1) return Failure($"Placement selector '{selector}' is not selector-shaped.");
+
+ var featureId = selector[..i];
+ var port = selector[(i + 1)..];
+ if (!featureBodies.TryGetValue(featureId, out var body)) return Failure($"Placement selector '{selector}' resolved empty at runtime.");
+
+ var featureKind = InferFeatureKind(body);
+ if (featureKind is null || !FirmamentSelectorContracts.TryGetPortContract(featureKind.Value, port, out var contract))
+ return Failure($"Placement selector '{selector}' uses unsupported selector result for placement anchor extraction.");
+
+ return contract.ResultKind switch
+ {
+ FirmamentSelectorResultKind.Face or FirmamentSelectorResultKind.FaceSet => ResolveFaceAnchor(body, port),
+ FirmamentSelectorResultKind.EdgeSet => ResolveEdgeAnchor(body, port),
+ FirmamentSelectorResultKind.VertexSet => ResolveVertexAnchor(body),
+ _ => Failure($"Placement selector '{selector}' uses unsupported selector result for placement anchor extraction.")
+ };
+ }
+
+ private static KernelResult<Point3D> ResolveFaceAnchor(BrepBody body, string port)
+ {
+ var facePoints = body.Topology.Faces
+ .Select(f => new { Face = f, Point = GetFaceRepresentativePoint(body, f.Id) })
+ .Where(x => x.Point is not null)
+ .Select(x => (x.Face, x.Point!.Value))
+ .ToList();
+ if (facePoints.Count == 0) return Failure("Placement selector resolved empty face set at runtime.");
+
+ IEnumerable<Point3D> selected = port switch
+ {
+ "top_face" => [facePoints.OrderByDescending(x => x.Item2.Z).First().Item2],
+ "bottom_face" => [facePoints.OrderBy(x => x.Item2.Z).First().Item2],
+ "side_face" => [facePoints.OrderBy(x => Math.Abs(x.Item2.Z)).First().Item2],
+ "side_faces" => facePoints.OrderByDescending(x => Math.Abs(x.Item2.Z)).Skip(2).Select(x => x.Item2),
+ "surface" => [facePoints.First().Item2],
+ _ => facePoints.Select(x => x.Item2)
+ };
+
+ var pts = selected.ToArray();
+ if (pts.Length == 0) return Failure("Placement selector resolved empty face set at runtime.");
+ return KernelResult<Point3D>.Success(ComputeCentroid(pts));
+ }
+
+ private static Point3D? GetFaceRepresentativePoint(BrepBody body, FaceId faceId)
+ {
+ if (!body.TryGetFaceSurfaceGeometry(faceId, out var s) || s is null) return null;
+ return s.Kind switch
+ {
+ SurfaceGeometryKind.Plane => s.Plane!.Value.Origin,
+ SurfaceGeometryKind.Cylinder => s.Cylinder!.Value.Origin,
+ SurfaceGeometryKind.Sphere => s.Sphere!.Value.Center,
+ _ => null
+ };
+ }
+
+ private static KernelResult<Point3D> ResolveEdgeAnchor(BrepBody body, string _)
+ {
+ var points = new List<Point3D>();
+ foreach (var edge in body.Topology.Edges)
+ {
+ if (TryGetVertexPoint(body, edge.StartVertexId, out var p1)) points.Add(p1);
+ if (TryGetVertexPoint(body, edge.EndVertexId, out var p2)) points.Add(p2);
+ }
+
+ return points.Count == 0 ? Failure("Placement selector resolved empty edge set at runtime.") : KernelResult<Point3D>.Success(ComputeCentroid(points));
+ }
+
+ private static KernelResult<Point3D> ResolveVertexAnchor(BrepBody body)
+ {
+ var points = new List<Point3D>();
+ foreach (var vertex in body.Topology.Vertices)
+ if (TryGetVertexPoint(body, vertex.Id, out var point)) points.Add(point);
+
+ return points.Count == 0 ? Failure("Placement selector resolved empty vertex set at runtime.") : KernelResult<Point3D>.Success(ComputeCentroid(points));
+ }
+
+ internal static bool TryGetVertexPoint(BrepBody body, VertexId vertexId, out Point3D point)
+ {
+ if (body.TryGetVertexPoint(vertexId, out point)) return true;
+
+ foreach (var edge in body.Topology.Edges)
+ {
+ if (edge.StartVertexId != vertexId && edge.EndVertexId != vertexId) continue;
+ if (!body.TryGetEdgeCurveGeometry(edge.Id, out var curve) || curve is null) continue;
+
+ if (curve.Kind == CurveGeometryKind.Line3)
+ {
+ var line = curve.Line3!.Value;
+ point = edge.StartVertexId == vertexId ? line.Evaluate(0d) : line.Evaluate(1d);
+ return true;
+ }
+
+ if (curve.Kind == CurveGeometryKind.Circle3)
+ {
+ point = curve.Circle3!.Value.Evaluate(0d);
+ return true;
+ }
+ }
+
+ point = Point3D.Origin;
+ return false;
+ }
+
+ private static Point3D ComputeCentroid(IReadOnlyList<Point3D> pts)
+ {
+ var sx = 0d; var sy = 0d; var sz = 0d;
+ foreach (var p in pts) { sx += p.X; sy += p.Y; sz += p.Z; }
+ return new Point3D(sx / pts.Count, sy / pts.Count, sz / pts.Count);
+ }
+
+ private static FirmamentKnownOpKind? InferFeatureKind(BrepBody body)
+ {
+ var f = body.Topology.Faces.Count();
+ var e = body.Topology.Edges.Count();
+ if (f == 6 && e == 12) return FirmamentKnownOpKind.Box;
+ if (f == 3) return FirmamentKnownOpKind.Cylinder;
+ if (f == 1) return FirmamentKnownOpKind.Sphere;
+ return FirmamentKnownOpKind.Add;
+ }
+
+ private static KernelResult<Point3D> Failure(string message) =>
+ KernelResult<Point3D>.Failure([new KernelDiagnostic(KernelDiagnosticCode.ValidationFailed, KernelDiagnosticSeverity.Error, $"[{FirmamentDiagnosticCodes.ValidationTargetSelectorResolvedEmpty.Value}] {message}", FirmamentDiagnosticConventions.Source)]);
+}
diff --git a/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs b/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs
index 85a32acf..28b7233a 100644
--- a/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs
+++ b/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs
@@ -1,7 +1,12 @@
using Aetheris.Kernel.Core.Brep;
using Aetheris.Kernel.Core.Brep.Boolean;
using Aetheris.Kernel.Core.Diagnostics;
+using Aetheris.Kernel.Core.Geometry;
+using Aetheris.Kernel.Core.Geometry.Curves;
+using Aetheris.Kernel.Core.Geometry.Surfaces;
+using Aetheris.Kernel.Core.Math;
using Aetheris.Kernel.Core.Results;
+using Aetheris.Kernel.Core.Topology;
using Aetheris.Kernel.Firmament.Lowering;
namespace Aetheris.Kernel.Firmament.Execution;
@@ -14,27 +19,25 @@ internal static class FirmamentPrimitiveExecutor
var executedPrimitives = new List<FirmamentExecutedPrimitive>(loweringPlan.Primitives.Count);
var executedBooleans = new List<FirmamentExecutedBoolean>(loweringPlan.Booleans.Count);
- var bodiesByFeatureId = new Dictionary<string, BrepBody>(StringComparer.Ordinal);
+ var publishedBodiesByFeatureId = new Dictionary<string, BrepBody>(StringComparer.Ordinal);
+ var booleanExecutionBodiesByFeatureId = new Dictionary<string, BrepBody>(StringComparer.Ordinal);
foreach (var primitive in loweringPlan.Primitives.OrderBy(p => p.OpIndex))
{
- var bodyResult = ExecutePrimitive(primitive);
+ var bodyResult = ExecutePrimitive(primitive, publishedBodiesByFeatureId);
if (!bodyResult.IsSuccess)
{
return KernelResult<FirmamentPrimitiveExecutionResult>.Failure(bodyResult.Diagnostics);
}
- executedPrimitives.Add(new FirmamentExecutedPrimitive(
- OpIndex: primitive.OpIndex,
- FeatureId: primitive.FeatureId,
- Kind: primitive.Kind,
- Body: bodyResult.Value));
- bodiesByFeatureId[primitive.FeatureId] = bodyResult.Value;
+ executedPrimitives.Add(new FirmamentExecutedPrimitive(primitive.OpIndex, primitive.FeatureId, primitive.Kind, bodyResult.Value.Published));
+ publishedBodiesByFeatureId[primitive.FeatureId] = bodyResult.Value.Published;
+ booleanExecutionBodiesByFeatureId[primitive.FeatureId] = bodyResult.Value.LegacyForBoolean;
}
foreach (var boolean in loweringPlan.Booleans.OrderBy(b => b.OpIndex))
{
- if (!bodiesByFeatureId.TryGetValue(boolean.PrimaryReferenceFeatureId, out var baseBody))
+ if (!booleanExecutionBodiesByFeatureId.TryGetValue(boolean.PrimaryReferenceFeatureId, out var baseBody))
{
continue;
}
@@ -56,28 +59,61 @@ internal static class FirmamentPrimitiveExecutor
return KernelResult<FirmamentPrimitiveExecutionResult>.Failure(booleanResult.Diagnostics);
}
- executedBooleans.Add(new FirmamentExecutedBoolean(
- OpIndex: boolean.OpIndex,
- FeatureId: boolean.FeatureId,
- Kind: boolean.Kind,
- Body: booleanResult.Value));
- bodiesByFeatureId[boolean.FeatureId] = booleanResult.Value;
+ executedBooleans.Add(new FirmamentExecutedBoolean(boolean.OpIndex, boolean.FeatureId, boolean.Kind, booleanResult.Value));
+ publishedBodiesByFeatureId[boolean.FeatureId] = booleanResult.Value;
+ booleanExecutionBodiesByFeatureId[boolean.FeatureId] = booleanResult.Value;
}
return KernelResult<FirmamentPrimitiveExecutionResult>.Success(new FirmamentPrimitiveExecutionResult(executedPrimitives, executedBooleans));
}
+ private static KernelResult<FirmamentExecutedPrimitiveBodies> ExecutePrimitive(FirmamentLoweredPrimitive primitive, IReadOnlyDictionary<string, BrepBody> publishedBodies)
+ {
+ var legacyResult = ExecuteLegacyPrimitive(primitive);
+ if (!legacyResult.IsSuccess)
+ {
+ return KernelResult<FirmamentExecutedPrimitiveBodies>.Failure(legacyResult.Diagnostics);
+ }
+
+ var defaultFrameBody = ApplyDefaultLocalFrame(primitive, legacyResult.Value);
+ var placementResult = FirmamentPlacementResolver.ResolvePlacementTranslation(primitive, publishedBodies);
+ if (!placementResult.IsSuccess)
+ {
+ return KernelResult<FirmamentExecutedPrimitiveBodies>.Failure(placementResult.Diagnostics);
+ }
+
+ var publishedBody = TranslateBody(defaultFrameBody, placementResult.Value);
+ return KernelResult<FirmamentExecutedPrimitiveBodies>.Success(new FirmamentExecutedPrimitiveBodies(publishedBody, legacyResult.Value));
+ }
+
+ private static BrepBody ApplyDefaultLocalFrame(FirmamentLoweredPrimitive primitive, BrepBody body)
+ {
+ return primitive.Kind switch
+ {
+ FirmamentLoweredPrimitiveKind.Box => TranslateBody(body, new Vector3D(0d, 0d, ((FirmamentLoweredBoxParameters)primitive.Parameters).SizeZ * 0.5d)),
+ FirmamentLoweredPrimitiveKind.Cylinder => TranslateBody(body, new Vector3D(0d, 0d, ((FirmamentLoweredCylinderParameters)primitive.Parameters).Height * 0.5d)),
+ _ => body
+ };
+ }
+
+ private static KernelResult<BrepBody> ExecuteLegacyPrimitive(FirmamentLoweredPrimitive primitive)
+ {
+ return primitive.Kind switch
+ {
+ FirmamentLoweredPrimitiveKind.Box => BrepPrimitives.CreateBox(((FirmamentLoweredBoxParameters)primitive.Parameters).SizeX, ((FirmamentLoweredBoxParameters)primitive.Parameters).SizeY, ((FirmamentLoweredBoxParameters)primitive.Parameters).SizeZ),
+ FirmamentLoweredPrimitiveKind.Cylinder => BrepPrimitives.CreateCylinder(((FirmamentLoweredCylinderParameters)primitive.Parameters).Radius, ((FirmamentLoweredCylinderParameters)primitive.Parameters).Height),
+ FirmamentLoweredPrimitiveKind.Sphere => BrepPrimitives.CreateSphere(((FirmamentLoweredSphereParameters)primitive.Parameters).Radius),
+ _ => KernelResult<BrepBody>.Failure([new KernelDiagnostic(KernelDiagnosticCode.NotImplemented, KernelDiagnosticSeverity.Error, $"Primitive execution for kind '{primitive.Kind}' is not implemented.")])
+ };
+ }
+
private static KernelResult<BrepBody> ExecuteTool(FirmamentLoweredToolOp tool)
{
if (string.Equals(tool.OpName, "box", StringComparison.Ordinal))
{
if (!tool.RawFields.TryGetValue("size", out var sizeRaw) || string.IsNullOrWhiteSpace(sizeRaw))
{
- return KernelResult<BrepBody>.Failure([
- new KernelDiagnostic(
- KernelDiagnosticCode.ValidationFailed,
- KernelDiagnosticSeverity.Error,
- "Boolean execution expected validated nested field 'with.size' for tool op 'box'.")]);
+ return KernelResult<BrepBody>.Failure([new KernelDiagnostic(KernelDiagnosticCode.ValidationFailed, KernelDiagnosticSeverity.Error, "Boolean execution expected validated nested field 'with.size' for tool op 'box'.")]);
}
var parameters = FirmamentPrimitiveToolParsing.ParseBox(sizeRaw);
@@ -89,100 +125,82 @@ internal static class FirmamentPrimitiveExecutor
if (!tool.RawFields.TryGetValue("radius", out var radiusRaw) || string.IsNullOrWhiteSpace(radiusRaw)
|| !tool.RawFields.TryGetValue("height", out var heightRaw) || string.IsNullOrWhiteSpace(heightRaw))
{
- return KernelResult<BrepBody>.Failure([
- new KernelDiagnostic(
- KernelDiagnosticCode.ValidationFailed,
- KernelDiagnosticSeverity.Error,
- "Boolean execution expected validated nested fields 'with.radius' and 'with.height' for tool op 'cylinder'.")]);
+ return KernelResult<BrepBody>.Failure([new KernelDiagnostic(KernelDiagnosticCode.ValidationFailed, KernelDiagnosticSeverity.Error, "Boolean execution expected validated nested fields 'with.radius' and 'with.height' for tool op 'cylinder'.")]);
}
- var radius = FirmamentPrimitiveToolParsing.ParseScalar(radiusRaw);
- var height = FirmamentPrimitiveToolParsing.ParseScalar(heightRaw);
- return BrepPrimitives.CreateCylinder(radius, height);
+ return BrepPrimitives.CreateCylinder(FirmamentPrimitiveToolParsing.ParseScalar(radiusRaw), FirmamentPrimitiveToolParsing.ParseScalar(heightRaw));
}
if (string.Equals(tool.OpName, "sphere", StringComparison.Ordinal))
{
if (!tool.RawFields.TryGetValue("radius", out var radiusRaw) || string.IsNullOrWhiteSpace(radiusRaw))
{
- return KernelResult<BrepBody>.Failure([
- new KernelDiagnostic(
- KernelDiagnosticCode.ValidationFailed,
- KernelDiagnosticSeverity.Error,
- "Boolean execution expected validated nested field 'with.radius' for tool op 'sphere'.")]);
+ return KernelResult<BrepBody>.Failure([new KernelDiagnostic(KernelDiagnosticCode.ValidationFailed, KernelDiagnosticSeverity.Error, "Boolean execution expected validated nested field 'with.radius' for tool op 'sphere'.")]);
}
- var radius = FirmamentPrimitiveToolParsing.ParseScalar(radiusRaw);
- return BrepPrimitives.CreateSphere(radius);
+ return BrepPrimitives.CreateSphere(FirmamentPrimitiveToolParsing.ParseScalar(radiusRaw));
}
- return KernelResult<BrepBody>.Failure([
- new KernelDiagnostic(
- KernelDiagnosticCode.NotImplemented,
- KernelDiagnosticSeverity.Error,
- $"Boolean execution supports nested tool ops 'box', 'cylinder', and 'sphere' only. Got '{tool.OpName}'.")]);
+ return KernelResult<BrepBody>.Failure([new KernelDiagnostic(KernelDiagnosticCode.NotImplemented, KernelDiagnosticSeverity.Error, $"Boolean execution supports nested tool ops 'box', 'cylinder', and 'sphere' only. Got '{tool.OpName}'.")]);
}
- private static KernelResult<BrepBody> ExecuteBoolean(FirmamentLoweredBooleanKind kind, BrepBody left, BrepBody right)
- {
- return kind switch
+ private static KernelResult<BrepBody> ExecuteBoolean(FirmamentLoweredBooleanKind kind, BrepBody left, BrepBody right) =>
+ kind switch
{
FirmamentLoweredBooleanKind.Add => BrepBoolean.Union(left, right),
FirmamentLoweredBooleanKind.Subtract => BrepBoolean.Subtract(left, right),
FirmamentLoweredBooleanKind.Intersect => BrepBoolean.Intersect(left, right),
- _ => KernelResult<BrepBody>.Failure([
- new KernelDiagnostic(
- KernelDiagnosticCode.NotImplemented,
- KernelDiagnosticSeverity.Error,
- $"Boolean execution for kind '{kind}' is not implemented.")])
+ _ => KernelResult<BrepBody>.Failure([new KernelDiagnostic(KernelDiagnosticCode.NotImplemented, KernelDiagnosticSeverity.Error, $"Boolean execution for kind '{kind}' is not implemented.")])
};
- }
- private static KernelResult<BrepBody> ExecutePrimitive(FirmamentLoweredPrimitive primitive)
+ private static BrepBody TranslateBody(BrepBody body, Vector3D translation)
{
- return primitive.Kind switch
+ if (translation == Vector3D.Zero) return body;
+
+ var translatedGeometry = new BrepGeometryStore();
+ foreach (var curveEntry in body.Geometry.Curves)
{
- FirmamentLoweredPrimitiveKind.Box => ExecuteBox(primitive),
- FirmamentLoweredPrimitiveKind.Cylinder => ExecuteCylinder(primitive),
- FirmamentLoweredPrimitiveKind.Sphere => ExecuteSphere(primitive),
- _ => KernelResult<BrepBody>.Failure([
- new KernelDiagnostic(
- KernelDiagnosticCode.NotImplemented,
- KernelDiagnosticSeverity.Error,
- $"Primitive execution for kind '{primitive.Kind}' is not implemented.")])
- };
- }
+ translatedGeometry.AddCurve(curveEntry.Key, curveEntry.Value.Kind switch
+ {
+ CurveGeometryKind.Line3 => CurveGeometry.FromLine(new Line3Curve(curveEntry.Value.Line3!.Value.Origin + translation, curveEntry.Value.Line3.Value.Direction)),
+ CurveGeometryKind.Circle3 => CurveGeometry.FromCircle(new Circle3Curve(curveEntry.Value.Circle3!.Value.Center + translation, curveEntry.Value.Circle3.Value.Normal, curveEntry.Value.Circle3.Value.Radius, curveEntry.Value.Circle3.Value.XAxis)),
+ _ => curveEntry.Value
+ });
+ }
- private static KernelResult<BrepBody> ExecuteBox(FirmamentLoweredPrimitive primitive)
- {
- var parameters = (FirmamentLoweredBoxParameters)primitive.Parameters;
- return BrepPrimitives.CreateBox(parameters.SizeX, parameters.SizeY, parameters.SizeZ);
- }
+ foreach (var surfaceEntry in body.Geometry.Surfaces)
+ {
+ translatedGeometry.AddSurface(surfaceEntry.Key, surfaceEntry.Value.Kind switch
+ {
+ SurfaceGeometryKind.Plane => SurfaceGeometry.FromPlane(new PlaneSurface(surfaceEntry.Value.Plane!.Value.Origin + translation, surfaceEntry.Value.Plane.Value.Normal, surfaceEntry.Value.Plane.Value.UAxis)),
+ SurfaceGeometryKind.Cylinder => SurfaceGeometry.FromCylinder(new CylinderSurface(surfaceEntry.Value.Cylinder!.Value.Origin + translation, surfaceEntry.Value.Cylinder.Value.Axis, surfaceEntry.Value.Cylinder.Value.Radius, surfaceEntry.Value.Cylinder.Value.XAxis)),
+ SurfaceGeometryKind.Sphere => SurfaceGeometry.FromSphere(new SphereSurface(surfaceEntry.Value.Sphere!.Value.Center + translation, surfaceEntry.Value.Sphere.Value.Axis, surfaceEntry.Value.Sphere.Value.Radius, surfaceEntry.Value.Sphere.Value.XAxis)),
+ _ => surfaceEntry.Value
+ });
+ }
- private static KernelResult<BrepBody> ExecuteCylinder(FirmamentLoweredPrimitive primitive)
- {
- var parameters = (FirmamentLoweredCylinderParameters)primitive.Parameters;
- return BrepPrimitives.CreateCylinder(parameters.Radius, parameters.Height);
- }
+ var vertexPoints = new Dictionary<VertexId, Point3D>();
+ foreach (var vertex in body.Topology.Vertices)
+ {
+ if (FirmamentPlacementResolver.TryGetVertexPoint(body, vertex.Id, out var point))
+ {
+ vertexPoints[vertex.Id] = point + translation;
+ }
+ }
- private static KernelResult<BrepBody> ExecuteSphere(FirmamentLoweredPrimitive primitive)
- {
- var parameters = (FirmamentLoweredSphereParameters)primitive.Parameters;
- return BrepPrimitives.CreateSphere(parameters.Radius);
+ return new BrepBody(body.Topology, translatedGeometry, body.Bindings, vertexPoints);
}
}
+internal sealed record FirmamentExecutedPrimitiveBodies(BrepBody Published, BrepBody LegacyForBoolean);
+
internal static class FirmamentPrimitiveToolParsing
{
public static FirmamentLoweredBoxParameters ParseBox(string sizeRaw)
{
using var doc = System.Text.Json.JsonDocument.Parse(sizeRaw);
var elements = doc.RootElement.EnumerateArray().ToArray();
-
- return new FirmamentLoweredBoxParameters(
- ParseScalar(elements[0].ToString()),
- ParseScalar(elements[1].ToString()),
- ParseScalar(elements[2].ToString()));
+ return new FirmamentLoweredBoxParameters(ParseScalar(elements[0].ToString()), ParseScalar(elements[1].ToString()), ParseScalar(elements[2].ToString()));
}
public static double ParseScalar(string raw)
diff --git a/Aetheris.Kernel.Firmament/FirmamentCompilationArtifact.cs b/Aetheris.Kernel.Firmament/FirmamentCompilationArtifact.cs
index d04e58b3..59ae9f6b 100644
--- a/Aetheris.Kernel.Firmament/FirmamentCompilationArtifact.cs
+++ b/Aetheris.Kernel.Firmament/FirmamentCompilationArtifact.cs
@@ -5,7 +5,7 @@ using Aetheris.Kernel.Firmament.ParsedModel;
namespace Aetheris.Kernel.Firmament;
public sealed record FirmamentCompilationArtifact(
- string ArtifactKind = "firmament-topology-manifold-validation-executed",
+ string ArtifactKind = "firmament-placement-executed",
FirmamentParsedDocument? ParsedDocument = null,
FirmamentPrimitiveLoweringPlan? PrimitiveLoweringPlan = null,
FirmamentPrimitiveExecutionResult? PrimitiveExecutionResult = null,
diff --git a/Aetheris.Kernel.Firmament/FirmamentCompiler.cs b/Aetheris.Kernel.Firmament/FirmamentCompiler.cs
index 592e08e2..53de2dca 100644
--- a/Aetheris.Kernel.Firmament/FirmamentCompiler.cs
+++ b/Aetheris.Kernel.Firmament/FirmamentCompiler.cs
@@ -80,7 +80,7 @@ public sealed class FirmamentCompiler
return new FirmamentCompileResult(
KernelResult<FirmamentCompilationArtifact>.Success(
new FirmamentCompilationArtifact(
- ArtifactKind: "firmament-topology-manifold-validation-executed",
+ ArtifactKind: "firmament-placement-executed",
ParsedDocument: validatedDocument,
PrimitiveLoweringPlan: primitiveLoweringResult.Value,
PrimitiveExecutionResult: primitiveExecutionResult.Value,
diff --git a/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLowerer.cs b/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLowerer.cs
index 6f946a09..fe1c204e 100644
--- a/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLowerer.cs
+++ b/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLowerer.cs
@@ -28,7 +28,8 @@ internal static class FirmamentPrimitiveLowerer
OpIndex: index,
FeatureId: entry.RawFields["id"],
Kind: FirmamentLoweredPrimitiveKind.Box,
- Parameters: LowerBoxParameters(entry.RawFields["size"])));
+ Parameters: LowerBoxParameters(entry.RawFields["size"]),
+ Placement: LowerPlacement(entry.Placement)));
break;
case FirmamentKnownOpKind.Cylinder:
@@ -38,7 +39,8 @@ internal static class FirmamentPrimitiveLowerer
Kind: FirmamentLoweredPrimitiveKind.Cylinder,
Parameters: new FirmamentLoweredCylinderParameters(
Radius: ParseScalar(entry.RawFields["radius"]),
- Height: ParseScalar(entry.RawFields["height"]))));
+ Height: ParseScalar(entry.RawFields["height"])),
+ Placement: LowerPlacement(entry.Placement)));
break;
case FirmamentKnownOpKind.Sphere:
@@ -47,7 +49,8 @@ internal static class FirmamentPrimitiveLowerer
FeatureId: entry.RawFields["id"],
Kind: FirmamentLoweredPrimitiveKind.Sphere,
Parameters: new FirmamentLoweredSphereParameters(
- Radius: ParseScalar(entry.RawFields["radius"]))));
+ Radius: ParseScalar(entry.RawFields["radius"])),
+ Placement: LowerPlacement(entry.Placement)));
break;
case FirmamentKnownOpKind.Add:
@@ -76,6 +79,29 @@ internal static class FirmamentPrimitiveLowerer
return KernelResult<FirmamentPrimitiveLoweringPlan>.Success(new FirmamentPrimitiveLoweringPlan(loweredPrimitives, loweredBooleans, skippedOps));
}
+
+ private static FirmamentLoweredPlacement? LowerPlacement(FirmamentParsedPlacement? placement)
+ {
+ if (placement is null)
+ {
+ return null;
+ }
+
+ FirmamentLoweredPlacementAnchor? loweredAnchor = placement.On switch
+ {
+ FirmamentParsedPlacementOriginAnchor => new FirmamentLoweredPlacementOriginAnchor(),
+ FirmamentParsedPlacementSelectorAnchor selector => new FirmamentLoweredPlacementSelectorAnchor(selector.Selector),
+ _ => null
+ };
+
+ if (loweredAnchor is null)
+ {
+ return null;
+ }
+
+ return new FirmamentLoweredPlacement(loweredAnchor, placement.Offset);
+ }
+
private static FirmamentLoweredBoolean LowerBoolean(
int opIndex,
FirmamentParsedOpEntry entry,
diff --git a/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLoweringPlan.cs b/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLoweringPlan.cs
index 825da0d3..6901dd45 100644
--- a/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLoweringPlan.cs
+++ b/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLoweringPlan.cs
@@ -11,7 +11,18 @@ public sealed record FirmamentLoweredPrimitive(
int OpIndex,
string FeatureId,
FirmamentLoweredPrimitiveKind Kind,
- FirmamentLoweredPrimitiveParameters Parameters);
+ FirmamentLoweredPrimitiveParameters Parameters,
+ FirmamentLoweredPlacement? Placement);
+
+public sealed record FirmamentLoweredPlacement(
+ FirmamentLoweredPlacementAnchor On,
+ IReadOnlyList<double> Offset);
+
+public abstract record FirmamentLoweredPlacementAnchor;
+
+public sealed record FirmamentLoweredPlacementOriginAnchor : FirmamentLoweredPlacementAnchor;
+
+public sealed record FirmamentLoweredPlacementSelectorAnchor(string Selector) : FirmamentLoweredPlacementAnchor;
public sealed record FirmamentLoweredBoolean(
int OpIndex,
diff --git a/testdata/firmament/fixtures/m7b-valid-placement-selector-anchor-boolean.firmament b/testdata/firmament/fixtures/m7b-valid-placement-selector-anchor-boolean.firmament
index 01feac54..806dc745 100644
--- a/testdata/firmament/fixtures/m7b-valid-placement-selector-anchor-boolean.firmament
+++ b/testdata/firmament/fixtures/m7b-valid-placement-selector-anchor-boolean.firmament
@@ -19,9 +19,11 @@ ops[3]:
id: union
to: base
with:
- op: cylinder
- radius: 1
- height: 2
+ op: box
+ size[3]:
+ 1
+ 1
+ 1
-
op: box
diff --git a/testdata/firmament/fixtures/m7c-invalid-placement-selector-runtime-empty.firmament b/testdata/firmament/fixtures/m7c-invalid-placement-selector-runtime-empty.firmament
new file mode 100644
index 00000000..738030cb
--- /dev/null
+++ b/testdata/firmament/fixtures/m7c-invalid-placement-selector-runtime-empty.firmament
@@ -0,0 +1,40 @@
+firmament:
+ version: 1
+
+model:
+ name: m7c_invalid_placement_selector_runtime_empty
+ units: mm
+
+ops[3]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 4
+ 4
+ 4
+
+ -
+ op: subtract
+ id: cut
+ from: base
+ with:
+ op: box
+ size[3]:
+ 4
+ 4
+ 4
+
+ -
+ op: box
+ id: placed
+ size[3]:
+ 1
+ 1
+ 1
+ place:
+ on: cut.edges
+ offset[3]:
+ 0
+ 0
+ 0
diff --git a/testdata/firmament/fixtures/m7c-valid-origin-placement-offset.firmament b/testdata/firmament/fixtures/m7c-valid-origin-placement-offset.firmament
new file mode 100644
index 00000000..1a82286c
--- /dev/null
+++ b/testdata/firmament/fixtures/m7c-valid-origin-placement-offset.firmament
@@ -0,0 +1,21 @@
+firmament:
+ version: 1
+
+model:
+ name: m7c_valid_origin_placement_offset
+ units: mm
+
+ops[1]:
+ -
+ op: box
+ id: moved
+ size[3]:
+ 2
+ 2
+ 2
+ place:
+ on: origin
+ offset[3]:
+ 10
+ -5
+ 2
diff --git a/testdata/firmament/fixtures/m7c-valid-selector-top-face-anchor.firmament b/testdata/firmament/fixtures/m7c-valid-selector-top-face-anchor.firmament
new file mode 100644
index 00000000..8dfa7eca
--- /dev/null
+++ b/testdata/firmament/fixtures/m7c-valid-selector-top-face-anchor.firmament
@@ -0,0 +1,29 @@
+firmament:
+ version: 1
+
+model:
+ name: m7c_valid_selector_top_face_anchor
+ units: mm
+
+ops[2]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 4
+ 4
+ 4
+
+ -
+ op: box
+ id: placed
+ size[3]:
+ 2
+ 2
+ 2
+ place:
+ on: base.top_face
+ offset[3]:
+ 0
+ 0
+ 0
diff --git a/testdata/firmament/fixtures/m7c-valid-selector-vertices-edges-anchors.firmament b/testdata/firmament/fixtures/m7c-valid-selector-vertices-edges-anchors.firmament
new file mode 100644
index 00000000..336defc3
--- /dev/null
+++ b/testdata/firmament/fixtures/m7c-valid-selector-vertices-edges-anchors.firmament
@@ -0,0 +1,43 @@
+firmament:
+ version: 1
+
+model:
+ name: m7c_valid_selector_vertices_edges_anchors
+ units: mm
+
+ops[3]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 4
+ 4
+ 4
+
+ -
+ op: box
+ id: on_vertices
+ size[3]:
+ 1
+ 1
+ 1
+ place:
+ on: base.vertices
+ offset[3]:
+ 0
+ 0
+ 0
+
+ -
+ op: box
+ id: on_edges
+ size[3]:
+ 1
+ 1
+ 1
+ place:
+ on: base.edges
+ offset[3]:
+ 0
+ 0
+ -2