@itwin/core-frontend 3.1.0-dev.8 → 3.1.0

package/lib/esm/tile/map/MapTileTree.js

@@ -5,14 +5,13 @@
 /** @packageDocumentation
  * @module Tiles
  */
-import { assert, compareBooleans, compareNumbers, compareStrings, compareStringsOrUndefined, CompressedId64Set } from "@itwin/core-bentley";
-import { Angle, AngleSweep, Constant, Ellipsoid, EllipsoidPatch, Point3d, Range1d, Range3d, Ray3d, Transform, Vector3d, } from "@itwin/core-geometry";
+import { assert, compareBooleans, compareBooleansOrUndefined, compareNumbers, compareStrings, compareStringsOrUndefined, CompressedId64Set } from "@itwin/core-bentley";
 import { Cartographic, FeatureAppearance, GeoCoordStatus, GlobeMode, MapLayerSettings, PlanarClipMaskPriority, TerrainHeightOriginMode, } from "@itwin/core-common";
+import { Angle, AngleSweep, Constant, Ellipsoid, EllipsoidPatch, Point3d, Range1d, Range3d, Ray3d, Transform, Vector3d, } from "@itwin/core-geometry";
 import { ApproximateTerrainHeights } from "../../ApproximateTerrainHeights";
-import { IModelApp } from "../../IModelApp";
 import { PlanarClipMaskState } from "../../PlanarClipMaskState";
 import { FeatureSymbology } from "../../render/FeatureSymbology";
-import { BingElevationProvider, createDefaultViewFlagOverrides, EllipsoidTerrainProvider, getCesiumTerrainProvider, MapCartoRectangle, MapTile, MapTileLoader, PlanarTilePatch, QuadId, RealityTileDrawArgs, RealityTileTree, TileTreeLoadStatus, TileTreeReference, UpsampledMapTile, WebMercatorTilingScheme, } from "../internal";
+import { BingElevationProvider, createDefaultViewFlagOverrides, createMapLayerTreeReference, EllipsoidTerrainProvider, getCesiumTerrainProvider, GraphicsCollectorDrawArgs, ImageryMapTileTree, MapCartoRectangle, MapTile, MapTileLoader, ModelMapLayerTileTreeReference, PlanarTilePatch, QuadId, RealityTileDrawArgs, RealityTileTree, TileTreeLoadStatus, TileTreeReference, UpsampledMapTile, WebMercatorTilingScheme, } from "../internal";
 const scratchPoint = Point3d.create();
 const scratchCorners = [Point3d.createZero(), Point3d.createZero(), Point3d.createZero(), Point3d.createZero(), Point3d.createZero(), Point3d.createZero(), Point3d.createZero(), Point3d.createZero()];
 const scratchCorner = Point3d.createZero();
