perf(geometry): simplify exact planar containment and distance predicates

Author: mrdav30

src/FixedMathSharp/Geometry/Primitives/Segments/FixedSegment2d.cs

@@ -142,7 +142,7 @@ public readonly bool IsDistanceAtLeast(
         if (TryGetUniqueIntersection(other, out _, out _))
             return false;
 
-        return WidePlanarProjection.AreSegmentEndpointDistancesAtLeast(
+        return WideFiniteAxisIntersection.AreSegmentEndpointDistancesAtLeast(
             this,
             other,
             minimumDistance);

src/FixedMathSharp/Geometry/Wide/Common/WidePlanarProjection.cs

@@ -52,53 +52,6 @@ internal RationalDistance(
 
     #endregion
 
-    internal static bool AreSegmentEndpointDistancesAtLeast(
-        FixedSegment2d first,
-        FixedSegment2d second,
-        Fixed64 minimumDistance)
-    {
-        Signed192 denominator = Signed192.Signed(1L);
-        RationalPoint firstStart = GetRawPoint(first.Start);
-        RationalPoint firstEnd = GetRawPoint(first.End);
-        RationalPoint secondStart = GetRawPoint(second.Start);
-        RationalPoint secondEnd = GetRawPoint(second.End);
-        Signed192 minimumRaw = Signed192.Raw(minimumDistance);
-
-        return CompareDistanceToRaw(
-                GetSegmentDistance(
-                    first.Start,
-                    denominator,
-                    secondStart,
-                    secondEnd),
-                minimumRaw) >= 0
-            && CompareDistanceToRaw(
-                GetSegmentDistance(
-                    first.End,
-                    denominator,
-                    secondStart,
-                    secondEnd),
-                minimumRaw) >= 0
-            && CompareDistanceToRaw(
-                GetSegmentDistance(
-                    second.Start,
-                    denominator,
-                    firstStart,
-                    firstEnd),
-                minimumRaw) >= 0
-            && CompareDistanceToRaw(
-                GetSegmentDistance(
-                    second.End,
-                    denominator,
-                    firstStart,
-                    firstEnd),
-                minimumRaw) >= 0;
-    }
-
-    private static RationalPoint GetRawPoint(Vector2d point) =>
-        new(
-            Signed320.ExtendValue(Signed192.Raw(point.X)),
-            Signed320.ExtendValue(Signed192.Raw(point.Y)));
-
     internal static bool TryGetSphereRelation(
         Vector2d circleCenter,
         Fixed64 circleRadius,

src/FixedMathSharp/Geometry/Wide/Convex/WideConvex2dRelations.cs

@@ -495,6 +495,9 @@ internal static bool ContainsPoint(
         Fixed64 convexRotation,
         ReadOnlySpan<Vector2d> convexVertexOffsets)
     {
+        if (convexRotation == Fixed64.Zero)
+            return ContainsPointUnrotated(point, convexOrigin, convexVertexOffsets);
+
         RotationFrame2d convexFrame = new(convexRotation);
         // Widen before subtracting: the point-to-origin displacement can exceed
         // the scalar domain. Keep it at the rotated vertices' product scale.
@@ -545,6 +548,45 @@ internal static bool ContainsPoint(
         return true;
     }
 
+    private static bool ContainsPointUnrotated(
+        Vector2d point,
+        Vector2d convexOrigin,
+        ReadOnlySpan<Vector2d> convexVertexOffsets)
+    {
+        // At zero rotation the general determinant is this raw determinant times
+        // 2^64, so its sign is unchanged. Widen before every subtraction: edges
+        // need 65 signed bits and point - origin - vertex can need 66.
+        Signed192 relativePointX = WideArithmetic.Difference(point.X, convexOrigin.X);
+        Signed192 relativePointY = WideArithmetic.Difference(point.Y, convexOrigin.Y);
+        Vector2d start = convexVertexOffsets[0];
+        bool hasPositive = false;
+        bool hasNegative = false;
+        for (int i = 0; i < convexVertexOffsets.Length; i++)
+        {
+            Vector2d end = convexVertexOffsets[
+                i + 1 == convexVertexOffsets.Length ? 0 : i + 1];
+            Signed192 edgeX = WideArithmetic.Difference(end.X, start.X);
+            Signed192 edgeY = WideArithmetic.Difference(end.Y, start.Y);
+            Signed192 pointX = WideArithmetic.SubtractSigned192(relativePointX, Signed192.Raw(start.X));
+            Signed192 pointY = WideArithmetic.SubtractSigned192(relativePointY, Signed192.Raw(start.Y));
+            int orientation = WideArithmetic.MultiplySubtract(
+                edgeX,
+                pointY,
+                edgeY,
+                pointX).Sign;
+            if (orientation > 0)
+                hasPositive = true;
+            else if (orientation < 0)
+                hasNegative = true;
+            if (hasPositive && hasNegative)
+                return false;
+
+            start = end;
+        }
+
+        return true;
+    }
+
     internal static bool TryProjectAnchorOntoFeature(
         in FixedPointAnchor2d source,
         Vector2d targetOrigin,

src/FixedMathSharp/Geometry/Wide/FiniteAxis/WideFiniteAxisIntersection.Containment.cs

@@ -14,6 +14,43 @@ namespace FixedMathSharp.Geometry;
 /// </content>
 internal static partial class WideFiniteAxisIntersection
 {
+    internal static bool AreSegmentEndpointDistancesAtLeast(
+        FixedSegment2d first,
+        FixedSegment2d second,
+        Fixed64 minimumDistance)
+    {
+        if (second.Start == second.End)
+        {
+            FixedSegment2d temporary = first;
+            first = second;
+            second = temporary;
+        }
+
+        Signed192 squaredRadius = GetSquaredRadius(Signed192.Raw(minimumDistance));
+        bool firstSeparated = IsPointSegmentDistanceAtLeast(first.Start, second, squaredRadius);
+        // For a point, this is the complete minimum distance. Distances to the
+        // other segment's endpoints cannot be smaller, and repeating the point adds nothing.
+        if (!firstSeparated || first.Start == first.End)
+            return firstSeparated;
+
+        return IsPointSegmentDistanceAtLeast(first.End, second, squaredRadius)
+            && IsPointSegmentDistanceAtLeast(second.Start, first, squaredRadius)
+            && IsPointSegmentDistanceAtLeast(second.End, first, squaredRadius);
+    }
+
+    private static bool IsPointSegmentDistanceAtLeast(
+        Vector2d point,
+        FixedSegment2d segment,
+        Signed192 squaredRadius) =>
+        // Negating strict capsule containment keeps equality without rounding a distance.
+        !IsCapsulePointContained(
+            GetDot(point, segment.Start, point, segment.Start),
+            GetDot(point, segment.End, point, segment.End),
+            GetDot(point, segment.Start, segment.End, segment.Start),
+            GetDot(segment.End, segment.Start, segment.End, segment.Start),
+            squaredRadius,
+            strict: true);
+
     internal static bool ContainsPointInCenteredFiniteCylinder(
         Vector3d point,
         Vector3d center,

src/FixedMathSharp/Geometry/Wide/FiniteAxis/WideFiniteAxisIntersection.cs

@@ -58,13 +58,10 @@ internal static bool TryGetCapsuleInterval(
         Signed192 expandedRadius = GetExpandedRadius(radius, radiusExpansion);
         Signed192 squaredRadius = GetSquaredRadius(expandedRadius);
         Signed192 axisLengthSquared = GetDot(axis.End, axis.Start, axis.End, axis.Start);
-        Signed192 queryLengthSquared = GetDot(query.End, query.Start, query.End, query.Start);
         Signed192 startDistanceSquared = GetDot(query.Start, axis.Start, query.Start, axis.Start);
         Signed192 endDistanceSquared = GetDot(query.End, axis.Start, query.End, axis.Start);
-        Signed192 directionsDot = GetDot(query.End, query.Start, axis.End, axis.Start);
         Signed192 startAxisProjection = GetDot(query.Start, axis.Start, axis.End, axis.Start);
         Signed192 endAxisProjection = GetDot(query.End, axis.Start, axis.End, axis.Start);
-        Signed192 startDirectionProjection = GetDot(query.Start, axis.Start, query.End, query.Start);
 
         if (axisLengthSquared.IsZero)
         {
@@ -93,6 +90,18 @@ internal static bool TryGetCapsuleInterval(
             axisLengthSquared,
             squaredRadius,
             strict: true);
+        // A capsule is convex: these already-certified endpoints enclose the
+        // complete query, so neither the finite-axis nor cap solves add evidence.
+        if (startContained && endContainedStrict)
+        {
+            entry = Fixed64.Zero;
+            exit = Fixed64.One;
+            return true;
+        }
+
+        Signed192 queryLengthSquared = GetDot(query.End, query.Start, query.End, query.Start);
+        Signed192 directionsDot = GetDot(query.End, query.Start, axis.End, axis.Start);
+        Signed192 startDirectionProjection = GetDot(query.Start, axis.Start, query.End, query.Start);
         bool found = TryGetFiniteAxisInterval(
             queryLengthSquared,
             axisLengthSquared,

tests/FixedMathSharp.Tests/Geometry/Primitives/FiniteAxisIntersection.Capsule.Tests.cs

@@ -7,6 +7,49 @@ namespace FixedMathSharp.Tests.Bounds;
 
 public sealed partial class FiniteAxisIntersectionTests
 {
+    [Theory]
+    [InlineData(false, false)]
+    [InlineData(false, true)]
+    [InlineData(true, false)]
+    [InlineData(true, true)]
+    public void EndpointCapsule2d_ContainedSegmentsRetainTheFullDomain(bool fullDomain, bool point)
+    {
+        FixedSegment2d axis = new(
+            new Vector2d(fullDomain ? Fixed64.MinValue : new Fixed64(-4), Fixed64.Zero),
+            new Vector2d(fullDomain ? Fixed64.MaxValue : new Fixed64(4), Fixed64.Zero));
+        FixedSegment2d query = point
+            ? new FixedSegment2d(new Vector2d(Fixed64.Zero, Fixed64.Half),
+                new Vector2d(Fixed64.Zero, Fixed64.Half))
+            : fullDomain ? axis : new FixedSegment2d(
+                new Vector2d(new Fixed64(-4) - Fixed64.Half, Fixed64.Zero),
+                new Vector2d(new Fixed64(4) + Fixed64.Half, Fixed64.Zero));
+
+        Assert.True(query.TryGetCapsuleIntersectionInterval(axis, Fixed64.Half, Fixed64.Half,
+            out Fixed64 entry, out Fixed64 exit, out bool startContained, out bool endContainedStrict));
+        Assert.Equal(Fixed64.Zero, entry);
+        Assert.Equal(Fixed64.One, exit);
+        Assert.True(startContained);
+        Assert.True(endContainedStrict);
+    }
+
+    [Theory]
+    [InlineData(1, 0, 0L, 4294967296L, true, true)]
+    [InlineData(0, 1, 0L, 4294967296L, true, false)]
+    [InlineData(2, 0, 2147483648L, 4294967296L, false, true)]
+    [InlineData(0, 2, 0L, 2147483648L, true, false)]
+    public void EndpointCapsule2d_BoundaryAndPartialQueriesRetainExactContainmentFlags(
+        int startY, int endY, long entryRaw, long exitRaw, bool expectedStart, bool expectedEndStrict)
+    {
+        FixedSegment2d axis = new(new Vector2d(-1, 0), new Vector2d(1, 0));
+        FixedSegment2d query = new(new Vector2d(0, startY), new Vector2d(0, endY));
+        Assert.True(query.TryGetCapsuleIntersectionInterval(axis, Fixed64.One, Fixed64.Zero,
+            out Fixed64 entry, out Fixed64 exit, out bool startContained, out bool endContainedStrict));
+        Assert.Equal(Fixed64.FromRaw(entryRaw), entry);
+        Assert.Equal(Fixed64.FromRaw(exitRaw), exit);
+        Assert.Equal(expectedStart, startContained);
+        Assert.Equal(expectedEndStrict, endContainedStrict);
+    }
+
     [Fact]
     public void CenteredCapsule_RepresentableAxisMatchesEndpointContract()
     {

tests/FixedMathSharp.Tests/Geometry/Primitives/FixedConvex2dRelations.Tests.cs

@@ -217,6 +217,85 @@ public void ContainsPoint_PreservesRotatedEdgesWiderThanTheScalarDomain(bool clo
             new(Fixed64.MinValue, Fixed64.Zero), new(Fixed64.MaxValue, Fixed64.Zero), Fixed64.PiOver4, rectangle));
     }
 
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public void ContainsPoint_ZeroRotationPreservesFullDomainDiagonal(bool clockwise)
+    {
+        Vector2d[] triangle =
+        {
+            new(Fixed64.MinValue, Fixed64.MinValue),
+            new(Fixed64.MaxValue, Fixed64.MinValue),
+            new(Fixed64.MinValue, Fixed64.MaxValue)
+        };
+        if (clockwise)
+            Array.Reverse(triangle);
+
+        // The diagonal is x + y = -1 raw unit, not zero: MinValue + MaxValue = -1 raw.
+        AssertZeroRotationContainment(true, triangle[0], Vector2d.Zero, triangle);
+        AssertZeroRotationContainment(true,
+            new(Fixed64.Zero, -Fixed64.MinIncrement), Vector2d.Zero, triangle);
+        AssertZeroRotationContainment(false, Vector2d.Zero, Vector2d.Zero, triangle);
+    }
+
+    [Theory]
+    [InlineData(false, false)]
+    [InlineData(false, true)]
+    [InlineData(true, false)]
+    [InlineData(true, true)]
+    public void ContainsPoint_ZeroRotationDoesNotNarrowOppositeExtremeDisplacements(
+        bool clockwise,
+        bool positiveOrigin)
+    {
+        Vector2d[] rectangle =
+        {
+            new(Fixed64.MinValue, Fixed64.MinValue),
+            new(Fixed64.MaxValue, Fixed64.MinValue),
+            new(Fixed64.MaxValue, Fixed64.MaxValue),
+            new(Fixed64.MinValue, Fixed64.MaxValue)
+        };
+        if (clockwise)
+            Array.Reverse(rectangle);
+        Fixed64 originCoordinate = positiveOrigin ? Fixed64.MaxValue : Fixed64.MinValue;
+        Fixed64 pointCoordinate = positiveOrigin ? Fixed64.MinValue : Fixed64.MaxValue;
+        Vector2d origin = new(originCoordinate, originCoordinate);
+
+        AssertZeroRotationContainment(true, origin, origin, rectangle);
+        // Each displacement exceeds the raw scalar range; clamping would put it on an included face.
+        AssertZeroRotationContainment(false, new(pointCoordinate, originCoordinate), origin, rectangle);
+        AssertZeroRotationContainment(false, new(originCoordinate, pointCoordinate), origin, rectangle);
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public void ContainsPoint_ZeroRotationPreservesCollinearAndRepeatedEdges(bool clockwise)
+    {
+        Vector2d[] rectangle =
+        {
+            new(0, 0), new(1, 0), new(2, 0), new(2, 0), new(2, 2), new(0, 2)
+        };
+        if (clockwise)
+            Array.Reverse(rectangle);
+        Vector2d origin = new(40, 50);
+
+        AssertZeroRotationContainment(true, new(41, 51), origin, rectangle);
+        AssertZeroRotationContainment(true, new(40, 51), origin, rectangle);
+        // Only the last-to-first edge rejects this point, in either authored winding.
+        AssertZeroRotationContainment(false,
+            new((Fixed64)40 - Fixed64.MinIncrement, (Fixed64)51), origin, rectangle);
+    }
+
+    private static void AssertZeroRotationContainment(
+        bool expected,
+        Vector2d point,
+        Vector2d origin,
+        Vector2d[] offsets)
+    {
+        Assert.Equal(expected, FixedConvex2dRelations.ContainsPoint(point, origin, offsets));
+        Assert.Equal(expected, FixedConvex2dRelations.ContainsPoint(point, origin, Fixed64.Zero, offsets));
+    }
+
     [Fact]
     public void SupportOffset_PreservesTheFirstAuthoredFeatureOnAnExactTie()
     {