feat: Select expresssions

Add `Expr::Select` variant and support conversion of MapLibre `Step`
expression into Galileo `Select`.

Author: Maximkaaa

galileo-maplibre/src/layer/vector_tile.rs

@@ -235,7 +235,7 @@ fn fill_rule(fill: &FillLayer, tile_schema: &TileSchema) -> Option<StyleRule> {
     let fill_opacity = &fill.paint.fill_opacity;
     let color = get_color_value(fill_color, fill_opacity)?;
 
-    if fill.paint.fill_antialias == false {
+    if !fill.paint.fill_antialias {
         log::debug!(
             "{} not-antialised polygons are not supported yet",
             crate::layer::UNSUPPORTED,

galileo-maplibre/src/style/expression.rs

@@ -24,7 +24,7 @@ use std::fmt;
 
 use galileo::expr::{
     ControlPoint, CubicBezierInterpolation, ExponentialInterpolation, Expr, ExprGeometryType,
-    ExprValue, LinearInterpolation, MatchCase, MatchExpr,
+    ExprValue, LinearInterpolation, MatchCase, MatchExpr, SelectCase, SelectExpr,
 };
 use serde::de::{self, SeqAccess, Visitor};
 use serde::{Deserialize, Deserializer, Serialize};
@@ -883,6 +883,35 @@ impl MlExpr {
                     .collect::<Option<Vec<_>>>()?,
                 fallback: fallback.to_galileo_expr()?,
             })),
+            MlExpr::Step {
+                input,
+                default_output,
+                stops,
+            } => {
+                let last_stop = stops.iter().last()?;
+                let mut cases = vec![];
+                let boxed_input = Box::new(input.to_galileo_expr()?);
+
+                let mut prev_out = default_output.to_galileo_expr()?;
+                for stop in stops {
+                    cases.push(SelectCase {
+                        condition: Expr::Lte(boxed_input.clone(), Box::new(stop.0.into())),
+                        out: prev_out,
+                    });
+
+                    prev_out = stop.1.to_galileo_expr()?;
+                }
+
+                cases.push(SelectCase {
+                    condition: Expr::Gte(boxed_input.clone(), Box::new(last_stop.0.into())),
+                    out: prev_out,
+                });
+
+                Expr::Select(Box::new(SelectExpr {
+                    cases,
+                    fallback: default_output.to_galileo_expr()?,
+                }))
+            }
             _ => {
                 log::debug!("{UNSUPPORTED} Expression {self:?} is not supported yet");
                 return None;

galileo/src/expr/match_expr.rs

@@ -2,6 +2,30 @@ use serde::{Deserialize, Serialize};
 
 use crate::expr::{Expr, ExprFeature, ExprValue, ExprView};
 
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct SelectExpr {
+    pub cases: Vec<SelectCase>,
+    pub fallback: Expr,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct SelectCase {
+    pub condition: Expr,
+    pub out: Expr,
+}
+
+impl SelectExpr {
+    pub fn eval<'a>(&'a self, f: &'a impl ExprFeature, v: ExprView) -> ExprValue<'a> {
+        for case in &self.cases {
+            if case.condition.eval(f, v).to_bool() {
+                return case.out.eval(f, v);
+            }
+        }
+
+        self.fallback.eval(f, v)
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct MatchExpr {
     pub input: Expr,

galileo/src/expr/mod.rs

@@ -47,6 +47,7 @@ pub enum Expr {
     CubicBezier(Box<CubicBezierInterpolation>),
 
     Match(Box<MatchExpr>),
+    Select(Box<SelectExpr>),
 
     WithOpacity(WithOpacityExpr),
 
@@ -229,6 +230,7 @@ impl Expr {
             Expr::Exponential(ip) => ip.eval(f, v),
             Expr::CubicBezier(ip) => ip.eval(f, v),
             Expr::Match(m) => m.eval(f, v),
+            Expr::Select(s) => s.eval(f, v),
             Expr::WithOpacity(wo) => wo.eval(f, v),
         }
     }