Zero-Copy reading and writing of geospatial data.
GeoZero defines an API for reading geospatial data formats without an intermediate representation. It defines traits which can be implemented to read and convert to an arbitrary format or render geometries directly.
Supported geometry types: * OGC Simple Features * Circular arcs as defined by SQL-MM Part 3 * TIN
Supported dimensions: X, Y, Z, M, T
Convert a GeoJSON polygon to geo-types and calculate centroid:
rust,ignore
let geojson = GeoJson(r#"{"type": "Polygon", "coordinates": [[[0, 0], [10, 0], [10, 6], [0, 6], [0, 0]]]}"#);
if let Ok(Geometry::Polygon(poly)) = geojson.to_geo() {
assert_eq!(poly.centroid().unwrap(), Point::new(5.0, 3.0));
}
Full source code: geo_types.rs
Convert GeoJSON to a GEOS prepared geometry:
rust,ignore
let geojson = GeoJson(r#"{"type": "Polygon", "coordinates": [[[0, 0], [10, 0], [10, 6], [0, 6], [0, 0]]]}"#);
let geom = geojson.to_geos().expect("GEOS conversion failed");
let prepared_geom = geom.to_prepared_geom().expect("to_prepared_geom failed");
let geom2 = geos::Geometry::new_from_wkt("POINT (2.5 2.5)").expect("Invalid geometry");
assert_eq!(prepared_geom.contains(&geom2), Ok(true));
Full source code: geos.rs
Read FlatGeobuf subset as GeoJSON:
rust,ignore
let mut file = BufReader::new(File::open("countries.fgb")?);
let mut fgb = FgbReader::open(&mut file)?.select_bbox(8.8, 47.2, 9.5, 55.3)?;
println!("{}", fgb.to_json()?);
Full source code: geojson.rs
Read FlatGeobuf data as geo-types geometries and calculate label position with polylabel-rs:
rust,ignore
let mut file = BufReader::new(File::open("countries.fgb")?);
let mut fgb = FgbReader::open(&mut file)?.select_all()?;
while let Some(feature) = fgb.next()? {
let name: String = feature.property("name").unwrap();
if let Ok(Geometry::MultiPolygon(mpoly)) = feature.to_geo() {
if let Some(poly) = &mpoly.0.iter().next() {
let label_pos = polylabel(&poly, &0.10).unwrap();
println!("{name}: {label_pos:?}");
}
}
}
Full source code: polylabel.rs
Select and insert geo-types geometries with rust-postgres: ```rust,ignore let mut client = Client::connect(&std::env::var("DATABASE_URL").unwrap(), NoTls)?;
let row = client.query_one( "SELECT 'SRID=4326;POLYGON ((0 0, 2 0, 2 2, 0 2, 0 0))'::geometry", &[], )?;
let value: wkb::Decode
// Insert geometry
let geom: geotypes::Geometry
Select and insert geo-types geometries with SQLx: ```rust,ignore let pool = PgPoolOptions::new() .maxconnections(5) .connect(&env::var("DATABASEURL").unwrap()) .await?;
let row: (wkb::Decode
// Insert geometry
let geom: geotypes::Geometry
Using compile-time verification requires type overrides: ```rust,ignore let _ = sqlx::query!( "INSERT INTO point2d (datetimefield, geom) VALUES(now(), $1::geometry)", wkb::Encode(geom) as _ ) .execute(&pool) .await?;
struct PointRec {
pub geom: wkb::Decode
Full source code: postgis.rs
Count vertices of an input geometry: ```rust,ignore struct VertexCounter(u64);
impl GeomProcessor for VertexCounter { fn xy(&mut self, _x: f64, _y: f64, _idx: usize) -> Result<()> { self.0 += 1; Ok(()) } }
let mut vertexcounter = VertexCounter(0); geometry.process(&mut vertexcounter, GeometryType::MultiPolygon)?; ``` Full source code: geozero-api.rs
Find maximal height in 3D polygons: ```rust,ignore struct MaxHeightFinder(f64);
impl GeomProcessor for MaxHeightFinder {
fn coordinate(&mut self, _x: f64, _y: f64, z: Option
let mut maxfinder = MaxHeightFinder(0.0); while let Some(feature) = fgb.next()? { let geometry = feature.geometry().unwrap(); geometry.process(&mut maxfinder, GeometryType::MultiPolygon)?; } ``` Full source code: geozero-api.rs
Render polygons: ```rust,ignore struct PathDrawer<'a> { canvas: &'a mut CanvasRenderingContext2D, path: Path2D, }
impl<'a> GeomProcessor for PathDrawer<'a> { fn xy(&mut self, x: f64, y: f64, idx: usize) -> Result<()> { if idx == 0 { self.path.moveto(vec2f(x, y)); } else { self.path.lineto(vec2f(x, y)); } Ok(()) } fn linestringend(&mut self, _tagged: bool, _idx: usize) -> Result<()> { self.path.closepath(); self.canvas.fill_path( mem::replace(&mut self.path, Path2D::new()), FillRule::Winding, ); Ok(()) } } ``` Full source code: flatgeobuf-gpu
Read a FlatGeobuf dataset with async HTTP client applying a bbox filter and convert to GeoJSON: ```rust,ignore let url = "https://flatgeobuf.org/test/data/countries.fgb"; let mut fgb = HttpFgbReader::open(url) .await? .select_bbox(8.8, 47.2, 9.5, 55.3) .await?;
let mut fout = BufWriter::new(File::create("countries.json")?); let mut json = GeoJsonWriter::new(&mut fout); fgb.process_features(&mut json).await?; ``` Full source code: geojson.rs
Create a KD-tree index with kdbush: ```rust,ignore struct PointIndex { pos: usize, index: KDBush, }
impl geozero::GeomProcessor for PointIndex { fn xy(&mut self, x: f64, y: f64, idx: usize) -> Result<()> { self.index.addpoint(self.pos, x, y); self.pos += 1; Ok(()) } }
let mut points = PointIndex { pos: 0, index: KDBush::new(1249, DEFAULTNODESIZE), }; readgeojsongeom(&mut f, &mut points)?; points.index.build_index(); ``` Full source code: kdbush.rs
