Fix guard rails on features with split geometry

GitOrigin-RevId: 74ab821553a64b277b890a86ad5a4f2a84c8074a

Author: mpulkki-mapbox

3d-style/elevation/elevated_structures.ts

@@ -1,6 +1,6 @@
 import assert from 'assert';
 import Point from "@mapbox/point-geometry";
-import {ElevationPolygons, ElevationPortalGraph, type ElevationPortalEdge, type ElevationPortalType, type LeveledPolygon} from "./elevation_graph";
+import {ElevationPortalGraph, type ElevationPortalEdge, type ElevationPortalType} from "./elevation_graph";
 import {vec2, vec3} from "gl-matrix";
 import {tileToMeter} from '../../src/geo/mercator_coordinate';
 import EXTENT from '../../src/style-spec/data/extent';
@@ -167,7 +167,6 @@ export class ElevatedStructures {
     shadowCasterSegments: SegmentVector | undefined;
 
     unevaluatedPortals = new ElevationPortalGraph();
-    portalPolygons = new ElevationPolygons();
 
     // Tracks the rail/tunnel mesh same-feature vertex sections
     // (within ElevatedStructure::vertexPositions).
@@ -276,60 +275,62 @@ export class ElevatedStructures {
         }
     }
 
-    addPortalCandidates(id: number, polygon: Point[][], isTunnel: boolean, elevation: ElevationFeature, zLevel: number) {
-        if (polygon.length === 0) return;
-
-        const leveledPoly: LeveledPolygon = {geometry: polygon, zLevel};
-        this.portalPolygons.add(id, leveledPoly);
+    addPortalCandidates(id: number, polygons: Point[][][], isTunnel: boolean, elevation: ElevationFeature, zLevel: number) {
+        if (polygons.length === 0) return;
 
         const pointsEqual = (a: Point, b: Point) => a.x === b.x && a.y === b.y;
 
-        // Each edge of the exterior ring is a potential portal
-        const exterior = polygon[0];
-        assert(exterior.length > 1 && pointsEqual(exterior[0], exterior[exterior.length - 1]));
-
         this.vertexHashLookup.clear();
 
-        let prevEdgeHash = ElevatedStructures.computeEdgeHash(exterior[exterior.length - 2], exterior[exterior.length - 1]);
+        for (const polygon of polygons) {
+            if (polygon.length === 0) {
+                continue;
+            }
+            // Each edge of the exterior ring is a potential portal
+            const exterior = polygon[0];
+            assert(exterior.length > 1 && pointsEqual(exterior[0], exterior[exterior.length - 1]));
+
+            let prevEdgeHash = ElevatedStructures.computeEdgeHash(exterior[exterior.length - 2], exterior[exterior.length - 1]);
 
-        for (let i = 0; i < exterior.length - 1; i++) {
-            const a = exterior[i + 0];
-            const b = exterior[i + 1];
+            for (let i = 0; i < exterior.length - 1; i++) {
+                const a = exterior[i + 0];
+                const b = exterior[i + 1];
 
-            const vavb = vec2.fromValues(b.x - a.x, b.y - a.y);
-            const length = vec2.length(vavb);
+                const vavb = vec2.fromValues(b.x - a.x, b.y - a.y);
+                const length = vec2.length(vavb);
 
-            if (length === 0) continue;
+                if (length === 0) continue;
 
-            let type: ElevationPortalType = 'unevaluated';
+                let type: ElevationPortalType = 'unevaluated';
 
-            // "Entrance" portals are entry & exit points for the polygons
-            // from ground level
-            const ha = elevation.pointElevation(a);
-            const hb = elevation.pointElevation(b);
-            const onGround = Math.abs(ha) < 0.01 && Math.abs(hb) < 0.01;
+                // "Entrance" portals are entry & exit points for the polygons
+                // from ground level
+                const ha = elevation.pointElevation(a);
+                const hb = elevation.pointElevation(b);
+                const onGround = Math.abs(ha) < 0.01 && Math.abs(hb) < 0.01;
 
-            if (onGround) {
-                type = 'entrance';
-            } else {
-                // Portals on tile borders describes connectivity between tiles
-                if (this.isOnBorder(a.x, b.x) || this.isOnBorder(a.y, b.y)) {
-                    type = 'border';
+                if (onGround) {
+                    type = 'entrance';
+                } else {
+                    // Portals on tile borders describes connectivity between tiles
+                    if (this.isOnBorder(a.x, b.x) || this.isOnBorder(a.y, b.y)) {
+                        type = 'border';
+                    }
                 }
-            }
 
-            const edgeHash = ElevatedStructures.computeEdgeHash(a, b);
-            this.unevaluatedPortals.portals.push({
-                connection: {a: id, b: undefined}, va: a, vb: b, vab: vavb, length, hash: edgeHash, isTunnel, type
-            });
+                const edgeHash = ElevatedStructures.computeEdgeHash(a, b);
+                this.unevaluatedPortals.portals.push({
+                    connection: {a: id, b: undefined}, va: a, vb: b, vab: vavb, length, hash: edgeHash, isTunnel, type
+                });
 
-            // Construct a lookup table where vertex position maps to hashes of edges it's connected to
-            const posHash = ElevatedStructures.computePosHash(a);
+                // Construct a lookup table where vertex position maps to hashes of edges it's connected to
+                const posHash = ElevatedStructures.computePosHash(a);
 
-            assert(!this.vertexHashLookup.has(posHash));
-            this.vertexHashLookup.set(posHash, {prev: prevEdgeHash, next: edgeHash});
+                assert(!this.vertexHashLookup.has(posHash));
+                this.vertexHashLookup.set(posHash, {prev: prevEdgeHash, next: edgeHash});
 
-            prevEdgeHash = edgeHash;
+                prevEdgeHash = edgeHash;
+            }
         }
     }
 

3d-style/elevation/elevation_graph.ts

@@ -24,30 +24,6 @@ export interface ElevationPortalEdge {
     type: ElevationPortalType;
 }
 
-export type LeveledPolygon = {
-    geometry: Point[][];
-    zLevel: number;
-};
-
-export class ElevationPolygons {
-    polygons: Map<number, Array<LeveledPolygon>> = new Map();
-
-    add(key: number, ...values: LeveledPolygon[]) {
-        const poly = this.polygons.get(key);
-        if (!poly) {
-            this.polygons.set(key, values);
-        } else {
-            poly.push(...values);
-        }
-    }
-
-    merge(elevationPolygons: ElevationPolygons) {
-        for (const [key, value] of elevationPolygons.polygons) {
-            this.add(key, ...value);
-        }
-    }
-}
-
 export class ElevationPortalGraph {
     portals: ElevationPortalEdge[] = [];
 
@@ -136,4 +112,3 @@ export class ElevationPortalGraph {
 }
 
 register(ElevationPortalGraph, 'ElevationPortalGraph');
-register(ElevationPolygons, "ElevationPolygons");

src/data/bucket/fill_bucket.ts

@@ -40,7 +40,7 @@ import type {TileTransform} from '../../geo/projection/tile_transform';
 import type {VectorTileLayer} from '@mapbox/vector-tile';
 import type {TileFootprint} from '../../../3d-style/util/conflation';
 import type {TypedStyleLayer} from '../../style/style_layer/typed_style_layer';
-import type {ElevationPolygons, ElevationPortalGraph} from '../../../3d-style/elevation/elevation_graph';
+import type {ElevationPortalGraph} from '../../../3d-style/elevation/elevation_graph';
 import type {ImageId} from '../../style-spec/expression/types/image_id';
 import type {GlobalProperties} from "../../style-spec/expression";
 import type {LUT} from '../../util/lut';
@@ -301,10 +301,6 @@ class FillBucket implements Bucket {
         return this.elevatedStructures ? this.elevatedStructures.unevaluatedPortals : undefined;
     }
 
-    getElevationPolygons(): ElevationPolygons | undefined {
-        return this.elevatedStructures ? this.elevatedStructures.portalPolygons : undefined;
-    }
-
     setEvaluatedPortalGraph(graph: ElevationPortalGraph, vtLayer: VectorTileLayer, canonical: CanonicalTileID, availableImages: ImageId[], brightness: number) {
         if (this.elevatedStructures) {
             this.elevatedStructures.construct(graph);
@@ -354,14 +350,12 @@ class FillBucket implements Bucket {
 
                     // Create "elevated structures" for polygons using "road" elevation mode that
                     // contains additional bridge and tunnel geometries for rendering. Additive "markup" features are
-                    // stacked on top of another elevated layers and do not need these structures of their own
-                    for (const polygon of elevated.polygons) {
-                        // Overlapping edges between adjacent polygons form "portals", i.e. entry & exit points
-                        // useful for traversing elevated polygons
-                        this.elevatedStructures.addPortalCandidates(
-                            elevated.elevationFeature.id, polygon, isTunnel, elevated.elevationFeature, zLevel
-                        );
-                    }
+                    // stacked on top of another elevated layers and do not need these structures of their own.
+                    // Overlapping edges between adjacent polygons form "portals", i.e. entry & exit points
+                    // useful for traversing elevated polygons
+                    this.elevatedStructures.addPortalCandidates(
+                        elevated.elevationFeature.id, elevated.polygons, isTunnel, elevated.elevationFeature, zLevel
+                    );
                 }
 
                 if (elevated.elevationFeature.constantHeight == null) {

test/unit/elevation/elevated_structures.test.ts

@@ -11,18 +11,18 @@ import type {Bounds} from '../../../src/style-spec/util/geometry_util';
 describe('ElevatedStructures', () => {
     test('#getUnevaluatedPortals', () => {
         // Entry & exit ramps and a tunnel section
-        const leftRamp: Point[][] = [
+        const leftRamp: Point[][][] = [[
             [new Point(1, 1), new Point(3, 1), new Point(3, 4), new Point(1, 4), new Point(1, 1)]
-        ];
+        ]];
 
-        const middleRamp: Point[][] = [
+        const middleRamp: Point[][][] = [[
             [new Point(3, 1), new Point(6, 1), new Point(6, 4), new Point(3, 4), new Point(3, 1)],
             [new Point(4, 2), new Point(4, 3), new Point(5, 3), new Point(5, 2), new Point(4, 2)]
-        ];
+        ]];
 
-        const rightRamp: Point[][] = [
+        const rightRamp: Point[][][] = [[
             [new Point(6, 1), new Point(8, 1), new Point(8, 4), new Point(6, 4), new Point(6, 1)]
-        ];
+        ]];
 
         // Mock elevation feature
         const vertices: Vertex[] = [