geoarrow-array 0.8.0

GeoArrow array definitions.
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use geoarrow_schema::PolygonType;
use geozero::{GeomProcessor, GeozeroGeometry};

use crate::array::PolygonArray;
use crate::builder::PolygonBuilder;
use crate::capacity::PolygonCapacity;
use crate::geozero::import::util::{from_xy, from_xyzm};

/// GeoZero trait to convert to GeoArrow PolygonArray.
pub trait ToPolygonArray {
    /// Convert to GeoArrow PolygonArray
    fn to_polygon_array(&self, typ: PolygonType) -> geozero::error::Result<PolygonArray> {
        Ok(self.to_polygon_builder(typ)?.finish())
    }

    /// Convert to a GeoArrow PolygonBuilder
    fn to_polygon_builder(&self, typ: PolygonType) -> geozero::error::Result<PolygonBuilder>;
}

impl<T: GeozeroGeometry> ToPolygonArray for T {
    fn to_polygon_builder(&self, typ: PolygonType) -> geozero::error::Result<PolygonBuilder> {
        let mut mutable_array = PolygonBuilder::new(typ);
        self.process_geom(&mut mutable_array)?;
        Ok(mutable_array)
    }
}

#[allow(unused_variables)]
impl GeomProcessor for PolygonBuilder {
    fn geometrycollection_begin(&mut self, size: usize, idx: usize) -> geozero::error::Result<()> {
        // reserve `size` geometries
        let capacity = PolygonCapacity::new(0, 0, size);
        self.reserve(capacity);
        Ok(())
    }

    fn geometrycollection_end(&mut self, idx: usize) -> geozero::error::Result<()> {
        // self.shrink_to_fit()
        Ok(())
    }

    fn xy(&mut self, x: f64, y: f64, idx: usize) -> geozero::error::Result<()> {
        // # Safety:
        // This upholds invariants because we call try_push_length in polygon_begin to ensure
        // offset arrays are correct.
        self.push_coord(&from_xy(x, y).expect("valid coord"))
            .unwrap();
        Ok(())
    }

    fn coordinate(
        &mut self,
        x: f64,
        y: f64,
        z: Option<f64>,
        m: Option<f64>,
        t: Option<f64>,
        tm: Option<u64>,
        idx: usize,
    ) -> geozero::error::Result<()> {
        // # Safety:
        // This upholds invariants because we call try_push_length in polygon_begin to ensure
        // offset arrays are correct.
        self.push_coord(&from_xyzm(x, y, z, m).expect("valid coord"))
            .unwrap();
        Ok(())
    }

    // Here, size is the number of rings in the polygon
    fn polygon_begin(
        &mut self,
        tagged: bool,
        size: usize,
        idx: usize,
    ) -> geozero::error::Result<()> {
        // reserve `size` rings
        let capacity = PolygonCapacity::new(0, size, 0);
        self.reserve(capacity);

        // # Safety:
        // This upholds invariants because we separately update the ring offsets in
        // linestring_begin
        self.try_push_geom_offset(size).unwrap();
        Ok(())
    }

    fn linestring_begin(
        &mut self,
        tagged: bool,
        size: usize,
        idx: usize,
    ) -> geozero::error::Result<()> {
        // reserve `size` coordinates
        let capacity = PolygonCapacity::new(size, 0, 0);
        self.reserve(capacity);

        // # Safety:
        // This upholds invariants because we separately update the geometry offsets in
        // polygon_begin
        self.try_push_ring_offset(size).unwrap();
        Ok(())
    }
}

#[cfg(test)]
mod test {
    use geo_types::Geometry;
    use geoarrow_schema::Dimension;
    use geozero::error::Result;

    use super::*;
    use crate::test::polygon::{p0, p1};

    #[test]
    fn from_geozero() -> Result<()> {
        let geo_geoms = vec![p0(), p1()];
        let gc = Geometry::GeometryCollection(
            geo_geoms
                .clone()
                .into_iter()
                .map(Geometry::Polygon)
                .collect(),
        );
        let typ = PolygonType::new(Dimension::XY, Default::default());
        let geo_arr = gc.to_polygon_array(typ.clone()).unwrap();

        let geo_arr2 = PolygonBuilder::from_polygons(&geo_geoms, typ).finish();

        // These are constructed with two different code paths
        assert_eq!(geo_arr, geo_arr2);
        Ok(())
    }
}