@openglobus/og 0.16.3 → 0.17.0

package/src/og/control/elevationProfile/ElevationProfile.js

@@ -0,0 +1,275 @@
+'use strict';
+
+import { Vec3 } from "../../math/Vec3.js";
+import { Deferred } from "../../Deferred.js";
+import { Events } from '../../Events.js';
+
+/**
+ * Point types
+ * @type {number}
+ */
+const SAFE = 0;
+const WARNING = 1;
+const COLLISION = 2;
+
+/**
+ * drawData index names
+ * @type {number}
+ */
+const TRACK = 0;
+const GROUND = 1;
+
+const SEGMMENT_LENGTH = 1.0; // Distance between query points on the ground
+const GROUND_OFFSET = 1.0; // Ground level offset
+const BOTTOM_PADDING = 0.1; // Range minY padding in percentage from the bottom
+const TOP_PADDING = 0.1; // Range maxY padding in percentage from the top
+
+const HEIGHT_EPS = 0.1; // Warning height level error
+
+class ElevationProfile {
+    constructor(options = {}) {
+        this.events = new Events(["profilecollected"]);
+
+        this.planet = options.planet;
+
+        this._warningHeightLevel = 50;
+        this._pointsReady = false;
+        this._isWarning = false;
+
+        this._minX = 0;
+        this._maxX = 1000;
+        this._minY = 0;
+        this._maxY = 200;
+
+        this._drawData = [][0];
+
+        this._promiseArr = [];
+        this._promiseCounter = 0;
+        this._pMaxY = 0;
+        this._pMinY = 0;
+        this._pDist = 0;
+        this._pTrackCoords = [[0, 0, SAFE]];
+        this._pGroundCoords = [[0, 0, SAFE]];
+        this._pIndex = 0;
+    }
+
+    setWarningHeightLevel(warningHeight = 0) {
+        this._warningHeightLevel = warningHeight;
+    }
+
+    setRange(minX, maxX, minY, maxY) {
+        this._minX = minX;
+        this._maxX = maxX;
+        this._minY = minY;
+        this._maxY = maxY;
+    }
+
+    _getHeightAsync(ll, pIndex) {
+        let def = new Deferred();
+        this.planet.terrain.getHeightAsync(ll, (elv) => {
+            elv += this.planet.terrain.geoid.getHeightLonLat(ll);
+            this._pGroundCoords[pIndex][1] = elv;
+            this._pGroundCoords[pIndex][2] = SAFE;
+            this._pGroundCoords[pIndex][3] = ll.height;
+            this._setPointType(pIndex);
+            def.resolve(elv);
+        });
+        return def.promise;
+    }
+
+    _collectCoordsBetweenTwoTrackPoints(internalPoints, scaleFactor, p0, trackDir) {
+        for (let j = 1; j <= internalPoints; j++) {
+            this._pDist += SEGMMENT_LENGTH;
+            this._pIndex++;
+
+            // Point on the track segment
+            let dirSegLen = j * scaleFactor;
+            let pjd = p0.add(trackDir.scaleTo(dirSegLen));
+            let llx = this.planet.ellipsoid.cartesianToLonLat(pjd);
+
+            this._pGroundCoords[this._pIndex] = [this._pDist, 0, SAFE];
+
+            ((lonlat, index) => {
+                this._promiseArr.push(
+                    this._getHeightAsync(lonlat, index)
+                        .then((elv) => {
+                            if (elv > this._pMaxY) this._pMaxY = elv;
+                            if (elv < this._pMinY) this._pMinY = elv;
+                        })
+                );
+            })(llx, this._pIndex);
+        }
+    }
+
+    _collectAllPoints(pointsLonLat) {
+
+        let p0 = new Vec3(),
+            p1 = new Vec3();
+
+        for (let i = 1, len = pointsLonLat.length; i < len; i++) {
+            let lonlat0 = pointsLonLat[i - 1],
+                lonlat1 = pointsLonLat[i];
+
+            this.planet.ellipsoid.lonLatToCartesianRes(lonlat0, p0);
+            this.planet.ellipsoid.lonLatToCartesianRes(lonlat1, p1);
+
+            let trackDir = p1.sub(p0);
+            let dirLength = trackDir.length();
+            let n0 = this.planet.ellipsoid.getSurfaceNormal3v(p0);
+            let proj = Vec3.proj_b_to_plane(trackDir, n0);
+            let projLen = proj.length();
+            let internalPoints = Math.floor(projLen / SEGMMENT_LENGTH);
+            let scaleFactor = SEGMMENT_LENGTH * dirLength / projLen;
+
+            this._getGroundElevation(lonlat0);
+
+            proj.normalize();
+            trackDir.normalize();
+
+            // Getting internal point elevations and looking for the collisions
+            this._collectCoordsBetweenTwoTrackPoints(internalPoints, scaleFactor, p0, trackDir);
+
+            this._pDist += projLen - internalPoints * SEGMMENT_LENGTH;
+            this._pIndex++;
+
+            let elv = lonlat1.height;
+            if (elv > this._pMaxY) this._pMaxY = elv;
+            if (elv < this._pMinY) this._pMinY = elv;
+
+            this._pTrackCoords[i] = [this._pDist, elv];
+        }
+    }
+
+    _getGroundElevation(lonLat) {
+        this._pGroundCoords[this._pIndex] = [this._pDist, 0, SAFE];
+        this._promiseArr.push(
+            this._getHeightAsync(lonLat, this._pIndex)
+                .then((elv) => {
+                    if (typeof elv === 'number') {
+                        if ((elv > this._pMaxY) && (elv)) this._pMaxY = elv;
+                        if ((elv < this._pMinY) && (elv)) this._pMinY = elv;
+                    }
+                })
+        );
+    }
+
+    _collectPromise(resolve) {
+        Promise.all(this._promiseArr).then(() => {
+            resolve({
+                dist: this._pDist,
+                minY: this._pMinY,
+                maxY: this._pMaxY,
+                trackCoords: this._pTrackCoords,
+                groundCoords: this._pGroundCoords
+            });
+        });
+    }
+
+    _calcPointsAsync(pointsLonLat) {
+        return new Promise((resolve, reject) => {
+            this._pTrackCoords = [[0, pointsLonLat[0].height]];
+            this._pMaxY = pointsLonLat[0].height;
+            this._pMinY = this._pMaxY;
+            this._pDist = 0;
+            this._pGroundCoords = [[0, 0, SAFE]];
+            this._pIndex = 0;
+            this._promiseArr = [];
+
+            this._collectAllPoints(pointsLonLat);
+            this._getGroundElevation(pointsLonLat[pointsLonLat.length - 1]);
+            this._collectPromise(resolve);
+        });
+    }
+
+    get minX() {
+        return this._minX;
+    }
+
+    get maxX() {
+        return this._maxX;
+    }
+
+    get minY() {
+        return this._minY;
+    }
+
+    get maxY() {
+        return this._maxY;
+    }
+
+    get pointsReady() {
+        return this._pointsReady;
+    }
+
+    get isWarningOrCollision() {
+        return this._isWarning;
+    }
+
+    collectProfile(pointsLonLat) {
+        this._pointsReady = false;
+        this._isWarning = false;
+
+        if (!pointsLonLat || !pointsLonLat.length) return;
+
+        this._promiseCounter++;
+
+        ((counter) => {
+            this._calcPointsAsync(pointsLonLat).then((p) => {
+                if (counter === this._promiseCounter) {
+                    this.setRange(0, p.dist, p.minY - BOTTOM_PADDING * Math.abs(p.minY), p.maxY + Math.abs(p.maxY) * TOP_PADDING);
+                    this._pointsReady = true;
+                    this._drawData = [p.trackCoords, p.groundCoords];
+                    this.events.dispatch(this.events.profilecollected, this._drawData, this);
+                }
+            });
+        })(this._promiseCounter);
+    }
+
+    _setPointType(pIndex) {
+        if ((this._pGroundCoords[pIndex][3] >= this._pGroundCoords[pIndex][1]) &&
+            (this._pGroundCoords[pIndex][3] < this._pGroundCoords[pIndex][1] + this._warningHeightLevel - HEIGHT_EPS)) {
+            this._pGroundCoords[pIndex][2] = WARNING;
+        }
+
+        if (this._pGroundCoords[pIndex][3] <= this._pGroundCoords[pIndex][1] + GROUND_OFFSET) {
+            this._pGroundCoords[pIndex][2] = COLLISION;
+        }
+
+        if (this._pGroundCoords[pIndex][2] == WARNING || this._pGroundCoords[pIndex][2] == COLLISION) {
+            this._isWarning = true;
+        }
+    }
+
+    _setPointsType() {
+        this._isWarning = false;
+
+        this._pTrackCoords = this._drawData[TRACK];
+        this._pGroundCoords = this._drawData[GROUND];
+
+        for (let i = 0; i < this._pGroundCoords.length; i++) {
+            this._setPointType(i);
+        }
+
+        this._drawData[GROUND] = this._pGroundCoords;
+        this.events.dispatch(this.events.profilecollected, this._drawData, this);
+    }
+
+    clear() {
+        this._pointsReady = false;
+        this._isWarning = false;
+        this._drawData = [][0];
+        this._pMaxY = 0;
+        this._pMinY = 0;
+        this._pDist = 0;
+        this._pTrackCoords = [[0, 0, SAFE]];
+        this._pGroundCoords = [[0, 0, SAFE]];
+        this._pIndex = 0;
+    }
+}
+
+export {
+    SAFE,
+    COLLISION,
+    WARNING,
+    ElevationProfile
+};

