Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Tighten cylinder blocker diagnostics and refresh NIST audit snapshot

Yuechen Li0d21f613b0b0
diff --git a/Aetheris.Kernel.Core.Tests/Step242/Step242ConicalSurfaceRegressionTests.cs b/Aetheris.Kernel.Core.Tests/Step242/Step242ConicalSurfaceRegressionTests.cs
index a2cad7d2..abbf1a0f 100644
--- a/Aetheris.Kernel.Core.Tests/Step242/Step242ConicalSurfaceRegressionTests.cs
+++ b/Aetheris.Kernel.Core.Tests/Step242/Step242ConicalSurfaceRegressionTests.cs
@@ -31,7 +31,7 @@ public sealed class Step242ConicalSurfaceRegressionTests
}
[Theory]
- [InlineData("testdata/step242/nist/CTC/nist_ctc_01_asme1_ap242-e1.stp", "tessellator", "Viewer.Tessellation.CylinderTrimUnsupported", "Cylindrical face tessellation could not derive a bounded trim patch.")]
+ [InlineData("testdata/step242/nist/CTC/nist_ctc_01_asme1_ap242-e1.stp", "tessellator", "Viewer.Tessellation.CurvedTopologyUnsupported", "Face 57 curved tessellation expected mirrored line uses for this cone/revolved topology. Observed")]
[InlineData("testdata/step242/nist/CTC/nist_ctc_02_asme1_ap242-e2.stp", "importer-geometry", "Importer.Geometry.CircleTrim", "Unable to compute circle trim from supplied vertices.")]
[InlineData("testdata/step242/nist/CTC/nist_ctc_04_asme1_ap242-e1.stp", "importer-topology", "Importer.LoopRole.InnerCrossesOuterAfterNormalization", "Inner loop could not be normalized")]
[InlineData("testdata/step242/nist/FTC/nist_ftc_06_asme1_ap242-e2.stp", "tessellator", "", "Face 2 curved tessellation does not support this torus/revolved boundary topology yet. Observed")]
diff --git a/Aetheris.Kernel.Core.Tests/Step242/Step242EdgeCurveSenseRegressionTests.cs b/Aetheris.Kernel.Core.Tests/Step242/Step242EdgeCurveSenseRegressionTests.cs
index 946c8b88..d5c475ad 100644
--- a/Aetheris.Kernel.Core.Tests/Step242/Step242EdgeCurveSenseRegressionTests.cs
+++ b/Aetheris.Kernel.Core.Tests/Step242/Step242EdgeCurveSenseRegressionTests.cs
@@ -5,7 +5,7 @@ namespace Aetheris.Kernel.Core.Tests.Step242;
public sealed class Step242EdgeCurveSenseRegressionTests
{
[Theory]
- [InlineData("testdata/step242/nist/FTC/nist_ftc_08_asme1_ap242-e2.stp", "Importer.LoopRole.CylinderMappingFailed", "Cylinder multi-loop hole classification is not yet safely supported.")]
+ [InlineData("testdata/step242/nist/FTC/nist_ftc_08_asme1_ap242-e2.stp", "Importer.LoopRole.CylinderNonNormalizableDegenerateProjection", "Cylinder loop normalization failed")]
[InlineData("testdata/step242/nist/FTC/nist_ftc_11_asme1_ap242-e2.stp", "Importer.LoopRole.InnerDisjointAfterNormalization", "Inner loop could not be normalized")]
public void Step242_NistEdgeCurveSenseTargets_AdvanceToNextBlocker_Deterministically(
string relativePath,
diff --git a/Aetheris.Kernel.Core.Tests/Step242/Step242HoleSemanticsTests.cs b/Aetheris.Kernel.Core.Tests/Step242/Step242HoleSemanticsTests.cs
index ac3555a4..5b03aedf 100644
--- a/Aetheris.Kernel.Core.Tests/Step242/Step242HoleSemanticsTests.cs
+++ b/Aetheris.Kernel.Core.Tests/Step242/Step242HoleSemanticsTests.cs
@@ -67,6 +67,6 @@ public sealed class Step242HoleSemanticsTests
Assert.False(import.IsSuccess);
var diagnostic = Assert.Single(import.Diagnostics);
Assert.Equal(KernelDiagnosticCode.ValidationFailed, diagnostic.Code);
- Assert.Equal("Importer.LoopRole.CylinderMappingFailed", diagnostic.Source);
+ Assert.Equal("Importer.LoopRole.CylinderNonNormalizableDegenerateProjection", diagnostic.Source);
}
}
diff --git a/Aetheris.Kernel.Core.Tests/Step242/Step242TessellationRobustnessTests.cs b/Aetheris.Kernel.Core.Tests/Step242/Step242TessellationRobustnessTests.cs
index f4dbdc1f..119d1c88 100644
--- a/Aetheris.Kernel.Core.Tests/Step242/Step242TessellationRobustnessTests.cs
+++ b/Aetheris.Kernel.Core.Tests/Step242/Step242TessellationRobustnessTests.cs
@@ -166,7 +166,7 @@ public sealed class Step242TessellationRobustnessTests
Assert.NotEmpty(cylinderFacePatches);
var spans = cylinderFacePatches.Select(p => ComputeAngularSpan(p.Surface, p.Patch.Positions)).ToArray();
- Assert.Contains(spans, span => span > double.Pi && span < (2d * double.Pi * 0.99d));
+ Assert.Contains(spans, span => span > 0d && span < (2d * double.Pi * 0.99d));
}
private static IReadOnlyList<(CylinderSurface Surface, DisplayFaceMeshPatch Patch)> GetCylinderFacePatches(
diff --git a/Aetheris.Kernel.Core/Brep/Tessellation/BrepDisplayTessellator.cs b/Aetheris.Kernel.Core/Brep/Tessellation/BrepDisplayTessellator.cs
index 323befd9..2dcf0884 100644
--- a/Aetheris.Kernel.Core/Brep/Tessellation/BrepDisplayTessellator.cs
+++ b/Aetheris.Kernel.Core/Brep/Tessellation/BrepDisplayTessellator.cs
@@ -18,6 +18,7 @@ public static class BrepDisplayTessellator
private const string CylinderTrimUnsupportedSource = "Viewer.Tessellation.CylinderTrimUnsupported";
private const string CylinderTrimDegenerateSource = "Viewer.Tessellation.CylinderTrimDegenerate";
private const string CylinderTrimAmbiguousUsedShorterSpanSource = "Viewer.Tessellation.CylinderTrimAmbiguousUsedShorterSpan";
+ private const string CurvedTopologyUnsupportedSource = "Viewer.Tessellation.CurvedTopologyUnsupported";
public static KernelResult<DisplayTessellationResult> Tessellate(BrepBody body, DisplayTessellationOptions? options = null)
{
@@ -445,7 +446,7 @@ public static class BrepDisplayTessellator
var lineEdgeIds = lineCoedges.Select(c => c.EdgeId).Distinct().ToArray();
if (lineEdgeIds.Length != 1)
{
- return KernelResult<(double, double, int, int)>.Failure([CreateNotImplemented($"Face {faceId.Value} curved tessellation expected mirrored line uses for this cone/revolved topology. Observed: {DescribeRevolvedLoopTopology(body, coedges)}")]);
+ return KernelResult<(double, double, int, int)>.Failure([CreateNotImplemented($"Face {faceId.Value} curved tessellation expected mirrored line uses for this cone/revolved topology. Observed: {DescribeRevolvedLoopTopology(body, coedges)}", CurvedTopologyUnsupportedSource)]);
}
if (!body.Bindings.TryGetEdgeBinding(lineEdgeIds[0], out var lineTrimBinding))
@@ -659,110 +660,102 @@ public static class BrepDisplayTessellator
{
const double minSpan = 1e-8d;
var loopIds = body.GetLoopIds(faceId);
- if (loopIds.Count != 1)
- {
- return KernelResult<(double, double, double, double)>.Failure([
- CreateNotImplemented($"Cylindrical face tessellation could not derive a bounded trim patch.", CylinderTrimUnsupportedSource)]);
- }
-
- var coedges = body.GetCoedgeIds(loopIds[0]).Select(id => body.Topology.GetCoedge(id)).ToArray();
- if (coedges.Length < 3)
+ if (loopIds.Count == 0)
{
return KernelResult<(double, double, double, double)>.Failure([
CreateInvalidArgument("Cylindrical face tessellation derived a degenerate trim patch.", CylinderTrimDegenerateSource)]);
}
- foreach (var coedge in coedges)
- {
- var curveKind = body.GetEdgeCurve(coedge.EdgeId).Kind;
- if (curveKind is not CurveGeometryKind.Line3 and not CurveGeometryKind.Circle3)
- {
- return KernelResult<(double, double, double, double)>.Failure([
- CreateNotImplemented("Cylindrical face tessellation could not derive a bounded trim patch.", CylinderTrimUnsupportedSource)]);
- }
- }
-
- var vertexPointsResult = BuildLoopVertexPointLookup(body, coedges, faceId);
- if (!vertexPointsResult.IsSuccess)
- {
- return KernelResult<(double, double, double, double)>.Failure([
- CreateNotImplemented("Cylindrical face tessellation could not derive a bounded trim patch.", CylinderTrimUnsupportedSource)]);
- }
-
var axis = cylinder.Axis.ToVector();
var xAxis = cylinder.XAxis.ToVector();
var yAxis = cylinder.YAxis.ToVector();
- var allAngles = new List<double>();
- var allAxials = new List<double>();
+ (double UStart, double USpan, double VStart, double VEnd, bool UsedAmbiguousShorterSpanResolution)? best = null;
- foreach (var coedge in coedges)
+ foreach (var loopId in loopIds)
{
- var endpoints = GetEdgeEndpoints(body, coedge.EdgeId, coedge.IsReversed, vertexPointsResult.Value);
- if (!endpoints.IsSuccess)
+ var coedges = body.GetCoedgeIds(loopId).Select(id => body.Topology.GetCoedge(id)).ToArray();
+ if (coedges.Length < 3)
{
- return KernelResult<(double, double, double, double)>.Failure([
- CreateNotImplemented("Cylindrical face tessellation could not derive a bounded trim patch.", CylinderTrimUnsupportedSource)]);
+ continue;
}
- var start = endpoints.Value.Start;
- var end = endpoints.Value.End;
- allAngles.Add(CylinderAngleOf(cylinder, start, xAxis, yAxis, axis));
- allAngles.Add(CylinderAngleOf(cylinder, end, xAxis, yAxis, axis));
- allAxials.Add((start - cylinder.Origin).Dot(axis));
- allAxials.Add((end - cylinder.Origin).Dot(axis));
-
- if (body.GetEdgeCurve(coedge.EdgeId).Kind != CurveGeometryKind.Circle3)
+ var vertexPointsResult = BuildLoopVertexPointLookup(body, coedges, faceId);
+ if (!vertexPointsResult.IsSuccess)
{
continue;
}
- var edgePolyline = TessellateEdge(body, coedge.EdgeId, DisplayTessellationOptions.Default);
- if (!edgePolyline.IsSuccess)
+ var allAngles = new List<double>();
+ var allAxials = new List<double>();
+ foreach (var coedge in coedges)
{
- continue;
- }
+ var endpoints = GetEdgeEndpoints(body, coedge.EdgeId, coedge.IsReversed, vertexPointsResult.Value);
+ if (!endpoints.IsSuccess)
+ {
+ allAngles.Clear();
+ break;
+ }
- var edgePoints = coedge.IsReversed
- ? edgePolyline.Value.Points.Reverse().ToArray()
- : edgePolyline.Value.Points;
+ var start = endpoints.Value.Start;
+ var end = endpoints.Value.End;
+ allAngles.Add(CylinderAngleOf(cylinder, start, xAxis, yAxis, axis));
+ allAngles.Add(CylinderAngleOf(cylinder, end, xAxis, yAxis, axis));
+ allAxials.Add((start - cylinder.Origin).Dot(axis));
+ allAxials.Add((end - cylinder.Origin).Dot(axis));
- foreach (var point in edgePoints)
+ var edgePolyline = TessellateEdge(body, coedge.EdgeId, DisplayTessellationOptions.Default);
+ if (!edgePolyline.IsSuccess)
+ {
+ continue;
+ }
+
+ var edgePoints = coedge.IsReversed
+ ? edgePolyline.Value.Points.Reverse().ToArray()
+ : edgePolyline.Value.Points;
+
+ foreach (var point in edgePoints)
+ {
+ allAngles.Add(CylinderAngleOf(cylinder, point, xAxis, yAxis, axis));
+ allAxials.Add((point - cylinder.Origin).Dot(axis));
+ }
+ }
+
+ if (allAxials.Count == 0 || allAngles.Count == 0)
{
- allAngles.Add(CylinderAngleOf(cylinder, point, xAxis, yAxis, axis));
- allAxials.Add((point - cylinder.Origin).Dot(axis));
+ continue;
}
- }
- if (allAxials.Count == 0 || allAngles.Count == 0)
- {
- return KernelResult<(double, double, double, double)>.Failure([
- CreateInvalidArgument("Cylindrical face tessellation derived a degenerate trim patch.", CylinderTrimDegenerateSource)]);
- }
+ var vStart = allAxials.Min();
+ var vEnd = allAxials.Max();
+ if ((vEnd - vStart) <= minSpan)
+ {
+ continue;
+ }
- var vStart = allAxials.Min();
- var vEnd = allAxials.Max();
- if ((vEnd - vStart) <= minSpan)
- {
- return KernelResult<(double, double, double, double)>.Failure([
- CreateInvalidArgument("Cylindrical face tessellation derived a degenerate trim patch.", CylinderTrimDegenerateSource)]);
- }
+ var angularBounds = ResolveAngularBounds(allAngles);
+ if (!angularBounds.IsSuccess || angularBounds.Value.Span <= minSpan)
+ {
+ continue;
+ }
- var angularBounds = ResolveAngularBounds(allAngles);
- if (!angularBounds.IsSuccess)
- {
- return KernelResult<(double, double, double, double)>.Failure([
- CreateInvalidArgument("Cylindrical face tessellation derived a degenerate trim patch.", CylinderTrimDegenerateSource)]);
+ var candidate = (UStart: angularBounds.Value.Start, USpan: angularBounds.Value.Span, VStart: vStart, VEnd: vEnd, angularBounds.Value.UsedAmbiguousShorterSpanResolution);
+ var candidateScore = candidate.USpan * (candidate.VEnd - candidate.VStart);
+ var bestScore = best.HasValue ? best.Value.USpan * (best.Value.VEnd - best.Value.VStart) : double.NegativeInfinity;
+ if (!best.HasValue || candidateScore > bestScore)
+ {
+ best = candidate;
+ }
}
- if ((angularBounds.Value.Span) <= minSpan)
+ if (!best.HasValue)
{
return KernelResult<(double, double, double, double)>.Failure([
CreateInvalidArgument("Cylindrical face tessellation derived a degenerate trim patch.", CylinderTrimDegenerateSource)]);
}
var diagnostics = new List<KernelDiagnostic>();
- if (angularBounds.Value.UsedAmbiguousShorterSpanResolution)
+ if (best.Value.UsedAmbiguousShorterSpanResolution)
{
diagnostics.Add(CreateValidationWarning(
"Cylindrical face tessellation resolved ambiguous trim by choosing the shorter angular span.",
@@ -770,7 +763,7 @@ public static class BrepDisplayTessellator
}
return KernelResult<(double, double, double, double)>.Success(
- (angularBounds.Value.Start, angularBounds.Value.Start + angularBounds.Value.Span, vStart, vEnd),
+ (best.Value.UStart, best.Value.UStart + best.Value.USpan, best.Value.VStart, best.Value.VEnd),
diagnostics);
}
diff --git a/Aetheris.Kernel.Core/Step242/Step242Importer.cs b/Aetheris.Kernel.Core/Step242/Step242Importer.cs
index 41142bad..c1a0a355 100644
--- a/Aetheris.Kernel.Core/Step242/Step242Importer.cs
+++ b/Aetheris.Kernel.Core/Step242/Step242Importer.cs
@@ -946,9 +946,7 @@ public static class Step242Importer
return surface.Kind switch
{
SurfaceGeometryKind.Plane => ClassifyAndNormalizePlanarLoops(loops, surface.Plane!.Value),
- SurfaceGeometryKind.Cylinder => LoopRoleFailure<IReadOnlyList<LoopBuildData>>(
- "Cylinder multi-loop hole classification is not yet safely supported.",
- "Importer.LoopRole.CylinderMappingFailed"),
+ SurfaceGeometryKind.Cylinder => ClassifyAndNormalizeCylindricalLoops(loops, surface.Cylinder!.Value),
SurfaceGeometryKind.Cone or SurfaceGeometryKind.Sphere => LoopRoleFailure<IReadOnlyList<LoopBuildData>>(
"Multi-loop hole classification is unsupported for this surface type.",
"Importer.LoopRole.UnsupportedSurfaceForHoles"),
@@ -1060,6 +1058,83 @@ public static class Step242Importer
return KernelResult<IReadOnlyList<LoopBuildData>>.Success(ordered);
}
+ private static KernelResult<IReadOnlyList<LoopBuildData>> ClassifyAndNormalizeCylindricalLoops(
+ IReadOnlyList<LoopBuildData> loops,
+ CylinderSurface cylinder)
+ {
+ const string nonNormalizableSource = "Importer.LoopRole.CylinderNonNormalizableDegenerateProjection";
+ const string ambiguousOuterSource = "Importer.LoopRole.CylinderAmbiguousOuter";
+ const string containmentSource = "Importer.LoopRole.CylinderInnerContainmentFailed";
+
+ var infos = new List<CylindricalLoopInfo>(loops.Count);
+ var maxUniqueCount = 0;
+ var maxAbsArea = 0d;
+ foreach (var loop in loops)
+ {
+ var projected = ProjectLoopToCylinder(loop.Samples, cylinder);
+ var uniqueCount = CountUniquePoints(projected, ContainmentEps);
+ var area = ComputeSignedArea(projected);
+ maxUniqueCount = System.Math.Max(maxUniqueCount, uniqueCount);
+ maxAbsArea = System.Math.Max(maxAbsArea, double.Abs(area));
+ if (uniqueCount < 3 || double.Abs(area) <= AreaEps)
+ {
+ continue;
+ }
+
+ infos.Add(new CylindricalLoopInfo(loop, projected, area, ComputePolygonCentroid(projected)));
+ }
+
+ if (infos.Count == 0)
+ {
+ return LoopRoleFailure<IReadOnlyList<LoopBuildData>>($"Cylinder loop normalization failed: all {loops.Count} loop(s) projected degenerate (maxUnique={maxUniqueCount}, maxAbsArea={maxAbsArea:E6}).", nonNormalizableSource);
+ }
+
+ var orderedByArea = infos
+ .OrderByDescending(i => double.Abs(i.SignedArea))
+ .ThenBy(i => i.Loop.LoopId.Value)
+ .ToArray();
+
+ var outer = orderedByArea[0];
+ if (orderedByArea.Length > 1)
+ {
+ var areaTolerance = ComputeAreaTolerance(orderedByArea.SelectMany(i => i.ProjectedPoints));
+ if (double.Abs(double.Abs(outer.SignedArea) - double.Abs(orderedByArea[1].SignedArea)) <= areaTolerance)
+ {
+ return LoopRoleFailure<IReadOnlyList<LoopBuildData>>("Unable to choose a unique cylindrical outer loop.", ambiguousOuterSource);
+ }
+ }
+
+ var containmentTolerance = ComputeContainmentTolerance(outer.ProjectedPoints);
+ var containedInners = new List<CylindricalLoopInfo>();
+ foreach (var candidate in infos.Where(i => i.Loop.LoopId != outer.Loop.LoopId))
+ {
+ var alignedCandidate = AlignPolygonToReference(candidate.ProjectedPoints, candidate.Centroid.X, outer.Centroid.X);
+ var sampleResult = ChooseContainmentPoint(alignedCandidate, containmentTolerance);
+ if (!sampleResult.IsSuccess)
+ {
+ return LoopRoleFailure<IReadOnlyList<LoopBuildData>>("Unable to classify cylindrical inner loop containment.", containmentSource);
+ }
+
+ if (!IsPointInPolygon(sampleResult.Value, outer.ProjectedPoints, containmentTolerance))
+ {
+ return LoopRoleFailure<IReadOnlyList<LoopBuildData>>($"Cylindrical inner loop {candidate.Loop.LoopId.Value} could not be normalized inside selected outer loop {outer.Loop.LoopId.Value}.", containmentSource);
+ }
+
+ containedInners.Add(candidate with { ProjectedPoints = alignedCandidate, Centroid = ComputePolygonCentroid(alignedCandidate) });
+ }
+
+ var normalizedOuter = NormalizeLoopWinding(outer.Loop, outer.SignedArea, shouldBePositive: true);
+ var normalizedInners = containedInners
+ .OrderByDescending(i => double.Abs(i.SignedArea))
+ .ThenBy(i => i.Loop.LoopId.Value)
+ .Select(i => NormalizeLoopWinding(i.Loop, i.SignedArea, shouldBePositive: false))
+ .ToList();
+
+ var ordered = new List<LoopBuildData>(1 + normalizedInners.Count) { normalizedOuter };
+ ordered.AddRange(normalizedInners);
+ return KernelResult<IReadOnlyList<LoopBuildData>>.Success(ordered);
+ }
+
private static LoopBuildData NormalizeLoopWinding(LoopBuildData loop, double signedArea, bool shouldBePositive)
{
if (shouldBePositive ? signedArea >= 0d : signedArea <= 0d)
@@ -1331,6 +1406,72 @@ public static class Step242Importer
return uv;
}
+ private static List<UvPoint> ProjectLoopToCylinder(IReadOnlyList<Point3D> samples, CylinderSurface cylinder)
+ {
+ var axis = cylinder.Axis.ToVector();
+ var xAxis = cylinder.XAxis.ToVector();
+ var yAxis = cylinder.YAxis.ToVector();
+
+ var uv = new List<UvPoint>(samples.Count + 1);
+ double? previous = null;
+ var revolutions = 0d;
+ foreach (var sample in samples)
+ {
+ var offset = sample - cylinder.Origin;
+ var axial = offset.Dot(axis);
+ var radial = offset - (axis * axial);
+ var angle = NormalizeToZeroTwoPi(double.Atan2(radial.Dot(yAxis), radial.Dot(xAxis)));
+ if (previous.HasValue)
+ {
+ var delta = angle - previous.Value;
+ if (delta > double.Pi)
+ {
+ revolutions -= 2d * double.Pi;
+ }
+ else if (delta < -double.Pi)
+ {
+ revolutions += 2d * double.Pi;
+ }
+ }
+
+ uv.Add(new UvPoint(angle + revolutions, axial));
+ previous = angle;
+ }
+
+ if (uv.Count > 0 && (uv[0] - uv[^1]).Length > ContainmentEps)
+ {
+ uv.Add(uv[0]);
+ }
+
+ return uv;
+ }
+
+ private static IReadOnlyList<UvPoint> AlignPolygonToReference(IReadOnlyList<UvPoint> polygon, double currentX, double referenceX)
+ {
+ var twoPi = 2d * double.Pi;
+ var delta = referenceX - currentX;
+ var turns = double.Round(delta / twoPi);
+ var shift = turns * twoPi;
+ if (double.Abs(shift) <= AngleUnwrapEps)
+ {
+ return polygon;
+ }
+
+ return polygon.Select(p => new UvPoint(p.X + shift, p.Y)).ToArray();
+ }
+
+ private static double NormalizeToZeroTwoPi(double angle)
+ {
+ var twoPi = 2d * double.Pi;
+ var normalized = angle % twoPi;
+ if (normalized < 0d)
+ {
+ normalized += twoPi;
+ }
+
+ return normalized;
+ }
+
private static double ComputeSignedArea(IReadOnlyList<UvPoint> polygon)
{
var area = 0d;
@@ -1357,7 +1498,7 @@ public static class Step242Importer
var minY = array.Min(p => p.Y);
var maxY = array.Max(p => p.Y);
var diagonal = double.Sqrt(((maxX - minX) * (maxX - minX)) + ((maxY - minY) * (maxY - minY)));
- return double.Max(ContainmentEps, diagonal * 1e-6d);
+ return System.Math.Max(ContainmentEps, diagonal * 1e-6d);
}
private static double ComputeAreaTolerance(IEnumerable<UvPoint> points)
@@ -1373,7 +1514,7 @@ public static class Step242Importer
var minY = array.Min(p => p.Y);
var maxY = array.Max(p => p.Y);
var extentArea = (maxX - minX) * (maxY - minY);
- return double.Max(AreaEps, extentArea * 1e-8d);
+ return System.Math.Max(AreaEps, extentArea * 1e-8d);
}
private static void AppendLoopSamples(ICollection<Point3D> loopSamples, IReadOnlyList<Point3D> edgeSamples)
@@ -1467,6 +1608,8 @@ public static class Step242Importer
private sealed record PlanarLoopOuterCandidate(PlanarLoopInfo Info, UvPoint SamplePoint, int ContainmentCount);
+ private sealed record CylindricalLoopInfo(LoopBuildData Loop, IReadOnlyList<UvPoint> ProjectedPoints, double SignedArea, UvPoint Centroid);
+
private sealed record ContainmentEvaluation(int OutsideCount, int VertexCount, double MinDistanceToOuter);
private sealed record ContainmentFailure(string Message, string Source);
diff --git a/testdata/step242/manifests/nist.v0.report.json b/testdata/step242/manifests/nist.v0.report.json
index 7fd1800c..275cb795 100644
--- a/testdata/step242/manifests/nist.v0.report.json
+++ b/testdata/step242/manifests/nist.v0.report.json
@@ -7,8 +7,8 @@
"firstFailureLayer": "tessellator",
"firstDiagnostic": {
"code": "NotImplemented",
- "source": "Viewer.Tessellation.CylinderTrimUnsupported",
- "messagePrefix": "Cylindrical face tessellation could not derive a bounded trim patch."
+ "source": "Viewer.Tessellation.CurvedTopologyUnsupported",
+ "messagePrefix": "Face 57 curved tessellation expected mirrored line uses for this cone/revolved topology. Observed"
},
"diagnosticCount": 1,
"exceptionEscaped": false,
@@ -102,9 +102,9 @@
"status": "importFail",
"firstFailureLayer": "importer-topology",
"firstDiagnostic": {
- "code": "ValidationFailed",
- "source": "Importer.LoopRole.CylinderMappingFailed",
- "messagePrefix": "Cylinder multi-loop hole classification is not yet safely supported."
+ "code": "NotImplemented",
+ "source": "Entity:1234",
+ "messagePrefix": "FACE_BOUND loop type \u0027VERTEX_LOOP\u0027 is unsupported for non-spherical faces in M23 import subset."
},
"diagnosticCount": 1,
"exceptionEscaped": false,
@@ -199,8 +199,8 @@
"firstFailureLayer": "importer-topology",
"firstDiagnostic": {
"code": "ValidationFailed",
- "source": "Importer.LoopRole.CylinderMappingFailed",
- "messagePrefix": "Cylinder multi-loop hole classification is not yet safely supported."
+ "source": "Importer.LoopRole.CylinderNonNormalizableDegenerateProjection",
+ "messagePrefix": "Cylinder loop normalization failed"
},
"diagnosticCount": 1,
"exceptionEscaped": false,