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

package/lib/Parser/ISGParser.js

@@ -0,0 +1,71 @@
+import * as THREE from 'three';
+import { Extent } from '@itowns/geographic';
+import GeoidGrid from "../Core/Geographic/GeoidGrid.js";
+import { getHeaderAttribute } from "./GDFParser.js";
+import { BYTES_PER_DOUBLE } from "./GTXParser.js";
+
+/**
+ * The `ISGParser` module provides a `[parse]{@link module:ISGParser.parse}` method. This method takes the content of a
+ * ISG file in, and returns a `{@link GeoidGrid}`. the `{@link GeoidGrid}` contains all the necessary attributes and
+ * methods to access the ISG data in iTowns.
+ *
+ * @module ISGParser
+ */
+export default {
+  /**
+   * Parses an ISG file content and returns a corresponding {@link GeoidGrid}.
+   *
+   * @param   {string}    isg                             The content of the ISG file to parse.
+   * @param   {Object}    options                         An object gathering the optional parameters to pass to
+                                                          * the parser.
+   * @param   {Object}    [options.in={}]                 Information on the ISG data.
+   * @param   {string}    [options.in.crs='EPSG:4326']    The Coordinates Reference System (CRS) of the ISG 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 ISG file data.
+   */
+  parse(isg) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+      in: {}
+    };
+    const rows = isg.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, 'lon min'),
+      maxX: getHeaderAttribute(rawHeaderData, 'lon max'),
+      minY: getHeaderAttribute(rawHeaderData, 'lat min'),
+      maxY: getHeaderAttribute(rawHeaderData, 'lat max'),
+      stepX: getHeaderAttribute(rawHeaderData, 'delta lon'),
+      stepY: getHeaderAttribute(rawHeaderData, 'delta lat'),
+      nRows: getHeaderAttribute(rawHeaderData, 'nrows'),
+      nColumns: getHeaderAttribute(rawHeaderData, 'ncols')
+    };
+
+    // ---------- 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;
+      }
+      for (const value of row) {
+        data.setFloat64(index * BYTES_PER_DOUBLE, parseFloat(value));
+        index++;
+      }
+    }
+
+    // ---------- CREATE A GeoidGrid FOR THE GIVEN FILE DATA : ----------
+
+    const dataExtent = new Extent(options.in.crs || 'EPSG:4326', metadata.minX + metadata.stepX / 2, metadata.maxX - metadata.stepX / 2, metadata.minY + metadata.stepY / 2, metadata.maxY - metadata.stepY / 2);
+    const dataStep = new THREE.Vector2(metadata.stepX, metadata.stepY);
+    return Promise.resolve(new GeoidGrid(dataExtent, dataStep, (verticalIndex, horizontalIndex) => data.getFloat64((metadata.nColumns * verticalIndex + horizontalIndex) * BYTES_PER_DOUBLE)));
+  }
+};

package/lib/Parser/KMLParser.js

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

package/lib/Parser/LASParser.js

