Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
H10 support bounded non-axis planar polygon analytic domains
Yuechen Li422e7365f422
diff --git a/Aetheris.Kernel.Core.Tests/Brep/Queries/AnalyticDisplayPacketBuilderTests.cs b/Aetheris.Kernel.Core.Tests/Brep/Queries/AnalyticDisplayPacketBuilderTests.csindex 9e0323a7..65349afb 100644--- a/Aetheris.Kernel.Core.Tests/Brep/Queries/AnalyticDisplayPacketBuilderTests.cs+++ b/Aetheris.Kernel.Core.Tests/Brep/Queries/AnalyticDisplayPacketBuilderTests.cs@@ -27,19 +27,25 @@ public sealed class AnalyticDisplayPacketBuilderTests[Fact]- public void Build_RotatedBoxBody_RoutesNonAxisPlanarFacesToFallback()+ public void Build_RotatedPlanarPolygonBody_KeepsNonAxisPlanarPolygonFaceAnalytic(){- var body = TransformBody(BrepPrimitives.CreateBox(2d, 2d, 2d).Value, Transform3D.CreateRotationX(double.Pi / 4d));+ var imported = ImportFromCorpus("testdata/step242/tessellation-robustness/planar-nonconvex-single-loop.step");+ var body = TransformBody(imported, Transform3D.CreateRotationX(double.Pi / 4d));var packet = AnalyticDisplayPacketBuilder.Build(body);- Assert.NotEmpty(packet.AnalyticFaces);- Assert.NotEmpty(packet.FallbackFaces);- Assert.All(packet.FallbackFaces, face =>- {- Assert.Equal(AnalyticDisplayFallbackReason.UnsupportedTrim, face.Reason);- Assert.Equal(SurfaceGeometryKind.Plane, face.SurfaceKind);- });+ Assert.Contains(packet.AnalyticFaces, face => face.SurfaceKind == SurfaceGeometryKind.Plane);+ }++ [Fact]+ public void Build_RotatedPlanarCurvedTrimBody_RoutesNonAxisUnsupportedPlanarTrimToFallback()+ {+ var imported = ImportFromCorpus("testdata/step242/tessellation-robustness/planar-rect-with-filleted-corners.step");+ var body = TransformBody(imported, Transform3D.CreateRotationX(double.Pi / 6d));++ var packet = AnalyticDisplayPacketBuilder.Build(body);++ Assert.Contains(packet.FallbackFaces, face => face.SurfaceKind == SurfaceGeometryKind.Plane && face.Reason == AnalyticDisplayFallbackReason.UnsupportedTrim);}[Fact]diff --git a/Aetheris.Kernel.Core.Tests/Brep/Queries/AnalyticDisplayQueryTests.cs b/Aetheris.Kernel.Core.Tests/Brep/Queries/AnalyticDisplayQueryTests.csindex f2c5f6b5..e9c2bd22 100644--- a/Aetheris.Kernel.Core.Tests/Brep/Queries/AnalyticDisplayQueryTests.cs+++ b/Aetheris.Kernel.Core.Tests/Brep/Queries/AnalyticDisplayQueryTests.cs@@ -34,26 +34,49 @@ public sealed class AnalyticDisplayQueryTests[Fact]- public void PlanarFace_RotatedBoxSide_RejectsOutOfDomainPlaneHit()+ public void PlanarFace_RotatedNonAxisPolygon_RejectsOutOfDomainPlaneHit(){- var rotated = TransformBody(BrepPrimitives.CreateBox(2d, 2d, 2d).Value, Transform3D.CreateRotationZ(double.Pi / 4d));- var sideFaceId = rotated.Topology.Faces- .Select(face => face.Id)- .First(faceId =>- {- var surface = rotated.GetFaceSurface(faceId);- return surface.Kind == SurfaceGeometryKind.Plane- && surface.Plane is { } plane- && double.Abs(plane.Normal.Z) < 0.1d;- });+ var imported = ImportFromCorpus("testdata/step242/tessellation-robustness/planar-nonconvex-single-loop.step");+ var rotated = TransformBody(imported, Transform3D.CreateRotationX(double.Pi / 4d));+ var sideFaceId = rotated.Topology.Faces.Single().Id;var plane = rotated.GetFaceSurface(sideFaceId).Plane!.Value;- var outsideOnPlane = plane.Origin + (plane.VAxis.ToVector() * 5d);+ var insideRay = new Ray3D(plane.Origin - (plane.Normal.ToVector() * 3d), Direction3D.Create(plane.Normal.ToVector()));+ var outsideOnPlane = plane.Origin + (plane.VAxis.ToVector() * 50d);var ray = new Ray3D(outsideOnPlane - (plane.Normal.ToVector() * 3d), Direction3D.Create(plane.Normal.ToVector()));+ Assert.True(AnalyticDisplayQuery.TryIntersectFace(rotated, sideFaceId, insideRay, out _));Assert.False(AnalyticDisplayQuery.TryIntersectFace(rotated, sideFaceId, ray, out _));}+ [Fact]+ public void PlanarFace_NonAxisPolygon_QueryAndPacketStayConsistent()+ {+ var imported = ImportFromCorpus("testdata/step242/tessellation-robustness/planar-nonconvex-single-loop.step");+ var rotated = TransformBody(imported, Transform3D.CreateRotationY(double.Pi / 5d));+ var packet = AnalyticDisplayPacketBuilder.Build(rotated);+ var sideFaceId = rotated.Topology.Faces.Single().Id;+ var plane = rotated.GetFaceSurface(sideFaceId).Plane!.Value;++ var hitRay = new Ray3D(plane.Origin - (plane.Normal.ToVector() * 4d), Direction3D.Create(plane.Normal.ToVector()));++ Assert.Contains(packet.AnalyticFaces, face => face.FaceId == sideFaceId && face.SurfaceKind == SurfaceGeometryKind.Plane);+ Assert.True(AnalyticDisplayQuery.TryIntersectFace(rotated, sideFaceId, hitRay, out _));+ }++ [Fact]+ public void PlanarFace_NonAxisCurvedTrim_RemainsFallbackAndQueryRejects()+ {+ var body = TransformBody(ImportFromCorpus("testdata/step242/tessellation-robustness/planar-rect-with-filleted-corners.step"), Transform3D.CreateRotationX(double.Pi / 6d));+ var packet = AnalyticDisplayPacketBuilder.Build(body);+ var planarFallback = Assert.Single(packet.FallbackFaces, face => face.SurfaceKind == SurfaceGeometryKind.Plane && face.Reason == AnalyticDisplayFallbackReason.UnsupportedTrim);+ var plane = body.GetFaceSurface(planarFallback.FaceId).Plane!.Value;+ var ray = new Ray3D(plane.Origin - (plane.Normal.ToVector() * 10d), Direction3D.Create(plane.Normal.ToVector()));++ Assert.DoesNotContain(packet.AnalyticFaces, face => face.FaceId == planarFallback.FaceId);+ Assert.False(AnalyticDisplayQuery.TryIntersectFace(body, planarFallback.FaceId, ray, out _));+ }+[Fact]public void PlanarFace_CircularCap_StillUsesAnalyticDomain(){diff --git a/Aetheris.Kernel.Core/Brep/Queries/AnalyticDisplayQuery.cs b/Aetheris.Kernel.Core/Brep/Queries/AnalyticDisplayQuery.csindex 3179b9c6..b347dfd9 100644--- a/Aetheris.Kernel.Core/Brep/Queries/AnalyticDisplayQuery.cs+++ b/Aetheris.Kernel.Core/Brep/Queries/AnalyticDisplayQuery.cs@@ -376,161 +376,12 @@ public static class AnalyticDisplayQueryprivate static bool IsPointOnPlaneFaceDomain(BrepBody body, FaceId faceId, PlaneSurface plane, Point3D point, ToleranceContext tolerance){- if (!body.Topology.TryGetFace(faceId, out var face) || face is null)- {- return true;- }-- var circularBoundaries = new List<(LoopId LoopId, Point3D Center, double Radius)>();-- foreach (var loopId in face.LoopIds)- {- var loop = body.Topology.GetLoop(loopId);- var loopHasOnlyCircles = loop.CoedgeIds.Count > 0;- Point3D? loopCenter = null;- double? loopRadius = null;-- foreach (var coedgeId in loop.CoedgeIds)- {- var edgeId = body.Topology.GetCoedge(coedgeId).EdgeId;- if (!body.Bindings.TryGetEdgeBinding(edgeId, out var edgeBinding)- || !body.Geometry.TryGetCurve(edgeBinding.CurveGeometryId, out var curve))- {- loopHasOnlyCircles = false;- continue;- }-- if (curve is { Kind: CurveGeometryKind.Circle3, Circle3: { } circle })- {- loopCenter ??= circle.Center;- loopRadius ??= circle.Radius;- continue;- }-- loopHasOnlyCircles = false;- }-- if (loopHasOnlyCircles && loopCenter.HasValue && loopRadius.HasValue)- {- circularBoundaries.Add((loopId, loopCenter.Value, loopRadius.Value));- }- }-- var normal = plane.Normal.ToVector();- var axisAlignedPlane = double.Abs(normal.X) > 0.9d || double.Abs(normal.Y) > 0.9d || double.Abs(normal.Z) > 0.9d;-- if (!axisAlignedPlane)- {- return circularBoundaries.Count == 1- && face.LoopIds.Count == 1- && IsPointInsideCircularBoundary(point, plane, circularBoundaries[0].Center, circularBoundaries[0].Radius, tolerance);- }-- var inAxisAlignedFaceBounds = true;- if (TryResolveAxisAlignedBoxBounds(body, out var min, out var max))- {- if (double.Abs(normal.X) > 0.9d)- {- inAxisAlignedFaceBounds = point.Y >= min.Y - tolerance.Linear && point.Y <= max.Y + tolerance.Linear- && point.Z >= min.Z - tolerance.Linear && point.Z <= max.Z + tolerance.Linear;- }- else if (double.Abs(normal.Y) > 0.9d)- {- inAxisAlignedFaceBounds = point.X >= min.X - tolerance.Linear && point.X <= max.X + tolerance.Linear- && point.Z >= min.Z - tolerance.Linear && point.Z <= max.Z + tolerance.Linear;- }- else- {- inAxisAlignedFaceBounds = point.X >= min.X - tolerance.Linear && point.X <= max.X + tolerance.Linear- && point.Y >= min.Y - tolerance.Linear && point.Y <= max.Y + tolerance.Linear;- }- }-- if (!inAxisAlignedFaceBounds)+ if (!AnalyticPlanarFaceDomain.TryCreate(body, faceId, plane, out var domain)){return false;}- if (circularBoundaries.Count == 1 && face.LoopIds.Count == 1)- {- return IsPointInsideCircularBoundary(point, plane, circularBoundaries[0].Center, circularBoundaries[0].Radius, tolerance);- }-- if (face.LoopIds.Count > 1 && circularBoundaries.Count > 0)- {- foreach (var boundary in circularBoundaries)- {- if (IsPointInsideCircularBoundary(point, plane, boundary.Center, boundary.Radius, tolerance))- {- return false;- }- }- }-- return true;- }-- private static bool IsPointInsideCircularBoundary(Point3D point, PlaneSurface plane, Point3D center, double radius, ToleranceContext tolerance)- {- var radial = point - center;- var height = radial.Dot(plane.Normal.ToVector());- var inPlaneRadial = radial - (plane.Normal.ToVector() * height);- return inPlaneRadial.Dot(inPlaneRadial) <= (radius + tolerance.Linear) * (radius + tolerance.Linear);- }-- private static bool TryResolveAxisAlignedBoxBounds(BrepBody body, out Point3D min, out Point3D max)- {- min = default;- max = default;- var hasXMin = false;- var hasXMax = false;- var hasYMin = false;- var hasYMax = false;- var hasZMin = false;- var hasZMax = false;-- foreach (var faceBinding in body.Bindings.FaceBindings)- {- var surface = body.Geometry.GetSurface(faceBinding.SurfaceGeometryId);- if (surface.Kind != SurfaceGeometryKind.Plane || surface.Plane is not PlaneSurface plane)- {- continue;- }-- var n = plane.Normal;- if (ToleranceMath.AlmostEqual(n.X, -1d, ToleranceContext.Default))- {- min = min with { X = plane.Origin.X };- hasXMin = true;- }- else if (ToleranceMath.AlmostEqual(n.X, 1d, ToleranceContext.Default))- {- max = max with { X = plane.Origin.X };- hasXMax = true;- }- else if (ToleranceMath.AlmostEqual(n.Y, -1d, ToleranceContext.Default))- {- min = min with { Y = plane.Origin.Y };- hasYMin = true;- }- else if (ToleranceMath.AlmostEqual(n.Y, 1d, ToleranceContext.Default))- {- max = max with { Y = plane.Origin.Y };- hasYMax = true;- }- else if (ToleranceMath.AlmostEqual(n.Z, -1d, ToleranceContext.Default))- {- min = min with { Z = plane.Origin.Z };- hasZMin = true;- }- else if (ToleranceMath.AlmostEqual(n.Z, 1d, ToleranceContext.Default))- {- max = max with { Z = plane.Origin.Z };- hasZMax = true;- }- }-- return hasXMin && hasXMax && hasYMin && hasYMax && hasZMin && hasZMax;+ return domain.Contains(point, tolerance);}private static void ResolveAxialBounds(BrepBody body, FaceId sideFaceId, Direction3D axis, Point3D axisOrigin, out double? minV, out double? maxV)diff --git a/Aetheris.Kernel.Core/Brep/Queries/AnalyticDisplaySupportPolicy.cs b/Aetheris.Kernel.Core/Brep/Queries/AnalyticDisplaySupportPolicy.csindex d84a3bf4..6a025358 100644--- a/Aetheris.Kernel.Core/Brep/Queries/AnalyticDisplaySupportPolicy.cs+++ b/Aetheris.Kernel.Core/Brep/Queries/AnalyticDisplaySupportPolicy.cs@@ -136,36 +136,6 @@ internal static class AnalyticDisplaySupportPolicyreturn false;}- var normal = plane.Normal.ToVector();- var axisAlignedPlane = double.Abs(normal.X) > 0.9d || double.Abs(normal.Y) > 0.9d || double.Abs(normal.Z) > 0.9d;- if (axisAlignedPlane)- {- return true;- }-- if (face.LoopIds.Count != 1)- {- return false;- }-- var loop = body.Topology.GetLoop(face.LoopIds[0]);- if (loop.CoedgeIds.Count == 0)- {- return false;- }-- foreach (var coedgeId in loop.CoedgeIds)- {- var edgeId = body.Topology.GetCoedge(coedgeId).EdgeId;- if (!body.Bindings.TryGetEdgeBinding(edgeId, out var edgeBinding)- || !body.Geometry.TryGetCurve(edgeBinding.CurveGeometryId, out var curve)- || curve is null- || curve.Kind != CurveGeometryKind.Circle3)- {- return false;- }- }-- return true;+ return AnalyticPlanarFaceDomain.TryCreate(body, faceId, plane, out _);}}diff --git a/Aetheris.Kernel.Core/Brep/Queries/AnalyticPlanarFaceDomain.cs b/Aetheris.Kernel.Core/Brep/Queries/AnalyticPlanarFaceDomain.csnew file mode 100644index 00000000..b8dbcb29--- /dev/null+++ b/Aetheris.Kernel.Core/Brep/Queries/AnalyticPlanarFaceDomain.cs@@ -0,0 +1,498 @@+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.Numerics;+using Aetheris.Kernel.Core.Topology;+using Aetheris.Kernel.Core.Brep.Tessellation;++namespace Aetheris.Kernel.Core.Brep.Queries;++internal sealed class AnalyticPlanarFaceDomain+{+ private readonly PlaneSurface _plane;+ private readonly (Point3D Min, Point3D Max)? _axisBounds;+ private readonly IReadOnlyList<(double U, double V)> _outerPolygon;+ private readonly IReadOnlyList<IReadOnlyList<(double U, double V)>> _innerPolygons;+ private readonly (Point3D Center, double Radius)? _singleCircularBoundary;+ private readonly IReadOnlyList<(Point3D Center, double Radius)> _circularExclusionBoundaries;++ private AnalyticPlanarFaceDomain(+ PlaneSurface plane,+ (Point3D Min, Point3D Max)? axisBounds,+ IReadOnlyList<(double U, double V)> outerPolygon,+ IReadOnlyList<IReadOnlyList<(double U, double V)>> innerPolygons,+ (Point3D Center, double Radius)? singleCircularBoundary,+ IReadOnlyList<(Point3D Center, double Radius)> circularExclusionBoundaries)+ {+ _plane = plane;+ _axisBounds = axisBounds;+ _outerPolygon = outerPolygon;+ _innerPolygons = innerPolygons;+ _singleCircularBoundary = singleCircularBoundary;+ _circularExclusionBoundaries = circularExclusionBoundaries;+ }++ public static bool TryCreate(BrepBody body, FaceId faceId, PlaneSurface plane, out AnalyticPlanarFaceDomain domain)+ {+ domain = null!;+ if (!body.Topology.TryGetFace(faceId, out var face) || face is null)+ {+ return false;+ }++ if (TryBuildPolygonLoops(body, face, plane, out var outerPolygon, out var innerPolygons))+ {+ domain = new AnalyticPlanarFaceDomain(+ plane,+ axisBounds: null,+ outerPolygon,+ innerPolygons,+ singleCircularBoundary: null,+ circularExclusionBoundaries: []);+ return true;+ }++ var circularBoundaries = TryResolveCircularBoundaries(body, face);+ if (face.LoopIds.Count == 1 && circularBoundaries.Count == 1)+ {+ domain = new AnalyticPlanarFaceDomain(+ plane,+ axisBounds: null,+ outerPolygon: [],+ innerPolygons: [],+ singleCircularBoundary: circularBoundaries[0],+ circularExclusionBoundaries: []);+ return true;+ }++ if (IsAxisAlignedPlane(plane.Normal.ToVector()))+ {+ TryResolveAxisAlignedBoxBounds(body, out var min, out var max);+ domain = new AnalyticPlanarFaceDomain(+ plane,+ (min, max),+ outerPolygon: [],+ innerPolygons: [],+ singleCircularBoundary: null,+ circularExclusionBoundaries: circularBoundaries);+ return true;+ }++ return false;+ }++ public bool Contains(Point3D point, ToleranceContext tolerance)+ {+ if (_outerPolygon.Count > 0)+ {+ var uv = ProjectToPlane(point, _plane);+ if (!ContainsPoint(_outerPolygon, uv, tolerance))+ {+ return false;+ }++ foreach (var hole in _innerPolygons)+ {+ if (ContainsPoint(hole, uv, tolerance))+ {+ return false;+ }+ }++ return true;+ }++ if (_singleCircularBoundary.HasValue)+ {+ return IsPointInsideCircularBoundary(point, _plane, _singleCircularBoundary.Value.Center, _singleCircularBoundary.Value.Radius, tolerance);+ }++ if (_axisBounds.HasValue)+ {+ if (!IsPointInsideAxisBounds(point, _plane.Normal.ToVector(), _axisBounds.Value.Min, _axisBounds.Value.Max, tolerance))+ {+ return false;+ }+ }++ foreach (var boundary in _circularExclusionBoundaries)+ {+ if (IsPointInsideCircularBoundary(point, _plane, boundary.Center, boundary.Radius, tolerance))+ {+ return false;+ }+ }++ return true;+ }++ private static bool TryBuildPolygonLoops(+ BrepBody body,+ Face face,+ PlaneSurface plane,+ out IReadOnlyList<(double U, double V)> outerPolygon,+ out IReadOnlyList<IReadOnlyList<(double U, double V)>> innerPolygons)+ {+ outerPolygon = [];+ innerPolygons = [];+ if (face.LoopIds.Count == 0)+ {+ return false;+ }++ var loopPolygons = new List<IReadOnlyList<(double U, double V)>>(face.LoopIds.Count);+ foreach (var loopId in face.LoopIds)+ {+ var loop = body.Topology.GetLoop(loopId);+ if (!TryBuildPolygonLoop(body, loop, plane, out var polygon))+ {+ return false;+ }++ loopPolygons.Add(polygon);+ }++ var sorted = loopPolygons+ .Select(loop => (Loop: loop, Area: double.Abs(SignedArea(loop))))+ .OrderByDescending(entry => entry.Area)+ .ToArray();++ if (sorted.Length == 0 || sorted[0].Area <= 1e-9d)+ {+ return false;+ }++ var outer = sorted[0].Loop;+ var holes = new List<IReadOnlyList<(double U, double V)>>(sorted.Length - 1);+ for (var i = 1; i < sorted.Length; i++)+ {+ var candidate = sorted[i].Loop;+ if (!candidate.All(vertex => ContainsPoint(outer, vertex, ToleranceContext.Default)))+ {+ return false;+ }++ holes.Add(candidate);+ }++ outerPolygon = outer;+ innerPolygons = holes;+ return true;+ }++ private static bool TryBuildPolygonLoop(BrepBody body, Loop loop, PlaneSurface plane, out IReadOnlyList<(double U, double V)> polygon)+ {+ polygon = [];+ if (loop.CoedgeIds.Count < 3)+ {+ return false;+ }++ var segments = new List<(Point3D Start, Point3D End)>(loop.CoedgeIds.Count);+ foreach (var coedgeId in loop.CoedgeIds)+ {+ var coedge = body.Topology.GetCoedge(coedgeId);+ if (!body.TryGetEdgeCurveGeometry(coedge.EdgeId, out var curve)+ || curve is null+ || curve.Kind != CurveGeometryKind.Line3)+ {+ return false;+ }++ if (!TryGetCoedgeLineEndpoints(body, coedge, curve.Line3!.Value, out var start, out var end))+ {+ return false;+ }++ segments.Add((start, end));+ }++ var used = new bool[segments.Count];+ var vertices = new List<Point3D>(segments.Count + 1) { segments[0].Start, segments[0].End };+ used[0] = true;++ for (var i = 1; i < segments.Count; i++)+ {+ var currentEnd = vertices[^1];+ var nextIndex = -1;+ var appendVertex = Point3D.Origin;++ for (var candidateIndex = 0; candidateIndex < segments.Count; candidateIndex++)+ {+ if (used[candidateIndex])+ {+ continue;+ }++ var candidate = segments[candidateIndex];+ if (PointsAlmostEqual(candidate.Start, currentEnd))+ {+ nextIndex = candidateIndex;+ appendVertex = candidate.End;+ break;+ }++ if (PointsAlmostEqual(candidate.End, currentEnd))+ {+ nextIndex = candidateIndex;+ appendVertex = candidate.Start;+ break;+ }+ }++ if (nextIndex < 0)+ {+ return false;+ }++ used[nextIndex] = true;+ vertices.Add(appendVertex);+ }++ if (!PointsAlmostEqual(vertices[0], vertices[^1]))+ {+ return false;+ }++ vertices.RemoveAt(vertices.Count - 1);+ if (vertices.Count < 3)+ {+ return false;+ }++ var projected = new List<(double U, double V)>(vertices.Count);+ foreach (var vertex in vertices)+ {+ projected.Add(ProjectToPlane(vertex, plane));+ }++ if (double.Abs(SignedArea(projected)) <= 1e-9d)+ {+ return false;+ }++ polygon = projected;+ return true;+ }++ private static bool TryGetCoedgeLineEndpoints(BrepBody body, Coedge coedge, Line3Curve line, out Point3D start, out Point3D end)+ {+ var edge = body.Topology.GetEdge(coedge.EdgeId);+ var haveStart = body.TryGetVertexPoint(edge.StartVertexId, out var startPoint);+ var haveEnd = body.TryGetVertexPoint(edge.EndVertexId, out var endPoint);+ if (!(haveStart && haveEnd))+ {+ if (!body.Bindings.TryGetEdgeBinding(coedge.EdgeId, out var binding))+ {+ start = default;+ end = default;+ return false;+ }++ var interval = binding.TrimInterval ?? new ParameterInterval(0d, 1d);+ var sampled = CurveSampler.SampleLine(line, interval);+ if (sampled.Count < 2)+ {+ start = default;+ end = default;+ return false;+ }++ startPoint = sampled[0];+ endPoint = sampled[1];+ if (!binding.OrientedEdgeSense)+ {+ (startPoint, endPoint) = (endPoint, startPoint);+ }+ }++ start = coedge.IsReversed ? endPoint : startPoint;+ end = coedge.IsReversed ? startPoint : endPoint;+ return true;+ }++ private static bool PointsAlmostEqual(Point3D a, Point3D b)+ => (a - b).Length <= 1e-7d;++ private static List<(Point3D Center, double Radius)> TryResolveCircularBoundaries(BrepBody body, Face face)+ {+ var boundaries = new List<(Point3D Center, double Radius)>();+ foreach (var loopId in face.LoopIds)+ {+ var loop = body.Topology.GetLoop(loopId);+ var hasOnlyCircles = loop.CoedgeIds.Count > 0;+ Point3D? center = null;+ double? radius = null;+ foreach (var coedgeId in loop.CoedgeIds)+ {+ var edgeId = body.Topology.GetCoedge(coedgeId).EdgeId;+ if (!body.Bindings.TryGetEdgeBinding(edgeId, out var edgeBinding)+ || !body.Geometry.TryGetCurve(edgeBinding.CurveGeometryId, out var curve)+ || curve is not { Kind: CurveGeometryKind.Circle3, Circle3: { } circle })+ {+ hasOnlyCircles = false;+ break;+ }++ center ??= circle.Center;+ radius ??= circle.Radius;+ }++ if (hasOnlyCircles && center.HasValue && radius.HasValue)+ {+ boundaries.Add((center.Value, radius.Value));+ }+ }++ return boundaries;+ }++ private static (double U, double V) ProjectToPlane(Point3D point, PlaneSurface plane)+ {+ var local = point - plane.Origin;+ return (local.Dot(plane.UAxis.ToVector()), local.Dot(plane.VAxis.ToVector()));+ }++ private static bool ContainsPoint(IReadOnlyList<(double U, double V)> polygon, (double U, double V) point, ToleranceContext tolerance)+ {+ var inside = false;+ for (var i = 0; i < polygon.Count; i++)+ {+ var a = polygon[i];+ var b = polygon[(i + 1) % polygon.Count];+ if (DistancePointToSegmentSquared(point, a, b) <= tolerance.Linear * tolerance.Linear)+ {+ return true;+ }++ var intersects = ((a.V > point.V) != (b.V > point.V))+ && (point.U < ((b.U - a.U) * (point.V - a.V) / (b.V - a.V + 1e-20d)) + a.U);+ if (intersects)+ {+ inside = !inside;+ }+ }++ return inside;+ }++ private static double DistancePointToSegmentSquared((double U, double V) point, (double U, double V) a, (double U, double V) b)+ {+ var abU = b.U - a.U;+ var abV = b.V - a.V;+ var lengthSquared = (abU * abU) + (abV * abV);+ if (lengthSquared <= 1e-20d)+ {+ var du = point.U - a.U;+ var dv = point.V - a.V;+ return (du * du) + (dv * dv);+ }++ var apU = point.U - a.U;+ var apV = point.V - a.V;+ var t = double.Clamp(((apU * abU) + (apV * abV)) / lengthSquared, 0d, 1d);+ var closestU = a.U + (abU * t);+ var closestV = a.V + (abV * t);+ var dU = point.U - closestU;+ var dV = point.V - closestV;+ return (dU * dU) + (dV * dV);+ }++ private static double SignedArea(IReadOnlyList<(double U, double V)> polygon)+ {+ var area = 0d;+ for (var i = 0; i < polygon.Count; i++)+ {+ var current = polygon[i];+ var next = polygon[(i + 1) % polygon.Count];+ area += (current.U * next.V) - (next.U * current.V);+ }++ return area * 0.5d;+ }++ private static bool IsAxisAlignedPlane(Vector3D normal)+ => double.Abs(normal.X) > 0.9d || double.Abs(normal.Y) > 0.9d || double.Abs(normal.Z) > 0.9d;++ private static bool IsPointInsideAxisBounds(Point3D point, Vector3D normal, Point3D min, Point3D max, ToleranceContext tolerance)+ {+ if (double.Abs(normal.X) > 0.9d)+ {+ return point.Y >= min.Y - tolerance.Linear && point.Y <= max.Y + tolerance.Linear+ && point.Z >= min.Z - tolerance.Linear && point.Z <= max.Z + tolerance.Linear;+ }++ if (double.Abs(normal.Y) > 0.9d)+ {+ return point.X >= min.X - tolerance.Linear && point.X <= max.X + tolerance.Linear+ && point.Z >= min.Z - tolerance.Linear && point.Z <= max.Z + tolerance.Linear;+ }++ return point.X >= min.X - tolerance.Linear && point.X <= max.X + tolerance.Linear+ && point.Y >= min.Y - tolerance.Linear && point.Y <= max.Y + tolerance.Linear;+ }++ private static bool IsPointInsideCircularBoundary(Point3D point, PlaneSurface plane, Point3D center, double radius, ToleranceContext tolerance)+ {+ var radial = point - center;+ var height = radial.Dot(plane.Normal.ToVector());+ var inPlaneRadial = radial - (plane.Normal.ToVector() * height);+ return inPlaneRadial.Dot(inPlaneRadial) <= (radius + tolerance.Linear) * (radius + tolerance.Linear);+ }++ private static bool TryResolveAxisAlignedBoxBounds(BrepBody body, out Point3D min, out Point3D max)+ {+ min = default;+ max = default;+ var hasXMin = false;+ var hasXMax = false;+ var hasYMin = false;+ var hasYMax = false;+ var hasZMin = false;+ var hasZMax = false;++ foreach (var faceBinding in body.Bindings.FaceBindings)+ {+ var surface = body.Geometry.GetSurface(faceBinding.SurfaceGeometryId);+ if (surface.Kind != SurfaceGeometryKind.Plane || surface.Plane is not PlaneSurface plane)+ {+ continue;+ }++ var n = plane.Normal;+ if (ToleranceMath.AlmostEqual(n.X, -1d, ToleranceContext.Default))+ {+ min = min with { X = plane.Origin.X };+ hasXMin = true;+ }+ else if (ToleranceMath.AlmostEqual(n.X, 1d, ToleranceContext.Default))+ {+ max = max with { X = plane.Origin.X };+ hasXMax = true;+ }+ else if (ToleranceMath.AlmostEqual(n.Y, -1d, ToleranceContext.Default))+ {+ min = min with { Y = plane.Origin.Y };+ hasYMin = true;+ }+ else if (ToleranceMath.AlmostEqual(n.Y, 1d, ToleranceContext.Default))+ {+ max = max with { Y = plane.Origin.Y };+ hasYMax = true;+ }+ else if (ToleranceMath.AlmostEqual(n.Z, -1d, ToleranceContext.Default))+ {+ min = min with { Z = plane.Origin.Z };+ hasZMin = true;+ }+ else if (ToleranceMath.AlmostEqual(n.Z, 1d, ToleranceContext.Default))+ {+ max = max with { Z = plane.Origin.Z };+ hasZMax = true;+ }+ }++ return hasXMin && hasXMax && hasYMin && hasYMax && hasZMin && hasZMax;+ }+}