"geometry-type" to identify Multi- features

src/expression/compound_expression.ts

@@ -461,7 +461,7 @@ CompoundExpression.register(expressions, {
     'filter-type-==': [
         BooleanType,
         [StringType],
-        (ctx, [v]) => ctx.geometryType() === (v as any).value
+        (ctx, [v]) => ctx.geometryDollarType() === (v as any).value
     ],
     'filter-<': [
         BooleanType,
@@ -548,7 +548,7 @@ CompoundExpression.register(expressions, {
     'filter-type-in': [
         BooleanType,
         [array(StringType)],
-        (ctx, [v]) => (v as any).value.indexOf(ctx.geometryType()) >= 0
+        (ctx, [v]) => (v as any).value.indexOf(ctx.geometryDollarType()) >= 0
     ],
     'filter-id-in': [
         BooleanType,

src/expression/definitions/within.ts

@@ -192,9 +192,9 @@ class Within implements Expression {
 
     evaluate(ctx: EvaluationContext) {
         if (ctx.geometry() != null && ctx.canonicalID() != null) {
-            if (ctx.geometryType() === 'Point') {
+            if (ctx.geometryDollarType() === 'Point') {
                 return pointsWithinPolygons(ctx, this.geometries);
-            } else if (ctx.geometryType() === 'LineString') {
+            } else if (ctx.geometryDollarType() === 'LineString') {
                 return linesWithinPolygons(ctx, this.geometries);
             }
         }

src/expression/evaluation_context.ts

@@ -2,8 +2,18 @@ import {Color} from './values';
 import type {FormattedSection} from './types/formatted';
 import type {GlobalProperties, Feature, FeatureState} from './index';
 import {ICanonicalTileID} from '../tiles_and_coordinates';
+import {hasMultipleOuterRings} from '../util/classify_rings';
 
 const geometryTypes = ['Unknown', 'Point', 'LineString', 'Polygon'];
+const simpleGeometryType = {
+    'Unknown': 'Unknown',
+    'Point': 'Point',
+    'MultiPoint': 'Point',
+    'LineString': 'LineString',
+    'MultiLineString': 'LineString',
+    'Polygon': 'Polygon',
+    'MultiPolygon': 'Polygon'
+};
 
 class EvaluationContext {
     globals: GlobalProperties;
@@ -14,6 +24,7 @@ class EvaluationContext {
     canonical: ICanonicalTileID;
 
     _parseColorCache: {[_: string]: Color};
+    _geometryType: string;
 
     constructor() {
         this.globals = null;
@@ -29,8 +40,33 @@ class EvaluationContext {
         return this.feature && 'id' in this.feature ? this.feature.id : null;
     }
 
+    geometryDollarType() {
+        return this.feature ?
+            typeof this.feature.type === 'number' ? geometryTypes[this.feature.type] : simpleGeometryType[this.feature.type] :
+            null;
+    }
+
     geometryType() {
-        return this.feature ? typeof this.feature.type === 'number' ? geometryTypes[this.feature.type] : this.feature.type : null;
+        let geometryType = this.feature.type;
+        if (typeof geometryType !== 'number') {
+            return geometryType;
+        }
+        geometryType = geometryTypes[this.feature.type];
+        if (geometryType === 'Unknown') {
+            return geometryType;
+        }
+        const geom = this.geometry();
+        const len = geom.length;
+        if (len === 1) {
+            return geometryType;
+        }
+        if (geometryType !== 'Polygon') {
+            return `Multi${geometryType}`;
+        }
+        if (hasMultipleOuterRings(geom)) {
+            return 'MultiPolygon';
+        }
+        return 'Polygon';
     }
 
     geometry() {

src/feature_filter/convert.ts

@@ -128,7 +128,7 @@ function runtimeTypeChecks(expectedTypes: ExpectedTypes): ExpressionFilterSpecif
 function convertComparisonOp(property: string, value: any, op: string, expectedTypes?: ExpectedTypes | null): ExpressionFilterSpecification {
     let get;
     if (property === '$type') {
-        return [op, ['geometry-type'], value] as ExpressionFilterSpecification;
+        return convertInOp('$type', [value], op === '!=');
     } else if (property === '$id') {
         get = ['id'];
     } else {
@@ -162,6 +162,10 @@ function convertInOp(property: string, values: Array<any>, negate = false): Expr
 
     let get: ExpressionSpecification;
     if (property === '$type') {
+        const len = values.length;
+        for (let i = 0; i < len; i++) {
+            values.push(`Multi${values[i]}`);
+        }
         get = ['geometry-type'];
     } else if (property === '$id') {
         get = ['id'];

src/feature_filter/feature_filter.test.ts

@@ -249,7 +249,7 @@ describe('convert legacy filters to expressions', () => {
             [
                 'match',
                 ['geometry-type'],
-                ['LineString', 'Point', 'Polygon'],
+                ['LineString', 'MultiLineString', 'MultiPoint', 'MultiPolygon', 'Point', 'Polygon'],
                 true,
                 false
             ],
@@ -328,10 +328,96 @@ function legacyFilterTests(createFilterExpr) {
         expect(f({zoom: 0}, {properties: {}})).toBe(false);
     });
 
-    test('==, $type', () => {
-        const f = createFilterExpr(['==', '$type', 'LineString']).filter;
-        expect(f({zoom: 0}, {type: 1})).toBe(false);
-        expect(f({zoom: 0}, {type: 2})).toBe(true);
+    const UnknownGeometry = {type: 0};
+    const PointGeometry = {type: 1, geometry: [
+        [{x: 0, y: 0}]]};
+    const MultiPointGeometry = {type: 1, geometry: [
+        [{x: 0, y: 0}],
+        [{x: 1, y: 1}]]};
+    const LinestringGeometry = {type: 2, geometry: [
+        [{x: 0, y: 0}, {x: 1, y: 1}]]};
+    const MultiLineStringGeometry = {type: 2, geometry: [
+        [{x: 0, y: 0}, {x: 1, y: 1}],
+        [{x: 2, y: 0}, {x: 1, y: 0}]]};
+    const PolygonGeometry = {type: 3, geometry: [
+        [{x: 0, y: 0}, {x: 3, y: 0}, {x: 3, y: 3}, {x: 0, y: 3}, {x: 0, y: 0}],
+        [{x: 0, y: 0}, {x: 0, y: 2}, {x: 2, y: 2}, {x: 2, y: 0}, {x: 0, y: 0}]]};
+    const MultiPolygonGeometry = {type: 3, geometry: [
+        [{x: 0, y: 0}, {x: 3, y: 0}, {x: 3, y: 3}, {x: 0, y: 3}, {x: 0, y: 0}],
+        [{x: 0, y: 0}, {x: 0, y: 2}, {x: 2, y: 2}, {x: 2, y: 0}, {x: 0, y: 0}],
+        [{x: 0, y: 0}, {x: 1, y: 0}, {x: 1, y: 1}, {x: 0, y: 1}, {x: 0, y: 0}]]};
+
+    test('==, $type, Point', () => {
+        const fPoint = createFilterExpr(['==', '$type', 'Point']).filter;
+        expect(fPoint({zoom: 0}, UnknownGeometry)).toBe(false);
+        expect(fPoint({zoom: 0}, PointGeometry)).toBe(true);
+        expect(fPoint({zoom: 0}, MultiPointGeometry)).toBe(true);
+        expect(fPoint({zoom: 0}, LinestringGeometry)).toBe(false);
+        expect(fPoint({zoom: 0}, MultiLineStringGeometry)).toBe(false);
+        expect(fPoint({zoom: 0}, PolygonGeometry)).toBe(false);
+        expect(fPoint({zoom: 0}, MultiPolygonGeometry)).toBe(false);
+        expect(fPoint({zoom: 0}, {type: 'Unknown'})).toBe(false);
+        expect(fPoint({zoom: 0}, {type: 'Point'})).toBe(true);
+        expect(fPoint({zoom: 0}, {type: 'MultiPoint'})).toBe(true);
+        expect(fPoint({zoom: 0}, {type: 'LineString'})).toBe(false);
+        expect(fPoint({zoom: 0}, {type: 'MultiLineString'})).toBe(false);
+        expect(fPoint({zoom: 0}, {type: 'Polygon'})).toBe(false);
+        expect(fPoint({zoom: 0}, {type: 'MultiPolygon'})).toBe(false);
+    });
+
+    test('==, $type, LineString', () => {
+        const fLineString = createFilterExpr(['==', '$type', 'LineString']).filter;
+        expect(fLineString({zoom: 0}, UnknownGeometry)).toBe(false);
+        expect(fLineString({zoom: 0}, PointGeometry)).toBe(false);
+        expect(fLineString({zoom: 0}, MultiPointGeometry)).toBe(false);
+        expect(fLineString({zoom: 0}, LinestringGeometry)).toBe(true);
+        expect(fLineString({zoom: 0}, MultiLineStringGeometry)).toBe(true);
+        expect(fLineString({zoom: 0}, PolygonGeometry)).toBe(false);
+        expect(fLineString({zoom: 0}, MultiPolygonGeometry)).toBe(false);
+        expect(fLineString({zoom: 0}, {type: 'Unknown'})).toBe(false);
+        expect(fLineString({zoom: 0}, {type: 'Point'})).toBe(false);
+        expect(fLineString({zoom: 0}, {type: 'MultiPoint'})).toBe(false);
+        expect(fLineString({zoom: 0}, {type: 'LineString'})).toBe(true);
+        expect(fLineString({zoom: 0}, {type: 'MultiLineString'})).toBe(true);
+        expect(fLineString({zoom: 0}, {type: 'Polygon'})).toBe(false);
+        expect(fLineString({zoom: 0}, {type: 'MultiPolygon'})).toBe(false);
+    });
+
+    test('==, $type, Polygon', () => {
+
+        const fPolygon = createFilterExpr(['==', '$type', 'Polygon']).filter;
+        expect(fPolygon({zoom: 0}, UnknownGeometry)).toBe(false);
+        expect(fPolygon({zoom: 0}, PointGeometry)).toBe(false);
+        expect(fPolygon({zoom: 0}, MultiPointGeometry)).toBe(false);
+        expect(fPolygon({zoom: 0}, LinestringGeometry)).toBe(false);
+        expect(fPolygon({zoom: 0}, MultiLineStringGeometry)).toBe(false);
+        expect(fPolygon({zoom: 0}, PolygonGeometry)).toBe(true);
+        expect(fPolygon({zoom: 0}, MultiPolygonGeometry)).toBe(true);
+        expect(fPolygon({zoom: 0}, {type: 'Unknown'})).toBe(false);
+        expect(fPolygon({zoom: 0}, {type: 'Point'})).toBe(false);
+        expect(fPolygon({zoom: 0}, {type: 'MultiPoint'})).toBe(false);
+        expect(fPolygon({zoom: 0}, {type: 'LineString'})).toBe(false);
+        expect(fPolygon({zoom: 0}, {type: 'MultiLineString'})).toBe(false);
+        expect(fPolygon({zoom: 0}, {type: 'Polygon'})).toBe(true);
+        expect(fPolygon({zoom: 0}, {type: 'MultiPolygon'})).toBe(true);
+    });
+
+    test('==, $type, Unknown', () => {
+        const fUnknown = createFilterExpr(['==', '$type', 'Unknown']).filter;
+        expect(fUnknown({zoom: 0}, UnknownGeometry)).toBe(true);
+        expect(fUnknown({zoom: 0}, PointGeometry)).toBe(false);
+        expect(fUnknown({zoom: 0}, MultiPointGeometry)).toBe(false);
+        expect(fUnknown({zoom: 0}, LinestringGeometry)).toBe(false);
+        expect(fUnknown({zoom: 0}, MultiLineStringGeometry)).toBe(false);
+        expect(fUnknown({zoom: 0}, PolygonGeometry)).toBe(false);
+        expect(fUnknown({zoom: 0}, MultiPolygonGeometry)).toBe(false);
+        expect(fUnknown({zoom: 0}, {type: 'Unknown'})).toBe(true);
+        expect(fUnknown({zoom: 0}, {type: 'Point'})).toBe(false);
+        expect(fUnknown({zoom: 0}, {type: 'MultiPoint'})).toBe(false);
+        expect(fUnknown({zoom: 0}, {type: 'LineString'})).toBe(false);
+        expect(fUnknown({zoom: 0}, {type: 'MultiLineString'})).toBe(false);
+        expect(fUnknown({zoom: 0}, {type: 'Polygon'})).toBe(false);
+        expect(fUnknown({zoom: 0}, {type: 'MultiPolygon'})).toBe(false);
     });
 
     test('==, $id', () => {
@@ -373,10 +459,76 @@ function legacyFilterTests(createFilterExpr) {
         expect(f({zoom: 0}, {properties: {}})).toBe(true);
     });
 
-    test('!=, $type', () => {
-        const f = createFilterExpr(['!=', '$type', 'LineString']).filter;
-        expect(f({zoom: 0}, {type: 1})).toBe(true);
-        expect(f({zoom: 0}, {type: 2})).toBe(false);
+    test('!=, $type, Point', () => {
+        const fPoint = createFilterExpr(['!=', '$type', 'Point']).filter;
+        expect(fPoint({zoom: 0}, UnknownGeometry)).toBe(true);
+        expect(fPoint({zoom: 0}, PointGeometry)).toBe(false);
+        expect(fPoint({zoom: 0}, MultiPointGeometry)).toBe(false);
+        expect(fPoint({zoom: 0}, LinestringGeometry)).toBe(true);
+        expect(fPoint({zoom: 0}, MultiLineStringGeometry)).toBe(true);
+        expect(fPoint({zoom: 0}, PolygonGeometry)).toBe(true);
+        expect(fPoint({zoom: 0}, MultiPolygonGeometry)).toBe(true);
+        expect(fPoint({zoom: 0}, {type: 'Unknown'})).toBe(true);
+        expect(fPoint({zoom: 0}, {type: 'Point'})).toBe(false);
+        expect(fPoint({zoom: 0}, {type: 'MultiPoint'})).toBe(false);
+        expect(fPoint({zoom: 0}, {type: 'LineString'})).toBe(true);
+        expect(fPoint({zoom: 0}, {type: 'MultiLineString'})).toBe(true);
+        expect(fPoint({zoom: 0}, {type: 'Polygon'})).toBe(true);
+        expect(fPoint({zoom: 0}, {type: 'MultiPolygon'})).toBe(true);
+    });
+
+    test('!=, $type, LineString', () => {
+        const fLineString = createFilterExpr(['!=', '$type', 'LineString']).filter;
+        expect(fLineString({zoom: 0}, UnknownGeometry)).toBe(true);
+        expect(fLineString({zoom: 0}, PointGeometry)).toBe(true);
+        expect(fLineString({zoom: 0}, MultiPointGeometry)).toBe(true);
+        expect(fLineString({zoom: 0}, LinestringGeometry)).toBe(false);
+        expect(fLineString({zoom: 0}, MultiLineStringGeometry)).toBe(false);
+        expect(fLineString({zoom: 0}, PolygonGeometry)).toBe(true);
+        expect(fLineString({zoom: 0}, MultiPolygonGeometry)).toBe(true);
+        expect(fLineString({zoom: 0}, {type: 'Unknown'})).toBe(true);
+        expect(fLineString({zoom: 0}, {type: 'Point'})).toBe(true);
+        expect(fLineString({zoom: 0}, {type: 'MultiPoint'})).toBe(true);
+        expect(fLineString({zoom: 0}, {type: 'LineString'})).toBe(false);
+        expect(fLineString({zoom: 0}, {type: 'MultiLineString'})).toBe(false);
+        expect(fLineString({zoom: 0}, {type: 'Polygon'})).toBe(true);
+        expect(fLineString({zoom: 0}, {type: 'MultiPolygon'})).toBe(true);
+    });
+
+    test('!=, $type, Polygon', () => {
+        const fPolygon = createFilterExpr(['!=', '$type', 'Polygon']).filter;
+        expect(fPolygon({zoom: 0}, UnknownGeometry)).toBe(true);
+        expect(fPolygon({zoom: 0}, PointGeometry)).toBe(true);
+        expect(fPolygon({zoom: 0}, MultiPointGeometry)).toBe(true);
+        expect(fPolygon({zoom: 0}, LinestringGeometry)).toBe(true);
+        expect(fPolygon({zoom: 0}, MultiLineStringGeometry)).toBe(true);
+        expect(fPolygon({zoom: 0}, PolygonGeometry)).toBe(false);
+        expect(fPolygon({zoom: 0}, MultiPolygonGeometry)).toBe(false);
+        expect(fPolygon({zoom: 0}, {type: 'Unknown'})).toBe(true);
+        expect(fPolygon({zoom: 0}, {type: 'Point'})).toBe(true);
+        expect(fPolygon({zoom: 0}, {type: 'MultiPoint'})).toBe(true);
+        expect(fPolygon({zoom: 0}, {type: 'LineString'})).toBe(true);
+        expect(fPolygon({zoom: 0}, {type: 'MultiLineString'})).toBe(true);
+        expect(fPolygon({zoom: 0}, {type: 'Polygon'})).toBe(false);
+        expect(fPolygon({zoom: 0}, {type: 'MultiPolygon'})).toBe(false);
+    });
+
+    test('!=, $type, Unknown', () => {
+        const fUnknown = createFilterExpr(['!=', '$type', 'Unknown']).filter;
+        expect(fUnknown({zoom: 0}, UnknownGeometry)).toBe(false);
+        expect(fUnknown({zoom: 0}, PointGeometry)).toBe(true);
+        expect(fUnknown({zoom: 0}, MultiPointGeometry)).toBe(true);
+        expect(fUnknown({zoom: 0}, LinestringGeometry)).toBe(true);
+        expect(fUnknown({zoom: 0}, MultiLineStringGeometry)).toBe(true);
+        expect(fUnknown({zoom: 0}, PolygonGeometry)).toBe(true);
+        expect(fUnknown({zoom: 0}, MultiPolygonGeometry)).toBe(true);
+        expect(fUnknown({zoom: 0}, {type: 'Unknown'})).toBe(false);
+        expect(fUnknown({zoom: 0}, {type: 'Point'})).toBe(true);
+        expect(fUnknown({zoom: 0}, {type: 'MultiPoint'})).toBe(true);
+        expect(fUnknown({zoom: 0}, {type: 'LineString'})).toBe(true);
+        expect(fUnknown({zoom: 0}, {type: 'MultiLineString'})).toBe(true);
+        expect(fUnknown({zoom: 0}, {type: 'Polygon'})).toBe(true);
+        expect(fUnknown({zoom: 0}, {type: 'MultiPolygon'})).toBe(true);
     });
 
     test('<, number', () => {
@@ -563,15 +715,22 @@ function legacyFilterTests(createFilterExpr) {
 
     test('in, $type', () => {
         const f = createFilterExpr(['in', '$type', 'LineString', 'Polygon']).filter;
-        expect(f({zoom: 0}, {type: 1})).toBe(false);
-        expect(f({zoom: 0}, {type: 2})).toBe(true);
-        expect(f({zoom: 0}, {type: 3})).toBe(true);
+        expect(f({zoom: 0}, {type: 'Unknown'})).toBe(false);
+        expect(f({zoom: 0}, {type: 'Point'})).toBe(false);
+        expect(f({zoom: 0}, {type: 'MultiPoint'})).toBe(false);
+        expect(f({zoom: 0}, {type: 'LineString'})).toBe(true);
+        expect(f({zoom: 0}, {type: 'MultiLineString'})).toBe(true);
+        expect(f({zoom: 0}, {type: 'Polygon'})).toBe(true);
+        expect(f({zoom: 0}, {type: 'MultiPolygon'})).toBe(true);
 
         const f1 = createFilterExpr(['in', '$type', 'Polygon', 'LineString', 'Point']).filter;
-        expect(f1({zoom: 0}, {type: 1})).toBe(true);
-        expect(f1({zoom: 0}, {type: 2})).toBe(true);
-        expect(f1({zoom: 0}, {type: 3})).toBe(true);
-
+        expect(f1({zoom: 0}, {type: 'Unknown'})).toBe(false);
+        expect(f1({zoom: 0}, {type: 'Point'})).toBe(true);
+        expect(f1({zoom: 0}, {type: 'MultiPoint'})).toBe(true);
+        expect(f1({zoom: 0}, {type: 'LineString'})).toBe(true);
+        expect(f1({zoom: 0}, {type: 'MultiLineString'})).toBe(true);
+        expect(f1({zoom: 0}, {type: 'Polygon'})).toBe(true);
+        expect(f1({zoom: 0}, {type: 'MultiPolygon'})).toBe(true);
     });
 
     test('!in, degenerate', () => {
@@ -621,9 +780,22 @@ function legacyFilterTests(createFilterExpr) {
 
     test('!in, $type', () => {
         const f = createFilterExpr(['!in', '$type', 'LineString', 'Polygon']).filter;
-        expect(f({zoom: 0}, {type: 1})).toBe(true);
-        expect(f({zoom: 0}, {type: 2})).toBe(false);
-        expect(f({zoom: 0}, {type: 3})).toBe(false);
+        expect(f({zoom: 0}, {type: 'Unknown'})).toBe(true);
+        expect(f({zoom: 0}, {type: 'Point'})).toBe(true);
+        expect(f({zoom: 0}, {type: 'MultiPoint'})).toBe(true);
+        expect(f({zoom: 0}, {type: 'LineString'})).toBe(false);
+        expect(f({zoom: 0}, {type: 'MultiLineString'})).toBe(false);
+        expect(f({zoom: 0}, {type: 'Polygon'})).toBe(false);
+        expect(f({zoom: 0}, {type: 'MultiPolygon'})).toBe(false);
+
+        const f1 = createFilterExpr(['!in', '$type', 'Polygon', 'LineString', 'Point']).filter;
+        expect(f1({zoom: 0}, {type: 'Unknown'})).toBe(true);
+        expect(f1({zoom: 0}, {type: 'Point'})).toBe(false);
+        expect(f1({zoom: 0}, {type: 'MultiPoint'})).toBe(false);
+        expect(f1({zoom: 0}, {type: 'LineString'})).toBe(false);
+        expect(f1({zoom: 0}, {type: 'MultiLineString'})).toBe(false);
+        expect(f1({zoom: 0}, {type: 'Polygon'})).toBe(false);
+        expect(f1({zoom: 0}, {type: 'MultiPolygon'})).toBe(false);
     });
 
     test('any', () => {

src/util/classify_rings.ts

@@ -69,3 +69,27 @@ function calculateSignedArea(ring: Point2D[]): number {
     }
     return sum;
 }
+
+/**
+ * Returns if there are multiple outer rings.
+ * The first ring is a outer ring. Its direction, cw or ccw, defines the direction of outer rings.
+ *
+ * @param rings - List of rings
+ * @returns Are there multiple outer rings
+ */
+export function hasMultipleOuterRings(rings: Point2D[][]): boolean {
+    // Following https://github.com/mapbox/vector-tile-js/blob/77851380b63b07fd0af3d5a3f144cc86fb39fdd1/lib/vectortilefeature.js#L197
+    const len = rings.length;
+    for (let i = 0, direction; i < len; i++) {
+        const area = calculateSignedArea(rings[i]);
+        if (area === 0) continue;
+        if (direction === undefined) {
+            // Keep the direction of the first ring
+            direction = area < 0;
+        } else if (direction === area < 0) {
+            // Same direction as the first ring -> a second outer ring
+            return true;
+        }
+    }
+    return false;
+}