@loaders.gl/las 4.3.4 → 4.4.0-alpha.10

package/src/lib/laz-rs-wasm/laslaz-decoder.ts

@@ -0,0 +1,528 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/*
+  Modified from Uday Verma and Howard Butler's plasio
+  https://github.com/verma/plasio/
+  MIT License
+*/
+// laslaz.js - treat as compiled code
+import type {LASHeader} from '../las-types';
+import {WasmLasZipDecompressor} from '../../libs/laz-rs-wasm/laz_rs_wasm';
+
+type LASPoint = {
+  position: [number, number, number];
+  intensity: number;
+  classification: number;
+  color?: [number, number, number];
+};
+
+type LASReader = (dv: DataView) => LASPoint;
+
+type LASReaders = {
+  [key: number]: LASReader;
+};
+
+type LASData = {
+  buffer: ArrayBuffer;
+  count: number;
+  hasMoreData: boolean;
+};
+
+const POINT_FORMAT_READERS: LASReaders = {
+  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)]
+    };
+  }
+};
+
+/**
+ * Reads incoming binary data depends on the Type parameter
+ * @param buf
+ * @param Type
+ * @param offset
+ * @param count
+ * @returns number | number[] from incoming binary data
+ */
+function readAs(buf: ArrayBuffer, Type: any = {}, offset: number, count?: number) {
+  count = count === undefined || 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: number[] = [];
+  for (let i = 0; i < count; i++) {
+    ret.push(r[i]);
+  }
+
+  return ret;
+}
+
+/**
+ * Parsing of header's attributes
+ * @param arraybuffer
+ * @returns header as LASHeader
+ */
+function parseLASHeader(arraybuffer: ArrayBuffer): LASHeader {
+  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 & 0x80) >> 7;
+  const bit6 = (rawPointsFormatId & 0x40) >> 6;
+
+  const isCompressed = bit7 === 1 || bit6 === 1;
+  const pointsFormatId = rawPointsFormatId & 0x3f;
+  const o: Partial<LASHeader> = {
+    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; // 8*3
+  o.offset = readAs(arraybuffer, Float64Array, start, 3);
+  start += 24;
+
+  const bounds = readAs(arraybuffer, Float64Array, start, 6);
+  start += 48; // 8*6
+  o.maxs = [bounds[0], bounds[2], bounds[4]];
+  o.mins = [bounds[1], bounds[3], bounds[5]];
+
+  start += 20; // 8*20
+
+  if (version === 14) {
+    o.pointsCount = Number(readAs(arraybuffer, BigUint64Array, start));
+  }
+
+  const colorPointFormats = new Set([2, 3, 5, 7, 8, 10]);
+  o.hasColor = colorPointFormats.has(pointsFormatId);
+  // @ts-expect-error Caused when restoring lazperf
+  return o;
+}
+
+// LAS Loader
+// Loads uncompressed files
+//
+class LASLoader {
+  arraybuffer: ArrayBuffer;
+  readOffset: number = 0;
+  header: LASHeader | null = null;
+
+  constructor(arraybuffer: ArrayBuffer) {
+    this.arraybuffer = arraybuffer;
+  }
+
+  /**
+   * @returns boolean
+   */
+  open() {
+    // Nothing needs to be done to open this
+    return true;
+  }
+  /**
+   * Parsing of incoming binary
+   * @returns LASHeader
+   */
+  getHeader() {
+    this.header = parseLASHeader(this.arraybuffer);
+    return this.header;
+  }
+
+  /**
+   * Reading data
+   * @param count
+   * @param skip
+   * @returns LasData
+   */
+  readData(count: number, skip: number): LASData {
+    const {header, arraybuffer} = this;
+    if (!header) {
+      throw new Error('Cannot start reading data till a header request is issued');
+    }
+
+    let {readOffset} = this;
+    let start: number;
+
+    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,
+        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++;
+    }
+    this.readOffset = readOffset;
+
+    return {
+      buffer: buf.buffer,
+      count: pointsRead,
+      hasMoreData: readOffset < header.pointsCount
+    };
+  }
+  /**
+   * Method which brings data to null to close the file
+   * @returns
+   */
+  close() {
+    // @ts-ignore Possibly null
+    this.arraybuffer = null;
+    return true;
+  }
+}
+
+/**
+ * LAZ Loader
+ * Uses NaCL module to load LAZ files
+ */
+class LAZLoader {
+  arraybuffer: ArrayBuffer;
+  readOffset: number = 0;
+  instance: WasmLasZipDecompressor | null = null;
+  header: LASHeader | null = null;
+
+  constructor(arraybuffer: ArrayBuffer) {
+    this.arraybuffer = arraybuffer;
+  }
+
+  /**
+   * Opens the file
+   * @returns boolean
+   */
+  open(): boolean {
+    try {
+      const abInt = new Uint8Array(this.arraybuffer);
+      this.instance = new WasmLasZipDecompressor(abInt);
+
+      return true;
+    } catch (error) {
+      throw new Error(`Failed to open file: ${(error as Error).message}`);
+    }
+  }
+
+  getHeader(): LASHeader {
+    try {
+      this.header = parseLASHeader(this.arraybuffer);
+      return this.header;
+    } catch (error) {
+      throw new Error(`Failed to get header: ${(error as Error).message}`);
+    }
+  }
+
+  /**
+   * @param count
+   * @param offset
+   * @param skip
+   * @returns LASData
+   */
+  readData(count: number, skip: number): LASData {
+    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 * skip, header.pointsCount - this.readOffset);
+      const bufferSize = Math.ceil(pointsToRead / skip);
+      let pointsRead = 0;
+
+      const buf = new Uint8Array(bufferSize * header.pointsStructSize);
+
+      const bufRead = new Uint8Array(header.pointsStructSize);
+      for (let i = 0; i < pointsToRead; i++) {
+        instance.decompress_many(bufRead);
+
+        if (i % skip === 0) {
+          buf.set(bufRead, pointsRead * header.pointsStructSize);
+          pointsRead++;
+        }
+
+        this.readOffset++;
+      }
+      return {
+        buffer: buf.buffer,
+        count: pointsRead,
+        hasMoreData: this.readOffset < header.pointsCount
+      };
+    } catch (error) {
+      throw new Error(`Failed to read data: ${(error as Error).message}`);
+    }
+  }
+
+  /**
+   * Deletes the instance
+   * @returns boolean
+   */
+  close(): boolean {
+    try {
+      if (this.instance !== null) {
+        this.instance.free();
+        this.instance = null;
+      }
+      // @ts-ignore Possibly null
+      this.arraybuffer = null;
+      return true;
+    } catch (error) {
+      throw new Error(`Failed to close file: ${(error as Error).message}`);
+    }
+  }
+}
+
+/**
+ * Helper class: Decodes LAS records into points
+ */
+class LASDecoder {
+  arrayb: ArrayBuffer;
+  decoder: (dv: DataView) => LASPoint;
+  pointsCount: number;
+  pointSize: number;
+
+  constructor(buffer: ArrayBuffer, len: number, header: LASHeader) {
+    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: number): LASPoint {
+    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);
+  }
+}
+
+/**
+ * A single consistent interface for loading LAS/LAZ files
+ */
+export class LASFile {
+  arraybuffer: ArrayBuffer;
+  formatId: number = 0;
+  loader: LASLoader | LAZLoader;
+  isCompressed: boolean = true;
+  isOpen: boolean = false;
+  version: number = 0;
+  versionAsString: string = '';
+
+  constructor(arraybuffer: ArrayBuffer) {
+    this.arraybuffer = arraybuffer;
+
+    this.validate();
+
+    this.loader = this.isCompressed
+      ? new LAZLoader(this.arraybuffer)
+      : new LASLoader(this.arraybuffer);
+  }
+
+  validate(): void {
+    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] === undefined) {
+      throw new Error('The point format ID is not supported');
+    }
+  }
+
+  /**
+   * Determines format in parameters of LASHeader
+   */
+  determineFormat(): void {
+    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;
+  }
+
+  /**
+   * Determines version
+   * @returns version
+   */
+  determineVersion(): number {
+    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(): void {
+    if (this.loader.open()) {
+      this.isOpen = true;
+    }
+  }
+  /**
+   * Gets the header
+   * @returns Header
+   */
+  getHeader(): LASHeader {
+    return this.loader.getHeader();
+  }
+
+  /**
+   * @param count
+   * @param start
+   * @param skip
+   * @returns LASData
+   */
+  readData(count: number, skip: number): LASData {
+    return this.loader.readData(count, skip);
+  }
+
+  /**
+   * Closes the file
+   */
+  close(): void {
+    if (this.loader.close()) {
+      this.isOpen = false;
+    }
+  }
+  /**
+   */
+  getUnpacker(): typeof LASDecoder {
+    return LASDecoder;
+  }
+}
+
+/* eslint no-use-before-define: 2 */
+// export const LASModuleWasLoaded = false;

