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

package/lib/Source/FileSource.js

@@ -0,0 +1,188 @@
+import Source from "./Source.js";
+import { LRUCache } from 'lru-cache';
+
+/**
+ * An object defining the source of a single resource to get from a direct
+ * access. It inherits from {@link Source}. There is multiple ways of adding a
+ * resource here:
+ * <ul>
+ *  <li>add the file like any other sources, using the `url` property.</li>
+ *  <li>fetch the file, and give the data to the source using the `fetchedData`
+ *  property.</li>
+ *  <li>fetch the file, parse it and git the parsed data to the source using the
+ *  `features` property.</li>
+ * </ul>
+ * See the examples below for real use cases.
+ *
+ * @extends Source
+ *
+ * @property {boolean} isFileSource - Used to checkout whether this source is a
+ * FileSource. Default is true. You should not change this, as it is used
+ * internally for optimisation.
+ * @property {*} fetchedData - Once the file has been loaded, the resulting data
+ * is stored in this property.
+ * @property {*} features - Once the file has been loaded and parsed, the
+ * resulting data is stored in this property.
+ *
+ * @example <caption>Simple: create a source, a layer, and let iTowns taking
+ * care of everything.</caption>
+ * const kmlSource = new itowns.FileSource({
+ *     url: 'https://raw.githubusercontent.com/iTowns/iTowns2-sample-data/master/croquis.kml',
+ *     crs: 'EPSG:4326',
+ *     fetcher: itowns.Fetcher.xml,
+ *     parser: itowns.KMLParser.parse,
+ * });
+ *
+ * const kmlLayer = new itowns.ColorLayer('Kml', {
+ *     name: 'kml',
+ *     transparent: true,
+ *     crs: view.tileLayer.extent.crs,
+ *     source: kmlSource,
+ * });
+ *
+ * view.addLayer(kmlLayer);
+ *
+ * @example <caption>Advanced: fetch some data, create a source, a layer, and
+ * let iTowns do the parsing and converting.</caption>
+ * // Parse and Convert by iTowns
+ * itowns.Fetcher.xml('https://raw.githubusercontent.com/iTowns/iTowns2-sample-data/master/ULTRA2009.gpx')
+ *     .then(function _(gpx) {
+ *         const gpxSource = new itowns.FileSource({
+ *             data: gpx,
+ *             crs: 'EPSG:4326',
+ *             parser: itowns.GpxParser.parse,
+ *         });
+ *
+ *         const gpxLayer = new itowns.ColorLayer('Gpx', {
+ *             name: 'Ultra 2009',
+ *             transparent: true,
+ *             source: gpxSource,
+ *         });
+ *
+ *         return view.addLayer(gpxLayer);
+ *     });
+ *
+ * @example <caption>More advanced: create a layer, fetch some data, parse the
+ * data, append a source to the layer and add the layer to iTowns.</caption>
+ * // Create a layer
+ * const ariege = new itowns.GeometryLayer('ariege', new itowns.THREE.Group());
+ *
+ * // Specify update method and conversion
+ * ariege.update = itowns.FeatureProcessing.update;
+ * ariege.convert = itowns.Feature2Mesh.convert({
+ *     color: () => new itowns.THREE.Color(0xffcc00),
+ *     extrude: () => 5000,
+ * });
+ *
+ * itowns.Fetcher.json('https://raw.githubusercontent.com/gregoiredavid/france-geojson/master/departements/09-ariege/departement-09-ariege.geojson')
+ *     .then(function _(geojson) {
+ *         return itowns.GeoJsonParser.parse(geojson, {
+ *             in: { crs: 'EPSG:4326' },
+ *             out: { crs: view.tileLayer.extent.crs,
+ *                      style: new itowns.Style({
+ *                          fill: {
+ *                              color: new itowns.THREE.Color(0xffcc00),
+ *                              extrusion_height: () => 5000,
+ *                      }),
+ *                  },
+ *             },
+ *         });
+ *     }).then(function _(features) {
+ *         ariege.source = new itowns.FileSource({
+ *             crs: 'EPSG:4326',
+ *             features,
+ *         });
+ *
+ *         return view.addLayer(ariegeLayer);
+ *     });
+ */
+class FileSource extends Source {
+  /**
+   * @param {Object} source - An object that can contain all properties of a
+   * FileSource and {@link Source}. Only `crs` is mandatory, but if it
+   * presents in `features` under the property `crs`, it is fine.
+   */
+  constructor(source) {
+    if (source.parsedData) {
+      console.warn('FileSource parsedData parameter is deprecated, use features instead of.');
+      source.features = source.features || source.parsedData;
+    }
+    if (source.projection) {
+      console.warn('FileSource projection parameter is deprecated, use crs instead.');
+      source.crs = source.crs || source.projection;
+    }
+    if (!source.crs) {
+      if (source.features && source.features.crs) {
+        source.crs = source.features.crs;
+      } else {
+        throw new Error('source.crs is required in FileSource');
+      }
+    }
+    if (!source.url && !source.fetchedData && !source.features) {
+      throw new Error(`url, fetchedData and features are not set in
+                FileSource; at least one needs to be present`);
+    }
+
+    // the fake url is for when we use the fetchedData or features mode
+    source.url = source.url || 'none';
+    super(source);
+    this.isFileSource = true;
+    this.fetchedData = source.fetchedData;
+    if (!this.fetchedData && !source.features) {
+      this.whenReady = this.fetcher(this.urlFromExtent(), this.networkOptions).then(f => {
+        this.fetchedData = f;
+      });
+    } else if (source.features) {
+      this._featuresCaches[source.features.crs] = new LRUCache({
+        max: 500
+      });
+      this._featuresCaches[source.features.crs].set(0, Promise.resolve(source.features));
+    }
+    this.whenReady.then(() => this.fetchedData);
+    this.zoom = {
+      min: 0,
+      max: Infinity
+    };
+  }
+  urlFromExtent() {
+    return this.url;
+  }
+  onLayerAdded(options) {
+    options.in = this;
+    super.onLayerAdded(options);
+    let features = this._featuresCaches[options.out.crs].get(0);
+    if (!features) {
+      options.out.buildExtent = this.crs != 'EPSG:4978';
+      if (options.out.buildExtent) {
+        options.out.forcedExtentCrs = options.out.crs != 'EPSG:4978' ? options.out.crs : this.crs;
+      }
+      features = this.parser(this.fetchedData, options);
+      this._featuresCaches[options.out.crs].set(0, features);
+    }
+    features.then(data => {
+      if (data.extent) {
+        this.extent = data.extent.clone();
+        // Transform local extent to data.crs projection.
+        if (this.extent.crs == data.crs) {
+          this.extent.applyMatrix4(data.matrixWorld);
+        }
+      }
+    });
+  }
+
+  /**
+   * load  data from cache or Fetch/Parse data.
+   * The loaded data is a Feature or Texture.
+   *
+   * @param      {Extent}  extent   extent requested parsed data.
+   * @param      {FeatureBuildingOptions|Layer}  out  The feature returned options
+   * @return     {FeatureCollection|Texture}  The parsed data.
+   */
+  loadData(extent, out) {
+    return this._featuresCaches[out.crs].get(0);
+  }
+  extentInsideLimit(extent) {
+    return this.extent.intersectsExtent(extent);
+  }
+}
+export default FileSource;

