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

package/lib/Renderer/c3DEngine.js

@@ -0,0 +1,214 @@
+/**
+ * Generated On: 2015-10-5
+ * Class: c3DEngine
+ * Description: 3DEngine est l'interface avec le framework webGL.
+ */
+
+import * as THREE from 'three';
+import Capabilities from "../Core/System/Capabilities.js";
+import { unpack1K } from "./LayeredMaterial.js";
+import Label2DRenderer from "./Label2DRenderer.js";
+import { deprecatedC3DEngineWebGLOptions } from "../Core/Deprecated/Undeprecator.js";
+import WEBGL from "../ThreeExtended/capabilities/WebGL.js";
+const depthRGBA = new THREE.Vector4();
+class c3DEngine {
+  constructor(rendererOrDiv) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    deprecatedC3DEngineWebGLOptions(options);
+
+    // pick sensible default options
+    if (options.antialias === undefined) {
+      options.antialias = true;
+    }
+    if (options.alpha === undefined) {
+      options.alpha = true;
+    }
+    if (options.logarithmicDepthBuffer === undefined) {
+      options.logarithmicDepthBuffer = true;
+    }
+
+    // If rendererOrDiv parameter is a domElement, we use it as support to display data.
+    // If it is a renderer, we check the renderer.domElement parameter which can be :
+    //    - a domElement, in this case we use this domElement as a support
+    //    - a canvas, in this case we use the canvas parent (which should be a domElement) as a support
+    let renderer;
+    let viewerDiv;
+    if (rendererOrDiv.domElement) {
+      renderer = rendererOrDiv;
+      viewerDiv = renderer.domElement instanceof HTMLDivElement ? renderer.domElement : renderer.domElement.parentElement;
+    } else {
+      viewerDiv = rendererOrDiv;
+    }
+    this.width = viewerDiv.clientWidth;
+    this.height = viewerDiv.clientHeight;
+    this.positionBuffer = null;
+    this._nextThreejsLayer = 1;
+    this.fullSizeRenderTarget = new THREE.WebGLRenderTarget(this.width, this.height);
+    this.fullSizeRenderTarget.texture.minFilter = THREE.LinearFilter;
+    this.fullSizeRenderTarget.texture.magFilter = THREE.NearestFilter;
+    this.fullSizeRenderTarget.depthBuffer = true;
+    this.fullSizeRenderTarget.depthTexture = new THREE.DepthTexture();
+    this.fullSizeRenderTarget.depthTexture.type = THREE.UnsignedShortType;
+    this.renderView = function (view) {
+      this.renderer.clear();
+      this.renderer.render(view.scene, view.camera3D);
+      if (view.tileLayer) {
+        this.label2dRenderer.render(view.tileLayer.object3d, view.camera3D);
+      }
+    }.bind(this);
+
+    /**
+     * @type {function}
+     * @param {number} w
+     * @param {number} h
+     */
+    this.onWindowResize = function (w, h) {
+      this.width = w;
+      this.height = h;
+      this.fullSizeRenderTarget.setSize(this.width, this.height);
+      this.renderer.setSize(this.width, this.height);
+      this.label2dRenderer.setSize(this.width, this.height);
+    }.bind(this);
+
+    // Create renderer
+    try {
+      this.label2dRenderer = new Label2DRenderer();
+      this.label2dRenderer.setSize(this.width, this.height);
+      viewerDiv.appendChild(this.label2dRenderer.domElement);
+      this.renderer = renderer || new THREE.WebGLRenderer({
+        canvas: document.createElement('canvas'),
+        antialias: options.antialias,
+        alpha: options.alpha,
+        logarithmicDepthBuffer: options.logarithmicDepthBuffer
+      });
+      this.renderer.domElement.style.position = 'relative';
+      this.renderer.domElement.style.zIndex = 0;
+      this.renderer.domElement.style.top = 0;
+    } catch (ex) {
+      if (!WEBGL.isWebGL2Available()) {
+        viewerDiv.appendChild(WEBGL.getErrorMessage(2));
+      }
+      throw ex;
+    }
+
+    // Let's allow our canvas to take focus
+    // The condition below looks weird, but it's correct: querying tabIndex
+    // returns -1 if not set, but we still need to explicitly set it to force
+    // the tabindex focus flag to true (see
+    // https://www.w3.org/TR/html5/editing.html#specially-focusable)
+    if (this.renderer.domElement.tabIndex === -1) {
+      this.renderer.domElement.tabIndex = -1;
+    }
+    Capabilities.updateCapabilities(this.renderer);
+    this.renderer.setClearColor(0x030508);
+    this.renderer.autoClear = false;
+    this.renderer.sortObjects = true;
+    this.renderer.debug.checkShaderErrors = false;
+    if (!renderer) {
+      this.renderer.setPixelRatio(viewerDiv.devicePixelRatio);
+      this.renderer.setSize(viewerDiv.clientWidth, viewerDiv.clientHeight);
+      viewerDiv.appendChild(this.renderer.domElement);
+    }
+  }
+  getWindowSize() {
+    return new THREE.Vector2(this.width, this.height);
+  }
+
+  /**
+   * return renderer THREE.js
+   * @returns {THREE.WebGLRenderer}
+   */
+  getRenderer() {
+    return this.renderer;
+  }
+
+  /**
+   * Render view to a Uint8Array.
+   *
+   * @param {View} view - The view to render
+   * @param {object} [zone] - partial zone to render
+   * @param {number} zone.x - x (in view coordinate)
+   * @param {number} zone.y - y (in view coordinate)
+   * @param {number} zone.width - width of area to render (in pixels)
+   * @param {number} zone.height - height of area to render (in pixels)
+   * @return {THREE.RenderTarget} - Uint8Array, 4 bytes per pixel. The first pixel in
+   * the array is the bottom-left pixel.
+   */
+  renderViewToBuffer(view, zone) {
+    if (!zone) {
+      zone = {
+        x: 0,
+        y: 0,
+        width: this.width,
+        height: this.height
+      };
+    }
+    zone.buffer = zone.buffer || new Uint8Array(4 * zone.width * zone.height);
+    this.renderViewToRenderTarget(view, this.fullSizeRenderTarget, zone);
+    this.renderer.readRenderTargetPixels(this.fullSizeRenderTarget, zone.x, this.height - (zone.y + zone.height), zone.width, zone.height, zone.buffer);
+    return zone.buffer;
+  }
+
+  /**
+   * Render view to a THREE.RenderTarget.
+   *
+   * @param {View} view - The view to render
+   * @param {THREE.RenderTarget} [target] - destination render target. Default value: full size render target owned by c3DEngine.
+   * @param {object} [zone] - partial zone to render (zone x/y uses view coordinates) Note: target must contain complete zone
+   * @return {THREE.RenderTarget} - the destination render target
+   */
+  renderViewToRenderTarget(view, target, zone) {
+    if (!target) {
+      target = this.fullSizeRenderTarget;
+    }
+    const current = this.renderer.getRenderTarget();
+
+    // Don't use setViewport / setScissor on renderer because they would affect
+    // on screen rendering as well. Instead set them on the render target.
+    // Example : this.fullSizeRenderTarget.viewport.set(0, 0, target.width, target.height);
+    if (zone) {
+      this.fullSizeRenderTarget.scissor.set(zone.x, target.height - (zone.y + zone.height), zone.width, zone.height);
+      this.fullSizeRenderTarget.scissorTest = true;
+    }
+    this.renderer.setRenderTarget(target);
+    this.renderer.clear(true, true, false);
+    this.renderer.render(view.scene, view.camera.camera3D);
+    this.renderer.setRenderTarget(current);
+    this.fullSizeRenderTarget.scissorTest = false;
+    return target;
+  }
+  bufferToImage(pixelBuffer, width, height) {
+    const canvas = document.createElement('canvas');
+    const ctx = canvas.getContext('2d', {
+      willReadFrequently: true
+    });
+
+    // size the canvas to your desired image
+    canvas.width = width;
+    canvas.height = height;
+    const imgData = ctx.getImageData(0, 0, width, height);
+    imgData.data.set(pixelBuffer);
+    ctx.putImageData(imgData, 0, 0);
+
+    // create a new img object
+    const image = new Image();
+
+    // set the img.src to the canvas data url
+    image.src = canvas.toDataURL();
+    return image;
+  }
+  depthBufferRGBAValueToOrthoZ(depthBufferRGBA, camera) {
+    depthRGBA.fromArray(depthBufferRGBA).divideScalar(255.0);
+    if (Capabilities.isLogDepthBufferSupported() && camera.type == 'PerspectiveCamera') {
+      const gl_FragDepthEXT = unpack1K(depthRGBA);
+      const logDepthBufFC = 2.0 / (Math.log(camera.far + 1.0) / Math.LN2);
+      // invert function : gl_FragDepthEXT = log2(vFragDepth) * logDepthBufFC * 0.5;
+      return 2 ** (2 * gl_FragDepthEXT / logDepthBufFC);
+    } else {
+      let gl_FragCoord_Z = unpack1K(depthRGBA);
+      gl_FragCoord_Z = gl_FragCoord_Z * 2.0 - 1.0;
+      return gl_FragCoord_Z;
+    }
+  }
+}
+export default c3DEngine;

