Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Fix Circle3 edge tessellation trim resolution for STEP arcs

Yuechen Li6d0cc10d5374
diff --git a/Aetheris.Kernel.Core.Tests/Step242/Step242ImporterTests.cs b/Aetheris.Kernel.Core.Tests/Step242/Step242ImporterTests.cs
index 930bb5be..3e346936 100644
--- a/Aetheris.Kernel.Core.Tests/Step242/Step242ImporterTests.cs
+++ b/Aetheris.Kernel.Core.Tests/Step242/Step242ImporterTests.cs
@@ -298,6 +298,87 @@ public sealed class Step242ImporterTests
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);
+ }
+ }
+
+ 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));
diff --git a/Aetheris.Kernel.Core/Brep/BrepBindings.cs b/Aetheris.Kernel.Core/Brep/BrepBindings.cs
index 2e948259..958f4b9d 100644
--- a/Aetheris.Kernel.Core/Brep/BrepBindings.cs
+++ b/Aetheris.Kernel.Core/Brep/BrepBindings.cs
@@ -3,7 +3,11 @@ using Aetheris.Kernel.Core.Topology;
namespace Aetheris.Kernel.Core.Brep;
-public readonly record struct EdgeGeometryBinding(EdgeId EdgeId, CurveGeometryId CurveGeometryId, ParameterInterval? TrimInterval = null);
+public readonly record struct EdgeGeometryBinding(
+ EdgeId EdgeId,
+ CurveGeometryId CurveGeometryId,
+ ParameterInterval? TrimInterval = null,
+ bool OrientedEdgeSense = true);
public readonly record struct FaceGeometryBinding(FaceId FaceId, SurfaceGeometryId SurfaceGeometryId);
diff --git a/Aetheris.Kernel.Core/Brep/Tessellation/BrepDisplayTessellator.cs b/Aetheris.Kernel.Core/Brep/Tessellation/BrepDisplayTessellator.cs
index 4084dadd..8cf6c955 100644
--- a/Aetheris.Kernel.Core/Brep/Tessellation/BrepDisplayTessellator.cs
+++ b/Aetheris.Kernel.Core/Brep/Tessellation/BrepDisplayTessellator.cs
@@ -13,6 +13,8 @@ public static class BrepDisplayTessellator
private const double LoopEndpointTolerance = 1e-6d;
private const string PlanarCurveFlatteningUnsupportedSource = "Viewer.Tessellation.PlanarCurveFlatteningUnsupported";
private const string PlanarCurveFlatteningFailedSource = "Viewer.Tessellation.PlanarCurveFlatteningFailed";
+ private const string CircleTrimResolveFailedSource = "Viewer.Tessellation.CircleTrimResolveFailed";
+ private const string CircleTrimAmbiguousUsedShorterArcSource = "Viewer.Tessellation.CircleTrimAmbiguousUsedShorterArc";
public static KernelResult<DisplayTessellationResult> Tessellate(BrepBody body, DisplayTessellationOptions? options = null)
{
@@ -28,6 +30,8 @@ public static class BrepDisplayTessellator
return KernelResult<DisplayTessellationResult>.Failure(optionDiagnostics);
}
+ var accumulatedDiagnostics = new List<KernelDiagnostic>();
+
var facePatches = new List<DisplayFaceMeshPatch>();
foreach (var face in body.Topology.Faces.OrderBy(f => f.Id.Value))
{
@@ -38,6 +42,7 @@ public static class BrepDisplayTessellator
}
facePatches.Add(faceResult.Value);
+ accumulatedDiagnostics.AddRange(faceResult.Diagnostics);
}
var edgePolylines = new List<DisplayEdgePolyline>();
@@ -50,9 +55,10 @@ public static class BrepDisplayTessellator
}
edgePolylines.Add(edgeResult.Value);
+ accumulatedDiagnostics.AddRange(edgeResult.Diagnostics);
}
- return KernelResult<DisplayTessellationResult>.Success(new DisplayTessellationResult(facePatches, edgePolylines));
+ return KernelResult<DisplayTessellationResult>.Success(new DisplayTessellationResult(facePatches, edgePolylines), accumulatedDiagnostics);
}
private static KernelResult<DisplayFaceMeshPatch> TessellateFace(BrepBody body, FaceId faceId, DisplayTessellationOptions options)
@@ -661,10 +667,39 @@ public static class BrepDisplayTessellator
case CurveGeometryKind.Circle3:
var circle = curve.Circle3!.Value;
- var delta = interval.End - interval.Start;
- var points = CurveSampler.SampleCircleArc(circle, interval.Start, delta);
-
- return KernelResult<DisplayEdgePolyline>.Success(new DisplayEdgePolyline(edgeId, points, IsClosed: delta >= (2d * double.Pi)));
+ var startPointResult = EvaluateEdgeEndpoint(body, edgeId, useStart: true);
+ if (!startPointResult.IsSuccess)
+ {
+ return KernelResult<DisplayEdgePolyline>.Failure(startPointResult.Diagnostics);
+ }
+
+ var endPointResult = EvaluateEdgeEndpoint(body, edgeId, useStart: false);
+ if (!endPointResult.IsSuccess)
+ {
+ return KernelResult<DisplayEdgePolyline>.Failure(endPointResult.Diagnostics);
+ }
+
+ if (!CurveSampler.TrySampleTrimmedCircleArc(
+ circle,
+ startPointResult.Value,
+ endPointResult.Value,
+ binding.OrientedEdgeSense,
+ out var points,
+ out var isClosed,
+ out var usedShorterArcFallback))
+ {
+ return KernelResult<DisplayEdgePolyline>.Failure([
+ CreateInvalidArgument($"Edge {edgeId.Value} failed to resolve circle trim from edge endpoints.", CircleTrimResolveFailedSource)]);
+ }
+
+ if (usedShorterArcFallback)
+ {
+ return KernelResult<DisplayEdgePolyline>.Success(
+ new DisplayEdgePolyline(edgeId, points, isClosed),
+ [CreateValidationWarning($"Edge {edgeId.Value} circular trim was ambiguous; using shorter arc.", CircleTrimAmbiguousUsedShorterArcSource)]);
+ }
+
+ return KernelResult<DisplayEdgePolyline>.Success(new DisplayEdgePolyline(edgeId, points, isClosed));
default:
return KernelResult<DisplayEdgePolyline>.Failure([CreateNotImplemented($"Edge {edgeId.Value} has unsupported curve kind '{curve.Kind}'.")]);
diff --git a/Aetheris.Kernel.Core/Brep/Tessellation/CurveSampler.cs b/Aetheris.Kernel.Core/Brep/Tessellation/CurveSampler.cs
index 64ba9417..70de4888 100644
--- a/Aetheris.Kernel.Core/Brep/Tessellation/CurveSampler.cs
+++ b/Aetheris.Kernel.Core/Brep/Tessellation/CurveSampler.cs
@@ -26,6 +26,102 @@ internal static class CurveSampler
return points;
}
+ public static bool TrySampleTrimmedCircleArc(
+ Circle3Curve circle,
+ Point3D startPoint,
+ Point3D endPoint,
+ bool orientedEdgeSense,
+ out IReadOnlyList<Point3D> points,
+ out bool isClosed,
+ out bool usedShorterArcFallback)
+ {
+ const double endpointTolerance = 1e-6d;
+ const double fullCircleEpsilon = 1e-6d;
+
+ usedShorterArcFallback = false;
+ isClosed = false;
+
+ var normal = circle.Normal.ToVector();
+ var distinctEndpoints = (startPoint - endPoint).Length > endpointTolerance;
+
+ var startProjected = ProjectPointToCirclePlane(circle.Center, normal, startPoint);
+ var endProjected = ProjectPointToCirclePlane(circle.Center, normal, endPoint);
+
+ var startRadius = (startProjected - circle.Center).Length;
+ var endRadius = (endProjected - circle.Center).Length;
+ if (double.Abs(startRadius - circle.Radius) > endpointTolerance || double.Abs(endRadius - circle.Radius) > endpointTolerance)
+ {
+ points = Array.Empty<Point3D>();
+ return false;
+ }
+
+ var u = circle.XAxis.ToVector();
+ var v = circle.YAxis.ToVector();
+
+ var startOffset = startProjected - circle.Center;
+ var endOffset = endProjected - circle.Center;
+ var thetaStart = NormalizeToZeroTwoPi(double.Atan2(startOffset.Dot(v), startOffset.Dot(u)));
+ var thetaEnd = NormalizeToZeroTwoPi(double.Atan2(endOffset.Dot(v), endOffset.Dot(u)));
+
+ var deltaForward = NormalizeToZeroTwoPi(thetaEnd - thetaStart);
+ var deltaBackward = NormalizeToZeroTwoPi(thetaStart - thetaEnd);
+
+ double delta;
+ if (!distinctEndpoints)
+ {
+ delta = 2d * double.Pi;
+ isClosed = true;
+ }
+ else if (orientedEdgeSense)
+ {
+ delta = deltaForward;
+ }
+ else
+ {
+ delta = -deltaBackward;
+ }
+
+ if (distinctEndpoints && double.Abs(double.Abs(delta) - (2d * double.Pi)) <= fullCircleEpsilon)
+ {
+ var shorterForward = deltaForward <= deltaBackward;
+ delta = shorterForward ? deltaForward : -deltaBackward;
+ usedShorterArcFallback = true;
+ }
+
+ if (distinctEndpoints)
+ {
+ var minDelta = 1e-9d;
+ var maxDelta = (2d * double.Pi) - 1e-9d;
+ var sign = delta >= 0d ? 1d : -1d;
+ delta = sign * System.Math.Clamp(double.Abs(delta), minDelta, maxDelta);
+ }
+
+ var sampled = SampleCircleArc(circle, thetaStart, delta).ToArray();
+ sampled[0] = startProjected;
+ sampled[^1] = endProjected;
+ points = sampled;
+ return true;
+ }
+
+ private static Point3D ProjectPointToCirclePlane(Point3D center, Vector3D normal, Point3D point)
+ {
+ var offset = point - center;
+ var distance = offset.Dot(normal);
+ return point - (normal * distance);
+ }
+
+ private static double NormalizeToZeroTwoPi(double angle)
+ {
+ var twoPi = 2d * double.Pi;
+ var normalized = angle % twoPi;
+ if (normalized < 0d)
+ {
+ normalized += twoPi;
+ }
+
+ return normalized;
+ }
+
private static int ResolveCircleSegmentCount(double delta)
{
var absoluteDelta = double.Abs(delta);
diff --git a/Aetheris.Kernel.Core/Step242/Step242Importer.cs b/Aetheris.Kernel.Core/Step242/Step242Importer.cs
index 2342f717..ffafd338 100644
--- a/Aetheris.Kernel.Core/Step242/Step242Importer.cs
+++ b/Aetheris.Kernel.Core/Step242/Step242Importer.cs
@@ -411,7 +411,7 @@ public static class Step242Importer
}
geometry.AddCurve(curveGeometryId, bindCurveResult.Value.CurveGeometry);
- bindings.AddEdgeBinding(new EdgeGeometryBinding(edgeId, curveGeometryId, bindCurveResult.Value.TrimInterval));
+ bindings.AddEdgeBinding(new EdgeGeometryBinding(edgeId, curveGeometryId, bindCurveResult.Value.TrimInterval, edgeSameSense));
return KernelResult<EdgeId>.Success(edgeId);
}