bruce-cesium 4.1.6 → 4.1.8

package/dist/bruce-cesium.es5.js

@@ -1,6 +1,6 @@
 import { BruceEvent, Cartes, Carto, Entity as Entity$1, Geometry, Tileset, MathUtils, LRUCache, ProjectViewTile, DelayQueue, ZoomControl, Style, EntityTag, Calculator, EntityLod, EntityType, ClientFile, ObjectUtils, Bounds, Api, EntityRelationType, ENVIRONMENT, EntityHistoricData, EntityCoords, EntitySource, MenuItem, EntityRelation, ProgramKey, AbstractApi, ProjectViewBookmark, EntityAttachment, EntityAttachmentType, EntityAttribute, ProjectView, ProjectViewLegacyTile, Camera } from 'bruce-models';
 import * as Cesium from 'cesium';
-import { Cartographic, Cartesian2, Math as Math$1, Cartesian3, CallbackProperty, Color, HeightReference, Rectangle, DistanceDisplayCondition, NearFarScalar, Model, ColorMaterialProperty, Entity, HorizontalOrigin, VerticalOrigin, ConstantProperty, ConstantPositionProperty, ClassificationType, ArcType, CornerType, ShadowMode, PolygonHierarchy, PolylineGraphics, ColorBlendMode, HeadingPitchRoll, Transforms, JulianDate, Primitive, Cesium3DTileFeature, SceneMode, GeoJsonDataSource, Cesium3DTileColorBlendMode, HeadingPitchRange, Ion, Cesium3DTileStyle, KmlDataSource, SceneTransforms, OrthographicFrustum, EasingFunction, EllipsoidTerrainProvider, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, IonImageryProvider, CesiumTerrainProvider, Cesium3DTileset, Matrix4, Matrix3, IonResource, CesiumInspector, defined, ClockRange, EllipsoidGeodesic, sampleTerrainMostDetailed, BoundingSphere, GeometryInstance, PolygonPipeline, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, ScreenSpaceEventHandler, ScreenSpaceEventType, CzmlDataSource, Quaternion, Intersect } from 'cesium';
+import { Cartographic, Cartesian2, Math as Math$1, Cartesian3, CallbackProperty, Color, HeightReference, Rectangle, JulianDate, SceneMode, Entity, Primitive, Cesium3DTileFeature, DistanceDisplayCondition, NearFarScalar, Model, ColorMaterialProperty, HorizontalOrigin, VerticalOrigin, ConstantProperty, ConstantPositionProperty, ClassificationType, ArcType, CornerType, ShadowMode, PolygonHierarchy, PolylineGraphics, ColorBlendMode, HeadingPitchRoll, Transforms, GeoJsonDataSource, Cesium3DTileColorBlendMode, HeadingPitchRange, Ion, Cesium3DTileStyle, KmlDataSource, SceneTransforms, OrthographicFrustum, EasingFunction, EllipsoidTerrainProvider, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, IonImageryProvider, CesiumTerrainProvider, CesiumInspector, defined, ClockRange, EllipsoidGeodesic, sampleTerrainMostDetailed, Cesium3DTileset, Matrix4, Matrix3, IonResource, PolygonPipeline, BoundingSphere, GeometryInstance, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, ScreenSpaceEventHandler, ScreenSpaceEventType, CzmlDataSource, Quaternion, Intersect } from 'cesium';
 
 /*! *****************************************************************************
 Copyright (c) Microsoft Corporation. All rights reserved.
@@ -4030,12 +4030,13 @@ var TERRAIN_HEIGHT_TOLERANCE_LOW_ENTITY_THRESHOLD = 100;
  * @returns
  */
 var getTerrainOffset = function (viewer, pos3d) {
+    var _a;
     if (!viewer.terrainProvider || viewer.terrainProvider["ready"] == false) {
         return null;
     }
-    var terrain = ViewUtils.GatherTerrainTile({
+    var terrain = (_a = ViewUtils.GatherTerrainTile({
         viewer: viewer
-    }).terrain;
+    })) === null || _a === void 0 ? void 0 : _a.terrain;
     if (!terrain || terrain.tilesetId == ProjectViewTile.EDefaultTerrain.FlatTerrain) {
         return 0;
     }
@@ -4044,8 +4045,8 @@ var getTerrainOffset = function (viewer, pos3d) {
     var keys = Array.from(_terrainCache.Entries());
     var tolerance = viewer.entities.values.length > TERRAIN_HEIGHT_TOLERANCE_LOW_ENTITY_THRESHOLD ? TERRAIN_HEIGHT_TOLERANCE : TERRAIN_HEIGHT_TOLERANCE_LOW_COUNT;
     for (var i = 0; i < keys.length; i++) {
-        var _a = keys[i], key_1 = _a[0], offset_1 = _a[1];
-        var _b = key_1.split("_"), terrainId2 = _b[0], x = _b[1], y = _b[2], z = _b[3];
+        var _b = keys[i], key_1 = _b[0], offset_1 = _b[1];
+        var _c = key_1.split("_"), terrainId2 = _c[0], x = _c[1], y = _c[2], z = _c[3];
         if (terrainId2 != terrainId) {
             continue;
         }
@@ -4102,13 +4103,13 @@ var adjustPos3d = function (viewer, heightRef, pos3d) {
     return newPos3d;
 };
 function isFlatTerrain(viewer) {
-    var _a;
+    var _a, _b;
     if (!viewer) {
         return false;
     }
-    return ((_a = ViewUtils.GatherTerrainTile({
+    return ((_b = (_a = ViewUtils.GatherTerrainTile({
         viewer: viewer
-    }).terrain) === null || _a === void 0 ? void 0 : _a.tilesetId) == ProjectViewTile.EDefaultTerrain.FlatTerrain;
+    })) === null || _a === void 0 ? void 0 : _a.terrain) === null || _b === void 0 ? void 0 : _b.tilesetId) == ProjectViewTile.EDefaultTerrain.FlatTerrain;
 }
 function getValue(viewer, obj) {
     if (obj === null || obj === void 0 ? void 0 : obj.getValue) {
@@ -4232,12 +4233,12 @@ function computeBoundingSphereFromPositions(positions) {
     return BoundingSphere.fromPoints(positions);
 }
 function shouldCullEntity(viewer, cEntity) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     var camera = viewer.scene.camera;
     var boundingSphere;
-    var terrainId = (_b = (_a = ViewUtils.GatherTerrainTile({
+    var terrainId = (_c = (_b = (_a = ViewUtils.GatherTerrainTile({
         viewer: viewer
-    }).terrain) === null || _a === void 0 ? void 0 : _a.tilesetId) !== null && _b !== void 0 ? _b : ProjectViewTile.EDefaultTerrain.FlatTerrain;
+    })) === null || _a === void 0 ? void 0 : _a.terrain) === null || _b === void 0 ? void 0 : _b.tilesetId) !== null && _c !== void 0 ? _c : ProjectViewTile.EDefaultTerrain.FlatTerrain;
     var cacheKey = terrainId + cEntity.id;
     var cacheData = boundingSphereCache.Get(cacheKey);
     if (cacheData) {
@@ -4245,7 +4246,7 @@ function shouldCullEntity(viewer, cEntity) {
     }
     else {
         var positions = getPositionsFromEntity(viewer, cEntity);
-        if ((_c = positions === null || positions === void 0 ? void 0 : positions.positions) === null || _c === void 0 ? void 0 : _c.length) {
+        if ((_d = positions === null || positions === void 0 ? void 0 : positions.positions) === null || _d === void 0 ? void 0 : _d.length) {
             // Sphere calculated from entity positions.
             // We will evaluate the visual now to see if the sphere should be counted, for example 3D models might not be loaded yet.
             var sphere = computeBoundingSphereFromPositions(positions.positions);
@@ -4645,6 +4646,235 @@ function OneTimeError(key, message) {
     }
 }
 
+/**
+ * Util for simplifying geometry on the fly.
+ */
+var SimplifyGeometry;
+(function (SimplifyGeometry) {
+    /**
+     * Returns the total number of points in the geometry.
+     * @param geometry
+     * @returns
+     */
+    function CountPoints(geometry) {
+        var count = 0;
+        var traverse = function (geometry) {
+            if (geometry.MultiGeometry) {
+                for (var i = 0; i < geometry.MultiGeometry.length; i++) {
+                    traverse(geometry.MultiGeometry[i]);
+                }
+            }
+            else if (geometry.Polygon) {
+                for (var i = 0; i < geometry.Polygon.length; i++) {
+                    var polygon = geometry.Polygon[i];
+                    count += Geometry.ParsePoints(polygon.LinearRing).length;
+                }
+            }
+            else if (geometry.LineString) {
+                count += Geometry.ParsePoints(geometry.LineString).length;
+            }
+            else if (geometry.Point) {
+                count += 1;
+            }
+        };
+        traverse(geometry);
+        return count;
+    }
+    SimplifyGeometry.CountPoints = CountPoints;
+    /**
+     * Simplifies input geometry.
+     * This will turn it into GeoJSON, run it through turf, then back to Bruce geometry.
+     * @param geometry
+     */
+    function Simplify(geometry, tolerance) {
+        if (!geometry || tolerance <= 0 || !turf || !turf.simplify) {
+            return geometry;
+        }
+        var geoJson = toGeoJson(geometry);
+        // Union overlapping shapes
+        var combinedFeatures = [];
+        geoJson.features.forEach(function (feature) {
+            var unioned = false;
+            for (var i = 0; i < combinedFeatures.length; i++) {
+                try {
+                    var unionResult = turf.union(combinedFeatures[i], feature);
+                    if (unionResult) {
+                        combinedFeatures[i] = unionResult;
+                        unioned = true;
+                        break;
+                    }
+                }
+                catch (error) {
+                    // Ignore the error if union fails, and continue
+                }
+            }
+            if (!unioned) {
+                combinedFeatures.push(feature);
+            }
+        });
+        geoJson = {
+            type: "FeatureCollection",
+            features: combinedFeatures,
+        };
+        // Simplify the combined result.
+        var simplified = turf.simplify(geoJson, { tolerance: tolerance, highQuality: true, mutate: true });
+        return fromGeoJson(simplified);
+    }
+    SimplifyGeometry.Simplify = Simplify;
+})(SimplifyGeometry || (SimplifyGeometry = {}));
+/**
+ * Converts Bruce geometry to GeoJSON.
+ * @param geometry
+ * @returns
+ */
+function toGeoJson(geometry) {
+    var features = [];
+    var excludeAltitude = false;
+    var areCoordinatesEqual = function (coord1, coord2) {
+        return coord1[0] === coord2[0] && coord1[1] === coord2[1] && (coord1[2] === coord2[2] || (coord1.length < 3 && coord2.length < 3));
+    };
+    var removeConsecutiveDuplicates = function (coordinates) {
+        return coordinates.filter(function (coord, index, array) {
+            return index === 0 || !areCoordinatesEqual(coord, array[index - 1]);
+        });
+    };
+    var closePolygonCoordinates = function (coordinates) {
+        if (coordinates.length > 0 && !areCoordinatesEqual(coordinates[0], coordinates[coordinates.length - 1])) {
+            var firstPointCopy = [].concat(coordinates[0]);
+            coordinates.push(firstPointCopy);
+        }
+        return coordinates;
+    };
+    var processGeometry = function (geometry) {
+        var _a, _b;
+        var feature = {
+            type: "Feature",
+            properties: {},
+            geometry: null
+        };
+        if ((_a = geometry.MultiGeometry) === null || _a === void 0 ? void 0 : _a.length) {
+            geometry.MultiGeometry.forEach(function (geo) { return processGeometry(geo); });
+            return;
+        }
+        else if ((_b = geometry.Polygon) === null || _b === void 0 ? void 0 : _b.length) {
+            var sortedPolygons = geometry.Polygon.sort(function (a, b) {
+                return a.Facing === Geometry.EPolygonRingType.Boundaries ? -1 : 1;
+            });
+            var coordinates = sortedPolygons.map(function (polygonRing) {
+                return closePolygonCoordinates(removeConsecutiveDuplicates(polygonRing.LinearRing.split(' ').map(function (coord) {
+                    var _a = coord.split(',').map(Number), lon = _a[0], lat = _a[1], alt = _a[2];
+                    return [lon, lat, alt !== undefined ? alt : 0];
+                })));
+            });
+            // Check if the polygon has at least 4 points.
+            var isValidPolygon = coordinates.every(function (polygon) { return polygon.length >= 4; });
+            if (!isValidPolygon) {
+                // Perhaps try other geometry instead of returning?
+                return;
+            }
+            feature.geometry = {
+                type: "Polygon",
+                coordinates: coordinates,
+            };
+        }
+        else if (geometry.LineString) {
+            var coordinates = removeConsecutiveDuplicates(geometry.LineString.split(' ').map(function (coord) {
+                var _a = coord.split(',').map(Number), lon = _a[0], lat = _a[1], alt = _a[2];
+                return [lon, lat, alt !== undefined ? alt : 0];
+            }));
+            // Check if the polyline has at least 2 points.
+            if (coordinates.length < 2) {
+                // Perhaps try other geometry instead of returning?
+                return;
+            }
+            feature.geometry = {
+                type: "LineString",
+                coordinates: coordinates,
+            };
+        }
+        else if (geometry.Point) {
+            var _c = geometry.Point.split(',').map(Number), lon = _c[0], lat = _c[1], alt = _c[2];
+            var coordinates = excludeAltitude ? [lon, lat] : [lon, lat, alt !== undefined ? alt : 0];
+            feature.geometry = {
+                type: "Point",
+                coordinates: coordinates,
+            };
+        }
+        if (feature.geometry) {
+            features.push(feature);
+        }
+    };
+    try {
+        processGeometry(geometry);
+    }
+    catch (e) {
+        console.error(e);
+        return null;
+    }
+    var geoJson = {
+        type: "FeatureCollection",
+        features: features,
+    };
+    return geoJson;
+}
+/**
+ * Converts GeoJSON to Bruce geometry.
+ * @param geoJson
+ * @returns
+ */
+function fromGeoJson(geoJson) {
+    if (geoJson.features.length === 0) {
+        return {};
+    }
+    var geometry = {
+        Polygon: [],
+        MultiGeometry: []
+    };
+    if (geoJson.features.length > 1) {
+        geoJson.features.forEach(function (feature) {
+            var featureGeometry = fromGeoJson({
+                type: "FeatureCollection",
+                features: [feature]
+            });
+            geometry.MultiGeometry.push(featureGeometry);
+        });
+        return geometry;
+    }
+    var feature = geoJson.features[0];
+    var _a = feature.geometry, type = _a.type, coordinates = _a.coordinates;
+    switch (type) {
+        case "Polygon":
+            coordinates.forEach(function (polygon, index) {
+                var linearRing = polygon.map(function (coord) { return coord.join(','); }).join(' ');
+                geometry.Polygon.push({
+                    LinearRing: linearRing,
+                    Facing: index === 0 ? Geometry.EPolygonRingType.Boundaries : Geometry.EPolygonRingType.Hole
+                });
+            });
+            break;
+        case "LineString":
+            geometry.LineString = coordinates.map(function (coord) { return coord.join(','); }).join(' ');
+            break;
+        case "Point":
+            geometry.Point = coordinates.join(',');
+            break;
+        case "MultiPolygon":
+            coordinates.forEach(function (multiPolygon) {
+                var multiPolygonGeometry = { Polygon: [] };
+                multiPolygon.forEach(function (polygon, index) {
+                    var linearRing = polygon.map(function (coord) { return coord.join(','); }).join(' ');
+                    multiPolygonGeometry.Polygon.push({
+                        LinearRing: linearRing,
+                        Facing: index === 0 ? Geometry.EPolygonRingType.Boundaries : Geometry.EPolygonRingType.Hole
+                    });
+                });
+                geometry.MultiGeometry.push(multiPolygonGeometry);
+            });
+            break;
+    }
+    return geometry;
+}
+
 function colorToCColor(color) {
     return new Color(color.red ? color.red / 255 : 0, color.green ? color.green / 255 : 0, color.blue ? color.blue / 255 : 0, color.alpha);
 }
@@ -5320,7 +5550,7 @@ var EntityRenderEngine;
     function Render(params) {
         var _a, _b, _c, _d, _e, _f, _g;
         return __awaiter(this, void 0, void 0, function () {
-            var groupRenderParams, i, entity, geometry, updated, cEntities, models, multiGeometry, polygons, polylines, points, i, entity, id, zoomItem, displayType, existingRego, newRenderId, oldRenderId, geometry, mParams, mEntities, i, entity, id, cEntity, _loop_1, i, pParams, pEntities, i, entity, cEntity, pParams, pEntities, i, entity, cEntity, pParams, pEntities, i, entity, cEntity;
+            var groupRenderParams, i, entity, geometry, optimized, updated, cEntities, models, multiGeometry, polygons, polylines, points, i, entity, id, zoomItem, displayType, existingRego, newRenderId, oldRenderId, geometry, mParams, mEntities, i, entity, id, cEntity, _loop_1, i, pParams, pEntities, i, entity, cEntity, pParams, pEntities, i, entity, cEntity, pParams, pEntities, i, entity, cEntity;
             return __generator(this, function (_h) {
                 switch (_h.label) {
                     case 0:
@@ -5339,17 +5569,37 @@ var EntityRenderEngine;
                                 entity: entity,
                                 path: ["Bruce", "VectorGeometry"]
                             });
-                            if (((_a = geometry === null || geometry === void 0 ? void 0 : geometry.MultiGeometry) === null || _a === void 0 ? void 0 : _a.length) == 1) {
-                                // Not migrated to internal, set in both places.
-                                if (entity.geometry) {
-                                    entity.geometry = __assign(__assign(__assign({}, entity.geometry), geometry.MultiGeometry[0]), { MultiGeometry: [] });
-                                    entity.Bruce.VectorGeometry = entity.geometry;
+                            // Optimize geometry if requested.
+                            // This will attempt to merge and simplify before rendering.
+                            // Note that this modifies the Entity object.
+                            if (params.optimizeGeometry) {
+                                if (params.optimizeMinPoints == null) {
+                                    params.optimizeMinPoints = 1000;
                                 }
-                                // Migrated to internal, we'll set it there.
-                                else if (entity.Bruce.VectorGeometry) {
-                                    entity.Bruce.VectorGeometry = __assign(__assign(__assign({}, entity.Bruce.VectorGeometry), geometry.MultiGeometry[0]), { MultiGeometry: [] });
+                                if (geometry && SimplifyGeometry.CountPoints(geometry) >= params.optimizeMinPoints) {
+                                    if (params.optimizeTolerance == null) {
+                                        params.optimizeTolerance = 0.0005;
+                                    }
+                                    optimized = SimplifyGeometry.Simplify(geometry, params.optimizeTolerance);
+                                    if (optimized) {
+                                        // Continue on with the rendering using the optimized geometry.
+                                        geometry = optimized;
+                                        // Dereference the Entity object now that we have done a destructive operation.
+                                        entity = Object.assign({}, entity);
+                                        entity.Bruce = Object.assign({}, entity.Bruce);
+                                        params.entities[i] = entity;
+                                    }
                                 }
                             }
+                            // We are using the new path.
+                            // This ensures we don't have a duplicate.
+                            entity.geometry = null;
+                            if (((_a = geometry === null || geometry === void 0 ? void 0 : geometry.MultiGeometry) === null || _a === void 0 ? void 0 : _a.length) == 1) {
+                                entity.Bruce.VectorGeometry = geometry.MultiGeometry[0];
+                            }
+                            else {
+                                entity.Bruce.VectorGeometry = geometry;
+                            }
                         }
                         updated = new Map();
                         cEntities = new Map();
@@ -5461,7 +5711,7 @@ var EntityRenderEngine;
                                         pParams.entitiesHistoric = params.entitiesHistoric;
                                         zoomItem = pParams.zoomItems[entity.Bruce.ID];
                                         for (j = 0; j < geometry.MultiGeometry.length; j++) {
-                                            subEntity = __assign(__assign({}, entity), { geometry: geometry.MultiGeometry[j], Bruce: __assign(__assign({}, entity.Bruce), { ID: ObjectUtils.UId() }) });
+                                            subEntity = __assign(__assign({}, entity), { geometry: null, Bruce: __assign(__assign({}, entity.Bruce), { ID: ObjectUtils.UId(), VectorGeometry: geometry.MultiGeometry[j] }) });
                                             pParams.zoomItems[subEntity.Bruce.ID] = zoomItem;
                                             pParams.entities.push(subEntity);
                                         }
@@ -11001,7 +11251,7 @@ var EntitiesRenderManager;
         Manager.prototype.renderAsGeojson = function (entities, force) {
             var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
             return __awaiter(this, void 0, void 0, function () {
-                var zoomItem, lods, withLods_1, individuals, style, e_4, entityTypeId, entityType, e_5, pStyle, lStyle, polygonsClamped, bFillColor, cFillColor, bLineColor, cLineColor, lineWidthPx, geojson, notRendered, source, groups, applyStyle, toForceUpdate, register, sEntities, i, cEntity;
+                var zoomItem, lods, withLods_1, individuals, style, e_4, entityTypeId, entityType, e_5, pStyle, lStyle, polygonsClamped, bFillColor, cFillColor, bLineColor, cLineColor, lineWidthPx, i, entity, geometry, optimized, geojson, notRendered, source, groups, applyStyle, toForceUpdate, register, sEntities, i, cEntity;
                 var _this = this;
                 return __generator(this, function (_o) {
                     switch (_o.label) {
@@ -11119,6 +11369,39 @@ var EntitiesRenderManager;
                                 lineWidthPx = 0;
                             }
                             lineWidthPx = Math.round(lineWidthPx);
+                            // If we are flagged to optimize then we'll run through and simplify each entity's geometry.
+                            if (this.item.optimizeGeometry) {
+                                for (i = 0; i < entities.length; i++) {
+                                    entity = entities[i];
+                                    geometry = Entity$1.GetValue({
+                                        entity: entity,
+                                        path: ["Bruce", "VectorGeometry"]
+                                    });
+                                    if (geometry) {
+                                        if (this.item.optimizeMinPoints == null) {
+                                            this.item.optimizeMinPoints = 1000;
+                                        }
+                                        if (SimplifyGeometry.CountPoints(geometry) > this.item.optimizeMinPoints) {
+                                            if (this.item.optimizeTolerance == null) {
+                                                this.item.optimizeTolerance = 0.0005;
+                                            }
+                                            optimized = SimplifyGeometry.Simplify(geometry, this.item.optimizeTolerance);
+                                            if (optimized) {
+                                                // Dereference the Entity object now that we have done a destructive operation.
+                                                entity = Object.assign({}, entity);
+                                                entity.Bruce = Object.assign({}, entity.Bruce);
+                                                entities[i] = entity;
+                                                // Continue on with the rendering using the optimized geometry.
+                                                geometry = optimized;
+                                            }
+                                        }
+                                    }
+                                    // We are using the new path.
+                                    // This ensures we don't have a duplicate.
+                                    entity.geometry = null;
+                                    entity.Bruce.VectorGeometry = geometry;
+                                }
+                            }
                             geojson = Entity$1.ToGeoJson({
                                 entities: entities,
                                 includeUserData: false,
@@ -11352,7 +11635,10 @@ var EntitiesRenderManager;
                                 visualRegister: this.visualsManager,
                                 zoomControl: this.item.CameraZoomSettings,
                                 entitiesHistoric: entitiesHistoric,
-                                force: force
+                                force: force,
+                                optimizeGeometry: this.item.optimizeGeometry,
+                                optimizeMinPoints: this.item.optimizeMinPoints,
+                                optimizeTolerance: this.item.optimizeTolerance,
                             })];
                         case 3:
                             _m = _o.sent(), updated = _m.updated, cEntities = _m.entities;
@@ -25323,7 +25609,7 @@ var ViewRenderEngine;
     ViewRenderEngine.Render = Render;
 })(ViewRenderEngine || (ViewRenderEngine = {}));
 
-var VERSION = "4.1.6";
+var VERSION = "4.1.8";
 
 export { VERSION, CesiumViewMonitor, ViewerUtils, MenuItemManager, EntityRenderEngine, MenuItemCreator, VisualsRegister, RenderManager, EntitiesIdsRenderManager, EntitiesLoadedRenderManager, EntitiesRenderManager, EntityRenderManager, TilesetCadRenderManager, TilesetArbRenderManager, TilesetEntitiesRenderManager, TilesetOsmRenderManager, TilesetPointcloudRenderManager, TilesetGooglePhotosRenderManager, DataSourceStaticKmlManager, GoogleSearchRenderManager, RelationsRenderManager, SharedGetters, CesiumParabola, EntityLabel, ViewRenderEngine, TileRenderEngine, TilesetRenderEngine, CESIUM_INSPECTOR_KEY, CESIUM_TIMELINE_KEY, ViewUtils, DrawingUtils, MeasureUtils, EntityUtils, CesiumEntityStyler, CesiumAnimatedProperty, CesiumAnimatedInOut, Draw3dPolygon, Draw3dPolyline };
 //# sourceMappingURL=bruce-cesium.es5.js.map