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.csindex 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 BrepPrimitivesTestsAssert.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.csindex 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.csindex 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.csindex 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.csindex 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 FirmamentPrimitiveExecutionTestsAssert.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.csindex 83fc5e4b..756af5e4 100644--- a/Aetheris.Kernel.Firmament/Execution/FirmamentBooleanToolBodyFactory.cs+++ b/Aetheris.Kernel.Firmament/Execution/FirmamentBooleanToolBodyFactory.cs@@ -69,6 +69,49 @@ internal static class FirmamentBooleanToolBodyFactoryFirmamentPrimitiveToolParsing.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.csindex 69bdfa57..5cee3d2a 100644--- a/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs+++ b/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs@@ -111,6 +111,19 @@ internal static class FirmamentPrimitiveExecutorreturn 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 FirmamentPrimitiveExecutorFirmamentLoweredPrimitiveKind.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 FirmamentPrimitiveExecutorFirmamentLoweredPrimitiveKind.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 FirmamentPrimitiveExecutorreturn 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.csindex 5457d45f..2f0f8f2a 100644--- a/Aetheris.Kernel.Firmament/Formatting/FirmamentCanonicalFormatter.cs+++ b/Aetheris.Kernel.Firmament/Formatting/FirmamentCanonicalFormatter.cs@@ -131,6 +131,20 @@ internal static class FirmamentCanonicalFormattercase 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.csindex 0268967f..50674bd4 100644--- a/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLowerer.cs+++ b/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLowerer.cs@@ -75,6 +75,38 @@ internal static class FirmamentPrimitiveLowererRadius: 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.csindex 9884343a..92747509 100644--- a/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLoweringPlan.cs+++ b/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLoweringPlan.cs@@ -52,7 +52,10 @@ public enum FirmamentLoweredPrimitiveKindCylinder,Cone,Torus,- Sphere+ Sphere,+ TriangularPrism,+ HexagonalPrism,+ StraightSlot}public abstract record FirmamentLoweredPrimitiveParameters;@@ -72,6 +75,15 @@ public sealed record FirmamentLoweredTorusParameters(double MajorRadius, doublepublic 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.csindex 9e1fba49..853d1794 100644--- a/Aetheris.Kernel.Firmament/ParsedModel/FirmamentKnownOpKind.cs+++ b/Aetheris.Kernel.Firmament/ParsedModel/FirmamentKnownOpKind.cs@@ -7,6 +7,9 @@ public enum FirmamentKnownOpKindCone,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 FirmamentKnownOpKindsFirmamentKnownOpKind.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.csindex 40153c30..3d2fbafd 100644--- a/Aetheris.Kernel.Firmament/Validation/FirmamentBooleanRequiredFieldValidator.cs+++ b/Aetheris.Kernel.Firmament/Validation/FirmamentBooleanRequiredFieldValidator.cs@@ -102,6 +102,21 @@ internal static class FirmamentBooleanRequiredFieldValidatorreturn 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 FirmamentBooleanRequiredFieldValidatorreturn 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.csindex d68bc15e..ec4729b8 100644--- a/Aetheris.Kernel.Firmament/Validation/FirmamentPrimitiveRequiredFieldValidator.cs+++ b/Aetheris.Kernel.Firmament/Validation/FirmamentPrimitiveRequiredFieldValidator.cs@@ -29,6 +29,9 @@ internal static class FirmamentPrimitiveRequiredFieldValidatorFirmamentKnownOpKind.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 FirmamentPrimitiveRequiredFieldValidatorreturn 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.csindex 436a235a..aec8db43 100644--- a/Aetheris.Kernel.Firmament/Validation/FirmamentSelectorContracts.cs+++ b/Aetheris.Kernel.Firmament/Validation/FirmamentSelectorContracts.cs@@ -70,6 +70,11 @@ internal static class FirmamentSelectorContractscase 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 FirmamentSelectorContractscase 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.firmamentnew file mode 100644index 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: 10diff --git a/testdata/firmament/examples/straight_slot_basic.firmament b/testdata/firmament/examples/straight_slot_basic.firmamentnew file mode 100644index 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: 8diff --git a/testdata/firmament/examples/triangular_prism_basic.firmament b/testdata/firmament/examples/triangular_prism_basic.firmamentnew file mode 100644index 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: 10diff --git a/testdata/firmament/exports/hexagonal_prism_basic.step b/testdata/firmament/exports/hexagonal_prism_basic.stepnew file mode 100644index 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.stepnew file mode 100644index 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.stepnew file mode 100644index 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.firmamentnew file mode 100644index 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.firmamentnew file mode 100644index 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.firmamentnew file mode 100644index 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 }