itowns 2.44.3-next.8 → 2.45.0

package/lib/Parser/B3dmParser.js

@@ -1,174 +0,0 @@
-import * as THREE from 'three';
-import C3DTBatchTable from "../Core/3DTiles/C3DTBatchTable.js";
-import Capabilities from "../Core/System/Capabilities.js";
-import { MeshBasicMaterial } from 'three';
-import disposeThreeMaterial from "../Utils/ThreeUtils.js";
-import shaderUtils from "../Renderer/Shader/ShaderUtils.js";
-import ReferLayerProperties from "../Layer/ReferencingLayerProperties.js";
-// A bit weird but temporary until we remove this deprecated parser. Mainly to benefit from the enableDracoLoader and enableKtx2Loader
-// methods.
-import { itownsGLTFLoader } from "../Layer/OGC3DTilesLayer.js";
-const matrixChangeUpVectorYtoZ = new THREE.Matrix4().makeRotationX(Math.PI / 2);
-const matrixChangeUpVectorXtoZ = new THREE.Matrix4().makeRotationZ(-Math.PI / 2);
-const utf8Decoder = new TextDecoder();
-
-/**
- * 3D Tiles pre-1.0 contain not standardized and specific uniforms that we filter out to avoid shader compilation errors
- * This method is passed to scene.traverse and applied to all 3D objects of the loaded gltf.
- * @param {THREE.Object3D} obj - 3D object of the gltf hierarchy
- */
-function filterUnsupportedSemantics(obj) {
-  // see GLTFLoader GLTFShader.prototype.update function
-  const supported = ['MODELVIEW', 'MODELVIEWINVERSETRANSPOSE', 'PROJECTION', 'JOINTMATRIX'];
-  if (obj.gltfShader) {
-    const names = [];
-    // eslint-disable-next-line guard-for-in
-    for (const name in obj.gltfShader.boundUniforms) {
-      names.push(name);
-    }
-    for (const name of names) {
-      const semantic = obj.gltfShader.boundUniforms[name].semantic;
-      if (!supported.includes(semantic)) {
-        delete obj.gltfShader.boundUniforms[name];
-      }
-    }
-  }
-}
-
-/**
- * Transforms loaded gltf model to z-up (either from y-up or from the up axis defined in gltfUpAxis). Note that
- * gltfUpAxis was an attribut of pre-1.0 3D Tiles and is now deprecated.
- * @param {THREE.Object3D} gltfScene - the parsed glTF scene
- * @param {String} gltfUpAxis - the gltfUpAxis parameter
- */
-function transformToZUp(gltfScene, gltfUpAxis) {
-  if (!gltfUpAxis || gltfUpAxis === 'Y') {
-    gltfScene.applyMatrix4(matrixChangeUpVectorYtoZ);
-  } else if (gltfUpAxis === 'X') {
-    gltfScene.applyMatrix4(matrixChangeUpVectorXtoZ);
-  }
-}
-
-/**
- * @module B3dmParser
- */
-
-export default {
-  /** Parse b3dm buffer and extract THREE.Scene and batch table
-   * @param {ArrayBuffer} buffer - the b3dm buffer.
-   * @param {Object} options - additional properties.
-   * @param {string=} [options.gltfUpAxis='Y'] - embedded glTF model up axis.
-   * @param {string} options.urlBase - the base url of the b3dm file (used to fetch textures for the embedded glTF model).
-   * @param {boolean=} [options.doNotPatchMaterial=false] - disable patching material with logarithmic depth buffer support.
-   * @param {float} [options.opacity=1.0] - the b3dm opacity.
-   * @param {boolean=} [options.frustumCulled=false] - enable frustum culling.
-   * @param {boolean|Material=} [options.overrideMaterials=false] - override b3dm's embedded glTF materials. If
-   * true, a threejs [MeshBasicMaterial](https://threejs.org/docs/index.html?q=meshbasic#api/en/materials/MeshBasicMaterial)
-   * is set up. config.overrideMaterials can also be a threejs [Material](https://threejs.org/docs/index.html?q=material#api/en/materials/Material)
-   * in which case it will be the material used to override.
-   * @return {Promise} - a promise that resolves with an object containig a THREE.Scene (gltf) and a batch table (batchTable).
-   *
-   */
-  parse(buffer, options) {
-    const frustumCulled = options.frustumCulled === true;
-    if (!buffer) {
-      throw new Error('No array buffer provided.');
-    }
-    const view = new DataView(buffer, 4); // starts after magic
-
-    let byteOffset = 0;
-    const b3dmHeader = {};
-
-    // Magic type is unsigned char [4]
-    const magicNumberByteLength = 4;
-    b3dmHeader.magic = utf8Decoder.decode(new Uint8Array(buffer, 0, magicNumberByteLength));
-    if (b3dmHeader.magic) {
-      // Version, byteLength, batchTableJSONByteLength, batchTableBinaryByteLength and batchTable types are uint32
-      b3dmHeader.version = view.getUint32(byteOffset, true);
-      byteOffset += Uint32Array.BYTES_PER_ELEMENT;
-      b3dmHeader.byteLength = view.getUint32(byteOffset, true);
-      byteOffset += Uint32Array.BYTES_PER_ELEMENT;
-      b3dmHeader.FTJSONLength = view.getUint32(byteOffset, true);
-      byteOffset += Uint32Array.BYTES_PER_ELEMENT;
-      b3dmHeader.FTBinaryLength = view.getUint32(byteOffset, true);
-      byteOffset += Uint32Array.BYTES_PER_ELEMENT;
-      b3dmHeader.BTJSONLength = view.getUint32(byteOffset, true);
-      byteOffset += Uint32Array.BYTES_PER_ELEMENT;
-      b3dmHeader.BTBinaryLength = view.getUint32(byteOffset, true);
-      byteOffset += Uint32Array.BYTES_PER_ELEMENT;
-      const headerByteLength = byteOffset + magicNumberByteLength;
-      const promises = [];
-      let FTJSON = {};
-      const FT_RTC = new THREE.Vector3();
-      if (b3dmHeader.FTJSONLength > 0) {
-        const sizeBegin = headerByteLength;
-        const jsonBuffer = buffer.slice(sizeBegin, b3dmHeader.FTJSONLength + sizeBegin);
-        const content = utf8Decoder.decode(new Uint8Array(jsonBuffer));
-        FTJSON = JSON.parse(content);
-        if (FTJSON.RTC_CENTER) {
-          FT_RTC.fromArray(FTJSON.RTC_CENTER);
-        } else {
-          FT_RTC.set(0, 0, 0);
-        }
-      }
-      if (b3dmHeader.FTBinaryLength > 0) {
-        console.warn('3D Tiles feature table binary not supported yet.');
-      }
-
-      // Parse batch table
-      if (b3dmHeader.BTJSONLength > 0) {
-        // sizeBegin is an index to the beginning of the batch table
-        const sizeBegin = headerByteLength + b3dmHeader.FTJSONLength + b3dmHeader.FTBinaryLength;
-        const BTBuffer = buffer.slice(sizeBegin, sizeBegin + b3dmHeader.BTJSONLength + b3dmHeader.BTBinaryLength);
-        promises.push(Promise.resolve(new C3DTBatchTable(BTBuffer, b3dmHeader.BTJSONLength, b3dmHeader.BTBinaryLength, FTJSON.BATCH_LENGTH, options.registeredExtensions)));
-      } else {
-        promises.push(Promise.resolve(new C3DTBatchTable()));
-      }
-      const posGltf = headerByteLength + b3dmHeader.FTJSONLength + b3dmHeader.FTBinaryLength + b3dmHeader.BTJSONLength + b3dmHeader.BTBinaryLength;
-      const gltfBuffer = buffer.slice(posGltf);
-      const init_mesh = function (mesh) {
-        mesh.frustumCulled = frustumCulled;
-        if (mesh.material) {
-          if (options.overrideMaterials) {
-            const oldMat = mesh.material;
-            // Set up new material
-            if (typeof options.overrideMaterials === 'object' && options.overrideMaterials.isMaterial) {
-              mesh.material = options.overrideMaterials;
-            } else {
-              mesh.material = new MeshBasicMaterial();
-            }
-            disposeThreeMaterial(oldMat);
-          } else if (Capabilities.isLogDepthBufferSupported() && mesh.material.isRawShaderMaterial && !options.doNotPatchMaterial) {
-            shaderUtils.patchMaterialForLogDepthSupport(mesh.material);
-            console.warn('glTF shader has been patched to add log depth buffer support');
-          }
-          ReferLayerProperties(mesh.material, options.layer);
-        }
-      };
-      promises.push(itownsGLTFLoader.parseAsync(gltfBuffer, options).then(gltf => {
-        for (const scene of gltf.scenes) {
-          scene.traverse(filterUnsupportedSemantics);
-        }
-        transformToZUp(gltf.scene, options.gltfUpAxis);
-        const shouldBePatchedForLogDepthSupport = Capabilities.isLogDepthBufferSupported() && !options.doNotPatchMaterial;
-        if (options.frustumCulling === false || options.overrideMaterials || shouldBePatchedForLogDepthSupport || options.layer) {
-          gltf.scene.traverse(init_mesh);
-        }
-
-        // Apply relative center from Feature table.
-        gltf.scene.position.copy(FT_RTC);
-        return gltf;
-      }).catch(e => {
-        throw new Error(e);
-      }));
-      return Promise.all(promises).then(values => ({
-        gltf: values[1],
-        batchTable: values[0]
-      })).catch(e => {
-        throw new Error(e);
-      });
-    } else {
-      throw new Error('Invalid b3dm file.');
-    }
-  }
-};

