Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
Fix same sense.
Yuechen Li9b9d1ca70b97
diff --git a/Aetheris.Kernel.Core.Tests/Brep/Surgery/BrepSurgeryRecipeParityTests.cs b/Aetheris.Kernel.Core.Tests/Brep/Surgery/BrepSurgeryRecipeParityTests.csindex 6b287cf7..56e61300 100644--- a/Aetheris.Kernel.Core.Tests/Brep/Surgery/BrepSurgeryRecipeParityTests.cs+++ b/Aetheris.Kernel.Core.Tests/Brep/Surgery/BrepSurgeryRecipeParityTests.cs@@ -18,7 +18,7 @@ public sealed class BrepSurgeryRecipeParityTestsnew AxisAlignedBoxExtents(2d, 4d, 0d, 2d, 0d, 1d),]).Value;- AssertCanonical(body, 8, 12, 6, "39692ac0ea3c48d9f2f6fb1155e3b494c1b946bf56cd8dd2ade2c9005cd38048", expectClosedManifold: true);+ AssertCanonical(body, 8, 12, 6, "90cfba06396e6d4ad535585b50b18a7e1fdfae6adb36b7e5a127b40a59a5d496", expectClosedManifold: true);}[Fact]diff --git a/Aetheris.Kernel.Core.Tests/Brep/Tessellation/DisplayMeshOrientationCorpusTests.cs b/Aetheris.Kernel.Core.Tests/Brep/Tessellation/DisplayMeshOrientationCorpusTests.csnew file mode 100644index 00000000..a2583101--- /dev/null+++ b/Aetheris.Kernel.Core.Tests/Brep/Tessellation/DisplayMeshOrientationCorpusTests.cs@@ -0,0 +1,96 @@+using Aetheris.Kernel.Core.Brep;+using Aetheris.Kernel.Core.Brep.Tessellation;+using Aetheris.Kernel.Core.Math;+using Aetheris.Kernel.Core.Step242;+using Aetheris.Kernel.Core.Tests.Step242;++namespace Aetheris.Kernel.Core.Tests.Brep.Tessellation;++/// <summary>+/// A display mesh of a closed solid has to be outward-oriented as a whole, not per face. The cheapest total check is+/// the divergence theorem: summing the signed tetrahedron volume of every triangle gives the part's volume when the+/// winding is consistently outward, and gives nonsense - frequently a negative number - when it is not.+/// <para>+/// This is worth pinning because it was false for years without anything noticing. Face sense was projected nowhere,+/// so each face carried whatever its own parameterization produced, and the corpus came out negative on seven files+/// of seventeen. Planes looked right only because import folded the sense into the plane support itself, which made+/// them the one kind every consumer had to special-case.+/// </para>+/// </summary>+public sealed class DisplayMeshOrientationCorpusTests+{+ public static TheoryData<string> ClosedBrepFiles => new()+ {+ "testdata/step242/nist/CTC/nist_ctc_01_asme1_ap242-e1.stp",+ "testdata/step242/nist/CTC/nist_ctc_02_asme1_ap242-e2.stp",+ "testdata/step242/nist/CTC/nist_ctc_03_asme1_ap242-e2.stp",+ "testdata/step242/nist/CTC/nist_ctc_04_asme1_ap242-e1.stp",+ "testdata/step242/nist/CTC/nist_ctc_05_asme1_ap242-e1.stp",+ "testdata/step242/nist/FTC/nist_ftc_06_asme1_ap242-e2.stp",+ "testdata/step242/nist/FTC/nist_ftc_07_asme1_ap242-e2.stp",+ "testdata/step242/nist/FTC/nist_ftc_08_asme1_ap242-e2.stp",+ "testdata/step242/nist/FTC/nist_ftc_09_asme1_ap242-e1.stp",+ "testdata/step242/nist/FTC/nist_ftc_10_asme1_ap242-e2.stp",+ "testdata/step242/nist/FTC/nist_ftc_11_asme1_ap242-e2.stp",+ "testdata/step242/nist/STC/nist_stc_06_asme1_ap242-e3.stp",+ "testdata/step242/nist/STC/nist_stc_07_asme1_ap242-e3.stp",+ "testdata/step242/nist/STC/nist_stc_08_asme1_ap242-e3.stp",+ "testdata/step242/nist/STC/nist_stc_09_asme1_ap242-e3.stp",+ "testdata/step242/nist/STC/nist_stc_10_asme1_ap242-e2.stp",+ };++ [Theory]+ [MemberData(nameof(ClosedBrepFiles))]+ public void DisplayMesh_OfAClosedBody_IsOutwardOriented(string relativePath)+ {+ var import = Step242Importer.ImportBody(ReadFixture(relativePath));+ Assert.True(import.IsSuccess);++ var (windingVolume, normalVolume) = MeasureVolumes(import.Value);++ Assert.True(windingVolume > 0d, $"triangle winding encloses a negative volume ({windingVolume:G6}), so the mesh is not outward-oriented");+ // Winding and stored normals are two independent statements of the same orientation; they have to agree.+ Assert.True(+ double.Abs(windingVolume - normalVolume) <= 0.02d * windingVolume,+ $"winding volume {windingVolume:G6} and stored-normal volume {normalVolume:G6} disagree");+ }++ private static (double WindingVolume, double NormalVolume) MeasureVolumes(BrepBody body)+ {+ var display = DisplayPreparationFallbackBuilder.Build(body, null);+ Assert.True(display.IsSuccess);++ var windingVolume = 0d;+ var normalVolume = 0d;+ foreach (var patch in display.Value.FacePatches)+ {+ for (var index = 0; index + 2 < patch.TriangleIndices.Count; index += 3)+ {+ var a = patch.Positions[patch.TriangleIndices[index]];+ var b = patch.Positions[patch.TriangleIndices[index + 1]];+ var c = patch.Positions[patch.TriangleIndices[index + 2]];+ var va = a - Point3D.Origin;+ var vb = b - Point3D.Origin;+ var vc = c - Point3D.Origin;+ windingVolume += va.Cross(vb).Dot(vc) / 6d;++ var area = (b - a).Cross(c - a).Length / 2d;+ var summed = patch.Normals[patch.TriangleIndices[index]]+ + patch.Normals[patch.TriangleIndices[index + 1]]+ + patch.Normals[patch.TriangleIndices[index + 2]];+ if (!summed.TryNormalize(out var normal))+ {+ continue;+ }++ var centroid = new Vector3D((a.X + b.X + c.X) / 3d, (a.Y + b.Y + c.Y) / 3d, (a.Z + b.Z + c.Z) / 3d);+ normalVolume += centroid.Dot(normal) * area / 3d;+ }+ }++ return (windingVolume, normalVolume);+ }++ private static string ReadFixture(string relativePath)+ => File.ReadAllText(Path.Combine(Step242CorpusManifestRunner.RepoRoot(), relativePath.Replace('/', Path.DirectorySeparatorChar)));+}diff --git a/Aetheris.Kernel.Core.Tests/Step242/Step242OrientationSemanticsTests.cs b/Aetheris.Kernel.Core.Tests/Step242/Step242OrientationSemanticsTests.csindex 9376d8e3..50e449b1 100644--- a/Aetheris.Kernel.Core.Tests/Step242/Step242OrientationSemanticsTests.cs+++ b/Aetheris.Kernel.Core.Tests/Step242/Step242OrientationSemanticsTests.cs@@ -33,8 +33,13 @@ public sealed class Step242OrientationSemanticsTestsAssert.Equal(forwardCoedge.IsReversed, reversedCoedge.IsReversed);}+ /// <summary>+ /// ADVANCED_FACE.same_sense is carried by the face binding, never folded into the stored support. Folding it in+ /// for planes alone made them the one kind a consumer had to special-case, and inverted their normal on every+ /// export/import cycle.+ /// </summary>[Fact]- public void ImportBody_AdvancedFaceSameSenseFalse_FlipsPlaneNormal()+ public void ImportBody_AdvancedFaceSameSenseFalse_KeepsTheStatedPlane_AndRecordsTheSenseOnTheBinding(){var forward = Step242Importer.ImportBody(BuildSingleTriangleStep(edgeCurveSameSense: true, faceBoundOrientation: true, advancedFaceSameSense: true));var reversed = Step242Importer.ImportBody(BuildSingleTriangleStep(edgeCurveSameSense: true, faceBoundOrientation: true, advancedFaceSameSense: false));@@ -49,7 +54,9 @@ public sealed class Step242OrientationSemanticsTestsAssert.True(reversed.Value.TryGetFaceSurfaceGeometry(reversedFace.Id, out var reversedSurface));Assert.Equal(1d, forwardSurface!.Plane!.Value.Normal.Z);- Assert.Equal(-1d, reversedSurface!.Plane!.Value.Normal.Z);+ Assert.Equal(1d, reversedSurface!.Plane!.Value.Normal.Z);+ Assert.True(forward.Value.Bindings.GetFaceBinding(forwardFace.Id).SameSense);+ Assert.False(reversed.Value.Bindings.GetFaceBinding(reversedFace.Id).SameSense);}[Fact]diff --git a/Aetheris.Kernel.Core.Tests/Step242/Step242RoundTripCorpusTests.cs b/Aetheris.Kernel.Core.Tests/Step242/Step242RoundTripCorpusTests.csnew file mode 100644index 00000000..8805e224--- /dev/null+++ b/Aetheris.Kernel.Core.Tests/Step242/Step242RoundTripCorpusTests.cs@@ -0,0 +1,84 @@+using Aetheris.Kernel.Core.Brep;+using Aetheris.Kernel.Core.Brep.Tessellation;+using Aetheris.Kernel.Core.Math;+using Aetheris.Kernel.Core.Step242;++namespace Aetheris.Kernel.Core.Tests.Step242;++/// <summary>+/// An Aetheris export has to be readable by Aetheris. That sounds tautological, and it was false: the exporter+/// rebuilt every LINE from its endpoints, so the emitted curve ran start-vertex to end-vertex by construction, and+/// then wrote the stored EDGE_CURVE.same_sense anyway. On the edges where that flag said otherwise, a reader walked+/// the edge backwards and the loop's consecutive coedges landed an edge-length apart.+/// <para>+/// Face and edge counts alone would not have caught it - the topology survives - so the volume of the display mesh+/// is compared too: a loop walked backwards changes the shape, not the counts.+/// </para>+/// </summary>+public sealed class Step242RoundTripCorpusTests+{+ public static TheoryData<string> CorpusFiles+ {+ get+ {+ var data = new TheoryData<string>();+ foreach (var path in Directory+ .EnumerateFiles(Path.Combine(Step242CorpusManifestRunner.RepoRoot(), "testdata", "step242", "nist"), "*.stp", SearchOption.AllDirectories)+ .OrderBy(path => path, StringComparer.Ordinal))+ {+ data.Add(Path.GetFileName(path));+ }++ return data;+ }+ }++ [Theory]+ [MemberData(nameof(CorpusFiles))]+ public void ExportedBody_IsReadableByAetheris_AndKeepsItsShape(string fileName)+ {+ var source = Step242Importer.ImportBody(ReadCorpusFile(fileName));+ Assert.True(source.IsSuccess, string.Join(" | ", source.Diagnostics.Select(diagnostic => diagnostic.Message)));++ var exported = Step242Exporter.ExportBody(source.Value);+ Assert.True(exported.IsSuccess, string.Join(" | ", exported.Diagnostics.Select(diagnostic => diagnostic.Message)));++ var reimported = Step242Importer.ImportBody(exported.Value);+ Assert.True(reimported.IsSuccess, string.Join(" | ", reimported.Diagnostics.Select(diagnostic => diagnostic.Message)));++ Assert.Equal(source.Value.Topology.Faces.Count(), reimported.Value.Topology.Faces.Count());+ Assert.Equal(source.Value.Topology.Edges.Count(), reimported.Value.Topology.Edges.Count());++ var before = EnclosedVolume(source.Value);+ var after = EnclosedVolume(reimported.Value);+ Assert.True(+ double.Abs(after - before) <= 0.01d * double.Max(double.Abs(before), 1d),+ $"round trip changed the enclosed volume from {before:G6} to {after:G6}");+ }++ /// <summary>Signed volume of the display mesh, which changes if any loop is walked in the wrong direction.</summary>+ private static double EnclosedVolume(BrepBody body)+ {+ var display = DisplayPreparationFallbackBuilder.Build(body, null);+ Assert.True(display.IsSuccess);++ var volume = 0d;+ foreach (var patch in display.Value.FacePatches)+ {+ for (var index = 0; index + 2 < patch.TriangleIndices.Count; index += 3)+ {+ var a = patch.Positions[patch.TriangleIndices[index]] - Point3D.Origin;+ var b = patch.Positions[patch.TriangleIndices[index + 1]] - Point3D.Origin;+ var c = patch.Positions[patch.TriangleIndices[index + 2]] - Point3D.Origin;+ volume += a.Cross(b).Dot(c) / 6d;+ }+ }++ return volume;+ }++ private static string ReadCorpusFile(string fileName)+ => File.ReadAllText(Directory+ .EnumerateFiles(Path.Combine(Step242CorpusManifestRunner.RepoRoot(), "testdata", "step242", "nist"), fileName, SearchOption.AllDirectories)+ .Single());+}diff --git a/Aetheris.Kernel.Core/Brep/Tessellation/BrepDisplayTessellator.cs b/Aetheris.Kernel.Core/Brep/Tessellation/BrepDisplayTessellator.csindex dca42ed7..c5cc1130 100644--- a/Aetheris.Kernel.Core/Brep/Tessellation/BrepDisplayTessellator.cs+++ b/Aetheris.Kernel.Core/Brep/Tessellation/BrepDisplayTessellator.cs@@ -255,6 +255,17 @@ public static class BrepDisplayTessellatorexecutionBudget?.ThrowIfExpired("FaceSurfaceDispatch", faceId, surface.Kind);+ // Every surface kind is tessellated in its own parameterization, whose normal is the support's, not the+ // face's. Projecting the face sense here - once, at the only place face patches are produced - is what makes+ // a body's display mesh consistently outward-oriented instead of per-face arbitrary.+ var patch = TessellateFaceSupport(body, faceId, surface, options, executionBudget);+ return patch.IsSuccess+ ? KernelResult<DisplayFaceMeshPatch>.Success(DisplayMeshOrientation.Orient(body, patch.Value), patch.Diagnostics)+ : patch;+ }++ private static KernelResult<DisplayFaceMeshPatch> TessellateFaceSupport(BrepBody body, FaceId faceId, SurfaceGeometry surface, DisplayTessellationOptions options, DisplayTessellationExecutionBudget? executionBudget)+ {return surface.Kind switch{SurfaceGeometryKind.Plane => TessellatePlanarFace(body, faceId, surface.Plane!.Value, options, executionBudget),diff --git a/Aetheris.Kernel.Core/Brep/Verification/BrepMassProperties.cs b/Aetheris.Kernel.Core/Brep/Verification/BrepMassProperties.csindex 9271b699..265247d3 100644--- a/Aetheris.Kernel.Core/Brep/Verification/BrepMassProperties.cs+++ b/Aetheris.Kernel.Core/Brep/Verification/BrepMassProperties.cs@@ -752,15 +752,10 @@ public static class BrepMassPropertiesvar b = patch.Positions[patch.TriangleIndices[i + 1]];var c = patch.Positions[patch.TriangleIndices[i + 2]];var cross = (b - a).Cross(c - a);- // STEP import normalizes planar ADVANCED_FACE same_sense by- // reversing the decoded PlaneSurface itself. Applying the binding- // flag a second time would invert an equivalent imported plane;- // canonical producer plans therefore use material-facing plane- // supports. Curved grid patches retain native parameter normals and- // require their explicit SameSense binding here.+ // Display patches arrive already oriented to the face: the tessellator projects the face sense once,+ // for every surface kind. This used to apply the binding flag here and exempt planes, because import+ // folded the flag into the plane support itself; both halves of that workaround are gone.var normal = patch.Normals[patch.TriangleIndices[i]] + patch.Normals[patch.TriangleIndices[i + 1]] + patch.Normals[patch.TriangleIndices[i + 2]];- var isPlanar = body.TryGetFaceSurfaceGeometry(patch.FaceId, out var surfaceForSense) && surfaceForSense?.Kind == SurfaceGeometryKind.Plane;- if (!isPlanar && !binding.SameSense) normal = -normal;if (cross.Dot(normal) < 0d){(b, c) = (c, b);diff --git a/Aetheris.Kernel.Core/Step242/Step242Exporter.cs b/Aetheris.Kernel.Core/Step242/Step242Exporter.csindex 41a193fc..8943fc25 100644--- a/Aetheris.Kernel.Core/Step242/Step242Exporter.cs+++ b/Aetheris.Kernel.Core/Step242/Step242Exporter.cs@@ -920,6 +920,9 @@ public static class Step242Exportervar endVertexId = EnsureVertex(writer, edge.EndVertexId, endPoint, vertexPoints, cartesianPointIds, vertexPointIds);string geometryCurveId;+ // EDGE_CURVE.same_sense relates the curve that is actually written to the vertex order that is actually+ // written. Most kinds are emitted exactly as stored, so the stored flag still describes them; a line is not.+ var emittedSameSense = edgeBinding.OrientedEdgeSense;if (curve.Kind == CurveGeometryKind.Line3 && curve.Line3 is Line3Curve line){if (!lineIds.TryGetValue(edgeId, out var lineId))@@ -948,6 +951,13 @@ public static class Step242ExporterlineIds[edgeId] = lineId;}+ // The line above is rebuilt from the endpoints: it starts at the start vertex and runs towards the end+ // vertex, in both branches, because the stored direction is kept only when it already agrees. So the+ // emitted curve agrees with the vertex order by construction, whatever the stored flag said. Writing the+ // stored flag here told a reader that a curve running start-to-end actually ran end-to-start, and the+ // reader then walked those edges backwards - which is what made a re-imported loop's consecutive coedges+ // land an edge-length apart.+ emittedSameSense = true;geometryCurveId = lineId;}else if (curve.Kind == CurveGeometryKind.Circle3 && curve.Circle3 is Circle3Curve circle)@@ -1058,7 +1068,7 @@ public static class Step242Exporter// direction is opposite the edge's authored start/end vertices. Writing// .T. here inverted that relation for downstream CAD, so cylindrical// faces at reflex arcs were trimmed through the complementary sweep.- var edgeCurveId = writer.AddEntity("EDGE_CURVE", "$", Step242TextWriter.Ref(startVertexId), Step242TextWriter.Ref(endVertexId), Step242TextWriter.Ref(geometryCurveId), Step242TextWriter.BooleanLogical(edgeBinding.OrientedEdgeSense));+ var edgeCurveId = writer.AddEntity("EDGE_CURVE", "$", Step242TextWriter.Ref(startVertexId), Step242TextWriter.Ref(endVertexId), Step242TextWriter.Ref(geometryCurveId), Step242TextWriter.BooleanLogical(emittedSameSense));return KernelResult<string>.Success(edgeCurveId);}diff --git a/Aetheris.Kernel.Core/Step242/Step242Importer.cs b/Aetheris.Kernel.Core/Step242/Step242Importer.csindex 12e417e4..98294f5b 100644--- a/Aetheris.Kernel.Core/Step242/Step242Importer.cs+++ b/Aetheris.Kernel.Core/Step242/Step242Importer.cs@@ -1126,20 +1126,14 @@ public static class Step242Importerreturn KernelResult<(SurfaceGeometryId SurfaceGeometryId, SurfaceGeometry SurfaceGeometry)>.Failure(planeResult.Diagnostics);}- var faceSurface = planeResult.Value;- if (!faceSameSense)- {- if (!Direction3D.TryCreate(-faceSurface.Normal.ToVector(), out var reversedNormal))- {- return OrientationFailure<(SurfaceGeometryId SurfaceGeometryId, SurfaceGeometry SurfaceGeometry)>(- "ADVANCED_FACE same_sense not supported for this face",- SourceFor(surfaceToDecode.Id, "Importer.Orientation.AdvancedFaceSense"));- }-- faceSurface = new PlaneSurface(faceSurface.Origin, reversedNormal, faceSurface.UAxis);- }-- return KernelResult<(SurfaceGeometryId SurfaceGeometryId, SurfaceGeometry SurfaceGeometry)>.Success((geometryId, SurfaceGeometry.FromPlane(faceSurface)));+ // ADVANCED_FACE.same_sense is not folded into the stored surface. It used to be, for planes only, which+ // made planes the one surface kind whose stored normal already carried the face sense while the binding+ // recorded it as well - so every consumer that honoured the binding flipped a plane twice, and a plane+ // face with same_sense=.F. inverted its normal on every export/import cycle. The stored surface is now+ // exactly what the file stated for every kind, and FaceGeometryBinding.SameSense is the only carrier of+ // face orientation. It cannot be the other way round: a cylinder normal cannot be negated without+ // flipping its axis, which would change the parameterization the trim intervals are written against.+ return KernelResult<(SurfaceGeometryId SurfaceGeometryId, SurfaceGeometry SurfaceGeometry)>.Success((geometryId, SurfaceGeometry.FromPlane(planeResult.Value)));}if (string.Equals(normalizedName, "CYLINDRICAL_SURFACE", StringComparison.Ordinal))diff --git a/testdata/step242/manifests/nist.v0.report.json b/testdata/step242/manifests/nist.v0.report.jsonindex 834065b1..a067f8b2 100644--- a/testdata/step242/manifests/nist.v0.report.json+++ b/testdata/step242/manifests/nist.v0.report.json@@ -77,7 +77,7 @@"edges": 1110,"faces": 484},- "canonicalSha256": "03de90f4b8e871a99fef440f93209d51acb78db36861c5d883dcc64f721d5794"+ "canonicalSha256": "b1e589dfefb511aced044ed7d0baf7cca95662a55771841b30ad5473702871d8"},{"fileId": "testdata_step242_nist_CTC_nist_ctc_05_asme1_ap242-e1",@@ -137,7 +137,7 @@"edges": 871,"faces": 306},- "canonicalSha256": "8d8fb42d6a9cbd874509dcdc71b3ed4579fe26240c8298874e5b7bebb138953b"+ "canonicalSha256": "647501aefa5266d177d4fb0f5dfb8dcc27ae4088fcb3535861373ffe1d5d86f8"},{"fileId": "testdata_step242_nist_FTC_nist_ftc_08_asme1_ap242-e1-tg",@@ -177,7 +177,7 @@"edges": 616,"faces": 247},- "canonicalSha256": "9c816376544b3555f98e0f1885285d73a27364148e54e4ee2e3d90457f7c1893"+ "canonicalSha256": "c4d4ac0e23e63b25ef56a63e1e0998d2ddfc3ffe90ba84b3629dc8a6fbee589f"},{"fileId": "testdata_step242_nist_FTC_nist_ftc_09_asme1_ap242-e1",@@ -197,7 +197,7 @@"edges": 458,"faces": 159},- "canonicalSha256": "641f443e67ea542042d4d7c592eef6106a0c8f31de6cb7f27fb7c80cba5afb19"+ "canonicalSha256": "cda7b5c424f4e6273620770d197c21cb0984d8172ff979a43d2d5cf1fa8facb3"},{"fileId": "testdata_step242_nist_FTC_nist_ftc_10_asme1_ap242-e2",@@ -217,7 +217,7 @@"edges": 813,"faces": 268},- "canonicalSha256": "7e36acd8fc0af5982d8840227bb6e7b4e018bd28bf091174bd7764fbc90f620d"+ "canonicalSha256": "48555040f7a76175729ba8cbdaebc258d8e78d77423305548a2e8821579a9ae1"},{"fileId": "testdata_step242_nist_FTC_nist_ftc_11_asme1_ap242-e2",@@ -237,7 +237,7 @@"edges": 104,"faces": 42},- "canonicalSha256": "689c291ea03f06c435a311016ad1a26cdde07d3bd444188a1a8646c7cb75da2a"+ "canonicalSha256": "a90e0b92aeedf89bbcaac0a3f585f34f1027e39a7405c0085ace7bd23d167681"},{"fileId": "testdata_step242_nist_STC_nist_stc_06_asme1_ap242-e3",@@ -257,7 +257,7 @@"edges": 310,"faces": 144},- "canonicalSha256": "e509bc6b93ac2b84dec4eaee851ff275b0173ca412170eab2312450ca749a513"+ "canonicalSha256": "780c836ee73b5ea5ccb83b2c6cf63e0166fe7a71de823471ccce0c3d552c5286"},{"fileId": "testdata_step242_nist_STC_nist_stc_07_asme1_ap242-e3",@@ -277,7 +277,7 @@"edges": 871,"faces": 306},- "canonicalSha256": "07ebd127a871a8d36ef34b153ee2435cdaf5031463c1eb36ce42fa5d40b5ba6c"+ "canonicalSha256": "1d504dba84b2ba2f7ecf5e67c058024447e194a4ddfecb9f0ad96814945a6458"},{"fileId": "testdata_step242_nist_STC_nist_stc_08_asme1_ap242-e3",@@ -317,7 +317,7 @@"edges": 392,"faces": 125},- "canonicalSha256": "ba2caabdb9ce89cea76a8789f45fbede49396f281a01301be6aa7076a84e473a"+ "canonicalSha256": "b6a0ecae8067ca806465a5774f8baf3281deec32506d663d28d70c10a9d0db84"},{"fileId": "testdata_step242_nist_STC_nist_stc_10_asme1_ap242-e2",@@ -337,6 +337,6 @@"edges": 551,"faces": 256},- "canonicalSha256": "7117d051431956f4e59f67c2ea95075e87b5bad28f1d0a7136d3a8b74ec135d0"+ "canonicalSha256": "873f87c65323ffd8e1c0258b9e3d47780935e655461a8498c9c6bb78d9ca25ad"}]