bruce-cesium 5.7.9 → 5.8.1

package/dist/types/rendering/getters/entity-filter-getter.d.ts

@@ -0,0 +1,104 @@
+import { BruceApi, BruceEvent, Entity, EntitySource, IDictionary } from "bruce-models";
+import { EntityGlobe } from "./entity-globe";
+import { CesiumViewMonitor } from "../../viewer/cesium-view-monitor";
+import * as Cesium from "cesium";
+/**
+ * This is a batched entity getter.
+ * It will scan for entity records in a view-area and emit them in batches.
+ * It will restart scanning if the camera moves.
+ */
+export declare namespace EntityFilterGetter {
+    enum EStatus {
+        Scanning = "SCANNING",
+        Loading = "LOADING"
+    }
+    interface IStatusUpdate {
+        msg: EStatus;
+        revoking: boolean;
+    }
+    interface IUpdate {
+        entities: Entity.IEntity[];
+        sources?: EntitySource.ISource[];
+        entityTypeSources?: any[];
+    }
+    class Getter {
+        private onUpdate;
+        get OnUpdate(): BruceEvent<IUpdate>;
+        LastStateUpdates: IDictionary<IStatusUpdate>;
+        private onStateUpdate;
+        get OnStateUpdate(): BruceEvent<IStatusUpdate>;
+        private onScanUpdate;
+        get OnScanUpdate(): BruceEvent<EntityGlobe.Cell[]>;
+        private api;
+        private viewer;
+        private viewPort;
+        private viewPortChangeRemoval;
+        private viewPortDelayQueue;
+        private viewerDateTimeChangeRemoval;
+        private cells;
+        private registeredItems;
+        private getterLoopId;
+        private getterLoopAbortControllers;
+        private looping;
+        private get isLooping();
+        private viaCdn;
+        private typeIds;
+        private schemaId;
+        private batchSize;
+        private tagIds;
+        private minHeight;
+        private maxHeight;
+        private attrFilter;
+        private viewRect;
+        private viewCenter;
+        private scenario;
+        private historic;
+        private historicAttrKey;
+        private historicInterpolation;
+        private historicAttrDateTime;
+        private historicRefreshAbortController;
+        private gatheredIntegrity;
+        private gatheredEntityIds;
+        constructor(params: {
+            api: BruceApi.Api;
+            viewer: Cesium.Viewer;
+            viewPort: CesiumViewMonitor.Monitor;
+            typeIds: string[];
+            schemaId?: string;
+            batchSize?: number;
+            attrFilter?: IDictionary<any>;
+            historicAttrKey?: string;
+            historic?: boolean;
+            historicInterpolation?: boolean;
+            viaCdn?: boolean;
+            scenario?: number | string;
+        });
+        /**
+         * Returns id that represents the combined menu item parameters.
+         * If integrity changes while a request is running, the request will not emit a response.
+         * @returns
+         */
+        private getIntegrityId;
+        private viewAreaSub;
+        private viewAreaDispose;
+        /**
+         * Monitors the Cesium viewer and updates the historic data filter values.
+         * If there is no historic attr set, this will do nothing.
+         */
+        private viewerDateTimeSub;
+        private updateHistoricDateTime;
+        private viewerDateTimeDispose;
+        GetMenuItems(): string[];
+        IncludeMenuItem(menuItemId: string, typeId: string, layerIds: number[], minHeight: number, maxHeight: number): void;
+        ExcludeMenuItem(menuItemId: string): void;
+        private updateBounds;
+        private updateState;
+        private postStatus;
+        private startGetterLoop;
+        /**
+         * Gets the historic state of found Entities for the current date times and emits them.
+         * Since geometry searches are tied to the base Entity, we don't have to re-scan the viewport.
+         */
+        private emitHistoricData;
+    }
+}

package/dist/types/rendering/getters/entity-globe.d.ts

@@ -0,0 +1,21 @@
+import { Bounds, Carto } from "bruce-models";
+/**
+ * This is a helper for making entity requests based on a grid area.
+ * It will return grid cells based on given view-area then will remember when stuff-
+ * was fully-fetched for those cells to avoid making duplicate requests.
+ */
+export declare namespace EntityGlobe {
+    class Cell {
+        Fetched: boolean;
+        IsFetched: () => boolean;
+        FetchPageIndex: number;
+        FetchURL?: string;
+        Boundaries: Bounds.IBounds;
+        Fetching: boolean;
+        GetBounds(): Bounds.IReqBounds;
+    }
+    class Grid {
+        private cells;
+        GetCellsForView(cameraPos: Carto.ICarto, viewRect: Bounds.IReqBounds): Cell[];
+    }
+}

