bruce-cesium 5.7.9 → 5.8.0

package/dist/types/rendering/visuals-register.d.ts

@@ -0,0 +1,351 @@
+import { ApiGetters, BruceEvent, Cartes, Entity, EntityRelation, IDictionary, MenuItem, ProjectViewBookmark } from "bruce-models";
+import * as Cesium from "cesium";
+/**
+ * Manages a registry of all Bruce visuals being rendered by menu items.
+ */
+export declare namespace VisualsRegister {
+    type Visual = Cesium.Entity | Cesium.Primitive | Cesium.Cesium3DTileFeature;
+    interface IVisualRego {
+        canEdit: boolean;
+        entityId: string;
+        accountId?: string;
+        relation?: EntityRelation.IRelation;
+        entityTypeId?: string;
+        schema?: string;
+        name?: string;
+        sourceId?: number;
+        sourceEntityId?: string;
+        rootId?: string;
+        tilesetId?: string;
+        tilesetType?: string;
+        tagIds?: number[];
+        menuItemId: string;
+        menuItemType: MenuItem.EType;
+        visual: Visual;
+        priority: number;
+        best?: boolean;
+        stale?: boolean;
+        opacity?: number;
+        overrideShow?: boolean;
+        cdn?: boolean;
+        collection?: Cesium.EntityCollection;
+        outline?: Entity.IOutline[];
+    }
+    enum EVisualUpdateType {
+        Add = "ADD",
+        Remove = "REMOVE",
+        Update = "UPDATE",
+        DeselectAll = "DESELECT_ALL"
+    }
+    interface IVisualUpdate {
+        type: EVisualUpdateType;
+        entityId?: string;
+        rego?: IVisualRego;
+        hidden?: boolean;
+        isolated?: boolean;
+        selected?: boolean;
+        opacity?: number;
+    }
+    class Register {
+        private id;
+        get Id(): string;
+        private disposed;
+        get Disposed(): boolean;
+        private viewer;
+        get Viewer(): Cesium.Viewer;
+        private apiGetters;
+        get ApiGetters(): ApiGetters;
+        private rego;
+        private onUpdate;
+        get OnUpdate(): BruceEvent<IVisualUpdate>;
+        private states;
+        private cameraCullerDispose;
+        private updateQueue;
+        private updateQueueSettings;
+        private updateQueueInterval;
+        constructor(params: {
+            viewer: Cesium.Viewer;
+            apiGetters?: ApiGetters;
+        });
+        private queueUpdate;
+        private pingUpdateQueue;
+        /**
+         * Returns the applied visual state for a given Entity ID.
+         * This is a combination of a Menu Item specific state and a general state.
+         * @param params
+         */
+        GetState(params: {
+            entityId: string;
+            menuItemId?: string;
+        }): ProjectViewBookmark.IVisualState;
+        /**
+         * Sets the state for a given Entity.
+         * This can be used to perform multiple visual updates in one go.
+         * @param state
+         * @param update
+         */
+        SetState(state: ProjectViewBookmark.IVisualState, update?: boolean): boolean;
+        SetStates(states: IDictionary<ProjectViewBookmark.IVisualState> | ProjectViewBookmark.IVisualState[]): void;
+        /**
+         * Sets the provided settings for a given Entity's state.
+         * @param params
+         */
+        private setStateValues;
+        /**
+         * Returns all visual state settings.
+         * This is typically used for saving.
+         */
+        GetStates(params?: {
+            optimized?: boolean;
+        }): ProjectViewBookmark.IVisualState[];
+        /**
+         * Applies a set of new states to override the existing ones.
+         * This can be a costly operation as it will update all visuals.
+         * @param states
+         */
+        OverrideStates(states: ProjectViewBookmark.IVisualState[]): void;
+        /**
+         * Returns all states with the first detected Menu Item ID settings included.
+         * This is a utility function for returning settings for apps that don't support the newer state settings.
+         * @deprecated Use GetStates() or GetState().
+         * @returns
+         */
+        GetStatesLegacy(): IDictionary<ProjectViewBookmark.IVisualState>;
+        /**
+         * Utility to iterate over all states.
+         * @param callback
+         */
+        ForEachState(callback: (state: ProjectViewBookmark.IVisualState) => void): void;
+        RefreshMark(params: {
+            rego: IVisualRego;
+        }): void;
+        Dispose(): void;
+        ForceUpdate(params: {
+            entityIds: string[];
+            refreshColors?: boolean;
+            requestRender?: boolean;
+        }): void;
+        /**
+         * Marks given entityIds as either labelled or not labelled.
+         * When an entity is labelled a label will be drawn on the "best" visual for it.
+         * @param params
+         */
+        SetLabelled(params: {
+            labelled: boolean;
+            entityIds: string[];
+            menuItemId?: string;
+            requestRender?: boolean;
+        }): void;
+        /**
+         * Returns if given entity id is labelled.
+         * @param params
+         */
+        GetIsLabelled(params: {
+            entityId: string;
+            menuItemId?: string;
+        }): boolean;
+        /**
+         * Clears all labelled entities.
+         * @param params
+         */
+        ClearLabelled(params?: {
+            requestRender?: boolean;
+        }): void;
+        /**
+         * Returns all labelled entity ids.
+         * @deprecated Use GetStates() or GetState().
+         */
+        GetLabelled(): string[];
+        /**
+         * Updates the selection color.
+         * This will not update the selection color for already selected entities.
+         * @param color
+         */
+        SetSelectionColor(color: Cesium.Color): void;
+        /**
+         * Updates the highlight color.
+         * This will not update the highlight color for already highlighted entities.
+         * @param color
+         */
+        SetHighlightColor(color: Cesium.Color): void;
+        SetSelected(params: {
+            selected: boolean;
+            entityIds: string[];
+            menuItemId?: string;
+            refreshIfSelected?: boolean;
+            requestRender?: boolean;
+        }): void;
+        GetIsSelected(params: {
+            entityId: string;
+            menuItemId?: string;
+        }): boolean;
+        ClearSelected(params?: {
+            requestRender?: boolean;
+        }): void;
+        /**
+         * @deprecated Use GetStates() or GetState().
+         * @returns
+         */
+        GetSelected(): string[];
+        SetHighlighted(params: {
+            highlighted: boolean;
+            entityIds: string[];
+            menuItemId?: string;
+            refreshIfHighlighted?: boolean;
+            requestRender?: boolean;
+        }): void;
+        GetIsHighlighted(params: {
+            entityId: string;
+            menuItemId?: string;
+        }): boolean;
+        ClearHighlighted(params?: {
+            requestRender?: boolean;
+        }): void;
+        /**
+         * @deprecated Use GetStates() or GetState().
+         * @returns
+         */
+        GetHighlighted(): string[];
+        SetIsolated(params: {
+            entityIds: string[];
+            menuItemId?: string;
+            isolated: boolean;
+            requestRender?: boolean;
+        }): void;
+        GetIsIsolated(params: {
+            entityId: string;
+            menuItemId?: string;
+        }): boolean;
+        GetIsIsolatedAny(): boolean;
+        /**
+         * @deprecated Use GetStates() or GetState().
+         * @returns
+         */
+        GetIsolated(): string[];
+        ClearIsolated(params?: {
+            requestRender?: boolean;
+        }): void;
+        SetHidden(params: {
+            hidden: boolean;
+            entityIds: string[];
+            menuItemId?: string;
+            requestRender?: boolean;
+        }): void;
+        GetIsHidden(params: {
+            entityId: string;
+            menuItemId?: string;
+        }): boolean;
+        /**
+         * @deprecated Use GetStates() or GetState().
+         * @returns
+         */
+        GetHidden(): string[];
+        ClearHidden(params?: {
+            requestRender?: boolean;
+        }): void;
+        AddRego(params: {
+            rego: IVisualRego;
+            requestRender?: boolean;
+            removePrior?: boolean;
+        }): void;
+        /**
+         * Locates a visual corresponding to a given entity id.
+         * If no menu item id is provided, then it will pick the "best" one.
+         * @param params
+         * @returns
+         */
+        GetRego(params: {
+            entityId?: string;
+            menuItemId?: string;
+            relation?: EntityRelation.IRelation;
+        }): IVisualRego;
+        /**
+         * Returns regos matching given criteria.
+         * Either entityId or menuItemId must be provided.
+         * @param params
+         * @returns
+         */
+        GetRegos(params: {
+            entityId?: string;
+            menuItemId?: string;
+        }): IVisualRego[];
+        /**
+         * Removes regos matching given criteria.
+         * Either entityId or menuItemId must be provided.
+         * @param params
+         * @returns
+         */
+        RemoveRegos(params: {
+            entityId?: string;
+            menuItemId?: string;
+            relation?: EntityRelation.IRelation;
+            doUpdate?: boolean;
+            doRemove?: boolean;
+            retainTagIds?: (string | number)[];
+            requestRender?: boolean;
+        }): void;
+        /**
+         * Returns an array of drilled visuals associated with this register.
+         * The top array item is the first found.
+         * @param params
+         * @returns
+         */
+        GetRegosFromCursor(params: {
+            cursor: Cartes.ICartes2;
+            width?: number;
+            height?: number;
+            pickLimit?: number;
+        }): {
+            regos: IVisualRego[];
+        };
+        /**
+         * Returns all registered entity ids.
+         */
+        GetEntityIds(): string[];
+        /**
+         * Marks regos corresponding to given entity ids as stale.
+         * This will cause them to be updated on the next update cycle.
+         * Optionally include menu item ids to restrict the filter.
+         * @param params
+         */
+        MarkStale(params: {
+            entityIds: string[];
+            menuItemIds?: string[];
+        }): void;
+        private updateAllEntities;
+        /**
+         * Sets opacity for given set of entities.
+         * 100% opacity is treated as "use original".
+         * @param params
+         */
+        SetOpacity(params: {
+            opacity: number;
+            entityIds: string[];
+            menuItemId?: string;
+            requestRender?: boolean;
+        }): void;
+        /**
+         * Returns opacity for given entity/s.
+         * If multiple entities are supplied, then the average is returned.
+         * Unknown opacity is treated as 100% opacity.
+         * @param params
+         * @returns
+         */
+        GetOpacity(params: {
+            entityId?: string;
+            entityIds?: string[];
+            menuItemId?: string;
+            menuItemIds?: string;
+        }): number;
+        ClearOpacity(params?: {
+            requestRender?: boolean;
+        }): void;
+        /**
+         * Returns a dictionary containing entityId -> opacity values.
+         * Opacity 1 = 100%.
+         * @returns
+         * @deprecated Use GetStates() or GetState().
+         */
+        GetOpacityMap(): IDictionary<number>;
+    }
+}