@@ -0,0 +1,137 @@
+import * as THREE from 'three';
+import { spawn, Thread, Transfer } from 'threads';
+let _lazPerf;
+let _thread;
+function workerInstance() {
+  return new Worker(/* webpackChunkName: "itowns_lasparser" */
+  new URL('../Worker/LASLoaderWorker.js', import.meta.url), {
+    type: 'module'
+  });
+}
+async function loader() {
+  if (_thread) {
+    return _thread;
+  }
+  _thread = await spawn(workerInstance());
+  if (_lazPerf) {
+    _thread.lazPerf(_lazPerf);
+  }
+  return _thread;
+}
+function buildBufferGeometry(attributes) {
+  const geometry = new THREE.BufferGeometry();
+  const positionBuffer = new THREE.BufferAttribute(attributes.position, 3);
+  geometry.setAttribute('position', positionBuffer);
+  const intensityBuffer = new THREE.BufferAttribute(attributes.intensity, 1);
+  geometry.setAttribute('intensity', intensityBuffer);
+  const returnNumber = new THREE.BufferAttribute(attributes.returnNumber, 1);
+  geometry.setAttribute('returnNumber', returnNumber);
+  const numberOfReturns = new THREE.BufferAttribute(attributes.numberOfReturns, 1);
+  geometry.setAttribute('numberOfReturns', numberOfReturns);
+  const classBuffer = new THREE.BufferAttribute(attributes.classification, 1);
+  geometry.setAttribute('classification', classBuffer);
+  const pointSourceID = new THREE.BufferAttribute(attributes.pointSourceID, 1);
+  geometry.setAttribute('pointSourceID', pointSourceID);
+  if (attributes.color) {
+    const colorBuffer = new THREE.BufferAttribute(attributes.color, 4, true);
+    geometry.setAttribute('color', colorBuffer);
+  }
+  const scanAngle = new THREE.BufferAttribute(attributes.scanAngle, 1);
+  geometry.setAttribute('scanAngle', scanAngle);
+  geometry.userData.origin = new THREE.Vector3().fromArray(attributes.origin);
+  return geometry;
+}
+
+/** The LASParser module provides a [parse]{@link
+ * module:LASParser.parse} method that takes a LAS or LAZ (LASZip) file in, and
+ * gives a `THREE.BufferGeometry` containing all the necessary attributes to be
+ * displayed in iTowns. It uses the
+ * [copc.js](https://github.com/connormanning/copc.js/) library.
+ *
+ * @module LASParser
+ */
+export default {
+  /*
+   * Set the laz-perf decoder path.
+   * @param {string} path - path to `laz-perf.wasm` folder.
+   */
+  enableLazPerf(path) {
+    if (!path) {
+      throw new Error('Path to laz-perf is mandatory');
+    }
+    _lazPerf = path;
+  },
+  /**
+   * Terminate all worker instances.
+   * @returns {Promise<void>}
+   */
+  terminate() {
+    const currentThread = _thread;
+    _thread = undefined;
+    return Thread.terminate(currentThread);
+  },
+  /**
+   * Parses a chunk of a LAS or LAZ (LASZip) and returns the corresponding
+   * `THREE.BufferGeometry`.
+   *
+   * @param {ArrayBuffer} data - The file content to parse.
+   * @param {Object} options
+   * @param {Object} options.in - Options to give to the parser.
+   * @param {number} options.in.pointCount - Number of points encoded in this
+   * data chunk.
+   * @param {Object} options.in.header - Partial LAS file header.
+   * @param {number} options.in.header.pointDataRecordFormat - Type of Point
+   * Data Record contained in the LAS file.
+   * @param {number} options.in.header.pointDataRecordLength - Size (in bytes)
+   * of the Point Data Record.
+   * @param {Object} [options.eb] - Extra bytes LAS VLRs headers.
+   * @param { 8 | 16 } [options.in.colorDepth] - Color depth (in bits).
+   * Defaults to 8 bits for LAS 1.2 and 16 bits for later versions
+   * (as mandatory by the specification)
+   *
+   * @return {Promise<THREE.BufferGeometry>} A promise resolving with a
+   * `THREE.BufferGeometry`.
+   */
+  async parseChunk(data) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    const lasLoader = await loader();
+    const parsedData = await lasLoader.parseChunk(Transfer(data), {
+      pointCount: options.in.pointCount,
+      header: options.in.header,
+      eb: options.eb,
+      colorDepth: options.in.colorDepth
+    });
+    const geometry = buildBufferGeometry(parsedData.attributes);
+    geometry.computeBoundingBox();
+    return geometry;
+  },
+  /**
+   * Parses a LAS file or a LAZ (LASZip) file and return the corresponding
+   * `THREE.BufferGeometry`.
+   *
+   * @param {ArrayBuffer} data - The file content to parse.
+   * @param {Object} [options]
+   * @param {Object} [options.in] - Options to give to the parser.
+   * @param { 8 | 16 } [options.in.colorDepth] - Color depth (in bits).
+   * Defaults to 8 bits for LAS 1.2 and 16 bits for later versions
+   * (as mandatory by the specification)
+   *
+   * @return {Promise} A promise resolving with a `THREE.BufferGeometry`. The
+   * header of the file is contained in `userData`.
+   */
+  async parse(data) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    if (options.out?.skip) {
+      console.warn("Warning: options 'skip' not supported anymore");
+    }
+    const input = options.in;
+    const lasLoader = await loader();
+    const parsedData = await lasLoader.parseFile(Transfer(data), {
+      colorDepth: input?.colorDepth
+    });
+    const geometry = buildBufferGeometry(parsedData.attributes);
+    geometry.userData.header = parsedData.header;
+    geometry.computeBoundingBox();
+    return geometry;
+  }
+};

