Enable Within Expression with paint property + Filter Expression

CMakeLists.txt

@@ -188,6 +188,7 @@ add_library(
     ${PROJECT_SOURCE_DIR}/include/mbgl/style/expression/step.hpp
     ${PROJECT_SOURCE_DIR}/include/mbgl/style/expression/type.hpp
     ${PROJECT_SOURCE_DIR}/include/mbgl/style/expression/value.hpp
+    ${PROJECT_SOURCE_DIR}/include/mbgl/style/expression/within.hpp
     ${PROJECT_SOURCE_DIR}/include/mbgl/style/filter.hpp
     ${PROJECT_SOURCE_DIR}/include/mbgl/style/image.hpp
     ${PROJECT_SOURCE_DIR}/include/mbgl/style/layer.hpp
@@ -578,6 +579,7 @@ add_library(
     ${PROJECT_SOURCE_DIR}/src/mbgl/style/expression/util.cpp
     ${PROJECT_SOURCE_DIR}/src/mbgl/style/expression/util.hpp
     ${PROJECT_SOURCE_DIR}/src/mbgl/style/expression/value.cpp
+    ${PROJECT_SOURCE_DIR}/src/mbgl/style/expression/within.cpp
     ${PROJECT_SOURCE_DIR}/src/mbgl/style/filter.cpp
     ${PROJECT_SOURCE_DIR}/src/mbgl/style/image.cpp
     ${PROJECT_SOURCE_DIR}/src/mbgl/style/image_impl.cpp

expression-test/expression_test_parser.cpp

@@ -14,6 +14,8 @@
 
 #include <args.hxx>
 
+#include <regex>
+
 using namespace mbgl;
 using namespace mbgl::style;
 using namespace mbgl::style::conversion;
@@ -254,6 +256,18 @@ bool parseInputs(const JSValue& inputsValue, TestData& data) {
             heatmapDensity = evaluationContext["heatmapDensity"].GetDouble();
         }
 
+        // Parse canonicalID
+        optional<CanonicalTileID> canonical;
+        if (evaluationContext.HasMember("canonicalID")) {
+            const auto& canonicalIDObject = evaluationContext["canonicalID"];
+            assert(canonicalIDObject.IsObject());
+            assert(canonicalIDObject.HasMember("z") && canonicalIDObject["z"].IsNumber());
+            assert(canonicalIDObject.HasMember("x") && canonicalIDObject["x"].IsNumber());
+            assert(canonicalIDObject.HasMember("y") && canonicalIDObject["y"].IsNumber());
+            canonical = CanonicalTileID(
+                canonicalIDObject["z"].GetUint(), canonicalIDObject["x"].GetUint(), canonicalIDObject["y"].GetUint());
+        }
+
         // Parse availableImages
         std::set<std::string> availableImages;
         if (evaluationContext.HasMember("availableImages")) {
@@ -282,8 +296,11 @@ bool parseInputs(const JSValue& inputsValue, TestData& data) {
             feature.id = mapbox::geojson::convert<mapbox::feature::identifier>(featureObject["id"]);
         }
 
-        data.inputs.emplace_back(
-            std::move(zoom), std::move(heatmapDensity), std::move(availableImages), std::move(feature));
+        data.inputs.emplace_back(std::move(zoom),
+                                 std::move(heatmapDensity),
+                                 std::move(canonical),
+                                 std::move(availableImages),
+                                 std::move(feature));
     }
     return true;
 }
@@ -294,11 +311,11 @@ std::tuple<filesystem::path, std::vector<filesystem::path>, bool, uint32_t> pars
     args::ArgumentParser argumentParser("Mapbox GL Expression Test Runner");
 
     args::HelpFlag helpFlag(argumentParser, "help", "Display this help menu", { 'h', "help" });
-    args::Flag shuffleFlag(argumentParser, "shuffle", "Toggle shuffling the tests order",
-                           { 's', "shuffle" });
+    args::Flag shuffleFlag(argumentParser, "shuffle", "Toggle shuffling the tests order", {'s', "shuffle"});
     args::ValueFlag<uint32_t> seedValue(argumentParser, "seed", "Shuffle seed (default: random)",
                                         { "seed" });
     args::PositionalList<std::string> testNameValues(argumentParser, "URL", "Test name(s)");
+    args::ValueFlag<std::string> testFilterValue(argumentParser, "filter", "Test filter regex", {'f', "filter"});
 
     try {
         argumentParser.ParseCLI(argc, argv);
@@ -336,6 +353,7 @@ std::tuple<filesystem::path, std::vector<filesystem::path>, bool, uint32_t> pars
         paths.emplace_back(rootPath);
     }
 
+    auto testFilter = testFilterValue ? args::get(testFilterValue) : std::string{};
     // Recursively traverse through the test paths and collect test directories containing "test.json".
     std::vector<filesystem::path> testPaths;
     testPaths.reserve(paths.size());
@@ -346,6 +364,9 @@ std::tuple<filesystem::path, std::vector<filesystem::path>, bool, uint32_t> pars
         }
 
         for (auto& testPath : filesystem::recursive_directory_iterator(path)) {
+            if (!testFilter.empty() && !std::regex_search(testPath.path().string(), std::regex(testFilter))) {
+                continue;
+            }
             if (testPath.path().filename() == "test.json") {
                 testPaths.emplace_back(testPath.path());
             }

expression-test/expression_test_parser.hpp

@@ -16,14 +16,17 @@ using namespace mbgl;
 struct Input {
     Input(optional<float> zoom_,
           optional<double> heatmapDensity_,
+          optional<CanonicalTileID> canonical_,
           std::set<std::string> availableImages_,
           Feature feature_)
         : zoom(std::move(zoom_)),
           heatmapDensity(std::move(heatmapDensity_)),
+          canonical(std::move(canonical_)),
           availableImages(std::move(availableImages_)),
           feature(std::move(feature_)) {}
     optional<float> zoom;
     optional<double> heatmapDensity;
+    optional<CanonicalTileID> canonical;
     std::set<std::string> availableImages;
     Feature feature;
 };

expression-test/expression_test_runner.cpp

@@ -104,8 +104,14 @@ TestRunOutput runExpressionTest(TestData& data, const std::string& rootPath, con
         std::vector<Value> outputs;
         if (!data.inputs.empty()) {
             for (const auto& input : data.inputs) {
-                auto evaluationResult =
-                    expression->evaluate(input.zoom, input.feature, input.heatmapDensity, input.availableImages);
+                mbgl::style::expression::EvaluationResult evaluationResult;
+                if (input.canonical) {
+                    evaluationResult = expression->evaluate(
+                        input.zoom, input.feature, input.heatmapDensity, input.availableImages, *input.canonical);
+                } else {
+                    evaluationResult =
+                        expression->evaluate(input.zoom, input.feature, input.heatmapDensity, input.availableImages);
+                }
                 if (!evaluationResult) {
                     std::unordered_map<std::string, Value> error{{"error", Value{evaluationResult.error().message}}};
                     outputs.emplace_back(Value{std::move(error)});

include/mbgl/style/expression/expression.hpp

@@ -1,11 +1,12 @@
 #pragma once
 
-#include <mbgl/util/optional.hpp>
-#include <mbgl/util/variant.hpp>
-#include <mbgl/util/color.hpp>
+#include <mbgl/style/expression/parsing_context.hpp>
 #include <mbgl/style/expression/type.hpp>
 #include <mbgl/style/expression/value.hpp>
-#include <mbgl/style/expression/parsing_context.hpp>
+#include <mbgl/tile/tile_id.hpp>
+#include <mbgl/util/color.hpp>
+#include <mbgl/util/optional.hpp>
+#include <mbgl/util/variant.hpp>
 
 #include <array>
 #include <vector>
@@ -53,14 +54,20 @@ class EvaluationContext {
         return *this;
     };
 
+    EvaluationContext& withCanonicalTileID(const mbgl::CanonicalTileID* canonical_) noexcept {
+        canonical = canonical_;
+        return *this;
+    };
+
     optional<float> zoom;
     optional<mbgl::Value> accumulated;
-    GeometryTileFeature const * feature = nullptr;
+    GeometryTileFeature const* feature = nullptr;
     optional<double> colorRampParameter;
     // Contains formatted section object, std::unordered_map<std::string, Value>.
     const Value* formattedSection = nullptr;
     const FeatureState* featureState = nullptr;
     const std::set<std::string>* availableImages = nullptr;
+    const mbgl::CanonicalTileID* canonical = nullptr;
 };
 
 template <typename T>
@@ -160,7 +167,8 @@ enum class Kind : int32_t {
     FormatExpression,
     FormatSectionOverride,
     NumberFormat,
-    ImageExpression
+    ImageExpression,
+    Within
 };
 
 class Expression {
@@ -183,6 +191,11 @@ class Expression {
                               const Feature& feature,
                               optional<double> colorRampParameter,
                               const std::set<std::string>& availableImages) const;
+    EvaluationResult evaluate(optional<float> zoom,
+                              const Feature& feature,
+                              optional<double> colorRampParameter,
+                              const std::set<std::string>& availableImages,
+                              const CanonicalTileID& canonical) const;
     EvaluationResult evaluate(optional<mbgl::Value> accumulated, const Feature& feature) const;
 
     /**

include/mbgl/style/expression/within.hpp

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <mbgl/style/conversion.hpp>
+#include <mbgl/style/expression/expression.hpp>
+#include <mbgl/style/expression/parsing_context.hpp>
+#include <mbgl/util/geojson.hpp>
+
+#include <memory>
+
+namespace mbgl {
+namespace style {
+namespace expression {
+
+class Within final : public Expression {
+public:
+    explicit Within(GeoJSON geojson);
+
+    ~Within() override;
+
+    EvaluationResult evaluate(const EvaluationContext&) const override;
+
+    static ParseResult parse(const mbgl::style::conversion::Convertible&, ParsingContext&);
+
+    void eachChild(const std::function<void(const Expression&)>&) const override {}
+
+    bool operator==(const Expression& e) const override {
+        if (e.getKind() == Kind::Within) {
+            auto rhs = static_cast<const Within*>(&e);
+            return geoJSONSource == rhs->geoJSONSource;
+        }
+        return false;
+    }
+
+    std::vector<optional<Value>> possibleOutputs() const override { return {{true}, {false}}; }
+
+    mbgl::Value serialize() const override;
+    std::string getOperator() const override { return "within"; }
+
+private:
+    GeoJSON geoJSONSource;
+};
+
+} // namespace expression
+} // namespace style
+} // namespace mbgl

metrics/android-render-test-runner/render-tests/within/filter-with-inlined-geojson/metrics.json

@@ -0,0 +1,35 @@
+{
+    "network": [
+        [
+            "probeNetwork - default - end",
+            0,
+            0
+        ],
+        [
+            "probeNetwork - default - start",
+            0,
+            0
+        ]
+    ],
+    "gfx": [
+        [
+            "probeGFX - default - end",
+            4,
+            4,
+            10,
+            1,
+            [
+                49152,
+                49152
+            ],
+            [
+                66,
+                66
+            ],
+            [
+                100,
+                100
+            ]
+        ]
+    ]
+}

metrics/android-render-test-runner/render-tests/within/paint-circle/metrics.json

@@ -0,0 +1,35 @@
+{
+    "network": [
+        [
+            "probeNetwork - default - end",
+            0,
+            0
+        ],
+        [
+            "probeNetwork - default - start",
+            0,
+            0
+        ]
+    ],
+    "gfx": [
+        [
+            "probeGFX - default - end",
+            16,
+            13,
+            29,
+            1,
+            [
+                196608,
+                196608
+            ],
+            [
+                246,
+                246
+            ],
+            [
+                528,
+                528
+            ]
+        ]
+    ]
+}

metrics/android-render-test-runner/render-tests/within/paint-icon/metrics.json

@@ -0,0 +1,35 @@
+{
+    "network": [
+        [
+            "probeNetwork - default - end",
+            2,
+            211659
+        ],
+        [
+            "probeNetwork - default - start",
+            0,
+            0
+        ]
+    ],
+    "gfx": [
+        [
+            "probeGFX - default - end",
+            13,
+            17,
+            22,
+            1,
+            [
+                154848,
+                154848
+            ],
+            [
+                174,
+                174
+            ],
+            [
+                528,
+                528
+            ]
+        ]
+    ]
+}

metrics/android-render-test-runner/render-tests/within/paint-text/metrics.json

@@ -0,0 +1,35 @@
+{
+    "network": [
+        [
+            "probeNetwork - default - end",
+            1,
+            84942
+        ],
+        [
+            "probeNetwork - default - start",
+            0,
+            0
+        ]
+    ],
+    "gfx": [
+        [
+            "probeGFX - default - end",
+            13,
+            17,
+            22,
+            1,
+            [
+                207700,
+                207700
+            ],
+            [
+                246,
+                246
+            ],
+            [
+                1680,
+                1680
+            ]
+        ]
+    ]
+}

metrics/binary-size/android-arm64-v8a/metrics.json

@@ -3,7 +3,7 @@
         [
             "android-arm64-v8a",
             "/tmp/attach/install/android-arm64-v8a-release/lib/libmapbox-gl.so",
-            1930061
+            1952143
         ]
     ]
 }

metrics/binary-size/android-armeabi-v7a/metrics.json

@@ -3,7 +3,7 @@
         [
             "android-armeabi-v7a",
             "/tmp/attach/install/android-armeabi-v7a-release/lib/libmapbox-gl.so",
-            1643552
+            1647895
         ]
     ]
 }