package/lib/Parser/CameraCalibrationParser.js

@@ -1,94 +0,0 @@
-import * as THREE from 'three';
-import OrientedImageCamera from "../Renderer/OrientedImageCamera.js";
-
-/**
- * The CameraCalibrationParser module provide a [parse]{@link module:CameraCalibrationParser.parse}
- * method that takes a JSON array of camera calibrations in and yields an array of {@link OrientedImageCamera}
- *
- * @module CameraCalibrationParser
- */
-
-const textureLoader = new THREE.TextureLoader();
-const matrix3 = new THREE.Matrix3();
-
-// the json format encodes the following transformation:
-// extrinsics: p_local = rotation * (p_world - position)
-// intrinsics: p_pixel = projection * p_local
-// distortion: p_raw = distortion(p_pixel)
-function parseCalibration(calibration) {
-  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  const useMask = options.useMask == undefined ? true : options.useMask;
-  const imageYDown = options.imageYDown == undefined ? true : options.imageYDown;
-  // parse intrinsics
-  const proj = calibration.projection;
-  const size = new THREE.Vector2().fromArray(calibration.size);
-  const focal = new THREE.Vector2(proj[0], proj[4]);
-  // Center of image,  convention in digital image is Y dow
-  // To transform image space to webGl texture. It could inverse Y axis.
-  const center = new THREE.Vector2(proj[2], imageYDown ? size.y - proj[5] : proj[5]);
-  const skew = proj[1];
-  const camera = new OrientedImageCamera(size, focal, center, options.near, options.far, skew);
-
-  // parse extrinsics: Object3d.matrix is from local to world
-  // p_world = position + transpose(rotation) * p_local
-  camera.position.fromArray(calibration.position);
-  // calibration.rotation is row-major but fromArray expects a column-major array, yielding the transposed matrix
-  const rotationInverse = matrix3.fromArray(calibration.rotation);
-  camera.matrix.setFromMatrix3(rotationInverse);
-  camera.quaternion.setFromRotationMatrix(camera.matrix);
-
-  // local axes for cameras is (X right, Y up, Z back) rather than (X right, Y down, Z front)
-  camera.rotateX(Math.PI);
-  if (calibration.distortion) {
-    camera.distortion.setFromMicmacCalibration(calibration.distortion, imageYDown);
-  }
-  camera.maskPath = calibration.mask;
-  camera.name = calibration.id;
-  let resolve;
-  const deferred = new Promise(r => {
-    resolve = r;
-  });
-  if (useMask && camera.maskPath) {
-    textureLoader.load(camera.maskPath, mask => {
-      camera.maskTexture = mask;
-      resolve(camera);
-    });
-  } else {
-    resolve(camera);
-  }
-  return deferred;
-}
-export default {
-  /**
-   * Description of a camera calibration in a JSON file.
-   *
-   * @typedef CameraCalibrationJson
-   * @type {Object}
-   *
-   * @property {number[]} projection - projection matrix,
-   * @property {number[]} size - image size in pixel.
-   * @property {number[]} position - position of the camera.
-   * @property {number[]} rotation - rotation matrix
-   * @property {Object} [distorsion={}] - distorsion
-   * @property {number[]} [distorsion.pps]
-   * @property {number[]} [distorsion.poly357]
-   * @property {number[]} [distorsion.limit]
-   * @property {number[]} [distorsion.l1l2]
-   * @property {number[]} [distorsion.etat]
-   */
-  /**
-   * Parser a JSON array of camera calibrations and return an array of {@link OrientedImageCamera}.
-   * @param {string|JSON} json - the json content of the calibration file.
-   * @param {Object} [options={}] - Options controlling the parsing.
-   * @param {string} [options.near=0.1] - Near of the created cameras. Default value comes from created {@link OrientedImageCamera}
-   * @param {string} [options.far=1000] - Far of the created cameras. Default value comes from created {@link OrientedImageCamera}
-   * @return {Promise} - A promise resolving with an array of {@link OrientedImageCamera}.
-   */
-  parse(json) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    if (typeof json === 'string') {
-      json = JSON.parse(json);
-    }
-    return Promise.all(json.map(calibration => parseCalibration(calibration, options)));
-  }
-};

