@giro3d/piero 25.10.0-beta.10

package/dist/src/providers/BanProvider.d.ts

@@ -0,0 +1,11 @@
+import { GeocodingResult } from './Geocoding';
+declare const _default: {
+    /**
+     * Searches for an address in the French BAN
+     *
+     * @param query - Search query
+     * @returns Results
+     */
+    geocode(query: string): Promise<GeocodingResult[]>;
+};
+export default _default;

package/dist/src/providers/Geocoding.d.ts

@@ -0,0 +1,7 @@
+export type GeocodingResult = {
+    label: string;
+    crs: string;
+    x: number;
+    y: number;
+    z: number;
+};

package/dist/src/providers/IgnProvider.d.ts

@@ -0,0 +1,11 @@
+import { default as Coordinates } from '@giro3d/giro3d/core/geographic/Coordinates';
+declare const _default: {
+    /**
+     * Fetches altitudes from IGN Alti service.
+     * Will fill the `altitude` component of each coordinates.
+     *
+     * @param coordinates - Coordinates to fetch altitudes for
+     */
+    alticode(coordinates: Coordinates[]): Promise<void>;
+};
+export default _default;

package/dist/src/services/AnalysisManager.d.ts

@@ -0,0 +1,10 @@
+import { default as Instance } from '@giro3d/giro3d/core/Instance';
+import { default as LayerManager } from './LayerManager';
+export default class AnalysisManager {
+    private readonly _instance;
+    private readonly _floodingPlaneManager;
+    private readonly _crossSectionManager;
+    private readonly _clippingBoxManager;
+    constructor(instance: Instance, layerManager: LayerManager);
+    dispose(): void;
+}

package/dist/src/services/AnnotationManager.d.ts

@@ -0,0 +1,48 @@
+import { default as CameraController } from './CameraController';
+import { default as Picker } from './Picker';
+import { PieroShapeUserData, default as Annotation } from '../types/Annotation';
+import { default as Instance } from '@giro3d/giro3d/core/Instance';
+import { default as Shape } from '@giro3d/giro3d/entities/Shape';
+export default class AnnotationManager {
+    private readonly _drawTool;
+    private readonly _shapes;
+    private readonly _picker;
+    private readonly _instance;
+    private readonly _store;
+    private readonly _notificationStore;
+    private readonly _boundOnKeyDown;
+    private readonly _boundExitEdition;
+    private readonly _boundOnStartDrag;
+    private readonly _boundOnEndDrag;
+    private readonly _boundUpdateLabels;
+    private _isEditing;
+    private _editedShape;
+    private _editedShapePreviousPoints;
+    constructor(instance: Instance, camera: CameraController, picker: Picker);
+    private udpateLabelVisibility;
+    private updateLabels;
+    dispose(): void;
+    private stopEdition;
+    private importShapeFromGeoJSON;
+    private onKeyDown;
+    private filterPickResults;
+    private pickDefault;
+    private pickMap;
+    private pickFeatures;
+    private pick;
+    private updateDrawing;
+    private addShape;
+    private getCreationOptions;
+    private draw;
+    private drawPoint;
+    private drawPolygon;
+    private drawLine;
+    pushNewAnnotation(title: string, shape: Shape<PieroShapeUserData>, properties?: object): Annotation;
+    private importAnnotation;
+    private importBlob;
+    private importAnnotationFile;
+    private importAnnotationFiles;
+    private editAnnotation;
+    private deleteAnnotation;
+    private computeMeasurements;
+}

package/dist/src/services/CameraController.d.ts