package/src/og/control/index.js

@@ -21,6 +21,8 @@ import { Sun } from "./Sun.js";
 import { ToggleWireframe } from "./ToggleWireframe.js";
 import { TouchNavigation } from "./TouchNavigation.js";
 import { ZoomControl } from "./ZoomControl.js";
+import { DrawingSwitcher } from "./DrawingSwitcher.js";
+import { DrawingControl } from "./drawing/DrawingControl.js";
 
 import { TimelineControl } from "./timeline/TimelineControl.js";
 
@@ -48,5 +50,7 @@ export {
     SimpleSkyBackground,
     Selection,
     LayerAnimation,
-    TimelineControl
+    TimelineControl,
+    DrawingSwitcher,
+    DrawingControl
 };

package/src/og/control/ruler/Ruler.js

@@ -1,7 +1,3 @@
-/**
- * @module og/control/Ruler
- */
-
 "use strict";
 
 import { Control } from "../Control.js";

package/src/og/control/ruler/RulerScene.js

@@ -275,8 +275,9 @@ class RulerScene extends RenderNode {
 
         let endPos = this._planet.ellipsoid.lonLatToCartesian(endLonLat);
 
-        let length = this._planet.ellipsoid.getGreatCircleDistance(startLonLat, endLonLat);
-        this._heading = Ellipsoid.getRhumbBearing(startLonLat, endLonLat);
+        let res = this._planet.ellipsoid.inverse(startLonLat, endLonLat);
+        let length = res.distance;
+        this._heading = res.initialAzimuth;
 
         let path = [];
         let dir = endPos.sub(startPos);

package/src/og/control/selection/Selection.js

@@ -1,7 +1,3 @@
-/**
- * @module og/control/Selector
- */
-
 "use strict";
 
 import { ToggleButton } from "../../ui/ToggleButton.js";

package/src/og/control/selection/SelectionScene.js

@@ -233,17 +233,15 @@ class SelectionScene extends RenderNode {
 
         let endPos = this._planet.ellipsoid.lonLatToCartesian(endLonLat);
 
-        let length = this._planet.ellipsoid.getGreatCircleDistance(startLonLat, endLonLat);
+        let res = this._planet.ellipsoid.direct(startLonLat, endLonLat);
 
-        this._heading = Ellipsoid.getRhumbBearing(startLonLat, endLonLat);
+        this._heading = res.initialAzimuth;
 
         let path = [];
 
-
         this._cornerEntity[0].setCartesian3v(startPos);
         this._cornerEntity[1].setCartesian3v(endPos);
 
-
         let corners = [
             startPos,
             this._planet.ellipsoid.lonLatToCartesian(new LonLat(endLonLat.lon, startLonLat.lat, startLonLat.height)),

package/src/og/control/timeline/TimelineControl.js

@@ -26,14 +26,14 @@ class TimelineControl extends Control {
         }
         super(options);
 
-        let currentDate = options.current || new Date();
+        let currentDate = options.current || new Date();
         let startDate = options.rangeStart || addHours(currentDate, -12);
-        let endDate = options.rangeEnd || addHours(currentDate, 12); 
+        let endDate = options.rangeEnd || addHours(currentDate, 12);
 
         this._timelineView = new TimelineView({
             rangeStart: startDate,
             rangeEnd: endDate,
-            current: currentDate
+            currentDate: currentDate
         });
 
         this._toggleBtn = new ToggleButton({
@@ -83,7 +83,7 @@ class TimelineControl extends Control {
             this.renderer.controls.mouseNavigation.deactivate();
         });
 
-        this._timelineView.on("stopdrag", () => {
+        this._timelineView.on("stopdrag", (e) => {
             this.renderer.controls.mouseNavigation.activate();
         });
 

package/src/og/control/timeline/TimelineModel.js

@@ -46,8 +46,8 @@ class TimelineModel {
     }
 
     stopped() {
-       return this._requestAnimationFrameId == 0;
-    }
+        return this._requestAnimationFrameId == 0;
+    }
 
     _animationFrameCallback() {
         this._requestAnimationFrameId = window.requestAnimationFrame(() => {

package/src/og/control/timeline/TimelineView.js

@@ -390,6 +390,7 @@ class TimelineView extends View {
             this._canvasEl.height = this._frameEl.clientHeight * this._canvasScale;
             this._canvasEl.style.width = `${this._frameEl.clientWidth}px`;
             this._canvasEl.style.height = `${this._frameEl.clientHeight}px`;
+
         }
     }
 

package/src/og/control/visibleExtent/Segment.js

@@ -269,11 +269,11 @@ class Segment {
      * @returns {Vec3} -
      */
     getEntityTerrainPoint(entity, res) {
-        return this.getTerrainPoint(entity._cartesian, entity._lonlatMerc, res);
+        return this.getTerrainPoint(entity._cartesian, entity._lonLatMerc, res);
     }
 
     isEntityInside(e) {
-        return this._extent.isInside(e._lonlatMerc);
+        return this._extent.isInside(e._lonLatMerc);
     }
 
     /**
@@ -281,7 +281,7 @@ class Segment {
      * @public
      * @param {Vec3} xyz - Cartesian object position.
      * @param {LonLat} insideSegmentPosition - Geodetic object position.
-     * @param {Vec3} [res] - Result cartesian coordiantes on the terrain.
+     * @param {Vec3} [res] - Result cartesian coordinates on the terrain.
      * @param {Vec3} [normal] - Terrain point normal.
      * @returns {number} -
      */
@@ -363,8 +363,8 @@ class Segment {
      * @param {LonLat} lonlat - Coordinates to project.
      * @returns {LonLat} -
      */
-    projectNative(lonlat) {
-        return lonlat.forwardMercator();
+    projectNative(lonLat) {
+        return lonLat.forwardMercator();
     }
 
     /**

package/src/og/control/visibleExtent/drawnode.js

@@ -1,7 +1,3 @@
-/**
- * @module og/shaders/drawnode
- */
-
 "use strict";
 
 import { Program } from "../../webgl/Program.js";