@loaders.gl/las 3.1.0-alpha.4 → 3.1.0-beta.3

package/dist/es5/lib/laslaz-decoder.js

@@ -7,31 +7,27 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.LASModuleWasLoaded = exports.LASFile = void 0;
 
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
-var _lazPerf = _interopRequireDefault(require("../libs/laz-perf"));
+var _lazPerf = _interopRequireDefault(require("./libs/laz-perf"));
 
-var Module = null;
-var POINT_FORMAT_READERS = {
-  0: function _(dv) {
+let Module = null;
+const POINT_FORMAT_READERS = {
+  0: dv => {
     return {
       position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],
       intensity: dv.getUint16(12, true),
       classification: dv.getUint8(15)
     };
   },
-  1: function _(dv) {
+  1: dv => {
     return {
       position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],
       intensity: dv.getUint16(12, true),
       classification: dv.getUint8(15)
     };
   },
-  2: function _(dv) {
+  2: dv => {
     return {
       position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],
       intensity: dv.getUint16(12, true),
@@ -39,7 +35,7 @@ var POINT_FORMAT_READERS = {
       color: [dv.getUint16(20, true), dv.getUint16(22, true), dv.getUint16(24, true)]
     };
   },
-  3: function _(dv) {
+  3: dv => {
     return {
       position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],
       intensity: dv.getUint16(12, true),
@@ -49,21 +45,18 @@ var POINT_FORMAT_READERS = {
   }
 };
 
-function readAs(buf) {
-  var Type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var offset = arguments.length > 2 ? arguments[2] : undefined;
-  var count = arguments.length > 3 ? arguments[3] : undefined;
+function readAs(buf, Type = {}, offset, count) {
   count = count === undefined || count === 0 ? 1 : count;
-  var sub = buf.slice(offset, offset + Type.BYTES_PER_ELEMENT * count);
-  var r = new Type(sub);
+  const sub = buf.slice(offset, offset + Type.BYTES_PER_ELEMENT * count);
+  const r = new Type(sub);
 
   if (count === 1) {
     return r[0];
   }
 
-  var ret = [];
+  const ret = [];
 
-  for (var i = 0; i < count; i++) {
+  for (let i = 0; i < count; i++) {
     ret.push(r[i]);
   }
 
@@ -71,8 +64,8 @@ function readAs(buf) {
 }
 
 function parseLASHeader(arraybuffer) {
-  var start = 32 * 3 + 35;
-  var o = {
+  let start = 32 * 3 + 35;
+  const o = {
     pointsOffset: readAs(arraybuffer, Uint32Array, 32 * 3),
     pointsFormatId: readAs(arraybuffer, Uint8Array, 32 * 3 + 8),
     pointsStructSize: readAs(arraybuffer, Uint16Array, 32 * 3 + 8 + 1),
@@ -82,16 +75,15 @@ function parseLASHeader(arraybuffer) {
   start += 24;
   o.offset = readAs(arraybuffer, Float64Array, start, 3);
   start += 24;
-  var bounds = readAs(arraybuffer, Float64Array, start, 6);
+  const bounds = readAs(arraybuffer, Float64Array, start, 6);
   start += 48;
   o.maxs = [bounds[0], bounds[2], bounds[4]];
   o.mins = [bounds[1], bounds[3], bounds[5]];
   return o;
 }
 
-var LASLoader = function () {
-  function LASLoader(arraybuffer) {
-    (0, _classCallCheck2.default)(this, LASLoader);
+class LASLoader {
+  constructor(arraybuffer) {
     (0, _defineProperty2.default)(this, "arraybuffer", void 0);
     (0, _defineProperty2.default)(this, "readOffset", 0);
     (0, _defineProperty2.default)(this, "header", {
@@ -111,79 +103,76 @@ var LASLoader = function () {
     this.arraybuffer = arraybuffer;
   }
 
-  (0, _createClass2.default)(LASLoader, [{
-    key: "open",
-    value: function open() {
-      return true;
-    }
-  }, {
-    key: "getHeader",
-    value: function getHeader() {
-      this.header = parseLASHeader(this.arraybuffer);
-      return this.header;
-    }
-  }, {
-    key: "readData",
-    value: function readData(count, skip) {
-      var header = this.header,
-          arraybuffer = this.arraybuffer;
-
-      if (!header) {
-        throw new Error('Cannot start reading data till a header request is issued');
-      }
-
-      var readOffset = this.readOffset;
-      var start;
+  open() {
+    return true;
+  }
 
-      if (skip <= 1) {
-        count = Math.min(count, header.pointsCount - readOffset);
-        start = header.pointsOffset + readOffset * header.pointsStructSize;
-        var end = start + count * header.pointsStructSize;
-        readOffset += count;
-        this.readOffset = readOffset;
-        return {
-          buffer: arraybuffer.slice(start, end),
-          count: count,
-          hasMoreData: readOffset < header.pointsCount
-        };
-      }
+  getHeader() {
+    this.header = parseLASHeader(this.arraybuffer);
+    return this.header;
+  }
 
-      var pointsToRead = Math.min(count * skip, header.pointsCount - readOffset);
-      var bufferSize = Math.ceil(pointsToRead / skip);
-      var pointsRead = 0;
-      var buf = new Uint8Array(bufferSize * header.pointsStructSize);
+  readData(count, skip) {
+    const {
+      header,
+      arraybuffer
+    } = this;
 
-      for (var i = 0; i < pointsToRead; i++) {
-        if (i % skip === 0) {
-          start = header.pointsOffset + readOffset * header.pointsStructSize;
-          var src = new Uint8Array(arraybuffer, start, header.pointsStructSize);
-          buf.set(src, pointsRead * header.pointsStructSize);
-          pointsRead++;
-        }
+    if (!header) {
+      throw new Error('Cannot start reading data till a header request is issued');
+    }
 
-        readOffset++;
-      }
+    let {
+      readOffset
+    } = this;
+    let start;
 
+    if (skip <= 1) {
+      count = Math.min(count, header.pointsCount - readOffset);
+      start = header.pointsOffset + readOffset * header.pointsStructSize;
+      const end = start + count * header.pointsStructSize;
+      readOffset += count;
       this.readOffset = readOffset;
       return {
-        buffer: buf.buffer,
-        count: pointsRead,
+        buffer: arraybuffer.slice(start, end),
+        count,
         hasMoreData: readOffset < header.pointsCount
       };
     }
-  }, {
-    key: "close",
-    value: function close() {
-      this.arraybuffer = null;
-      return true;
+
+    const pointsToRead = Math.min(count * skip, header.pointsCount - readOffset);
+    const bufferSize = Math.ceil(pointsToRead / skip);
+    let pointsRead = 0;
+    const buf = new Uint8Array(bufferSize * header.pointsStructSize);
+
+    for (let i = 0; i < pointsToRead; i++) {
+      if (i % skip === 0) {
+        start = header.pointsOffset + readOffset * header.pointsStructSize;
+        const src = new Uint8Array(arraybuffer, start, header.pointsStructSize);
+        buf.set(src, pointsRead * header.pointsStructSize);
+        pointsRead++;
+      }
+
+      readOffset++;
     }
-  }]);
-  return LASLoader;
-}();
 
-var LAZLoader = function () {
-  function LAZLoader(arraybuffer) {
-    (0, _classCallCheck2.default)(this, LAZLoader);
+    this.readOffset = readOffset;
+    return {
+      buffer: buf.buffer,
+      count: pointsRead,
+      hasMoreData: readOffset < header.pointsCount
+    };
+  }
+
+  close() {
+    this.arraybuffer = null;
+    return true;
+  }
+
+}
+
+class LAZLoader {
+  constructor(arraybuffer) {
     (0, _defineProperty2.default)(this, "arraybuffer", void 0);
     (0, _defineProperty2.default)(this, "instance", null);
     (0, _defineProperty2.default)(this, "header", null);
@@ -194,106 +183,103 @@ var LAZLoader = function () {
     }
   }
 
-  (0, _createClass2.default)(LAZLoader, [{
-    key: "open",
-    value: function open() {
-      try {
-        var arraybuffer = this.arraybuffer;
-        this.instance = new Module.LASZip();
-        var abInt = new Uint8Array(arraybuffer);
-
-        var buf = Module._malloc(arraybuffer.byteLength);
-
-        this.instance.arraybuffer = arraybuffer;
-        this.instance.buf = buf;
-        Module.HEAPU8.set(abInt, buf);
-        this.instance.open(buf, arraybuffer.byteLength);
-        this.instance.readOffset = 0;
-        return true;
-      } catch (error) {
-        throw new Error("Failed to open file: ".concat(error.message));
-      }
+  open() {
+    try {
+      const {
+        arraybuffer
+      } = this;
+      this.instance = new Module.LASZip();
+      const abInt = new Uint8Array(arraybuffer);
+
+      const buf = Module._malloc(arraybuffer.byteLength);
+
+      this.instance.arraybuffer = arraybuffer;
+      this.instance.buf = buf;
+      Module.HEAPU8.set(abInt, buf);
+      this.instance.open(buf, arraybuffer.byteLength);
+      this.instance.readOffset = 0;
+      return true;
+    } catch (error) {
+      throw new Error("Failed to open file: ".concat(error.message));
     }
-  }, {
-    key: "getHeader",
-    value: function getHeader() {
-      if (!this.instance) {
-        throw new Error('You need to open the file before trying to read header');
-      }
+  }
 
-      try {
-        var header = parseLASHeader(this.instance.arraybuffer);
-        header.pointsFormatId &= 0x3f;
-        this.header = header;
-        return header;
-      } catch (error) {
-        throw new Error("Failed to get header: ".concat(error.message));
-      }
+  getHeader() {
+    if (!this.instance) {
+      throw new Error('You need to open the file before trying to read header');
     }
-  }, {
-    key: "readData",
-    value: function readData(count, offset, skip) {
-      if (!this.instance) {
-        throw new Error('You need to open the file before trying to read stuff');
-      }
 
-      var header = this.header,
-          instance = this.instance;
+    try {
+      const header = parseLASHeader(this.instance.arraybuffer);
+      header.pointsFormatId &= 0x3f;
+      this.header = header;
+      return header;
+    } catch (error) {
+      throw new Error("Failed to get header: ".concat(error.message));
+    }
+  }
+
+  readData(count, offset, skip) {
+    if (!this.instance) {
+      throw new Error('You need to open the file before trying to read stuff');
+    }
 
-      if (!header) {
-        throw new Error('You need to query header before reading, I maintain state that way, sorry :(');
-      }
+    const {
+      header,
+      instance
+    } = this;
 
-      try {
-        var pointsToRead = Math.min(count * skip, header.pointsCount - instance.readOffset);
-        var bufferSize = Math.ceil(pointsToRead / skip);
-        var pointsRead = 0;
-        var thisBuf = new Uint8Array(bufferSize * header.pointsStructSize);
+    if (!header) {
+      throw new Error('You need to query header before reading, I maintain state that way, sorry :(');
+    }
 
-        var bufRead = Module._malloc(header.pointsStructSize);
+    try {
+      const pointsToRead = Math.min(count * skip, header.pointsCount - instance.readOffset);
+      const bufferSize = Math.ceil(pointsToRead / skip);
+      let pointsRead = 0;
+      const thisBuf = new Uint8Array(bufferSize * header.pointsStructSize);
 
-        for (var i = 0; i < pointsToRead; i++) {
-          instance.getPoint(bufRead);
+      const bufRead = Module._malloc(header.pointsStructSize);
 
-          if (i % skip === 0) {
-            var a = new Uint8Array(Module.HEAPU8.buffer, bufRead, header.pointsStructSize);
-            thisBuf.set(a, pointsRead * header.pointsStructSize);
-            pointsRead++;
-          }
+      for (let i = 0; i < pointsToRead; i++) {
+        instance.getPoint(bufRead);
 
-          instance.readOffset++;
+        if (i % skip === 0) {
+          const a = new Uint8Array(Module.HEAPU8.buffer, bufRead, header.pointsStructSize);
+          thisBuf.set(a, pointsRead * header.pointsStructSize);
+          pointsRead++;
         }
 
-        return {
-          buffer: thisBuf.buffer,
-          count: pointsRead,
-          hasMoreData: instance.readOffset < header.pointsCount
-        };
-      } catch (error) {
-        throw new Error("Failed to read data: ".concat(error.message));
+        instance.readOffset++;
       }
+
+      return {
+        buffer: thisBuf.buffer,
+        count: pointsRead,
+        hasMoreData: instance.readOffset < header.pointsCount
+      };
+    } catch (error) {
+      throw new Error("Failed to read data: ".concat(error.message));
     }
-  }, {
-    key: "close",
-    value: function close() {
-      try {
-        if (this.instance !== null) {
-          this.instance.delete();
-          this.instance = null;
-        }
+  }
 
-        return true;
-      } catch (error) {
-        throw new Error("Failed to close file: ".concat(error.message));
+  close() {
+    try {
+      if (this.instance !== null) {
+        this.instance.delete();
+        this.instance = null;
       }
+
+      return true;
+    } catch (error) {
+      throw new Error("Failed to close file: ".concat(error.message));
     }
-  }]);
-  return LAZLoader;
-}();
+  }
 
-var LASDecoder = function () {
-  function LASDecoder(buffer, len, header) {
-    (0, _classCallCheck2.default)(this, LASDecoder);
+}
+
+class LASDecoder {
+  constructor(buffer, len, header) {
     (0, _defineProperty2.default)(this, "arrayb", void 0);
     (0, _defineProperty2.default)(this, "decoder", void 0);
     (0, _defineProperty2.default)(this, "pointsCount", void 0);
@@ -312,23 +298,19 @@ var LASDecoder = function () {
     this.maxs = header.maxs;
   }
 
-  (0, _createClass2.default)(LASDecoder, [{
-    key: "getPoint",
-    value: function getPoint(index) {
-      if (index < 0 || index >= this.pointsCount) {
-        throw new Error('Point index out of range');
-      }
-
-      var dv = new DataView(this.arrayb, index * this.pointSize, this.pointSize);
-      return this.decoder(dv);
+  getPoint(index) {
+    if (index < 0 || index >= this.pointsCount) {
+      throw new Error('Point index out of range');
     }
-  }]);
-  return LASDecoder;
-}();
 
-var LASFile = function () {
-  function LASFile(arraybuffer) {
-    (0, _classCallCheck2.default)(this, LASFile);
+    const dv = new DataView(this.arrayb, index * this.pointSize, this.pointSize);
+    return this.decoder(dv);
+  }
+
+}
+
+class LASFile {
+  constructor(arraybuffer) {
     (0, _defineProperty2.default)(this, "arraybuffer", void 0);
     (0, _defineProperty2.default)(this, "formatId", 0);
     (0, _defineProperty2.default)(this, "loader", void 0);
@@ -351,62 +333,53 @@ var LASFile = function () {
     this.loader = this.isCompressed ? new LAZLoader(this.arraybuffer) : new LASLoader(this.arraybuffer);
   }
 
-  (0, _createClass2.default)(LASFile, [{
-    key: "determineFormat",
-    value: function determineFormat() {
-      var formatId = readAs(this.arraybuffer, Uint8Array, 32 * 3 + 8);
-      var bit7 = (formatId & 0x80) >> 7;
-      var bit6 = (formatId & 0x40) >> 6;
+  determineFormat() {
+    const formatId = readAs(this.arraybuffer, Uint8Array, 32 * 3 + 8);
+    const bit7 = (formatId & 0x80) >> 7;
+    const bit6 = (formatId & 0x40) >> 6;
 
-      if (bit7 === 1 && bit6 === 1) {
-        throw new Error('Old style compression not supported');
-      }
-
-      this.formatId = formatId & 0x3f;
-      this.isCompressed = bit7 === 1 || bit6 === 1;
-    }
-  }, {
-    key: "determineVersion",
-    value: function determineVersion() {
-      var ver = new Int8Array(this.arraybuffer, 24, 2);
-      this.version = ver[0] * 10 + ver[1];
-      this.versionAsString = "".concat(ver[0], ".").concat(ver[1]);
-      return this.version;
+    if (bit7 === 1 && bit6 === 1) {
+      throw new Error('Old style compression not supported');
     }
-  }, {
-    key: "open",
-    value: function open() {
-      if (this.loader.open()) {
-        this.isOpen = true;
-      }
-    }
-  }, {
-    key: "getHeader",
-    value: function getHeader() {
-      return this.loader.getHeader();
-    }
-  }, {
-    key: "readData",
-    value: function readData(count, start, skip) {
-      return this.loader.readData(count, start, skip);
-    }
-  }, {
-    key: "close",
-    value: function close() {
-      if (this.loader.close()) {
-        this.isOpen = false;
-      }
+
+    this.formatId = formatId & 0x3f;
+    this.isCompressed = bit7 === 1 || bit6 === 1;
+  }
+
+  determineVersion() {
+    const ver = new Int8Array(this.arraybuffer, 24, 2);
+    this.version = ver[0] * 10 + ver[1];
+    this.versionAsString = "".concat(ver[0], ".").concat(ver[1]);
+    return this.version;
+  }
+
+  open() {
+    if (this.loader.open()) {
+      this.isOpen = true;
     }
-  }, {
-    key: "getUnpacker",
-    value: function getUnpacker() {
-      return LASDecoder;
+  }
+
+  getHeader() {
+    return this.loader.getHeader();
+  }
+
+  readData(count, start, skip) {
+    return this.loader.readData(count, start, skip);
+  }
+
+  close() {
+    if (this.loader.close()) {
+      this.isOpen = false;
     }
-  }]);
-  return LASFile;
-}();
+  }
+
+  getUnpacker() {
+    return LASDecoder;
+  }
+
+}
 
 exports.LASFile = LASFile;
-var LASModuleWasLoaded = false;
+const LASModuleWasLoaded = false;
 exports.LASModuleWasLoaded = LASModuleWasLoaded;
 //# sourceMappingURL=laslaz-decoder.js.map