@@ -0,0 +1,99 @@
+import { default as CameraPosition } from '../types/CameraPosition';
+import { default as Instance } from '@giro3d/giro3d/core/Instance';
+import { default as Extent } from '@giro3d/giro3d/core/geographic/Extent';
+import { default as Entity3D } from '@giro3d/giro3d/entities/Entity3D';
+import { Object3D, Box3, EventDispatcher, Vector3 } from '../../../../node_modules/three';
+import { default as Picker } from './Picker';
+type CameraControllerEventMap = {
+    'interaction-start': {};
+    'interaction-end': {};
+};
+/**
+ * Wraps Camera-controls into Giro3D
+ */
+declare class CameraController extends EventDispatcher<CameraControllerEventMap> {
+    private readonly _instance;
+    private readonly _picker;
+    private readonly _orbitControls;
+    private readonly _pickObjectsAt;
+    private readonly _clock;
+    private readonly _store;
+    private readonly _giro3dStore;
+    private readonly _orbitHelper;
+    private readonly _positionOnMapHelper;
+    private _cameraControlsInspector;
+    private readonly _boundOnBeforeCameraUpdate;
+    private readonly _boundOnAfterCameraUpdate;
+    private _boundOrbitControlsOnContextMenu;
+    private _boundOrbitControlsOnMouseUp;
+    private _boundOrbitControlsOnWheel;
+    private _boundOrbitControlsOnKey;
+    private _boundPositionOnMapOnMouseMove;
+    private _boundPositionOnMapOnClick;
+    private _boundPositionOnMapOnContextMenu;
+    /**
+     * Creates new Camera-controls and bind them to Giro3D.
+     *
+     * @param instance - Giro3D instance
+     * @param picker - Picker
+     */
+    constructor(instance: Instance, picker: Picker);
+    dispose(): void;
+    private initializeInspector;
+    private initializeOrbitControls;
+    private disposeOrbitControls;
+    private orbitControlsOnContextMenu;
+    private orbitControlsOnMouseUp;
+    private orbitControlsOnWheel;
+    private orbitControlsOnKey;
+    private _enablePositionOnMap;
+    private _disablePositionOnMap;
+    private onPositionOnMapMouseMove;
+    private onPositionOnMapContextMenu;
+    private onPositionOnMapClick;
+    private setNavigationMode;
+    onBeforeCameraUpdate(): void;
+    onAfterCameraUpdate(): void;
+    /**
+     * Executes an interaction with animation.
+     *
+     * Required to call this instead of calling directly camera-controls because
+     * of how Giro3D mainloop works.
+     *
+     * @param callback - Interaction to execute
+     * @returns Resolves when interaction is done
+     */
+    executeInteraction<T = void>(callback: () => Promise<T>): Promise<T>;
+    /**
+     * Sets initial position of camera to view an extent.
+     *
+     * @param extent - Extent to look at
+     * @param altitude - Altitude of camera
+     */
+    setInitialPosition(extent: Extent, altitude?: number): void;
+    /**
+     * Sets the camera to look at a position.
+     *
+     * @param position - Position of the camera
+     * @param lookAt - Posiiton to look at
+     * @param enableTransition - Enables transition
+     * @returns Resolves when interaction is done
+     */
+    lookAt(position: Vector3, lookAt: Vector3, enableTransition?: boolean): Promise<void>;
+    get enabled(): boolean;
+    set enabled(v: boolean);
+    getCameraPosition(target?: CameraPosition): CameraPosition;
+    setCamera(pos: CameraPosition): void;
+    /**
+     * Looks to a bounding box or Object3D.
+     *
+     * @param obj - Bounding box or Object to look at
+     * @param enableTransition - Enables transition
+     * @param options - Camera-controls' fitToBox options
+     * @returns Resolves when interaction is done
+     */
+    goToBox(obj: Box3 | Object3D | Entity3D, enableTransition?: boolean, options?: object): Promise<void[]>;
+    lookTopDownAt(obj: Box3 | Object3D | Entity3D, enableTransition?: boolean): Promise<void>;
+    protected getBox(obj: Box3 | Object3D | Entity3D): Box3;
+}
+export default CameraController;

package/dist/src/services/DatasetManager.d.ts

@@ -0,0 +1,27 @@
+import { default as Instance } from '@giro3d/giro3d/core/Instance';
+import { default as LayerManager } from './LayerManager';
+export default class DatasetManager {
+    private readonly _instance;
+    private readonly _layerManager;
+    private readonly _entities;
+    private readonly _overlays;
+    private readonly _axisGrids;
+    private readonly _masks;
+    private readonly _store;
+    private readonly _notifications;
+    constructor(instance: Instance, layerManager: LayerManager);
+    dispose(): void;
+    private createGrid;
+    private deleteGrid;
+    private onToggleGrid;
+    private createMask;
+    private deleteMask;
+    private onToggleMask;
+    private onVisibilityChanged;
+    private importFromFile;
+    private updateDataset;
+    private deleteDataset;
+    private onDatasetPreloaded;
+    private onDatasetPreloadedAsLayer;
+    private preloadDataset;
+}

