@openglobus/og 0.17.2 → 0.18.1

package/lib/js/control/drawing/PolygonDrawingScene.d.ts

@@ -0,0 +1,98 @@
+import { EventsHandler } from '../../Events';
+import { CoordinatesType } from "../../entity/Geometry";
+import { Entity } from '../../entity/Entity';
+import { IMouseState } from "../../renderer/RendererEvents";
+import { Object3d } from '../../Object3d';
+import { Planet } from '../../scene/Planet';
+import { RenderNode } from '../../scene/RenderNode';
+import { Vec2 } from '../../math/Vec2';
+import { Vec3 } from '../../math/Vec3';
+import { Vector } from '../../layer/Vector';
+type PolygonDrawingSceneEventsList = ["change", "startpoint"];
+export interface IPolygonDrawingSceneParams {
+    coordinates?: CoordinatesType[];
+    name: string;
+}
+export declare const NUM_SEGMENTS = 200;
+export declare const OUTLINE_ALT = 0.3;
+export declare const COORDINATES_COLOR = "rgb(350, 350, 0)";
+export declare const CENTER_COLOR = "rgb(0, 350, 50)";
+export declare const OUTLINE_COLOR = "rgb(0, 350, 50)";
+export declare const OUTLINE_THICKNESS = 3.5;
+export declare const CORNER_OPTIONS: {
+    scale: number;
+    instanced: boolean;
+    tag: string;
+    color: string;
+    object3d: Object3d;
+};
+export declare const CENTER_OPTIONS: {
+    scale: number;
+    instanced: boolean;
+    tag: string;
+    color: string;
+    object3d: Object3d;
+};
+export declare const OUTLINE_OPTIONS: {
+    thickness: number;
+    color: string;
+};
+declare class PolygonDrawingScene extends RenderNode {
+    events: EventsHandler<PolygonDrawingSceneEventsList>;
+    _planet: Planet | null;
+    protected _initCoordinates: CoordinatesType[];
+    protected _pickedCorner: Entity | null;
+    protected _pickedCenter: Entity | null;
+    protected _startPos: Vec2 | null;
+    protected _startClick: Vec2;
+    protected _geometryLayer: Vector;
+    protected _cornerLayer: Vector;
+    protected _centerLayer: Vector;
+    protected _outlineLayer: Vector;
+    protected _ghostCorner: Entity;
+    protected _ghostOutlineLayer: Vector;
+    protected _showGhostPointer: boolean;
+    protected _isStartPoint: boolean;
+    protected _insertCornerIndex: number;
+    protected _cornerDblClick: boolean;
+    constructor(options: IPolygonDrawingSceneParams);
+    get geometryType(): string;
+    getCoordinates(): CoordinatesType[];
+    bindPlanet(planet: Planet): void;
+    init(): void;
+    protected _onChange: (e: PolygonDrawingScene) => void;
+    onremove(): void;
+    clear(): void;
+    setCoordinates(coords: CoordinatesType[]): void;
+    stopNewPoint(): void;
+    startNewPoint(): void;
+    showGhostPointer(): void;
+    hideGhostPointer(): void;
+    setGhostPointerPosition(groundPos: Vec3): void;
+    protected _onCornerMouseEnter: (e: IMouseState) => void;
+    _onCornerMouseLeave: (e: IMouseState) => void;
+    _onCenterMouseEnter: (e: IMouseState) => void;
+    _onCenterMouseLeave: (e: IMouseState) => void;
+    protected _onLup: (e: IMouseState) => void;
+    protected _getLdown(e: IMouseState): Entity | null;
+    protected _onCornerLdown: (e: IMouseState) => void;
+    protected _onCenterLdown: (e: IMouseState) => void;
+    protected _onMouseMove: (e: IMouseState) => void;
+    protected _onCornerLdblclick: (e: IMouseState) => void;
+    protected _onMouseDblClick: (e: IMouseState) => void;
+    protected _initEvents(): void;
+    protected _clearEvents(): void;
+    protected _drawCorners(): void;
+    protected _drawCenters(): void;
+    protected _drawGhostCorner(): void;
+    frame(): void;
+    protected _checkTerrainCollision(entity: Entity): void;
+    protected _moveCenterPoint(): void;
+    protected _addNew(cart: Vec3): void;
+    protected _appendCart(cart: Vec3): void;
+    protected _clearGhostPointer(): void;
+    protected _moveCornerPoint(e: Vec2): void;
+    protected _updateGhostOutlinePointer(groundPos: Vec3): void;
+    protected _initGhostLayerPointer(): void;
+}
+export { PolygonDrawingScene };