package/lib/Source/OGC3DTilesGoogleSource.js

@@ -0,0 +1,29 @@
+import OGC3DTilesSource from "./OGC3DTilesSource.js";
+class OGC3DTilesGoogleSource extends OGC3DTilesSource {
+  /**
+   * An object defining the source connection to a 3D Tiles asset from [Google Tiles API](https://tile.googleapis.com).
+   *
+   * @extends OGC3DTilesSource
+   *
+   * @property {boolean} isOGC3DTilesGoogleSource - Used to check if this source is an OGC3DTilesGoogleSource. Set to true.
+   * You should not change this, as it is used internally for optimisation.
+   * @property {string} url - The URL to the tileset json.
+   * @property {string} baseUrl - The base URL to access tiles.
+   *
+   * @property {boolean} isOGC3DTilesGoogleSource - Used to check if this source is an OGC3DTilesGoogleSource. Set to
+   * true. You should not change this, as it is used internally for optimisation.
+   * @param {Object} source An object that can contain all properties of an OGC3DTilesGoogleSource and {@link Source}.
+   * @param {String} source.key Your google tiles map API access key
+   */
+  constructor(source) {
+    if (!source.key) {
+      throw new Error('[OGC3DTilesGoogleSource]: A API key for the google map tiles API is required');
+    }
+    // URL to the root tileset
+    source.url = `https://tile.googleapis.com/v1/3dtiles/root.json?key=${source.key}`;
+    super(source);
+    this.isOGC3DTilesGoogleSource = true;
+    this.key = source.key;
+  }
+}
+export default OGC3DTilesGoogleSource;

