Skip to content

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.cs
index 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.cs
index 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.cs
index 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 AnalyticDisplayQuery
private 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.cs
index 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 AnalyticDisplaySupportPolicy
return 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.cs
new file mode 100644
index 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;
+ }
+}