@openglobus/og 0.17.2 → 0.18.1

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

@@ -0,0 +1,217 @@
+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 {
+    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;
+        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 { 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/lib/js/control/heightRuler/HeightRuler.js

@@ -0,0 +1,11 @@
+import { Ruler } from "../ruler/Ruler";
+import { HeightRulerScene } from "./HeightRulerScene";
+export class HeightRuler extends Ruler {
+    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 };

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

@@ -0,0 +1,181 @@
+import { Entity } from '../../entity/Entity';
+import { Object3d } from "../../Object3d";
+import { RulerScene } from "../ruler/RulerScene";
+import { Vector } from "../../layer/Vector";
+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, 0]
+};
+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._geoRulerLayer = new Vector("rayHeightRuler", {
+            entities: [],
+            pickingEnabled: false,
+            polygonOffsetUnits: -2.0,
+            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) {
+        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 = null;
+        // this._rayV = null;
+        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._labelLayer.addEntities(this._heightLabels);
+        this._geoRulerLayer.addEntities([this._rayH, this._rayV]);
+        this._planet.addLayer(this._geoRulerLayer);
+    }
+    frame() {
+        super.frame();
+        this._updateHeightRaysAndLabels();
+    }
+}
+export { HeightRulerScene };

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

@@ -0,0 +1,6 @@
+import { RulerSwitcher } from "../RulerSwitcher";
+export declare class HeightRulerSwitcher extends RulerSwitcher {
+    constructor(options?: {
+        ignoreTerrain?: boolean;
+    });
+}

package/lib/js/control/heightRuler/HeightRulerSwitcher.js

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

package/lib/js/control/index.d.ts

@@ -0,0 +1,28 @@
+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/lib/js/control/index.js

@@ -0,0 +1,28 @@
+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/lib/js/control/ruler/Ruler.d.ts

@@ -0,0 +1,13 @@
+import { Control, IControlParams } from "../Control";
+import { RulerScene } from "./RulerScene";
+export interface IRulerParams extends IControlParams {
+    ignoreTerrain?: boolean;
+}
+export declare class Ruler extends Control {
+    protected _rulerScene: RulerScene;
+    constructor(options?: IRulerParams);
+    set ignoreTerrain(v: boolean);
+    oninit(): void;
+    onactivate(): void;
+    ondeactivate(): void;
+}

package/lib/js/control/ruler/Ruler.js

@@ -0,0 +1,23 @@
+import { Control } from "../Control";
+import { RulerScene } from "./RulerScene";
+export 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 && this.renderer.addNode(this._rulerScene);
+    }
+    ondeactivate() {
+        this.renderer && this.renderer.removeNode(this._rulerScene);
+    }
+}

package/lib/js/control/ruler/RulerScene.d.ts

@@ -0,0 +1,88 @@
+import { Entity } from '../../entity/Entity';
+import { EventsHandler } from '../../Events';
+import { LonLat } from "../../LonLat";
+import { Planet } from "../../scene/Planet";
+import { RenderNode } from '../../scene/RenderNode';
+import { Vector } from '../../layer/Vector';
+import { Vec2 } from '../../math/Vec2';
+import { Vec3 } from '../../math/Vec3';
+import { IMouseState } from "../../renderer/RendererEvents";
+import { Ellipsoid } from "../../ellipsoid/Ellipsoid";
+export interface IRulerSceneParams {
+    name?: string;
+    ignoreTerrain?: boolean;
+    planet?: Planet;
+}
+export declare const distanceFormat: (v: number) => string;
+type RulerSceneEventsList = [
+    "add",
+    "remove",
+    "mousemove",
+    "mouseenter",
+    "mouseleave",
+    "lclick",
+    "rclick",
+    "mclick",
+    "ldblclick",
+    "rdblclick",
+    "mdblclick",
+    "lup",
+    "rup",
+    "mup",
+    "ldown",
+    "rdown",
+    "mdown",
+    "lhold",
+    "rhold",
+    "mhold",
+    "mousewheel",
+    "touchmove",
+    "touchstart",
+    "touchend",
+    "doubletouch",
+    "touchleave",
+    "touchenter"
+];
+declare class RulerScene extends RenderNode {
+    events: EventsHandler<RulerSceneEventsList>;
+    protected _ignoreTerrain: boolean;
+    protected _planet: Planet | null;
+    protected _startLonLat: LonLat | null;
+    protected _preventClick: boolean;
+    protected _stopDrawing: boolean;
+    protected _pickedCorner: Entity | null;
+    protected _startPos: Vec2 | null;
+    protected _startClick: Vec2;
+    protected _heading: number;
+    protected _trackLayer: Vector;
+    protected _labelLayer: Vector;
+    protected _cornersLayer: Vector;
+    protected _cornerEntity: Entity[];
+    protected _propsLabel: Entity;
+    protected _trackEntity: Entity;
+    protected _anchorLonLat: LonLat | null;
+    protected _timeout: any;
+    constructor(options?: IRulerSceneParams);
+    set ignoreTerrain(v: boolean);
+    bindPlanet(planet: Planet): void;
+    protected _createCorners(): void;
+    init(): void;
+    onremove(): void;
+    _activate(): void;
+    protected _deactivate(): void;
+    protected _onCornerLdown: (e: IMouseState) => void;
+    protected _onLUp: () => void;
+    protected _onCornerLup: () => void;
+    protected _onCornerEnter: (e: IMouseState) => void;
+    protected _onCornerLeave: (e: IMouseState) => void;
+    protected _onLdblclick: () => void;
+    setVisibility(visibility: boolean): void;
+    protected _onLclick: (e: IMouseState) => void;
+    protected _drawLine(startLonLat: LonLat, endLonLat: LonLat, startPos?: Vec3): void;
+    protected _onMouseMove: (e: IMouseState) => void;
+    clear(): void;
+    isCornersPositionChanged(): boolean;
+    frame(): void;
+    get ellipsoid(): Ellipsoid | null;
+}
+export { RulerScene };