package/lib/Parser/MapBoxUrlParser.js

@@ -0,0 +1,83 @@
+const urlRe = /^(\w+):\/\/([^/?]*)(\/[^?]+)?\??(.+)?/;
+const config = {
+  API_URL: 'https://api.mapbox.com',
+  REQUIRE_ACCESS_TOKEN: true,
+  ACCESS_TOKEN: null
+};
+function formatUrl(obj) {
+  const params = obj.params.length ? `?${obj.params.join('&')}` : '';
+  return `${obj.protocol}://${obj.authority}${obj.path}${params}`;
+}
+function makeAPIURL(urlObject, accessToken) {
+  const apiUrlObject = parseUrl(config.API_URL);
+  urlObject.protocol = apiUrlObject.protocol;
+  urlObject.authority = apiUrlObject.authority;
+  if (urlObject.protocol === 'http') {
+    const i = urlObject.params.indexOf('secure');
+    if (i >= 0) {
+      urlObject.params.splice(i, 1);
+    }
+  }
+  if (apiUrlObject.path !== '/') {
+    urlObject.path = `${apiUrlObject.path}${urlObject.path}`;
+  }
+  if (!config.REQUIRE_ACCESS_TOKEN) {
+    return formatUrl(urlObject);
+  }
+  accessToken = accessToken || config.ACCESS_TOKEN;
+  if (!accessToken) {
+    throw new Error('An API access token is required');
+  }
+  if (accessToken[0] === 's') {
+    throw new Error('Use a public access token (pk.*), not a secret access token (sk.*).');
+  }
+  urlObject.params = urlObject.params.filter(d => d.indexOf('access_token') === -1);
+  urlObject.params.push(`access_token=${accessToken}`);
+  return formatUrl(urlObject);
+}
+function isMapboxURL(url) {
+  return url.indexOf('mapbox:') === 0;
+}
+function parseUrl(url) {
+  const parts = url.match(urlRe);
+  if (!parts) {
+    throw new Error('Unable to parse URL object');
+  }
+  return {
+    protocol: parts[1],
+    authority: parts[2],
+    path: parts[3] || '/',
+    params: parts[4] ? parts[4].split('&') : []
+  };
+}
+function normalizeSpriteURL(url, format, extension, accessToken) {
+  const urlObject = parseUrl(url);
+  if (!isMapboxURL(url)) {
+    urlObject.path += `${format}${extension}`;
+    return formatUrl(urlObject);
+  }
+  urlObject.path = `/styles/v1${urlObject.path}/sprite${format}${extension}`;
+  return makeAPIURL(urlObject, accessToken);
+}
+function normalizeSourceURL(url, accessToken) {
+  if (!isMapboxURL(url)) {
+    return url;
+  }
+  const urlObject = parseUrl(url);
+  urlObject.path = `/v4/${urlObject.authority}.json`;
+  urlObject.params.push('secure');
+  return makeAPIURL(urlObject, accessToken);
+}
+function normalizeStyleURL(url, accessToken) {
+  if (!isMapboxURL(url)) {
+    return url;
+  }
+  const urlObject = parseUrl(url);
+  urlObject.path = `/styles/v1${urlObject.path}`;
+  return makeAPIURL(urlObject, accessToken);
+}
+export default {
+  normalizeStyleURL,
+  normalizeSourceURL,
+  normalizeSpriteURL
+};

package/lib/Parser/PntsParser.js

