@scoova/mgl 1.0.0

package/src/symbol/cross_tile_symbol_index.test.ts

@@ -0,0 +1,260 @@
+import {CrossTileSymbolIndex, KDBUSH_THRESHHOLD} from './cross_tile_symbol_index';
+import {OverscaledTileID} from '../source/tile_id';
+import {StyleLayer} from '../style/style_layer';
+
+const styleLayer = {
+    id: 'test'
+} as StyleLayer;
+
+const makeSymbolInstance = (x, y, key): any => {
+    return {
+        anchorX: x,
+        anchorY: y,
+        key
+    };
+};
+
+const makeTile = (tileID, symbolInstances): any => {
+    const bucket = {
+        symbolInstances: {
+            get(i) { return symbolInstances[i]; },
+            length: symbolInstances.length
+        },
+        layerIds: ['test']
+    };
+    return {
+        tileID,
+        getBucket: () => bucket,
+        latestFeatureIndex: {}
+    };
+};
+
+describe('CrossTileSymbolIndex.addLayer', () => {
+
+    test('matches ids', () => {
+        const index = new CrossTileSymbolIndex();
+
+        const mainID = new OverscaledTileID(6, 0, 6, 8, 8);
+        const mainInstances = [
+            makeSymbolInstance(1000, 1000, 'Detroit'),
+            makeSymbolInstance(2000, 2000, 'Toronto')
+        ];
+        const mainTile = makeTile(mainID, mainInstances);
+
+        index.addLayer(styleLayer, [mainTile], 0);
+        // Assigned new IDs
+        expect(mainInstances[0].crossTileID).toBe(1);
+        expect(mainInstances[1].crossTileID).toBe(2);
+
+        const childID = new OverscaledTileID(7, 0, 7, 16, 16);
+        const childInstances = [
+            makeSymbolInstance(2000, 2000, 'Detroit'),
+            makeSymbolInstance(2000, 2000, 'Windsor'),
+            makeSymbolInstance(3000, 3000, 'Toronto'),
+            makeSymbolInstance(4001, 4001, 'Toronto')
+        ];
+        const childTile = makeTile(childID, childInstances);
+
+        index.addLayer(styleLayer, [mainTile, childTile], 0);
+        // matched parent tile
+        expect(childInstances[0].crossTileID).toBe(1);
+        // does not match because of different key
+        expect(childInstances[1].crossTileID).toBe(3);
+        // does not match because of different location
+        expect(childInstances[2].crossTileID).toBe(4);
+        // matches with a slightly different location
+        expect(childInstances[3].crossTileID).toBe(2);
+
+        const parentID = new OverscaledTileID(5, 0, 5, 4, 4);
+        const parentInstances = [
+            makeSymbolInstance(500, 500, 'Detroit')
+        ];
+        const parentTile = makeTile(parentID, parentInstances);
+
+        index.addLayer(styleLayer, [mainTile, childTile, parentTile], 0);
+        // matched child tile
+        expect(parentInstances[0].crossTileID).toBe(1);
+
+        const grandchildID = new OverscaledTileID(8, 0, 8, 32, 32);
+        const grandchildInstances = [
+            makeSymbolInstance(4000, 4000, 'Detroit'),
+            makeSymbolInstance(4000, 4000, 'Windsor')
+        ];
+        const grandchildTile = makeTile(grandchildID, grandchildInstances);
+
+        index.addLayer(styleLayer, [mainTile], 0);
+        index.addLayer(styleLayer, [mainTile, grandchildTile], 0);
+        // Matches the symbol in `mainBucket`
+        expect(grandchildInstances[0].crossTileID).toBe(1);
+        // Does not match the previous value for Windsor because that tile was removed
+        expect(grandchildInstances[1].crossTileID).toBe(5);
+
+    });
+
+    test('overwrites ids when re-adding', () => {
+        const index = new CrossTileSymbolIndex();
+
+        const mainID = new OverscaledTileID(6, 0, 6, 8, 8);
+        const mainInstances = [makeSymbolInstance(1000, 1000, 'Detroit')];
+        const mainTile = makeTile(mainID, mainInstances);
+
+        const childID = new OverscaledTileID(7, 0, 7, 16, 16);
+        const childInstances = [makeSymbolInstance(2000, 2000, 'Detroit')];
+        const childTile = makeTile(childID, childInstances);
+
+        // assigns a new id
+        index.addLayer(styleLayer, [mainTile], 0);
+        expect(mainInstances[0].crossTileID).toBe(1);
+
+        // removes the tile
+        index.addLayer(styleLayer, [], 0);
+
+        // assigns a new id
+        index.addLayer(styleLayer, [childTile], 0);
+        expect(childInstances[0].crossTileID).toBe(2);
+
+        // overwrites the old id to match the already-added tile
+        index.addLayer(styleLayer, [mainTile, childTile], 0);
+        expect(mainInstances[0].crossTileID).toBe(2);
+        expect(childInstances[0].crossTileID).toBe(2);
+
+    });
+
+    test('does not duplicate ids within one zoom level', () => {
+        const index = new CrossTileSymbolIndex();
+
+        const mainID = new OverscaledTileID(6, 0, 6, 8, 8);
+        const mainInstances = [
+            makeSymbolInstance(1000, 1000, ''), // A
+            makeSymbolInstance(1000, 1000, '')  // B
+        ];
+        const mainTile = makeTile(mainID, mainInstances);
+
+        const childID = new OverscaledTileID(7, 0, 7, 16, 16);
+        const childInstances = [
+            makeSymbolInstance(2000, 2000, ''), // A'
+            makeSymbolInstance(2000, 2000, ''), // B'
+            makeSymbolInstance(2000, 2000, '')  // C'
+        ];
+        const childTile = makeTile(childID, childInstances);
+
+        // assigns new ids
+        index.addLayer(styleLayer, [mainTile], 0);
+        expect(mainInstances[0].crossTileID).toBe(1);
+        expect(mainInstances[1].crossTileID).toBe(2);
+
+        const layerIndex = index.layerIndexes[styleLayer.id];
+        expect(Object.keys(layerIndex.usedCrossTileIDs[6])).toEqual(['1', '2']);
+
+        // copies parent ids without duplicate ids in this tile
+        index.addLayer(styleLayer, [childTile], 0);
+        expect(childInstances[0].crossTileID).toBe(1); // A' copies from A
+        expect(childInstances[1].crossTileID).toBe(2); // B' copies from B
+        expect(childInstances[2].crossTileID).toBe(3); // C' gets new ID
+
+        // Updates per-zoom usedCrossTileIDs
+        expect(Object.keys(layerIndex.usedCrossTileIDs[6])).toEqual([]);
+        expect(Object.keys(layerIndex.usedCrossTileIDs[7])).toEqual(['1', '2', '3']);
+
+    });
+
+    test('does not regenerate ids for same zoom', () => {
+        const index = new CrossTileSymbolIndex();
+
+        const tileID = new OverscaledTileID(6, 0, 6, 8, 8);
+        const firstInstances = [
+            makeSymbolInstance(1000, 1000, ''), // A
+            makeSymbolInstance(1000, 1000, '')  // B
+        ];
+        const firstTile = makeTile(tileID, firstInstances);
+
+        const secondInstances = [
+            makeSymbolInstance(1000, 1000, ''), // A'
+            makeSymbolInstance(1000, 1000, ''), // B'
+            makeSymbolInstance(1000, 1000, ''), // C'
+        ];
+        const secondTile = makeTile(tileID, secondInstances);
+
+        // assigns new ids
+        index.addLayer(styleLayer, [firstTile], 0);
+        expect(firstInstances[0].crossTileID).toBe(1);
+        expect(firstInstances[1].crossTileID).toBe(2);
+
+        const layerIndex = index.layerIndexes[styleLayer.id];
+        expect(Object.keys(layerIndex.usedCrossTileIDs[6])).toEqual(['1', '2']);
+
+        // uses same ids when tile gets updated
+        index.addLayer(styleLayer, [secondTile], 0);
+        expect(secondInstances[0].crossTileID).toBe(1); // A' copies from A
+        expect(secondInstances[1].crossTileID).toBe(2); // B' copies from B
+        expect(secondInstances[2].crossTileID).toBe(3); // C' gets new ID
+
+        expect(Object.keys(layerIndex.usedCrossTileIDs[6])).toEqual(['1', '2', '3']);
+
+    });
+
+    test('reuses indexes when longitude is wrapped', () => {
+        const index = new CrossTileSymbolIndex();
+        const longitude = 370;
+
+        const tileID = new OverscaledTileID(6, 1, 6, 8, 8);
+        const firstInstances = [
+            makeSymbolInstance(1000, 1000, ''), // A
+        ];
+        const tile = makeTile(tileID, firstInstances);
+
+        index.addLayer(styleLayer, [tile], longitude);
+        expect(firstInstances[0].crossTileID).toBe(1); // A
+
+        tile.tileID = tileID.wrapped();
+
+        index.addLayer(styleLayer, [tile], longitude % 360);
+        expect(firstInstances[0].crossTileID).toBe(1);
+
+    });
+
+    test('indexes data for findMatches perf', () => {
+        const index = new CrossTileSymbolIndex();
+
+        const mainID = new OverscaledTileID(6, 0, 6, 8, 8);
+        const childID = new OverscaledTileID(7, 0, 7, 16, 16);
+
+        const mainInstances: any[] = [];
+        const childInstances: any[] = [];
+
+        for (let i = 0; i < KDBUSH_THRESHHOLD + 1; i++) {
+            mainInstances.push(makeSymbolInstance(0, 0, ''));
+            childInstances.push(makeSymbolInstance(0, 0, ''));
+        }
+        const mainTile = makeTile(mainID, mainInstances);
+        const childTile = makeTile(childID, childInstances);
+        index.addLayer(styleLayer, [mainTile], 0);
+        index.addLayer(styleLayer, [childTile], 0);
+
+        // check that we matched the parent tile
+        expect(childInstances[0].crossTileID).toBe(1);
+
+    });
+});
+
+describe('CrossTileSymbolIndex.pruneUnusedLayers', () => {
+    const index = new CrossTileSymbolIndex();
+
+    const tileID = new OverscaledTileID(6, 0, 6, 8, 8);
+    const instances = [
+        makeSymbolInstance(1000, 1000, ''), // A
+        makeSymbolInstance(1000, 1000, '')  // B
+    ];
+    const tile = makeTile(tileID, instances);
+
+    // assigns new ids
+    index.addLayer(styleLayer, [tile], 0);
+    expect(instances[0].crossTileID).toBe(1);
+    expect(instances[1].crossTileID).toBe(2);
+    expect(index.layerIndexes[styleLayer.id]).toBeTruthy();
+
+    // remove styleLayer
+    index.pruneUnusedLayers([]);
+    expect(index.layerIndexes[styleLayer.id]).toBeFalsy();
+
+});

