@loaders.gl/las 3.1.0-beta.4 → 3.1.1

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

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