12127398032

Committed 02 Dec 2024 08:26PM UTC coverage: 58.291% (-0.2%) from 58.521%

Build # 12127398032

Build Type

push

github

Committed by

web-flow

Commit Message

feat(las): Enable both laz-perf and laz-rs-wasm for comparison and benchmarking. (#3168)

Co-authored-by: Oleksii Vykaliuk <alekzvik@gmail.com>

Run Details

7090 of 9470 branches covered (74.87%)

Branch coverage included in aggregate %.

287 of 780 new or added lines in 9 files covered. (36.79%)

91 existing lines in 3 files now uncovered.

66602 of 116951 relevant lines covered (56.95%)

2419.91 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

36.21

/modules/las/src/lib/laz-rs-wasm/laslaz-decoder.ts

// 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;

1	// loaders.gl	1✔
2	// SPDX-License-Identifier: MIT	1✔
3	// Copyright (c) vis.gl contributors	1✔
4		1✔
5	/*	1✔
6	Modified from Uday Verma and Howard Butler's plasio	1✔
7	https://github.com/verma/plasio/	1✔
8	MIT License	1✔
9	*/	1✔
10	// laslaz.js - treat as compiled code	1✔
11	import type {LASHeader} from '../las-types';	1✔
12	import {WasmLasZipDecompressor} from '../../libs/laz-rs-wasm/laz_rs_wasm';	1✔
13		1✔
14	type LASPoint = {	1✔
15	position: [number, number, number];	1✔
16	intensity: number;	1✔
17	classification: number;	1✔
18	color?: [number, number, number];	1✔
19	};	1✔
20		1✔
21	type LASReader = (dv: DataView) => LASPoint;	1✔
22		1✔
23	type LASReaders = {	1✔
24	[key: number]: LASReader;	1✔
25	};	1✔
26		1✔
27	type LASData = {	1✔
28	buffer: ArrayBuffer;	1✔
29	count: number;	1✔
30	hasMoreData: boolean;	1✔
31	};	1✔
32		1✔
33	const POINT_FORMAT_READERS: LASReaders = {	1✔
34	0: (dv) => {	1✔
35	return {	×
36	position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],	×
37	intensity: dv.getUint16(12, true),	×
38	classification: dv.getUint8(15)	×
39	};	×
40	},	×
41	1: (dv) => {	1✔
42	return {	×
43	position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],	×
44	intensity: dv.getUint16(12, true),	×
45	classification: dv.getUint8(15)	×
46	};	×
47	},	×
48	2: (dv) => {	1✔
49	return {	×
50	position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],	×
51	intensity: dv.getUint16(12, true),	×
52	classification: dv.getUint8(15),	×
53	color: [dv.getUint16(20, true), dv.getUint16(22, true), dv.getUint16(24, true)]	×
54	};	×
55	},	×
56	3: (dv) => {	1✔
57	return {	×
58	position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],	×
59	intensity: dv.getUint16(12, true),	×
60	classification: dv.getUint8(15),	×
61	color: [dv.getUint16(28, true), dv.getUint16(30, true), dv.getUint16(32, true)]	×
62	};	×
63	},	×
64	4: (dv) => {	1✔
65	return {	×
66	position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],	×
67	intensity: dv.getUint16(12, true),	×
68	classification: dv.getUint8(15)	×
69	};	×
70	},	×
71	5: (dv) => {	1✔
72	return {	×
73	position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],	×
74	intensity: dv.getUint16(12, true),	×
75	classification: dv.getUint8(15),	×
76	color: [dv.getUint16(28, true), dv.getUint16(30, true), dv.getUint16(32, true)]	×
77	};	×
78	},	×
79	6: (dv) => {	1✔
80	return {	×
81	position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],	×
82	intensity: dv.getUint16(12, true),	×
83	classification: dv.getUint8(16)	×
84	};	×
85	},	×
86	7: (dv) => {	1✔
87	return {	×
88	position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],	×
89	intensity: dv.getUint16(12, true),	×
90	classification: dv.getUint8(16),	×
91	color: [dv.getUint16(30, true), dv.getUint16(32, true), dv.getUint16(34, true)]	×
92	};	×
93	},	×
94	8: (dv) => {	1✔
95	return {	×
96	position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],	×
97	intensity: dv.getUint16(12, true),	×
98	classification: dv.getUint8(16),	×
99	color: [dv.getUint16(30, true), dv.getUint16(32, true), dv.getUint16(34, true)]	×
100	};	×
101	},	×
102	9: (dv) => {	1✔
103	return {	×
104	position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],	×
105	intensity: dv.getUint16(12, true),	×
106	classification: dv.getUint8(16)	×
107	};	×
108	},	×
109	10: (dv) => {	1✔
110	return {	×
111	position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],	×
112	intensity: dv.getUint16(12, true),	×
113	classification: dv.getUint8(16),	×
114	color: [dv.getUint16(30, true), dv.getUint16(32, true), dv.getUint16(34, true)]	×
115	};	×
116	}	×
117	};	1✔
118		1✔
119	/**	1✔
120	* Reads incoming binary data depends on the Type parameter	1✔
121	* @param buf	1✔
122	* @param Type	1✔
123	* @param offset	1✔
124	* @param count	1✔
125	* @returns number \| number[] from incoming binary data	1✔
126	*/	1✔
127	function readAs(buf: ArrayBuffer, Type: any = {}, offset: number, count?: number) {	×
128	count = count === undefined \|\| count === 0 ? 1 : count;	×
129	const sub = buf.slice(offset, offset + Type.BYTES_PER_ELEMENT * count);	×
130		×
131	const r = new Type(sub);	×
132	if (count === 1) {	×
133	return r[0];	×
134	}	×
135		×
136	const ret: number[] = [];	×
137	for (let i = 0; i < count; i++) {	×
138	ret.push(r[i]);	×
139	}	×
140		×
141	return ret;	×
142	}	×
143		1✔
144	/**	1✔
145	* Parsing of header's attributes	1✔
146	* @param arraybuffer	1✔
147	* @returns header as LASHeader	1✔
148	*/	1✔
149	function parseLASHeader(arraybuffer: ArrayBuffer): LASHeader {	×
150	const ver = new Uint8Array(arraybuffer, 24, 2);	×
151	const version = ver[0] * 10 + ver[1];	×
152	const versionAsString = `${ver[0]}.${ver[1]}`;	×
153		×
154	const rawPointsFormatId = readAs(arraybuffer, Uint8Array, 32 * 3 + 8);	×
155	const bit7 = (rawPointsFormatId & 0x80) >> 7;	×
156	const bit6 = (rawPointsFormatId & 0x40) >> 6;	×
157		×
158	const isCompressed = bit7 === 1 \|\| bit6 === 1;	×
159	const pointsFormatId = rawPointsFormatId & 0x3f;	×
160	const o: Partial<LASHeader> = {	×
161	pointsOffset: readAs(arraybuffer, Uint32Array, 32 * 3),	×
162	pointsFormatId,	×
163	pointsStructSize: readAs(arraybuffer, Uint16Array, 32 * 3 + 8 + 1),	×
164	pointsCount: readAs(arraybuffer, Uint32Array, 32 * 3 + 11),	×
165	versionAsString,	×
166	isCompressed	×
167	};	×
168		×
169	let start = 32 * 3 + 35;	×
170		×
171	o.scale = readAs(arraybuffer, Float64Array, start, 3);	×
172	start += 24; // 8*3	×
173	o.offset = readAs(arraybuffer, Float64Array, start, 3);	×
174	start += 24;	×
175		×
176	const bounds = readAs(arraybuffer, Float64Array, start, 6);	×
177	start += 48; // 8*6	×
178	o.maxs = [bounds[0], bounds[2], bounds[4]];	×
179	o.mins = [bounds[1], bounds[3], bounds[5]];	×
180		×
181	start += 20; // 8*20	×
182		×
183	if (version === 14) {	×
184	o.pointsCount = Number(readAs(arraybuffer, BigUint64Array, start));	×
185	}	×
186		×
187	const colorPointFormats = new Set([2, 3, 5, 7, 8, 10]);	×
188	o.hasColor = colorPointFormats.has(pointsFormatId);	×
NEW 189	// @ts-expect-error Caused when restoring lazperf	×
NEW 190	return o;	×
191	}	×
192		1✔
193	// LAS Loader	1✔
194	// Loads uncompressed files	1✔
195	//	1✔
196	class LASLoader {	1✔
197	arraybuffer: ArrayBuffer;	1!
198	readOffset: number = 0;	×
199	header: LASHeader \| null = null;	×
200		1✔
201	constructor(arraybuffer: ArrayBuffer) {	1✔
202	this.arraybuffer = arraybuffer;	×
203	}	×
204		1✔
205	/**	1✔
206	* @returns boolean	1✔
207	*/	1✔
208	open() {	1✔
209	// Nothing needs to be done to open this	×
210	return true;	×
211	}	×
212	/**	1✔
213	* Parsing of incoming binary	1✔
214	* @returns LASHeader	1✔
215	*/	1✔
216	getHeader() {	1✔
217	this.header = parseLASHeader(this.arraybuffer);	×
218	return this.header;	×
219	}	×
220		1✔
221	/**	1✔
222	* Reading data	1✔
223	* @param count	1✔
224	* @param skip	1✔
225	* @returns LasData	1✔
226	*/	1✔
227	readData(count: number, skip: number): LASData {	1✔
228	const {header, arraybuffer} = this;	×
229	if (!header) {	×
230	throw new Error('Cannot start reading data till a header request is issued');	×
231	}	×
232		×
233	let {readOffset} = this;	×
234	let start: number;	×
235		×
236	if (skip <= 1) {	×
237	count = Math.min(count, header.pointsCount - readOffset);	×
238	start = header.pointsOffset + readOffset * header.pointsStructSize;	×
239	const end = start + count * header.pointsStructSize;	×
240	readOffset += count;	×
241	this.readOffset = readOffset;	×
242	return {	×
243	buffer: arraybuffer.slice(start, end),	×
244	count,	×
245	hasMoreData: readOffset < header.pointsCount	×
246	};	×
247	}	×
248		×
249	const pointsToRead = Math.min(count * skip, header.pointsCount - readOffset);	×
250	const bufferSize = Math.ceil(pointsToRead / skip);	×
251	let pointsRead = 0;	×
252		×
253	const buf = new Uint8Array(bufferSize * header.pointsStructSize);	×
254	for (let i = 0; i < pointsToRead; i++) {	×
255	if (i % skip === 0) {	×
256	start = header.pointsOffset + readOffset * header.pointsStructSize;	×
257	const src = new Uint8Array(arraybuffer, start, header.pointsStructSize);	×
258		×
259	buf.set(src, pointsRead * header.pointsStructSize);	×
260	pointsRead++;	×
261	}	×
262		×
263	readOffset++;	×
264	}	×
265	this.readOffset = readOffset;	×
266		×
267	return {	×
268	buffer: buf.buffer,	×
269	count: pointsRead,	×
270	hasMoreData: readOffset < header.pointsCount	×
271	};	×
272	}	×
273	/**	1✔
274	* Method which brings data to null to close the file	1✔
275	* @returns	1✔
276	*/	1✔
277	close() {	1✔
278	// @ts-ignore Possibly null	×
279	this.arraybuffer = null;	×
280	return true;	×
281	}	×
282	}	1✔
283		1✔
284	/**	1✔
285	* LAZ Loader	1✔
286	* Uses NaCL module to load LAZ files	1✔
287	*/	1✔
288	class LAZLoader {	1✔
289	arraybuffer: ArrayBuffer;	1!
290	readOffset: number = 0;	×
291	instance: WasmLasZipDecompressor \| null = null;	×
292	header: LASHeader \| null = null;	×
293		1✔
294	constructor(arraybuffer: ArrayBuffer) {	1✔
295	this.arraybuffer = arraybuffer;	×
296	}	×
297		1✔
298	/**	1✔
299	* Opens the file	1✔
300	* @returns boolean	1✔
301	*/	1✔
302	open(): boolean {	1✔
303	try {	×
304	const abInt = new Uint8Array(this.arraybuffer);	×
305	this.instance = new WasmLasZipDecompressor(abInt);	×
306		×
307	return true;	×
308	} catch (error) {	×
309	throw new Error(`Failed to open file: ${(error as Error).message}`);	×
310	}	×
311	}	×
312		1✔
313	getHeader(): LASHeader {	1✔
314	try {	×
315	this.header = parseLASHeader(this.arraybuffer);	×
316	return this.header;	×
317	} catch (error) {	×
318	throw new Error(`Failed to get header: ${(error as Error).message}`);	×
319	}	×
320	}	×
321		1✔
322	/**	1✔
323	* @param count	1✔
324	* @param offset	1✔
325	* @param skip	1✔
326	* @returns LASData	1✔
327	*/	1✔
328	readData(count: number, skip: number): LASData {	1✔
329	if (!this.instance) {	×
330	throw new Error('You need to open the file before trying to read stuff');	×
331	}	×
332		×
333	const {header, instance} = this;	×
334		×
335	if (!header) {	×
336	throw new Error(	×
337	'You need to query header before reading, I maintain state that way, sorry :('	×
338	);	×
339	}	×
340		×
341	try {	×
342	const pointsToRead = Math.min(count * skip, header.pointsCount - this.readOffset);	×
343	const bufferSize = Math.ceil(pointsToRead / skip);	×
344	let pointsRead = 0;	×
345		×
346	const buf = new Uint8Array(bufferSize * header.pointsStructSize);	×
347		×
348	const bufRead = new Uint8Array(header.pointsStructSize);	×
349	for (let i = 0; i < pointsToRead; i++) {	×
350	instance.decompress_many(bufRead);	×
351		×
352	if (i % skip === 0) {	×
353	buf.set(bufRead, pointsRead * header.pointsStructSize);	×
354	pointsRead++;	×
355	}	×
356		×
357	this.readOffset++;	×
358	}	×
359	return {	×
360	buffer: buf.buffer,	×
361	count: pointsRead,	×
362	hasMoreData: this.readOffset < header.pointsCount	×
363	};	×
364	} catch (error) {	×
365	throw new Error(`Failed to read data: ${(error as Error).message}`);	×
366	}	×
367	}	×
368		1✔
369	/**	1✔
370	* Deletes the instance	1✔
371	* @returns boolean	1✔
372	*/	1✔
373	close(): boolean {	1✔
374	try {	×
375	if (this.instance !== null) {	×
376	this.instance.free();	×
377	this.instance = null;	×
378	}	×
379	// @ts-ignore Possibly null	×
380	this.arraybuffer = null;	×
381	return true;	×
382	} catch (error) {	×
383	throw new Error(`Failed to close file: ${(error as Error).message}`);	×
384	}	×
385	}	×
386	}	1✔
387		1✔
388	/**	1✔
389	* Helper class: Decodes LAS records into points	1✔
390	*/	1✔
391	class LASDecoder {	1✔
392	arrayb: ArrayBuffer;	1!
393	decoder: (dv: DataView) => LASPoint;	×
394	pointsCount: number;	×
395	pointSize: number;	×
396		1✔
397	constructor(buffer: ArrayBuffer, len: number, header: LASHeader) {	1✔
398	this.arrayb = buffer;	×
399	this.decoder = POINT_FORMAT_READERS[header.pointsFormatId];	×
400	this.pointsCount = len;	×
401	this.pointSize = header.pointsStructSize;	×
402	}	×
403		1✔
404	/**	1✔
405	* Decodes data depends on this point size	1✔
406	* @param index	1✔
407	* @returns New object	1✔
408	*/	1✔
409	getPoint(index: number): LASPoint {	1✔
410	if (index < 0 \|\| index >= this.pointsCount) {	×
411	throw new Error('Point index out of range');	×
412	}	×
413		×
414	const dv = new DataView(this.arrayb, index * this.pointSize, this.pointSize);	×
415	return this.decoder(dv);	×
416	}	×
417	}	1✔
418		1✔
419	/**	1✔
420	* A single consistent interface for loading LAS/LAZ files	1✔
421	*/	1✔
422	export class LASFile {	1✔
423	arraybuffer: ArrayBuffer;	1!
424	formatId: number = 0;	×
425	loader: LASLoader \| LAZLoader;	×
426	isCompressed: boolean = true;	×
427	isOpen: boolean = false;	×
428	version: number = 0;	×
429	versionAsString: string = '';	×
430		1✔
431	constructor(arraybuffer: ArrayBuffer) {	1✔
432	this.arraybuffer = arraybuffer;	×
433		×
434	this.validate();	×
435		×
436	this.loader = this.isCompressed	×
437	? new LAZLoader(this.arraybuffer)	×
438	: new LASLoader(this.arraybuffer);	×
439	}	×
440		1✔
441	validate(): void {	1✔
442	const signature = readAs(this.arraybuffer, Uint8Array, 0, 4);	×
443	const check = String.fromCharCode(...signature);	×
444	if (check !== 'LASF') {	×
445	throw new Error('Invalid LAS file');	×
446	}	×
447		×
448	if (this.determineVersion() > 14) {	×
449	throw new Error('Only file versions <= 1.4 are supported');	×
450	}	×
451		×
452	this.determineFormat();	×
453	if (POINT_FORMAT_READERS[this.formatId] === undefined) {	×
454	throw new Error('The point format ID is not supported');	×
455	}	×
456	}	×
457		1✔
458	/**	1✔
459	* Determines format in parameters of LASHeader	1✔
460	*/	1✔
461	determineFormat(): void {	1✔
462	const formatId = readAs(this.arraybuffer, Uint8Array, 32 * 3 + 8);	×
463	const bit7 = (formatId & 0x80) >> 7;	×
464	const bit6 = (formatId & 0x40) >> 6;	×
465		×
466	if (bit7 === 1 && bit6 === 1) {	×
467	throw new Error('Old style compression not supported');	×
468	}	×
469		×
470	this.formatId = formatId & 0x3f;	×
471	this.isCompressed = bit7 === 1 \|\| bit6 === 1;	×
472	}	×
473		1✔
474	/**	1✔
475	* Determines version	1✔
476	* @returns version	1✔
477	*/	1✔
478	determineVersion(): number {	1✔
479	const ver = new Uint8Array(this.arraybuffer, 24, 2);	×
480	this.version = ver[0] * 10 + ver[1];	×
481	this.versionAsString = `${ver[0]}.${ver[1]}`;	×
482	return this.version;	×
483	}	×
484		1✔
485	/**	1✔
486	* Reads if the file is open	1✔
487	* @returns boolean	1✔
488	*/	1✔
489	open(): void {	1✔
490	if (this.loader.open()) {	×
491	this.isOpen = true;	×
492	}	×
493	}	×
494	/**	1✔
495	* Gets the header	1✔
496	* @returns Header	1✔
497	*/	1✔
498	getHeader(): LASHeader {	1✔
499	return this.loader.getHeader();	×
500	}	×
501		1✔
502	/**	1✔
503	* @param count	1✔
504	* @param start	1✔
505	* @param skip	1✔
506	* @returns LASData	1✔
507	*/	1✔
508	readData(count: number, skip: number): LASData {	1✔
509	return this.loader.readData(count, skip);	×
510	}	×
511		1✔
512	/**	1✔
513	* Closes the file	1✔
514	*/	1✔
515	close(): void {	1✔
516	if (this.loader.close()) {	×
517	this.isOpen = false;	×
518	}	×
519	}	×
520	/**	1✔
521	*/	1✔
522	getUnpacker(): typeof LASDecoder {	1✔
523	return LASDecoder;	×
524	}	×
525	}	1✔
526		1✔
527	/* eslint no-use-before-define: 2 */	1✔
528	// export const LASModuleWasLoaded = false;	1✔

visgl / loaders.gl / 12127398032

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous