interior-point 1.0.0

JTS InteriorPoint algorithm ported to Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

//! Ports `InteriorPoint.java`.
//!
//! @jts InteriorPoint

use geo_types::{Coord, Geometry};

use crate::algorithm::interior_point_area::interior_point_area;
use crate::algorithm::interior_point_line::interior_point_line;
use crate::algorithm::interior_point_point::interior_point_point;
use crate::geometry_adapter::{dimension, is_geometry_empty};

/// Computes a location of an interior point in a `Geometry`.
/// Handles all geometry types.
///
/// For collections, the interior point is computed for the collection of
/// non-empty elements of highest dimension:
///
/// - **Dimension 2** (Polygon/MultiPolygon) — the point is in the interior of
///   the widest scan-line section.
/// - **Dimension 1** (LineString/MultiLineString) — the point is the interior
///   vertex closest to the centroid.
/// - **Dimension 0** (Point/MultiPoint) — the point is the point closest to
///   the centroid.
///
/// Returns the location of an interior point, or `None` if the input is empty.
///
/// @jts InteriorPoint#getInteriorPoint(Geometry)
/// @jts-deviate module-level name — `get_interior_point` would collide with the
///   same static factory in the other three modules.
pub fn interior_point(geom: &Geometry<f64>) -> Option<Coord<f64>> {
    if is_geometry_empty(geom) {
        return None;
    }

    let interior_pt;
    let dim = dimension_non_empty(geom);
    // this should not happen, but just in case...
    if dim < 0 {
        return None;
    }
    if dim == 0 {
        interior_pt = interior_point_point(geom);
    } else if dim == 1 {
        interior_pt = interior_point_line(geom);
    } else {
        interior_pt = interior_point_area(geom);
    }
    interior_pt
}

/// @jts InteriorPoint#dimensionNonEmpty(Geometry)
pub(crate) fn dimension_non_empty(geom: &Geometry<f64>) -> i32 {
    // JTS builds the filter and applies it; here the filter is the traversal,
    // so this is a single call.
    dimension_non_empty_filter(geom)
}

/// @jts InteriorPoint.DimensionNonEmptyFilter#filter(Geometry)
/// @jts InteriorPoint.DimensionNonEmptyFilter#getDimension()
/// @jts-deviate GeometryFilter / Geometry.apply() are not part of the adapted
///   geometry model, so the filter becomes a recursive traversal with identical
///   semantics. The receptacle is preserved, per the structure rule: the function
///   keeps the filter's name and its body mirrors `filter(Geometry elem)`,
///   returning what `getDimension()` would have reported.
fn dimension_non_empty_filter(elem: &Geometry<f64>) -> i32 {
    let mut dim = -1;
    if let Geometry::GeometryCollection(gc) = elem {
        for g in &gc.0 {
            let elem_dim = dimension_non_empty_filter(g);
            if elem_dim > dim {
                dim = elem_dim;
            }
        }
        return dim;
    }
    if !is_geometry_empty(elem) {
        let elem_dim = dimension(elem);
        if elem_dim > dim {
            dim = elem_dim;
        }
    }
    dim
}