package/dist/src/services/Giro3DManager.d.ts

@@ -0,0 +1,42 @@
+import { default as AnalysisManager } from './AnalysisManager';
+import { default as AnnotationManager } from './AnnotationManager';
+import { default as CameraController } from './CameraController';
+import { default as DatasetManager } from './DatasetManager';
+import { default as Highlighter } from './Highlighter';
+import { default as LayerManager } from './LayerManager';
+import { default as MeasurementManager } from './MeasurementManager';
+import { default as Picker } from './Picker';
+import { default as Instance } from '@giro3d/giro3d/core/Instance';
+import { Object3D, AmbientLight, Box3, DirectionalLight, EventDispatcher } from '../../../../node_modules/three';
+type Giro3DManagerEventMap = {
+    update: {};
+};
+export default class Giro3DManager extends EventDispatcher<Giro3DManagerEventMap> {
+    private readonly _store;
+    readonly mainInstance: Instance;
+    readonly camera: CameraController;
+    readonly layerManager: LayerManager;
+    readonly datasetManager: DatasetManager;
+    readonly annotationManager: AnnotationManager;
+    readonly analysisManager: AnalysisManager;
+    readonly highlighter: Highlighter;
+    readonly picker: Picker;
+    readonly measurementManager: MeasurementManager;
+    readonly ambientLight: AmbientLight;
+    readonly dirLight: DirectionalLight;
+    private readonly _boundOnFrameEnd;
+    constructor(instance: Instance);
+    dispose(): void;
+    onFrameEnd(): void;
+    /**
+     * Gets the datasets & annotations as Object3D.
+     */
+    getObjects3d(): Object3D[];
+    /**
+     * Gets bounding box of all datasets & annotations.
+     *
+     * @returns Bounding box of all datasets.
+     */
+    getBoundingBox(): Box3;
+}
+export {};

package/dist/src/services/Highlighter.d.ts

@@ -0,0 +1,11 @@
+import { default as PickResult } from '@giro3d/giro3d/core/picking/PickResult';
+export type ClearHighlightFn = () => void;
+export type HighlightFn = (obj: PickResult) => ClearHighlightFn | null;
+export declare const customHighlighters: HighlightFn[];
+export default class Highlighter {
+    private _clearHighlight;
+    dispose(): void;
+    clear(): void;
+    private highlightShape;
+    highlightFromPick(pick: PickResult): void;
+}

package/dist/src/services/LayerManager.d.ts

@@ -0,0 +1,37 @@
+import { BaseLayer, BasemapLayer } from '../types/BaseLayer';
+import { Overlay } from '../types/Overlay';
+import { default as Instance } from '@giro3d/giro3d/core/Instance';
+import { EventDispatcher } from '../../../../node_modules/three';
+export declare const GRID_NAME = "grid";
+export declare const PLANE_NAME = "plane";
+export default class LayerManager extends EventDispatcher {
+    private readonly _instance;
+    private readonly _cameraStore;
+    private readonly _giro3dStore;
+    private readonly _layerStore;
+    private readonly _basemap;
+    private readonly _grid;
+    private readonly _plane;
+    private readonly _baseLayers;
+    private readonly _overlays;
+    private readonly _datasetLayers;
+    private readonly _boundOnAfterCameraUpdate;
+    constructor(instance: Instance);
+    dispose(): void;
+    private onAfterCameraUpdate;
+    notify(layer: BasemapLayer): void;
+    removeBasemapLayer(layer: BasemapLayer): void;
+    addDatasetLayer(layer: BasemapLayer): Promise<void>;
+    get extent(): import('@giro3d/giro3d/core/geographic/Extent').default;
+    setMapOpacity(opacity: number): void;
+    private loadBasemap;
+    private loadOverlay;
+    private getLayer;
+    private getOverlay;
+    onOverlayReordered(overlay: Overlay): void;
+    onLayerOpacityChanged(basemap: BaseLayer, newOpacity: number): Promise<void>;
+    onOverlayOpacityChanged(overlay: Overlay, newOpacity: number): Promise<void>;
+    onLayerVisibilityChanged(basemap: BaseLayer, newVisibility: boolean): Promise<void>;
+    onOverlayVisibilityChanged(overlay: Overlay, newVisibility: boolean): Promise<void>;
+    private updateLayerOrdering;
+}

