@openglobus/og 0.18.0 → 0.18.2

package/src/control/ruler/RulerScene.ts

@@ -1,437 +0,0 @@
-import {Entity} from '../../entity/Entity';
-import {createEvents, EventsHandler} from '../../Events';
-import {LonLat} from "../../LonLat";
-import {Object3d} from '../../Object3d';
-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";
-import {ILabelParams} from "../../entity/Label";
-
-const OUTLINE_COUNT = 120;
-
-export interface IRulerSceneParams {
-    name?: string;
-    ignoreTerrain?: boolean;
-    planet?: Planet;
-}
-
-export const distanceFormat = (v: number): string => {
-    if (v > 1000) {
-        return `${(v / 1000).toFixed(1)} km`;
-    } else if (v > 9) {
-        return `${Math.round(v)} m`;
-    } else {
-        return `${v.toFixed(1)} m`;
-    }
-}
-
-let obj3d = Object3d.createCylinder(1.1, 0, 2.7, 20, 1, true, false, 0, 0, 0);
-
-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, 20, 0]
-};
-const RULER_CORNER_OPTIONS = {
-    scale: 1,
-    instanced: true,
-    tag: "ruler",
-    color: "rgb(0,305,0)",
-    object3d: obj3d
-};
-
-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"
-];
-
-class RulerScene extends RenderNode {
-    public 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 = {}) {
-        super(options.name);
-
-        this.events = createEvents(RULERSCENE_EVENTS);
-
-        this._ignoreTerrain = options.ignoreTerrain != undefined ? options.ignoreTerrain : true;
-
-        this._planet = options.planet || null;
-
-        this._startLonLat = null;
-        this._preventClick = false;
-        this._stopDrawing = false;
-
-        this._pickedCorner = null;
-        this._startPos = null;
-        this._startClick = new Vec2();
-
-        this._anchorLonLat = null;
-
-        this._heading = 0;
-
-        this._trackLayer = new Vector("track", {
-            entities: [],
-            pickingEnabled: false,
-            polygonOffsetUnits: -1.0,
-            relativeToGround: true,
-            displayInLayerSwitcher: false
-        });
-
-        this._labelLayer = new Vector("ruler-label", {
-            entities: [],
-            pickingEnabled: false,
-            polygonOffsetUnits: -100.0,
-            relativeToGround: true,
-            displayInLayerSwitcher: false
-        });
-
-        this._cornersLayer = new Vector("corners", {
-            entities: [],
-            pickingEnabled: true,
-            displayInLayerSwitcher: false,
-            scaleByDistance: [100, 4000000, 1.0],
-            pickingScale: 2
-        });
-
-        this._propsLabel = new Entity({
-            name: 'propsLabel',
-            label: LABEL_OPTIONS
-        });
-
-        this._trackEntity = new Entity({
-            polyline: {
-                path3v: [],
-                thickness: 4.8,
-                color: "rgb(255,131,0)",
-                isClosed: false
-            }
-        });
-
-        this._trackEntity.polyline!.altitude = 0.01;
-
-        this._cornerEntity = [
-            new Entity({
-                geoObject: RULER_CORNER_OPTIONS,
-                properties: {
-                    name: "start"
-                }
-            }),
-            new Entity({
-                geoObject: RULER_CORNER_OPTIONS,
-                properties: {
-                    name: "end"
-                }
-            })
-        ];
-    }
-
-    public set ignoreTerrain(v: boolean) {
-        this._ignoreTerrain = v;
-        if (v) {
-            //...redraw line
-        }
-    }
-
-    public bindPlanet(planet: Planet) {
-        this._planet = planet;
-    }
-
-    protected _createCorners() {
-        this._cornersLayer.addEntities(this._cornerEntity)
-    }
-
-    public override init() {
-        this._createCorners();
-        this._trackLayer.addEntities([this._trackEntity]);
-        this._labelLayer.addEntities([this._propsLabel]);
-        this._planet!.addLayer(this._labelLayer);
-        this._planet!.addLayer(this._trackLayer);
-        this._planet!.addLayer(this._cornersLayer);
-        this._activate();
-    }
-
-    public override onremove() {
-        this._deactivate();
-    }
-
-    public _activate() {
-
-        this._propsLabel.label!.setVisibility(false);
-        this.setVisibility(false);
-
-        this.renderer!.events.on("lclick", this._onLclick, this);
-        this.renderer!.events.on("mousemove", this._onMouseMove, this);
-        this.renderer!.events.on("ldblclick", this._onLdblclick, this);
-        this.renderer!.events.on("lup", this._onLUp, this);
-
-        this._cornersLayer.events.on("mouseenter", this._onCornerEnter, this);
-        this._cornersLayer.events.on("mouseleave", this._onCornerLeave, this);
-        this._cornersLayer.events.on("ldown", this._onCornerLdown, this);
-        this._cornersLayer.events.on("lup", this._onCornerLup, this);
-
-    }
-
-    protected _deactivate() {
-        this._startLonLat = null;
-        this._preventClick = false;
-        this._stopDrawing = false;
-        this._pickedCorner = null;
-        // this._trackLayer.remove();
-        // this._cornersLayer.remove();
-
-        this.renderer!.events.off("lclick", this._onLclick);
-        this.renderer!.events.off("mousemove", this._onMouseMove);
-        this.renderer!.events.off("lup", this._onLUp);
-
-        this._cornersLayer.events.off("mouseenter", this._onCornerEnter);
-        this._cornersLayer.events.off("mouseleave", this._onCornerLeave);
-        this._cornersLayer.events.off("ldown", this._onCornerLdown);
-        this._cornersLayer.events.off("lup", this._onCornerLup);
-
-        this.clear();
-    }
-
-    protected _onCornerLdown = (e: IMouseState) => {
-        if (!this._startLonLat) {
-            this.renderer?.controls.mouseNavigation?.deactivate();
-            this._startClick.set(e.x, e.y);
-            let coords = e.pickingObject.getCartesian();
-            this._startPos = this._planet!.getPixelFromCartesian(coords);
-            this._pickedCorner = e.pickingObject;
-            if (e.pickingObject.properties.name == "start") {
-                this._anchorLonLat = this._cornerEntity[1].getLonLat().clone();
-            } else {
-                this._anchorLonLat = this._cornerEntity[0].getLonLat().clone();
-            }
-        }
-    }
-
-    protected _onLUp = () => {
-        if (this._pickedCorner) {
-            this.renderer!.controls.mouseNavigation?.activate();
-            this._pickedCorner = null;
-            this._anchorLonLat = null;
-        }
-    }
-
-    protected _onCornerLup = () => {
-        this._onLUp();
-    }
-
-    protected _onCornerEnter = (e: IMouseState) => {
-        e.renderer.handler.canvas!.style.cursor = "pointer";
-    }
-
-    protected _onCornerLeave = (e: IMouseState) => {
-        e.renderer.handler.canvas!.style.cursor = "default";
-    }
-
-    protected _onLdblclick = () => {
-        this._preventClick = true;
-    }
-
-    public setVisibility(visibility: boolean) {
-        this._cornersLayer.setVisibility(visibility);
-        this._trackLayer.setVisibility(visibility);
-        this._labelLayer.setVisibility(visibility);
-    }
-
-    protected _onLclick = (e: IMouseState) => {
-        let startLonLat = this._planet!.getLonLatFromPixelTerrain(e.pos);
-        if (!startLonLat) return;
-        this._timeout = setTimeout(() => {
-            if (!this._preventClick) {
-                if (!this._startLonLat) {
-                    this.setVisibility(true);
-                    this._stopDrawing = false;
-                    this._startLonLat = startLonLat!;
-                } else {
-                    this._startLonLat = null;
-                }
-            }
-            this._preventClick = false;
-            this._stopDrawing = false;
-            clearTimeout(this._timeout);
-        }, 200);
-
-        if (this._startLonLat) {
-            this._stopDrawing = true;
-        }
-    }
-
-    protected _drawLine(startLonLat: LonLat, endLonLat: LonLat, startPos?: Vec3) {
-
-        if (!startPos) {
-            startPos = this._planet!.ellipsoid.lonLatToCartesian(startLonLat);
-        }
-
-        let endPos = this._planet!.ellipsoid.lonLatToCartesian(endLonLat);
-
-        let res = this._planet!.ellipsoid.inverse(startLonLat, endLonLat);
-        let length = res.distance;
-        this._heading = res.initialAzimuth;
-
-        let path = [];
-        let dir = endPos.sub(startPos);
-        let dist = dir.length();
-        dir.normalize();
-
-        for (let i = 0; i < OUTLINE_COUNT; i++) {
-            let f = dir.scaleTo(i * dist / OUTLINE_COUNT).addA(startPos);
-            path.push(f);
-        }
-        path.push(endPos);
-
-        this._trackEntity.polyline!.setPath3v([path]);
-
-        if (this._ignoreTerrain) {
-            this._propsLabel.setCartesian3v(path[Math.floor(path.length / 2)]);
-            this._propsLabel.label!.setText(`${distanceFormat(length)}, ${Math.round(this._heading)} deg`);
-        }
-    }
-
-    protected _onMouseMove = (e: IMouseState) => {
-        if (this._startLonLat && !this._stopDrawing) {
-            this._propsLabel.label!.setVisibility(true);
-            let endLonLat = this._planet!.getLonLatFromPixelTerrain(e.pos);
-            if (!endLonLat) return;
-            this._drawLine(this._startLonLat, endLonLat);
-        } else if (this._pickedCorner) {
-            let newLonLat = this._planet!.getLonLatFromPixelTerrain(e.pos);
-            if (newLonLat) {
-                if (this._pickedCorner.properties.name === "start") {
-                    this._drawLine(newLonLat, this._anchorLonLat!);
-                } else {
-                    this._drawLine(this._anchorLonLat!, newLonLat);
-                }
-            }
-        }
-    }
-
-    public clear() {
-        this._trackEntity.remove();
-        this._cornerEntity[0].remove();
-        this._cornerEntity[1].remove();
-        this._propsLabel.remove();
-        this._planet!.removeLayer(this._trackLayer);
-        this._planet!.removeLayer(this._cornersLayer);
-    }
-
-    public isCornersPositionChanged(): boolean {
-        let t = this._trackEntity.polyline!.getPath3v()[0] as Vec3[];
-        if (t) {
-            const startPos = t[0].clone(),
-                endPos = t[t.length - 1].clone();
-            return this._cornerEntity[0].getCartesian().equal(startPos) &&
-                this._cornerEntity[1].getCartesian().equal(endPos)
-        }
-        return false
-    }
-
-    public override frame() {
-        let t = this._trackEntity.polyline!.getPath3v()[0] as Vec3[];
-        if (t) {
-            const startPos = t[0].clone(),
-                endPos = t[t.length - 1].clone();
-
-            if (!this.isCornersPositionChanged()) {
-                this._cornerEntity[0].setCartesian3v(startPos);
-                this._cornerEntity[1].setCartesian3v(endPos);
-                if (!this._ignoreTerrain) {
-                    let res = 0;
-                    for (let i = 0, len = t.length - 1; i < len; i++) {
-                        res += t[i + 1].distance(t[i]);
-                    }
-                    this._propsLabel.setCartesian3v(t[Math.floor(t.length / 2)]);
-                    this._propsLabel.label!.setText(`${distanceFormat(res)}, ${Math.round(this._heading)} deg`);
-                }
-            }
-        }
-    }
-
-    public get ellipsoid(): Ellipsoid | null {
-        return this._planet ? this._planet.ellipsoid : null;
-    }
-}
-
-const RULERSCENE_EVENTS: 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"
-];
-
-export {RulerScene};

