itowns 2.45.1-next.0 → 2.45.1-next.1

package/lib/Provider/Fetcher.js

@@ -0,0 +1,233 @@
+import { TextureLoader, DataTexture, RedFormat, FloatType } from 'three';
+const TEXTURE_TILE_DIM = 256;
+const TEXTURE_TILE_SIZE = TEXTURE_TILE_DIM * TEXTURE_TILE_DIM;
+const textureLoader = new TextureLoader();
+function checkResponse(response) {
+  if (!response.ok) {
+    const error = new Error(`Error loading ${response.url}: status ${response.status}`);
+    error.response = response;
+    throw error;
+  }
+}
+const arrayBuffer = function (url) {
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return fetch(url, options).then(response => {
+    checkResponse(response);
+    return response.arrayBuffer();
+  });
+};
+
+/**
+ * Utilitary to fetch resources from a server using the [fetch API](
+ * https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch).
+ *
+ * @module Fetcher
+ */
+export 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.
+   */
+  text(url) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    return fetch(url, options).then(response => {
+      checkResponse(response);
+      return response.text();
+    });
+  },
+  /**
+   * 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.
+   */
+  json(url) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    return fetch(url, options).then(response => {
+      checkResponse(response);
+      return response.json();
+    });
+  },
+  /**
+   * 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.
+   */
+  xml(url) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    return fetch(url, options).then(response => {
+      checkResponse(response);
+      return response.text();
+    }).then(text => new window.DOMParser().parseFromString(text, 'text/xml'));
+  },
+  /**
+   * 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).
+   */
+  texture(url) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    let res;
+    let rej;
+    textureLoader.crossOrigin = options.crossOrigin;
+    const promise = new Promise((resolve, reject) => {
+      res = resolve;
+      rej = reject;
+    });
+    textureLoader.load(url, res, () => {}, event => {
+      const error = new Error(`Failed to load texture from URL: \`${url}\``);
+      error.originalEvent = event;
+      rej(error);
+    });
+    return promise;
+  },
+  /**
+   * Wrapper over fetch to get some ArrayBuffer.
+   *
+   * @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<ArrayBuffer>} Promise containing the ArrayBuffer.
+   */
+  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.
+   */
+  textureFloat(url) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    return arrayBuffer(url, options).then(buffer => {
+      if (buffer.byteLength !== TEXTURE_TILE_SIZE * Float32Array.BYTES_PER_ELEMENT) {
+        throw new Error(`Invalid float data from URL: \`${url}\``);
+      }
+      const data = new Float32Array(buffer);
+      const texture = new DataTexture(data, TEXTURE_TILE_DIM, TEXTURE_TILE_DIM, RedFormat, FloatType);
+      texture.internalFormat = 'R32F';
+      texture.needsUpdate = true;
+      return texture;
+    });
+  },
+  /**
+   * 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
+   *     };
+   * });
+   */
+  multiple(baseUrl, extensions) {
+    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    const promises = [];
+    let url;
+    for (const fetchType in extensions) {
+      if (!this[fetchType]) {
+        throw new Error(`${fetchType} is not a valid Fetcher method.`);
+      } else {
+        for (const extension of extensions[fetchType]) {
+          url = `${baseUrl}.${extension}`;
+          promises.push(this[fetchType](url, options).then(result => ({
+            type: extension,
+            result
+          })));
+        }
+      }
+    }
+    return Promise.all(promises).then(result => {
+      const all = {};
+      for (const res of result) {
+        all[res.type] = res.result;
+      }
+      return Promise.resolve(all);
+    });
+  },
+  get() {
+    let format = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+    const [type, subtype] = format.split('/');
+    switch (type) {
+      case 'application':
+        switch (subtype) {
+          case 'geo+json':
+          case 'json':
+            return this.json;
+          case 'kml':
+          case 'gpx':
+            return this.xml;
+          case 'x-protobuf;type=mapbox-vector':
+          case 'gtx':
+            return this.arrayBuffer;
+          case 'isg':
+          case 'gdf':
+          default:
+            return this.text;
+        }
+      case 'image':
+        switch (subtype) {
+          case 'x-bil;bits=32':
+            return this.textureFloat;
+          default:
+            return this.texture;
+        }
+      default:
+        return this.texture;
+    }
+  }
+};

package/lib/Provider/PointCloudProvider.js

