itowns 2.45.1 → 2.45.2-next.1

package/lib/Core/EntwinePointTileNode.js

@@ -1,10 +1,6 @@
-import * as THREE from 'three';
 import Fetcher from "../Provider/Fetcher.js";
 import PointCloudNode from "./PointCloudNode.js";
-const size = new THREE.Vector3();
-const position = new THREE.Vector3();
-const translation = new THREE.Vector3();
-function buildId(depth, x, y, z) {
+function buildVoxelKey(depth, x, y, z) {
   return `${depth}-${x}-${y}-${z}`;
 }
 
@@ -20,13 +16,13 @@ function buildId(depth, x, y, z) {
  * @property {number} x - The x coordinate of the node in the tree - see the
  * [Entwine
  * documentation](https://entwine.io/entwine-point-tile.html#ept-data)
- * @property {number} y - The x coordinate of the node in the tree - see the
+ * @property {number} y - The y coordinate of the node in the tree - see the
  * [Entwine
  * documentation](https://entwine.io/entwine-point-tile.html#ept-data)
- * @property {number} z - The x coordinate of the node in the tree - see the
+ * @property {number} z - The z coordinate of the node in the tree - see the
  * [Entwine
  * documentation](https://entwine.io/entwine-point-tile.html#ept-data)
- * @property {string} id - The id of the node, constituted of the four
+ * @property {string} voxelKey - The id of the node, constituted of the four
  * components: `depth-x-y-z`.
  */
 class EntwinePointTileNode extends PointCloudNode {
@@ -41,10 +37,10 @@ class EntwinePointTileNode extends PointCloudNode {
    * @param {number} x - The x coordinate of the node in the tree - see the
    * [Entwine
    * documentation](https://entwine.io/entwine-point-tile.html#ept-data)
-   * @param {number} y - The x coordinate of the node in the tree - see the
+   * @param {number} y - The y coordinate of the node in the tree - see the
    * [Entwine
    * documentation](https://entwine.io/entwine-point-tile.html#ept-data)
-   * @param {number} z - The x coordinate of the node in the tree - see the
+   * @param {number} z - The z coordinate of the node in the tree - see the
    * [Entwine
    * documentation](https://entwine.io/entwine-point-tile.html#ept-data)
    * @param {EntwinePointTileLayer} layer - The layer the node is attached to.
@@ -60,40 +56,19 @@ class EntwinePointTileNode extends PointCloudNode {
     this.x = x;
     this.y = y;
     this.z = z;
-    this.id = buildId(depth, x, y, z);
-    this.url = `${this.layer.source.url}/ept-data/${this.id}.${this.layer.source.extension}`;
-  }
-  createChildAABB(node) {
-    // factor to apply, based on the depth difference (can be > 1)
-    const f = 2 ** (node.depth - this.depth);
-
-    // size of the child node bbox (Vector3), based on the size of the
-    // parent node, and divided by the factor
-    this.bbox.getSize(size).divideScalar(f);
-
-    // initialize the child node bbox at the location of the parent node bbox
-    node.bbox.min.copy(this.bbox.min);
-
-    // position of the parent node, if it was at the same depth than the
-    // child, found by multiplying the tree position by the factor
-    position.copy(this).multiplyScalar(f);
-
-    // difference in position between the two nodes, at child depth, and
-    // scale it using the size
-    translation.subVectors(node, position).multiply(size);
-
-    // apply the translation to the child node bbox
-    node.bbox.min.add(translation);
-
-    // use the size computed above to set the max
-    node.bbox.max.copy(node.bbox.min).add(size);
+    this.voxelKey = buildVoxelKey(depth, x, y, z);
+    this.url = `${this.layer.source.url}/ept-data/${this.voxelKey}.${this.layer.source.extension}`;
   }
   get octreeIsLoaded() {
     return this.numPoints >= 0;
   }
+  get id() {
+    return `${this.depth}${this.x}${this.y}${this.z}`;
+  }
   loadOctree() {
-    return Fetcher.json(`${this.layer.source.url}/ept-hierarchy/${this.id}.json`, this.layer.source.networkOptions).then(hierarchy => {
-      this.numPoints = hierarchy[this.id];
+    const hierarchyUrl = `${this.layer.source.url}/ept-hierarchy/${this.voxelKey}.json`;
+    return Fetcher.json(hierarchyUrl, this.layer.source.networkOptions).then(hierarchy => {
+      this.numPoints = hierarchy[this.voxelKey];
       const stack = [];
       stack.push(this);
       while (stack.length) {
@@ -114,8 +89,8 @@ class EntwinePointTileNode extends PointCloudNode {
     });
   }
   findAndCreateChild(depth, x, y, z, hierarchy, stack) {
-    const id = buildId(depth, x, y, z);
-    const numPoints = hierarchy[id];
+    const voxelKey = buildVoxelKey(depth, x, y, z);
+    const numPoints = hierarchy[voxelKey];
     if (typeof numPoints == 'number') {
       const child = new EntwinePointTileNode(depth, x, y, z, this.layer, numPoints);
       this.add(child);

package/lib/Core/Feature.d.ts

@@ -0,0 +1,323 @@
+export namespace FEATURE_TYPES {
+    let POINT: number;
+    let LINE: number;
+    let POLYGON: number;
+}
+/**
+ * @typedef {Object} FeatureBuildingOptions
+ * @property {string} crs - The CRS to convert the input coordinates to.
+ * @property {string} [structure='2d'] - data structure type : 2d or 3d.
+ * If the structure is 3d, the feature have 3 dimensions by vertices positions and
+ * a normal for each vertices.
+ * @property {Extent|boolean} [filteringExtent=undefined] - Optional filter to reject
+ * features outside of extent. Extent filtering is file extent if filteringExtent is true.
+ * @property {boolean} [buildExtent] - If true the geometry will
+ * have an extent property containing the area covered by the geometry.
+ * Default value is false if `structure` parameter is set to '3d', and true otherwise.
+ * True if the layer does not inherit from {@link GeometryLayer}.
+ * @property {string} forcedExtentCrs - force feature extent crs if buildExtent is true.
+ * @property {function} [filter] - Filter function to remove features
+ * @property {boolean} [mergeFeatures=true] - If true all geometries are merged by type and multi-type.
+ * @property {Style} style - The style to inherit when creating
+ * style for all new features.
+ *
+ */
+/**
+ * @property {Extent} extent - The 2D extent containing all the points
+ * composing the geometry.
+ * @property {Object[]} indices - Contains the indices that define the geometry.
+ * Objects stored in this array have two properties, an `offset` and a `count`.
+ * The offset is related to the overall number of vertices in the Feature.
+ *
+ * @property {Object} properties - Properties of the geometry. It can be
+ * anything specified in the GeoJSON under the `properties` property.
+ */
+export class FeatureGeometry {
+    /**
+     * @param {Feature} feature geometry
+     */
+    constructor(feature: Feature);
+    indices: any[];
+    properties: {};
+    size: number;
+    extent: Extent | undefined;
+    /**
+     * Add a new marker to indicate the starting of sub geometry and extends the vertices buffer.
+     * Then you have to push new the coordinates of sub geometry.
+     * The sub geometry stored in indices, see constructor for more information.
+     * @param {number} count - count of vertices
+     * @param {Feature} feature - the feature containing the geometry
+     */
+    startSubGeometry(count: number, feature: Feature): void;
+    /**
+     * After you have pushed new the coordinates of sub geometry without
+     * `startSubGeometry`, this function close sub geometry. The sub geometry
+     * stored in indices, see constructor for more information.
+     * @param {number} count count of vertices
+     * @param {Feature} feature - the feature containing the geometry
+     */
+    closeSubGeometry(count: number, feature: Feature): void;
+    getLastSubGeometry(): any;
+    /**
+     * Push new coordinates in vertices buffer.
+     * @param {Feature} feature - the feature containing the geometry
+     * @param {Coordinates} coordIn The coordinates to push.
+     */
+    pushCoordinates(feature: Feature, coordIn: Coordinates): void;
+    /**
+     * Push new values coordinates in vertices buffer without any transformation.
+     * No geographical conversion is made or the normal doesn't stored.
+     *
+     * @param {Feature} feature - the feature containing the geometry
+     * @param {Object} coordIn An object containing the coordinates values to push.
+     * @param {number} coordIn.x the x coordinate (in a local system).
+     * @param {number} coordIn.y the y coordinate (in a local system).
+     * @param {THREE.Vector3} [coordIn.normal] the normal on coordinates (only for `EPSG:4978` projection).
+     * @param {Coordinates} [coordProj] An optional argument containing the geodesic coordinates in EPSG:4326
+     * It allows the user to get access to the feature coordinates to set style.base_altitude.
+    */
+    pushCoordinatesValues(feature: Feature, coordIn: {
+        x: number;
+        y: number;
+        normal?: THREE.Vector3 | undefined;
+    }, coordProj?: Coordinates, ...args: any[]): void;
+    /**
+     * update geometry extent with the last sub geometry extent.
+     */
+    updateExtent(): void;
+    #private;
+}
+export default Feature;
+/**
+ * An object regrouping a list of [features]{@link Feature} and the extent of this collection.
+ * **Warning**, the data (`extent` or `Coordinates`) can be stored in a local system.
+ * The local system center is the `center` property.
+ * To use `Feature` vertices or `FeatureCollection/Feature` extent in FeatureCollection.crs projection,
+ * it's necessary to transform `Coordinates` or `Extent` by `FeatureCollection.matrixWorld`.
+ *
+ * ```js
+ * // To have featureCollection extent in featureCollection.crs projection:
+ * featureCollection.extent.applyMatrix4(featureCollection.matrixWorld);
+ *
+ * // To have feature vertex in featureCollection.crs projection:
+ * const vertices = featureCollection.features[0].vertices;
+ * coord.crs = featureCollection.crs;
+ * coord.setFromArray(vertices)
+ * coord.applyMatrix4(featureCollection.matrixWorld);
+ *```
+ *
+ * @extends THREE.Object3D
+ *
+ * @property {Feature[]} features - The array of features composing the
+ * collection.
+ * @property {Extent?} extent - The 2D extent containing all the features
+ * composing the collection. The extent projection is the same local projection `FeatureCollection`.
+ * To transform `FeatureCollection.extent` to `FeatureCollection.crs` projection, the transformation matrix must be applied.
+ *
+ * **WARNING** if crs is `EPSG:4978` because the 3d geocentric system doesn't work with 2D `Extent`,
+ * The FeatureCollection.extent projection is the original projection.
+ * In this case, there isn't need to transform the extent.
+ *
+ * @property {string} crs - Geographic or Geocentric coordinates system.
+ * @property {boolean} isFeatureCollection - Used to check whether this is FeatureCollection.
+ * @property {number} size - The size structure, it's 3 for 3d and 2 for 2d.
+ * @property {Style} style - The collection style used to display the feature collection.
+ * @property {boolean} isInverted - This option is to be set to the
+ * correct value, true or false (default being false), if the computation of
+ * the coordinates needs to be inverted to same scheme as OSM, Google Maps
+ * or other system. See [this link](
+ * https://alastaira.wordpress.com/2011/07/06/converting-tms-tile-coordinates-to-googlebingosm-tile-coordinates)
+ * for more informations.
+ * @property {THREE.Matrix4} matrixWorldInverse - The matrix world inverse.
+ * @property {Coordinates} center - The local center coordinates in `EPSG:4326`.
+ * The local system is centred in this center.
+ *
+ */
+export class FeatureCollection extends THREE.Object3D<THREE.Object3DEventMap> {
+    /**
+     * @param      {FeatureBuildingOptions|Layer}  options  The building options .
+     */
+    constructor(options: FeatureBuildingOptions | Layer);
+    isFeatureCollection: boolean;
+    crs: any;
+    features: any[];
+    mergeFeatures: any;
+    size: number;
+    filterExtent: any;
+    style: any;
+    isInverted: boolean;
+    matrixWorldInverse: THREE.Matrix4;
+    center: Coordinates;
+    extent: Extent | undefined;
+    normalMatrixInverse: THREE.Matrix3;
+    /**
+     * Apply the matrix World inverse on the coordinates.
+     * This method is used when the coordinates is pushed
+     * to transform it in local system.
+     *
+     * @param   {Coordinates}  coordinates  The coordinates
+     * @returns {Coordinates} The coordinates in local system
+     */
+    transformToLocalSystem(coordinates: Coordinates): Coordinates;
+    /**
+     * Update FeatureCollection extent with `extent` or all features extent if
+     * `extent` is `undefined`.
+     * @param {Extent} extent
+     */
+    updateExtent(extent: Extent): void;
+    /**
+     * Updates the global transform of the object and its descendants.
+     *
+     * @param {boolean}  force   The force
+     */
+    updateMatrixWorld(force: boolean): void;
+    /**
+     * Remove features that don't have {@link FeatureGeometry}.
+     */
+    removeEmptyFeature(): void;
+    /**
+     * Push the `feature` in FeatureCollection.
+     * @param {Feature} feature
+     */
+    pushFeature(feature: Feature): void;
+    requestFeature(type: any, callback: any): any;
+    /**
+     * Returns the Feature by type if `mergeFeatures` is `true` or returns the
+     * new instance of typed Feature.
+     *
+     * @param {string} type the type requested
+     * @returns {Feature}
+     */
+    requestFeatureByType(type: string): Feature;
+    /**
+     * Returns the Feature by type if `mergeFeatures` is `true` or returns the
+     * new instance of typed Feature.
+     *
+     * @param {string} id the id requested
+     * @param {string} type the type requested
+     * @returns {Feature}
+     */
+    requestFeatureById(id: string, type: string): Feature;
+    /**
+     * Add a new feature with references to all properties.
+     * It allows to have features with different styles
+     * without having to duplicate the geometry.
+     * @param      {Feature}   feature  The feature to reference.
+     * @return     {Feature}  The new referenced feature
+     */
+    newFeatureByReference(feature: Feature): Feature;
+    #private;
+}
+export type FeatureBuildingOptions = {
+    /**
+     * - The CRS to convert the input coordinates to.
+     */
+    crs: string;
+    /**
+     * - data structure type : 2d or 3d.
+     * If the structure is 3d, the feature have 3 dimensions by vertices positions and
+     * a normal for each vertices.
+     */
+    structure?: string | undefined;
+    /**
+     * - Optional filter to reject
+     * features outside of extent. Extent filtering is file extent if filteringExtent is true.
+     */
+    filteringExtent?: boolean | Extent | undefined;
+    /**
+     * - If true the geometry will
+     * have an extent property containing the area covered by the geometry.
+     * Default value is false if `structure` parameter is set to '3d', and true otherwise.
+     * True if the layer does not inherit from {@link GeometryLayer}.
+     */
+    buildExtent?: boolean | undefined;
+    /**
+     * - force feature extent crs if buildExtent is true.
+     */
+    forcedExtentCrs: string;
+    /**
+     * - Filter function to remove features
+     */
+    filter?: Function | undefined;
+    /**
+     * - If true all geometries are merged by type and multi-type.
+     */
+    mergeFeatures?: boolean | undefined;
+    /**
+     * - The style to inherit when creating
+     * style for all new features.
+     */
+    style: Style;
+};
+import { Extent } from '@itowns/geographic';
+/**
+ *
+ * This class improves and simplifies the construction and conversion of geographic data structures.
+ * It's an intermediary structure between geomatic formats and THREE objects.
+ *
+ * **Warning**, the data (`extent` or `Coordinates`) can be stored in a local system.
+ * To use vertices or extent in `Feature.crs` projection,
+ * it's necessary to transform `Coordinates` or `Extent` by `FeatureCollection.matrixWorld`.
+ *
+ * ```js
+ * // To have feature extent in featureCollection.crs projection:
+ * feature.extent.applyMatrix4(featureCollection.matrixWorld);
+ *
+ * // To have feature vertex in feature.crs projection:
+ * coord.crs = feature.crs;
+ * coord.setFromArray(feature.vertices)
+ * coord.applyMatrix4(featureCollection.matrixWorld);
+ *```
+ *
+ * @property {string} type - Geometry type, can be `point`, `line`, or
+ * `polygon`.
+ * @property {number[]} vertices - All the vertices of the Feature.
+ * @property {number[]} normals - All the normals of the Feature.
+ * @property {number} size - the number of values of the array that should be associated with a coordinates.
+ * The size is 3 with altitude and 2 without altitude.
+ * @property {boolean} hasRawElevationData - indicates if the geographic coordinates, from original source, has an elevation,
+ * the coordinates has a third coordinate.
+ * @property {string} crs - Geographic or Geocentric coordinates system.
+ * @property {FeatureGeometry[]} geometries - An array containing all {@link
+ * FeatureGeometry}.
+ * @property {Extent?} extent - The extent containing all the geometries
+ * composing the feature.
+ */
+declare class Feature {
+    /**
+     *
+     * @param {string} type type of Feature. It can be 'point', 'line' or 'polygon'.
+     * @param {FeatureCollection} collection Parent feature collection.
+     */
+    constructor(type: string, collection: FeatureCollection);
+    type: string;
+    geometries: any[];
+    vertices: any[];
+    crs: any;
+    size: number;
+    normals: never[] | undefined;
+    hasRawElevationData: boolean;
+    transformToLocalSystem: (coordinates: Coordinates) => Coordinates;
+    extent: Extent | undefined;
+    useCrsOut: boolean | undefined;
+    _pos: number;
+    _pushValues: typeof push3DValues;
+    style: (properties: Object, featCtx: FeatureContext) => StyleOptions;
+    /**
+     * Instance a new {@link FeatureGeometry}  and push in {@link Feature}.
+     * @returns {FeatureGeometry} the instancied geometry.
+     */
+    bindNewGeometry(): FeatureGeometry;
+    /**
+     * Update {@link Extent} feature with {@link Extent} geometry
+     * @param {FeatureGeometry} geometry used to update Feature {@link Extent}
+     */
+    updateExtent(geometry: FeatureGeometry): void;
+    /**
+     * @returns {number} the count of geometry.
+     */
+    get geometryCount(): number;
+}
+import { Coordinates } from '@itowns/geographic';
+import * as THREE from 'three';
+declare function push3DValues(value0: any, value1: any, value2?: number): void;

package/lib/Core/Geographic/GeoidGrid.d.ts

@@ -0,0 +1,86 @@
+export default GeoidGrid;
+/**
+ * An instance of `GeoidGrid` allows accessing some geoid height grid data from geographic instances (like some
+ * {@link Coordinates}). The geoid height grid data must contain geoid height values for a set of geographic points
+ * regularly dispatched on a planar surface.
+ *
+ * @property    {Extent}        extent      The geographic extent of the geoid height grid data.
+ * @property    {THREE.Vector2} step        The distance between two consecutive points of the geoid height grid. The
+ * `x` value stands for the distance along the West-East direction, and the
+ * `y` value stands for the distance along the South-North direction.
+ * @property    {THREE.Vector2} dimensions  The planar dimensions of the geoid height grid data extent.
+ * @property    {THREE.Vector2} dataSize    The number of values in the gridded data along the West-East direction (`x`
+                                            * axis) and the South-North direction (`y` axis).
+ *
+ * @example
+ * // Create a set of gridded data.
+ * const data = [
+ *     [1, 2, 3],
+ *     [2, 3, 4],
+ *     [3, 4, 5],
+ * ];
+ * // This set of data presents the following spatial distribution of geoid heights values :
+ * //
+ * //    Latitudes  ^
+ * //               |
+ * //         41.0  |   3  4  5
+ * //         40.5  |   2  3  4
+ * //         40.0  |   1  2  3
+ * //               |------------->
+ * //                   1  2  3     Longitudes
+ *
+ * // Create a GeoidGrid allowing to access the gridded data.
+ * const geoidGrid = new GeoidGrid(
+ *     new Extent('EPSG:4326', 1, 3, 40, 41),
+ *     new THREE.Vector2(1, 0.5),
+ *     (verticalIndex, horizontalIndex) => data[verticalIndex][horizontalIndex],
+ * );
+ *
+ * // Access a value of geoid height at some geographic coordinates.
+ * // The value is interpolated from the gridded data.
+ * const value = geoidGrid.getHeightAtCoordinates(
+ *     new Coordinates('EPSG:4326', 1.5, 40.25)
+ * );
+ * // This should return 2.0, which is the result from the bi-linear
+ * // interpolation at the center of the `[[1, 2], [2, 3]]` subsection
+ * // of the grid data.
+ */
+declare class GeoidGrid {
+    /**
+     * @param   {Extent}        extent      The geographic extent of the geoid height grid data.
+     * @param   {THREE.Vector2} step        The distance between two consecutive points of the geoid height grid. The
+     * `x` value stands for the distance along the West-East direction, and the
+     * `y` value stands for the distance along the South-North direction.
+     * @param   {function}      getData     A method that allows reading a value in the geoid height grid from its
+     * vertical and horizontal indexes. The lower an index, the lower the
+     * coordinate on the corresponding axis - 0 being the index of the minimal
+     * coordinate of the gridded data on a given axis. In other words :
+     * - `getData(0, 0)` must return the geoid height value at the SOUTH-WEST
+     *   corner of your data extent.
+     * - `getData(0, j)` must return a geoid height on the southern limit of your
+     *   data extent.
+     * - `getData(i, 0)` must return a geoid height on the western limit of your
+     *   data extent.
+     * - if your gridded data has dimensions (rowNumber, colNumber),
+     *   `getData(rowNumber - 1, colNumber - 1)` must return the geoid height at
+     *   the NORTH-EAST corner of your data extent.
+     */
+    constructor(extent: Extent, step: THREE.Vector2, getData: Function);
+    extent: Extent;
+    step: THREE.Vector2;
+    dimensions: any;
+    dataSize: THREE.Vector2;
+    getData: Function;
+    /**
+     * Get the value of the geoid height at given geographic {@link Coordinates}. The geoid height value is
+     * bi-linearly interpolated from the gridded data accessed by the `GeoidGrid` instance.
+     *
+     * @param   {Coordinates}   coordinates     Geographic coordinates to get the geoid height value at.
+     *
+     * @returns {number}    The geoid height value at the given {@link Coordinates}, bi-interpolated from the gridded
+                            * data accessed by the `GeoidGrid` instance.
+     */
+    getHeightAtCoordinates(coordinates: Coordinates): number;
+}
+import * as THREE from 'three';
+import { Coordinates } from '@itowns/geographic';

package/lib/Core/Label.d.ts

@@ -0,0 +1,86 @@
+export default Label;
+/**
+ * An object that handles the display of a text and/or an icon, linked to a 3D
+ * position. The content of the `Label` is managed through a DOM object, in a
+ * `<div>` handled by the `Label2DRenderer`.
+ *
+ * @property {boolean} isLabel - Used to checkout whether this object is a
+ * Label. Default is true. You should not change this, as it is used internally
+ * for optimisation.
+ * @property {Element} content - The DOM object that contains the content of the
+ * label. The style and the position are applied on this object. All labels
+ * contain the `itowns-label` class, as well as a specific class related to the
+ * layer linked to it: `itowns-label-[layer-id]` (replace `[layer-id]` by the
+ * correct string).
+ * @property {THREE.Vector3} position - The position in the 3D world of the
+ * label.
+ * @property {number} padding - sets the padding area on all four sides of an element at once.
+ * @property {Coordinates} coordinates - The coordinates of the label.
+ * @property {number} order - Order of the label that will be read from the
+ * style. It helps sorting and prioritizing a Label during render.
+ */
+declare class Label extends THREE.Object3D<THREE.Object3DEventMap> {
+    /**
+     * @param {Element|string} content - The content; can be a
+     * string, with or without HTML tags in it, or it can be an Element.
+     * @param {Coordinates} coordinates - The world coordinates, where to place
+     * the Label.
+     * @param {Style} style - The style to apply to the content. Once the style
+     * is applied, it cannot be changed directly. However, if it really needed,
+     * it can be accessed through `label.content.style`, but it is highly
+     * discouraged to do so.
+     */
+    constructor(content: (Element | string) | undefined, coordinates: Coordinates, style?: Style, ...args: any[]);
+    isLabel: boolean;
+    coordinates: Coordinates;
+    projectedPosition: {
+        x: number;
+        y: number;
+    };
+    boundaries: {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    };
+    content: Node;
+    anchor: any;
+    styleOffset: any;
+    icon: any;
+    iconOffset: {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    };
+    zoom: {
+        min: any;
+        max: any;
+    };
+    order: any;
+    padding: number;
+    /**
+     * Moves a label on the screen, using screen coordinates. It updates the
+     * boundaries as it moves it.
+     *
+     * @param {number} x - X coordinates in pixels, from left.
+     * @param {number} y - Y coordinates in pixels, from top.
+     */
+    updateProjectedPosition(x: number, y: number): void;
+    updateCSSPosition(): void;
+    /**
+     * Updates the screen dimensions of the label, using
+     * `getBoundingClientRect`.  It updates `width` and `height` property of the
+     * label, and the boundaries.
+     */
+    initDimensions(): void;
+    offset: {
+        left: any;
+        top: any;
+    } | undefined;
+    update3dPosition(crs: any): void;
+    updateElevationFromLayer(layer: any, nodes: any): void;
+    updateHorizonCullingPoint(): void;
+}
+import * as THREE from 'three';
+import { Coordinates } from '@itowns/geographic';

package/lib/Core/MainLoop.d.ts

@@ -0,0 +1,23 @@
+export const RENDERING_PAUSED: 0;
+export const RENDERING_SCHEDULED: 1;
+export namespace MAIN_LOOP_EVENTS {
+    let UPDATE_START: string;
+    let BEFORE_CAMERA_UPDATE: string;
+    let AFTER_CAMERA_UPDATE: string;
+    let BEFORE_LAYER_UPDATE: string;
+    let AFTER_LAYER_UPDATE: string;
+    let BEFORE_RENDER: string;
+    let AFTER_RENDER: string;
+    let UPDATE_END: string;
+}
+export default MainLoop;
+declare class MainLoop extends EventDispatcher<any> {
+    constructor(scheduler: any, engine: any);
+    renderingState: number;
+    scheduler: any;
+    gfxEngine: any;
+    scheduleViewUpdate(view: any, forceRedraw: any): void;
+    step(view: any, timestamp: any): void;
+    #private;
+}
+import { EventDispatcher } from 'three';

package/lib/Core/Picking.d.ts

@@ -0,0 +1,6 @@
+declare namespace _default {
+    function pickTilesAt(view: any, viewCoords: any, radius: any, layer: any, results?: any[]): any[];
+    function pickPointsAt(view: any, viewCoords: any, radius: any, layer: any, result?: any[]): any[] | undefined;
+    function pickObjectsAt(view: any, viewCoords: any, radius: any, object: any, target?: any[]): any[];
+}
+export default _default;

package/lib/Core/Picking.js

@@ -157,6 +157,10 @@ export default {
         // disable picking mode
         o.material.enablePicking(false);
 
+        // Skip if geometry is invalid or missing position attribute
+        if (!o.geometry || !o.geometry.attributes || !o.geometry.attributes.position) {
+          return;
+        }
         // if baseId matches objId, the clicked point belongs to `o`
         for (let i = 0; i < candidates.length; i++) {
           if (candidates[i].objId == o.baseId) {

package/lib/Core/PointCloudNode.d.ts

@@ -0,0 +1,16 @@
+export default PointCloudNode;
+declare class PointCloudNode extends THREE.EventDispatcher<any> {
+    constructor(numPoints: number | undefined, layer: any);
+    numPoints: number;
+    layer: any;
+    children: any[];
+    bbox: THREE.Box3;
+    sse: number;
+    get pointSpacing(): number;
+    get id(): void;
+    add(node: any, indexChild: any): void;
+    createChildAABB(node: any): void;
+    load(): any;
+    findCommonAncestor(node: any): any;
+}
+import * as THREE from 'three';