itowns 2.45.1 → 2.45.2-next.0

package/lib/Process/ObjectRemovalHelper.d.ts

@@ -0,0 +1,32 @@
+declare namespace _default {
+    /**
+     * Cleanup obj to release three.js allocated resources
+     * @param {Object3D} obj object to release
+     */
+    function cleanup(obj: Object3D): void;
+    /**
+     * Remove obj's children belonging to a layer.
+     * Neither obj nor its children will be disposed!
+     * @param {Layer} layer The layer that objects must belong to. Other object are ignored
+     * @param {Object3D} obj The Object3D we want to clean
+     * @return {Array} an array of removed Object3D from obj (not including the recursive removals)
+     */
+    function removeChildren(layer: Layer, obj: Object3D): any[];
+    /**
+     * Remove an obj and all its children belonging to a layer and only cleanup the obj (and not its children).
+     * obj will be disposed but its children **won't**!
+     * @param {Layer} layer The layer that objects must belong to. Other object are ignored
+     * @param {Object3D} obj The Object3D we want to clean
+     * @return {Array} an array of removed Object3D from obj (not including the recursive removals)
+     */
+    function removeChildrenAndCleanup(layer: Layer, obj: Object3D): any[];
+    /**
+     * Recursively remove an obj and all its children belonging to a layer.
+     * All removed obj will have their geometry/material disposed.
+     * @param {Layer} layer The layer that objects must belong to. Other object are ignored
+     * @param {Object3D} obj The Object3D we want to clean
+     * @return {Array} an array of removed Object3D from obj (not including the recursive removals)
+     */
+    function removeChildrenAndCleanupRecursively(layer: Layer, obj: Object3D): any[];
+}
+export default _default;

package/lib/Process/handlerNodeError.d.ts

@@ -0,0 +1 @@
+export default function handlingError(err: any, node: any, layer: any, targetLevel: any, view: any): void;

package/lib/Provider/3dTilesProvider.d.ts

@@ -0,0 +1,7 @@
+export function configureTile(tile: any, layer: any, metadata: any, parent: any): void;
+declare namespace _default {
+    export { executeCommand };
+}
+export default _default;
+declare function executeCommand(command: any): Promise<THREE.Object3D<THREE.Object3DEventMap>>;
+import * as THREE from 'three';

package/lib/Provider/DataSourceProvider.d.ts

@@ -0,0 +1,4 @@
+declare namespace _default {
+    function executeCommand(command: any): Promise<any[]>;
+}
+export default _default;

package/lib/Provider/Fetcher.d.ts