package/lib/Source/OGC3DTilesIonSource.js

@@ -0,0 +1,34 @@
+import OGC3DTilesSource from "./OGC3DTilesSource.js";
+class OGC3DTilesIonSource extends OGC3DTilesSource {
+  /**
+   * An object defining the source connection to a 3DTiles asset of a [Cesium ion server](https://cesium.com/learn/ion/).
+   *
+   * @extends Source
+   *
+   * @property {boolean} isOGC3DTilesIonSource - Used to check if this source is an OGC3DTilesIonSource. Set to true.
+   * You should not change this, as it is used internally for optimisation.
+   * @property {string} accessToken - The Cesium ion access token used to retrieve the resource.
+   * @property {string} assetId - The id of the asset on Cesium ion.
+   *
+   * @param {Object} source An object that can contain all properties of an OGC3DTilesIonSource and {@link Source}.
+   * Only `accessToken` and `assetId` are mandatory.
+   * @param {string} source.accessToken - The Cesium ion access token used to retrieve the resource.
+   * @param {string} source.assetId - The id of the asset on Cesium ion.
+   */
+  constructor(source) {
+    if (!source.accessToken) {
+      throw new Error('[OGC3DTilesIonSource]: accessToken is required');
+    }
+    if (!source.assetId) {
+      throw new Error('[OGC3DTilesIonSource]: assetId is required');
+    }
+
+    // Url to query cesium ion the first time to retrieve metadata of the asset with assetId
+    source.url = `https://api.cesium.com/v1/assets/${source.assetId}/endpoint?access_token=${source.accessToken}`;
+    super(source);
+    this.isOGC3DTilesIonSource = true;
+    this.accessToken = source.accessToken;
+    this.assetId = source.assetId;
+  }
+}
+export default OGC3DTilesIonSource;

package/lib/Source/OGC3DTilesSource.js

@@ -0,0 +1,21 @@
+import Source from "./Source.js";
+class OGC3DTilesSource extends Source {
+  /**
+   * An object defining the source connection to a 3DTiles dataset from a web server.
+   *
+   * @extends Source
+   *
+   * @property {boolean} isOGC3DTilesSource - Used to check if this source is an isOGC3DTilesSource. Set to true.
+   * You should not change this, as it is used internally for optimisation.
+   * @property {string} url - The URL of the tileset json.
+   *
+   * @param {Object} source An object that can contain all properties of OGC3DTilesSource and of {@link Source}.
+   * Only `url` is mandatory.
+   * @param {string} source.url - The URL of the tileset json.
+   */
+  constructor(source) {
+    super(source);
+    this.isOGC3DTilesSource = true;
+  }
+}
+export default OGC3DTilesSource;

package/lib/Source/OrientedImageSource.js

