itowns 2.45.1 → 2.45.2-next.1

package/lib/Layer/ColorLayer.d.ts

@@ -0,0 +1,128 @@
+export default ColorLayer;
+/**
+ * Fires when the visiblity of the layer has changed.
+ * @event ColorLayer#visible-property-changed
+ */
+/**
+ * Fires when the opacity of the layer has changed.
+ * @event ColorLayer#opacity-property-changed
+ */
+/**
+ * Fires when the sequence of the layer has changed, meaning that the order of
+ * the layer changed in the view it is attached to.
+ * @event ColorLayer#sequence-property-changed
+ */
+/**
+ * @property {boolean} isColorLayer - Used to checkout whether this layer is a
+ * ColorLayer. Default is true. You should not change this, as it is used
+ * internally for optimisation.
+ * @property {StyleOptions|Style} style - style properties or a Style defined by the user,
+ * to apply to the layer features.
+ * @property {boolean} visible - property to display or to hide layer.
+ * @property {number} opacity - property to adjust transparency, opacity is between 0. and 1.
+ * @property {boolean} transparent - specify if the layer could be transparent.
+ * @property {boolean} noTextureParentOutsideLimit - don't parent texture if it's outside limit.
+ * @property {number} effect_type - type effect to apply on the raster color.
+ * If `effect_type` equals:
+ * * `0`: no effect.
+ * * `1`: light color to invisible effect: transparency effect is stronger for
+ *   light colors (whose distance is closer to white). This effect can be
+ *   amplified by `effect_parameter`.
+ * * `2`: white color to invisible effect: white color is considered as
+ *   transparent.
+ * * `3`: custom shader effect: set `ShaderChunk.customBodyColorLayer` and
+ *   `ShaderChunk.customHeaderColorLayer` to add your own glsl code in
+ *   respectively the color layer function body and at top-level.
+ * @property {number} effect_parameter - value used as parameter of certain type
+ * of effects. If `effect_type` equals:
+ * * `0`: unused.
+ * * `1`: used to amplify the transparency effect.
+ * * `2`: unused.
+ * * `3`: could be used by your own glsl code.
+ *
+ * @extends RasterLayer
+ */
+declare class ColorLayer extends RasterLayer {
+    /**
+     * A simple layer, usually managing a texture to display on a view. For example,
+     * it can be an aerial view of the ground or a simple transparent layer with the
+     * roads displayed.
+     *
+     * @param {string} id - The id of the layer, that should be unique. It is
+     * not mandatory, but an error will be emitted if this layer is added a
+     * {@link View} that already has a layer going by that id.
+     * @param {Object} [config] - Optional configuration, all elements in it
+     * will be merged as is in the layer. For example, if the configuration
+     * contains three elements `name, protocol, extent`, these elements will be
+     * available using `layer.name` or something else depending on the property
+     * name.
+     * @param {Source} [config.source] - Description and options of the source.
+     * @param {number} [config.magFilter] - How the texture is sampled when a texel covers more than one pixel. [see](https://threejs.org/docs/?q=texture#api/en/textures/Texture.magFilter)
+     * @param {number} [config.minFilter] - How the texture is sampled when a texel covers less than one pixel. [see](https://threejs.org/docs/?q=texture#api/en/textures/Texture.minFilter)
+     * @param {number} [config.effect_type=0] - type effect to apply on raster color.
+     * if `effect_type` equals:
+     * * `0`: no special effect.
+     * * `1`: light color to invisible effect.
+     * * `2`: white color to invisible effect.
+     * * `3`: custom shader effect (defined `ShaderChunk.customBodyColorLayer` and `ShaderChunk.customHeaderColorLayer`).
+     * @param {number} [config.effect_parameter=1.0] - amount value used with effect applied on raster color.
+     *
+     * @example
+     * // Create a ColorLayer
+     * const color = new ColorLayer('roads', {
+     *     source: new  SourceWMTS({
+     *          protocol: 'wmts',
+     *          url: 'http://server.geo/wmts/....',
+     *          format: 'image/png',
+     *          name: 'nameService',
+     *          tileMatrixSet: 'PM',
+     *     }),
+     *     transparent: true,
+     *     opacity: 0.5,
+     * });
+     *
+     * // Add the layer
+     * view.addLayer(color);
+     */
+    constructor(id: string, config?: {
+        source?: any;
+        magFilter?: number | undefined;
+        minFilter?: number | undefined;
+        effect_type?: number | undefined;
+        effect_parameter?: number | undefined;
+    });
+    /**
+     * @type {boolean}
+     * @readonly
+     */
+    readonly isColorLayer: boolean;
+    /**
+     * @type {boolean}
+     */
+    visible: boolean;
+    /**
+     * @type {number}
+     */
+    opacity: number;
+    /**
+     * @type {number}
+     */
+    sequence: number;
+    transparent: any;
+    noTextureParentOutsideLimit: any;
+    effect_type: number;
+    effect_parameter: number;
+    buildExtent: boolean;
+    structure: string;
+    /**
+     * Setup RasterColorTile added to TileMesh. This RasterColorTile handles
+     * the ColorLayer textures mapped on this TileMesh.
+     *
+     * @param      {TileMesh}  node    The node to apply new RasterColorTile;
+     * @return     {RasterColorTile}  The raster color node added.
+     */
+    setupRasterNode(node: TileMesh): RasterColorTile;
+    update(context: any, layer: any, node: any, parent: any): any;
+}
+import RasterLayer from '../Layer/RasterLayer';
+import { RasterColorTile } from '../Renderer/RasterTile';