@@ -0,0 +1,101 @@
+declare namespace _default {
+    /**
+     * Wrapper over fetch to get some text.
+     *
+     * @param {string} url - The URL of the resources to fetch.
+     * @param {Object} options - Fetch options (passed directly to `fetch()`),
+     * see [the syntax for more information](
+     * https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Syntax).
+     *
+     * @return {Promise<string>} Promise containing the text.
+     */
+    export function text(url: string, options?: Object): Promise<string>;
+    /**
+     * Little wrapper over fetch to get some JSON.
+     *
+     * @param {string} url - The URL of the resources to fetch.
+     * @param {Object} options - Fetch options (passed directly to `fetch()`),
+     * see [the syntax for more information](
+     * https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Syntax).
+     *
+     * @return {Promise<Object>} Promise containing the JSON object.
+     */
+    export function json(url: string, options?: Object): Promise<Object>;
+    /**
+     * Wrapper over fetch to get some XML.
+     *
+     * @param {string} url - The URL of the resources to fetch.
+     * @param {Object} options - Fetch options (passed directly to `fetch()`),
+     * see [the syntax for more information](
+     * https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Syntax).
+     *
+     * @return {Promise<Document>} Promise containing the XML Document.
+     */
+    export function xml(url: string, options?: Object): Promise<Document>;
+    /**
+     * Wrapper around [THREE.TextureLoader](https://threejs.org/docs/#api/en/loaders/TextureLoader).
+     *
+     * @param {string} url - The URL of the resources to fetch.
+     * @param {Object} options - Fetch options (passed directly to `fetch()`),
+     * see [the syntax for more information](
+     * https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Syntax).
+     * Note that THREE.js docs mentions `withCredentials`, but it is not
+     * actually used in [THREE.TextureLoader](https://threejs.org/docs/#api/en/loaders/TextureLoader).
+     *
+     * @return {Promise<THREE.Texture>} Promise containing the
+     * [THREE.Texture](https://threejs.org/docs/api/en/textures/Texture.html).
+     */
+    export function texture(url: string, options?: Object): Promise<THREE.Texture>;
+    export { arrayBuffer };
+    /**
+     * Wrapper over fetch to get some
+     * [THREE.DataTexture](https://threejs.org/docs/#api/en/textures/DataTexture).
+     *
+     * @param {string} url - The URL of the resources to fetch.
+     * @param {Object} options - Fetch options (passed directly to `fetch()`),
+     * see [the syntax for more information](
+     * https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Syntax).
+     *
+     * @return {Promise<THREE.DataTexture>} Promise containing the DataTexture.
+     */
+    export function textureFloat(url: string, options?: Object): Promise<THREE.DataTexture>;
+    /**
+     * Wrapper over fetch to get a bunch of files sharing the same name, but
+     * different extensions.
+     *
+     * @param {string} baseUrl - The shared URL of the resources to fetch.
+     * @param {Object} extensions - An object containing arrays. The keys of
+     * each of this array are available fetch type, such as `text`, `json` or
+     * even `arrayBuffer`. The arrays contains the extensions to append after
+     * the `baseUrl` (see example below).
+     * @param {Object} options - Fetch options (passed directly to `fetch()`),
+     * see [the syntax for more information](
+     * https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Syntax).
+     *
+     * @return {Promise[]} An array of promises, containing all the files,
+     * organized by their extensions (see the example below).
+     *
+     * @example
+     * itowns.Fetcher.multiple('http://geo.server/shapefile', {
+     *     // will fetch:
+     *     // - http://geo.server/shapefile.shp
+     *     // - http://geo.server/shapefile.dbf
+     *     // - http://geo.server/shapefile.shx
+     *     // - http://geo.server/shapefile.prj
+     *     arrayBuffer: ['shp', 'dbf', 'shx'],
+     *     text: ['prj'],
+     * }).then(function _(result) {
+     *     // result looks like:
+     *     result = {
+     *         shp: ArrayBuffer
+     *         dbf: ArrayBuffer
+     *         shx: ArrayBuffer
+     *         prj: string
+     *     };
+     * });
+     */
+    export function multiple(baseUrl: string, extensions: Object, options?: Object): Promise<any>[];
+    export function get(format?: string): (url: string, options?: Object) => Promise<THREE.Texture>;
+}
+export default _default;
+declare function arrayBuffer(url: any, options?: {}): Promise<ArrayBuffer>;

package/lib/Provider/PointCloudProvider.d.ts

@@ -0,0 +1,4 @@
+declare namespace _default {
+    function executeCommand(command: any): any;
+}
+export default _default;

package/lib/Provider/TileProvider.d.ts

@@ -0,0 +1,4 @@
+declare namespace _default {
+    function executeCommand(command: any): Promise<any[]>;
+}
+export default _default;

package/lib/Provider/URLBuilder.d.ts

@@ -0,0 +1,28 @@
+declare namespace _default {
+    export { subDomains };
+    export function xyz(coords: {
+        row: number;
+        col: number;
+        zoom: number;
+    }, source: {
+        url: string;
+        tileMatrixCallback: Function;
+    }): string;
+    export function bbox(bbox: {
+        west: number;
+        south: number;
+        east: number;
+        north: number;
+    }, source: {
+        crs: string;
+        bboxDigits: number;
+        url: string;
+        axisOrder: string;
+    }): string;
+}
+export default _default;
+/**
+ * @param {string} url
+ * @returns {string}
+ */
+declare function subDomains(url: string): string;

package/lib/Renderer/Camera.d.ts

