Implement the MovingFeatures Spec

CHANGELOG.md

@@ -10,6 +10,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 
 - Dynamic OpenAPI definition extraction.
+- Types for `OGCAPI - Moving Features`
 - Async OGC API - Processes execution (jobs).
 - Multipart/related response support for raw OGC API - Processes results with multiple outputs.
 - Echo process for testing.

ogcapi-types/Cargo.toml

@@ -11,7 +11,7 @@ keywords.workspace = true
 include = ["/src", "/assets"]
 
 [features]
-default = ["common", "edr", "features", "processes", "tiles"]
+default = ["common", "edr", "features", "movingfeatures", "processes", "tiles"]
 
 # standards
 common = []
@@ -22,6 +22,7 @@ stac = ["features"]
 styles = []
 tiles = ["common"]
 coverages = []
+movingfeatures = ["common", "features"]
 
 [dependencies]
 chrono = { version = "0.4.42", features = ["serde"] }

ogcapi-types/src/common/collection.rs

@@ -87,6 +87,14 @@ pub struct Collection {
     #[cfg(feature = "stac")]
     #[serde(default, skip_serializing_if = "std::collections::HashMap::is_empty")]
     pub assets: std::collections::HashMap<String, crate::stac::Asset>,
+    #[cfg(feature = "movingfeatures")]
+    #[serde(
+        default,
+        rename = "updateFrequency",
+        skip_serializing_if = "Option::is_none"
+    )]
+    /// A time interval of sampling location. The time unit of this property is millisecond.
+    pub update_frequency: Option<i64>,
     #[serde(flatten, default, skip_serializing_if = "Map::is_empty")]
     pub additional_properties: Map<String, Value>,
 }
@@ -131,6 +139,8 @@ impl Default for Collection {
             summaries: Default::default(),
             #[cfg(feature = "stac")]
             assets: Default::default(),
+            #[cfg(feature = "movingfeatures")]
+            update_frequency: Default::default(),
             additional_properties: Default::default(),
         }
     }

ogcapi-types/src/common/extent.rs

@@ -73,7 +73,7 @@ impl Default for TemporalExtent {
     }
 }
 
