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.csnew file mode 100644index 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.csnew file mode 100644index 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);