itowns 2.44.3-next.8 → 2.45.0

package/lib/Parser/ISGParser.js

@@ -1,71 +0,0 @@
-import * as THREE from 'three';
-import GeoidGrid from "../Core/Geographic/GeoidGrid.js";
-import Extent from "../Core/Geographic/Extent.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

@@ -1,25 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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

@@ -1,131 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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);
-  }
-};