@@ -0,0 +1,95 @@
+export namespace CAMERA_TYPE {
+    let PERSPECTIVE: number;
+    let ORTHOGRAPHIC: number;
+}
+export default Camera;
+/**
+ * ~CAMERA_TYPE
+ * Stores the different types of camera usable in iTowns.
+ */
+export type Camera = {
+    /**
+     * Perspective type of camera
+     */
+    PERSPECTIVE: number;
+    /**
+     * Orthographic type of camera
+     */
+    ORTHOGRAPHIC: number;
+};
+/**
+ * Wrapper around Three.js camera to expose some geographic helpers.
+ *
+ * @property    {string}    crs             The camera's coordinate projection system.
+ * @property    {THREE.Camera}    camera3D        The Three.js camera that is wrapped around.
+ * @property    {number}    width           The width of the camera.
+ * @property    {number}    height          The height of the camera.
+ * @property    {number}    _preSSE         The precomputed constant part of the screen space error.
+ */
+declare class Camera {
+    /**
+     * @param   {string}                crs                                     The camera's coordinate projection system.
+     * @param   {number}                width                                   The width (in pixels) of the view the
+        * camera is associated to.
+     * @param   {number}                height                                  The height (in pixels) of the view the
+        * camera is associated to.
+     * @param   {Object}                [options]                               Options for the camera.
+     * @param   {THREE.Camera}          [options.cameraThree]                   A custom Three.js camera object to wrap
+        * around.
+     * @param   {Camera~CAMERA_TYPE}    [options.type=CAMERA_TYPE.PERSPECTIVE]  The type of the camera. See {@link
+        * CAMERA_TYPE}.
+     * @constructor
+     */
+    constructor(crs: string, width: number, height: number, options?: {
+        cameraThree?: THREE.Camera | undefined;
+    });
+    crs: string;
+    camera3D: {
+        cameraThree?: THREE.Camera | undefined;
+    } | THREE.Camera;
+    width: number;
+    height: number;
+    _preSSE: number;
+    /**
+     * Resize the camera to a given width and height.
+     *
+     * @param {number} width The width to resize the camera to. Must be strictly positive, won't resize otherwise.
+     * @param {number} height The height to resize the camera to. Must be strictly positive, won't resize otherwise.
+     */
+    resize(width: number, height: number): void;
+    update(): void;
+    /**
+     * Return the position in the requested CRS, or in camera's CRS if undefined.
+     *
+     * @param   {string}        [crs]   If defined (e.g 'EPSG:4326'), the camera position will be returned in this CRS.
+     *
+     * @return  {Coordinates}   Coordinates object holding camera's position.
+     */
+    position(crs?: string): Coordinates;
+    /**
+     * Set the position of the camera using a Coordinates object.
+     * If you want to modify the position directly using x,y,z values then use `camera.camera3D.position.set(x, y, z)`
+     *
+     * @param   {Coordinates}   position    The new position of the camera.
+     */
+    setPosition(position: Coordinates): void;
+    isBox3Visible(box3: any, matrixWorld: any): boolean;
+    isSphereVisible(sphere: any, matrixWorld: any): boolean;
+    box3SizeOnScreen(box3: any, matrixWorld: any): THREE.Box3;
+    /**
+     * Test for collision between camera and a geometry layer (DTM/DSM) to adjust camera position.
+     * It could be modified later to handle an array of geometry layers.
+     * TODO Improve Coordinates class to handle altitude for any coordinate system (even projected one)
+     *
+     * @param   {View}              view                    The view where we test the collision between geometry layers
+     * and the camera
+     * @param   {ElevationLayer}    elevationLayer          The elevation layer (DTM/DSM) used to test the collision
+     * with the camera. Could be another geometry layer.
+     * @param   {number}            minDistanceCollision    The minimum distance allowed between the camera and the
+     * surface.
+     */
+    adjustAltitudeToAvoidCollisionWithLayer(view: View, elevationLayer: ElevationLayer, minDistanceCollision: number): void;
+    #private;
+}
+import * as THREE from 'three';
+import { Coordinates } from '@itowns/geographic';

package/lib/Renderer/Color.d.ts

@@ -0,0 +1,3 @@
+export function lab2rgb(lab: any): number[];
+export function rgb2lab(rgb: any): number[];
+export function deltaE(rgbA: any, rgbB: any): number;

package/lib/Renderer/ColorLayersOrdering.d.ts