package/dist/src/services/MeasureTool.d.ts

@@ -0,0 +1,13 @@
+import { default as Measure3D } from '../giro3d/Measure3D';
+import { default as Picker } from './Picker';
+import { default as Instance } from '@giro3d/giro3d/core/Instance';
+export default class MeasureTool {
+    private readonly _picker;
+    private readonly _raycaster;
+    private _hoverMeasurement;
+    constructor(picker: Picker);
+    dispose(): void;
+    measure(instance: Instance, event: MouseEvent): void;
+    clean(): void;
+    getLastMeasurement(): Measure3D | undefined;
+}

package/dist/src/services/MeasurementManager.d.ts

@@ -0,0 +1,31 @@
+import { default as CameraController } from './CameraController';
+import { default as Picker } from './Picker';
+import { default as Measure } from '../types/Measure';
+import { default as Instance } from '@giro3d/giro3d/core/Instance';
+export default class MeasurementManager {
+    private readonly _instance;
+    private readonly _measureTool;
+    private readonly _camera;
+    private readonly _store;
+    private readonly _notificationStore;
+    private _paused;
+    private readonly _boundOnEscape;
+    private readonly _boundPause;
+    private readonly _boundRestart;
+    private readonly _boundMeasure;
+    private readonly _boundSaveMeasure;
+    constructor(instance: Instance, camera: CameraController, picker: Picker);
+    dispose(): void;
+    private onEscape;
+    startMeasuring(): void;
+    stopMeasuring(): void;
+    private measure;
+    private saveMeasure;
+    private pushNewMeasure;
+    updateMeasure(measure: Measure): void;
+    private deleteMeasure;
+    private importMeasure;
+    private importBlob;
+    private importMeasureFile;
+    private importMeasureFiles;
+}

package/dist/src/services/MinimapController.d.ts

@@ -0,0 +1,19 @@
+import { default as Instance } from '@giro3d/giro3d/core/Instance';
+import { Vector3 } from '../../../../node_modules/three';
+export default class MinimapController {
+    private _mainInstance;
+    private readonly _minimapInstance;
+    private readonly _viewbox;
+    private readonly _basemap;
+    private _boundUpdateViewbox;
+    constructor(instance: Instance);
+    dispose(): void;
+    setMainInstance(instance: Instance | null): void;
+    getCorners(): {
+        ul: Vector3;
+        ur: Vector3;
+        ll: Vector3;
+        lr: Vector3;
+    } | undefined;
+    updateViewbox(): void;
+}

package/dist/src/services/Picker.d.ts

