wkt adapted for 3d/m change in geo

nyurik · nyurik · commit e21865f903ab · 2022-03-22T07:41:07.000-04:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -10,7 +10,7 @@ keywords = ["geo", "geospatial", "wkt"]
 edition = "2021"
 
 [dependencies]
-geo-types = { version = "0.7.3", optional = true }
+geo-types = { git = "https://github.com/nyurik/geo.git", branch = "dim-no-wkt", optional = true }
 num-traits = "0.2"
 serde = { version = "1.0", default-features = false, optional = true }
 thiserror = "1.0.23"
diff --git a/src/conversion.rs b/src/conversion.rs
@@ -148,7 +148,7 @@ where
             .map(geo_types::Coordinate::from)
             .collect();
 
-        geo_types::LineString(coords)
+        geo_types::LineString::new(coords)
     }
 }
 
@@ -173,7 +173,7 @@ where
             .map(geo_types::LineString::from)
             .collect();
 
-        geo_types::MultiLineString(geo_line_strings)
+        geo_types::MultiLineString::new(geo_line_strings)
     }
 }
 
@@ -195,7 +195,7 @@ where
         let mut iter = polygon.0.into_iter().map(geo_types::LineString::from);
         match iter.next() {
             Some(interior) => geo_types::Polygon::new(interior, iter.collect()),
-            None => geo_types::Polygon::new(geo_types::LineString(vec![]), vec![]),
+            None => geo_types::Polygon::new(geo_types::LineString::new(vec![]), vec![]),
         }
     }
 }
@@ -224,7 +224,7 @@ where
             .map(geo_types::Point::try_from)
             .collect::<Result<Vec<_>, _>>()?;
 
-        Ok(geo_types::MultiPoint(points))
+        Ok(geo_types::MultiPoint::new(points))
     }
 }
 
@@ -249,7 +249,7 @@ where
             .map(geo_types::Polygon::from)
             .collect();
 
-        geo_types::MultiPolygon(geo_polygons)
+        geo_types::MultiPolygon::new(geo_polygons)
     }
 }
 
@@ -278,7 +278,7 @@ where
             .map(Geometry::try_into)
             .collect::<Result<_, _>>()?;
 
-        Ok(geo_types::GeometryCollection(geo_geometries))
+        Ok(geo_types::GeometryCollection::new_from(geo_geometries))
     }
 }
 
@@ -295,7 +295,7 @@ where
                 if g.0.is_some() {
                     geo_types::Point::try_from(g)?.into()
                 } else {
-                    geo_types::MultiPoint(vec![]).into()
+                    geo_types::MultiPoint::new(vec![]).into()
                 }
             }
             Geometry::LineString(g) => geo_types::Geometry::LineString(g.into()),
