@openglobus/og 0.18.0 → 0.18.2

package/lib/js/control/elevationProfile/ElevationProfile.d.ts

@@ -0,0 +1,61 @@
+import { EventsHandler } from '../../Events';
+import { Vec3 } from "../../math/Vec3";
+import { Planet } from "../../scene/Planet";
+import { LonLat } from "../../LonLat";
+interface ElevationProfileParams {
+    planet: Planet;
+}
+interface IProfileData {
+    dist: number;
+    minY: number;
+    maxY: number;
+    trackCoords: number[][];
+    groundCoords: number[][];
+}
+type ElevationProfileEventsList = ["profilecollected"];
+/**
+ * Point types
+ */
+declare const SAFE = 0;
+declare const WARNING = 1;
+declare const COLLISION = 2;
+declare class ElevationProfile {
+    events: EventsHandler<ElevationProfileEventsList>;
+    planet: Planet;
+    protected _warningHeightLevel: number;
+    protected _pointsReady: boolean;
+    protected _isWarning: boolean;
+    protected _minX: number;
+    protected _maxX: number;
+    protected _minY: number;
+    protected _maxY: number;
+    protected _drawData: [number[][], number[][]];
+    protected _promiseArr: Promise<void | number>[];
+    protected _promiseCounter: number;
+    protected _pMaxY: number;
+    protected _pMinY: number;
+    protected _pDist: number;
+    protected _pTrackCoords: number[][];
+    protected _pGroundCoords: number[][];
+    protected _pIndex: number;
+    constructor(options: ElevationProfileParams);
+    setWarningHeightLevel(warningHeight?: number): void;
+    setRange(minX: number, maxX: number, minY: number, maxY: number): void;
+    protected _getHeightAsync(ll: LonLat, pIndex: number): Promise<number>;
+    protected _collectCoordsBetweenTwoTrackPoints(internalPoints: number, scaleFactor: number, p0: Vec3, trackDir: Vec3): void;
+    protected _collectAllPoints(pointsLonLat: LonLat[]): void;
+    protected _getGroundElevation(lonLat: LonLat): void;
+    protected _collectPromise(resolve: (p: IProfileData) => void): void;
+    protected _calcPointsAsync(pointsLonLat: LonLat[]): Promise<IProfileData>;
+    get minX(): number;
+    get maxX(): number;
+    get minY(): number;
+    get maxY(): number;
+    get pointsReady(): boolean;
+    get isWarningOrCollision(): boolean;
+    collectProfile(pointsLonLat: LonLat[]): void;
+    protected _setPointType(pIndex: number): void;
+    protected _setPointsType(): void;
+    clear(): void;
+}
+export { COLLISION, SAFE, WARNING, type IProfileData, ElevationProfile, };

package/{src/control/elevationProfile/ElevationProfile.ts → lib/js/control/elevationProfile/ElevationProfile.js}

@@ -1,81 +1,35 @@
-import {Deferred} from '../../Deferred';
-import {createEvents, EventsHandler} from '../../Events';
-import {Vec3} from "../../math/Vec3";
-import {Planet} from "../../scene/Planet";
-import {LonLat} from "../../LonLat";
-
-interface ElevationProfileParams {
-    planet: Planet
-}
-
-interface IProfileData {
-    dist: number;
-    minY: number;
-    maxY: number;
-    trackCoords: number[][];
-    groundCoords: number[][];
-}
-
-type ElevationProfileEventsList = ["profilecollected"];
-
-const ELEVATIONPROFILE_EVENTS: ElevationProfileEventsList = ["profilecollected"];
-
+import { Deferred } from '../../Deferred';
+import { createEvents } from '../../Events';
+import { Vec3 } from "../../math/Vec3";
+const ELEVATIONPROFILE_EVENTS = ["profilecollected"];
 /**
  * Point types
  */
 const SAFE = 0;
 const WARNING = 1;
 const COLLISION = 2;
-
 /**
  * drawData index names
  */
 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 {
-    public events: EventsHandler<ElevationProfileEventsList>;
-    public planet: Planet;
-    protected _warningHeightLevel: number;
-    protected _pointsReady: boolean;
-    protected _isWarning: boolean;
-    protected _minX: number;
-    protected _maxX: number;
-    protected _minY: number;
-    protected _maxY: number;
-    protected _drawData: [number[][], number[][]];
-    protected _promiseArr: Promise<void | number>[];
-    protected _promiseCounter: number;
-    protected _pMaxY: number;
-    protected _pMinY: number;
-    protected _pDist: number;
-    protected _pTrackCoords: number[][];
-    protected _pGroundCoords: number[][];
-    protected _pIndex: number;
-
-    constructor(options: ElevationProfileParams) {
+    constructor(options) {
         this.events = createEvents(ELEVATIONPROFILE_EVENTS);
-
         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;
@@ -85,22 +39,19 @@ class ElevationProfile {
         this._pGroundCoords = [[0, 0, SAFE]];
         this._pIndex = 0;
     }
-
-    public setWarningHeightLevel(warningHeight: number = 0) {
+    setWarningHeightLevel(warningHeight = 0) {
         this._warningHeightLevel = warningHeight;
     }
-
-    public setRange(minX: number, maxX: number, minY: number, maxY: number) {
+    setRange(minX, maxX, minY, maxY) {
         this._minX = minX;
         this._maxX = maxX;
         this._minY = minY;
         this._maxY = maxY;
     }
-
-    protected _getHeightAsync(ll: LonLat, pIndex: number): Promise<number> {
-        let def = new Deferred<number>();
-        this.planet.terrain!.getHeightAsync(ll, (elv: number) => {
-            elv += this.planet.terrain!.geoid.getHeightLonLat(ll);
+    _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;
@@ -109,43 +60,32 @@ class ElevationProfile {
         });
         return def.promise;
     }
-
-    protected _collectCoordsBetweenTwoTrackPoints(internalPoints: number, scaleFactor: number, p0: Vec3, trackDir: Vec3) {
+    _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: LonLat, index: number) => {
-                this._promiseArr.push(
-                    this._getHeightAsync(lonlat, index)
-                        .then((elv) => {
-                            if (elv > this._pMaxY) this._pMaxY = elv;
-                            if (elv < this._pMinY) this._pMinY = elv;
-                        })
-                );
+            ((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);
         }
     }
-
-    protected _collectAllPoints(pointsLonLat: LonLat[]) {
-
-        let p0 = new Vec3(),
-            p1 = new Vec3();
-
+    _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];
-
+            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);
@@ -153,40 +93,34 @@ class ElevationProfile {
             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;
-
+            if (elv > this._pMaxY)
+                this._pMaxY = elv;
+            if (elv < this._pMinY)
+                this._pMinY = elv;
             this._pTrackCoords[i] = [this._pDist, elv];
         }
     }
-
-    protected _getGroundElevation(lonLat: LonLat) {
+    _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;
-                    }
-                })
-        );
-    }
-
-    protected _collectPromise(resolve: (p: IProfileData) => void) {
+        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,
@@ -197,9 +131,8 @@ class ElevationProfile {
             });
         });
     }
-
-    protected _calcPointsAsync(pointsLonLat: LonLat[]) {
-        return new Promise<IProfileData>((resolve: (p: IProfileData) => void, reject) => {
+    _calcPointsAsync(pointsLonLat) {
+        return new Promise((resolve, reject) => {
             this._pTrackCoords = [[0, pointsLonLat[0].height]];
             this._pMaxY = pointsLonLat[0].height;
             this._pMinY = this._pMaxY;
@@ -207,47 +140,37 @@ class ElevationProfile {
             this._pGroundCoords = [[0, 0, SAFE]];
             this._pIndex = 0;
             this._promiseArr = [];
-
             this._collectAllPoints(pointsLonLat);
             this._getGroundElevation(pointsLonLat[pointsLonLat.length - 1]);
             this._collectPromise(resolve);
         });
     }
-
-    public get minX(): number {
+    get minX() {
         return this._minX;
     }
-
-    public get maxX(): number {
+    get maxX() {
         return this._maxX;
     }
-
-    public get minY(): number {
+    get minY() {
         return this._minY;
     }
-
-    public get maxY(): number {
+    get maxY() {
         return this._maxY;
     }
-
-    public get pointsReady(): boolean {
+    get pointsReady() {
         return this._pointsReady;
     }
-
-    public get isWarningOrCollision(): boolean {
+    get isWarningOrCollision() {
         return this._isWarning;
     }
-
-    public collectProfile(pointsLonLat: LonLat[]) {
+    collectProfile(pointsLonLat) {
         this._pointsReady = false;
         this._isWarning = false;
-
-        if (!pointsLonLat || !pointsLonLat.length) return;
-
+        if (!pointsLonLat || !pointsLonLat.length)
+            return;
         this._promiseCounter++;
-
-        ((counter: number) => {
-            this._calcPointsAsync(pointsLonLat).then((p: IProfileData) => {
+        ((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;
@@ -257,37 +180,29 @@ class ElevationProfile {
             });
         })(this._promiseCounter);
     }
-
-    protected _setPointType(pIndex: number) {
+    _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;
         }
     }
-
-    protected _setPointsType() {
+    _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);
     }
-
-    public clear() {
+    clear() {
         this._pointsReady = false;
         this._isWarning = false;
         this._drawData = [][0];
@@ -299,11 +214,4 @@ class ElevationProfile {
         this._pIndex = 0;
     }
 }
-
-export {
-    COLLISION,
-    SAFE,
-    WARNING,
-    IProfileData,
-    ElevationProfile,
-};
+export { COLLISION, SAFE, WARNING, ElevationProfile, };

package/lib/js/control/heightRuler/HeightRuler.d.ts

@@ -0,0 +1,7 @@
+import { Ruler, IRulerParams } from "../ruler/Ruler";
+interface IHeightRulerParams extends IRulerParams {
+}
+export declare class HeightRuler extends Ruler {
+    constructor(options?: IHeightRulerParams);
+}
+export {};

package/{src/control/heightRuler/HeightRuler.ts → lib/js/control/heightRuler/HeightRuler.js}

@@ -1,16 +1,11 @@
-import {Ruler, IRulerParams} from "../ruler/Ruler";
-import {HeightRulerScene} from "./HeightRulerScene";
-
-interface IHeightRulerParams extends IRulerParams {
-
-}
-
+import { Ruler } from "../ruler/Ruler";
+import { HeightRulerScene } from "./HeightRulerScene";
 export class HeightRuler extends Ruler {
-    constructor(options: IHeightRulerParams = {}) {
+    constructor(options = {}) {
         super(options);
         this._rulerScene = new HeightRulerScene({
             name: `heightRulerScene:${this.__id}`,
             ignoreTerrain: false
         });
     }
-}
+}

package/lib/js/control/heightRuler/HeightRulerScene.d.ts

@@ -0,0 +1,35 @@
+import { Entity } from '../../entity/Entity';
+import { LonLat } from "../../LonLat";
+import { RulerScene, IRulerSceneParams } from "../ruler/RulerScene";
+import { Vector } from "../../layer/Vector";
+import { Vec3 } from "../../math/Vec3";
+interface IHeightRulerSceneParams extends IRulerSceneParams {
+}
+declare class HeightRulerScene extends RulerScene {
+    protected _geoRulerLayer: Vector;
+    protected _heightLabels: Entity[];
+    protected _rayH: Entity;
+    protected _rayV: Entity;
+    constructor(options?: IHeightRulerSceneParams);
+    setVisibility(visibility: boolean): void;
+    get deltaLabel(): Entity;
+    get startLabel(): Entity;
+    get endLabel(): Entity;
+    get corners(): Entity[];
+    get startCorner(): Entity;
+    get endCorner(): Entity;
+    get startCornerLonLat(): LonLat;
+    get startCornerHeight(): number;
+    get endCornerLonLat(): LonLat;
+    get endCornerHeight(): number;
+    get maxHeightCornerLonLat(): LonLat;
+    get minHeightCornerLonLat(): LonLat;
+    get deltaHeight(): number;
+    _drawLine(startLonLat: LonLat, endLonLat: LonLat, startPos?: Vec3): void;
+    protected _updateHeightRaysAndLabels(): Promise<void>;
+    clear(): void;
+    _createCorners(): void;
+    init(): void;
+    frame(): void;
+}
+export { HeightRulerScene };