mlt_core/convert/mvt/
encode.rs

1//! Encode row-oriented [`TileLayer`]s as MVT (Mapbox Vector Tile) bytes,
2//! delegating wire-format details to the [`fast_mvt`] crate.
3
4use fast_mvt::{MvtTileBuilder, MvtValue};
5
6use crate::tile::{PropValue, TileLayer};
7use crate::{MltError, MltResult};
8
9/// Encode row-oriented [`TileLayer`]s as MVT (Mapbox Vector Tile) bytes.
10pub fn tile_layers_to_mvt(layers: Vec<TileLayer>) -> MltResult<Vec<u8>> {
11    let mut tile = MvtTileBuilder::with_capacity(layers.len());
12    for layer in layers {
13        if layer.name.is_empty() {
14            return Err(MltError::MissingLayerName);
15        }
16        let mut mvt_layer = tile.layer_with_capacity(layer.name, layer.features.len())?;
17        mvt_layer.extent(layer.extent.into());
18        for feat in layer.features {
19            let mut feature = mvt_layer.feature(&feat.geometry)?;
20            feature.id(feat.id);
21            for (col_idx, prop) in feat.properties.into_iter().enumerate() {
22                if let Some(name) = layer.property_names.get(col_idx)
23                    && let Ok(value) = MvtValue::try_from(prop)
24                {
25                    feature.tag(name, value)?;
26                }
27            }
28            mvt_layer = feature.end();
29        }
30        tile = mvt_layer.end();
31    }
32    Ok(tile.encode())
33}
34
35impl TryFrom<PropValue> for MvtValue {
36    type Error = ();
37
38    fn try_from(prop: PropValue) -> Result<Self, Self::Error> {
39        Ok(match prop {
40            PropValue::Bool(Some(b)) => Self::Bool(b),
41            PropValue::I8(Some(i)) => Self::SInt(i.into()),
42            PropValue::U8(Some(u)) => Self::UInt(u.into()),
43            PropValue::I32(Some(i)) => Self::SInt(i.into()),
44            PropValue::U32(Some(u)) => Self::UInt(u.into()),
45            PropValue::I64(Some(i)) => Self::SInt(i),
46            PropValue::U64(Some(u)) => Self::UInt(u),
47            PropValue::F32(Some(f)) => Self::Float(f),
48            PropValue::F64(Some(f)) => Self::Double(f),
49            PropValue::Str(Some(s)) => Self::String(s),
50            PropValue::Bool(None)
51            | PropValue::I8(None)
52            | PropValue::U8(None)
53            | PropValue::I32(None)
54            | PropValue::U32(None)
55            | PropValue::I64(None)
56            | PropValue::U64(None)
57            | PropValue::F32(None)
58            | PropValue::F64(None)
59            | PropValue::Str(None) => Err(())?,
60        })
61    }
62}
63
64#[cfg(test)]
65mod tests {
66    use super::*;
67    use crate::mvt::mvt_to_tile_layers;
68    use crate::tile::{Extent, TileFeature};
69
70    #[test]
71    fn empty_input_yields_empty_output() {
72        let bytes = tile_layers_to_mvt(Vec::new()).unwrap();
73        let decoded = mvt_to_tile_layers(bytes).unwrap();
74        assert_eq!(decoded, [] as [TileLayer; 0]);
75    }
76
77    #[test]
78    fn rejects_empty_layer_name() {
79        let layer = TileLayer {
80            name: String::new(),
81            extent: Extent::new(4096).unwrap(),
82            property_names: vec![],
83            property_kinds: vec![],
84            #[cfg(feature = "unstable-v2")]
85            m_value_names: vec![],
86            #[cfg(feature = "unstable-v2")]
87            m_value_kinds: vec![],
88            #[cfg(feature = "unstable-v2")]
89            nested_names: vec![],
90            #[cfg(feature = "unstable-v2")]
91            nested_kinds: vec![],
92            features: vec![],
93        };
94
95        assert!(matches!(
96            tile_layers_to_mvt(vec![layer]),
97            Err(MltError::MissingLayerName)
98        ));
99    }
100
101    /// `ClosePath` repeats the first vertex; an input with the closing
102    /// duplicate must therefore round-trip without growing extra vertices.
103    #[test]
104    fn ring_is_implicitly_closed() {
105        use geo_types::{Geometry, LineString, Polygon};
106        let ring = vec![
107            (0_i32, 0_i32).into(),
108            (10, 0).into(),
109            (10, 10).into(),
110            (0, 10).into(),
111            (0, 0).into(),
112        ];
113        let layer = TileLayer::from_parts(
114            "L",
115            4096,
116            vec![],
117            vec![TileFeature {
118                id: Some(1),
119                geometry: Geometry::Polygon(Polygon::new(LineString(ring), vec![])),
120                properties: vec![],
121                #[cfg(feature = "unstable-v2")]
122                m_values: vec![],
123                #[cfg(feature = "unstable-v2")]
124                nested: vec![],
125            }],
126        )
127        .unwrap();
128        let bytes = tile_layers_to_mvt(vec![layer]).unwrap();
129        let back = mvt_to_tile_layers(bytes).unwrap();
130        let Geometry::Polygon(p) = back[0].features()[0].geometry() else {
131            panic!(
132                "expected polygon, got {:?}",
133                back[0].features()[0].geometry()
134            );
135        };
136        assert_eq!(p.exterior().0.len(), 5);
137        assert_eq!(p.exterior().0.first(), p.exterior().0.last());
138    }
139}
mlt_core/convert/mvt/encode.rs

mlt_core/convert/mvt/
encode.rs