package/dist/types/utils/cesium-entity-styler.d.ts

@@ -0,0 +1,103 @@
+import * as Cesium from "cesium";
+import { VisualsRegister } from "../rendering/visuals-register";
+import { IDictionary } from "bruce-models";
+/**
+ * Internal utility to help with managing Cesium Entity styling.
+ * Do not expose this to public as it will likely be killed and replaced with something that do animated changes.
+ */
+export declare namespace CesiumEntityStyler {
+    function UpdateColorSetting(key: "select" | "highlight", color: Cesium.Color): void;
+    function Refresh(params: {
+        viewer: Cesium.Viewer;
+        entity: VisualsRegister.Visual;
+        requestRender?: boolean;
+    }): void;
+    function BakeDefaultColor(params: {
+        viewer: Cesium.Viewer;
+        entity: VisualsRegister.Visual;
+        override?: boolean;
+        refresh?: boolean;
+        colors?: Map<string, Cesium.Color> | IDictionary<Cesium.Color>;
+    }): void;
+    /**
+     * Updates the default colour of a graphic.
+     * This will not change the graphic's state to use it if the entity is selected/highlighted.
+     * @param params
+     * @returns
+     */
+    function SetDefaultColor(params: {
+        viewer: Cesium.Viewer;
+        entity: VisualsRegister.Visual;
+        color: Cesium.Color;
+        override?: boolean;
+        requestRender?: boolean;
+    }): void;
+    /**
+     * Updates the opacity of the graphic.
+     * This will multiply against the current colour's opacity before applying.
+     * @param params
+     * @returns
+     */
+    function SetOpacity(params: {
+        viewer: Cesium.Viewer;
+        entity: VisualsRegister.Visual;
+        opacity: number;
+        requestRender?: boolean;
+    }): void;
+    /**
+     * Returns the opacity of a graphic.
+     * This will return the last applied opacity. If no opacity has been applied, it will return null.
+     * @param params
+     */
+    function GetOpacity(params: {
+        entity: VisualsRegister.Visual;
+    }): number | null;
+    /**
+     * Clears the opacity from a graphic and refreshes it.
+     * Eg: if it is selected it will change the color to the selected color with the original selection opacity.
+     * @param params
+     */
+    function ClearOpacity(params: {
+        viewer: Cesium.Viewer;
+        entity: VisualsRegister.Visual;
+        requestRender?: boolean;
+    }): void;
+    /**
+     * Selects a graphic and refreshes it.
+     * @param params
+     */
+    function Select(params: {
+        viewer: Cesium.Viewer;
+        entity: VisualsRegister.Visual;
+        requestRender?: boolean;
+    }): void;
+    /**
+     * Deselects a graphic and refreshes it.
+     * If the graphic is highlighted, it will change the color to the highlighted color.
+     * @param params
+     */
+    function Deselect(params: {
+        viewer: Cesium.Viewer;
+        entity: VisualsRegister.Visual;
+        requestRender?: boolean;
+    }): void;
+    /**
+     * Highlights a graphic and refreshes it.
+     * If the graphic is selected, it will not change the color.
+     * @param params
+     */
+    function Highlight(params: {
+        viewer: Cesium.Viewer;
+        entity: VisualsRegister.Visual;
+        requestRender?: boolean;
+    }): void;
+    /**
+     * Removes the highlight from a graphic and refreshes it.
+     * @param params
+     */
+    function Unhighlight(params: {
+        viewer: Cesium.Viewer;
+        entity: VisualsRegister.Visual;
+        requestRender?: boolean;
+    }): void;
+}