@@ -0,0 +1,53 @@
+import { Attribute, AttributesGroups, default as Feature } from '../types/Feature';
+import { default as Instance } from '@giro3d/giro3d/core/Instance';
+import { PointsPickResult } from '@giro3d/giro3d/core/picking/PickPointsAt';
+import { default as PickResult } from '@giro3d/giro3d/core/picking/PickResult';
+import { default as Entity } from '@giro3d/giro3d/entities/Entity';
+import { ShapePickResult } from '@giro3d/giro3d/entities/Shape';
+import { Feature as OLFeature } from 'ol';
+import { Vector2, Vector3, Object3D } from '../../../../node_modules/three';
+export type AttributeExtractorFn<T extends PickResult = PickResult> = (pickResult: T, attributesGroups: AttributesGroups) => void;
+export declare const customAttributeExtractors: AttributeExtractorFn[];
+export default class Picker {
+    private readonly _analysisStore;
+    filterPick(instance: Instance, result: PickResult): boolean;
+    getNameFromOLFeature(feature: OLFeature): string;
+    getAttributesFromOLFeature(feature: OLFeature, attributesGroups: AttributesGroups): void;
+    getAttributesFromPointCloud(pickResult: PointsPickResult, attributesGroups: AttributesGroups): void;
+    getAttributesFromUserData(userData: object, attributes: Attribute[]): void;
+    getAttributesFromObject3D(object: Object3D, attributes: Attribute[]): void;
+    getAttributesFromPickedObject3D(pickResult: PickResult, attributesGroups: AttributesGroups): void;
+    getAttributesFromEntity(entity: Entity, attributesGroups: AttributesGroups): void;
+    getDatasetAttributes(object: Object3D, datasetAttributes: Attribute[]): void;
+    /**
+     * Gets the closest dataset object from where the user clicked.
+     * Does **NOT** pick on the base map!
+     *
+     * @param e - Mouse event
+     * @param radius - Radius - the smaller, the faster and more precise (but
+     * may return nothing)
+     * @returns Result or null if notthing found
+     */
+    getObjectsAt(instance: Instance, e: MouseEvent | Vector2, radius?: number, filterOnObjects?: (obj: Object3D | Entity) => boolean): PickResult[] | null;
+    /**
+     * Gets the point on map or grid where the user clicked.
+     *
+     * @param e - Mouse event
+     * @param radius - Radius - the smaller, the faster and more precise (but
+     * may return nothing)
+     * @returns Result or null if nothing found
+     */
+    getMapAt(instance: Instance, e: MouseEvent, radius?: number): PickResult | null;
+    getFirstFeatureAt(instance: Instance, e: MouseEvent, radius?: number, filterOnObjects?: (obj: Object3D | Entity) => boolean): PickResult[] | null;
+    getGeometryAttributes(object: Object3D, attributes: Array<Attribute>): void;
+    getAttributesFromAnnotation(pickResult: ShapePickResult, attributesGroups: AttributesGroups): void;
+    getAttributesFromMeasure(pickResult: PickResult, attributesGroups: AttributesGroups): void;
+    getFeatureFromPickedObject(pickedObject: PickResult): Feature | null;
+    getMouseCoordinate(instance: Instance, mouse: Vector2): Vector3 | null;
+    hasFeature(instance: Instance, mouse: Vector2): boolean;
+    pick(instance: Instance, event: MouseEvent): {
+        point: Vector3;
+        feature: Feature | null;
+        pickResult: PickResult;
+    } | null;
+}

package/dist/src/services/analysis/ClippingBoxManager.d.ts

@@ -0,0 +1,41 @@
+import { default as Instance } from '@giro3d/giro3d/core/Instance';
+export default class ClippingBoxManager {
+    private readonly _instance;
+    private readonly _volumeHelpers;
+    private _clippingBox;
+    private _clippingBoxHelper;
+    private _clippingBoxMesh;
+    private _transformControls;
+    private _previousTransformControls;
+    private readonly _store;
+    private readonly _cameraStore;
+    private readonly _datasetStore;
+    constructor(instance: Instance);
+    dispose(): void;
+    /**
+     * Creates the whole clipping box and helpers if displayed
+     * @param center - Center of the clipping box
+     * @param size - Size of the clipping box
+     */
+    private createClippingBox;
+    private getPlanesFromBoxSides;
+    /**
+     * Disposes of the clipping box and all helpers
+     */
+    private disposeClippingBox;
+    /**
+     * Applies defined clipping planes to all entities.
+     * This is required after:
+     * - changing the clipping box
+     * - loading a new entity
+     */
+    private applyClippingPlanes;
+    /**
+     * Moves an existing clipping box, while keeping its size
+     */
+    private moveClippingBox;
+    /**
+     * Updates the clipping box; required when changing its size
+     */
+    private updateClippingBox;
+}

package/dist/src/services/analysis/CrossSectionManager.d.ts

@@ -0,0 +1,9 @@
+import { default as Instance } from '@giro3d/giro3d/core/Instance';
+export default class CrossSectionManager {
+    private readonly _instance;
+    private readonly _store;
+    private readonly _datasetStore;
+    constructor(instance: Instance);
+    dispose(): void;
+    private updateCrossSection;
+}

package/dist/src/services/analysis/FloodingPlaneManager.d.ts

@@ -0,0 +1,11 @@
+import { default as LayerManager } from '../LayerManager';
+import { default as Instance } from '@giro3d/giro3d/core/Instance';
+export default class FloodingPlaneManager {
+    private readonly _instance;
+    private readonly _layerManager;
+    private readonly _store;
+    private _plane;
+    constructor(instance: Instance, layerManager: LayerManager);
+    dispose(): void;
+    private updatePlane;
+}