package/dist/types/rendering/menu-item-creator.d.ts

@@ -0,0 +1,53 @@
+import { ApiGetters, BruceApi, IDictionary, MenuItem, ProjectView, ProjectViewBookmark, Tileset } from "bruce-models";
+import { MenuItemManager } from "./menu-item-manager";
+import * as Cesium from "cesium";
+/**
+ * Utility to help generate menu items for rendering various data.
+ */
+export declare namespace MenuItemCreator {
+    interface IParams {
+        getters?: ApiGetters;
+        apiGetter?: BruceApi.IGetter;
+        viewer?: Cesium.Viewer;
+        manager?: MenuItemManager.Manager;
+    }
+    function RenderEntities(params: {
+        entityIds: string[];
+    } & IParams): Promise<{
+        menuItemIds: string[];
+        menuItems: MenuItem.IItem[];
+    }>;
+    function RenderEntityTypes(params: {
+        entityTypeIds: string[];
+    } & IParams): Promise<{
+        menuItemIds: string[];
+        menuItems: MenuItem.IItem[];
+    }>;
+    function RenderEntityFilter(params: {
+        attrFilter: IDictionary<string>;
+    } & IParams): Promise<{
+        menuItemIds: string[];
+        menuItems: MenuItem.IItem[];
+    }>;
+    function RenderMenuItems(params: {
+        menuItems: MenuItem.IItem[];
+    } & IParams): Promise<{
+        menuItemIds: string[];
+    }>;
+    function RenderTileset(params: {
+        tilesetId?: string;
+        tileset?: Tileset.ITileset;
+    } & IParams): Promise<{
+        menuItemIds: string[];
+        menuItems: MenuItem.IItem[];
+    }>;
+    function RenderBookmarkItems(params: {
+        viewId?: string;
+        view?: ProjectView.IView;
+        bookmarkId?: string;
+        bookmark?: ProjectViewBookmark.IBookmark;
+    } & IParams): Promise<{
+        menuItemIds: string[];
+        menuItems: MenuItem.IItem[];
+    }>;
+}

package/dist/types/rendering/menu-item-manager.d.ts

@@ -0,0 +1,85 @@
+import { ApiGetters, BruceApi, BruceEvent, Entity, MenuItem } from "bruce-models";
+import * as Cesium from "cesium";
+import { RenderManager } from "./render-managers/render-manager";
+import { VisualsRegister } from "./visuals-register";
+import { CesiumViewMonitor } from "../viewer/cesium-view-monitor";
+interface IRenderedItem {
+    id: string;
+    type: MenuItem.EType;
+    childIds: string[];
+    item: MenuItem.IItem;
+    renderManager: RenderManager.IManager;
+    errors?: (string | any)[];
+}
+/**
+ * Utility to keep track of enabled menu items within a Cesium viewer.
+ */
+export declare namespace MenuItemManager {
+    interface IMenuItemUpdate {
+        itemId: string;
+        isEnabling: boolean;
+    }
+    class Manager {
+        private getters;
+        get Getters(): ApiGetters;
+        private viewer;
+        get Viewer(): Cesium.Viewer;
+        private items;
+        private visualsRegister;
+        get VisualsRegister(): VisualsRegister.Register;
+        private onUpdate;
+        get OnUpdate(): BruceEvent<IMenuItemUpdate>;
+        private sharedGetters;
+        private sharedMonitor;
+        get Monitor(): CesiumViewMonitor.Monitor;
+        constructor(params: {
+            viewer: Cesium.Viewer;
+            visualsRegister?: VisualsRegister.Register;
+            getters: ApiGetters;
+        });
+        /**
+         * Disposes the menu item manager.
+         * This will dispose all render managers and unregister all menu items.
+         */
+        Dispose(params?: {
+            disposeRegister?: boolean;
+        }): void;
+        /**
+         * Renders a given menu item and all its children.
+         * Will return the enabled item id.
+         * @param params
+         * @returns
+         */
+        RenderItem(params: {
+            item: MenuItem.IItem;
+            modelSpace?: boolean;
+            recursive?: boolean;
+            getters?: ApiGetters;
+            apiGetter?: BruceApi.IGetter;
+        }): string;
+        /**
+         * Disables a menu item by its id.
+         * This will disable all children as well.
+         * @param params
+         */
+        RemoveItemById(params: {
+            menuItemId: string;
+            recursive?: boolean;
+        }): void;
+        GetEnabledItemIds(): string[];
+        GetEnabledItem(id: string): IRenderedItem;
+        /**
+         * Rerenders given entities.
+         * If no menu items are specified then the rerender is called on all enabled menu items.
+         * It is highly recommended to supply menu item ids.
+         * @param params
+         */
+        ReRender(params: {
+            entityIds?: string[];
+            entities?: Entity.IEntity[];
+            menuItemIds?: string[];
+            force?: boolean;
+        }): Promise<void>;
+    }
+}
+export {};

