las-laz-js 0.3.0 → 0.4.0

package/src/laz/v2/rgb12.js

@@ -3,13 +3,15 @@
 // 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.
+// predicts blue's (clamped to a byte). Shared by the 1.4 RGB14 item;
+// encodeRgb is decodeRgb's mirror, over the same RgbModels.
 //
 // 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.
+// NOTICE). Changes: translated from Rust to JavaScript, Brent Buffham 2026;
+// the compressor (encodeRgb, Rgb12Compressor) added beside the decompressor.
 //==========================================================
 
 import { ArithmeticModel } from "../models.js";
@@ -61,13 +63,16 @@ export function decodeRgb(dec, m, last) {
 	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);
+// The state and models both halves start a chunk with
+function initRgb12(self) {
+	self.size = 6;
+	self.models = new RgbModels();
+	self.last = new Uint16Array(3);
 }
 
+/** RGB12 v2 decompressor: one per chunk. */
+export function Rgb12Decompressor() { initRgb12(this); }
+
 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);
@@ -77,3 +82,53 @@ 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);
 };
+
+/**
+ * Encode one colour against the last one: the mirror of decodeRgb.
+ * @param {object} enc - ArithmeticEncoder
+ * @param {RgbModels} m
+ * @param {Uint16Array} last - [r, g, b] of the last point (not changed)
+ * @param {Uint16Array} cur - [r, g, b] of this point
+ * @returns {number} the symbol coded: which bytes changed, and bit 6 when it is not grey
+ */
+export function encodeRgb(enc, m, last, cur) {
+	var lr = last[0], lg = last[1], lb = last[2], r = cur[0], g = cur[1], b = cur[2];
+	var sym = ((lr ^ r) & 255 ? 1 : 0) | ((lr ^ r) & 0xFF00 ? 2 : 0) | ((lg ^ g) & 255 ? 4 : 0) | ((lg ^ g) & 0xFF00 ? 8 : 0) |
+		((lb ^ b) & 255 ? 16 : 0) | ((lb ^ b) & 0xFF00 ? 32 : 0) | (r !== g || r !== b ? 64 : 0);
+	var diffL = 0, diffH = 0;
+	enc.encodeSymbol(m.byteUsed, sym);
+	if (sym & 1) { diffL = (r & 255) - (lr & 255); enc.encodeSymbol(m.lowRed, diffL & 255); }
+	if (sym & 2) { diffH = (r >>> 8) - (lr >>> 8); enc.encodeSymbol(m.highRed, diffH & 255); }
+	if (sym & 64) {
+		if (sym & 4) enc.encodeSymbol(m.lowGreen, ((g & 255) - clamp8(diffL + (lg & 255))) & 255);
+		if (sym & 16) {
+			diffL = Math.trunc((diffL + (g & 255) - (lg & 255)) / 2);
+			enc.encodeSymbol(m.lowBlue, ((b & 255) - clamp8(diffL + (lb & 255))) & 255);
+		}
+		if (sym & 8) enc.encodeSymbol(m.highGreen, ((g >>> 8) - clamp8(diffH + (lg >>> 8))) & 255);
+		if (sym & 32) {
+			diffH = Math.trunc((diffH + (g >>> 8) - (lg >>> 8)) / 2);
+			enc.encodeSymbol(m.highBlue, ((b >>> 8) - clamp8(diffH + (lb >>> 8))) & 255);
+		}
+	}
+	return sym;
+}
+
+/** RGB12 v2 compressor: one per chunk, the mirror of Rgb12Decompressor. */
+export function Rgb12Compressor() {
+	initRgb12(this);
+	this.cur = new Uint16Array(3);
+}
+
+/** [r, g, b] of the record bytes at s, into out (RGB14 reads them the same way). */
+export function readRgb(out, src, s) {
+	out[0] = src[s] + src[s + 1] * 256; out[1] = src[s + 2] + src[s + 3] * 256; out[2] = src[s + 4] + src[s + 5] * 256;
+}
+
+Rgb12Compressor.prototype.first = function (src, s) { readRgb(this.last, src, s); };
+
+Rgb12Compressor.prototype.next = function (enc, src, s) {
+	readRgb(this.cur, src, s);
+	encodeRgb(enc, this.models, this.last, this.cur);
+	var t = this.last; this.last = this.cur; this.cur = t;
+};

package/src/laz/v3/layered.js

@@ -6,20 +6,27 @@
 // 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.
+// Each compressor shares its decompressor's setup and context switch,
+// so the two stay in step point for point.
 //
 // 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.
+// NOTICE). Changes: translated from Rust to JavaScript, Brent Buffham 2026;
+// the compressors (Rgb14Compressor, Nir14Compressor, Byte14Compressor)
+// added beside the decompressors, writing a layer once a value changes
+// as LAZperf (hobuinc/laz-perf, field_rgb14/nir14/byte14.cpp) does.
 //==========================================================
 
 import { ArithmeticDecoder } from "../ArithmeticDecoder.js";
