bruce-cesium 1.0.3 → 1.0.4

package/dist/bruce-cesium.es5.js

@@ -1,5 +1,5 @@
 import { BruceEvent, Cartes, Carto, Geometry, ZoomControl, Style, EntityTag, Calculator, EntityLod, EntityType, ClientFile, DelayQueue, Entity as Entity$1, BatchedDataGetter, ObjectUtils, Tileset, EntityCoords, EntityFilterGetter, EntitySource, MenuItem, ProjectView, ProjectViewBookmark, ProjectViewTile, ProjectViewLegacyTile, ProgramKey, Camera } from 'bruce-models';
-import { Cartesian2, Cartographic, Math as Math$1, Entity, Primitive, Cesium3DTileFeature, Color, Cartesian3, HeightReference, HorizontalOrigin, VerticalOrigin, ClassificationType, ArcType, PolygonHierarchy, ShadowMode, PolylineGraphics, HeadingPitchRoll, Transforms, ColorBlendMode, Cesium3DTileColorBlendMode, HeadingPitchRange, OrthographicFrustum, JulianDate, createWorldTerrain, EllipsoidTerrainProvider, CesiumTerrainProvider, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, UrlTemplateImageryProvider, TileMapServiceImageryProvider, IonImageryProvider, PolygonPipeline, Matrix4, Cesium3DTileStyle, Cesium3DTileset, IonResource, ColorMaterialProperty, Rectangle, Matrix3, EasingFunction, GeometryInstance, EllipsoidGeodesic, createOsmBuildings, KmlDataSource } from 'cesium';
+import { Cartesian2, Cartographic, Math as Math$1, Color, HeightReference, Cartesian3, Entity, HorizontalOrigin, VerticalOrigin, ClassificationType, ArcType, PolygonHierarchy, ShadowMode, PolylineGraphics, HeadingPitchRoll, Transforms, ColorBlendMode, Primitive, Cesium3DTileFeature, Cesium3DTileColorBlendMode, HeadingPitchRange, OrthographicFrustum, JulianDate, createWorldTerrain, EllipsoidTerrainProvider, CesiumTerrainProvider, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, UrlTemplateImageryProvider, TileMapServiceImageryProvider, IonImageryProvider, Matrix4, Cesium3DTileStyle, Cesium3DTileset, IonResource, EllipsoidGeodesic, sampleTerrainMostDetailed, PolygonPipeline, ColorMaterialProperty, Rectangle, Matrix3, EasingFunction, GeometryInstance, CallbackProperty, createOsmBuildings, KmlDataSource } from 'cesium';
 
 var TIME_LAG = 300;
 var POSITION_CHECK_TIMER = 950;
@@ -401,6 +401,54 @@ var DrawingUtils;
         };
     }
     DrawingUtils.PointAcrossPolyline = PointAcrossPolyline;
+    /**
+     * Returns terrain height from current viewer's provider.
+     * On error or flat terrain, it will return 0.
+     * If an error occurred it will be attached to the result.
+     * @param pos3d
+     * @param viewer
+     * @returns
+     */
+    function GetTerrainHeight(params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var pos3d, viewer, sample, height, e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        pos3d = params.pos3d, viewer = params.viewer;
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        if (viewer.scene.terrainProvider instanceof EllipsoidTerrainProvider) {
+                            return [2 /*return*/, {
+                                    height: 0
+                                }];
+                        }
+                        return [4 /*yield*/, sampleTerrainMostDetailed(viewer.scene.terrainProvider, [Cartographic.fromCartesian(pos3d)])];
+                    case 2:
+                        sample = _a.sent();
+                        height = (sample === null || sample === void 0 ? void 0 : sample.length) ? sample[0].height : null;
+                        if (isNaN(height)) {
+                            return [2 /*return*/, {
+                                    height: 0,
+                                    error: "NaN"
+                                }];
+                        }
+                        return [2 /*return*/, {
+                                height: height
+                            }];
+                    case 3:
+                        e_1 = _a.sent();
+                        return [2 /*return*/, {
+                                height: 0,
+                                error: e_1
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    }
+    DrawingUtils.GetTerrainHeight = GetTerrainHeight;
 })(DrawingUtils || (DrawingUtils = {}));
 
 var MeasureUtils;
