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            #[cfg(feature = "unstable-v2")]
93            z_step: None,
94            features: vec![],
95        };
96
97        assert!(matches!(
98            tile_layers_to_mvt(vec![layer]),
99            Err(MltError::MissingLayerName)
100        ));
101    }
102
103    /// `ClosePath` repeats the first vertex; an input with the closing
104    /// duplicate must therefore round-trip without growing extra vertices.
105    #[test]
106    fn ring_is_implicitly_closed() {
107        use geo_types::{Geometry, LineString, Polygon};
108        let ring = vec![
109            (0_i32, 0_i32).into(),
110            (10, 0).into(),
111            (10, 10).into(),
112            (0, 10).into(),
113            (0, 0).into(),
114        ];
115        let layer = TileLayer::from_parts(
116            "L",
117            4096,
118            vec![],
119            vec![TileFeature {
120                id: Some(1),
121                geometry: Geometry::Polygon(Polygon::new(LineString(ring), vec![])),
122                properties: vec![],
123                #[cfg(feature = "unstable-v2")]
124                m_values: vec![],
125                #[cfg(feature = "unstable-v2")]
126                nested: vec![],
127                #[cfg(feature = "unstable-v2")]
128                z: Vec::new(),
129            }],
130        )
131        .unwrap();
132        let bytes = tile_layers_to_mvt(vec![layer]).unwrap();
133        let back = mvt_to_tile_layers(bytes).unwrap();
134        let Geometry::Polygon(p) = back[0].features()[0].geometry() else {
135            panic!(
136                "expected polygon, got {:?}",
137                back[0].features()[0].geometry()
138            );
139        };
140        assert_eq!(p.exterior().0.len(), 5);
141        assert_eq!(p.exterior().0.first(), p.exterior().0.last());
142    }
143}
mlt_core/convert/mvt/encode.rs

mlt_core/convert/mvt/
encode.rs
