las-laz-js 0.1.0 → 0.2.0

package/src/laz/v2/rgb12.js

@@ -0,0 +1,79 @@
+// src/laz/v2/rgb12.js
+//==========================================================
+// LASzip RGB12 item, version 2: the 6 colour bytes. A symbol says which
+// bytes changed and whether green and blue differ from red; red's byte
+// differences predict green's, and the mean of red's and green's
+// predicts blue's (clamped to a byte). Shared by the 1.4 RGB14 item.
+//
+// Ported from laz-rs src/las/rgb.rs, module v2 (https://github.com/laz-rs/laz-rs),
+// itself a port of LASzip by rapidlasso. (c) 2007-2014 martin isenburg,
+// rapidlasso; (c) 2014 Uday Verma, Hobu, Inc.; (c) 2019 Thomas Montaigu.
+// Licensed under the Apache License, Version 2.0 (see LICENSE-APACHE and
+// NOTICE). Changes: translated from Rust to JavaScript, Brent Buffham 2026.
+//==========================================================
+
+import { ArithmeticModel } from "../models.js";
+
+var LE = true;
+
+function clamp8(v) { return v < 0 ? 0 : v > 255 ? 255 : v; }
+
+/** The seven models of one RGB context. */
+export function RgbModels() {
+	this.byteUsed = new ArithmeticModel(128);
+	this.lowRed = new ArithmeticModel(256); this.highRed = new ArithmeticModel(256);
+	this.lowGreen = new ArithmeticModel(256); this.highGreen = new ArithmeticModel(256);
+	this.lowBlue = new ArithmeticModel(256); this.highBlue = new ArithmeticModel(256);
+}
+
+/**
+ * Decode one colour from the last one.
+ * @param {object} dec - ArithmeticDecoder
+ * @param {RgbModels} m
+ * @param {Uint16Array} last - [r, g, b]; overwritten with the new colour
+ */
+export function decodeRgb(dec, m, last) {
+	var sym = dec.decodeSymbol(m.byteUsed);
+	var lr = last[0], lg = last[1], lb = last[2];
+	var r, g, b, diff;
+	r = sym & 1 ? (dec.decodeSymbol(m.lowRed) + (lr & 255)) & 255 : lr & 255;
+	r += sym & 2 ? ((dec.decodeSymbol(m.highRed) + (lr >>> 8)) & 255) * 256 : lr & 0xFF00;
+	if (sym & 64) {
+		diff = (r & 255) - (lr & 255);
+		g = sym & 4 ? (dec.decodeSymbol(m.lowGreen) + clamp8(diff + (lg & 255))) & 255 : lg & 255;
+		if (sym & 16) {
+			diff = Math.trunc((diff + (g & 255) - (lg & 255)) / 2);
+			b = (dec.decodeSymbol(m.lowBlue) + clamp8(diff + (lb & 255))) & 255;
+		} else {
+			b = lb & 255;
+		}
+		diff = (r >>> 8) - (lr >>> 8);
+		g += sym & 8 ? ((dec.decodeSymbol(m.highGreen) + clamp8(diff + (lg >>> 8))) & 255) * 256 : lg & 0xFF00;
+		if (sym & 32) {
+			diff = Math.trunc((diff + (g >>> 8) - (lg >>> 8)) / 2);
+			b += ((dec.decodeSymbol(m.highBlue) + clamp8(diff + (lb >>> 8))) & 255) * 256;
+		} else {
+			b += lb & 0xFF00;
+		}
+	} else {
+		g = r; b = r;
+	}
+	last[0] = r; last[1] = g; last[2] = b;
+}
+
+/** RGB12 v2 decompressor: one per chunk. */
+export function Rgb12Decompressor() {
+	this.size = 6;
+	this.models = new RgbModels();
+	this.last = new Uint16Array(3);
+}
+
+Rgb12Decompressor.prototype.first = function (src, s, view, o) {
+	for (var i = 0; i < 6; i++) view.setUint8(o + i, src[s + i]);
+	this.last[0] = view.getUint16(o, LE); this.last[1] = view.getUint16(o + 2, LE); this.last[2] = view.getUint16(o + 4, LE);
+};
+
+Rgb12Decompressor.prototype.next = function (dec, view, o) {
+	decodeRgb(dec, this.models, this.last);
+	view.setUint16(o, this.last[0], LE); view.setUint16(o + 2, this.last[1], LE); view.setUint16(o + 4, this.last[2], LE);
+};

package/src/laz/v3/layered.js

