@loaders.gl/pointclouds 0.0.0-stage → 5.0.0-beta.1

package/dist/las/lib/laz-rs-wasm/laslaz-decoder.cjs

@@ -0,0 +1,631 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/las/lib/laz-rs-wasm/laslaz-decoder.ts
+var laslaz_decoder_exports = {};
+__export(laslaz_decoder_exports, {
+  LASFile: () => LASFile
+});
+module.exports = __toCommonJS(laslaz_decoder_exports);
+
+// src/las/libs/laz-rs-wasm/laz_rs_wasm.js
+var wasm;
+var cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
+}
+var cachedTextDecoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-8", { ignoreBOM: true, fatal: true }) : { decode: () => {
+  throw Error("TextDecoder not available");
+} };
+if (typeof TextDecoder !== "undefined") {
+  cachedTextDecoder.decode();
+}
+function _assertClass(instance, klass) {
+  if (!(instance instanceof klass)) {
+    throw new Error(`expected instance of ${klass.name}`);
+  }
+  return instance.ptr;
+}
+function takeFromExternrefTable0(idx) {
+  const value = wasm.__wbindgen_export_0.get(idx);
+  wasm.__externref_table_dealloc(idx);
+  return value;
+}
+var WASM_VECTOR_LEN = 0;
+function passArray8ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 1, 1) >>> 0;
+  getUint8ArrayMemory0().set(arg, ptr / 1);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
+var cachedTextEncoder = typeof TextEncoder !== "undefined" ? new TextEncoder("utf-8") : { encode: () => {
+  throw Error("TextEncoder not available");
+} };
+var encodeString = typeof cachedTextEncoder.encodeInto === "function" ? function(arg, view) {
+  return cachedTextEncoder.encodeInto(arg, view);
+} : function(arg, view) {
+  const buf = cachedTextEncoder.encode(arg);
+  view.set(buf);
+  return {
+    read: arg.length,
+    written: buf.length
+  };
+};
+var WasmLasZipDecompressorFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_wasmlaszipdecompressor_free(ptr >>> 0, 1));
+var WasmLasZipDecompressor = class {
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    WasmLasZipDecompressorFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_wasmlaszipdecompressor_free(ptr, 0);
+  }
+  /**
+   * @returns {WasmQuickHeader}
+   */
+  get header() {
+    const ret = wasm.__wbg_get_wasmlaszipdecompressor_header(this.__wbg_ptr);
+    return WasmQuickHeader.__wrap(ret);
+  }
+  /**
+   * @param {WasmQuickHeader} arg0
+   */
+  set header(arg0) {
+    _assertClass(arg0, WasmQuickHeader);
+    var ptr0 = arg0.__destroy_into_raw();
+    wasm.__wbg_set_wasmlaszipdecompressor_header(this.__wbg_ptr, ptr0);
+  }
+  /**
+   * @param {Uint8Array} buf
+   */
+  constructor(buf) {
+    const ret = wasm.wasmlaszipdecompressor_new(buf);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    this.__wbg_ptr = ret[0] >>> 0;
+    WasmLasZipDecompressorFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * @param {Uint8Array} out
+   */
+  decompress_many(out) {
+    var ptr0 = passArray8ToWasm0(out, wasm.__wbindgen_malloc);
+    var len0 = WASM_VECTOR_LEN;
+    const ret = wasm.wasmlaszipdecompressor_decompress_many(this.__wbg_ptr, ptr0, len0, out);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+};
+var WasmQuickHeaderFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_wasmquickheader_free(ptr >>> 0, 1));
+var WasmQuickHeader = class _WasmQuickHeader {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(_WasmQuickHeader.prototype);
+    obj.__wbg_ptr = ptr;
+    WasmQuickHeaderFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    WasmQuickHeaderFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_wasmquickheader_free(ptr, 0);
+  }
+  /**
+   * @returns {number}
+   */
+  get major() {
+    const ret = wasm.__wbg_get_wasmquickheader_major(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * @param {number} arg0
+   */
+  set major(arg0) {
+    wasm.__wbg_set_wasmquickheader_major(this.__wbg_ptr, arg0);
+  }
+  /**
+   * @returns {number}
+   */
+  get minor() {
+    const ret = wasm.__wbg_get_wasmquickheader_minor(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * @param {number} arg0
+   */
+  set minor(arg0) {
+    wasm.__wbg_set_wasmquickheader_minor(this.__wbg_ptr, arg0);
+  }
+  /**
+   * @returns {number}
+   */
+  get offset_to_points() {
+    const ret = wasm.__wbg_get_wasmquickheader_offset_to_points(this.__wbg_ptr);
+    return ret >>> 0;
+  }
+  /**
+   * @param {number} arg0
+   */
+  set offset_to_points(arg0) {
+    wasm.__wbg_set_wasmquickheader_offset_to_points(this.__wbg_ptr, arg0);
+  }
+  /**
+   * @returns {number}
+   */
+  get num_vlrs() {
+    const ret = wasm.__wbg_get_wasmquickheader_num_vlrs(this.__wbg_ptr);
+    return ret >>> 0;
+  }
+  /**
+   * @param {number} arg0
+   */
+  set num_vlrs(arg0) {
+    wasm.__wbg_set_wasmquickheader_num_vlrs(this.__wbg_ptr, arg0);
+  }
+  /**
+   * @returns {number}
+   */
+  get point_format_id() {
+    const ret = wasm.__wbg_get_wasmquickheader_point_format_id(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * @param {number} arg0
+   */
+  set point_format_id(arg0) {
+    wasm.__wbg_set_wasmquickheader_point_format_id(this.__wbg_ptr, arg0);
+  }
+  /**
+   * @returns {number}
+   */
+  get point_size() {
+    const ret = wasm.__wbg_get_wasmquickheader_point_size(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * @param {number} arg0
+   */
+  set point_size(arg0) {
+    wasm.__wbg_set_wasmquickheader_point_size(this.__wbg_ptr, arg0);
+  }
+  /**
+   * @returns {bigint}
+   */
+  get num_points() {
+    const ret = wasm.__wbg_get_wasmquickheader_num_points(this.__wbg_ptr);
+    return BigInt.asUintN(64, ret);
+  }
+  /**
+   * @param {bigint} arg0
+   */
+  set num_points(arg0) {
+    wasm.__wbg_set_wasmquickheader_num_points(this.__wbg_ptr, arg0);
+  }
+  /**
+   * @returns {number}
+   */
+  get header_size() {
+    const ret = wasm.__wbg_get_wasmquickheader_header_size(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * @param {number} arg0
+   */
+  set header_size(arg0) {
+    wasm.__wbg_set_wasmquickheader_header_size(this.__wbg_ptr, arg0);
+  }
+};
+
+// src/las/lib/laz-rs-wasm/laslaz-decoder.ts
+var 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: (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) => {
+    return {
+      position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],
+      intensity: dv.getUint16(12, true),
+      classification: dv.getUint8(15),
+      color: [dv.getUint16(20, true), dv.getUint16(22, true), dv.getUint16(24, true)]
+    };
+  },
+  3: (dv) => {
+    return {
+      position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],
+      intensity: dv.getUint16(12, true),
+      classification: dv.getUint8(15),
+      color: [dv.getUint16(28, true), dv.getUint16(30, true), dv.getUint16(32, true)]
+    };
+  },
+  4: (dv) => {
+    return {
+      position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],
+      intensity: dv.getUint16(12, true),
+      classification: dv.getUint8(15)
+    };
+  },
+  5: (dv) => {
+    return {
+      position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],
+      intensity: dv.getUint16(12, true),
+      classification: dv.getUint8(15),
+      color: [dv.getUint16(28, true), dv.getUint16(30, true), dv.getUint16(32, true)]
+    };
+  },
+  6: (dv) => {
+    return {
+      position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],
+      intensity: dv.getUint16(12, true),
+      classification: dv.getUint8(16)
+    };
+  },
+  7: (dv) => {
+    return {
+      position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],
+      intensity: dv.getUint16(12, true),
+      classification: dv.getUint8(16),
+      color: [dv.getUint16(30, true), dv.getUint16(32, true), dv.getUint16(34, true)]
+    };
+  },
+  8: (dv) => {
+    return {
+      position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],
+      intensity: dv.getUint16(12, true),
+      classification: dv.getUint8(16),
+      color: [dv.getUint16(30, true), dv.getUint16(32, true), dv.getUint16(34, true)]
+    };
+  },
+  9: (dv) => {
+    return {
+      position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],
+      intensity: dv.getUint16(12, true),
+      classification: dv.getUint8(16)
+    };
+  },
+  10: (dv) => {
+    return {
+      position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],
+      intensity: dv.getUint16(12, true),
+      classification: dv.getUint8(16),
+      color: [dv.getUint16(30, true), dv.getUint16(32, true), dv.getUint16(34, true)]
+    };
+  }
+};
+function readAs(buf, Type = {}, offset, count) {
+  count = count === void 0 || count === 0 ? 1 : count;
+  const sub = buf.slice(offset, offset + Type.BYTES_PER_ELEMENT * count);
+  const r = new Type(sub);
+  if (count === 1) {
+    return r[0];
+  }
+  const ret = [];
+  for (let i = 0; i < count; i++) {
+    ret.push(r[i]);
+  }
+  return ret;
+}
+function parseLASHeader(arraybuffer) {
+  const ver = new Uint8Array(arraybuffer, 24, 2);
+  const version = ver[0] * 10 + ver[1];
+  const versionAsString = `${ver[0]}.${ver[1]}`;
+  const rawPointsFormatId = readAs(arraybuffer, Uint8Array, 32 * 3 + 8);
+  const bit7 = (rawPointsFormatId & 128) >> 7;
+  const bit6 = (rawPointsFormatId & 64) >> 6;
+  const isCompressed = bit7 === 1 || bit6 === 1;
+  const pointsFormatId = rawPointsFormatId & 63;
+  const o = {
+    pointsOffset: readAs(arraybuffer, Uint32Array, 32 * 3),
+    pointsFormatId,
+    pointsStructSize: readAs(arraybuffer, Uint16Array, 32 * 3 + 8 + 1),
+    pointsCount: readAs(arraybuffer, Uint32Array, 32 * 3 + 11),
+    versionAsString,
+    isCompressed
+  };
+  let start = 32 * 3 + 35;
+  o.scale = readAs(arraybuffer, Float64Array, start, 3);
+  start += 24;
+  o.offset = readAs(arraybuffer, Float64Array, start, 3);
+  start += 24;
+  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]];
+  start += 20;
+  if (version === 14) {
+    o.pointsCount = Number(readAs(arraybuffer, BigUint64Array, start));
+  }
+  const colorPointFormats = /* @__PURE__ */ new Set([2, 3, 5, 7, 8, 10]);
+  o.hasColor = colorPointFormats.has(pointsFormatId);
+  return o;
+}
+var LASLoader = class {
+  arraybuffer;
+  readOffset = 0;
+  header = null;
+  constructor(arraybuffer) {
+    this.arraybuffer = arraybuffer;
+  }
+  /**
+   * @returns boolean
+   */
+  open() {
+    return true;
+  }
+  /**
+   * Parsing of incoming binary
+   * @returns LASHeader
+   */
+  getHeader() {
+    this.header = parseLASHeader(this.arraybuffer);
+    return this.header;
+  }
+  /**
+   * Reading data
+   * @param count
+   * @returns LasData
+   */
+  readData(count) {
+    const { header, arraybuffer } = this;
+    if (!header) {
+      throw new Error("Cannot start reading data till a header request is issued");
+    }
+    let { readOffset } = this;
+    count = Math.min(count, header.pointsCount - readOffset);
+    const start = header.pointsOffset + readOffset * header.pointsStructSize;
+    const end = start + count * header.pointsStructSize;
+    readOffset += count;
+    this.readOffset = readOffset;
+    return {
+      buffer: arraybuffer.slice(start, end),
+      count,
+      hasMoreData: readOffset < header.pointsCount
+    };
+  }
+  /**
+   * Method which brings data to null to close the file
+   * @returns
+   */
+  close() {
+    this.arraybuffer = null;
+    return true;
+  }
+};
+var LAZLoader = class {
+  arraybuffer;
+  readOffset = 0;
+  instance = null;
+  header = null;
+  constructor(arraybuffer) {
+    this.arraybuffer = arraybuffer;
+  }
+  /**
+   * Opens the file
+   * @returns boolean
+   */
+  open() {
+    try {
+      const abInt = new Uint8Array(this.arraybuffer);
+      this.instance = new WasmLasZipDecompressor(abInt);
+      return true;
+    } catch (error) {
+      throw new Error(`Failed to open file: ${error.message}`);
+    }
+  }
+  getHeader() {
+    try {
+      this.header = parseLASHeader(this.arraybuffer);
+      return this.header;
+    } catch (error) {
+      throw new Error(`Failed to get header: ${error.message}`);
+    }
+  }
+  /**
+   * @param count
+   * @returns LASData
+   */
+  readData(count) {
+    if (!this.instance) {
+      throw new Error("You need to open the file before trying to read stuff");
+    }
+    const { header, instance } = this;
+    if (!header) {
+      throw new Error(
+        "You need to query header before reading, I maintain state that way, sorry :("
+      );
+    }
+    try {
+      const pointsToRead = Math.min(count, header.pointsCount - this.readOffset);
+      const buf = new Uint8Array(pointsToRead * header.pointsStructSize);
+      const bufRead = new Uint8Array(header.pointsStructSize);
+      for (let i = 0; i < pointsToRead; i++) {
+        instance.decompress_many(bufRead);
+        buf.set(bufRead, i * header.pointsStructSize);
+        this.readOffset++;
+      }
+      return {
+        buffer: buf.buffer,
+        count: pointsToRead,
+        hasMoreData: this.readOffset < header.pointsCount
+      };
+    } catch (error) {
+      throw new Error(`Failed to read data: ${error.message}`);
+    }
+  }
+  /**
+   * Deletes the instance
+   * @returns boolean
+   */
+  close() {
+    try {
+      if (this.instance !== null) {
+        this.instance.free();
+        this.instance = null;
+      }
+      this.arraybuffer = null;
+      return true;
+    } catch (error) {
+      throw new Error(`Failed to close file: ${error.message}`);
+    }
+  }
+};
+var LASDecoder = class {
+  arrayb;
+  decoder;
+  pointsCount;
+  pointSize;
+  constructor(buffer, len, header) {
+    this.arrayb = buffer;
+    this.decoder = POINT_FORMAT_READERS[header.pointsFormatId];
+    this.pointsCount = len;
+    this.pointSize = header.pointsStructSize;
+  }
+  /**
+   * Decodes data depends on this point size
+   * @param index
+   * @returns New object
+   */
+  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);
+  }
+};
+var LASFile = class {
+  arraybuffer;
+  formatId = 0;
+  loader;
+  isCompressed = true;
+  isOpen = false;
+  version = 0;
+  versionAsString = "";
+  constructor(arraybuffer) {
+    this.arraybuffer = arraybuffer;
+    this.validate();
+    this.loader = this.isCompressed ? new LAZLoader(this.arraybuffer) : new LASLoader(this.arraybuffer);
+  }
+  validate() {
+    const signature = readAs(this.arraybuffer, Uint8Array, 0, 4);
+    const check = String.fromCharCode(...signature);
+    if (check !== "LASF") {
+      throw new Error("Invalid LAS file");
+    }
+    if (this.determineVersion() > 14) {
+      throw new Error("Only file versions <= 1.4 are supported");
+    }
+    this.determineFormat();
+    if (POINT_FORMAT_READERS[this.formatId] === void 0) {
+      throw new Error("The point format ID is not supported");
+    }
+  }
+  /**
+   * Determines format in parameters of LASHeader
+   */
+  determineFormat() {
+    const formatId = readAs(this.arraybuffer, Uint8Array, 32 * 3 + 8);
+    const bit7 = (formatId & 128) >> 7;
+    const bit6 = (formatId & 64) >> 6;
+    if (bit7 === 1 && bit6 === 1) {
+      throw new Error("Old style compression not supported");
+    }
+    this.formatId = formatId & 63;
+    this.isCompressed = bit7 === 1 || bit6 === 1;
+  }
+  /**
+   * Determines version
+   * @returns version
+   */
+  determineVersion() {
+    const ver = new Uint8Array(this.arraybuffer, 24, 2);
+    this.version = ver[0] * 10 + ver[1];
+    this.versionAsString = `${ver[0]}.${ver[1]}`;
+    return this.version;
+  }
+  /**
+   * Reads if the file is open
+   * @returns boolean
+   */
+  open() {
+    if (this.loader.open()) {
+      this.isOpen = true;
+    }
+  }
+  /**
+   * Gets the header
+   * @returns Header
+   */
+  getHeader() {
+    return this.loader.getHeader();
+  }
+  /**
+   * @param count
+   * @returns LASData
+   */
+  readData(count) {
+    return this.loader.readData(count);
+  }
+  /**
+   * Closes the file
+   */
+  close() {
+    if (this.loader.close()) {
+      this.isOpen = false;
+    }
+  }
+  /**
+   */
+  getUnpacker() {
+    return LASDecoder;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LASFile
+});
+//# sourceMappingURL=laslaz-decoder.cjs.map