feat: Add interpolation for text style properties (galileo-map#302)

Author: shri-acha

galileo/examples/vector_tiles_labels.rs

@@ -2,11 +2,11 @@
 
 use galileo::layer::data_provider::remove_parameters_modifier;
 use galileo::layer::vector_tile_layer::style::{
-    StyleRule, VectorTileLabelSymbol, VectorTileStyle, VectorTileSymbol,
+    StyleRule, VectorTileLabelSymbol, VectorTileStyle, VectorTileSymbol, VtTextStyle,
 };
 use galileo::layer::vector_tile_layer::{VectorTileLayer, VectorTileLayerBuilder};
 use galileo::render::text::text_service::TextService;
-use galileo::render::text::{FontWeight, RustybuzzRasterizer, TextStyle};
+use galileo::render::text::{FontWeight, RustybuzzRasterizer};
 use galileo::tile_schema::{TileIndex, TileSchema, TileSchemaBuilder};
 use galileo::{Color, MapBuilder};
 
@@ -48,7 +48,7 @@ pub(crate) fn run() {
             properties: Default::default(),
             symbol: VectorTileSymbol::Label(VectorTileLabelSymbol {
                 pattern: String::from("{name}"),
-                text_style: TextStyle {
+                text_style: VtTextStyle {
                     font_family: vec![
                         "Noto Sans".to_string(),
                         "Noto Sans Arabic".to_string(),
@@ -57,14 +57,14 @@ pub(crate) fn run() {
                         "Noto Sans KR".to_string(),
                         "Noto Sans JP".to_string(),
                     ],
-                    font_size: 12.0,
-                    font_color: Color::BLACK,
+                    font_size: 12.0.into(),
+                    font_color: Color::BLACK.into(),
                     horizontal_alignment: Default::default(),
                     vertical_alignment: Default::default(),
                     weight: FontWeight::BOLD,
                     style: Default::default(),
-                    outline_width: 2.0,
-                    outline_color: Color::WHITE,
+                    outline_width: 2.0.into(),
+                    outline_color: Color::WHITE.into(),
                 },
             }),
         }],

galileo/src/layer/vector_tile_layer/expressions.rs

@@ -191,6 +191,17 @@ impl StyleValue<f64> {
     }
 }
 
+impl StyleValue<f32> {
+    /// Evaluates value of Number depending upon the type of expression used.
+    pub fn get_value(&self, current_resolution: f64) -> f32 {
+        match self {
+            StyleValue::Simple(t) => *t,
+            StyleValue::Interpolate(expression) => expression.evaluate(current_resolution),
+            StyleValue::Steps(expression) => expression.evaluate(current_resolution),
+        }
+    }
+}
+
 impl<T> InterpolateExpression<T> {
     /// Returns a new instance of `InterpolateExpression`
     pub fn new(interpolation_args: InterpolationArgs<T>) -> Self {
@@ -234,6 +245,22 @@ trait InterpolatableValue: Copy {
     fn set_component(&mut self, component: &Self::COMPONENTS, value: f64);
 }
 
+impl InterpolatableValue for f32 {
+    type COMPONENTS = ();
+
+    fn iter_components() -> impl Iterator<Item = Self::COMPONENTS> {
+        std::iter::once(())
+    }
+
+    fn get_component(&self, _component: &Self::COMPONENTS) -> f64 {
+        *self as f64
+    }
+
+    fn set_component(&mut self, _component: &Self::COMPONENTS, value: f64) {
+        *self = value as f32
+    }
+}
+
 impl InterpolatableValue for f64 {
     type COMPONENTS = ();
 

galileo/src/layer/vector_tile_layer/style.rs

@@ -5,7 +5,9 @@ use serde::{Deserialize, Serialize};
 
 use crate::layer::vector_tile_layer::expressions::StyleValue;
 use crate::render::point_paint::PointPaint;
-use crate::render::text::TextStyle;
+use crate::render::text::{
+    FontStyle, FontWeight, HorizontalAlignment, TextStyle, VerticalAlignment,
+};
 use crate::render::{LineCap, LinePaint, PolygonPaint};
 use crate::Color;
 
@@ -329,7 +331,68 @@ pub struct VectorTileLabelSymbol {
     /// Text of the label with substitutes for feature attributes.
     pub pattern: String,
     /// Style of the text.
-    pub text_style: TextStyle,
+    pub text_style: VtTextStyle,
+}
+
+/// Raw Style of a text label that generates a `TextStyle`.
+/// This allows for interpolation of fields like font_size,font_color,outline_color,outline_width.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct VtTextStyle {
+    /// Name of the font to use.
+    pub font_family: Vec<String>,
+    /// Size of the font in pixels.
+    pub font_size: StyleValue<f32>,
+    /// Color of the font.
+    #[serde(default = "default_font_color_style")]
+    pub font_color: StyleValue<Color>,
+    /// Alignment of label along horizontal axis.
+    #[serde(default)]
+    pub horizontal_alignment: HorizontalAlignment,
+    /// Alignment of label along vertical axis.
+    #[serde(default)]
+    pub vertical_alignment: VerticalAlignment,
+    /// Weight of the font.
+    #[serde(default)]
+    pub weight: FontWeight,
+    /// sTyle of the font.
+    #[serde(default)]
+    pub style: FontStyle,
+    /// Width of the outline around the letters.
+    #[serde(default = "default_outline_width_style")]
+    pub outline_width: StyleValue<f32>,
+    /// Color of the outline around the letters.
+    #[serde(default = "default_outline_color_style")]
+    pub outline_color: StyleValue<Color>,
+}
+
+impl VtTextStyle {
+    /// This method returns the value of the struct `TextStyle` on the basis of the
+    /// current resolution level.
+    pub fn get_value(self, current_resolution: f64) -> TextStyle {
+        TextStyle {
+            font_family: self.font_family,
+            font_size: self.font_size.get_value(current_resolution),
+            font_color: self.font_color.get_value(current_resolution),
+            horizontal_alignment: self.horizontal_alignment,
+            vertical_alignment: self.vertical_alignment,
+            weight: self.weight,
+            style: self.style,
+            outline_width: self.outline_width.get_value(current_resolution),
+            outline_color: self.outline_color.get_value(current_resolution),
+        }
+    }
+}
+
+fn default_font_color_style() -> StyleValue<Color> {
+    Color::BLACK.into()
+}
+
+fn default_outline_color_style() -> StyleValue<Color> {
+    Color::TRANSPARENT.into()
+}
+
+fn default_outline_width_style() -> StyleValue<f32> {
+    0.0.into()
 }
 
 #[cfg(test)]

galileo/src/layer/vector_tile_layer/tile_provider/vt_processor.rs

@@ -137,12 +137,13 @@ impl VtProcessor {
             .or_else(|| {
                 rule.symbol
                     .label()
-                    .and_then(|symbol| Self::format_label(symbol, feature))
+                    .and_then(|symbol| Self::format_label(symbol, resolution, feature))
             })
     }
 
     fn format_label<'a>(
         label_symbol: &VectorTileLabelSymbol,
+        resolution: f64,
         feature: &MvtFeature,
     ) -> Option<PointPaint<'a>> {
         let re = Regex::new("\\{(?<name>.+)}").ok()?;
@@ -159,7 +160,7 @@ impl VtProcessor {
         }
         Some(PointPaint::label_owned(
             text,
-            label_symbol.text_style.clone(),
+            label_symbol.text_style.clone().get_value(resolution),
         ))
     }