-fn serialize_interval<S>(
+pub(crate) fn serialize_interval<S>(
     interval: &Vec<[Option<DateTime<Utc>>; 2]>,
     serializer: S,
 ) -> Result<S::Ok, S::Error>

ogcapi-types/src/features/feature.rs

@@ -4,6 +4,16 @@ use std::fmt::Display;
 
 #[cfg(feature = "stac")]
 use crate::common::Bbox;
+
+#[cfg(feature = "movingfeatures")]
+use crate::movingfeatures::{
+    crs::Crs, temporal_geometry::TemporalGeometry, temporal_properties::TemporalProperties,
+    trs::Trs,
+};
+
+#[cfg(feature = "movingfeatures")]
+use chrono::{DateTime, Utc};
+
 use geojson::Geometry;
 use serde::{Deserialize, Serialize};
 use serde_json::{Map, Value};
@@ -69,6 +79,27 @@ pub struct Feature {
     #[cfg(feature = "stac")]
     #[serde(default)]
     pub assets: HashMap<String, crate::stac::Asset>,
+    #[cfg(feature = "movingfeatures")]
+    #[serde(
+        default,
+        serialize_with = "crate::common::serialize_interval",
+        skip_serializing_if = "Vec::is_empty"
+    )]
+    /// Life span information for the moving feature.
+    /// See [MF-Json 7.2.3 LifeSpan](https://docs.ogc.org/is/19-045r3/19-045r3.html#time)
+    pub time: Vec<[Option<DateTime<Utc>>; 2]>,
+    #[cfg(feature = "movingfeatures")]
+    #[serde(default)]
+    pub crs: Crs,
+    #[cfg(feature = "movingfeatures")]
+    #[serde(default)]
+    pub trs: Trs,
+    #[cfg(feature = "movingfeatures")]
+    #[serde(default, rename = "temporalGeometry")]
+    pub temporal_geometry: Option<TemporalGeometry>,
+    #[cfg(feature = "movingfeatures")]
+    #[serde(default, rename = "temporalProperties")]
+    pub temporal_properties: Option<TemporalProperties>,
 }
 
 impl Feature {

ogcapi-types/src/features/feature_collection.rs

@@ -4,6 +4,9 @@ use utoipa::ToSchema;
 
 use crate::common::Link;
 
+#[cfg(feature = "movingfeatures")]
+use crate::common::Bbox;
+
 use super::Feature;
 
 #[derive(Serialize, Deserialize, ToSchema, Default, Debug, Clone, Copy, PartialEq, Eq)]
@@ -26,6 +29,15 @@ pub struct FeatureCollection {
     pub time_stamp: Option<String>,
     pub number_matched: Option<u64>,
     pub number_returned: Option<u64>,
+    #[cfg(feature = "movingfeatures")]
+    #[serde(default)]
+    pub crs: crate::movingfeatures::crs::Crs,
+    #[cfg(feature = "movingfeatures")]
+    #[serde(default)]
+    pub trs: crate::movingfeatures::trs::Trs,
+    #[cfg(feature = "movingfeatures")]
+    #[serde(default)]
+    pub bbox: Option<Bbox>,
 }
 
 impl FeatureCollection {

ogcapi-types/src/lib.rs

@@ -9,6 +9,9 @@ pub mod edr;
 /// Types specified in the `OGC API - Features` standard.
 #[cfg(feature = "features")]
 pub mod features;
+/// Types specified in the `OGC API - Moving Features` standard.
+#[cfg(feature = "movingfeatures")]
+pub mod movingfeatures;
 /// Types specified in the `OGC API - Processes` standard.
 #[cfg(feature = "processes")]
 pub mod processes;

ogcapi-types/src/movingfeatures/crs.rs

@@ -0,0 +1,93 @@
+use std::str::FromStr;
+
+use serde::{Deserialize, Serialize};
+use utoipa::ToSchema;
+
+use crate::common;
+
+/// MF-JSON uses a CRS as described in in (GeoJSON:2008)[https://geojson.org/geojson-spec#coordinate-reference-system-objects]
+/// See (7.2.3 CoordinateReferenceSystem Object)[https://docs.ogc.org/is/19-045r3/19-045r3.html#crs]
+/// See (6. Overview of Moving features JSON Encodings)[https://docs.ogc.org/is/19-045r3/19-045r3.html#_overview_of_moving_features_json_encodings_informative]
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, ToSchema)]
+#[serde(tag = "type", content = "properties")]
+pub enum Crs {
+    /// A Named CRS object indicates a coordinate reference system by name. In this case, the value of its "type" member
+    /// is the string "Name". The value of its "properties" member is a JSON object containing a "name" member whose
+    /// value is a string identifying a coordinate reference system (not JSON null value). The value of "href" and "type"
+    /// is a JSON null value. This standard recommends an EPSG[3] code as the value of "name", such as "EPSG::4326."
+    ///
+    /// See (7.2.3.1 Named CRS)[https://docs.ogc.org/is/19-045r3/19-045r3.html#_7_2_3_1_named_crs]
+    Name { name: String },
+    /// A linked CRS object has one required member "href" and one optional member "type". The value of the required "href"
+    /// member is a dereferenceable URI. The value of the optional "type" member is a string that hints at the format used
+    /// to represent CRS parameters at the provided URI. Suggested values are: "Proj4", "OGCWKT", "ESRIWKT", but others can
+    /// be used.
+    ///
+    /// See (7.2.3.2. Linked CRS)[https://docs.ogc.org/is/19-045r3/19-045r3.html#_7_2_3_2_linked_crs]
+    Link {
+        r#type: Option<String>,
+        href: String,
+    },
+}
+
+impl Default for Crs {
+    fn default() -> Self {
+        Self::Name {
+            name: common::Crs::default().to_urn(),
+        }
+    }
+}
+
+impl TryFrom<Crs> for common::Crs {
+    type Error = String;
+
+    fn try_from(value: Crs) -> Result<Self, Self::Error> {
+        match value {
+            // TODO this might not work for names like "EPSG:4326"
+            Crs::Name { name } => Self::from_str(name.as_str()),
+            Crs::Link { href, .. } => Self::from_str(href.as_str()),
+        }
+    }
+}
+
+impl From<common::Crs> for Crs {
+    fn from(value: common::Crs) -> Self {
+        Self::Name {
+            name: value.to_urn(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+
+    #[test]
+    fn serde_json() {
+        // TODO this contradicts example from https://developer.ogc.org/api/movingfeatures/index.html#tag/MovingFeatures/operation/retrieveMovingFeatures
+        // Example from https://docs.ogc.org/is/19-045r3/19-045r3.html#_7_2_3_1_named_crs
+        let trs: Crs = serde_json::from_str(
+            r#"
+            {
+              "type": "Name",
+              "properties": {
+                "name": "urn:ogc:def:crs:OGC:1.3:CRS84"
+              }
+            }
+        "#,
+        )
+        .expect("Failed to parse Crs");
+        let expected_trs = Crs::default();
+        assert_eq!(trs, expected_trs);
+    }
+
+    #[test]
+    fn into_common_crs() {
+        // assert_eq!(common::Crs::try_from(Crs::default()).unwrap(), common::Crs::default());
+        assert_eq!(common::Crs::default(), Crs::default().try_into().unwrap());
+
+        // assert_eq!(Crs::from(common::Crs::default()), Crs::default());
+        assert_eq!(Crs::default(), common::Crs::default().into());
+    }
+}