@@ -0,0 +1,59 @@
+import Source from "./Source.js";
+import Fetcher from "../Provider/Fetcher.js";
+
+/**
+ * OrientedImageSource is a specific source used to load oriented images.
+ * @extends Source
+ */
+class OrientedImageSource extends Source {
+  /**
+   * @param { Object } source - Configuration object
+   * @param { string } source.url - Url for all the textures.
+   * @param { string } source.orientationsUrl - Json Url, using GeoJSon format to represent points,
+   * it's a set of panoramic position and orientation.
+   * @param { string } source.calibrationUrl - Json url, representing a set of camera.
+   * see {@link CameraCalibrationParser}
+   * This Url must contains {sensorId} and {cameraId}, and these pattern will be replaced to build the Url,
+   * to find the good texture for each camera for each panoramic.
+   */
+  constructor(source) {
+    super(source);
+    this.isOrientedImageSource = true;
+
+    // Fetch the two files
+    const promises = [];
+    promises.push(source.orientationsUrl ? Fetcher.json(source.orientationsUrl, this.networkOptions) : Promise.resolve());
+    promises.push(source.calibrationUrl ? Fetcher.json(source.calibrationUrl, this.networkOptions) : Promise.resolve());
+    this.whenReady = Promise.all(promises).then(data => ({
+      orientation: data[0],
+      calibration: data[1]
+    }));
+  }
+
+  /**
+   * Build the url of the texture, but not from extent.
+   *
+   * @param      {Object}  imageInfo - Information about the texture
+   * @param      {string}  imageInfo.camera - Id of the camera
+   * @param      {string}  imageInfo.pano - Id of the panoramic
+   * @return     {string}  Url of the image
+   */
+  urlFromExtent(imageInfo) {
+    return this.imageUrl(imageInfo.cameraId, imageInfo.panoId);
+  }
+  getDataKey(image) {
+    return `c${image.cameraId}p${image.panoId}`;
+  }
+
+  /**
+   * Build the url of the image, for a given panoramic id, and a given camera id.
+   *
+   * @param      {string}  cameraId  Id of the camera
+   * @param      {string}  panoId   Id of the panoramic
+   * @return     {string}  Url of the image
+   */
+  imageUrl(cameraId, panoId) {
+    return this.url.replace('{cameraId}', cameraId).replace('{panoId}', panoId);
+  }
+}
+export default OrientedImageSource;

package/lib/Source/Potree2Source.js

