@openglobus/og 0.17.2 → 0.18.1

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

@@ -1,275 +0,0 @@
-'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/heightRuler/HeightRuler.js

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

package/src/og/control/heightRuler/HeightRulerScene.js

@@ -1,228 +0,0 @@
-'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 = {
-    startColor: "rgb(255,131,0)",
-    endColor: "rgb(255,131,0)",
-    thickness: 5
-}
-const LABEL_OPTIONS = {
-    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]
-};
-
-const RULER_CORNER_OPTIONS = {
-    scale: 1,
-    instanced: true,
-    tag: "height-ruler",
-    color: "rgb(255,131,0)",
-    object3d: obj3d
-};
-
-class HeightRulerScene extends RulerScene {
-    constructor(options = {}) {
-        super(options);
-
-
-        this._cornersLayer = new Vector("corners", {
-            entities: [],
-            pickingEnabled: true,
-            displayInLayerSwitcher: false,
-            scaleByDistance: [100, 4000000, 1.0],
-            pickingScale: 2
-        });
-
-
-        this._geoRulerLayer = new Vector("rayHeightRuler", {
-            entities: [],
-            pickingEnabled: false,
-            polygonOffsetUnits: -2.0,
-            relativeToGround: false,
-            displayInLayerSwitcher: false
-        });
-    }
-
-    setVisibility(visibility) {
-        super.setVisibility(visibility);
-        this._geoRulerLayer.setVisibility(visibility);
-    }
-
-    get deltaLabel() {
-        return this._heightLabels[2]
-    }
-
-    get startLabel() {
-        return this._heightLabels[0]
-    }
-
-    get endLabel() {
-        return this._heightLabels[1]
-    }
-
-    get corners() {
-        return this._cornerEntity;
-    }
-
-    get startCorner() {
-        return this.corners[0];
-    }
-
-    get endCorner() {
-        return this.corners[1];
-    }
-
-    get startCornerLonLat() {
-        return this.startCorner.getLonLat();
-    }
-
-    get startCornerHeight() {
-        return this.startCornerLonLat.height;
-    }
-
-    get endCornerLonLat() {
-        return this.endCorner.getLonLat();
-    }
-
-    get endCornerHeight() {
-        return this.endCornerLonLat.height;
-    }
-
-    get maxHeightCornerLonLat() {
-        if (this.startCornerHeight <= this.endCornerHeight) {
-            return this.endCornerLonLat;
-        } else {
-            return this.startCornerLonLat;
-        }
-    }
-
-    get minHeightCornerLonLat() {
-        if (this.startCornerHeight > this.endCornerHeight) {
-            return this.endCornerLonLat;
-        } else {
-            return this.startCornerLonLat;
-        }
-    }
-
-    get deltaHeight() {
-        return Math.abs(this.startCornerHeight - this.endCornerHeight);
-    }
-
-    _drawLine(startLonLat, endLonLat, startPos) {
-        super._drawLine(startLonLat, endLonLat, startPos);
-        this._updateHeightRaysAndLabels();
-    }
-
-    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));
-
-        middleLonLat.height = this.minHeightCornerLonLat.height + this.deltaHeight / 2;
-
-        this.deltaLabel.setLonLat(middleLonLat);
-        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)
-
-        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() {
-        this._rayH.remove();
-        this._rayV.remove();
-        this.startCorner.remove();
-        this.endCorner.remove();
-        this.startLabel.remove();
-        this.endLabel.remove();
-        this.deltaLabel.remove();
-        super.clear()
-        this._rayH = undefined;
-        this._rayV = undefined;
-
-        this._planet.removeLayer(this._geoRulerLayer);
-    }
-
-    _createCorners() {
-        this._cornerEntity = [
-            new Entity({
-                geoObject: RULER_CORNER_OPTIONS,
-                properties: {
-                    name: "start"
-                }
-            }),
-            new Entity({
-                geoObject: RULER_CORNER_OPTIONS,
-                properties: {
-                    name: "end"
-                }
-            })
-        ];
-
-        this._cornersLayer.setEntities(this._cornerEntity);
-    }
-
-    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);
-    }
-
-    frame() {
-        super.frame()
-        this._updateHeightRaysAndLabels();
-    }
-}
-
-
-export { HeightRulerScene };

