las-laz-js 0.1.0 → 0.3.0

package/src/LasReader.js

@@ -17,13 +17,18 @@ import { NodeFileSource } from "./io/NodeFileSource.js";
 import { parseHeader } from "./format/LasHeader.js";
 import { parseVlrs, parseEvlrs } from "./format/LasVlr.js";
 import { parseCrs } from "./format/LasCrs.js";
-import { decodeRecords, resolveFields } from "./read/decodeRecords.js";
-import { windows } from "./read/windows.js";
-import { makeKeep, strideFor } from "./filter/filters.js";
+import { decodeRecords, resolveFields, columnType } from "./read/decodeRecords.js";
+import { windows, lazWindows } from "./read/windows.js";
+import { findLazVlr } from "./laz/LazVlr.js";
+import { readChunks } from "./laz/chunkTable.js";
+import { createChunkDecoder } from "./laz/decompressChunk.js";
+import { createLazPool, defaultThreads } from "./laz/pool.js";
+import { makeKeep, countKept } from "./filter/filters.js";
 import { dedupe } from "./filter/dedupe.js";
 import { openScratchSyncWriter } from "./io/ScratchBinaryFile.js";
 
 var DEFAULT_WINDOW = 64 * 1024 * 1024;
+var AUTO_MIN_CHUNKS = 4;
 
 function memorySource(bytes) {
 	return { size: bytes.length, read: async function (a, b) {
@@ -32,19 +37,35 @@ function memorySource(bytes) {
 	} };
 }
 
+// A caller's own { size, read } source: every read must hand back exactly
+// the bytes asked for, or a short read would silently drop points
+function checkedSource(src) {
+	function check(got, a, b) {
+		if (got instanceof ArrayBuffer) got = new Uint8Array(got);
+		if (!(got instanceof Uint8Array)) throw new LasError(ERROR_CODES.INVALID_ARGUMENT, "source.read(" + a + ", " + b + ") must return a Uint8Array or ArrayBuffer");
+		if (got.length !== b - a) throw new LasError(ERROR_CODES.TRUNCATED, "source.read(" + a + ", " + b + ") returned " + got.length + " bytes, not " + (b - a), a + Math.min(got.length, b - a));
+		return got;
+	}
+	var out = { size: src.size, read: async function (a, b) { return check(await src.read(a, b), a, b); } };
+	if (typeof src.readInto === "function") out.readInto = async function (a, b, t) { return check(await src.readInto(a, b, t), a, b); };
+	if (typeof src.close === "function") out.close = function () { return src.close(); };
+	return out;
+}
+
 async function toSource(source) {
 	if (source instanceof Uint8Array) return memorySource(source);
 	if (source instanceof ArrayBuffer) return memorySource(new Uint8Array(source));
 	if (typeof source === "string") return NodeFileSource.open(source);
 	if (source && typeof source.slice === "function" && typeof source.size === "number" && typeof source.read !== "function") return new BlobSource(source);
-	if (source && typeof source.size === "number" && typeof source.read === "function") return source;
+	if (source && typeof source.size === "number" && typeof source.read === "function") return checkedSource(source);
 	throw new LasError(ERROR_CODES.INVALID_ARGUMENT, "openLas needs a File / Blob, ArrayBuffer, Uint8Array, file path or { size, read } source");
 }
 
 /**
  * Open a LAS (or LAZ) file and read its header and VLRs.
  * @param {*} source
- * @param {{windowSize?: number}} [opts]
+ * @param {{windowSize?: number, threads?: number}} [opts] - threads: LAZ decode workers
+ *   (default automatic: cores - 1, at most 16; 1 = decode on this thread)
  * @returns {Promise<LasReader>}
  */
 export async function openLas(source, opts) {
@@ -59,12 +80,29 @@ export async function openLas(source, opts) {
 	}
 	var evlrs = [];
 	if (header.numberOfEvlrs > 0 && header.evlrStart > 0 && header.evlrStart < src.size) {
-		var evBytes = await src.read(header.evlrStart, src.size);
-		evlrs = parseEvlrs(new MemorySource(evBytes), 0, header.numberOfEvlrs).map(function (e) {
-			return Object.assign({}, e, { start: e.start + header.evlrStart });
-		});
+		evlrs = await walkEvlrs(src, header.evlrStart, header.numberOfEvlrs);
 	}
-	return new LasReader(src, header, vlrs, evlrs, (opts && opts.windowSize) || DEFAULT_WINDOW);
+	var reader = new LasReader(src, header, vlrs, evlrs, (opts && opts.windowSize) || DEFAULT_WINDOW);
+	reader._threads = opts && opts.threads > 0 ? Math.floor(opts.threads) : 0;   // 0 = automatic
+	return reader;
+}
+
+// EVLRs sit after the points and can be huge (waveform data): read each
+// 60-byte header, keep the bytes of small and coordinate-system records,
+// and leave the rest on disk for readEvlrBytes.
+var EVLR_EAGER = 65536;
+async function walkEvlrs(src, start, count) {
+	var out = [], pos = start;
+	for (var i = 0; i < count; i++) {
+		if (pos + 60 > src.size) throw new LasError(ERROR_CODES.BAD_VLR, "EVLR " + (i + 1) + " starts past the end of the file", pos);
+		var e = parseEvlrs(new MemorySource(await src.read(pos, pos + 60)), 0, 1, true)[0];
+		if (pos + 60 + e.length > src.size) throw new LasError(ERROR_CODES.BAD_VLR, "EVLR " + (i + 1) + " runs past the end of the file", pos);
+		e.start = pos + 60;
+		e.bytes = e.length <= EVLR_EAGER || e.userId === "LASF_Projection" ? new Uint8Array(await src.read(e.start, e.start + e.length)) : null;
+		out.push(e);
+		pos += 60 + e.length;
+	}
+	return out;
 }
 
 /**
@@ -83,17 +121,60 @@ export function LasReader(src, header, vlrs, evlrs, windowSize) {
 	this.crs = parseCrs(vlrs.concat(evlrs));
 	/** True for LAZ (compressed points). */
 	this.compressed = header.compressed;
+	/** The parsed LASzip VLR of a LAZ file (compressor, chunk size, items), else null. */
+	this.laz = null;
+	if (header.compressed) { try { this.laz = findLazVlr(vlrs); } catch (e) { this.laz = null; } }   // a bad VLR fails on read, not open
 }
 
