@openglobus/og 0.17.2 → 0.18.0

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

@@ -1,12 +1,27 @@
-'use strict';
+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[][];
+}
 
-import { Vec3 } from "../../math/Vec3.js";
-import { Deferred } from "../../Deferred.js";
-import { Events } from '../../Events.js';
+type ElevationProfileEventsList = ["profilecollected"];
+
+const ELEVATIONPROFILE_EVENTS: ElevationProfileEventsList = ["profilecollected"];
 
 /**
  * Point types
- * @type {number}
  */
 const SAFE = 0;
 const WARNING = 1;
@@ -14,7 +29,6 @@ const COLLISION = 2;
 
 /**
  * drawData index names
- * @type {number}
  */
 const TRACK = 0;
 const GROUND = 1;
@@ -27,8 +41,27 @@ 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"]);
+    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) {
+        this.events = createEvents(ELEVATIONPROFILE_EVENTS);
 
         this.planet = options.planet;
 
@@ -53,21 +86,21 @@ class ElevationProfile {
         this._pIndex = 0;
     }
 
-    setWarningHeightLevel(warningHeight = 0) {
+    public setWarningHeightLevel(warningHeight: number = 0) {
         this._warningHeightLevel = warningHeight;
     }
 
-    setRange(minX, maxX, minY, maxY) {
+    public setRange(minX: number, maxX: number, minY: number, maxY: number) {
         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);
+    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);
             this._pGroundCoords[pIndex][1] = elv;
             this._pGroundCoords[pIndex][2] = SAFE;
             this._pGroundCoords[pIndex][3] = ll.height;
@@ -77,7 +110,7 @@ class ElevationProfile {
         return def.promise;
     }
 
-    _collectCoordsBetweenTwoTrackPoints(internalPoints, scaleFactor, p0, trackDir) {
+    protected _collectCoordsBetweenTwoTrackPoints(internalPoints: number, scaleFactor: number, p0: Vec3, trackDir: Vec3) {
         for (let j = 1; j <= internalPoints; j++) {
             this._pDist += SEGMMENT_LENGTH;
             this._pIndex++;
@@ -89,7 +122,7 @@ class ElevationProfile {
 
             this._pGroundCoords[this._pIndex] = [this._pDist, 0, SAFE];
 
-            ((lonlat, index) => {
+            ((lonlat: LonLat, index: number) => {
                 this._promiseArr.push(
                     this._getHeightAsync(lonlat, index)
                         .then((elv) => {
@@ -101,7 +134,7 @@ class ElevationProfile {
         }
     }
 
-    _collectAllPoints(pointsLonLat) {
+    protected _collectAllPoints(pointsLonLat: LonLat[]) {
 
         let p0 = new Vec3(),
             p1 = new Vec3();
@@ -140,7 +173,7 @@ class ElevationProfile {
         }
     }
 
-    _getGroundElevation(lonLat) {
+    protected _getGroundElevation(lonLat: LonLat) {
         this._pGroundCoords[this._pIndex] = [this._pDist, 0, SAFE];
         this._promiseArr.push(
             this._getHeightAsync(lonLat, this._pIndex)
@@ -153,7 +186,7 @@ class ElevationProfile {
         );
     }
 
-    _collectPromise(resolve) {
+    protected _collectPromise(resolve: (p: IProfileData) => void) {
         Promise.all(this._promiseArr).then(() => {
             resolve({
                 dist: this._pDist,
@@ -165,8 +198,8 @@ class ElevationProfile {
         });
     }
 
-    _calcPointsAsync(pointsLonLat) {
-        return new Promise((resolve, reject) => {
+    protected _calcPointsAsync(pointsLonLat: LonLat[]) {
+        return new Promise<IProfileData>((resolve: (p: IProfileData) => void, reject) => {
             this._pTrackCoords = [[0, pointsLonLat[0].height]];
             this._pMaxY = pointsLonLat[0].height;
             this._pMinY = this._pMaxY;
@@ -181,31 +214,31 @@ class ElevationProfile {
         });
     }
 
-    get minX() {
+    public get minX(): number {
         return this._minX;
     }
 
-    get maxX() {
+    public get maxX(): number {
         return this._maxX;
     }
 
-    get minY() {
+    public get minY(): number {
         return this._minY;
     }
 
-    get maxY() {
+    public get maxY(): number {
         return this._maxY;
     }
 
-    get pointsReady() {
+    public get pointsReady(): boolean {
         return this._pointsReady;
     }
 
-    get isWarningOrCollision() {
+    public get isWarningOrCollision(): boolean {
         return this._isWarning;
     }
 
-    collectProfile(pointsLonLat) {
+    public collectProfile(pointsLonLat: LonLat[]) {
         this._pointsReady = false;
         this._isWarning = false;
 
@@ -213,8 +246,8 @@ class ElevationProfile {
 
         this._promiseCounter++;
 
-        ((counter) => {
-            this._calcPointsAsync(pointsLonLat).then((p) => {
+        ((counter: number) => {
+            this._calcPointsAsync(pointsLonLat).then((p: IProfileData) => {
                 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;
@@ -225,7 +258,7 @@ class ElevationProfile {
         })(this._promiseCounter);
     }
 
-    _setPointType(pIndex) {
+    protected _setPointType(pIndex: number) {
         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;
@@ -240,7 +273,7 @@ class ElevationProfile {
         }
     }
 
-    _setPointsType() {
+    protected _setPointsType() {
         this._isWarning = false;
 
         this._pTrackCoords = this._drawData[TRACK];
@@ -254,7 +287,7 @@ class ElevationProfile {
         this.events.dispatch(this.events.profilecollected, this._drawData, this);
     }
 
-    clear() {
+    public clear() {
         this._pointsReady = false;
         this._isWarning = false;
         this._drawData = [][0];
@@ -268,8 +301,9 @@ class ElevationProfile {
 }
 
 export {
-    SAFE,
     COLLISION,
+    SAFE,
     WARNING,
-    ElevationProfile
-};
+    IProfileData,
+    ElevationProfile,
+};

package/src/control/heightRuler/HeightRuler.ts

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

package/src/{og/control/heightRuler/HeightRulerScene.js → control/heightRuler/HeightRulerScene.ts}

@@ -1,25 +1,27 @@
-'use strict';
-
-import { Entity } from '../../entity/Entity.js';
-import { RulerScene } from "../ruler/RulerScene.js";
-import { Vector } from "../../layer/Vector.js";
-import { Object3d } from "../../Object3d.js";
-
-let obj3d = Object3d.createCylinder(1.1, 0, 2, 6, 1, true, true, 0, 0, 0)
-
-const RAYS_OPTIONS = {
+import {Entity} from '../../entity/Entity';
+import {LonLat} from "../../LonLat";
+import {Object3d} from "../../Object3d";
+import {RulerScene, IRulerSceneParams} from "../ruler/RulerScene";
+import {Vector} from "../../layer/Vector";
+import {Vec3} from "../../math/Vec3";
+import {ILabelParams} from "../../entity/Label";
+import {IRayParams} from "../../entity/Ray";
+
+let obj3d = Object3d.createCylinder(1.1, 0, 2, 6, 1, true, true, 0, 0, 0);
+
+const RAYS_OPTIONS: IRayParams = {
     startColor: "rgb(255,131,0)",
     endColor: "rgb(255,131,0)",
     thickness: 5
 }
-const LABEL_OPTIONS = {
+const LABEL_OPTIONS: ILabelParams = {
     text: "",
     size: 11,
     color: "rgba(455,455,455,1.0)",
     outlineColor: "rgba(0,0,0,0.34)",
     outline: 0.23,
     align: "center",
-    offset: [0, 18]
+    offset: [0, 18, 0]
 };
 
 const RULER_CORNER_OPTIONS = {
@@ -30,19 +32,18 @@ const RULER_CORNER_OPTIONS = {
     object3d: obj3d
 };
 
-class HeightRulerScene extends RulerScene {
-    constructor(options = {}) {
-        super(options);
+interface IHeightRulerSceneParams extends IRulerSceneParams {
 
+}
 
-        this._cornersLayer = new Vector("corners", {
-            entities: [],
-            pickingEnabled: true,
-            displayInLayerSwitcher: false,
-            scaleByDistance: [100, 4000000, 1.0],
-            pickingScale: 2
-        });
+class HeightRulerScene extends RulerScene {
+    protected _geoRulerLayer: Vector;
+    protected _heightLabels: Entity[];
+    protected _rayH: Entity;
+    protected _rayV: Entity;
 
+    constructor(options: IHeightRulerSceneParams = {}) {
+        super(options);
 
         this._geoRulerLayer = new Vector("rayHeightRuler", {
             entities: [],
@@ -51,54 +52,85 @@ class HeightRulerScene extends RulerScene {
             relativeToGround: false,
             displayInLayerSwitcher: false
         });
+
+        this._rayV = new Entity({
+            name: 'verticalRay',
+            ray: RAYS_OPTIONS
+        });
+
+        this._rayH = new Entity({
+            name: 'heightRay',
+            ray: RAYS_OPTIONS
+        });
+
+        this._heightLabels = [
+            new Entity({
+                name: 'startCornerLabel',
+                label: {
+                    ...LABEL_OPTIONS
+                }
+            }),
+            new Entity({
+                name: 'endCornerLabel',
+                label: {
+                    ...LABEL_OPTIONS
+                }
+            }),
+            new Entity({
+                name: 'deltaLabel',
+                label: {
+                    ...LABEL_OPTIONS
+                }
+            })
+        ];
     }
 
-    setVisibility(visibility) {
+    public override setVisibility(visibility: boolean) {
         super.setVisibility(visibility);
         this._geoRulerLayer.setVisibility(visibility);
     }
 
-    get deltaLabel() {
-        return this._heightLabels[2]
+    public get deltaLabel(): Entity {
+        return this._heightLabels[2];
     }
 
-    get startLabel() {
+    public get startLabel(): Entity {
         return this._heightLabels[0]
     }
 
-    get endLabel() {
+    public get endLabel(): Entity {
         return this._heightLabels[1]
     }
 
-    get corners() {
+    public get corners(): Entity[] {
         return this._cornerEntity;
     }
 
-    get startCorner() {
+    public get startCorner(): Entity {
         return this.corners[0];
     }
 
-    get endCorner() {
+    public get endCorner(): Entity {
         return this.corners[1];
     }
 
-    get startCornerLonLat() {
+    public get startCornerLonLat(): LonLat {
         return this.startCorner.getLonLat();
     }
 
-    get startCornerHeight() {
+    public get startCornerHeight(): number {
         return this.startCornerLonLat.height;
     }
 
-    get endCornerLonLat() {
+    public get endCornerLonLat(): LonLat {
         return this.endCorner.getLonLat();
     }
 
-    get endCornerHeight() {
+    public get endCornerHeight(): number {
         return this.endCornerLonLat.height;
     }
 
-    get maxHeightCornerLonLat() {
+    public get maxHeightCornerLonLat(): LonLat {
         if (this.startCornerHeight <= this.endCornerHeight) {
             return this.endCornerLonLat;
         } else {
@@ -106,7 +138,7 @@ class HeightRulerScene extends RulerScene {
         }
     }
 
-    get minHeightCornerLonLat() {
+    public get minHeightCornerLonLat(): LonLat {
         if (this.startCornerHeight > this.endCornerHeight) {
             return this.endCornerLonLat;
         } else {
@@ -114,23 +146,23 @@ class HeightRulerScene extends RulerScene {
         }
     }
 
-    get deltaHeight() {
+    public get deltaHeight(): number {
         return Math.abs(this.startCornerHeight - this.endCornerHeight);
     }
 
-    _drawLine(startLonLat, endLonLat, startPos) {
+    public override _drawLine(startLonLat: LonLat, endLonLat: LonLat, startPos?: Vec3) {
         super._drawLine(startLonLat, endLonLat, startPos);
         this._updateHeightRaysAndLabels();
     }
 
-    async _updateHeightRaysAndLabels() {
+    protected async _updateHeightRaysAndLabels() {
         const middleLonLat = this.minHeightCornerLonLat.clone();
         middleLonLat.height = this.maxHeightCornerLonLat.height;
 
-        this._rayH.ray.setStartPosition3v(this._planet.ellipsoid.lonLatToCartesian(this.maxHeightCornerLonLat))
-        this._rayH.ray.setEndPosition3v(this._planet.ellipsoid.lonLatToCartesian(middleLonLat))
-        this._rayV.ray.setStartPosition3v(this._planet.ellipsoid.lonLatToCartesian(this.minHeightCornerLonLat));
-        this._rayV.ray.setEndPosition3v(this._planet.ellipsoid.lonLatToCartesian(middleLonLat));
+        this._rayH.ray!.setStartPosition3v(this._planet!.ellipsoid.lonLatToCartesian(this.maxHeightCornerLonLat))
+        this._rayH.ray!.setEndPosition3v(this._planet!.ellipsoid.lonLatToCartesian(middleLonLat))
+        this._rayV.ray!.setStartPosition3v(this._planet!.ellipsoid.lonLatToCartesian(this.minHeightCornerLonLat));
+        this._rayV.ray!.setEndPosition3v(this._planet!.ellipsoid.lonLatToCartesian(middleLonLat));
 
         middleLonLat.height = this.minHeightCornerLonLat.height + this.deltaHeight / 2;
 
@@ -138,15 +170,15 @@ class HeightRulerScene extends RulerScene {
         this.startLabel.setLonLat(this.startCornerLonLat);
         this.endLabel.setLonLat(this.endCornerLonLat);
 
-        const startHeight = await this._planet.getHeightDefault(this.startCornerLonLat),
-            endHeight = await this._planet.getHeightDefault(this.endCornerLonLat)
+        const startHeight = await this._planet!.getHeightDefault(this.startCornerLonLat),
+            endHeight = await this._planet!.getHeightDefault(this.endCornerLonLat)
 
-        this.deltaLabel.label.setText(`\u0394 ${Math.abs(startHeight - endHeight).toFixed(1)} m`);
-        this.startLabel.label.setText(`P1 ${startHeight.toFixed(1)} m`)
-        this.endLabel.label.setText(`P2 ${endHeight.toFixed(1)} m`)
+        this.deltaLabel.label!.setText(`\u0394 ${Math.abs(startHeight - endHeight).toFixed(1)} m`);
+        this.startLabel.label!.setText(`P1 ${startHeight.toFixed(1)} m`)
+        this.endLabel.label!.setText(`P2 ${endHeight.toFixed(1)} m`)
     }
 
-    clear() {
+    public override clear() {
         this._rayH.remove();
         this._rayV.remove();
         this.startCorner.remove();
@@ -154,14 +186,15 @@ class HeightRulerScene extends RulerScene {
         this.startLabel.remove();
         this.endLabel.remove();
         this.deltaLabel.remove();
-        super.clear()
-        this._rayH = undefined;
-        this._rayV = undefined;
+        super.clear();
+
+        // this._rayH = null;
+        // this._rayV = null;
 
-        this._planet.removeLayer(this._geoRulerLayer);
+        this._planet!.removeLayer(this._geoRulerLayer);
     }
 
-    _createCorners() {
+    public override _createCorners() {
         this._cornerEntity = [
             new Entity({
                 geoObject: RULER_CORNER_OPTIONS,
@@ -180,49 +213,21 @@ class HeightRulerScene extends RulerScene {
         this._cornersLayer.setEntities(this._cornerEntity);
     }
 
-    init() {
-
+    public override init() {
         super.init();
         this._createCorners();
-        this._rayV = new Entity({
-            'name': 'verticalRay',
-            'ray': RAYS_OPTIONS
-        });
-        this._rayH = new Entity({
-            'name': 'heightRay',
-            'ray': RAYS_OPTIONS
-        });
-        this._heightLabels = [
-            new Entity({
-                'name': 'startCornerLabel',
-                'label': {
-                    ...LABEL_OPTIONS
-                }
-            }),
-            new Entity({
-                'name': 'endCornerLabel',
-                'label': {
-                    ...LABEL_OPTIONS
-                }
-            }),
-            new Entity({
-                'name': 'deltaLabel',
-                'label': {
-                    ...LABEL_OPTIONS
-                }
-            })
-        ];
+
         this._labelLayer.addEntities(this._heightLabels);
         this._geoRulerLayer.addEntities([this._rayH, this._rayV]);
 
-        this._planet.addLayer(this._geoRulerLayer);
+        this._planet!.addLayer(this._geoRulerLayer);
     }
 
-    frame() {
+    public override frame() {
         super.frame()
         this._updateHeightRaysAndLabels();
     }
 }
 
 
-export { HeightRulerScene };
+export {HeightRulerScene};

package/src/{og/control/heightRuler/HeightRulerSwitcher.js → control/heightRuler/HeightRulerSwitcher.ts}

@@ -1,8 +1,8 @@
-import { RulerSwitcher } from "../RulerSwitcher.js";
-import { HeightRuler } from "./HeightRuler.js";
+import { RulerSwitcher } from "../RulerSwitcher";
+import { HeightRuler } from "./HeightRuler";
 
 export class HeightRulerSwitcher extends RulerSwitcher {
-    constructor(options = {}) {
+    constructor(options: { ignoreTerrain?: boolean } = {}) {
         super({
             name: `HeightRulerSwitcher`,
             ...options

package/src/control/index.ts

@@ -0,0 +1,45 @@
+import { CompassButton } from "./CompassButton";
+import { Control } from "./Control";
+import { DebugInfo } from "./DebugInfo";
+import { DrawingSwitcher } from "./DrawingSwitcher";
+import { EarthCoordinates } from "./EarthCoordinates";
+import { EarthNavigation } from "./EarthNavigation";
+import { GeoImageDragControl } from "./GeoImageDragControl";
+import { KeyboardNavigation } from "./KeyboardNavigation";
+import { LayerAnimation } from "./LayerAnimation";
+import { LayerSwitcher } from "./LayerSwitcher";
+import { Lighting } from "./Lighting";
+import { MouseNavigation } from "./MouseNavigation";
+import { MouseWheelZoomControl } from "./MouseWheelZoomControl";
+import { RulerSwitcher } from "./RulerSwitcher";
+import { ScaleControl } from "./ScaleControl";
+import { ShowFps } from "./ShowFps";
+import { SimpleNavigation } from "./SimpleNavigation";
+import { SimpleSkyBackground } from "./SimpleSkyBackground";
+import { Sun } from "./Sun";
+import { ToggleWireframe } from "./ToggleWireframe";
+import { TouchNavigation } from "./TouchNavigation";
+import { ZoomControl } from "./ZoomControl";
+import { DrawingControl } from "./drawing/DrawingControl";
+import { HeightRuler } from "./heightRuler/HeightRuler";
+import { Ruler } from "./ruler/Ruler";
+import { Selection } from "./selection/Selection";
+import { TimelineControl } from "./timeline/TimelineControl";
+
+export {
+    CompassButton, Control, DebugInfo, DrawingControl, DrawingSwitcher, EarthCoordinates, EarthNavigation, GeoImageDragControl,
+    HeightRuler,
+    KeyboardNavigation, LayerAnimation, LayerSwitcher,
+    Lighting, MouseNavigation,
+    MouseWheelZoomControl,
+    Ruler,
+    RulerSwitcher,
+    ScaleControl, Selection, ShowFps,
+    SimpleNavigation,
+    SimpleSkyBackground,
+    Sun, TimelineControl,
+    ToggleWireframe,
+    TouchNavigation,
+    ZoomControl
+};
+

package/src/control/ruler/Ruler.ts

@@ -0,0 +1,35 @@
+import {Control, IControlParams} from "../Control";
+import {RulerScene} from "./RulerScene";
+
+export interface IRulerParams extends IControlParams {
+    ignoreTerrain?: boolean
+}
+
+export class Ruler extends Control {
+    protected _rulerScene: RulerScene;
+
+    constructor(options: IRulerParams = {}) {
+        super(options);
+
+        this._rulerScene = new RulerScene({
+            name: `rulerScene:${this.__id}`,
+            ignoreTerrain: options.ignoreTerrain
+        });
+    }
+
+    public set ignoreTerrain(v: boolean) {
+        this._rulerScene.ignoreTerrain = v;
+    }
+
+    public override oninit() {
+        this._rulerScene.bindPlanet(this.planet!);
+    }
+
+    public override onactivate() {
+        this.renderer && this.renderer.addNode(this._rulerScene);
+    }
+
+    public override ondeactivate() {
+        this.renderer && this.renderer.removeNode(this._rulerScene);
+    }
+}