package/lib/Source/C3DTilesGoogleSource.js

@@ -0,0 +1,74 @@
+import Fetcher from "../Provider/Fetcher.js";
+import C3DTilesSource from "./C3DTilesSource.js";
+function findSessionId(tile) {
+  if (!tile) {
+    return null;
+  }
+  if (tile.content && tile.content.uri) {
+    const searchParams = new URLSearchParams(tile.content.uri.slice(tile.content.uri.indexOf('?') + 1));
+    return searchParams.get('session');
+  } else if (tile.children && tile.children.length > 0) {
+    for (const c of tile.children) {
+      const sessionId = findSessionId(c);
+      if (sessionId) {
+        return sessionId;
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * An object defining the source connection to a 3DTiles asset from a [Google api](https://tile.googleapis.com).
+ *
+ * @extends C3DTilesSource
+ *
+ * @property {boolean} isC3DTilesGoogleSource - Used to checkout whether this source is a C3DTilesGoogleSource. Default is
+ * 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.
+ */
+class C3DTilesGoogleSource extends C3DTilesSource {
+  /**
+   * Create a new Source for 3D Tiles data from Google api (experimental).
+   *
+   * @extends C3DTilesSource
+   *
+   * @property {boolean} isC3DTilesGoogleSource - Used to checkout whether this source is a C3DTilesGoogleSource. Default is
+   * true. You should not change this, as it is used internally for optimisation.
+   * @param {Object} source An object that can contain all properties of a C3DTilesGoogleSource and {@link Source}.
+   * @param {String} source.key Your google tiles map API access key
+   */
+  constructor(source) {
+    if (!source.key) {
+      throw new Error('[C3DTilesGoogleSource]: 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.isC3DTilesGoogleSource = true;
+    this.baseUrl = 'https://tile.googleapis.com';
+    this.key = source.key;
+    this.whenReady = Fetcher.json(source.url, this.networkOptions).then(json => {
+      if (json && json.root) {
+        this.sessionId = findSessionId(json.root);
+        if (this.sessionId === null) {
+          throw new Error('[C3DTilesGoogleSource]: Cannot find sessionId from the tileset while it is mandatory to request tiles.');
+        }
+      }
+      return json;
+    });
+  }
+
+  /**
+   * Adds the key and session to the tile url (non-standard behaviour, that is specific to Google 3D tiles),
+   * see https://github.com/CesiumGS/3d-tiles/issues/746
+   * @param {String} url the tile url
+   * @returns {String} the tile url with Google map tiles api key and session parameters added at the end of the url
+   */
+  getTileUrl(url) {
+    const extraParameters = `key=${this.key}&session=${this.sessionId}`;
+    return /\?/.test(url) ? `${url}&${extraParameters}` : `${url}?${extraParameters}`;
+  }
+}
+export default C3DTilesGoogleSource;

package/lib/Source/C3DTilesIonSource.js

@@ -0,0 +1,54 @@
+import Fetcher from "../Provider/Fetcher.js";
+import C3DTilesSource from "./C3DTilesSource.js";
+
+/**
+ * An object defining the source connection to a 3DTiles asset of a [Cesium ion server](https://cesium.com/learn/ion/).
+ *
+ * @extends Source
+ *
+ * @property {boolean} isC3DTilesIonSource - Used to checkout whether this source is a C3DTilesIonSource. Default is
+ * true. You should not change this, as it is used internally for optimisation.
+ * @property {string} url - The URL of the tileset json.
+ * @property {string} baseUrl - The base URL to access tiles.
+ * @property {string} accessToken - The Cesium ion access token used to retrieve the resource.
+ * @property {string} assetId - The id of the asset on Cesium ion.
+ */
+class C3DTilesIonSource extends C3DTilesSource {
+  /**
+   * Create a new Source for 3D Tiles data from Cesium ion.
+   *
+   * @extends Source
+   *
+   * @param {Object} source An object that can contain all properties of a C3DTilesIonSource and {@link Source}.
+   * Only `accessToken` and `assetId` are mandatory.
+   */
+  constructor(source) {
+    if (!source.accessToken) {
+      throw new Error('New 3D Tiles Ion Source: access token is required');
+    }
+    if (!source.assetId) {
+      throw new Error('New 3D Tiles Ion Source: asset id 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.isC3DTilesIonSource = true;
+    this.accessToken = source.accessToken;
+    this.assetId = source.assetId;
+
+    // get asset metadata
+    this.whenReady = Fetcher.json(source.url, this.networkOptions).then(json => {
+      if (json.type !== '3DTILES') {
+        throw new Error(`${json.type} datasets from Cesium ion are not supported with C3DTilesIonSource. ` + 'Only 3D Tiles datasets are supported.');
+      }
+      this.url = json.url; // Store url to the tileset.json
+      this.baseUrl = json.url.slice(0, json.url.lastIndexOf('/') + 1); // baseUrl for tiles queries
+      this.networkOptions.headers = {};
+      this.networkOptions.headers.Authorization = `Bearer ${json.accessToken}`;
+      this.attribution = json.attributions;
+      return Fetcher.json(this.url, this.networkOptions);
+    });
+  }
+}
+export default C3DTilesIonSource;

package/lib/Source/C3DTilesSource.js

@@ -0,0 +1,30 @@
+import Source from "./Source.js";
+import Fetcher from "../Provider/Fetcher.js";
+
+/**
+ * An object defining the source connection to a 3DTiles dataset from a web server.
+ *
+ * @extends Source
+ *
+ * @property {boolean} isC3DTilesSource - Used to checkout whether this source is a isC3DTilesSource. Default is
+ * true. You should not change this, as it is used internally for optimisation.
+ * @property {string} url - The URL of the tileset json.
+ * @property {string} baseUrl - The base URL to access tiles.
+ */
+class C3DTilesSource extends Source {
+  /**
+   * Create a new Source for 3D Tiles data from a web server.
+   *
+   * @extends Source
+   *
+   * @param {Object} source An object that can contain all properties of {@link Source}.
+   * Only `url` is mandatory.
+   */
+  constructor(source) {
+    super(source);
+    this.isC3DTilesSource = true;
+    this.baseUrl = this.url.slice(0, this.url.lastIndexOf('/') + 1);
+    this.whenReady = Fetcher.json(this.url, this.networkOptions);
+  }
+}
+export default C3DTilesSource;

package/lib/Source/CopcSource.js

@@ -0,0 +1,126 @@
+import proj4 from 'proj4';
+import { Binary, Info, Las } from 'copc';
+import { Extent } from '@itowns/geographic';
+import Fetcher from "../Provider/Fetcher.js";
+import LASParser from "../Parser/LASParser.js";
+import Source from "./Source.js";
+import * as THREE from 'three';
+
+/**
+ * @param {function(number, number):Promise<Uint8Array>} fetcher
+ */
+async function getHeaders(fetcher) {
+  const header = Las.Header.parse(await fetcher(0, Las.Constants.minHeaderLength));
+  const vlrs = await Las.Vlr.walk(fetcher, header);
+
+  // info VLR: required by COPC
+  const infoVlr = Las.Vlr.find(vlrs, 'copc', 1);
+  if (!infoVlr) {
+    return Promise.reject('COPC info VLR is required');
+  }
+  const info = Info.parse(await Las.Vlr.fetch(fetcher, infoVlr));
+
+  // OGC Coordinate System WKT: required by LAS1.4
+  const wktVlr = Las.Vlr.find(vlrs, 'LASF_Projection', 2112);
+  if (!wktVlr) {
+    return Promise.reject('LAS1.4 WKT VLR is required');
+  }
+  const wkt = Binary.toCString(await Las.Vlr.fetch(fetcher, wktVlr));
+
+  // Extra bytes: optional by LAS1.4
+  const ebVlr = Las.Vlr.find(vlrs, 'LASF_Spec', 4);
+  const eb = ebVlr ? Las.ExtraBytes.parse(await Las.Vlr.fetch(fetcher, ebVlr)) : [];
+  return {
+    header,
+    info,
+    wkt,
+    eb
+  };
+}
+
+/**
+ * A source for [Cloud Optimised Point Cloud](https://copc.io/) (COPC) data.
+ * Such data consists of a [LAZ 1.4](https://www.ogc.org/standard/las/) file
+ * that stores compressed points data organized in a clustered octree.
+ *
+ * A freshly created source fetches and parses portions of the file
+ * corresponding to the LAS 1.4 header, all the Variable Length Record (VLR)
+ * headers as well the following VLRs:
+ * - COPC [`info`](https://copc.io/#info-vlr) record (mandatory)
+ * - LAS 1.4 `OGC Coordinate System WKT` record (mandatory, see [Las 1.4
+ *   spec](https://portal.ogc.org/files/?artifact_id=74523))
+ * - LAS 1.4 `Extra Bytes` record (optional, see [Las 1.4
+ *   spec](https://portal.ogc.org/files/?artifact_id=74523))
+ *
+ * @extends {Source}
+ *
+ * @property {boolean} isCopcSource - Read-only flag to check that a given
+ * object is of type CopcSource.
+ * @property {Object} header - LAS header of the source.
+ * @property {Object[]} eb - List of headers of each Variable Length Records
+ * (VLRs).
+ * @property {Object} info - COPC `info` VLR.
+ * @property {number[]} info.cube - Bounding box of the octree as a 6-elements.
+ * tuple `[minX, minY, minZ, maxX, maxY, maxZ]`. Computed from `center_x`,
+ * `center_y`, `center_z` and `halfSize` properties.
+ * @property {Object} info.rootHierarchyPage - Hierarchy page of the root node.
+ * @property {number} info.rootHierarchyPage.pageOffset - Absolute Offset to the
+ * root node data chunk.
+ * @property {number} info.rootHierarchyPage.pageOffset - Size (in bytes) of the
+ * root node data chunk.
+ * @property {number[]} gpsTimeRange - A 2-element tuple denoting the minimum
+ * and maximum values of attribute `gpsTime`.
+ */
+class CopcSource extends Source {
+  /**
+   * @param {Object} config - Source configuration
+   * @param {string} config.url - URL of the COPC resource.
+   * @param {8 | 16} [config.colorDepth=16] - Encoding of the `color`
+   * attribute. Either `8` or `16` bits.
+   * @param {string} [config._lazPerfBaseUrl] - (experimental) Overrides base
+   * url of the `las-zip.wasm` file of the `laz-perf` library.
+   * @param {string} [config.crs='EPSG:4326'] - Native CRS of the COPC
+   * ressource. Note that this is not for now inferred from the COPC header.
+   * @param {RequestInit} [config.networkOptions] - Fetch options (passed
+   * directly to `fetch()`), see [the syntax for more information](
+   * https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Syntax).
+   * @param {Object} [config.attribution] - Attribution of the data.
+   */
+  constructor(config) {
+    super(config);
+    this.isCopcSource = true;
+    this.parser = LASParser.parseChunk;
+    this.fetcher = Fetcher.arrayBuffer;
+    this.colorDepth = config.colorDepth ?? 16;
+    const get = (/** @type {number} */begin, /** @type {number} */end) => this.fetcher(this.url, {
+      ...this.networkOptions,
+      headers: {
+        ...this.networkOptions.headers,
+        range: `bytes=${begin}-${end - 1}`
+      }
+    }).then(buffer => new Uint8Array(buffer));
+    this.whenReady = getHeaders(get).then(metadata => {
+      this.header = metadata.header;
+      this.info = metadata.info;
+      this.eb = metadata.eb;
+      proj4.defs('unknown', metadata.wkt);
+      let projCS;
+      if (proj4.defs('unknown').type === 'COMPD_CS') {
+        console.warn('CopcSource: compound coordinate system is not yet supported.');
+        projCS = proj4.defs('unknown').PROJCS;
+      } else {
+        projCS = proj4.defs('unknown');
+      }
+      this.crs = projCS.title || projCS.name || 'EPSG:4326';
+      if (!(this.crs in proj4.defs)) {
+        proj4.defs(this.crs, projCS);
+      }
+      const bbox = new THREE.Box3();
+      bbox.min.fromArray(this.info.cube, 0);
+      bbox.max.fromArray(this.info.cube, 3);
+      this.extent = Extent.fromBox3(this.crs, bbox);
+      return this;
+    });
+  }
+}
+export default CopcSource;

package/lib/Source/EntwinePointTileSource.js

@@ -0,0 +1,72 @@
+import proj4 from 'proj4';
+import LASParser from "../Parser/LASParser.js";
+import PotreeBinParser from "../Parser/PotreeBinParser.js";
+import Fetcher from "../Provider/Fetcher.js";
+import Source from "./Source.js";
+
+/**
+ * An object defining the source of Entwine Point Tile data. It fetches and
+ * parses the main configuration file of Entwine Point Tile format,
+ * [`ept.json`](https://entwine.io/entwine-point-tile.html#ept-json).
+ *
+ * @extends Source
+ *
+ * @property {boolean} isEntwinePointTileSource - Used to checkout whether this
+ * source is a EntwinePointTileSource. Default is true. You should not change
+ * this, as it is used internally for optimisation.
+ * @property {string} url - The URL of the directory containing the whole
+ * Entwine Point Tile structure.
+ */
+class EntwinePointTileSource extends Source {
+  /**
+   * @param {Object} config - The configuration, see {@link Source} for
+   * available values.
+   * @param {number|string} [config.colorDepth='auto'] - Does the color
+   * encoding is known ? Is it `8` or `16` bits ? By default it is to
+   * `'auto'`, but it will be more performant if a specific value is set.
+   */
+  constructor(config) {
+    super(config);
+    this.isEntwinePointTileSource = true;
+    this.colorDepth = config.colorDepth;
+
+    // Necessary because we use the url without the ept.json part as a base
+    this.url = this.url.replace('/ept.json', '');
+
+    // https://entwine.io/entwine-point-tile.html#ept-json
+    this.whenReady = Fetcher.json(`${this.url}/ept.json`, this.networkOptions).then(metadata => {
+      // Set parser and its configuration from schema
+      this.parse = metadata.dataType === 'laszip' ? LASParser.parse : PotreeBinParser.parse;
+      this.extension = metadata.dataType === 'laszip' ? 'laz' : 'bin';
+      if (metadata.srs) {
+        if (metadata.srs.authority && metadata.srs.horizontal) {
+          this.crs = `${metadata.srs.authority}:${metadata.srs.horizontal}`;
+          if (!proj4.defs(this.crs)) {
+            proj4.defs(this.crs, metadata.srs.wkt);
+          }
+        } else if (metadata.srs.wkt) {
+          proj4.defs('unknown', metadata.srs.wkt);
+          const projCS = proj4.defs('unknown');
+          this.crs = projCS.title || projCS.name;
+          if (!(this.crs in proj4.defs)) {
+            proj4.defs(this.crs, projCS);
+          }
+        }
+        if (metadata.srs.vertical && metadata.srs.vertical !== metadata.srs.horizontal) {
+          console.warn('EntwinePointTileSource: Vertical coordinates system code is not yet supported.');
+        }
+      }
+
+      // NOTE: this spacing is kinda arbitrary here, we take the width and
+      // length (height can be ignored), and we divide by the specified
+      // span in ept.json. This needs improvements.
+      this.spacing = (Math.abs(metadata.boundsConforming[3] - metadata.boundsConforming[0]) + Math.abs(metadata.boundsConforming[4] - metadata.boundsConforming[1])) / (2 * metadata.span);
+      this.boundsConforming = metadata.boundsConforming;
+      this.bounds = metadata.bounds;
+      this.span = metadata.span;
+      return this;
+    });
+    this.fetcher = Fetcher.arrayBuffer;
+  }
+}
+export default EntwinePointTileSource;