+import { ArithmeticEncoder } from "../ArithmeticEncoder.js";
 import { ArithmeticModel } from "../models.js";
-import { RgbModels, decodeRgb } from "../v2/rgb12.js";
+import { RgbModels, decodeRgb, encodeRgb, readRgb } from "../v2/rgb12.js";
 
 var LE = true;
+var EMPTY = new Uint8Array(0);
 
 // 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`.
@@ -38,6 +45,13 @@ function enterContext(item, ctx) {
 	return lastIdx;
 }
 
+// The first point of a chunk: only its channel's context is in use
+function firstContext(item, ctx) {
+	item.unused = [true, true, true, true];
+	item.unused[ctx] = false;
+	item.lastContext = ctx;
+}
+
 function layer(item, bytes, q, n, fail, e, base) {
 	if (q + n > e) fail(q);
 	if (n === 0) return null;
@@ -46,27 +60,30 @@ function layer(item, bytes, q, n, fail, e, base) {
 	return d;
 }
 
+// The state and models both halves of RGB14 start a chunk with
+function initRgb14(self, version) {
+	self.size = 6;
+	self.version = version;
+	self.models = [new RgbModels(), new RgbModels(), new RgbModels(), new RgbModels()];
+	self.last = [new Uint16Array(3), new Uint16Array(3), new Uint16Array(3), new Uint16Array(3)];
+	self.unused = [true, true, true, true];
+	self.lastContext = 0;
+}
+function seedRgb(from, to) { this.last[to].set(this.last[from]); }
+
 /** 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;
+	initRgb14(this, version);
 	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;
+	readRgb(this.last[ctx.v], src, s);
+	firstContext(this, ctx.v);
 };
 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.seed = function (from, to) { this.last[to].set(this.last[from]); };
+Rgb14Decompressor.prototype.seed = seedRgb;
 Rgb14Decompressor.prototype.next = function (view, o, ctx) {
 	var idx = enterContext(this, ctx.v);
 	var rgb = this.last[idx];
@@ -74,32 +91,57 @@ Rgb14Decompressor.prototype.next = function (view, o, ctx) {
 	view.setUint16(o, rgb[0], LE); view.setUint16(o + 2, rgb[1], LE); view.setUint16(o + 4, rgb[2], LE);
 };
 
+/** RGB14 compressor (version 3 or 4): one layer, written once a colour differs or is not grey. */
+export function Rgb14Compressor(version) {
+	initRgb14(this, version);
+	this.enc = new ArithmeticEncoder();
+	this.used = false;
+	this.cur = new Uint16Array(3);
+}
+Rgb14Compressor.prototype.first = function (src, s, ctx) {
+	readRgb(this.last[ctx.v], src, s);
+	firstContext(this, ctx.v);
+};
+Rgb14Compressor.prototype.seed = seedRgb;
+Rgb14Compressor.prototype.next = function (src, s, ctx) {
+	var idx = enterContext(this, ctx.v);
+	readRgb(this.cur, src, s);
+	if (encodeRgb(this.enc, this.models[this.lastContext], this.last[idx], this.cur)) this.used = true;
+	this.last[idx].set(this.cur);
+};
+/** @returns {Array<Uint8Array>} the one layer (empty when nothing was coded) */
+Rgb14Compressor.prototype.finish = function () { return [this.used ? this.enc.done() : EMPTY]; };
+
+// The state and models both halves of NIR14 start a chunk with
+function initNir14(self, version) {
+	self.size = 2;
+	self.version = version;
+	self.usedModel = []; self.low = []; self.high = [];
+	for (var i = 0; i < 4; i++) { self.usedModel.push(new ArithmeticModel(4)); self.low.push(new ArithmeticModel(256)); self.high.push(new ArithmeticModel(256)); }
+	self.last = new Uint16Array(4);
+	self.unused = [true, true, true, true];
+	self.lastContext = 0;
+}
+function seedNir(from, to) { this.last[to] = this.last[from]; }
+
 /** 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;
+	initNir14(this, version);
 	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;
+	this.last[ctx.v] = src[s] + src[s + 1] * 256;
+	firstContext(this, ctx.v);
 };
 Nir14Decompressor.prototype.readLayerSizes = Rgb14Decompressor.prototype.readLayerSizes;
 Nir14Decompressor.prototype.readLayers = Rgb14Decompressor.prototype.readLayers;
-Nir14Decompressor.prototype.seed = function (from, to) { this.last[to] = this.last[from]; };
+Nir14Decompressor.prototype.seed = seedNir;
 Nir14Decompressor.prototype.next = function (view, o, ctx) {
 	var idx = enterContext(this, ctx.v);
 	if (this.dec) {
 		var c = this.lastContext, last = this.last[idx];
-		var sym = this.dec.decodeSymbol(this.used[c]);
+		var sym = this.dec.decodeSymbol(this.usedModel[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;
@@ -107,25 +149,56 @@ Nir14Decompressor.prototype.next = function (view, o, ctx) {
 	view.setUint16(o, this.last[idx], LE);
 };
 
+/** NIR14 compressor (version 3 or 4): one layer, written once the value changes. */
+export function Nir14Compressor(version) {
+	initNir14(this, version);
+	this.enc = new ArithmeticEncoder();
+	this.used = false;
+}
+Nir14Compressor.prototype.first = function (src, s, ctx) {
+	this.last[ctx.v] = src[s] + src[s + 1] * 256;
+	firstContext(this, ctx.v);
+};
+Nir14Compressor.prototype.seed = seedNir;
+Nir14Compressor.prototype.next = function (src, s, ctx) {
+	var idx = enterContext(this, ctx.v), c = this.lastContext;
+	var last = this.last[idx], v = src[s] + src[s + 1] * 256;
+	var sym = ((last ^ v) & 255 ? 1 : 0) + ((last ^ v) & 0xFF00 ? 2 : 0);
+	this.enc.encodeSymbol(this.usedModel[c], sym);
+	if (sym & 1) this.enc.encodeSymbol(this.low[c], ((v & 255) - (last & 255)) & 255);
+	if (sym & 2) this.enc.encodeSymbol(this.high[c], ((v >>> 8) - (last >>> 8)) & 255);
+	if (sym) this.used = true;
+	this.last[idx] = v;
+};
+/** @returns {Array<Uint8Array>} the one layer (empty when the value never changed) */
+Nir14Compressor.prototype.finish = Rgb14Compressor.prototype.finish;
+
+// The state both halves of Byte14 start a chunk with; a context's models are made when it is first used
+function initByte14(self, count, version) {
+	self.size = count;
+	self.version = version;
+	self.models = [null, null, null, null];
+	self.last = [new Uint8Array(count), new Uint8Array(count), new Uint8Array(count), new Uint8Array(count)];
+	self.unused = [true, true, true, true];
+	self.lastContext = 0;
+}
+function byteModels(count) { var m = []; for (var i = 0; i < count; i++) m.push(new ArithmeticModel(256)); return m; }
+function firstBytes(item, src, s, ctx) {
+	item.last[ctx.v].set(src.subarray(s, s + item.size));
+	firstContext(item, ctx.v);
+	item.models[ctx.v] = byteModels(item.size);
+}
+function seedBytes(from, to) { this.models[to] = byteModels(this.size); this.last[to].set(this.last[from]); }
+
 /** 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;
+	initByte14(this, count, version);
 	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;
+	firstBytes(this, src, s, ctx);
 };
 Byte14Decompressor.prototype.readLayerSizes = function (dv, q) {
 	for (var i = 0; i < this.size; i++) { this.sizes[i] = dv.getUint32(q, LE); q += 4; }
@@ -135,7 +208,7 @@ 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.seed = function (from, to) { this.models[to] = byteModels(this.size); this.last[to].set(this.last[from]); };
+Byte14Decompressor.prototype.seed = seedBytes;
 Byte14Decompressor.prototype.next = function (view, o, ctx) {
 	var idx = enterContext(this, ctx.v);
 	var last = this.last[idx], models = this.models[ctx.v];
@@ -144,3 +217,28 @@ Byte14Decompressor.prototype.next = function (view, o, ctx) {
 		view.setUint8(o + i, last[i]);
 	}
 };
+
+/** Byte14 compressor (version 3 or 4): `count` extra bytes, a layer each, written once that byte changes. */
+export function Byte14Compressor(count, version) {
+	initByte14(this, count, version);
+	this.enc = [];
+	this.used = [];
+	for (var i = 0; i < count; i++) { this.enc.push(new ArithmeticEncoder()); this.used.push(false); }
+}
+Byte14Compressor.prototype.first = function (src, s, ctx) { firstBytes(this, src, s, ctx); };
+Byte14Compressor.prototype.seed = seedBytes;
+Byte14Compressor.prototype.next = function (src, s, ctx) {
+	var idx = enterContext(this, ctx.v);
+	var last = this.last[idx], models = this.models[ctx.v];
+	for (var i = 0; i < this.size; i++) {
+		var d = (src[s + i] - last[i]) & 255;   // u8 wrapping_sub
+		this.enc[i].encodeSymbol(models[i], d);
+		if (d) { this.used[i] = true; last[i] = src[s + i]; }
+	}
+};
+/** @returns {Array<Uint8Array>} one layer per byte (empty when that byte never changed) */
+Byte14Compressor.prototype.finish = function () {
+	var out = [];
+	for (var i = 0; i < this.size; i++) out.push(this.used[i] ? this.enc[i].done() : EMPTY);
+	return out;
+};