@@ -0,0 +1,131 @@
+import * as THREE from 'three';
+import C3DTBatchTable from "../Core/3DTiles/C3DTBatchTable.js";
+const utf8Decoder = new TextDecoder();
+export default {
+  /** @module PntsParser */
+  /** Parse pnts buffer and extract THREE.Points and batch table
+   * @function parse
+   * @param {ArrayBuffer} buffer - the pnts buffer.
+   * @param {Object} registeredExtensions - 3D Tiles extensions registered
+   * in the layer
+   * @return {Promise} - a promise that resolves with an object containig a THREE.Points (point) and a batch table (batchTable).
+   *
+   */
+  parse: function (buffer, registeredExtensions) {
+    if (!buffer) {
+      throw new Error('No array buffer provided.');
+    }
+    const view = new DataView(buffer);
+    let byteOffset = 0;
+    const pntsHeader = {};
+    let batchTable = {};
+    let point = {};
+
+    // Magic type is unsigned char [4]
+    pntsHeader.magic = utf8Decoder.decode(new Uint8Array(buffer, byteOffset, 4));
+    byteOffset += 4;
+    if (pntsHeader.magic) {
+      // Version, byteLength, batchTableJSONByteLength, batchTableBinaryByteLength and batchTable types are uint32
+      pntsHeader.version = view.getUint32(byteOffset, true);
+      byteOffset += Uint32Array.BYTES_PER_ELEMENT;
+      pntsHeader.byteLength = view.getUint32(byteOffset, true);
+      byteOffset += Uint32Array.BYTES_PER_ELEMENT;
+      pntsHeader.FTJSONLength = view.getUint32(byteOffset, true);
+      byteOffset += Uint32Array.BYTES_PER_ELEMENT;
+      pntsHeader.FTBinaryLength = view.getUint32(byteOffset, true);
+      byteOffset += Uint32Array.BYTES_PER_ELEMENT;
+      pntsHeader.BTJSONLength = view.getUint32(byteOffset, true);
+      byteOffset += Uint32Array.BYTES_PER_ELEMENT;
+      pntsHeader.BTBinaryLength = view.getUint32(byteOffset, true);
+      byteOffset += Uint32Array.BYTES_PER_ELEMENT;
+
+      // feature table
+      let FTJSON = {};
+      if (pntsHeader.FTJSONLength > 0) {
+        const sizeBegin = byteOffset;
+        const jsonBuffer = buffer.slice(sizeBegin, pntsHeader.FTJSONLength + sizeBegin);
+        const content = utf8Decoder.decode(new Uint8Array(jsonBuffer));
+        FTJSON = JSON.parse(content);
+      }
+
+      // binary table
+      if (pntsHeader.FTBinaryLength > 0) {
+        point = parseFeatureBinary(buffer, byteOffset, pntsHeader.FTJSONLength);
+      }
+
+      // batch table
+      if (pntsHeader.BTJSONLength > 0) {
+        // parse batch table
+        const sizeBegin = byteOffset + pntsHeader.FTJSONLength + pntsHeader.FTBinaryLength;
+        const BTBuffer = buffer.slice(sizeBegin, pntsHeader.BTJSONLength + pntsHeader.BTBinaryLength + sizeBegin);
+
+        // If the BATCH_ID semantic is not defined, then the Batch Table stores per-point metadata, and the length of the Batch Table arrays will equal POINTS_LENGTH.
+        batchTable = new C3DTBatchTable(BTBuffer, pntsHeader.BTJSONLength, pntsHeader.BTBinaryLength, FTJSON.BATCH_ID && FTJSON.BATCH_LENGTH ? FTJSON.BATCH_LENGTH : FTJSON.POINTS_LENGTH, registeredExtensions);
+        point = setClassification(point, batchTable);
+      }
+      const pnts = {
+        point,
+        batchTable
+      };
+      return Promise.resolve(pnts);
+    } else {
+      throw new Error('Invalid pnts file.');
+    }
+  }
+};
+function parseFeatureBinary(array, byteOffset, FTJSONLength) {
+  // Init geometry
+  const geometry = new THREE.BufferGeometry();
+
+  // init Array feature binary
+  const subArrayJson = utf8Decoder.decode(new Uint8Array(array, byteOffset, FTJSONLength));
+  const parseJSON = JSON.parse(subArrayJson);
+  let lengthFeature;
+  if (parseJSON.POINTS_LENGTH) {
+    lengthFeature = parseJSON.POINTS_LENGTH;
+  }
+  if (parseJSON.POSITION) {
+    const byteOffsetPos = parseJSON.POSITION.byteOffset + subArrayJson.length + byteOffset;
+    const positionArray = new Float32Array(array, byteOffsetPos, lengthFeature * 3);
+    geometry.setAttribute('position', new THREE.BufferAttribute(positionArray, 3));
+  }
+  if (parseJSON.RGB) {
+    const byteOffsetCol = parseJSON.RGB.byteOffset + subArrayJson.length + byteOffset;
+    const colorArray = new Uint8Array(array, byteOffsetCol, lengthFeature * 3);
+    geometry.setAttribute('color', new THREE.BufferAttribute(colorArray, 3, true));
+  }
+  if (parseJSON.POSITION_QUANTIZED) {
+    throw new Error('For pnts loader, POSITION_QUANTIZED: not yet managed');
+  }
+  if (parseJSON.RGBA) {
+    throw new Error('For pnts loader, RGBA: not yet managed');
+  }
+  if (parseJSON.RGB565) {
+    throw new Error('For pnts loader, RGB565: not yet managed');
+  }
+  if (parseJSON.NORMAL) {
+    throw new Error('For pnts loader, NORMAL: not yet managed');
+  }
+  if (parseJSON.NORMAL_OCT16P) {
+    throw new Error('For pnts loader, NORMAL_OCT16P: not yet managed');
+  }
+  if (parseJSON.BATCH_ID) {
+    throw new Error('For pnts loader, BATCH_ID: not yet managed');
+  }
+
+  // Add RTC feature
+  const offset = parseJSON.RTC_CENTER ? new THREE.Vector3().fromArray(parseJSON.RTC_CENTER) : undefined;
+  return {
+    geometry,
+    offset
+  };
+}
+function setClassification(point, batchTable) {
+  if (!point.geometry) {
+    return;
+  }
+  if (batchTable.content && batchTable.content.Classification) {
+    point.geometry.setAttribute('classification', new THREE.BufferAttribute(new Uint8Array(batchTable.content.Classification), 1));
+  }
+  return point;
+}