package/lib/Parser/GDFParser.js

@@ -1,72 +0,0 @@
-import * as THREE from 'three';
-import GeoidGrid from "../Core/Geographic/GeoidGrid.js";
-import Extent from "../Core/Geographic/Extent.js";
-import { BYTES_PER_DOUBLE } from "./GTXParser.js";
-export function getHeaderAttribute(header, attributeName) {
-  const attributeRow = header[header.indexOf(header.find(element => element.includes(attributeName)))].split(' ').filter(value => value !== '');
-  return parseFloat(attributeRow[attributeRow.length - 1]);
-}
-
-/**
- * The `GDFParser` module provides a `[parse]{@link module:GDFParser.parse}` method. This method takes the content of a
- * GDF file in, and returns a `{@link GeoidGrid}`. the `{@link GeoidGrid}` contains all the necessary attributes and
- * methods to access the GDF data in iTowns.
- *
- * @module GDFParser
- */
-export default {
-  /**
-   * Parses a GDF file content and returns a corresponding {@link GeoidGrid}.
-   *
-   * @param   {string}    gdf                             The content of the GDF file to parse.
-   * @param   {Object}    options                         An object gathering the optional parameters to pass to
-                                                          * the parser.
-   * @param   {Object}    [options.in={}]                 Information on the GDF data.
-   * @param   {string}    [options.in.crs='EPSG:4326']    The Coordinates Reference System (CRS) of the GDF data.
-                                                          * It must be a geographic CRS, and must be given as an EPSG
-                                                          * code.
-   *
-   * @returns {Promise<GeoidGrid>}    A promise resolving with a {@link GeoidGrid}, which contains all the necessary
-                                      * attributes and methods to access GDF file data.
-   */
-  parse(gdf) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
-      in: {}
-    };
-    const rows = gdf.split('\n');
-    const firstMeasureLine = rows.indexOf(rows.find(row => row.includes('end_of_head'))) + 1;
-    const rawHeaderData = rows.slice(0, firstMeasureLine);
-
-    // ---------- GET METADATA FROM THE FILE : ----------
-
-    const metadata = {
-      minX: getHeaderAttribute(rawHeaderData, 'longlimit_west'),
-      maxX: getHeaderAttribute(rawHeaderData, 'longlimit_east'),
-      minY: getHeaderAttribute(rawHeaderData, 'latlimit_south'),
-      maxY: getHeaderAttribute(rawHeaderData, 'latlimit_north'),
-      stepX: getHeaderAttribute(rawHeaderData, 'gridstep'),
-      stepY: getHeaderAttribute(rawHeaderData, 'gridstep'),
-      nRows: getHeaderAttribute(rawHeaderData, 'latitude_parallels'),
-      nColumns: getHeaderAttribute(rawHeaderData, 'longitude_parallels')
-    };
-
-    // ---------- BUILD A DATA VIEWER FROM THE TEXT DATA : ----------
-
-    const data = new DataView(new ArrayBuffer(BYTES_PER_DOUBLE * metadata.nRows * metadata.nColumns));
-    let index = 0;
-    for (let row of rows.slice(firstMeasureLine, rows.length)) {
-      row = row.split(' ').filter(value => value !== '');
-      if (!row.length) {
-        continue;
-      }
-      data.setFloat64(index * BYTES_PER_DOUBLE, parseFloat(row[2]));
-      index++;
-    }
-
-    // ---------- CREATE A GeoidGrid FOR THE GIVEN FILE DATA : ----------
-
-    const dataExtent = new Extent(options.in.crs || 'EPSG:4326', metadata.minX, metadata.maxX, metadata.minY, metadata.maxY);
-    const dataStep = new THREE.Vector2(metadata.stepX, metadata.stepY);
-    return Promise.resolve(new GeoidGrid(dataExtent, dataStep, (verticalIndex, horizontalIndex) => data.getFloat64((metadata.nColumns * (metadata.nRows - verticalIndex - 1) + horizontalIndex) * BYTES_PER_DOUBLE)));
-  }
-};