package/dist/types/rendering/relation-render-engine.d.ts

@@ -0,0 +1,32 @@
+import { BruceApi, Entity, EntityRelation, IDictionary, Style } from "bruce-models";
+import { VisualsRegister } from "./visuals-register";
+import * as Cesium from "cesium";
+export declare namespace RelationRenderEngine {
+    interface ICesiumEntityExt extends Cesium.Entity {
+        _siblingGraphics?: Cesium.Entity[];
+        _parentEntity?: Cesium.Entity;
+        _renderGroup?: string;
+        _dispose: () => void;
+    }
+    function GetRenderGroupId(relation: EntityRelation.IRelation): string;
+    function Render(params: {
+        apiGetter: BruceApi.IGetter;
+        viewer: Cesium.Viewer;
+        visualRegister: VisualsRegister.Register;
+        menuItemId: string;
+        relations: EntityRelation.IRelation[];
+    }): Promise<IDictionary<ICesiumEntityExt>>;
+    namespace Parabola {
+        interface IParabola {
+            viewer: Cesium.Viewer;
+            relation: EntityRelation.IRelation;
+            fromEntity: Entity.IEntity;
+            toEntity: Entity.IEntity;
+            dataEntity: Entity.IEntity;
+            style: Style.IStyle;
+            visualRegister?: VisualsRegister.Register;
+            apiGetter: BruceApi.IGetter;
+        }
+        function Render(params: IParabola): Promise<ICesiumEntityExt>;
+    }
+}

package/dist/types/rendering/render-managers/common/cesium-parabola.d.ts

@@ -0,0 +1,39 @@
+import * as Cesium from "cesium";
+/**
+ * Utility for rendering parabolas between two points on the map.
+ */
+export declare class CesiumParabola {
+    private disposed;
+    get Disposed(): boolean;
+    private viewer;
+    private pos1;
+    private pos2;
+    private color;
+    private width;
+    private duration;
+    private heightDistanceRatio;
+    private curPoints;
+    private animateInterval;
+    private retryTimeout;
+    private parabola;
+    private siblings;
+    private hidden;
+    set Hidden(value: boolean);
+    private get curPos1();
+    private get curPos2();
+    constructor(params: {
+        viewer: Cesium.Viewer;
+        pos1: Cesium.Cartesian3 | (() => Cesium.Cartesian3);
+        pos2: Cesium.Cartesian3 | (() => Cesium.Cartesian3);
+        color?: string;
+        width?: number;
+        duration?: number;
+        heightDistanceRatio?: number;
+    });
+    private prepareEntities;
+    Animate(): {
+        parabola: Cesium.Entity;
+        siblings: Cesium.Entity[];
+    };
+    Dispose(): void;
+}

package/dist/types/rendering/render-managers/common/entity-label.d.ts

@@ -0,0 +1,82 @@
+import * as Cesium from "cesium";
+import { VisualsRegister } from "../../visuals-register";
+import { BruceApi } from "bruce-models";
+/**
+ * Util for generating labels within cesium space on entities.
+*/
+export declare namespace EntityLabel {
+    const ATTACH_KEY = "nextspace-navigator-entity-label";
+    class Label {
+        private counter;
+        private viewer;
+        private api;
+        private visualRegister;
+        private rego;
+        get Rego(): VisualsRegister.IVisualRego;
+        private label;
+        private renderRemoval;
+        private terrChangedRemoval;
+        private disposed;
+        get Disposed(): boolean;
+        private _pos3d;
+        get pos3d(): Cesium.Cartesian3;
+        set pos3d(val: Cesium.Cartesian3);
+        private prePositioned;
+        private loadTimeout;
+        private loadedName;
+        private line;
+        private additionalTexts;
+        constructor(params: {
+            rego: VisualsRegister.IVisualRego;
+            viewer: Cesium.Viewer;
+            pos3d?: Cesium.Cartesian3;
+            visualRegister?: VisualsRegister.Register;
+            api?: BruceApi.Api;
+        });
+        /**
+         * Loads the Entity's name and updates the corresponding visual rego.
+         */
+        private loadName;
+        /**
+         * Disposes label and marks instance as disposed.
+         * Recalling will be ignored.
+         */
+        Dispose(): void;
+        /**
+         * Creates cesium entity for the label if one does not exist.
+         * @param starterPos3d optional position to create label at. Ignored for billboard labels.
+         */
+        private createLabel;
+        /**
+         * Removes label from the viewer and unsubscribes from events.
+         */
+        private removeLabel;
+    }
+    /**
+     * Creates an entity label for a given rego.
+     * If one exists then the action is ignored.
+     */
+    function Attach(params: {
+        rego: VisualsRegister.IVisualRego;
+        viewer: Cesium.Viewer;
+        pos3d?: Cesium.Cartesian3;
+        visualRegister?: VisualsRegister.Register;
+        api?: BruceApi.Api;
+    }): Label;
+    /**
+     * Removes an entity label from a given rego.
+     * If one doesn't exist then the action is ignored.
+     */
+    function Detatch(params: {
+        rego?: VisualsRegister.IVisualRego;
+        label?: Label;
+    }): void;
+    /**
+     * Returns label instance from given rego if one exists.
+     * @param params
+     * @returns
+     */
+    function GetLabel(params: {
+        rego: VisualsRegister.IVisualRego;
+    }): Label;
+}

