@maplibre/geojson-vt 5.0.4 → 6.0.0

package/src/clip.ts

@@ -1,110 +1,78 @@
 
 import {createFeature} from './feature';
-import type { GeoJSONVTInternalFeature, GeoJSONVTOptions, StartEndSizeArray } from './definitions';
+import type { GeoJSONVTInternalFeature, GeoJSONVTInternalLineStringFeature, GeoJSONVTInternalMultiLineStringFeature, GeoJSONVTInternalMultiPointFeature, GeoJSONVTInternalMultiPolygonFeature, GeoJSONVTInternalPointFeature, GeoJSONVTInternalPolygonFeature, GeoJSONVTOptions, StartEndSizeArray } from './definitions';
 
-/* clip features between two vertical or horizontal axis-parallel lines:
+export const enum AxisType {
+    X = 0,
+    Y = 1
+}
+
+/** 
+ * clip features between two vertical or horizontal axis-parallel lines:
  *     |        |
  *  ___|___     |     /
  * /   |   \____|____/
  *     |        |
  *
- * k1 and k2 are the line coordinates
- * axis: 0 for x, 1 for y
- * minAll and maxAll: minimum and maximum coordinate value for all features
+ * @param features - the features to clip
+ * @param scale - the scale to divide start and end inputs
+ * @param start - the start of the clip range
+ * @param end - the end of the clip range
+ * @param axis - which axis to clip against
+ * @param minAll - the minimum for all features in the relevant axis
+ * @param maxAll - the maximum for all features in the relevant axis
  */