@@ -27,6 +26,8 @@ export class MapTileTree extends RealityTileTree {
         this.sourceTilingScheme = sourceTilingScheme;
         this.imageryTrees = [];
         this._layerSettings = new Map();
+        this._modelIdToIndex = new Map();
+        this.layerClassifiers = new Map();
         this._mercatorTilingScheme = new WebMercatorTilingScheme();
         this._mercatorFractionToDb = this._mercatorTilingScheme.computeMercatorFractionToDb(ecefToDb, bimElevationBias, params.iModel, applyTerrain);
         const quadId = new QuadId(sourceTilingScheme.rootLevel, 0, 0);
@@ -44,6 +45,7 @@ export class MapTileTree extends RealityTileTree {
         if (applyTerrain) {
             this.minEarthEllipsoid = Ellipsoid.createCenterMatrixRadii(this.globeOrigin, this.ecefToDb.matrix, Constant.earthRadiusWGS84.equator + globalHeightRange.low, Constant.earthRadiusWGS84.equator + globalHeightRange.low, Constant.earthRadiusWGS84.polar + globalHeightRange.low);
             this.maxEarthEllipsoid = Ellipsoid.createCenterMatrixRadii(this.globeOrigin, this.ecefToDb.matrix, Constant.earthRadiusWGS84.equator + globalHeightRange.high, Constant.earthRadiusWGS84.equator + globalHeightRange.high, Constant.earthRadiusWGS84.polar + globalHeightRange.high);
+            this.produceGeometry = id.produceGeometry;
         }
         else {
             this.minEarthEllipsoid = this.earthEllipsoid;
@@ -66,19 +68,28 @@ export class MapTileTree extends RealityTileTree {
     tileFromQuadId(quadId) {
         return this._rootTile.tileFromQuadId(quadId);
     }
-    addImageryLayer(tree, settings) {
-        const maxLayers = IModelApp.renderSystem.maxRealityImageryLayers;
-        if (this.imageryTrees.length < maxLayers) {
-            this.imageryTrees.push(tree);
-            this._layerSettings.set(tree.modelId, settings);
-        }
-        else {
-            // TBD -- Notify user that layers is being ignored?
-        }
+    addImageryLayer(tree, settings, index) {
+        this.imageryTrees.push(tree);
+        this._layerSettings.set(tree.modelId, settings);
+        this._modelIdToIndex.set(tree.modelId, index);
+    }
+    addModelLayer(layerTreeRef, context) {
+        const classifier = context.addPlanarClassifier(`MapLayer ${this.modelId}-${layerTreeRef.layerIndex}`, layerTreeRef);
+        if (classifier)
+            this.layerClassifiers.set(layerTreeRef.layerIndex, classifier);
     }
-    clearImageryLayers() {
+    collectClassifierGraphics(args, selectedTiles) {
+        super.collectClassifierGraphics(args, selectedTiles);
+        this.layerClassifiers.forEach((layerClassifier) => {
+            if (!(args instanceof GraphicsCollectorDrawArgs))
+                layerClassifier.collectGraphics(args.context, { modelId: this.modelId, tiles: selectedTiles, location: args.location, isPointCloud: this.isPointCloud });
+        });
+    }
+    clearImageryTreesAndClassifiers() {
         this.imageryTrees.length = 0;
         this._layerSettings.clear();
+        this._modelIdToIndex.clear();
+        this.layerClassifiers.clear();
     }
     get isTransparent() {
         return this.mapTransparent || this.baseTransparent;
@@ -90,9 +101,12 @@ export class MapTileTree extends RealityTileTree {
         return maxDepth;
     }
     createPlanarChild(params, quadId, corners, normal, rectangle, chordHeight, heightRange) {
+        const childAvailable = this.mapLoader.isTileAvailable(quadId);
+        if (!childAvailable && this.produceGeometry)
+            return undefined;
         const patch = new PlanarTilePatch(corners, normal, chordHeight);
         const cornerNormals = this.getCornerRays(rectangle);
-        const ctor = this.mapLoader.isTileAvailable(quadId) ? MapTile : UpsampledMapTile;
+        const ctor = childAvailable ? MapTile : UpsampledMapTile;
         return new ctor(params, this, quadId, patch, rectangle, heightRange, cornerNormals);
     }
     createGlobeChild(params, quadId, _rangeCorners, rectangle, ellipsoidPatch, heightRange) {
@@ -267,10 +281,8 @@ export class MapTileTree extends RealityTileTree {
         return this.sourceTilingScheme.tileXYToRectangle(quadId.column, quadId.row, quadId.level);
     }
     getLayerIndex(imageryTreeId) {
-        for (let index = 0; index < this.imageryTrees.length; index++)
-            if (imageryTreeId === this.imageryTrees[index].modelId)
-                return index;
-        return -1;
+        const index = this._modelIdToIndex.get(imageryTreeId);
+        return index === undefined ? -1 : index;
     }
     getLayerTransparency(imageryTreeId) {
         const layerSettings = this._layerSettings.get(imageryTreeId);
@@ -309,7 +321,7 @@ class MapTreeSupplier {
             cmp = compareStringsOrUndefined(lhs.maskModelIds, rhs.maskModelIds);
             if (0 === cmp) {
                 cmp = compareBooleans(lhs.isOverlay, rhs.isOverlay);
-                if (0 === cmp && !lhs.isOverlay) {
+                if (0 === cmp) {
                     cmp = compareBooleans(lhs.wantSkirts, rhs.wantSkirts);
                     if (0 === cmp) {
                         cmp = compareBooleans(lhs.wantNormals, rhs.wantNormals);
@@ -331,8 +343,11 @@ class MapTreeSupplier {
                                                         cmp = compareNumbers(lhs.terrainHeightOrigin, rhs.terrainHeightOrigin);
                                                         if (0 === cmp) {
                                                             cmp = compareNumbers(lhs.terrainHeightOriginMode, rhs.terrainHeightOriginMode);
-                                                            if (0 === cmp)
+                                                            if (0 === cmp) {
                                                                 cmp = compareNumbers(lhs.terrainExaggeration, rhs.terrainExaggeration);
+                                                                if (0 === cmp)
+                                                                    cmp = compareBooleansOrUndefined(lhs.produceGeometry, rhs.produceGeometry);
+                                                            }
                                                         }
                                                     }
                                                 }
@@ -400,7 +415,7 @@ const mapTreeSupplier = new MapTreeSupplier();
  */
 export class MapTileTreeReference extends TileTreeReference {
     constructor(settings, _baseLayerSettings, _layerSettings, iModel, tileUserId, isOverlay, _isDrape, _overrideTerrainDisplay) {
-        var _a;
+        var _a, _b;
         super();
         this._baseLayerSettings = _baseLayerSettings;
         this._layerSettings = _layerSettings;
@@ -408,7 +423,7 @@ export class MapTileTreeReference extends TileTreeReference {
         this._isDrape = _isDrape;
         this._overrideTerrainDisplay = _overrideTerrainDisplay;
         this._baseImageryLayerIncluded = false;
-        this._imageryTrees = new Array();
+        this._layerTrees = new Array();
         this._baseTransparent = false;
         this._tileUserId = tileUserId;
         this._settings = settings;
@@ -416,7 +431,7 @@ export class MapTileTreeReference extends TileTreeReference {
         let tree;
         if (!isOverlay && this._baseLayerSettings !== undefined) {
             if (this._baseLayerSettings instanceof MapLayerSettings) {
-                tree = IModelApp.mapLayerFormatRegistry.createImageryMapLayerTree(this._baseLayerSettings, 0, iModel);
+                tree = createMapLayerTreeReference(this._baseLayerSettings, 0, iModel);
                 this._baseTransparent = this._baseLayerSettings.transparency > 0;
             }
             else {
@@ -425,16 +440,25 @@ export class MapTileTreeReference extends TileTreeReference {
             }
         }
         if (this._baseImageryLayerIncluded = (undefined !== tree))
-            this._imageryTrees.push(tree);
+            this._layerTrees.push(tree);
         for (let i = 0; i < this._layerSettings.length; i++)
-            if (undefined !== (tree = IModelApp.mapLayerFormatRegistry.createImageryMapLayerTree(this._layerSettings[i], i + 1, iModel)))
-                this._imageryTrees.push(tree);
+            if (undefined !== (tree = createMapLayerTreeReference(this._layerSettings[i], i + 1, iModel)))
+                this._layerTrees.push(tree);
         if (this._settings.planarClipMask && this._settings.planarClipMask.isValid)
             this._planarClipMask = PlanarClipMaskState.create(this._settings.planarClipMask);
+        if (this._overrideTerrainDisplay && ((_b = this._overrideTerrainDisplay()) === null || _b === void 0 ? void 0 : _b.produceGeometry))
+            this.collectTileGeometry = (collector) => this._collectTileGeometry(collector);
     }
     get isGlobal() { return true; }
     get baseColor() { return this._baseColor; }
     get planarclipMaskPriority() { return PlanarClipMaskPriority.BackgroundMap; }
+    _createGeometryTreeReference() {
+        if (!this._settings.applyTerrain || this._isDrape)
+            return undefined; // Don't bother generating non-terrain (flat) geometry.
+        const ref = new MapTileTreeReference(this._settings, undefined, [], this._iModel, this._tileUserId, false, false, () => { return { produceGeometry: true }; });
+        assert(undefined !== ref.collectTileGeometry);
+        return ref;
+    }
     /** Terrain  tiles do not contribute to the range used by "fit view". */
     unionFitRange(_range) { }
     get settings() { return this._settings; }
@@ -447,7 +471,7 @@ export class MapTileTreeReference extends TileTreeReference {
         let tree;
         this._baseLayerSettings = baseLayerSettings;
         if (baseLayerSettings instanceof MapLayerSettings) {
-            tree = IModelApp.mapLayerFormatRegistry.createImageryMapLayerTree(baseLayerSettings, 0, this._iModel);
+            tree = createMapLayerTreeReference(baseLayerSettings, 0, this._iModel);
             this._baseColor = undefined;
             this._baseTransparent = baseLayerSettings.transparency > 0;
         }
@@ -457,13 +481,13 @@ export class MapTileTreeReference extends TileTreeReference {
         }
         if (tree) {
             if (this._baseImageryLayerIncluded)
-                this._imageryTrees[0] = tree;
+                this._layerTrees[0] = tree;
             else
-                this._imageryTrees.splice(0, 0, tree);
+                this._layerTrees.splice(0, 0, tree);
         }
         else {
             if (this._baseImageryLayerIncluded)
-                this._imageryTrees.shift();
+                this._layerTrees.shift();
         }
         this._baseImageryLayerIncluded = tree !== undefined;
         this.clearLayers();
@@ -474,11 +498,11 @@ export class MapTileTreeReference extends TileTreeReference {
     setLayerSettings(layerSettings) {
         this._layerSettings = layerSettings;
         const baseLayerIndex = this._baseImageryLayerIncluded ? 1 : 0;
-        this._imageryTrees.length = Math.min(layerSettings.length + baseLayerIndex, this._imageryTrees.length); // Truncate if number of layers reduced.
+        this._layerTrees.length = Math.min(layerSettings.length + baseLayerIndex, this._layerTrees.length); // Truncate if number of layers reduced.
         for (let i = 0; i < layerSettings.length; i++) {
             const treeIndex = i + baseLayerIndex;
-            if (treeIndex >= this._imageryTrees.length || !this._imageryTrees[treeIndex].layerSettings.displayMatches(layerSettings[i]))
-                this._imageryTrees[treeIndex] = IModelApp.mapLayerFormatRegistry.createImageryMapLayerTree(layerSettings[i], treeIndex, this._iModel);
+            if (treeIndex >= this._layerTrees.length || !this._layerTrees[treeIndex].layerSettings.displayMatches(layerSettings[i]))
+                this._layerTrees[treeIndex] = createMapLayerTreeReference(layerSettings[i], treeIndex, this._iModel);
         }
         this.clearLayers();
     }
@@ -492,7 +516,7 @@ export class MapTileTreeReference extends TileTreeReference {
     }
     get _isLoadingComplete() {
         // Wait until drape tree is fully loaded too.
-        for (const drapeTree of this._imageryTrees)
+        for (const drapeTree of this._layerTrees)
             if (!drapeTree.isLoadingComplete)
                 return false;
         return super._isLoadingComplete;
@@ -509,7 +533,7 @@ export class MapTileTreeReference extends TileTreeReference {
         }
         const id = {
             tileUserId: this._tileUserId,
-            applyTerrain: this.settings.applyTerrain && !this.isOverlay && !this._isDrape,
+            applyTerrain: this.settings.applyTerrain && !this._isDrape,
             terrainProviderName: this.settings.terrainSettings.providerName,
             terrainHeightOrigin: this.settings.terrainSettings.heightOrigin,
             terrainHeightOriginMode: this.settings.terrainSettings.heightOriginMode,
@@ -525,12 +549,14 @@ export class MapTileTreeReference extends TileTreeReference {
             baseTransparent: this._baseTransparent,
             mapTransparent: this.settings.transparency > 0,
             maskModelIds: (_b = this._planarClipMask) === null || _b === void 0 ? void 0 : _b.settings.compressedModelIds,
+            produceGeometry: false,
         };
         if (undefined !== this._overrideTerrainDisplay) {
             const ovr = this._overrideTerrainDisplay();
             if (undefined !== ovr) {
                 id.wantSkirts = (_c = ovr.wantSkirts) !== null && _c !== void 0 ? _c : id.wantSkirts;
                 id.wantNormals = (_d = ovr.wantNormals) !== null && _d !== void 0 ? _d : id.wantNormals;
+                id.produceGeometry = ovr.produceGeometry === true;
             }
         }
         return this._iModel.tiles.getTileTreeOwner(id, mapTreeSupplier);
@@ -538,30 +564,33 @@ export class MapTileTreeReference extends TileTreeReference {
     getLayerImageryTreeRef(index) {
         const baseLayerIndex = this._baseImageryLayerIncluded ? 1 : 0;
         const treeIndex = index + baseLayerIndex;
-        return index < 0 || treeIndex >= this._imageryTrees.length ? undefined : this._imageryTrees[treeIndex];
+        return index < 0 || treeIndex >= this._layerTrees.length ? undefined : this._layerTrees[treeIndex];
     }
-    initializeImagery() {
+    initializeLayers(context) {
         const tree = this.treeOwner.load();
         if (undefined === tree)
             return false; // Not loaded yet.
         tree.imageryTrees.length = 0;
-        if (0 === this._imageryTrees.length)
+        if (0 === this._layerTrees.length)
             return !this.isOverlay;
-        let treeIndex = this._imageryTrees.length - 1;
+        let treeIndex = this._layerTrees.length - 1;
         // Start displaying at the highest completely opaque layer...
         for (; treeIndex >= 1; treeIndex--) {
-            const imageryTreeRef = this._imageryTrees[treeIndex];
-            const layerSettings = imageryTreeRef.layerSettings;
-            if (layerSettings.visible && !imageryTreeRef.layerSettings.allSubLayersInvisible && !layerSettings.transparentBackground && 0 === layerSettings.transparency)
+            const layerTreeRef = this._layerTrees[treeIndex];
+            if (layerTreeRef.isOpaque)
                 break; // This layer is completely opaque and will obscure all others so ignore lower ones.
         }
-        for (; treeIndex < this._imageryTrees.length; treeIndex++) {
-            const imageryTreeRef = this._imageryTrees[treeIndex];
-            if (TileTreeLoadStatus.NotFound !== imageryTreeRef.treeOwner.loadStatus && imageryTreeRef.layerSettings.visible && !imageryTreeRef.layerSettings.allSubLayersInvisible) {
-                const imageryTree = imageryTreeRef.treeOwner.load();
-                if (undefined === imageryTree)
+        for (; treeIndex < this._layerTrees.length; treeIndex++) {
+            const layerTreeRef = this._layerTrees[treeIndex];
+            if (TileTreeLoadStatus.NotFound !== layerTreeRef.treeOwner.loadStatus && layerTreeRef.layerSettings.visible && !layerTreeRef.layerSettings.allSubLayersInvisible) {
+                const layerTree = layerTreeRef.treeOwner.load();
+                if (undefined === layerTree)
                     return false; // Not loaded yet.
-                tree.addImageryLayer(imageryTree, imageryTreeRef.layerSettings);
+                if (layerTree instanceof ImageryMapTileTree) {
+                    tree.addImageryLayer(layerTree, layerTreeRef.layerSettings, treeIndex);
+                }
+                else if (layerTreeRef instanceof ModelMapLayerTileTreeReference)
+                    tree.addModelLayer(layerTreeRef, context);
             }
         }
         return true;
@@ -571,7 +600,7 @@ export class MapTileTreeReference extends TileTreeReference {
         if (!context.viewFlags.backgroundMap)
             return;
         const tree = this.treeOwner.load();
-        if (undefined === tree || !this.initializeImagery())
+        if (undefined === tree || !this.initializeLayers(context))
             return; // Not loaded yet.
         if (this._planarClipMask && this._planarClipMask.settings.isValid)
             context.addPlanarClassifier(tree.modelId, undefined, this._planarClipMask);
@@ -587,13 +616,14 @@ export class MapTileTreeReference extends TileTreeReference {
         const args = this.createDrawArgs(context);
         if (undefined !== args)
             tree.draw(args);
-        tree.clearImageryLayers();
+        tree.clearImageryTreesAndClassifiers();
     }
     createDrawArgs(context) {
         const args = super.createDrawArgs(context);
         if (undefined === args)
             return undefined;
-        return new RealityTileDrawArgs(args, args.worldToViewMap, args.frustumPlanes);
+        const tree = this.treeOwner.load();
+        return new RealityTileDrawArgs(args, args.worldToViewMap, args.frustumPlanes, undefined, tree === null || tree === void 0 ? void 0 : tree.layerClassifiers);
     }
     getViewFlagOverrides(_tree) {
         return createViewFlagOverrides(false, this._settings.applyTerrain ? undefined : false);
@@ -603,7 +633,7 @@ export class MapTileTreeReference extends TileTreeReference {
     }
     discloseTileTrees(trees) {
         super.discloseTileTrees(trees);
-        this._imageryTrees.forEach((imageryTree) => trees.disclose(imageryTree));
+        this._layerTrees.forEach((imageryTree) => trees.disclose(imageryTree));
         if (this._planarClipMask)
             this._planarClipMask.discloseTileTrees(trees);
     }
@@ -611,7 +641,7 @@ export class MapTileTreeReference extends TileTreeReference {
         const tree = this.treeOwner.tileTree;
         if (undefined === tree || tree.modelId !== mapTreeModelId)
             return undefined;
-        for (const imageryTree of this._imageryTrees)
+        for (const imageryTree of this._layerTrees)
             if (imageryTree.treeOwner.tileTree && imageryTree.treeOwner.tileTree.modelId === layerTreeModelId)
                 return imageryTree;
         return undefined;
@@ -620,16 +650,24 @@ export class MapTileTreeReference extends TileTreeReference {
         const imageryTree = this.imageryTreeFromTreeModelIds(mapTreeModelId, layerTreeModelId);
         return imageryTree === undefined ? imageryTree : imageryTree.layerSettings;
     }
-    async getToolTip(hit) {
+    // Utility method that execute the provided function for every *imagery* tiles under a given HotDetail object.
+    async forEachImageryTileHit(hit, func) {
         const tree = this.treeOwner.tileTree;
-        // eslint-disable-next-line @typescript-eslint/unbound-method
         if (undefined === tree || hit.iModel !== tree.iModel || tree.modelId !== hit.modelId || !hit.viewport || !hit.viewport.view.is3d)
             return undefined;
         const backgroundMapGeometry = hit.viewport.displayStyle.getBackgroundMapGeometry();
         if (undefined === backgroundMapGeometry)
             return undefined;
         const worldPoint = hit.hitPoint.clone();
-        const cartoGraphic = await backgroundMapGeometry.dbToCartographicFromGcs(worldPoint);
+        let cartoGraphic;
+        try {
+            cartoGraphic = await backgroundMapGeometry.dbToCartographicFromGcs(worldPoint);
+        }
+        catch {
+        }
+        if (!cartoGraphic) {
+            return undefined;
+        }
         const strings = [];
         const imageryTreeRef = this.imageryTreeFromTreeModelIds(hit.modelId, hit.sourceId);
         if (imageryTreeRef !== undefined) {
@@ -641,23 +679,72 @@ export class MapTileTreeReference extends TileTreeReference {
                     const imageryTree = imageryTreeRef.treeOwner.tileTree;
                     if (imageryTree) {
                         for (const imageryTile of terrainTile.imageryTiles) {
-                            if (imageryTree === imageryTile.imageryTree && imageryTile.rectangle.containsCartographic(cartoGraphic))
-                                await imageryTree.imageryLoader.getToolTip(strings, imageryTile.quadId, cartoGraphic, imageryTree);
+                            if (imageryTree === imageryTile.imageryTree && imageryTile.rectangle.containsCartographic(cartoGraphic)) {
+                                try {
+                                    await func(imageryTreeRef, imageryTile.quadId, cartoGraphic, imageryTree);
+                                }
+                                catch {
+                                    // continue iterating even though we got a failure.
+                                }
+                            }
                         }
                     }
                 }
             }
         }
-        strings.push(`Latitude: ${cartoGraphic.latitudeDegrees.toFixed(4)}`);
-        strings.push(`Longitude: ${cartoGraphic.longitudeDegrees.toFixed(4)}`);
-        if (this.settings.applyTerrain) {
-            const geodeticHeight = (cartoGraphic.height - tree.bimElevationBias) / tree.terrainExaggeration;
-            strings.push(`Height (Meters) Geodetic: ${geodeticHeight.toFixed(1)} Sea Level: ${(geodeticHeight - tree.geodeticOffset).toFixed(1)}`);
+    }
+    async getToolTip(hit) {
+        const tree = this.treeOwner.tileTree;
+        if (tree.modelId !== hit.modelId)
+            return undefined;
+        let carto;
+        const strings = [];
+        const getTooltipFunc = async (imageryTreeRef, quadId, cartoGraphic, imageryTree) => {
+            strings.push(`Imagery Layer: ${imageryTreeRef.layerSettings.name}`);
+            carto = cartoGraphic;
+            await imageryTree.imageryLoader.getToolTip(strings, quadId, cartoGraphic, imageryTree);
+        };
+        try {
+            await this.forEachImageryTileHit(hit, getTooltipFunc);
+        }
+        catch {
+            // No results added
+        }
+        if (carto) {
+            strings.push(`Latitude: ${carto.latitudeDegrees.toFixed(4)}`);
+            strings.push(`Longitude: ${carto.longitudeDegrees.toFixed(4)}`);
+            if (this.settings.applyTerrain && tree.terrainExaggeration !== 0.0) {
+                const geodeticHeight = (carto.height - tree.bimElevationBias) / tree.terrainExaggeration;
+                strings.push(`Height (Meters) Geodetic: ${geodeticHeight.toFixed(1)} Sea Level: ${(geodeticHeight - tree.geodeticOffset).toFixed(1)}`);
+            }
         }
         const div = document.createElement("div");
         div.innerHTML = strings.join("<br>");
         return div;
     }
+    async getMapFeatureInfo(hit) {
+        const tree = this.treeOwner.tileTree;
+        if (undefined === tree || hit.iModel !== tree.iModel || tree.modelId !== hit.modelId || !hit.viewport || !hit.viewport.view.is3d)
+            return undefined;
+        const info = [];
+        const imageryTreeRef = this.imageryTreeFromTreeModelIds(hit.modelId, hit.sourceId);
+        if (imageryTreeRef !== undefined) {
+            const getFeatureInfoFunc = async (_imageryTreeRef, quadId, cartoGraphic, imageryTree) => {
+                try {
+                    await imageryTree.imageryLoader.getMapFeatureInfo(info, quadId, cartoGraphic, imageryTree);
+                }
+                catch {
+                }
+            };
+            try {
+                await this.forEachImageryTileHit(hit, getFeatureInfoFunc);
+            }
+            catch {
+                // No results added
+            }
+        }
+        return info;
+    }
     /** Add logo cards to logo div. */
     addLogoCards(cards, vp) {
         const tree = this.treeOwner.tileTree;
@@ -665,7 +752,7 @@ export class MapTileTreeReference extends TileTreeReference {
         if (tree) {
             if (undefined !== (logo = tree.mapLoader.terrainProvider.getLogo()))
                 cards.appendChild(logo);
-            for (const imageryTreeRef of this._imageryTrees) {
+            for (const imageryTreeRef of this._layerTrees) {
                 if (imageryTreeRef.layerSettings.visible) {
                     const imageryTree = imageryTreeRef.treeOwner.tileTree;
                     if (imageryTree && (undefined !== (logo = imageryTree.getLogo(vp))))