package/dist/types/utils/drawing-utils.d.ts

@@ -0,0 +1,59 @@
+import * as Cesium from "cesium";
+export declare namespace DrawingUtils {
+    /**
+     * Returns the point across a polyline at a given distance.
+     * If the distance exceeds the length of the line, the point will be placed at the end of the line.
+     * @param viewer deprecated, unused.
+     * @param positions
+     * @param distance
+     * @returns
+     */
+    function PointAcrossPolyline(params: {
+        viewer?: Cesium.Viewer;
+        posses: Cesium.Cartesian3[];
+        distance: number;
+    }): {
+        point: Cesium.Cartesian3;
+    };
+    /**
+     * Returns terrain height from current viewer's provider.
+     * On error or flat terrain, it will return 0.
+     * If an error occurred it will be attached to the result.
+     * @param pos3d
+     * @param viewer
+     * @returns
+     */
+    function GetTerrainHeight(params: {
+        pos3d: Cesium.Cartesian3;
+        viewer: Cesium.Viewer;
+    }): Promise<{
+        height: number;
+        error?: any;
+    }>;
+    function EnsurePosHeight(params: {
+        pos3d: Cesium.Cartesian3;
+        viewer: Cesium.Viewer;
+        desiredHeightRef: Cesium.HeightReference;
+        heightRef: Cesium.HeightReference;
+    }): Cesium.Cartesian3;
+    /**
+     * Returns an accurate 3d position from a given screen position.
+     * @param viewer
+     * @param cursor
+     * @returns
+     */
+    const GetAccuratePosition: (viewer: Cesium.Viewer, cursor: Cesium.Cartesian2, pickOnly?: boolean, ignoredPickOnly?: any[]) => any;
+    /**
+     * Smooths a given set of points.
+     * @param points
+     * @param multiplier
+     * @param closed: true if this is a closed shape. Eg: polygon.
+     * @returns
+     */
+    function SmoothPoints(points: Cesium.Cartesian3[], multiplier: number, closed: boolean): Cesium.Cartesian3[];
+    /**
+     * @param pos3d
+     * @param minimumHeight height relative to ground
+     */
+    function RaisePos3d(viewer: Cesium.Viewer, pos3d: Cesium.Cartesian3, minimumHeight?: number): Promise<Cesium.Cartesian3>;
+}

