first version of OpenCL support for operations on rasters (and soon f…

datatypes/src/collections/data_types.rs

@@ -1,3 +1,6 @@
+use crate::collections::{
+    DataCollection, MultiLineStringCollection, MultiPointCollection, MultiPolygonCollection,
+};
 use serde::{Deserialize, Serialize};
 
 /// An enum that contains all possible vector data types
@@ -9,3 +12,29 @@ pub enum VectorDataType {
     MultiLineString,
     MultiPolygon,
 }
+
+pub enum TypedFeatureCollection {
+    Data(DataCollection),
+    MultiPoint(MultiPointCollection),
+    MultiLineString(MultiLineStringCollection),
+    MultiPolygon(MultiPolygonCollection),
+}
+
+impl TypedFeatureCollection {
+    pub fn vector_data_type(&self) -> VectorDataType {
+        match self {
+            TypedFeatureCollection::Data(_) => VectorDataType::Data,
+            TypedFeatureCollection::MultiPoint(_) => VectorDataType::MultiPoint,
+            TypedFeatureCollection::MultiLineString(_) => VectorDataType::MultiLineString,
+            TypedFeatureCollection::MultiPolygon(_) => VectorDataType::MultiPolygon,
+        }
+    }
+
+    // TODO: other types
+    pub fn get_points(self) -> Option<MultiPointCollection> {
+        if let TypedFeatureCollection::MultiPoint(points) = self {
+            return Some(points);
+        }
+        None
+    }
+}

datatypes/src/collections/mod.rs

@@ -24,3 +24,25 @@ pub use data_types::VectorDataType;
 pub use multi_line_string_collection::MultiLineStringCollection;
 pub use multi_point_collection::MultiPointCollection;
 pub use multi_polygon_collection::MultiPolygonCollection;
+
+pub use data_types::TypedFeatureCollection;
+
+/// Calls a function on a `TypedFeatureCollection` by calling it on its variant.
+/// Call via `call_generic_features!(input, features => function)`.
+#[macro_export]
+macro_rules! call_generic_features {
+    ($input_features:expr, $features:ident => $function_call:expr) => {
+        call_generic_features!(
+            @variants $input_features, $features => $function_call,
+            Data, MultiPoint, MultiLineString, MultiPolygon
+        )
+    };
+
+    (@variants $input_features:expr, $features:ident => $function_call:expr, $($variant:tt),+) => {
+        match $input_features {
+            $(
+                $crate::collections::TypedFeatureCollection::$variant($features) => $function_call,
+            )+
+        }
+    };
+}

datatypes/src/collections/multi_point_collection.rs

@@ -100,6 +100,44 @@ impl GeoFeatureCollectionRowBuilder<MultiPoint> for FeatureCollectionRowBuilder<
     }
 }
 