package/lib/Layer/ColorLayer.js

@@ -141,11 +141,11 @@ class ColorLayer extends RasterLayer {
    * @return     {RasterColorTile}  The raster color node added.
    */
   setupRasterNode(node) {
-    const rasterColorNode = new RasterColorTile(node.material, this);
-    node.material.addLayer(rasterColorNode);
+    const rasterColorTile = new RasterColorTile(this);
+    node.material.addColorTile(rasterColorTile);
     // set up ColorLayer ordering.
-    node.material.setSequence(this.parent.colorLayersOrder);
-    return rasterColorNode;
+    node.material.setColorTileIds(this.parent.colorLayersOrder);
+    return rasterColorTile;
   }
   update(context, layer, node, parent) {
     return updateLayeredMaterialNodeImagery(context, this, node, parent);

package/lib/Layer/CopcLayer.d.ts

@@ -0,0 +1,42 @@
+export default CopcLayer;
+/**
+ * A layer for [Cloud Optimised Point Cloud](https://copc.io) (COPC) datasets.
+ * See {@link PointCloudLayer} class for documentation on base properties.
+ *
+ * @extends {PointCloudLayer}
+ *
+ * @example
+ * // Create a new COPC layer
+ * const copcSource = new CopcSource({
+ *     url: 'https://s3.amazonaws.com/hobu-lidar/autzen-classified.copc.laz',
+ *     crs: 'EPSG:4978',
+ *     colorDepth: 16, // bit-depth of 'color' attribute (either 8 or 16 bits)
+ * });
+ *
+ * const copcLayer = new CopcLayer('COPC', {
+ *     source: copcSource,
+ * });
+ *
+ * View.prototype.addLayer.call(view, copcLayer);
+ */
+declare class CopcLayer extends PointCloudLayer {
+    /**
+     * @param {string} id - Unique id of the layer.
+     * @param {Object} config - See {@link PointCloudLayer} for base pointcloud
+     * options.
+     */
+    constructor(id: string, config: Object);
+    /**
+     * @type {boolean}
+     * @readonly
+     */
+    readonly isCopcLayer: boolean;
+    whenReady: Promise<any>;
+    spacing: any;
+    minElevationRange: any;
+    maxElevationRange: any;
+    scale: THREE.Vector3;
+    offset: THREE.Vector3;
+}
+import PointCloudLayer from '../Layer/PointCloudLayer';
+import * as THREE from 'three';

package/lib/Layer/CopcLayer.js

@@ -39,13 +39,13 @@ class CopcLayer extends PointCloudLayer {
     const resolve = () => this;
     this.whenReady = this.source.whenReady.then((/** @type {CopcSource} */source) => {
       const {
-        cube,
-        rootHierarchyPage
+        cube
       } = source.info;
       const {
         pageOffset,
         pageLength
-      } = rootHierarchyPage;
+      } = source.info.rootHierarchyPage;
+      this.spacing = source.info.spacing;
       this.root = new CopcNode(0, 0, 0, 0, pageOffset, pageLength, this, -1);
       this.root.bbox.min.fromArray(cube, 0);
       this.root.bbox.max.fromArray(cube, 3);
@@ -56,8 +56,5 @@ class CopcLayer extends PointCloudLayer {
       return this.root.loadOctree().then(resolve);
     });
   }
-  get spacing() {
-    return this.source.info.spacing;
-  }
 }
 export default CopcLayer;

package/lib/Layer/ElevationLayer.d.ts

@@ -0,0 +1,96 @@
+export default ElevationLayer;
+/**
+ * @property {boolean} isElevationLayer - Used to checkout whether this layer is
+ * an ElevationLayer. Default is true. You should not change this, as it is used
+ * internally for optimisation.
+ * @property {number} noDataValue - Used to specify a **null** or **no data value** in the elevation terrain.
+ * @property {number} [zmin] - Used to specify a minimum value for the elevation terrain (if the data goes lower, it will be clamped).
+ * @property {number} [zmax] - Used to specify a maximum value for the elevation terrain (if the data goes higher, it will be clamped)
+ * @property {number} scale - Used to apply a scale on the elevation value. It
+ * can be used for exageration of the elevation, like in [this
+ * example](https://www.itowns-project.org/itowns/examples/#plugins_pyramidal_tiff).
+ * @property {boolean} useColorTextureElevation - the elevation is computed with one color texture channel,
+ * `this.colorTextureElevationMaxZ` and `this.colorTextureElevationMinZ`.
+ *
+ * The formula is:
+ *
+ * ```js
+ * elevation = color.r * (this.colorTextureElevationMaxZ - this.colorTextureElevationMinZ) + this.colorTextureElevationMinZ
+ * ```
+ * @property {number} colorTextureElevationMinZ - elevation minimum in `useColorTextureElevation` mode.
+ * @property {number} colorTextureElevationMaxZ - elevation maximum in `useColorTextureElevation` mode.
+ *
+ * @extends RasterLayer
+ */
+declare class ElevationLayer extends RasterLayer {
+    /**
+     * A simple layer, managing an elevation texture to add some reliefs on the
+     * plane or globe view for example.
+     *
+     * @param {string} id - The id of the layer, that should be unique. It is
+     * not mandatory, but an error will be emitted if this layer is added a
+     * {@link View} that already has a layer going by that id.
+     * @param {Object} [config] - Optional configuration, all elements in it
+     * will be merged as is in the layer. For example, if the configuration
+     * contains three elements `name, protocol, extent`, these elements will be
+     * available using `layer.name` or something else depending on the property
+     * name.
+     * @param {number} [config.noDataValue]   The value coding the noData in the data set
+     * @param {Object} [config.clampValues] - Optional information for clamping
+     * the elevation between a minimum and a maximum value
+     * @param {number} [config.clampValues.min]   The minimum value to clamp the elevation
+     * @param {number} [config.clampValues.max]   The maximum value to clamp the elevation
+     *
+     * @example
+     * // Create an ElevationLayer
+     * const elevation = new ElevationLayer('IGN_MNT', {
+     *      source: new WMTSSource({
+     *          "url": "https://data.geopf.fr/wmts?",
+     *           "crs": "EPSG:4326",
+     *           "format": "image/x-bil;bits=32",
+     *           "name": "ELEVATION.ELEVATIONGRIDCOVERAGE",
+     *      }),
+     * });
+     *
+     * // Add the layer
+     * view.addLayer(elevation);
+     */
+    constructor(id: string, config?: {
+        noDataValue?: number | undefined;
+        clampValues?: {
+            min?: number | undefined;
+            max?: number | undefined;
+        } | undefined;
+    });
+    /**
+     * @type {boolean}
+     * @readonly
+     */
+    readonly isElevationLayer: boolean;
+    noDataValue: number | undefined;
+    /**
+     * @type {number | undefined}
+     */
+    zmin: number | undefined;
+    /**
+     * @type {number | undefined}
+     */
+    zmax: number | undefined;
+    useRgbaTextureElevation: any;
+    useColorTextureElevation: any;
+    colorTextureElevationMinZ: any;
+    colorTextureElevationMaxZ: any;
+    bias: any;
+    mode: any;
+    /**
+     * Setup RasterElevationTile added to TileMesh. This RasterElevationTile handles
+     * the elevation texture to displace TileMesh vertices.
+     *
+     * @param      {TileMesh}  node    The node to apply new RasterElevationTile;
+     * @return     {RasterElevationTile}  The raster elevation node added.
+     */
+    setupRasterNode(node: TileMesh): RasterElevationTile;
+    update(context: any, layer: any, node: any, parent: any): any;
+}
+import RasterLayer from '../Layer/RasterLayer';
+import { RasterElevationTile } from '../Renderer/RasterTile';

package/lib/Layer/ElevationLayer.js

@@ -110,9 +110,9 @@ class ElevationLayer extends RasterLayer {
    * @return     {RasterElevationTile}  The raster elevation node added.
    */
   setupRasterNode(node) {
-    const rasterElevationNode = new RasterElevationTile(node.material, this);
-    node.material.addLayer(rasterElevationNode);
-    node.material.setSequenceElevation(this.id);
+    const rasterElevationNode = new RasterElevationTile(this);
+    node.material.setElevationTile(rasterElevationNode);
+    node.material.setElevationTileId(this.id);
     // bounding box initialisation
     const updateBBox = () => node.setBBoxZ({
       min: rasterElevationNode.min,

package/lib/Layer/EntwinePointTileLayer.d.ts

@@ -0,0 +1,56 @@
+export default EntwinePointTileLayer;
+/**
+ * @property {boolean} isEntwinePointTileLayer - Used to checkout whether this
+ * layer is a EntwinePointTileLayer. Default is `true`. You should not change
+ * this, as it is used internally for optimisation.
+ *
+ * @extends PointCloudLayer
+ */
+declare class EntwinePointTileLayer extends PointCloudLayer {
+    /**
+     * Constructs a new instance of Entwine Point Tile layer.
+     *
+     * @example
+     * // Create a new point cloud layer
+     * const points = new EntwinePointTileLayer('EPT',
+     *  {
+     *      source: new EntwinePointTileSource({
+     *          url: 'https://server.geo/ept-dataset',
+     *      }
+     *  });
+     *
+     * View.prototype.addLayer.call(view, points);
+     *
+     * @param {string} id - The id of the layer, that should be unique. It is
+     * not mandatory, but an error will be emitted if this layer is added a
+     * {@link View} that already has a layer going by that id.
+     * @param {Object} config - Configuration, all elements in it
+     * will be merged as is in the layer. For example, if the configuration
+     * contains three elements `name, protocol, extent`, these elements will be
+     * available using `layer.name` or something else depending on the property
+     * name. See the list of properties to know which one can be specified.
+     * @param {string} [config.crs='ESPG:4326'] - The CRS of the {@link View} this
+     * layer will be attached to. This is used to determine the extent of this
+     * layer. Default to `EPSG:4326`.
+     */
+    constructor(id: string, config: {
+        crs?: string | undefined;
+    });
+    /**
+     * @type {boolean}
+     * @readonly
+     */
+    readonly isEntwinePointTileLayer: boolean;
+    /**
+     * @type {THREE.Vector3}
+     */
+    scale: THREE.Vector3;
+    whenReady: Promise<any>;
+    spacing: number;
+    minElevationRange: any;
+    maxElevationRange: any;
+    extent: Extent;
+}
+import PointCloudLayer from '../Layer/PointCloudLayer';
+import * as THREE from 'three';
+import { Extent } from '@itowns/geographic';

package/lib/Layer/EntwinePointTileLayer.js

@@ -55,6 +55,10 @@ class EntwinePointTileLayer extends PointCloudLayer {
     this.scale = new THREE.Vector3(1, 1, 1);
     const resolve = this.addInitializationStep();
     this.whenReady = this.source.whenReady.then(() => {
+      // NOTE: this spacing is kinda arbitrary here, we take the width and
+      // length (height can be ignored), and we divide by the specified
+      // span in ept.json. This needs improvements.
+      this.spacing = (Math.abs(this.source.bounds[3] - this.source.bounds[0]) + Math.abs(this.source.bounds[4] - this.source.bounds[1])) / (2 * this.source.span);
       this.root = new EntwinePointTileNode(0, 0, 0, 0, this, -1);
       this.root.bbox.min.fromArray(this.source.boundsConforming, 0);
       this.root.bbox.max.fromArray(this.source.boundsConforming, 3);
@@ -64,8 +68,5 @@ class EntwinePointTileLayer extends PointCloudLayer {
       return this.root.loadOctree().then(resolve);
     });
   }
-  get spacing() {
-    return this.source.spacing;
-  }
 }
 export default EntwinePointTileLayer;

package/lib/Layer/FeatureGeometryLayer.d.ts

@@ -0,0 +1,62 @@
+export default FeatureGeometryLayer;
+/**
+ * `FeatureGeometryLayer` displays geographic vector data (geojson, kml...) in object 3D.
+ * `FeatureGeometryLayer` is a pre-configured `GeometryLayer` to load and convert vector data.
+ * In deed, `GeometryLayer` allows customizing data loading (`update` method)
+ * and their conversion (`convert` method),
+ *
+ * @property {boolean} isFeatureGeometryLayer - Used to checkout whether this layer is
+ * a FeatureGeometryLayer. Default is true. You should not change this, as it is used
+ * internally for optimisation.
+ *
+ * @extends GeometryLayer
+ */
+declare class FeatureGeometryLayer extends GeometryLayer {
+    /**
+     *
+     * @param {string} id - The id of the layer, that should be unique. It is
+     * not mandatory, but an error will be emitted if this layer is added a
+     * {@link View} that already has a layer going by that id.
+     * @param {Object} [options] - Optional configuration, all elements in it
+     * will be merged as is in the layer.
+     * @param {function} [options.batchId] - optional function to create batchId attribute.
+     * It is passed the feature property and the feature index.
+     * As the batchId is using an unsigned int structure on 32 bits, the batchId could be between 0 and 4,294,967,295.
+     * @param {THREE.Object3D} [options.object3d=new THREE.Group()] root object3d layer.
+     * @param {function} [options.onMeshCreated] this callback is called when the mesh is created. The callback parameters are the
+     * `mesh` and the `context`.
+     * @param {function} [options.filter] callback which filters the features of
+     * this layer. It takes an object with a `properties` property as argument
+     * and shall return a boolean.
+     * @param {boolean} [options.accurate=TRUE] If `accurate` is `true`, data are re-projected with maximum geographical accuracy.
+     * With `true`, `proj4` is used to transform data source.
+     *
+     * If `accurate` is `false`, re-projecting is faster but less accurate.
+     * With `false`, an affine transformation is used to transform data source.
+     * This method is an approximation. The error increases with the extent
+     * dimension of the object or queries.
+     *
+     * For example :
+     * * for a **100** meter dimension, there's a difference of **0.001** meter with the accurate method
+     * * for a **500** meter dimension, there's a difference of **0.05** meter with the accurate method
+     * * for a **20000** meter dimension, there's a difference of **40** meter with the accurate method
+     *
+     * **WARNING** If the source is `VectorTilesSource` then `accurate` is always false.
+     */
+    constructor(id: string, options?: {
+        batchId?: Function | undefined;
+        object3d?: any;
+        onMeshCreated?: Function | undefined;
+        filter?: Function | undefined;
+        accurate?: boolean | undefined;
+    });
+    update: (context: any, layer: any, node: any) => any;
+    convert: Function;
+    onMeshCreated: Function | undefined;
+    isFeatureGeometryLayer: boolean;
+    accurate: boolean;
+    buildExtent: boolean;
+    filter: Function | undefined;
+    preUpdate(context: any, sources: any): void;
+}
+import GeometryLayer from '../Layer/GeometryLayer';

package/lib/Layer/GeoidLayer.d.ts

@@ -0,0 +1,41 @@
+export function geoidLayerIsVisible(tilelayer: any): any;
+export default GeoidLayer;
+/**
+ * `GeoidLayer` is a specific `{@link Layer}` which supports geoid height data. When added to a `{@link View}`, it
+ * vertically translates each of the view's tiles by a proper geoid height value. For a given tile, the geoid height
+ * value used for translation is the geoid height computed at the center of the tile.
+ *
+ * @example
+ * // Create a GeoidLayer from a GTX geoid heights file.
+ * const geoidLayer = new GeoidLayer('geoid', {
+ *     source: new FileSource({
+ *         url: 'url-to-some-GTX-geoid-heights-file.gtx',
+ *         crs: 'EPSG:4326',
+ *         format: 'application/gtx',
+ *     }),
+ * });
+ */
+declare class GeoidLayer extends Layer {
+    /**
+     * Creates a new instance of `GeoidLayer`.
+     *
+     * @param   {string}    id              An unique identifier for the layer.
+     * @param   {Object}    config          The layer configuration. All elements in it will be merged as is in the
+                                            * layer. For example, if the configuration contains three elements `name,
+                                            * protocol, extent`, these elements will be available using `layer.name` or
+                                            * something else depending on the property name. Only `config.source`
+                                            * parameter is mandatory.
+     * @param   {Object}    config.source   The source of the geoid data displayed by the `GeoidLayer`. It is mandatory
+                                            * that the source data for a `GeoidLayer` be parsed into a
+                                            * `{@link GeoidGrid}`. You can refer to `{@link GTXParser}`,
+                                            * `{@link GDFParser}` and `{@link ISGParser}` to see how three standard
+                                            * geoid height grid file formats are parsed into `{@link GeoidGrid}`.
+     */
+    constructor(id: string, config?: {
+        source: Object;
+    });
+    isGeoidLayer: boolean;
+    updateNodeZ(node: any): void;
+    update(context: any, layer: any, node: any, parent: any): any;
+}
+import Layer from '../Layer/Layer';

package/lib/Layer/GeometryLayer.d.ts

@@ -0,0 +1,120 @@
+export default GeometryLayer;
+/**
+ * Fires when the opacity of the layer has changed.
+ * @event GeometryLayer#opacity-property-changed
+ */
+/**
+ * @property {boolean} isGeometryLayer - Used to checkout whether this layer is
+ * a GeometryLayer. Default is true. You should not change this, as it is used
+ * internally for optimisation.
+ * @property {number} [zoom.max=Infinity] - this is the maximum zoom beyond which it'll be hidden.
+ * The `max` is constant and the value is `Infinity` because there's no maximum display level after which it is hidden.
+ * This property is used only if the layer is attached to {@link TiledGeometryLayer}.
+ * @property {number} [zoom.min=0] - this is the minimum zoom from which it'll be visible.
+ * This property is used only if the layer is attached to {@link TiledGeometryLayer}.
+ */
+declare class GeometryLayer extends Layer {
+    /**
+     * A layer usually managing a geometry to display on a view. For example, it
+     * can be a layer of buildings extruded from a a WFS stream.
+     *
+     * @param {string} id - The id of the layer, that should be unique. It is
+     * not mandatory, but an error will be emitted if this layer is added a
+     * {@link View} that already has a layer going by that id.
+     * @param {THREE.Object3D} object3d - The object3D used to contain the
+     * geometry of the GeometryLayer. It is usually a `THREE.Group`, but it can
+     * be anything inheriting from a `THREE.Object3D`.
+     * @param {Object} [config] - Optional configuration, all elements in it
+     * will be merged as is in the layer. For example, if the configuration
+     * contains three elements `name, protocol, extent`, these elements will be
+     * available using `layer.name` or something else depending on the property
+     * name.
+     * @param {Source} config.source - Description and options of the source.
+     * @param {number} [config.cacheLifeTime=Infinity] - set life time value in cache.
+     * This value is used for [Cache]{@link Cache} expiration mechanism.
+     * @param {boolean} [config.visible]
+     *
+     * @throws {Error} `object3d` must be a valid `THREE.Object3d`.
+     *
+     * @example
+     * // Create a GeometryLayer
+     * const geometry = new GeometryLayer('buildings', new THREE.Object3D(), {
+     *      source: {
+     *          url: 'http://server.geo/wfs?',
+     *          protocol: 'wfs',
+     *          format: 'application/json'
+     *      },
+     * });
+     *
+     * // Add the layer
+     * view.addLayer(geometry);
+     */
+    constructor(id: string, object3d: THREE.Object3D, config?: {
+        source: Source;
+        cacheLifeTime?: number | undefined;
+        visible?: boolean | undefined;
+    });
+    /**
+     * @type {boolean}
+     * @readonly
+     */
+    readonly isGeometryLayer: boolean;
+    /**
+     * @type {THREE.Object3D}
+     * @readonly
+     */
+    readonly object3d: THREE.Object3D;
+    /**
+     * @type {number}
+     */
+    opacity: number;
+    /**
+     * @type {boolean}
+     */
+    wireframe: boolean;
+    /**
+     * @type {Layer[]}
+     */
+    attachedLayers: Layer[];
+    set visible(value: any);
+    get visible(): any;
+    filteringExtent: boolean;
+    structure: string;
+    getObjectToUpdateForAttachedLayers(obj: any): {
+        element: any;
+        parent: any;
+    } | undefined;
+    postUpdate(): void;
+    culling(): boolean;
+    /**
+     * Attach another layer to this one. Layers attached to a GeometryLayer will
+     * be available in `geometryLayer.attachedLayers`.
+     *
+     * @param {Layer} layer - The layer to attach, that must have an `update`
+     * method.
+     */
+    attach(layer: Layer): void;
+    /**
+     * Detach a layer attached to this one. See {@link attach} to learn how to
+     * attach a layer.
+     *
+     * @param {Layer} layer - The layer to detach.
+     *
+     * @return {boolean} Confirmation of the detachment of the layer.
+     */
+    detach(layer: Layer): boolean;
+    /**
+     * Picking method for this layer.
+     *
+     * @param {View} view - The view instance.
+     * @param {Object} coordinates - The coordinates to pick in the view. It
+     * should have at least `x` and `y` properties.
+     * @param {number} radius - Radius of the picking circle.
+     * @param {Array} target - target to push result.
+     *
+     * @return {Array} An array containing all targets picked under the
+     * specified coordinates.
+     */
+    pickObjectsAt(view: View, coordinates: Object, radius?: number, target?: any[]): any[];
+}
+import Layer from '../Layer/Layer';

package/lib/Layer/InfoLayer.d.ts

@@ -0,0 +1,24 @@
+export default class InfoLayer {
+    constructor(layer: any);
+    layer: any;
+    clear(): void;
+    update(): void;
+}
+/**
+ * InfoTiledGeometryLayer that provides some states layer informations. These
+ * informations are displayed tiles, displayed {@link ColorLayer} and {@link
+ * ElevationLayer} and extent of displayed tiles.
+ *
+ * @class InfoTiledGeometryLayer
+ *
+ * @property {object} displayed
+ * @property {Layer[]} displayed.layers - Displayed {@link ColorLayer} and {@link ElevationLayer}.
+ * @property {Extent} displayed.extent - {@link Extent} of displayed tiles.
+ * @property {Set} displayed.tiles - Set of displayed tiles.
+ */
+export class InfoTiledGeometryLayer extends InfoLayer {
+    displayed: {
+        tiles: Set<any>;
+    };
+    update(tile: any): void;
+}

package/lib/Layer/InfoLayer.js

@@ -32,7 +32,7 @@ export class InfoTiledGeometryLayer extends InfoLayer {
         let layers = [];
         this.displayed.tiles.forEach(tile => {
           const m = tile.material;
-          layers = [...new Set([...layers, ...m.colorLayerIds.filter(id => m.getLayer(id)), ...m.elevationLayerIds])];
+          layers = [...new Set([...layers, ...m.colorTileIds.filter(id => m.getColorTile(id)), m.elevationTileId])];
         });
         return this.layer.attachedLayers.filter(l => layers.includes(l.id));
       }