Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Add internal BSpline UV-grid scaffold builder with acceptance gates

Yuechen Li8ea965bca75a
diff --git a/Aetheris.Kernel.Core.Tests/Step242/Step242BsplineUvGridScaffoldBuilderTests.cs b/Aetheris.Kernel.Core.Tests/Step242/Step242BsplineUvGridScaffoldBuilderTests.cs
new file mode 100644
index 00000000..0d75b8bd
--- /dev/null
+++ b/Aetheris.Kernel.Core.Tests/Step242/Step242BsplineUvGridScaffoldBuilderTests.cs
@@ -0,0 +1,288 @@
+using Aetheris.Kernel.Core.Brep;
+using Aetheris.Kernel.Core.Brep.Tessellation;
+using Aetheris.Kernel.Core.Geometry;
+using Aetheris.Kernel.Core.Geometry.Curves;
+using Aetheris.Kernel.Core.Geometry.Surfaces;
+using Aetheris.Kernel.Core.Math;
+using Aetheris.Kernel.Core.Step242;
+using Aetheris.Kernel.Core.Topology;
+
+namespace Aetheris.Kernel.Core.Tests.Step242;
+
+public sealed class Step242BsplineUvGridScaffoldBuilderTests
+{
+ private static readonly BsplineUvGridScaffoldBuilder Builder = new();
+
+ [Fact]
+ public void M18_M17h_RectangularFace_IsAccepted_AndDeterministic()
+ {
+ var body = ImportRepresentativeBsplineBody();
+ var face = Assert.Single(body.Topology.Faces);
+ var surface = GetBsplineSurface(body, face.Id);
+ var referencePatch = GetReferencePatch(body, face.Id);
+
+ var request = new BsplineUvGridScaffoldBuildRequest(
+ USegments: 12,
+ VSegments: 12,
+ ReferencePositions: referencePatch.Positions,
+ ReferenceTriangleCount: referencePatch.TriangleIndices.Count / 3,
+ MaxFidelityError: 0.08d,
+ MaxTriangleDensityRatioVsFallback: 1.10d);
+
+ var first = Builder.Build(surface, request);
+ var second = Builder.Build(surface, request);
+
+ Assert.Equal(BsplineUvGridScaffoldAcceptance.Accepted, first.Acceptance);
+ Assert.Equal(BsplineUvGridScaffoldRejectionReason.None, first.RejectionReason);
+ Assert.NotNull(first.Mesh);
+ Assert.Equal(first.Mesh!.Positions, second.Mesh!.Positions);
+ Assert.Equal(first.Mesh.TriangleIndices, second.Mesh.TriangleIndices);
+ Assert.Equal(first.Acceptance, second.Acceptance);
+ Assert.Equal(first.RejectionReason, second.RejectionReason);
+ }
+
+ [Fact]
+ public void M18_M17h2_CurvedRectangularFace_IsAccepted()
+ {
+ var body = CreateHarderCurvedRectangularBsplineBody();
+ var face = Assert.Single(body.Topology.Faces);
+ var surface = GetBsplineSurface(body, face.Id);
+ var referencePatch = GetReferencePatch(body, face.Id);
+
+ var result = Builder.Build(
+ surface,
+ new BsplineUvGridScaffoldBuildRequest(
+ USegments: 16,
+ VSegments: 16,
+ ReferencePositions: referencePatch.Positions,
+ ReferenceTriangleCount: referencePatch.TriangleIndices.Count / 3,
+ MaxFidelityError: 0.08d,
+ MaxTriangleDensityRatioVsFallback: 1.10d));
+
+ Assert.Equal(BsplineUvGridScaffoldAcceptance.Accepted, result.Acceptance);
+ Assert.Equal(BsplineUvGridScaffoldRejectionReason.None, result.RejectionReason);
+ }
+
+ [Fact]
+ public void M18_M17h3_InnerHoleMaskedCase_IsAccepted_WithoutLeakage()
+ {
+ var body = CreateTrimmedPlanarBsplineBodyWithRectangularHole(out var outerLoopUv, out var innerHoleUv);
+ var face = Assert.Single(body.Topology.Faces);
+ var surface = GetBsplineSurface(body, face.Id);
+ var referencePatch = GetReferencePatch(body, face.Id);
+
+ var trimMask = new BsplineUvGridTrimMask(outerLoopUv, [innerHoleUv]);
+
+ var result = Builder.Build(
+ surface,
+ new BsplineUvGridScaffoldBuildRequest(
+ USegments: 20,
+ VSegments: 20,
+ TrimMask: trimMask,
+ ReferencePositions: referencePatch.Positions,
+ ReferenceTriangleCount: referencePatch.TriangleIndices.Count / 3,
+ MaxFidelityError: 0.10d,
+ MaxBoundaryDeviationUv: 0.051d,
+ MaxTriangleDensityRatioVsFallback: 1.10d));
+
+ Assert.Equal(BsplineUvGridScaffoldAcceptance.Accepted, result.Acceptance);
+ Assert.Equal(BsplineUvGridScaffoldRejectionReason.None, result.RejectionReason);
+ Assert.Equal(0, result.Metrics.LeakageTriangleCount);
+ }
+
+ [Fact]
+ public void M18_Rejects_WhenTooDenseVsFallback_AndProvidesReason()
+ {
+ var body = ImportRepresentativeBsplineBody();
+ var face = Assert.Single(body.Topology.Faces);
+ var surface = GetBsplineSurface(body, face.Id);
+ var referencePatch = GetReferencePatch(body, face.Id);
+
+ var accepted = Builder.Build(
+ surface,
+ new BsplineUvGridScaffoldBuildRequest(
+ USegments: 12,
+ VSegments: 12,
+ ReferencePositions: referencePatch.Positions,
+ ReferenceTriangleCount: referencePatch.TriangleIndices.Count / 3,
+ MaxFidelityError: 0.08d,
+ MaxTriangleDensityRatioVsFallback: 1.10d));
+
+ var rejected = Builder.Build(
+ surface,
+ new BsplineUvGridScaffoldBuildRequest(
+ USegments: 12,
+ VSegments: 12,
+ ReferencePositions: referencePatch.Positions,
+ ReferenceTriangleCount: referencePatch.TriangleIndices.Count / 3,
+ MaxFidelityError: 0.08d,
+ MaxTriangleDensityRatioVsFallback: 0.10d));
+
+ Assert.Equal(BsplineUvGridScaffoldAcceptance.Accepted, accepted.Acceptance);
+ Assert.Equal(BsplineUvGridScaffoldAcceptance.Rejected, rejected.Acceptance);
+ Assert.Equal(BsplineUvGridScaffoldRejectionReason.TooDenseVsFallback, rejected.RejectionReason);
+ }
+
+ private static DisplayFaceMeshPatch GetReferencePatch(BrepBody body, FaceId faceId)
+ {
+ var tessellation = BrepDisplayTessellator.Tessellate(body);
+ Assert.True(tessellation.IsSuccess);
+ return Assert.Single(tessellation.Value.FacePatches, patch => patch.FaceId == faceId);
+ }
+
+ private static BrepBody ImportRepresentativeBsplineBody()
+ {
+ const string text = "ISO-10303-21;\nHEADER;\nENDSEC;\nDATA;\n#1=MANIFOLD_SOLID_BREP('s',#2);\n#2=CLOSED_SHELL($,(#3));\n#3=ADVANCED_FACE((#4),#5,.T.);\n#4=FACE_OUTER_BOUND($,#6,.T.);\n#5=B_SPLINE_SURFACE_WITH_KNOTS('',3,3,((#100,#101,#102,#103),(#104,#105,#106,#107),(#108,#109,#110,#111),(#112,#113,#114,#115)),.UNSPECIFIED.,.F.,.F.,.F.,(4,4),(4,4),(0.,1.),(0.,1.),.UNSPECIFIED.);\n#6=EDGE_LOOP($,(#10,#11,#12,#13));\n#10=ORIENTED_EDGE($,$,$,#20,.T.);\n#11=ORIENTED_EDGE($,$,$,#21,.T.);\n#12=ORIENTED_EDGE($,$,$,#22,.T.);\n#13=ORIENTED_EDGE($,$,$,#23,.T.);\n#20=EDGE_CURVE($,#30,#31,#40,.T.);\n#21=EDGE_CURVE($,#31,#32,#41,.T.);\n#22=EDGE_CURVE($,#32,#33,#42,.T.);\n#23=EDGE_CURVE($,#33,#30,#43,.T.);\n#30=VERTEX_POINT($,#50);\n#31=VERTEX_POINT($,#51);\n#32=VERTEX_POINT($,#52);\n#33=VERTEX_POINT($,#53);\n#40=LINE($,#50,#80);\n#41=LINE($,#51,#81);\n#42=LINE($,#52,#82);\n#43=LINE($,#53,#83);\n#50=CARTESIAN_POINT($,(0,0,0));\n#51=CARTESIAN_POINT($,(1,0,0));\n#52=CARTESIAN_POINT($,(1,1,0));\n#53=CARTESIAN_POINT($,(0,1,0));\n#80=VECTOR($,#84,1.0);\n#81=VECTOR($,#85,1.0);\n#82=VECTOR($,#86,1.0);\n#83=VECTOR($,#87,1.0);\n#84=DIRECTION($,(1,0,0));\n#85=DIRECTION($,(0,1,0));\n#86=DIRECTION($,(-1,0,0));\n#87=DIRECTION($,(0,-1,0));\n#100=CARTESIAN_POINT($,(0,0,0));\n#101=CARTESIAN_POINT($,(0,0.33,0));\n#102=CARTESIAN_POINT($,(0,0.66,0));\n#103=CARTESIAN_POINT($,(0,1,0));\n#104=CARTESIAN_POINT($,(0.33,0,0));\n#105=CARTESIAN_POINT($,(0.33,0.33,0));\n#106=CARTESIAN_POINT($,(0.33,0.66,0));\n#107=CARTESIAN_POINT($,(0.33,1,0));\n#108=CARTESIAN_POINT($,(0.66,0,0));\n#109=CARTESIAN_POINT($,(0.66,0.33,0));\n#110=CARTESIAN_POINT($,(0.66,0.66,0));\n#111=CARTESIAN_POINT($,(0.66,1,0));\n#112=CARTESIAN_POINT($,(1,0,0));\n#113=CARTESIAN_POINT($,(1,0.33,0));\n#114=CARTESIAN_POINT($,(1,0.66,0));\n#115=CARTESIAN_POINT($,(1,1,0));\nENDSEC;\nEND-ISO-10303-21;";
+ var import = Step242Importer.ImportBody(text);
+ Assert.True(import.IsSuccess);
+ return import.Value;
+ }
+
+ private static BSplineSurfaceWithKnots GetBsplineSurface(BrepBody body, FaceId faceId)
+ {
+ Assert.True(body.TryGetFaceSurfaceGeometry(faceId, out var surface));
+ Assert.NotNull(surface);
+ Assert.Equal(SurfaceGeometryKind.BSplineSurfaceWithKnots, surface!.Kind);
+ return Assert.IsType<BSplineSurfaceWithKnots>(surface.BSplineSurfaceWithKnots);
+ }
+
+ private static BrepBody CreateHarderCurvedRectangularBsplineBody()
+ {
+ IReadOnlyList<UvPoint> outerLoop = [new(0d, 0d), new(1d, 0d), new(1d, 1d), new(0d, 1d)];
+ var surface = CreateCurvedBsplineSurface();
+ return CreateFaceBody(surface, outerLoop, []);
+ }
+
+ private static BrepBody CreateTrimmedPlanarBsplineBodyWithRectangularHole(
+ out IReadOnlyList<UvPoint> outerLoopUv,
+ out IReadOnlyList<UvPoint> innerHoleUv)
+ {
+ outerLoopUv = [new(0d, 0d), new(1d, 0d), new(1d, 1d), new(0d, 1d)];
+ innerHoleUv = [new(0.35d, 0.35d), new(0.65d, 0.35d), new(0.65d, 0.65d), new(0.35d, 0.65d)];
+ return CreateFaceBody(CreatePlanarBsplineSurface(), outerLoopUv, [innerHoleUv]);
+ }
+
+ private static BrepBody CreateFaceBody(BSplineSurfaceWithKnots surface, IReadOnlyList<UvPoint> outerLoop, IReadOnlyList<IReadOnlyList<UvPoint>> innerLoops)
+ {
+ var builder = new TopologyBuilder();
+ var geometry = new BrepGeometryStore();
+ var bindings = new BrepBindingModel();
+ var vertexPoints = new Dictionary<VertexId, Point3D>();
+ var curveId = 1;
+
+ var loopIds = new List<LoopId>
+ {
+ AddUvPolygonLoop(outerLoop, surface, builder, geometry, bindings, vertexPoints, ref curveId)
+ };
+
+ foreach (var innerLoop in innerLoops)
+ {
+ loopIds.Add(AddUvPolygonLoop(innerLoop, surface, builder, geometry, bindings, vertexPoints, ref curveId));
+ }
+
+ var faceId = builder.AddFace(loopIds);
+ var shell = builder.AddShell([faceId]);
+ builder.AddBody([shell]);
+
+ geometry.AddSurface(new SurfaceGeometryId(1), SurfaceGeometry.FromBSplineSurfaceWithKnots(surface));
+ bindings.AddFaceBinding(new FaceGeometryBinding(faceId, new SurfaceGeometryId(1)));
+
+ return new BrepBody(builder.Model, geometry, bindings, vertexPoints);
+ }
+
+ private static LoopId AddUvPolygonLoop(
+ IReadOnlyList<UvPoint> uvPolygon,
+ BSplineSurfaceWithKnots surface,
+ TopologyBuilder builder,
+ BrepGeometryStore geometry,
+ BrepBindingModel bindings,
+ IDictionary<VertexId, Point3D> vertexPoints,
+ ref int nextCurveId)
+ {
+ var loopId = builder.AllocateLoopId();
+ var edgeIds = new List<EdgeId>(uvPolygon.Count);
+ var coedgeIds = new List<CoedgeId>(uvPolygon.Count);
+
+ var vertices = uvPolygon.Select(uv => surface.Evaluate(uv.U, uv.V)).ToArray();
+ var vertexIds = vertices.Select(point =>
+ {
+ var vertexId = builder.AddVertex();
+ vertexPoints[vertexId] = point;
+ return vertexId;
+ }).ToArray();
+
+ for (var i = 0; i < uvPolygon.Count; i++)
+ {
+ var startVertex = vertexIds[i];
+ var endVertex = vertexIds[(i + 1) % uvPolygon.Count];
+ var edgeId = builder.AddEdge(startVertex, endVertex);
+ edgeIds.Add(edgeId);
+
+ var line = CreateLine(vertices[i], vertices[(i + 1) % uvPolygon.Count], out var length);
+ var geometryId = new CurveGeometryId(nextCurveId++);
+ geometry.AddCurve(geometryId, CurveGeometry.FromLine(line));
+ bindings.AddEdgeBinding(new EdgeGeometryBinding(edgeId, geometryId, new ParameterInterval(0d, length)));
+
+ 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 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 BSplineSurfaceWithKnots CreateCurvedBsplineSurface()
+ => new(
+ degreeU: 3,
+ degreeV: 3,
+ controlPoints:
+ [
+ [new Point3D(0.00d, 0.00d, 0.00d), new Point3D(0.00d, 0.33d, 0.28d), new Point3D(0.00d, 0.66d, -0.22d), new Point3D(0.00d, 1.00d, 0.10d)],
+ [new Point3D(0.33d, 0.00d, 0.42d), new Point3D(0.33d, 0.33d, 0.62d), new Point3D(0.33d, 0.66d, 0.18d), new Point3D(0.33d, 1.00d, -0.10d)],
+ [new Point3D(0.66d, 0.00d, -0.20d), new Point3D(0.66d, 0.33d, 0.20d), new Point3D(0.66d, 0.66d, 0.72d), new Point3D(0.66d, 1.00d, 0.34d)],
+ [new Point3D(1.00d, 0.00d, 0.12d), new Point3D(1.00d, 0.33d, -0.30d), new Point3D(1.00d, 0.66d, 0.24d), new Point3D(1.00d, 1.00d, 0.52d)],
+ ],
+ surfaceForm: "UNSPECIFIED",
+ uClosed: false,
+ vClosed: false,
+ selfIntersect: false,
+ knotMultiplicitiesU: [4, 4],
+ knotMultiplicitiesV: [4, 4],
+ knotValuesU: [0d, 1d],
+ knotValuesV: [0d, 1d],
+ knotSpec: "UNSPECIFIED");
+
+ private static BSplineSurfaceWithKnots CreatePlanarBsplineSurface()
+ => new(
+ degreeU: 3,
+ degreeV: 3,
+ controlPoints:
+ [
+ [new Point3D(0.00d, 0.00d, 0.00d), new Point3D(0.00d, 0.33d, 0.00d), new Point3D(0.00d, 0.66d, 0.00d), new Point3D(0.00d, 1.00d, 0.00d)],
+ [new Point3D(0.33d, 0.00d, 0.00d), new Point3D(0.33d, 0.33d, 0.00d), new Point3D(0.33d, 0.66d, 0.00d), new Point3D(0.33d, 1.00d, 0.00d)],
+ [new Point3D(0.66d, 0.00d, 0.00d), new Point3D(0.66d, 0.33d, 0.00d), new Point3D(0.66d, 0.66d, 0.00d), new Point3D(0.66d, 1.00d, 0.00d)],
+ [new Point3D(1.00d, 0.00d, 0.00d), new Point3D(1.00d, 0.33d, 0.00d), new Point3D(1.00d, 0.66d, 0.00d), new Point3D(1.00d, 1.00d, 0.00d)],
+ ],
+ surfaceForm: "UNSPECIFIED",
+ uClosed: false,
+ vClosed: false,
+ selfIntersect: false,
+ knotMultiplicitiesU: [4, 4],
+ knotMultiplicitiesV: [4, 4],
+ knotValuesU: [0d, 1d],
+ knotValuesV: [0d, 1d],
+ knotSpec: "UNSPECIFIED");
+}
diff --git a/Aetheris.Kernel.Core/Brep/Tessellation/BsplineUvGridScaffoldBuilder.cs b/Aetheris.Kernel.Core/Brep/Tessellation/BsplineUvGridScaffoldBuilder.cs
new file mode 100644
index 00000000..5d0a9969
--- /dev/null
+++ b/Aetheris.Kernel.Core/Brep/Tessellation/BsplineUvGridScaffoldBuilder.cs
@@ -0,0 +1,424 @@
+using Aetheris.Kernel.Core.Geometry.Surfaces;
+using Aetheris.Kernel.Core.Math;
+
+namespace Aetheris.Kernel.Core.Brep.Tessellation;
+
+internal sealed class BsplineUvGridScaffoldBuilder
+{
+ internal BsplineUvGridScaffoldResult Build(BSplineSurfaceWithKnots surface, BsplineUvGridScaffoldBuildRequest request)
+ {
+ if (request.USegments <= 0 || request.VSegments <= 0)
+ {
+ return BsplineUvGridScaffoldResult.Rejected(BsplineUvGridScaffoldRejectionReason.UnsupportedInput, BsplineUvGridScaffoldMetrics.Empty);
+ }
+
+ var rows = request.USegments + 1;
+ var columns = request.VSegments + 1;
+ var positions = new Point3D[rows * columns];
+ var uvPoints = new UvPoint[rows * columns];
+
+ for (var uIndex = 0; uIndex < rows; uIndex++)
+ {
+ var tu = (double)uIndex / request.USegments;
+ var u = Lerp(surface.DomainStartU, surface.DomainEndU, tu);
+ for (var vIndex = 0; vIndex < columns; vIndex++)
+ {
+ var tv = (double)vIndex / request.VSegments;
+ var v = Lerp(surface.DomainStartV, surface.DomainEndV, tv);
+ var index = GridIndex(uIndex, vIndex, columns);
+ uvPoints[index] = new UvPoint(u, v);
+ positions[index] = surface.Evaluate(u, v);
+ }
+ }
+
+ var triangles = BuildTriangles(request, uvPoints, columns);
+ var mesh = new BsplineUvGridScaffoldMesh(positions, triangles, uvPoints);
+
+ if (!HasValidTriangleIndexing(mesh))
+ {
+ return BsplineUvGridScaffoldResult.Rejected(BsplineUvGridScaffoldRejectionReason.InvalidIndices, BsplineUvGridScaffoldMetrics.Empty, mesh);
+ }
+
+ if (HasNonFinite(mesh.Positions))
+ {
+ return BsplineUvGridScaffoldResult.Rejected(BsplineUvGridScaffoldRejectionReason.NonFiniteGeometry, BsplineUvGridScaffoldMetrics.Empty, mesh);
+ }
+
+ if (mesh.TriangleIndices.Count == 0)
+ {
+ return BsplineUvGridScaffoldResult.Rejected(BsplineUvGridScaffoldRejectionReason.UnsupportedInput, BsplineUvGridScaffoldMetrics.Empty, mesh);
+ }
+
+ var degenerateRatio = ComputeDegenerateTriangleRatio(mesh, request.DegenerateTriangleAreaTolerance);
+ if (degenerateRatio > request.MaxDegenerateTriangleRatio)
+ {
+ return BsplineUvGridScaffoldResult.Rejected(
+ BsplineUvGridScaffoldRejectionReason.ExcessiveDegenerateTriangles,
+ new BsplineUvGridScaffoldMetrics(degenerateRatio, 0, 0d, 0d, 1d),
+ mesh);
+ }
+
+ var leakageCount = ComputeTrimLeakageCount(mesh, request.TrimMask);
+ if (leakageCount > 0)
+ {
+ return BsplineUvGridScaffoldResult.Rejected(
+ BsplineUvGridScaffoldRejectionReason.TrimLeakage,
+ new BsplineUvGridScaffoldMetrics(degenerateRatio, leakageCount, 0d, 0d, 1d),
+ mesh);
+ }
+
+ var boundaryDeviation = ComputeBoundaryDeviation(mesh, request.TrimMask);
+ if (boundaryDeviation > request.MaxBoundaryDeviationUv)
+ {
+ return BsplineUvGridScaffoldResult.Rejected(
+ BsplineUvGridScaffoldRejectionReason.BoundaryDeviationTooHigh,
+ new BsplineUvGridScaffoldMetrics(degenerateRatio, leakageCount, boundaryDeviation, 0d, 1d),
+ mesh);
+ }
+
+ var fidelityError = ComputeFidelityError(mesh, request.ReferencePositions);
+ if (fidelityError > request.MaxFidelityError)
+ {
+ return BsplineUvGridScaffoldResult.Rejected(
+ BsplineUvGridScaffoldRejectionReason.FidelityTooLow,
+ new BsplineUvGridScaffoldMetrics(degenerateRatio, leakageCount, boundaryDeviation, fidelityError, 1d),
+ mesh);
+ }
+
+ var densityRatio = ComputeDensityRatio(mesh, request.ReferenceTriangleCount);
+ if (densityRatio > request.MaxTriangleDensityRatioVsFallback)
+ {
+ return BsplineUvGridScaffoldResult.Rejected(
+ BsplineUvGridScaffoldRejectionReason.TooDenseVsFallback,
+ new BsplineUvGridScaffoldMetrics(degenerateRatio, leakageCount, boundaryDeviation, fidelityError, densityRatio),
+ mesh);
+ }
+
+ return BsplineUvGridScaffoldResult.Accepted(
+ mesh,
+ new BsplineUvGridScaffoldMetrics(degenerateRatio, leakageCount, boundaryDeviation, fidelityError, densityRatio));
+ }
+
+ private static List<int> BuildTriangles(BsplineUvGridScaffoldBuildRequest request, IReadOnlyList<UvPoint> uvPoints, int columns)
+ {
+ var triangles = new List<int>(request.USegments * request.VSegments * 6);
+ for (var uIndex = 0; uIndex < request.USegments; uIndex++)
+ {
+ for (var vIndex = 0; vIndex < request.VSegments; vIndex++)
+ {
+ var bottomLeft = GridIndex(uIndex, vIndex, columns);
+ var bottomRight = GridIndex(uIndex + 1, vIndex, columns);
+ var topLeft = GridIndex(uIndex, vIndex + 1, columns);
+ var topRight = GridIndex(uIndex + 1, vIndex + 1, columns);
+
+ if (request.TrimMask is not null
+ && (!request.TrimMask.Contains(uvPoints[bottomLeft])
+ || !request.TrimMask.Contains(uvPoints[bottomRight])
+ || !request.TrimMask.Contains(uvPoints[topLeft])
+ || !request.TrimMask.Contains(uvPoints[topRight])))
+ {
+ continue;
+ }
+
+ triangles.Add(bottomLeft);
+ triangles.Add(bottomRight);
+ triangles.Add(topRight);
+
+ triangles.Add(bottomLeft);
+ triangles.Add(topRight);
+ triangles.Add(topLeft);
+ }
+ }
+
+ return triangles;
+ }
+
+ private static bool HasValidTriangleIndexing(BsplineUvGridScaffoldMesh mesh)
+ => mesh.TriangleIndices.Count % 3 == 0
+ && mesh.TriangleIndices.All(index => index >= 0 && index < mesh.Positions.Count);
+
+ private static bool HasNonFinite(IReadOnlyList<Point3D> positions)
+ => positions.Any(point => !double.IsFinite(point.X) || !double.IsFinite(point.Y) || !double.IsFinite(point.Z));
+
+ private static double ComputeDegenerateTriangleRatio(BsplineUvGridScaffoldMesh mesh, double areaTolerance)
+ {
+ var triangles = mesh.TriangleIndices.Count / 3;
+ if (triangles == 0)
+ {
+ return 1d;
+ }
+
+ var degenerate = 0;
+ for (var i = 0; i < mesh.TriangleIndices.Count; i += 3)
+ {
+ var a = mesh.Positions[mesh.TriangleIndices[i]];
+ var b = mesh.Positions[mesh.TriangleIndices[i + 1]];
+ var c = mesh.Positions[mesh.TriangleIndices[i + 2]];
+ var area2 = (b - a).Cross(c - a).Length;
+ if (area2 <= areaTolerance)
+ {
+ degenerate++;
+ }
+ }
+
+ return (double)degenerate / triangles;
+ }
+
+ private static int ComputeTrimLeakageCount(BsplineUvGridScaffoldMesh mesh, BsplineUvGridTrimMask? trimMask)
+ {
+ if (trimMask is null)
+ {
+ return 0;
+ }
+
+ var leakage = 0;
+ for (var i = 0; i < mesh.TriangleIndices.Count; i += 3)
+ {
+ var a = mesh.UvPoints[mesh.TriangleIndices[i]];
+ var b = mesh.UvPoints[mesh.TriangleIndices[i + 1]];
+ var c = mesh.UvPoints[mesh.TriangleIndices[i + 2]];
+ var centroid = new UvPoint((a.U + b.U + c.U) / 3d, (a.V + b.V + c.V) / 3d);
+ if (!trimMask.Contains(centroid))
+ {
+ leakage++;
+ }
+ }
+
+ return leakage;
+ }
+
+ private static double ComputeBoundaryDeviation(BsplineUvGridScaffoldMesh mesh, BsplineUvGridTrimMask? trimMask)
+ {
+ if (trimMask is null)
+ {
+ return 0d;
+ }
+
+ var usedIndices = mesh.TriangleIndices.Distinct().ToArray();
+ if (usedIndices.Length == 0)
+ {
+ return double.PositiveInfinity;
+ }
+
+ var usedUv = usedIndices.Select(index => mesh.UvPoints[index]).ToArray();
+ var maxDeviation = 0d;
+
+ maxDeviation = double.Max(maxDeviation, ComputeLoopDeviation(trimMask.OuterLoop, usedUv));
+ foreach (var hole in trimMask.InnerLoops)
+ {
+ maxDeviation = double.Max(maxDeviation, ComputeLoopDeviation(hole, usedUv));
+ }
+
+ return maxDeviation;
+ }
+
+ private static double ComputeLoopDeviation(IReadOnlyList<UvPoint> loop, IReadOnlyList<UvPoint> usedUv)
+ {
+ var maxDeviation = 0d;
+ for (var i = 0; i < loop.Count; i++)
+ {
+ var start = loop[i];
+ var end = loop[(i + 1) % loop.Count];
+ var nearest = usedUv.Min(sample => DistancePointToSegment(sample, start, end));
+ maxDeviation = double.Max(maxDeviation, nearest);
+ }
+
+ return maxDeviation;
+ }
+
+ private static double ComputeFidelityError(BsplineUvGridScaffoldMesh mesh, IReadOnlyList<Point3D>? referencePositions)
+ {
+ if (referencePositions is null || referencePositions.Count == 0)
+ {
+ return 0d;
+ }
+
+ var usedPositions = mesh.TriangleIndices
+ .Distinct()
+ .Select(index => mesh.Positions[index])
+ .ToArray();
+ if (usedPositions.Length == 0)
+ {
+ return double.PositiveInfinity;
+ }
+
+ var forward = ComputeMeanNearestDistance(usedPositions, referencePositions);
+ var reverse = ComputeMeanNearestDistance(referencePositions, usedPositions);
+ return double.Max(forward, reverse);
+ }
+
+ private static double ComputeDensityRatio(BsplineUvGridScaffoldMesh mesh, int? referenceTriangleCount)
+ {
+ if (referenceTriangleCount is null || referenceTriangleCount <= 0)
+ {
+ return 1d;
+ }
+
+ return (double)(mesh.TriangleIndices.Count / 3) / referenceTriangleCount.Value;
+ }
+
+ private static double ComputeMeanNearestDistance(IReadOnlyList<Point3D> source, IReadOnlyList<Point3D> target)
+ {
+ var sum = 0d;
+ foreach (var sourcePoint in source)
+ {
+ var nearest = target.Min(targetPoint => (targetPoint - sourcePoint).Length);
+ sum += nearest;
+ }
+
+ return source.Count == 0 ? double.PositiveInfinity : sum / source.Count;
+ }
+
+ private static double DistancePointToSegment(UvPoint point, UvPoint segmentStart, UvPoint segmentEnd)
+ {
+ var segmentU = segmentEnd.U - segmentStart.U;
+ var segmentV = segmentEnd.V - segmentStart.V;
+ var lengthSquared = (segmentU * segmentU) + (segmentV * segmentV);
+ if (lengthSquared <= 1e-12d)
+ {
+ return UvDistance(point, segmentStart);
+ }
+
+ var projection = (((point.U - segmentStart.U) * segmentU) + ((point.V - segmentStart.V) * segmentV)) / lengthSquared;
+ projection = double.Clamp(projection, 0d, 1d);
+ var nearest = new UvPoint(segmentStart.U + (projection * segmentU), segmentStart.V + (projection * segmentV));
+ return UvDistance(point, nearest);
+ }
+
+ private static double UvDistance(UvPoint left, UvPoint right)
+ {
+ var du = left.U - right.U;
+ var dv = left.V - right.V;
+ return double.Sqrt((du * du) + (dv * dv));
+ }
+
+ private static int GridIndex(int uIndex, int vIndex, int columns)
+ => (uIndex * columns) + vIndex;
+
+ private static double Lerp(double start, double end, double t)
+ => start + ((end - start) * t);
+}
+
+internal sealed record BsplineUvGridScaffoldBuildRequest(
+ int USegments,
+ int VSegments,
+ BsplineUvGridTrimMask? TrimMask = null,
+ IReadOnlyList<Point3D>? ReferencePositions = null,
+ int? ReferenceTriangleCount = null,
+ double MaxDegenerateTriangleRatio = 0.15d,
+ double DegenerateTriangleAreaTolerance = 1e-12d,
+ double MaxBoundaryDeviationUv = 0.06d,
+ double MaxFidelityError = 0.10d,
+ double MaxTriangleDensityRatioVsFallback = 1.10d);
+
+internal sealed record BsplineUvGridScaffoldMesh(
+ IReadOnlyList<Point3D> Positions,
+ IReadOnlyList<int> TriangleIndices,
+ IReadOnlyList<UvPoint> UvPoints);
+
+internal sealed record BsplineUvGridScaffoldMetrics(
+ double DegenerateTriangleRatio,
+ int LeakageTriangleCount,
+ double BoundaryDeviationUv,
+ double FidelityError,
+ double TriangleDensityRatio)
+{
+ internal static BsplineUvGridScaffoldMetrics Empty { get; } = new(0d, 0, 0d, 0d, 1d);
+}
+
+internal enum BsplineUvGridScaffoldAcceptance
+{
+ Accepted,
+ Rejected,
+}
+
+internal enum BsplineUvGridScaffoldRejectionReason
+{
+ None,
+ UnsupportedInput,
+ InvalidIndices,
+ NonFiniteGeometry,
+ ExcessiveDegenerateTriangles,
+ TrimLeakage,
+ BoundaryDeviationTooHigh,
+ FidelityTooLow,
+ TooDenseVsFallback,
+}
+
+internal sealed record BsplineUvGridScaffoldResult(
+ BsplineUvGridScaffoldAcceptance Acceptance,
+ BsplineUvGridScaffoldMesh? Mesh,
+ BsplineUvGridScaffoldMetrics Metrics,
+ BsplineUvGridScaffoldRejectionReason RejectionReason)
+{
+ internal static BsplineUvGridScaffoldResult Accepted(BsplineUvGridScaffoldMesh mesh, BsplineUvGridScaffoldMetrics metrics)
+ => new(BsplineUvGridScaffoldAcceptance.Accepted, mesh, metrics, BsplineUvGridScaffoldRejectionReason.None);
+
+ internal static BsplineUvGridScaffoldResult Rejected(BsplineUvGridScaffoldRejectionReason reason, BsplineUvGridScaffoldMetrics metrics, BsplineUvGridScaffoldMesh? mesh = null)
+ => new(BsplineUvGridScaffoldAcceptance.Rejected, mesh, metrics, reason);
+}
+
+internal sealed record BsplineUvGridTrimMask(IReadOnlyList<UvPoint> OuterLoop, IReadOnlyList<IReadOnlyList<UvPoint>> InnerLoops)
+{
+ internal bool Contains(UvPoint point)
+ {
+ if (!PointInLoop(OuterLoop, point))
+ {
+ return false;
+ }
+
+ foreach (var hole in InnerLoops)
+ {
+ if (PointInLoop(hole, point))
+ {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ private static bool PointInLoop(IReadOnlyList<UvPoint> loop, UvPoint point)
+ {
+ var inside = false;
+ for (var i = 0; i < loop.Count; i++)
+ {
+ var a = loop[i];
+ var b = loop[(i + 1) % loop.Count];
+ if (IsPointOnSegment(point, a, b))
+ {
+ return true;
+ }
+
+ var crosses = ((a.V > point.V) != (b.V > point.V))
+ && (point.U < (((b.U - a.U) * (point.V - a.V)) / (b.V - a.V)) + a.U);
+ if (crosses)
+ {
+ inside = !inside;
+ }
+ }
+
+ return inside;
+ }
+
+ private static bool IsPointOnSegment(UvPoint point, UvPoint a, UvPoint b)
+ {
+ const double tolerance = 1e-9d;
+ var cross = ((point.U - a.U) * (b.V - a.V)) - ((point.V - a.V) * (b.U - a.U));
+ if (double.Abs(cross) > tolerance)
+ {
+ return false;
+ }
+
+ var dot = ((point.U - a.U) * (b.U - a.U)) + ((point.V - a.V) * (b.V - a.V));
+ if (dot < -tolerance)
+ {
+ return false;
+ }
+
+ var lengthSquared = ((b.U - a.U) * (b.U - a.U)) + ((b.V - a.V) * (b.V - a.V));
+ return dot <= lengthSquared + tolerance;
+ }
+}
+
+internal readonly record struct UvPoint(double U, double V);