@@ -0,0 +1,38 @@
+export const COLOR_LAYERS_ORDER_CHANGED: "layers-order-changed";
+declare namespace _default {
+    /**
+     * Moves up in the layer list. This function has no effect if the layer is
+     * moved to its current index.
+     *
+     * @param {View} view - The view in which the layer is moved up.
+     * @param {string} layerId - The ID of the layer to move.
+     *
+     * @example
+     * itowns.ColorLayersOrdering.moveLayerUp(viewer, 'idLayerToUp');
+     */
+    function moveLayerUp(view: View, layerId: string): void;
+    /**
+     * Moves down in the layer list. This function has no effect if the layer is
+     * moved to its current index.
+     *
+     * @param {View} view - The view in which the layer is moved down.
+     * @param {string} layerId - The ID of the layer to move.
+     *
+     * @example
+     * itowns.ColorLayersOrdering.moveLayerDown(viewer, 'idLayerToDown');
+     */
+    function moveLayerDown(view: View, layerId: string): void;
+    /**
+     * Moves a specific layer to a specific index in the layer list. This
+     * function has no effect if the layer is moved to its current index.
+     *
+     * @param {View} view - The view in which the layer is moved.
+     * @param {string} layerId - The ID of the layer to move.
+     * @param {number} index - The index to move the layer to.
+     *
+     * @example
+     * itowns.ColorLayersOrdering.moveLayerToIndex(viewer, 'idLayerToChangeIndex', 2);
+     */
+    function moveLayerToIndex(view: View, layerId: string, index: number): void;
+}
+export default _default;

package/lib/Renderer/ColorLayersOrdering.js

