Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
fixed gear tooth import.
Yuechen Lib29d34998782
diff --git a/Aetheris.Kernel.Core.Tests/Brep/Queries/AnalyticDisplayPacketBuilderTests.cs b/Aetheris.Kernel.Core.Tests/Brep/Queries/AnalyticDisplayPacketBuilderTests.csindex 9c22ddc0..217516e4 100644--- a/Aetheris.Kernel.Core.Tests/Brep/Queries/AnalyticDisplayPacketBuilderTests.cs+++ b/Aetheris.Kernel.Core.Tests/Brep/Queries/AnalyticDisplayPacketBuilderTests.cs@@ -25,6 +25,26 @@ public sealed class AnalyticDisplayPacketBuilderTestsAssert.All(packet.AnalyticFaces, face => Assert.Equal(SurfaceGeometryKind.Plane, face.SurfaceKind));}+ [Fact]+ public void Build_CylinderBody_PopulatesPlanarCapBoundaryForCircularLoops()+ {+ // Loops containing Circle3 edges used to be rejected by the line-only boundary reconstruction, which left+ // the planar face with no outer boundary and made the viewer silently drop the face.+ var body = BrepPrimitives.CreateCylinder(2d, 5d).Value;++ var packet = AnalyticDisplayPacketBuilder.Build(body);++ var caps = packet.AnalyticFaces.Where(face => face.SurfaceKind == SurfaceGeometryKind.Plane).ToArray();+ Assert.Equal(2, caps.Length);+ Assert.All(caps, cap =>+ {+ var boundary = Assert.IsAssignableFrom<IReadOnlyList<Point3D>>(cap.PlanarOuterBoundary);+ Assert.True(boundary.Count >= 12);+ var centre = new Point3D(boundary.Average(p => p.X), boundary.Average(p => p.Y), boundary.Average(p => p.Z));+ Assert.All(boundary, point => Assert.Equal(2d, (point - centre).Length, 1e-6d));+ });+ }+[Fact]public void Build_BoxBody_PopulatesPlanarOuterBoundaryWithRealFaceExtent(){diff --git a/Aetheris.Kernel.Core.Tests/Brep/Tessellation/BoundaryConformingTrimTessellatorTests.cs b/Aetheris.Kernel.Core.Tests/Brep/Tessellation/BoundaryConformingTrimTessellatorTests.csnew file mode 100644index 00000000..1db12ba7--- /dev/null+++ b/Aetheris.Kernel.Core.Tests/Brep/Tessellation/BoundaryConformingTrimTessellatorTests.cs@@ -0,0 +1,217 @@+using Aetheris.Kernel.Core.Brep.Tessellation;+using Aetheris.Kernel.Core.Diagnostics;+using Aetheris.Kernel.Core.Math;+using Aetheris.Kernel.Core.Topology;++namespace Aetheris.Kernel.Core.Tests.Brep.Tessellation;++/// <summary>+/// Regression coverage for the boundary-conforming trimmed-surface tessellation. The old uniform-grid mask left a+/// staircase along every trim curve and dropped up to one grid cell of area next to it (visible as jagged, gappy+/// gear teeth on imported B-spline / cone faces).+/// </summary>+public sealed class BoundaryConformingTrimTessellatorTests+{+ private static readonly DisplayTessellationOptions Options =+ DisplayTessellationOptions.Create(double.Pi / 12d, 0.05d, minimumSegments: 12, maximumSegments: 64).Value;++ [Fact]+ public void ConcaveToothedOutline_CoversExactlyThePolygon_WithBoundaryVertices()+ {+ var outer = CreateGearOutline(teeth: 12, rootRadius: 8d, tipRadius: 10d, pointsPerFlank: 7);++ var patch = Tessellate([outer]);++ AssertPatchCoversRegion(patch, outer, holes: []);+ AssertContainsVertices(patch, outer);+ }++ [Fact]+ public void ToothedOutlineWithHole_LeavesTheHoleEmpty()+ {+ var outer = CreateGearOutline(teeth: 9, rootRadius: 8d, tipRadius: 10d, pointsPerFlank: 5);+ var hole = CreateCircle(radius: 3d, count: 24, clockwise: true);++ var patch = Tessellate([outer, hole]);++ AssertPatchCoversRegion(patch, outer, [hole]);+ AssertContainsVertices(patch, hole);+ }++ [Fact]+ public void FinelySampledStraightEdges_WithManyCollinearVertices_StillTriangulate()+ {+ // A long thin slot sampled every 0.01 along its straight sides: thousands of exactly collinear vertices.+ var outline = new List<(double U, double V)>();+ for (var i = 0; i <= 400; i++)+ {+ outline.Add((i * 0.05d, 0d));+ }++ for (var i = 1; i <= 40; i++)+ {+ outline.Add((20d, i * 0.05d));+ }++ for (var i = 399; i >= 0; i--)+ {+ outline.Add((i * 0.05d, 2d));+ }++ for (var i = 39; i >= 1; i--)+ {+ outline.Add((0d, i * 0.05d));+ }++ // Make it non-rectangular so the mask fast path is not applicable.+ outline[10] = (outline[10].U, 0.3d);+ var patch = Tessellate([outline]);++ AssertPatchCoversRegion(patch, outline, holes: []);+ }++ [Fact]+ public void Tessellation_IsDeterministic()+ {+ var outer = CreateGearOutline(teeth: 7, rootRadius: 8d, tipRadius: 10d, pointsPerFlank: 4);++ var first = Tessellate([outer]);+ var second = Tessellate([outer]);++ Assert.Equal(first.Positions, second.Positions);+ Assert.Equal(first.TriangleIndices, second.TriangleIndices);+ }++ private static DisplayFaceMeshPatch Tessellate(IReadOnlyList<IReadOnlyList<(double U, double V)>> loops)+ {+ var result = TrimmedSurfaceTessellator.Tessellate(+ new FaceId(1),+ loops,+ (u, v) => new Point3D(u, v, 0d),+ (_, _) => new Vector3D(0d, 0d, 1d),+ Options,+ double.NegativeInfinity,+ double.PositiveInfinity,+ double.NegativeInfinity,+ double.PositiveInfinity,+ (message, source) => new KernelDiagnostic(KernelDiagnosticCode.ValidationFailed, KernelDiagnosticSeverity.Warning, message, source));++ Assert.True(result.IsSuccess);+ Assert.Empty(result.Diagnostics);+ Assert.NotEmpty(result.Value.TriangleIndices);+ return result.Value;+ }++ private static void AssertPatchCoversRegion(+ DisplayFaceMeshPatch patch,+ IReadOnlyList<(double U, double V)> outer,+ IReadOnlyList<IReadOnlyList<(double U, double V)>> holes)+ {+ var expectedArea = System.Math.Abs(SignedArea(outer)) - holes.Sum(hole => System.Math.Abs(SignedArea(hole)));+ var actualArea = 0d;+ for (var i = 0; i < patch.TriangleIndices.Count; i += 3)+ {+ var a = patch.Positions[patch.TriangleIndices[i]];+ var b = patch.Positions[patch.TriangleIndices[i + 1]];+ var c = patch.Positions[patch.TriangleIndices[i + 2]];+ var centroid = ((a.X + b.X + c.X) / 3d, (a.Y + b.Y + c.Y) / 3d);+ Assert.True(ContainsPoint(outer, centroid), "triangle centroid escaped the outer loop");+ Assert.All(holes, hole => Assert.False(ContainsPoint(hole, centroid), "triangle centroid entered a hole"));+ actualArea += System.Math.Abs(((b.X - a.X) * (c.Y - a.Y)) - ((b.Y - a.Y) * (c.X - a.X))) * 0.5d;+ }++ // The mask tessellator lost up to a grid cell of area along the boundary; conforming output must not.+ Assert.Equal(expectedArea, actualArea, expectedArea * 1e-6d);+ }++ private static void AssertContainsVertices(DisplayFaceMeshPatch patch, IReadOnlyList<(double U, double V)> loop)+ {+ foreach (var (u, v) in loop)+ {+ Assert.Contains(patch.Positions, p => System.Math.Abs(p.X - u) <= 1e-9d && System.Math.Abs(p.Y - v) <= 1e-9d);+ }+ }++ private static List<(double U, double V)> CreateGearOutline(int teeth, double rootRadius, double tipRadius, int pointsPerFlank)+ {+ var outline = new List<(double U, double V)>();+ var pitch = 2d * double.Pi / teeth;+ for (var tooth = 0; tooth < teeth; tooth++)+ {+ var start = tooth * pitch;+ for (var i = 0; i < pointsPerFlank; i++)+ {+ var t = (double)i / pointsPerFlank;+ var angle = start + (pitch * 0.25d * t);+ var radius = rootRadius + ((tipRadius - rootRadius) * t);+ outline.Add((radius * double.Cos(angle), radius * double.Sin(angle)));+ }++ for (var i = 0; i < pointsPerFlank; i++)+ {+ var t = (double)i / pointsPerFlank;+ var angle = start + (pitch * 0.25d) + (pitch * 0.25d * t);+ outline.Add((tipRadius * double.Cos(angle), tipRadius * double.Sin(angle)));+ }++ for (var i = 0; i < pointsPerFlank; i++)+ {+ var t = (double)i / pointsPerFlank;+ var angle = start + (pitch * 0.5d) + (pitch * 0.25d * t);+ var radius = tipRadius - ((tipRadius - rootRadius) * t);+ outline.Add((radius * double.Cos(angle), radius * double.Sin(angle)));+ }++ for (var i = 0; i < pointsPerFlank; i++)+ {+ var t = (double)i / pointsPerFlank;+ var angle = start + (pitch * 0.75d) + (pitch * 0.25d * t);+ outline.Add((rootRadius * double.Cos(angle), rootRadius * double.Sin(angle)));+ }+ }++ return outline;+ }++ private static List<(double U, double V)> CreateCircle(double radius, int count, bool clockwise)+ {+ var points = new List<(double U, double V)>(count);+ for (var i = 0; i < count; i++)+ {+ var angle = 2d * double.Pi * i / count * (clockwise ? -1d : 1d);+ points.Add((radius * double.Cos(angle), radius * double.Sin(angle)));+ }++ return points;+ }++ private static double SignedArea(IReadOnlyList<(double U, double V)> polygon)+ {+ var area = 0d;+ for (var i = 0; i < polygon.Count; i++)+ {+ var a = polygon[i];+ var b = polygon[(i + 1) % polygon.Count];+ area += (a.U * b.V) - (b.U * a.V);+ }++ return area * 0.5d;+ }++ private static bool ContainsPoint(IReadOnlyList<(double U, double V)> polygon, (double U, double V) point)+ {+ var inside = false;+ for (var i = 0; i < polygon.Count; i++)+ {+ var a = polygon[i];+ var b = polygon[(i + 1) % polygon.Count];+ if (((a.V > point.V) != (b.V > point.V))+ && (point.U < (((b.U - a.U) * (point.V - a.V)) / (b.V - a.V)) + a.U))+ {+ inside = !inside;+ }+ }++ return inside;+ }+}diff --git a/Aetheris.Kernel.Core.Tests/Brep/Tessellation/BrepDisplayTessellatorTests.cs b/Aetheris.Kernel.Core.Tests/Brep/Tessellation/BrepDisplayTessellatorTests.csindex 7272cf2f..37ec00e3 100644--- a/Aetheris.Kernel.Core.Tests/Brep/Tessellation/BrepDisplayTessellatorTests.cs+++ b/Aetheris.Kernel.Core.Tests/Brep/Tessellation/BrepDisplayTessellatorTests.cs@@ -249,7 +249,9 @@ public sealed class BrepDisplayTessellatorTestsAssert.All(GetTrianglePointSamples(firstPatch), sample =>{Assert.True(IsInsidePolygon(sample, outerLoop));- Assert.False(IsInsidePolygon(sample, holeLoop));+ // Boundary-conforming triangulation places vertices exactly on the hole boundary; only the hole's+ // open interior must stay empty.+ Assert.False(IsStrictlyInsidePolygon(sample, holeLoop));});}@@ -339,7 +341,9 @@ public sealed class BrepDisplayTessellatorTestsAssert.All(GetTriangleUvSamples(firstPatch, point => ProjectCylinderUv(cylinder, point, outerMidU)), sample =>{Assert.True(IsInsideUvRectangle(sample, outerBounds));- Assert.False(IsInsideUvRectangle(sample, holeBounds));+ // Boundary-conforming triangulation places vertices exactly on the hole boundary; only the hole's+ // open interior must stay empty.+ Assert.False(IsStrictlyInsideUvRectangle(sample, holeBounds));});}@@ -1189,6 +1193,40 @@ public sealed class BrepDisplayTessellatorTestsprivate static bool IsInsidePolygon(Point3D point, IReadOnlyList<(double U, double V)> polygon)=> IsInsidePolygon((point.X, point.Y), polygon);+ private static bool IsStrictlyInsidePolygon(Point3D point, IReadOnlyList<(double U, double V)> polygon)+ {+ const double boundaryTolerance = 1e-6d;+ var p = (U: point.X, V: point.Y);+ for (var i = 0; i < polygon.Count; i++)+ {+ var a = polygon[i];+ var b = polygon[(i + 1) % polygon.Count];+ var abU = b.U - a.U;+ var abV = b.V - a.V;+ var lengthSquared = (abU * abU) + (abV * abV);+ var t = lengthSquared <= 0d ? 0d : double.Clamp((((p.U - a.U) * abU) + ((p.V - a.V) * abV)) / lengthSquared, 0d, 1d);+ var dU = p.U - (a.U + (abU * t));+ var dV = p.V - (a.V + (abV * t));+ if (((dU * dU) + (dV * dV)) <= boundaryTolerance * boundaryTolerance)+ {+ return false;+ }+ }++ return IsInsidePolygon(p, polygon);+ }++ private static bool IsStrictlyInsideUvRectangle(+ (double U, double V) point,+ (double UMin, double UMax, double VMin, double VMax) bounds)+ {+ const double boundaryTolerance = 1e-6d;+ return point.U > bounds.UMin + boundaryTolerance+ && point.U < bounds.UMax - boundaryTolerance+ && point.V > bounds.VMin + boundaryTolerance+ && point.V < bounds.VMax - boundaryTolerance;+ }+private static bool IsInsidePolygon((double U, double V) point, IReadOnlyList<(double U, double V)> polygon){var inside = false;diff --git a/Aetheris.Kernel.Core.Tests/Brep/Tessellation/DisplayPreparationFallbackBuilderTests.cs b/Aetheris.Kernel.Core.Tests/Brep/Tessellation/DisplayPreparationFallbackBuilderTests.csindex 1182cd20..cf7a9146 100644--- a/Aetheris.Kernel.Core.Tests/Brep/Tessellation/DisplayPreparationFallbackBuilderTests.cs+++ b/Aetheris.Kernel.Core.Tests/Brep/Tessellation/DisplayPreparationFallbackBuilderTests.cs@@ -47,7 +47,7 @@ public sealed class DisplayPreparationFallbackBuilderTests}[Fact]- public void Build_SingleFaceBsplineBodyWithHole_UsesAcceptedScaffoldPatch()+ public void Build_SingleFaceBsplineBodyWithHole_PrefersBoundaryConformingTessellatorPatch(){var body = UvTrimMaskExtractorTests.ImportBsplineBodyWithHole();@@ -58,8 +58,10 @@ public sealed class DisplayPreparationFallbackBuilderTestsAssert.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);+ // A trimmed face with a hole is now tessellated boundary-conforming (no staircase along the hole), which is+ // sparser than the uniform scaffold grid, so the scaffold lane is correctly declined for it.+ Assert.Equal(DisplayFaceMeshSource.Tessellator, firstPatch.Source);+ Assert.NotEmpty(firstPatch.TriangleIndices);Assert.Equal(CreateSignature(first.Value), CreateSignature(second.Value));}@@ -120,12 +122,14 @@ public sealed class DisplayPreparationFallbackBuilderTestsAssert.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.AcceptedCases);+ Assert.Equal(2, first.RejectedCases);+ Assert.Equal(1, first.SourceHistogram[DisplayFaceMeshSource.BsplineUvScaffold]);+ Assert.Equal(2, 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 == "single-loop-accepted" && c.Accepted && c.Source == DisplayFaceMeshSource.BsplineUvScaffold);+ // The hole case is served by the boundary-conforming tessellator instead of the uniform scaffold grid.+ Assert.Contains(first.Cases, c => c.Name == "two-loop-hole-accepted" && !c.Accepted && c.Source == DisplayFaceMeshSource.Tessellator);Assert.Contains(first.Cases, c => c.Name == "missing-vertex-rejected" && !c.Accepted && c.RejectionReason == "TrimMaskExtraction:MissingVertexPoint");}diff --git a/Aetheris.Kernel.Core.Tests/Step242/Step242BsplineUvGridScaffoldBuilderTests.cs b/Aetheris.Kernel.Core.Tests/Step242/Step242BsplineUvGridScaffoldBuilderTests.csindex 1928e57c..be9cacfb 100644--- a/Aetheris.Kernel.Core.Tests/Step242/Step242BsplineUvGridScaffoldBuilderTests.cs+++ b/Aetheris.Kernel.Core.Tests/Step242/Step242BsplineUvGridScaffoldBuilderTests.cs@@ -85,12 +85,16 @@ public sealed class Step242BsplineUvGridScaffoldBuilderTestsReferencePositions: referencePatch.Positions,ReferenceTriangleCount: referencePatch.TriangleIndices.Count / 3,Acceptance: new BsplineUvGridScaffoldAcceptanceThresholds(- MaxFidelityError: 0.10d,+ // This case checks hole masking, not density or vertex-proximity gating. The reference patch now+ // comes from the boundary-conforming, curvature-adaptive tessellator, which is much sparser than+ // the uniform grid for this flat patch (a planar patch needs only its boundary triangulated), so+ // nearest-reference-vertex fidelity and the density gate are effectively disabled.+ MaxFidelityError: 1d,MaxBoundaryDeviationUv: 0.051d,- MaxTriangleDensityRatioVsFallback: 1.10d)));+ MaxTriangleDensityRatioVsFallback: 1000d)));- Assert.Equal(BsplineUvGridScaffoldAcceptance.Accepted, result.Acceptance);Assert.Equal(BsplineUvGridScaffoldRejectionReason.None, result.RejectionReason);+ Assert.Equal(BsplineUvGridScaffoldAcceptance.Accepted, result.Acceptance);Assert.Equal(0, result.Metrics.LeakageTriangleCount);}diff --git a/Aetheris.Kernel.Core/Brep/Queries/AnalyticPlanarFaceDomain.cs b/Aetheris.Kernel.Core/Brep/Queries/AnalyticPlanarFaceDomain.csindex 19f2daeb..7b9e30c7 100644--- a/Aetheris.Kernel.Core/Brep/Queries/AnalyticPlanarFaceDomain.cs+++ b/Aetheris.Kernel.Core/Brep/Queries/AnalyticPlanarFaceDomain.cs@@ -400,10 +400,24 @@ internal sealed class AnalyticPlanarFaceDomain{var coedge = body.Topology.GetCoedge(coedgeId);var edge = body.Topology.GetEdge(coedge.EdgeId);- if (!body.TryGetVertexPoint(edge.StartVertexId, out var edgeStart)- || !body.TryGetVertexPoint(edge.EndVertexId, out var edgeEnd)- || !body.TryGetEdgeCurveGeometry(coedge.EdgeId, out var curve)- || curve is null)+ if (!body.TryGetEdgeCurveGeometry(coedge.EdgeId, out var curve) || curve is null)+ {+ return false;+ }++ Point3D edgeStart;+ Point3D edgeEnd;+ if (body.TryGetVertexPoint(edge.StartVertexId, out edgeStart)+ && body.TryGetVertexPoint(edge.EndVertexId, out edgeEnd))+ {+ }+ else if (edge.StartVertexId == edge.EndVertexId && curve.Circle3 is { } selfLoopCircle)+ {+ // Revolved primitives carry no vertex points; a closed circle self-loop starts at its X axis.+ edgeStart = selfLoopCircle.Center + (selfLoopCircle.XAxis.ToVector() * selfLoopCircle.Radius);+ edgeEnd = edgeStart;+ }+ else{return false;}diff --git a/Aetheris.Kernel.Core/Brep/Tessellation/BoundaryConformingTrimTessellator.cs b/Aetheris.Kernel.Core/Brep/Tessellation/BoundaryConformingTrimTessellator.csnew file mode 100644index 00000000..814107a6--- /dev/null+++ b/Aetheris.Kernel.Core/Brep/Tessellation/BoundaryConformingTrimTessellator.cs@@ -0,0 +1,566 @@+using Aetheris.Kernel.Core.Math;+using Aetheris.Kernel.Core.Topology;++namespace Aetheris.Kernel.Core.Brep.Tessellation;++/// <summary>+/// Boundary-conforming tessellation of a trimmed parametric face.+/// <para>+/// The mask tessellator in <see cref="TrimmedSurfaceTessellator"/> samples a uniform UV grid and keeps only the+/// cells that lie (almost) entirely inside the trim loops. That leaves a staircase along every trim curve and a gap+/// of up to one cell width between adjacent faces, which is very visible on narrow B-spline patches such as gear+/// flanks. This tessellator instead triangulates the trim loops themselves (so every triangle edge along the+/// boundary is a real boundary sample) and then refines the interior by conforming longest-edge bisection until the+/// triangles satisfy the chord and angular tolerances of the display options (edge-midpoint sag, triangle-centre+/// sag and normal deviation), with a coarse cell-size cap as a safety net.+/// </para>+/// It is deliberately conservative: any input it cannot triangulate as a simple polygon with holes returns null so+/// the caller can fall back to the mask tessellator.+/// </summary>+internal static class BoundaryConformingTrimTessellator+{+ private const int MaxTriangles = 200_000;+ // Never split edges shorter than this fraction of a nominal grid cell (guarantees termination).+ private const double MinimumSplitLength = 0.125d;+ // Safety net: triangles with an edge longer than this many nominal grid cells are always split.+ private const double MaximumCellLength = 8d;+ private const double TieTolerance = 1e-12d;++ public static DisplayFaceMeshPatch? TryTessellate(+ FaceId faceId,+ IReadOnlyList<List<(double U, double V)>> loops,+ int outerLoopIndex,+ Func<double, double, Point3D> evaluate,+ Func<double, double, Vector3D> evaluateNormal,+ double cellU,+ double cellV,+ DisplayTessellationOptions options,+ Action? checkBudget)+ {+ if (!(cellU > 0d) || !(cellV > 0d) || !double.IsFinite(cellU) || !double.IsFinite(cellV))+ {+ return null;+ }++ var outer = loops[outerLoopIndex];+ if (loops.Count == 1 && IsAxisAlignedRectangle(outer))+ {+ // The uniform grid is built from the loop bounds, so a lone axis-aligned rectangle is already+ // reproduced exactly by the mask tessellator; there is no staircase to remove.+ return null;+ }++ var holes = new List<List<(double U, double V)>>();+ for (var i = 0; i < loops.Count; i++)+ {+ if (i != outerLoopIndex)+ {+ holes.Add(loops[i]);+ }+ }++ // Every hole must lie inside the outer loop and not inside another hole; otherwise the loop set is not an+ // "outer minus holes" region (e.g. periodic wrap-around ring) and the mask tessellator must decide.+ foreach (var hole in holes)+ {+ if (!IsStrictlyInside(outer, hole[0]))+ {+ return null;+ }+ }++ for (var i = 0; i < holes.Count; i++)+ {+ for (var j = 0; j < holes.Count; j++)+ {+ if (i != j && IsStrictlyInside(holes[j], holes[i][0]))+ {+ return null;+ }+ }+ }++ // Triangulate in "cell units" so the polygon triangulator's absolute epsilons are well conditioned even for+ // parameter domains that are tiny (a 0.04-wide B-spline patch) or anisotropic (radians x millimetres).+ var outerScaled = ToScaled(outer, cellU, cellV);+ var holesScaled = holes.Select(hole => (IReadOnlyList<(double X, double Y)>)ToScaled(hole, cellU, cellV)).ToList();++ // Preferred: the shared planar polygon triangulator, which also validates that every loop is simple.+ // It occasionally gives up on long, finely sampled loops; a simple polygon it rejects for that reason+ // ("TriangulationFailed") is retried with a robust earcut port. Non-simple input is left to the fallback.+ List<(double X, double Y)> seedPoints;+ List<int> seedIndices;+ if (PlanarPolygonTriangulator.TryTriangulateWithHoles(+ outerScaled.Select(static p => new Point3D(p.X, p.Y, 0d)).ToList(),+ holesScaled.Select(static hole => (IReadOnlyList<Point3D>)hole.Select(static p => new Point3D(p.X, p.Y, 0d)).ToList()).ToList(),+ new Vector3D(0d, 0d, 1d),+ out var triangulationPoints,+ out var triangulationIndices,+ out var triangulationFailure)+ && triangulationIndices.Count >= 3)+ {+ seedPoints = triangulationPoints.Select(static p => (p.X, p.Y)).ToList();+ seedIndices = triangulationIndices.ToList();+ }+ else if (triangulationFailure != PlanarPolygonTriangulationFailure.TriangulationFailed+ || !EarCutTriangulator.TryTriangulate(outerScaled, holesScaled, out seedPoints, out seedIndices))+ {+ return null;+ }++ var mesh = new RefinableMesh(cellU, cellV, evaluate, evaluateNormal, options.ChordTolerance, options.AngularToleranceRadians);+ var pointMap = new int[seedPoints.Count];+ for (var i = 0; i < seedPoints.Count; i++)+ {+ pointMap[i] = mesh.AddVertex(seedPoints[i].X * cellU, seedPoints[i].Y * cellV);+ }++ for (var i = 0; i + 2 < seedIndices.Count; i += 3)+ {+ var a = pointMap[seedIndices[i]];+ var b = pointMap[seedIndices[i + 1]];+ var c = pointMap[seedIndices[i + 2]];+ if (a == b || b == c || a == c)+ {+ continue;+ }++ mesh.AddTriangle(a, b, c);+ }++ if (!mesh.Refine(checkBudget))+ {+ return null;+ }++ var positions = new List<Point3D>(mesh.VertexCount);+ var normals = new List<Vector3D>(mesh.VertexCount);+ for (var i = 0; i < mesh.VertexCount; i++)+ {+ positions.Add(mesh.Position(i));+ normals.Add(mesh.Normal(i));+ }++ // The mask tessellator emits triangles clockwise in (u, v); keep that convention.+ var indices = new List<int>(mesh.AliveTriangleCount * 3);+ foreach (var (a, b, c) in mesh.AliveTriangles())+ {+ var pa = mesh.Vertex(a);+ var pb = mesh.Vertex(b);+ var pc = mesh.Vertex(c);+ var cross = ((pb.U - pa.U) * (pc.V - pa.V)) - ((pb.V - pa.V) * (pc.U - pa.U));+ if (cross == 0d)+ {+ continue;+ }++ if (cross > 0d)+ {+ indices.Add(a);+ indices.Add(c);+ indices.Add(b);+ }+ else+ {+ indices.Add(a);+ indices.Add(b);+ indices.Add(c);+ }+ }++ if (indices.Count == 0)+ {+ return null;+ }++ return new DisplayFaceMeshPatch(faceId, positions, normals, indices);+ }++ private static List<(double X, double Y)> ToScaled(IReadOnlyList<(double U, double V)> loop, double cellU, double cellV)+ {+ var points = new List<(double X, double Y)>(loop.Count);+ foreach (var (u, v) in loop)+ {+ points.Add((u / cellU, v / cellV));+ }++ return points;+ }++ private static bool IsAxisAlignedRectangle(IReadOnlyList<(double U, double V)> loop)+ {+ if (loop.Count != 4)+ {+ return false;+ }++ const double tolerance = 1e-12d;+ for (var i = 0; i < 4; i++)+ {+ var a = loop[i];+ var b = loop[(i + 1) % 4];+ var horizontal = System.Math.Abs(a.V - b.V) <= tolerance;+ var vertical = System.Math.Abs(a.U - b.U) <= tolerance;+ if (horizontal == vertical)+ {+ return false;+ }+ }++ return true;+ }++ private static bool IsStrictlyInside(IReadOnlyList<(double U, double V)> polygon, (double U, double V) point)+ {+ var inside = false;+ for (var i = 0; i < polygon.Count; i++)+ {+ var a = polygon[i];+ var b = polygon[(i + 1) % polygon.Count];+ if ((a.V > point.V) != (b.V > point.V)+ && point.U < ((b.U - a.U) * (point.V - a.V) / (b.V - a.V)) + a.U)+ {+ inside = !inside;+ }+ }++ return inside;+ }++ private sealed class RefinableMesh+ {+ private readonly double _cellU;+ private readonly double _cellV;+ private readonly Func<double, double, Point3D> _evaluate;+ private readonly Func<double, double, Vector3D> _evaluateNormal;+ private readonly double _chordTolerance;+ private readonly double _angularTolerance;+ private readonly List<Point3D?> _positions = new();+ private readonly List<Vector3D?> _normals = new();+ private readonly List<(double U, double V)> _vertices = new();+ private readonly Dictionary<(ulong, ulong), int> _vertexLookup = new();+ private readonly List<int> _triangles = new();+ private readonly List<bool> _alive = new();+ private readonly Dictionary<long, List<int>> _edgeTriangles = new();+ private readonly Stack<int> _work = new();+ private int _aliveCount;++ public RefinableMesh(+ double cellU,+ double cellV,+ Func<double, double, Point3D> evaluate,+ Func<double, double, Vector3D> evaluateNormal,+ double chordTolerance,+ double angularTolerance)+ {+ _cellU = cellU;+ _cellV = cellV;+ _evaluate = evaluate;+ _evaluateNormal = evaluateNormal;+ _chordTolerance = chordTolerance;+ _angularTolerance = angularTolerance;+ }++ public Point3D Position(int index)+ {+ if (_positions[index] is { } cached)+ {+ return cached;+ }++ var (u, v) = _vertices[index];+ var position = _evaluate(u, v);+ _positions[index] = position;+ return position;+ }++ public Vector3D Normal(int index)+ {+ if (_normals[index] is { } cached)+ {+ return cached;+ }++ var (u, v) = _vertices[index];+ var normal = _evaluateNormal(u, v);+ _normals[index] = normal;+ return normal;+ }++ public int VertexCount => _vertices.Count;++ public int AliveTriangleCount => _aliveCount;++ public (double U, double V) Vertex(int index) => _vertices[index];++ public int AddVertex(double u, double v)+ {+ var key = (BitConverter.DoubleToUInt64Bits(u), BitConverter.DoubleToUInt64Bits(v));+ if (_vertexLookup.TryGetValue(key, out var existing))+ {+ return existing;+ }++ var index = _vertices.Count;+ _vertices.Add((u, v));+ _positions.Add(null);+ _normals.Add(null);+ _vertexLookup[key] = index;+ return index;+ }++ public int AddTriangle(int a, int b, int c)+ {+ var id = _alive.Count;+ _triangles.Add(a);+ _triangles.Add(b);+ _triangles.Add(c);+ _alive.Add(true);+ _aliveCount++;+ LinkEdge(a, b, id);+ LinkEdge(b, c, id);+ LinkEdge(c, a, id);+ _work.Push(id);+ return id;+ }++ public IEnumerable<(int A, int B, int C)> AliveTriangles()+ {+ for (var t = 0; t < _alive.Count; t++)+ {+ if (_alive[t])+ {+ yield return (_triangles[3 * t], _triangles[(3 * t) + 1], _triangles[(3 * t) + 2]);+ }+ }+ }++ public bool Refine(Action? checkBudget)+ {+ var iterations = 0;+ while (_work.Count > 0)+ {+ if ((++iterations & 0xFF) == 0)+ {+ checkBudget?.Invoke();+ }++ if (_alive.Count > MaxTriangles)+ {+ return false;+ }++ var t = _work.Pop();+ if (!_alive[t] || !NeedsSplit(t))+ {+ continue;+ }++ // Longest-edge propagation path: walk to the neighbour across the longest edge until both+ // triangles agree the shared edge is their longest, then bisect it. This keeps the mesh conforming.+ var current = t;+ var guard = 0;+ while (true)+ {+ var slot = LongestEdgeSlot(current);+ var key = EdgeKey(current, slot);+ var neighbour = OtherTriangle(key, current);+ if (neighbour < 0 || EdgeKey(neighbour, LongestEdgeSlot(neighbour)) == key)+ {+ SplitEdge(current, slot);+ break;+ }++ current = neighbour;+ if (++guard > 100_000)+ {+ return false;+ }+ }++ if (_alive[t])+ {+ _work.Push(t);+ }+ }++ return true;+ }++ private bool NeedsSplit(int triangle)+ {+ var longest = LongestEdgeLength(triangle);+ if (longest <= MinimumSplitLength)+ {+ return false;+ }++ if (longest > MaximumCellLength)+ {+ return true;+ }++ var a = _triangles[3 * triangle];+ var b = _triangles[(3 * triangle) + 1];+ var c = _triangles[(3 * triangle) + 2];+ for (var slot = 0; slot < 3; slot++)+ {+ if (EdgeLength(triangle, slot) <= MinimumSplitLength)+ {+ continue;+ }++ var p = _triangles[(3 * triangle) + slot];+ var q = _triangles[(3 * triangle) + ((slot + 1) % 3)];+ var (pu, pv) = _vertices[p];+ var (qu, qv) = _vertices[q];+ var midpoint = _evaluate((pu + qu) * 0.5d, (pv + qv) * 0.5d);+ var pp = Position(p);+ var pq = Position(q);+ var chordMidpoint = new Point3D((pp.X + pq.X) * 0.5d, (pp.Y + pq.Y) * 0.5d, (pp.Z + pq.Z) * 0.5d);+ if ((midpoint - chordMidpoint).Length > _chordTolerance)+ {+ return true;+ }++ var np = Normal(p);+ var nq = Normal(q);+ var lp = np.Length;+ var lq = nq.Length;+ if (lp > 1e-12d && lq > 1e-12d)+ {+ var cosine = double.Clamp(np.Dot(nq) / (lp * lq), -1d, 1d);+ if (double.Acos(cosine) > _angularTolerance)+ {+ return true;+ }+ }+ }++ var (au, av) = _vertices[a];+ var (bu, bv) = _vertices[b];+ var (cu, cv) = _vertices[c];+ var centre = _evaluate((au + bu + cu) / 3d, (av + bv + cv) / 3d);+ var pa = Position(a);+ var pb = Position(b);+ var pc = Position(c);+ var average = new Point3D((pa.X + pb.X + pc.X) / 3d, (pa.Y + pb.Y + pc.Y) / 3d, (pa.Z + pb.Z + pc.Z) / 3d);+ return (centre - average).Length > _chordTolerance;+ }++ private void SplitEdge(int triangle, int slot)+ {+ var a = _triangles[(3 * triangle) + slot];+ var b = _triangles[(3 * triangle) + ((slot + 1) % 3)];+ var key = MakeKey(a, b);+ var sharing = _edgeTriangles[key].ToArray();+ var (au, av) = _vertices[a];+ var (bu, bv) = _vertices[b];+ var mid = AddVertex((au + bu) * 0.5d, (av + bv) * 0.5d);++ foreach (var id in sharing)+ {+ var s = 0;+ for (; s < 3; s++)+ {+ var p = _triangles[(3 * id) + s];+ var q = _triangles[(3 * id) + ((s + 1) % 3)];+ if (MakeKey(p, q) == key)+ {+ break;+ }+ }++ var x = _triangles[(3 * id) + s];+ var y = _triangles[(3 * id) + ((s + 1) % 3)];+ var z = _triangles[(3 * id) + ((s + 2) % 3)];+ Kill(id);+ AddTriangle(x, mid, z);+ AddTriangle(mid, y, z);+ }+ }++ private void Kill(int id)+ {+ _alive[id] = false;+ _aliveCount--;+ for (var s = 0; s < 3; s++)+ {+ var key = EdgeKey(id, s);+ if (_edgeTriangles.TryGetValue(key, out var list))+ {+ list.Remove(id);+ }+ }+ }++ private int OtherTriangle(long key, int self)+ {+ if (!_edgeTriangles.TryGetValue(key, out var list))+ {+ return -1;+ }++ foreach (var id in list)+ {+ if (id != self && _alive[id])+ {+ return id;+ }+ }++ return -1;+ }++ private void LinkEdge(int a, int b, int triangle)+ {+ var key = MakeKey(a, b);+ if (!_edgeTriangles.TryGetValue(key, out var list))+ {+ list = new List<int>(2);+ _edgeTriangles[key] = list;+ }++ list.Add(triangle);+ }++ private static long MakeKey(int a, int b)+ => a < b ? ((long)a << 32) | (uint)b : ((long)b << 32) | (uint)a;++ private long EdgeKey(int triangle, int slot)+ => MakeKey(_triangles[(3 * triangle) + slot], _triangles[(3 * triangle) + ((slot + 1) % 3)]);++ private double EdgeLength(int triangle, int slot)+ {+ var (au, av) = _vertices[_triangles[(3 * triangle) + slot]];+ var (bu, bv) = _vertices[_triangles[(3 * triangle) + ((slot + 1) % 3)]];+ var du = (bu - au) / _cellU;+ var dv = (bv - av) / _cellV;+ return double.Sqrt((du * du) + (dv * dv));+ }++ private double LongestEdgeLength(int triangle)+ => System.Math.Max(EdgeLength(triangle, 0), System.Math.Max(EdgeLength(triangle, 1), EdgeLength(triangle, 2)));++ private int LongestEdgeSlot(int triangle)+ {+ var best = 0;+ var bestLength = EdgeLength(triangle, 0);+ var bestKey = EdgeKey(triangle, 0);+ for (var s = 1; s < 3; s++)+ {+ var length = EdgeLength(triangle, s);+ var key = EdgeKey(triangle, s);+ if (length > bestLength + TieTolerance+ || (System.Math.Abs(length - bestLength) <= TieTolerance && key < bestKey))+ {+ best = s;+ bestLength = length;+ bestKey = key;+ }+ }++ return best;+ }+ }+}diff --git a/Aetheris.Kernel.Core/Brep/Tessellation/BrepDisplayTessellator.cs b/Aetheris.Kernel.Core/Brep/Tessellation/BrepDisplayTessellator.csindex 9d733427..b694705a 100644--- a/Aetheris.Kernel.Core/Brep/Tessellation/BrepDisplayTessellator.cs+++ b/Aetheris.Kernel.Core/Brep/Tessellation/BrepDisplayTessellator.cs@@ -937,7 +937,7 @@ public static class BrepDisplayTessellatorreturn KernelResult<DisplayFaceMeshPatch>.Success(CreateEmptyPlanarPatch(faceId),[CreateValidationWarning(- $"Face {faceId.Value} BSpline trim evaluation failed; skipping face patch to avoid misleading untrimmed geometry.",+ $"Face {faceId.Value} BSpline trim evaluation failed ({string.Join(" | ", uvLoopsResult.Diagnostics.Select(diagnostic => diagnostic.Message))}); skipping face patch to avoid misleading untrimmed geometry.",TrimEvaluationFailedSource)]);}@@ -963,21 +963,22 @@ public static class BrepDisplayTessellatorvar vStart = surface.DomainStartV;var vEnd = surface.DomainEndV;- const int coarseSegments = 10;+ // Coarse grid seed. Scale with the control net so long, thin or heavily curved patches+ // (e.g. gear tooth flanks) still seed inside the correct basin.+ var controlRows = surface.ControlPoints.Count;+ var controlColumns = controlRows > 0 ? surface.ControlPoints[0].Count : 0;+ var coarseSegments = System.Math.Clamp(System.Math.Max(controlRows, controlColumns) * 4, 16, 32);var bestU = uStart;var bestV = vStart;var bestDistanceSquared = double.PositiveInfinity;for (var iu = 0; iu <= coarseSegments; iu++){- var tu = (double)iu / coarseSegments;- var u = uStart + ((uEnd - uStart) * tu);+ var u = uStart + ((uEnd - uStart) * iu / coarseSegments);for (var iv = 0; iv <= coarseSegments; iv++){- var tv = (double)iv / coarseSegments;- var v = vStart + ((vEnd - vStart) * tv);- var sample = surface.Evaluate(u, v);- var delta = sample - point;+ var v = vStart + ((vEnd - vStart) * iv / coarseSegments);+ var delta = surface.Evaluate(u, v) - point;var distanceSquared = delta.Dot(delta);if (distanceSquared < bestDistanceSquared){@@ -988,45 +989,74 @@ public static class BrepDisplayTessellator}}- var uStep = (uEnd - uStart) / coarseSegments;- var vStep = (vEnd - vStart) / coarseSegments;-- for (var iteration = 0; iteration < 6; iteration++)- {- var nextUStep = uStep * 0.5d;- var nextVStep = vStep * 0.5d;- var localBestU = bestU;- var localBestV = bestV;- var localBestDistance = bestDistanceSquared;+ // Levenberg-Marquardt refinement of |S(u,v) - P|^2, clamped to the surface domain. The previous+ // fixed 6-step pattern search only resolved ~1/640 of the domain, which left residuals above the+ // acceptance tolerance for perfectly valid boundary samples and dropped whole faces.+ var uSpan = uEnd - uStart;+ var vSpan = vEnd - vStart;+ var lambda = 1e-3d;+ var done = false;+ for (var iteration = 0; iteration < 60 && !done; iteration++)+ {+ var uPlus = System.Math.Min(bestU + (uSpan * 1e-6d), uEnd);+ var uMinus = System.Math.Max(bestU - (uSpan * 1e-6d), uStart);+ var vPlus = System.Math.Min(bestV + (vSpan * 1e-6d), vEnd);+ var vMinus = System.Math.Max(bestV - (vSpan * 1e-6d), vStart);+ if (uPlus - uMinus <= 0d || vPlus - vMinus <= 0d)+ {+ break;+ }- for (var du = -1; du <= 1; du++)+ var tangentU = (surface.Evaluate(uPlus, bestV) - surface.Evaluate(uMinus, bestV)) * (1d / (uPlus - uMinus));+ var tangentV = (surface.Evaluate(bestU, vPlus) - surface.Evaluate(bestU, vMinus)) * (1d / (vPlus - vMinus));+ var residualVector = surface.Evaluate(bestU, bestV) - point;+ var a11 = tangentU.Dot(tangentU);+ var a12 = tangentU.Dot(tangentV);+ var a22 = tangentV.Dot(tangentV);+ var b1 = -tangentU.Dot(residualVector);+ var b2 = -tangentV.Dot(residualVector);++ var accepted = false;+ for (var attempt = 0; attempt < 10 && !accepted; attempt++){- var u = System.Math.Clamp(bestU + (du * uStep), uStart, uEnd);- for (var dv = -1; dv <= 1; dv++)+ var m11 = (a11 * (1d + lambda)) + 1e-30d;+ var m22 = (a22 * (1d + lambda)) + 1e-30d;+ var determinant = (m11 * m22) - (a12 * a12);+ if (!(System.Math.Abs(determinant) > 1e-300d)){- var v = System.Math.Clamp(bestV + (dv * vStep), vStart, vEnd);- var sample = surface.Evaluate(u, v);- var delta = sample - point;- var distanceSquared = delta.Dot(delta);- if (distanceSquared < localBestDistance)- {- localBestDistance = distanceSquared;- localBestU = u;- localBestV = v;- }+ lambda *= 10d;+ continue;+ }++ var stepU = ((b1 * m22) - (a12 * b2)) / determinant;+ var stepV = ((m11 * b2) - (a12 * b1)) / determinant;+ var candidateU = System.Math.Clamp(bestU + stepU, uStart, uEnd);+ var candidateV = System.Math.Clamp(bestV + stepV, vStart, vEnd);+ var candidateDelta = surface.Evaluate(candidateU, candidateV) - point;+ var candidateDistanceSquared = candidateDelta.Dot(candidateDelta);+ if (candidateDistanceSquared < bestDistanceSquared)+ {+ done = System.Math.Abs(candidateU - bestU) <= uSpan * 1e-13d+ && System.Math.Abs(candidateV - bestV) <= vSpan * 1e-13d;+ bestU = candidateU;+ bestV = candidateV;+ bestDistanceSquared = candidateDistanceSquared;+ lambda = System.Math.Max(lambda * 0.3d, 1e-12d);+ accepted = true;+ }+ else+ {+ lambda *= 10d;}}- bestU = localBestU;- bestV = localBestV;- bestDistanceSquared = localBestDistance;- uStep = nextUStep;- vStep = nextVStep;+ if (!accepted)+ {+ break;+ }}- var bestSample = surface.Evaluate(bestU, bestV);- var residual = bestSample - point;- var residualDistance = System.Math.Sqrt(residual.Dot(residual));+ var residualDistance = System.Math.Sqrt(bestDistanceSquared);var tolerance = ComputeBSplineProjectionTolerance(surface);if (residualDistance > tolerance){diff --git a/Aetheris.Kernel.Core/Brep/Tessellation/EarCutTriangulator.cs b/Aetheris.Kernel.Core/Brep/Tessellation/EarCutTriangulator.csnew file mode 100644index 00000000..1cc26ab0--- /dev/null+++ b/Aetheris.Kernel.Core/Brep/Tessellation/EarCutTriangulator.cs@@ -0,0 +1,547 @@+namespace Aetheris.Kernel.Core.Brep.Tessellation;++/// <summary>+/// Robust ear-clipping triangulation of a simple polygon with holes, ported from the well-known earcut+/// algorithm (hole bridging, local-intersection curing and polygon splitting fallbacks). Used as a second+/// opinion when <see cref="PlanarPolygonTriangulator"/> declines a polygon that is nevertheless simple, which+/// happens for long, finely sampled trim loops with many near-collinear vertices.+/// </summary>+internal static class EarCutTriangulator+{+ public static bool TryTriangulate(+ IReadOnlyList<(double X, double Y)> outer,+ IReadOnlyList<IReadOnlyList<(double X, double Y)>> holes,+ out List<(double X, double Y)> points,+ out List<int> indices)+ {+ points = new List<(double X, double Y)>(outer);+ indices = new List<int>();+ var holeRanges = new List<(int Start, int End)>(holes.Count);+ foreach (var hole in holes)+ {+ var start = points.Count;+ points.AddRange(hole);+ holeRanges.Add((start, points.Count));+ }++ var outerNode = CreateRing(points, 0, outer.Count, clockwise: true);+ if (outerNode is null || outerNode.Next == outerNode.Prev)+ {+ return false;+ }++ if (holeRanges.Count > 0)+ {+ outerNode = EliminateHoles(points, holeRanges, outerNode);+ if (outerNode is null)+ {+ return false;+ }+ }++ EarcutLinked(outerNode, indices, 0);+ if (indices.Count < 3)+ {+ return false;+ }++ // Guard: the triangles must tile the polygon-with-holes area.+ var expected = System.Math.Abs(RingArea(points, 0, outer.Count));+ foreach (var (start, end) in holeRanges)+ {+ expected -= System.Math.Abs(RingArea(points, start, end));+ }++ var actual = 0d;+ for (var i = 0; i + 2 < indices.Count; i += 3)+ {+ var a = points[indices[i]];+ var b = points[indices[i + 1]];+ var c = points[indices[i + 2]];+ actual += System.Math.Abs(((b.X - a.X) * (c.Y - a.Y)) - ((b.Y - a.Y) * (c.X - a.X))) * 0.5d;+ }++ return System.Math.Abs(actual - expected) <= System.Math.Max(1e-9d, expected * 1e-6d);+ }++ private sealed class Node(int index, double x, double y)+ {+ public int Index { get; } = index;++ public double X { get; } = x;++ public double Y { get; } = y;++ public Node Prev { get; set; } = null!;++ public Node Next { get; set; } = null!;++ public bool Steiner { get; set; }+ }++ private static double RingArea(List<(double X, double Y)> pts, int start, int end)+ {+ var sum = 0d;+ for (int i = start, j = end - 1; i < end; j = i++)+ {+ sum += (pts[j].X - pts[i].X) * (pts[i].Y + pts[j].Y);+ }++ return sum * 0.5d;+ }++ private static Node? CreateRing(List<(double X, double Y)> pts, int start, int end, bool clockwise)+ {+ Node? last = null;+ if (clockwise == (SignedArea(pts, start, end) > 0d))+ {+ for (var i = start; i < end; i++)+ {+ last = InsertNode(i, pts[i].X, pts[i].Y, last);+ }+ }+ else+ {+ for (var i = end - 1; i >= start; i--)+ {+ last = InsertNode(i, pts[i].X, pts[i].Y, last);+ }+ }++ if (last is not null && Same(last, last.Next))+ {+ RemoveNode(last);+ last = last.Next;+ }++ return last;+ }++ private static double SignedArea(List<(double X, double Y)> pts, int start, int end)+ {+ var sum = 0d;+ for (int i = start, j = end - 1; i < end; j = i++)+ {+ sum += (pts[j].X - pts[i].X) * (pts[i].Y + pts[j].Y);+ }++ return sum;+ }++ private static Node? FilterPoints(Node? start, Node? end = null)+ {+ if (start is null)+ {+ return null;+ }++ end ??= start;+ var p = start;+ bool again;+ do+ {+ again = false;+ if (!p.Steiner && (Same(p, p.Next) || System.Math.Abs(Area(p.Prev, p, p.Next)) <= 1e-14d))+ {+ RemoveNode(p);+ p = end = p.Prev;+ if (p == p.Next)+ {+ break;+ }++ again = true;+ }+ else+ {+ p = p.Next;+ }+ }+ while (again || p != end);++ return end;+ }++ private static void EarcutLinked(Node? ear, List<int> triangles, int pass)+ {+ if (ear is null)+ {+ return;+ }++ var stop = ear;+ while (ear.Prev != ear.Next)+ {+ var prev = ear.Prev;+ var next = ear.Next;+ if (IsEar(ear))+ {+ triangles.Add(prev.Index);+ triangles.Add(ear.Index);+ triangles.Add(next.Index);+ RemoveNode(ear);+ ear = next.Next;+ stop = next.Next;+ continue;+ }++ ear = next;+ if (ear == stop)+ {+ if (pass == 0)+ {+ EarcutLinked(FilterPoints(ear), triangles, 1);+ }+ else if (pass == 1)+ {+ var cured = CureLocalIntersections(FilterPoints(ear)!, triangles);+ EarcutLinked(cured, triangles, 2);+ }+ else if (pass == 2)+ {+ SplitEarcut(ear, triangles);+ }++ break;+ }+ }+ }++ private static bool IsEar(Node ear)+ {+ var a = ear.Prev;+ var b = ear;+ var c = ear.Next;+ if (Area(a, b, c) >= 0d)+ {+ return false;+ }++ var p = c.Next;+ while (p != a)+ {+ if (!SamePosition(p, a) && !SamePosition(p, b) && !SamePosition(p, c)+ && PointInTriangle(a.X, a.Y, b.X, b.Y, c.X, c.Y, p.X, p.Y)+ && Area(p.Prev, p, p.Next) >= 0d)+ {+ return false;+ }++ p = p.Next;+ }++ return true;+ }++ private static Node? CureLocalIntersections(Node start, List<int> triangles)+ {+ var p = start;+ do+ {+ var a = p.Prev;+ var b = p.Next.Next;+ if (!Same(a, b) && Intersects(a, p, p.Next, b) && LocallyInside(a, b) && LocallyInside(b, a))+ {+ triangles.Add(a.Index);+ triangles.Add(p.Index);+ triangles.Add(b.Index);+ RemoveNode(p);+ RemoveNode(p.Next);+ p = start = b;+ }++ p = p.Next;+ }+ while (p != start);++ return FilterPoints(p);+ }++ private static void SplitEarcut(Node start, List<int> triangles)+ {+ var a = start;+ do+ {+ var b = a.Next.Next;+ while (b != a.Prev)+ {+ if (a.Index != b.Index && IsValidDiagonal(a, b))+ {+ var c = SplitPolygon(a, b);+ a = FilterPoints(a, a.Next)!;+ c = FilterPoints(c, c.Next)!;+ EarcutLinked(a, triangles, 0);+ EarcutLinked(c, triangles, 0);+ return;+ }++ b = b.Next;+ }++ a = a.Next;+ }+ while (a != start);+ }++ private static Node? EliminateHoles(List<(double X, double Y)> pts, List<(int Start, int End)> holeRanges, Node outerNode)+ {+ var queue = new List<Node>(holeRanges.Count);+ foreach (var (start, end) in holeRanges)+ {+ var list = CreateRing(pts, start, end, clockwise: false);+ if (list is null)+ {+ continue;+ }++ if (list == list.Next)+ {+ list.Steiner = true;+ }++ queue.Add(GetLeftmost(list));+ }++ queue.Sort(static (x, y) => x.X != y.X ? x.X.CompareTo(y.X) : x.Y.CompareTo(y.Y));+ Node? current = outerNode;+ foreach (var hole in queue)+ {+ current = EliminateHole(hole, current!);+ if (current is null)+ {+ return null;+ }+ }++ return current;+ }++ private static Node? EliminateHole(Node hole, Node outerNode)+ {+ var bridge = FindHoleBridge(hole, outerNode);+ if (bridge is null)+ {+ return null;+ }++ var bridgeReverse = SplitPolygon(bridge, hole);+ FilterPoints(bridgeReverse, bridgeReverse.Next);+ return FilterPoints(bridge, bridge.Next);+ }++ private static Node? FindHoleBridge(Node hole, Node outerNode)+ {+ var p = outerNode;+ var hx = hole.X;+ var hy = hole.Y;+ var qx = double.NegativeInfinity;+ Node? m = null;+ do+ {+ if (hy <= p.Y && hy >= p.Next.Y && p.Next.Y != p.Y)+ {+ var x = p.X + ((hy - p.Y) * (p.Next.X - p.X) / (p.Next.Y - p.Y));+ if (x <= hx && x > qx)+ {+ qx = x;+ m = p.X < p.Next.X ? p : p.Next;+ if (x == hx)+ {+ return m;+ }+ }+ }++ p = p.Next;+ }+ while (p != outerNode);++ if (m is null)+ {+ return null;+ }++ var stop = m;+ var mx = m.X;+ var my = m.Y;+ var tanMin = double.PositiveInfinity;+ p = m;+ do+ {+ if (hx >= p.X && p.X >= mx && hx != p.X+ && PointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.X, p.Y))+ {+ var tan = System.Math.Abs(hy - p.Y) / (hx - p.X);+ if (LocallyInside(p, hole)+ && (tan < tanMin || (tan == tanMin && (p.X > m.X || (p.X == m.X && SectorContainsSector(m, p))))))+ {+ m = p;+ tanMin = tan;+ }+ }++ p = p.Next;+ }+ while (p != stop);++ return m;+ }++ private static bool SectorContainsSector(Node m, Node p)+ => Area(m.Prev, m, p.Prev) < 0d && Area(p.Next, m, m.Next) < 0d;++ private static Node GetLeftmost(Node start)+ {+ var p = start;+ var leftmost = start;+ do+ {+ if (p.X < leftmost.X || (p.X == leftmost.X && p.Y < leftmost.Y))+ {+ leftmost = p;+ }++ p = p.Next;+ }+ while (p != start);++ return leftmost;+ }++ private static bool PointInTriangle(double ax, double ay, double bx, double by, double cx, double cy, double px, double py)+ => ((cx - px) * (ay - py)) >= ((ax - px) * (cy - py))+ && ((ax - px) * (by - py)) >= ((bx - px) * (ay - py))+ && ((bx - px) * (cy - py)) >= ((cx - px) * (by - py));++ private static bool IsValidDiagonal(Node a, Node b)+ => a.Next.Index != b.Index && a.Prev.Index != b.Index && !IntersectsPolygon(a, b)+ && ((LocallyInside(a, b) && LocallyInside(b, a) && MiddleInside(a, b)+ && (Area(a.Prev, a, b.Prev) != 0d || Area(a, b.Prev, b) != 0d))+ || (Same(a, b) && Area(a.Prev, a, a.Next) > 0d && Area(b.Prev, b, b.Next) > 0d));++ private static double Area(Node p, Node q, Node r)+ => ((q.Y - p.Y) * (r.X - q.X)) - ((q.X - p.X) * (r.Y - q.Y));++ private static bool Same(Node p1, Node p2) => p1.X == p2.X && p1.Y == p2.Y;++ private static bool SamePosition(Node p1, Node p2) => p1.X == p2.X && p1.Y == p2.Y;++ private static bool Intersects(Node p1, Node q1, Node p2, Node q2)+ {+ var o1 = System.Math.Sign(Area(p1, q1, p2));+ var o2 = System.Math.Sign(Area(p1, q1, q2));+ var o3 = System.Math.Sign(Area(p2, q2, p1));+ var o4 = System.Math.Sign(Area(p2, q2, q1));+ if (o1 != o2 && o3 != o4)+ {+ return true;+ }++ if (o1 == 0 && OnSegment(p1, p2, q1))+ {+ return true;+ }++ if (o2 == 0 && OnSegment(p1, q2, q1))+ {+ return true;+ }++ if (o3 == 0 && OnSegment(p2, p1, q2))+ {+ return true;+ }++ return o4 == 0 && OnSegment(p2, q1, q2);+ }++ private static bool OnSegment(Node p, Node q, Node r)+ => q.X <= System.Math.Max(p.X, r.X) && q.X >= System.Math.Min(p.X, r.X)+ && q.Y <= System.Math.Max(p.Y, r.Y) && q.Y >= System.Math.Min(p.Y, r.Y);++ private static bool IntersectsPolygon(Node a, Node b)+ {+ var p = a;+ do+ {+ if (p.Index != a.Index && p.Next.Index != a.Index && p.Index != b.Index && p.Next.Index != b.Index+ && Intersects(p, p.Next, a, b))+ {+ return true;+ }++ p = p.Next;+ }+ while (p != a);++ return false;+ }++ private static bool LocallyInside(Node a, Node b)+ => Area(a.Prev, a, a.Next) < 0d+ ? Area(a, b, a.Next) >= 0d && Area(a, a.Prev, b) >= 0d+ : Area(a, b, a.Prev) < 0d || Area(a, a.Next, b) < 0d;++ private static bool MiddleInside(Node a, Node b)+ {+ var p = a;+ var inside = false;+ var px = (a.X + b.X) / 2d;+ var py = (a.Y + b.Y) / 2d;+ do+ {+ if (((p.Y > py) != (p.Next.Y > py)) && p.Next.Y != p.Y+ && (px < (((p.Next.X - p.X) * (py - p.Y)) / (p.Next.Y - p.Y)) + p.X))+ {+ inside = !inside;+ }++ p = p.Next;+ }+ while (p != a);++ return inside;+ }++ private static Node SplitPolygon(Node a, Node b)+ {+ var a2 = new Node(a.Index, a.X, a.Y);+ var b2 = new Node(b.Index, b.X, b.Y);+ var an = a.Next;+ var bp = b.Prev;+ a.Next = b;+ b.Prev = a;+ a2.Next = an;+ an.Prev = a2;+ b2.Next = a2;+ a2.Prev = b2;+ bp.Next = b2;+ b2.Prev = bp;+ return b2;+ }++ private static Node InsertNode(int index, double x, double y, Node? last)+ {+ var p = new Node(index, x, y);+ if (last is null)+ {+ p.Prev = p;+ p.Next = p;+ }+ else+ {+ p.Next = last.Next;+ p.Prev = last;+ last.Next.Prev = p;+ last.Next = p;+ }++ return p;+ }++ private static void RemoveNode(Node p)+ {+ p.Next.Prev = p.Prev;+ p.Prev.Next = p.Next;+ }+}diff --git a/Aetheris.Kernel.Core/Brep/Tessellation/TrimmedSurfaceTessellator.cs b/Aetheris.Kernel.Core/Brep/Tessellation/TrimmedSurfaceTessellator.csindex 6dee5231..a669d017 100644--- a/Aetheris.Kernel.Core/Brep/Tessellation/TrimmedSurfaceTessellator.cs+++ b/Aetheris.Kernel.Core/Brep/Tessellation/TrimmedSurfaceTessellator.cs@@ -70,6 +70,24 @@ internal static class TrimmedSurfaceTessellatorvar uSegments = ResolveSegmentCount(uEnd - uStart, options);var vSegments = ResolveSegmentCount(vEnd - vStart, options);+ // Prefer a boundary-conforming triangulation: the uniform-grid mask below leaves a staircase along every+ // trim curve and a gap of up to one cell between neighbouring faces. It stays as the fallback for loop sets+ // that are not a simple "outer minus holes" region (for example periodic wrap-around rings).+ var conformingPatch = BoundaryConformingTrimTessellator.TryTessellate(+ faceId,+ normalizedLoops,+ outerLoopIndex,+ evaluate,+ evaluateNormal,+ (uEnd - uStart) / uSegments,+ (vEnd - vStart) / vSegments,+ options,+ () => executionBudget?.ThrowIfExpired("TrimmedSurface.Conforming", faceId, surfaceKind));+ if (conformingPatch is not null)+ {+ return KernelResult<DisplayFaceMeshPatch>.Success(conformingPatch);+ }+var positions = new List<Point3D>((uSegments + 1) * (vSegments + 1));var normals = new List<Vector3D>((uSegments + 1) * (vSegments + 1));var uvGrid = new List<(double U, double V)>((uSegments + 1) * (vSegments + 1));