package/src/symbol/cross_tile_symbol_index.ts

@@ -0,0 +1,367 @@
+import KDBush from 'kdbush';
+import {EXTENT} from '../data/extent';
+
+import {SymbolInstanceArray} from '../data/array_types.g';
+
+import type {SymbolInstance} from '../data/array_types.g';
+import type {OverscaledTileID} from '../source/tile_id';
+import type {SymbolBucket} from '../data/bucket/symbol_bucket';
+import type {StyleLayer} from '../style/style_layer';
+import type {Tile} from '../source/tile';
+
+/*
+    The CrossTileSymbolIndex generally works on the assumption that
+    a conceptual "unique symbol" can be identified by the text of
+    the label combined with the anchor point. The goal is to assign
+    these conceptual "unique symbols" a shared crossTileID that can be
+    used by Placement to keep fading opacity states consistent and to
+    deduplicate labels.
+
+    The CrossTileSymbolIndex indexes all the current symbol instances and
+    their crossTileIDs. When a symbol bucket gets added or updated, the
+    index assigns a crossTileID to each of it's symbol instances by either
+    matching it with an existing id or assigning a new one.
+*/
+
+// Round anchor positions to roughly 4 pixel grid
+const roundingFactor = 512 / EXTENT / 2;
+
+export const KDBUSH_THRESHHOLD = 128;
+
+interface SymbolsByKeyEntry {
+    index?: KDBush;
+    positions?: {x: number; y: number}[];
+    crossTileIDs: number[];
+}
+
+class TileLayerIndex {
+    _symbolsByKey: Record<number, SymbolsByKeyEntry> = {};
+
+    constructor(public tileID: OverscaledTileID, symbolInstances: SymbolInstanceArray, public bucketInstanceId: number) {
+        // group the symbolInstances by key
+        const symbolInstancesByKey = new Map<number, SymbolInstance[]>();
+        for (let i = 0; i < symbolInstances.length; i++) {
+            const symbolInstance = symbolInstances.get(i);
+            const key = symbolInstance.key;
+            const instances = symbolInstancesByKey.get(key);
+            if (instances) {
+                // This tile may have multiple symbol instances with the same key
+                // Store each one along with its coordinates
+                instances.push(symbolInstance);
+            } else {
+                symbolInstancesByKey.set(key, [symbolInstance]);
+            }
+        }
+
+        // index the SymbolInstances in this each bucket
+        for (const [key, symbols] of symbolInstancesByKey) {
+            const positions = symbols.map(symbolInstance => ({x: Math.floor(symbolInstance.anchorX * roundingFactor), y: Math.floor(symbolInstance.anchorY * roundingFactor)}));
+            const crossTileIDs = symbols.map(v => v.crossTileID);
+            const entry: SymbolsByKeyEntry = {positions, crossTileIDs};
+
+            // once we get too many symbols for a given key, it becomes much faster to index it before queries
+            if (entry.positions.length > KDBUSH_THRESHHOLD) {
+
+                const index = new KDBush(entry.positions.length, 16, Uint16Array);
+                for (const {x, y} of entry.positions) index.add(x, y);
+                index.finish();
+
+                // clear all references to the original positions data
+                delete entry.positions;
+                entry.index = index;
+            }
+
+            this._symbolsByKey[key] = entry;
+        }
+    }
+
+    // Converts the coordinates of the input symbol instance into coordinates that be can compared
+    // against other symbols in this index. Coordinates are:
+    // (1) local-tile-based (so after correction we get x,y values relative to our local anchorX/Y)
+    // (2) converted to the z-scale of this TileLayerIndex
+    // (3) down-sampled by "roundingFactor" from tile coordinate precision in order to be
+    //     more tolerant of small differences between tiles.
+    getScaledCoordinates(symbolInstance: SymbolInstance, childTileID: OverscaledTileID): {x: number; y: number} {
+        const {x: localX, y: localY, z: localZ} = this.tileID.canonical;
+        const {x, y, z} = childTileID.canonical;
+
+        const zDifference = z - localZ;
+        const scale = roundingFactor / Math.pow(2, zDifference);
+        const xWorld = (x * EXTENT + symbolInstance.anchorX) * scale;
+        const yWorld = (y * EXTENT + symbolInstance.anchorY) * scale;
+        const xOffset = localX * EXTENT * roundingFactor;
+        const yOffset = localY * EXTENT * roundingFactor;
+        const result =  {
+            x: Math.floor(xWorld - xOffset),
+            y: Math.floor(yWorld - yOffset)
+        };
+
+        return result;
+    }
+
+    findMatches(symbolInstances: SymbolInstanceArray, newTileID: OverscaledTileID, zoomCrossTileIDs: {
+        [crossTileID: number]: boolean;
+    }) {
+        const tolerance = this.tileID.canonical.z < newTileID.canonical.z ? 1 : Math.pow(2, this.tileID.canonical.z - newTileID.canonical.z);
+
+        for (let i = 0; i < symbolInstances.length; i++) {
+            const symbolInstance = symbolInstances.get(i);
+            if (symbolInstance.crossTileID) {
+                // already has a match, skip
+                continue;
+            }
+
+            const entry = this._symbolsByKey[symbolInstance.key];
+            if (!entry) {
+                // No symbol with this key in this bucket
+                continue;
+            }
+
+            const scaledSymbolCoord = this.getScaledCoordinates(symbolInstance, newTileID);
+
+            if (entry.index) {
+                // Return any symbol with the same keys whose coordinates are within 1
+                // grid unit. (with a 4px grid, this covers a 12px by 12px area)
+                const indexes = entry.index.range(
+                    scaledSymbolCoord.x - tolerance,
+                    scaledSymbolCoord.y - tolerance,
+                    scaledSymbolCoord.x + tolerance,
+                    scaledSymbolCoord.y + tolerance).sort();
+
+                for (const i of indexes) {
+                    const crossTileID = entry.crossTileIDs[i];
+
+                    if (!zoomCrossTileIDs[crossTileID]) {
+                        // Once we've marked ourselves duplicate against this parent symbol,
+                        // don't let any other symbols at the same zoom level duplicate against
+                        // the same parent (see issue #5993)
+                        zoomCrossTileIDs[crossTileID] = true;
+                        symbolInstance.crossTileID = crossTileID;
+                        break;
+                    }
+                }
+            } else if (entry.positions) {
+                for (let i = 0; i < entry.positions.length; i++) {
+                    const thisTileSymbol = entry.positions[i];
+                    const crossTileID = entry.crossTileIDs[i];
+
+                    // Return any symbol with the same keys whose coordinates are within 1
+                    // grid unit. (with a 4px grid, this covers a 12px by 12px area)
+                    if (Math.abs(thisTileSymbol.x - scaledSymbolCoord.x) <= tolerance &&
+                        Math.abs(thisTileSymbol.y - scaledSymbolCoord.y) <= tolerance &&
+                        !zoomCrossTileIDs[crossTileID]) {
+                        // Once we've marked ourselves duplicate against this parent symbol,
+                        // don't let any other symbols at the same zoom level duplicate against
+                        // the same parent (see issue #5993)
+                        zoomCrossTileIDs[crossTileID] = true;
+                        symbolInstance.crossTileID = crossTileID;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    getCrossTileIDsLists() {
+        return Object.values(this._symbolsByKey).map(({crossTileIDs}) => crossTileIDs);
+    }
+}
+
+class CrossTileIDs {
+    maxCrossTileID: number;
+    constructor() {
+        this.maxCrossTileID = 0;
+    }
+    generate() {
+        return ++this.maxCrossTileID;
+    }
+}
+
+class CrossTileSymbolLayerIndex {
+    indexes: {
+        [zoom in string | number]: {
+            [tileId in string | number]: TileLayerIndex;
+        };
+    };
+    usedCrossTileIDs: {
+        [zoom in string | number]: {
+            [crossTileID: number]: boolean;
+        };
+    };
+    lng: number;
+
+    constructor() {
+        this.indexes = {};
+        this.usedCrossTileIDs = {};
+        this.lng = 0;
+    }
+
+    /*
+     * Sometimes when a user pans across the antimeridian the longitude value gets wrapped.
+     * To prevent labels from flashing out and in we adjust the tileID values in the indexes
+     * so that they match the new wrapped version of the map.
+     */
+    handleWrapJump(lng: number) {
+        const wrapDelta = Math.round((lng - this.lng) / 360);
+        if (wrapDelta !== 0) {
+            for (const zoom in this.indexes) {
+                const zoomIndexes = this.indexes[zoom];
+                const newZoomIndex = {};
+                for (const key in zoomIndexes) {
+                    // change the tileID's wrap and add it to a new index
+                    const index = zoomIndexes[key];
+                    index.tileID = index.tileID.unwrapTo(index.tileID.wrap + wrapDelta);
+                    newZoomIndex[index.tileID.key] = index;
+                }
+                this.indexes[zoom] = newZoomIndex;
+            }
+        }
+        this.lng = lng;
+    }
+
+    addBucket(tileID: OverscaledTileID, bucket: SymbolBucket, crossTileIDs: CrossTileIDs) {
+        if (this.indexes[tileID.overscaledZ] &&
+            this.indexes[tileID.overscaledZ][tileID.key]) {
+            if (this.indexes[tileID.overscaledZ][tileID.key].bucketInstanceId ===
+                bucket.bucketInstanceId) {
+                return false;
+            } else {
+                // We're replacing this bucket with an updated version
+                // Remove the old bucket's "used crossTileIDs" now so that
+                // the new bucket can claim them.
+                // The old index entries themselves stick around until
+                // 'removeStaleBuckets' is called.
+                this.removeBucketCrossTileIDs(tileID.overscaledZ,
+                    this.indexes[tileID.overscaledZ][tileID.key]);
+            }
+        }
+
+        for (let i = 0; i < bucket.symbolInstances.length; i++) {
+            const symbolInstance = bucket.symbolInstances.get(i);
+            symbolInstance.crossTileID = 0;
+        }
+
+        if (!this.usedCrossTileIDs[tileID.overscaledZ]) {
+            this.usedCrossTileIDs[tileID.overscaledZ] = {};
+        }
+        const zoomCrossTileIDs = this.usedCrossTileIDs[tileID.overscaledZ];
+
+        for (const zoom in this.indexes) {
+            const zoomIndexes = this.indexes[zoom];
+            if (Number(zoom) > tileID.overscaledZ) {
+                for (const id in zoomIndexes) {
+                    const childIndex = zoomIndexes[id];
+                    if (childIndex.tileID.isChildOf(tileID)) {
+                        childIndex.findMatches(bucket.symbolInstances, tileID, zoomCrossTileIDs);
+                    }
+                }
+            } else {
+                const parentCoord = tileID.scaledTo(Number(zoom));
+                const parentIndex = zoomIndexes[parentCoord.key];
+                if (parentIndex) {
+                    parentIndex.findMatches(bucket.symbolInstances, tileID, zoomCrossTileIDs);
+                }
+            }
+        }
+
+        for (let i = 0; i < bucket.symbolInstances.length; i++) {
+            const symbolInstance = bucket.symbolInstances.get(i);
+            if (!symbolInstance.crossTileID) {
+                // symbol did not match any known symbol, assign a new id
+                symbolInstance.crossTileID = crossTileIDs.generate();
+                zoomCrossTileIDs[symbolInstance.crossTileID] = true;
+            }
+        }
+
+        if (this.indexes[tileID.overscaledZ] === undefined) {
+            this.indexes[tileID.overscaledZ] = {};
+        }
+        this.indexes[tileID.overscaledZ][tileID.key] = new TileLayerIndex(tileID, bucket.symbolInstances, bucket.bucketInstanceId);
+
+        return true;
+    }
+
+    removeBucketCrossTileIDs(zoom: string | number, removedBucket: TileLayerIndex) {
+        for (const crossTileIDs of removedBucket.getCrossTileIDsLists()) {
+            for (const crossTileID of crossTileIDs) {
+                delete this.usedCrossTileIDs[zoom][crossTileID];
+            }
+        }
+    }
+
+    removeStaleBuckets(currentIDs: {
+        [k in string | number]: boolean;
+    }) {
+        let tilesChanged = false;
+        for (const z in this.indexes) {
+            const zoomIndexes = this.indexes[z];
+            for (const tileKey in zoomIndexes) {
+                if (!currentIDs[zoomIndexes[tileKey].bucketInstanceId]) {
+                    this.removeBucketCrossTileIDs(z, zoomIndexes[tileKey]);
+                    delete zoomIndexes[tileKey];
+                    tilesChanged = true;
+                }
+            }
+        }
+        return tilesChanged;
+    }
+}
+
+export class CrossTileSymbolIndex {
+    layerIndexes: {[layerId: string]: CrossTileSymbolLayerIndex};
+    crossTileIDs: CrossTileIDs;
+    maxBucketInstanceId: number;
+    bucketsInCurrentPlacement: {[_: number]: boolean};
+
+    constructor() {
+        this.layerIndexes = {};
+        this.crossTileIDs = new CrossTileIDs();
+        this.maxBucketInstanceId = 0;
+        this.bucketsInCurrentPlacement = {};
+    }
+
+    addLayer(styleLayer: StyleLayer, tiles: Array<Tile>, lng: number) {
+        let layerIndex = this.layerIndexes[styleLayer.id];
+        if (layerIndex === undefined) {
+            layerIndex = this.layerIndexes[styleLayer.id] = new CrossTileSymbolLayerIndex();
+        }
+
+        let symbolBucketsChanged = false;
+        const currentBucketIDs = {};
+
+        layerIndex.handleWrapJump(lng);
+
+        for (const tile of tiles) {
+            const symbolBucket = (tile.getBucket(styleLayer) as any as SymbolBucket);
+            if (!symbolBucket || styleLayer.id !== symbolBucket.layerIds[0])
+                continue;
+
+            if (!symbolBucket.bucketInstanceId) {
+                symbolBucket.bucketInstanceId = ++this.maxBucketInstanceId;
+            }
+
+            if (layerIndex.addBucket(tile.tileID, symbolBucket, this.crossTileIDs)) {
+                symbolBucketsChanged = true;
+            }
+            currentBucketIDs[symbolBucket.bucketInstanceId] = true;
+        }
+
+        if (layerIndex.removeStaleBuckets(currentBucketIDs)) {
+            symbolBucketsChanged = true;
+        }
+
+        return symbolBucketsChanged;
+    }
+
+    pruneUnusedLayers(usedLayers: Array<string>) {
+        const usedLayerMap = {};
+        usedLayers.forEach((usedLayer) => {
+            usedLayerMap[usedLayer] = true;
+        });
+        for (const layerId in this.layerIndexes) {
+            if (!usedLayerMap[layerId]) {
+                delete this.layerIndexes[layerId];
+            }
+        }
+    }
+}