@@ -0,0 +1,167 @@
+import Source from "./Source.js";
+import Fetcher from "../Provider/Fetcher.js";
+import Potree2BinParser from "../Parser/Potree2BinParser.js";
+
+/**
+ * Potree2Source are object containing informations on how to fetch potree 2.0 points cloud resources.
+ */
+
+class Potree2Source extends Source {
+  /**
+   * @param {Object} source - An object that can contain all properties of a
+   * Potree2Source
+   * @param {string} source.url - folder url.
+   * @param {string} source.file - metadata file name.
+   *
+   * This `metadata` file stores information about the potree cloud 2.0 in JSON format. the structure is :
+   *
+   * * __`version`__ - The metadata.json format may change over time. The version number is
+   * necessary so that parsers know how to interpret the data.
+   * * __`name`__ - Point cloud name.
+   * * __`description`__ - Point cloud description.
+   * * __`points`__ - Total number of points.
+   * * __`projection`__ - Point cloud geographic projection system.
+   * * __`hierarchy`__ - Information about point cloud hierarchy (first chunk size, step size, octree depth).
+   * * __`offset`__ - Position offset used to determine the global point position.
+   * * __`scale`__ - Point cloud scale.
+   * * __`spacing`__ - The minimum distance between points at root level.
+   * * __`boundingBox`__ - Contains the minimum and maximum of the axis aligned bounding box. This bounding box is cubic and aligned to fit to the octree root.
+   * * __`encoding`__ - Encoding type: BROTLI or DEFAULT (uncompressed).
+   * * __`attributes`__ - Array of attributes (position,  intensity, return number, number of returns, classification, scan angle rank, user data, point source id, gps-time, rgb).
+   * ```
+   * {
+   *     version: '2.0',
+   *     name: "sample",
+   *     description: "",
+   *     points: 534909153,
+   *     projection: "",
+   *     hierarchy: {
+   *         firstChunkSize: 1276,
+   *         stepSize: 4,
+   *         depth: 16
+   *     },
+   *     offset: [1339072.07, 7238866.339, 85.281],
+   *     scale: [0.001, 0.001, 0.002],
+   *     spacing: 24.476062500005355,
+   *     boundingBox: {
+   *         min: [1339072.07, 7238866.339, 85.281],
+   *         max: [1342205.0060000008, 7241999.275, 3218.2170000006854]
+   *     },
+   *     encoding: "BROTLI",
+   *     attributes: [
+   *          {
+   *              name: "position",
+   *              description: "",
+   *              size: 12,
+   *              numElements: 3,
+   *              elementSize: 4,
+   *              type: "int32",
+   *              min: [-0.74821299314498901, -2.7804059982299805, 2.5478212833404541],
+   *              max: [2.4514148223438199, 1.4893437627414672, 7.1957106576508663]
+   *          },
+   *          {
+   *              name: "intensity",
+   *              description: "",
+   *              size: 2,
+   *              numElements: 1,
+   *              elementSize: 2,
+   *              type: "uint16",
+   *              min: [0],
+   *              max: [0]
+   *          },{
+   *              name: "return number",
+   *              description: "",
+   *              size: 1,
+   *              numElements: 1,
+   *              elementSize: 1,
+   *              type: "uint8",
+   *              min: [0],
+   *              max: [0]
+   *          },{
+   *              name: "number of returns",
+   *              description: "",
+   *              size: 1,
+   *              numElements: 1,
+   *              elementSize: 1,
+   *              type: "uint8",
+   *              min: [0],
+   *              max: [0]
+   *          },{
+   *              name: "classification",
+   *              description: "",
+   *              size: 1,
+   *              numElements: 1,
+   *              elementSize: 1,
+   *              type: "uint8",
+   *              min: [0],
+   *              max: [0]
+   *          },{
+   *              name: "scan angle rank",
+   *              description: "",
+   *              size: 1,
+   *              numElements: 1,
+   *              elementSize: 1,
+   *              type: "uint8",
+   *              min: [0],
+   *              max: [0]
+   *          },{
+   *              name: "user data",
+   *              description: "",
+   *              size: 1,
+   *              numElements: 1,
+   *              elementSize: 1,
+   *              type: "uint8",
+   *              min: [0],
+   *              max: [0]
+   *          },{
+   *              name: "point source id",
+   *              description: "",
+   *              size: 2,
+   *              numElements: 1,
+   *              elementSize: 2,
+   *              type: "uint16",
+   *              min: [0],
+   *              max: [0]
+   *          },{
+   *              name: "gps-time",
+   *              description: "",
+   *              size: 8,
+   *              numElements: 1,
+   *              elementSize: 8,
+   *              type: "double",
+   *              min: [0],
+   *              max: [0]
+   *          },{
+   *              name: "rgb",
+   *              description: "",
+   *              size: 6,
+   *              numElements: 3,
+   *              elementSize: 2,
+   *              type: "uint16",
+   *              min: [5632, 5376, 4864],
+   *              max: [65280, 65280, 65280]
+   *          }
+   *     ]
+   * }
+   * ```
+   *
+   * @extends Source
+   */
+  constructor(source) {
+    if (!source.file) {
+      throw new Error('New Potree2Source: file is required');
+    }
+    super(source);
+    this.file = source.file;
+    this.fetcher = Fetcher.arrayBuffer;
+    this.whenReady = (source.metadata ? Promise.resolve(source.metadata) : Fetcher.json(`${this.url}/${this.file}`, this.networkOptions)).then(metadata => {
+      this.metadata = metadata;
+      this.pointAttributes = metadata.attributes;
+      this.baseurl = `${this.url}`;
+      this.extension = 'bin';
+      this.parser = Potree2BinParser.parse;
+      return metadata;
+    });
+  }
+}
+export default Potree2Source;