package/lib/Parser/Potree2BinParser.js

@@ -0,0 +1,92 @@
+import * as THREE from 'three';
+import { spawn, Thread, Transfer } from 'threads';
+let _thread;
+function workerInstance() {
+  return new Worker(/* webpackChunkName: "itowns_potree2worker" */
+  new URL('../Worker/Potree2Worker.js', import.meta.url), {
+    type: 'module'
+  });
+}
+async function loader() {
+  if (_thread) {
+    return _thread;
+  }
+  _thread = await spawn(workerInstance());
+  return _thread;
+}
+function decoder(w, metadata) {
+  return metadata.encoding === 'BROTLI' ? w.parseBrotli : w.parse;
+}
+export default {
+  /**
+   * @return {Promise<void>}
+   */
+  terminate() {
+    const currentThread = _thread;
+    _thread = undefined;
+    return Thread.terminate(currentThread);
+  },
+  /** @module Potree2BinParser */
+  /** Parse .bin PotreeConverter 2.0 format and convert to a THREE.BufferGeometry
+   * @function parse
+   * @param {ArrayBuffer} buffer - the bin buffer.
+   * @param {Object} options
+   * @param {string[]} options.in.pointAttributes - the point attributes information contained in metadata.js
+   * @return {Promise} - a promise that resolves with a THREE.BufferGeometry.
+   *
+   */
+  parse: async function (buffer, options) {
+    const metadata = options.in.source.metadata;
+    const layer = options.out;
+    const pointAttributes = layer.pointAttributes;
+    const scale = metadata.scale;
+    const box = options.in.bbox;
+    const min = box.min;
+    const size = box.max.clone().sub(box.min);
+    const max = box.max;
+    const offset = metadata.offset;
+    const numPoints = options.in.numPoints;
+    const potreeLoader = await loader();
+    const decode = decoder(potreeLoader, metadata);
+    const data = await decode(Transfer(buffer), {
+      pointAttributes,
+      scale,
+      min,
+      max,
+      size,
+      offset,
+      numPoints
+    });
+    const buffers = data.attributeBuffers;
+    const geometry = new THREE.BufferGeometry();
+    Object.keys(buffers).forEach(property => {
+      const buffer = buffers[property].buffer;
+      if (property === 'position') {
+        geometry.setAttribute('position', new THREE.BufferAttribute(new Float32Array(buffer), 3));
+      } else if (property === 'rgba') {
+        geometry.setAttribute('color', new THREE.BufferAttribute(new Uint8Array(buffer), 4, true));
+      } else if (property === 'NORMAL') {
+        geometry.setAttribute('normal', new THREE.BufferAttribute(new Float32Array(buffer), 3));
+      } else if (property === 'INDICES') {
+        const bufferAttribute = new THREE.BufferAttribute(new Uint8Array(buffer), 4);
+        bufferAttribute.normalized = true;
+        geometry.setAttribute('indices', bufferAttribute);
+      } else {
+        const bufferAttribute = new THREE.BufferAttribute(new Float32Array(buffer), 1);
+        const batchAttribute = buffers[property].attribute;
+        bufferAttribute.potree = {
+          offset: buffers[property].offset,
+          scale: buffers[property].scale,
+          preciseBuffer: buffers[property].preciseBuffer,
+          range: batchAttribute.range
+        };
+        geometry.setAttribute(property, bufferAttribute);
+      }
+    });
+    geometry.computeBoundingBox();
+    return {
+      geometry,
+      density: data.density
+    };
+  }
+};