package/dist/types/utils/entity-utils.d.ts

@@ -0,0 +1,133 @@
+import { BruceApi, Entity as E, Entity, Tileset } from "bruce-models";
+import * as Cesium from "cesium";
+import { VisualsRegister } from "../rendering/visuals-register";
+import { MenuItemManager } from "../rendering/menu-item-manager";
+interface IGetLocationSample {
+    entityId?: string;
+    entity?: E.IEntity;
+    menuItemId?: string;
+    tileset?: Tileset.ITileset;
+    tilesetId?: string;
+    heightRef?: Cesium.HeightReference;
+    returnHeightRef?: Cesium.HeightReference;
+    disallowRendered?: boolean;
+}
+interface IGetLocation {
+    api?: BruceApi.Api;
+    viewer: Cesium.Viewer;
+    samples: IGetLocationSample[] | IGetLocationSample;
+    visualRegister?: VisualsRegister.Register;
+    minimumAlt?: number;
+    paddingAlt?: number;
+}
+export declare namespace EntityUtils {
+    /**
+     * Returns the location for given entity or entities.
+     * If available it will also compute a rectangle.
+     * It is recommended to fly-to a rectangle if available as it will ensure the full geometry is in view.
+     * @param params
+     */
+    function GetLocation(params: IGetLocation): Promise<{
+        pos3d: Cesium.Cartesian3;
+        rectangle?: Cesium.Rectangle;
+        sphere?: Cesium.BoundingSphere;
+    }>;
+    /**
+     * Returns an entity's position.
+     * This will attempt to calculate it from multiple sources of data.
+     * @param params
+     * @deprecated use GetLocation instead.
+     * @returns
+     */
+    function GetPos(params: {
+        viewer: Cesium.Viewer;
+        entity: E.IEntity;
+        visualRegister?: VisualsRegister.Register;
+        returnHeightRef?: Cesium.HeightReference;
+        recordHeightRef?: Cesium.HeightReference;
+        allowRendered?: boolean;
+    }): Cesium.Cartesian3;
+    /**
+     * Returns the position of the entity.
+     * This is an async variant that checks for related assemblies.
+     * @param params
+     * @deprecated use GetLocation instead.
+     * @returns
+     */
+    function GetPosAsync(params: {
+        api?: BruceApi.Api;
+        viewer: Cesium.Viewer;
+        entityId?: string;
+        entity?: Entity.IEntity;
+        tileset?: Tileset.ITileset;
+        tilesetId?: string;
+        visualRegister?: VisualsRegister.Register;
+        returnHeightRef?: Cesium.HeightReference;
+        recordHeightRef?: Cesium.HeightReference;
+    }): Promise<Cesium.Cartesian3>;
+    /**
+     * Returns entity and any associated parent/sibling entities as a flat array.
+     * @param entity
+     */
+    function GatherEntity(params: {
+        entity: VisualsRegister.Visual;
+        editable?: boolean;
+        selectable?: boolean;
+    }): VisualsRegister.Visual[];
+    /**
+     * Looks at given entities with least amount of movement.
+     * @param viewer
+     * @param entities
+     */
+    function LookAtEntities(params: {
+        viewer: Cesium.Viewer;
+        entities: VisualsRegister.Visual[];
+    }): Promise<void>;
+    /**
+     * Sets opacity of given entity.
+     * Opacity will be multiplied by original opacity.
+     * Setting opacity puts original opacity into a temporary storage which can be reverted into.
+     * @param viewer
+     * @param entity
+     * @param opacity
+     */
+    function SetOpacity(params: {
+        viewer: Cesium.Viewer;
+        entity: VisualsRegister.Visual;
+        opacity: number;
+        requestRender?: boolean;
+    }): void;
+    /**
+     * Reverts opacity of given entity to original opacity.
+     * If opacity was not updated using "SetOpacity" then nothing will happen.
+     * @param viewer
+     * @param entity
+     */
+    function RevertOpacity(params: {
+        viewer: Cesium.Viewer;
+        entity: VisualsRegister.Visual;
+        requestRender?: boolean;
+    }): void;
+    /**
+     * Gets opacity of the entity.
+     * This does not count opacity that it was rendered with.
+     * This is the opacity that was set post-rendering.
+     * @param viewer
+     * @param entity
+     */
+    function GetOpacity(params: {
+        entity: VisualsRegister.Visual;
+    }): number;
+    function FlyTo(params: {
+        viewer: Cesium.Viewer;
+        entityIds: string[];
+        manager?: MenuItemManager.Manager;
+        tileset?: Cesium.Cesium3DTileset;
+        durationSec?: number;
+        isCancelled?: () => boolean;
+        onCompleted?: () => void;
+        minimumAlt?: number;
+        debug?: boolean;
+    }): Promise<boolean>;
+}
+export {};