@@ -7094,5 +7142,284 @@ var ViewUtils;
     ViewUtils.GatherTerrainTile = GatherTerrainTile;
 })(ViewUtils || (ViewUtils = {}));
 
-export { CesiumViewMonitor, ViewerUtils, MenuItemManager, EntityRenderEngine, MenuItemCreator, VisualsRegister, RenderManager, EntitiesIdsRenderManager, EntitiesLoadedRenderManager, EntitiesRenderManager, EntityRenderManager, TilesetCadRenderManager, ViewRenderEngine, TileRenderEngine, TilesetRenderEngine, SharedGetters, ViewUtils, DrawingUtils, MeasureUtils, EntityUtils };
+/**
+ * Utility for rendering parabolas between two points on the map.
+ */
+var CesiumParabola = /** @class */ (function () {
+    function CesiumParabola(params) {
+        this.color = "white";
+        this.width = 2;
+        this.duration = 10;
+        this.heightDistanceRatio = 0.25;
+        this.viewer = params.viewer;
+        this.pos1 = params.pos1;
+        this.pos2 = params.pos2;
+        if (params.color) {
+            this.color = params.color;
+        }
+        if (!isNaN(params.width)) {
+            this.width = params.width;
+        }
+        if (!isNaN(params.duration)) {
+            this.duration = params.duration;
+        }
+        if (!isNaN(params.heightDistanceRatio)) {
+            this.heightDistanceRatio = params.heightDistanceRatio;
+        }
+    }
+    Object.defineProperty(CesiumParabola.prototype, "curPos1", {
+        get: function () {
+            return this.pos1 instanceof Function ? this.pos1() : this.pos1;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(CesiumParabola.prototype, "curPos2", {
+        get: function () {
+            return this.pos2 instanceof Function ? this.pos2() : this.pos2;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CesiumParabola.prototype.Animate = function () {
+        var _this = this;
+        this.Dispose();
+        var p1 = this.curPos1;
+        var p2 = this.curPos2;
+        var retry = false;
+        if (!p1 || !p2 || !Cartes.ValidateCartes3(p1) || !Cartes.ValidateCartes3(p2)) {
+            retry = true;
+        }
+        var TOTAL_LENGTH = retry ? 0 : Cartesian3.distance(p1, p2);
+        if (TOTAL_LENGTH <= 0) {
+            retry = true;
+        }
+        if (retry) {
+            var retryTimeout_1 = setTimeout(function () {
+                _this.Animate();
+            }, 2000);
+            this.dispose = function () {
+                clearTimeout(retryTimeout_1);
+            };
+            return;
+        }
+        var TOTAL_POINTS = Math.max(50, Math.min(1000, TOTAL_LENGTH * 0.1));
+        var POINT_LENGTH = TOTAL_LENGTH / TOTAL_POINTS;
+        var RATE_PER_SECOND = 1000 / 40;
+        var SEC_DURATION = this.duration;
+        var HEIGHT_DISTANCE_RATIO = this.heightDistanceRatio;
+        var TICK_LENGTH_INC = TOTAL_POINTS / (RATE_PER_SECOND * SEC_DURATION);
+        var curPoints = [];
+        var curPoint = 0;
+        var parabola = new Entity({
+            polyline: {
+                positions: new CallbackProperty(function () {
+                    return curPoints;
+                }, false),
+                width: this.width,
+                material: Color.fromCssColorString(this.color)
+            }
+        });
+        this.viewer.entities.add(parabola);
+        var p1Entity = new Entity({
+            position: new CallbackProperty(function () {
+                return curPoints.length ? curPoints[0] : new Cartesian3();
+            }, false),
+            point: {
+                heightReference: HeightReference.NONE,
+                pixelSize: this.width * 1.3,
+                color: Color.fromCssColorString(this.color),
+                outlineColor: Color.WHITE,
+                outlineWidth: 2
+            }
+        });
+        var p2Entity = new Entity({
+            position: new CallbackProperty(function () {
+                return curPoints.length ? curPoints[curPoints.length - 1] : new Cartesian3();
+            }, false),
+            point: {
+                heightReference: HeightReference.NONE,
+                pixelSize: this.width * 1.3,
+                color: Color.fromCssColorString(this.color),
+                outlineColor: Color.WHITE,
+                outlineWidth: 2
+            }
+        });
+        this.viewer.entities.add(p1Entity);
+        this.viewer.entities.add(p2Entity);
+        p1Entity.parent = parabola;
+        p2Entity.parent = parabola;
+        var quadraticKey = null;
+        var quadratic = null;
+        var prepareQuadratic = function () {
+            var p1 = _this.curPos1;
+            var p2 = _this.curPos2;
+            if (!p1 || !p2 || !Cartes.ValidateCartes3(p1) || !Cartes.ValidateCartes3(p2)) {
+                return;
+            }
+            var height1 = Cartographic.fromCartesian(p1).height;
+            var height2 = Cartographic.fromCartesian(p2).height;
+            if (isNaN(height1) || isNaN(height2)) {
+                return;
+            }
+            var totalHeight = height2 + height1;
+            var curQuadraticKey = height1 + "-" + height2;
+            if (quadraticKey == curQuadraticKey) {
+                return;
+            }
+            var points2d = [
+                new Cartesian2(0, height1),
+                new Cartesian2(TOTAL_LENGTH, height2)
+            ];
+            var vertexHeight = 0;
+            // Flat line.
+            if (HEIGHT_DISTANCE_RATIO == 0) {
+                vertexHeight = totalHeight * 0.5;
+            }
+            else {
+                var largestHeight = Math.max(height1, height2);
+                vertexHeight = largestHeight + (TOTAL_LENGTH * HEIGHT_DISTANCE_RATIO);
+            }
+            points2d.push(new Cartesian2(TOTAL_LENGTH * 0.5, vertexHeight));
+            var calcQuadratic = function (points) {
+                // Swaps position of two rows in matrix.
+                function swapRows(matrix, rowAIndex, rowBIndex) {
+                    var rowAVal = matrix[rowAIndex];
+                    matrix[rowAIndex] = matrix[rowBIndex];
+                    matrix[rowBIndex] = rowAVal;
+                    return matrix;
+                }
+                // Zeros rowA at colIndex by subtracting a multiplied rowB from it.
+                function reduceMatrixRowByRow(matrix, zeroingIndex, parentIndex, colIndex) {
+                    var zeroRow = matrix[zeroingIndex];
+                    var parentRow = matrix[parentIndex];
+                    if (zeroRow[colIndex] == 0) {
+                        return matrix;
+                    }
+                    else if (parentRow[colIndex] == 0) {
+                        matrix = swapRows(matrix, parentIndex, zeroingIndex);
+                        return divideMatrixRow(matrix, parentIndex, colIndex);
+                    }
+                    // rowAIndex colIndex / rowBIndex colIndex = factor;
+                    var factor = zeroRow[colIndex] / parentRow[colIndex];
+                    for (var i = 0; i < zeroRow.length; i++) {
+                        if (i >= colIndex) {
+                            zeroRow[i] -= parentRow[i] * factor;
+                        }
+                    }
+                    return matrix;
+                }
+                // Makes a given row column equal 1 by diving while row by that column.
+                function divideMatrixRow(matrix, rowIndex, colIndex) {
+                    var row = matrix[rowIndex];
+                    var colValue = row[colIndex];
+                    for (var i = 0; i < row.length; i++) {
+                        if (i >= colIndex) {
+                            row[i] /= colValue;
+                        }
+                    }
+                    return matrix;
+                }
+                // Returns initial matrix for calculating a, b and c for quadratic formula from given points.
+                function matrixFromPoints(points) {
+                    var rows = [];
+                    var constructRow = function (point) {
+                        rows.push([
+                            -Math.pow(point.x, 2),
+                            point.x,
+                            1,
+                            point.y
+                        ]);
+                    };
+                    for (var i = 0; i < points.length; i++) {
+                        constructRow(points[i]);
+                    }
+                    return rows;
+                }
+                var initialMatrix = matrixFromPoints(points);
+                var step1Matrix = reduceMatrixRowByRow(initialMatrix, 1, 0, 0);
+                var step2Matrix = reduceMatrixRowByRow(step1Matrix, 2, 0, 0);
+                var step3Matrix = reduceMatrixRowByRow(step2Matrix, 2, 1, 1);
+                var step4Matrix = reduceMatrixRowByRow(step3Matrix, 0, 1, 1);
+                var step5Matrix = reduceMatrixRowByRow(step4Matrix, 0, 2, 2);
+                var step6Matrix = reduceMatrixRowByRow(step5Matrix, 1, 2, 2);
+                var a = step6Matrix[0][3];
+                var b = step6Matrix[1][3];
+                var c = step6Matrix[2][3];
+                return { a: a, b: b, c: c };
+            };
+            quadratic = calcQuadratic(points2d);
+        };
+        var getPosition = function (increment) {
+            if (!quadratic) {
+                return null;
+            }
+            var lengthAcross = POINT_LENGTH * increment;
+            if (lengthAcross > TOTAL_LENGTH) {
+                lengthAcross = TOTAL_LENGTH;
+            }
+            var getParabolaYFromX = function (x, quadLetters) {
+                var a = quadLetters.a;
+                var b = quadLetters.b;
+                var c = quadLetters.c;
+                return (-a * Math.pow(x, 2)) + (b * x) + c;
+            };
+            var pos3d = DrawingUtils.PointAcrossPolyline({
+                viewer: _this.viewer,
+                distance: lengthAcross,
+                posses: [p1, p2]
+            }).point;
+            var point = Cartographic.fromCartesian(pos3d);
+            var posHeight = getParabolaYFromX(lengthAcross, quadratic);
+            return Cartesian3.fromRadians(point.longitude, point.latitude, posHeight);
+        };
+        var updatePoints = function () {
+            var increment = Math.floor(curPoint);
+            var chips = curPoint - Math.floor(curPoint);
+            var posses = [];
+            posses.push(getPosition(0));
+            var addLast = increment >= TOTAL_POINTS;
+            var totalCycles = addLast ? increment + 1 : increment;
+            for (var i = 0; i < totalCycles; i++) {
+                posses.push(getPosition(i));
+            }
+            posses.push(getPosition(increment + chips));
+            if (posses.find(function (x) { return !x || !Cartes.ValidateCartes3(x); })) {
+                return;
+            }
+            curPoints = posses;
+        };
+        var doTick = function () {
+            if (curPoint >= TOTAL_POINTS) {
+                clearInterval(animateInterval);
+                return;
+            }
+            curPoint += TICK_LENGTH_INC;
+            prepareQuadratic();
+            updatePoints();
+        };
+        var animateInterval = setInterval(doTick, RATE_PER_SECOND);
+        this.dispose = function () {
+            clearInterval(animateInterval);
+            if (parabola && _this.viewer.entities.contains(parabola)) {
+                _this.viewer.entities.remove(parabola);
+            }
+            if (p1Entity && _this.viewer.entities.contains(p1Entity)) {
+                _this.viewer.entities.remove(p1Entity);
+            }
+            if (p2Entity && _this.viewer.entities.contains(p2Entity)) {
+                _this.viewer.entities.remove(p2Entity);
+            }
+        };
+        return parabola;
+    };
+    CesiumParabola.prototype.Dispose = function () {
+        var _a;
+        (_a = this.dispose) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.dispose = null;
+    };
+    return CesiumParabola;
+}());
+
+export { CesiumViewMonitor, ViewerUtils, MenuItemManager, EntityRenderEngine, MenuItemCreator, VisualsRegister, RenderManager, EntitiesIdsRenderManager, EntitiesLoadedRenderManager, EntitiesRenderManager, EntityRenderManager, TilesetCadRenderManager, ViewRenderEngine, TileRenderEngine, TilesetRenderEngine, SharedGetters, ViewUtils, DrawingUtils, MeasureUtils, EntityUtils, CesiumParabola };
 //# sourceMappingURL=bruce-cesium.es5.js.map