Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

M3: add bounded prism primitives and explicit boolean deferral diagnostics

Yuechen Li319109f3cdf1
diff --git a/Aetheris.Kernel.Core.Tests/Brep/Primitives/BrepPrimitivesTests.cs b/Aetheris.Kernel.Core.Tests/Brep/Primitives/BrepPrimitivesTests.cs
index 67a7d628..e8a54805 100644
--- a/Aetheris.Kernel.Core.Tests/Brep/Primitives/BrepPrimitivesTests.cs
+++ b/Aetheris.Kernel.Core.Tests/Brep/Primitives/BrepPrimitivesTests.cs
@@ -198,4 +198,49 @@ public sealed class BrepPrimitivesTests
Assert.False(result.IsSuccess);
Assert.Contains(result.Diagnostics, d => d.Code == KernelDiagnosticCode.InvalidArgument);
}
+
+ [Fact]
+ public void CreateTriangularPrism_ProducesPlanarPolyhedralBody()
+ {
+ var result = BrepPrimitives.CreateTriangularPrism(8d, 6d, 10d);
+
+ Assert.True(result.IsSuccess);
+ var body = result.Value;
+ Assert.Equal(5, body.Topology.Faces.Count());
+ Assert.All(body.Topology.Faces, face =>
+ {
+ var surface = body.GetFaceSurface(face.Id);
+ Assert.Equal(SurfaceGeometryKind.Plane, surface.Kind);
+ });
+ }
+
+ [Fact]
+ public void CreateHexagonalPrism_ProducesPlanarPolyhedralBody()
+ {
+ var result = BrepPrimitives.CreateHexagonalPrism(10d, 12d);
+
+ Assert.True(result.IsSuccess);
+ var body = result.Value;
+ Assert.Equal(8, body.Topology.Faces.Count());
+ Assert.All(body.Topology.Faces, face =>
+ {
+ var surface = body.GetFaceSurface(face.Id);
+ Assert.Equal(SurfaceGeometryKind.Plane, surface.Kind);
+ });
+ }
+
+ [Fact]
+ public void CreateStraightSlot_ProducesPlanarPolyhedralBody()
+ {
+ var result = BrepPrimitives.CreateStraightSlot(20d, 8d, 6d);
+
+ Assert.True(result.IsSuccess);
+ var body = result.Value;
+ Assert.True(body.Topology.Faces.Count() >= 10);
+ Assert.All(body.Topology.Faces, face =>
+ {
+ var surface = body.GetFaceSurface(face.Id);
+ Assert.Equal(SurfaceGeometryKind.Plane, surface.Kind);
+ });
+ }
}
diff --git a/Aetheris.Kernel.Core/Brep/BrepPrimitives.cs b/Aetheris.Kernel.Core/Brep/BrepPrimitives.cs
index f35f7ea9..31e3993c 100644
--- a/Aetheris.Kernel.Core/Brep/BrepPrimitives.cs
+++ b/Aetheris.Kernel.Core/Brep/BrepPrimitives.cs
@@ -1,5 +1,7 @@
+using System.Linq;
using Aetheris.Kernel.Core.Diagnostics;
using Aetheris.Kernel.Core.Geometry;
+using Aetheris.Kernel.Core.Brep.Features;
using Aetheris.Kernel.Core.Geometry.Curves;
using Aetheris.Kernel.Core.Geometry.Surfaces;
using Aetheris.Kernel.Core.Math;
@@ -14,6 +16,126 @@ namespace Aetheris.Kernel.Core.Brep;
/// </summary>
public static class BrepPrimitives
{
+ /// <summary>
+ /// Bounded M3 triangular prism primitive.
+ /// Profile frame is XY, extrusion is world +Z, and the triangle base is centered about origin:
+ /// (-baseWidth/2,-baseDepth/2), (+baseWidth/2,-baseDepth/2), (0,+baseDepth/2).
+ /// Legacy body is centered on Z in [-height/2,+height/2].
+ /// </summary>
+ public static KernelResult<BrepBody> CreateTriangularPrism(double baseWidth, double baseDepth, double height)
+ {
+ var diagnostics = ValidatePositiveFinite((baseWidth, nameof(baseWidth)), (baseDepth, nameof(baseDepth)), (height, nameof(height)));
+ if (diagnostics.Count > 0)
+ {
+ return KernelResult<BrepBody>.Failure(diagnostics);
+ }
+
+ var profile = PolylineProfile2D.Create(
+ [
+ new ProfilePoint2D(-baseWidth * 0.5d, -baseDepth * 0.5d),
+ new ProfilePoint2D(baseWidth * 0.5d, -baseDepth * 0.5d),
+ new ProfilePoint2D(0d, baseDepth * 0.5d),
+ ]);
+ if (!profile.IsSuccess)
+ {
+ return KernelResult<BrepBody>.Failure(profile.Diagnostics);
+ }
+
+ var extrude = BrepExtrude.Create(
+ profile.Value,
+ new ExtrudeFrame3D(new Point3D(0d, 0d, -height * 0.5d), Direction3D.Create(new Vector3D(0d, 0d, 1d)), Direction3D.Create(new Vector3D(1d, 0d, 0d))),
+ height);
+ return extrude;
+ }
+
+ /// <summary>
+ /// Bounded M3 hexagonal prism primitive.
+ /// Profile frame is XY, extrusion is world +Z, regular hexagon centered at origin with across-flats distance.
+ /// Legacy body is centered on Z in [-height/2,+height/2].
+ /// </summary>
+ public static KernelResult<BrepBody> CreateHexagonalPrism(double acrossFlats, double height)
+ {
+ var diagnostics = ValidatePositiveFinite((acrossFlats, nameof(acrossFlats)), (height, nameof(height)));
+ if (diagnostics.Count > 0)
+ {
+ return KernelResult<BrepBody>.Failure(diagnostics);
+ }
+
+ var circumradius = acrossFlats / double.Sqrt(3d);
+ var vertices = Enumerable.Range(0, 6)
+ .Select(index =>
+ {
+ var angle = (double.Pi / 3d) * index;
+ return new ProfilePoint2D(circumradius * double.Cos(angle), circumradius * double.Sin(angle));
+ })
+ .ToArray();
+ var profile = PolylineProfile2D.Create(vertices);
+ if (!profile.IsSuccess)
+ {
+ return KernelResult<BrepBody>.Failure(profile.Diagnostics);
+ }
+
+ var extrude = BrepExtrude.Create(
+ profile.Value,
+ new ExtrudeFrame3D(new Point3D(0d, 0d, -height * 0.5d), Direction3D.Create(new Vector3D(0d, 0d, 1d)), Direction3D.Create(new Vector3D(1d, 0d, 0d))),
+ height);
+ return extrude;
+ }
+
+ /// <summary>
+ /// Bounded M3 straight slot primitive as an obround (capsule) prism.
+ /// Profile frame is XY, extrusion is world +Z, with slot major axis on X and rounded ends approximated by a polyline.
+ /// Legacy body is centered on Z in [-height/2,+height/2].
+ /// </summary>
+ public static KernelResult<BrepBody> CreateStraightSlot(double length, double width, double height)
+ {
+ var diagnostics = ValidatePositiveFinite((length, nameof(length)), (width, nameof(width)), (height, nameof(height)));
+ if (diagnostics.Count > 0)
+ {
+ return KernelResult<BrepBody>.Failure(diagnostics);
+ }
+
+ if (length < width)
+ {
+ return KernelResult<BrepBody>.Failure([
+ new KernelDiagnostic(
+ KernelDiagnosticCode.InvalidArgument,
+ KernelDiagnosticSeverity.Error,
+ $"{nameof(length)} must be greater than or equal to {nameof(width)} for straight slot primitive.")
+ ]);
+ }
+
+ const int semicircleSegments = 8;
+ var halfLength = length * 0.5d;
+ var radius = width * 0.5d;
+ var centerOffset = halfLength - radius;
+ var profileVertices = new List<ProfilePoint2D>(2 * (semicircleSegments + 1));
+
+ for (var i = 0; i <= semicircleSegments; i++)
+ {
+ var t = double.Pi * (i / (double)semicircleSegments) - (double.Pi * 0.5d);
+ profileVertices.Add(new ProfilePoint2D(centerOffset + (radius * double.Cos(t)), radius * double.Sin(t)));
+ }
+
+ for (var i = 0; i <= semicircleSegments; i++)
+ {
+ var t = double.Pi * (i / (double)semicircleSegments) + (double.Pi * 0.5d);
+ profileVertices.Add(new ProfilePoint2D(-centerOffset + (radius * double.Cos(t)), radius * double.Sin(t)));
+ }
+
+ var profile = PolylineProfile2D.Create(profileVertices);
+ if (!profile.IsSuccess)
+ {
+ return KernelResult<BrepBody>.Failure(profile.Diagnostics);
+ }
+
+ var extrude = BrepExtrude.Create(
+ profile.Value,
+ new ExtrudeFrame3D(new Point3D(0d, 0d, -height * 0.5d), Direction3D.Create(new Vector3D(0d, 0d, 1d)), Direction3D.Create(new Vector3D(1d, 0d, 0d))),
+ height);
+ return extrude;
+ }
+
public static KernelResult<BrepBody> CreateBox(double width, double height, double depth)
{
var diagnostics = ValidatePositiveFinite((width, nameof(width)), (height, nameof(height)), (depth, nameof(depth)));
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentBuildAndExportTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentBuildAndExportTests.cs
index f7c09ee2..3ff7fd5d 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentBuildAndExportTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentBuildAndExportTests.cs
@@ -54,6 +54,42 @@ public sealed class FirmamentBuildAndExportTests
"torus");
}
+ [Fact]
+ public void Run_TriangularPrismBasicExample_Writes_Default_Export_Artifact()
+ {
+ AssertExampleBuildAndExport(
+ "testdata/firmament/examples/triangular_prism_basic.firmament",
+ "triangular_prism_basic.step",
+ "tri1",
+ 0,
+ "primitive",
+ "triangularprism");
+ }
+
+ [Fact]
+ public void Run_HexagonalPrismBasicExample_Writes_Default_Export_Artifact()
+ {
+ AssertExampleBuildAndExport(
+ "testdata/firmament/examples/hexagonal_prism_basic.firmament",
+ "hexagonal_prism_basic.step",
+ "hex1",
+ 0,
+ "primitive",
+ "hexagonalprism");
+ }
+
+ [Fact]
+ public void Run_StraightSlotBasicExample_Writes_Default_Export_Artifact()
+ {
+ AssertExampleBuildAndExport(
+ "testdata/firmament/examples/straight_slot_basic.firmament",
+ "straight_slot_basic.step",
+ "slot1",
+ 0,
+ "primitive",
+ "straightslot");
+ }
+
[Fact]
public void Run_ConeFrustumBasicExample_Writes_Default_Export_Artifact()
{
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentExamplePackSmokeTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentExamplePackSmokeTests.cs
index 2df72b46..b4c14e84 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentExamplePackSmokeTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentExamplePackSmokeTests.cs
@@ -12,6 +12,9 @@ public sealed class FirmamentExamplePackSmokeTests
"testdata/firmament/examples/cone_pointed_top_zero.firmament",
"testdata/firmament/examples/sphere_basic.firmament",
"testdata/firmament/examples/torus_basic.firmament",
+ "testdata/firmament/examples/triangular_prism_basic.firmament",
+ "testdata/firmament/examples/hexagonal_prism_basic.firmament",
+ "testdata/firmament/examples/straight_slot_basic.firmament",
"testdata/firmament/examples/box_add_basic.firmament",
"testdata/firmament/examples/boolean_add_basic.firmament",
"testdata/firmament/examples/boolean_subtract_basic.firmament",
@@ -45,6 +48,9 @@ public sealed class FirmamentExamplePackSmokeTests
[InlineData("testdata/firmament/examples/cone_pointed_top_zero.firmament", "pointed1", 0, "primitive", "cone")]
[InlineData("testdata/firmament/examples/sphere_basic.firmament", "ball", 0, "primitive", "sphere")]
[InlineData("testdata/firmament/examples/torus_basic.firmament", "donut1", 0, "primitive", "torus")]
+ [InlineData("testdata/firmament/examples/triangular_prism_basic.firmament", "tri1", 0, "primitive", "triangularprism")]
+ [InlineData("testdata/firmament/examples/hexagonal_prism_basic.firmament", "hex1", 0, "primitive", "hexagonalprism")]
+ [InlineData("testdata/firmament/examples/straight_slot_basic.firmament", "slot1", 0, "primitive", "straightslot")]
[InlineData("testdata/firmament/examples/box_add_basic.firmament", "joined", 1, "boolean", "add")]
[InlineData("testdata/firmament/examples/boolean_add_basic.firmament", "joined", 2, "boolean", "add")]
[InlineData("testdata/firmament/examples/boolean_subtract_basic.firmament", "carved", 2, "boolean", "subtract")]
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs
index 045340e4..b05a70f9 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs
@@ -183,6 +183,42 @@ public sealed class FirmamentPrimitiveExecutionTests
});
}
+ [Fact]
+ public void Compile_Executes_TriangularPrism_Primitive_Into_Real_Body()
+ {
+ var result = CompileFixture("testdata/firmament/examples/triangular_prism_basic.firmament");
+
+ Assert.True(result.Compilation.IsSuccess);
+ var executed = Assert.Single(result.Compilation.Value.PrimitiveExecutionResult!.ExecutedPrimitives);
+ Assert.Equal("tri1", executed.FeatureId);
+ Assert.Equal(FirmamentLoweredPrimitiveKind.TriangularPrism, executed.Kind);
+ Assert.Equal(5, executed.Body.Topology.Faces.Count());
+ }
+
+ [Fact]
+ public void Compile_Executes_HexagonalPrism_Primitive_Into_Real_Body()
+ {
+ var result = CompileFixture("testdata/firmament/examples/hexagonal_prism_basic.firmament");
+
+ Assert.True(result.Compilation.IsSuccess);
+ var executed = Assert.Single(result.Compilation.Value.PrimitiveExecutionResult!.ExecutedPrimitives);
+ Assert.Equal("hex1", executed.FeatureId);
+ Assert.Equal(FirmamentLoweredPrimitiveKind.HexagonalPrism, executed.Kind);
+ Assert.Equal(8, executed.Body.Topology.Faces.Count());
+ }
+
+ [Fact]
+ public void Compile_Executes_StraightSlot_Primitive_Into_Real_Body()
+ {
+ var result = CompileFixture("testdata/firmament/examples/straight_slot_basic.firmament");
+
+ Assert.True(result.Compilation.IsSuccess);
+ var executed = Assert.Single(result.Compilation.Value.PrimitiveExecutionResult!.ExecutedPrimitives);
+ Assert.Equal("slot1", executed.FeatureId);
+ Assert.Equal(FirmamentLoweredPrimitiveKind.StraightSlot, executed.Kind);
+ Assert.True(executed.Body.Topology.Faces.Count() >= 10);
+ }
+
[Fact]
public void Compile_Executes_Add_Boolean_Into_Real_Body()
{
@@ -258,7 +294,7 @@ public sealed class FirmamentPrimitiveExecutionTests
Assert.False(result.Compilation.IsSuccess);
var diagnostic = Assert.Single(result.Compilation.Diagnostics);
Assert.Equal(Aetheris.Kernel.Core.Diagnostics.KernelDiagnosticCode.NotImplemented, diagnostic.Code);
- Assert.Contains("supports nested tool ops 'box', 'cylinder', 'sphere', 'cone', and 'torus' only", diagnostic.Message, StringComparison.Ordinal);
+ Assert.Contains("supports nested tool ops 'box', 'cylinder', 'sphere', 'cone', 'torus', 'triangular_prism', 'hexagonal_prism', and 'straight_slot' only", diagnostic.Message, StringComparison.Ordinal);
}
[Theory]
@@ -281,6 +317,20 @@ public sealed class FirmamentPrimitiveExecutionTests
|| diagnostic.Message.Contains("Boolean feature", StringComparison.Ordinal)));
}
+ [Theory]
+ [InlineData("testdata/firmament/fixtures/m3-prism-boolean-triangular-rejected.firmament", "tri_cut")]
+ [InlineData("testdata/firmament/fixtures/m3-prism-boolean-hexagonal-rejected.firmament", "hex_cut")]
+ [InlineData("testdata/firmament/fixtures/m3-prism-boolean-slot-rejected.firmament", "slot_cut")]
+ public void Compile_PrismBooleanTools_AreExplicitlyRejected(string fixturePath, string featureId)
+ {
+ var result = CompileFixture(fixturePath);
+
+ Assert.False(result.Compilation.IsSuccess);
+ Assert.Contains(result.Compilation.Diagnostics, diagnostic =>
+ diagnostic.Message.Contains($"Boolean feature '{featureId}'", StringComparison.Ordinal)
+ && diagnostic.Message.Contains("bounded prism-family booleans are explicitly deferred", StringComparison.Ordinal));
+ }
+
[Fact]
public void Compile_ValidationFailure_Still_Fails_Before_Execution()
{
diff --git a/Aetheris.Kernel.Firmament/Execution/FirmamentBooleanToolBodyFactory.cs b/Aetheris.Kernel.Firmament/Execution/FirmamentBooleanToolBodyFactory.cs
index 83fc5e4b..756af5e4 100644
--- a/Aetheris.Kernel.Firmament/Execution/FirmamentBooleanToolBodyFactory.cs
+++ b/Aetheris.Kernel.Firmament/Execution/FirmamentBooleanToolBodyFactory.cs
@@ -69,6 +69,49 @@ internal static class FirmamentBooleanToolBodyFactory
FirmamentPrimitiveToolParsing.ParseScalar(minorRadiusRaw));
}
- return KernelResult<BrepBody>.Failure([new KernelDiagnostic(KernelDiagnosticCode.NotImplemented, KernelDiagnosticSeverity.Error, $"Boolean execution supports nested tool ops 'box', 'cylinder', 'sphere', 'cone', and 'torus' only. Got '{tool.OpName}'.")]);
+ if (string.Equals(tool.OpName, "triangular_prism", StringComparison.Ordinal))
+ {
+ if (!tool.RawFields.TryGetValue("base_width", out var baseWidthRaw) || string.IsNullOrWhiteSpace(baseWidthRaw)
+ || !tool.RawFields.TryGetValue("base_depth", out var baseDepthRaw) || string.IsNullOrWhiteSpace(baseDepthRaw)
+ || !tool.RawFields.TryGetValue("height", out var triangularHeightRaw) || string.IsNullOrWhiteSpace(triangularHeightRaw))
+ {
+ return KernelResult<BrepBody>.Failure([new KernelDiagnostic(KernelDiagnosticCode.ValidationFailed, KernelDiagnosticSeverity.Error, "Boolean execution expected validated nested fields 'with.base_width', 'with.base_depth', and 'with.height' for tool op 'triangular_prism'.")]);
+ }
+
+ return BrepPrimitives.CreateTriangularPrism(
+ FirmamentPrimitiveToolParsing.ParseScalar(baseWidthRaw),
+ FirmamentPrimitiveToolParsing.ParseScalar(baseDepthRaw),
+ FirmamentPrimitiveToolParsing.ParseScalar(triangularHeightRaw));
+ }
+
+ if (string.Equals(tool.OpName, "hexagonal_prism", StringComparison.Ordinal))
+ {
+ if (!tool.RawFields.TryGetValue("across_flats", out var acrossFlatsRaw) || string.IsNullOrWhiteSpace(acrossFlatsRaw)
+ || !tool.RawFields.TryGetValue("height", out var hexagonalHeightRaw) || string.IsNullOrWhiteSpace(hexagonalHeightRaw))
+ {
+ return KernelResult<BrepBody>.Failure([new KernelDiagnostic(KernelDiagnosticCode.ValidationFailed, KernelDiagnosticSeverity.Error, "Boolean execution expected validated nested fields 'with.across_flats' and 'with.height' for tool op 'hexagonal_prism'.")]);
+ }
+
+ return BrepPrimitives.CreateHexagonalPrism(
+ FirmamentPrimitiveToolParsing.ParseScalar(acrossFlatsRaw),
+ FirmamentPrimitiveToolParsing.ParseScalar(hexagonalHeightRaw));
+ }
+
+ if (string.Equals(tool.OpName, "straight_slot", StringComparison.Ordinal))
+ {
+ if (!tool.RawFields.TryGetValue("length", out var lengthRaw) || string.IsNullOrWhiteSpace(lengthRaw)
+ || !tool.RawFields.TryGetValue("width", out var widthRaw) || string.IsNullOrWhiteSpace(widthRaw)
+ || !tool.RawFields.TryGetValue("height", out var slotHeightRaw) || string.IsNullOrWhiteSpace(slotHeightRaw))
+ {
+ return KernelResult<BrepBody>.Failure([new KernelDiagnostic(KernelDiagnosticCode.ValidationFailed, KernelDiagnosticSeverity.Error, "Boolean execution expected validated nested fields 'with.length', 'with.width', and 'with.height' for tool op 'straight_slot'.")]);
+ }
+
+ return BrepPrimitives.CreateStraightSlot(
+ FirmamentPrimitiveToolParsing.ParseScalar(lengthRaw),
+ FirmamentPrimitiveToolParsing.ParseScalar(widthRaw),
+ FirmamentPrimitiveToolParsing.ParseScalar(slotHeightRaw));
+ }
+
+ return KernelResult<BrepBody>.Failure([new KernelDiagnostic(KernelDiagnosticCode.NotImplemented, KernelDiagnosticSeverity.Error, $"Boolean execution supports nested tool ops 'box', 'cylinder', 'sphere', 'cone', 'torus', 'triangular_prism', 'hexagonal_prism', and 'straight_slot' only. Got '{tool.OpName}'.")]);
}
}
diff --git a/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs b/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs
index 69bdfa57..5cee3d2a 100644
--- a/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs
+++ b/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs
@@ -111,6 +111,19 @@ internal static class FirmamentPrimitiveExecutor
return KernelResult<FirmamentPrimitiveExecutionResult>.Failure(toolResult.Diagnostics);
}
+ if (IsBoundedPrismTool(boolean.Tool.OpName))
+ {
+ return KernelResult<FirmamentPrimitiveExecutionResult>.Failure(
+ [
+ CreateBooleanExecutionFailureDiagnostic(boolean),
+ new KernelDiagnostic(
+ KernelDiagnosticCode.NotImplemented,
+ KernelDiagnosticSeverity.Error,
+ $"Boolean feature '{boolean.FeatureId}' ({boolean.Kind.ToString().ToLowerInvariant()}): bounded prism-family booleans are explicitly deferred in M3 implementation mode; standalone primitive execution/export is supported for 'triangular_prism', 'hexagonal_prism', and 'straight_slot' only.",
+ Source: "firmament")
+ ]);
+ }
+
var featureGraphValidation = FirmamentSafeSubtractFeatureGraphValidator.ValidateNextBoolean(
boolean,
featureGraphStates,
@@ -234,6 +247,11 @@ internal static class FirmamentPrimitiveExecutor
|| featureId.Contains("__cir", StringComparison.Ordinal)
|| featureId.Contains("__mir_", StringComparison.Ordinal);
+ private static bool IsBoundedPrismTool(string opName)
+ => string.Equals(opName, "triangular_prism", StringComparison.Ordinal)
+ || string.Equals(opName, "hexagonal_prism", StringComparison.Ordinal)
+ || string.Equals(opName, "straight_slot", StringComparison.Ordinal);
+
private static KernelResult<FirmamentExecutedPrimitiveBodies> ExecutePrimitive(FirmamentLoweredPrimitive primitive, IReadOnlyDictionary<string, BrepBody> publishedBodies)
{
var legacyResult = ExecuteLegacyPrimitive(primitive);
@@ -260,6 +278,9 @@ internal static class FirmamentPrimitiveExecutor
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)),
FirmamentLoweredPrimitiveKind.Cone => TranslateBody(body, new Vector3D(0d, 0d, ((FirmamentLoweredConeParameters)primitive.Parameters).Height * 0.5d)),
+ FirmamentLoweredPrimitiveKind.TriangularPrism => TranslateBody(body, new Vector3D(0d, 0d, ((FirmamentLoweredTriangularPrismParameters)primitive.Parameters).Height * 0.5d)),
+ FirmamentLoweredPrimitiveKind.HexagonalPrism => TranslateBody(body, new Vector3D(0d, 0d, ((FirmamentLoweredHexagonalPrismParameters)primitive.Parameters).Height * 0.5d)),
+ FirmamentLoweredPrimitiveKind.StraightSlot => TranslateBody(body, new Vector3D(0d, 0d, ((FirmamentLoweredStraightSlotParameters)primitive.Parameters).Height * 0.5d)),
_ => body
};
}
@@ -273,6 +294,17 @@ internal static class FirmamentPrimitiveExecutor
FirmamentLoweredPrimitiveKind.Cone => ExecuteCone((FirmamentLoweredConeParameters)primitive.Parameters),
FirmamentLoweredPrimitiveKind.Torus => BrepPrimitives.CreateTorus(((FirmamentLoweredTorusParameters)primitive.Parameters).MajorRadius, ((FirmamentLoweredTorusParameters)primitive.Parameters).MinorRadius),
FirmamentLoweredPrimitiveKind.Sphere => BrepPrimitives.CreateSphere(((FirmamentLoweredSphereParameters)primitive.Parameters).Radius),
+ FirmamentLoweredPrimitiveKind.TriangularPrism => BrepPrimitives.CreateTriangularPrism(
+ ((FirmamentLoweredTriangularPrismParameters)primitive.Parameters).BaseWidth,
+ ((FirmamentLoweredTriangularPrismParameters)primitive.Parameters).BaseDepth,
+ ((FirmamentLoweredTriangularPrismParameters)primitive.Parameters).Height),
+ FirmamentLoweredPrimitiveKind.HexagonalPrism => BrepPrimitives.CreateHexagonalPrism(
+ ((FirmamentLoweredHexagonalPrismParameters)primitive.Parameters).AcrossFlats,
+ ((FirmamentLoweredHexagonalPrismParameters)primitive.Parameters).Height),
+ FirmamentLoweredPrimitiveKind.StraightSlot => BrepPrimitives.CreateStraightSlot(
+ ((FirmamentLoweredStraightSlotParameters)primitive.Parameters).Length,
+ ((FirmamentLoweredStraightSlotParameters)primitive.Parameters).Width,
+ ((FirmamentLoweredStraightSlotParameters)primitive.Parameters).Height),
_ => KernelResult<BrepBody>.Failure([new KernelDiagnostic(KernelDiagnosticCode.NotImplemented, KernelDiagnosticSeverity.Error, $"Primitive execution for kind '{primitive.Kind}' is not implemented.")])
};
}
@@ -357,6 +389,30 @@ internal static class FirmamentPrimitiveExecutor
return TranslateBody(body, new Vector3D(0d, 0d, height * 0.5d));
}
+ if (string.Equals(tool.OpName, "triangular_prism", StringComparison.Ordinal)
+ && tool.RawFields.TryGetValue("height", out var triangularHeightRaw)
+ && !string.IsNullOrWhiteSpace(triangularHeightRaw))
+ {
+ var height = FirmamentPrimitiveToolParsing.ParseScalar(triangularHeightRaw);
+ return TranslateBody(body, new Vector3D(0d, 0d, height * 0.5d));
+ }
+
+ if (string.Equals(tool.OpName, "hexagonal_prism", StringComparison.Ordinal)
+ && tool.RawFields.TryGetValue("height", out var hexagonalHeightRaw)
+ && !string.IsNullOrWhiteSpace(hexagonalHeightRaw))
+ {
+ var height = FirmamentPrimitiveToolParsing.ParseScalar(hexagonalHeightRaw);
+ return TranslateBody(body, new Vector3D(0d, 0d, height * 0.5d));
+ }
+
+ if (string.Equals(tool.OpName, "straight_slot", StringComparison.Ordinal)
+ && tool.RawFields.TryGetValue("height", out var slotHeightRaw)
+ && !string.IsNullOrWhiteSpace(slotHeightRaw))
+ {
+ var height = FirmamentPrimitiveToolParsing.ParseScalar(slotHeightRaw);
+ return TranslateBody(body, new Vector3D(0d, 0d, height * 0.5d));
+ }
+
return body;
}
diff --git a/Aetheris.Kernel.Firmament/Formatting/FirmamentCanonicalFormatter.cs b/Aetheris.Kernel.Firmament/Formatting/FirmamentCanonicalFormatter.cs
index 5457d45f..2f0f8f2a 100644
--- a/Aetheris.Kernel.Firmament/Formatting/FirmamentCanonicalFormatter.cs
+++ b/Aetheris.Kernel.Firmament/Formatting/FirmamentCanonicalFormatter.cs
@@ -131,6 +131,20 @@ internal static class FirmamentCanonicalFormatter
case FirmamentKnownOpKind.Sphere:
EmitIfPresent(builder, entry.RawFields, emitted, indentLevel, "radius");
break;
+ case FirmamentKnownOpKind.TriangularPrism:
+ EmitIfPresent(builder, entry.RawFields, emitted, indentLevel, "base_width");
+ EmitIfPresent(builder, entry.RawFields, emitted, indentLevel, "base_depth");
+ EmitIfPresent(builder, entry.RawFields, emitted, indentLevel, "height");
+ break;
+ case FirmamentKnownOpKind.HexagonalPrism:
+ EmitIfPresent(builder, entry.RawFields, emitted, indentLevel, "across_flats");
+ EmitIfPresent(builder, entry.RawFields, emitted, indentLevel, "height");
+ break;
+ case FirmamentKnownOpKind.StraightSlot:
+ EmitIfPresent(builder, entry.RawFields, emitted, indentLevel, "length");
+ EmitIfPresent(builder, entry.RawFields, emitted, indentLevel, "width");
+ EmitIfPresent(builder, entry.RawFields, emitted, indentLevel, "height");
+ break;
case FirmamentKnownOpKind.Add:
EmitIfPresent(builder, entry.RawFields, emitted, indentLevel, "to");
EmitIfPresent(builder, entry.RawFields, emitted, indentLevel, "with");
diff --git a/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLowerer.cs b/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLowerer.cs
index 0268967f..50674bd4 100644
--- a/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLowerer.cs
+++ b/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLowerer.cs
@@ -75,6 +75,38 @@ internal static class FirmamentPrimitiveLowerer
Radius: ParseScalar(entry.RawFields["radius"])),
Placement: LowerPlacement(entry.Placement)));
break;
+ case FirmamentKnownOpKind.TriangularPrism:
+ loweredPrimitives.Add(new FirmamentLoweredPrimitive(
+ OpIndex: index,
+ FeatureId: entry.RawFields["id"],
+ Kind: FirmamentLoweredPrimitiveKind.TriangularPrism,
+ Parameters: new FirmamentLoweredTriangularPrismParameters(
+ BaseWidth: ParseScalar(entry.RawFields["base_width"]),
+ BaseDepth: ParseScalar(entry.RawFields["base_depth"]),
+ Height: ParseScalar(entry.RawFields["height"])),
+ Placement: LowerPlacement(entry.Placement)));
+ break;
+ case FirmamentKnownOpKind.HexagonalPrism:
+ loweredPrimitives.Add(new FirmamentLoweredPrimitive(
+ OpIndex: index,
+ FeatureId: entry.RawFields["id"],
+ Kind: FirmamentLoweredPrimitiveKind.HexagonalPrism,
+ Parameters: new FirmamentLoweredHexagonalPrismParameters(
+ AcrossFlats: ParseScalar(entry.RawFields["across_flats"]),
+ Height: ParseScalar(entry.RawFields["height"])),
+ Placement: LowerPlacement(entry.Placement)));
+ break;
+ case FirmamentKnownOpKind.StraightSlot:
+ loweredPrimitives.Add(new FirmamentLoweredPrimitive(
+ OpIndex: index,
+ FeatureId: entry.RawFields["id"],
+ Kind: FirmamentLoweredPrimitiveKind.StraightSlot,
+ Parameters: new FirmamentLoweredStraightSlotParameters(
+ Length: ParseScalar(entry.RawFields["length"]),
+ Width: ParseScalar(entry.RawFields["width"]),
+ Height: ParseScalar(entry.RawFields["height"])),
+ Placement: LowerPlacement(entry.Placement)));
+ break;
case FirmamentKnownOpKind.Add:
loweredBooleans.Add(LowerBoolean(index, entry, FirmamentLoweredBooleanKind.Add, "to"));
diff --git a/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLoweringPlan.cs b/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLoweringPlan.cs
index 9884343a..92747509 100644
--- a/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLoweringPlan.cs
+++ b/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLoweringPlan.cs
@@ -52,7 +52,10 @@ public enum FirmamentLoweredPrimitiveKind
Cylinder,
Cone,
Torus,
- Sphere
+ Sphere,
+ TriangularPrism,
+ HexagonalPrism,
+ StraightSlot
}
public abstract record FirmamentLoweredPrimitiveParameters;
@@ -72,6 +75,15 @@ public sealed record FirmamentLoweredTorusParameters(double MajorRadius, double
public sealed record FirmamentLoweredSphereParameters(double Radius)
: FirmamentLoweredPrimitiveParameters;
+public sealed record FirmamentLoweredTriangularPrismParameters(double BaseWidth, double BaseDepth, double Height)
+ : FirmamentLoweredPrimitiveParameters;
+
+public sealed record FirmamentLoweredHexagonalPrismParameters(double AcrossFlats, double Height)
+ : FirmamentLoweredPrimitiveParameters;
+
+public sealed record FirmamentLoweredStraightSlotParameters(double Length, double Width, double Height)
+ : FirmamentLoweredPrimitiveParameters;
+
public sealed record FirmamentLoweredToolOp(
string OpName,
IReadOnlyDictionary<string, string> RawFields,
diff --git a/Aetheris.Kernel.Firmament/ParsedModel/FirmamentKnownOpKind.cs b/Aetheris.Kernel.Firmament/ParsedModel/FirmamentKnownOpKind.cs
index 9e1fba49..853d1794 100644
--- a/Aetheris.Kernel.Firmament/ParsedModel/FirmamentKnownOpKind.cs
+++ b/Aetheris.Kernel.Firmament/ParsedModel/FirmamentKnownOpKind.cs
@@ -7,6 +7,9 @@ public enum FirmamentKnownOpKind
Cone,
Torus,
Sphere,
+ TriangularPrism,
+ HexagonalPrism,
+ StraightSlot,
Add,
Subtract,
Intersect,
@@ -28,6 +31,9 @@ internal static class FirmamentKnownOpKinds
["cone"] = FirmamentKnownOpKind.Cone,
["torus"] = FirmamentKnownOpKind.Torus,
["sphere"] = FirmamentKnownOpKind.Sphere,
+ ["triangular_prism"] = FirmamentKnownOpKind.TriangularPrism,
+ ["hexagonal_prism"] = FirmamentKnownOpKind.HexagonalPrism,
+ ["straight_slot"] = FirmamentKnownOpKind.StraightSlot,
["add"] = FirmamentKnownOpKind.Add,
["subtract"] = FirmamentKnownOpKind.Subtract,
["intersect"] = FirmamentKnownOpKind.Intersect,
@@ -50,6 +56,9 @@ internal static class FirmamentKnownOpKinds
FirmamentKnownOpKind.Cone => FirmamentOpFamily.Primitive,
FirmamentKnownOpKind.Torus => FirmamentOpFamily.Primitive,
FirmamentKnownOpKind.Sphere => FirmamentOpFamily.Primitive,
+ FirmamentKnownOpKind.TriangularPrism => FirmamentOpFamily.Primitive,
+ FirmamentKnownOpKind.HexagonalPrism => FirmamentOpFamily.Primitive,
+ FirmamentKnownOpKind.StraightSlot => FirmamentOpFamily.Primitive,
FirmamentKnownOpKind.Add => FirmamentOpFamily.Boolean,
FirmamentKnownOpKind.Subtract => FirmamentOpFamily.Boolean,
FirmamentKnownOpKind.Intersect => FirmamentOpFamily.Boolean,
diff --git a/Aetheris.Kernel.Firmament/Validation/FirmamentBooleanRequiredFieldValidator.cs b/Aetheris.Kernel.Firmament/Validation/FirmamentBooleanRequiredFieldValidator.cs
index 40153c30..3d2fbafd 100644
--- a/Aetheris.Kernel.Firmament/Validation/FirmamentBooleanRequiredFieldValidator.cs
+++ b/Aetheris.Kernel.Firmament/Validation/FirmamentBooleanRequiredFieldValidator.cs
@@ -102,6 +102,21 @@ internal static class FirmamentBooleanRequiredFieldValidator
return ValidateTorusTool(entry, opIndex, withFields);
}
+ if (string.Equals(withOpRaw, "triangular_prism", StringComparison.Ordinal))
+ {
+ return ValidateTriangularPrismTool(entry, opIndex, withFields);
+ }
+
+ if (string.Equals(withOpRaw, "hexagonal_prism", StringComparison.Ordinal))
+ {
+ return ValidateHexagonalPrismTool(entry, opIndex, withFields);
+ }
+
+ if (string.Equals(withOpRaw, "straight_slot", StringComparison.Ordinal))
+ {
+ return ValidateStraightSlotTool(entry, opIndex, withFields);
+ }
+
return KernelResult<bool>.Success(true);
}
@@ -206,6 +221,51 @@ internal static class FirmamentBooleanRequiredFieldValidator
return KernelResult<bool>.Success(true);
}
+ private static KernelResult<bool> ValidateTriangularPrismTool(FirmamentParsedOpEntry entry, int opIndex, IReadOnlyDictionary<string, string> withFields)
+ {
+ var baseWidth = ValidatePositiveNumericWithField(entry, opIndex, withFields, "base_width");
+ if (!baseWidth.IsSuccess)
+ {
+ return baseWidth;
+ }
+
+ var baseDepth = ValidatePositiveNumericWithField(entry, opIndex, withFields, "base_depth");
+ if (!baseDepth.IsSuccess)
+ {
+ return baseDepth;
+ }
+
+ return ValidatePositiveNumericWithField(entry, opIndex, withFields, "height");
+ }
+
+ private static KernelResult<bool> ValidateHexagonalPrismTool(FirmamentParsedOpEntry entry, int opIndex, IReadOnlyDictionary<string, string> withFields)
+ {
+ var acrossFlats = ValidatePositiveNumericWithField(entry, opIndex, withFields, "across_flats");
+ if (!acrossFlats.IsSuccess)
+ {
+ return acrossFlats;
+ }
+
+ return ValidatePositiveNumericWithField(entry, opIndex, withFields, "height");
+ }
+
+ private static KernelResult<bool> ValidateStraightSlotTool(FirmamentParsedOpEntry entry, int opIndex, IReadOnlyDictionary<string, string> withFields)
+ {
+ var length = ValidatePositiveNumericWithField(entry, opIndex, withFields, "length");
+ if (!length.IsSuccess)
+ {
+ return length;
+ }
+
+ var width = ValidatePositiveNumericWithField(entry, opIndex, withFields, "width");
+ if (!width.IsSuccess)
+ {
+ return width;
+ }
+
+ return ValidatePositiveNumericWithField(entry, opIndex, withFields, "height");
+ }
+
private static KernelResult<bool> ValidatePositiveNumericWithField(FirmamentParsedOpEntry entry, int opIndex, IReadOnlyDictionary<string, string> withFields, string fieldName)
{
var qualifiedFieldName = $"with.{fieldName}";
diff --git a/Aetheris.Kernel.Firmament/Validation/FirmamentPrimitiveRequiredFieldValidator.cs b/Aetheris.Kernel.Firmament/Validation/FirmamentPrimitiveRequiredFieldValidator.cs
index d68bc15e..ec4729b8 100644
--- a/Aetheris.Kernel.Firmament/Validation/FirmamentPrimitiveRequiredFieldValidator.cs
+++ b/Aetheris.Kernel.Firmament/Validation/FirmamentPrimitiveRequiredFieldValidator.cs
@@ -29,6 +29,9 @@ internal static class FirmamentPrimitiveRequiredFieldValidator
FirmamentKnownOpKind.Cone => ValidateCone(entry, index),
FirmamentKnownOpKind.Torus => ValidateTorus(entry, index),
FirmamentKnownOpKind.Sphere => ValidateSphere(entry, index),
+ FirmamentKnownOpKind.TriangularPrism => ValidateTriangularPrism(entry, index),
+ FirmamentKnownOpKind.HexagonalPrism => ValidateHexagonalPrism(entry, index),
+ FirmamentKnownOpKind.StraightSlot => ValidateStraightSlot(entry, index),
_ => KernelResult<bool>.Success(true)
};
@@ -211,6 +214,84 @@ internal static class FirmamentPrimitiveRequiredFieldValidator
return KernelResult<bool>.Success(true);
}
+ private static KernelResult<bool> ValidateTriangularPrism(FirmamentParsedOpEntry entry, int opIndex)
+ {
+ if (!TryGetRequiredNonEmptyScalar(entry, "id", opIndex, out var missingOrTypeDiagnostic))
+ {
+ return KernelResult<bool>.Failure([missingOrTypeDiagnostic!]);
+ }
+
+ var baseWidth = ValidatePositiveNumericField(entry, "base_width", opIndex);
+ if (!baseWidth.IsSuccess)
+ {
+ return baseWidth;
+ }
+
+ var baseDepth = ValidatePositiveNumericField(entry, "base_depth", opIndex);
+ if (!baseDepth.IsSuccess)
+ {
+ return baseDepth;
+ }
+
+ var heightResult = ValidatePositiveNumericField(entry, "height", opIndex);
+ if (!heightResult.IsSuccess)
+ {
+ return heightResult;
+ }
+
+ return ValidatePlacement(entry, opIndex);
+ }
+
+ private static KernelResult<bool> ValidateHexagonalPrism(FirmamentParsedOpEntry entry, int opIndex)
+ {
+ if (!TryGetRequiredNonEmptyScalar(entry, "id", opIndex, out var missingOrTypeDiagnostic))
+ {
+ return KernelResult<bool>.Failure([missingOrTypeDiagnostic!]);
+ }
+
+ var acrossFlats = ValidatePositiveNumericField(entry, "across_flats", opIndex);
+ if (!acrossFlats.IsSuccess)
+ {
+ return acrossFlats;
+ }
+
+ var heightResult = ValidatePositiveNumericField(entry, "height", opIndex);
+ if (!heightResult.IsSuccess)
+ {
+ return heightResult;
+ }
+
+ return ValidatePlacement(entry, opIndex);
+ }
+
+ private static KernelResult<bool> ValidateStraightSlot(FirmamentParsedOpEntry entry, int opIndex)
+ {
+ if (!TryGetRequiredNonEmptyScalar(entry, "id", opIndex, out var missingOrTypeDiagnostic))
+ {
+ return KernelResult<bool>.Failure([missingOrTypeDiagnostic!]);
+ }
+
+ var lengthResult = ValidatePositiveNumericField(entry, "length", opIndex);
+ if (!lengthResult.IsSuccess)
+ {
+ return lengthResult;
+ }
+
+ var widthResult = ValidatePositiveNumericField(entry, "width", opIndex);
+ if (!widthResult.IsSuccess)
+ {
+ return widthResult;
+ }
+
+ var heightResult = ValidatePositiveNumericField(entry, "height", opIndex);
+ if (!heightResult.IsSuccess)
+ {
+ return heightResult;
+ }
+
+ return ValidatePlacement(entry, opIndex);
+ }
+
private static KernelResult<bool> ValidatePlacement(FirmamentParsedOpEntry entry, int opIndex)
{
if (!entry.RawFields.ContainsKey("place"))
diff --git a/Aetheris.Kernel.Firmament/Validation/FirmamentSelectorContracts.cs b/Aetheris.Kernel.Firmament/Validation/FirmamentSelectorContracts.cs
index 436a235a..aec8db43 100644
--- a/Aetheris.Kernel.Firmament/Validation/FirmamentSelectorContracts.cs
+++ b/Aetheris.Kernel.Firmament/Validation/FirmamentSelectorContracts.cs
@@ -70,6 +70,11 @@ internal static class FirmamentSelectorContracts
case FirmamentKnownOpKind.Cylinder:
allowedPorts = CylinderAllowedPorts;
return true;
+ case FirmamentKnownOpKind.TriangularPrism:
+ case FirmamentKnownOpKind.HexagonalPrism:
+ case FirmamentKnownOpKind.StraightSlot:
+ allowedPorts = BoxAllowedPorts;
+ return true;
case FirmamentKnownOpKind.Cone:
allowedPorts = ConeAllowedPorts;
return true;
@@ -112,6 +117,11 @@ internal static class FirmamentSelectorContracts
case FirmamentKnownOpKind.Cylinder:
contracts = CylinderPorts;
return true;
+ case FirmamentKnownOpKind.TriangularPrism:
+ case FirmamentKnownOpKind.HexagonalPrism:
+ case FirmamentKnownOpKind.StraightSlot:
+ contracts = BoxPorts;
+ return true;
case FirmamentKnownOpKind.Cone:
contracts = ConePorts;
return true;
diff --git a/testdata/firmament/examples/hexagonal_prism_basic.firmament b/testdata/firmament/examples/hexagonal_prism_basic.firmament
new file mode 100644
index 00000000..5e09dc35
--- /dev/null
+++ b/testdata/firmament/examples/hexagonal_prism_basic.firmament
@@ -0,0 +1,13 @@
+firmament:
+ version: 1
+
+model:
+ name: hexagonal_prism_basic
+ units: mm
+
+ops[1]:
+ -
+ op: hexagonal_prism
+ id: hex1
+ across_flats: 16
+ height: 10
diff --git a/testdata/firmament/examples/straight_slot_basic.firmament b/testdata/firmament/examples/straight_slot_basic.firmament
new file mode 100644
index 00000000..b3b0dfa9
--- /dev/null
+++ b/testdata/firmament/examples/straight_slot_basic.firmament
@@ -0,0 +1,14 @@
+firmament:
+ version: 1
+
+model:
+ name: straight_slot_basic
+ units: mm
+
+ops[1]:
+ -
+ op: straight_slot
+ id: slot1
+ length: 30
+ width: 10
+ height: 8
diff --git a/testdata/firmament/examples/triangular_prism_basic.firmament b/testdata/firmament/examples/triangular_prism_basic.firmament
new file mode 100644
index 00000000..13661e28
--- /dev/null
+++ b/testdata/firmament/examples/triangular_prism_basic.firmament
@@ -0,0 +1,14 @@
+firmament:
+ version: 1
+
+model:
+ name: triangular_prism_basic
+ units: mm
+
+ops[1]:
+ -
+ op: triangular_prism
+ id: tri1
+ base_width: 20
+ base_depth: 12
+ height: 10
diff --git a/testdata/firmament/exports/hexagonal_prism_basic.step b/testdata/firmament/exports/hexagonal_prism_basic.step
new file mode 100644
index 00000000..4f6e4eaf
--- /dev/null
+++ b/testdata/firmament/exports/hexagonal_prism_basic.step
@@ -0,0 +1,238 @@
+ISO-10303-21;
+HEADER;
+FILE_DESCRIPTION(('Aetheris AP242 subset export'),'2;1');
+FILE_NAME('aetheris_export.step','1970-01-01T00:00:00',('Aetheris'),('Aetheris'),'Aetheris.Kernel','Aetheris.Kernel','');
+FILE_SCHEMA(('AP242_MANAGED_MODEL_BASED_3D_ENGINEERING_MIM_LF'));
+ENDSEC;
+DATA;
+#1=CARTESIAN_POINT($,(0,0,0));
+#2=DIRECTION($,(-0,-0,-1));
+#3=DIRECTION($,(1,0,0));
+#4=AXIS2_PLACEMENT_3D($,#1,#2,#3);
+#5=PLANE($,#4);
+#6=CARTESIAN_POINT($,(9.23760430703402,0,0));
+#7=VERTEX_POINT($,#6);
+#8=CARTESIAN_POINT($,(4.61880215351701,8,-0));
+#9=VERTEX_POINT($,#8);
+#10=CARTESIAN_POINT($,(9.23760430703402,0,0));
+#11=DIRECTION($,(-0.5,0.866025403784439,0));
+#12=VECTOR($,#11,1);
+#13=LINE($,#10,#12);
+#14=EDGE_CURVE($,#7,#9,#13,.T.);
+#15=ORIENTED_EDGE($,$,$,#14,.T.);
+#16=CARTESIAN_POINT($,(-4.618802153517,8,-0));
+#17=VERTEX_POINT($,#16);
+#18=CARTESIAN_POINT($,(4.61880215351701,8,-0));
+#19=DIRECTION($,(-1,0,0));
+#20=VECTOR($,#19,1);
+#21=LINE($,#18,#20);
+#22=EDGE_CURVE($,#9,#17,#21,.T.);
+#23=ORIENTED_EDGE($,$,$,#22,.T.);
+#24=CARTESIAN_POINT($,(-9.23760430703401,0.000000000000001,-0));
+#25=VERTEX_POINT($,#24);
+#26=CARTESIAN_POINT($,(-4.618802153517,8,-0));
+#27=DIRECTION($,(-0.5,-0.866025403784439,0));
+#28=VECTOR($,#27,1);
+#29=LINE($,#26,#28);
+#30=EDGE_CURVE($,#17,#25,#29,.T.);
+#31=ORIENTED_EDGE($,$,$,#30,.T.);
+#32=CARTESIAN_POINT($,(-4.61880215351701,-8,-0));
+#33=VERTEX_POINT($,#32);
+#34=CARTESIAN_POINT($,(-9.23760430703401,0.000000000000001,-0));
+#35=DIRECTION($,(0.5,-0.866025403784439,0));
+#36=VECTOR($,#35,1);
+#37=LINE($,#34,#36);
+#38=EDGE_CURVE($,#25,#33,#37,.T.);
+#39=ORIENTED_EDGE($,$,$,#38,.T.);
+#40=CARTESIAN_POINT($,(4.618802153517,-8.00000000000001,-0));
+#41=VERTEX_POINT($,#40);
+#42=CARTESIAN_POINT($,(-4.61880215351701,-8,-0));
+#43=DIRECTION($,(1,-0.000000000000001,0));
+#44=VECTOR($,#43,1);
+#45=LINE($,#42,#44);
+#46=EDGE_CURVE($,#33,#41,#45,.T.);
+#47=ORIENTED_EDGE($,$,$,#46,.T.);
+#48=CARTESIAN_POINT($,(4.618802153517,-8.00000000000001,-0));
+#49=DIRECTION($,(0.5,0.866025403784438,0));
+#50=VECTOR($,#49,1);
+#51=LINE($,#48,#50);
+#52=EDGE_CURVE($,#41,#7,#51,.T.);
+#53=ORIENTED_EDGE($,$,$,#52,.T.);
+#54=EDGE_LOOP($,(#15,#23,#31,#39,#47,#53));
+#55=FACE_OUTER_BOUND('',#54,.T.);
+#56=ADVANCED_FACE('',(#55),#5,.T.);
+#57=CARTESIAN_POINT($,(0,0,10));
+#58=DIRECTION($,(0,0,1));
+#59=DIRECTION($,(1,0,0));
+#60=AXIS2_PLACEMENT_3D($,#57,#58,#59);
+#61=PLANE($,#60);
+#62=CARTESIAN_POINT($,(9.23760430703402,-0,10));
+#63=VERTEX_POINT($,#62);
+#64=CARTESIAN_POINT($,(4.61880215351701,8,10));
+#65=VERTEX_POINT($,#64);
+#66=CARTESIAN_POINT($,(9.23760430703402,-0,10));
+#67=DIRECTION($,(-0.5,0.866025403784439,0));
+#68=VECTOR($,#67,1);
+#69=LINE($,#66,#68);
+#70=EDGE_CURVE($,#63,#65,#69,.T.);
+#71=ORIENTED_EDGE($,$,$,#70,.F.);
+#72=CARTESIAN_POINT($,(-4.618802153517,8,10));
+#73=VERTEX_POINT($,#72);
+#74=CARTESIAN_POINT($,(4.61880215351701,8,10));
+#75=DIRECTION($,(-1,0,0));
+#76=VECTOR($,#75,1);
+#77=LINE($,#74,#76);
+#78=EDGE_CURVE($,#65,#73,#77,.T.);
+#79=ORIENTED_EDGE($,$,$,#78,.F.);
+#80=CARTESIAN_POINT($,(-9.23760430703401,0.000000000000001,10));
+#81=VERTEX_POINT($,#80);
+#82=CARTESIAN_POINT($,(-4.618802153517,8,10));
+#83=DIRECTION($,(-0.5,-0.866025403784439,0));
+#84=VECTOR($,#83,1);
+#85=LINE($,#82,#84);
+#86=EDGE_CURVE($,#73,#81,#85,.T.);
+#87=ORIENTED_EDGE($,$,$,#86,.F.);
+#88=CARTESIAN_POINT($,(-4.61880215351701,-8,10));
+#89=VERTEX_POINT($,#88);
+#90=CARTESIAN_POINT($,(-9.23760430703401,0.000000000000001,10));
+#91=DIRECTION($,(0.5,-0.866025403784439,0));
+#92=VECTOR($,#91,1);
+#93=LINE($,#90,#92);
+#94=EDGE_CURVE($,#81,#89,#93,.T.);
+#95=ORIENTED_EDGE($,$,$,#94,.F.);
+#96=CARTESIAN_POINT($,(4.618802153517,-8.00000000000001,10));
+#97=VERTEX_POINT($,#96);
+#98=CARTESIAN_POINT($,(-4.61880215351701,-8,10));
+#99=DIRECTION($,(1,-0.000000000000001,0));
+#100=VECTOR($,#99,1);
+#101=LINE($,#98,#100);
+#102=EDGE_CURVE($,#89,#97,#101,.T.);
+#103=ORIENTED_EDGE($,$,$,#102,.F.);
+#104=CARTESIAN_POINT($,(4.618802153517,-8.00000000000001,10));
+#105=DIRECTION($,(0.5,0.866025403784438,0));
+#106=VECTOR($,#105,1);
+#107=LINE($,#104,#106);
+#108=EDGE_CURVE($,#97,#63,#107,.T.);
+#109=ORIENTED_EDGE($,$,$,#108,.F.);
+#110=EDGE_LOOP($,(#71,#79,#87,#95,#103,#109));
+#111=FACE_OUTER_BOUND('',#110,.T.);
+#112=ADVANCED_FACE('',(#111),#61,.T.);
+#113=CARTESIAN_POINT($,(9.23760430703401,0,0));
+#114=DIRECTION($,(0.866025403784439,0.5,-0));
+#115=DIRECTION($,(0,0,1));
+#116=AXIS2_PLACEMENT_3D($,#113,#114,#115);
+#117=PLANE($,#116);
+#118=ORIENTED_EDGE($,$,$,#14,.T.);
+#119=CARTESIAN_POINT($,(4.61880215351701,8,-0));
+#120=DIRECTION($,(0,0,1));
+#121=VECTOR($,#120,1);
+#122=LINE($,#119,#121);
+#123=EDGE_CURVE($,#9,#65,#122,.T.);
+#124=ORIENTED_EDGE($,$,$,#123,.T.);
+#125=ORIENTED_EDGE($,$,$,#70,.F.);
+#126=CARTESIAN_POINT($,(9.23760430703402,0,0));
+#127=DIRECTION($,(0,0,1));
+#128=VECTOR($,#127,1);
+#129=LINE($,#126,#128);
+#130=EDGE_CURVE($,#7,#63,#129,.T.);
+#131=ORIENTED_EDGE($,$,$,#130,.F.);
+#132=EDGE_LOOP($,(#118,#124,#125,#131));
+#133=FACE_OUTER_BOUND('',#132,.T.);
+#134=ADVANCED_FACE('',(#133),#117,.T.);
+#135=CARTESIAN_POINT($,(4.61880215351701,8,0));
+#136=DIRECTION($,(0,1,-0));
+#137=DIRECTION($,(0,0,1));
+#138=AXIS2_PLACEMENT_3D($,#135,#136,#137);
+#139=PLANE($,#138);
+#140=ORIENTED_EDGE($,$,$,#22,.T.);
+#141=CARTESIAN_POINT($,(-4.618802153517,8,-0));
+#142=DIRECTION($,(0,0,1));
+#143=VECTOR($,#142,1);
+#144=LINE($,#141,#143);
+#145=EDGE_CURVE($,#17,#73,#144,.T.);
+#146=ORIENTED_EDGE($,$,$,#145,.T.);
+#147=ORIENTED_EDGE($,$,$,#78,.F.);
+#148=ORIENTED_EDGE($,$,$,#123,.F.);
+#149=EDGE_LOOP($,(#140,#146,#147,#148));
+#150=FACE_OUTER_BOUND('',#149,.T.);
+#151=ADVANCED_FACE('',(#150),#139,.T.);
+#152=CARTESIAN_POINT($,(-4.618802153517,8,0));
+#153=DIRECTION($,(-0.866025403784438,0.5,0));
+#154=DIRECTION($,(0,0,1));
+#155=AXIS2_PLACEMENT_3D($,#152,#153,#154);
+#156=PLANE($,#155);
+#157=ORIENTED_EDGE($,$,$,#30,.T.);
+#158=CARTESIAN_POINT($,(-9.23760430703401,0.000000000000001,-0));
+#159=DIRECTION($,(0,0,1));
+#160=VECTOR($,#159,1);
+#161=LINE($,#158,#160);
+#162=EDGE_CURVE($,#25,#81,#161,.T.);
+#163=ORIENTED_EDGE($,$,$,#162,.T.);
+#164=ORIENTED_EDGE($,$,$,#86,.F.);
+#165=ORIENTED_EDGE($,$,$,#145,.F.);
+#166=EDGE_LOOP($,(#157,#163,#164,#165));
+#167=FACE_OUTER_BOUND('',#166,.T.);
+#168=ADVANCED_FACE('',(#167),#156,.T.);
+#169=CARTESIAN_POINT($,(-9.23760430703401,0.000000000000001,0));
+#170=DIRECTION($,(-0.866025403784439,-0.5,0));
+#171=DIRECTION($,(0,0,1));
+#172=AXIS2_PLACEMENT_3D($,#169,#170,#171);
+#173=PLANE($,#172);
+#174=ORIENTED_EDGE($,$,$,#38,.T.);
+#175=CARTESIAN_POINT($,(-4.61880215351701,-8,-0));
+#176=DIRECTION($,(0,0,1));
+#177=VECTOR($,#176,1);
+#178=LINE($,#175,#177);
+#179=EDGE_CURVE($,#33,#89,#178,.T.);
+#180=ORIENTED_EDGE($,$,$,#179,.T.);
+#181=ORIENTED_EDGE($,$,$,#94,.F.);
+#182=ORIENTED_EDGE($,$,$,#162,.F.);
+#183=EDGE_LOOP($,(#174,#180,#181,#182));
+#184=FACE_OUTER_BOUND('',#183,.T.);
+#185=ADVANCED_FACE('',(#184),#173,.T.);
+#186=CARTESIAN_POINT($,(-4.61880215351701,-8,0));
+#187=DIRECTION($,(-0.000000000000001,-1,0));
+#188=DIRECTION($,(0,0,1));
+#189=AXIS2_PLACEMENT_3D($,#186,#187,#188);
+#190=PLANE($,#189);
+#191=ORIENTED_EDGE($,$,$,#46,.T.);
+#192=CARTESIAN_POINT($,(4.618802153517,-8.00000000000001,-0));
+#193=DIRECTION($,(0,0,1));
+#194=VECTOR($,#193,1);
+#195=LINE($,#192,#194);
+#196=EDGE_CURVE($,#41,#97,#195,.T.);
+#197=ORIENTED_EDGE($,$,$,#196,.T.);
+#198=ORIENTED_EDGE($,$,$,#102,.F.);
+#199=ORIENTED_EDGE($,$,$,#179,.F.);
+#200=EDGE_LOOP($,(#191,#197,#198,#199));
+#201=FACE_OUTER_BOUND('',#200,.T.);
+#202=ADVANCED_FACE('',(#201),#190,.T.);
+#203=CARTESIAN_POINT($,(4.618802153517,-8.00000000000001,0));
+#204=DIRECTION($,(0.866025403784438,-0.5,0));
+#205=DIRECTION($,(0,0,1));
+#206=AXIS2_PLACEMENT_3D($,#203,#204,#205);
+#207=PLANE($,#206);
+#208=ORIENTED_EDGE($,$,$,#52,.T.);
+#209=ORIENTED_EDGE($,$,$,#130,.T.);
+#210=ORIENTED_EDGE($,$,$,#108,.F.);
+#211=ORIENTED_EDGE($,$,$,#196,.F.);
+#212=EDGE_LOOP($,(#208,#209,#210,#211));
+#213=FACE_OUTER_BOUND('',#212,.T.);
+#214=ADVANCED_FACE('',(#213),#207,.T.);
+#215=CLOSED_SHELL($,(#56,#112,#134,#151,#168,#185,#202,#214));
+#216=MANIFOLD_SOLID_BREP('AetherisBody',#215);
+#217=APPLICATION_CONTEXT('mechanical design');
+#218=PRODUCT_CONTEXT('',#217,'mechanical');
+#219=PRODUCT('AETHERIS','AetherisBody','',(#218));
+#220=PRODUCT_DEFINITION_FORMATION('','',#219);
+#221=PRODUCT_DEFINITION_CONTEXT('design',#217,'design');
+#222=PRODUCT_DEFINITION('','',#220,#221);
+#223=PRODUCT_DEFINITION_SHAPE('','',#222);
+#224=(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.));
+#225=(NAMED_UNIT(*)PLANE_ANGLE_UNIT()SI_UNIT($,.RADIAN.));
+#226=(NAMED_UNIT(*)SI_UNIT($,.STERADIAN.)SOLID_ANGLE_UNIT());
+#227=(GEOMETRIC_REPRESENTATION_CONTEXT(3)GLOBAL_UNIT_ASSIGNED_CONTEXT((#224,#225,#226))REPRESENTATION_CONTEXT('3','3D'));
+#228=SHAPE_REPRESENTATION('AetherisBody',(#216),#227);
+#229=SHAPE_DEFINITION_REPRESENTATION(#223,#228);
+ENDSEC;
+END-ISO-10303-21;
diff --git a/testdata/firmament/exports/straight_slot_basic.step b/testdata/firmament/exports/straight_slot_basic.step
new file mode 100644
index 00000000..00cd446f
--- /dev/null
+++ b/testdata/firmament/exports/straight_slot_basic.step
@@ -0,0 +1,634 @@
+ISO-10303-21;
+HEADER;
+FILE_DESCRIPTION(('Aetheris AP242 subset export'),'2;1');
+FILE_NAME('aetheris_export.step','1970-01-01T00:00:00',('Aetheris'),('Aetheris'),'Aetheris.Kernel','Aetheris.Kernel','');
+FILE_SCHEMA(('AP242_MANAGED_MODEL_BASED_3D_ENGINEERING_MIM_LF'));
+ENDSEC;
+DATA;
+#1=CARTESIAN_POINT($,(0,0,0));
+#2=DIRECTION($,(-0,-0,-1));
+#3=DIRECTION($,(1,0,0));
+#4=AXIS2_PLACEMENT_3D($,#1,#2,#3);
+#5=PLANE($,#4);
+#6=CARTESIAN_POINT($,(10,-5,0));
+#7=VERTEX_POINT($,#6);
+#8=CARTESIAN_POINT($,(11.9134171618255,-4.61939766255643,-0));
+#9=VERTEX_POINT($,#8);
+#10=CARTESIAN_POINT($,(10,-5,0));
+#11=DIRECTION($,(0.980785280403231,0.195090322016128,0));
+#12=VECTOR($,#11,1);
+#13=LINE($,#10,#12);
+#14=EDGE_CURVE($,#7,#9,#13,.T.);
+#15=ORIENTED_EDGE($,$,$,#14,.T.);
+#16=CARTESIAN_POINT($,(13.5355339059327,-3.53553390593274,-0));
+#17=VERTEX_POINT($,#16);
+#18=CARTESIAN_POINT($,(11.9134171618255,-4.61939766255643,-0));
+#19=DIRECTION($,(0.831469612302545,0.555570233019603,0));
+#20=VECTOR($,#19,1);
+#21=LINE($,#18,#20);
+#22=EDGE_CURVE($,#9,#17,#21,.T.);
+#23=ORIENTED_EDGE($,$,$,#22,.T.);
+#24=CARTESIAN_POINT($,(14.6193976625564,-1.91341716182545,-0));
+#25=VERTEX_POINT($,#24);
+#26=CARTESIAN_POINT($,(13.5355339059327,-3.53553390593274,-0));
+#27=DIRECTION($,(0.555570233019602,0.831469612302545,0));
+#28=VECTOR($,#27,1);
+#29=LINE($,#26,#28);
+#30=EDGE_CURVE($,#17,#25,#29,.T.);
+#31=ORIENTED_EDGE($,$,$,#30,.T.);
+#32=CARTESIAN_POINT($,(15,-0,-0));
+#33=VERTEX_POINT($,#32);
+#34=CARTESIAN_POINT($,(14.6193976625564,-1.91341716182545,-0));
+#35=DIRECTION($,(0.195090322016128,0.98078528040323,0));
+#36=VECTOR($,#35,1);
+#37=LINE($,#34,#36);
+#38=EDGE_CURVE($,#25,#33,#37,.T.);
+#39=ORIENTED_EDGE($,$,$,#38,.T.);
+#40=CARTESIAN_POINT($,(14.6193976625564,1.91341716182545,-0));
+#41=VERTEX_POINT($,#40);
+#42=CARTESIAN_POINT($,(15,-0,-0));
+#43=DIRECTION($,(-0.195090322016128,0.98078528040323,0));
+#44=VECTOR($,#43,1);
+#45=LINE($,#42,#44);
+#46=EDGE_CURVE($,#33,#41,#45,.T.);
+#47=ORIENTED_EDGE($,$,$,#46,.T.);
+#48=CARTESIAN_POINT($,(13.5355339059327,3.53553390593274,-0));
+#49=VERTEX_POINT($,#48);
+#50=CARTESIAN_POINT($,(14.6193976625564,1.91341716182545,-0));
+#51=DIRECTION($,(-0.555570233019602,0.831469612302545,0));
+#52=VECTOR($,#51,1);
+#53=LINE($,#50,#52);
+#54=EDGE_CURVE($,#41,#49,#53,.T.);
+#55=ORIENTED_EDGE($,$,$,#54,.T.);
+#56=CARTESIAN_POINT($,(11.9134171618255,4.61939766255643,-0));
+#57=VERTEX_POINT($,#56);
+#58=CARTESIAN_POINT($,(13.5355339059327,3.53553390593274,-0));
+#59=DIRECTION($,(-0.831469612302545,0.555570233019603,0));
+#60=VECTOR($,#59,1);
+#61=LINE($,#58,#60);
+#62=EDGE_CURVE($,#49,#57,#61,.T.);
+#63=ORIENTED_EDGE($,$,$,#62,.T.);
+#64=CARTESIAN_POINT($,(10,5,-0));
+#65=VERTEX_POINT($,#64);
+#66=CARTESIAN_POINT($,(11.9134171618255,4.61939766255643,-0));
+#67=DIRECTION($,(-0.980785280403231,0.195090322016128,0));
+#68=VECTOR($,#67,1);
+#69=LINE($,#66,#68);
+#70=EDGE_CURVE($,#57,#65,#69,.T.);
+#71=ORIENTED_EDGE($,$,$,#70,.T.);
+#72=CARTESIAN_POINT($,(-10,5,-0));
+#73=VERTEX_POINT($,#72);
+#74=CARTESIAN_POINT($,(10,5,-0));
+#75=DIRECTION($,(-1,0,0));
+#76=VECTOR($,#75,1);
+#77=LINE($,#74,#76);
+#78=EDGE_CURVE($,#65,#73,#77,.T.);
+#79=ORIENTED_EDGE($,$,$,#78,.T.);
+#80=CARTESIAN_POINT($,(-11.9134171618254,4.61939766255643,-0));
+#81=VERTEX_POINT($,#80);
+#82=CARTESIAN_POINT($,(-10,5,-0));
+#83=DIRECTION($,(-0.98078528040323,-0.195090322016128,0));
+#84=VECTOR($,#83,1);
+#85=LINE($,#82,#84);
+#86=EDGE_CURVE($,#73,#81,#85,.T.);
+#87=ORIENTED_EDGE($,$,$,#86,.T.);
+#88=CARTESIAN_POINT($,(-13.5355339059327,3.53553390593274,-0));
+#89=VERTEX_POINT($,#88);
+#90=CARTESIAN_POINT($,(-11.9134171618254,4.61939766255643,-0));
+#91=DIRECTION($,(-0.831469612302545,-0.555570233019602,0));
+#92=VECTOR($,#91,1);
+#93=LINE($,#90,#92);
+#94=EDGE_CURVE($,#81,#89,#93,.T.);
+#95=ORIENTED_EDGE($,$,$,#94,.T.);
+#96=CARTESIAN_POINT($,(-14.6193976625564,1.91341716182545,-0));
+#97=VERTEX_POINT($,#96);
+#98=CARTESIAN_POINT($,(-13.5355339059327,3.53553390593274,-0));
+#99=DIRECTION($,(-0.555570233019602,-0.831469612302545,0));
+#100=VECTOR($,#99,1);
+#101=LINE($,#98,#100);
+#102=EDGE_CURVE($,#89,#97,#101,.T.);
+#103=ORIENTED_EDGE($,$,$,#102,.T.);
+#104=CARTESIAN_POINT($,(-15,-0,-0));
+#105=VERTEX_POINT($,#104);
+#106=CARTESIAN_POINT($,(-14.6193976625564,1.91341716182545,-0));
+#107=DIRECTION($,(-0.195090322016128,-0.98078528040323,0));
+#108=VECTOR($,#107,1);
+#109=LINE($,#106,#108);
+#110=EDGE_CURVE($,#97,#105,#109,.T.);
+#111=ORIENTED_EDGE($,$,$,#110,.T.);
+#112=CARTESIAN_POINT($,(-14.6193976625564,-1.91341716182545,-0));
+#113=VERTEX_POINT($,#112);
+#114=CARTESIAN_POINT($,(-15,-0,-0));
+#115=DIRECTION($,(0.195090322016128,-0.98078528040323,0));
+#116=VECTOR($,#115,1);
+#117=LINE($,#114,#116);
+#118=EDGE_CURVE($,#105,#113,#117,.T.);
+#119=ORIENTED_EDGE($,$,$,#118,.T.);
+#120=CARTESIAN_POINT($,(-13.5355339059327,-3.53553390593274,-0));
+#121=VERTEX_POINT($,#120);
+#122=CARTESIAN_POINT($,(-14.6193976625564,-1.91341716182545,-0));
+#123=DIRECTION($,(0.555570233019602,-0.831469612302545,0));
+#124=VECTOR($,#123,1);
+#125=LINE($,#122,#124);
+#126=EDGE_CURVE($,#113,#121,#125,.T.);
+#127=ORIENTED_EDGE($,$,$,#126,.T.);
+#128=CARTESIAN_POINT($,(-11.9134171618254,-4.61939766255643,-0));
+#129=VERTEX_POINT($,#128);
+#130=CARTESIAN_POINT($,(-13.5355339059327,-3.53553390593274,-0));
+#131=DIRECTION($,(0.831469612302545,-0.555570233019602,0));
+#132=VECTOR($,#131,1);
+#133=LINE($,#130,#132);
+#134=EDGE_CURVE($,#121,#129,#133,.T.);
+#135=ORIENTED_EDGE($,$,$,#134,.T.);
+#136=CARTESIAN_POINT($,(-10,-5,-0));
+#137=VERTEX_POINT($,#136);
+#138=CARTESIAN_POINT($,(-11.9134171618254,-4.61939766255643,-0));
+#139=DIRECTION($,(0.98078528040323,-0.195090322016129,0));
+#140=VECTOR($,#139,1);
+#141=LINE($,#138,#140);
+#142=EDGE_CURVE($,#129,#137,#141,.T.);
+#143=ORIENTED_EDGE($,$,$,#142,.T.);
+#144=CARTESIAN_POINT($,(-10,-5,-0));
+#145=DIRECTION($,(1,0,0));
+#146=VECTOR($,#145,1);
+#147=LINE($,#144,#146);
+#148=EDGE_CURVE($,#137,#7,#147,.T.);
+#149=ORIENTED_EDGE($,$,$,#148,.T.);
+#150=EDGE_LOOP($,(#15,#23,#31,#39,#47,#55,#63,#71,#79,#87,#95,#103,#111,#119,#127,#135,#143,#149));
+#151=FACE_OUTER_BOUND('',#150,.T.);
+#152=ADVANCED_FACE('',(#151),#5,.T.);
+#153=CARTESIAN_POINT($,(0,0,8));
+#154=DIRECTION($,(0,0,1));
+#155=DIRECTION($,(1,0,0));
+#156=AXIS2_PLACEMENT_3D($,#153,#154,#155);
+#157=PLANE($,#156);
+#158=CARTESIAN_POINT($,(10,-5,8));
+#159=VERTEX_POINT($,#158);
+#160=CARTESIAN_POINT($,(11.9134171618255,-4.61939766255643,8));
+#161=VERTEX_POINT($,#160);
+#162=CARTESIAN_POINT($,(10,-5,8));
+#163=DIRECTION($,(0.980785280403231,0.195090322016128,0));
+#164=VECTOR($,#163,1);
+#165=LINE($,#162,#164);
+#166=EDGE_CURVE($,#159,#161,#165,.T.);
+#167=ORIENTED_EDGE($,$,$,#166,.F.);
+#168=CARTESIAN_POINT($,(13.5355339059327,-3.53553390593274,8));
+#169=VERTEX_POINT($,#168);
+#170=CARTESIAN_POINT($,(11.9134171618255,-4.61939766255643,8));
+#171=DIRECTION($,(0.831469612302545,0.555570233019603,0));
+#172=VECTOR($,#171,1);
+#173=LINE($,#170,#172);
+#174=EDGE_CURVE($,#161,#169,#173,.T.);
+#175=ORIENTED_EDGE($,$,$,#174,.F.);
+#176=CARTESIAN_POINT($,(14.6193976625564,-1.91341716182545,8));
+#177=VERTEX_POINT($,#176);
+#178=CARTESIAN_POINT($,(13.5355339059327,-3.53553390593274,8));
+#179=DIRECTION($,(0.555570233019602,0.831469612302545,0));
+#180=VECTOR($,#179,1);
+#181=LINE($,#178,#180);
+#182=EDGE_CURVE($,#169,#177,#181,.T.);
+#183=ORIENTED_EDGE($,$,$,#182,.F.);
+#184=CARTESIAN_POINT($,(15,0,8));
+#185=VERTEX_POINT($,#184);
+#186=CARTESIAN_POINT($,(14.6193976625564,-1.91341716182545,8));
+#187=DIRECTION($,(0.195090322016128,0.98078528040323,0));
+#188=VECTOR($,#187,1);
+#189=LINE($,#186,#188);
+#190=EDGE_CURVE($,#177,#185,#189,.T.);
+#191=ORIENTED_EDGE($,$,$,#190,.F.);
+#192=CARTESIAN_POINT($,(14.6193976625564,1.91341716182545,8));
+#193=VERTEX_POINT($,#192);
+#194=CARTESIAN_POINT($,(15,0,8));
+#195=DIRECTION($,(-0.195090322016128,0.98078528040323,0));
+#196=VECTOR($,#195,1);
+#197=LINE($,#194,#196);
+#198=EDGE_CURVE($,#185,#193,#197,.T.);
+#199=ORIENTED_EDGE($,$,$,#198,.F.);
+#200=CARTESIAN_POINT($,(13.5355339059327,3.53553390593274,8));
+#201=VERTEX_POINT($,#200);
+#202=CARTESIAN_POINT($,(14.6193976625564,1.91341716182545,8));
+#203=DIRECTION($,(-0.555570233019602,0.831469612302545,0));
+#204=VECTOR($,#203,1);
+#205=LINE($,#202,#204);
+#206=EDGE_CURVE($,#193,#201,#205,.T.);
+#207=ORIENTED_EDGE($,$,$,#206,.F.);
+#208=CARTESIAN_POINT($,(11.9134171618255,4.61939766255643,8));
+#209=VERTEX_POINT($,#208);
+#210=CARTESIAN_POINT($,(13.5355339059327,3.53553390593274,8));
+#211=DIRECTION($,(-0.831469612302545,0.555570233019603,0));
+#212=VECTOR($,#211,1);
+#213=LINE($,#210,#212);
+#214=EDGE_CURVE($,#201,#209,#213,.T.);
+#215=ORIENTED_EDGE($,$,$,#214,.F.);
+#216=CARTESIAN_POINT($,(10,5,8));
+#217=VERTEX_POINT($,#216);
+#218=CARTESIAN_POINT($,(11.9134171618255,4.61939766255643,8));
+#219=DIRECTION($,(-0.980785280403231,0.195090322016128,0));
+#220=VECTOR($,#219,1);
+#221=LINE($,#218,#220);
+#222=EDGE_CURVE($,#209,#217,#221,.T.);
+#223=ORIENTED_EDGE($,$,$,#222,.F.);
+#224=CARTESIAN_POINT($,(-10,5,8));
+#225=VERTEX_POINT($,#224);
+#226=CARTESIAN_POINT($,(10,5,8));
+#227=DIRECTION($,(-1,0,0));
+#228=VECTOR($,#227,1);
+#229=LINE($,#226,#228);
+#230=EDGE_CURVE($,#217,#225,#229,.T.);
+#231=ORIENTED_EDGE($,$,$,#230,.F.);
+#232=CARTESIAN_POINT($,(-11.9134171618254,4.61939766255643,8));
+#233=VERTEX_POINT($,#232);
+#234=CARTESIAN_POINT($,(-10,5,8));
+#235=DIRECTION($,(-0.98078528040323,-0.195090322016128,0));
+#236=VECTOR($,#235,1);
+#237=LINE($,#234,#236);
+#238=EDGE_CURVE($,#225,#233,#237,.T.);
+#239=ORIENTED_EDGE($,$,$,#238,.F.);
+#240=CARTESIAN_POINT($,(-13.5355339059327,3.53553390593274,8));
+#241=VERTEX_POINT($,#240);
+#242=CARTESIAN_POINT($,(-11.9134171618254,4.61939766255643,8));
+#243=DIRECTION($,(-0.831469612302545,-0.555570233019602,0));
+#244=VECTOR($,#243,1);
+#245=LINE($,#242,#244);
+#246=EDGE_CURVE($,#233,#241,#245,.T.);
+#247=ORIENTED_EDGE($,$,$,#246,.F.);
+#248=CARTESIAN_POINT($,(-14.6193976625564,1.91341716182545,8));
+#249=VERTEX_POINT($,#248);
+#250=CARTESIAN_POINT($,(-13.5355339059327,3.53553390593274,8));
+#251=DIRECTION($,(-0.555570233019602,-0.831469612302545,0));
+#252=VECTOR($,#251,1);
+#253=LINE($,#250,#252);
+#254=EDGE_CURVE($,#241,#249,#253,.T.);
+#255=ORIENTED_EDGE($,$,$,#254,.F.);
+#256=CARTESIAN_POINT($,(-15,0,8));
+#257=VERTEX_POINT($,#256);
+#258=CARTESIAN_POINT($,(-14.6193976625564,1.91341716182545,8));
+#259=DIRECTION($,(-0.195090322016128,-0.98078528040323,0));
+#260=VECTOR($,#259,1);
+#261=LINE($,#258,#260);
+#262=EDGE_CURVE($,#249,#257,#261,.T.);
+#263=ORIENTED_EDGE($,$,$,#262,.F.);
+#264=CARTESIAN_POINT($,(-14.6193976625564,-1.91341716182545,8));
+#265=VERTEX_POINT($,#264);
+#266=CARTESIAN_POINT($,(-15,0,8));
+#267=DIRECTION($,(0.195090322016128,-0.98078528040323,0));
+#268=VECTOR($,#267,1);
+#269=LINE($,#266,#268);
+#270=EDGE_CURVE($,#257,#265,#269,.T.);
+#271=ORIENTED_EDGE($,$,$,#270,.F.);
+#272=CARTESIAN_POINT($,(-13.5355339059327,-3.53553390593274,8));
+#273=VERTEX_POINT($,#272);
+#274=CARTESIAN_POINT($,(-14.6193976625564,-1.91341716182545,8));
+#275=DIRECTION($,(0.555570233019602,-0.831469612302545,0));
+#276=VECTOR($,#275,1);
+#277=LINE($,#274,#276);
+#278=EDGE_CURVE($,#265,#273,#277,.T.);
+#279=ORIENTED_EDGE($,$,$,#278,.F.);
+#280=CARTESIAN_POINT($,(-11.9134171618254,-4.61939766255643,8));
+#281=VERTEX_POINT($,#280);
+#282=CARTESIAN_POINT($,(-13.5355339059327,-3.53553390593274,8));
+#283=DIRECTION($,(0.831469612302545,-0.555570233019602,0));
+#284=VECTOR($,#283,1);
+#285=LINE($,#282,#284);
+#286=EDGE_CURVE($,#273,#281,#285,.T.);
+#287=ORIENTED_EDGE($,$,$,#286,.F.);
+#288=CARTESIAN_POINT($,(-10,-5,8));
+#289=VERTEX_POINT($,#288);
+#290=CARTESIAN_POINT($,(-11.9134171618254,-4.61939766255643,8));
+#291=DIRECTION($,(0.98078528040323,-0.195090322016129,0));
+#292=VECTOR($,#291,1);
+#293=LINE($,#290,#292);
+#294=EDGE_CURVE($,#281,#289,#293,.T.);
+#295=ORIENTED_EDGE($,$,$,#294,.F.);
+#296=CARTESIAN_POINT($,(-10,-5,8));
+#297=DIRECTION($,(1,0,0));
+#298=VECTOR($,#297,1);
+#299=LINE($,#296,#298);
+#300=EDGE_CURVE($,#289,#159,#299,.T.);
+#301=ORIENTED_EDGE($,$,$,#300,.F.);
+#302=EDGE_LOOP($,(#167,#175,#183,#191,#199,#207,#215,#223,#231,#239,#247,#255,#263,#271,#279,#287,#295,#301));
+#303=FACE_OUTER_BOUND('',#302,.T.);
+#304=ADVANCED_FACE('',(#303),#157,.T.);
+#305=CARTESIAN_POINT($,(10,-5,0));
+#306=DIRECTION($,(0.195090322016128,-0.980785280403231,0));
+#307=DIRECTION($,(0,0,1));
+#308=AXIS2_PLACEMENT_3D($,#305,#306,#307);
+#309=PLANE($,#308);
+#310=ORIENTED_EDGE($,$,$,#14,.T.);
+#311=CARTESIAN_POINT($,(11.9134171618255,-4.61939766255643,-0));
+#312=DIRECTION($,(0,0,1));
+#313=VECTOR($,#312,1);
+#314=LINE($,#311,#313);
+#315=EDGE_CURVE($,#9,#161,#314,.T.);
+#316=ORIENTED_EDGE($,$,$,#315,.T.);
+#317=ORIENTED_EDGE($,$,$,#166,.F.);
+#318=CARTESIAN_POINT($,(10,-5,0));
+#319=DIRECTION($,(0,0,1));
+#320=VECTOR($,#319,1);
+#321=LINE($,#318,#320);
+#322=EDGE_CURVE($,#7,#159,#321,.T.);
+#323=ORIENTED_EDGE($,$,$,#322,.F.);
+#324=EDGE_LOOP($,(#310,#316,#317,#323));
+#325=FACE_OUTER_BOUND('',#324,.T.);
+#326=ADVANCED_FACE('',(#325),#309,.T.);
+#327=CARTESIAN_POINT($,(11.9134171618254,-4.61939766255643,0));
+#328=DIRECTION($,(0.555570233019603,-0.831469612302545,0));
+#329=DIRECTION($,(0,0,1));
+#330=AXIS2_PLACEMENT_3D($,#327,#328,#329);
+#331=PLANE($,#330);
+#332=ORIENTED_EDGE($,$,$,#22,.T.);
+#333=CARTESIAN_POINT($,(13.5355339059327,-3.53553390593274,-0));
+#334=DIRECTION($,(0,0,1));
+#335=VECTOR($,#334,1);
+#336=LINE($,#333,#335);
+#337=EDGE_CURVE($,#17,#169,#336,.T.);
+#338=ORIENTED_EDGE($,$,$,#337,.T.);
+#339=ORIENTED_EDGE($,$,$,#174,.F.);
+#340=ORIENTED_EDGE($,$,$,#315,.F.);
+#341=EDGE_LOOP($,(#332,#338,#339,#340));
+#342=FACE_OUTER_BOUND('',#341,.T.);
+#343=ADVANCED_FACE('',(#342),#331,.T.);
+#344=CARTESIAN_POINT($,(13.5355339059327,-3.53553390593274,0));
+#345=DIRECTION($,(0.831469612302545,-0.555570233019602,0));
+#346=DIRECTION($,(0,0,1));
+#347=AXIS2_PLACEMENT_3D($,#344,#345,#346);
+#348=PLANE($,#347);
+#349=ORIENTED_EDGE($,$,$,#30,.T.);
+#350=CARTESIAN_POINT($,(14.6193976625564,-1.91341716182545,-0));
+#351=DIRECTION($,(0,0,1));
+#352=VECTOR($,#351,1);
+#353=LINE($,#350,#352);
+#354=EDGE_CURVE($,#25,#177,#353,.T.);
+#355=ORIENTED_EDGE($,$,$,#354,.T.);
+#356=ORIENTED_EDGE($,$,$,#182,.F.);
+#357=ORIENTED_EDGE($,$,$,#337,.F.);
+#358=EDGE_LOOP($,(#349,#355,#356,#357));
+#359=FACE_OUTER_BOUND('',#358,.T.);
+#360=ADVANCED_FACE('',(#359),#348,.T.);
+#361=CARTESIAN_POINT($,(14.6193976625564,-1.91341716182545,0));
+#362=DIRECTION($,(0.98078528040323,-0.195090322016128,0));
+#363=DIRECTION($,(0,0,1));
+#364=AXIS2_PLACEMENT_3D($,#361,#362,#363);
+#365=PLANE($,#364);
+#366=ORIENTED_EDGE($,$,$,#38,.T.);
+#367=CARTESIAN_POINT($,(15,-0,-0));
+#368=DIRECTION($,(0,0,1));
+#369=VECTOR($,#368,1);
+#370=LINE($,#367,#369);
+#371=EDGE_CURVE($,#33,#185,#370,.T.);
+#372=ORIENTED_EDGE($,$,$,#371,.T.);
+#373=ORIENTED_EDGE($,$,$,#190,.F.);
+#374=ORIENTED_EDGE($,$,$,#354,.F.);
+#375=EDGE_LOOP($,(#366,#372,#373,#374));
+#376=FACE_OUTER_BOUND('',#375,.T.);
+#377=ADVANCED_FACE('',(#376),#365,.T.);
+#378=CARTESIAN_POINT($,(15,0,0));
+#379=DIRECTION($,(0.98078528040323,0.195090322016128,-0));
+#380=DIRECTION($,(0,0,1));
+#381=AXIS2_PLACEMENT_3D($,#378,#379,#380);
+#382=PLANE($,#381);
+#383=ORIENTED_EDGE($,$,$,#46,.T.);
+#384=CARTESIAN_POINT($,(14.6193976625564,1.91341716182545,-0));
+#385=DIRECTION($,(0,0,1));
+#386=VECTOR($,#385,1);
+#387=LINE($,#384,#386);
+#388=EDGE_CURVE($,#41,#193,#387,.T.);
+#389=ORIENTED_EDGE($,$,$,#388,.T.);
+#390=ORIENTED_EDGE($,$,$,#198,.F.);
+#391=ORIENTED_EDGE($,$,$,#371,.F.);
+#392=EDGE_LOOP($,(#383,#389,#390,#391));
+#393=FACE_OUTER_BOUND('',#392,.T.);
+#394=ADVANCED_FACE('',(#393),#382,.T.);
+#395=CARTESIAN_POINT($,(14.6193976625564,1.91341716182545,0));
+#396=DIRECTION($,(0.831469612302545,0.555570233019602,-0));
+#397=DIRECTION($,(0,0,1));
+#398=AXIS2_PLACEMENT_3D($,#395,#396,#397);
+#399=PLANE($,#398);
+#400=ORIENTED_EDGE($,$,$,#54,.T.);
+#401=CARTESIAN_POINT($,(13.5355339059327,3.53553390593274,-0));
+#402=DIRECTION($,(0,0,1));
+#403=VECTOR($,#402,1);
+#404=LINE($,#401,#403);
+#405=EDGE_CURVE($,#49,#201,#404,.T.);
+#406=ORIENTED_EDGE($,$,$,#405,.T.);
+#407=ORIENTED_EDGE($,$,$,#206,.F.);
+#408=ORIENTED_EDGE($,$,$,#388,.F.);
+#409=EDGE_LOOP($,(#400,#406,#407,#408));
+#410=FACE_OUTER_BOUND('',#409,.T.);
+#411=ADVANCED_FACE('',(#410),#399,.T.);
+#412=CARTESIAN_POINT($,(13.5355339059327,3.53553390593274,0));
+#413=DIRECTION($,(0.555570233019603,0.831469612302545,-0));
+#414=DIRECTION($,(0,0,1));
+#415=AXIS2_PLACEMENT_3D($,#412,#413,#414);
+#416=PLANE($,#415);
+#417=ORIENTED_EDGE($,$,$,#62,.T.);
+#418=CARTESIAN_POINT($,(11.9134171618255,4.61939766255643,-0));
+#419=DIRECTION($,(0,0,1));
+#420=VECTOR($,#419,1);
+#421=LINE($,#418,#420);
+#422=EDGE_CURVE($,#57,#209,#421,.T.);
+#423=ORIENTED_EDGE($,$,$,#422,.T.);
+#424=ORIENTED_EDGE($,$,$,#214,.F.);
+#425=ORIENTED_EDGE($,$,$,#405,.F.);
+#426=EDGE_LOOP($,(#417,#423,#424,#425));
+#427=FACE_OUTER_BOUND('',#426,.T.);
+#428=ADVANCED_FACE('',(#427),#416,.T.);
+#429=CARTESIAN_POINT($,(11.9134171618254,4.61939766255643,0));
+#430=DIRECTION($,(0.195090322016128,0.980785280403231,-0));
+#431=DIRECTION($,(0,0,1));
+#432=AXIS2_PLACEMENT_3D($,#429,#430,#431);
+#433=PLANE($,#432);
+#434=ORIENTED_EDGE($,$,$,#70,.T.);
+#435=CARTESIAN_POINT($,(10,5,-0));
+#436=DIRECTION($,(0,0,1));
+#437=VECTOR($,#436,1);
+#438=LINE($,#435,#437);
+#439=EDGE_CURVE($,#65,#217,#438,.T.);
+#440=ORIENTED_EDGE($,$,$,#439,.T.);
+#441=ORIENTED_EDGE($,$,$,#222,.F.);
+#442=ORIENTED_EDGE($,$,$,#422,.F.);
+#443=EDGE_LOOP($,(#434,#440,#441,#442));
+#444=FACE_OUTER_BOUND('',#443,.T.);
+#445=ADVANCED_FACE('',(#444),#433,.T.);
+#446=CARTESIAN_POINT($,(10,5,0));
+#447=DIRECTION($,(0,1,-0));
+#448=DIRECTION($,(0,0,1));
+#449=AXIS2_PLACEMENT_3D($,#446,#447,#448);
+#450=PLANE($,#449);
+#451=ORIENTED_EDGE($,$,$,#78,.T.);
+#452=CARTESIAN_POINT($,(-10,5,-0));
+#453=DIRECTION($,(0,0,1));
+#454=VECTOR($,#453,1);
+#455=LINE($,#452,#454);
+#456=EDGE_CURVE($,#73,#225,#455,.T.);
+#457=ORIENTED_EDGE($,$,$,#456,.T.);
+#458=ORIENTED_EDGE($,$,$,#230,.F.);
+#459=ORIENTED_EDGE($,$,$,#439,.F.);
+#460=EDGE_LOOP($,(#451,#457,#458,#459));
+#461=FACE_OUTER_BOUND('',#460,.T.);
+#462=ADVANCED_FACE('',(#461),#450,.T.);
+#463=CARTESIAN_POINT($,(-10,5,0));
+#464=DIRECTION($,(-0.195090322016128,0.98078528040323,0));
+#465=DIRECTION($,(0,0,1));
+#466=AXIS2_PLACEMENT_3D($,#463,#464,#465);
+#467=PLANE($,#466);
+#468=ORIENTED_EDGE($,$,$,#86,.T.);
+#469=CARTESIAN_POINT($,(-11.9134171618254,4.61939766255643,-0));
+#470=DIRECTION($,(0,0,1));
+#471=VECTOR($,#470,1);
+#472=LINE($,#469,#471);
+#473=EDGE_CURVE($,#81,#233,#472,.T.);
+#474=ORIENTED_EDGE($,$,$,#473,.T.);
+#475=ORIENTED_EDGE($,$,$,#238,.F.);
+#476=ORIENTED_EDGE($,$,$,#456,.F.);
+#477=EDGE_LOOP($,(#468,#474,#475,#476));
+#478=FACE_OUTER_BOUND('',#477,.T.);
+#479=ADVANCED_FACE('',(#478),#467,.T.);
+#480=CARTESIAN_POINT($,(-11.9134171618254,4.61939766255643,0));
+#481=DIRECTION($,(-0.555570233019602,0.831469612302545,0));
+#482=DIRECTION($,(0,0,1));
+#483=AXIS2_PLACEMENT_3D($,#480,#481,#482);
+#484=PLANE($,#483);
+#485=ORIENTED_EDGE($,$,$,#94,.T.);
+#486=CARTESIAN_POINT($,(-13.5355339059327,3.53553390593274,-0));
+#487=DIRECTION($,(0,0,1));
+#488=VECTOR($,#487,1);
+#489=LINE($,#486,#488);
+#490=EDGE_CURVE($,#89,#241,#489,.T.);
+#491=ORIENTED_EDGE($,$,$,#490,.T.);
+#492=ORIENTED_EDGE($,$,$,#246,.F.);
+#493=ORIENTED_EDGE($,$,$,#473,.F.);
+#494=EDGE_LOOP($,(#485,#491,#492,#493));
+#495=FACE_OUTER_BOUND('',#494,.T.);
+#496=ADVANCED_FACE('',(#495),#484,.T.);
+#497=CARTESIAN_POINT($,(-13.5355339059327,3.53553390593274,0));
+#498=DIRECTION($,(-0.831469612302545,0.555570233019602,0));
+#499=DIRECTION($,(0,0,1));
+#500=AXIS2_PLACEMENT_3D($,#497,#498,#499);
+#501=PLANE($,#500);
+#502=ORIENTED_EDGE($,$,$,#102,.T.);
+#503=CARTESIAN_POINT($,(-14.6193976625564,1.91341716182545,-0));
+#504=DIRECTION($,(0,0,1));
+#505=VECTOR($,#504,1);
+#506=LINE($,#503,#505);
+#507=EDGE_CURVE($,#97,#249,#506,.T.);
+#508=ORIENTED_EDGE($,$,$,#507,.T.);
+#509=ORIENTED_EDGE($,$,$,#254,.F.);
+#510=ORIENTED_EDGE($,$,$,#490,.F.);
+#511=EDGE_LOOP($,(#502,#508,#509,#510));
+#512=FACE_OUTER_BOUND('',#511,.T.);
+#513=ADVANCED_FACE('',(#512),#501,.T.);
+#514=CARTESIAN_POINT($,(-14.6193976625564,1.91341716182545,0));
+#515=DIRECTION($,(-0.98078528040323,0.195090322016128,0));
+#516=DIRECTION($,(0,0,1));
+#517=AXIS2_PLACEMENT_3D($,#514,#515,#516);
+#518=PLANE($,#517);
+#519=ORIENTED_EDGE($,$,$,#110,.T.);
+#520=CARTESIAN_POINT($,(-15,-0,-0));
+#521=DIRECTION($,(0,0,1));
+#522=VECTOR($,#521,1);
+#523=LINE($,#520,#522);
+#524=EDGE_CURVE($,#105,#257,#523,.T.);
+#525=ORIENTED_EDGE($,$,$,#524,.T.);
+#526=ORIENTED_EDGE($,$,$,#262,.F.);
+#527=ORIENTED_EDGE($,$,$,#507,.F.);
+#528=EDGE_LOOP($,(#519,#525,#526,#527));
+#529=FACE_OUTER_BOUND('',#528,.T.);
+#530=ADVANCED_FACE('',(#529),#518,.T.);
+#531=CARTESIAN_POINT($,(-15,0.000000000000001,0));
+#532=DIRECTION($,(-0.98078528040323,-0.195090322016128,0));
+#533=DIRECTION($,(0,0,1));
+#534=AXIS2_PLACEMENT_3D($,#531,#532,#533);
+#535=PLANE($,#534);
+#536=ORIENTED_EDGE($,$,$,#118,.T.);
+#537=CARTESIAN_POINT($,(-14.6193976625564,-1.91341716182545,-0));
+#538=DIRECTION($,(0,0,1));
+#539=VECTOR($,#538,1);
+#540=LINE($,#537,#539);
+#541=EDGE_CURVE($,#113,#265,#540,.T.);
+#542=ORIENTED_EDGE($,$,$,#541,.T.);
+#543=ORIENTED_EDGE($,$,$,#270,.F.);
+#544=ORIENTED_EDGE($,$,$,#524,.F.);
+#545=EDGE_LOOP($,(#536,#542,#543,#544));
+#546=FACE_OUTER_BOUND('',#545,.T.);
+#547=ADVANCED_FACE('',(#546),#535,.T.);
+#548=CARTESIAN_POINT($,(-14.6193976625564,-1.91341716182545,0));
+#549=DIRECTION($,(-0.831469612302545,-0.555570233019602,0));
+#550=DIRECTION($,(0,0,1));
+#551=AXIS2_PLACEMENT_3D($,#548,#549,#550);
+#552=PLANE($,#551);
+#553=ORIENTED_EDGE($,$,$,#126,.T.);
+#554=CARTESIAN_POINT($,(-13.5355339059327,-3.53553390593274,-0));
+#555=DIRECTION($,(0,0,1));
+#556=VECTOR($,#555,1);
+#557=LINE($,#554,#556);
+#558=EDGE_CURVE($,#121,#273,#557,.T.);
+#559=ORIENTED_EDGE($,$,$,#558,.T.);
+#560=ORIENTED_EDGE($,$,$,#278,.F.);
+#561=ORIENTED_EDGE($,$,$,#541,.F.);
+#562=EDGE_LOOP($,(#553,#559,#560,#561));
+#563=FACE_OUTER_BOUND('',#562,.T.);
+#564=ADVANCED_FACE('',(#563),#552,.T.);
+#565=CARTESIAN_POINT($,(-13.5355339059327,-3.53553390593274,0));
+#566=DIRECTION($,(-0.555570233019602,-0.831469612302545,0));
+#567=DIRECTION($,(0,0,1));
+#568=AXIS2_PLACEMENT_3D($,#565,#566,#567);
+#569=PLANE($,#568);
+#570=ORIENTED_EDGE($,$,$,#134,.T.);
+#571=CARTESIAN_POINT($,(-11.9134171618254,-4.61939766255643,-0));
+#572=DIRECTION($,(0,0,1));
+#573=VECTOR($,#572,1);
+#574=LINE($,#571,#573);
+#575=EDGE_CURVE($,#129,#281,#574,.T.);
+#576=ORIENTED_EDGE($,$,$,#575,.T.);
+#577=ORIENTED_EDGE($,$,$,#286,.F.);
+#578=ORIENTED_EDGE($,$,$,#558,.F.);
+#579=EDGE_LOOP($,(#570,#576,#577,#578));
+#580=FACE_OUTER_BOUND('',#579,.T.);
+#581=ADVANCED_FACE('',(#580),#569,.T.);
+#582=CARTESIAN_POINT($,(-11.9134171618255,-4.61939766255643,0));
+#583=DIRECTION($,(-0.195090322016129,-0.98078528040323,0));
+#584=DIRECTION($,(0,0,1));
+#585=AXIS2_PLACEMENT_3D($,#582,#583,#584);
+#586=PLANE($,#585);
+#587=ORIENTED_EDGE($,$,$,#142,.T.);
+#588=CARTESIAN_POINT($,(-10,-5,-0));
+#589=DIRECTION($,(0,0,1));
+#590=VECTOR($,#589,1);
+#591=LINE($,#588,#590);
+#592=EDGE_CURVE($,#137,#289,#591,.T.);
+#593=ORIENTED_EDGE($,$,$,#592,.T.);
+#594=ORIENTED_EDGE($,$,$,#294,.F.);
+#595=ORIENTED_EDGE($,$,$,#575,.F.);
+#596=EDGE_LOOP($,(#587,#593,#594,#595));
+#597=FACE_OUTER_BOUND('',#596,.T.);
+#598=ADVANCED_FACE('',(#597),#586,.T.);
+#599=CARTESIAN_POINT($,(-10,-5,0));
+#600=DIRECTION($,(0,-1,0));
+#601=DIRECTION($,(0,0,1));
+#602=AXIS2_PLACEMENT_3D($,#599,#600,#601);
+#603=PLANE($,#602);
+#604=ORIENTED_EDGE($,$,$,#148,.T.);
+#605=ORIENTED_EDGE($,$,$,#322,.T.);
+#606=ORIENTED_EDGE($,$,$,#300,.F.);
+#607=ORIENTED_EDGE($,$,$,#592,.F.);
+#608=EDGE_LOOP($,(#604,#605,#606,#607));
+#609=FACE_OUTER_BOUND('',#608,.T.);
+#610=ADVANCED_FACE('',(#609),#603,.T.);
+#611=CLOSED_SHELL($,(#152,#304,#326,#343,#360,#377,#394,#411,#428,#445,#462,#479,#496,#513,#530,#547,#564,#581,#598,#610));
+#612=MANIFOLD_SOLID_BREP('AetherisBody',#611);
+#613=APPLICATION_CONTEXT('mechanical design');
+#614=PRODUCT_CONTEXT('',#613,'mechanical');
+#615=PRODUCT('AETHERIS','AetherisBody','',(#614));
+#616=PRODUCT_DEFINITION_FORMATION('','',#615);
+#617=PRODUCT_DEFINITION_CONTEXT('design',#613,'design');
+#618=PRODUCT_DEFINITION('','',#616,#617);
+#619=PRODUCT_DEFINITION_SHAPE('','',#618);
+#620=(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.));
+#621=(NAMED_UNIT(*)PLANE_ANGLE_UNIT()SI_UNIT($,.RADIAN.));
+#622=(NAMED_UNIT(*)SI_UNIT($,.STERADIAN.)SOLID_ANGLE_UNIT());
+#623=(GEOMETRIC_REPRESENTATION_CONTEXT(3)GLOBAL_UNIT_ASSIGNED_CONTEXT((#620,#621,#622))REPRESENTATION_CONTEXT('3','3D'));
+#624=SHAPE_REPRESENTATION('AetherisBody',(#612),#623);
+#625=SHAPE_DEFINITION_REPRESENTATION(#619,#624);
+ENDSEC;
+END-ISO-10303-21;
diff --git a/testdata/firmament/exports/triangular_prism_basic.step b/testdata/firmament/exports/triangular_prism_basic.step
new file mode 100644
index 00000000..c255cae5
--- /dev/null
+++ b/testdata/firmament/exports/triangular_prism_basic.step
@@ -0,0 +1,139 @@
+ISO-10303-21;
+HEADER;
+FILE_DESCRIPTION(('Aetheris AP242 subset export'),'2;1');
+FILE_NAME('aetheris_export.step','1970-01-01T00:00:00',('Aetheris'),('Aetheris'),'Aetheris.Kernel','Aetheris.Kernel','');
+FILE_SCHEMA(('AP242_MANAGED_MODEL_BASED_3D_ENGINEERING_MIM_LF'));
+ENDSEC;
+DATA;
+#1=CARTESIAN_POINT($,(0,0,0));
+#2=DIRECTION($,(-0,-0,-1));
+#3=DIRECTION($,(1,0,0));
+#4=AXIS2_PLACEMENT_3D($,#1,#2,#3);
+#5=PLANE($,#4);
+#6=CARTESIAN_POINT($,(-10,-6,0));
+#7=VERTEX_POINT($,#6);
+#8=CARTESIAN_POINT($,(10,-6,-0));
+#9=VERTEX_POINT($,#8);
+#10=CARTESIAN_POINT($,(-10,-6,0));
+#11=DIRECTION($,(1,0,0));
+#12=VECTOR($,#11,1);
+#13=LINE($,#10,#12);
+#14=EDGE_CURVE($,#7,#9,#13,.T.);
+#15=ORIENTED_EDGE($,$,$,#14,.T.);
+#16=CARTESIAN_POINT($,(-0,6,-0));
+#17=VERTEX_POINT($,#16);
+#18=CARTESIAN_POINT($,(10,-6,-0));
+#19=DIRECTION($,(-0.64018439966448,0.768221279597376,0));
+#20=VECTOR($,#19,1);
+#21=LINE($,#18,#20);
+#22=EDGE_CURVE($,#9,#17,#21,.T.);
+#23=ORIENTED_EDGE($,$,$,#22,.T.);
+#24=CARTESIAN_POINT($,(-0,6,-0));
+#25=DIRECTION($,(-0.64018439966448,-0.768221279597376,0));
+#26=VECTOR($,#25,1);
+#27=LINE($,#24,#26);
+#28=EDGE_CURVE($,#17,#7,#27,.T.);
+#29=ORIENTED_EDGE($,$,$,#28,.T.);
+#30=EDGE_LOOP($,(#15,#23,#29));
+#31=FACE_OUTER_BOUND('',#30,.T.);
+#32=ADVANCED_FACE('',(#31),#5,.T.);
+#33=CARTESIAN_POINT($,(0,0,10));
+#34=DIRECTION($,(0,0,1));
+#35=DIRECTION($,(1,0,0));
+#36=AXIS2_PLACEMENT_3D($,#33,#34,#35);
+#37=PLANE($,#36);
+#38=CARTESIAN_POINT($,(-10,-6,10));
+#39=VERTEX_POINT($,#38);
+#40=CARTESIAN_POINT($,(10,-6,10));
+#41=VERTEX_POINT($,#40);
+#42=CARTESIAN_POINT($,(-10,-6,10));
+#43=DIRECTION($,(1,0,0));
+#44=VECTOR($,#43,1);
+#45=LINE($,#42,#44);
+#46=EDGE_CURVE($,#39,#41,#45,.T.);
+#47=ORIENTED_EDGE($,$,$,#46,.F.);
+#48=CARTESIAN_POINT($,(-0,6,10));
+#49=VERTEX_POINT($,#48);
+#50=CARTESIAN_POINT($,(10,-6,10));
+#51=DIRECTION($,(-0.64018439966448,0.768221279597376,0));
+#52=VECTOR($,#51,1);
+#53=LINE($,#50,#52);
+#54=EDGE_CURVE($,#41,#49,#53,.T.);
+#55=ORIENTED_EDGE($,$,$,#54,.F.);
+#56=CARTESIAN_POINT($,(-0,6,10));
+#57=DIRECTION($,(-0.64018439966448,-0.768221279597376,0));
+#58=VECTOR($,#57,1);
+#59=LINE($,#56,#58);
+#60=EDGE_CURVE($,#49,#39,#59,.T.);
+#61=ORIENTED_EDGE($,$,$,#60,.F.);
+#62=EDGE_LOOP($,(#47,#55,#61));
+#63=FACE_OUTER_BOUND('',#62,.T.);
+#64=ADVANCED_FACE('',(#63),#37,.T.);
+#65=CARTESIAN_POINT($,(-10,-6,0));
+#66=DIRECTION($,(0,-1,0));
+#67=DIRECTION($,(0,0,1));
+#68=AXIS2_PLACEMENT_3D($,#65,#66,#67);
+#69=PLANE($,#68);
+#70=ORIENTED_EDGE($,$,$,#14,.T.);
+#71=CARTESIAN_POINT($,(10,-6,-0));
+#72=DIRECTION($,(0,0,1));
+#73=VECTOR($,#72,1);
+#74=LINE($,#71,#73);
+#75=EDGE_CURVE($,#9,#41,#74,.T.);
+#76=ORIENTED_EDGE($,$,$,#75,.T.);
+#77=ORIENTED_EDGE($,$,$,#46,.F.);
+#78=CARTESIAN_POINT($,(-10,-6,0));
+#79=DIRECTION($,(0,0,1));
+#80=VECTOR($,#79,1);
+#81=LINE($,#78,#80);
+#82=EDGE_CURVE($,#7,#39,#81,.T.);
+#83=ORIENTED_EDGE($,$,$,#82,.F.);
+#84=EDGE_LOOP($,(#70,#76,#77,#83));
+#85=FACE_OUTER_BOUND('',#84,.T.);
+#86=ADVANCED_FACE('',(#85),#69,.T.);
+#87=CARTESIAN_POINT($,(10,-6,0));
+#88=DIRECTION($,(0.768221279597376,0.64018439966448,-0));
+#89=DIRECTION($,(0,0,1));
+#90=AXIS2_PLACEMENT_3D($,#87,#88,#89);
+#91=PLANE($,#90);
+#92=ORIENTED_EDGE($,$,$,#22,.T.);
+#93=CARTESIAN_POINT($,(-0,6,-0));
+#94=DIRECTION($,(0,0,1));
+#95=VECTOR($,#94,1);
+#96=LINE($,#93,#95);
+#97=EDGE_CURVE($,#17,#49,#96,.T.);
+#98=ORIENTED_EDGE($,$,$,#97,.T.);
+#99=ORIENTED_EDGE($,$,$,#54,.F.);
+#100=ORIENTED_EDGE($,$,$,#75,.F.);
+#101=EDGE_LOOP($,(#92,#98,#99,#100));
+#102=FACE_OUTER_BOUND('',#101,.T.);
+#103=ADVANCED_FACE('',(#102),#91,.T.);
+#104=CARTESIAN_POINT($,(0,6,0));
+#105=DIRECTION($,(-0.768221279597376,0.64018439966448,0));
+#106=DIRECTION($,(0,0,1));
+#107=AXIS2_PLACEMENT_3D($,#104,#105,#106);
+#108=PLANE($,#107);
+#109=ORIENTED_EDGE($,$,$,#28,.T.);
+#110=ORIENTED_EDGE($,$,$,#82,.T.);
+#111=ORIENTED_EDGE($,$,$,#60,.F.);
+#112=ORIENTED_EDGE($,$,$,#97,.F.);
+#113=EDGE_LOOP($,(#109,#110,#111,#112));
+#114=FACE_OUTER_BOUND('',#113,.T.);
+#115=ADVANCED_FACE('',(#114),#108,.T.);
+#116=CLOSED_SHELL($,(#32,#64,#86,#103,#115));
+#117=MANIFOLD_SOLID_BREP('AetherisBody',#116);
+#118=APPLICATION_CONTEXT('mechanical design');
+#119=PRODUCT_CONTEXT('',#118,'mechanical');
+#120=PRODUCT('AETHERIS','AetherisBody','',(#119));
+#121=PRODUCT_DEFINITION_FORMATION('','',#120);
+#122=PRODUCT_DEFINITION_CONTEXT('design',#118,'design');
+#123=PRODUCT_DEFINITION('','',#121,#122);
+#124=PRODUCT_DEFINITION_SHAPE('','',#123);
+#125=(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.));
+#126=(NAMED_UNIT(*)PLANE_ANGLE_UNIT()SI_UNIT($,.RADIAN.));
+#127=(NAMED_UNIT(*)SI_UNIT($,.STERADIAN.)SOLID_ANGLE_UNIT());
+#128=(GEOMETRIC_REPRESENTATION_CONTEXT(3)GLOBAL_UNIT_ASSIGNED_CONTEXT((#125,#126,#127))REPRESENTATION_CONTEXT('3','3D'));
+#129=SHAPE_REPRESENTATION('AetherisBody',(#117),#128);
+#130=SHAPE_DEFINITION_REPRESENTATION(#124,#129);
+ENDSEC;
+END-ISO-10303-21;
diff --git a/testdata/firmament/fixtures/m3-prism-boolean-hexagonal-rejected.firmament b/testdata/firmament/fixtures/m3-prism-boolean-hexagonal-rejected.firmament
new file mode 100644
index 00000000..c537534a
--- /dev/null
+++ b/testdata/firmament/fixtures/m3-prism-boolean-hexagonal-rejected.firmament
@@ -0,0 +1,17 @@
+firmament:
+ version: 1
+
+model:
+ name: m3_prism_boolean_hexagonal_rejected
+ units: mm
+
+ops[2]:
+ -
+ op: box
+ id: base
+ size[3]: [40, 30, 20]
+ -
+ op: subtract
+ id: hex_cut
+ from: base
+ with: { op: hexagonal_prism, across_flats: 12, height: 24 }
diff --git a/testdata/firmament/fixtures/m3-prism-boolean-slot-rejected.firmament b/testdata/firmament/fixtures/m3-prism-boolean-slot-rejected.firmament
new file mode 100644
index 00000000..c2848b32
--- /dev/null
+++ b/testdata/firmament/fixtures/m3-prism-boolean-slot-rejected.firmament
@@ -0,0 +1,17 @@
+firmament:
+ version: 1
+
+model:
+ name: m3_prism_boolean_slot_rejected
+ units: mm
+
+ops[2]:
+ -
+ op: box
+ id: base
+ size[3]: [40, 30, 20]
+ -
+ op: subtract
+ id: slot_cut
+ from: base
+ with: { op: straight_slot, length: 24, width: 8, height: 24 }
diff --git a/testdata/firmament/fixtures/m3-prism-boolean-triangular-rejected.firmament b/testdata/firmament/fixtures/m3-prism-boolean-triangular-rejected.firmament
new file mode 100644
index 00000000..1edac3ce
--- /dev/null
+++ b/testdata/firmament/fixtures/m3-prism-boolean-triangular-rejected.firmament
@@ -0,0 +1,17 @@
+firmament:
+ version: 1
+
+model:
+ name: m3_prism_boolean_triangular_rejected
+ units: mm
+
+ops[2]:
+ -
+ op: box
+ id: base
+ size[3]: [40, 30, 20]
+ -
+ op: subtract
+ id: tri_cut
+ from: base
+ with: { op: triangular_prism, base_width: 18, base_depth: 10, height: 24 }