geozero

To work with PostGIS geometries in rust-postgres, enable the with-postgis-postgres feature. You can use wkb::Decode to read geometries from rows and wkb::Encode to insert them.

Note: This requires the with-postgis-postgres feature.

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<geo_types::Geometry<f64>> = row.get(0);
if let Some(geo_types::Geometry::Polygon(poly)) = value.geometry {
    assert_eq!(
        *poly.exterior(),
        vec![(0.0, 0.0), (2.0, 0.0), (2.0, 2.0), (0.0, 2.0), (0.0, 0.0)].into()
    );
}

// Insert geometry
let geom: geo_types::Geometry<f64> = geo::Point::new(1.0, 3.0).into();
let _ = client.execute(
    "INSERT INTO point2d (datetimefield,geom) VALUES(now(),ST_SetSRID($1,4326))",
    &[&wkb::Encode(geom)],
);

To work with PostGIS geometries in SQLx, enable the with-postgis-sqlx feature. You can use wkb::Decode for selecting and wkb::Encode for binding parameters in queries.

Note: This requires the with-postgis-sqlx feature.

let pool = PgPoolOptions::new()
    .max_connections(5)
    .connect(&env::var("DATABASE_URL").unwrap())
    .await?;

let row: (wkb::Decode<geo_types::Geometry<f64>>,) =
    sqlx::query_as("SELECT 'SRID=4326;POLYGON ((0 0, 2 0, 2 2, 0 2, 0 0))'::geometry")
        .fetch_one(&pool)
        .await?;
let value = row.0;
if let Some(geo_types::Geometry::Polygon(poly)) = value.geometry {
    assert_eq!(
        *poly.exterior(),
        vec![(0.0, 0.0), (2.0, 0.0), (2.0, 2.0), (0.0, 2.0), (0.0, 0.0)].into()
    );
}

// Insert geometry
let geom: geo_types::Geometry<f64> = geo::Point::new(10.0, 20.0).into();
let _ = sqlx::query(
    "INSERT INTO point2d (datetimefield,geom) VALUES(now(),ST_SetSRID($1,4326))",
)
.bind(wkb::Encode(geom))
.execute(&pool)
.await?;

GeoZero uses a visitor-style pattern for processing geospatial data. Instead of loading entire datasets into memory, you provide a Processor (implementing FeatureProcessor, GeomProcessor, or PropertyProcessor) that the library calls as it iterates through the data.

There are three main levels of abstraction:

1. GeozeroDatasource: Represents a collection of features (e.g., a file or a database table). You call .process(processor) to iterate over all features.
2. FeatureAccess: Represents a single feature. It combines geometry and properties. You can use .process(processor, idx) to process a specific feature's geometry and attributes.
3. FeatureProperties: Provides methods to access the attributes of a feature.

For high-performance, zero-copy access, implement the process_properties method in your PropertyProcessor. For convenience, the API provides helper methods like .property(name) and .properties() which use internal readers.

The geozero-cli tool allows you to convert geospatial data between various formats such as CSV, GeoJSON, FlatGeobuf (FGB), Parquet/GeoParquet, SVG, WKT, and more. The tool determines the input format based on the file extension of the input path and the output format based on the extension of the dest path.

Supported Input Formats

• CSV: Requires specifying the geometry column via --csv-geometry-column.
• GeoJSON / JSON: Standard GeoJSON files.
• GeoJSONL / JSONL: Line-delimited GeoJSON.
• GeoParquet / Parquet: Uses GeoParquet metadata for spatial filtering.
• FlatGeobuf (FGB): Supports local files and remote URLs (via HTTP/HTTPS).
• WKT: Well-Known Text files.

Supported Output Formats

• CSV
• GeoJSON / JSON
• FlatGeobuf (FGB)
• SVG: Generates an SVG visualization. If no extent is provided, the tool first computes the bounds of the input data.
• WKT

The MvtWriter is a generator used to encode geometries and properties into MVT features and layers. It implements geozero processor traits, allowing you to stream data from a datasource (like GeoJSON) directly into an MVT layer.

To use MvtWriter, you can either:

1. Scale coordinates: Use MvtWriter::new(extent, left, bottom, right, top) to automatically transform map-space coordinates into integer tile-space coordinates based on the provided bounding box and extent.
2. Use unscaled coordinates: Use MvtWriter::new_unscaled(extent) if your input data is already in the desired integer tile coordinate space.

After processing your datasource, call .layer(name) to retrieve the finished MvtLayer. This layer can then be added to an MvtTile for final encoding.

use geozero::{GeozeroDatasource, geojson::GeoJsonString, mvt::MvtWriter};

let mut geojson = GeoJsonString(
    serde_json::json!({
        "type": "FeatureCollection",
        "features": [
            {
                "type": "Feature",
                "properties": {
                    "population": 100
                },
                "geometry": {
                    "type": "Point",
                    "coordinates": [1.0, 2.0]
                }
            }
        ]
    })
    .to_string(),
);

// Create a writer with a 4096 extent (unscaled)
let mut mvt_writer = MvtWriter::new_unscaled(4096).unwrap();

// Process the datasource
geojson.process(&mut mvt_writer).unwrap();

// Obtain the finished MVT layer
let mvt_layer = mvt_writer.layer("sample");