Remove duplicate spherical implementation conflicting with UnitSpherical version

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: asinghvi17

src/methods/clipping/sutherland_hodgman.jl

@@ -359,296 +359,3 @@ function _intersection_sutherland_hodgman(
         "got $(typeof(trait_a)) and $(typeof(trait_b))"
     ))
 end
-
-# =============================================================================
-# Spherical Implementation
-# =============================================================================
-
-using ..UnitSpherical: UnitSphericalPoint, UnitSphereFromGeographic, GeographicFromUnitSphere
-using LinearAlgebra: cross, dot, normalize, norm
-
-"""
-    spherical_orient(a, b, c)
-
-Compute the orientation of point `c` with respect to the great circle through `a` and `b`.
-
-Returns:
-- Positive if `c` is to the left of the directed great circle arc from `a` to `b`
-- Negative if `c` is to the right
-- Zero if `c` is on the great circle
-
-The orientation is computed as the triple scalar product: (a × b) · c
-"""
-function spherical_orient(a::UnitSphericalPoint, b::UnitSphericalPoint, c::UnitSphericalPoint)
-    # Triple scalar product: (a × b) · c
-    return dot(cross(a, b), c)
-end
-
-"""
-    _point_in_convex_spherical_polygon(point, polygon_points)
-
-Check if a point is STRICTLY inside a convex spherical polygon.
-
-Returns `true` only if the point is strictly inside (all orientations positive).
-Returns `false` if the point is on the boundary (any orientation is zero) or outside.
-
-This is critical for the fallback containment check in Sutherland-Hodgman:
-points exactly ON the boundary should NOT be considered "inside", as this would
-cause adjacent (non-overlapping) polygons to incorrectly return the clip polygon.
-"""
-function _point_in_convex_spherical_polygon(
-    point::UnitSphericalPoint,
-    polygon_points::Vector{<:UnitSphericalPoint}
-)
-    n = length(polygon_points)
-    n < 3 && return false
-
-    for i in 1:n
-        edge_start = polygon_points[i]
-        edge_end = polygon_points[mod1(i + 1, n)]
-        orient = spherical_orient(edge_start, edge_end, point)
-        if orient <= 0  # strictly outside OR on the boundary
-            return false
-        end
-    end
-    return true  # strictly inside (all orient > 0)
-end
-
-# Helper to convert a GeoInterface point to UnitSphericalPoint
-function _to_unit_spherical(point)
-    return UnitSphericalPoint(GI.PointTrait(), point)
-end
-
-# Spherical Polygon-Polygon intersection using Sutherland-Hodgman
-function _intersection_sutherland_hodgman(
-    alg::ConvexConvexSutherlandHodgman{<:Spherical},
-    ::Type{T},
-    ::GI.PolygonTrait, poly_a,
-    ::GI.PolygonTrait, poly_b
-) where {T}
-    # Get exterior rings (convex polygons have no holes)
-    ring_a = GI.getexterior(poly_a)
-    ring_b = GI.getexterior(poly_b)
-
-    # Convert poly_a vertices to UnitSphericalPoints (excluding closing point)
-    output = UnitSphericalPoint{T}[]
-    for point in GI.getpoint(ring_a)
-        pt = _to_unit_spherical(point)
-        pt_typed = UnitSphericalPoint{T}(pt.x, pt.y, pt.z)
-        # Skip the closing point (same as first)
-        if !isempty(output) && isapprox(pt_typed, output[1]; atol=eps(T)*10)
-            continue
-        end
-        push!(output, pt_typed)
-    end
-
-    # Store original subject polygon for containment check
-    original_subject = copy(output)
-
-    # Convert clip polygon vertices (excluding closing point)
-    clip_points = UnitSphericalPoint{T}[]
-    for point in GI.getpoint(ring_b)
-        pt = _to_unit_spherical(point)
-        pt_typed = UnitSphericalPoint{T}(pt.x, pt.y, pt.z)
-        if !isempty(clip_points) && isapprox(pt_typed, clip_points[1]; atol=eps(T)*10)
-            continue
-        end
-        push!(clip_points, pt_typed)
-    end
-
-    # Clip against each edge of poly_b
-    n_clip = length(clip_points)
-    for i in 1:n_clip
-        isempty(output) && break
-        edge_start = clip_points[i]
-        edge_end = clip_points[mod1(i + 1, n_clip)]
-        output = _sh_spherical_clip_to_edge(output, edge_start, edge_end, T)
-    end
-
-    # Handle empty result - check if clip polygon is fully inside the original subject
-    if isempty(output)
-        # Use strict interior check: point ON boundary returns false
-        if !isempty(clip_points) && _point_in_convex_spherical_polygon(clip_points[1], original_subject)
-            # Subject strictly contains clip - return clip polygon
-            result = copy(clip_points)
-            push!(result, result[1])
-            return _spherical_polygon_to_geo(result, T)
-        end
-        # No intersection - return degenerate polygon with zero area
-        zero_pt = (zero(T), zero(T))
-        return GI.Polygon([[zero_pt, zero_pt, zero_pt]])
-    end
-
-    # Check for degenerate result (collinear points = line segment, not polygon)
-    # This happens when adjacent polygons share an edge
-    if _is_degenerate_spherical_polygon(output, T)
-        zero_pt = (zero(T), zero(T))
-        return GI.Polygon([[zero_pt, zero_pt, zero_pt]])
-    end
-
-    # Close the ring and convert back to geographic coordinates
-    push!(output, output[1])
-    return _spherical_polygon_to_geo(output, T)
-end
-
-"""
-    _is_degenerate_spherical_polygon(points, T)
-
-Check if a set of spherical points forms a degenerate polygon (zero area).
-
-A polygon is degenerate if:
-1. It has fewer than 3 distinct points
-2. All points are collinear (lie on a single great circle)
-
-This is critical for detecting edge-sharing cases where Sutherland-Hodgman
-produces a "polygon" that is actually just a line segment.
-"""
-function _is_degenerate_spherical_polygon(
-    points::Vector{UnitSphericalPoint{T}},
-    ::Type{T}
-) where T
-    n = length(points)
-    n < 3 && return true
-
-    # Remove duplicate/very close points
-    unique_points = UnitSphericalPoint{T}[]
-    for p in points
-        is_dup = false
-        for existing in unique_points
-            if isapprox(p, existing; atol=eps(T)*100)
-                is_dup = true
-                break
-            end
-        end
-        if !is_dup
-            push!(unique_points, p)
-        end
-    end
-
-    length(unique_points) < 3 && return true
-
-    # Check if all points are collinear on the sphere
-    # Points are collinear if they all lie on the same great circle
-    # This is true if for any three points A, B, C: (A × B) · C ≈ 0
-    p1 = unique_points[1]
-    p2 = unique_points[2]
-
-    # Normal to the great circle through p1 and p2
-    normal = cross(p1, p2)
-    normal_len_sq = dot(normal, normal)
-
-    # If p1 and p2 are nearly identical or antipodal, can't determine great circle
-    if normal_len_sq < eps(T)
-        return true
-    end
-
-    # Check if all other points lie on the same great circle
-    for i in 3:length(unique_points)
-        p = unique_points[i]
-        # Distance from point to great circle plane
-        dist = abs(dot(normal, p)) / sqrt(normal_len_sq)
-        if dist > sqrt(eps(T))  # Point is not on the great circle
-            return false  # Non-degenerate polygon
-        end
-    end
-
-    return true  # All points are collinear
-end
-
-# Convert UnitSphericalPoints back to geographic polygon
-function _spherical_polygon_to_geo(points::Vector{UnitSphericalPoint{T}}, ::Type{T}) where T
-    geo_transform = GeographicFromUnitSphere()
-    geo_points = [geo_transform(p) for p in points]
-    return GI.Polygon([geo_points])
-end
-
-# Clip polygon against a single spherical edge using Sutherland-Hodgman rules
-function _sh_spherical_clip_to_edge(
-    polygon_points::Vector{UnitSphericalPoint{T}},
-    edge_start::UnitSphericalPoint{T},
-    edge_end::UnitSphericalPoint{T},
-    ::Type{T}
-) where T
-    output = UnitSphericalPoint{T}[]
-    n = length(polygon_points)
-    n == 0 && return output
-
-    for i in 1:n
-        current = polygon_points[i]
-        next_pt = polygon_points[mod1(i + 1, n)]
-
-        # Determine if points are inside (left of or on the edge)
-        # orient > 0 means left (inside for CCW polygon), == 0 means on edge, < 0 means right (outside)
-        current_orient = spherical_orient(edge_start, edge_end, current)
-        next_orient = spherical_orient(edge_start, edge_end, next_pt)
-
-        current_inside = current_orient >= 0
-        next_inside = next_orient >= 0
-
-        if current_inside
-            push!(output, current)
-            if !next_inside
-                # Exiting: add intersection point
-                intr_pt = _sh_spherical_line_intersection(current, next_pt, edge_start, edge_end, T)
-                if !isnothing(intr_pt)
-                    push!(output, intr_pt)
-                end
-            end
-        elseif next_inside
-            # Entering: add intersection point
-            intr_pt = _sh_spherical_line_intersection(current, next_pt, edge_start, edge_end, T)
-            if !isnothing(intr_pt)
-                push!(output, intr_pt)
-            end
-        end
-        # Both outside: add nothing
-    end
-
-    return output
-end
-
-# Compute intersection point of two great circle arcs
-function _sh_spherical_line_intersection(
-    p1::UnitSphericalPoint{T},
-    p2::UnitSphericalPoint{T},
-    p3::UnitSphericalPoint{T},
-    p4::UnitSphericalPoint{T},
-    ::Type{T}
-) where T
-    # The intersection of two great circles is found by:
-    # 1. Compute normal vectors to each great circle plane
-    # 2. The intersection is the cross product of these normals (normalized)
-
-    # Normal to great circle through p1, p2
-    n1 = cross(p1, p2)
-    # Normal to great circle through p3, p4
-    n2 = cross(p3, p4)
-
-    # Cross product gives intersection direction
-    intersection_dir = cross(n1, n2)
-
-    # Check if great circles are parallel (no intersection or same circle)
-    len_sq = dot(intersection_dir, intersection_dir)
-    if len_sq < eps(T)^2
-        # Great circles are parallel - return midpoint as fallback
-        return nothing
-    end
-
-    # Normalize to get point on unit sphere
-    intersection_pt = normalize(intersection_dir)
-
-    # The cross product gives us one of two antipodal points
-    # We need to pick the one that lies on the arcs (or closer to them)
-    # Check if this point is on the correct side of both arcs
-    # Use dot product to check if point is in the "positive" direction
-
-    # Check which of the two antipodal points is closer to the arc midpoints
-    mid1 = normalize(p1 + p2)
-    mid2 = normalize(p3 + p4)
-
-    if dot(intersection_pt, mid1) < 0 || dot(intersection_pt, mid2) < 0
-        intersection_pt = -intersection_pt
-    end
-
-    return UnitSphericalPoint{T}(intersection_pt.x, intersection_pt.y, intersection_pt.z)
-end