@@ -358,7 +358,7 @@ mod tests {
     #[test]
     fn convert_empty_linestring() {
         let w_linestring = LineString(vec![]).as_item();
-        let g_linestring: geo_types::LineString<f64> = geo_types::LineString(vec![]);
+        let g_linestring: geo_types::LineString<f64> = geo_types::LineString::new(vec![]);
         assert_eq!(
             geo_types::Geometry::LineString(g_linestring),
             w_linestring.try_into().unwrap()
@@ -393,7 +393,7 @@ mod tests {
     fn convert_empty_polygon() {
         let w_polygon = Polygon(vec![]).as_item();
         let g_polygon: geo_types::Polygon<f64> =
-            geo_types::Polygon::new(geo_types::LineString(vec![]), vec![]);
+            geo_types::Polygon::new(geo_types::LineString::new(vec![]), vec![]);
         assert_eq!(
             geo_types::Geometry::Polygon(g_polygon),
             w_polygon.try_into().unwrap()
@@ -470,7 +470,8 @@ mod tests {
     #[test]
     fn convert_empty_multilinestring() {
         let w_multilinestring = MultiLineString(vec![]).as_item();
-        let g_multilinestring: geo_types::MultiLineString<f64> = geo_types::MultiLineString(vec![]);
+        let g_multilinestring: geo_types::MultiLineString<f64> =
+            geo_types::MultiLineString::new(vec![]);
         assert_eq!(
             geo_types::Geometry::MultiLineString(g_multilinestring),
             w_multilinestring.try_into().unwrap()
@@ -510,10 +511,11 @@ mod tests {
             ]),
         ])
         .as_item();
-        let g_multilinestring: geo_types::MultiLineString<f64> = geo_types::MultiLineString(vec![
-            vec![(10., 20.), (30., 40.)].into(),
-            vec![(50., 60.), (70., 80.)].into(),
-        ]);
+        let g_multilinestring: geo_types::MultiLineString<f64> =
+            geo_types::MultiLineString::new(vec![
+                vec![(10., 20.), (30., 40.)].into(),
+                vec![(50., 60.), (70., 80.)].into(),
+            ]);
         assert_eq!(
             geo_types::Geometry::MultiLineString(g_multilinestring),
             w_multilinestring.try_into().unwrap()
@@ -523,7 +525,7 @@ mod tests {
     #[test]
     fn convert_empty_multipoint() {
         let w_multipoint = MultiPoint(vec![]).as_item();
-        let g_multipoint: geo_types::MultiPoint<f64> = geo_types::MultiPoint(vec![]);
+        let g_multipoint: geo_types::MultiPoint<f64> = geo_types::MultiPoint::new(vec![]);
         assert_eq!(
             geo_types::Geometry::MultiPoint(g_multipoint),
             w_multipoint.try_into().unwrap()
@@ -557,7 +559,7 @@ mod tests {
     #[test]
     fn convert_empty_multipolygon() {
         let w_multipolygon = MultiPolygon(vec![]).as_item();
-        let g_multipolygon: geo_types::MultiPolygon<f64> = geo_types::MultiPolygon(vec![]);
+        let g_multipolygon: geo_types::MultiPolygon<f64> = geo_types::MultiPolygon::new(vec![]);
         assert_eq!(
             geo_types::Geometry::MultiPolygon(g_multipolygon),
             w_multipolygon.try_into().unwrap()
@@ -650,7 +652,7 @@ mod tests {
         ])
         .as_item();
 
-        let g_multipolygon: geo_types::MultiPolygon<f64> = geo_types::MultiPolygon(vec![
+        let g_multipolygon: geo_types::MultiPolygon<f64> = geo_types::MultiPolygon::new(vec![
             geo_types::Polygon::new(
                 vec![(0., 0.), (20., 40.), (40., 0.), (0., 0.)].into(),
                 vec![vec![(5., 5.), (20., 30.), (30., 5.), (5., 5.)].into()],
@@ -670,7 +672,7 @@ mod tests {
     fn convert_empty_geometrycollection() {
         let w_geometrycollection = GeometryCollection(vec![]).as_item();
         let g_geometrycollection: geo_types::GeometryCollection<f64> =
-            geo_types::GeometryCollection(vec![]);
+            geo_types::GeometryCollection::default();
         assert_eq!(
             geo_types::Geometry::GeometryCollection(g_geometrycollection),
             w_geometrycollection.try_into().unwrap()
@@ -851,12 +853,13 @@ mod tests {
             vec![(0., 0.), (20., 40.), (40., 0.), (0., 0.)].into(),
             vec![],
         );
-        let g_multilinestring: geo_types::MultiLineString<f64> = geo_types::MultiLineString(vec![
-            vec![(10., 20.), (30., 40.)].into(),
-            vec![(50., 60.), (70., 80.)].into(),
-        ]);
+        let g_multilinestring: geo_types::MultiLineString<f64> =
+            geo_types::MultiLineString::new(vec![
+                vec![(10., 20.), (30., 40.)].into(),
+                vec![(50., 60.), (70., 80.)].into(),
+            ]);
         let g_multipoint: geo_types::MultiPoint<f64> = vec![(10., 20.), (30., 40.)].into();
-        let g_multipolygon: geo_types::MultiPolygon<f64> = geo_types::MultiPolygon(vec![
+        let g_multipolygon: geo_types::MultiPolygon<f64> = geo_types::MultiPolygon::new(vec![
             geo_types::Polygon::new(
                 vec![(0., 0.), (20., 40.), (40., 0.), (0., 0.)].into(),
                 vec![],
@@ -868,7 +871,7 @@ mod tests {
         ]);
 
         let g_geometrycollection: geo_types::GeometryCollection<f64> =
-            geo_types::GeometryCollection(vec![
+            geo_types::GeometryCollection::new_from(vec![
                 geo_types::Geometry::Point(g_point),
                 geo_types::Geometry::MultiPoint(g_multipoint),
                 geo_types::Geometry::LineString(g_linestring),
diff --git a/src/deserialize.rs b/src/deserialize.rs
@@ -127,7 +127,7 @@ where
 /// # extern crate wkt;
 /// # extern crate geo_types;
 /// # extern crate serde_json;
-/// use geo_types::Point;
+/// use geo_types::{Point, PointTZM};
 ///
 /// #[derive(serde::Deserialize)]
 /// struct MyType {
@@ -137,7 +137,7 @@ where
 ///
 /// let json = r#"{ "geometry": "POINT (3.14 42)" }"#;
 /// let my_type: MyType = serde_json::from_str(json).unwrap();
-/// assert!(matches!(my_type.geometry, Some(Point(_))));
+/// assert!(matches!(my_type.geometry, Some(PointTZM(_))));
 ///
 /// let json = r#"{ "geometry": "POINT EMPTY" }"#;
 /// let my_type: MyType = serde_json::from_str(json).unwrap();
@@ -156,7 +156,7 @@ where
         geo_types::Geometry::try_from(wkt)
             .map_err(D::Error::custom)
             .and_then(|geom| {
-                use geo_types::Geometry::*;
+                use geo_types::GeometryTZM::*;
                 match geom {
                     Point(p) => Ok(Some(p)),
                     MultiPoint(mp) if mp.0.is_empty() => Ok(None),
diff --git a/src/towkt.rs b/src/towkt.rs
@@ -66,8 +66,7 @@ fn g_linestring_to_w_linestring<T>(g_linestring: &geo_types::LineString<T>) -> L
 where
     T: CoordFloat,
 {
-    let &geo_types::LineString(ref g_points) = g_linestring;
-    g_points_to_w_linestring(g_points)
+    g_points_to_w_linestring(&g_linestring.0)
 }
 
 fn g_points_to_w_linestring<T>(g_coords: &[geo_types::Coordinate<T>]) -> LineString<T>
@@ -84,8 +83,7 @@ where
 {
     let mut w_lines = vec![];
     for g_line in g_lines {
-        let &geo_types::LineString(ref g_points) = g_line;
-        w_lines.push(g_points_to_w_linestring(g_points));
+        w_lines.push(g_points_to_w_linestring(&g_line.0));
     }
     w_lines
 }
@@ -115,7 +113,7 @@ where
     let mut poly_lines = vec![];
 
     // Outer
-    let &geo_types::LineString(ref outer_points) = outer_line;
+    let outer_points = &outer_line.0;
     if !outer_points.is_empty() {
         poly_lines.push(g_points_to_w_linestring(outer_points));
     }
@@ -131,17 +129,15 @@ fn g_mpoint_to_w_mpoint<T>(g_mpoint: &geo_types::MultiPoint<T>) -> MultiPoint<T>
 where
     T: CoordFloat,
 {
-    let &geo_types::MultiPoint(ref g_points) = g_mpoint;
-    let w_points = g_points_to_w_points(g_points);
+    let w_points = g_points_to_w_points(&g_mpoint.0);
     MultiPoint(w_points)
 }
 
 fn g_mline_to_w_mline<T>(g_mline: &geo_types::MultiLineString<T>) -> MultiLineString<T>
 where
     T: CoordFloat,
 {
-    let &geo_types::MultiLineString(ref g_lines) = g_mline;
-    let w_lines = g_lines_to_w_lines(g_lines);
+    let w_lines = g_lines_to_w_lines(&g_mline.0);
     MultiLineString(w_lines)
 }
 
@@ -160,18 +156,16 @@ fn g_mpolygon_to_w_mpolygon<T>(g_mpolygon: &geo_types::MultiPolygon<T>) -> Multi
 where
     T: CoordFloat,
 {
-    let &geo_types::MultiPolygon(ref g_polygons) = g_mpolygon;
-    let w_polygons = g_polygons_to_w_polygons(g_polygons);
+    let w_polygons = g_polygons_to_w_polygons(&g_mpolygon.0);
     MultiPolygon(w_polygons)
 }
 
 fn g_geocol_to_w_geocol<T>(g_geocol: &geo_types::GeometryCollection<T>) -> GeometryCollection<T>
 where
     T: CoordFloat,
 {
-    let &geo_types::GeometryCollection(ref g_geoms) = g_geocol;
     let mut w_geoms = vec![];
-    for g_geom in g_geoms {
+    for g_geom in g_geocol.iter() {
         let w_geom = g_geom_to_w_geom(g_geom);
         w_geoms.push(w_geom);
     }

Original file line number	Diff line number	Diff line change
`@@ -66,8 +66,7 @@ fn g_linestring_to_w_linestring<T>(g_linestring: &geo_types::LineString<T>) -> L`
`66`	`66`	`where`
`67`	`67`	`T: CoordFloat,`
`68`	`68`	`{`
`69`		`- let &geo_types::LineString(ref g_points) = g_linestring;`
`70`		`- g_points_to_w_linestring(g_points)`
	`69`	`+ g_points_to_w_linestring(&g_linestring.0)`
`71`	`70`	`}`
`72`	`71`
`73`	`72`	`fn g_points_to_w_linestring<T>(g_coords: &[geo_types::Coordinate<T>]) -> LineString<T>`
`@@ -84,8 +83,7 @@ where`
`84`	`83`	`{`
`85`	`84`	`let mut w_lines = vec![];`
`86`	`85`	`for g_line in g_lines {`
`87`		`- let &geo_types::LineString(ref g_points) = g_line;`
`88`		`- w_lines.push(g_points_to_w_linestring(g_points));`
	`86`	`+ w_lines.push(g_points_to_w_linestring(&g_line.0));`
`89`	`87`	`}`
`90`	`88`	`w_lines`
`91`	`89`	`}`
`@@ -115,7 +113,7 @@ where`
`115`	`113`	`let mut poly_lines = vec![];`
`116`	`114`
`117`	`115`	`// Outer`
`118`		`- let &geo_types::LineString(ref outer_points) = outer_line;`
	`116`	`+ let outer_points = &outer_line.0;`
`119`	`117`	`if !outer_points.is_empty() {`
`120`	`118`	`poly_lines.push(g_points_to_w_linestring(outer_points));`
`121`	`119`	`}`
`@@ -131,17 +129,15 @@ fn g_mpoint_to_w_mpoint<T>(g_mpoint: &geo_types::MultiPoint<T>) -> MultiPoint<T>`
`131`	`129`	`where`
`132`	`130`	`T: CoordFloat,`
`133`	`131`	`{`
`134`		`- let &geo_types::MultiPoint(ref g_points) = g_mpoint;`
`135`		`- let w_points = g_points_to_w_points(g_points);`
	`132`	`+ let w_points = g_points_to_w_points(&g_mpoint.0);`
`136`	`133`	`MultiPoint(w_points)`
`137`	`134`	`}`
`138`	`135`
`139`	`136`	`fn g_mline_to_w_mline<T>(g_mline: &geo_types::MultiLineString<T>) -> MultiLineString<T>`
`140`	`137`	`where`
`141`	`138`	`T: CoordFloat,`
`142`	`139`	`{`
`143`		`- let &geo_types::MultiLineString(ref g_lines) = g_mline;`
`144`		`- let w_lines = g_lines_to_w_lines(g_lines);`
	`140`	`+ let w_lines = g_lines_to_w_lines(&g_mline.0);`
`145`	`141`	`MultiLineString(w_lines)`
`146`	`142`	`}`
`147`	`143`
`@@ -160,18 +156,16 @@ fn g_mpolygon_to_w_mpolygon<T>(g_mpolygon: &geo_types::MultiPolygon<T>) -> Multi`
`160`	`156`	`where`
`161`	`157`	`T: CoordFloat,`
`162`	`158`	`{`
`163`		`- let &geo_types::MultiPolygon(ref g_polygons) = g_mpolygon;`
`164`		`- let w_polygons = g_polygons_to_w_polygons(g_polygons);`
	`159`	`+ let w_polygons = g_polygons_to_w_polygons(&g_mpolygon.0);`
`165`	`160`	`MultiPolygon(w_polygons)`
`166`	`161`	`}`
`167`	`162`
`168`	`163`	`fn g_geocol_to_w_geocol<T>(g_geocol: &geo_types::GeometryCollection<T>) -> GeometryCollection<T>`
`169`	`164`	`where`
`170`	`165`	`T: CoordFloat,`
`171`	`166`	`{`
`172`		`- let &geo_types::GeometryCollection(ref g_geoms) = g_geocol;`
`173`	`167`	`let mut w_geoms = vec![];`
`174`		`- for g_geom in g_geoms {`
	`168`	`+ for g_geom in g_geocol.iter() {`
`175`	`169`	`let w_geom = g_geom_to_w_geom(g_geom);`
`176`	`170`	`w_geoms.push(w_geom);`
`177`	`171`	`}`