Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

from wkt #830

Draft
wants to merge 1 commit into
base: main
Choose a base branch
from
+137 −127
Draft

from wkt #830

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
8 changes: 4 additions & 4 deletions Cargo.lock
View file
Open in desktop

Some generated files are not rendered by default. Learn more about how customized files appear on GitHub.

2 changes: 1 addition & 1 deletion Cargo.toml
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -95,7 +95,7 @@ sqlx = { version = "0.7", optional = true, default-features = false, features =
] }
thiserror = "1"
tokio = { version = "1", default-features = false, optional = true }
wkt = "0.11"
wkt = "0.11.1"


[dev-dependencies]
Expand Down
4 changes: 4 additions & 0 deletions src/error.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -86,6 +86,10 @@ pub enum GeoArrowError {
#[cfg(feature = "postgis")]
#[error(transparent)]
SqlxError(#[from] sqlx::Error),

/// Error from [wkt] crate
#[error("WKT error: {0}")]
WktError(String),
}

/// Crate-specific result type.
Expand Down
180 changes: 58 additions & 122 deletions src/io/wkb/api.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -22,19 +22,9 @@ pub trait FromWKB: Sized {
fn from_wkb<O: OffsetSizeTrait>(arr: &Self::Input<O>, coord_type: CoordType) -> Result<Self>;
}

impl FromWKB for PointArray<2> {
type Input<O: OffsetSizeTrait> = WKBArray<O>;

fn from_wkb<O: OffsetSizeTrait>(arr: &WKBArray<O>, coord_type: CoordType) -> Result<Self> {
let wkb_objects: Vec<Option<WKB<'_, O>>> = arr.iter().collect();
let builder = PointBuilder::from_wkb(&wkb_objects, Some(coord_type), arr.metadata())?;
Ok(builder.finish())
}
}

macro_rules! impl_from_wkb {
($array:ty, $builder:ty) => {
impl FromWKB for $array {
impl<const D: usize> FromWKB for $array {
type Input<O: OffsetSizeTrait> = WKBArray<O>;

fn from_wkb<O: OffsetSizeTrait>(
Expand All @@ -49,18 +39,19 @@ macro_rules! impl_from_wkb {
};
}

impl_from_wkb!(LineStringArray<2>, LineStringBuilder<2>);
impl_from_wkb!(PolygonArray<2>, PolygonBuilder<2>);
impl_from_wkb!(MultiPointArray<2>, MultiPointBuilder<2>);
impl_from_wkb!(MultiLineStringArray<2>, MultiLineStringBuilder<2>);
impl_from_wkb!(MultiPolygonArray<2>, MultiPolygonBuilder<2>);
impl_from_wkb!(PointArray<D>, PointBuilder<D>);
impl_from_wkb!(LineStringArray<D>, LineStringBuilder<D>);
impl_from_wkb!(PolygonArray<D>, PolygonBuilder<D>);
impl_from_wkb!(MultiPointArray<D>, MultiPointBuilder<D>);
impl_from_wkb!(MultiLineStringArray<D>, MultiLineStringBuilder<D>);
impl_from_wkb!(MultiPolygonArray<D>, MultiPolygonBuilder<D>);

impl FromWKB for MixedGeometryArray<2> {
impl<const D: usize> FromWKB for MixedGeometryArray<D> {
type Input<O: OffsetSizeTrait> = WKBArray<O>;

fn from_wkb<O: OffsetSizeTrait>(arr: &WKBArray<O>, coord_type: CoordType) -> Result<Self> {
let wkb_objects: Vec<Option<WKB<'_, O>>> = arr.iter().collect();
let builder = MixedGeometryBuilder::<2>::from_wkb(
let builder = MixedGeometryBuilder::<D>::from_wkb(
&wkb_objects,
Some(coord_type),
arr.metadata(),
Expand All @@ -70,12 +61,12 @@ impl FromWKB for MixedGeometryArray<2> {
}
}

impl FromWKB for GeometryCollectionArray<2> {
impl<const D: usize> FromWKB for GeometryCollectionArray<D> {
type Input<O: OffsetSizeTrait> = WKBArray<O>;

fn from_wkb<O: OffsetSizeTrait>(arr: &WKBArray<O>, coord_type: CoordType) -> Result<Self> {
let wkb_objects: Vec<Option<WKB<'_, O>>> = arr.iter().collect();
let builder = GeometryCollectionBuilder::<2>::from_wkb(
let builder = GeometryCollectionBuilder::<D>::from_wkb(
&wkb_objects,
Some(coord_type),
arr.metadata(),
Expand All @@ -100,18 +91,9 @@ impl FromWKB for Arc<dyn NativeArray> {
}
}

impl FromWKB for ChunkedPointArray<2> {
type Input<O: OffsetSizeTrait> = ChunkedWKBArray<O>;

fn from_wkb<O: OffsetSizeTrait>(arr: &Self::Input<O>, coord_type: CoordType) -> Result<Self> {
arr.try_map(|chunk| FromWKB::from_wkb(chunk, coord_type))?
.try_into()
}
}

macro_rules! impl_chunked {
($chunked_array:ty) => {
impl FromWKB for $chunked_array {
impl<const D: usize> FromWKB for $chunked_array {
type Input<O: OffsetSizeTrait> = ChunkedWKBArray<O>;

fn from_wkb<O: OffsetSizeTrait>(
Expand All @@ -125,13 +107,14 @@ macro_rules! impl_chunked {
};
}

impl_chunked!(ChunkedLineStringArray<2>);
impl_chunked!(ChunkedPolygonArray<2>);
impl_chunked!(ChunkedMultiPointArray<2>);
impl_chunked!(ChunkedMultiLineStringArray<2>);
impl_chunked!(ChunkedMultiPolygonArray<2>);
impl_chunked!(ChunkedMixedGeometryArray<2>);
impl_chunked!(ChunkedGeometryCollectionArray<2>);
impl_chunked!(ChunkedPointArray<D>);
impl_chunked!(ChunkedLineStringArray<D>);
impl_chunked!(ChunkedPolygonArray<D>);
impl_chunked!(ChunkedMultiPointArray<D>);
impl_chunked!(ChunkedMultiLineStringArray<D>);
impl_chunked!(ChunkedMultiPolygonArray<D>);
impl_chunked!(ChunkedMixedGeometryArray<D>);
impl_chunked!(ChunkedGeometryCollectionArray<D>);

impl FromWKB for Arc<dyn ChunkedNativeArray> {
type Input<O: OffsetSizeTrait> = ChunkedWKBArray<O>;
Expand All @@ -153,117 +136,70 @@ pub fn from_wkb<O: OffsetSizeTrait>(
target_geo_data_type: NativeType,
prefer_multi: bool,
) -> Result<Arc<dyn NativeArray>> {
use Dimension::*;
use NativeType::*;

let wkb_objects: Vec<Option<crate::scalar::WKB<'_, O>>> = arr.iter().collect();
match target_geo_data_type {
Point(coord_type, Dimension::XY) => {
let builder =
PointBuilder::<2>::from_wkb(&wkb_objects, Some(coord_type), arr.metadata())?;
Ok(Arc::new(builder.finish()))
}
LineString(coord_type, Dimension::XY) => {
let builder =
LineStringBuilder::<2>::from_wkb(&wkb_objects, Some(coord_type), arr.metadata())?;
Ok(Arc::new(builder.finish()))
}
Polygon(coord_type, Dimension::XY) => {
let builder =
PolygonBuilder::<2>::from_wkb(&wkb_objects, Some(coord_type), arr.metadata())?;
Ok(Arc::new(builder.finish()))
}
MultiPoint(coord_type, Dimension::XY) => {
let builder =
MultiPointBuilder::<2>::from_wkb(&wkb_objects, Some(coord_type), arr.metadata())?;
Ok(Arc::new(builder.finish()))
}
MultiLineString(coord_type, Dimension::XY) => {
let builder = MultiLineStringBuilder::<2>::from_wkb(
&wkb_objects,
Some(coord_type),
arr.metadata(),
)?;
Ok(Arc::new(builder.finish()))
}
MultiPolygon(coord_type, Dimension::XY) => {
let builder =
MultiPolygonBuilder::<2>::from_wkb(&wkb_objects, Some(coord_type), arr.metadata())?;
Ok(Arc::new(builder.finish()))
}
Mixed(coord_type, Dimension::XY) => {
let out: Arc<dyn NativeArray> = match target_geo_data_type {
Point(ct, XY) => Arc::new(PointArray::<2>::from_wkb(arr, ct)?),
LineString(ct, XY) => Arc::new(LineStringArray::<2>::from_wkb(arr, ct)?),
Polygon(ct, XY) => Arc::new(PolygonArray::<2>::from_wkb(arr, ct)?),
MultiPoint(ct, XY) => Arc::new(MultiPointArray::<2>::from_wkb(arr, ct)?),
MultiLineString(ct, XY) => Arc::new(MultiLineStringArray::<2>::from_wkb(arr, ct)?),
MultiPolygon(ct, XY) => Arc::new(MultiPolygonArray::<2>::from_wkb(arr, ct)?),
Mixed(ct, XY) => {
let wkb_objects: Vec<Option<crate::scalar::WKB<'_, O>>> = arr.iter().collect();
let builder = MixedGeometryBuilder::<2>::from_wkb(
&wkb_objects,
Some(coord_type),
Some(ct),
arr.metadata(),
prefer_multi,
)?;
Ok(Arc::new(builder.finish()))
Arc::new(builder.finish())
}
GeometryCollection(coord_type, Dimension::XY) => {
GeometryCollection(ct, XY) => {
let wkb_objects: Vec<Option<crate::scalar::WKB<'_, O>>> = arr.iter().collect();
let builder = GeometryCollectionBuilder::<2>::from_wkb(
&wkb_objects,
Some(coord_type),
Some(ct),
arr.metadata(),
prefer_multi,
)?;
Ok(Arc::new(builder.finish()))
}
Point(coord_type, Dimension::XYZ) => {
let builder =
PointBuilder::<3>::from_wkb(&wkb_objects, Some(coord_type), arr.metadata())?;
Ok(Arc::new(builder.finish()))
}
LineString(coord_type, Dimension::XYZ) => {
let builder =
LineStringBuilder::<3>::from_wkb(&wkb_objects, Some(coord_type), arr.metadata())?;
Ok(Arc::new(builder.finish()))
}
Polygon(coord_type, Dimension::XYZ) => {
let builder =
PolygonBuilder::<3>::from_wkb(&wkb_objects, Some(coord_type), arr.metadata())?;
Ok(Arc::new(builder.finish()))
}
MultiPoint(coord_type, Dimension::XYZ) => {
let builder =
MultiPointBuilder::<3>::from_wkb(&wkb_objects, Some(coord_type), arr.metadata())?;
Ok(Arc::new(builder.finish()))
Arc::new(builder.finish())
}
MultiLineString(coord_type, Dimension::XYZ) => {
let builder = MultiLineStringBuilder::<3>::from_wkb(
&wkb_objects,
Some(coord_type),
arr.metadata(),
)?;
Ok(Arc::new(builder.finish()))
}
MultiPolygon(coord_type, Dimension::XYZ) => {
let builder =
MultiPolygonBuilder::<3>::from_wkb(&wkb_objects, Some(coord_type), arr.metadata())?;
Ok(Arc::new(builder.finish()))
}
Mixed(coord_type, Dimension::XYZ) => {
Point(ct, XYZ) => Arc::new(PointArray::<3>::from_wkb(arr, ct)?),
LineString(ct, XYZ) => Arc::new(LineStringArray::<3>::from_wkb(arr, ct)?),
Polygon(ct, XYZ) => Arc::new(PolygonArray::<3>::from_wkb(arr, ct)?),
MultiPoint(ct, XYZ) => Arc::new(MultiPointArray::<3>::from_wkb(arr, ct)?),
MultiLineString(ct, XYZ) => Arc::new(MultiLineStringArray::<3>::from_wkb(arr, ct)?),
MultiPolygon(ct, XYZ) => Arc::new(MultiPolygonArray::<3>::from_wkb(arr, ct)?),
Mixed(ct, XYZ) => {
let wkb_objects: Vec<Option<crate::scalar::WKB<'_, O>>> = arr.iter().collect();
let builder = MixedGeometryBuilder::<3>::from_wkb(
&wkb_objects,
Some(coord_type),
Some(ct),
arr.metadata(),
prefer_multi,
)?;
Ok(Arc::new(builder.finish()))
Arc::new(builder.finish())
}
GeometryCollection(coord_type, Dimension::XYZ) => {
GeometryCollection(ct, XYZ) => {
let wkb_objects: Vec<Option<crate::scalar::WKB<'_, O>>> = arr.iter().collect();
let builder = GeometryCollectionBuilder::<3>::from_wkb(
&wkb_objects,
Some(coord_type),
Some(ct),
arr.metadata(),
prefer_multi,
)?;
Ok(Arc::new(builder.finish()))
Arc::new(builder.finish())
}
Rect(_) => Err(GeoArrowError::General(format!(
"Unexpected data type {:?}",
target_geo_data_type,
))),
}
Rect(_) => {
return Err(GeoArrowError::General(format!(
"Unexpected data type {:?}",
target_geo_data_type,
)))
}
};
Ok(out)
}

/// An optimized implementation of converting from ISO WKB-encoded geometries.
Expand Down
1 change: 1 addition & 0 deletions src/io/wkt/mod.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,4 +1,5 @@
pub mod reader;
mod writer;

pub use reader::FromWKT;
pub use writer::ToWKT;
66 changes: 66 additions & 0 deletions src/io/wkt/reader/api.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,66 @@
use std::str::FromStr;

use ::wkt::Wkt;
use arrow_array::OffsetSizeTrait;

use crate::array::*;
use crate::error::{GeoArrowError, Result};
use crate::ArrayBase;

pub trait FromWKT: Sized {
type Input<O: OffsetSizeTrait>;

fn from_wkt<O: OffsetSizeTrait>(arr: &Self::Input<O>, coord_type: CoordType) -> Result<Self>;
}

// impl<const D: usize> FromWKT for PointArray<D> {
// type Input<O: OffsetSizeTrait> = WKTArray<O>;

// fn from_wkt<O: OffsetSizeTrait>(arr: &WKTArray<O>, coord_type: CoordType) -> Result<Self> {
// let mut builder = PointBuilder::<D>::new_with_options(coord_type, arr.metadata().clone());
// for row in arr.array.iter() {
// if let Some(s) = row {
// let geom = Wkt::<f64>::from_str(s)
// .map_err(|err| GeoArrowError::WktError(err.to_string()))?;
// builder.push_geometry(Some(&geom))?;
// } else {
// builder.push_null();
// }
// }

// Ok(builder.finish())
// }
// }

macro_rules! impl_from_wkt {
($array:ty, $builder:ty) => {
impl<const D: usize> FromWKT for $array {
type Input<O: OffsetSizeTrait> = WKTArray<O>;

fn from_wkt<O: OffsetSizeTrait>(
arr: &WKTArray<O>,
coord_type: CoordType,
) -> Result<Self> {
let mut builder = <$builder>::new_with_options(coord_type, arr.metadata().clone());
for row in arr.array.iter() {
if let Some(s) = row {
let geom = Wkt::<f64>::from_str(s)
.map_err(|err| GeoArrowError::WktError(err.to_string()))?;
builder.push_geometry(Some(&geom))?;
} else {
builder.push_null();
}
}

Ok(builder.finish())
}
}
};
}

impl_from_wkt!(PointArray<D>, PointBuilder<D>);
impl_from_wkt!(LineStringArray<D>, LineStringBuilder<D>);
impl_from_wkt!(PolygonArray<D>, PolygonBuilder<D>);
impl_from_wkt!(MultiPointArray<D>, MultiPointBuilder<D>);
impl_from_wkt!(MultiLineStringArray<D>, MultiLineStringBuilder<D>);
impl_from_wkt!(MultiPolygonArray<D>, MultiPolygonBuilder<D>);
3 changes: 3 additions & 0 deletions src/io/wkt/reader/mod.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -7,8 +7,11 @@ use crate::array::metadata::ArrayMetadata;
use crate::array::{CoordType, MixedGeometryBuilder};
use crate::NativeArray;

mod api;
mod wkt_trait;

pub use api::FromWKT;

// TODO: refactor this trait implementation once a WKTArray exists
pub trait ParseWKT {
type Output;
Expand Down
Loading