Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
using System.Text;
using Aetheris.Kernel.Core.Brep;
using Aetheris.Kernel.Core.Brep.Tessellation;
using Aetheris.Kernel.Core.Diagnostics;
using Aetheris.Kernel.Core.Geometry;
using Aetheris.Kernel.Core.Geometry.Curves;
using Aetheris.Kernel.Core.Math;
using Aetheris.Kernel.Core.Step242;
using Aetheris.Kernel.Core.Topology;
namespace Aetheris.Kernel.Core.Tests.Step242;
public sealed class Step242ImporterTests
{
[Fact]
public void ImportBody_KnownGoodM22SubsetText_ReturnsValidatedBody()
{
var fixtureText = Step242FixtureCorpus.CanonicalBoxGolden;
var import = Step242Importer.ImportBody(fixtureText);
Assert.True(import.IsSuccess);
var validation = BrepBindingValidator.Validate(import.Value, requireAllEdgeAndFaceBindings: true);
Assert.True(validation.IsSuccess);
var tessellation = BrepDisplayTessellator.Tessellate(import.Value);
Assert.True(tessellation.IsSuccess);
Assert.NotEmpty(tessellation.Value.FacePatches);
}
[Fact]
public void ExportImportRoundTrip_BoxSubset_PreservesBasicTopologyInvariants()
{
var boxResult = BrepPrimitives.CreateBox(4d, 6d, 8d);
Assert.True(boxResult.IsSuccess);
var export = Step242Exporter.ExportBody(boxResult.Value);
Assert.True(export.IsSuccess);
var import = Step242Importer.ImportBody(export.Value);
Assert.True(import.IsSuccess);
Assert.Equal(boxResult.Value.Topology.Vertices.Count(), import.Value.Topology.Vertices.Count());
Assert.Equal(boxResult.Value.Topology.Edges.Count(), import.Value.Topology.Edges.Count());
Assert.Equal(boxResult.Value.Topology.Faces.Count(), import.Value.Topology.Faces.Count());
var tessellation = BrepDisplayTessellator.Tessellate(import.Value);
Assert.True(tessellation.IsSuccess);
}
[Fact]
public void ImportBody_MalformedStep_ReturnsDiagnosticWithoutThrowing()
{
var malformed = Step242FixtureCorpus.MalformedMissingParen;
var import = Step242Importer.ImportBody(malformed);
Assert.False(import.IsSuccess);
var diagnostic = Assert.Single(import.Diagnostics);
Assert.Equal(KernelDiagnosticCode.InvalidArgument, diagnostic.Code);
Assert.Equal(KernelDiagnosticSeverity.Error, diagnostic.Severity);
Assert.StartsWith("Parser", diagnostic.Source, StringComparison.Ordinal);
}
[Fact]
public void ImportBody_ToroidalSurfaceEntity_IsNoLongerRejectedAsUnsupportedFamily()
{
var toroidalOnly = Step242FixtureCorpus.UnsupportedToroidalSurface;
var import = Step242Importer.ImportBody(toroidalOnly);
Assert.False(import.IsSuccess);
var diagnostic = Assert.Single(import.Diagnostics);
Assert.Equal(KernelDiagnosticCode.NotImplemented, diagnostic.Code);
Assert.Equal(KernelDiagnosticSeverity.Error, diagnostic.Severity);
Assert.Equal("Importer.TopologyRoot", diagnostic.Source);
Assert.DoesNotContain("TOROIDAL_SURFACE", diagnostic.Message, StringComparison.OrdinalIgnoreCase);
}
[Fact]
public void ImportBody_MissingSolidRoot_ReturnsDeterministicTopologyRootDiagnostic()
{
const string noRoot = "ISO-10303-21;\nHEADER;\nENDSEC;\nDATA;\n#1=CARTESIAN_POINT($,(0,0,0));\nENDSEC;\nEND-ISO-10303-21;";
var import = Step242Importer.ImportBody(noRoot);
Assert.False(import.IsSuccess);
var diagnostic = Assert.Single(import.Diagnostics);
Assert.Equal(KernelDiagnosticCode.NotImplemented, diagnostic.Code);
Assert.Equal("Importer.TopologyRoot", diagnostic.Source);
Assert.StartsWith("Missing MANIFOLD_SOLID_BREP or BREP_WITH_VOIDS", diagnostic.Message, StringComparison.Ordinal);
}
[Fact]
public void ImportBody_MultipleSolidRoots_ClassifiesInputAsAssemblyLike()
{
const string multiRoot = "ISO-10303-21;\nHEADER;\nENDSEC;\nDATA;\n#1=MANIFOLD_SOLID_BREP('a',#3);\n#2=MANIFOLD_SOLID_BREP('b',#3);\n#3=CLOSED_SHELL($,());\nENDSEC;\nEND-ISO-10303-21;";
var import = Step242Importer.ImportBody(multiRoot);
Assert.False(import.IsSuccess);
var diagnostic = Assert.Single(import.Diagnostics);
Assert.Equal(KernelDiagnosticCode.NotImplemented, diagnostic.Code);
Assert.Equal("Importer.AssemblyLike.StepMultiRoot", diagnostic.Source);
Assert.Contains("assembly-like", diagnostic.Message, StringComparison.OrdinalIgnoreCase);
Assert.Contains("detected 2 exact BRep rigid roots", diagnostic.Message, StringComparison.Ordinal);
}
[Fact]
public void ImportRigidRoots_MultipleSolidRoots_ImportsEveryRootWithoutWeakeningPartContract()
{
var box = BrepPrimitives.CreateBox(2, 4, 6).Value;
var sphere = BrepPrimitives.CreateSphere(3).Value;
var exported = Step242AssemblyExporter.Export(new Step242AssemblyExportModel("Pair", "root", [
new("box-def", "Box", box), new("sphere-def", "Sphere", sphere)], [
new("root", "Pair", null, null, Identity()),
new("box-occ", "Box", "root", "box-def", Identity()),
new("sphere-occ", "Sphere", "root", "sphere-def", Identity())]));
Assert.True(exported.IsSuccess);
var strictPart = Step242Importer.ImportBody(exported.Value);
Assert.False(strictPart.IsSuccess);
var roots = Step242Importer.ImportRigidRoots(exported.Value);
Assert.True(roots.IsSuccess, string.Join("; ", roots.Diagnostics.Select(d => d.Message)));
Assert.Equal(2, roots.Value.Count);
Assert.Equal([6, 1], roots.Value.Select(root => root.Body.Topology.Faces.Count()).OrderDescending().ToArray());
}
private static double[] Identity() => [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
[Fact]
public void ImportBody_TessellatedSolidWithComplexTriangulatedFace_ImportsWithoutManifoldSolidBrep()
{
const string tessellated = "ISO-10303-21;\nHEADER;\nENDSEC;\nDATA;\n#1=TESSELLATED_SOLID('part',(#2));\n#2=TESSELLATED_SHELL('shell',(#3));\n#3=COMPLEX_TRIANGULATED_FACE('',#10,3,((0,0,1)),#20,(1,2,3),((1,2,3)),());\n#10=COORDINATES_LIST('',3,((0,0,0),(1,0,0),(0,1,0)));\n#20=PLANE('',#30);\n#30=AXIS2_PLACEMENT_3D('',#31,#32,#33);\n#31=CARTESIAN_POINT('',(0,0,0));\n#32=DIRECTION('',(0,0,1));\n#33=DIRECTION('',(1,0,0));\nENDSEC;\nEND-ISO-10303-21;";
var import = Step242Importer.ImportBody(tessellated);
Assert.True(import.IsSuccess);
Assert.Single(import.Value.Topology.Faces);
Assert.DoesNotContain(import.Diagnostics, d => string.Equals(d.Source, "Importer.TopologyRoot", StringComparison.Ordinal));
}
[Fact]
public void NistFtc08Tg_TessellatedVariant_IsClassifiedAsUnsupportedForExactBrepCorpus()
{
var text = LoadFixture("testdata/step242/nist/FTC/nist_ftc_08_asme1_ap242-e1-tg.stp");
var parse = Step242SubsetParser.Parse(text);
Assert.True(parse.IsSuccess);
var import = Step242ExactBRepImportLane.ImportExactBrep(parse.Value);
Assert.False(import.IsSuccess);
var diagnostic = Assert.Single(import.Diagnostics);
Assert.Equal(KernelDiagnosticCode.NotImplemented, diagnostic.Code);
Assert.Equal("Importer.TopologyRoot", diagnostic.Source);
Assert.StartsWith("Missing MANIFOLD_SOLID_BREP or BREP_WITH_VOIDS", diagnostic.Message, StringComparison.Ordinal);
}
[Fact]
public void ImportBody_DegenerateDirection_ReturnsDiagnosticWithoutThrowing()
{
const string degenerateDirection = "ISO-10303-21;\nHEADER;\nENDSEC;\nDATA;\n#1=MANIFOLD_SOLID_BREP('solid',#2);\n#2=CLOSED_SHELL($,(#3));\n#3=ADVANCED_FACE((#4),#5,.T.);\n#4=FACE_OUTER_BOUND($,#6,.T.);\n#5=PLANE($,#20);\n#6=EDGE_LOOP($,(#7));\n#7=ORIENTED_EDGE($,$,$,#8,.T.);\n#8=EDGE_CURVE($,#9,#10,#11,.T.);\n#9=VERTEX_POINT($,#12);\n#10=VERTEX_POINT($,#13);\n#11=LINE($,#12,#14);\n#12=CARTESIAN_POINT($,(0,0,0));\n#13=CARTESIAN_POINT($,(1,0,0));\n#14=VECTOR($,#15,1.0);\n#15=DIRECTION($,(1,0,0));\n#20=AXIS2_PLACEMENT_3D($,#12,#21,#22);\n#21=DIRECTION($,(0,0,0));\n#22=DIRECTION($,(1,0,0));\nENDSEC;\nEND-ISO-10303-21;";
var import = Step242Importer.ImportBody(degenerateDirection);
Assert.False(import.IsSuccess);
var diagnostic = Assert.Single(import.Diagnostics);
Assert.Equal(KernelDiagnosticCode.NotImplemented, diagnostic.Code);
Assert.Equal("Importer.Geometry.Direction", diagnostic.Source);
Assert.StartsWith("Degenerate direction vector", diagnostic.Message, StringComparison.Ordinal);
}
[Fact]
public void Step242_AdvancedFace_Bounds_SingleAggregate_ConsumesCorrectly()
{
var text = LoadFixture("testdata/step242/syntax-robustness/advanced-face-bounds-single-aggregate.step");
var import = Step242Importer.ImportBody(text);
Assert.True(import.IsSuccess);
Assert.DoesNotContain(import.Diagnostics, d => d.Message.Contains("ADVANCED_FACE surface: expected entity reference or inline entity constructor.", StringComparison.Ordinal));
}
[Fact]
public void Step242_AdvancedFace_Bounds_MultiAggregate_ConsumesCorrectly()
{
var text = LoadFixture("testdata/step242/syntax-robustness/advanced-face-bounds-multi-aggregate.step");
var import = Step242Importer.ImportBody(text);
Assert.DoesNotContain(import.Diagnostics, d => d.Message.Contains("ADVANCED_FACE surface: expected entity reference or inline entity constructor.", StringComparison.Ordinal));
Assert.DoesNotContain(import.Diagnostics, d => string.Equals(d.Source, "Importer.StepSyntax.AdvancedFaceBounds", StringComparison.Ordinal));
}
[Fact]
public void Step242_FreeCAD_Repro_ImportsPastAdvancedFaceBounds()
{
var text = LoadFixture("testdata/step242/syntax-robustness/freecad-pad-repro.step");
var import = Step242Importer.ImportBody(text);
Assert.True(import.IsSuccess);
Assert.DoesNotContain(import.Diagnostics, d => d.Message.Contains("ADVANCED_FACE surface", StringComparison.Ordinal));
}
[Fact]
public void Step242_AdvancedFace_Surface_AllowsInlinePlaneConstructor()
{
var text = LoadFixture("testdata/step242/syntax-robustness/advanced-face-inline-plane.step");
var parseResult = Step242SubsetParser.Parse(text);
Assert.True(parseResult.IsSuccess);
var import = Step242Importer.ImportBody(text);
Assert.True(import.IsSuccess);
Assert.Single(import.Value.Topology.Faces);
Assert.DoesNotContain(import.Diagnostics, d => d.Message.Contains("ADVANCED_FACE surface: expected entity reference argument.", StringComparison.Ordinal));
}
[Fact]
public void Step242_AdvancedFace_Surface_AllowsEntityRefPlaneConstructor()
{
var text = LoadFixture("testdata/step242/syntax-robustness/advanced-face-ref-plane.step");
var parseResult = Step242SubsetParser.Parse(text);
Assert.True(parseResult.IsSuccess);
var import = Step242Importer.ImportBody(text);
Assert.True(import.IsSuccess);
Assert.Single(import.Value.Topology.Faces);
}
[Fact]
public void Step242_AdvancedFace_Surface_AllowsInlineCylindricalSurfaceConstructor()
{
var text = LoadFixture("testdata/step242/syntax-robustness/advanced-face-inline-cylinder.step");
var parseResult = Step242SubsetParser.Parse(text);
Assert.True(parseResult.IsSuccess);
var import = Step242Importer.ImportBody(text);
Assert.DoesNotContain(import.Diagnostics, d => d.Source is not null && d.Source.StartsWith("Parser", StringComparison.Ordinal));
Assert.DoesNotContain(import.Diagnostics, d => string.Equals(d.Source, "Importer.StepSyntax.InlineEntity", StringComparison.Ordinal));
if (!import.IsSuccess)
{
Assert.NotEmpty(import.Diagnostics);
return;
}
Assert.Contains(import.Value.Geometry.Surfaces, s => s.Value.Kind == SurfaceGeometryKind.Cylinder);
}
[Fact]
public void Step242_AdvancedFace_Surface_RejectsInlineCylinderMalformedArgs()
{
var text = LoadFixture("testdata/step242/syntax-robustness/advanced-face-inline-cylinder-malformed.step");
var parseResult = Step242SubsetParser.Parse(text);
Assert.True(parseResult.IsSuccess);
var import = Step242Importer.ImportBody(text);
Assert.False(import.IsSuccess);
var diagnostic = Assert.Single(import.Diagnostics);
Assert.Equal(KernelDiagnosticCode.NotImplemented, diagnostic.Code);
Assert.Equal("Importer.StepSyntax.InlineEntity", diagnostic.Source);
Assert.StartsWith("Inline ADVANCED_FACE.surface constructor 'CYLINDRICAL_SURFACE' has unsupported argument shape.", diagnostic.Message, StringComparison.Ordinal);
}
[Fact]
public void Step242_AdvancedFace_Surface_AllowsInlineConicalSurfaceConstructor()
{
var text = LoadFixture("testdata/step242/syntax-robustness/advanced-face-inline-cone-valid.step");
var parseResult = Step242SubsetParser.Parse(text);
Assert.True(parseResult.IsSuccess);
var import = Step242Importer.ImportBody(text);
Assert.DoesNotContain(import.Diagnostics, d => d.Source is not null && d.Source.StartsWith("Parser", StringComparison.Ordinal));
Assert.DoesNotContain(import.Diagnostics, d => string.Equals(d.Source, "Importer.StepSyntax.InlineEntity", StringComparison.Ordinal));
if (!import.IsSuccess)
{
Assert.NotEmpty(import.Diagnostics);
return;
}
Assert.Contains(import.Value.Geometry.Surfaces, s => s.Value.Kind == SurfaceGeometryKind.Cone);
}
[Fact]
public void Step242_AdvancedFace_Surface_RejectsInlineConicalSurface_MalformedArgs()
{
var text = LoadFixture("testdata/step242/syntax-robustness/advanced-face-inline-cone-malformed.step");
var parseResult = Step242SubsetParser.Parse(text);
Assert.True(parseResult.IsSuccess);
var import = Step242Importer.ImportBody(text);
Assert.False(import.IsSuccess);
var diagnostic = Assert.Single(import.Diagnostics);
Assert.Equal(KernelDiagnosticCode.NotImplemented, diagnostic.Code);
Assert.Equal("Importer.StepSyntax.InlineEntity", diagnostic.Source);
Assert.StartsWith("Inline ADVANCED_FACE.surface constructor 'CONICAL_SURFACE' has unsupported argument shape.", diagnostic.Message, StringComparison.Ordinal);
}
[Fact]
public void Step242_SubsetDecoder_ReadEllipseCurve_DecodesPlacementAndRadii()
{
const string text = "ISO-10303-21;\nHEADER;\nENDSEC;\nDATA;\n"
+ "#10=ELLIPSE('',#20,6.,4.);\n"
+ "#20=AXIS2_PLACEMENT_3D('',#21,#22,#23);\n"
+ "#21=CARTESIAN_POINT('',(1.,2.,3.));\n"
+ "#22=DIRECTION('',(0.,0.,1.));\n"
+ "#23=DIRECTION('',(1.,0.,0.));\n"
+ "ENDSEC;\nEND-ISO-10303-21;";
var parse = Step242SubsetParser.Parse(text);
Assert.True(parse.IsSuccess);
var ellipseEntityResult = parse.Value.TryGetEntity(10, "ELLIPSE");
Assert.True(ellipseEntityResult.IsSuccess);
var ellipse = Step242SubsetDecoder.ReadEllipseCurve(parse.Value, ellipseEntityResult.Value);
Assert.True(ellipse.IsSuccess);
Assert.Equal(6d, ellipse.Value.MajorRadius, 9);
Assert.Equal(4d, ellipse.Value.MinorRadius, 9);
Assert.True(((ellipse.Value.Evaluate(0d) - new Point3D(7d, 2d, 3d)).LengthSquared) < 1e-12d);
Assert.True(((ellipse.Value.Evaluate(double.Pi / 2d) - new Point3D(1d, 6d, 3d)).LengthSquared) < 1e-12d);
}
[Fact]
public void Step242_CurveSampler_Circle3_SamplesArcDeterministically()
{
var circle = new Circle3Curve(Point3D.Origin, Direction3D.Create(new Vector3D(0d, 0d, 1d)), 2d, Direction3D.Create(new Vector3D(1d, 0d, 0d)));
var forward = CurveSampler.SampleCircleArc(circle, 0d, double.Pi / 2d);
var second = CurveSampler.SampleCircleArc(circle, 0d, double.Pi / 2d);
var reversed = CurveSampler.SampleCircleArc(circle, double.Pi / 2d, -double.Pi / 2d);
Assert.Equal(forward.Count, second.Count);
Assert.Equal(13, forward.Count);
Assert.True(((forward[0] - circle.Evaluate(0d)).LengthSquared) < 1e-12d);
Assert.True(((forward[^1] - circle.Evaluate(double.Pi / 2d)).LengthSquared) < 1e-12d);
for (var i = 0; i < forward.Count; i++)
{
Assert.True(((forward[i] - second[i]).LengthSquared) < 1e-12d);
Assert.True(((forward[i] - reversed[^(i + 1)]).LengthSquared) < 1e-12d);
}
}
[Fact]
public void Step242_0430200200_Import_NoCircle3LineOnlyError()
{
var text = LoadFixture("testdata/step242/tessellation-robustness/planar-rect-with-filleted-corners.step");
var import = Step242Importer.ImportBody(text);
Assert.True(import.IsSuccess);
var tessellation = BrepDisplayTessellator.Tessellate(import.Value);
Assert.True(tessellation.IsSuccess);
Assert.DoesNotContain(import.Diagnostics, d => d.Message.Contains("Circle3", StringComparison.Ordinal));
Assert.DoesNotContain(import.Diagnostics, d => d.Message.Contains("line edges only", StringComparison.OrdinalIgnoreCase));
Assert.DoesNotContain(tessellation.Diagnostics, d => d.Message.Contains("Circle3", StringComparison.Ordinal));
Assert.DoesNotContain(tessellation.Diagnostics, d => d.Message.Contains("line edges only", StringComparison.OrdinalIgnoreCase));
}
[Fact]
public void CircleTrim_ShortArc_DoesNotWrapFullCircle()
{
var circle = new Circle3Curve(Point3D.Origin, Direction3D.Create(new Vector3D(0d, 0d, 1d)), 1d, Direction3D.Create(new Vector3D(1d, 0d, 0d)));
var start = circle.Evaluate(0d);
var end = circle.Evaluate(double.Pi / 6d);
var sampled = CurveSampler.TrySampleTrimmedCircleArc(circle, start, end, orientedEdgeSense: true, out var points, out _, out var shorterArcFallback);
Assert.True(sampled);
Assert.False(shorterArcFallback);
Assert.True(points.Count >= 3);
var angles = points
.Select(p => NormalizeToZeroTwoPi(double.Atan2(p.Y, p.X)))
.ToArray();
for (var i = 1; i < angles.Length; i++)
{
Assert.True(angles[i] + 1e-8d >= angles[i - 1]);
}
var span = angles[^1] - angles[0];
Assert.InRange(span, (double.Pi / 6d) - 0.05d, (double.Pi / 6d) + 0.05d);
Assert.True(span < double.Pi);
}
[Fact]
public void CircleTrim_ReversedSense_ReversesPointOrder()
{
var circle = new Circle3Curve(Point3D.Origin, Direction3D.Create(new Vector3D(0d, 0d, 1d)), 1d, Direction3D.Create(new Vector3D(1d, 0d, 0d)));
var start = circle.Evaluate(0d);
var end = circle.Evaluate(double.Pi / 6d);
var forwardOk = CurveSampler.TrySampleTrimmedCircleArc(circle, start, end, orientedEdgeSense: true, out var forward, out _, out _);
var reverseOk = CurveSampler.TrySampleTrimmedCircleArc(circle, start, end, orientedEdgeSense: false, out var reversed, out _, out _);
Assert.True(forwardOk);
Assert.True(reverseOk);
Assert.True(((forward[0] - reversed[0]).Length) < 1e-9d);
Assert.True(forward[1].Y > 0d);
Assert.True(reversed[1].Y < 0d);
}
[Fact]
public void Step242_CircleTrimFixture_Tessellation_UsesShortArcsWithoutTrimDiagnostics()
{
var text = LoadFixture("testdata/step242/tessellation-robustness/planar-rect-with-filleted-corners.step");
var import = Step242Importer.ImportBody(text);
Assert.True(import.IsSuccess);
var tessellation = BrepDisplayTessellator.Tessellate(import.Value);
Assert.True(tessellation.IsSuccess);
Assert.DoesNotContain(tessellation.Diagnostics, d => string.Equals(d.Source, "Viewer.Tessellation.CircleTrimResolveFailed", StringComparison.Ordinal));
var circularEdges = import.Value.Topology.Edges
.Where(e => import.Value.TryGetEdgeCurveGeometry(e.Id, out var curve) && curve?.Kind == CurveGeometryKind.Circle3)
.ToArray();
Assert.NotEmpty(circularEdges);
foreach (var edge in circularEdges)
{
var polyline = Assert.Single(tessellation.Value.EdgePolylines, p => p.EdgeId == edge.Id);
Assert.True(polyline.Points.Count <= 20);
}
}
[Fact]
public void Step242_ToroidalFixture_ImportsAndTessellates()
{
var text = LoadFixture("testdata/step242/generated/v0-required/toroid.step");
var import = Step242Importer.ImportBody(text);
Assert.True(import.IsSuccess);
Assert.Contains(import.Value.Geometry.Surfaces, s => s.Value.Kind == SurfaceGeometryKind.Torus);
var tessellation = BrepDisplayTessellator.Tessellate(import.Value);
Assert.True(tessellation.IsSuccess);
Assert.NotEmpty(tessellation.Value.FacePatches);
}
[Fact]
public void Step242_HandcraftedSphereFixture_AcceptsVertexLoopFaceBound_AndImports()
{
var text = LoadFixture("testdata/step242/handcrafted/baseline/sphere.step");
var import = Step242Importer.ImportBody(text);
Assert.True(import.IsSuccess);
Assert.Single(import.Value.Topology.Faces);
var face = Assert.Single(import.Value.Topology.Faces);
var loop = import.Value.Topology.GetLoop(Assert.Single(import.Value.GetLoopIds(face.Id)));
Assert.Equal(LoopKind.Vertex, loop.Kind);
Assert.NotNull(loop.VertexLoopVertexId);
Assert.Empty(loop.CoedgeIds);
Assert.True(import.Value.Bindings.TryGetVertexLoopParameterBinding(loop.Id, out var vertexLoop));
Assert.Equal(face.Id, vertexLoop.FaceId);
}
[Fact]
public void Step242_HandcraftedSphereFixture_AdvancesPastVertexLoopBlocker_AndTessellates()
{
var text = LoadFixture("testdata/step242/handcrafted/baseline/sphere.step");
var import = Step242Importer.ImportBody(text);
Assert.True(import.IsSuccess);
var tessellation = BrepDisplayTessellator.Tessellate(import.Value);
Assert.True(tessellation.IsSuccess);
Assert.DoesNotContain(tessellation.Diagnostics,
d => d.Message.Contains("expected 'EDGE_LOOP' but found 'VERTEX_LOOP'", StringComparison.Ordinal));
Assert.NotEmpty(tessellation.Value.FacePatches);
}
[Fact]
public void Step242_HandcraftedToroidFixture_UsesCircularSeamTopology_AndTessellates()
{
var text = LoadFixture("testdata/step242/handcrafted/baseline/toroid.step");
var import = Step242Importer.ImportBody(text);
Assert.True(import.IsSuccess);
var torusFace = Assert.Single(import.Value.Topology.Faces, face =>
{
Assert.True(import.Value.Bindings.TryGetFaceBinding(face.Id, out var binding));
Assert.True(import.Value.Geometry.TryGetSurface(binding.SurfaceGeometryId, out var surface));
return surface!.Kind == SurfaceGeometryKind.Torus;
});
var loopIds = import.Value.GetLoopIds(torusFace.Id);
var loopId = Assert.Single(loopIds);
var coedges = import.Value.GetCoedgeIds(loopId)
.Select(id => import.Value.Topology.GetCoedge(id))
.ToArray();
Assert.Equal(4, coedges.Length);
Assert.All(coedges, coedge => Assert.Equal(CurveGeometryKind.Circle3, import.Value.GetEdgeCurve(coedge.EdgeId).Kind));
var seamUseCount = coedges.Count(coedge =>
{
var edge = import.Value.Topology.GetEdge(coedge.EdgeId);
return edge.StartVertexId == edge.EndVertexId;
});
Assert.Equal(4, seamUseCount);
Assert.Equal(2, coedges.Select(c => c.EdgeId).Distinct().Count());
var tessellationA = BrepDisplayTessellator.Tessellate(import.Value);
Assert.True(tessellationA.IsSuccess);
Assert.DoesNotContain(tessellationA.Diagnostics,
d => d.Message.Contains("two line seam uses and two circular trim uses", StringComparison.OrdinalIgnoreCase));
var tessellationB = BrepDisplayTessellator.Tessellate(import.Value);
Assert.True(tessellationB.IsSuccess);
var patchA = Assert.Single(tessellationA.Value.FacePatches, p => p.FaceId == torusFace.Id);
var patchB = Assert.Single(tessellationB.Value.FacePatches, p => p.FaceId == torusFace.Id);
Assert.Equal(patchA.Positions.Count, patchB.Positions.Count);
Assert.Equal(patchA.Normals.Count, patchB.Normals.Count);
Assert.Equal(patchA.TriangleIndices.Count, patchB.TriangleIndices.Count);
Assert.True(patchA.Positions.SequenceEqual(patchB.Positions));
Assert.True(patchA.Normals.SequenceEqual(patchB.Normals));
Assert.True(patchA.TriangleIndices.SequenceEqual(patchB.TriangleIndices));
}
[Fact]
public void Step242_HandcraftedCylinderFixture_TessellatesSideAsPeriodicClosedGrid()
{
var text = LoadFixture("testdata/step242/handcrafted/baseline/cylinder.step");
var import = Step242Importer.ImportBody(text);
Assert.True(import.IsSuccess);
var options = DisplayTessellationOptions.Create(double.Pi / 6d, 10d, minimumSegments: 12, maximumSegments: 12).Value;
var tessellation = BrepDisplayTessellator.Tessellate(import.Value, options);
Assert.True(tessellation.IsSuccess);
var cylinderFace = Assert.Single(import.Value.Topology.Faces, face =>
{
Assert.True(import.Value.Bindings.TryGetFaceBinding(face.Id, out var binding));
Assert.True(import.Value.Geometry.TryGetSurface(binding.SurfaceGeometryId, out var surface));
return surface!.Kind == SurfaceGeometryKind.Cylinder;
});
var patch = Assert.Single(tessellation.Value.FacePatches, p => p.FaceId == cylinderFace.Id);
Assert.Equal(26, patch.Positions.Count);
Assert.Equal(26, patch.Normals.Count);
Assert.Equal(72, patch.TriangleIndices.Count);
const int rowWidth = 13;
const int axialRows = 2;
for (var row = 0; row < axialRows; row++)
{
var seamStart = patch.Positions[row * rowWidth];
var seamEnd = patch.Positions[(row * rowWidth) + (rowWidth - 1)];
Assert.True((seamStart - seamEnd).Length <= 1e-8d);
}
var cylinderSurface = import.Value.GetFaceSurface(cylinderFace.Id).Cylinder!.Value;
var axis = cylinderSurface.Axis.ToVector();
var sideAxials = patch.Positions
.Select(point => (point - cylinderSurface.Origin).Dot(axis))
.ToArray();
var sideVMin = sideAxials.Min();
var sideVMax = sideAxials.Max();
var capPlanes = import.Value.Topology.Faces
.Where(face => face.Id != cylinderFace.Id)
.Select(face => import.Value.GetFaceSurface(face.Id))
.Where(surface => surface.Kind == SurfaceGeometryKind.Plane)
.Select(surface => surface.Plane!.Value)
.ToArray();
Assert.Equal(2, capPlanes.Length);
var capAxials = capPlanes
.Select(plane => (plane.Origin - cylinderSurface.Origin).Dot(axis))
.OrderBy(v => v)
.ToArray();
Assert.True(double.Abs(capAxials[0] - sideVMin) <= 1e-8d);
Assert.True(double.Abs(capAxials[1] - sideVMax) <= 1e-8d);
Assert.All(patch.TriangleIndices, index => Assert.InRange(index, 0, patch.Positions.Count - 1));
for (var i = 0; i < patch.TriangleIndices.Count; i += 3)
{
var p0 = patch.Positions[patch.TriangleIndices[i]];
var p1 = patch.Positions[patch.TriangleIndices[i + 1]];
var p2 = patch.Positions[patch.TriangleIndices[i + 2]];
var area2 = (p1 - p0).Cross(p2 - p0).Length;
Assert.True(area2 > 1e-9d);
}
}
[Fact]
public void Step242_HandcraftedCylinderFixture_Tessellation_IsDeterministic()
{
var text = LoadFixture("testdata/step242/handcrafted/baseline/cylinder.step");
var import = Step242Importer.ImportBody(text);
Assert.True(import.IsSuccess);
var options = DisplayTessellationOptions.Create(double.Pi / 6d, 10d, minimumSegments: 12, maximumSegments: 12).Value;
var tessellationA = BrepDisplayTessellator.Tessellate(import.Value, options);
var tessellationB = BrepDisplayTessellator.Tessellate(import.Value, options);
Assert.True(tessellationA.IsSuccess);
Assert.True(tessellationB.IsSuccess);
var cylinderFace = Assert.Single(import.Value.Topology.Faces, face =>
{
Assert.True(import.Value.Bindings.TryGetFaceBinding(face.Id, out var binding));
Assert.True(import.Value.Geometry.TryGetSurface(binding.SurfaceGeometryId, out var surface));
return surface!.Kind == SurfaceGeometryKind.Cylinder;
});
var patchA = Assert.Single(tessellationA.Value.FacePatches, p => p.FaceId == cylinderFace.Id);
var patchB = Assert.Single(tessellationB.Value.FacePatches, p => p.FaceId == cylinderFace.Id);
Assert.True(patchA.Positions.SequenceEqual(patchB.Positions));
Assert.True(patchA.Normals.SequenceEqual(patchB.Normals));
Assert.True(patchA.TriangleIndices.SequenceEqual(patchB.TriangleIndices));
}
[Fact]
public void Step242_HandcraftedConeFixture_UsesThreeCoedgeSeamTopology_AndTessellates()
{
var text = LoadFixture("testdata/step242/handcrafted/baseline/cone.step");
var import = Step242Importer.ImportBody(text);
Assert.True(import.IsSuccess);
var coneFace = Assert.Single(import.Value.Topology.Faces, face =>
{
Assert.True(import.Value.Bindings.TryGetFaceBinding(face.Id, out var binding));
Assert.True(import.Value.Geometry.TryGetSurface(binding.SurfaceGeometryId, out var surface));
return surface!.Kind == SurfaceGeometryKind.Cone;
});
var baseFace = Assert.Single(import.Value.Topology.Faces, face =>
{
Assert.True(import.Value.Bindings.TryGetFaceBinding(face.Id, out var binding));
Assert.True(import.Value.Geometry.TryGetSurface(binding.SurfaceGeometryId, out var surface));
return surface!.Kind == SurfaceGeometryKind.Plane;
});
Assert.True(import.Value.Bindings.TryGetFaceBinding(baseFace.Id, out var baseFaceBinding));
Assert.True(import.Value.Geometry.TryGetSurface(baseFaceBinding.SurfaceGeometryId, out var baseFaceSurface));
var basePlane = baseFaceSurface!.Plane!.Value;
var loopIds = import.Value.GetLoopIds(coneFace.Id);
var loopId = Assert.Single(loopIds);
var coedges = import.Value.GetCoedgeIds(loopId)
.Select(id => import.Value.Topology.GetCoedge(id))
.ToArray();
Assert.Equal(3, coedges.Length);
Assert.Equal(2, coedges.Count(coedge => import.Value.GetEdgeCurve(coedge.EdgeId).Kind == CurveGeometryKind.Line3));
Assert.Equal(1, coedges.Count(coedge => import.Value.GetEdgeCurve(coedge.EdgeId).Kind == CurveGeometryKind.Circle3));
var seamUseCount = coedges.Count(coedge =>
{
var edge = import.Value.Topology.GetEdge(coedge.EdgeId);
return edge.StartVertexId == edge.EndVertexId;
});
Assert.Equal(1, seamUseCount);
var lineEdgeIds = coedges
.Where(coedge => import.Value.GetEdgeCurve(coedge.EdgeId).Kind == CurveGeometryKind.Line3)
.Select(coedge => coedge.EdgeId)
.Distinct()
.ToArray();
Assert.Single(lineEdgeIds);
var tessellationA = BrepDisplayTessellator.Tessellate(import.Value);
Assert.True(tessellationA.IsSuccess);
Assert.DoesNotContain(tessellationA.Diagnostics,
d => d.Message.Contains("four-coedge torus/revolved loop layouts", StringComparison.OrdinalIgnoreCase));
var tessellationB = BrepDisplayTessellator.Tessellate(import.Value);
Assert.True(tessellationB.IsSuccess);
var patchA = Assert.Single(tessellationA.Value.FacePatches, p => p.FaceId == coneFace.Id);
var patchB = Assert.Single(tessellationB.Value.FacePatches, p => p.FaceId == coneFace.Id);
Assert.Equal(patchA.Positions.Count, patchB.Positions.Count);
Assert.Equal(patchA.Normals.Count, patchB.Normals.Count);
Assert.Equal(patchA.TriangleIndices.Count, patchB.TriangleIndices.Count);
Assert.True(patchA.Positions.SequenceEqual(patchB.Positions));
Assert.True(patchA.Normals.SequenceEqual(patchB.Normals));
Assert.True(patchA.TriangleIndices.SequenceEqual(patchB.TriangleIndices));
var baseNormal = basePlane.Normal.ToVector();
var signedDistances = patchA.Positions
.Select(point => (point - basePlane.Origin).Dot(baseNormal))
.ToArray();
var minDistance = signedDistances.Min();
var maxDistance = signedDistances.Max();
Assert.True(minDistance >= -1e-8d || maxDistance <= 1e-8d);
Assert.True(signedDistances.Count(distance => double.Abs(distance) <= 1e-8d) >= 8);
}
[Fact]
public void Step242_NistFile_WithToroidalSurface_AdvancesPastToroidalBlocker()
{
var text = LoadFixture("testdata/step242/nist/FTC/nist_ftc_06_asme1_ap242-e2.stp");
var import = Step242Importer.ImportBody(text);
Assert.True(import.IsSuccess);
Assert.DoesNotContain(import.Diagnostics,
d => d.Message.Contains("TOROIDAL_SURFACE", StringComparison.OrdinalIgnoreCase));
var tessellation = BrepDisplayTessellator.Tessellate(import.Value);
Assert.True(tessellation.IsSuccess);
Assert.DoesNotContain(tessellation.Diagnostics,
d => d.Message.Contains("TOROIDAL_SURFACE", StringComparison.OrdinalIgnoreCase));
}
private static double NormalizeToZeroTwoPi(double angle)
{
var twoPi = 2d * double.Pi;
var normalized = angle % twoPi;
if (normalized < 0d)
{
normalized += twoPi;
}
return normalized;
}
private static string LoadFixture(string relativePath)
{
var path = Path.Combine(Step242CorpusManifestRunner.RepoRoot(), relativePath.Replace('/', Path.DirectorySeparatorChar));
return File.ReadAllText(path, Encoding.UTF8);
}
}