@@ -0,0 +1,45 @@
+import * as THREE from 'three';
+import { Extent } from '@itowns/geographic';
+let nextuuid = 1;
+function addPickingAttribute(points) {
+  // generate unique id for picking
+  const numPoints = points.geometry.attributes.position.count;
+  const ids = new Uint8Array(4 * numPoints);
+  const baseId = nextuuid++;
+  if (numPoints > 0xffff || baseId > 0xffff) {
+    // TODO: fixme
+    console.warn('Currently picking is limited to Points with less than 65535 elements and less than 65535 Points instances');
+    return points;
+  }
+  for (let i = 0; i < numPoints; i++) {
+    // todo numpoints > 16bits
+    const v = baseId << 16 | i;
+    ids[4 * i + 0] = (v & 0xff000000) >> 24;
+    ids[4 * i + 1] = (v & 0x00ff0000) >> 16;
+    ids[4 * i + 2] = (v & 0x0000ff00) >> 8;
+    ids[4 * i + 3] = (v & 0x000000ff) >> 0;
+  }
+  points.baseId = baseId;
+  points.geometry.setAttribute('unique_id', new THREE.BufferAttribute(ids, 4, true));
+  return points;
+}
+export default {
+  executeCommand(command) {
+    const layer = command.layer;
+    const node = command.requester;
+    return node.load().then(geometry => {
+      const points = new THREE.Points(geometry, layer.material);
+      addPickingAttribute(points);
+      points.frustumCulled = false;
+      points.matrixAutoUpdate = false;
+      points.position.copy(geometry.userData.origin || node.bbox.min);
+      points.scale.copy(layer.scale);
+      points.updateMatrix();
+      points.tightbbox = geometry.boundingBox.applyMatrix4(points.matrix);
+      points.layer = layer;
+      points.extent = Extent.fromBox3(command.view.referenceCrs, node.bbox);
+      points.userData.node = node;
+      return points;
+    });
+  }
+};

package/lib/Provider/TileProvider.js

@@ -0,0 +1,16 @@
+import CancelledCommandException from "../Core/Scheduler/CancelledCommandException.js";
+export default {
+  executeCommand(command) {
+    const promises = [];
+    const layer = command.layer;
+    const requester = command.requester;
+    const extentsSource = command.extentsSource;
+    if (requester && !requester.material) {
+      return Promise.reject(new CancelledCommandException(command));
+    }
+    for (const extent of extentsSource) {
+      promises.push(layer.convert(requester, extent));
+    }
+    return Promise.all(promises);
+  }
+};

package/lib/Provider/URLBuilder.js