package/dist/types/rendering/render-managers/common/point-clustering.d.ts

@@ -0,0 +1,91 @@
+import { MenuItem } from "bruce-models";
+import * as Cesium from "cesium";
+import { VisualsRegister } from "../../visuals-register";
+export declare class PointClustering {
+    private minDistance;
+    private minTotalCount;
+    private quadTree;
+    private prevClusteredEntities;
+    private currClusteredEntities;
+    private viewer;
+    private register;
+    private updateQueue;
+    private clusterEntities;
+    private disposed;
+    private listenCameraRemoval;
+    private listenUpdateRemoval;
+    private menuItemId;
+    private registeredEntityIds;
+    private pointColorBg;
+    private pointColorTxt;
+    private iconUrl;
+    private updateEntityQueue;
+    private queueInterval;
+    constructor(register: VisualsRegister.Register, menuItemId: string, settings?: MenuItem.Item.IClustering);
+    Update(): void;
+    private queueForceUpdate;
+    private runForceUpdateQueue;
+    /**
+     * Starts listening to camera changes.
+     * This will trigger the clustering update whenever camera is moved.
+     */
+    private listenCamera;
+    /**
+     * Stops listening to camera changes.
+     */
+    private unlistenCamera;
+    /**
+     * Starts listening to entity selection changes.
+     * Selected entities are not clustered.
+     */
+    private listenSelection;
+    private unlistenSelection;
+    /**
+     * Removes all clusters and updates entities to no longer be suppressed.
+     * @returns
+     */
+    Dispose(): void;
+    /**
+     * Calculates center of given points.
+     * @param points
+     * @returns
+     */
+    private calculateCentroid;
+    /**
+     * Gathers current clusters and renders them.
+     * @returns
+     */
+    private doUpdate;
+    private getClusterSpacing;
+    private getClusters;
+    /**
+     * Removes Cesium cluster entity.
+     * @param clusterId
+     */
+    private removeClusterEntity;
+    private convertCartesianToCartographic;
+    /**
+     * Adds new entity to the clustering logic.
+     * @param id Bruce entity ID.
+     * @param cartesian3 entity's position.
+     */
+    private addPoint;
+    /**
+     * Adds entity to clustering logic.
+     * Will return false if entity could not be clustered and therefor should not be hidden.
+     * @param id
+     * @param entity
+     * @param queueUpdate
+     * @returns
+     */
+    AddEntity(id: string, entity: Cesium.Entity, queueUpdate?: boolean): boolean;
+    /**
+     * Removes entity from clustering logic.
+     * Warning: This will not reveal the entity, suppressShow will remain true.
+     * This is made with the assumption that the entity is being removed from viewer.
+     * @param id
+     * @param queueUpdate
+     * @returns
+     */
+    RemoveEntity(id: string, queueUpdate?: boolean): void;
+}

package/dist/types/rendering/render-managers/common/shared-getters.d.ts