@@ -0,0 +1,145 @@
+// src/laz/v3/layered.js
+//==========================================================
+// The LAS 1.4 layered items that follow Point14: RGB14, NIR14 (the
+// second half of RGBNIR14) and Byte14 (extra bytes, one layer per
+// byte). Each keeps up to four contexts keyed by the scanner channel
+// Point14 passes on, with the version-3 quirk preserved: a context
+// first used is seeded from the last one, and in version 3 later
+// values are predicted from whichever context it was entered from.
+//
+// Ported from laz-rs src/las/rgb.rs, nir.rs and extra_bytes.rs, modules
+// v3_v4 (https://github.com/laz-rs/laz-rs), itself a port of LASzip by
+// rapidlasso. (c) 2007-2015 martin isenburg, rapidlasso; (c) 2019-2023
+// Thomas Montaigu.
+// Licensed under the Apache License, Version 2.0 (see LICENSE-APACHE and
+// NOTICE). Changes: translated from Rust to JavaScript, Brent Buffham 2026.
+//==========================================================
+
+import { ArithmeticDecoder } from "../ArithmeticDecoder.js";
+import { ArithmeticModel } from "../models.js";
+import { RgbModels, decodeRgb } from "../v2/rgb12.js";
+
+var LE = true;
+
+// laz-rs's context switch, shared by the three items: returns the index whose
+// last value predicts this point (`last_idx`), after switching to `ctx`.
+function enterContext(item, ctx, seed) {
+	var lastIdx = item.lastContext;
+	if (item.lastContext !== ctx) {
+		item.lastContext = ctx;
+		if (item.unused[ctx]) {
+			seed(lastIdx, ctx);
+			item.unused[ctx] = false;
+			if (item.version === 3) lastIdx = ctx;
+		}
+		if (item.version === 4) lastIdx = ctx;
+	}
+	return lastIdx;
+}
+
+function layer(item, bytes, q, n, fail, e, base) {
+	if (q + n > e) fail(q);
+	if (n === 0) return null;
+	var d = new ArithmeticDecoder(bytes, q, q + n, base);
+	d.readInitBytes();
+	return d;
+}
+
+/** RGB14 (version 3 or 4). */
+export function Rgb14Decompressor(version) {
+	this.size = 6;
+	this.version = version;
+	this.models = [new RgbModels(), new RgbModels(), new RgbModels(), new RgbModels()];
+	this.last = [new Uint16Array(3), new Uint16Array(3), new Uint16Array(3), new Uint16Array(3)];
+	this.unused = [true, true, true, true];
+	this.lastContext = 0;
+	this.dec = null;
+}
+Rgb14Decompressor.prototype.first = function (src, s, view, o, ctx) {
+	for (var i = 0; i < 6; i++) view.setUint8(o + i, src[s + i]);
+	var c = ctx.v;
+	this.last[c][0] = view.getUint16(o, LE); this.last[c][1] = view.getUint16(o + 2, LE); this.last[c][2] = view.getUint16(o + 4, LE);
+	this.unused = [true, true, true, true];
+	this.unused[c] = false;
+	this.lastContext = c;
+};
+Rgb14Decompressor.prototype.readLayerSizes = function (dv, q) { this.layerSize = dv.getUint32(q, LE); return q + 4; };
+Rgb14Decompressor.prototype.readLayers = function (bytes, q, e, fail, base) { this.dec = layer(this, bytes, q, this.layerSize, fail, e, base); return q + this.layerSize; };
+Rgb14Decompressor.prototype.next = function (view, o, ctx) {
+	var self = this;
+	var idx = enterContext(this, ctx.v, function (from, to) { self.last[to].set(self.last[from]); });
+	var rgb = this.last[idx];
+	if (this.dec) decodeRgb(this.dec, this.models[this.lastContext], rgb);
+	view.setUint16(o, rgb[0], LE); view.setUint16(o + 2, rgb[1], LE); view.setUint16(o + 4, rgb[2], LE);
+};
+
+/** NIR14 (version 3 or 4): the near-infrared word of RGBNIR14. */
+export function Nir14Decompressor(version) {
+	this.size = 2;
+	this.version = version;
+	this.used = []; this.low = []; this.high = [];
+	for (var i = 0; i < 4; i++) { this.used.push(new ArithmeticModel(4)); this.low.push(new ArithmeticModel(256)); this.high.push(new ArithmeticModel(256)); }
+	this.last = new Uint16Array(4);
+	this.unused = [true, true, true, true];
+	this.lastContext = 0;
+	this.dec = null;
+}
+Nir14Decompressor.prototype.first = function (src, s, view, o, ctx) {
+	view.setUint8(o, src[s]); view.setUint8(o + 1, src[s + 1]);
+	this.last[ctx.v] = view.getUint16(o, LE);
+	this.unused = [true, true, true, true];
+	this.unused[ctx.v] = false;
+	this.lastContext = ctx.v;
+};
+Nir14Decompressor.prototype.readLayerSizes = Rgb14Decompressor.prototype.readLayerSizes;
+Nir14Decompressor.prototype.readLayers = Rgb14Decompressor.prototype.readLayers;
+Nir14Decompressor.prototype.next = function (view, o, ctx) {
+	var self = this;
+	var idx = enterContext(this, ctx.v, function (from, to) { self.last[to] = self.last[from]; });
+	if (this.dec) {
+		var c = this.lastContext, last = this.last[idx];
+		var sym = this.dec.decodeSymbol(this.used[c]);
+		var v = sym & 1 ? (this.dec.decodeSymbol(this.low[c]) + (last & 255)) & 255 : last & 255;
+		v += sym & 2 ? ((this.dec.decodeSymbol(this.high[c]) + (last >>> 8)) & 255) * 256 : last & 0xFF00;
+		this.last[idx] = v;
+	}
+	view.setUint16(o, this.last[idx], LE);
+};
+
+/** Byte14 (version 3 or 4): `count` extra bytes, one layer each. */
+export function Byte14Decompressor(count, version) {
+	this.size = count;
+	this.version = version;
+	this.models = [null, null, null, null];
+	this.last = [new Uint8Array(count), new Uint8Array(count), new Uint8Array(count), new Uint8Array(count)];
+	this.unused = [true, true, true, true];
+	this.lastContext = 0;
+	this.sizes = new Array(count);
+	this.dec = new Array(count);
+}
+function byteModels(count) { var m = []; for (var i = 0; i < count; i++) m.push(new ArithmeticModel(256)); return m; }
+Byte14Decompressor.prototype.first = function (src, s, view, o, ctx) {
+	for (var i = 0; i < this.size; i++) view.setUint8(o + i, src[s + i]);
+	this.last[ctx.v].set(src.subarray(s, s + this.size));
+	this.unused = [true, true, true, true];
+	this.unused[ctx.v] = false;
+	this.models[ctx.v] = byteModels(this.size);
+	this.lastContext = ctx.v;
+};
+Byte14Decompressor.prototype.readLayerSizes = function (dv, q) {
+	for (var i = 0; i < this.size; i++) { this.sizes[i] = dv.getUint32(q, LE); q += 4; }
+	return q;
+};
+Byte14Decompressor.prototype.readLayers = function (bytes, q, e, fail, base) {
+	for (var i = 0; i < this.size; i++) { this.dec[i] = layer(this, bytes, q, this.sizes[i], fail, e, base); q += this.sizes[i]; }
+	return q;
+};
+Byte14Decompressor.prototype.next = function (view, o, ctx) {
+	var self = this;
+	var idx = enterContext(this, ctx.v, function (from, to) { self.models[to] = byteModels(self.size); self.last[to].set(self.last[from]); });
+	var last = this.last[idx], models = this.models[ctx.v];
+	for (var i = 0; i < this.size; i++) {
+		if (this.dec[i]) last[i] = (last[i] + this.dec[i].decodeSymbol(models[i])) & 255;
+		view.setUint8(o + i, last[i]);
+	}
+};

