Function polygon_contains_polygon

nodedb-spatial/src/predicates/contains.rs:193–232

Polygon A contains Polygon B.

(rings_a: &[Vec<[f64; 2]>], rings_b: &[Vec<[f64; 2]>])

/// Polygon A contains Polygon B.
fn polygon_contains_polygon(rings_a: &[Vec<[f64; 2]>], rings_b: &[Vec<[f64; 2]>]) -> bool {
    let Some(ext_b) = rings_b.first() else {
        return true;
    };

    // All vertices of B's exterior must be inside A (or on A's boundary,
    // but at least one must be strictly inside).
    let Some(ext_a) = rings_a.first() else {
        return false;
    };

    for pt in ext_b {
        if !point_in_polygon(pt[0], pt[1], ext_a) && !point_on_ring_boundary(*pt, ext_a) {
            return false;
        }
    }

    // B's exterior must not be inside any hole of A.
    for hole in &rings_a[1..] {
        for pt in ext_b {
            if point_in_polygon(pt[0], pt[1], hole) {
                return false;
            }
        }
    }

    // No proper edge crossings between A's exterior and B's exterior.
    let a_edges = ring_edges(ext_a);
    let b_edges = ring_edges(ext_b);
    for &(a1, a2) in &a_edges {
        for &(b1, b2) in &b_edges {
            if edges_properly_cross(a1, a2, b1, b2) {
                return false;
            }
        }
    }

    // At least one vertex of B must be strictly inside A.
    ext_b.iter().any(|pt| polygon_contains_point(rings_a, *pt))
}

/// Whether two segments properly cross (not just touch at endpoints).
fn edges_properly_cross(a1: [f64; 2], a2: [f64; 2], b1: [f64; 2], b2: [f64; 2]) -> bool {