Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

M23 widen bounded bspline scaffold support and add sweep

Yuechen Lif819e56e086a
diff --git a/Aetheris.Kernel.Core.Tests/Brep/Tessellation/DisplayPreparationFallbackBuilderTests.cs b/Aetheris.Kernel.Core.Tests/Brep/Tessellation/DisplayPreparationFallbackBuilderTests.cs
index 7c5e77f0..475c8433 100644
--- a/Aetheris.Kernel.Core.Tests/Brep/Tessellation/DisplayPreparationFallbackBuilderTests.cs
+++ b/Aetheris.Kernel.Core.Tests/Brep/Tessellation/DisplayPreparationFallbackBuilderTests.cs
@@ -5,6 +5,13 @@ namespace Aetheris.Kernel.Core.Tests.Brep.Tessellation;
public sealed class DisplayPreparationFallbackBuilderTests
{
+ private static readonly DisplayPreparationSweepCase[] BoundedRealCaseSweepCases =
+ [
+ new("single-loop-accepted", UvTrimMaskExtractorTests.ImportSingleLoopBsplineBody),
+ new("two-loop-hole-accepted", UvTrimMaskExtractorTests.ImportBsplineBodyWithHole),
+ new("missing-vertex-rejected", () => UvTrimMaskExtractorTests.CreateBodyWithMissingVertexPoint(UvTrimMaskExtractorTests.ImportSingleLoopBsplineBody())),
+ ];
+
[Fact]
public void Build_SingleFaceBsplineBody_UsesAcceptedScaffoldPatch()
{
@@ -38,6 +45,23 @@ public sealed class DisplayPreparationFallbackBuilderTests
Assert.Equal(BsplineUvGridScaffoldRejectionReason.TooDenseVsFallback.ToString(), patch.ScaffoldRejectionReason);
}
+ [Fact]
+ public void Build_SingleFaceBsplineBodyWithHole_UsesAcceptedScaffoldPatch()
+ {
+ var body = UvTrimMaskExtractorTests.ImportBsplineBodyWithHole();
+
+ var first = DisplayPreparationFallbackBuilder.Build(body);
+ var second = DisplayPreparationFallbackBuilder.Build(body);
+
+ Assert.True(first.IsSuccess);
+ Assert.True(second.IsSuccess);
+ var firstPatch = Assert.Single(first.Value.FacePatches);
+ var secondPatch = Assert.Single(second.Value.FacePatches);
+ Assert.Equal(DisplayFaceMeshSource.BsplineUvScaffold, firstPatch.Source);
+ Assert.Null(firstPatch.ScaffoldRejectionReason);
+ Assert.Equal(CreateSignature(first.Value), CreateSignature(second.Value));
+ }
+
[Fact]
public void Build_UnsupportedBody_StaysOnExistingFallbackWithoutScaffoldAttempt()
{
@@ -87,9 +111,87 @@ public sealed class DisplayPreparationFallbackBuilderTests
Assert.Equal(CreateSignature(first.Value), CreateSignature(second.Value));
}
+ [Fact]
+ public void Build_BoundedRealCaseSweep_ReportsDeterministicAcceptedRejectedAndReasons()
+ {
+ var first = RunBoundedRealCaseSweep();
+ var second = RunBoundedRealCaseSweep();
+
+ Assert.Equal(CreateSweepSignature(first), CreateSweepSignature(second));
+ Assert.Equal(3, first.TotalCases);
+ Assert.Equal(2, first.AcceptedCases);
+ Assert.Equal(1, first.RejectedCases);
+ Assert.Equal(2, first.SourceHistogram[DisplayFaceMeshSource.BsplineUvScaffold]);
+ Assert.Equal(1, first.SourceHistogram[DisplayFaceMeshSource.Tessellator]);
+ Assert.Equal(1, first.RejectionReasonHistogram["TrimMaskExtraction:MissingVertexPoint"]);
+ Assert.Contains(first.Cases, c => c.Name == "two-loop-hole-accepted" && c.Accepted && c.Source == DisplayFaceMeshSource.BsplineUvScaffold);
+ Assert.Contains(first.Cases, c => c.Name == "missing-vertex-rejected" && !c.Accepted && c.RejectionReason == "TrimMaskExtraction:MissingVertexPoint");
+ }
+
+ private static BoundedRealCaseSweepSummary RunBoundedRealCaseSweep()
+ {
+ var caseResults = new List<BoundedRealCaseSweepCaseResult>(BoundedRealCaseSweepCases.Length);
+ foreach (var sweepCase in BoundedRealCaseSweepCases)
+ {
+ var body = sweepCase.CreateBody();
+ var result = DisplayPreparationFallbackBuilder.Build(body);
+ Assert.True(result.IsSuccess);
+ var patch = Assert.Single(result.Value.FacePatches);
+ caseResults.Add(new BoundedRealCaseSweepCaseResult(
+ sweepCase.Name,
+ Attempted: patch.Source == DisplayFaceMeshSource.BsplineUvScaffold || patch.ScaffoldRejectionReason is not null,
+ Accepted: patch.Source == DisplayFaceMeshSource.BsplineUvScaffold,
+ patch.ScaffoldRejectionReason,
+ patch.Source));
+ }
+
+ var sourceHistogram = caseResults
+ .GroupBy(c => c.Source)
+ .ToDictionary(group => group.Key, group => group.Count());
+ var rejectionHistogram = caseResults
+ .Where(c => !string.IsNullOrWhiteSpace(c.RejectionReason))
+ .GroupBy(c => c.RejectionReason!, StringComparer.Ordinal)
+ .ToDictionary(group => group.Key, group => group.Count(), StringComparer.Ordinal);
+
+ return new BoundedRealCaseSweepSummary(
+ caseResults.Count,
+ caseResults.Count(c => c.Accepted),
+ caseResults.Count(c => !c.Accepted),
+ sourceHistogram,
+ rejectionHistogram,
+ caseResults);
+ }
+
+ private static string CreateSweepSignature(BoundedRealCaseSweepSummary summary)
+ {
+ var sources = string.Join(",", summary.SourceHistogram.OrderBy(kvp => kvp.Key).Select(kvp => $"{kvp.Key}:{kvp.Value}"));
+ var reasons = string.Join(",", summary.RejectionReasonHistogram.OrderBy(kvp => kvp.Key, StringComparer.Ordinal).Select(kvp => $"{kvp.Key}:{kvp.Value}"));
+ var cases = string.Join("|", summary.Cases.Select(c => $"{c.Name}:{c.Attempted}:{c.Accepted}:{c.Source}:{c.RejectionReason}"));
+ return $"{summary.TotalCases}:{summary.AcceptedCases}:{summary.RejectedCases}:{sources}:{reasons}:{cases}";
+ }
+
private static string CreateSignature(DisplayTessellationResult result)
=> string.Join(
"|",
result.FacePatches.Select(patch =>
$"{patch.FaceId.Value}:{patch.Source}:{patch.ScaffoldRejectionReason}:{patch.Positions.Count}:{patch.TriangleIndices.Count}:{string.Join(',', patch.TriangleIndices.Take(24))}"));
}
+
+internal sealed record DisplayPreparationSweepCase(
+ string Name,
+ Func<BrepBody> CreateBody);
+
+internal sealed record BoundedRealCaseSweepCaseResult(
+ string Name,
+ bool Attempted,
+ bool Accepted,
+ string? RejectionReason,
+ DisplayFaceMeshSource Source);
+
+internal sealed record BoundedRealCaseSweepSummary(
+ int TotalCases,
+ int AcceptedCases,
+ int RejectedCases,
+ IReadOnlyDictionary<DisplayFaceMeshSource, int> SourceHistogram,
+ IReadOnlyDictionary<string, int> RejectionReasonHistogram,
+ IReadOnlyList<BoundedRealCaseSweepCaseResult> Cases);
diff --git a/Aetheris.Kernel.Core.Tests/Brep/Tessellation/UvTrimMaskExtractorTests.cs b/Aetheris.Kernel.Core.Tests/Brep/Tessellation/UvTrimMaskExtractorTests.cs
index c2bce5a2..898c972a 100644
--- a/Aetheris.Kernel.Core.Tests/Brep/Tessellation/UvTrimMaskExtractorTests.cs
+++ b/Aetheris.Kernel.Core.Tests/Brep/Tessellation/UvTrimMaskExtractorTests.cs
@@ -1,7 +1,11 @@
using Aetheris.Kernel.Core.Brep;
using Aetheris.Kernel.Core.Brep.Tessellation;
+using Aetheris.Kernel.Core.Geometry.Curves;
+using Aetheris.Kernel.Core.Geometry.Surfaces;
using Aetheris.Kernel.Core.Geometry;
+using Aetheris.Kernel.Core.Math;
using Aetheris.Kernel.Core.Step242;
+using Aetheris.Kernel.Core.Topology;
namespace Aetheris.Kernel.Core.Tests.Brep.Tessellation;
@@ -45,6 +49,29 @@ public sealed class UvTrimMaskExtractorTests
Assert.Equal(BsplineUvGridScaffoldRejectionReason.None, scaffold.RejectionReason);
}
+ [Fact]
+ public void TryExtract_RealBsplineFaceWithHole_BuildsDeterministicOuterAndInnerLoops()
+ {
+ var body = ImportBsplineBodyWithHole();
+ var face = Assert.Single(body.Topology.Faces);
+ Assert.True(body.TryGetFaceSurfaceGeometry(face.Id, out var surface));
+ var bspline = surface?.BSplineSurfaceWithKnots;
+ Assert.NotNull(bspline);
+
+ var extractor = new UvTrimMaskExtractor();
+ var first = extractor.TryExtract(body, face.Id, bspline!);
+ var second = extractor.TryExtract(body, face.Id, bspline!);
+
+ Assert.True(first.IsSuccess);
+ Assert.True(second.IsSuccess);
+ Assert.NotNull(first.TrimMask);
+ Assert.NotNull(second.TrimMask);
+ Assert.Equal(first.TrimMask!.OuterLoop, second.TrimMask!.OuterLoop);
+ Assert.Equal(first.TrimMask.InnerLoops.Count, second.TrimMask.InnerLoops.Count);
+ Assert.Single(first.TrimMask.InnerLoops);
+ Assert.Equal(first.TrimMask.InnerLoops[0], second.TrimMask.InnerLoops[0]);
+ }
+
[Fact]
public void TryExtract_BsplineFaceWithUnsupportedTrimEdge_IsExplicitlyUnsupported()
{
@@ -70,6 +97,127 @@ public sealed class UvTrimMaskExtractorTests
return import.Value;
}
+ internal static BrepBody ImportBsplineBodyWithHole()
+ {
+ return CreateTrimmedBsplineSurfaceBody(
+ outerBounds: (0d, 1d, 0d, 1d),
+ holeBounds: (0.3d, 0.7d, 0.3d, 0.7d));
+ }
+
+ private static BrepBody CreateTrimmedBsplineSurfaceBody(
+ (double UMin, double UMax, double VMin, double VMax) outerBounds,
+ (double UMin, double UMax, double VMin, double VMax)? holeBounds)
+ {
+ var loops = new List<IReadOnlyList<(double U, double V)>> { CreateRectangleLoop(outerBounds) };
+ if (holeBounds is { } hole)
+ {
+ loops.Add(CreateRectangleLoop(hole));
+ }
+
+ var builder = new TopologyBuilder();
+ var geometry = new BrepGeometryStore();
+ var bindings = new BrepBindingModel();
+ var vertexPoints = new Dictionary<VertexId, Point3D>();
+ var faceLoops = new List<LoopId>(loops.Count);
+ var curveId = 1;
+
+ foreach (var loop in loops)
+ {
+ faceLoops.Add(AddLoop(builder, geometry, bindings, vertexPoints, CreateBsplineLoopVertices(loop), ref curveId));
+ }
+
+ var face = builder.AddFace(faceLoops);
+ var shell = builder.AddShell([face]);
+ builder.AddBody([shell]);
+
+ geometry.AddSurface(new SurfaceGeometryId(1), SurfaceGeometry.FromBSplineSurfaceWithKnots(CreateBilinearBsplineSurface()));
+ bindings.AddFaceBinding(new FaceGeometryBinding(face, new SurfaceGeometryId(1)));
+
+ return new BrepBody(builder.Model, geometry, bindings, vertexPoints);
+ }
+
+ private static LoopId AddLoop(
+ TopologyBuilder builder,
+ BrepGeometryStore geometry,
+ BrepBindingModel bindings,
+ Dictionary<VertexId, Point3D> vertexPoints,
+ IReadOnlyList<Point3D> vertices,
+ ref int curveId)
+ {
+ var vertexIds = vertices.Select(point =>
+ {
+ var vertexId = builder.AddVertex();
+ vertexPoints[vertexId] = point;
+ return vertexId;
+ }).ToArray();
+
+ var loopId = builder.AllocateLoopId();
+ var coedgeIds = new List<CoedgeId>(vertices.Count);
+ var edgeIds = new List<EdgeId>(vertices.Count);
+ for (var i = 0; i < vertices.Count; i++)
+ {
+ var edgeId = builder.AddEdge(vertexIds[i], vertexIds[(i + 1) % vertices.Count]);
+ edgeIds.Add(edgeId);
+ var line = CreateLine(vertices[i], vertices[(i + 1) % vertices.Count], out var length);
+ var geometryId = new CurveGeometryId(curveId++);
+ geometry.AddCurve(geometryId, CurveGeometry.FromLine(line));
+ bindings.AddEdgeBinding(new EdgeGeometryBinding(edgeId, geometryId, new ParameterInterval(0d, length)));
+ }
+
+ for (var i = 0; i < edgeIds.Count; i++)
+ {
+ coedgeIds.Add(builder.AllocateCoedgeId());
+ }
+
+ for (var i = 0; i < edgeIds.Count; i++)
+ {
+ var next = coedgeIds[(i + 1) % coedgeIds.Count];
+ var prev = coedgeIds[(i - 1 + coedgeIds.Count) % coedgeIds.Count];
+ builder.AddCoedge(new Coedge(coedgeIds[i], edgeIds[i], loopId, next, prev, IsReversed: false));
+ }
+
+ builder.AddLoop(new Loop(loopId, coedgeIds));
+ return loopId;
+ }
+
+ private static Point3D[] CreateBsplineLoopVertices(IReadOnlyList<(double U, double V)> uvLoop)
+ => uvLoop.Select(point => new Point3D(point.U, point.V, point.U * point.V)).ToArray();
+
+ private static Line3Curve CreateLine(Point3D start, Point3D end, out double length)
+ {
+ var delta = end - start;
+ length = delta.Length;
+ return new Line3Curve(start, Direction3D.Create(delta));
+ }
+
+ private static (double U, double V)[] CreateRectangleLoop((double UMin, double UMax, double VMin, double VMax) bounds)
+ =>
+ [
+ (bounds.UMin, bounds.VMin),
+ (bounds.UMax, bounds.VMin),
+ (bounds.UMax, bounds.VMax),
+ (bounds.UMin, bounds.VMax),
+ ];
+
+ private static BSplineSurfaceWithKnots CreateBilinearBsplineSurface()
+ => new(
+ degreeU: 1,
+ degreeV: 1,
+ controlPoints:
+ [
+ [new Point3D(0d, 0d, 0d), new Point3D(0d, 1d, 0d)],
+ [new Point3D(1d, 0d, 0d), new Point3D(1d, 1d, 1d)],
+ ],
+ surfaceForm: "UNSPECIFIED",
+ uClosed: false,
+ vClosed: false,
+ selfIntersect: false,
+ knotMultiplicitiesU: [2, 2],
+ knotMultiplicitiesV: [2, 2],
+ knotValuesU: [0d, 1d],
+ knotValuesV: [0d, 1d],
+ knotSpec: "UNSPECIFIED");
+
internal static BrepBody CreateBodyWithMissingVertexPoint(BrepBody source)
{
var geometry = new BrepGeometryStore();
diff --git a/Aetheris.Kernel.Core/Brep/Tessellation/UvTrimMaskExtractor.cs b/Aetheris.Kernel.Core/Brep/Tessellation/UvTrimMaskExtractor.cs
index 41106cf3..d2b54c0d 100644
--- a/Aetheris.Kernel.Core/Brep/Tessellation/UvTrimMaskExtractor.cs
+++ b/Aetheris.Kernel.Core/Brep/Tessellation/UvTrimMaskExtractor.cs
@@ -9,10 +9,12 @@ namespace Aetheris.Kernel.Core.Brep.Tessellation;
internal sealed class UvTrimMaskExtractor
{
+ private const int MaxSupportedLoops = 2;
+
internal UvTrimMaskExtractionResult TryExtract(BrepBody body, FaceId faceId, BSplineSurfaceWithKnots surface)
{
var loopIds = body.GetLoopIds(faceId).OrderBy(id => id.Value).ToArray();
- if (loopIds.Length != 1)
+ if (loopIds.Length == 0 || loopIds.Length > MaxSupportedLoops)
{
return UvTrimMaskExtractionResult.Unsupported(UvTrimMaskExtractionFailureReason.UnsupportedLoopTopology);
}