-export function clip(features: GeoJSONVTInternalFeature[], scale: number, k1: number, k2: number, axis: number, minAll: number, maxAll: number, options: GeoJSONVTOptions): GeoJSONVTInternalFeature[] | null {
-    k1 /= scale;
-    k2 /= scale;
+export function clip(features: GeoJSONVTInternalFeature[], scale: number, start: number, end: number, axis: AxisType, minAll: number, maxAll: number, options: GeoJSONVTOptions): GeoJSONVTInternalFeature[] | null {
+    start /= scale;
+    end /= scale;
 
-    if (minAll >= k1 && maxAll < k2) { // trivial accept
+    if (minAll >= start && maxAll < end) { // trivial accept
         return features;
     }
 
-    if (maxAll < k1 || minAll >= k2) { // trivial reject
+    if (maxAll < start || minAll >= end) { // trivial reject
         return null;
     }
 
     const clipped: GeoJSONVTInternalFeature[] = [];
 
     for (const feature of features) {
-        const min = axis === 0 ? feature.minX : feature.minY;
-        const max = axis === 0 ? feature.maxX : feature.maxY;
+        const min = axis === AxisType.X ? feature.minX : feature.minY;
+        const max = axis === AxisType.X ? feature.maxX : feature.maxY;
 
-        if (min >= k1 && max < k2) { // trivial accept
+        if (min >= start && max < end) { // trivial accept
             clipped.push(feature);
             continue;
         }
 
-        if (max < k1 || min >= k2) { // trivial reject
+        if (max < start || min >= end) { // trivial reject
             continue;
         }
 
         switch (feature.type) {
             case 'Point':
             case 'MultiPoint': {
-                const pointGeometry: number[] = [];
-                clipPoints(feature.geometry, pointGeometry, k1, k2, axis);
-                if (!pointGeometry.length) continue;
-
-                const type = pointGeometry.length === 3 ? 'Point' : 'MultiPoint';
-                clipped.push(createFeature(feature.id, type, pointGeometry, feature.tags));
+                clipPointFeature(feature, clipped, start, end, axis);
                 continue;
             }
 
             case 'LineString': {
-                const lineGeometry: StartEndSizeArray[] = [];
-                clipLine(feature.geometry, lineGeometry, k1, k2, axis, false, options.lineMetrics);
-                if (!lineGeometry.length) continue;
-
-                if (options.lineMetrics) {
-                    for (const line of lineGeometry) {
-                        clipped.push(createFeature(feature.id, feature.type, line, feature.tags));
-                    }
-                    continue;
-                }
-
-                if (lineGeometry.length > 1) {
-                    clipped.push(createFeature(feature.id, "MultiLineString", lineGeometry, feature.tags));
-                    continue;
-                }
-
-                clipped.push(createFeature(feature.id, feature.type, lineGeometry[0], feature.tags));
+                clipLineStringFeature(feature, clipped, start, end, axis, options);
                 continue;
             }
 
             case 'MultiLineString': {
-                const multiLineGeometry: StartEndSizeArray[] = [];
-                clipLines(feature.geometry, multiLineGeometry, k1, k2, axis, false);
-                if (!multiLineGeometry.length) continue;
-
-                if (multiLineGeometry.length === 1) {
-                    clipped.push(createFeature(feature.id, "LineString", multiLineGeometry[0], feature.tags));
-                    continue;
-                }
-
-                clipped.push(createFeature(feature.id, feature.type, multiLineGeometry, feature.tags));
+                clipMultiLineStringFeature(feature, clipped, start, end, axis);
                 continue;
             }
 
             case 'Polygon': {
-                const polygonGeometry: StartEndSizeArray[] = [];
-                clipLines(feature.geometry, polygonGeometry, k1, k2, axis, true);
-                if (!polygonGeometry.length) continue;
-
-                clipped.push(createFeature(feature.id, feature.type, polygonGeometry, feature.tags));
+                clipPolygonFeature(feature, clipped, start, end, axis);
                 continue;
             }
 
             case 'MultiPolygon': {
-                const multiPolygonGeometry: StartEndSizeArray[][] = [];
-                for (const polygon of feature.geometry) {
-                    const newPolygon: StartEndSizeArray[] = [];
-                    clipLines(polygon, newPolygon, k1, k2, axis, true);
-                    if (newPolygon.length) multiPolygonGeometry.push(newPolygon);
-                }
-                if (!multiPolygonGeometry.length) continue;
-
-                clipped.push(createFeature(feature.id, feature.type, multiPolygonGeometry, feature.tags));
+                clipMultiPolygonFeature(feature, clipped, start, end, axis);
                 continue;
             }
         }
@@ -115,20 +83,90 @@ export function clip(features: GeoJSONVTInternalFeature[], scale: number, k1: nu
     return clipped;
 }
 
-function clipPoints(geom: number[], newGeom: number[], k1: number, k2: number, axis: number) {
+function clipPointFeature(feature: GeoJSONVTInternalPointFeature | GeoJSONVTInternalMultiPointFeature, clipped: GeoJSONVTInternalFeature[], start: number, end: number, axis: AxisType) {
+    const geom: number[] = [];
+
+    clipPoints(feature.geometry, geom, start, end, axis);
+    if (!geom.length) return;
+
+    const type = geom.length === 3 ? 'Point' : 'MultiPoint';
+    clipped.push(createFeature(feature.id, type, geom, feature.tags));
+}
+
+function clipLineStringFeature(feature: GeoJSONVTInternalLineStringFeature, clipped: GeoJSONVTInternalFeature[], start: number, end: number, axis: AxisType, options: GeoJSONVTOptions) {
+    const geom: StartEndSizeArray[] = [];
+
+    clipLine(feature.geometry, geom, start, end, axis, false, options.lineMetrics);
+    if (!geom.length) return;
+
+    if (options.lineMetrics) {
+        for (const line of geom) {
+            clipped.push(createFeature(feature.id, 'LineString', line, feature.tags));
+        }
+        return;
+    }
+
+    if (geom.length > 1) {
+        clipped.push(createFeature(feature.id, 'MultiLineString', geom, feature.tags));
+        return;
+    }
+
+    clipped.push(createFeature(feature.id, 'LineString', geom[0], feature.tags));
+}
+
+function clipMultiLineStringFeature(feature: GeoJSONVTInternalMultiLineStringFeature, clipped: GeoJSONVTInternalFeature[], start: number, end: number, axis: AxisType) {
+    const geom: StartEndSizeArray[] = [];
+
+    clipLines(feature.geometry, geom, start, end, axis, false);
+    if (!geom.length) return;
+
+    if (geom.length === 1) {
+        clipped.push(createFeature(feature.id, 'LineString', geom[0], feature.tags));
+        return;
+    }
+
+    clipped.push(createFeature(feature.id,'MultiLineString', geom, feature.tags));
+}
+
+function clipPolygonFeature(feature: GeoJSONVTInternalPolygonFeature, clipped: GeoJSONVTInternalFeature[], start: number, end: number, axis: AxisType) {
+    const geom: StartEndSizeArray[] = [];
+
+    clipLines(feature.geometry, geom, start, end, axis, true);
+    if (!geom.length) return;
+
+    clipped.push(createFeature(feature.id, 'Polygon', geom, feature.tags));
+}
+
+function clipMultiPolygonFeature(feature: GeoJSONVTInternalMultiPolygonFeature, clipped: GeoJSONVTInternalFeature[], start: number, end: number, axis: AxisType) {
+    const geom: StartEndSizeArray[][] = [];
+
+    for (const polygon of feature.geometry) {
+        const newPolygon: StartEndSizeArray[] = [];
+
+        clipLines(polygon, newPolygon, start, end, axis, true);
+        if (!newPolygon.length) continue;
+
+        geom.push(newPolygon);
+    }
+    if (!geom.length) return;
+
+    clipped.push(createFeature(feature.id, 'MultiPolygon', geom, feature.tags));
+}
+
+function clipPoints(geom: number[], newGeom: number[], start: number, end: number, axis: AxisType) {
     for (let i = 0; i < geom.length; i += 3) {
         const a = geom[i + axis];
 
-        if (a >= k1 && a <= k2) {
+        if (a >= start && a <= end) {
             addPoint(newGeom, geom[i], geom[i + 1], geom[i + 2]);
         }
     }
 }
 
-function clipLine(geom: StartEndSizeArray, newGeom: StartEndSizeArray[], k1: number, k2: number, axis: number, isPolygon: boolean, trackMetrics: boolean) {
+function clipLine(geom: StartEndSizeArray, newGeom: StartEndSizeArray[], start: number, end: number, axis: AxisType, isPolygon: boolean, trackMetrics: boolean) {
 
     let slice = newSlice(geom);
-    const intersect = axis === 0 ? intersectX : intersectY;
+    const intersect = axis === AxisType.X ? intersectX : intersectY;
     let len = geom.start;
     let segLen, t;
 
@@ -138,37 +176,37 @@ function clipLine(geom: StartEndSizeArray, newGeom: StartEndSizeArray[], k1: num
         const az = geom[i + 2];
         const bx = geom[i + 3];
         const by = geom[i + 4];
-        const a = axis === 0 ? ax : ay;
-        const b = axis === 0 ? bx : by;
+        const a = axis === AxisType.X ? ax : ay;
+        const b = axis === AxisType.X ? bx : by;
         let exited = false;
 
         if (trackMetrics) segLen = Math.sqrt(Math.pow(ax - bx, 2) + Math.pow(ay - by, 2));
 
-        if (a < k1) {
+        if (a < start) {
             // ---|-->  | (line enters the clip region from the left)
-            if (b > k1) {
-                t = intersect(slice, ax, ay, bx, by, k1);
+            if (b > start) {
+                t = intersect(slice, ax, ay, bx, by, start);
                 if (trackMetrics) slice.start = len + segLen * t;
             }
-        } else if (a > k2) {
+        } else if (a > end) {
             // |  <--|--- (line enters the clip region from the right)
-            if (b < k2) {
-                t = intersect(slice, ax, ay, bx, by, k2);
+            if (b < end) {
+                t = intersect(slice, ax, ay, bx, by, end);
                 if (trackMetrics) slice.start = len + segLen * t;
             }
         } else {
             addPoint(slice, ax, ay, az);
         }
 
-        if (b < k1 && a >= k1) {
+        if (b < start && a >= start) {
             // <--|---  | or <--|-----|--- (line exits the clip region on the left)
-            t = intersect(slice, ax, ay, bx, by, k1);
+            t = intersect(slice, ax, ay, bx, by, start);
             exited = true;
         }
 
-        if (b > k2 && a <= k2) {
+        if (b > end && a <= end) {
             // |  ---|--> or ---|-----|--> (line exits the clip region on the right)
-            t = intersect(slice, ax, ay, bx, by, k2);
+            t = intersect(slice, ax, ay, bx, by, end);
             exited = true;
         }
 
@@ -186,8 +224,8 @@ function clipLine(geom: StartEndSizeArray, newGeom: StartEndSizeArray[], k1: num
     const ax = geom[last];
     const ay = geom[last + 1];
     const az = geom[last + 2];
-    const a = axis === 0 ? ax : ay;
-    if (a >= k1 && a <= k2) addPoint(slice, ax, ay, az);
+    const a = axis === AxisType.X ? ax : ay;
+    if (a >= start && a <= end) addPoint(slice, ax, ay, az);
 
     // close the polygon if its endpoints are not the same after clipping
     last = slice.length - 3;
@@ -209,9 +247,9 @@ function newSlice(line: StartEndSizeArray): StartEndSizeArray {
     return slice;
 }
 
-function clipLines(geom: StartEndSizeArray[], newGeom: StartEndSizeArray[], k1: number, k2: number, axis: number, isPolygon: boolean) {
+function clipLines(geom: StartEndSizeArray[], newGeom: StartEndSizeArray[], start: number, end: number, axis: AxisType, isPolygon: boolean) {
     for (const line of geom) {
-        clipLine(line, newGeom, k1, k2, axis, isPolygon, false);
+        clipLine(line, newGeom, start, end, axis, isPolygon, false);
     }
 }
 

package/src/cluster-tile-index.test.ts

@@ -0,0 +1,205 @@
+import {test, expect} from 'vitest';
+import {readFileSync} from 'fs';
+import {ClusterTileIndex} from './cluster-tile-index';
+import type {ClusterProperties, GeoJSONVTTile} from './definitions';
+
+const places = JSON.parse(readFileSync(new URL('../test/fixtures/places.json', import.meta.url), 'utf-8')) as GeoJSON.FeatureCollection<GeoJSON.Point>;
+const placesTile = JSON.parse(readFileSync(new URL('../test/fixtures/places-z0-0-0.json', import.meta.url), 'utf-8')) as GeoJSONVTTile;
+const placesTileMin5 = JSON.parse(readFileSync(new URL('../test/fixtures/places-z0-0-0-min5.json', import.meta.url), 'utf-8')) as GeoJSONVTTile;
+
+test('generates clusters properly', () => {
+    const index = new ClusterTileIndex();
+    index.load(places.features);
+    const tile = index.getTile(0, 0, 0);
+    expect(tile?.features).toEqual(placesTile.features);
+});
+
+test('supports minPoints option', () => {
+    const index = new ClusterTileIndex({minPoints: 5});
+    index.load(places.features);
+    const tile = index.getTile(0, 0, 0);
+    expect(tile?.features).toEqual(placesTileMin5.features);
+});
+
+test('returns children of a cluster', () => {
+    const index = new ClusterTileIndex();
+    index.load(places.features);
+    const childCounts = index.getChildren(163).map(p => (p.properties as ClusterProperties)?.point_count || 1);
+    expect(childCounts).toEqual([6, 7, 2, 1]);
+});
+
+test('returns leaves of a cluster', () => {
+    const index = new ClusterTileIndex();
+    index.load(places.features);
+    const leafNames = index.getLeaves(163, 10, 5).map(p => (p.properties as {name: string} | null)?.name);
+    expect(leafNames).toEqual([
+        'Niagara Falls',
+        'Cape San Blas',
+        'Cape Sable',
+        'Cape Canaveral',
+        'San  Salvador',
+        'Cabo Gracias a Dios',
+        'I. de Cozumel',
+        'Grand Cayman',
+        'Miquelon',
+        'Cape Bauld'
+    ]);
+});
+
+test('generates unique ids with generateId option', () => {
+    const index = new ClusterTileIndex({generateId: true});
+    index.load(places.features);
+    const tile = index.getTile(0, 0, 0)!;
+    const ids = tile.features.filter(f => !(f.tags as ClusterProperties)?.cluster).map(f => f.id);
+    expect(ids).toEqual([12, 20, 21, 22, 24, 28, 30, 62, 81, 118, 119, 125, 81, 118]);
+});
+
+test('getLeaves handles null-property features', () => {
+    const index = new ClusterTileIndex();
+    index.load(places.features.concat([{
+        type: 'Feature',
+        properties: null,
+        geometry: {
+            type: 'Point',
+            coordinates: [-79.04411780507252, 43.08771393436908]
+        }
+    }]));
+    const leaves = index.getLeaves(164, 1, 6);
+    expect(leaves[0].properties).toBe(null);
+});
+
+test('returns cluster expansion zoom', () => {
+    const index = new ClusterTileIndex();
+    index.load(places.features);
+    expect(index.getClusterExpansionZoom(163)).toBe(1);
+    expect(index.getClusterExpansionZoom(195)).toBe(1);
+    expect(index.getClusterExpansionZoom(580)).toBe(2);
+    expect(index.getClusterExpansionZoom(1156)).toBe(2);
+    expect(index.getClusterExpansionZoom(4133)).toBe(3);
+});
+
+test('returns cluster expansion zoom for maxZoom', () => {
+    const index = new ClusterTileIndex({
+        radius: 60,
+        extent: 256,
+        maxZoom: 4,
+    });
+    index.load(places.features);
+
+    expect(index.getClusterExpansionZoom(2503)).toBe(5);
+});
+
+test('aggregates cluster properties with reduce', () => {
+    const index = new ClusterTileIndex({
+        map: (props) => ({sum: (props as {scalerank: number})?.scalerank}),
+        reduce: (a, b) => { (a as {sum: number}).sum += (b as {sum: number}).sum; },
+        radius: 100
+    });
+    index.load(places.features);
+
+    expect(index.getTile(1, 0, 0)!.features.map(f => (f.tags as {sum?: number})?.sum).filter(Boolean)).toEqual(
+        [146, 84, 63, 23, 34, 12, 19, 29, 8, 8, 80, 35]);
+    expect(index.getTile(0, 0, 0)!.features.map(f => (f.tags as {sum?: number})?.sum).filter(Boolean)).toEqual(
+        [298, 122, 12, 36, 98, 7, 24, 8, 125, 98, 125, 12, 36, 8]);
+});
+
+test('uses default map function with reduce', () => {
+    const index = new ClusterTileIndex({
+        reduce: () => {},
+        radius: 100
+    });
+    index.load(places.features);
+
+    expect(index.getTile(0, 0, 0)).toBeTruthy();
+});
+
+test('returns clusters when query crosses international dateline', () => {
+    const index = new ClusterTileIndex();
+    index.load([
+        {
+            type: 'Feature',
+            properties: null,
+            geometry: {
+                type: 'Point',
+                coordinates: [-178.989, 0]
+            }
+        }, {
+            type: 'Feature',
+            properties: null,
+            geometry: {
+                type: 'Point',
+                coordinates: [-178.990, 0]
+            }
+        }, {
+            type: 'Feature',
+            properties: null,
+            geometry: {
+                type: 'Point',
+                coordinates: [-178.991, 0]
+            }
+        }, {
+            type: 'Feature',
+            properties: null,
+            geometry: {
+                type: 'Point',
+                coordinates: [-178.992, 0]
+            }
+        }
+    ]);
+
+    const nonCrossing = index.getClusters([-179, -10, -177, 10], 1);
+    const crossing = index.getClusters([179, -10, -177, 10], 1);
+
+    expect(nonCrossing.length).toBeGreaterThan(0);
+    expect(crossing.length).toBeGreaterThan(0);
+    expect(nonCrossing.length).toBe(crossing.length);
+});
+
+test('does not crash on weird bbox values', () => {
+    const index = new ClusterTileIndex();
+    index.load(places.features);
+    expect(index.getClusters([129.426390, -103.720017, -445.930843, 114.518236], 1).length).toBe(26);
+    expect(index.getClusters([112.207836, -84.578666, -463.149397, 120.169159], 1).length).toBe(27);
+    expect(index.getClusters([129.886277, -82.332680, -445.470956, 120.390930], 1).length).toBe(26);
+    expect(index.getClusters([458.220043, -84.239039, -117.137190, 120.206585], 1).length).toBe(25);
+    expect(index.getClusters([456.713058, -80.354196, -118.644175, 120.539148], 1).length).toBe(25);
+    expect(index.getClusters([453.105328, -75.857422, -122.251904, 120.732760], 1).length).toBe(25);
+    expect(index.getClusters([-180, -90, 180, 90], 1).length).toBe(61);
+});
+
+test('does not crash on non-integer zoom values', () => {
+    const index = new ClusterTileIndex();
+    index.load(places.features);
+    expect(index.getClusters([179, -10, -177, 10], 1.25)).toBeTruthy();
+});
+
+test('makes sure same-location points are clustered', () => {
+    const index = new ClusterTileIndex({
+        maxZoom: 20,
+        extent: 8192,
+        radius: 16
+    });
+    index.load([
+        {type: 'Feature', properties: null, geometry: {type: 'Point', coordinates: [-1.426798, 53.943034]}},
+        {type: 'Feature', properties: null, geometry: {type: 'Point', coordinates: [-1.426798, 53.943034]}}
+    ]);
+
+    expect(index.trees[20].ids.length).toBe(1);
+});
+
+test('makes sure unclustered point coords are not rounded', () => {
+    const index = new ClusterTileIndex({maxZoom: 19});
+    index.load([
+        {type: 'Feature', properties: null, geometry: {type: 'Point', coordinates: [173.19150559062456, -41.340357424709275]}}
+    ]);
+
+    expect(index.getTile(20, 1028744, 656754)!.features[0].geometry[0]).toEqual([421, 281]);
+});
+
+test('does not throw on zero items', () => {
+    expect(() => {
+        const index = new ClusterTileIndex();
+        index.load([]);
+        expect(index.getClusters([-180, -85, 180, 85], 0)).toEqual([]);
+    }).not.toThrow();
+});