@@ -2,8 +2,8 @@ import { ImageryLayers } from "../Layer/Layer.js";
 function updateLayersOrdering(geometryLayer, imageryLayers) {
   const sequence = ImageryLayers.getColorLayersIdOrderedBySequence(imageryLayers);
   const cO = function (object) {
-    if (object.material?.setSequence) {
-      object.material.setSequence(sequence);
+    if (object.material?.setColorTileIds) {
+      object.material.setColorTileIds(sequence);
     }
   };
   for (const node of geometryLayer.level0Nodes) {

package/lib/Renderer/CommonMaterial.d.ts

@@ -0,0 +1,6 @@
+declare namespace _default {
+    function setDefineMapping(object: any, PROPERTY: any, mapping: any): void;
+    function setDefineProperty(object: any, property: any, PROPERTY: any, initValue: any): void;
+    function setUniformProperty(object: any, property: any, initValue: any): void;
+}
+export default _default;

package/lib/Renderer/Label2DRenderer.d.ts

@@ -0,0 +1,31 @@
+export class ScreenGrid {
+    constructor(x: number | undefined, y: number | undefined, width: any, height: any);
+    x: number;
+    y: number;
+    grid: any[];
+    visible: any[];
+    width: any;
+    height: any;
+    reset(): void;
+    resize(): void;
+    insert(obj: any): boolean;
+}
+export default Label2DRenderer;
+/**
+ * This renderer is inspired by the
+ * [`THREE.CSS2DRenderer`](https://threejs.org/docs/#examples/en/renderers/CSS2DRenderer).
+ * It is instanciated in `c3DEngine`, as another renderer to handles Labels.
+ */
+declare class Label2DRenderer {
+    domElement: HTMLDivElement;
+    garbage: HTMLDivElement;
+    halfWidth: number;
+    halfHeight: number;
+    grid: ScreenGrid;
+    infoTileLayer: any;
+    setSize(width: any, height: any): void;
+    registerLayer(layer: any): void;
+    render(scene: any, camera: any): void;
+    culling(label: any, camera: any): void;
+    removeLabelDOM(label: any): void;
+}

package/lib/Renderer/LayeredMaterial.d.ts

@@ -0,0 +1,121 @@
+import * as THREE from 'three';
+import RenderMode from '../Renderer/RenderMode';
+import { RasterTile, RasterElevationTile, RasterColorTile } from './RasterTile';
+export declare function unpack1K(color: THREE.Vector4Like, factor: number): number;
+export declare function getMaxColorSamplerUnitsCount(): number;
+export declare const colorLayerEffects: {
+    readonly noEffect: 0;
+    readonly removeLightColor: 1;
+    readonly removeWhiteColor: 2;
+    readonly customEffect: 3;
+};
+/** GPU struct for color layers */
+interface StructColorLayer {
+    textureOffset: number;
+    crs: number;
+    opacity: number;
+    effect_parameter: number;
+    effect_type: number;
+    transparent: boolean;
+}
+/** GPU struct for elevation layers */
+interface StructElevationLayer {
+    scale: number;
+    bias: number;
+    mode: number;
+    zmin: number;
+    zmax: number;
+}
+export declare const ELEVATION_MODES: {
+    readonly RGBA: 0;
+    readonly COLOR: 1;
+    readonly DATA: 2;
+};
+/**
+ * Convenience type that wraps all of the generic type's fields in
+ * [THREE.IUniform]s.
+ */
+type MappedUniforms<Uniforms> = {
+    [name in keyof Uniforms]: THREE.IUniform<Uniforms[name]>;
+};
+/** List of the uniform types required for a LayeredMaterial. */
+interface LayeredMaterialRawUniforms {
+    diffuse: THREE.Color;
+    opacity: number;
+    lightingEnabled: boolean;
+    lightPosition: THREE.Vector3;
+    fogDistance: number;
+    fogColor: THREE.Color;
+    overlayAlpha: number;
+    overlayColor: THREE.Color;
+    objectId: number;
+    geoidHeight: number;
+    minBorderDistance: number;
+    showOutline: boolean;
+    outlineWidth: number;
+    outlineColors: THREE.Color[];
+    elevationLayers: Array<StructElevationLayer>;
+    elevationTextures: Array<THREE.Texture>;
+    elevationOffsetScales: Array<THREE.Vector4>;
+    elevationTextureCount: number;
+    colorLayers: Array<StructColorLayer>;
+    colorTextures: Array<THREE.Texture>;
+    colorOffsetScales: Array<THREE.Vector4>;
+    colorTextureCount: number;
+}
+/** Replacing the default uniforms dynamic type with our own static map. */
+export interface LayeredMaterialParameters extends THREE.ShaderMaterialParameters {
+    uniforms?: MappedUniforms<LayeredMaterialRawUniforms>;
+}
+type DefineMapping<Prefix extends string, Mapping extends Record<string, unknown>> = {
+    [Name in Extract<keyof Mapping, string> as `${Prefix}_${Name}`]: Mapping[Name];
+};
+type ElevationModeDefines = DefineMapping<'ELEVATION', typeof ELEVATION_MODES>;
+type RenderModeDefines = DefineMapping<'MODE', typeof RenderMode.MODES>;
+type LayeredMaterialDefines = {
+    NUM_VS_TEXTURES: number;
+    NUM_FS_TEXTURES: number;
+    USE_FOG: number;
+    NUM_CRS: number;
+    DEBUG: number;
+    MODE: number;
+} & ElevationModeDefines & RenderModeDefines;
+/** Material that handles the overlap of multiple raster tiles. */
+export declare class LayeredMaterial extends THREE.ShaderMaterial {
+    private _visible;
+    colorTiles: RasterColorTile[];
+    elevationTile: RasterElevationTile | undefined;
+    colorTileIds: string[];
+    elevationTileId: string | undefined;
+    layersNeedUpdate: boolean;
+    defines: LayeredMaterialDefines;
+    constructor(options: LayeredMaterialParameters | undefined, crsCount: number);
+    get mode(): number;
+    set mode(mode: number);
+    getUniform<Name extends keyof LayeredMaterialRawUniforms>(name: Name): LayeredMaterialRawUniforms[Name] | undefined;
+    setUniform<Name extends keyof LayeredMaterialRawUniforms, Value extends LayeredMaterialRawUniforms[Name]>(name: Name, value: Value): void;
+    initUniforms(uniforms: {
+        [Name in keyof LayeredMaterialRawUniforms]?: LayeredMaterialRawUniforms[Name];
+    }): void;
+    setUniforms(uniforms: {
+        [Name in keyof LayeredMaterialRawUniforms]?: LayeredMaterialRawUniforms[Name];
+    }): void;
+    getLayerUniforms<Type extends 'color' | 'elevation'>(type: Type): MappedUniforms<{
+        layers: Array<Type extends 'color' ? StructColorLayer : StructElevationLayer>;
+        textures: Array<THREE.Texture>;
+        offsetScales: Array<THREE.Vector4>;
+        textureCount: number;
+    }>;
+    updateLayersUniforms(): void;
+    dispose(): void;
+    setColorTileIds(ids: string[]): void;
+    setElevationTileId(id: string): void;
+    removeTile(tileId: string): void;
+    addColorTile(rasterTile: RasterColorTile): void;
+    setElevationTile(rasterTile: RasterElevationTile): void;
+    getColorTile(id: string): RasterColorTile | undefined;
+    getElevationTile(): RasterElevationTile | undefined;
+    getTile(id: string): RasterTile | undefined;
+    getTiles(ids: string[]): RasterTile[];
+}
+export {};