+impl MultiPointCollection {
+    pub fn coordinates(&self) -> &[Coordinate2D] {
+        let geometries_ref = self
+            .table
+            .column_by_name(Self::GEOMETRY_COLUMN_NAME)
+            .expect("There must exist a geometry column");
+        let geometries: &ListArray = downcast_array(geometries_ref);
+
+        let coordinates_ref = geometries.values();
+        let coordinates: &FixedSizeListArray = downcast_array(&coordinates_ref);
+
+        let number_of_coordinates = coordinates.data().len();
+
+        let floats_ref = coordinates.values();
+        let floats: &Float64Array = downcast_array(&floats_ref);
+
+        unsafe {
+            slice::from_raw_parts(
+                floats.raw_values() as *const Coordinate2D,
+                number_of_coordinates,
+            )
+        }
+    }
+
+    pub fn coordinates_offsets(&self) -> &[i32] {
+        let geometries_ref = self
+            .table
+            .column_by_name(Self::GEOMETRY_COLUMN_NAME)
+            .expect("There must exist a geometry column");
+        let geometries: &ListArray = downcast_array(geometries_ref);
+
+        let data = geometries.data();
+        let buffer = &data.buffers()[0];
+
+        unsafe { slice::from_raw_parts(buffer.raw_data() as *const i32, geometries.len() + 1) }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -864,4 +902,47 @@ mod tests {
 
         assert_eq!(collection, deserialized);
     }
+
+    #[test]
+    fn coordinates() {
+        let pc = MultiPointCollection::from_data(
+            MultiPoint::many(vec![
+                vec![(0., 0.)],
+                vec![(1., 1.), (1.1, 1.1)],
+                vec![(2., 2.)],
+            ])
+            .unwrap(),
+            vec![
+                TimeInterval::new_unchecked(0, 1),
+                TimeInterval::new_unchecked(1, 2),
+                TimeInterval::new_unchecked(2, 3),
+            ],
+            {
+                let mut map = HashMap::new();
+                map.insert("numbers".into(), FeatureData::Number(vec![0., 1., 2.]));
+                map.insert(
+                    "number_nulls".into(),
+                    FeatureData::NullableNumber(vec![Some(0.), None, Some(2.)]),
+                );
+                map
+            },
+        )
+        .unwrap();
+
+        let coords = pc.coordinates();
+        assert_eq!(coords.len(), 4);
+        assert_eq!(
+            coords,
+            &[
+                [0., 0.].into(),
+                [1., 1.].into(),
+                [1.1, 1.1].into(),
+                [2., 2.].into(),
+            ]
+        );
+
+        let offsets = pc.coordinates_offsets();
+        assert_eq!(offsets.len(), 4);
+        assert_eq!(offsets, &[0, 1, 3, 4]);
+    }
 }

datatypes/src/error.rs

@@ -124,6 +124,7 @@ pub enum Error {
     ParseU32 {
         source: <u32 as std::str::FromStr>::Err,
     },
+    InvalidTypedRasterConversion,
 }
 
 impl From<arrow::error::ArrowError> for Error {

datatypes/src/primitives/coordinate.rs

@@ -2,16 +2,19 @@ use crate::util::arrow::ArrowTyped;
 use arrow::array::{BooleanArray, Float64Builder};
 use arrow::datatypes::DataType;
 use arrow::error::ArrowError;
+use ocl::OclPrm;
 use serde::{Deserialize, Serialize};
 use std::{fmt, slice};
 
-#[derive(Clone, Copy, Debug, Deserialize, PartialEq, PartialOrd, Serialize)]
+#[derive(Clone, Copy, Debug, Deserialize, PartialEq, PartialOrd, Serialize, Default)]
 #[repr(C)]
 pub struct Coordinate2D {
     pub x: f64,
     pub y: f64,
 }
 
+unsafe impl OclPrm for Coordinate2D {}
+
 impl Coordinate2D {
     /// Creates a new coordinate
     ///

datatypes/src/raster/data_type.rs

@@ -1,4 +1,5 @@
 use crate::operations::image::RgbaTransmutable;
+use crate::raster::typed_raster::TypedRasterConversion;
 use num_traits::{AsPrimitive, Num};
 use serde::{Deserialize, Serialize};
 
@@ -35,6 +36,7 @@ pub trait Pixel:
     + FromPrimitive<Self>
     + StaticRasterDataType
     + RgbaTransmutable
+    + TypedRasterConversion
 {
 }
 

datatypes/src/raster/helpers.rs

@@ -41,7 +41,7 @@ macro_rules! call_generic_raster2d {
 }
 
 /// Calls a function on two `TypedRaster2D`s by calling it on their variant combination.
-/// Call via `call_bi_generic_raster2d!(input, (raster_a, raster_b) => function)`.
+/// Call via `call_bi_generic_raster2d!(input_a, input_b, (raster_a, raster_b) => function)`.
 #[macro_export]
 macro_rules! call_bi_generic_raster2d {
     (
@@ -84,7 +84,7 @@ macro_rules! call_bi_generic_raster2d {
 }
 
 /// Calls a function on two `TypedRaster2D`s by calling it on their variant combination.
-/// Call via `call_bi_generic_raster2d_same!(input, (raster_a, raster_b) => function)`.
+/// Call via `call_bi_generic_raster2d_same!(input_a, input_b, (raster_a, raster_b) => function)`.
 /// The resulting call requires the rasters to be of the same type.
 /// Otherwise, the last optional parameter is a catch-all function (or it just panics).
 #[macro_export]
@@ -134,7 +134,7 @@ macro_rules! call_bi_generic_raster2d_same {
 }
 
 /// Calls a function on two `TypedRaster2D`s by calling it on their variant combination.
-/// Call via `call_bi_generic_raster2d_staircase!(input, (raster_a, raster_b) => function)`.
+/// Call via `call_bi_generic_raster2d_staircase!(input_a, input_b, (raster_a, raster_b) => function)`.
 /// This macro requires the first raster type to be greater or equal to the second one.
 /// Otherwise, the last optional parameter is a catch-all function (or it just panics).
 #[macro_export]
@@ -214,10 +214,35 @@ macro_rules! generate_generic_raster2d {
     };
 }
 
+/// Calls a function on a `TypedRaster2D` and some `RasterDataType`-like enum, effectively matching
+/// the raster with the corresponding enum value of the other enum.
+/// Call via `call_generic_raster2d_ext!(input, (raster, e) => function)`.
+#[macro_export]
+macro_rules! call_generic_raster2d_ext {
+    ($input_raster:expr, $other_enum:ty, ($raster:ident, $enum:ident) => $func:expr) => {
+        call_generic_raster2d_ext!(
+            @variants $input_raster, $other_enum, ($raster, $enum) => $func,
+            U8, U16, U32, U64, I8, I16, I32, I64, F32, F64
+        )
+    };
+
+    (@variants $input_raster:expr, $other_enum:ty, ($raster:ident, $enum:ident) => $func:expr, $($variant:tt),+) => {
+        match $input_raster {
+            $(
+                $crate::raster::TypedRaster2D::$variant($raster) => {
+                    let $enum = <$other_enum>::$variant;
+                    $func
+                }
+            )+
+        }
+    };
+}
+
 #[cfg(test)]
 mod tests {
     use crate::raster::{GridPixelAccess, Pixel, Raster2D, RasterDataType, TypedRaster2D};
     use crate::util::test::catch_unwind_silent;
+    use serde::export::PhantomData;
 
     #[test]
     fn map_generic_raster2d() {
@@ -446,4 +471,45 @@ mod tests {
         ))
         .is_err());
     }
+
+    #[test]
+    fn ext() {
+        struct T<S> {
+            s: PhantomData<S>,
+        }
+
+        enum Foo {
+            U8(T<u8>),
+            U16(T<u16>),
+            U32(T<u32>),
+            U64(T<u64>),
+            I8(T<i8>),
+            I16(T<i16>),
+            I32(T<i32>),
+            I64(T<i64>),
+            F32(T<f32>),
+            F64(T<f64>),
+        }
+
+        fn foo<S>(_f: fn(T<S>) -> Foo, _r: &Raster2D<S>)
+        where
+            S: Pixel,
+        {
+        }
+
+        let typed_raster_a = TypedRaster2D::U32(
+            Raster2D::new(
+                [3, 2].into(),
+                vec![1, 2, 3, 4, 5, 6],
+                None,
+                Default::default(),
+                [1.0, 1.0, 0.0, 1.0, 0.0, 1.0].into(),
+            )
+            .unwrap(),
+        );
+
+        call_generic_raster2d_ext!(typed_raster_a, Foo, (raster, e) => {
+            foo(e, &raster)
+        });
+    }
 }