Improve indoor buildings visibility check (internal-10029)

GitOrigin-RevId: 0c3a68bd91deb8df91951a027ab4544bb3b578d5

Author: aleksproger

src/render/indoor_parser.ts

@@ -1,51 +1,34 @@
 import {warnOnce} from "../util/util";
+import {getLngLatPoint} from "../style-spec/expression/definitions/distance";
+import {IndoorActiveFloorStrategy} from "../style/indoor_active_floor_strategy";
 
 import type {VectorTile, VectorTileFeature} from "@mapbox/vector-tile";
 import type {IndoorBuilding, IndoorData, IndoorTileOptions} from "../style/indoor_data";
 import type Actor from "../util/actor";
+import type {CanonicalTileID} from "../source/tile_id";
+import type {Polygon, MultiPolygon} from "geojson";
 
-export function parseActiveFloors(data: VectorTile, indoorTileOptions: IndoorTileOptions, actor: Actor): Set<string> | undefined {
+export function parseActiveFloors(data: VectorTile, indoorTileOptions: IndoorTileOptions, actor: Actor, tileID: CanonicalTileID): Set<string> | undefined {
     const activeFloorsVisible = indoorTileOptions.indoorState.activeFloorsVisible;
     if (!indoorTileOptions.sourceLayers) {
         return activeFloorsVisible ? indoorTileOptions.indoorState.activeFloors : undefined;
     }
     const sourceLayers = calculateIndoorSourceLayers(indoorTileOptions.sourceLayers, new Set(Object.keys(data.layers)));
     const indoorState = indoorTileOptions.indoorState;
-    const indoorData = parseData(data, sourceLayers, indoorState.activeFloors, indoorState.selectedFloorId);
+    const indoorData = parseData(data, sourceLayers, indoorState.activeFloors, indoorState.selectedFloorId, tileID);
     actor.send('setIndoorData', indoorData);
     return activeFloorsVisible ? indoorData.activeFloors : undefined;
 }
 
-// This function is used to parse the indoor data from the vector tile
-// And resolve set of currently active floors based on lastActiveFloors and selectedFloorId
-// 1. Parse the indoor data from the vector tile
-// 2. selectedFloorId will be used to determine if the floor is active (either directly or via connected_floor_ids)
-// 3. if lastActiveFloors is provided, we will also add floors from that set that are not conflicting with the new active floors from step 2
-// 4. we also add default floors that are not conflicting with the new active floors from steps 2 and 3
-// ResolveD data will be passed to the bucket and emitted to indoor manager to create new indoorState
 function parseData(
     data: VectorTile,
     sourceLayers: Set<string>,
     lastActiveFloors: Set<string>,
-    selectedFloorId: string
+    selectedFloorId: string,
+    tileID: CanonicalTileID
 ): IndoorData {
-    const newActiveFloors = new Set<string>();
-    const allFloors = new Set<string>();
-    const allDefaultFloors = new Set<string>();
-
-    const floorIdToConflicts = new Map<string, Set<string>>();
     const buildings: Record<string, IndoorBuilding> = {};
 
-    // If any active floor lists candidate as conflict, or candidate lists any active as conflict
-    const conflictsWithActive = (candidateId: string): boolean => {
-        const candidateConflicts = floorIdToConflicts.get(candidateId) || new Set<string>();
-        for (const activeId of newActiveFloors) {
-            const activeConflicts = floorIdToConflicts.get(activeId) || new Set<string>();
-            if (activeConflicts.has(candidateId) || candidateConflicts.has(activeId)) return true;
-        }
-        return false;
-    };
-
     for (const layerId of sourceLayers) {
         const sourceLayer = data.layers[layerId];
         if (!sourceLayer) {
@@ -59,52 +42,21 @@ function parseData(
             if (isValidBuildingFeature(feature)) {
                 const {id, center} = parseBuilding(feature);
                 upsertBuilding(buildings, id, center);
-                newActiveFloors.add(id);
                 continue;
             }
 
             // Next step: Introduce better logging in case of invalid feature with valid type
             if (isValidFloorFeature(feature)) {
-                const {id, isDefault, connections, conflicts, buildings: buildingIds, name, zIndex} = parseFloor(feature);
-                assignFloorToBuildings(buildings, buildingIds, id, {name, zIndex});
-
-                floorIdToConflicts.set(id, conflicts);
-
-                const isActiveFloor = (id === selectedFloorId) || connections.has(selectedFloorId);
-                if (isActiveFloor) {
-                    newActiveFloors.add(id);
-                }
-
-                allFloors.add(id);
-                if (isDefault) {
-                    allDefaultFloors.add(id);
-                }
+                const floor = parseFloor(feature, tileID);
+                assignFloorToBuildings(buildings, floor.buildings, floor.id, floor);
             }
         }
     }
 
-    // Add last active floors that still exist and don't conflict with current active floors
-    if (lastActiveFloors) {
-        for (const lastActiveFloorId of lastActiveFloors) {
-            // lastActiveFloors may contain floors that are not in the current tile data, so we need to check if they exist and skip if they don't
-            if (!allFloors.has(lastActiveFloorId)) continue;
-            if (!conflictsWithActive(lastActiveFloorId)) {
-                newActiveFloors.add(lastActiveFloorId);
-            }
-        }
-    }
-
-    // Add default floors that don't conflict with the active floors
-    for (const defaultFloorId of allDefaultFloors) {
-        if (newActiveFloors.has(defaultFloorId)) continue;
-        if (!conflictsWithActive(defaultFloorId)) {
-            newActiveFloors.add(defaultFloorId);
-        }
-    }
-
+    const activeFloors = IndoorActiveFloorStrategy.calculate(buildings, selectedFloorId, lastActiveFloors);
     return {
         buildings,
-        activeFloors: newActiveFloors
+        activeFloors
     };
 }
 
@@ -128,7 +80,7 @@ function assignFloorToBuildings(
     buildings: Record<string, IndoorBuilding>,
     buildingIds: Set<string>,
     floorId: string,
-    floor: {name: string, zIndex: number}
+    floor: {name: string, zIndex: number, connections: Set<string>, conflicts: Set<string>, isDefault: boolean, buildings: Set<string>}
 ): void {
     for (const buildingId of buildingIds) {
         upsertBuilding(buildings, buildingId);
@@ -143,7 +95,7 @@ function parseBuilding(feature: VectorTileFeature): {id: string, center: [number
     return {id, center};
 }
 
-function parseFloor(feature: VectorTileFeature): {id: string, isDefault: boolean, connections: Set<string>, conflicts: Set<string>, buildings: Set<string>, zIndex: number, name: string} {
+function parseFloor(feature: VectorTileFeature, tileID: CanonicalTileID): {id: string, isDefault: boolean, connections: Set<string>, conflicts: Set<string>, buildings: Set<string>, zIndex: number, name: string, geometry: Polygon | MultiPolygon | undefined} {
     const id = feature.properties.id.toString();
     const isDefault = feature.properties.is_default ?
         feature.properties.is_default as boolean :
@@ -159,8 +111,23 @@ function parseFloor(feature: VectorTileFeature): {id: string, isDefault: boolean
         new Set();
     const name = feature.properties.name.toString();
     const zIndex = feature.properties.z_index as number;
+    const geometry = extractGeometry(feature, tileID);
+    return {id, isDefault, connections, conflicts, buildings, name, zIndex, geometry};
+}
+
+function extractGeometry(feature: VectorTileFeature, tileID: CanonicalTileID): Polygon | MultiPolygon | undefined {
+    const geometry = feature.loadGeometry();
+    if (!geometry || geometry.length === 0) return undefined;
+
+    const coordinates = geometry.map(ring => {
+        return ring.map(p => {
+            return getLngLatPoint(p, tileID, feature.extent);
+        });
+    });
+    if (coordinates.length === 0) return undefined;
 
-    return {id, isDefault, connections, conflicts, buildings, name, zIndex};
+    // Just construct a Polygon with the first ring as exterior.
+    return {type: 'Polygon', coordinates: [coordinates[0]]};
 }
 
 function hasRequiredProperties(feature: VectorTileFeature, requiredProps: string[]): boolean {

src/source/worker_tile.ts

@@ -140,7 +140,7 @@ class WorkerTile {
         };
 
         if (this.indoor) {
-            options.activeFloors = parseActiveFloors(data, this.indoor, actor);
+            options.activeFloors = parseActiveFloors(data, this.indoor, actor, this.canonical);
         }
 
         const asyncBucketLoads: Promise<unknown>[] = [];
@@ -233,7 +233,7 @@ class WorkerTile {
                 if (layer.maxzoom && this.zoom >= layer.maxzoom) continue;
                 if (layer.visibility === 'none') continue;
 
-                recalculateLayers(family, this.zoom, options.brightness, availableImages, this.worldview);
+                recalculateLayers(family, this.zoom, options.brightness, availableImages, this.worldview, options.activeFloors);
 
                 // @ts-expect-error: Type 'TypedStyleLayer' doesn't have a 'createBucket' method in all of its subtypes
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call
@@ -317,7 +317,7 @@ class WorkerTile {
                     for (const key in buckets) {
                         const bucket = buckets[key];
                         if (bucket instanceof SymbolBucket) {
-                            recalculateLayers(bucket.layers, this.zoom, options.brightness, availableImages, this.worldview);
+                            recalculateLayers(bucket.layers, this.zoom, options.brightness, availableImages, this.worldview, options.activeFloors);
                             symbolLayoutData[key] =
                             performSymbolLayout(bucket,
                                     glyphMap,
@@ -358,7 +358,7 @@ class WorkerTile {
                         (bucket instanceof LineBucket ||
                             bucket instanceof FillBucket ||
                             bucket instanceof FillExtrusionBucket)) {
-                        recalculateLayers(bucket.layers, this.zoom, options.brightness, availableImages, this.worldview);
+                        recalculateLayers(bucket.layers, this.zoom, options.brightness, availableImages, this.worldview, options.activeFloors);
                         const imagePositions: SpritePositions = Object.fromEntries(imageAtlas.patternPositions);
                         bucket.addFeatures(options, this.tileID.canonical, imagePositions, availableImages, this.tileTransform, this.brightness);
                     }
@@ -531,9 +531,9 @@ class WorkerTile {
     }
 }
 
-function recalculateLayers(layers: ReadonlyArray<TypedStyleLayer>, zoom: number, brightness: number, availableImages: ImageId[], worldview: string | undefined) {
+function recalculateLayers(layers: ReadonlyArray<TypedStyleLayer>, zoom: number, brightness: number, availableImages: ImageId[], worldview: string | undefined, activeFloors: Set<string> | undefined) {
     // Layers are shared and may have been used by a WorkerTile with a different zoom.
-    const parameters = new EvaluationParameters(zoom, {brightness, worldview});
+    const parameters = new EvaluationParameters(zoom, {brightness, worldview, activeFloors});
     for (const layer of layers) {
         layer.recalculate(parameters, availableImages);
     }

src/style-spec/expression/definitions/distance.ts

@@ -135,10 +135,10 @@ function latFromMercatorY(y: number): number {
     return 360 / Math.PI * Math.atan(Math.exp(y2 * Math.PI / 180)) - 90;
 }
 
-function getLngLatPoint(coord: Point, canonical: CanonicalTileID): [number, number] {
+export function getLngLatPoint(coord: Point, canonical: CanonicalTileID, extent: number = EXTENT): [number, number] {
     const tilesAtZoom = Math.pow(2, canonical.z);
-    const x = (coord.x / EXTENT + canonical.x) / tilesAtZoom;
-    const y = (coord.y / EXTENT + canonical.y) / tilesAtZoom;
+    const x = (coord.x / extent + canonical.x) / tilesAtZoom;
+    const y = (coord.y / extent + canonical.y) / tilesAtZoom;
     return [lngFromMercatorX(x), latFromMercatorY(y)];
 }
 

src/style/indoor_active_floor_strategy.ts

@@ -0,0 +1,59 @@
+import type {IndoorBuilding} from './indoor_data';
+
+export class IndoorActiveFloorStrategy {
+    static calculate(
+        buildings: Record<string, IndoorBuilding>,
+        selectedFloorId: string | null,
+        lastActiveFloors: Set<string> | null
+    ): Set<string> {
+        const newActiveFloors = new Set<string>();
+        const floorIdToConflicts = new Map<string, Set<string>>();
+        const allFloors = new Set<string>();
+        const allDefaultFloors = new Set<string>();
+
+        // Build graph from all loaded buildings
+        for (const building of Object.values(buildings)) {
+            for (const [floorId, floor] of Object.entries(building.floors)) {
+                allFloors.add(floorId);
+                if (floor.isDefault) allDefaultFloors.add(floorId);
+                if (floor.conflicts) floorIdToConflicts.set(floorId, floor.conflicts);
+
+                // Add selected floor and its connections
+                const isSelected = (floorId === selectedFloorId);
+                const isConnected = floor.connections && selectedFloorId && floor.connections.has(selectedFloorId);
+                if (isSelected || isConnected) {
+                    newActiveFloors.add(floorId);
+                }
+            }
+        }
+
+        const conflictsWithActive = (candidateId: string): boolean => {
+            const candidateConflicts = floorIdToConflicts.get(candidateId) || new Set<string>();
+            for (const activeId of newActiveFloors) {
+                const activeConflicts = floorIdToConflicts.get(activeId) || new Set<string>();
+                if (activeConflicts.has(candidateId) || candidateConflicts.has(activeId)) return true;
+            }
+            return false;
+        };
+
+        // Add last active floors that still exist and don't conflict
+        if (lastActiveFloors) {
+            for (const lastActiveFloorId of lastActiveFloors) {
+                if (!allFloors.has(lastActiveFloorId)) continue;
+                if (!conflictsWithActive(lastActiveFloorId)) {
+                    newActiveFloors.add(lastActiveFloorId);
+                }
+            }
+        }
+
+        // Add default floors that don't conflict
+        for (const defaultFloorId of allDefaultFloors) {
+            if (newActiveFloors.has(defaultFloorId)) continue;
+            if (!conflictsWithActive(defaultFloorId)) {
+                newActiveFloors.add(defaultFloorId);
+            }
+        }
+
+        return newActiveFloors;
+    }
+}

src/style/indoor_building_detection.ts

@@ -0,0 +1,112 @@
+import Point from '@mapbox/point-geometry';
+import {polygonIntersectsPolygon, polygonIntersectsMultiPolygon} from '../util/intersection_tests';
+
+import type LngLat from '../geo/lng_lat';
+import type {LngLatBounds} from '../geo/lng_lat';
+import type {IndoorBuilding} from './indoor_data';
+
+export class ViewportIntersectionStrategy {
+    _previousClosestBuildingId: string | null = null;
+    _hysteresisRatio: number = 0.8;
+    _indoorMinimumZoom: number = 16.0;
+
+    findClosestBuilding(
+        buildings: Record<string, IndoorBuilding>,
+        mapCenter: LngLat,
+        zoom: number,
+        mapBounds: LngLatBounds,
+        viewportPolygon?: Point[]
+    ): string | null {
+        if (zoom < this._indoorMinimumZoom) {
+            this._previousClosestBuildingId = null;
+            return null;
+        }
+
+        let nextClosestBuildingId: string | null = null;
+        let minDistance = Number.MAX_VALUE;
+
+        let currentBuildingDistance = Number.MAX_VALUE;
+        let currentInBounds = false;
+
+        const previousBuilding = this._previousClosestBuildingId ? buildings[this._previousClosestBuildingId] : null;
+
+        if (this._previousClosestBuildingId && previousBuilding) {
+            const isVisible = this._isBuildingVisible(previousBuilding, mapBounds, viewportPolygon);
+            if (isVisible) {
+                currentInBounds = true;
+                currentBuildingDistance = this._calculateDistance(mapCenter, previousBuilding);
+            }
+        }
+
+        for (const [id, building] of Object.entries(buildings)) {
+            const isVisible = this._isBuildingVisible(building, mapBounds, viewportPolygon);
+            if (!isVisible) continue;
+
+            const distance = this._calculateDistance(mapCenter, building);
+
+            if (distance < minDistance) {
+                minDistance = distance;
+                nextClosestBuildingId = id;
+            }
+        }
+
+        // Switch to a new closest building only if it is significantly closer (hysteresis)
+        if (currentInBounds && nextClosestBuildingId && this._previousClosestBuildingId && nextClosestBuildingId !== this._previousClosestBuildingId) {
+            if (minDistance > currentBuildingDistance * this._hysteresisRatio) {
+                nextClosestBuildingId = this._previousClosestBuildingId;
+            }
+        } else if (currentInBounds && !nextClosestBuildingId) {
+            nextClosestBuildingId = this._previousClosestBuildingId;
+        }
+
+        this._previousClosestBuildingId = nextClosestBuildingId;
+        return nextClosestBuildingId;
+    }
+
+    _calculateDistance(mapCenter: LngLat, building: IndoorBuilding): number {
+        if (!building.center) return Number.MAX_VALUE;
+        // Simple squared euclidean distance
+        const dLat = mapCenter.lat - building.center[1];
+        const dLng = mapCenter.lng - building.center[0];
+        return dLat * dLat + dLng * dLng;
+    }
+
+    _isBuildingVisible(building: IndoorBuilding, mapBounds: LngLatBounds, viewportPolygon?: Point[]): boolean {
+        if (!viewportPolygon) {
+            return false;
+        }
+
+        // Check intersection with viewport polygon, if any floor is visible
+        for (const floorId of building.floorIds) {
+            const floor = building.floors[floorId];
+            if (!floor.geometry) continue;
+
+            const geometry = floor.geometry;
+            if (geometry.type === 'Polygon') {
+                const floorPoly = this._convertRingToPoints(geometry.coordinates[0]);
+                if (polygonIntersectsPolygon(floorPoly, viewportPolygon)) {
+                    return true;
+                }
+            } else if (geometry.type === 'MultiPolygon') {
+                const floorMultiPoly = this._convertMultiPolygonToPoints(geometry.coordinates);
+                if (polygonIntersectsMultiPolygon(viewportPolygon, floorMultiPoly)) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    _convertRingToPoints(ring: number[][]): Point[] {
+        return ring.map(c => new Point(c[0], c[1]));
+    }
+
+    _convertMultiPolygonToPoints(multiPoly: number[][][][]): Point[][] {
+        // Convert each polygon's exterior ring
+        return multiPoly.map(poly => {
+            if (poly.length === 0) return [];
+            return poly[0].map(c => new Point(c[0], c[1]));
+        });
+    }
+}