package/src/laz/v3/point14.js

@@ -0,0 +1,266 @@
+// src/laz/v3/point14.js
+//==========================================================
+// LASzip Point14 item, versions 3 and 4 (LAS 1.4 point formats 6-10):
+// the 30-byte extended record, coded in nine LAYERS — channel/returns/
+// XY, Z, classification, flags, intensity, scan angle, user data,
+// point source, GPS time — each its own arithmetic stream, so a layer
+// that never changes in a chunk costs nothing (size 0: the value stays
+// the last one). Up to four contexts follow the scanner channel.
+//
+// Ported from laz-rs src/las/point6.rs, module v3_v4, and the 16x16
+// return tables of src/las/utils.rs (https://github.com/laz-rs/laz-rs),
+// itself a port of LASzip by rapidlasso. (c) 2007-2015 martin isenburg,
+// rapidlasso; (c) 2019-2023 Thomas Montaigu.
+// Licensed under the Apache License, Version 2.0 (see LICENSE-APACHE and
+// NOTICE). Changes: translated from Rust to JavaScript, working on raw
+// record bytes, GPS time as two u32 halves, Brent Buffham 2026.
+//==========================================================
+
+import { ArithmeticDecoder } from "../ArithmeticDecoder.js";
+import { ArithmeticModel } from "../models.js";
+import { IntegerDecompressor } from "../IntegerDecompressor.js";
+import { StreamingMedian } from "../v2/point10.js";
+
+var LE = true;
+var MULTI = 500, MULTI_MINUS = -10;
+var CODE_FULL = MULTI - MULTI_MINUS + 1;   // 511
+var MULTI_TOTAL = MULTI - MULTI_MINUS + 5; // 515
+
+/** NUMBER_RETURN_MAP_6CTX[n][r] (LASzip). */
+var MAP_6CTX = [
+	[0, 1, 2, 3, 4, 5, 3, 4, 4, 5, 5, 5, 5, 5, 5, 5], [1, 0, 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3],
+	[2, 1, 2, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3], [3, 3, 4, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4],
+	[4, 3, 4, 4, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4], [5, 3, 4, 4, 4, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4],
+	[3, 3, 4, 4, 4, 4, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4], [4, 3, 4, 4, 4, 4, 4, 5, 4, 4, 4, 4, 4, 4, 4, 4],
+	[4, 3, 4, 4, 4, 4, 4, 4, 5, 4, 4, 4, 4, 4, 4, 4], [5, 3, 4, 4, 4, 4, 4, 4, 4, 5, 4, 4, 4, 4, 4, 4],
+	[5, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5, 4, 4, 4, 4, 4], [5, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 4, 4, 4],
+	[5, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 4, 4], [5, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 4],
+	[5, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5], [5, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5]
+];
+/** NUMBER_RETURN_LEVEL_8CT[n][r] (LASzip): |n - r|, capped at 7. */
+var LEVEL_8CT = [];
+for (var ln = 0; ln < 16; ln++) { LEVEL_8CT.push([]); for (var lr = 0; lr < 16; lr++) LEVEL_8CT[ln].push(Math.min(7, Math.abs(ln - lr))); }
+
+function medians(n) { var out = []; for (var i = 0; i < n; i++) out.push(new StreamingMedian()); return out; }
+
+// One context's state, started from the last point of another (laz-rs from_last_point)
+function Context(p) {
+	this.unused = false;
+	this.p = { x: p.x, y: p.y, z: p.z, intensity: p.intensity, bits: p.bits, flags: p.flags, cls: p.cls, angle: p.angle, user: p.user, psid: p.psid, gpsHi: p.gpsHi, gpsLo: p.gpsLo, gpsChange: false };
+	this.lastIntensity = new Uint16Array(8).fill(p.intensity);
+	this.xMedian = medians(12);
+	this.yMedian = medians(12);
+	this.lastZ = new Int32Array(8).fill(p.z);
+	this.changed = []; for (var i = 0; i < 8; i++) this.changed.push(new ArithmeticModel(128));
+	this.channel = new ArithmeticModel(3);
+	this.nret = new Array(16);
+	this.rnum = new Array(16);
+	this.rnumGpsSame = new ArithmeticModel(13);
+	this.clsM = new Array(64);
+	this.flagsM = new Array(64);
+	this.userM = new Array(64);
+	this.gpsMulti = new ArithmeticModel(MULTI_TOTAL);
+	this.gpsNoDiff = new ArithmeticModel(5);
+	this.icDx = new IntegerDecompressor(32, 2);
+	this.icDy = new IntegerDecompressor(32, 22);
+	this.icZ = new IntegerDecompressor(32, 20);
+	this.icIntensity = new IntegerDecompressor(16, 4);
+	this.icAngle = new IntegerDecompressor(16, 2);
+	this.icPsid = new IntegerDecompressor(16, 1);
+	this.icGps = new IntegerDecompressor(32, 9);
+	this.gLast = 0; this.gNext = 0;
+	this.gHi = new Int32Array(4); this.gLo = new Float64Array(4);
+	this.gHi[0] = p.gpsHi; this.gLo[0] = p.gpsLo;
+	this.gDiff = new Int32Array(4);
+	this.gExtreme = new Int32Array(4);
+}
+
+function lazy(arr, i, symbols) { return arr[i] || (arr[i] = new ArithmeticModel(symbols)); }
+
+Context.prototype.addGps = function (i, d) {
+	var lo = this.gLo[i] + d;
+	if (lo >= 4294967296) { lo -= 4294967296; this.gHi[i] = (this.gHi[i] + 1) | 0; }
+	else if (lo < 0) { lo += 4294967296; this.gHi[i] = (this.gHi[i] - 1) | 0; }
+	this.gLo[i] = lo;
+};
+Context.prototype.fullGps = function (dec) {
+	this.gNext = (this.gNext + 1) & 3;
+	this.gHi[this.gNext] = this.icGps.decompress(dec, this.gHi[this.gLast], 8);
+	this.gLo[this.gNext] = dec.readInt();
+	this.gLast = this.gNext;
+	this.gDiff[this.gLast] = 0;
+	this.gExtreme[this.gLast] = 0;
+};
+Context.prototype.extremeGps = function (d) {
+	if (++this.gExtreme[this.gLast] > 3) { this.gDiff[this.gLast] = d; this.gExtreme[this.gLast] = 0; }
+};
+// laz-rs read_gps_time (the 1.4 variant: no "unchanged" code, full = 511)
+Context.prototype.readGps = function (dec) {
+	for (;;) {
+		var L = this.gLast, multi, d;
+		if (this.gDiff[L] === 0) {
+			multi = dec.decodeSymbol(this.gpsNoDiff);
+			if (multi === 0) {
+				this.gDiff[L] = this.icGps.decompress(dec, 0, 0);
+				this.addGps(L, this.gDiff[L]);
+				this.gExtreme[L] = 0;
+			} else if (multi === 1) {
+				this.fullGps(dec);
+			} else {
+				this.gLast = (L + multi - 1) & 3;
+				continue;
+			}
+		} else {
+			multi = dec.decodeSymbol(this.gpsMulti);
+			if (multi === 1) {
+				this.addGps(L, this.icGps.decompress(dec, this.gDiff[L], 1));
+				this.gExtreme[L] = 0;
+			} else if (multi < CODE_FULL) {
+				if (multi === 0) {
+					d = this.icGps.decompress(dec, 0, 7);
+					this.extremeGps(d);
+				} else if (multi < MULTI) {
+					d = this.icGps.decompress(dec, Math.imul(multi, this.gDiff[L]), multi < 10 ? 2 : 3);
+				} else if (multi === MULTI) {
+					d = this.icGps.decompress(dec, Math.imul(MULTI, this.gDiff[L]), 4);
+					this.extremeGps(d);
+				} else {
+					multi = MULTI - multi;
+					if (multi > MULTI_MINUS) {
+						d = this.icGps.decompress(dec, Math.imul(multi, this.gDiff[L]), 5);
+					} else {
+						d = this.icGps.decompress(dec, Math.imul(MULTI_MINUS, this.gDiff[L]), 6);
+						this.extremeGps(d);
+					}
+				}
+				this.addGps(L, d);
+			} else if (multi === CODE_FULL) {
+				this.fullGps(dec);
+			} else {
+				this.gLast = (L + multi - CODE_FULL) & 3;
+				continue;
+			}
+		}
+		return;
+	}
+};
+
+var LAYERS = 9;   // channel/returns/xy, z, classification, flags, intensity, scan angle, user data, point source, gps time
+
+/**
+ * Point14 decompressor: one per chunk.
+ * @param {number} version - LASzip item version, 3 or 4 (they pass the scanner channel on differently)
+ */
+export function Point14Decompressor(version) {
+	this.size = 30;
+	this.version = version;
+	this.contexts = [null, null, null, null];
+	this.current = 0;
+	this.sizes = new Array(LAYERS);
+	this.dec = new Array(LAYERS);
+	this.on = new Array(LAYERS);
+}
+
+Point14Decompressor.prototype.first = function (src, s, view, o, ctx) {
+	for (var i = 0; i < 30; i++) view.setUint8(o + i, src[s + i]);
+	var p = {
+		x: view.getInt32(o, LE), y: view.getInt32(o + 4, LE), z: view.getInt32(o + 8, LE),
+		intensity: view.getUint16(o + 12, LE), bits: view.getUint8(o + 14), flags: view.getUint8(o + 15),
+		cls: view.getUint8(o + 16), user: view.getUint8(o + 17), angle: view.getInt16(o + 18, LE),
+		psid: view.getUint16(o + 20, LE), gpsLo: view.getUint32(o + 22, LE), gpsHi: view.getInt32(o + 26, LE)
+	};
+	this.current = (p.flags >>> 4) & 3;
+	this.contexts = [null, null, null, null];
+	this.contexts[this.current] = new Context(p);
+	ctx.v = this.current;
+};
+
+Point14Decompressor.prototype.readLayerSizes = function (dv, q) {
+	for (var i = 0; i < LAYERS; i++) { this.sizes[i] = dv.getUint32(q, LE); q += 4; }
+	return q;
+};
+
+Point14Decompressor.prototype.readLayers = function (bytes, q, e, fail, base) {
+	if (this.sizes[0] === 0) fail(q);   // channel / returns / XY is coded for every point after the first
+	for (var i = 0; i < LAYERS; i++) {
+		var n = this.sizes[i];
+		if (q + n > e) fail(q);
+		this.on[i] = n > 0;
+		if (n > 0) { this.dec[i] = new ArithmeticDecoder(bytes, q, q + n, base); this.dec[i].readInitBytes(); }
+		q += n;
+	}
+	return q;
+};
+
+Point14Decompressor.prototype.next = function (view, o, ctx) {
+	var c = this.contexts[this.current];
+	var p = c.p, d0 = this.dec[0];
+	var r = p.bits & 15, n = p.bits >>> 4;
+	var lpr = (r === 1 ? 1 : 0) + (r >= n ? 2 : 0) + (p.gpsChange ? 4 : 0);
+	var changed = d0.decodeSymbol(c.changed[lpr]);
+	if (changed & 64) {
+		var channel = (this.current + d0.decodeSymbol(c.channel) + 1) % 4;
+		if (!this.contexts[channel]) this.contexts[channel] = new Context(p);
+		this.current = channel;
+		if (this.version === 3) ctx.v = channel;
+		c = this.contexts[channel];
+		p = c.p;
+		p.flags = (p.flags & 0xCF) | (channel << 4);
+	}
+	if (this.version !== 3) ctx.v = this.current;
+	var psidChanged = changed & 32, gpsChanged = changed & 16 ? 1 : 0, angleChanged = changed & 8;
+	var lastN = p.bits >>> 4, lastR = p.bits & 15;
+	n = changed & 4 ? d0.decodeSymbol(lazy(c.nret, lastN, 16)) : lastN;
+	var low = changed & 3;
+	if (low === 0) r = lastR;
+	else if (low === 1) r = (lastR + 1) % 16;
+	else if (low === 2) r = (lastR + 15) % 16;
+	else if (gpsChanged) r = d0.decodeSymbol(lazy(c.rnum, lastR, 16));
+	else r = (lastR + d0.decodeSymbol(c.rnumGpsSame) + 2) % 16;
+	p.bits = r + n * 16;
+	var m = MAP_6CTX[n][r], l = LEVEL_8CT[n][r];
+	var cpr = (r === 1 ? 2 : 0) + (r >= n ? 1 : 0);
+	var single = n === 1 ? 1 : 0;
+	var idx = m * 2 + gpsChanged;
+	var diff = c.icDx.decompress(d0, c.xMedian[idx].get(), single);
+	p.x = (p.x + diff) | 0;
+	c.xMedian[idx].add(diff);
+	var kx = c.icDx.k;
+	diff = c.icDy.decompress(d0, c.yMedian[idx].get(), single + (kx < 20 ? kx & 0xFFFFFFFE : 20));
+	p.y = (p.y + diff) | 0;
+	c.yMedian[idx].add(diff);
+	if (this.on[1]) {
+		var kz = Math.floor((c.icDx.k + c.icDy.k) / 2);
+		p.z = c.icZ.decompress(this.dec[1], c.lastZ[l], single + (kz < 18 ? kz & 0xFFFFFFFE : 18));
+		c.lastZ[l] = p.z;
+	}
+	if (this.on[2]) p.cls = this.dec[2].decodeSymbol(lazy(c.clsM, (p.cls & 31) * 2 + (cpr === 3 ? 1 : 0), 256));
+	if (this.on[3]) {
+		var lastFlags = ((p.flags >>> 7) & 1) * 32 + ((p.flags >>> 6) & 1) * 16 + (p.flags & 15);
+		var f = this.dec[3].decodeSymbol(lazy(c.flagsM, lastFlags, 64));
+		p.flags = ((f >>> 5) & 1) * 128 + ((f >>> 4) & 1) * 64 + (p.flags & 0x30) + (f & 15);
+	}
+	if (this.on[4]) {
+		var ii = cpr * 2 + gpsChanged;
+		p.intensity = c.icIntensity.decompress(this.dec[4], c.lastIntensity[ii], cpr) & 0xFFFF;
+		c.lastIntensity[ii] = p.intensity;
+	}
+	if (this.on[5] && angleChanged) p.angle = (c.icAngle.decompress(this.dec[5], p.angle, gpsChanged) << 16) >> 16;   // as i16
+	if (this.on[6]) p.user = this.dec[6].decodeSymbol(lazy(c.userM, Math.floor(p.user / 4), 256));
+	if (this.on[7] && psidChanged) p.psid = c.icPsid.decompress(this.dec[7], p.psid, 0) & 0xFFFF;
+	p.gpsChange = !!gpsChanged;
+	if (this.on[8] && gpsChanged) {
+		c.readGps(this.dec[8]);
+		p.gpsHi = c.gHi[c.gLast]; p.gpsLo = c.gLo[c.gLast];
+	}
+	view.setInt32(o, p.x, LE); view.setInt32(o + 4, p.y, LE); view.setInt32(o + 8, p.z, LE);
+	view.setUint16(o + 12, p.intensity, LE);
+	view.setUint8(o + 14, p.bits);
+	view.setUint8(o + 15, p.flags);
+	view.setUint8(o + 16, p.cls);
+	view.setUint8(o + 17, p.user);
+	view.setInt16(o + 18, p.angle, LE);
+	view.setUint16(o + 20, p.psid, LE);
+	view.setUint32(o + 22, p.gpsLo, LE);
+	view.setInt32(o + 26, p.gpsHi, LE);
+};