package/lib/Parser/PotreeBinParser.js

@@ -0,0 +1,106 @@
+import * as THREE from 'three';
+
+// See the different constants holding ordinal, name, numElements, byteSize in PointAttributes.cpp in PotreeConverter
+// elementByteSize is byteSize / numElements
+const POINT_ATTRIBUTES = {
+  POSITION_CARTESIAN: {
+    numElements: 3,
+    arrayType: Float32Array,
+    attributeName: 'position'
+  },
+  COLOR_PACKED: {
+    numElements: 4,
+    arrayType: Uint8Array,
+    attributeName: 'color',
+    normalized: true
+  },
+  INTENSITY: {
+    numElements: 1,
+    numByte: 2,
+    // using Float32Array because Float16Array doesn't exist
+    arrayType: Uint16Array,
+    attributeName: 'intensity',
+    normalized: true
+  },
+  CLASSIFICATION: {
+    numElements: 1,
+    arrayType: Uint8Array,
+    attributeName: 'classification',
+    normalized: true
+  },
+  // Note: at the time of writing, PotreeConverter will only generate normals in Oct16 format
+  // see PotreeConverter.cpp:121
+  // we keep all the historical value to still supports old conversion
+  NORMAL_SPHEREMAPPED: {
+    numElements: 2,
+    arrayType: Uint8Array,
+    attributeName: 'sphereMappedNormal'
+  },
+  // see https://web.archive.org/web/20150303053317/http://lgdv.cs.fau.de/get/1602
+  NORMAL_OCT16: {
+    numElements: 2,
+    arrayType: Uint8Array,
+    attributeName: 'oct16Normal'
+  },
+  NORMAL: {
+    numElements: 3,
+    arrayType: Float32Array,
+    attributeName: 'normal'
+  }
+};
+for (const potreeName of Object.keys(POINT_ATTRIBUTES)) {
+  const attr = POINT_ATTRIBUTES[potreeName];
+  attr.potreeName = potreeName;
+  attr.numByte = attr.numByte || attr.arrayType.BYTES_PER_ELEMENT;
+  attr.byteSize = attr.numElements * attr.numByte;
+  attr.normalized = attr.normalized || false;
+  // chrome is known to perform badly when we call a method without respecting its arity
+  const fnName = `getUint${attr.numByte * 8}`;
+  attr.getValue = attr.numByte === 1 ? function (view, offset) {
+    return view[fnName](offset);
+  } : function (view, offset) {
+    return view[fnName](offset, true);
+  };
+}
+export default {
+  /** @module PotreeBinParser */
+  /** Parse .bin PotreeConverter format and convert to a THREE.BufferGeometry
+   * @function parse
+   * @param {ArrayBuffer} buffer - the bin buffer.
+   * @param {Object} options
+   * @param {string[]} options.in.pointAttributes - the point attributes information contained in cloud.js
+   * @return {Promise} - a promise that resolves with a THREE.BufferGeometry.
+   *
+   */
+  parse: function (buffer, options) {
+    if (!buffer) {
+      throw new Error('No array buffer provided.');
+    }
+    const view = new DataView(buffer);
+    // Format: X1,Y1,Z1,R1,G1,B1,A1,[...],XN,YN,ZN,RN,GN,BN,AN
+    let pointByteSize = 0;
+    for (const potreeName of options.in.pointAttributes) {
+      pointByteSize += POINT_ATTRIBUTES[potreeName].byteSize;
+    }
+    const numPoints = Math.floor(buffer.byteLength / pointByteSize);
+    const geometry = new THREE.BufferGeometry();
+    let elemOffset = 0;
+    let attrOffset = 0;
+    for (const potreeName of options.in.pointAttributes) {
+      const attr = POINT_ATTRIBUTES[potreeName];
+      const arrayLength = attr.numElements * numPoints;
+      const array = new attr.arrayType(arrayLength);
+      for (let arrayOffset = 0; arrayOffset < arrayLength; arrayOffset += attr.numElements) {
+        for (let elemIdx = 0; elemIdx < attr.numElements; elemIdx++) {
+          array[arrayOffset + elemIdx] = attr.getValue(view, attrOffset + elemIdx * attr.numByte);
+        }
+        attrOffset += pointByteSize;
+      }
+      elemOffset += attr.byteSize;
+      attrOffset = elemOffset;
+      geometry.setAttribute(attr.attributeName, new THREE.BufferAttribute(array, attr.numElements, attr.normalized));
+    }
+    geometry.computeBoundingBox();
+    return Promise.resolve(geometry);
+  }
+};