package/lib/Source/PotreeSource.js

@@ -0,0 +1,82 @@
+import Source from "./Source.js";
+import Fetcher from "../Provider/Fetcher.js";
+import PotreeBinParser from "../Parser/PotreeBinParser.js";
+import PotreeCinParser from "../Parser/PotreeCinParser.js";
+
+/**
+ * PotreeSource are object containing informations on how to fetch points cloud resources.
+ */
+
+class PotreeSource extends Source {
+  /**
+   * @param {Object} source - An object that can contain all properties of a
+   * PotreeSource
+   * @param {string} source.url - folder url.
+   * @param {string} source.file - cloud file name.
+   *
+   * This `cloud` file stores information about the potree cloud in JSON format. the structure is :
+   *
+   * * __`version`__ - The cloud.js format may change over time. The version number is
+   * necessary so that parsers know how to interpret the data.
+   * * __`octreeDir`__ - Directory or URL where node data is stored. Usually points to
+   * "data".
+   * * __`boundingBox`__ - Contains the minimum and maximum of the axis aligned bounding box. This bounding box is cubic and aligned to fit to the octree root.
+   * * __`tightBoundingBox`__ - This bounding box thightly fits the point data.
+   * * __`pointAttributes`__ - Declares the point data format. May be 'LAS', 'LAZ' or in case if the BINARY format an array of attributes like
+   * `['POSITION_CARTESIAN', 'COLOR_PACKED', 'INTENSITY']`
+   * * __`POSITION_CARTESIAN`__ - 3 x 32bit signed integers for x/y/z coordinates
+   * * __`COLOR_PACKED`__ - 4 x unsigned byte for r,g,b,a colors.
+   * * __`spacing`__ - The minimum distance between points at root level.
+   * ```
+   * {
+   *     version: '1.6',
+   *     octreeDir: 'data',
+   *     boundingBox: {
+   *         lx: -4.9854,
+   *         ly: 1.0366,
+   *         lz: -3.4494,
+   *         ux: 0.702300000000001,
+   *         uy: 6.7243,
+   *         uz: 2.2383
+   *     },
+   *     tightBoundingBox: {
+   *         lx: -4.9854,
+   *         ly: 1.0375,
+   *         lz: -3.4494,
+   *         ux: -0.7889,
+   *         uy: 6.7243,
+   *         uz: 1.1245
+   *     },
+   *     pointAttributes: [
+   *         'POSITION_CARTESIAN',
+   *         'COLOR_PACKED'
+   *     ],
+   *     spacing: 0.03,
+   *     scale: 0.001,
+   *     hierarchyStepSize: 5
+   * }
+   * ```
+   *
+   * @extends Source
+   */
+  constructor(source) {
+    if (!source.file) {
+      throw new Error('New PotreeSource: file is required');
+    }
+    super(source);
+    this.file = source.file;
+    this.fetcher = Fetcher.arrayBuffer;
+    this.extensionOctree = 'hrc';
+
+    // For cloud specification visit:
+    // https://github.com/PropellerAero/potree-propeller-private/blob/master/docs/file_format.md#cloudjs
+    this.whenReady = (source.cloud ? Promise.resolve(source.cloud) : Fetcher.json(`${this.url}/${this.file}`, this.networkOptions)).then(cloud => {
+      this.pointAttributes = cloud.pointAttributes;
+      this.baseurl = `${this.url}/${cloud.octreeDir}/r`;
+      this.extension = cloud.pointAttributes === 'CIN' ? 'cin' : 'bin';
+      this.parse = this.extension === 'cin' ? PotreeCinParser.parse : PotreeBinParser.parse;
+      return cloud;
+    });
+  }
+}
+export default PotreeSource;