package/dist/types/utils/measure-utils.d.ts

@@ -0,0 +1,20 @@
+import * as Cesium from "cesium";
+export declare namespace MeasureUtils {
+    /**
+     * Returns the total distance in meters between an array of points.
+     * This distance is NOT following the terrain.
+     * @param posses
+     * @returns
+     */
+    function MeasurePolyline(params: {
+        posses: Cesium.Cartesian3[];
+    }): {
+        totalLength: number;
+    };
+    function MeasurePolygon(params: {
+        posses: Cesium.Cartesian3[];
+    }): {
+        area: number;
+        perimeter: number;
+    };
+}

package/dist/types/utils/simplify-geometry.d.ts

@@ -0,0 +1,19 @@
+import { Geometry } from "bruce-models";
+/**
+ * Util for simplifying geometry on the fly.
+ */
+export declare namespace SimplifyGeometry {
+    /**
+     * Returns the total number of points in the geometry.
+     * @param geometry
+     * @param limit number to count up to before returning.
+     * @returns
+     */
+    function CountPoints(geometry: Geometry.IGeometry, limit?: number): number;
+    /**
+     * Simplifies input geometry.
+     * This will turn it into GeoJSON, run it through turf, then back to Bruce geometry.
+     * @param geometry
+     */
+    function Simplify(entityId: string, geometry: Geometry.IGeometry, tolerance: number): Geometry.IGeometry;
+}