package/src/read/decodeRecords.js

@@ -11,9 +11,12 @@
 // data, never on positions (marked // bits-ok for the guard test).
 //
 // opts.keep(view, recordOffset) rejects a record before it is
-// decoded (filters, see filter/filters.js). opts.stride keeps every
-// stride-th record counted from the file's first record
-// (opts.firstIndex = the window's first record number).
+// decoded (filters, see filter/filters.js). opts.thin
+// { total, target, acc } then keeps exactly target of the total
+// records that pass, spread evenly: an integer accumulator gains
+// target per passing record and keeps the record each time it
+// reaches total (Bresenham), so record ceil(j * total / target) - 1
+// is the j-th kept. acc is carried from window to window.
 //==========================================================
 
 import { LasError, ERROR_CODES } from "../errors.js";
@@ -69,7 +72,9 @@ export function resolveFields(header, fields) {
  * Decode a window of whole point records.
  * @param {Uint8Array} bytes - whole records, the first at bytes[0].
  * @param {object} header - from parseHeader.
- * @param {object} [opts] - { fields, keep, stride, firstIndex, localOrigin, float32 }
+ * @param {object} [opts] - { fields, keep, thin, localOrigin, float32, into }
+ *   into: { cols, at } decodes straight into existing columns from index at
+ *   (each sized for every record that can be kept) and returns only { count }
  * @returns {object} PointColumns: { count, <field>: TypedArray, ... }
  */
 export function decodeRecords(bytes, header, opts) {
@@ -79,8 +84,7 @@ export function decodeRecords(bytes, header, opts) {
 	var len = header.recordLength;
 	var n = Math.floor(bytes.length / len);
 	var view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-	var stride = opts.stride > 1 ? opts.stride : 1;
-	var first = opts.firstIndex || 0;
+	var thin = opts.thin && opts.thin.target < opts.thin.total ? opts.thin : null;
 	var keep = typeof opts.keep === "function" ? opts.keep : null;
 	var origin = opts.localOrigin || null;
 	var ox = origin && isFinite(origin.x) ? origin.x : 0;
@@ -88,12 +92,9 @@ export function decodeRecords(bytes, header, opts) {
 	var oz = origin && isFinite(origin.z) ? origin.z : 0;
 	var f32 = !!(opts.float32 && origin);
 
-	var cols = {};
-	fields.forEach(function (name) {
-		var Type = FIELD_TYPES[name];
-		if (f32 && (name === "x" || name === "y" || name === "z")) Type = Float32Array;
-		cols[name] = new Type(n);
-	});
+	var into = opts.into || null;
+	var cols = into ? into.cols : {};
+	if (!into) fields.forEach(function (name) { cols[name] = new (columnType(name, opts))(n); });
 	var F = fmt.fields;
 	var sx = header.scale.x, sy = header.scale.y, sz = header.scale.z;
 	var tx = header.offset.x - ox, ty = header.offset.y - oy, tz = header.offset.z - oz;
@@ -101,11 +102,15 @@ export function decodeRecords(bytes, header, opts) {
 	var want = {};
 	fields.forEach(function (name) { want[name] = true; });
 
-	var k = 0;
+	var k = into ? into.at : 0;
 	for (var i = 0; i < n; i++) {
-		if (stride > 1 && (first + i) % stride !== 0) continue;
 		var at = i * len;
 		if (keep && !keep(view, at)) continue;
+		if (thin) {
+			thin.acc += thin.target;
+			if (thin.acc < thin.total) continue;
+			thin.acc -= thin.total;
+		}
 		if (want.x) cols.x[k] = view.getInt32(at, LE) * sx + tx;
 		if (want.y) cols.y[k] = view.getInt32(at + 4, LE) * sy + ty;
 		if (want.z) cols.z[k] = view.getInt32(at + 8, LE) * sz + tz;
@@ -140,7 +145,20 @@ export function decodeRecords(bytes, header, opts) {
 		if (want.nir) cols.nir[k] = view.getUint16(at + F.nir.offset, LE);
 		k++;
 	}
+	if (into) return { count: k - into.at };
 	if (k < n) fields.forEach(function (name) { cols[name] = cols[name].slice(0, k); });
 	cols.count = k;
 	return cols;
 }
+
+/**
+ * The typed-array type a field is decoded into (x / y / z are Float32
+ * when float32 is asked for with a local origin).
+ * @param {string} name
+ * @param {{float32?:boolean, localOrigin?:object}} [opts]
+ * @returns {Function}
+ */
+export function columnType(name, opts) {
+	var f32 = !!(opts && opts.float32 && opts.localOrigin);
+	return f32 && (name === "x" || name === "y" || name === "z") ? Float32Array : FIELD_TYPES[name];
+}

package/src/read/windows.js

@@ -22,3 +22,24 @@ export function windows(header, windowSize) {
 	}
 	return out;
 }
+
+/**
+ * Group LAZ chunks into windows of whole chunks, about windowSize bytes of
+ * DECOMPRESSED records each (one chunk at least).
+ * @param {Array<{firstRecord:number, count:number, start:number, end:number}>} chunks - from readChunks
+ * @param {number} recordLength
+ * @param {number} windowSize
+ * @returns {Array<{start:number, end:number, firstRecord:number, count:number, chunks:Array}>}
+ */
+export function lazWindows(chunks, recordLength, windowSize) {
+	var out = [], cur = null;
+	chunks.forEach(function (c) {
+		if (cur && (cur.count + c.count) * recordLength > windowSize) { out.push(cur); cur = null; }
+		if (!cur) cur = { start: c.start, end: c.end, firstRecord: c.firstRecord, count: 0, chunks: [] };
+		cur.end = c.end;
+		cur.count += c.count;
+		cur.chunks.push(c);
+	});
+	if (cur) out.push(cur);
+	return out;
+}

package/src/workers/workerProtocol.js

@@ -4,10 +4,12 @@
 // Worker globals so it can be driven directly (tests, custom hosts).
 // Same shape as ecw-js's.
 // In:  { id, type, payload }
-//   open                { blob | bytes, windowSize? } -> { header, vlrs, evlrs, crs, compressed }
+//   open                { blob | bytes, windowSize? } -> { header, vlrs, evlrs, crs, compressed, laz }
 //   readPoints          readPoints options + colour?  -> PointColumns (+ colours)
 //   chunks              chunks options + colour?      -> streams { id, type: "chunk", chunk } per
-//                                                        window, then result { count }
+//                                                        window, then result { count }; colours
+//                                                        follow one rule for the whole stream
+//                                                        (createChunkColourizer)
 //   readPointsToScratch readPointsToScratch options   -> { count, fields, types, bounds }
 //   colourize           { points, by, ramp?, range? } -> Uint8Array
 //   abort               { id }                        -> cancels that job (it rejects ABORTED)
@@ -19,7 +21,7 @@
 
 import { LasError, ERROR_CODES } from "../errors.js";
 import { openLas } from "../LasReader.js";
-import { colourize } from "../colour/colourize.js";
+import { colourize, createChunkColourizer } from "../colour/colourize.js";
 
 function buffersOf(cols) {
 	var out = [];
@@ -66,16 +68,17 @@ export function createWorkerHandler(post) {
 			if (reader) await reader.close();
 			reader = null;
 			reader = await openLas((payload && (payload.blob || payload.bytes)), { windowSize: payload && payload.windowSize });
-			return { result: { header: reader.header, vlrs: reader.vlrs, evlrs: reader.evlrs, crs: reader.crs, compressed: reader.compressed } };
+			return { result: { header: reader.header, vlrs: reader.vlrs, evlrs: reader.evlrs, crs: reader.crs, compressed: reader.compressed, laz: reader.laz } };
 		},
 		readPoints: async function (id, payload, controller) {
 			var cols = withColour(await needReader().readPoints(readOptions(id, payload, controller)), payload && payload.colour);
 			return { result: cols, transfer: buffersOf(cols) };
 		},
 		chunks: async function (id, payload, controller) {
-			var count = 0;
-			for await (var c of needReader().chunks(readOptions(id, payload, controller))) {
-				withColour(c, payload && payload.colour);
+			var count = 0, r = needReader();
+			var paint = payload.colour ? createChunkColourizer(payload.colour, r.header.bounds, payload.localOrigin) : null;
+			for await (var c of r.chunks(readOptions(id, payload, controller))) {
+				if (paint) c.colours = paint(c);
 				count += c.count;
 				post({ id: id, type: "chunk", chunk: c }, buffersOf(c));
 			}