package/lib/Parser/GTXParser.js

@@ -1,75 +0,0 @@
-import * as THREE from 'three';
-import GeoidGrid from "../Core/Geographic/GeoidGrid.js";
-import Extent from "../Core/Geographic/Extent.js";
-export const BYTES_PER_DOUBLE = 8;
-export const BYTES_PER_FLOAT = 4;
-
-/**
- * The `GTXParser` module provides a `[parse]{@link module:GTXParser.parse}` method. This method takes the content of a
- * GTX file in, and returns a {@link GeoidGrid}. The {@link GeoidGrid} contains all the necessary attributes and
- * methods to access the GTX data in iTowns.
- *
- * @module GTXParser
- */
-export default {
-  /**
-   * Parses a GTX file content and returns a corresponding {@link GeoidGrid}.
-   *
-   * @param   {ArrayBuffer}   gtx                             The content of the GTX file to parse.
-   * @param   {Object}        options                         An object gathering the optional parameters to pass to
-                                                              * the parser.
-   * @param   {Object}        [options.in={}]                 Information on the GTX data.
-   * @param   {string}        [options.in.crs='EPSG:4326']    The Coordinates Reference System (CRS) of the GTX data.
-                                                              * It must be a geographic CRS, and must be given as an
-                                                              * EPSG code.
-   * @param   {string}        [options.in.dataType='float']   The encoding of geoid height data within the GTX file.
-                                                              * Must be `'float'` or `'double'`.
-   *
-   * @returns {Promise<GeoidGrid>}    A promise resolving with a {@link GeoidGrid}, which contains all the necessary
-                                      * attributes and methods to access GTX file data.
-   */
-  parse(gtx) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
-      in: {}
-    };
-    const dataType = options.in.dataType || 'float';
-    if (!['float', 'double'].includes(dataType)) {
-      throw new Error('`dataType` parameter is incorrect for GTXParser.parse method. ' + 'This parameter must be either `double` or `float`.');
-    }
-
-    // ---------- GET METADATA FROM THE FILE : ----------
-
-    const headerView = new DataView(gtx, 0, 40);
-    const metadata = {
-      minX: headerView.getFloat64(8),
-      minY: headerView.getFloat64(0),
-      stepX: headerView.getFloat64(24),
-      stepY: headerView.getFloat64(16),
-      nColumns: headerView.getInt32(36),
-      nRows: headerView.getInt32(32)
-    };
-
-    // ---------- BUILD A DATA VIEWER : ----------
-
-    const dataView = new DataView(gtx, 40);
-
-    // ---------- CREATE A GeoidGrid FOR THE GIVEN FILE DATA : ----------
-
-    // formula for the max longitude : maxLongitude = minLongitude + deltaLongitude * (nColumns - 1)
-    const maxX = metadata.minX + metadata.stepX * (metadata.nColumns - 1);
-    // formula for the max latitude : maxLatitude = minLatitude + deltaLatitude * (nRows - 1)
-    const maxY = metadata.minY + metadata.stepY * (metadata.nRows - 1);
-    const dataExtent = new Extent(options.in.crs || 'EPSG:4326', metadata.minX, maxX, metadata.minY, maxY);
-    const dataStep = new THREE.Vector2(metadata.stepX, metadata.stepY);
-    return Promise.resolve(new GeoidGrid(dataExtent, dataStep, (verticalIndex, horizontalIndex) => {
-      // formula to get the index of a geoid height from a latitude and longitude indexes is :
-      // ``(nColumns * latIndex + lonIndex) * nBytes``, where nBytes stands for the number of bytes geoid
-      // height data are encoded on.
-      if (dataType === 'float') {
-        return dataView.getFloat32((metadata.nColumns * verticalIndex + horizontalIndex) * BYTES_PER_FLOAT);
-      } else if (dataType === 'double') {
-        return dataView.getFloat64((metadata.nColumns * verticalIndex + horizontalIndex) * BYTES_PER_DOUBLE);
-      }
-    }));
-  }
-};

