Merge #180

180: Add PostGIS and GeoJSON integration/conversions r=frewsxcv a=eeeeeta

This PR adds conversions from PostGIS types to `geo` primitives, and conversions from `geo` primitives to GeoJSON and PostGIS types.

This integration is gated behind two new features, `postgis-integration` and `geojson-integration`.

Author: bors[bot]

Cargo.toml

@@ -17,6 +17,14 @@ num-traits = "0.1"
 serde = "1.0"
 serde_derive = "1.0"
 spade = "1.3.0"
+postgis = { version = "0.5", optional = true }
+
+[features]
+default = []
+postgis-integration = ["postgis"]
 
 [dev-dependencies]
 approx = "0.1.1"
+
+[package.metadata.docs.rs]
+all-features = true

src/algorithm/from_postgis.rs

@@ -0,0 +1,97 @@
+use types::{MultiPoint, Point, LineString, MultiLineString, MultiPolygon, Polygon, Geometry, GeometryCollection};
+use postgis;
+use postgis::ewkb::{GeometryT, GeometryCollectionT};
+
+/// Creates geometry from a PostGIS type.
+///
+/// Note that PostGIS databases can store data under any spatial
+/// reference system - not just WGS84. No attempt is made to convert
+/// data between reference systems.
+pub trait FromPostgis<T> {
+    fn from_postgis(T) -> Self;
+}
+
+impl<'a, T> FromPostgis<&'a T> for Point<f64> where T: postgis::Point {
+    fn from_postgis(pt: &'a T) -> Self {
+        Point::new(pt.x(), pt.y())
+    }
+}
+impl<'a, T> FromPostgis<&'a T> for LineString<f64> where T: postgis::LineString<'a> {
+    fn from_postgis(ls: &'a T) -> Self {
+        let ret = ls.points()
+            .map(|x| Point::from_postgis(x))
+            .collect();
+        LineString(ret)
+    }
+}
+impl<'a, T> FromPostgis<&'a T> for Option<Polygon<f64>> where T: postgis::Polygon<'a> {
+    /// This returns an `Option`, because it's possible for a PostGIS `Polygon`
+    /// to contain zero rings, which makes for an invalid `geo::Polygon`.
+    fn from_postgis(poly: &'a T) -> Self {
+        let mut rings = poly.rings()
+            .map(|x| LineString::from_postgis(x))
+            .collect::<Vec<_>>();
+        if rings.len() == 0 {
+            return None;
+        }
+        let exterior = rings.remove(0);
+        Some(Polygon {
+            exterior,
+            interiors: rings
+        })
+    }
+}
+impl<'a, T> FromPostgis<&'a T> for MultiPoint<f64> where T: postgis::MultiPoint<'a> {
+    fn from_postgis(mp: &'a T) -> Self {
+        let ret = mp.points()
+            .map(|x| Point::from_postgis(x))
+            .collect();
+        MultiPoint(ret)
+    }
+}
+impl<'a, T> FromPostgis<&'a T> for MultiLineString<f64> where T: postgis::MultiLineString<'a> {
+    fn from_postgis(mp: &'a T) -> Self {
+        let ret = mp.lines()
+            .map(|x| LineString::from_postgis(x))
+            .collect();
+        MultiLineString(ret)
+    }
+}
+impl<'a, T> FromPostgis<&'a T> for MultiPolygon<f64> where T: postgis::MultiPolygon<'a> {
+    /// This implementation discards PostGIS polygons that don't convert
+    /// (return `None` when `from_postgis()` is called on them).
+    fn from_postgis(mp: &'a T) -> Self {
+        let ret = mp.polygons()
+            .filter_map(|x| Option::from_postgis(x))
+            .collect();
+        MultiPolygon(ret)
+    }
+}
+impl<'a, T> FromPostgis<&'a GeometryCollectionT<T>> for GeometryCollection<f64> where T: postgis::Point + postgis::ewkb::EwkbRead {
+    /// This implementation discards geometries that don't convert
+    /// (return `None` when `from_postgis()` is called on them).
+    fn from_postgis(gc: &'a GeometryCollectionT<T>) -> Self {
+        let geoms = gc.geometries.iter()
+            .filter_map(|x| Option::from_postgis(x))
+            .collect();
+        GeometryCollection(geoms)
+    }
+}
+impl<'a, T> FromPostgis<&'a GeometryT<T>> for Option<Geometry<f64>> where T: postgis::Point + postgis::ewkb::EwkbRead {
+    /// This returns an `Option`, because the supplied geometry
+    /// could be an invalid `Polygon`.
+    fn from_postgis(geo: &'a GeometryT<T>) -> Self {
+        Some(match *geo {
+            GeometryT::Point(ref p) => Geometry::Point(Point::from_postgis(p)),
+            GeometryT::LineString(ref ls) => Geometry::LineString(LineString::from_postgis(ls)),
+            GeometryT::Polygon(ref p) => match Option::from_postgis(p) {
+                Some(p) => Geometry::Polygon(p),
+                None => return None
+            },
+            GeometryT::MultiPoint(ref p) => Geometry::MultiPoint(MultiPoint::from_postgis(p)),
+            GeometryT::MultiLineString(ref p) => Geometry::MultiLineString(MultiLineString::from_postgis(p)),
+            GeometryT::MultiPolygon(ref p) => Geometry::MultiPolygon(MultiPolygon::from_postgis(p)),
+            GeometryT::GeometryCollection(ref p) => Geometry::GeometryCollection(GeometryCollection::from_postgis(p))
+        })
+    }
+}