package/src/control/timeline/timelineUtils.ts

@@ -1,133 +0,0 @@
-import * as math from '../../math';
-
-type BaselineType = "alphabetic" | "bottom" | "hanging" | "ideographic" | "middle" | "top";
-type AlignType = "center" | "end" | "left" | "right" | "start";
-
-export function addSeconds(date: Date, seconds: number): Date {
-    return new Date(+date + seconds * 1000);
-}
-
-export function dateToStr(date: Date, showTime: boolean = true, showMilliseconds: boolean = false): string {
-
-    let month = MONTHS[date.getMonth()],
-        day = date.getUTCDate(),
-        year = date.getUTCFullYear();
-
-    if (showTime) {
-        let h = date.getUTCHours().toString().padStart(2, '0'),
-            m = date.getUTCMinutes().toString().padStart(2, '0'),
-            s = date.getUTCSeconds().toString().padStart(2, '0');
-
-        if (showMilliseconds) {
-            let ms = date.getUTCMilliseconds().toString().padStart(3, '0');
-            return `${month} ${day} ${year} ${h}:${m}:${s}.${ms}`;
-        }
-
-        return `${month} ${day} ${year} ${h}:${m}:${s}`;
-    }
-
-    return `${month} ${day} ${year}`;
-}
-
-export function createCanvasHTML(): HTMLCanvasElement {
-    return document.createElement("canvas");
-}
-
-export function getNearestTimeLeft(t: number, div: number): number {
-    return t - (t % div);
-}
-
-export function drawNotch(ctx: CanvasRenderingContext2D, xOffset: number = 0, size: number = 10, thickness: number = 2, color: string = "white") {
-    ctx.lineWidth = thickness;
-    ctx.strokeStyle = color;
-    ctx.beginPath();
-    ctx.moveTo(xOffset, 0);
-    ctx.lineTo(xOffset, size);
-    ctx.stroke();
-}
-
-export function drawText(ctx: CanvasRenderingContext2D, text: string, x: number, y: number, font: string = "12px Arial", fillStyle: string = "black", align: AlignType = "left", baseLine: BaselineType = "bottom", rotDeg: number = 0) {
-    ctx.save();
-    ctx.translate(x, y);
-    ctx.rotate(rotDeg * math.RADIANS);
-    ctx.fillStyle = fillStyle;
-    ctx.textBaseline = baseLine;
-    ctx.font = font;
-    ctx.textAlign = align;
-    ctx.fillText(text, 0, 0);
-    ctx.restore();
-}
-
-export const SCALES: [number, number][] = [
-    [0.001, 10],
-    [0.002, 10],
-    [0.005, 10],
-    [0.01, 10],
-    [0.02, 10],
-    [0.05, 10],
-    [0.1, 10],
-    [0.25, 10],
-    [0.5, 5],
-    [1.0, 10],
-    [2.0, 10],
-    [5.0, 5],
-    [10.0, 10],
-    [15.0, 15],
-    [30.0, 6],
-    [60.0, 12], // 1min
-    [120.0, 12], // 2min
-    [300.0, 5], // 5min
-    [600.0, 10], // 10min
-    [900.0, 15], // 15min
-    [1800.0, 6], // 30min
-    [3600.0, 12], // 1hr
-    [7200.0, 10], // 2hr
-    [14400.0, 4], // 4hr
-    [21600.0, 6], // 6hr
-    [43200.0, 12], // 12hr
-    [86400.0, 24], // 24hr
-    [172800.0, 2], // 2days
-    [345600.0, 4], // 4days
-    [604800.0, 7], // 7days
-    [1296000.0, 15], // 15days
-    [2592000.0, 5], // 30days
-    [5184000.0, 6], // 60days
-    [7776000.0, 9], // 90days
-    [15552000.0, 18], // 180days
-    [31536000.0, 12], // 365days
-    [63072000.0, 2], // 2years
-    [126144000.0, 4], // 4years
-    [157680000.0, 5], // 5years
-    [315360000.0, 10], // 10years
-    [630720000.0, 2], // 20years
-    [1261440000.0, 4], // 40years
-    [1576800000.0, 5], // 50years
-    [3153600000.0, 10], // 100years
-    [6307200000.0, 2], // 200years
-    [12614400000.0, 4], // 400years
-    [15768000000.0, 5], // 500years
-    [31536000000.0, 10], // 1000years
-];
-
-export function getScale(seconds: number) {
-    for (let i = 0, len = SCALES.length; i < len; i++) {
-        if (SCALES[i][0] > seconds) {
-            return SCALES[i - 1];
-        }
-    }
-}
-
-export const MONTHS = [
-    "Jan",
-    "Feb",
-    "Mar",
-    "Apr",
-    "May",
-    "Jun",
-    "Jul",
-    "Aug",
-    "Sep",
-    "Oct",
-    "Nov",
-    "Dec",
-];

package/src/ellipsoid/index.ts

@@ -1,4 +0,0 @@
-import {Ellipsoid} from './Ellipsoid';
-import {wgs84} from './wgs84';
-
-export {Ellipsoid, wgs84};