@@ -0,0 +1,116 @@
+let subDomainsCount = 0;
+
+/**
+ * @param {string} url
+ * @returns {string}
+ */
+function subDomains(url) {
+  const subDomainsPtrn = /\$\{u:([\w-_.|]+)\}/.exec(url);
+  if (!subDomainsPtrn) {
+    return url;
+  }
+  const subDomainsList = subDomainsPtrn[1].split('|');
+  return url.replace(subDomainsPtrn[0], subDomainsList[subDomainsCount++ % subDomainsList.length]);
+}
+
+/**
+ * This module performs basic operations around urls, to replace some elements
+ * in it by coordinates or other things.
+ *
+ * In an url, it is also possible to specify subdomains alternatives using the
+ * `${u:a|b|c}` pattern, by separating differents options using `|`. It will go
+ * through the following alternative each time (no random). For example
+ * `https://${u:xyz.org|yzx.org|zxy.org}/${z}/${x}/${y}.png` or
+ * `https://${u:a|b|c}.tile.openstreetmap.org/${z}/${x}/${y}.png`.
+ *
+ * @module URLBuilder
+ */
+export default {
+  subDomains,
+  /**
+   * Builds an URL knowing the coordinates and the source to query.
+   * <br><br>
+   * The source object needs to have an url property, which should have some
+   * specific strings that will be replaced by coordinates.
+   * <ul>
+   * <li>`${x}` or `%COL` will be replaced by `coords.col`</li>
+   * <li>`${y}` or `%ROW` will be replaced by `coords.row`</li>
+   * <li>`${z}` or `%TILEMATRIX` will be replaced by `coords.zoom`</li>
+   * </ul>
+   *
+   * @example
+   * coords = new Extent(CRS.formatToTms('EPSG:4326'), 12, 1410, 2072);
+   * source.url = 'http://server.geo/wmts/SERVICE=WMTS&TILEMATRIX=%TILEMATRIX&TILEROW=%ROW&TILECOL=%COL';
+   * url = URLBuilder.xyz(coords, source);
+   *
+   * // The resulting url is:
+   * // http://server.geo/wmts/SERVICE=WMTS&TILEMATRIX=12&TILEROW=1410&TILECOL=2072;
+   *
+   * @example
+   * coords = new Extent('TMS', 15, 2142, 3412);
+   * source.url = 'http://server.geo/tms/${z}/${y}/${x}.jpg';
+   * url = URLBuilder.xyz(coords, source);
+   *
+   * // The resulting url is:
+   * // http://server.geo/tms/15/2142/3412.jpg;
+   *
+   * @param {Object} coords - tile coordinates
+   * @param {number} coords.row - tile row
+   * @param {number} coords.col - tile column
+   * @param {number} coords.zoom - tile zoom
+   * @param {Object} source
+   * @param {string} source.url
+   * @param {Function} source.tileMatrixCallback
+   *
+   * @return {string} the formed url
+   */
+  xyz: function (coords, source) {
+    return subDomains(source.url.replace(/(\$\{z\}|%TILEMATRIX)/, source.tileMatrixCallback(coords.zoom)).replace(/(\$\{y\}|%ROW)/, coords.row).replace(/(\$\{x\}|%COL)/, coords.col));
+  },
+  /**
+   * Builds an URL knowing the bounding box and the source to query.
+   * <br><br>
+   * The source object needs to have an url property, which should have the
+   * string `%bbox` in it. This string will be replaced by the four cardinal
+   * points composing the bounding box.
+   * <br><br>
+   * Order of the points can be specified in the `axisOrder` property in
+   * source, using the letters `w, s, e, n` respectively for `WEST, SOUTH,
+   * EAST, NORTH`. The default order is `wsen`.
+   *
+   * @example
+   * extent = new Extent('EPSG:4326', 12, 14, 35, 46);
+   * source.crs = 'EPSG:4326';
+   * source.url = 'http://server.geo/wms/BBOX=%bbox&FORMAT=jpg&SERVICE=WMS';
+   * url = URLBuilder.bbox(extent, source);
+   *
+   * // The resulting url is:
+   * // http://server.geo/wms/BBOX=12,35,14,46&FORMAT=jpg&SERVICE=WMS
+   *
+   * @param {Object} bbox - the bounding box
+   * @param {number} bbox.west
+   * @param {number} bbox.south
+   * @param {number} bbox.east
+   * @param {number} bbox.north
+   * @param {Object} source - the source of data
+   * @param {string} source.crs
+   * @param {number} source.bboxDigits
+   * @param {string} source.url
+   * @param {string} source.axisOrder
+   *
+   * @return {string} the formed url
+   */
+  bbox: function (bbox, source) {
+    let precision = source.crs == 'EPSG:4326' ? 9 : 2;
+    if (source.bboxDigits !== undefined) {
+      precision = source.bboxDigits;
+    }
+    const w = bbox.west.toFixed(precision);
+    const s = bbox.south.toFixed(precision);
+    const e = bbox.east.toFixed(precision);
+    const n = bbox.north.toFixed(precision);
+    let bboxInUnit = source.axisOrder || 'wsen';
+    bboxInUnit = bboxInUnit.replace('w', `${w},`).replace('s', `${s},`).replace('e', `${e},`).replace('n', `${n},`).slice(0, -1);
+    return subDomains(source.url.replace('%bbox', bboxInUnit));
+  }
+};

package/lib/Renderer/Camera.js

