Skip to content

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.cs
index 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 BrepSurgeryRecipeParityTests
new 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.cs
new file mode 100644
index 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.cs
index 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 Step242OrientationSemanticsTests
Assert.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 Step242OrientationSemanticsTests
Assert.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.cs
new file mode 100644
index 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.cs
index 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 BrepDisplayTessellator
executionBudget?.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.cs
index 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 BrepMassProperties
var 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.cs
index 41a193fc..8943fc25 100644
--- a/Aetheris.Kernel.Core/Step242/Step242Exporter.cs
+++ b/Aetheris.Kernel.Core/Step242/Step242Exporter.cs
@@ -920,6 +920,9 @@ public static class Step242Exporter
var 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 Step242Exporter
lineIds[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.cs
index 12e417e4..98294f5b 100644
--- a/Aetheris.Kernel.Core/Step242/Step242Importer.cs
+++ b/Aetheris.Kernel.Core/Step242/Step242Importer.cs
@@ -1126,20 +1126,14 @@ public static class Step242Importer
return 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.json
index 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"
}
]