package/lib/js/control/drawing/PolygonDrawingScene.js

@@ -0,0 +1,534 @@
+import * as math from "../../math";
+import { createEvents } from '../../Events';
+import { Entity } from '../../entity/Entity';
+import { LonLat } from '../../LonLat';
+import { Line3 } from '../../math/Line3';
+import { Object3d } from '../../Object3d';
+import { RenderNode } from '../../scene/RenderNode';
+import { Vec2 } from '../../math/Vec2';
+import { Vec3 } from '../../math/Vec3';
+import { Vector } from '../../layer/Vector';
+const POLYGONDRAWINGSCENE_EVENTS = ["change", "startpoint"];
+const POINTER_OBJ3D = Object3d.createCylinder(1, 1, 2.0, 20, 1, true, false, 0, -0.5, 0);
+export const NUM_SEGMENTS = 200;
+export const OUTLINE_ALT = 0.3;
+export const COORDINATES_COLOR = "rgb(350, 350, 0)";
+export const CENTER_COLOR = "rgb(0, 350, 50)";
+export const OUTLINE_COLOR = "rgb(0, 350, 50)";
+export const OUTLINE_THICKNESS = 3.5;
+export const CORNER_OPTIONS = {
+    scale: 0.5,
+    instanced: true,
+    tag: "corners",
+    color: COORDINATES_COLOR,
+    object3d: POINTER_OBJ3D
+};
+export const CENTER_OPTIONS = {
+    scale: 0.4,
+    instanced: true,
+    tag: "centers",
+    color: CENTER_COLOR,
+    object3d: POINTER_OBJ3D
+};
+export const OUTLINE_OPTIONS = {
+    thickness: OUTLINE_THICKNESS,
+    color: OUTLINE_COLOR
+};
+class PolygonDrawingScene extends RenderNode {
+    constructor(options) {
+        super(options.name);
+        this._cornerDblClick = false;
+        this._onChange = (e) => {
+            if (e.geometryType === "Polygon") {
+                let coords = this.getCoordinates();
+                let entity = new Entity({
+                    'geometry': {
+                        'type': e.geometryType,
+                        'coordinates': [coords],
+                        'style': {
+                            'fillColor': "rgba(0,146,247,0.2)"
+                        }
+                    }
+                });
+                this._geometryLayer.clear();
+                this._geometryLayer.add(entity);
+            }
+        };
+        this._onCornerMouseEnter = (e) => {
+            e.renderer.handler.canvas.style.cursor = "pointer";
+            this.hideGhostPointer();
+        };
+        this._onCornerMouseLeave = (e) => {
+            e.renderer.handler.canvas.style.cursor = "default";
+            this.showGhostPointer();
+        };
+        this._onCenterMouseEnter = (e) => {
+            e.renderer.handler.canvas.style.cursor = "pointer";
+            this.hideGhostPointer();
+        };
+        this._onCenterMouseLeave = (e) => {
+            e.renderer.handler.canvas.style.cursor = "default";
+            if (!(this._pickedCenter || this._pickedCorner)) {
+                this.showGhostPointer();
+            }
+        };
+        this._onLup = (e) => {
+            this._planet.renderer.controls.mouseNavigation.activate();
+            if (this._pickedCorner || this._pickedCenter) {
+                this.events.dispatch(this.events.change, this);
+                this.setGhostPointerPosition(this._planet.getCartesianFromPixelTerrain(e));
+                this.showGhostPointer();
+                this._pickedCorner = null;
+                this._pickedCenter = null;
+            }
+        };
+        this._onCornerLdown = (e) => {
+            this._pickedCorner = this._getLdown(e);
+        };
+        this._onCenterLdown = (e) => {
+            this._pickedCenter = this._getLdown(e);
+        };
+        this._onMouseMove = (e) => {
+            if (this._pickedCenter) {
+                this._moveCenterPoint();
+            }
+            else if (this._pickedCorner) {
+                this._moveCornerPoint(e.pos);
+            }
+            else {
+                this.setGhostPointerPosition(this._planet.getCartesianFromPixelTerrain(e.pos));
+            }
+        };
+        this._onCornerLdblclick = (e) => {
+            this._cornerDblClick = true;
+            let coords = this.getCoordinates();
+            coords.splice(e.pickingObject.layerIndex, 1);
+            this.setCoordinates(coords);
+        };
+        this._onMouseDblClick = (e) => {
+            if (this._cornerDblClick) {
+                this._cornerDblClick = false;
+                return;
+            }
+            if (!this._showGhostPointer) {
+                return;
+            }
+            let cart = this._planet.getCartesianFromPixelTerrain(e);
+            if (cart) {
+                this._addNew(cart);
+                if (!this._isStartPoint && this._cornerLayer.getEntities().length > 2) {
+                    this._isStartPoint = true;
+                    this.events.dispatch(this.events.startpoint, this);
+                }
+                this.events.dispatch(this.events.change, this);
+            }
+        };
+        this.events = createEvents(POLYGONDRAWINGSCENE_EVENTS);
+        this._planet = null;
+        this._initCoordinates = options.coordinates || [];
+        this._pickedCorner = null;
+        this._pickedCenter = null;
+        this._startPos = null;
+        this._startClick = new Vec2();
+        this._geometryLayer = new Vector();
+        //
+        // outline vectors
+        //
+        this._cornerLayer = new Vector("corners", {
+            pickingScale: 3,
+            pickingEnabled: true,
+            polygonOffsetUnits: -5,
+            relativeToGround: true,
+            scaleByDistance: [100, 4000000, 1.0]
+        });
+        this._centerLayer = new Vector("centers", {
+            pickingScale: 3,
+            pickingEnabled: true,
+            polygonOffsetUnits: -5,
+            relativeToGround: true,
+            scaleByDistance: [100, 4000000, 1.0]
+        });
+        this._outlineLayer = new Vector("outline", {
+            entities: [new Entity({
+                    polyline: {
+                        path3v: [],
+                        isClosed: false,
+                        ...OUTLINE_OPTIONS
+                    }
+                })],
+            pickingEnabled: false,
+            polygonOffsetUnits: -5,
+            relativeToGround: true
+        });
+        this._outlineLayer.getEntities()[0].polyline.altitude = OUTLINE_ALT;
+        //
+        // Ghost cursor pointer
+        //
+        this._ghostCorner = new Entity({
+            geoObject: CORNER_OPTIONS
+        });
+        this._ghostOutlineLayer = new Vector("ghost-pointer", {
+            pickingEnabled: false,
+            polygonOffsetUnits: -5,
+            relativeToGround: true,
+            scaleByDistance: [100, 4000000, 1.0],
+            opacity: 0.5
+        });
+        this._showGhostPointer = false;
+        this._isStartPoint = false;
+        this._insertCornerIndex = -1;
+    }
+    get geometryType() {
+        return "Polygon";
+    }
+    getCoordinates() {
+        let corners = this._cornerLayer.getEntities();
+        if (corners.length > 0) {
+            return corners.map((c) => {
+                let ll = c.getLonLat();
+                return [ll.lon, ll.lat, ll.height];
+            });
+        }
+        else {
+            return this._initCoordinates;
+        }
+    }
+    bindPlanet(planet) {
+        this._planet = planet;
+    }
+    init() {
+        this._initEvents();
+        this._initGhostLayerPointer();
+        if (this._initCoordinates.length) {
+            this.setCoordinates(this._initCoordinates);
+        }
+        this._planet.addLayer(this._outlineLayer);
+        this._planet.addLayer(this._cornerLayer);
+        this._planet.addLayer(this._centerLayer);
+        this.showGhostPointer();
+        this.startNewPoint();
+        this._planet.renderer.controls.mouseNavigation.deactivateDoubleClickZoom();
+        this._geometryLayer.addTo(this._planet);
+        this.events.on("change", this._onChange, this);
+    }
+    onremove() {
+        this._clearEvents();
+        this.hideGhostPointer();
+        this.stopNewPoint();
+        this.clear();
+        this._geometryLayer.remove();
+    }
+    clear() {
+        this._geometryLayer.clear();
+        let corners = this._cornerLayer.getEntities();
+        let i = corners.length;
+        while (i--) {
+            corners[i].remove();
+        }
+        let centers = this._centerLayer.getEntities();
+        i = centers.length;
+        while (i--) {
+            centers[i].remove();
+        }
+        let entities = this._outlineLayer.getEntities();
+        i = entities.length;
+        while (i--) {
+            entities[i].polyline.clear();
+            if (i > 0) {
+                entities[i].remove();
+            }
+        }
+        this._clearGhostPointer();
+    }
+    setCoordinates(coords) {
+        this.clear();
+        for (let i = 0; i < coords.length; i++) {
+            let ci = coords[i];
+            let cart = this._planet.ellipsoid.lonLatToCartesian(new LonLat(ci[0], ci[1], ci[2]));
+            this._appendCart(cart);
+        }
+        this.events.dispatch(this.events.change, this);
+    }
+    stopNewPoint() {
+        if (this.renderer) {
+            this.renderer.events.off("ldblclick", this._onMouseDblClick);
+        }
+    }
+    startNewPoint() {
+        this.renderer.events.on("ldblclick", this._onMouseDblClick, this);
+    }
+    showGhostPointer() {
+        this._showGhostPointer = true;
+        this._planet.addLayer(this._ghostOutlineLayer);
+        this._insertCornerIndex = this._cornerLayer.getEntities().length;
+    }
+    hideGhostPointer() {
+        this._showGhostPointer = false;
+        this._ghostOutlineLayer.remove();
+        this._insertCornerIndex = -1;
+    }
+    setGhostPointerPosition(groundPos) {
+        if (groundPos) {
+            this._ghostCorner.setCartesian3v(groundPos);
+            this._updateGhostOutlinePointer(groundPos);
+        }
+    }
+    _getLdown(e) {
+        this._planet.renderer.controls.mouseNavigation.deactivate();
+        this._startClick.set(e.x, e.y);
+        let coords = e.pickingObject.getCartesian();
+        this._startPos = this._planet.getPixelFromCartesian(coords);
+        return e.pickingObject;
+    }
+    _initEvents() {
+        this._cornerLayer.events.on("ldblclick", this._onCornerLdblclick, this);
+        this._cornerLayer.events.on("ldown", this._onCornerLdown, this);
+        this._centerLayer.events.on("ldown", this._onCenterLdown, this);
+        this.renderer.events.on("lup", this._onLup, this);
+        this.renderer.events.on("mousemove", this._onMouseMove, this);
+        this._cornerLayer.events.on("mouseenter", this._onCornerMouseEnter, this);
+        this._cornerLayer.events.on("mouseleave", this._onCornerMouseLeave, this);
+        this._centerLayer.events.on("mouseenter", this._onCenterMouseEnter, this);
+        this._centerLayer.events.on("mouseleave", this._onCenterMouseLeave, this);
+    }
+    _clearEvents() {
+        this._cornerLayer.events.off("ldblclick", this._onCornerLdblclick);
+        this._cornerLayer.events.off("ldown", this._onCornerLdown);
+        this._centerLayer.events.off("ldown", this._onCenterLdown);
+        this.renderer.events.off("lup", this._onLup);
+        this.renderer.events.off("mousemove", this._onMouseMove);
+        this._cornerLayer.events.off("mouseenter", this._onCornerMouseEnter);
+        this._cornerLayer.events.off("mouseleave", this._onCornerMouseLeave);
+        this._centerLayer.events.off("mouseenter", this._onCenterMouseEnter);
+        this._centerLayer.events.off("mouseleave", this._onCenterMouseLeave);
+    }
+    _drawCorners() {
+        let corners = this._cornerLayer.getEntities();
+        for (let i = 0; i < corners.length; i++) {
+            let ai = corners[i];
+            this._checkTerrainCollision(ai);
+        }
+    }
+    _drawCenters() {
+        let centers = this._centerLayer.getEntities();
+        for (let i = 0; i < centers.length; i++) {
+            let ai = centers[i];
+            this._checkTerrainCollision(ai);
+        }
+    }
+    _drawGhostCorner() {
+        if (this._showGhostPointer) {
+            this._checkTerrainCollision(this._ghostCorner);
+        }
+    }
+    frame() {
+        this._drawCorners();
+        this._drawCenters();
+        this._drawGhostCorner();
+    }
+    _checkTerrainCollision(entity) {
+        let _tempTerrPoint = new Vec3();
+        let nodes = this._planet._renderedNodes;
+        for (let j = 0; j < nodes.length; j++) {
+            let seg = nodes[j].segment;
+            if (seg && seg._extentLonLat.isInside(entity.getLonLat())) {
+                seg.getEntityTerrainPoint(entity, _tempTerrPoint);
+                entity.setCartesian3v(_tempTerrPoint);
+                break;
+            }
+        }
+    }
+    _moveCenterPoint() {
+        let coords = this.getCoordinates(), index = this._pickedCenter.layerIndex + 1, ll = this._pickedCenter.getLonLat();
+        let newCorner = [ll.lon, ll.lat, ll.height];
+        coords.splice(index, 0, newCorner);
+        this.setCoordinates(coords);
+        this._pickedCenter = null;
+        this._pickedCorner = this._cornerLayer.getEntities()[index];
+    }
+    _addNew(cart) {
+        if (this._insertCornerIndex === -1 || this._cornerLayer.getEntities().length < 2) {
+            this._appendCart(cart);
+        }
+        else {
+            let area = this.getCoordinates(), index = this._insertCornerIndex;
+            let ll = this._planet.ellipsoid.cartesianToLonLat(cart);
+            let newCorner = [ll.lon, ll.lat, ll.height];
+            area.splice(index, 0, newCorner);
+            this.clear();
+            this.setCoordinates(area);
+        }
+    }
+    _appendCart(cart) {
+        let corners = this._cornerLayer.getEntities();
+        let segNum = corners.length - 1;
+        let prevCorn = corners[segNum];
+        let corner = new Entity({
+            geoObject: CORNER_OPTIONS,
+        });
+        corner.setCartesian3v(cart);
+        corner.addTo(this._cornerLayer);
+        this._checkTerrainCollision(corner);
+        if (prevCorn) {
+            let firstCart = corners[0].getCartesian(), prevCart = prevCorn.getCartesian();
+            let vecPrev = corner.getCartesian().sub(prevCart), vecFirst = corner.getCartesian().sub(firstCart);
+            let distPrev = vecPrev.length(), distFirst = vecFirst.length();
+            vecPrev.normalize();
+            vecFirst.normalize();
+            let prevPath = [], firstPath = [];
+            for (let i = 0; i <= NUM_SEGMENTS; i++) {
+                let p = vecPrev.scaleTo(i * distPrev / NUM_SEGMENTS).addA(prevCart);
+                prevPath.push(p);
+                let f = vecFirst.scaleTo(i * distFirst / NUM_SEGMENTS).addA(firstCart);
+                firstPath.push(f);
+            }
+            this._outlineLayer.getEntities()[0].polyline.setPath3v([firstPath]);
+            let entity = new Entity({
+                polyline: {
+                    path3v: [prevPath],
+                    isClosed: false,
+                    ...OUTLINE_OPTIONS
+                }
+            });
+            entity.polyline.altitude = OUTLINE_ALT;
+            this._outlineLayer.add(entity);
+            let centers = this._centerLayer.getEntities();
+            let firstCenter = centers[centers.length - 1];
+            let prevCenterCart = vecPrev.scaleTo(distPrev * 0.5).addA(prevCart), firstCenterCart = vecFirst.scaleTo(distFirst * 0.5).addA(firstCart);
+            let center = new Entity({
+                geoObject: CENTER_OPTIONS,
+            });
+            center.setCartesian3v(prevCenterCart);
+            center.addTo(this._centerLayer);
+            this._checkTerrainCollision(center);
+            //moveToEnd
+            firstCenter.remove();
+            firstCenter.addTo(this._centerLayer);
+            firstCenter.setCartesian3v(firstCenterCart);
+        }
+        else {
+            let center = new Entity({
+                geoObject: CENTER_OPTIONS,
+            });
+            center.addTo(this._centerLayer);
+        }
+    }
+    _clearGhostPointer() {
+        const g = this._ghostOutlineLayer;
+        g.getEntities()[0].polyline.clear();
+        g.getEntities()[1].polyline.clear();
+    }
+    _moveCornerPoint(e) {
+        let d = new Vec2(e.x, e.y).sub(this._startClick), p = this._startPos.add(d);
+        let groundCoords = this._planet.getCartesianFromPixelTerrain(p);
+        if (groundCoords) {
+            this._pickedCorner.setCartesian3v(groundCoords);
+            let corners = this._cornerLayer.getEntities();
+            if (corners.length) {
+                let ind = this._pickedCorner.layerIndex;
+                let size = corners.length;
+                let cartPrev = corners[ind === 0 ? (size - 1) : (ind - 1)].getCartesian(), cartNext = corners[(ind + 1) % size].getCartesian();
+                let vecPrev = this._pickedCorner.getCartesian().sub(cartPrev), vecNext = this._pickedCorner.getCartesian().sub(cartNext);
+                let distPrev = vecPrev.length(), distNext = vecNext.length();
+                vecPrev.normalize();
+                vecNext.normalize();
+                let pathPrev = [], pathNext = [];
+                for (let i = 0; i <= NUM_SEGMENTS; i++) {
+                    let p = vecPrev.scaleTo(i * distPrev / NUM_SEGMENTS).addA(cartPrev);
+                    pathPrev.push(p);
+                    let f = vecNext.scaleTo(i * distNext / NUM_SEGMENTS).addA(cartNext);
+                    pathNext.push(f);
+                }
+                let entities = this._outlineLayer.getEntities();
+                let prevPolyline = entities[ind].polyline, nextPolyline = entities[(ind + 1) % size].polyline;
+                prevPolyline?.setPath3v([pathPrev]);
+                nextPolyline?.setPath3v([pathNext]);
+                //
+                // Move center points
+                let centers = this._centerLayer.getEntities();
+                let prevCenter = centers[ind === 0 ? (size - 1) : (ind - 1)], nextCenter = centers[ind];
+                let prevCenterCart = vecPrev.scaleTo(distPrev * 0.5).addA(cartPrev), nextCenterCart = vecNext.scaleTo(distNext * 0.5).addA(cartNext);
+                prevCenter.setCartesian3v(prevCenterCart);
+                this._checkTerrainCollision(prevCenter);
+                nextCenter.setCartesian3v(nextCenterCart);
+                this._checkTerrainCollision(nextCenter);
+            }
+        }
+    }
+    _updateGhostOutlinePointer(groundPos) {
+        let corners = this._cornerLayer.getEntities();
+        let size = corners.length;
+        if (size > 0) {
+            let ind = 0;
+            let minDist = math.MAX;
+            for (let i = 0; i < size; i++) {
+                let ci = corners[i];
+                let dist = ci.getCartesian().distance(groundPos);
+                if (dist < minDist) {
+                    minDist = dist;
+                    ind = i;
+                }
+            }
+            let cCurr = corners[ind].getCartesian(), cNext = corners[(ind + 1) % size].getCartesian(), cPrev = corners[ind === 0 ? (size - 1) : (ind - 1)].getCartesian();
+            let nPrev = cPrev.sub(cCurr).normalize(), nNext = cNext.sub(cCurr).normalize(), nGround = groundPos.sub(cCurr).normalize();
+            let midVec = nPrev.add(nNext).normalize();
+            let toMid = nGround.cross(midVec), up = nPrev.cross(nNext);
+            if (toMid.dot(up) > 0) {
+                ind--;
+                if (ind < 0) {
+                    ind = size - 1;
+                }
+            }
+            let temp = new Vec3();
+            for (let i = 0; i < size; i++) {
+                let side = new Line3(corners[i].getCartesian(), corners[(i + 1) % size].getCartesian());
+                let u = side.getNearestDistancePoint(groundPos, temp);
+                if (u) {
+                    let dist = temp.distance(groundPos);
+                    if (dist < minDist) {
+                        minDist = dist;
+                        ind = i;
+                    }
+                }
+            }
+            this._insertCornerIndex = (ind + 1) % size;
+            let cartPrev = corners[ind % size].getCartesian(), cartNext = corners[(ind + 1) % size].getCartesian();
+            let vecPrev = this._ghostCorner.getCartesian().sub(cartPrev), vecNext = this._ghostCorner.getCartesian().sub(cartNext);
+            let distPrev = vecPrev.length(), distNext = vecNext.length();
+            vecPrev.normalize();
+            vecNext.normalize();
+            let pathPrev = [], pathNext = [];
+            for (let i = 0; i <= NUM_SEGMENTS; i++) {
+                let p = vecPrev.scaleTo(i * distPrev / NUM_SEGMENTS).addA(cartPrev);
+                pathPrev.push(p);
+                let f = vecNext.scaleTo(i * distNext / NUM_SEGMENTS).addA(cartNext);
+                pathNext.push(f);
+            }
+            let entities = this._ghostOutlineLayer.getEntities();
+            let prevPolyline = entities[0].polyline, nextPolyline = entities[1].polyline;
+            prevPolyline?.setPath3v([pathPrev]);
+            nextPolyline?.setPath3v([pathNext]);
+        }
+    }
+    _initGhostLayerPointer() {
+        this._ghostOutlineLayer.setEntities([
+            new Entity({
+                polyline: {
+                    path3v: [],
+                    isClosed: false,
+                    ...OUTLINE_OPTIONS
+                }
+            }), new Entity({
+                polyline: {
+                    path3v: [],
+                    isClosed: false,
+                    ...OUTLINE_OPTIONS
+                }
+            }),
+            this._ghostCorner
+        ]);
+        const g = this._ghostOutlineLayer;
+        g.getEntities()[0].polyline.altitude = g.getEntities()[1].polyline.altitude = OUTLINE_ALT;
+    }
+}
+export { PolygonDrawingScene };

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, };