@@ -0,0 +1,281 @@
+import * as THREE from 'three';
+import { Coordinates } from '@itowns/geographic';
+import DEMUtils from "../Utils/DEMUtils.js";
+
+/**
+ * @typedef     {object}    Camera~CAMERA_TYPE
+ * Stores the different types of camera usable in iTowns.
+ *
+ * @property    {number}    PERSPECTIVE     Perspective type of camera
+ * @property    {number}    ORTHOGRAPHIC    Orthographic type of camera
+ */
+export const CAMERA_TYPE = {
+  PERSPECTIVE: 0,
+  ORTHOGRAPHIC: 1
+};
+const tmp = {
+  frustum: new THREE.Frustum(),
+  matrix: new THREE.Matrix4(),
+  box3: new THREE.Box3()
+};
+const ndcBox3 = new THREE.Box3(new THREE.Vector3(-1, -1, -1), new THREE.Vector3(1, 1, 1));
+function updatePreSse(camera, height, fov) {
+  // sse = projected geometric error on screen plane from distance
+  // We're using an approximation, assuming that the geometric error of all
+  // objects is perpendicular to the camera view vector (= we always compute
+  // for worst case).
+  //
+  //            screen plane             object
+  //               |                         __
+  //               |                        /  \
+  //               |             geometric{|
+  //  < fov angle  . } sse          error {|    |
+  //               |                        \__/
+  //               |
+  //               |<--------------------->
+  //               |        distance
+  //
+  //              geometric_error * screen_width      (resp. screen_height)
+  //     =  ---------------------------------------
+  //        2 * distance * tan (horizontal_fov / 2)   (resp. vertical_fov)
+  //
+  //
+  // We pre-compute the preSSE (= constant part of the screen space error formula) once here
+
+  // Note: the preSSE for the horizontal FOV is the same value
+  // focal = (this.height * 0.5) / Math.tan(verticalFOV * 0.5);
+  // horizontalFOV = 2 * Math.atan(this.width * 0.5 / focal);
+  // horizontalPreSSE = this.width / (2.0 * Math.tan(horizontalFOV * 0.5)); (1)
+  // => replacing horizontalFOV in Math.tan(horizontalFOV * 0.5)
+  // Math.tan(horizontalFOV * 0.5) = Math.tan(2 * Math.atan(this.width * 0.5 / focal) * 0.5)
+  //                               = Math.tan(Math.atan(this.width * 0.5 / focal))
+  //                               = this.width * 0.5 / focal
+  // => now replacing focal
+  //                               = this.width * 0.5 / (this.height * 0.5) / Math.tan(verticalFOV * 0.5)
+  //                               = Math.tan(verticalFOV * 0.5) * this.width / this.height
+  // => back to (1)
+  // horizontalPreSSE = this.width / (2.0 * Math.tan(verticalFOV * 0.5) * this.width / this.height)
+  //                  = this.height / 2.0 * Math.tan(verticalFOV * 0.5)
+  //                  = verticalPreSSE
+
+  if (camera.camera3D.isOrthographicCamera) {
+    camera._preSSE = height;
+  } else {
+    const verticalFOV = THREE.MathUtils.degToRad(fov);
+    camera._preSSE = height / (2.0 * Math.tan(verticalFOV * 0.5));
+  }
+}
+
+/**
+ * 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.
+ */
+class Camera {
+  #_viewMatrixNeedsUpdate = true;
+  #_viewMatrix = (() => new THREE.Matrix4())();
+
+  /**
+   * @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, width, height) {
+    let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+    this.crs = crs;
+    if (options.isCamera) {
+      console.warn('options.camera parameter is deprecated. Use options.camera.cameraThree to place a custom ' + 'camera as a parameter. See the documentation of Camera.');
+      this.camera3D = options;
+    } else if (options.cameraThree) {
+      this.camera3D = options.cameraThree;
+    } else {
+      switch (options.type) {
+        case CAMERA_TYPE.ORTHOGRAPHIC:
+          this.camera3D = new THREE.OrthographicCamera();
+          break;
+        case CAMERA_TYPE.PERSPECTIVE:
+        default:
+          this.camera3D = new THREE.PerspectiveCamera(30);
+          break;
+      }
+    }
+    this.camera3D.aspect = this.camera3D.aspect ?? 1;
+    this.width = width;
+    this.height = height;
+    this.resize(width, height);
+    this._preSSE = Infinity;
+    if (this.camera3D.isPerspectiveCamera) {
+      let fov = this.camera3D.fov;
+      Object.defineProperty(this.camera3D, 'fov', {
+        get: () => fov,
+        set: newFov => {
+          fov = newFov;
+          updatePreSse(this, this.height, fov);
+        }
+      });
+    }
+  }
+
+  /**
+   * 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, height) {
+    if (!width || width <= 0 || !height || height <= 0) {
+      console.warn(`Trying to resize the Camera with invalid height (${height}) or width (${width}). Skipping resize.`);
+      return;
+    }
+    const ratio = width / height;
+    if (this.camera3D.aspect !== ratio) {
+      if (this.camera3D.isOrthographicCamera) {
+        this.camera3D.zoom *= this.width / width;
+        const halfH = this.camera3D.top * this.camera3D.aspect / ratio;
+        this.camera3D.bottom = -halfH;
+        this.camera3D.top = halfH;
+      } else if (this.camera3D.isPerspectiveCamera) {
+        this.camera3D.fov = 2 * THREE.MathUtils.radToDeg(Math.atan(height / this.height * Math.tan(THREE.MathUtils.degToRad(this.camera3D.fov) / 2)));
+      }
+      this.camera3D.aspect = ratio;
+    }
+    this.width = width;
+    this.height = height;
+    updatePreSse(this, this.height, this.camera3D.fov);
+    if (this.camera3D.updateProjectionMatrix) {
+      this.camera3D.updateProjectionMatrix();
+      this.#_viewMatrixNeedsUpdate = true;
+    }
+  }
+  update() {
+    // update matrix
+    this.camera3D.updateMatrixWorld();
+    this.#_viewMatrixNeedsUpdate = true;
+  }
+
+  /**
+   * 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) {
+    return new Coordinates(this.crs).setFromVector3(this.camera3D.position).as(crs || this.crs);
+  }
+
+  /**
+   * 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) {
+    this.camera3D.position.copy(position.as(this.crs));
+  }
+  isBox3Visible(box3, matrixWorld) {
+    return this.box3SizeOnScreen(box3, matrixWorld).intersectsBox(ndcBox3);
+  }
+  isSphereVisible(sphere, matrixWorld) {
+    if (this.#_viewMatrixNeedsUpdate) {
+      // update visibility testing matrix
+      this.#_viewMatrix.multiplyMatrices(this.camera3D.projectionMatrix, this.camera3D.matrixWorldInverse);
+      this.#_viewMatrixNeedsUpdate = false;
+    }
+    if (matrixWorld) {
+      tmp.matrix.multiplyMatrices(this.#_viewMatrix, matrixWorld);
+      tmp.frustum.setFromProjectionMatrix(tmp.matrix);
+    } else {
+      tmp.frustum.setFromProjectionMatrix(this.#_viewMatrix);
+    }
+    return tmp.frustum.intersectsSphere(sphere);
+  }
+  box3SizeOnScreen(box3, matrixWorld) {
+    const pts = projectBox3PointsInCameraSpace(this, box3, matrixWorld);
+
+    // All points are in front of the near plane -> box3 is invisible
+    if (!pts) {
+      return tmp.box3.makeEmpty();
+    }
+
+    // Project points on screen
+    for (let i = 0; i < 8; i++) {
+      pts[i].applyMatrix4(this.camera3D.projectionMatrix);
+    }
+    return tmp.box3.setFromPoints(pts);
+  }
+
+  /**
+   * 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, elevationLayer, minDistanceCollision) {
+    // We put the camera location in geographic by default to easily handle altitude.
+    // (Should be improved in Coordinates class for all ref)
+    const camLocation = view.camera.position().as('EPSG:4326');
+    if (elevationLayer !== undefined) {
+      const elevationUnderCamera = DEMUtils.getElevationValueAt(elevationLayer, camLocation);
+      if (elevationUnderCamera !== undefined) {
+        const difElevation = camLocation.altitude - (elevationUnderCamera + minDistanceCollision);
+        // We move the camera to avoid collision if too close to terrain
+        if (difElevation < 0) {
+          camLocation.altitude = elevationUnderCamera + minDistanceCollision;
+          view.camera3D.position.copy(camLocation.as(view.referenceCrs));
+          view.notifyChange(this.camera3D);
+        }
+      }
+    }
+  }
+}
+const points = [new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3()];
+function projectBox3PointsInCameraSpace(camera, box3, matrixWorld) {
+  // Projects points in camera space
+  // We don't project directly on screen to avoid artifacts when projecting
+  // points behind the near plane.
+  let m = camera.camera3D.matrixWorldInverse;
+  if (matrixWorld) {
+    m = tmp.matrix.multiplyMatrices(camera.camera3D.matrixWorldInverse, matrixWorld);
+  }
+  points[0].set(box3.min.x, box3.min.y, box3.min.z).applyMatrix4(m);
+  points[1].set(box3.min.x, box3.min.y, box3.max.z).applyMatrix4(m);
+  points[2].set(box3.min.x, box3.max.y, box3.min.z).applyMatrix4(m);
+  points[3].set(box3.min.x, box3.max.y, box3.max.z).applyMatrix4(m);
+  points[4].set(box3.max.x, box3.min.y, box3.min.z).applyMatrix4(m);
+  points[5].set(box3.max.x, box3.min.y, box3.max.z).applyMatrix4(m);
+  points[6].set(box3.max.x, box3.max.y, box3.min.z).applyMatrix4(m);
+  points[7].set(box3.max.x, box3.max.y, box3.max.z).applyMatrix4(m);
+
+  // In camera space objects are along the -Z axis
+  // So if min.z is > -near, the object is invisible
+  let atLeastOneInFrontOfNearPlane = false;
+  for (let i = 0; i < 8; i++) {
+    if (points[i].z <= -camera.camera3D.near) {
+      atLeastOneInFrontOfNearPlane = true;
+    } else {
+      // Clamp to near plane
+      points[i].z = -camera.camera3D.near;
+    }
+  }
+  return atLeastOneInFrontOfNearPlane ? points : undefined;
+}
+export default Camera;