src/algorithm/mod.rs

@@ -34,3 +34,9 @@ pub mod translate;
 pub mod map_coords;
 /// Determine the closest point between two objects.
 pub mod closest_point;
+/// Produces geometry from PostGIS.
+#[cfg(feature = "postgis-integration")]
+pub mod from_postgis;
+/// Converts geometry into PostGIS types.
+#[cfg(feature = "postgis-integration")]
+pub mod to_postgis;

src/algorithm/to_postgis.rs

@@ -0,0 +1,82 @@
+use types::{MultiPoint, Line, Point, LineString, MultiLineString, MultiPolygon, Polygon, Geometry, GeometryCollection};
+use postgis::ewkb;
+
+/// Converts geometry to a PostGIS type.
+///
+/// Note that PostGIS databases can include a SRID (spatial reference
+/// system identifier) for geometry stored in them. You should specify
+/// the SRID of your geometry when converting, using `to_postgis_with_srid()`,
+/// or use `to_postgis_wgs84()` if your data is standard WGS84.
+pub trait ToPostgis<T> {
+    /// Converts this geometry to a PostGIS type, using the supplied SRID.
+    fn to_postgis_with_srid(&self, srid: Option<i32>) -> T;
+    /// Converts this WGS84 geometry to a PostGIS type.
+    fn to_postgis_wgs84(&self) -> T {
+        self.to_postgis_with_srid(Some(4326))
+    }
+}
+
+impl ToPostgis<ewkb::Point> for Point<f64> {
+    fn to_postgis_with_srid(&self, srid: Option<i32>) -> ewkb::Point {
+        ewkb::Point::new(self.x(), self.y(), srid)
+    }
+}
+impl ToPostgis<ewkb::LineString> for Line<f64> {
+    fn to_postgis_with_srid(&self, srid: Option<i32>) -> ewkb::LineString {
+        let points = vec![
+            self.start.to_postgis_with_srid(srid),
+            self.end.to_postgis_with_srid(srid)
+        ];
+        ewkb::LineString { points, srid }
+    }
+}
+impl ToPostgis<ewkb::Polygon> for Polygon<f64> {
+    fn to_postgis_with_srid(&self, srid: Option<i32>) -> ewkb::Polygon {
+        let rings = ::std::iter::once(&self.exterior)
+            .chain(self.interiors.iter())
+            .map(|x| x.to_postgis_with_srid(srid))
+            .collect();
+        ewkb::Polygon { rings, srid }
+    }
+}
+macro_rules! to_postgis_impl {
+    ($from:ident, $to:path, $name:ident, srid) => {
+        impl ToPostgis<$to> for $from<f64> {
+            fn to_postgis_with_srid(&self, srid: Option<i32>) -> $to {
+                let $name = self.0.iter()
+                    .map(|x| x.to_postgis_with_srid(srid))
+                    .collect();
+                $to { $name, srid }
+            }
+        }
+    };
+    ($from:ident, $to:path, $name:ident) => {
+        impl ToPostgis<$to> for $from<f64> {
+            fn to_postgis_with_srid(&self, srid: Option<i32>) -> $to {
+                let $name = self.0.iter()
+                    .map(|x| x.to_postgis_with_srid(srid))
+                    .collect();
+                $to { $name }
+            }
+        }
+    };
+}
+to_postgis_impl!(GeometryCollection, ewkb::GeometryCollection, geometries);
+to_postgis_impl!(MultiPolygon, ewkb::MultiPolygon, polygons, srid);
+to_postgis_impl!(MultiLineString, ewkb::MultiLineString, lines, srid);
+to_postgis_impl!(MultiPoint, ewkb::MultiPoint, points, srid);
+to_postgis_impl!(LineString, ewkb::LineString, points, srid);
+impl ToPostgis<ewkb::Geometry> for Geometry<f64> {
+    fn to_postgis_with_srid(&self, srid: Option<i32>) -> ewkb::Geometry {
+        match *self {
+            Geometry::Point(ref p) => ewkb::GeometryT::Point(p.to_postgis_with_srid(srid)),
+            Geometry::Line(ref p) => ewkb::GeometryT::LineString(p.to_postgis_with_srid(srid)),
+            Geometry::LineString(ref p) => ewkb::GeometryT::LineString(p.to_postgis_with_srid(srid)),
+            Geometry::Polygon(ref p) => ewkb::GeometryT::Polygon(p.to_postgis_with_srid(srid)),
+            Geometry::MultiPoint(ref p) => ewkb::GeometryT::MultiPoint(p.to_postgis_with_srid(srid)),
+            Geometry::MultiLineString(ref p) => ewkb::GeometryT::MultiLineString(p.to_postgis_with_srid(srid)),
+            Geometry::MultiPolygon(ref p) => ewkb::GeometryT::MultiPolygon(p.to_postgis_with_srid(srid)),
+            Geometry::GeometryCollection(ref p) => ewkb::GeometryT::GeometryCollection(p.to_postgis_with_srid(srid)),
+        }
+    }
+}

src/lib.rs

@@ -2,6 +2,8 @@ extern crate num_traits;
 #[macro_use]
 extern crate serde_derive;
 extern crate spade;
+#[cfg(feature = "postgis-integration")]
+extern crate postgis;
 
 pub use traits::ToGeo;
 pub use types::*;