package/lib/Parser/GeoJsonParser.js

@@ -1,212 +0,0 @@
-import Coordinates from "../Core/Geographic/Coordinates.js";
-import { FeatureCollection, FEATURE_TYPES } from "../Core/Feature.js";
-import { deprecatedParsingOptionsToNewOne } from "../Core/Deprecated/Undeprecator.js";
-function readCRS(json) {
-  if (json.crs) {
-    if (json.crs.type.toLowerCase() == 'epsg') {
-      return `EPSG:${json.crs.properties.code}`;
-    } else if (json.crs.type.toLowerCase() == 'name') {
-      if (json.crs.properties.name.toLowerCase().includes('epsg:')) {
-        // OGC CRS URN: urn:ogc:def:crs:authority:version:code => EPSG:[...]:code
-        // legacy identifier: authority:code => EPSG:code
-        const codeStart = json.crs.properties.name.lastIndexOf(':');
-        if (codeStart > 0) {
-          return `EPSG:${json.crs.properties.name.substr(codeStart + 1)}`;
-        }
-      }
-      throw new Error(`Unsupported CRS authority '${json.crs.properties.name}'`);
-    }
-    throw new Error(`Unsupported CRS type '${json.crs}'`);
-  }
-  // assume default crs
-  return 'EPSG:4326';
-}
-const coord = new Coordinates('EPSG:4978', 0, 0, 0);
-const last = new Coordinates('EPSG:4978', 0, 0, 0);
-const first = new Coordinates('EPSG:4978', 0, 0, 0);
-
-// filter with the first point
-const firstPtIsOut = (extent, aCoords, crs) => {
-  coord.crs = crs;
-  coord.setFromArray(aCoords[0]);
-  return !extent.isPointInside(coord);
-};
-const toFeature = {
-  populateGeometry(crsIn, coordinates, geometry, feature) {
-    geometry.startSubGeometry(coordinates.length, feature);
-    coord.crs = crsIn;
-    // coordinates is a list of pair [[x1, y1], [x2, y2], ..., [xn, yn]]
-    // or list of triplet [[x1, y1, z1], [x2, y2, z2], ..., [xn, yn, zn]]
-    for (const triplet of coordinates) {
-      coord.setFromValues(triplet[0], triplet[1], triplet[2]);
-      geometry.pushCoordinates(feature, coord);
-    }
-    geometry.updateExtent();
-  },
-  // compute clockwise polygon
-  populateGeometryWithCCW(crsIn, coordinates, geometry, feature) {
-    geometry.startSubGeometry(coordinates.length, feature);
-    coord.crs = crsIn;
-    let sum = 0;
-    first.setFromValues(coordinates[0][0], coordinates[0][1], coordinates[0][2]);
-    last.copy(first);
-    for (let i = 0; i < coordinates.length; i++) {
-      coord.setFromValues(coordinates[i][0], coordinates[i][1], coordinates[i][2]);
-      sum += (last.x - coord.x) * (last.y + coord.y);
-      last.copy(coord);
-      geometry.pushCoordinates(feature, coord);
-    }
-    sum += (last.x - first.x) * (last.y + first.y);
-    geometry.getLastSubGeometry().ccw = sum < 0;
-    geometry.updateExtent();
-  },
-  point(feature, crsIn, coordsIn, collection, properties) {
-    this.default(feature, crsIn, [coordsIn], collection, properties);
-  },
-  default(feature, crsIn, coordsIn, collection, properties) {
-    if (collection.filterExtent && firstPtIsOut(collection.filterExtent, coordsIn, crsIn)) {
-      return;
-    }
-    const geometry = feature.bindNewGeometry();
-    geometry.properties = properties;
-    this.populateGeometry(crsIn, coordsIn, geometry, feature);
-    feature.updateExtent(geometry);
-  },
-  polygon(feature, crsIn, coordsIn, collection, properties) {
-    // filtering
-    if (collection.filterExtent && firstPtIsOut(collection.filterExtent, coordsIn[0], crsIn)) {
-      return;
-    }
-    const geometry = feature.bindNewGeometry();
-    geometry.properties = properties;
-
-    // Then read contour and holes
-    for (let i = 0; i < coordsIn.length; i++) {
-      this.populateGeometryWithCCW(crsIn, coordsIn[i], geometry, feature);
-    }
-    feature.updateExtent(geometry);
-  },
-  multi(type, feature, crsIn, coordsIn, collection, properties) {
-    for (const coords of coordsIn) {
-      this[type](feature, crsIn, coords, collection, properties);
-    }
-  }
-};
-function coordinatesToFeature(type, feature, crsIn, coordinates, collection, properties) {
-  if (coordinates.length == 0) {
-    return;
-  }
-  switch (type) {
-    case 'point':
-    case 'linestring':
-      return toFeature.default(feature, crsIn, coordinates, collection, properties);
-    case 'multipoint':
-      return toFeature.multi('point', feature, crsIn, coordinates, collection, properties);
-    case 'multilinestring':
-      return toFeature.multi('default', feature, crsIn, coordinates, collection, properties);
-    case 'polygon':
-      return toFeature.polygon(feature, crsIn, coordinates, collection, properties);
-    case 'multipolygon':
-      return toFeature.multi('polygon', feature, crsIn, coordinates, collection, properties);
-    case 'geometrycollection':
-    default:
-      throw new Error(`Unhandled geojson type ${feature.type}`);
-  }
-}
-function toFeatureType(jsonType) {
-  switch (jsonType) {
-    case 'point':
-    case 'multipoint':
-      return FEATURE_TYPES.POINT;
-    case 'linestring':
-    case 'multilinestring':
-      return FEATURE_TYPES.LINE;
-    case 'polygon':
-    case 'multipolygon':
-      return FEATURE_TYPES.POLYGON;
-    case 'geometrycollection':
-    default:
-      throw new Error(`Unhandled geometry type ${jsonType}`);
-  }
-}
-const keyProperties = ['type', 'geometry', 'properties'];
-const firstCoordinates = a => a === undefined || Array.isArray(a) && !isNaN(a[0]) ? a : firstCoordinates(a[0]);
-function jsonFeatureToFeature(crsIn, json, collection) {
-  if (!json.geometry?.type) {
-    console.warn('No geometry provided');
-    return null;
-  }
-  const jsonType = json.geometry.type.toLowerCase();
-  const featureType = toFeatureType(jsonType);
-  const feature = collection.requestFeatureByType(featureType);
-  const coordinates = jsonType != 'point' ? json.geometry.coordinates : [json.geometry.coordinates];
-  const properties = json.properties || {};
-  feature.hasRawElevationData = firstCoordinates(coordinates)?.length === 3;
-
-  // copy other properties
-  for (const key of Object.keys(json)) {
-    if (!keyProperties.includes(key.toLowerCase())) {
-      // create `geojson` key if it does not exist yet
-      properties.geojson = properties.geojson || {};
-      // add key defined property to `geojson` property
-      properties.geojson[key] = json[key];
-    }
-  }
-  coordinatesToFeature(jsonType, feature, crsIn, coordinates, collection, properties);
-  return feature;
-}
-function jsonFeaturesToFeatures(crsIn, jsonFeatures, options) {
-  const collection = new FeatureCollection(options);
-  const filter = options.filter || (() => true);
-  for (const jsonFeature of jsonFeatures) {
-    if (filter(jsonFeature.properties, jsonFeature.geometry)) {
-      jsonFeatureToFeature(crsIn, jsonFeature, collection);
-    }
-  }
-  collection.removeEmptyFeature();
-  collection.updateExtent();
-  return collection;
-}
-
-/**
- * The GeoJsonParser module provide a [parse]{@link module:GeoJsonParser.parse}
- * method that takes a GeoJSON in and gives an object formatted for iTowns
- * containing all necessary informations to display this GeoJSON.
- *
- * @module GeoJsonParser
- */
-export default {
-  /**
-   * Parse a GeoJSON file content and return a {@link FeatureCollection}.
-   *
-   * @param {string} json - The GeoJSON file content to parse.
-   * @param {ParsingOptions} options - Options controlling the parsing.
-    * @return {Promise} A promise resolving with a {@link FeatureCollection}.
-   */
-  parse(json) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    options = deprecatedParsingOptionsToNewOne(options);
-    options.in = options.in || {};
-    const out = options.out;
-    const _in = options.in;
-    if (typeof json === 'string') {
-      json = JSON.parse(json);
-    }
-    _in.crs = _in.crs || readCRS(json);
-    if (out.filteringExtent) {
-      if (typeof out.filteringExtent == 'boolean') {
-        out.filterExtent = options.extent.isExtent ? options.extent.as(_in.crs) : options.extent.toExtent(_in.crs);
-      } else if (out.filteringExtent.isExtent) {
-        out.filterExtent = out.filteringExtent;
-      }
-    }
-    switch (json.type.toLowerCase()) {
-      case 'featurecollection':
-        return Promise.resolve(jsonFeaturesToFeatures(_in.crs, json.features, out));
-      case 'feature':
-        return Promise.resolve(jsonFeaturesToFeatures(_in.crs, [json], out));
-      default:
-        throw new Error(`Unsupported GeoJSON type: '${json.type}`);
-    }
-  }
-};

package/lib/Parser/GpxParser.js

@@ -1,25 +0,0 @@
-import { gpx } from '@tmcw/togeojson';
-import GeoJsonParser from "./GeoJsonParser.js";
-import { deprecatedParsingOptionsToNewOne } from "../Core/Deprecated/Undeprecator.js";
-
-/**
- * The GpxParser module provides a [parse]{@link module:GpxParser.parse}
- * method that takes a GPX in and gives an object formatted for iTowns
- * containing all necessary informations to display this GPX.
- *
- * @module GpxParser
- */
-export default {
-  /**
-   * Parse a GPX file content and return a {@link FeatureCollection}.
-   *
-   * @param {XMLDocument} gpxFile - The GPX file content to parse.
-   * @param {ParsingOptions} options - Options controlling the parsing.
-   *
-   * @return {Promise} A promise resolving with a {@link FeatureCollection}.
-   */
-  parse(gpxFile, options) {
-    options = deprecatedParsingOptionsToNewOne(options);
-    return GeoJsonParser.parse(gpx(gpxFile), options);
-  }
-};