Crate wbvector 

wbvector

Pure-Rust library for reading and writing common vector GIS data formats.

Supported formats

Format	Read	Write	Extension
FlatGeobuf	✓	✓	.fgb
GeoJSON	✓	✓	.geojson
GeoPackage	✓	✓	.gpkg
GeoParquet*	✓	✓	.parquet
GML	✓	✓	.gml
GPX	✓	✓	.gpx
KML	✓	✓	.kml
KMZ*	✓	✓	.kmz
MapInfo MIF	✓	✓	.mif
OSM PBF**	✓	-	.osm.pbf
Shapefile	✓	✓	.shp

* GeoParquet and KMZ supports are optional and require geoparquet / kmz features. ** OSM PBF support is optional and requires the osmpbf crate feature.

Common API

All format drivers convert to/from the same in-memory types:

• feature::Layer — named collection of features + schema
• feature::Feature — optional geometry + attribute values
• feature::FieldValue — typed attribute value
• geometry::Geometry — OGC Simple Features geometry

You can also use crate-level sniffed I/O:

let layer = wbvector::read("roads.gpkg")?; // auto-detect format
wbvector::write(&layer, "roads.fgb", wbvector::VectorFormat::FlatGeobuf)?;

Quick start

use wbvector::{flatgeobuf, geojson, geopackage, gml, gpx, kml, mapinfo, shapefile};
#[cfg(feature = "geoparquet")]
use wbvector::geoparquet;
#[cfg(feature = "kmz")]
use wbvector::kmz;
#[cfg(feature = "osmpbf")]
use wbvector::osmpbf;
use wbvector::feature::{Layer, FieldDef, FieldType};
use wbvector::geometry::{Geometry, GeometryType};

// Build a layer in memory
let mut layer = Layer::new("cities")
    .with_geom_type(GeometryType::Point)
    .with_crs_epsg(4326);

layer.add_field(FieldDef::new("name",       FieldType::Text));
layer.add_field(FieldDef::new("population", FieldType::Integer));

layer.add_feature(
    Some(Geometry::point(-0.1278, 51.5074)),
    &[("name", "London".into()), ("population", 9_000_000i64.into())],
)?;

// Write to every format
flatgeobuf::write(&layer,  "cities.fgb")?;
geojson::write(&layer,     "cities.geojson")?;
geopackage::write(&layer,  "cities.gpkg")?;
gml::write(&layer,         "cities.gml")?;
gpx::write(&layer,         "cities.gpx")?;
kml::write(&layer,         "cities.kml")?;
#[cfg(feature = "kmz")]
kmz::write(&layer,         "cities.kmz")?;
mapinfo::write(&layer,     "cities.mif")?;
shapefile::write(&layer,   "cities")?;       // → cities.shp/.shx/.dbf/.prj

// Read back from any format — same Layer type
let from_fgb  = flatgeobuf::read("cities.fgb")?;
let from_json = geojson::read("cities.geojson")?;
let from_gpkg = geopackage::read("cities.gpkg")?;
#[cfg(feature = "geoparquet")]
geoparquet::write(&layer, "cities.parquet")?;
let options = geoparquet::GeoParquetWriteOptions::for_large_files();
geoparquet::write_with_options(&layer, "cities_tuned.parquet", &options)?;
let fast_options = geoparquet::GeoParquetWriteOptions::for_interactive_files();
geoparquet::write_with_options(&layer, "cities_fast.parquet", &fast_options)?;
let from_parquet = geoparquet::read("cities.parquet")?;
let from_gml  = gml::read("cities.gml")?;
let from_gpx  = gpx::read("cities.gpx")?;
let from_kml  = kml::read("cities.kml")?;
#[cfg(feature = "kmz")]
let from_kmz  = kmz::read("cities.kmz")?;
let from_mif  = mapinfo::read("cities.mif")?;
let from_shp  = shapefile::read("cities")?;
#[cfg(feature = "osmpbf")]
let from_osm  = osmpbf::read("extract.osm.pbf")?;

Format conversion

Because all drivers share the same feature::Layer type, conversion between any pair of formats is two lines:

let layer = shapefile::read("roads")?;
geopackage::write(&layer, "roads.gpkg")?;

Dependencies

Core external dependencies include thiserror, flatbuffers, and wbprojection. All format codecs — including the SQLite engine powering GeoPackage I/O — are implemented from scratch in pure Rust.

Re-exports

pub use error::GeoError;

pub use error::Result;

pub use feature::Crs;

pub use feature::Feature;

pub use feature::FieldDef;

pub use feature::FieldType;

pub use feature::FieldValue;

pub use feature::Layer;

pub use feature::Schema;

pub use geometry::BBox;

pub use geometry::Coord;

pub use geometry::Geometry;

pub use geometry::GeometryType;

pub use geometry::Ring;

Modules

error

Unified error type for all wbvector format drivers.

feature

The common feature model used by every format driver.

flatgeobuf

FlatGeobuf (.fgb) reader and writer.

geojson

GeoJSON (RFC 7946) reader and writer.

geometry

Canonical geometry types shared by all format drivers.

geopackage

GeoPackage (.gpkg) reader and writer.

gml

Geography Markup Language (GML) reader and writer.

gpx

GPX (GPS Exchange Format) reader and writer.

kml

KML (Keyhole Markup Language) reader and writer.

mapinfo

MapInfo Interchange Format (MIF/MID) reader and writer.

memory_store

In-process vector memory store for passing vectors between tools without disk I/O.

reproject

Layer reprojection utilities backed by wbprojection.

shapefile

Shapefile (.shp / .shx / .dbf / .prj) reader and writer.

Enums

VectorFormat

Supported vector formats for crate-level sniffed I/O.

Functions

read

Generic vector read with automatic format sniffing.

write

Generic vector write when the target format is known.