-LasReader.prototype._check = function () {
-	var h = this.header;
-	if (h.compressed) {
-		throw new LasError(ERROR_CODES.COMPRESSED_LAZ, "this file is LAZ (compressed); reading LAZ points is supported from las-laz-js 0.2.0");
-	}
-	var end = h.offsetToPointData + h.pointCount * h.recordLength;
-	if (end > this._src.size) {
-		throw new LasError(ERROR_CODES.TRUNCATED, "the header promises " + h.pointCount + " points ending at byte " + end + " but the file is " + this._src.size + " bytes", this._src.size);
+// How to read this file's points: the windows, and how to turn one into raw
+// LAS records (a LAS window is read as it is; a LAZ window is a run of whole
+// chunks, decompressed into the scan's buffer). Built once per reader.
+LasReader.prototype._plan = async function () {
+	if (this._planned) return this._planned;
+	var h = this.header, src = this._src, len = h.recordLength;
+	var plan;
+	if (!h.compressed) {
+		var end = h.offsetToPointData + h.pointCount * len;
+		if (end > src.size) {
+			throw new LasError(ERROR_CODES.TRUNCATED, "the header promises " + h.pointCount + " points ending at byte " + end + " but the file is " + src.size + " bytes", src.size);
+		}
+		var list = windows(h, this._windowSize);
+		plan = {
+			list: list,
+			// a source that can fill one reused buffer gets one (no bytes outlive a window)
+			bufferSize: typeof src.readInto === "function" && list.length ? list[0].end - list[0].start : 0,
+			records: function (win, buf) { return buf ? src.readInto(win.start, win.end, buf) : src.read(win.start, win.end); }
+		};
+	} else {
+		var vlr = findLazVlr(this.vlrs);
+		if (!vlr) throw new LasError(ERROR_CODES.BAD_VLR, "this LAZ file has no LASzip VLR (user \"laszip encoded\", record 22204), so its points cannot be decompressed");
+		var decode = createChunkDecoder(vlr, len);
+		var lazList = lazWindows(await readChunks(src, h, vlr), len, this._windowSize);
+		plan = {
+			list: lazList,
+			bufferSize: lazList.reduce(function (m, w) { return Math.max(m, w.count * len); }, 0),
+			records: async function (win, buf) {
+				var packed = await src.read(win.start, win.end);
+				var view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+				win.chunks.forEach(function (c) { decode(packed, c.start - win.start, c.end - win.start, c.count, view, (c.firstRecord - win.firstRecord) * len, win.start); });
+				return buf.subarray(0, win.count * len);
+			},
+			// The same records, each chunk decoded by a pool worker from its own copy of the bytes
+			parallel: async function (win, pool) {
+				var packed = await src.read(win.start, win.end);
+				var out = new Uint8Array(win.count * len);
+				await Promise.all(win.chunks.map(function (c) {
+					var piece = packed.slice(c.start - win.start, c.end - win.start);
+					return pool.decode({ vlr: vlr, recordLength: len, packed: piece.buffer, chunks: [{ s: 0, e: piece.length, count: c.count }], base: c.start })
+						.then(function (rec) { out.set(rec, (c.firstRecord - win.firstRecord) * len); });
+				}));
+				return out;
+			},
+			chunkCount: lazList.reduce(function (n, w) { return n + w.chunks.length; }, 0)
+		};
 	}
+	this._planned = plan;
+	return plan;
 };
 
 /**
@@ -104,33 +185,76 @@ LasReader.prototype._check = function () {
 LasReader.prototype.chunks = async function* (opts) {
 	opts = opts || {};
 	if (opts.dedupe) throw new LasError(ERROR_CODES.INVALID_ARGUMENT, "dedupe needs every point at once: use readPoints, not chunks");
-	this._check();
+	yield* this._scan(opts, null);
+};
+
+// The window loop behind chunks and readPoints. into(win, n) -> { cols, at }
+// makes decodeRecords write straight into readPoints' result columns.
+LasReader.prototype._scan = async function* (opts, into) {
 	var h = this.header;
+	var plan = await this._plan();
 	var keep = makeKeep(opts, h);
-	var stride = strideFor(h.pointCount, opts.maxPoints);
-	var cap = opts.maxPoints > 0 ? opts.maxPoints : Infinity;
 	var fields = resolveFields(h, opts.fields);
-	var list = windows(h, this._windowSize);
-	var kept = 0;
-	for (var w = 0; w < list.length && kept < cap; w++) {
+	var list = plan.list;
+	var pool = await this._pool(plan);
+	try {
+		var buf = !pool && plan.bufferSize ? new Uint8Array(plan.bufferSize) : null;
+		var thin = null;
+		if (opts.maxPoints > 0) {
+			// Thin the points that pass the filters; with filters set, count them first (a second read)
+			var passing = keep ? await this._countPassing(plan, pool, buf, keep, opts.signal) : h.pointCount;
+			if (passing > opts.maxPoints) thin = { total: passing, target: opts.maxPoints, acc: 0 };
+		}
+		var kept = 0, w = 0;
+		for await (var bytes of windowBytes(plan, pool, buf, opts.signal)) {
+			var win = list[w];
+			var cols = decodeRecords(bytes, h, { fields: fields, keep: keep, thin: thin, localOrigin: opts.localOrigin, float32: opts.float32, into: into ? into(win) : null });
+			kept += cols.count;
+			w++;
+			if (typeof opts.onProgress === "function") opts.onProgress(w / list.length, "read " + kept + " points");
+			yield cols;
+		}
 		if (opts.signal && opts.signal.aborted) throw new LasError(ERROR_CODES.ABORTED, "read aborted");
-		var win = list[w];
-		var bytes = await this._src.read(win.start, win.end);
-		var cols = decodeRecords(bytes, h, { fields: fields, keep: keep, stride: stride, firstIndex: win.firstRecord, localOrigin: opts.localOrigin, float32: opts.float32 });
-		if (kept + cols.count > cap) cols = trim(cols, fields, cap - kept);
-		kept += cols.count;
-		if (typeof opts.onProgress === "function") opts.onProgress(kept >= cap ? 1 : (w + 1) / list.length, "read " + kept + " points");
-		yield cols;
+	} finally {
+		if (pool) pool.close();
 	}
-	if (opts.signal && opts.signal.aborted) throw new LasError(ERROR_CODES.ABORTED, "read aborted");
 };
 
-function trim(cols, fields, n) {
-	var out = { count: n };
-	fields.forEach(function (f) { out[f] = cols[f].slice(0, n); });
-	return out;
+// Each window's raw records in order. With a pool the next window is already
+// decoding while this one is used; without one, one buffer is reused.
+async function* windowBytes(plan, pool, buf, signal) {
+	var list = plan.list;
+	function fetch(i) {
+		var p = plan.parallel(list[i], pool);
+		p.catch(function () {});                 // a prefetch abandoned by an abort must not go unhandled
+		return p;
+	}
+	var next = pool && list.length ? fetch(0) : null;
+	for (var w = 0; w < list.length; w++) {
+		if (signal && signal.aborted) throw new LasError(ERROR_CODES.ABORTED, "read aborted");
+		if (!pool) { yield await plan.records(list[w], buf); continue; }
+		var current = next;
+		next = w + 1 < list.length ? fetch(w + 1) : null;
+		yield await current;
+	}
 }
 
+// A decode pool for this scan, or null: LAS, threads: 1, one chunk, or no workers available
+LasReader.prototype._pool = async function (plan) {
+	if (!plan.parallel || this._threads === 1) return null;
+	// automatic: only when there is enough to share (starting workers costs about as much as
+	// decoding a few chunks); an explicit thread count is always honoured
+	if (!this._threads && plan.chunkCount < AUTO_MIN_CHUNKS) return null;
+	var n = Math.min(this._threads || await defaultThreads(), plan.chunkCount);
+	return n >= 2 ? createLazPool(n) : null;
+};
+
+LasReader.prototype._countPassing = async function (plan, pool, buf, keep, signal) {
+	var n = 0;
+	for await (var bytes of windowBytes(plan, pool, buf, signal)) n += countKept(bytes, this.header.recordLength, keep);
+	return n;
+};
+
 /**
  * Read the selected points into one set of columns.
  * @param {object} [opts] - chunks() options plus dedupe (tolerance) and dedupeZ
@@ -142,22 +266,25 @@ LasReader.prototype.readPoints = async function (opts) {
 	var chunkOpts = Object.assign({}, opts);
 	delete chunkOpts.dedupe;
 	var fields = resolveFields(h, opts.fields);
-	var acc = null, n = 0;
-	for await (var c of this.chunks(chunkOpts)) {
-		if (!acc) {
-			acc = {};
-			var guess = Math.max(c.count, 1024);
-			fields.forEach(function (f) { acc[f] = new c[f].constructor(guess); });
-		}
-		if (n + c.count > acc[fields[0]].length) {
-			var size = Math.max(n + c.count, acc[fields[0]].length * 2);
+	// Allocate once when the count is known (no filters: every point, or
+	// maxPoints of them; filters + maxPoints: at most maxPoints), so the
+	// peak is the result itself. Filters alone: grow by doubling.
+	var filtered = !!makeKeep(opts, h);
+	var cap = !filtered ? (opts.maxPoints > 0 ? Math.min(opts.maxPoints, h.pointCount) : h.pointCount)
+		: (opts.maxPoints > 0 ? Math.min(opts.maxPoints, h.pointCount) : 0);
+	var acc = {}, n = 0;
+	fields.forEach(function (f) { acc[f] = new (columnType(f, opts))(cap || 1024); });
+	function into(win) {
+		// A known cap is never exceeded, so it never grows; filters alone grow by doubling
+		if (!cap && n + win.count > acc[fields[0]].length) {
+			var size = Math.max(n + win.count, acc[fields[0]].length * 2);
 			fields.forEach(function (f) { var g = new acc[f].constructor(size); g.set(acc[f].subarray(0, n)); acc[f] = g; });
 		}
-		for (var i = 0; i < fields.length; i++) acc[fields[i]].set(c[fields[i]], n);
-		n += c.count;
+		return { cols: acc, at: n };
 	}
+	for await (var c of this._scan(chunkOpts, into)) n += c.count;
 	var out = { count: n };
-	fields.forEach(function (f) { out[f] = acc ? acc[f].slice(0, n) : new Float64Array(0); });
+	fields.forEach(function (f) { out[f] = acc[f].length === n ? acc[f] : acc[f].slice(0, n); });
 	if (opts.dedupe) out = dedupe(out, opts.dedupe, { z: !!opts.dedupeZ });
 	out.bounds = boundsOf(out, opts.localOrigin);
 	out.stats = statsOf(out);
@@ -236,6 +363,18 @@ LasReader.prototype.readPointsToScratch = async function (opts) {
 	return { count: count, fields: ids, types: types, bounds: worldBounds(b, opts.localOrigin) };
 };
 
+/**
+ * The bytes of an EVLR — big ones are not read by openLas (bytes: null).
+ * @param {number} index - into reader.evlrs
+ * @returns {Promise<Uint8Array>}
+ */
+LasReader.prototype.readEvlrBytes = async function (index) {
+	var e = this.evlrs[index];
+	if (!e) throw new LasError(ERROR_CODES.INVALID_ARGUMENT, "no EVLR " + index + " (the file has " + this.evlrs.length + ")");
+	if (e.bytes) return e.bytes;
+	return new Uint8Array(await this._src.read(e.start, e.start + e.length));
+};
+
 /** Close the underlying file (Node). */
 LasReader.prototype.close = async function () {
 	if (this._src && typeof this._src.close === "function") await this._src.close();

package/src/colour/colourize.js

@@ -14,6 +14,12 @@
 //   so one hot return does not wash the rest out.
 // classification: conventional viewer colours. ASPRS defines the
 //   codes, not colours; these follow common LiDAR-viewer practice.
+//
+// createChunkColourizer colours a STREAM of chunks with one set of
+// rules, so neighbouring windows match: elevation over the file's
+// header Z range, intensity over the first chunk's percentiles, and
+// the 8-bit decision made once (it only ever moves to 16-bit, when a
+// later chunk holds a value above 255).
 //==========================================================
 
 import { LasError, ERROR_CODES } from "../errors.js";
@@ -81,9 +87,15 @@ function rampColours(values, n, range, ramp) {
 	return out;
 }
 
+function maxRgb(points) {
+	var n = points.count;
+	return Math.max(rangeOf(need(points, "red"), n)[1], rangeOf(need(points, "green"), n)[1], rangeOf(need(points, "blue"), n)[1]);
+}
+
 /**
  * @param {object} points - PointColumns.
- * @param {{by:string, ramp?:string, range?:number[]}} opts
+ * @param {{by:string, ramp?:string, range?:number[], eightBit?:boolean}} opts - eightBit
+ *   overrides the 8-bit colour detection
  * @returns {Uint8Array} r, g, b per point
  */
 export function colourize(points, opts) {
@@ -96,8 +108,7 @@ export function colourize(points, opts) {
 	switch (opts.by) {
 		case "rgb": {
 			var r = need(points, "red"), g = need(points, "green"), b = need(points, "blue");
-			var max = Math.max(rangeOf(r, n)[1], rangeOf(g, n)[1], rangeOf(b, n)[1]);
-			var eightBit = max <= 255;
+			var eightBit = typeof opts.eightBit === "boolean" ? opts.eightBit : maxRgb(points) <= 255;
 			out = new Uint8Array(n * 3);
 			for (i = 0; i < n; i++) {
 				out[i * 3] = eightBit ? r[i] : Math.min(255, Math.round(r[i] / 256));
@@ -127,3 +138,24 @@ export function colourize(points, opts) {
 			throw new LasError(ERROR_CODES.INVALID_ARGUMENT, "colourize by \"" + opts.by + "\" is not a mode (rgb, intensity, elevation, classification)");
 	}
 }
+
+/**
+ * Colour a stream of chunks (reader.chunks) consistently from window to window.
+ * @param {{by:string, ramp?:string, range?:number[]}} opts - as colourize
+ * @param {{minZ:number, maxZ:number}} [bounds] - the file's header bounds (elevation range)
+ * @param {{z?:number}} [localOrigin] - the origin the chunks were read with
+ * @returns {function(object): Uint8Array} colours one chunk
+ */
+export function createChunkColourizer(opts, bounds, localOrigin) {
+	opts = opts || {};
+	var range = opts.range || null, eightBit = null;
+	if (!range && opts.by === "elevation" && bounds && bounds.maxZ >= bounds.minZ) {
+		var oz = localOrigin && isFinite(localOrigin.z) ? localOrigin.z : 0;
+		range = [bounds.minZ - oz, bounds.maxZ - oz];
+	}
+	return function (points) {
+		if (opts.by === "intensity" && !range && points.count) range = percentiles(need(points, "intensity"), points.count);
+		if (opts.by === "rgb" && points.count && eightBit !== false) eightBit = maxRgb(points) <= 255;
+		return colourize(points, Object.assign({}, opts, { range: range || undefined, eightBit: eightBit === null ? undefined : eightBit }));
+	};
+}

package/src/filter/dedupe.js

@@ -20,35 +20,52 @@ export function dedupe(cols, tolerance, opts) {
 	if (!(tolerance > 0)) throw new LasError(ERROR_CODES.INVALID_ARGUMENT, "dedupe tolerance must be > 0");
 	var use3d = !!(opts && opts.z && cols.z);
 	var tol2 = tolerance * tolerance;
-	var grid = new Map();
-	var kept = new Uint32Array(cols.count);
-	var nKept = 0;
+	var n = cols.count;
 	var x = cols.x, y = cols.y, z = cols.z;
 	var dzRange = use3d ? 1 : 0;
 
-	for (var i = 0; i < cols.count; i++) {
-		var cx = Math.floor(x[i] / tolerance), cy = Math.floor(y[i] / tolerance);
-		var cz = use3d ? Math.floor(z[i] / tolerance) : 0;
+	// Cell indices, shifted so every neighbour is >= 0
+	var lo = [Infinity, Infinity, Infinity], hi = [-Infinity, -Infinity, -Infinity];
+	for (var p = 0; p < n; p++) {
+		var a0 = Math.floor(x[p] / tolerance), a1 = Math.floor(y[p] / tolerance), a2 = use3d ? Math.floor(z[p] / tolerance) : 0;
+		if (a0 < lo[0]) lo[0] = a0; if (a0 > hi[0]) hi[0] = a0;
+		if (a1 < lo[1]) lo[1] = a1; if (a1 > hi[1]) hi[1] = a1;
+		if (a2 < lo[2]) lo[2] = a2; if (a2 > hi[2]) hi[2] = a2;
+	}
+	var SY = hi[1] - lo[1] + 3, SZ = hi[2] - lo[2] + 3;
+	// A dense numeric key when the cell count fits 2^53; else a hashed one —
+	// two cells may then share a key, which only adds candidates: every
+	// candidate is still distance-checked, so the result is exact either way
+	var dense = (hi[0] - lo[0] + 3) * SY * SZ <= 9007199254740992;
+	function key(i, j, k) { return dense ? (i * SY + j) * SZ + k : (i * 73856093 + j * 19349663 + k * 83492791) % 9007199254740881; }
+
+	// Each cell is a linked list through next[] (Map: key -> most recent point)
+	var head = new Map();
+	var next = new Int32Array(n);
+	var kept = new Uint32Array(n);
+	var nKept = 0;
+	for (var i = 0; i < n; i++) {
+		var cx = Math.floor(x[i] / tolerance) - lo[0] + 1, cy = Math.floor(y[i] / tolerance) - lo[1] + 1;
+		var cz = use3d ? Math.floor(z[i] / tolerance) - lo[2] + 1 : 1;
 		var dup = false;
 		for (var dx = -1; dx <= 1 && !dup; dx++) {
 			for (var dy = -1; dy <= 1 && !dup; dy++) {
 				for (var dz = -dzRange; dz <= dzRange && !dup; dz++) {
-					var cell = grid.get((cx + dx) + "_" + (cy + dy) + "_" + (cz + dz));
-					if (!cell) continue;
-					for (var j = 0; j < cell.length; j++) {
-						var k = cell[j];
+					var k = head.get(key(cx + dx, cy + dy, cz + dz));
+					while (k !== undefined && k >= 0) {
 						var ex = x[k] - x[i], ey = y[k] - y[i];
 						var ez = use3d ? z[k] - z[i] : 0;
 						if (ex * ex + ey * ey + ez * ez <= tol2) { dup = true; break; }
+						k = next[k];
 					}
 				}
 			}
 		}
 		if (dup) continue;
-		var key = cx + "_" + cy + "_" + cz;
-		var own = grid.get(key);
-		if (!own) { own = []; grid.set(key, own); }
-		own.push(i);
+		var own = key(cx, cy, cz);
+		var prev = head.get(own);
+		next[i] = prev === undefined ? -1 : prev;
+		head.set(own, i);
 		kept[nKept++] = i;
 	}
 

package/src/filter/filters.js

@@ -4,9 +4,10 @@
 // rejected points cost one or two byte reads (Kirra's classFilter
 // trick, generalised): classification codes, return numbers and a
 // 3D box. Filters combine with AND.
-// strideFor is Kirra's maxPoints rule: keep every
-// floor(count / maxPoints)-th record; 0 keeps every point. The
-// reader also caps the kept count at maxPoints.
+// maxPoints thinning is NOT Kirra's floor-stride-and-cap rule, which
+// kept only the start of the file and, run before the filters,
+// could leave nothing: decodeRecords thins the records that PASS,
+// evenly over the whole file (countKept supplies their number).
 //==========================================================
 
 import { POINT_FORMATS } from "../format/PointFormats.js";
@@ -57,12 +58,15 @@ export function makeKeep(filter, header) {
 }
 
 /**
- * Record stride for a maxPoints cap (Kirra's rule).
- * @param {number} pointCount
- * @param {number} maxPoints - 0 = keep every point
- * @returns {number} stride, at least 1
+ * Count the records in a window of whole records that pass keep.
+ * @param {Uint8Array} bytes
+ * @param {number} recordLength
+ * @param {function(DataView, number): boolean} keep
+ * @returns {number}
  */
-export function strideFor(pointCount, maxPoints) {
-	if (!(maxPoints > 0) || pointCount <= maxPoints) return 1;
-	return Math.max(1, Math.floor(pointCount / maxPoints));
+export function countKept(bytes, recordLength, keep) {
+	var view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	var n = Math.floor(bytes.length / recordLength), k = 0;
+	for (var i = 0; i < n; i++) if (keep(view, i * recordLength)) k++;
+	return k;
 }

package/src/format/LasVlr.js

@@ -16,7 +16,7 @@ var LE = true;
  * @param {number} start - offset of the first record in src.
  * @param {number} count
  * @param {number} [limit] - records must end at or before this offset (default: end of src).
- * @returns {Array<{userId:string, recordId:number, description:string, start:number, bytes:Uint8Array}>}
+ * @returns {Array<{userId:string, recordId:number, description:string, start:number, length:number, bytes:Uint8Array}>}
  */
 export function parseVlrs(src, start, count, limit) {
 	var end = typeof limit === "number" ? limit : src.length();
@@ -31,6 +31,7 @@ export function parseVlrs(src, start, count, limit) {
 			recordId: src.getUint16(pos + 18, LE),
 			description: readAscii(src, pos + 22, 32),
 			start: pos + 54,
+			length: len,
 			bytes: new Uint8Array(src.slice(pos + 54, pos + 54 + len))
 		});
 		pos += 54 + len;
@@ -43,21 +44,23 @@ export function parseVlrs(src, start, count, limit) {
  * @param {object} src - sync source holding the records (offsets in src).
  * @param {number} start
  * @param {number} count
- * @returns {Array<{userId:string, recordId:number, description:string, start:number, bytes:Uint8Array}>}
+ * @param {boolean} [headersOnly] - src holds only the headers: no bytes (null), no length check
+ * @returns {Array<{userId:string, recordId:number, description:string, start:number, length:number, bytes:Uint8Array|null}>}
  */
-export function parseEvlrs(src, start, count) {
+export function parseEvlrs(src, start, count, headersOnly) {
 	var out = [];
 	var pos = start;
 	for (var i = 0; i < count; i++) {
 		if (pos + 60 > src.length()) throw new LasError(ERROR_CODES.BAD_VLR, "EVLR " + (i + 1) + " starts past the end of the file", pos);
 		var len = readU64(src, pos + 20, LE);
-		if (len === null || pos + 60 + len > src.length()) throw new LasError(ERROR_CODES.BAD_VLR, "EVLR " + (i + 1) + " runs past the end of the file", pos);
+		if (len === null || (!headersOnly && pos + 60 + len > src.length())) throw new LasError(ERROR_CODES.BAD_VLR, "EVLR " + (i + 1) + " runs past the end of the file", pos);
 		out.push({
 			userId: readAscii(src, pos + 2, 16),
 			recordId: src.getUint16(pos + 18, LE),
 			description: readAscii(src, pos + 28, 32),
 			start: pos + 60,
-			bytes: new Uint8Array(src.slice(pos + 60, pos + 60 + len))
+			length: len,
+			bytes: headersOnly ? null : new Uint8Array(src.slice(pos + 60, pos + 60 + len))
 		});
 		pos += 60 + len;
 	}

package/src/index.js

@@ -6,7 +6,7 @@
 //==========================================================
 
 /** Library version, matches package.json. */
-export var VERSION = "0.1.0";
+export var VERSION = "0.3.0";
 
 export { LasError, ERROR_CODES } from "./errors.js";
 export { openLas, LasReader } from "./LasReader.js";
@@ -15,13 +15,13 @@ export { parseVlrs, parseEvlrs } from "./format/LasVlr.js";
 export { parseCrs } from "./format/LasCrs.js";
 export { POINT_FORMATS, formatHasRgb } from "./format/PointFormats.js";
 export { decodeRecords, DEFAULT_FIELDS, FIELD_TYPES } from "./read/decodeRecords.js";
-export { makeKeep, strideFor } from "./filter/filters.js";
+export { makeKeep, countKept } from "./filter/filters.js";
 export { dedupe } from "./filter/dedupe.js";
 export { MemorySource } from "./io/MemorySource.js";
 export { BlobSource } from "./io/BlobSource.js";
 export { NodeFileSource } from "./io/NodeFileSource.js";
 export { SCRATCH_DIR, openScratchSyncWriter, openScratchReader, removeScratchFile, sweepStaleScratchFiles, listScratchFiles, getScratchFile } from "./io/ScratchBinaryFile.js";
-export { colourize, RAMPS, CLASS_COLOURS } from "./colour/colourize.js";
+export { colourize, createChunkColourizer, RAMPS, CLASS_COLOURS } from "./colour/colourize.js";
 export { writeLas, createLasWriter } from "./write/writeLas.js";
 export { chooseScaleOffset } from "./write/scaleOffset.js";
 export { createWorkerHandler } from "./workers/workerProtocol.js";

package/src/io/NodeFileSource.js

@@ -26,11 +26,15 @@ export function NodeFileSource(handle, size) {
  * @param {string} path
  * @returns {Promise<NodeFileSource>}
  */
+var NODE_FS = ["node", "fs/promises"].join(":");
+
 NodeFileSource.open = async function (path) {
 	if (typeof path !== "string" || !path) {
 		throw new LasError(ERROR_CODES.INVALID_ARGUMENT, "NodeFileSource needs a file path");
 	}
-	var fs = await import("node:fs/promises");
+	// A non-literal specifier, so browser bundlers (esbuild, webpack, Vite)
+	// leave it alone instead of failing to resolve a Node built-in
+	var fs = await import(/* webpackIgnore: true */ /* @vite-ignore */ NODE_FS);
 	var handle = await fs.open(path, "r");
 	var stat = await handle.stat();
 	return new NodeFileSource(handle, stat.size);
@@ -49,7 +53,25 @@ NodeFileSource.prototype.read = async function (start, end) {
 	if (end > this.size) {
 		throw new LasError(ERROR_CODES.TRUNCATED, "read past end of " + this.size + "-byte file", end);
 	}
-	var out = new Uint8Array(end - start);
+	return this.readInto(start, end, new Uint8Array(end - start));
+};
+
+/**
+ * Read bytes [start, end) into the front of target (reused by the reader
+ * from window to window, so a big read leaves no per-window garbage).
+ * @param {number} start
+ * @param {number} end
+ * @param {Uint8Array} target - at least end - start bytes
+ * @returns {Promise<Uint8Array>} the filled view of target
+ */
+NodeFileSource.prototype.readInto = async function (start, end, target) {
+	if (start < 0 || end < start) {
+		throw new LasError(ERROR_CODES.INVALID_ARGUMENT, "bad read range " + start + ".." + end);
+	}
+	if (end > this.size) {
+		throw new LasError(ERROR_CODES.TRUNCATED, "read past end of " + this.size + "-byte file", end);
+	}
+	var out = target.subarray(0, end - start);
 	var done = 0;
 	while (done < out.length) {
 		var r = await this._handle.read(out, done, out.length - done, start + done);