package/src/og/control/heightRuler/HeightRulerSwitcher.js

@@ -1,15 +0,0 @@
-import { RulerSwitcher } from "../RulerSwitcher.js";
-import { HeightRuler } from "./HeightRuler.js";
-
-export class HeightRulerSwitcher extends RulerSwitcher {
-    constructor(options = {}) {
-        super({
-            name: `HeightRulerSwitcher`,
-            ...options
-        });
-        this.ruler = new HeightRuler({
-            ignoreTerrain: options.ignoreTerrain
-        });
-    }
-
-}

package/src/og/control/index.js

@@ -1,56 +0,0 @@
-import { CompassButton } from "./CompassButton.js";
-import { Control } from "./Control.js";
-import { DebugInfo } from "./DebugInfo.js";
-import { EarthCoordinates } from "./EarthCoordinates.js";
-import { EarthNavigation } from "./EarthNavigation.js";
-import { GeoImageDragControl } from "./GeoImageDragControl.js";
-import { KeyboardNavigation } from "./KeyboardNavigation.js";
-import { LayerAnimation } from "./LayerAnimation.js";
-import { LayerSwitcher } from "./LayerSwitcher.js";
-import { Lighting } from "./Lighting.js";
-import { MouseNavigation } from "./MouseNavigation.js";
-import { MouseWheelZoomControl } from "./MouseWheelZoomControl.js";
-import { Ruler } from "./ruler/Ruler.js";
-import { HeightRuler } from "./heightRuler/HeightRuler.js";
-import { ScaleControl } from "./ScaleControl.js";
-import { Selection } from "./selection/Selection.js";
-import { ShowFps } from "./ShowFps.js";
-import { SimpleNavigation } from "./SimpleNavigation.js";
-import { SimpleSkyBackground } from "./SimpleSkyBackground.js";
-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";
-
-export {
-    Control,
-    CompassButton,
-    DebugInfo,
-    EarthNavigation,
-    EarthCoordinates,
-    GeoImageDragControl,
-    KeyboardNavigation,
-    LayerSwitcher,
-    MouseNavigation,
-    ToggleWireframe,
-    TouchNavigation,
-    SimpleNavigation,
-    ShowFps,
-    ScaleControl,
-    Sun,
-    ZoomControl,
-    MouseWheelZoomControl,
-    Lighting,
-    Ruler,
-    HeightRuler,
-    SimpleSkyBackground,
-    Selection,
-    LayerAnimation,
-    TimelineControl,
-    DrawingSwitcher,
-    DrawingControl
-};

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

@@ -1,39 +0,0 @@
-"use strict";
-
-import { Control } from "../Control.js";
-import { RulerScene } from "./RulerScene.js";
-
-/**
- * Activate ruler
- * @class
- * @extends {Control}
- * @param {Object} [options] - Control options.
- */
-class Ruler extends Control {
-    constructor(options = {}) {
-        super(options);
-
-        this._rulerScene = new RulerScene({
-            name: `rulerScene:${this._id}`,
-            ignoreTerrain: options.ignoreTerrain
-        });
-    }
-
-    set ignoreTerrain(v) {
-        this._rulerScene.ignoreTerrain = v;
-    }
-
-    oninit() {
-        this._rulerScene.bindPlanet(this.planet);
-    }
-
-    onactivate() {
-        this.renderer.addNode(this._rulerScene);
-    }
-
-    ondeactivate() {
-        this.renderer.removeNode(this._rulerScene);
-    }
-}
-
-export { Ruler };