package/src/lib/{parse-las.ts → laz-rs-wasm/parse-las.ts}

@@ -1,30 +1,32 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 // ported and es6-ified from https://github.com/verma/plasio/
 // import type {ArrowTable, ColumnarTable} from '@loaders.gl/schema';
-import type {LASLoaderOptions} from '../las-loader';
-import type {LASMesh, LASHeader} from './las-types';
-import {getMeshBoundingBox /* , convertMesh */} from '@loaders.gl/schema';
+import type {LASLoaderOptions} from '../../las-loader';
+import type {LASMesh, LASHeader} from '../las-types';
+import {getMeshBoundingBox /* , convertMeshToTable */} from '@loaders.gl/schema-utils';
+import {getLASSchema} from '../get-las-schema';
 import {LASFile} from './laslaz-decoder';
-import {getLASSchema} from './get-las-schema';
 
 type LASChunk = {
   count: number;
   buffer: ArrayBuffer;
   hasMoreData: boolean;
-  versionAsString?: string;
-  isCompressed?: boolean;
 };
 
 /**
  * Parsing of .las file
  * @param arrayBuffer
  * @param options
- * @returns LASHeader
+ * @returns LASMesh
  */
 export function parseLAS(arrayBuffer: ArrayBuffer, options?: LASLoaderOptions): LASMesh {
   return parseLASMesh(arrayBuffer, options);
   // This code breaks pointcloud example on the website
   // const mesh = parseLASMesh(arrayBuffer, options);
-  // return convertMesh(mesh, options?.las?.shape || 'mesh') as LASMesh | ArrowTable | ColumnarTable;
+  // return convertMeshToTable(mesh, options?.las?.shape || 'mesh') as LASMesh | ArrowTable | ColumnarTable;
 }
 
 /**
@@ -69,7 +71,7 @@ function parseLASMesh(arrayBuffer: ArrayBuffer, options: LASLoaderOptions = {}):
       const PositionsType = options.las?.fp64 ? Float64Array : Float32Array;
       positions = new PositionsType(total * 3);
       // laslaz-decoder.js `pointFormatReaders`
-      colors = lasHeader.pointsFormatId >= 2 ? new Uint8Array(total * 4) : null;
+      colors = lasHeader.hasColor ? new Uint8Array(total * 4) : null;
       intensities = new Uint16Array(total);
       classifications = new Uint8Array(total);
 
@@ -168,13 +170,11 @@ export function parseLASChunked(rawData: ArrayBuffer, skip: number, onParseData:
 
     /* eslint-disable no-constant-condition */
     while (true) {
-      const chunk: LASChunk = dataHandler.readData(1000 * 100, 0, skip);
+      const chunk: LASChunk = dataHandler.readData(1000 * 100, skip);
 
       totalRead += chunk.count;
 
       header.totalRead = totalRead;
-      header.versionAsString = chunk.versionAsString;
-      header.isCompressed = chunk.isCompressed;
 
       const unpacker = new Unpacker(chunk.buffer, chunk.count, header);
 

package/src/libs/laz-rs-wasm/laz_rs_wasm.d.ts

@@ -0,0 +1,80 @@
+/* tslint:disable */
+/* eslint-disable */
+export class WasmLasZipDecompressor {
+  free(): void;
+  /**
+   * @param {Uint8Array} buf
+   */
+  constructor(buf: Uint8Array);
+  /**
+   * @param {Uint8Array} out
+   */
+  decompress_many(out: Uint8Array): void;
+  header: WasmQuickHeader;
+}
+export class WasmQuickHeader {
+  free(): void;
+  header_size: number;
+  major: number;
+  minor: number;
+  num_points: bigint;
+  num_vlrs: number;
+  offset_to_points: number;
+  point_format_id: number;
+  point_size: number;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+  readonly memory: WebAssembly.Memory;
+  readonly __wbg_wasmquickheader_free: (a: number, b: number) => void;
+  readonly __wbg_get_wasmquickheader_major: (a: number) => number;
+  readonly __wbg_set_wasmquickheader_major: (a: number, b: number) => void;
+  readonly __wbg_get_wasmquickheader_minor: (a: number) => number;
+  readonly __wbg_set_wasmquickheader_minor: (a: number, b: number) => void;
+  readonly __wbg_get_wasmquickheader_offset_to_points: (a: number) => number;
+  readonly __wbg_set_wasmquickheader_offset_to_points: (a: number, b: number) => void;
+  readonly __wbg_get_wasmquickheader_num_vlrs: (a: number) => number;
+  readonly __wbg_set_wasmquickheader_num_vlrs: (a: number, b: number) => void;
+  readonly __wbg_get_wasmquickheader_point_format_id: (a: number) => number;
+  readonly __wbg_set_wasmquickheader_point_format_id: (a: number, b: number) => void;
+  readonly __wbg_get_wasmquickheader_point_size: (a: number) => number;
+  readonly __wbg_set_wasmquickheader_point_size: (a: number, b: number) => void;
+  readonly __wbg_get_wasmquickheader_num_points: (a: number) => number;
+  readonly __wbg_set_wasmquickheader_num_points: (a: number, b: number) => void;
+  readonly __wbg_get_wasmquickheader_header_size: (a: number) => number;
+  readonly __wbg_set_wasmquickheader_header_size: (a: number, b: number) => void;
+  readonly __wbg_wasmlaszipdecompressor_free: (a: number, b: number) => void;
+  readonly __wbg_get_wasmlaszipdecompressor_header: (a: number) => number;
+  readonly __wbg_set_wasmlaszipdecompressor_header: (a: number, b: number) => void;
+  readonly wasmlaszipdecompressor_new: (a: number) => Array;
+  readonly wasmlaszipdecompressor_decompress_many: (a: number, b: number, c: number, d: number) => Array;
+  readonly __wbindgen_export_0: WebAssembly.Table;
+  readonly __externref_table_dealloc: (a: number) => void;
+  readonly __wbindgen_malloc: (a: number, b: number) => number;
+  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+  readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+/**
+* Instantiates the given `module`, which can either be bytes or
+* a precompiled `WebAssembly.Module`.
+*
+* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+*
+* @returns {InitOutput}
+*/
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+* for everything else, calls `WebAssembly.instantiate` directly.
+*
+* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+*
+* @returns {Promise<InitOutput>}
+*/
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;