package/lib/Parser/PotreeCinParser.js

@@ -0,0 +1,29 @@
+import * as THREE from 'three';
+export default {
+  /** @module PotreeCinParser */
+  /** Parse .cin PotreeConverter format (see {@link https://github.com/peppsac/PotreeConverter/tree/custom_bin}) and convert to a THREE.BufferGeometry
+   * @function parse
+   * @param {ArrayBuffer} buffer - the cin buffer.
+   * @return {Promise} - a promise that resolves with a THREE.BufferGeometry.
+   *
+   */
+  parse: function (buffer) {
+    if (!buffer) {
+      throw new Error('No array buffer provided.');
+    }
+
+    // Format: MinX,MinY,MinZ,MaxX,MaxY,MaxZ,X1,Y1,Z1,[...],XN,YN,ZN,R1,G1,B1,A1,[...],RN,GN,BN,AN
+    const view = new DataView(buffer, 0, 6 * 4);
+    const min = new THREE.Vector3(view.getFloat32(0, true), view.getFloat32(4, true), view.getFloat32(8, true));
+    const max = new THREE.Vector3(view.getFloat32(12, true), view.getFloat32(16, true), view.getFloat32(20, true));
+    const box = new THREE.Box3(min, max);
+    const numPoints = Math.floor((buffer.byteLength - 24) / 16);
+    const positions = new Float32Array(buffer, 24, 3 * numPoints);
+    const colors = new Uint8Array(buffer, 24 + 3 * 4 * numPoints, 4 * numPoints);
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+    geometry.setAttribute('color', new THREE.BufferAttribute(colors, 4, true));
+    geometry.boundingBox = box;
+    return Promise.resolve(geometry);
+  }
+};