@@ -0,0 +1,41 @@
+import { IDictionary, BruceApi } from "bruce-models";
+import { CesiumViewMonitor } from "../../../viewer/cesium-view-monitor";
+import { EntityFilterGetter } from "../../getters/entity-filter-getter";
+import * as Cesium from "cesium";
+export declare namespace SharedGetters {
+    interface IFilterGetterParams {
+        api: BruceApi.Api;
+        typeId: string | string[];
+        batchSize: number;
+        attrFilter: IDictionary<string>;
+        monitor: CesiumViewMonitor.Monitor;
+        viewer?: Cesium.Viewer;
+        cdn?: boolean;
+        tagIds?: (number | string)[];
+        historicAttrKey?: string;
+        historic?: boolean;
+        historicInterpolation?: boolean;
+        debugShowBounds?: boolean;
+        schemaId?: string;
+        scenario?: number | string;
+    }
+    class Cache {
+        private data;
+        GetOrCreateFilterGetter(params: IFilterGetterParams): EntityFilterGetter.Getter;
+    }
+    /**
+     * To avoid performing multiple expensive queries at the same time,
+     * we'll have the getters work through a queue of requests.
+     */
+    namespace Queue {
+        /**
+         * Called to run a provided function.
+         * When the function is complete, the next function in the queue will be called.
+         * This function will resolve when the provided function is complete.
+         * If the provided function crashes, the error bubbles up to the caller.
+         * @param name
+         * @param call
+         */
+        function Run(name: string, call: () => Promise<void> | void): Promise<any>;
+    }
+}

package/dist/types/rendering/render-managers/data-source/data-source-static-csv-manager.d.ts

@@ -0,0 +1,41 @@
+import { BruceApi, MenuItem } from "bruce-models";
+import * as Cesium from "cesium";
+import { RenderManager } from "../render-manager";
+import { VisualsRegister } from "../../visuals-register";
+/**
+ * Made for a POC experiment.
+ * Do not use without reviewing the purpose and settings of the Menu Item.
+ */
+export declare namespace DataSourceStaticCsvManager {
+    class Manager implements RenderManager.IManager {
+        private viewer;
+        private apiGetter;
+        private item;
+        private register;
+        private disposed;
+        get Disposed(): boolean;
+        private dataSource;
+        get DataSources(): Cesium.DataSource[];
+        private czmlDataInputs;
+        get CzmlDataInputs(): any[][];
+        private tickRemovals;
+        constructor(params: {
+            viewer: Cesium.Viewer;
+            register: VisualsRegister.Register;
+            apiGetter: BruceApi.IGetter;
+            item: MenuItem.Item.ICsv;
+        });
+        Init(): void;
+        /**
+         * Takes a set of CSV files and renders the collection as a single moving item (truck, car, etc).
+         * This will try to find which is the primary source of point data, and complimentary sources of attribute information.
+         * @param files
+         */
+        private renderMovingItem;
+        Dispose(): void;
+        ReRender(params: {
+            entityIds?: string[];
+            force?: boolean;
+        }): Promise<void>;
+    }
+}

package/dist/types/rendering/render-managers/data-source/data-source-static-kml-manager.d.ts

@@ -0,0 +1,25 @@
+import { BruceApi, MenuItem } from "bruce-models";
+import * as Cesium from "cesium";
+import { RenderManager } from "../render-manager";
+export declare namespace DataSourceStaticKmlManager {
+    class Manager implements RenderManager.IManager {
+        private viewer;
+        private apiGetter;
+        private item;
+        private disposed;
+        get Disposed(): boolean;
+        private dataSources;
+        get DataSources(): Cesium.DataSource[];
+        constructor(params: {
+            viewer: Cesium.Viewer;
+            apiGetter: BruceApi.IGetter;
+            item: MenuItem.Item.IKml;
+        });
+        Init(): void;
+        Dispose(): void;
+        ReRender(params: {
+            entityIds?: string[];
+            force?: boolean;
+        }): Promise<void>;
+    }
+}

package/dist/types/rendering/render-managers/entities/entities-datalab-render-manager.d.ts

@@ -0,0 +1,31 @@
+import { BruceApi, MenuItem } from "bruce-models";
+import * as Cesium from "cesium";
+import { VisualsRegister } from "../../visuals-register";
+import { RenderManager } from "../render-manager";
+import { CesiumViewMonitor } from "../../../viewer/cesium-view-monitor";
+export declare namespace DataLabRenderManager {
+    class Manager implements RenderManager.IManager {
+        private viewer;
+        private item;
+        private apiGetter;
+        private visualsManager;
+        private monitor;
+        private getter;
+        private disposed;
+        get Disposed(): boolean;
+        private renderPriority;
+        constructor(params: {
+            viewer: Cesium.Viewer;
+            item: MenuItem.Item.IDataLab;
+            apiGetter: BruceApi.IGetter;
+            monitor: CesiumViewMonitor.Monitor;
+            visualsRegister: VisualsRegister.Register;
+        });
+        Init(): void;
+        Dispose(): void;
+        private doDispose;
+        private onGetterUpdate;
+        private renderDataLabEntities;
+        ReRender(): Promise<void>;
+    }
+}